Proposal: Allow keywords as the target of a using-alias statement (specifically, n(u)int)

[bartonjs]

In existing corefx code we have interop aliases like

using CFIndex=System.IntPtr;

In some cases it may be more desirable to use the nint type, and unless the using-alias statement allows the keywords (or attributes) it's not possible to get nint instead of System.IntPtr.

cc: @tannergooding @cston @333fred

[333fred]

Specifically, this is interesting for nint and nuint because we will not be exposing operators on System.(U)IntPtr, only on the aliased types, as well as aliasing the static methods defined on those types. Specifically, we'd change this section of the spec: https://github.com/dotnet/csharplang/blob/master/spec/basic-concepts.md#namespace-and-type-names

Existing rules

If the namespace_or_type_name is a qualified-alias-member its meaning is as described in Namespace alias qualifiers. Otherwise, a namespace_or_type_name has one of four forms:

• I
• I<A1, ..., Ak>
• N.I
• N.I<A1, ..., Ak>

where I is a single identifier, N is a namespace_or_type_name and <A1, ..., Ak> is an optional type_argument_list. When no type_argument_list is specified, consider k to be zero.

The meaning of a namespace_or_type_name is determined as follows:

• If the namespace_or_type_name is of the form I or of the form I<A1, ..., Ak>:
  • If K is zero and the namespace_or_type_name appears within a generic method declaration (Methods) and if that declaration includes a type parameter (Type parameters) with name I, then the namespace_or_type_name refers to that type parameter.
  • Otherwise, if the namespace_or_type_name appears within a type declaration, then for each instance type T (The instance type), starting with the instance type of that 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 namespace_or_type_name refers to that type parameter.
    • Otherwise, if the namespace_or_type_name appears within the body of the type declaration, and T or any of its base types contain a nested accessible type having name I and K type parameters, then the namespace_or_type_name refers to that type constructed with the given type arguments. If there is more than one such type, the type declared within the more derived type is selected. Note that non-type members (constants, fields, methods, properties, indexers, operators, instance constructors, destructors, and static constructors) and type members with a different number of type parameters are ignored when determining the meaning of the namespace_or_type_name.
  • If the previous steps were unsuccessful then, for each namespace N, starting with the namespace in which the namespace_or_type_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 namespace_or_type_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 namespace_or_type_name is ambiguous and a compile-time error occurs.
      • Otherwise, the namespace_or_type_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 namespace_or_type_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 namespace_or_type_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 namespace_or_type_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 namespace_or_type_name refers to that namespace or type.
      • Otherwise, if the namespaces and type declarations imported by the using_namespace_directives and using_alias_directives of the namespace declaration contain exactly one accessible type having name I and K type parameters, then the namespace_or_type_name refers to that type constructed with the given type arguments.
      • Otherwise, if the namespaces and type declarations imported by the using_namespace_directives and using_alias_directives of the namespace declaration contain more than one accessible type having name I and K type parameters, then the namespace_or_type_name is ambiguous and an error occurs.
  • Otherwise, the namespace_or_type_name is undefined and a compile-time error occurs.

New Rule

This rule is inserted just before the final namespace_or_type_name is undefined:

• If the previous steps were unsuccessful, and K is zero, and I is a simple_type, then the namespace_or_type_name refers to the predefined struct type defined in https://github.com/dotnet/csharplang/blob/master/spec/types.md#simple-types

Updated Rules

If the namespace_or_type_name is a qualified-alias-member its meaning is as described in Namespace alias qualifiers. Otherwise, a namespace_or_type_name has one of four forms:

• I
• I<A1, ..., Ak>
• N.I
• N.I<A1, ..., Ak>

where I is a single identifier, N is a namespace_or_type_name and <A1, ..., Ak> is an optional type_argument_list. When no type_argument_list is specified, consider k to be zero.

The meaning of a namespace_or_type_name is determined as follows:

• If the namespace_or_type_name is of the form I or of the form I<A1, ..., Ak>:
  • If K is zero and the namespace_or_type_name appears within a generic method declaration (Methods) and if that declaration includes a type parameter (Type parameters) with name I, then the namespace_or_type_name refers to that type parameter.
  • Otherwise, if the namespace_or_type_name appears within a type declaration, then for each instance type T (The instance type), starting with the instance type of that 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 namespace_or_type_name refers to that type parameter.
    • Otherwise, if the namespace_or_type_name appears within the body of the type declaration, and T or any of its base types contain a nested accessible type having name I and K type parameters, then the namespace_or_type_name refers to that type constructed with the given type arguments. If there is more than one such type, the type declared within the more derived type is selected. Note that non-type members (constants, fields, methods, properties, indexers, operators, instance constructors, destructors, and static constructors) and type members with a different number of type parameters are ignored when determining the meaning of the namespace_or_type_name.
  • If the previous steps were unsuccessful then, for each namespace N, starting with the namespace in which the namespace_or_type_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 namespace_or_type_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 namespace_or_type_name is ambiguous and a compile-time error occurs.
      • Otherwise, the namespace_or_type_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 namespace_or_type_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 namespace_or_type_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 namespace_or_type_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 namespace_or_type_name refers to that namespace or type.
      • Otherwise, if the namespaces and type declarations imported by the using_namespace_directives and using_alias_directives of the namespace declaration contain exactly one accessible type having name I and K type parameters, then the namespace_or_type_name refers to that type constructed with the given type arguments.
      • Otherwise, if the namespaces and type declarations imported by the using_namespace_directives and using_alias_directives of the namespace declaration contain more than one accessible type having name I and K type parameters, then the namespace_or_type_name is ambiguous and an error occurs.
  • If the previous steps were unsuccessful, and K is zero, and I is a simple_type, then the namespace_or_type_name refers to the predefined struct type defined in https://github.com/dotnet/csharplang/blob/master/spec/types.md#simple-types
  • Otherwise, the namespace_or_type_name is undefined and a compile-time error occurs.

[gafter]

@333fred that approach to the spec doesn't work, as these keywords are not identifiers.