Chapter 14 Expressions

114.5.1 Literals

2A primary-expression that consists of a literal (§9.4.4) is classified as a value.

314.5.2 Simple names

4A simple-name consists of an identifier, optionally followed by a type argument list:

5simple-name:

7A simple-name is either of the form I or of the form I<A1, ..., AK>, where I is a single identifier and <A1,

8..., AK> is an optional type-argument-list. When no type-argument-list is specified, consider K to be zero.

9The simple-name is evaluated and classified as follows:

10• If K is zero and the simple-name appears within a block and if the block’s (or an enclosing block’s) local

11variable declaration space (§10.3) contains a local variable, parameter or constant with name I, then the

12simple-name refers to that local variable, parameter or constant and is classified as a variable or value.

13• If K is zero and the simple-name appears within the body of a generic method declaration and if that

14declaration includes a type parameter with name I, then the simple-name refers to that type parameter.

15• Otherwise, for each instance type T (§26.1.2), starting with the instance type of the immediately

16enclosing type declaration and continuing with the instance type of each enclosing class or struct

17declaration (if any):

18o If K is zero and the declaration of T includes a type parameter with name I, then the simple-name

19refers to that type parameter.

20o Otherwise, if a member lookup (§14.3) of I in T with K type arguments produces a match:

21• If T is the instance type of the immediately enclosing class or struct type and the lookup

30AK>. In this case, it is a compile-time error for the simple-name to refer to an instance member.

31• Otherwise, for each namespace N, starting with the namespace in which the simple-name occurs,

32continuing with each enclosing namespace (if any), and ending with the global namespace, the following

33steps are evaluated until an entity is located:

34o If K is zero and I is the name of a namespace in N, then:

35• If the location where the simple-name occurs is enclosed by a namespace declaration for N and

39• Otherwise, the simple-name refers to the namespace named I in N.

40o Otherwise, if N contains an accessible type having name I and K type parameters, then:

41• If K is zero and the location where the simple-name occurs is enclosed by a namespace

161

C# LANGUAGE SPECIFICATION

3o Otherwise, if the location where the simple-name occurs is enclosed by a namespace declaration

4for N:

5• If K is zero and the namespace declaration contains an extern-alias-directive or using-alias-

14[Note: This entire step is exactly parallel to the corresponding step in the processing of a namespace-or-

15type-name (§10.8). end note]

16• Otherwise, the simple-name is undefined and a compile-time error occurs.

1714.5.2.1 Invariant meaning in blocks

18For each occurrence of a given identifier as a simple-name in an expression or declarator, every other

19occurrence of the same identifier as a simple-name in an expression or declarator within the immediately

20enclosing block (§15.2) or switch-block (§15.7.2) shall refer to the same entity. [Note: This rule ensures that

21the meaning of a name is always the same within a block. end note]

22[Example: The example

23class Test

24{

31}

32}

33results in a compile-time error because x refers to different entities within the outer block (the extent of

34which includes the nested block in the if statement). In contrast, the example

35class Test

36{

45}

46}

47is permitted because the name x is never used in the outer block. end example]

48[Note: The rule of invariant meaning applies only to simple names. It is perfectly valid for the same

49identifier to have one meaning as a simple name and another meaning as right operand of a member access

50(§14.5.4). end note] [Example:

162