Native-sized integers proposal #2833

cston · 2019-09-27T15:23:49Z

No description provided.

tannergooding · 2019-09-27T17:18:15Z

proposals/NativeInt.md

+
+### Constants
+
+There is no direct syntax for native int literals. Explicit casts of other integral constant values can be used instead: `(nint)42`.


Given that there is an implicit conversion from int to nint, nint x = 42 and nint x = (nint)42 would both be valid, correct?

I presume const nint x = 42 would also work? #Resolved

Yes, const nint x = 42 would work.

In reply to: 329172165 [](ancestors = 329172165)

danmoseley · 2019-09-30T19:02:30Z

proposals/NativeInt.md

+New contextual keywords `nint` and `nuint` represent native signed and unsigned integer types.
+The identifiers are only treated as keywords when used in a type context and when the identifier does not otherwise bind to a symbol at that program location.
+
+The types `nint` and `nuint` are essentially aliases to underlying types `System.IntPtr` and `System.UIntPtr`, where the compiler can surface additional conversions and operations for native ints.


Presumably a secondary motivation is to reduce confusion? I have always found it confusing that IntPtr is often not representing a pointer.

danmoseley · 2019-09-30T19:04:33Z

proposals/NativeInt.md

+
+### Metadata
+
+`nint` and `nuint` are represented in metadata as `System.IntPtr` and `System.UIntPtr`.


Do I understand correctly that there is no longer any reason to use IntPtr and UIntPtr? Even public API can be changed, it seems. We could search and replace our entire codebase?

There may be some reasoning to continue using IntPtr if users want to clearly differentiate something that is meant to be an "opaque handle" vs something that is meant to be a "native integer". Something that is meant to be a "pointer" could fall into either category, depending on what operations you need to perform on it.

An opaque handle is often not a pointer, even under the covers. So the confusion still exists (possibly in my mind only)

Right, opaque handles are often something you never want to perform arithmetic with; and so they are good candidates to stay as IntPtr.

Things which are actually pointers you may want to make nint, if performing arithmetic is something needed.

Things which are actually numbers you probably want to make nint, since you want to treat them as numbers.

Right, hence we're continuing to recommend something that contains Ptr in the name for representing things that are not necessarily pointers. That's a shame, but perhaps it isn't a problem this set out to solve.

tannergooding · 2019-09-30T19:10:45Z

proposals/NativeInt.md

+```C#
+public static readonly IntPtr Zero;
+public static int Size { get; }
+public static IntPtr Add(IntPtr pointer, int offset);


Is it worth calling out that these members have the behavior of that for IntPtr, so some (like Add and Subtract) may differ in behavior from the nint operators?

I find that confusing. What is the rationale for Add not to return native type? #ByDesign

These are existing members on Sustem.IntPtr with a particular behavior, changing that behavior is a breaking change.

The corresponding nint operator +(nint, nint) operator is included in the Operators section above.

In reply to: 330888788 [](ancestors = 330888788)

tannergooding · 2019-09-30T19:13:01Z

proposals/NativeInt.md

+
+### Miscellaneous
+
+`native int` types cannot be used as enum underlying types.


Why not? Given the constraints for constants (values must be less than int.MaxValue and greater than int.MinValue) and that the runtime explicitly supports native int enums, it seems like this would be beneficial for some interop code?

tannergooding

LGTM

gafter · 2019-10-02T20:13:21Z

proposals/NativeInt.md

+[design]: #design
+
+New contextual keywords `nint` and `nuint` represent native signed and unsigned integer types.
+The identifiers are only treated as keywords when used in a type context and when the identifier does not otherwise bind to a symbol at that program location.


when the identifier does not otherwise bind to a symbol at that program location [](start = 77, length = 80)

This needs to be specified as a modification to name lookup. There is no existing spec concept of when an identifier "does not otherwise bind" to a symbol. #Resolved

gafter · 2019-10-02T20:14:47Z

proposals/NativeInt.md

+New contextual keywords `nint` and `nuint` represent native signed and unsigned integer types.
+The identifiers are only treated as keywords when used in a type context and when the identifier does not otherwise bind to a symbol at that program location.
+
+The types `nint` and `nuint` are essentially aliases to underlying types `System.IntPtr` and `System.UIntPtr`, where the compiler can surface additional conversions and operations for native ints.


essentially aliases [](start = 33, length = 19)

The first half of this sentence and the second half contradict each other (if it is an alias then it has precisely the same set of operations). I think you want to say that they are represented by the underling types in the implementation, and that there is an identity conversion in both directions between these types. #Resolved

gafter · 2019-10-02T20:15:36Z

proposals/NativeInt.md

+
+### Constants
+
+There is no direct syntax for native int literals. Explicit casts of other integral constant values can be used instead: `(nint)42`.


direct syntax for native int literals [](start = 12, length = 37)

Do you intend that constants of these new types exist? If so, the spec for "constant expressions" would need to be amended. #Resolved

gafter · 2019-10-02T20:16:29Z

proposals/NativeInt.md

+There are no `MinValue` or `MaxValue` fields on `nint` or `nuint` because, other than `nuint.MinValue`, those values cannot be emitted as constants.
+
+Constant folding is supported for all operators: { (unary)`-`, `~`, `+`, `-`, `*`, `/`, `%`, `==`, `!=`, `<`, `<=`, `>`, `>=`, `&`, `|`, `<<`, `>>` }.
+Constant folding operations are evaluated with `Int32` and `UInt32` operands rather than native ints for consistent behavior regardless of compiler platform.


are evaluated with Int32 and UInt32 operands [](start = 28, length = 48)

In other words, they produce different values than are produced at runtime on some platforms? #Resolved

Such combinations that could produce different values should be disallowed without explicit unchecked context like int.MaxValue + 1 is disallowed today for int constants.

I believe the decision in the last LDM meeting was that nint x = int.MaxValue + 1 would be illegal, even with unchecked due to the platform specific differences.

Instead, constant folding would only be allowed if the operation stayed within the 32-bit range limitation put forth by the compiler.

It would probably be worth explaining this limitation or elaborating on how folding works if I'm misremembering.

Constant expressions that exceed 32 bits will be reported as errors.

In reply to: 330750070 [](ancestors = 330750070)

Constant expressions that exceed 32 bits will be reported as errors.

In reply to: 330750070 [](ancestors = 330750070)

I don't see how unary ~ could ever be valid given that constraint.
#Resolved

Good catch, thanks.

In reply to: 386612190 [](ancestors = 386612190)

gafter · 2019-10-02T20:19:43Z

proposals/NativeInt.md

+
+### Operators
+
+The following operators are supported.


are supported [](start = 24, length = 13)

Do you mean to say that these are built-in operators considered when seeking to determine the semantics of an operation in source, like the built-in ones described in https://github.com/dotnet/csharplang/blob/master/spec/expressions.md#addition-operator ? #Resolved

gafter · 2019-10-02T20:21:10Z

proposals/NativeInt.md

+| `>=` | `native` | `native` | `native` | `bge` / `bge.un` |
+| `&` | `native` | `native` | `native` | `and` |
+| `\|` | `native` | `native` | `native` | `or` |
+| `<<` | `native` | `int` | `native` | `shl` |


<< [](start = 2, length = 4)

What are the semantics of the shift operators? For comparison, the spec in https://github.com/dotnet/csharplang/blob/master/spec/expressions.md#shift-operators has text that begins "For the predefined operators, the number of bits to shift is computed as follows" The compiler produces code to mask off any "extra" bits because the IL instructions that perform the shift are undefined outside the valid range of shift values. What mask do you imagine the C# compiler would produce for the shift operators? #Resolved

gafter · 2019-10-02T20:26:00Z

proposals/NativeInt.md

+## Unresolved questions
+[unresolved]: #unresolved-questions
+
+What parts of the design are still undecided?


What parts of the design are still undecided [](start = 0, length = 44)

What is the common type between a value of type nint and a value of type IntPtr? The common type between G<nint> and G<IntPtr>? When both are bounds in type inference, which wins?

gafter · 2019-10-02T20:28:17Z

proposals/NativeInt.md

+Constant folding operations are evaluated with `Int32` and `UInt32` operands rather than native ints for consistent behavior regardless of compiler platform.
+
+### Conversions
+Types that differ only by `nint` and `IntPtr` and by `nuint` and `UIntPtr` are considered equivalent. That applies to the primitive types as well as arrays, `Nullable<>`, constructed types, and tuples.


are considered equivalent [](start = 75, length = 25)

I presume you mean there is an identity conversion between them. #Resolved

gafter · 2019-10-02T21:10:24Z

proposals/NativeInt.md

+| `>` | `native` | `native` | `native` | `bgt` / `cgt` / `bgt.un` / `cgt.un` |
+| `>=` | `native` | `native` | `native` | `bge` / `bge.un` |
+| `&` | `native` | `native` | `native` | `and` |
+| `\|` | `native` | `native` | `native` | `or` |


\| [](start = 2, length = 4)

This should be <code>|</code> to get it to render properly #Resolved

gafter · 2019-10-02T21:12:07Z

I don't have any further comments (Iteration 5). #Resolved

gafter · 2019-10-03T03:19:40Z

From #435 (comment) : please specify that these types are atomic. #Resolved

marek-safar · 2019-10-03T06:56:40Z

proposals/NativeInt.md

+```
+
+The optional attribute argument contains a bit for each primitive type in the type reference.
+If there is a single primitive type, the parameter-less constructor can be used.


I think this needs better wording to be clear for cases like (IntPtr, nint) B

nietras · 2019-10-03T07:05:07Z

Good to see a proposal for adding this to C# 👍

Just to plug my own exercises in futility you might find https://github.com/DotNetCross/NativeInts interesting with regards to API. This lists all operators and includes tests that can be viewed for inspiration.

gafter · 2019-12-05T20:22:22Z

proposals/NativeInt.md

+
+(The IL for each operator includes the variants for `unchecked` and `checked` contexts if different.)
+
+| Unary | Operator Signature | IL |


Per the shape of the language specification, this should be something like

nint operator +(nint value); // nop nuint operator +(nuint value); // nop nint operator -(nint value); // neg nint operator ~(nint value); // not nuint operator ~(nuint value); // not

They are definitely not considered members of the types as indicated here. #Resolved

gafter · 2019-12-05T20:22:42Z

proposals/NativeInt.md

+
+### Operators
+
+The following operators are provided by the compiler.


The following operators are provided by the compiler [](start = 0, length = 52)

The predefined operators are as follows. #Resolved

gafter · 2019-12-05T20:30:05Z

proposals/NativeInt.md

+| `nuint` | `char` | ExplicitNumeric | `conv.u2` / `conv.ovf.u2.un` |
+| `nuint` | `float` | ImplicitNumeric | `conv.r.un conv.r4` |
+| `nuint` | `double` | ImplicitNumeric | `conv.r.un conv.r8` |
+| `nuint` | `decimal` | ExplicitNumeric | `ulong decimal.op_Explicit(decimal) UIntPtr UIntPtr.op_Explicit(ulong)` |


ExplicitNumeric [](start = 24, length = 15)

Since the conversion from ulong to decimal is an implicit conversion, this should be too. #Resolved

https://github.com/dotnet/csharplang/pull/2833/files#r386614583

gafter · 2019-12-05T20:43:26Z

proposals/NativeInt.md

+| `nint` | `char` | ExplicitNumeric | `conv.u2` / `conv.ovf.u2` |
+| `nint` | `float` | ImplicitNumeric | `conv.r4` |
+| `nint` | `double` | ImplicitNumeric | `conv.r8` |
+| `nint` | `decimal` | ExplicitNumeric | `long decimal.op_Explicit(decimal) IntPtr IntPtr.op_Explicit(long)` |


ExplicitNumeric [](start = 23, length = 15)

Since the conversion from long to decimal is an implicit conversion, this should be too. #Resolved

From a future-proofing perspective, I don't think that makes sense. long and decimal both have fixed sizes, and a long can always be represented as a decimal without any loss in precision--that's a strong guarantee. That isn't the case for nint/nuint -> decimal. If .NET Core ever lands on a platform with 128-bit native ints, that decision is going to be hard to correct.

gafter · 2020-01-10T01:33:52Z

proposals/NativeInt.md

+Constant folding operations are evaluated with `Int32` and `UInt32` operands rather than native ints for consistent behavior regardless of compiler platform.
+
+### Conversions
+There are identity conversions between native ints and the underlying types in both directions.


between native ints and the underlying types [](start = 31, length = 44)

Please make these explicit. Specifically, please say that "There is an identity conversion between nint and IntPtr, and between nuint and UIntPtr." #Resolved

gafter · 2020-01-10T01:36:18Z

proposals/NativeInt.md

+}
+```
+
+`nint` and `nuint` can be used as an `enum` base type.


enum [](start = 38, length = 4)

What is the reason for this change? How it is helpful to users? #Resolved

The decision at https://github.com/dotnet/csharplang/blob/master/meetings/2019/LDM-2019-10-23.md was to allow as enum underlying type if it is "not too much implementation work".

In reply to: 365039199 [](ancestors = 365039199)

crowo · 2020-03-02T19:12:40Z

Also there is need to specify FieldOffset in explicit StructLayout classes/structs which contain pointer sized fields. So we need compiler support to specify word size's in attributes and/or constants. also something like const void* invalidHandle = (void*)-1; should be valid as IntPtr isnt treated like primitive.

jcouv · 2020-04-08T19:55:54Z

@cston Can this be merged, so that I can link to it?

gafter · 2020-04-13T23:53:36Z

proposals/native-integers.md

+Constant folding is supported for all unary operators { `+`, `-` } and binary operators { `+`, `-`, `*`, `/`, `%`, `==`, `!=`, `<`, `<=`, `>`, `>=`, `&`, `|`, `^`, `<<`, `>>` }.
+Constant folding operations are evaluated with `Int32` and `UInt32` operands rather than native ints for consistent behavior regardless of compiler platform.
+If the operation results in a constant value in 32-bits, constant folding is performed at compile-time.
+Otherwise the operation is executed at runtime and not considered a constant. (The unary operator `~` in particular cannot be used in constant expressions.)


The unary operator ~ in particular cannot be used in constant expressions [](start = 79, length = 75)

I think this is not correct. ~ can be used in constant expressions for all nint values (e.g. ~(nint)0) is (nint)-1; in general ~(nint)(int)N is (nint)(~(int)N)). This sentence is correct for nuint, as the result value always depends on sizeof(nuint). #Closed

gafter · 2020-04-13T23:56:01Z

proposals/native-integers.md

+### Operators
+
+The predefined operators are as follows.
+These operators are considered during overload resolution based on normal rules for implicit conversions of arguments.


based on normal rules for implicit [](start = 58, length = 34)

These operators are only considered if one of the operands is of type nint or nuint. #Closed

gafter · 2020-04-13T23:59:19Z

proposals/native-integers.md

+Compound assignment operations `x op= y` where `x` or `y` are native ints follow the same rules as with other primitive types with pre-defined operators.
+Specifically the expression is bound as `x = (T)(x op y)` where `T` is the type of `x` and where `x` is only evaluated once.
+
+The shift operators should mask the number of bits to shift appropriately


appropriately [](start = 60, length = 13)

You should clarify that "appropriately" means to five bits if sizeof(nint) is 4, and to six bits of sizeof(nint) is 5. We cannot get that from the quoted section of the spec. #Closed

gafter · 2020-04-14T00:00:20Z

proposals/native-integers.md

+```C#
+nint x = 3;
+var y = nameof(nuint);
+var z = nint.Zero;


Zero [](start = 13, length = 4)

Disagrees with line 214, which says that Zero is not a member. #Closed

gafter · 2020-04-14T00:01:26Z

proposals/native-integers.md

+public string ToString(string format);
+```
+
+Interfaces implemented by `System.IntPtr` and `System.UIntPtr` _are implicitly included_ in `nint` and `nuint`.


included_ [](start = 79, length = 9)

...with occurrences of the underlying type replaced by the corresponding native type. #Closed

gafter · 2020-04-14T00:57:57Z

proposals/native-integers.md

+
+### Miscellaneous
+
+`nint` and `nuint` expressions used as array indices are emitted without conversion.


emitted without conversion [](start = 57, length = 26)

It isn't clear what "emitted without conversion" means. The specification for array indexing requires a conversion, and the array indexing IL instructions have specific requirements for the type of the index.

array indexing IL instructions have specific requirements for the type of the index

IL instructions like ldelem and ldelema take either a native int or an int32

gafter · 2020-04-14T01:03:14Z

proposals/native-integers.md

+
+### Constants
+
+There is no direct syntax for native int literals. Explicit casts of other integral constant values can be used instead: `(nint)42`.


direct syntax for native int literals [](start = 12, length = 37)

Do you intend that constant expressions can be of these new types? If so, you need to explicitly say so, as the spec for "constant expressions" excludes these types from the list of types for which constants exist. #Closed

gafter · 2020-04-14T01:04:38Z

Finished reviewing (Commit 17)

gafter

gafter · 2020-04-14T19:37:13Z

Open question: What is the common type between a value of type nint and a value of type IntPtr? The common type between G and G? When both are bounds in type inference, which wins?

gafter

cston force-pushed the NativeInt branch from ab0ebef to c71ab1c Compare September 27, 2019 15:27

cston changed the title ~~Native int proposal~~ Native-sized integers proposal Sep 27, 2019

cston added 2 commits September 27, 2019 08:32

Native-sized integers proposal

4f2bc74

PR feedback

3287a05

cston force-pushed the NativeInt branch from c71ab1c to 3287a05 Compare September 27, 2019 15:33

cston marked this pull request as ready for review September 27, 2019 15:34

tannergooding reviewed Sep 27, 2019

View reviewed changes

Update available members

f6e7645

cston force-pushed the NativeInt branch from 9078906 to f6e7645 Compare September 27, 2019 17:57

Misc.

b20766e

danmoseley reviewed Sep 30, 2019

View reviewed changes

tannergooding reviewed Sep 30, 2019

View reviewed changes

tannergooding approved these changes Sep 30, 2019

View reviewed changes

Fix table entry

8749711

gafter reviewed Oct 2, 2019

View reviewed changes

gafter mentioned this pull request Oct 3, 2019

Champion "Native-Sized Number Types" (VS 16.8, .NET 5) #435

Open

5 tasks

marek-safar reviewed Oct 3, 2019

View reviewed changes

gafter reviewed Dec 5, 2019

View reviewed changes

Update attribute description

b75760a

gafter reviewed Jan 10, 2020

View reviewed changes

tannergooding mentioned this pull request Mar 2, 2020

Support natural size data types in the CLR dotnet/runtime#4233

Closed

jcouv mentioned this pull request Mar 12, 2020

Test plan for "native ints" dotnet/roslyn#38821

Closed

83 tasks

cston added 4 commits April 11, 2020 16:24

PR feedback

65f0b3a

Rename

2328c97

Misc.

585249e

Misc.

3b5a5dc

gafter reviewed Apr 13, 2020

View reviewed changes

gafter reviewed Apr 14, 2020

View reviewed changes

PR feedback

2b2a91d

gafter approved these changes Apr 14, 2020

View reviewed changes

cston merged commit 583bdd2 into dotnet:master Apr 14, 2020

cston deleted the NativeInt branch April 14, 2020 19:39


		### Constants

		There is no direct syntax for native int literals. Explicit casts of other integral constant values can be used instead: `(nint)42`.


		### Metadata

		`nint` and `nuint` are represented in metadata as `System.IntPtr` and `System.UIntPtr`.


		### Miscellaneous

		`native int` types cannot be used as enum underlying types.


		(The IL for each operator includes the variants for `unchecked` and `checked` contexts if different.)

		\| Unary \| Operator Signature \| IL \|


		### Operators

		The following operators are provided by the compiler.


		### Miscellaneous

		`nint` and `nuint` expressions used as array indices are emitted without conversion.

Native-sized integers proposal #2833

Native-sized integers proposal #2833

Conversation

cston commented Sep 27, 2019

tannergooding Sep 27, 2019 • edited by cston Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

marek-safar Oct 3, 2019 • edited by cston Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

tannergooding left a comment

Choose a reason for hiding this comment

gafter Oct 2, 2019 • edited by cston Loading

Choose a reason for hiding this comment

gafter Oct 2, 2019 • edited by cston Loading

Choose a reason for hiding this comment

gafter Oct 2, 2019 • edited Loading

Choose a reason for hiding this comment

gafter Oct 2, 2019 • edited by cston Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Zenexer Mar 2, 2020 • edited by cston Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

gafter Oct 2, 2019 • edited Loading

Choose a reason for hiding this comment

gafter Oct 2, 2019 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

gafter Oct 2, 2019 • edited by cston Loading

Choose a reason for hiding this comment

gafter Oct 2, 2019 • edited by cston Loading

Choose a reason for hiding this comment

gafter commented Oct 2, 2019 • edited by cston Loading

gafter commented Oct 3, 2019 • edited by cston Loading

Choose a reason for hiding this comment

nietras commented Oct 3, 2019

gafter Dec 5, 2019 • edited by cston Loading

Choose a reason for hiding this comment

gafter Dec 5, 2019 • edited by cston Loading

Choose a reason for hiding this comment

gafter Dec 5, 2019 • edited by cston Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

gafter Dec 5, 2019 • edited by cston Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

gafter Jan 10, 2020 • edited by cston Loading

Choose a reason for hiding this comment

gafter Jan 10, 2020 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

crowo commented Mar 2, 2020

jcouv commented Apr 8, 2020

gafter Apr 13, 2020 • edited Loading

Choose a reason for hiding this comment

gafter Apr 13, 2020 • edited Loading

Choose a reason for hiding this comment

gafter Apr 13, 2020 • edited Loading

Choose a reason for hiding this comment

gafter Apr 14, 2020 • edited Loading

Choose a reason for hiding this comment

gafter Apr 14, 2020 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

gafter Apr 14, 2020 • edited Loading

Choose a reason for hiding this comment

gafter commented Apr 14, 2020

tannergooding Sep 27, 2019 •

edited by cston

Loading

marek-safar Oct 3, 2019 •

edited by cston

Loading

gafter Oct 2, 2019 •

edited by cston

Loading

gafter Oct 2, 2019 •

edited by cston

Loading

gafter Oct 2, 2019 •

edited

Loading

gafter Oct 2, 2019 •

edited by cston

Loading

Zenexer Mar 2, 2020 •

edited by cston

Loading

gafter Oct 2, 2019 •

edited

Loading

gafter Oct 2, 2019 •

edited

Loading

gafter Oct 2, 2019 •

edited by cston

Loading

gafter Oct 2, 2019 •

edited by cston

Loading

gafter commented Oct 2, 2019 •

edited by cston

Loading

gafter commented Oct 3, 2019 •

edited by cston

Loading

gafter Dec 5, 2019 •

edited by cston

Loading

gafter Dec 5, 2019 •

edited by cston

Loading

gafter Dec 5, 2019 •

edited by cston

Loading

gafter Dec 5, 2019 •

edited by cston

Loading

gafter Jan 10, 2020 •

edited by cston

Loading

gafter Jan 10, 2020 •

edited

Loading

gafter Apr 13, 2020 •

edited

Loading

gafter Apr 13, 2020 •

edited

Loading

gafter Apr 13, 2020 •

edited

Loading

gafter Apr 14, 2020 •

edited

Loading

gafter Apr 14, 2020 •

edited

Loading

gafter Apr 14, 2020 •

edited

Loading