From dfb2b8a861fc97ce90c8f31c886d4d27c5b36f46 Mon Sep 17 00:00:00 2001
From: Adeel Mujahid <3840695+am11@users.noreply.github.com>
Date: Thu, 12 Dec 2024 13:25:30 +0200
Subject: [PATCH] Update dependencies from dotnet/roslyn (#110105)

* Update dependencies from https://github.com/dotnet/roslyn build 20241122.2

Microsoft.SourceBuild.Intermediate.roslyn , Microsoft.CodeAnalysis , Microsoft.CodeAnalysis.CSharp , Microsoft.Net.Compilers.Toolset
 From Version 4.13.0-2.24570.4 -> To Version 4.13.0-2.24572.2

* Update dependencies from https://github.com/dotnet/roslyn build 20241122.15

Microsoft.SourceBuild.Intermediate.roslyn , Microsoft.CodeAnalysis , Microsoft.CodeAnalysis.CSharp , Microsoft.Net.Compilers.Toolset
 From Version 4.13.0-2.24570.4 -> To Version 4.13.0-2.24572.15

* Update dependencies from https://github.com/dotnet/roslyn build 20241124.5

Microsoft.SourceBuild.Intermediate.roslyn , Microsoft.CodeAnalysis , Microsoft.CodeAnalysis.CSharp , Microsoft.Net.Compilers.Toolset
 From Version 4.13.0-2.24570.4 -> To Version 4.13.0-2.24574.5

* Update dependencies from https://github.com/dotnet/roslyn build 20241125.18

Microsoft.SourceBuild.Intermediate.roslyn , Microsoft.CodeAnalysis , Microsoft.CodeAnalysis.CSharp , Microsoft.Net.Compilers.Toolset
 From Version 4.13.0-2.24570.4 -> To Version 4.13.0-3.24575.18

* Update dependencies from https://github.com/dotnet/roslyn build 20241127.2

Microsoft.SourceBuild.Intermediate.roslyn , Microsoft.CodeAnalysis , Microsoft.CodeAnalysis.CSharp , Microsoft.Net.Compilers.Toolset
 From Version 4.13.0-2.24570.4 -> To Version 4.13.0-3.24577.2

* Update dependencies from https://github.com/dotnet/roslyn build 20241128.2

Microsoft.SourceBuild.Intermediate.roslyn , Microsoft.CodeAnalysis , Microsoft.CodeAnalysis.CSharp , Microsoft.Net.Compilers.Toolset
 From Version 4.13.0-2.24570.4 -> To Version 4.13.0-3.24578.2

* Update dependencies from https://github.com/dotnet/roslyn build 20241128.3

Microsoft.SourceBuild.Intermediate.roslyn , Microsoft.CodeAnalysis , Microsoft.CodeAnalysis.CSharp , Microsoft.Net.Compilers.Toolset
 From Version 4.13.0-2.24570.4 -> To Version 4.13.0-3.24578.3

* Update dependencies from https://github.com/dotnet/roslyn build 20241130.1

Microsoft.SourceBuild.Intermediate.roslyn , Microsoft.CodeAnalysis , Microsoft.CodeAnalysis.CSharp , Microsoft.Net.Compilers.Toolset
 From Version 4.13.0-2.24570.4 -> To Version 4.13.0-3.24580.1

* Update dependencies from https://github.com/dotnet/roslyn build 20241130.2

Microsoft.SourceBuild.Intermediate.roslyn , Microsoft.CodeAnalysis , Microsoft.CodeAnalysis.CSharp , Microsoft.Net.Compilers.Toolset
 From Version 4.13.0-2.24570.4 -> To Version 4.13.0-3.24580.2

* Update dependencies from https://github.com/dotnet/roslyn build 20241201.2

Microsoft.SourceBuild.Intermediate.roslyn , Microsoft.CodeAnalysis , Microsoft.CodeAnalysis.CSharp , Microsoft.Net.Compilers.Toolset
 From Version 4.13.0-2.24570.4 -> To Version 4.13.0-3.24601.2

* Update dependencies from https://github.com/dotnet/roslyn build 20241202.26

Microsoft.SourceBuild.Intermediate.roslyn , Microsoft.CodeAnalysis , Microsoft.CodeAnalysis.CSharp , Microsoft.Net.Compilers.Toolset
 From Version 4.13.0-2.24570.4 -> To Version 4.13.0-3.24602.26

* Use explicit AsSpan

* Fix LibraryImportGenerator.UnitTests

* Fix regex tests

* Adjust trimming test for new codegen

With this roslyn update, the generated iterator state machine
for this test includes a Dispose method which assigns null to the
array, inhibiting dataflow analysis.

---------

Co-authored-by: dotnet-maestro[bot] <dotnet-maestro[bot]@users.noreply.github.com>
Co-authored-by: Sven Boemer <sbomer@gmail.com>
---
 eng/Version.Details.xml                        | 16 ++++++++--------
 eng/Versions.props                             |  6 +++---
 .../ReachabilityInstrumentationFilter.cs       |  2 +-
 .../System/IO/StreamConformanceTests.cs        |  4 ++--
 .../Formats/Nrbf/ArraySinglePrimitiveRecord.cs |  8 ++++----
 src/libraries/System.Linq/tests/RangeTests.cs  |  2 +-
 src/libraries/System.Linq/tests/RepeatTests.cs |  2 +-
 .../Base64Url/Base64UrlUnicodeAPIsUnitTests.cs |  2 +-
 .../System.Memory/tests/Span/SearchValues.cs   |  2 +-
 .../tests/Span/StringSearchValues.cs           |  2 +-
 .../SocketAsyncEventArgsTest.cs                |  2 +-
 ..._StatefulLinearCollectionShapeValidation.cs |  3 +--
 ...eFixerTests_StatefulValueShapeValidation.cs |  1 -
 ...StatelessLinearCollectionShapeValidation.cs |  1 -
 ...FixerTests_StatelessValueShapeValidation.cs |  1 -
 .../InteropServices/CollectionsMarshalTests.cs | 10 +++++-----
 .../src/System/Numerics/BigInteger.cs          |  2 +-
 .../FileStream/ReadAsync.cs                    |  2 +-
 .../System/Convert.FromHexString.cs            |  2 +-
 .../System/Random.cs                           | 18 +++++++++---------
 .../Ascii/CaseConversionTests.cs               | 16 ++++++++--------
 .../tests/CoseHeaderValueTests.cs              |  6 +++---
 .../tests/SpanProtectedDataTests.cs            |  2 +-
 .../tests/HashAlgorithmTestDriver.cs           |  8 ++++----
 .../tests/HmacTests.cs                         |  8 ++++----
 .../tests/KmacTestDriver.cs                    |  2 +-
 .../AuthorityKeyIdentifierTests.cs             |  2 +-
 .../Json/Document/JsonDocument.MetadataDb.cs   |  2 +-
 .../CollectionTests/CollectionTests.Memory.cs  |  8 ++++----
 .../UpgradeToGeneratedRegexAnalyzerTests.cs    |  8 ++------
 ...mpilerGeneratedCodeAccessedViaReflection.cs |  1 +
 31 files changed, 72 insertions(+), 79 deletions(-)

diff --git a/eng/Version.Details.xml b/eng/Version.Details.xml
index 70c0a792543b3..83e1ab38472d0 100644
--- a/eng/Version.Details.xml
+++ b/eng/Version.Details.xml
@@ -376,17 +376,17 @@
       <Uri>https://github.com/dotnet/runtime-assets</Uri>
       <Sha>4daef9f8f673c1d0bbec273f2bcda1ab9074ef75</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.Net.Compilers.Toolset" Version="4.13.0-2.24570.4">
+    <Dependency Name="Microsoft.Net.Compilers.Toolset" Version="4.13.0-3.24602.26">
       <Uri>https://github.com/dotnet/roslyn</Uri>
-      <Sha>94fff7ad4f11977f903f435b0d97dcf0f2183710</Sha>
+      <Sha>089e61c59dcb3d46fe766abc85176ef8e42e4d58</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.CodeAnalysis" Version="4.13.0-2.24570.4">
+    <Dependency Name="Microsoft.CodeAnalysis" Version="4.13.0-3.24602.26">
       <Uri>https://github.com/dotnet/roslyn</Uri>
-      <Sha>94fff7ad4f11977f903f435b0d97dcf0f2183710</Sha>
+      <Sha>089e61c59dcb3d46fe766abc85176ef8e42e4d58</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.CodeAnalysis.CSharp" Version="4.13.0-2.24570.4">
+    <Dependency Name="Microsoft.CodeAnalysis.CSharp" Version="4.13.0-3.24602.26">
       <Uri>https://github.com/dotnet/roslyn</Uri>
-      <Sha>94fff7ad4f11977f903f435b0d97dcf0f2183710</Sha>
+      <Sha>089e61c59dcb3d46fe766abc85176ef8e42e4d58</Sha>
     </Dependency>
     <Dependency Name="Microsoft.CodeAnalysis.Analyzers" Version="3.12.0-beta1.24559.1">
       <Uri>https://github.com/dotnet/roslyn-analyzers</Uri>
@@ -397,9 +397,9 @@
       <Sha>5435ba7b1037f21237adc1b3845f97e9fdbc075d</Sha>
     </Dependency>
     <!-- Intermediate is necessary for source build. -->
-    <Dependency Name="Microsoft.SourceBuild.Intermediate.roslyn" Version="4.13.0-2.24570.4">
+    <Dependency Name="Microsoft.SourceBuild.Intermediate.roslyn" Version="4.13.0-3.24602.26">
       <Uri>https://github.com/dotnet/roslyn</Uri>
-      <Sha>94fff7ad4f11977f903f435b0d97dcf0f2183710</Sha>
+      <Sha>089e61c59dcb3d46fe766abc85176ef8e42e4d58</Sha>
       <SourceBuild RepoName="roslyn" ManagedOnly="true" />
     </Dependency>
     <Dependency Name="Microsoft.DotNet.ApiCompat.Task" Version="10.0.100-alpha.1.24480.5">
diff --git a/eng/Versions.props b/eng/Versions.props
index b762a76e6910c..1f89aa4347619 100644
--- a/eng/Versions.props
+++ b/eng/Versions.props
@@ -43,9 +43,9 @@
       Any tools that contribute to the design-time experience should use the MicrosoftCodeAnalysisVersion_LatestVS property above to ensure
       they do not break the local dev experience.
     -->
-    <MicrosoftCodeAnalysisCSharpVersion>4.13.0-2.24570.4</MicrosoftCodeAnalysisCSharpVersion>
-    <MicrosoftCodeAnalysisVersion>4.13.0-2.24570.4</MicrosoftCodeAnalysisVersion>
-    <MicrosoftNetCompilersToolsetVersion>4.13.0-2.24570.4</MicrosoftNetCompilersToolsetVersion>
+    <MicrosoftCodeAnalysisCSharpVersion>4.13.0-3.24602.26</MicrosoftCodeAnalysisCSharpVersion>
+    <MicrosoftCodeAnalysisVersion>4.13.0-3.24602.26</MicrosoftCodeAnalysisVersion>
+    <MicrosoftNetCompilersToolsetVersion>4.13.0-3.24602.26</MicrosoftNetCompilersToolsetVersion>
   </PropertyGroup>
   <!--
     For source generator support we need to target multiple versions of Roslyn in order to be able to run on older versions of Roslyn.
diff --git a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/ReachabilityInstrumentationFilter.cs b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/ReachabilityInstrumentationFilter.cs
index 9afe7e724fcc8..2fb613d9521df 100644
--- a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/ReachabilityInstrumentationFilter.cs
+++ b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/ReachabilityInstrumentationFilter.cs
@@ -44,7 +44,7 @@ public ReachabilityInstrumentationFilter(string profileDataFileName, ILProvider
                 int numTokens = reader.ReadInt32();
 
                 bool[] tokenStates = new bool[numTokens];
-                if (reader.Read(MemoryMarshal.Cast<bool, byte>(tokenStates)) != numTokens)
+                if (reader.Read(MemoryMarshal.Cast<bool, byte>(tokenStates.AsSpan())) != numTokens)
                     throw new IOException("Unexpected end of file");
 
                 _reachabilityInfo.Add(new Guid(guidBytes), tokenStates);
diff --git a/src/libraries/Common/tests/StreamConformanceTests/System/IO/StreamConformanceTests.cs b/src/libraries/Common/tests/StreamConformanceTests/System/IO/StreamConformanceTests.cs
index 61fb0f51936e2..e9ff147bbe5f0 100644
--- a/src/libraries/Common/tests/StreamConformanceTests/System/IO/StreamConformanceTests.cs
+++ b/src/libraries/Common/tests/StreamConformanceTests/System/IO/StreamConformanceTests.cs
@@ -1915,7 +1915,7 @@ public virtual async Task ReadWrite_MessagesSmallerThanReadBuffer_Success(ReadWr
                         }
 
                         Assert.Equal(writerBytes.Length, n);
-                        AssertExtensions.SequenceEqual(writerBytes, readerBytes.AsSpan(0, writerBytes.Length));
+                        AssertExtensions.SequenceEqual(writerBytes.AsSpan(), readerBytes.AsSpan(0, writerBytes.Length));
 
                         await writes;
                     }
@@ -3069,7 +3069,7 @@ public virtual async Task ZeroByteRead_PerformsZeroByteReadOnUnderlyingStreamWhe
 
                 if (FlushGuaranteesAllDataWritten)
                 {
-                    AssertExtensions.SequenceEqual(data, buffer.AsSpan(0, bytesRead));
+                    AssertExtensions.SequenceEqual(data.AsSpan(), buffer.AsSpan(0, bytesRead));
                 }
             }
         }
diff --git a/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/ArraySinglePrimitiveRecord.cs b/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/ArraySinglePrimitiveRecord.cs
index a28359d9bb13d..ef2195a342a04 100644
--- a/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/ArraySinglePrimitiveRecord.cs
+++ b/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/ArraySinglePrimitiveRecord.cs
@@ -161,7 +161,7 @@ internal static IReadOnlyList<T> DecodePrimitiveTypes(BinaryReader reader, int c
         {
             if (typeof(T) == typeof(short) || typeof(T) == typeof(ushort))
             {
-                Span<short> span = MemoryMarshal.Cast<T, short>(result);
+                Span<short> span = MemoryMarshal.Cast<T, short>(result.AsSpan());
 #if NET
                 BinaryPrimitives.ReverseEndianness(span, span);
 #else
@@ -173,7 +173,7 @@ internal static IReadOnlyList<T> DecodePrimitiveTypes(BinaryReader reader, int c
             }
             else if (typeof(T) == typeof(int) || typeof(T) == typeof(uint) || typeof(T) == typeof(float))
             {
-                Span<int> span = MemoryMarshal.Cast<T, int>(result);
+                Span<int> span = MemoryMarshal.Cast<T, int>(result.AsSpan());
 #if NET
                 BinaryPrimitives.ReverseEndianness(span, span);
 #else
@@ -185,7 +185,7 @@ internal static IReadOnlyList<T> DecodePrimitiveTypes(BinaryReader reader, int c
             }
             else if (typeof(T) == typeof(long) || typeof(T) == typeof(ulong) || typeof(T) == typeof(double))
             {
-                Span<long> span = MemoryMarshal.Cast<T, long>(result);
+                Span<long> span = MemoryMarshal.Cast<T, long>(result.AsSpan());
 #if NET
                 BinaryPrimitives.ReverseEndianness(span, span);
 #else
@@ -201,7 +201,7 @@ internal static IReadOnlyList<T> DecodePrimitiveTypes(BinaryReader reader, int c
         {
             // See DontCastBytesToBooleans test to see what could go wrong.
             bool[] booleans = (bool[])(object)result;
-            Span<byte> resultAsBytes = MemoryMarshal.AsBytes<T>(result);
+            Span<byte> resultAsBytes = MemoryMarshal.AsBytes<T>(result.AsSpan());
             for (int i = 0; i < booleans.Length; i++)
             {
                 // We don't use the bool array to get the value, as an optimizing compiler or JIT could elide this.
diff --git a/src/libraries/System.Linq/tests/RangeTests.cs b/src/libraries/System.Linq/tests/RangeTests.cs
index 2e331cfee7ecd..26ec544f327af 100644
--- a/src/libraries/System.Linq/tests/RangeTests.cs
+++ b/src/libraries/System.Linq/tests/RangeTests.cs
@@ -270,7 +270,7 @@ static void Validate(IEnumerable<int> e, int[] expected)
                 list.CopyTo(actual, 1);
                 Assert.Equal(0, actual[0]);
                 Assert.Equal(0, actual[^1]);
-                AssertExtensions.SequenceEqual(expected, actual.AsSpan(1, expected.Length));
+                AssertExtensions.SequenceEqual(expected.AsSpan(), actual.AsSpan(1, expected.Length));
             }
         }
     }
diff --git a/src/libraries/System.Linq/tests/RepeatTests.cs b/src/libraries/System.Linq/tests/RepeatTests.cs
index df8eebda35691..9ee0d7f68fb14 100644
--- a/src/libraries/System.Linq/tests/RepeatTests.cs
+++ b/src/libraries/System.Linq/tests/RepeatTests.cs
@@ -282,7 +282,7 @@ static void Validate(IEnumerable<int> e, int[] expected)
                 list.CopyTo(actual, 1);
                 Assert.Equal(0, actual[0]);
                 Assert.Equal(0, actual[^1]);
-                AssertExtensions.SequenceEqual(expected, actual.AsSpan(1, expected.Length));
+                AssertExtensions.SequenceEqual(expected.AsSpan(), actual.AsSpan(1, expected.Length));
             }
         }
     }
diff --git a/src/libraries/System.Memory/tests/Base64Url/Base64UrlUnicodeAPIsUnitTests.cs b/src/libraries/System.Memory/tests/Base64Url/Base64UrlUnicodeAPIsUnitTests.cs
index 09326bef170ea..a455075bb9c7e 100644
--- a/src/libraries/System.Memory/tests/Base64Url/Base64UrlUnicodeAPIsUnitTests.cs
+++ b/src/libraries/System.Memory/tests/Base64Url/Base64UrlUnicodeAPIsUnitTests.cs
@@ -438,7 +438,7 @@ public static void Base64_AllMethodsRoundtripConsistently()
                 Span<byte> decodedBytes = new byte[original.Length];
                 int decoded = Base64Url.DecodeFromChars(encodedArray, decodedBytes);
                 Assert.Equal(original.Length, decoded);
-                AssertExtensions.SequenceEqual(original, decodedBytes);
+                AssertExtensions.SequenceEqual(original.AsSpan(), decodedBytes);
 
                 byte[] actualBytes = new byte[original.Length];
                 Assert.True(Base64Url.TryDecodeFromChars(encodedSpan, actualBytes, out int bytesWritten));
diff --git a/src/libraries/System.Memory/tests/Span/SearchValues.cs b/src/libraries/System.Memory/tests/Span/SearchValues.cs
index 00e9c71e3dfb7..51c8688bfae2b 100644
--- a/src/libraries/System.Memory/tests/Span/SearchValues.cs
+++ b/src/libraries/System.Memory/tests/Span/SearchValues.cs
@@ -465,7 +465,7 @@ static SearchValuesTestHelper()
                     s_randomLatin1Chars[i] = (char)rng.Next(0, 256);
                 }
 
-                rng.NextBytes(MemoryMarshal.Cast<char, byte>(s_randomChars));
+                rng.NextBytes(MemoryMarshal.Cast<char, byte>(s_randomChars.AsSpan()));
 
                 s_randomAsciiBytes = Encoding.ASCII.GetBytes(s_randomAsciiChars);
 
diff --git a/src/libraries/System.Memory/tests/Span/StringSearchValues.cs b/src/libraries/System.Memory/tests/Span/StringSearchValues.cs
index c0b80b5ab0677..f702b0bdcad99 100644
--- a/src/libraries/System.Memory/tests/Span/StringSearchValues.cs
+++ b/src/libraries/System.Memory/tests/Span/StringSearchValues.cs
@@ -620,7 +620,7 @@ public StringSearchValuesTestHelper(IndexOfAnySearchDelegate expected, SearchVal
                     }));
                 }
 
-                rng.NextBytes(MemoryMarshal.Cast<char, byte>(_randomChars));
+                rng.NextBytes(MemoryMarshal.Cast<char, byte>(_randomChars.AsSpan()));
             }
 
             public void StressRandomInputs(TimeSpan duration)
diff --git a/src/libraries/System.Net.Sockets/tests/FunctionalTests/SocketAsyncEventArgsTest.cs b/src/libraries/System.Net.Sockets/tests/FunctionalTests/SocketAsyncEventArgsTest.cs
index 9909192150ed0..73c4ee74d18e2 100644
--- a/src/libraries/System.Net.Sockets/tests/FunctionalTests/SocketAsyncEventArgsTest.cs
+++ b/src/libraries/System.Net.Sockets/tests/FunctionalTests/SocketAsyncEventArgsTest.cs
@@ -728,7 +728,7 @@ public void AcceptAsync_WithReceiveBuffer_Success()
 
                 Assert.Equal(acceptBufferDataSize, acceptArgs.BytesTransferred);
 
-                AssertExtensions.SequenceEqual(sendBuffer, acceptArgs.Buffer.AsSpan(0, acceptArgs.BytesTransferred));
+                AssertExtensions.SequenceEqual(sendBuffer.AsSpan(), acceptArgs.Buffer.AsSpan(0, acceptArgs.BytesTransferred));
             }
         }
 
diff --git a/src/libraries/System.Runtime.InteropServices/tests/LibraryImportGenerator.UnitTests/CustomMarshallerAttributeFixerTests_StatefulLinearCollectionShapeValidation.cs b/src/libraries/System.Runtime.InteropServices/tests/LibraryImportGenerator.UnitTests/CustomMarshallerAttributeFixerTests_StatefulLinearCollectionShapeValidation.cs
index 2aedfde9936f4..e798e184b6bf7 100644
--- a/src/libraries/System.Runtime.InteropServices/tests/LibraryImportGenerator.UnitTests/CustomMarshallerAttributeFixerTests_StatefulLinearCollectionShapeValidation.cs
+++ b/src/libraries/System.Runtime.InteropServices/tests/LibraryImportGenerator.UnitTests/CustomMarshallerAttributeFixerTests_StatefulLinearCollectionShapeValidation.cs
@@ -171,7 +171,7 @@ public void FromManaged(ManagedType m) {}
                     public nint ToUnmanaged() => default;
                     public void Free() {}
                     public Span<T> GetUnmanagedValuesDestination() => default;
-                
+
                     public ReadOnlySpan<nint> GetManagedValuesSource()
                     {
                         throw new NotImplementedException();
@@ -602,7 +602,6 @@ public void FromManaged(ManagedType m, Span<byte> buffer) {}
                     public void Free() {}
                     public ReadOnlySpan<byte> GetManagedValuesSource() => default;
                     public Span<T> GetUnmanagedValuesDestination() => default;
-
                     public static int BufferSize
                     {
                         get
diff --git a/src/libraries/System.Runtime.InteropServices/tests/LibraryImportGenerator.UnitTests/CustomMarshallerAttributeFixerTests_StatefulValueShapeValidation.cs b/src/libraries/System.Runtime.InteropServices/tests/LibraryImportGenerator.UnitTests/CustomMarshallerAttributeFixerTests_StatefulValueShapeValidation.cs
index 9a72a5fbc4916..cb2c5d8caf10e 100644
--- a/src/libraries/System.Runtime.InteropServices/tests/LibraryImportGenerator.UnitTests/CustomMarshallerAttributeFixerTests_StatefulValueShapeValidation.cs
+++ b/src/libraries/System.Runtime.InteropServices/tests/LibraryImportGenerator.UnitTests/CustomMarshallerAttributeFixerTests_StatefulValueShapeValidation.cs
@@ -382,7 +382,6 @@ public void FromManaged(ManagedType m, Span<byte> b) {}
                     public int ToUnmanaged() => default;
 
                     public void Free() {}
-
                     public static int BufferSize
                     {
                         get
diff --git a/src/libraries/System.Runtime.InteropServices/tests/LibraryImportGenerator.UnitTests/CustomMarshallerAttributeFixerTests_StatelessLinearCollectionShapeValidation.cs b/src/libraries/System.Runtime.InteropServices/tests/LibraryImportGenerator.UnitTests/CustomMarshallerAttributeFixerTests_StatelessLinearCollectionShapeValidation.cs
index fec16b2bc7ff7..b60bb78f2acc2 100644
--- a/src/libraries/System.Runtime.InteropServices/tests/LibraryImportGenerator.UnitTests/CustomMarshallerAttributeFixerTests_StatelessLinearCollectionShapeValidation.cs
+++ b/src/libraries/System.Runtime.InteropServices/tests/LibraryImportGenerator.UnitTests/CustomMarshallerAttributeFixerTests_StatelessLinearCollectionShapeValidation.cs
@@ -614,7 +614,6 @@ static class MarshallerType<T>
                     public static ReadOnlySpan<int> GetManagedValuesSource(ManagedType m) => default;
 
                     public static Span<T> GetUnmanagedValuesDestination(nint unmanaged, int numElements) => default;
-
                     public static int BufferSize
                     {
                         get
diff --git a/src/libraries/System.Runtime.InteropServices/tests/LibraryImportGenerator.UnitTests/CustomMarshallerAttributeFixerTests_StatelessValueShapeValidation.cs b/src/libraries/System.Runtime.InteropServices/tests/LibraryImportGenerator.UnitTests/CustomMarshallerAttributeFixerTests_StatelessValueShapeValidation.cs
index 7d94afb9985f7..35c90af32f81b 100644
--- a/src/libraries/System.Runtime.InteropServices/tests/LibraryImportGenerator.UnitTests/CustomMarshallerAttributeFixerTests_StatelessValueShapeValidation.cs
+++ b/src/libraries/System.Runtime.InteropServices/tests/LibraryImportGenerator.UnitTests/CustomMarshallerAttributeFixerTests_StatelessValueShapeValidation.cs
@@ -363,7 +363,6 @@ class ManagedType {}
                 static class MarshallerType
                 {
                     public static nint ConvertToUnmanaged(ManagedType m, Span<byte> b) => default;
-
                     public static int BufferSize
                     {
                         get
diff --git a/src/libraries/System.Runtime.InteropServices/tests/System.Runtime.InteropServices.UnitTests/System/Runtime/InteropServices/CollectionsMarshalTests.cs b/src/libraries/System.Runtime.InteropServices/tests/System.Runtime.InteropServices.UnitTests/System/Runtime/InteropServices/CollectionsMarshalTests.cs
index 325c9a43de630..867ee99b852e8 100644
--- a/src/libraries/System.Runtime.InteropServices/tests/System.Runtime.InteropServices.UnitTests/System/Runtime/InteropServices/CollectionsMarshalTests.cs
+++ b/src/libraries/System.Runtime.InteropServices/tests/System.Runtime.InteropServices.UnitTests/System/Runtime/InteropServices/CollectionsMarshalTests.cs
@@ -527,19 +527,19 @@ public void ListSetCount()
             CollectionsMarshal.SetCount(list, 3);
             Assert.Equal(3, list.Count);
             Assert.Throws<ArgumentOutOfRangeException>(() => list[3]);
-            AssertExtensions.SequenceEqual(CollectionsMarshal.AsSpan(list), new int[] { 1, 2, 3 });
+            AssertExtensions.SequenceEqual(CollectionsMarshal.AsSpan(list), new int[] { 1, 2, 3 }.AsSpan());
             Assert.True(Unsafe.AreSame(ref intRef, ref MemoryMarshal.GetReference(CollectionsMarshal.AsSpan(list))));
 
             // make sure that size increase preserves content and doesn't clear
             CollectionsMarshal.SetCount(list, 5);
-            AssertExtensions.SequenceEqual(CollectionsMarshal.AsSpan(list), new int[] { 1, 2, 3, 4, 5 });
+            AssertExtensions.SequenceEqual(CollectionsMarshal.AsSpan(list), new int[] { 1, 2, 3, 4, 5 }.AsSpan());
             Assert.True(Unsafe.AreSame(ref intRef, ref MemoryMarshal.GetReference(CollectionsMarshal.AsSpan(list))));
 
             // make sure that reallocations preserve content
             int newCount = list.Capacity * 2;
             CollectionsMarshal.SetCount(list, newCount);
             Assert.Equal(newCount, list.Count);
-            AssertExtensions.SequenceEqual(CollectionsMarshal.AsSpan(list)[..3], new int[] { 1, 2, 3 });
+            AssertExtensions.SequenceEqual(CollectionsMarshal.AsSpan(list)[..3], new int[] { 1, 2, 3 }.AsSpan());
             Assert.True(!Unsafe.AreSame(ref intRef, ref MemoryMarshal.GetReference(CollectionsMarshal.AsSpan(list))));
 
             List<string> listReference = new() { "a", "b", "c", "d", "e" };
@@ -547,12 +547,12 @@ public void ListSetCount()
             CollectionsMarshal.SetCount(listReference, 3);
 
             // verify that reference types aren't cleared
-            AssertExtensions.SequenceEqual(CollectionsMarshal.AsSpan(listReference), new string[] { "a", "b", "c" });
+            AssertExtensions.SequenceEqual(CollectionsMarshal.AsSpan(listReference), new string[] { "a", "b", "c" }.AsSpan());
             Assert.True(Unsafe.AreSame(ref stringRef, ref MemoryMarshal.GetReference(CollectionsMarshal.AsSpan(listReference))));
             CollectionsMarshal.SetCount(listReference, 5);
 
             // verify that removed reference types are cleared
-            AssertExtensions.SequenceEqual(CollectionsMarshal.AsSpan(listReference), new string[] { "a", "b", "c", null, null });
+            AssertExtensions.SequenceEqual(CollectionsMarshal.AsSpan(listReference), new string[] { "a", "b", "c", null, null }.AsSpan());
             Assert.True(Unsafe.AreSame(ref stringRef, ref MemoryMarshal.GetReference(CollectionsMarshal.AsSpan(listReference))));
         }
     }
diff --git a/src/libraries/System.Runtime.Numerics/src/System/Numerics/BigInteger.cs b/src/libraries/System.Runtime.Numerics/src/System/Numerics/BigInteger.cs
index 3832028c2dd4a..418a565dbd812 100644
--- a/src/libraries/System.Runtime.Numerics/src/System/Numerics/BigInteger.cs
+++ b/src/libraries/System.Runtime.Numerics/src/System/Numerics/BigInteger.cs
@@ -384,7 +384,7 @@ public BigInteger(ReadOnlySpan<byte> value, bool isUnsigned = false, bool isBigE
                     // The bytes parameter is in little-endian byte order.
                     // We can just copy the bytes directly into the uint array.
 
-                    value.Slice(0, wholeUInt32Count * 4).CopyTo(MemoryMarshal.AsBytes<uint>(val));
+                    value.Slice(0, wholeUInt32Count * 4).CopyTo(MemoryMarshal.AsBytes<uint>(val.AsSpan()));
                 }
 
                 // In both of the above cases on big-endian architecture, we need to perform
diff --git a/src/libraries/System.Runtime/tests/System.IO.FileSystem.Tests/FileStream/ReadAsync.cs b/src/libraries/System.Runtime/tests/System.IO.FileSystem.Tests/FileStream/ReadAsync.cs
index d31149d297c5e..40220b45ef875 100644
--- a/src/libraries/System.Runtime/tests/System.IO.FileSystem.Tests/FileStream/ReadAsync.cs
+++ b/src/libraries/System.Runtime/tests/System.IO.FileSystem.Tests/FileStream/ReadAsync.cs
@@ -123,7 +123,7 @@ public async Task IncompleteReadCantSetPositionBeyondEndOfFile(FileShare fileSha
                 await Task.WhenAll(reads);
                 // but when they are finished, the first buffer should contain valid data:
                 Assert.Equal(fileSize, reads.First().Result);
-                AssertExtensions.SequenceEqual(content, buffers.First().AsSpan(0, fileSize));
+                AssertExtensions.SequenceEqual(content.AsSpan(), buffers.First().AsSpan(0, fileSize));
                 // and other reads should return 0:
                 Assert.All(reads.Skip(1), read => Assert.Equal(0, read.Result));
                 // and the Position must be correct:
diff --git a/src/libraries/System.Runtime/tests/System.Runtime.Extensions.Tests/System/Convert.FromHexString.cs b/src/libraries/System.Runtime/tests/System.Runtime.Extensions.Tests/System/Convert.FromHexString.cs
index fd8bcd6c8e05d..643971e016396 100644
--- a/src/libraries/System.Runtime/tests/System.Runtime.Extensions.Tests/System/Convert.FromHexString.cs
+++ b/src/libraries/System.Runtime/tests/System.Runtime.Extensions.Tests/System/Convert.FromHexString.cs
@@ -42,7 +42,7 @@ private static void TestSequence(byte[] expected, string actual)
             Assert.Equal(OperationStatus.Done, Convert.FromHexString(actual, tryResult, out int consumed, out int written));
             Assert.Equal(fromResult.Length, written);
             Assert.Equal(actual.Length, consumed);
-            AssertExtensions.SequenceEqual(expected, tryResult);
+            AssertExtensions.SequenceEqual(expected.AsSpan(), tryResult);
         }
 
         [Fact]
diff --git a/src/libraries/System.Runtime/tests/System.Runtime.Extensions.Tests/System/Random.cs b/src/libraries/System.Runtime/tests/System.Runtime.Extensions.Tests/System/Random.cs
index f6cb50a52fc90..057d6f0c96c12 100644
--- a/src/libraries/System.Runtime/tests/System.Runtime.Extensions.Tests/System/Random.cs
+++ b/src/libraries/System.Runtime/tests/System.Runtime.Extensions.Tests/System/Random.cs
@@ -713,9 +713,9 @@ public static void Shuffle_Array_Seeded(bool emptyShuffle)
             Random random = new Random(0x70636A61);
             int[] items = new int[] { 1, 2, 3, 4 };
             random.Shuffle(items);
-            AssertExtensions.SequenceEqual(stackalloc int[] { 4, 2, 1, 3 }, items);
+            AssertExtensions.SequenceEqual(stackalloc int[] { 4, 2, 1, 3 }, items.AsSpan());
             random.Shuffle(items);
-            AssertExtensions.SequenceEqual(stackalloc int[] { 2, 3, 4, 1 }, items);
+            AssertExtensions.SequenceEqual(stackalloc int[] { 2, 3, 4, 1 }, items.AsSpan());
 
             if (emptyShuffle)
             {
@@ -724,7 +724,7 @@ public static void Shuffle_Array_Seeded(bool emptyShuffle)
             }
 
             random.Shuffle(items);
-            AssertExtensions.SequenceEqual(stackalloc int[] { 1, 4, 3, 2 }, items);
+            AssertExtensions.SequenceEqual(stackalloc int[] { 1, 4, 3, 2 }, items.AsSpan());
         }
 
         [Fact]
@@ -831,13 +831,13 @@ public static void GetItems_Buffer_Seeded_NonPower2()
 
             Span<byte> buffer = stackalloc byte[7];
             random.GetItems(items, buffer);
-            AssertExtensions.SequenceEqual(new byte[] { 3, 1, 3, 2, 3, 3, 3 }, buffer);
+            AssertExtensions.SequenceEqual(new byte[] { 3, 1, 3, 2, 3, 3, 3 }.AsSpan(), buffer);
 
             random.GetItems(items, buffer);
-            AssertExtensions.SequenceEqual(new byte[] { 2, 1, 2, 1, 2, 3, 1 }, buffer);
+            AssertExtensions.SequenceEqual(new byte[] { 2, 1, 2, 1, 2, 3, 1 }.AsSpan(), buffer);
 
             random.GetItems(items, buffer);
-            AssertExtensions.SequenceEqual(new byte[] { 1, 1, 3, 1, 3, 2, 2 }, buffer);
+            AssertExtensions.SequenceEqual(new byte[] { 1, 1, 3, 1, 3, 2, 2 }.AsSpan(), buffer);
         }
 
         [Fact]
@@ -880,13 +880,13 @@ public static void GetItems_Buffer_Seeded_Power2()
 
             Span<byte> buffer = stackalloc byte[7];
             random.GetItems(items, buffer);
-            AssertExtensions.SequenceEqual(new byte[] { 4, 1, 4, 2, 4, 4, 4 }, buffer);
+            AssertExtensions.SequenceEqual(new byte[] { 4, 1, 4, 2, 4, 4, 4 }.AsSpan(), buffer);
 
             random.GetItems(items, buffer);
-            AssertExtensions.SequenceEqual(new byte[] { 2, 2, 3, 1, 3, 3, 1 }, buffer);
+            AssertExtensions.SequenceEqual(new byte[] { 2, 2, 3, 1, 3, 3, 1 }.AsSpan(), buffer);
 
             random.GetItems(items, buffer);
-            AssertExtensions.SequenceEqual(new byte[] { 2, 1, 4, 2, 4, 2, 2 }, buffer);
+            AssertExtensions.SequenceEqual(new byte[] { 2, 1, 4, 2, 4, 2, 2 }.AsSpan(), buffer);
         }
 
         [Theory]
diff --git a/src/libraries/System.Runtime/tests/System.Text.Encoding.Tests/Ascii/CaseConversionTests.cs b/src/libraries/System.Runtime/tests/System.Text.Encoding.Tests/Ascii/CaseConversionTests.cs
index ceb836ff268a4..ef06e40d1c2df 100644
--- a/src/libraries/System.Runtime/tests/System.Text.Encoding.Tests/Ascii/CaseConversionTests.cs
+++ b/src/libraries/System.Runtime/tests/System.Text.Encoding.Tests/Ascii/CaseConversionTests.cs
@@ -25,20 +25,20 @@ public static void OverlappingBuffers_Throws()
             Assert.Throws<InvalidOperationException>(() => Ascii.ToUpper(byteBuffer, byteBuffer, out _));
             Assert.Throws<InvalidOperationException>(() => Ascii.ToUpper(byteBuffer.AsSpan(1, 3), byteBuffer.AsSpan(3, 5), out _));
             // byte -> char
-            Assert.Throws<InvalidOperationException>(() => Ascii.ToLower(byteBuffer, MemoryMarshal.Cast<byte, char>(byteBuffer), out _));
-            Assert.Throws<InvalidOperationException>(() => Ascii.ToLower(byteBuffer, MemoryMarshal.Cast<byte, char>(byteBuffer).Slice(1, 3), out _));
-            Assert.Throws<InvalidOperationException>(() => Ascii.ToUpper(byteBuffer, MemoryMarshal.Cast<byte, char>(byteBuffer), out _));
-            Assert.Throws<InvalidOperationException>(() => Ascii.ToUpper(byteBuffer, MemoryMarshal.Cast<byte, char>(byteBuffer).Slice(1, 3), out _));
+            Assert.Throws<InvalidOperationException>(() => Ascii.ToLower(byteBuffer, MemoryMarshal.Cast<byte, char>(byteBuffer.AsSpan()), out _));
+            Assert.Throws<InvalidOperationException>(() => Ascii.ToLower(byteBuffer, MemoryMarshal.Cast<byte, char>(byteBuffer.AsSpan()).Slice(1, 3), out _));
+            Assert.Throws<InvalidOperationException>(() => Ascii.ToUpper(byteBuffer, MemoryMarshal.Cast<byte, char>(byteBuffer.AsSpan()), out _));
+            Assert.Throws<InvalidOperationException>(() => Ascii.ToUpper(byteBuffer, MemoryMarshal.Cast<byte, char>(byteBuffer.AsSpan()).Slice(1, 3), out _));
             // char -> char
             Assert.Throws<InvalidOperationException>(() => Ascii.ToLower(charBuffer, charBuffer, out _));
             Assert.Throws<InvalidOperationException>(() => Ascii.ToLower(charBuffer.AsSpan(1, 3), charBuffer.AsSpan(3, 5), out _));
             Assert.Throws<InvalidOperationException>(() => Ascii.ToUpper(charBuffer, charBuffer, out _));
             Assert.Throws<InvalidOperationException>(() => Ascii.ToUpper(charBuffer.AsSpan(1, 3), charBuffer.AsSpan(3, 5), out _));
             // char -> byte
-            Assert.Throws<InvalidOperationException>(() => Ascii.ToLower(charBuffer, MemoryMarshal.Cast<char, byte>(charBuffer), out _));
-            Assert.Throws<InvalidOperationException>(() => Ascii.ToLower(charBuffer, MemoryMarshal.Cast<char, byte>(charBuffer).Slice(1, 3), out _));
-            Assert.Throws<InvalidOperationException>(() => Ascii.ToUpper(charBuffer, MemoryMarshal.Cast<char, byte>(charBuffer), out _));
-            Assert.Throws<InvalidOperationException>(() => Ascii.ToUpper(charBuffer, MemoryMarshal.Cast<char, byte>(charBuffer).Slice(1, 3), out _));
+            Assert.Throws<InvalidOperationException>(() => Ascii.ToLower(charBuffer, MemoryMarshal.Cast<char, byte>(charBuffer.AsSpan()), out _));
+            Assert.Throws<InvalidOperationException>(() => Ascii.ToLower(charBuffer, MemoryMarshal.Cast<char, byte>(charBuffer.AsSpan()).Slice(1, 3), out _));
+            Assert.Throws<InvalidOperationException>(() => Ascii.ToUpper(charBuffer, MemoryMarshal.Cast<char, byte>(charBuffer.AsSpan()), out _));
+            Assert.Throws<InvalidOperationException>(() => Ascii.ToUpper(charBuffer, MemoryMarshal.Cast<char, byte>(charBuffer.AsSpan()).Slice(1, 3), out _));
         }
 
         private static void VerifySingleChar<T>(OperationStatus status, int value, T expected, T actual, int written)
diff --git a/src/libraries/System.Security.Cryptography.Cose/tests/CoseHeaderValueTests.cs b/src/libraries/System.Security.Cryptography.Cose/tests/CoseHeaderValueTests.cs
index b01cbc953177c..2d7c891fecf4e 100644
--- a/src/libraries/System.Security.Cryptography.Cose/tests/CoseHeaderValueTests.cs
+++ b/src/libraries/System.Security.Cryptography.Cose/tests/CoseHeaderValueTests.cs
@@ -97,7 +97,7 @@ public void GetValueAsBytesSucceeds(ContentTestCase @case)
             Span<byte> buffer = new byte[content.Length];
             int length = headerValue.GetValueAsBytes(buffer);
             Assert.Equal(content.Length, length);
-            AssertExtensions.SequenceEqual(content, buffer);
+            AssertExtensions.SequenceEqual(content.AsSpan(), buffer);
         }
 
         [Theory]
@@ -138,7 +138,7 @@ void Verify(int repetitions)
 
                 for (int i = 0; i < expectedLength; i+= content.Length)
                 {
-                    AssertExtensions.SequenceEqual(content, buffer.Slice(i, content.Length));
+                    AssertExtensions.SequenceEqual(content.AsSpan(), buffer.Slice(i, content.Length));
                 }
             }
         }
@@ -244,7 +244,7 @@ public void FromBytesSucceeds(ContentTestCase @case)
 
             Span<byte> buffer = new byte[content.Length];
             int length = headerValue.GetValueAsBytes(buffer);
-            AssertExtensions.SequenceEqual(content, buffer);
+            AssertExtensions.SequenceEqual(content.AsSpan(), buffer);
             Assert.Equal(content.Length, length);
         }
 
diff --git a/src/libraries/System.Security.Cryptography.ProtectedData/tests/SpanProtectedDataTests.cs b/src/libraries/System.Security.Cryptography.ProtectedData/tests/SpanProtectedDataTests.cs
index e626a4ce9301b..e1cfc029ea66b 100644
--- a/src/libraries/System.Security.Cryptography.ProtectedData/tests/SpanProtectedDataTests.cs
+++ b/src/libraries/System.Security.Cryptography.ProtectedData/tests/SpanProtectedDataTests.cs
@@ -42,7 +42,7 @@ public void ZeroBufferThrows()
         public void NearCorrectSizeBufferTests(int delta, bool success)
         {
             byte[] buffer = new byte[DefaultProtectedBufferSize];
-            int original = ProtectedData.Protect([1, 2, 3], DataProtectionScope.CurrentUser, buffer);
+            int original = ProtectedData.Protect([1, 2, 3], DataProtectionScope.CurrentUser, buffer.AsSpan());
 
             if (success)
             {
diff --git a/src/libraries/System.Security.Cryptography/tests/HashAlgorithmTestDriver.cs b/src/libraries/System.Security.Cryptography/tests/HashAlgorithmTestDriver.cs
index bbcf23ec0e596..53e6839c5eee4 100644
--- a/src/libraries/System.Security.Cryptography/tests/HashAlgorithmTestDriver.cs
+++ b/src/libraries/System.Security.Cryptography/tests/HashAlgorithmTestDriver.cs
@@ -66,7 +66,7 @@ private void VerifyOneShotStream(Stream input, string output)
             Span<byte> buffer = stackalloc byte[512 / 8];
 
             int written = HashData(input, buffer);
-            AssertExtensions.SequenceEqual(expected, buffer.Slice(0, written));
+            AssertExtensions.SequenceEqual(expected.AsSpan(), buffer.Slice(0, written));
         }
 
         private async Task VerifyOneShotStreamAsync(Stream input, string output)
@@ -75,7 +75,7 @@ private async Task VerifyOneShotStreamAsync(Stream input, string output)
             Memory<byte> buffer = new byte[512 / 8];
 
             int written = await HashDataAsync(input, buffer, cancellationToken: default);
-            AssertExtensions.SequenceEqual(expected, buffer.Slice(0, written).Span);
+            AssertExtensions.SequenceEqual(expected.AsSpan(), buffer.Slice(0, written).Span);
         }
 
         private void VerifyOneShotAllocatingStream(Stream input, string output)
@@ -100,7 +100,7 @@ private void VerifyOneShotStream_CryptographicOperations(Stream input, string ou
             Span<byte> buffer = stackalloc byte[512 / 8];
 
             int written = CryptographicOperations.HashData(HashAlgorithm, input, buffer);
-            AssertExtensions.SequenceEqual(expected, buffer.Slice(0, written));
+            AssertExtensions.SequenceEqual(expected.AsSpan(), buffer.Slice(0, written));
         }
 
         private async Task VerifyOneShotStreamAsync_CryptographicOperations(Stream input, string output)
@@ -114,7 +114,7 @@ private async Task VerifyOneShotStreamAsync_CryptographicOperations(Stream input
                 buffer,
                 cancellationToken: default);
 
-            AssertExtensions.SequenceEqual(expected, buffer.Slice(0, written).Span);
+            AssertExtensions.SequenceEqual(expected.AsSpan(), buffer.Slice(0, written).Span);
         }
 
         private void VerifyOneShotAllocatingStream_CryptographicOperations(Stream input, string output)
diff --git a/src/libraries/System.Security.Cryptography/tests/HmacTests.cs b/src/libraries/System.Security.Cryptography/tests/HmacTests.cs
index 75a36fba2e879..a2d649fb3d960 100644
--- a/src/libraries/System.Security.Cryptography/tests/HmacTests.cs
+++ b/src/libraries/System.Security.Cryptography/tests/HmacTests.cs
@@ -136,7 +136,7 @@ protected void VerifyHashDataStream(ReadOnlySpan<byte> key, Stream stream, strin
             int written = HashDataOneShot(key, stream, destination);
 
             Assert.Equal(MacSize, written);
-            AssertExtensions.SequenceEqual(expected, destination);
+            AssertExtensions.SequenceEqual(expected.AsSpan(), destination);
         }
 
         protected void VerifyHashDataStream_CryptographicOperations(ReadOnlySpan<byte> key, Stream stream, string output)
@@ -146,7 +146,7 @@ protected void VerifyHashDataStream_CryptographicOperations(ReadOnlySpan<byte> k
             int written = CryptographicOperations.HmacData(HashAlgorithm, key, stream, destination);
 
             Assert.Equal(MacSize, written);
-            AssertExtensions.SequenceEqual(expected, destination);
+            AssertExtensions.SequenceEqual(expected.AsSpan(), destination);
         }
 
         protected async Task VerifyHashDataStreamAsync(ReadOnlyMemory<byte> key, Stream stream, string output)
@@ -156,7 +156,7 @@ protected async Task VerifyHashDataStreamAsync(ReadOnlyMemory<byte> key, Stream
             int written = await HashDataOneShotAsync(key, stream, destination, cancellationToken: default);
 
             Assert.Equal(MacSize, written);
-            AssertExtensions.SequenceEqual(expected, destination.Span);
+            AssertExtensions.SequenceEqual(expected.AsSpan(), destination.Span);
         }
 
         protected async Task VerifyHashDataStreamAsync_CryptographicOperations(ReadOnlyMemory<byte> key, Stream stream, string output)
@@ -171,7 +171,7 @@ protected async Task VerifyHashDataStreamAsync_CryptographicOperations(ReadOnlyM
                 cancellationToken: default);
 
             Assert.Equal(MacSize, written);
-            AssertExtensions.SequenceEqual(expected, destination.Span);
+            AssertExtensions.SequenceEqual(expected.AsSpan(), destination.Span);
         }
 
         protected void VerifyHashDataStreamAllocating(byte[] key, Stream stream, string output, bool spanKey)
diff --git a/src/libraries/System.Security.Cryptography/tests/KmacTestDriver.cs b/src/libraries/System.Security.Cryptography/tests/KmacTestDriver.cs
index b508acacc1d6d..4d7c10b317add 100644
--- a/src/libraries/System.Security.Cryptography/tests/KmacTestDriver.cs
+++ b/src/libraries/System.Security.Cryptography/tests/KmacTestDriver.cs
@@ -500,7 +500,7 @@ public void GetHashAndReset_ResetWithEmpty()
                 mac = stackalloc byte[OutputLength];
                 TKmacTrait.AppendData(kmac, "habaneros"u8);
                 TKmacTrait.GetHashAndReset(kmac, mac);
-                AssertExtensions.SequenceEqual(expected, mac);
+                AssertExtensions.SequenceEqual(expected.AsSpan(), mac);
             }
         }
 
diff --git a/src/libraries/System.Security.Cryptography/tests/X509Certificates/ExtensionsTests/AuthorityKeyIdentifierTests.cs b/src/libraries/System.Security.Cryptography/tests/X509Certificates/ExtensionsTests/AuthorityKeyIdentifierTests.cs
index 520d52cbc8512..326491ac53b7f 100644
--- a/src/libraries/System.Security.Cryptography/tests/X509Certificates/ExtensionsTests/AuthorityKeyIdentifierTests.cs
+++ b/src/libraries/System.Security.Cryptography/tests/X509Certificates/ExtensionsTests/AuthorityKeyIdentifierTests.cs
@@ -477,7 +477,7 @@ public static void CreateFromLargeKeyIdentifier()
 
             byte[] rawData = akid.RawData;
 
-            AssertExtensions.SequenceEqual(keyId, rawData.AsSpan(6));
+            AssertExtensions.SequenceEqual(keyId.AsSpan(), rawData.AsSpan(6));
             Assert.Equal("308183808180", rawData.AsSpan(0, 6).ByteArrayToHex());
         }
 
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Document/JsonDocument.MetadataDb.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Document/JsonDocument.MetadataDb.cs
index dca61c889c89d..20cdf3775c0a4 100644
--- a/src/libraries/System.Text.Json/src/System/Text/Json/Document/JsonDocument.MetadataDb.cs
+++ b/src/libraries/System.Text.Json/src/System/Text/Json/Document/JsonDocument.MetadataDb.cs
@@ -381,7 +381,7 @@ internal MetadataDb CopySegment(int startIndex, int endIndex)
                 byte[] newDatabase = new byte[length];
                 _data.AsSpan(startIndex, length).CopyTo(newDatabase);
 
-                Span<int> newDbInts = MemoryMarshal.Cast<byte, int>(newDatabase);
+                Span<int> newDbInts = MemoryMarshal.Cast<byte, int>(newDatabase.AsSpan());
                 int locationOffset = newDbInts[0];
 
                 // Need to nudge one forward to account for the hidden quote on the string.
diff --git a/src/libraries/System.Text.Json/tests/Common/CollectionTests/CollectionTests.Memory.cs b/src/libraries/System.Text.Json/tests/Common/CollectionTests/CollectionTests.Memory.cs
index 58525300624be..b99428c39c7d6 100644
--- a/src/libraries/System.Text.Json/tests/Common/CollectionTests/CollectionTests.Memory.cs
+++ b/src/libraries/System.Text.Json/tests/Common/CollectionTests/CollectionTests.Memory.cs
@@ -34,7 +34,7 @@ public async Task SerializeReadOnlyMemoryOfTAsync()
         public async Task DeserializeMemoryOfTAsync()
         {
             Memory<int> memoryInt = await Serializer.DeserializeWrapper<Memory<int>>("[1,2,3]");
-            AssertExtensions.SequenceEqual(new int[] { 1, 2, 3 }, memoryInt.Span);
+            AssertExtensions.SequenceEqual(new int[] { 1, 2, 3 }.AsSpan(), memoryInt.Span);
 
             Memory<EmptyClass> memoryPoco = new EmptyClass[] { new(), new(), new() }.AsMemory();
             Assert.Equal(3, memoryPoco.Length);
@@ -75,7 +75,7 @@ public async Task DeserializeMemoryOfTClassAsync()
         {
             string json = @"{""Memory"":[1,2,3]}";
             MemoryOfTClass<int> memoryOfIntClass = await Serializer.DeserializeWrapper<MemoryOfTClass<int>>(json);
-            AssertExtensions.SequenceEqual(new int[] { 1, 2, 3 }, memoryOfIntClass.Memory.Span);
+            AssertExtensions.SequenceEqual(new int[] { 1, 2, 3 }.AsSpan(), memoryOfIntClass.Memory.Span);
         }
 
         [Fact]
@@ -97,7 +97,7 @@ public async Task SerializeMemoryByteAsync()
         public async Task DeserializeMemoryByteAsync()
         {
             Memory<byte> memory = await Serializer.DeserializeWrapper<Memory<byte>>("\"VGhpcyBpcyBzb21lIHRlc3QgZGF0YSEhIQ==\"");
-            AssertExtensions.SequenceEqual(s_testData, memory.Span);
+            AssertExtensions.SequenceEqual(s_testData.AsSpan(), memory.Span);
 
             ReadOnlyMemory<byte> readOnlyMemory = await Serializer.DeserializeWrapper<ReadOnlyMemory<byte>>("\"VGhpcyBpcyBzb21lIHRlc3QgZGF0YSEhIQ==\"");
             AssertExtensions.SequenceEqual(s_testData, readOnlyMemory.Span);
@@ -135,7 +135,7 @@ public async Task DeserializeMemoryByteClassAsync()
             string json = @"{""Memory"":""VGhpcyBpcyBzb21lIHRlc3QgZGF0YSEhIQ==""}";
 
             MemoryOfTClass<byte> memoryOfByteClass = await Serializer.DeserializeWrapper<MemoryOfTClass<byte>>(json);
-            AssertExtensions.SequenceEqual<byte>(s_testData, memoryOfByteClass.Memory.Span);
+            AssertExtensions.SequenceEqual<byte>(s_testData.AsSpan(), memoryOfByteClass.Memory.Span);
         }
     }
 }
diff --git a/src/libraries/System.Text.RegularExpressions/tests/FunctionalTests/UpgradeToGeneratedRegexAnalyzerTests.cs b/src/libraries/System.Text.RegularExpressions/tests/FunctionalTests/UpgradeToGeneratedRegexAnalyzerTests.cs
index feca0c535edf9..c1a704287c87b 100644
--- a/src/libraries/System.Text.RegularExpressions/tests/FunctionalTests/UpgradeToGeneratedRegexAnalyzerTests.cs
+++ b/src/libraries/System.Text.RegularExpressions/tests/FunctionalTests/UpgradeToGeneratedRegexAnalyzerTests.cs
@@ -85,9 +85,7 @@ public async Task TopLevelStatements(InvocationType invocationType)
             string test = @"using System.Text.RegularExpressions;
 var isMatch = [|" + ConstructRegexInvocation(invocationType, pattern: "\"\"") + @"|]" + isMatchInvocation + ";";
             string fixedCode = @"using System.Text.RegularExpressions;
-var isMatch = MyRegex().IsMatch("""");
-
-partial class Program
+var isMatch = MyRegex().IsMatch(""""); partial class Program
 {
     [GeneratedRegex("""")]
     private static partial Regex MyRegex();
@@ -850,9 +848,7 @@ public async Task TopLevelStatements_MultipleSourceFiles()
                 },
                 FixedState =
                 {
-                    Sources = { "public class C { }", @"var r = MyRegex();
-
-partial class Program
+                    Sources = { "public class C { }", @"var r = MyRegex(); partial class Program
 {
     [System.Text.RegularExpressions.GeneratedRegex("""")]
     private static partial System.Text.RegularExpressions.Regex MyRegex();
diff --git a/src/tools/illink/test/Mono.Linker.Tests.Cases/DataFlow/CompilerGeneratedCodeAccessedViaReflection.cs b/src/tools/illink/test/Mono.Linker.Tests.Cases/DataFlow/CompilerGeneratedCodeAccessedViaReflection.cs
index 1c83b288191d0..2ff8304984acc 100644
--- a/src/tools/illink/test/Mono.Linker.Tests.Cases/DataFlow/CompilerGeneratedCodeAccessedViaReflection.cs
+++ b/src/tools/illink/test/Mono.Linker.Tests.Cases/DataFlow/CompilerGeneratedCodeAccessedViaReflection.cs
@@ -63,6 +63,7 @@ public static IEnumerable<int> IteratorWithCorrectDataflow ()
 				t_IteratorWithCorrectDataflow.RequiresAll ();
 			}
 
+			[UnexpectedWarning ("IL2062", Tool.Trimmer | Tool.NativeAot, "https://github.com/dotnet/runtime/issues/110553", CompilerGeneratedCode = true)]
 			public static IEnumerable<int> IteratorWithIntegerDataflow ()
 			{
 				int integerLocal = 0;