Address operator feedback

1. Arithmetic operator code blocks (all add nint/nuint between uint/ulong and long/ulong lines):
   - added nint operator *(nint x, nint y); and nuint operator *(nuint x, nuint y);
   - added nint/nuint division operators
   - added nint/nuint remainder operators
   - added nint/nuint addition operators
   - added nint/nuint subtraction operators (also fixed missing closing paren on ulong line)
2. Shift operator code blocks:
   - added nint operator <<(nint x, int count); and nuint operator <<(nuint x, int count);
   - added nint operator >>(nint x, int count); and nuint operator >>(nuint x, int count);
3. Unary minus operator:
    - added nint operator –(nint x);
    - updated to mention nint: "(−2³¹ for int, the corresponding value for nint, or −2⁶³ for long)"

Author: BillWagner

standard/expressions.md

@@ -3612,11 +3612,12 @@ For an operation of the form `-x`, unary operator overload resolution ([§12.4.
 
   ```csharp
   int operator –(int x);
+  nint operator –(nint x);
   long operator –(long x);
   ```
 
-  The result is computed by subtracting `X` from zero. If the value of `X` is the smallest representable value of the operand type (−2³¹ for `int` or −2⁶³ for `long`), then the mathematical negation of `X` is not representable within the operand type. If this occurs within a `checked` context, a `System.OverflowException` is thrown; if it occurs within an `unchecked` context, the result is the value of the operand and the overflow is not reported.
-
+  The result is computed by subtracting `X` from zero. If the value of `X` is the smallest representable value of the operand type (−2³¹ for `int`, the corresponding value for `nint`, or −2⁶³ for `long`), then the mathematical negation of `X` is not representable within the operand type. If this occurs within a `checked` context, a `System.OverflowException` is thrown; if it occurs within an `unchecked` context, the result is the value of the operand and the overflow is not reported.
+  
   If the operand of the negation operator is of type `uint`, it is converted to type `long`, and the type of the result is `long`. An exception is the rule that permits the `int` value `−2147483648` (−2³¹) to be written as a decimal integer literal ([§6.4.5.3](lexical-structure.md#6453-integer-literals)).
 
   If the operand of the negation operator is of type `nuint`, a compile-time error occurs.
@@ -3971,6 +3972,8 @@ The predefined multiplication operators are listed below. The operators all comp
   ```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);
   ```
@@ -4018,6 +4021,8 @@ The predefined division operators are listed below. The operators all compute th
   ```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);
   ```
@@ -4069,6 +4074,8 @@ The predefined remainder operators are listed below. The operators all compute t
   ```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);
   ```
@@ -4119,6 +4126,8 @@ The predefined addition operators are listed below. For numeric and enumeration
   ```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);
   ```
@@ -4221,8 +4230,10 @@ The predefined subtraction operators are listed below. The operators all subtrac
   ```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
+  ulong operator –(ulong x, ulong y);
   ```
 
   In a `checked` context, if the difference is outside the range of the result type, a `System.OverflowException` is thrown. In an `unchecked` context, overflows are not reported and any significant high-order bits outside the range of the result type are discarded.
@@ -4346,6 +4357,8 @@ The predefined shift operators are listed below.
   ```csharp
   int operator <<(int x, int count);
   uint operator <<(uint x, int count);
+  nint operator <<(nint x, int count);
+  nuint operator <<(nuint x, int count);
   long operator <<(long x, int count);
   ulong operator <<(ulong x, int count);
   ```
@@ -4358,6 +4371,8 @@ The predefined shift operators are listed below.
   ```csharp
   int operator >>(int x, int count);
   uint operator >>(uint x, int count);
+  nint operator >>(nint x, int count);
+  nuint operator >>(nuint x, int count);
   long operator >>(long x, int count);
   ulong operator >>(ulong x, int count);
   ```