C# Language Specification

Literals

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

2. Simple names

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

simple-name:
identifier type-argument-list_opt

A simple-name is either of the form I or of the form I1, ..., A_K>, where I is a single identifier and 1, ..., A_K> is an optional type-argument-list. When no type-argument-list is specified, consider K to be zero. The simple-name is evaluated and classified as follows:

• 
  If K is zero and the simple-name appears within a block and if the block’s (or an enclosing block’s) local variable declaration space (§3.3) contains a local variable, parameter or constant with name I, then the simple-name refers to that local variable, parameter or constant and is classified as a variable or value.
  
• 
  If K is zero and the simple-name appears within the body of a generic method declaration and if that declaration includes a type parameter with name I, then the simple-name refers to that type parameter.
  
• 
  Otherwise, for each instance type T (§10.3.1), starting with the instance type of the immediately enclosing type declaration and continuing with the instance type of each enclosing class or struct declaration (if any):
  

• 
  If K is zero and the declaration of T includes a type parameter with name I, then the simple-name refers to that type parameter.
  
• 
  Otherwise, if a member lookup (§7.4) of I in T with K type arguments produces a match:
  

• 
  If T is the instance type of 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 a type argument list was specified, it is used in calling a generic method (§7.6.5.1).
  
• 
  Otherwise, if T is the instance type of 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 (§7.6.4) of the form this.I. This can only happen when K is zero.
  
• 
  Otherwise, the result is the same as a member access (§7.6.4) of the form T.I or T.I1, ..., A_K>. In this case, it is a binding-time error for the simple-name to refer to an instance member.
  

• 
  Otherwise, for each namespace N, 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 K is zero and I is the name of a namespace in N, then:
  

• 
  If the location where the simple-name occurs is enclosed by a namespace declaration for N and the namespace declaration contains an extern-alias-directive or using-alias-directive that associates the name I with a namespace or type, then the simple-name is ambiguous and a compile-time error occurs.
  
• 
  Otherwise, the simple-name refers to the namespace named I in N.
  

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

• 
  If K is zero and the location where the simple-name occurs is enclosed by a namespace declaration for N and the namespace declaration contains an extern-alias-directive or using-alias-directive that associates the name I with a namespace or type, then the simple-name is ambiguous and a compile-time error occurs.
  
• 
  Otherwise, the namespace-or-type-name refers to the type constructed with the given type arguments.
  

• 
  Otherwise, if the location where the simple-name occurs is enclosed by a namespace declaration for N:
  

• 
  If K is zero and the namespace declaration contains an extern-alias-directive or using-alias-directive that associates the name I 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 having name I and K type parameters, then the simple-name refers to that type constructed with the given type arguments.
  
• 
  Otherwise, if the namespaces imported by the using-namespace-directives of the namespace declaration contain more than one type having name I and K type parameters, then the simple-name is ambiguous and an error occurs.
  

Note that this entire step is exactly parallel to the corresponding step in the processing of a namespace-or-type-name (§3.8).

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

1.