Temporarily removing use of ReadOnlySpan indexer in Runtime.Extensions

src/System.Runtime.Extensions/src/System.Runtime.Extensions.csproj

@@ -266,6 +266,9 @@
   <ItemGroup Condition="'$(TargetGroup)' == 'uapaot'">
     <ReferenceFromRuntime Include="System.Private.Interop" />
   </ItemGroup>
+  <ItemGroup Condition="'$(TargetGroup)' != 'uapaot'">
+    <ProjectReference Include="..\..\System.Runtime.CompilerServices.Unsafe\src\System.Runtime.CompilerServices.Unsafe.ilproj" />
+  </ItemGroup>
   <ItemGroup>
     <ReferenceFromRuntime Include="System.Private.CoreLib" />
   </ItemGroup>

src/System.Runtime.Extensions/src/System/IO/StreamReader.cs

@@ -5,6 +5,7 @@
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.Diagnostics.Contracts;
+using System.Runtime.CompilerServices;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
@@ -566,7 +567,13 @@ private bool IsPreamble()
                 return _checkPreamble;
             }
 
-            ReadOnlySpan<byte> preamble = _encoding.Preamble;
+            ReadOnlySpan<byte> readonlyPreamble = _encoding.Preamble;
+            Span<byte> preamble;
+
+            unsafe
+            {
+                preamble = new Span<byte>(Unsafe.AsPointer<byte>(ref readonlyPreamble.DangerousGetPinnableReference()), readonlyPreamble.Length);
+            }
 
             Debug.Assert(_bytePos <= preamble.Length, "_compressPreamble was called with the current bytePos greater than the preamble buffer length.  Are two threads using this StreamReader at the same time?");
             int len = (_byteLen >= (preamble.Length)) ? (preamble.Length - _bytePos) : (_byteLen - _bytePos);

src/System.Runtime.Extensions/src/System/IO/StreamWriter.cs

@@ -3,6 +3,7 @@
 // See the LICENSE file in the project root for more information.
 
 using System.Diagnostics;
+using System.Runtime.CompilerServices;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
@@ -370,14 +371,19 @@ private unsafe void WriteCore(ReadOnlySpan<char> buffer, bool autoFlush)
         {
             CheckAsyncTaskInProgress();
 
-            if (buffer.Length <= 4 && // Threshold of 4 chosen based on perf experimentation
-                buffer.Length <= _charLen - _charPos)
+            Span<char> bufferSpan;
+            unsafe
+            {
+                bufferSpan = new Span<char>(Unsafe.AsPointer<char>(ref buffer.DangerousGetPinnableReference()), buffer.Length);
+            }
+            if (bufferSpan.Length <= 4 && // Threshold of 4 chosen based on perf experimentation
+                bufferSpan.Length <= _charLen - _charPos)
             {
                 // For very short buffers and when we don't need to worry about running out of space
                 // in the char buffer, just copy the chars individually.
-                for (int i = 0; i < buffer.Length; i++)
+                for (int i = 0; i < bufferSpan.Length; i++)
                 {
-                    _charBuffer[_charPos++] = buffer[i];
+                    _charBuffer[_charPos++] = bufferSpan[i];
                 }
             }
             else
@@ -394,11 +400,11 @@ private unsafe void WriteCore(ReadOnlySpan<char> buffer, bool autoFlush)
                     throw new ObjectDisposedException(null, SR.ObjectDisposed_WriterClosed);
                 }
 
-                fixed (char* bufferPtr = &buffer.DangerousGetPinnableReference())
+                fixed (char* bufferPtr = &bufferSpan.DangerousGetPinnableReference())
                 fixed (char* dstPtr = &charBuffer[0])
                 {
                     char* srcPtr = bufferPtr;
-                    int count = buffer.Length;
+                    int count = bufferSpan.Length;
                     int dstPos = _charPos; // use a local copy of _charPos for safety
                     while (count > 0)
                     {