Revert uses of Unsafe.BitCast with spans to unblock mono

src/libraries/System.Linq/src/System/Linq/Sum.cs

@@ -60,11 +60,11 @@ private static TResult Sum<T, TResult>(ReadOnlySpan<T> span)
 
                 if (typeof(T) == typeof(long))
                 {
-                    return (TResult)(object)SumSignedIntegersVectorized(Unsafe.BitCast<ReadOnlySpan<T>, ReadOnlySpan<long>>(span));
+                    return (TResult)(object)SumSignedIntegersVectorized(MemoryMarshal.Cast<T, long>(span));
                 }
                 if (typeof(T) == typeof(int))
                 {
-                    return (TResult)(object)SumSignedIntegersVectorized(Unsafe.BitCast<ReadOnlySpan<T>, ReadOnlySpan<int>>(span));
+                    return (TResult)(object)SumSignedIntegersVectorized(MemoryMarshal.Cast<T, int>(span));
                 }
             }
 

src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/TensorPrimitives.Helpers.cs

@@ -36,11 +36,7 @@ private static void ValidateInputOutputSpanNonOverlapping<T>(ReadOnlySpan<T> inp
         private static unsafe Span<TTo> Rename<TFrom, TTo>(Span<TFrom> span)
         {
             Debug.Assert(sizeof(TFrom) == sizeof(TTo));
-#if NET9_0_OR_GREATER
-            return Unsafe.BitCast<Span<TFrom>, Span<TTo>>(span);
-#else
             return *(Span<TTo>*)(&span);
-#endif
         }
 
         /// <summary>Creates a span of <typeparamref name="TTo"/> from a <typeparamref name="TFrom"/> when they're the same type.</summary>
@@ -52,11 +48,7 @@ private static unsafe Span<TTo> Rename<TFrom, TTo>(Span<TFrom> span)
         private static unsafe ReadOnlySpan<TTo> Rename<TFrom, TTo>(ReadOnlySpan<TFrom> span)
         {
             Debug.Assert(sizeof(TFrom) == sizeof(TTo));
-#if NET9_0_OR_GREATER
-            return Unsafe.BitCast<ReadOnlySpan<TFrom>, ReadOnlySpan<TTo>>(span);
-#else
             return *(ReadOnlySpan<TTo>*)(&span);
-#endif
         }
 
         /// <summary>Mask used to handle alignment elements before vectorized handling of the input.</summary>

src/libraries/System.Private.CoreLib/src/System/Globalization/DateTimeFormat.cs

@@ -763,12 +763,12 @@ private static void AppendString<TChar>(ref ValueListBuilder<TChar> result, scop
         {
             if (typeof(TChar) == typeof(char))
             {
-                result.Append(Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(s));
+                result.Append(MemoryMarshal.Cast<char, TChar>(s));
             }
             else
             {
                 Debug.Assert(typeof(TChar) == typeof(byte));
-                Encoding.UTF8.GetBytes(s, Unsafe.BitCast<Span<TChar>, Span<byte>>(result.AppendSpan(Encoding.UTF8.GetByteCount(s))));
+                Encoding.UTF8.GetBytes(s, MemoryMarshal.Cast<TChar, byte>(result.AppendSpan(Encoding.UTF8.GetByteCount(s))));
             }
         }
 
@@ -777,8 +777,8 @@ internal static void FormatFraction<TChar>(ref ValueListBuilder<TChar> result, i
             Span<TChar> chars = stackalloc TChar[11];
             int charCount;
             bool formatted = typeof(TChar) == typeof(char) ?
-                fraction.TryFormat(Unsafe.BitCast<Span<TChar>, Span<char>>(chars), out charCount, fractionFormat, CultureInfo.InvariantCulture) :
-                fraction.TryFormat(Unsafe.BitCast<Span<TChar>, Span<byte>>(chars), out charCount, fractionFormat, CultureInfo.InvariantCulture);
+                fraction.TryFormat(MemoryMarshal.Cast<TChar, char>(chars), out charCount, fractionFormat, CultureInfo.InvariantCulture) :
+                fraction.TryFormat(MemoryMarshal.Cast<TChar, byte>(chars), out charCount, fractionFormat, CultureInfo.InvariantCulture);
             Debug.Assert(charCount != 0);
             result.Append(chars.Slice(0, charCount));
         }

src/libraries/System.Private.CoreLib/src/System/Globalization/DateTimeFormatInfo.cs

@@ -358,8 +358,8 @@ internal ReadOnlySpan<TChar> AMDesignatorTChar<TChar>() where TChar : unmanaged,
         {
             Debug.Assert(typeof(TChar) == typeof(char) || typeof(TChar) == typeof(byte));
             return typeof(TChar) == typeof(char) ?
-                Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(AMDesignator) :
-                Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(amDesignatorUtf8 ??= Encoding.UTF8.GetBytes(AMDesignator));
+                MemoryMarshal.Cast<char, TChar>(AMDesignator) :
+                MemoryMarshal.Cast<byte, TChar>(amDesignatorUtf8 ??= Encoding.UTF8.GetBytes(AMDesignator));
         }
 
         public Calendar Calendar
@@ -607,8 +607,8 @@ internal ReadOnlySpan<TChar> DateSeparatorTChar<TChar>() where TChar : unmanaged
         {
             Debug.Assert(typeof(TChar) == typeof(char) || typeof(TChar) == typeof(byte));
             return typeof(TChar) == typeof(char) ?
-                Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(DateSeparator) :
-                Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(dateSeparatorUtf8 ??= Encoding.UTF8.GetBytes(DateSeparator));
+                MemoryMarshal.Cast<char, TChar>(DateSeparator) :
+                MemoryMarshal.Cast<byte, TChar>(dateSeparatorUtf8 ??= Encoding.UTF8.GetBytes(DateSeparator));
         }
 
         public DayOfWeek FirstDayOfWeek
@@ -810,8 +810,8 @@ internal ReadOnlySpan<TChar> PMDesignatorTChar<TChar>() where TChar : unmanaged,
         {
             Debug.Assert(typeof(TChar) == typeof(char) || typeof(TChar) == typeof(byte));
             return typeof(TChar) == typeof(char) ?
-                Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(PMDesignator) :
-                Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(pmDesignatorUtf8 ??= Encoding.UTF8.GetBytes(PMDesignator));
+                MemoryMarshal.Cast<char, TChar>(PMDesignator) :
+                MemoryMarshal.Cast<byte, TChar>(pmDesignatorUtf8 ??= Encoding.UTF8.GetBytes(PMDesignator));
         }
 
         public string RFC1123Pattern => rfc1123Pattern;
@@ -992,8 +992,8 @@ internal ReadOnlySpan<TChar> TimeSeparatorTChar<TChar>() where TChar : unmanaged
         {
             Debug.Assert(typeof(TChar) == typeof(char) || typeof(TChar) == typeof(byte));
             return typeof(TChar) == typeof(char) ?
-                Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(TimeSeparator) :
-                Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(timeSeparatorUtf8 ??= Encoding.UTF8.GetBytes(TimeSeparator));
+                MemoryMarshal.Cast<char, TChar>(TimeSeparator) :
+                MemoryMarshal.Cast<byte, TChar>(timeSeparatorUtf8 ??= Encoding.UTF8.GetBytes(TimeSeparator));
         }
 
         public string UniversalSortableDateTimePattern => universalSortableDateTimePattern;
@@ -1731,8 +1731,8 @@ internal ReadOnlySpan<TChar> DecimalSeparatorTChar<TChar>() where TChar : unmana
         {
             Debug.Assert(typeof(TChar) == typeof(char) || typeof(TChar) == typeof(byte));
             return typeof(TChar) == typeof(char) ?
-                Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(DecimalSeparator) :
-                Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_decimalSeparatorUtf8 ??= Encoding.UTF8.GetBytes(DecimalSeparator));
+                MemoryMarshal.Cast<char, TChar>(DecimalSeparator) :
+                MemoryMarshal.Cast<byte, TChar>(_decimalSeparatorUtf8 ??= Encoding.UTF8.GetBytes(DecimalSeparator));
         }
 
         // Positive TimeSpan Pattern

src/libraries/System.Private.CoreLib/src/System/Globalization/NumberFormatInfo.cs

@@ -269,8 +269,8 @@ internal ReadOnlySpan<TChar> CurrencyDecimalSeparatorTChar<TChar>() where TChar
         {
             Debug.Assert(typeof(TChar) == typeof(char) || typeof(TChar) == typeof(byte));
             return typeof(TChar) == typeof(char) ?
-                Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_currencyDecimalSeparator) :
-                Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_currencyDecimalSeparatorUtf8 ??= Encoding.UTF8.GetBytes(_currencyDecimalSeparator));
+                MemoryMarshal.Cast<char, TChar>(_currencyDecimalSeparator) :
+                MemoryMarshal.Cast<byte, TChar>(_currencyDecimalSeparatorUtf8 ??= Encoding.UTF8.GetBytes(_currencyDecimalSeparator));
         }
 
         public bool IsReadOnly => _isReadOnly;
@@ -361,8 +361,8 @@ internal ReadOnlySpan<TChar> CurrencyGroupSeparatorTChar<TChar>() where TChar :
         {
             Debug.Assert(typeof(TChar) == typeof(char) || typeof(TChar) == typeof(byte));
             return typeof(TChar) == typeof(char) ?
-                Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_currencyGroupSeparator) :
-                Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_currencyGroupSeparatorUtf8 ??= Encoding.UTF8.GetBytes(_currencyGroupSeparator));
+                MemoryMarshal.Cast<char, TChar>(_currencyGroupSeparator) :
+                MemoryMarshal.Cast<byte, TChar>(_currencyGroupSeparatorUtf8 ??= Encoding.UTF8.GetBytes(_currencyGroupSeparator));
         }
 
         public string CurrencySymbol
@@ -383,8 +383,8 @@ internal ReadOnlySpan<TChar> CurrencySymbolTChar<TChar>() where TChar : unmanage
         {
             Debug.Assert(typeof(TChar) == typeof(char) || typeof(TChar) == typeof(byte));
             return typeof(TChar) == typeof(char) ?
-                Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_currencySymbol) :
-                Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_currencySymbolUtf8 ??= Encoding.UTF8.GetBytes(_currencySymbol));
+                MemoryMarshal.Cast<char, TChar>(_currencySymbol) :
+                MemoryMarshal.Cast<byte, TChar>(_currencySymbolUtf8 ??= Encoding.UTF8.GetBytes(_currencySymbol));
         }
 
         internal byte[]? CurrencySymbolUtf8 => _currencySymbolUtf8 ??= Encoding.UTF8.GetBytes(_currencySymbol);
@@ -429,8 +429,8 @@ internal ReadOnlySpan<TChar> NaNSymbolTChar<TChar>() where TChar : unmanaged, IU
         {
             Debug.Assert(typeof(TChar) == typeof(char) || typeof(TChar) == typeof(byte));
             return typeof(TChar) == typeof(char) ?
-                Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_nanSymbol) :
-                Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_nanSymbolUtf8 ??= Encoding.UTF8.GetBytes(_nanSymbol));
+                MemoryMarshal.Cast<char, TChar>(_nanSymbol) :
+                MemoryMarshal.Cast<byte, TChar>(_nanSymbolUtf8 ??= Encoding.UTF8.GetBytes(_nanSymbol));
         }
 
         public int CurrencyNegativePattern
@@ -514,8 +514,8 @@ internal ReadOnlySpan<TChar> NegativeInfinitySymbolTChar<TChar>() where TChar :
         {
             Debug.Assert(typeof(TChar) == typeof(char) || typeof(TChar) == typeof(byte));
             return typeof(TChar) == typeof(char) ?
-                Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_negativeInfinitySymbol) :
-                Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_negativeInfinitySymbolUtf8 ??= Encoding.UTF8.GetBytes(_negativeInfinitySymbol));
+                MemoryMarshal.Cast<char, TChar>(_negativeInfinitySymbol) :
+                MemoryMarshal.Cast<byte, TChar>(_negativeInfinitySymbolUtf8 ??= Encoding.UTF8.GetBytes(_negativeInfinitySymbol));
         }
 
         public string NegativeSign
@@ -537,8 +537,8 @@ internal ReadOnlySpan<TChar> NegativeSignTChar<TChar>() where TChar : unmanaged,
         {
             Debug.Assert(typeof(TChar) == typeof(char) || typeof(TChar) == typeof(byte));
             return typeof(TChar) == typeof(char) ?
-                Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_negativeSign) :
-                Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_negativeSignUtf8 ??= Encoding.UTF8.GetBytes(_negativeSign));
+                MemoryMarshal.Cast<char, TChar>(_negativeSign) :
+                MemoryMarshal.Cast<byte, TChar>(_negativeSignUtf8 ??= Encoding.UTF8.GetBytes(_negativeSign));
         }
 
         public int NumberDecimalDigits
@@ -573,8 +573,8 @@ internal ReadOnlySpan<TChar> NumberDecimalSeparatorTChar<TChar>() where TChar :
         {
             Debug.Assert(typeof(TChar) == typeof(char) || typeof(TChar) == typeof(byte));
             return typeof(TChar) == typeof(char) ?
-                Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_numberDecimalSeparator) :
-                Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_numberDecimalSeparatorUtf8 ??= Encoding.UTF8.GetBytes(_numberDecimalSeparator));
+                MemoryMarshal.Cast<char, TChar>(_numberDecimalSeparator) :
+                MemoryMarshal.Cast<byte, TChar>(_numberDecimalSeparatorUtf8 ??= Encoding.UTF8.GetBytes(_numberDecimalSeparator));
         }
 
         public string NumberGroupSeparator
@@ -594,8 +594,8 @@ internal ReadOnlySpan<TChar> NumberGroupSeparatorTChar<TChar>() where TChar : un
         {
             Debug.Assert(typeof(TChar) == typeof(char) || typeof(TChar) == typeof(byte));
             return typeof(TChar) == typeof(char) ?
-                Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_numberGroupSeparator) :
-                Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_numberGroupSeparatorUtf8 ??= Encoding.UTF8.GetBytes(_numberGroupSeparator));
+                MemoryMarshal.Cast<char, TChar>(_numberGroupSeparator) :
+                MemoryMarshal.Cast<byte, TChar>(_numberGroupSeparatorUtf8 ??= Encoding.UTF8.GetBytes(_numberGroupSeparator));
         }
 
         public int CurrencyPositivePattern
@@ -631,8 +631,8 @@ internal ReadOnlySpan<TChar> PositiveInfinitySymbolTChar<TChar>() where TChar :
         {
             Debug.Assert(typeof(TChar) == typeof(char) || typeof(TChar) == typeof(byte));
             return typeof(TChar) == typeof(char) ?
-                Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_positiveInfinitySymbol) :
-                Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_positiveInfinitySymbolUtf8 ??= Encoding.UTF8.GetBytes(_positiveInfinitySymbol));
+                MemoryMarshal.Cast<char, TChar>(_positiveInfinitySymbol) :
+                MemoryMarshal.Cast<byte, TChar>(_positiveInfinitySymbolUtf8 ??= Encoding.UTF8.GetBytes(_positiveInfinitySymbol));
         }
 
         public string PositiveSign
@@ -654,8 +654,8 @@ internal ReadOnlySpan<TChar> PositiveSignTChar<TChar>() where TChar : unmanaged,
         {
             Debug.Assert(typeof(TChar) == typeof(char) || typeof(TChar) == typeof(byte));
             return typeof(TChar) == typeof(char) ?
-                Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_positiveSign) :
-                Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_positiveSignUtf8 ??= Encoding.UTF8.GetBytes(_positiveSign));
+                MemoryMarshal.Cast<char, TChar>(_positiveSign) :
+                MemoryMarshal.Cast<byte, TChar>(_positiveSignUtf8 ??= Encoding.UTF8.GetBytes(_positiveSign));
         }
 
         public int PercentDecimalDigits
@@ -690,8 +690,8 @@ internal ReadOnlySpan<TChar> PercentDecimalSeparatorTChar<TChar>() where TChar :
         {
             Debug.Assert(typeof(TChar) == typeof(char) || typeof(TChar) == typeof(byte));
             return typeof(TChar) == typeof(char) ?
-                Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_percentDecimalSeparator) :
-                Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_percentDecimalSeparatorUtf8 ??= Encoding.UTF8.GetBytes(_percentDecimalSeparator));
+                MemoryMarshal.Cast<char, TChar>(_percentDecimalSeparator) :
+                MemoryMarshal.Cast<byte, TChar>(_percentDecimalSeparatorUtf8 ??= Encoding.UTF8.GetBytes(_percentDecimalSeparator));
         }
 
         public string PercentGroupSeparator
@@ -711,8 +711,8 @@ internal ReadOnlySpan<TChar> PercentGroupSeparatorTChar<TChar>() where TChar : u
         {
             Debug.Assert(typeof(TChar) == typeof(char) || typeof(TChar) == typeof(byte));
             return typeof(TChar) == typeof(char) ?
-                Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_percentGroupSeparator) :
-                Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_percentGroupSeparatorUtf8 ??= Encoding.UTF8.GetBytes(_percentGroupSeparator));
+                MemoryMarshal.Cast<char, TChar>(_percentGroupSeparator) :
+                MemoryMarshal.Cast<byte, TChar>(_percentGroupSeparatorUtf8 ??= Encoding.UTF8.GetBytes(_percentGroupSeparator));
         }
 
         public string PercentSymbol
@@ -732,8 +732,8 @@ internal ReadOnlySpan<TChar> PercentSymbolTChar<TChar>() where TChar : unmanaged
         {
             Debug.Assert(typeof(TChar) == typeof(char) || typeof(TChar) == typeof(byte));
             return typeof(TChar) == typeof(char) ?
-                Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_percentSymbol) :
-                Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_percentSymbolUtf8 ??= Encoding.UTF8.GetBytes(_percentSymbol));
+                MemoryMarshal.Cast<char, TChar>(_percentSymbol) :
+                MemoryMarshal.Cast<byte, TChar>(_percentSymbolUtf8 ??= Encoding.UTF8.GetBytes(_percentSymbol));
         }
 
         public string PerMilleSymbol
@@ -754,8 +754,8 @@ internal ReadOnlySpan<TChar> PerMilleSymbolTChar<TChar>() where TChar : unmanage
         {
             Debug.Assert(typeof(TChar) == typeof(char) || typeof(TChar) == typeof(byte));
             return typeof(TChar) == typeof(char) ?
-                Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_perMilleSymbol) :
-                Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_perMilleSymbolUtf8 ??= Encoding.UTF8.GetBytes(_perMilleSymbol));
+                MemoryMarshal.Cast<char, TChar>(_perMilleSymbol) :
+                MemoryMarshal.Cast<byte, TChar>(_perMilleSymbolUtf8 ??= Encoding.UTF8.GetBytes(_perMilleSymbol));
         }
 
         public string[] NativeDigits

src/libraries/System.Private.CoreLib/src/System/Number.Formatting.cs

@@ -853,7 +853,7 @@ private static bool TryCopyTo<TChar>(string source, Span<TChar> destination, out
 
             if (typeof(TChar) == typeof(char))
             {
-                if (source.TryCopyTo(Unsafe.BitCast<Span<TChar>, Span<char>>(destination)))
+                if (source.TryCopyTo(MemoryMarshal.Cast<TChar, char>(destination)))
                 {
                     charsWritten = source.Length;
                     return true;
@@ -864,7 +864,7 @@ private static bool TryCopyTo<TChar>(string source, Span<TChar> destination, out
             }
             else
             {
-                return Encoding.UTF8.TryGetBytes(source, Unsafe.BitCast<Span<TChar>, Span<byte>>(destination), out charsWritten);
+                return Encoding.UTF8.TryGetBytes(source, MemoryMarshal.Cast<TChar, byte>(destination), out charsWritten);
             }
         }