Removed JIT (uint) cast workaround to elide bound-checks in CoreLib (#67448)

gfoidl · web-flow · commit 6e33ec9a499f · 2022-07-12T10:54:20.000-07:00
* Removed (uint) cast workaround in CoreLib, annotated missing places with TODOs * Fixed the bug I introduced in TimeSpanParse.TimeSpanTokenizer * Use uint-cast on both sided for clarity Cf. #67448 (comment) * Use uint-division in BitHelper as the JIT can produce more efficient code Cf. #67448 (comment) * Don't have struct local in ValueStringBuilder due to hitting JIT optimization limits Cf. #67448 (comment) * BitHelper with uint division and without Math.DivRem for even better codegen AggressiveInlining isn't needed anymore, also the JIT recognizes the _span field, so no local Span is needed here. * BitHelper needs local Span due to regression in jit-diff otherwise * Added Debug.Asserts to BitHelper's method that take bitPosition * BitHelper: comment for workaround to tracking issue
diff --git a/src/libraries/Common/src/System/Collections/Generic/BitHelper.cs b/src/libraries/Common/src/System/Collections/Generic/BitHelper.cs
@@ -1,6 +1,8 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Diagnostics;
+
 namespace System.Collections.Generic
 {
     internal ref struct BitHelper
@@ -19,19 +21,29 @@ internal BitHelper(Span<int> span, bool clear)
 
         internal void MarkBit(int bitPosition)
         {
-            int bitArrayIndex = bitPosition / IntSize;
-            if ((uint)bitArrayIndex < (uint)_span.Length)
+            Debug.Assert(bitPosition >= 0);
+
+            uint bitArrayIndex = (uint)bitPosition / IntSize;
+
+            // Workaround for https://github.com/dotnet/runtime/issues/72004
+            Span<int> span = _span;
+            if (bitArrayIndex < (uint)span.Length)
             {
-                _span[bitArrayIndex] |= (1 << (bitPosition % IntSize));
+                span[(int)bitArrayIndex] |= (1 << (int)((uint)bitPosition % IntSize));
             }
         }
 
         internal bool IsMarked(int bitPosition)
         {
-            int bitArrayIndex = bitPosition / IntSize;
+            Debug.Assert(bitPosition >= 0);
+
+            uint bitArrayIndex = (uint)bitPosition / IntSize;
+
+            // Workaround for https://github.com/dotnet/runtime/issues/72004
+            Span<int> span = _span;
             return
-                (uint)bitArrayIndex < (uint)_span.Length &&
-                (_span[bitArrayIndex] & (1 << (bitPosition % IntSize))) != 0;
+                bitArrayIndex < (uint)span.Length &&
+                (span[(int)bitArrayIndex] & (1 << ((int)((uint)bitPosition % IntSize)))) != 0;
         }
 
         /// <summary>How many ints must be allocated to represent n bits. Returns (n+31)/32, but avoids overflow.</summary>
diff --git a/src/libraries/System.Private.CoreLib/src/System/Boolean.cs b/src/libraries/System.Private.CoreLib/src/System/Boolean.cs
@@ -99,7 +99,7 @@ public bool TryFormat(Span<char> destination, out int charsWritten)
         {
             if (m_value)
             {
-                if ((uint)destination.Length > 3) // uint cast, per https://github.com/dotnet/runtime/issues/10596
+                if (destination.Length > 3)
                 {
                     ulong true_val = BitConverter.IsLittleEndian ? 0x65007500720054ul : 0x54007200750065ul; // "True"
                     MemoryMarshal.Write<ulong>(MemoryMarshal.AsBytes(destination), ref true_val);
@@ -109,7 +109,7 @@ public bool TryFormat(Span<char> destination, out int charsWritten)
             }
             else
             {
-                if ((uint)destination.Length > 4)
+                if (destination.Length > 4)
                 {
                     ulong fals_val = BitConverter.IsLittleEndian ? 0x73006C00610046ul : 0x460061006C0073ul; // "Fals"
                     MemoryMarshal.Write<ulong>(MemoryMarshal.AsBytes(destination), ref fals_val);
diff --git a/src/libraries/System.Private.CoreLib/src/System/Buffers/StandardFormat.cs b/src/libraries/System.Private.CoreLib/src/System/Buffers/StandardFormat.cs
@@ -164,8 +164,7 @@ internal int Format(Span<char> destination)
             int count = 0;
             char symbol = Symbol;
 
-            if (symbol != default &&
-                (uint)destination.Length == FormatStringLength) // to eliminate bounds checks
+            if (symbol != default && destination.Length == FormatStringLength)
             {
                 destination[0] = symbol;
                 count = 1;
diff --git a/src/libraries/System.Private.CoreLib/src/System/Buffers/Text/Utf8Formatter/Utf8Formatter.Boolean.cs b/src/libraries/System.Private.CoreLib/src/System/Buffers/Text/Utf8Formatter/Utf8Formatter.Boolean.cs
@@ -65,7 +65,7 @@ public static bool TryFormat(bool value, Span<byte> destination, out int bytesWr
                 {
                     // This check can't be performed earlier because we need to throw if an invalid symbol is
                     // provided, even if the buffer is too small.
-                    if ((uint)4 >= (uint)destination.Length)
+                    if (destination.Length <= 4)
                     {
                         goto BufferTooSmall;
                     }
@@ -75,7 +75,7 @@ public static bool TryFormat(bool value, Span<byte> destination, out int bytesWr
                 }
                 else if (symbol == 'l')
                 {
-                    if ((uint)4 >= (uint)destination.Length)
+                    if (destination.Length <= 4)
                     {
                         goto BufferTooSmall;
                     }
diff --git a/src/libraries/System.Private.CoreLib/src/System/Buffers/Text/Utf8Formatter/Utf8Formatter.Date.L.cs b/src/libraries/System.Private.CoreLib/src/System/Buffers/Text/Utf8Formatter/Utf8Formatter.Date.L.cs
@@ -13,9 +13,7 @@ public static partial class Utf8Formatter
         //
         private static bool TryFormatDateTimeL(DateTime value, Span<byte> destination, out int bytesWritten)
         {
-            // Writing the check in this fashion elides all bounds checks on 'buffer'
-            // for the remainder of the method.
-            if ((uint)28 >= (uint)destination.Length)
+            if (destination.Length <= 28)
             {
                 bytesWritten = 0;
                 return false;
diff --git a/src/libraries/System.Private.CoreLib/src/System/Buffers/Text/Utf8Formatter/Utf8Formatter.Date.R.cs b/src/libraries/System.Private.CoreLib/src/System/Buffers/Text/Utf8Formatter/Utf8Formatter.Date.R.cs
@@ -13,9 +13,7 @@ public static partial class Utf8Formatter
         //
         private static bool TryFormatDateTimeR(DateTime value, Span<byte> destination, out int bytesWritten)
         {
-            // Writing the check in this fashion elides all bounds checks on 'buffer'
-            // for the remainder of the method.
-            if ((uint)28 >= (uint)destination.Length)
+            if (destination.Length <= 28)
             {
                 bytesWritten = 0;
                 return false;
diff --git a/src/libraries/System.Private.CoreLib/src/System/Char.cs b/src/libraries/System.Private.CoreLib/src/System/Char.cs
@@ -591,7 +591,7 @@ public static bool IsControl(string s, int index)
             {
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
             }
-            if (((uint)index) >= ((uint)s.Length))
+            if ((uint)index >= (uint)s.Length)
             {
                 ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);
             }
@@ -606,7 +606,7 @@ public static bool IsDigit(string s, int index)
             {
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
             }
-            if (((uint)index) >= ((uint)s.Length))
+            if ((uint)index >= (uint)s.Length)
             {
                 ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);
             }
@@ -626,7 +626,7 @@ public static bool IsLetter(string s, int index)
             {
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
             }
-            if (((uint)index) >= ((uint)s.Length))
+            if ((uint)index >= (uint)s.Length)
             {
                 ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);
             }
@@ -647,7 +647,7 @@ public static bool IsLetterOrDigit(string s, int index)
             {
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
             }
-            if (((uint)index) >= ((uint)s.Length))
+            if ((uint)index >= (uint)s.Length)
             {
                 ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);
             }
@@ -667,8 +667,7 @@ public static bool IsLower(string s, int index)
             {
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
             }
-
-            if (((uint)index) >= ((uint)s.Length))
+            if ((uint)index >= (uint)s.Length)
             {
                 ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);
             }
@@ -710,7 +709,7 @@ public static bool IsNumber(string s, int index)
             {
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
             }
-            if (((uint)index) >= ((uint)s.Length))
+            if ((uint)index >= (uint)s.Length)
             {
                 ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);
             }
@@ -743,7 +742,7 @@ public static bool IsPunctuation(string s, int index)
             {
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
             }
-            if (((uint)index) >= ((uint)s.Length))
+            if ((uint)index >= (uint)s.Length)
             {
                 ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);
             }
@@ -788,7 +787,7 @@ public static bool IsSeparator(string s, int index)
             {
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
             }
-            if (((uint)index) >= ((uint)s.Length))
+            if ((uint)index >= (uint)s.Length)
             {
                 ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);
             }
@@ -813,7 +812,7 @@ public static bool IsSurrogate(string s, int index)
             {
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
             }
-            if (((uint)index) >= ((uint)s.Length))
+            if ((uint)index >= (uint)s.Length)
             {
                 ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);
             }
@@ -845,7 +844,7 @@ public static bool IsSymbol(string s, int index)
             {
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
             }
-            if (((uint)index) >= ((uint)s.Length))
+            if ((uint)index >= (uint)s.Length)
             {
                 ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);
             }
@@ -865,7 +864,7 @@ public static bool IsUpper(string s, int index)
             {
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
             }
-            if (((uint)index) >= ((uint)s.Length))
+            if ((uint)index >= (uint)s.Length)
             {
                 ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);
             }
@@ -885,7 +884,7 @@ public static bool IsWhiteSpace(string s, int index)
             {
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
             }
-            if (((uint)index) >= ((uint)s.Length))
+            if ((uint)index >= (uint)s.Length)
             {
                 ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);
             }
@@ -911,7 +910,7 @@ public static UnicodeCategory GetUnicodeCategory(string s, int index)
             {
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
             }
-            if (((uint)index) >= ((uint)s.Length))
+            if ((uint)index >= (uint)s.Length)
             {
                 ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);
             }
@@ -935,7 +934,7 @@ public static double GetNumericValue(string s, int index)
             {
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
             }
-            if (((uint)index) >= ((uint)s.Length))
+            if ((uint)index >= (uint)s.Length)
             {
                 ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);
             }
@@ -957,7 +956,7 @@ public static bool IsHighSurrogate(string s, int index)
             {
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
             }
-            if (((uint)index) >= ((uint)s.Length))
+            if ((uint)index >= (uint)s.Length)
             {
                 ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);
             }
@@ -979,7 +978,7 @@ public static bool IsLowSurrogate(string s, int index)
             {
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
             }
-            if (((uint)index) >= ((uint)s.Length))
+            if ((uint)index >= (uint)s.Length)
             {
                 ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);
             }
@@ -996,7 +995,7 @@ public static bool IsSurrogatePair(string s, int index)
             {
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
             }
-            if (((uint)index) >= ((uint)s.Length))
+            if ((uint)index >= (uint)s.Length)
             {
                 ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);
             }
diff --git a/src/libraries/System.Private.CoreLib/src/System/Collections/Generic/ValueListBuilder.cs b/src/libraries/System.Private.CoreLib/src/System/Collections/Generic/ValueListBuilder.cs
@@ -44,9 +44,12 @@ public ref T this[int index]
         public void Append(T item)
         {
             int pos = _pos;
-            if ((uint)pos < (uint)_span.Length)
+
+            // Workaround for https://github.com/dotnet/runtime/issues/72004
+            Span<T> span = _span;
+            if ((uint)pos < (uint)span.Length)
             {
-                _span[pos] = item;
+                span[pos] = item;
                 _pos = pos + 1;
             }
             else
diff --git a/src/libraries/System.Private.CoreLib/src/System/Decimal.cs b/src/libraries/System.Private.CoreLib/src/System/Decimal.cs
@@ -602,7 +602,7 @@ public static int[] GetBits(decimal d)
         /// <exception cref="ArgumentException">The destination span was not long enough to store the binary representation.</exception>
         public static int GetBits(decimal d, Span<int> destination)
         {
-            if ((uint)destination.Length <= 3)
+            if (destination.Length <= 3)
             {
                 ThrowHelper.ThrowArgumentException_DestinationTooShort();
             }
@@ -623,7 +623,7 @@ public static int GetBits(decimal d, Span<int> destination)
         /// <returns>true if the decimal's binary representation was written to the destination; false if the destination wasn't long enough.</returns>
         public static bool TryGetBits(decimal d, Span<int> destination, out int valuesWritten)
         {
-            if ((uint)destination.Length <= 3)
+            if (destination.Length <= 3)
             {
                 valuesWritten = 0;
                 return false;
diff --git a/src/libraries/System.Private.CoreLib/src/System/Globalization/DateTimeParse.cs b/src/libraries/System.Private.CoreLib/src/System/Globalization/DateTimeParse.cs
@@ -4663,7 +4663,7 @@ private static bool ParseFormatR(ReadOnlySpan<char> source, ref ParsingInfo pars
             // Tue, 03 Jan 2017 08:08:05 GMT
 
             // The format is exactly 29 characters.
-            if ((uint)source.Length != 29)
+            if (source.Length != 29)
             {
                 result.SetBadDateTimeFailure();
                 return false;
@@ -4860,7 +4860,7 @@ private static bool ParseFormatO(ReadOnlySpan<char> source, ref DateTimeResult r
             // 2017-06-12T05:30:45.7680000-7:00   (special-case of one-digit offset hour)
             // 2017-06-12T05:30:45.7680000-07:00
 
-            if ((uint)source.Length < 27 ||
+            if (source.Length < 27 ||
                 source[4] != '-' ||
                 source[7] != '-' ||
                 source[10] != 'T' ||
@@ -4981,7 +4981,7 @@ private static bool ParseFormatO(ReadOnlySpan<char> source, ref DateTimeResult r
                 return false;
             }
 
-            if ((uint)source.Length > 27)
+            if (source.Length > 27)
             {
                 char offsetChar = source[27];
                 switch (offsetChar)
@@ -4999,7 +4999,7 @@ private static bool ParseFormatO(ReadOnlySpan<char> source, ref DateTimeResult r
                     case '-':
                         int offsetHours, colonIndex;
 
-                        if ((uint)source.Length == 33)
+                        if (source.Length == 33)
                         {
                             uint oh1 = (uint)(source[28] - '0'), oh2 = (uint)(source[29] - '0');
 
@@ -5012,7 +5012,7 @@ private static bool ParseFormatO(ReadOnlySpan<char> source, ref DateTimeResult r
                             offsetHours = (int)(oh1 * 10 + oh2);
                             colonIndex = 30;
                         }
-                        else if ((uint)source.Length == 32) // special-case allowed for compat: only one offset hour digit
+                        else if (source.Length == 32) // special-case allowed for compat: only one offset hour digit
                         {
                             offsetHours = source[28] - '0';
 
diff --git a/src/libraries/System.Private.CoreLib/src/System/Globalization/TimeSpanParse.cs b/src/libraries/System.Private.CoreLib/src/System/Globalization/TimeSpanParse.cs
diff --git a/src/libraries/System.Private.CoreLib/src/System/Guid.cs b/src/libraries/System.Private.CoreLib/src/System/Guid.cs
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/CompilerServices/DefaultInterpolatedStringHandler.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/CompilerServices/DefaultInterpolatedStringHandler.cs
diff --git a/src/libraries/System.Private.CoreLib/src/System/Text/Rune.cs b/src/libraries/System.Private.CoreLib/src/System/Text/Rune.cs
diff --git a/src/libraries/System.Private.CoreLib/src/System/Text/StringBuilder.cs b/src/libraries/System.Private.CoreLib/src/System/Text/StringBuilder.cs

Original file line number	Diff line number	Diff line change
`@@ -99,7 +99,7 @@ public bool TryFormat(Span<char> destination, out int charsWritten)`
`99`	`99`	`{`
`100`	`100`	`if (m_value)`
`101`	`101`	`{`
`102`		`- if ((uint)destination.Length > 3) // uint cast, per https://github.com/dotnet/runtime/issues/10596`
	`102`	`+ if (destination.Length > 3)`
`103`	`103`	`{`
`104`	`104`	`ulong true_val = BitConverter.IsLittleEndian ? 0x65007500720054ul : 0x54007200750065ul; // "True"`
`105`	`105`	`MemoryMarshal.Write<ulong>(MemoryMarshal.AsBytes(destination), ref true_val);`
`@@ -109,7 +109,7 @@ public bool TryFormat(Span<char> destination, out int charsWritten)`
`109`	`109`	`}`
`110`	`110`	`else`
`111`	`111`	`{`
`112`		`- if ((uint)destination.Length > 4)`
	`112`	`+ if (destination.Length > 4)`
`113`	`113`	`{`
`114`	`114`	`ulong fals_val = BitConverter.IsLittleEndian ? 0x73006C00610046ul : 0x460061006C0073ul; // "Fals"`
`115`	`115`	`MemoryMarshal.Write<ulong>(MemoryMarshal.AsBytes(destination), ref fals_val);`
Original file line number	Diff line number	Diff line change
`@@ -164,8 +164,7 @@ internal int Format(Span<char> destination)`
`164`	`164`	`int count = 0;`
`165`	`165`	`char symbol = Symbol;`
`166`	`166`
`167`		`- if (symbol != default &&`
`168`		`- (uint)destination.Length == FormatStringLength) // to eliminate bounds checks`
	`167`	`+ if (symbol != default && destination.Length == FormatStringLength)`
`169`	`168`	`{`
`170`	`169`	`destination[0] = symbol;`
`171`	`170`	`count = 1;`
Original file line number	Diff line number	Diff line change
`@@ -65,7 +65,7 @@ public static bool TryFormat(bool value, Span<byte> destination, out int bytesWr`
`65`	`65`	`{`
`66`	`66`	`// This check can't be performed earlier because we need to throw if an invalid symbol is`
`67`	`67`	`// provided, even if the buffer is too small.`
`68`		`- if ((uint)4 >= (uint)destination.Length)`
	`68`	`+ if (destination.Length <= 4)`
`69`	`69`	`{`
`70`	`70`	`goto BufferTooSmall;`
`71`	`71`	`}`
`@@ -75,7 +75,7 @@ public static bool TryFormat(bool value, Span<byte> destination, out int bytesWr`
`75`	`75`	`}`
`76`	`76`	`else if (symbol == 'l')`
`77`	`77`	`{`
`78`		`- if ((uint)4 >= (uint)destination.Length)`
	`78`	`+ if (destination.Length <= 4)`
`79`	`79`	`{`
`80`	`80`	`goto BufferTooSmall;`
`81`	`81`	`}`
Original file line number	Diff line number	Diff line change
`@@ -13,9 +13,7 @@ public static partial class Utf8Formatter`
`13`	`13`	`//`
`14`	`14`	`private static bool TryFormatDateTimeL(DateTime value, Span<byte> destination, out int bytesWritten)`
`15`	`15`	`{`
`16`		`- // Writing the check in this fashion elides all bounds checks on 'buffer'`
`17`		`- // for the remainder of the method.`
`18`		`- if ((uint)28 >= (uint)destination.Length)`
	`16`	`+ if (destination.Length <= 28)`
`19`	`17`	`{`
`20`	`18`	`bytesWritten = 0;`
`21`	`19`	`return false;`
Original file line number	Diff line number	Diff line change
`@@ -591,7 +591,7 @@ public static bool IsControl(string s, int index)`
`591`	`591`	`{`
`592`	`592`	`ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);`
`593`	`593`	`}`
`594`		`- if (((uint)index) >= ((uint)s.Length))`
	`594`	`+ if ((uint)index >= (uint)s.Length)`
`595`	`595`	`{`
`596`	`596`	`ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);`
`597`	`597`	`}`
`@@ -606,7 +606,7 @@ public static bool IsDigit(string s, int index)`
`606`	`606`	`{`
`607`	`607`	`ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);`
`608`	`608`	`}`
`609`		`- if (((uint)index) >= ((uint)s.Length))`
	`609`	`+ if ((uint)index >= (uint)s.Length)`
`610`	`610`	`{`
`611`	`611`	`ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);`
`612`	`612`	`}`
`@@ -626,7 +626,7 @@ public static bool IsLetter(string s, int index)`
`626`	`626`	`{`
`627`	`627`	`ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);`
`628`	`628`	`}`
`629`		`- if (((uint)index) >= ((uint)s.Length))`
	`629`	`+ if ((uint)index >= (uint)s.Length)`
`630`	`630`	`{`
`631`	`631`	`ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);`
`632`	`632`	`}`
`@@ -647,7 +647,7 @@ public static bool IsLetterOrDigit(string s, int index)`
`647`	`647`	`{`
`648`	`648`	`ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);`
`649`	`649`	`}`
`650`		`- if (((uint)index) >= ((uint)s.Length))`
	`650`	`+ if ((uint)index >= (uint)s.Length)`
`651`	`651`	`{`
`652`	`652`	`ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);`
`653`	`653`	`}`
`@@ -667,8 +667,7 @@ public static bool IsLower(string s, int index)`
`667`	`667`	`{`
`668`	`668`	`ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);`
`669`	`669`	`}`
`670`		`-`
`671`		`- if (((uint)index) >= ((uint)s.Length))`
	`670`	`+ if ((uint)index >= (uint)s.Length)`
`672`	`671`	`{`
`673`	`672`	`ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);`
`674`	`673`	`}`
`@@ -710,7 +709,7 @@ public static bool IsNumber(string s, int index)`
`710`	`709`	`{`
`711`	`710`	`ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);`
`712`	`711`	`}`
`713`		`- if (((uint)index) >= ((uint)s.Length))`
	`712`	`+ if ((uint)index >= (uint)s.Length)`
`714`	`713`	`{`
`715`	`714`	`ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);`
`716`	`715`	`}`
`@@ -743,7 +742,7 @@ public static bool IsPunctuation(string s, int index)`
`743`	`742`	`{`
`744`	`743`	`ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);`
`745`	`744`	`}`
`746`		`- if (((uint)index) >= ((uint)s.Length))`
	`745`	`+ if ((uint)index >= (uint)s.Length)`
`747`	`746`	`{`
`748`	`747`	`ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);`
`749`	`748`	`}`
`@@ -788,7 +787,7 @@ public static bool IsSeparator(string s, int index)`
`788`	`787`	`{`
`789`	`788`	`ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);`
`790`	`789`	`}`
`791`		`- if (((uint)index) >= ((uint)s.Length))`
	`790`	`+ if ((uint)index >= (uint)s.Length)`
`792`	`791`	`{`
`793`	`792`	`ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);`
`794`	`793`	`}`
`@@ -813,7 +812,7 @@ public static bool IsSurrogate(string s, int index)`
`813`	`812`	`{`
`814`	`813`	`ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);`
`815`	`814`	`}`
`816`		`- if (((uint)index) >= ((uint)s.Length))`
	`815`	`+ if ((uint)index >= (uint)s.Length)`
`817`	`816`	`{`
`818`	`817`	`ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);`
`819`	`818`	`}`
`@@ -845,7 +844,7 @@ public static bool IsSymbol(string s, int index)`
`845`	`844`	`{`
`846`	`845`	`ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);`
`847`	`846`	`}`
`848`		`- if (((uint)index) >= ((uint)s.Length))`
	`847`	`+ if ((uint)index >= (uint)s.Length)`
`849`	`848`	`{`
`850`	`849`	`ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);`
`851`	`850`	`}`
`@@ -865,7 +864,7 @@ public static bool IsUpper(string s, int index)`
`865`	`864`	`{`
`866`	`865`	`ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);`
`867`	`866`	`}`
`868`		`- if (((uint)index) >= ((uint)s.Length))`
	`867`	`+ if ((uint)index >= (uint)s.Length)`
`869`	`868`	`{`
`870`	`869`	`ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);`
`871`	`870`	`}`
`@@ -885,7 +884,7 @@ public static bool IsWhiteSpace(string s, int index)`
`885`	`884`	`{`
`886`	`885`	`ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);`
`887`	`886`	`}`
`888`		`- if (((uint)index) >= ((uint)s.Length))`
	`887`	`+ if ((uint)index >= (uint)s.Length)`
`889`	`888`	`{`
`890`	`889`	`ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);`
`891`	`890`	`}`
`@@ -911,7 +910,7 @@ public static UnicodeCategory GetUnicodeCategory(string s, int index)`
`911`	`910`	`{`
`912`	`911`	`ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);`
`913`	`912`	`}`
`914`		`- if (((uint)index) >= ((uint)s.Length))`
	`913`	`+ if ((uint)index >= (uint)s.Length)`
`915`	`914`	`{`
`916`	`915`	`ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);`
`917`	`916`	`}`
`@@ -935,7 +934,7 @@ public static double GetNumericValue(string s, int index)`
`935`	`934`	`{`
`936`	`935`	`ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);`
`937`	`936`	`}`
`938`		`- if (((uint)index) >= ((uint)s.Length))`
	`937`	`+ if ((uint)index >= (uint)s.Length)`
`939`	`938`	`{`
`940`	`939`	`ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);`
`941`	`940`	`}`
`@@ -957,7 +956,7 @@ public static bool IsHighSurrogate(string s, int index)`
`957`	`956`	`{`
`958`	`957`	`ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);`
`959`	`958`	`}`
`960`		`- if (((uint)index) >= ((uint)s.Length))`
	`959`	`+ if ((uint)index >= (uint)s.Length)`
`961`	`960`	`{`
`962`	`961`	`ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);`
`963`	`962`	`}`
`@@ -979,7 +978,7 @@ public static bool IsLowSurrogate(string s, int index)`
`979`	`978`	`{`
`980`	`979`	`ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);`
`981`	`980`	`}`
`982`		`- if (((uint)index) >= ((uint)s.Length))`
	`981`	`+ if ((uint)index >= (uint)s.Length)`
`983`	`982`	`{`
`984`	`983`	`ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);`
`985`	`984`	`}`
`@@ -996,7 +995,7 @@ public static bool IsSurrogatePair(string s, int index)`
`996`	`995`	`{`
`997`	`996`	`ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);`
`998`	`997`	`}`
`999`		`- if (((uint)index) >= ((uint)s.Length))`
	`998`	`+ if ((uint)index >= (uint)s.Length)`
`1000`	`999`	`{`
`1001`	`1000`	`ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);`
`1002`	`1001`	`}`
Original file line number	Diff line number	Diff line change
`@@ -44,9 +44,12 @@ public ref T this[int index]`
`44`	`44`	`public void Append(T item)`
`45`	`45`	`{`
`46`	`46`	`int pos = _pos;`
`47`		`- if ((uint)pos < (uint)_span.Length)`
	`47`	`+`
	`48`	`+ // Workaround for https://github.com/dotnet/runtime/issues/72004`
	`49`	`+ Span<T> span = _span;`
	`50`	`+ if ((uint)pos < (uint)span.Length)`
`48`	`51`	`{`
`49`		`- _span[pos] = item;`
	`52`	`+ span[pos] = item;`
`50`	`53`	`_pos = pos + 1;`
`51`	`54`	`}`
`52`	`55`	`else`
Original file line number	Diff line number	Diff line change
`@@ -602,7 +602,7 @@ public static int[] GetBits(decimal d)`
`602`	`602`	`/// <exception cref="ArgumentException">The destination span was not long enough to store the binary representation.</exception>`
`603`	`603`	`public static int GetBits(decimal d, Span<int> destination)`
`604`	`604`	`{`
`605`		`- if ((uint)destination.Length <= 3)`
	`605`	`+ if (destination.Length <= 3)`
`606`	`606`	`{`
`607`	`607`	`ThrowHelper.ThrowArgumentException_DestinationTooShort();`
`608`	`608`	`}`
`@@ -623,7 +623,7 @@ public static int GetBits(decimal d, Span<int> destination)`
`623`	`623`	`/// <returns>true if the decimal's binary representation was written to the destination; false if the destination wasn't long enough.</returns>`
`624`	`624`	`public static bool TryGetBits(decimal d, Span<int> destination, out int valuesWritten)`
`625`	`625`	`{`
`626`		`- if ((uint)destination.Length <= 3)`
	`626`	`+ if (destination.Length <= 3)`
`627`	`627`	`{`
`628`	`628`	`valuesWritten = 0;`
`629`	`629`	`return false;`