Test plan for "native ints"

[jcouv]

Test plan for "native ints" #38821

Championed issue

• [x] ** Specification checked in to dotnet/csharplang
• [x] Open language issues (https://github.com/dotnet/csharplang/issues/3259) resolved and implemented accordingly.
• [x] ** LangVersion
  • [x] ** Blocks the use of the "reserved" words [NativeIntegerTests.LanguageVersion]
  • [x] Blocks the use of the nint/nuint operators?
• [x] nint and nuint contextual keywords
  • [x] bind to new types only when name lookup does not find a viable result [NativeIntegerTests.{ClassName, AliasName_*, MemberName_01}]
  • [x] examples: [NativeIntegerTests.{NameOf_*, MemberName_02}]
  • [x] nint x = 3;
  • [x] _ = nameof(nint);
  • [x] _ = nint.Equals(x, 3); [MemberName_02]
• [x] Compile-time constants in int and uint ranges [NativeIntegerTests.Constants_FromMetadata]
• [x] Constant folding supported for all unary and binary operators [NativeIntegerTests.ConstantFolding]
  • [x] Compile-time evaluation in checked and unchecked contexts within int/uint ranges
  • [x] Runtime evaluation in unchecked context otherwise (we have an open issue)
• [x] Conversions
  • [x] Identity conversions between System.IntPtr and nint, and between System.UIntPtr and nuint [NativeIntegerTests.Conversions]
  • [x] Common type of nint and IntPtr?
  • [x] Common type of A<nint> and A<IntPtr> ?
  • [x] Type inference when nint and IntPtr are both bounds
  • [x] Identity conversions between arrays, Nullable<>, constructed types, tuples that differ only by native integers and underlying types
  • [x] ImplicitNumeric conversions from integer types with smaller range to native integers; ExplicitNumeric otherwise [NativeIntegerTests.Conversions]
  • [x] ImplicitNumeric conversions from native integers to integer types with larger range; ExplicitNumeric otherwise [NativeIntegerTests.Conversions]
  • [x] Boxing/Unboxing conversions between object and native integer types [NativeIntegerTests.Conversions]
  • [x] IEquatable<nint>
  • [x] PointerToVoid conversions between void* and native integer types [NativeIntegerTests.Conversions]
  • [x] Implicit/explicit nullable conversion from A to B? if implicit/explict conversion from A to B [NativeIntegerTests.Conversions]
  • [x] Explicit nullable conversion from A? to B if identity or implicit/explicit conversion from A to B [NativeIntegerTests.Conversions]
  • [x] Explicit nullable conversion from from A? to B? if implicit/explicit conversion from A to B [NativeIntegerTests.Conversions]
• [x] Built-in operators provided by the compiler: unary { ++, --, +, -, ~ }, binary { +, -, *, /, %, <, <=, >, >=, <<, >>, ==, !=, |, &, ^ }
  • [x] Operations are emitted directly using IL operators for native integers [NativeIntegerTests.{UnaryOperators, BinaryOperators}]
  • [x] Lifted operators provided by the compiler for the above [NativeIntegerTests.{UnaryOperators, BinaryOperators}]
  • [x] SemanticModel exposes fake operator method syms
• [x] Overridiing, interface implementation, hiding consider native integers and underlying types as equivalent
  • [x] Overrides and interface implementations may differ by native integers and underlying types alone [NativeIntegerTests.Overrides_*]
  • [x] Overloads cannot differ by native integers and underlying types alone [NativeIntegerTests.Overloads_*]
  • [x] Methods hide other methods that differ by native integers and underlying types alone [NativeIntegerTests.Overloads_*]
• [x] Type members from underlying types:
  • [x] Constructors from underlying types are hidden for nint and nuint [NativeIntegerTests.ConstructorsAndOperators]
  • [x] Operators from underlying types (including implicit and explicit conversion operators) are hidden for nint and nuint [NativeIntegerTests.ConstructorsAndOperators]
  • [x] Instance and static members from underlying types are hidden except for an explicit opt-in list [NativeIntegerTests.{InstanceMembers, StaticMembers}]
  • [x] Interfaces implemented by underlying types are implemented, with substitution for generic interfaces such as IEquatable<IntPtr> [NativeIntegerTests.Interfaces]
  • [x] Request IComparable<nint> etc and we can expose it
• [x] Type unification of interfaces that differ by native integers and underlying types
• [x] No changes for dynamic: runtime binding to underlying types only
• [x] Can be used as default parameter value [NativeIntegerTests.Constants_ParameterDefaults]
• [x] Cannot be used as attribute argument (neither positional nor named arguments) [NativeIntegerTests.AttributeValue_*]
• [ ] Native integers cannot be used as enum base type
• [x] Native integer fields may be marked volatile
• [x] typeof(nint) is typeof(IntPtr)
• [x] sizeof(nint) is supported in unsafe context only and is defined as sizeof(IntPtr) not IntPtr.Size [NativeIntegerTests.SizeOf_*]
• [x] Compiler diagnostics refer to nint and nuint rather than underlying types [NativeIntegerTests.ConstantConversions_*]
• [x] SymbolDisplay uses nint and nuint always regardless of SymbolDisplayFormat [NativeIntegerTests.TypeDefinitions_FromMetadata]
• [x] Metadata representation uses System.IntPtr and System.UIntPtr with additional NativeIntegerAttribute on containing type reference [AttributeTests_NativeInteger]
• [x] Doc for metadata representation in spec. NativeIntegerAttribute.md
• [x] Public API allows:
  • [x] determine if ITypeSymbol is native integer: ITypeSymbol.IsNativeInteger [NativeIntegerTests.TypeDefinitions_FromMetadata]
  • [x] get underlying INamedTypeSymbol for native integer: INamedTypeSymbol.NativeIntegerUnderlyingType [NativeIntegerTests.TypeDefinitions_FromMetadata]
  • [x] get signed and unsigned native integer INamedTypeSymbol instances from compilation: Compilation.CreateNativeIntegerTypeSymbol() [NativeIntegerTests.CreateNativeIntegerTypeSymbol_FromMetadata]
• [ ] Add NativeIntegerAttribute definition to .NET 5.0 (see https://github.com/dotnet/runtime/issues/38683)
• [ ] The semantic model GetTypeInfo API should return the new types when appropriate, even** when compiling at an older language version. Language behavior agrees with semantic model.
• [x] The set of members of nint and nuint as seen through the language is tested to be as specified.
• [x] The set of built-in operators as seen through the language is tested to be as specified.
• [x] When using the built-in operators, they obey the appropriate checked/unchecked context for overflow, on platforms with 32-bit nints and 64-bit nints. [NativeIntegerTests.{UnaryOperators, BinaryOperators}]
• [x] Test that constant folding works as specified (including checked/unchecked) [NativeIntegerTests.ConstantFolding]
• [ ] Test pattern-matching for nint constants, e.g. o is (nint)1
• [ ] Test switching on a value of type nint. Do we generate an IL switch instruction?
• [x] Test decoding of nint in a modreq (we don't do it, intentional)

BCL

• [ ] we should consider what Interlocked overloads the BCL/runtime should provide for those new types.

IDE Scenarios

• [x] ** Completion offers nint and nuint (PR https://github.com/dotnet/roslyn/pull/42976)
• [x] ** Highlight as keywords
• [x] Generating syntax (issue https://github.com/dotnet/roslyn/issues/42986)
  • [ ] Refactor to change var to nint (make explicit type)
  • [ ] Generate override uses keyword
  • [ ] Implement interface uses keyword
  • [ ] View metadata as source works
  • [ ] Extract local for subexpression (of type nint)
• [x] Extract method that uses nint
• [x] Offer langversion if you try to use nint/nuint (jcouv verified)
• [ ] Quick info
• [ ] Find all references for nint works like int (issue https://github.com/dotnet/roslyn/issues/42988)
• [ ] Go to definition of nint (goes to IntPtr)
• [ ] ?Symbol key and anything that depends on it?

[gafter]

@cston If you identify a test for each bullet, I will verify those items and check the boxes.

[cston]

Closing. Any remaining issues can be opened as separate bugs.