[Version 14.0] Feature support for unbound generic types in nameof

standard/expressions.md

@@ -1,15 +1,15 @@
 # 12 Expressions
 
 ## 12.1 General
 
 An expression is a sequence of operators and operands. This clause defines the syntax, order of evaluation of operands and operators, and meaning of expressions.
 
 An expression *E* is said to ***directly contain*** a subexpression *E₁* if it is not subject to a user-defined conversion [§10.5](conversions.md#105-user-defined-conversions) whose parameter is not of a non-nullable value type, and one of the following conditions holds:
 
 - *E* is *E₁*.
 - If *E* is a parenthesized expression `(E₂)`, and *E₂* directly contains *E₁*.
 - If *E* is a null-forgiving operator expression `E₂!`, and *E₂* directly contains *E₁*.
 - If *E* is a cast expression `(T)E₂`, and the cast does not subject *E₂* to a non-lifted user-defined conversion whose parameter is not of a non-nullable value type, and *E₂* directly contains *E₁*.
 
 ## 12.2 Expression classifications
 
@@ -1789,15 +1789,17 @@
 
 ### 12.8.4 Simple names
 
-A *simple_name* consists of an identifier, optionally followed by a type argument list:
+A *simple_name* consists of an identifier, optionally followed by a *type_argument_list* or a *generic_dimension_specifier*:
 
 ```ANTLR
 simple_name
-    : identifier type_argument_list?
+    : identifier (type_argument_list | generic_dimension_specifier)?
     ;
 ```
 
-A *simple_name* is either of the form `I` or of the form `I<A₁, ..., Aₑ>`, where `I` is a single identifier and `I<A₁, ..., Aₑ>` is an optional *type_argument_list*. When no *type_argument_list* is specified, consider `e` to be zero. The *simple_name* is evaluated and classified as follows:
+A *simple_name* can be of the form `I` or `I<A₁, ..., Aₑ>`, where `I` is a single identifier and `I<A₁, ..., Aₑ>` is an optional *type_argument_list*. When no *type_argument_list* is specified, consider `e` to be zero. The presence of *generic_dimension_specifier* allows names like `X<>` or `X<,>` to be considered simple names.
+
+The *simple_name* is evaluated and classified as follows:
 
 - If `e` is zero and the *simple_name* appears within a local variable declaration space ([§7.2](basic-concepts.md#72-declarations)) that directly contains a local variable, parameter (with the exception of discard parameters ([§12.22.2](expressions.md#12222-anonymous-function-signatures))), 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 `e` is zero and the *simple_name* appears within a generic method declaration but outside the *attributes* of its *method_declaration*, and if that declaration includes a type parameter with name `I`, then the *simple_name* refers to that type parameter.
@@ -3646,6 +3648,8 @@
 >
 > *end example*
 
+It is an error to use `generic_dimension_specifier` outside of a `typeof` or `nameof` expression.  Within either of those expressions it is an error to use `generic_dimension_specifier` within a `type_argument_list`, `array_type`, `pointer_type`, or `nullable_type`.
+
 ### 12.8.19 The sizeof operator
 
 The `sizeof` operator returns the number of 8-bit bytes occupied by a variable of a given type.
@@ -3943,7 +3947,8 @@
     ;
 
 named_entity
-    : named_entity_target ('.' identifier type_argument_list?)*
+    : named_entity_target ('.' identifier
+        (type_argument_list | generic_dimension_specifier)?)*
     ;
 
 named_entity_target
@@ -3992,9 +3997,9 @@
 >         string n9 = nameof(Program.InstanceMethod);      // "InstanceMethod"
 >         string n10 = nameof(Program.GenericMethod);      // "GenericMethod"
 >         string n11 = nameof(Program.NestedClass);        // "NestedClass"
-> 
+>         string x1 = nameof(List<>);                      // "List">
+>
 >         // Invalid
->         // string x1 = nameof(List<>);            // Empty type argument list
 >         // string x2 = nameof(List<T>);           // T is not in scope
 >         // string x3 = nameof(GenericMethod<>);   // Empty type argument list
 >         // string x4 = nameof(GenericMethod<T>);  // T is not in scope
@@ -4018,6 +4023,8 @@
 > Potentially surprising parts of this example are the resolution of `nameof(System.Collections.Generic)` to just “Generic” instead of the full namespace, and of `nameof(TestAlias)` to “TestAlias” rather than “String”.
 > *end example*
 
+Member lookup on an unbound type expression within a `nameof` is performed the same way as for a `this` expression within that type declaration (modulo performing accessibility checks at the call site). In other words, lookup off of `List<>` in `nameof(List<>…)` works the same as lookup off of `this` within the `class List<T>` type itself.
+
 ### 12.8.24 Anonymous method expressions
 
 An *anonymous_method_expression* is one of two ways of defining an anonymous function. These are further described in [§12.22](expressions.md#1222-anonymous-function-expressions).