A simple-name consists of a single identifier.
simple-name:
identifier
A simple-name is evaluated and classified as follows:
?If the simple-name appears within a block and if the block?s (or an
enclosing block?s) local variable
declaration space (?0.3) contains a local variable or parameter with the
given name, then the simplename
refers to that local variable or parameter and is classified as a variable.
?Otherwise, for each type T, starting with the immediately enclosing
class, struct, or enumeration
declaration and continuing with each enclosing outer class or struct
declaration (if any), if a member
lookup of the simple-name in T produces a match:
If T is the immediately enclosing class or struct type and the lookup
identifies one or more methods, the
result is a method group with an associated instance expression of this.
If T is the immediately enclosing class or struct type, if the lookup
identifies an instance member, and if the
reference occurs within the block of an instance constructor, an instance
method, or an instance accessor, the
result is the same as a member access (?4.5.4) of the form this.E, where E
is the simple-name.
Otherwise, the result is the same as a member access (?4.5.4) of the form
T.E, where E is the simple-name.
In this case, it is a compile-time error for the simple-name to refer to an
instance member.
?Otherwise, starting with the namespace in which the simple-name occurs,
continuing with each
enclosing namespace (if any), and ending with the global namespace, the
following steps are evaluated
until an entity is located:
If the namespace contains a namespace member with the given name, then the
simple-name refers to that
member and, depending on the member, is classified as a namespace or a type.
Otherwise, if the namespace has a corresponding namespace declaration
enclosing the location where the
simple-name occurs, then:
?If the namespace declaration contains a using-alias-directive that
associates the given name with
an imported namespace or type, then the simple-name refers to that
namespace or type.
?Otherwise, if the namespaces imported by the using-namespace-directives
of the namespace
declaration contain exactly one type with the given name, then the
simple-name refers to that
type.
?Otherwise, if the namespaces imported by the using-namespace-directives
of the namespace
declaration contain more than one type with the given name, then the
simple-name is ambiguous
and a compile-time error occurs.
?Otherwise, the name given by the simple-name is undefined and a
compile-time error occurs.
14.5.2.1 Invariant meaning in blocks
For each occurrence of a given identifier as a simple-name in an expression
or declarator, every other
occurrence of the same identifier as a simple-name in an expression or
declarator within the immediately
Chapter 14 Expressions
139
enclosing block (?5.2) or switch-block (?5.7.2) must refer to the same
entity. [Note: This rule ensures that
the meaning of a name is always the same within a block. end note]
[Example: The example
class Test
{
double x;
void F(bool b) {
x = 1.0;
if (b) {
int x = 1;
}
}
}
results in a compile-time error because x refers to different entities
within the outer block (the extent of
which includes the nested block in the if statement). In contrast, the
example
class Test
{
double x;
void F(bool b) {
if (b) {
x = 1.0;
}
else {
int x = 1;
}
}
}
is permitted because the name x is never used in the outer block. end
example]
[Note: The rule of invariant meaning applies only to simple names. It is
perfectly valid for the same
identifier to have one meaning as a simple name and another meaning as
right operand of a member access
(?4.5.4). end note] [Example: For example:
struct Point
{
int x, y;
public Point(int x, int y) {
this.x = x;
this.y = y;
}
}
The example above illustrates a common pattern of using the names of fields
as parameter names in an
instance constructor. In the example, the simple names x and y refer to the
parameters, but that does not
prevent the member access expressions this.x and this.y from accessing the
fields. end example]