From c286a8efb3c0d534557dde476d5b54b15c0aeaed Mon Sep 17 00:00:00 2001
From: Stephen Toub <stoub@microsoft.com>
Date: Mon, 3 Jun 2024 17:23:46 -0400
Subject: [PATCH] Revert uses of Unsafe.BitCast with spans to unblock mono
 (#102998)

* Revert uses of Unsafe.BitCast with spans to unblock mono

* Comment out a test
---
 .../System.Linq/src/System/Linq/Sum.cs        |  4 +-
 .../Tensors/TensorPrimitives.Helpers.cs       |  8 ---
 .../System/Globalization/DateTimeFormat.cs    |  8 +--
 .../Globalization/DateTimeFormatInfo.cs       | 20 +++----
 .../System/Globalization/NumberFormatInfo.cs  | 56 +++++++++----------
 .../src/System/Number.Formatting.cs           |  4 +-
 .../src/System/Number.Parsing.cs              | 22 ++++----
 .../src/System/Version.cs                     |  4 +-
 .../src/System/Numerics/Complex.cs            |  8 +--
 .../UnsafeTests.cs                            |  7 ++-
 10 files changed, 67 insertions(+), 74 deletions(-)

diff --git a/src/libraries/System.Linq/src/System/Linq/Sum.cs b/src/libraries/System.Linq/src/System/Linq/Sum.cs
index 481997b8f8263..7eb2dc855dc67 100644
--- a/src/libraries/System.Linq/src/System/Linq/Sum.cs
+++ b/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));
                 }
             }
 
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/TensorPrimitives.Helpers.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/TensorPrimitives.Helpers.cs
index 5e4e89b61742d..1ddabb93dd0ea 100644
--- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/TensorPrimitives.Helpers.cs
+++ b/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>
diff --git a/src/libraries/System.Private.CoreLib/src/System/Globalization/DateTimeFormat.cs b/src/libraries/System.Private.CoreLib/src/System/Globalization/DateTimeFormat.cs
index 5192820e1a4d5..db12f89bf2dd1 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Globalization/DateTimeFormat.cs
+++ b/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));
         }
diff --git a/src/libraries/System.Private.CoreLib/src/System/Globalization/DateTimeFormatInfo.cs b/src/libraries/System.Private.CoreLib/src/System/Globalization/DateTimeFormatInfo.cs
index f2b99e5a81b3b..e87960b61792d 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Globalization/DateTimeFormatInfo.cs
+++ b/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
diff --git a/src/libraries/System.Private.CoreLib/src/System/Globalization/NumberFormatInfo.cs b/src/libraries/System.Private.CoreLib/src/System/Globalization/NumberFormatInfo.cs
index 60882f7aaaa0e..0424b678e4b18 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Globalization/NumberFormatInfo.cs
+++ b/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
diff --git a/src/libraries/System.Private.CoreLib/src/System/Number.Formatting.cs b/src/libraries/System.Private.CoreLib/src/System/Number.Formatting.cs
index 38a752c6810ff..928eaea0d9540 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Number.Formatting.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Number.Formatting.cs
@@ -621,7 +621,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;
@@ -632,7 +632,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);
             }
         }
 
diff --git a/src/libraries/System.Private.CoreLib/src/System/Number.Parsing.cs b/src/libraries/System.Private.CoreLib/src/System/Number.Parsing.cs
index f15712bf5fe92..263f60ad0ba10 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Number.Parsing.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Number.Parsing.cs
@@ -895,16 +895,16 @@ internal static bool SpanStartsWith<TChar>(ReadOnlySpan<TChar> span, ReadOnlySpa
         {
             if (typeof(TChar) == typeof(char))
             {
-                ReadOnlySpan<char> typedSpan = Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<char>>(span);
-                ReadOnlySpan<char> typedValue = Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<char>>(value);
+                ReadOnlySpan<char> typedSpan = MemoryMarshal.Cast<TChar, char>(span);
+                ReadOnlySpan<char> typedValue = MemoryMarshal.Cast<TChar, char>(value);
                 return typedSpan.StartsWith(typedValue, comparisonType);
             }
             else
             {
                 Debug.Assert(typeof(TChar) == typeof(byte));
 
-                ReadOnlySpan<byte> typedSpan = Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<byte>>(span);
-                ReadOnlySpan<byte> typedValue = Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<byte>>(value);
+                ReadOnlySpan<byte> typedSpan = MemoryMarshal.Cast<TChar, byte>(span);
+                ReadOnlySpan<byte> typedValue = MemoryMarshal.Cast<TChar, byte>(value);
                 return typedSpan.StartsWithUtf8(typedValue, comparisonType);
             }
         }
@@ -915,13 +915,13 @@ internal static ReadOnlySpan<TChar> SpanTrim<TChar>(ReadOnlySpan<TChar> span)
         {
             if (typeof(TChar) == typeof(char))
             {
-                return Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<char>>(span).Trim());
+                return MemoryMarshal.Cast<char, TChar>(MemoryMarshal.Cast<TChar, char>(span).Trim());
             }
             else
             {
                 Debug.Assert(typeof(TChar) == typeof(byte));
 
-                return Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<byte>>(span).TrimUtf8());
+                return MemoryMarshal.Cast<byte, TChar>(MemoryMarshal.Cast<TChar, byte>(span).TrimUtf8());
             }
         }
 
@@ -931,16 +931,16 @@ internal static bool SpanEqualsOrdinalIgnoreCase<TChar>(ReadOnlySpan<TChar> span
         {
             if (typeof(TChar) == typeof(char))
             {
-                ReadOnlySpan<char> typedSpan = Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<char>>(span);
-                ReadOnlySpan<char> typedValue = Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<char>>(value);
+                ReadOnlySpan<char> typedSpan = MemoryMarshal.Cast<TChar, char>(span);
+                ReadOnlySpan<char> typedValue = MemoryMarshal.Cast<TChar, char>(value);
                 return typedSpan.EqualsOrdinalIgnoreCase(typedValue);
             }
             else
             {
                 Debug.Assert(typeof(TChar) == typeof(byte));
 
-                ReadOnlySpan<byte> typedSpan = Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<byte>>(span);
-                ReadOnlySpan<byte> typedValue = Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<byte>>(value);
+                ReadOnlySpan<byte> typedSpan = MemoryMarshal.Cast<TChar, byte>(span);
+                ReadOnlySpan<byte> typedValue = MemoryMarshal.Cast<TChar, byte>(value);
                 return typedSpan.EqualsOrdinalIgnoreCaseUtf8(typedValue);
             }
         }
@@ -1053,7 +1053,7 @@ internal static void ThrowFormatException<TChar>(ReadOnlySpan<TChar> value)
                 // It's possible after we check the bytes for validity that they could be concurrently
                 // mutated, but if that's happening, all bets are off, anyway, and it simply impacts
                 // which exception is thrown.
-                ReadOnlySpan<byte> bytes = Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<byte>>(value);
+                ReadOnlySpan<byte> bytes = MemoryMarshal.Cast<TChar, byte>(value);
                 errorMessage = Utf8.IsValid(bytes) ?
                     SR.Format(SR.Format_InvalidStringWithValue, Encoding.UTF8.GetString(bytes)) :
                     SR.Format_InvalidString;
diff --git a/src/libraries/System.Private.CoreLib/src/System/Version.cs b/src/libraries/System.Private.CoreLib/src/System/Version.cs
index 607a72d03fb9a..99c26d59a9143 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Version.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Version.cs
@@ -249,8 +249,8 @@ static void ThrowArgumentException(string failureUpperBound) =>
 
                 int valueCharsWritten;
                 bool formatted = typeof(TChar) == typeof(char) ?
-                    ((uint)value).TryFormat(Unsafe.BitCast<Span<TChar>, Span<char>>(destination), out valueCharsWritten) :
-                    ((uint)value).TryFormat(Unsafe.BitCast<Span<TChar>, Span<byte>>(destination), out valueCharsWritten, default, CultureInfo.InvariantCulture);
+                    ((uint)value).TryFormat(MemoryMarshal.Cast<TChar, char>(destination), out valueCharsWritten) :
+                    ((uint)value).TryFormat(MemoryMarshal.Cast<TChar, byte>(destination), out valueCharsWritten, default, CultureInfo.InvariantCulture);
 
                 if (!formatted)
                 {
diff --git a/src/libraries/System.Runtime.Numerics/src/System/Numerics/Complex.cs b/src/libraries/System.Runtime.Numerics/src/System/Numerics/Complex.cs
index a62190ee40d93..8d6b7abbfdbd9 100644
--- a/src/libraries/System.Runtime.Numerics/src/System/Numerics/Complex.cs
+++ b/src/libraries/System.Runtime.Numerics/src/System/Numerics/Complex.cs
@@ -2241,8 +2241,8 @@ private bool TryFormatCore<TChar>(Span<TChar> destination, out int charsWritten,
             {
                 int realChars;
                 if (typeof(TChar) == typeof(char) ?
-                    m_real.TryFormat(Unsafe.BitCast<Span<TChar>, Span<char>>(destination.Slice(1)), out realChars, format, provider) :
-                    m_real.TryFormat(Unsafe.BitCast<Span<TChar>, Span<byte>>(destination.Slice(1)), out realChars, format, provider))
+                    m_real.TryFormat(MemoryMarshal.Cast<TChar, char>(destination.Slice(1)), out realChars, format, provider) :
+                    m_real.TryFormat(MemoryMarshal.Cast<TChar, byte>(destination.Slice(1)), out realChars, format, provider))
                 {
                     destination[0] = TChar.CreateTruncating('<');
                     destination = destination.Slice(1 + realChars); // + 1 for <
@@ -2252,8 +2252,8 @@ private bool TryFormatCore<TChar>(Span<TChar> destination, out int charsWritten,
                     {
                         int imaginaryChars;
                         if (typeof(TChar) == typeof(char) ?
-                            m_imaginary.TryFormat(Unsafe.BitCast<Span<TChar>, Span<char>>(destination.Slice(2)), out imaginaryChars, format, provider) :
-                            m_imaginary.TryFormat(Unsafe.BitCast<Span<TChar>, Span<byte>>(destination.Slice(2)), out imaginaryChars, format, provider))
+                            m_imaginary.TryFormat(MemoryMarshal.Cast<TChar, char>(destination.Slice(2)), out imaginaryChars, format, provider) :
+                            m_imaginary.TryFormat(MemoryMarshal.Cast<TChar, byte>(destination.Slice(2)), out imaginaryChars, format, provider))
                         {
                             // We have 1 more character for: >
                             if ((uint)(2 + imaginaryChars) < (uint)destination.Length)
diff --git a/src/libraries/System.Runtime/tests/System.Runtime.CompilerServices.Unsafe.Tests/UnsafeTests.cs b/src/libraries/System.Runtime/tests/System.Runtime.CompilerServices.Unsafe.Tests/UnsafeTests.cs
index 8cc4f236af4de..3df92cd860935 100644
--- a/src/libraries/System.Runtime/tests/System.Runtime.CompilerServices.Unsafe.Tests/UnsafeTests.cs
+++ b/src/libraries/System.Runtime/tests/System.Runtime.CompilerServices.Unsafe.Tests/UnsafeTests.cs
@@ -1263,9 +1263,10 @@ public static unsafe void BitCast()
 
             // Conversion between same sized ref structs should succeed
 
-            int i = 42;
-            Span<int> span = Unsafe.BitCast<ReadOnlySpan<int>, Span<int>>(new ReadOnlySpan<int>(&i, 1));
-            Assert.Equal(42, span[0]);
+            // TODO https://github.com/dotnet/runtime/issues/102988: Uncomment once this works on mono
+            //int i = 42;
+            //Span<int> span = Unsafe.BitCast<ReadOnlySpan<int>, Span<int>>(new ReadOnlySpan<int>(&i, 1));
+            //Assert.Equal(42, span[0]);
 
             // Conversion from runtime SIMD type to a custom struct should succeed