CHAPTER 4

Names

Names are used to refer to entities declared in a program (§4.1). A declared entity is a class type, a member (field or method) of a reference type, a parameter (to a method or constructor) or a main block variable.

Names in T programs are simple, consisting of a single identifier (§4.2).

Every declaration that introduces a name has a scope (§4.3), which is the part of the program text within which the declared entity can be referred to by a name.

Reference types (that is, class types and array types) have members (§4.4). A member can be referred to using a qualified name N.x, where N is a variable of a reference type (or this or super) and x is an identifier that names a member of that type, which is either a field or a method.

In determining the meaning of a name (§4.5), the context of the occurrence is used to disambiguate among types, variables, and methods with the same name.

4.1 Declarations

A declaration introduces an entity into a program and includes an identifier that can be used as a name to refer to this entity. A declared entity is one of the following:

• A class, declared in a class type declaration.
• A member of a reference type, one of the following:
  • A field, declared in a class type,
  • The field length, which is implicitly a member of every array type,
  • A method declared in a class type,
• A parameter of a method or constructor of a class.
• A main block variable.

Constructors and destructors are also introduced by declarations, but use a name based upon the name of the class in which they are declared rather than introducing a new name.

4.2 Names and Identifiers

A name is used to refer to an entity declared in a program. All names are simple names: a single identifier.

4.3 Scope of a Declaration

The scope of a declaration is the region of the program within which the entity declared by the declaration can be referred to using a name (provided it is visible). A declaration is said to be in scope at a particular point in a program if and only if the declaration's scope includes that point.

• The scope of a type is all type declarations in the program.
• The scope of a declaration of a member m declared in or inherited by a class type C is the entire body of C.
• The scope of a parameter of a method or constructor is the entire body of the method or constructor.
• The scope of a main block variable declaration is the rest of the main block. (Note: main block variables can only be declared at the outermost level of the main block.)

These rules imply that declarations of class types need not appear before uses of the types.

4.3.1 Shadowing Declarations

Some declarations may be shadowed in part of their scope by another declaration of the same name, in which case a name cannot be used to refer to the declared entity.

A declaration d of a method parameter or constructor parameter named n shadows the declarations of any fields named n that are in scope at the point where d occurs throughout the scope of d.

A declaration d is said to be visible at point p in a program if the scope of d includes p, and d is not shadowed by any other declaration at p.

Note that shadowing is distinct from hiding. Hiding applies only to members which would otherwise be inherited but are not because of a declaration in a subclass.

4.4 Members and Inheritance

Reference types have members.

This section provides an overview of the members of reference types here, as background for the discussion of the determination of the meaning of names.

4.4.1 The Members of a Class Type

The members of a class type are fields and methods. Members are either declared in the type, or inherited because they are members of a superclass which are not overridden.

The members of a class type are all of the following:

• Members inherited from its direct superclass, if it has one (the class Object has no direct superclass)
• Members declared in the body of the class

Constructors and destructors are not members.

There is no restriction against a field and a method of a class type having the same name.

A class type may have two or more methods with the same name if the methods have different signatures, that is, if they have different numbers of parameters or different parameter types in at least one parameter position. Such a method member name is said to be overloaded.

A class type may contain a declaration for a method with the same name and the same signature as a method that would otherwise be inherited from a superclass. In this case, the method of the superclass is not inherited. The new declaration is said to override it.

4.4.2 The Members of an Array Type

The members of an array type are specified in §6.5. For convenience, we repeat that specification here.

The members of an array type are the following:

• The field length, which contains the number of components of the array (length may be positive or zero), and which always denotes a value and never a variable.
• The equals method inherited from class Object.

4.5 Determining the Meaning of a Name

The meaning of a name depends on the context in which it is used. The determination of the meaning of a name requires two steps. First, context causes a name syntactically to fall into one of three categories: TypeName, ExpressionName or MethodName. Second, the resulting category then dictates the final determination of the meaning of the name (or a compilation error if the name has no meaning).

TypeName:

    Identifier



ExpressionName:

    Identifier



MethodName:

    Identifier

4.5.1 Syntactic Classification of a Name According to Context

A name is syntactically classified as a TypeName in these contexts:

• In an extends clause in a class declaration
• As a Type (or the part of a Type that remains after all brackets are deleted) in any of the following contexts:
  • In a field declaration
  • As the result type of a method
  • As the type of a formal parameter of a method or constructor
  • As the type of a main block variable
  • As the class type which is to be instantiated in a class instance creation expression
  • As the element type of an array to be created in an array creation expression
  • As the type mentioned in the cast operator of a cast expression (§8.12.3)

A name is syntactically classified as an ExpressionName in these contexts:

• As the array reference expression in an array access expression
• As a Primary
• As the left-hand operand of an assignment operator

A name is syntactically classified as a MethodName in this context:

• Before the "(" in a method invocation expression

4.5.2 Meaning of Type Names

A type name consists of a single Identifier. The identifier must occur in the scope of a declaration of a type with this name, or a compile-time error occurs.

4.5.3 Meaning of Expression Names

The meaning of a name classified as an ExpressionName is determined as follows.

4.5.3.1 Simple Expression Names

If an expression name consists of a single Identifier, then:

• If the Identifier appears within the scope of a main block variable declaration or visible parameter declaration with that name, then the expression name denotes a variable, that is, that main block variable or parameter. There is necessarily at most one such main block variable or parameter. The type of the expression name is the declared type of the main variable or parameter.
• Otherwise, if the Identifier appears within a class declaration:
  • If there is not exactly one member that is a field with that name, then a compile-time error results.
  • Otherwise, the expression name denotes a variable, the single member field with that name. The type of the expression name is the field's declared type.

4.5.3.2 Qualified Expression Names

If an expression name is of the form Q.Id, then Q has already been classified as an expression name. Let T be the type of Q:

• If T is not a reference type, a compile-time error occurs.
• If there is not exactly one accessible member of the type T that is a field named Id, then a compile-time error occurs.
• Otherwise, if T is an array type and Id is length, then Q.length denotes a value with type int, the length of the array. If Q.length appears in a context that requires a variable and not a value, then a compile-time error occurs.
• Otherwise, Q.Id denotes a variable. The type of the expression Q.Id is the declared type of the field.

4.5.4 Meaning of Method Names

A MethodName can appear only in a method invocation expression. The meaning of a name classified as a MethodName is determined as follows.

4.5.4.1 Simple Method Names

If a method name consists of a single Identifier, then Identifier is the method name to be used for method invocation. The Identifier must name at least one method of a class within whose declaration the Identifier appears.

4.5.4.2 Qualified Method Names

If a method name is of the form Q.Id, then Q has already been classified as an expression name. Id is the method name to be used for method invocation. Let T be the type of the expression Q; Id must name at least one method of the type T.

Author(s): John Augros (§4.1-4.5)