[Version 11.0] Feature support for Numeric IntPtr

standard/conversions.md

@@ -25,7 +25,7 @@
 > ```csharp
 > enum Color { Red, Blue, Green }
 >
 > // The expression 0 converts implicitly to enum types
 > Color c0 = 0;
 >
 > // Other int expressions need explicit conversion
@@ -120,6 +120,8 @@
 
 There is an identity conversion between `nint` and `System.IntPtr`, and between `nuint` and `System.UIntPtr`.
 
+For the compound types array, nullable type, constructed type, and tuple, there is an identity conversion between native integers ([§8.3.6](types.md#836-integral-types)) and their underlying types.
+
 ### 10.2.3 Implicit numeric conversions
 
 The implicit numeric conversions are:

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
 
@@ -287,6 +287,8 @@
 ```csharp
 int operator *(int x, int y);
 uint operator *(uint x, uint y);
+nint operator *(nint x, nint y);
+nuint operator *(nuint x, nuint y);
 long operator *(long x, long y);
 ulong operator *(ulong x, ulong y);
 float operator *(float x, float y);

standard/types.md

@@ -1,8 +1,8 @@
 # 8 Types
 
 ## 8.1 General
 
 The types of the C# language are divided into two main categories: ***reference type*** and ***value type***. A value type or a reference type may be a ***generic type***, which takes one or more ***type parameter***s. Type parameters can designate both value types and reference types.
 
 ```ANTLR
 type
@@ -20,8 +20,8 @@
 > *Note*: When a variable is a reference or output parameter, it does not have its own storage but references the storage of another variable. In this case, the ref or out variable is effectively an alias for another variable and not a distinct variable. *end note*
 
 C#’s type system is unified such that *a value of any type can be treated as an object*. Every type in C# directly or indirectly derives from the `object` class type, and `object` is the ultimate base class of all types. Values of reference types are treated as objects simply by viewing the values as type `object`. Values of value types are treated as objects by performing boxing and unboxing operations ([§8.3.13](types.md#8313-boxing-and-unboxing)).
 
 For convenience, throughout this specification, some library type names are written without using their full name qualification. Refer to [§C.5](standard-library.md#c5-library-type-abbreviations) for more information.
 
 ## 8.2 Reference types
 
@@ -280,7 +280,7 @@
 
 ### 8.3.5 Simple types
 
-Except for `nint` and `nuint`, the simple types are aliases for predefined `struct` types in the `System` namespace, as described in the table below.
+The simple types are aliases for predefined `struct` types in the `System` namespace, as described in the table below.
 
 **Keyword** | **Aliased type**
 ----------- | ------------------
@@ -290,8 +290,8 @@
   `ushort`  |   `System.UInt16`
   `int`     |   `System.Int32`
   `uint`    |   `System.UInt32`
-  `nint`    |    none; see below
-  `nuint`   |    none; see below
+  `nint`    |   `System.IntPtr`
+  `nuint`   |   `System.UIntPtr`
   `long`    |   `System.Int64`
   `ulong`   |   `System.UInt64`
   `char`    |   `System.Char`
@@ -300,7 +300,7 @@
   `bool`    |   `System.Boolean`
   `decimal` |   `System.Decimal`
 
-Every simple type has members. Each simple type that is an alias for a predefined struct type, has that struct type’s members.
+Every simple type has members. Each simple type has its aliased struct type’s members.
 
 > *Example*: `int` has any implementation-specific members declared in `System.Int32` and the members (required and implementation specific) inherited from `System.Object`, and the following statements are permitted:
 >
@@ -324,14 +324,6 @@
 >
 > *end note*.
 
-<!-- C# 11: In C# 11, nint and nuint become true aliases for System.IntPtr and System.UIntPtr. The following paragraphs describing the non-alias relationship should be updated or removed. -->
-
-The types `nint` and `nuint` are represented by the types `System.IntPtr` and `System.UIntPtr`, respectively, and are *not* aliases for these types. In this context being *represented by* means:
-
-- The only members directly accessible for `nint` and `nuint` are the required methods of `Object` ([§C.2](standard-library.md#c2-standard-library-types-defined-in-isoiec-23271)). Any other members of `System.IntPtr` and `System.UIntPtr` may be accessed via those types.
-- Operations performed through `dynamic` binding on `System.IntPtr` and `System.UIntPtr` values do not have access to the `nint` and `nuint` operators.
-- In all other respects `nint` and `nuint` behave as if they are aliases of `System.IntPtr` and `System.UIntPtr`.
-
 ### 8.3.6 Integral types
 
 C# supports the following integral types, with the sizes and value ranges, as shown:

standard/unsafe-code.md

@@ -787,22 +787,28 @@ In an unsafe context, the `+` operator ([§12.13.5](expressions.md#12135-additio
 ```csharp
 T* operator +(T* x, int y);
 T* operator +(T* x, uint y);
+T* operator +(T* x, nint y);
+T* operator +(T* x, nuint y);
 T* operator +(T* x, long y);
 T* operator +(T* x, ulong y);
 T* operator +(int x, T* y);
 T* operator +(uint x, T* y);
+T* operator +(nint x, T* y);
+T* operator +(nuint x, T* y);
 T* operator +(long x, T* y);
 T* operator +(ulong x, T* y);
 T* operator –(T* x, int y);
 T* operator –(T* x, uint y);
+T* operator -(T* x, nint y);
+T* operator -(T* x, nuint y);
 T* operator –(T* x, long y);
 T* operator –(T* x, ulong y);
 long operator –(T* x, T* y);
 ```
 
 There are no predefined operators for pointer addition or subtraction with native integer ([§8.3.6](types.md#836-integral-types)) offsets. Instead, `nint` and `nuint` values shall be promoted to `long` and `ulong`, respectively, with pointer arithmetic using the predefined operators for those types.
 
-Given an expression `P` of a data pointer type `T*` and an expression `N` of type `int`, `uint`, `long`, or `ulong`, the expressions `P + N` and `N + P` compute the pointer value of type `T*` that results from adding `N * sizeof(T)` to the address given by `P`. Likewise, the expression `P – N` computes the pointer value of type `T*` that results from subtracting `N * sizeof(T)` from the address given by `P`.
+Given an expression `P` of a data pointer type `T*` and an expression `N` of type `int`, `uint`, `nint`, `nuint`, `long`, or `ulong`, the expressions `P + N` and `N + P` compute the pointer value of type `T*` that results from adding `N * sizeof(T)` to the address given by `P`. Likewise, the expression `P – N` computes the pointer value of type `T*` that results from subtracting `N * sizeof(T)` from the address given by `P`.
 
 Given two expressions, `P` and `Q`, of a data pointer type `T*`, the expression `P – Q` computes the difference between the addresses given by `P` and `Q` and then divides that difference by `sizeof(T)`. The type of the result is always `long`. In effect, `P - Q` is computed as `((long)(P) - (long)(Q)) / sizeof(T)`.