Remove obsolete code

src/Directory.Build.props

@@ -21,6 +21,10 @@
     <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
   </PropertyGroup>
 
+  <PropertyGroup>
+    <CodeAnalysisRuleSet>..\ImageSharp.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+
   <ItemGroup>
     <!-- DynamicProxyGenAssembly2 is needed so Moq can use our internals -->
     <InternalsVisibleTo Include="DynamicProxyGenAssembly2" Key="0024000004800000940000000602000000240000525341310004000001000100c547cac37abd99c8db225ef2f6c8a3602f3b3606cc9891605d02baa56104f4cfc0734aa39b93bf7852f7d9266654753cc297e7d2edfe0bac1cdcf9f717241550e0a7b191195b7667bb4f64bcb8e2121380fd1d9d46ad2d92d2d15605093924cceaf74c4861eff62abf69b9291ed0a340e113be11e6a7d3113e92484cf7045cc7" />

src/ImageSharp.ruleset

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8"?>
+<RuleSet Name="ImageSharp" ToolsVersion="17.0">
+  <Include Path="..\shared-infrastructure\sixlabors.ruleset" Action="Default" />
+  <Rules AnalyzerId="StyleCop.Analyzers" RuleNamespace="StyleCop.Analyzers">
+    <Rule Id="SA1011" Action="None" />
+  </Rules>
+</RuleSet>

src/ImageSharp/ColorSpaces/Companding/SRgbCompanding.cs

@@ -5,10 +5,8 @@
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
-#if SUPPORTS_RUNTIME_INTRINSICS
 using System.Runtime.Intrinsics;
 using System.Runtime.Intrinsics.X86;
-#endif
 
 namespace SixLabors.ImageSharp.ColorSpaces.Companding
 {
@@ -25,10 +23,10 @@ public static class SRgbCompanding
         private const int Length = Scale + 2; // 256kb @ 16bit precision.
         private const int Scale = (1 << 16) - 1;
 
-        private static readonly Lazy<float[]> LazyCompressTable = new Lazy<float[]>(
+        private static readonly Lazy<float[]> LazyCompressTable = new(
             () =>
             {
-                var result = new float[Length];
+                float[] result = new float[Length];
 
                 for (int i = 0; i < result.Length; i++)
                 {
@@ -49,10 +47,10 @@ public static class SRgbCompanding
             },
             true);
 
-        private static readonly Lazy<float[]> LazyExpandTable = new Lazy<float[]>(
+        private static readonly Lazy<float[]> LazyExpandTable = new(
             () =>
             {
-                var result = new float[Length];
+                float[] result = new float[Length];
 
                 for (int i = 0; i < result.Length; i++)
                 {
@@ -84,19 +82,17 @@ public static class SRgbCompanding
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static void Expand(Span<Vector4> vectors)
         {
-#if SUPPORTS_RUNTIME_INTRINSICS
             if (Avx2.IsSupported && vectors.Length >= 2)
             {
                 CompandAvx2(vectors, ExpandTable);
 
                 if (Numerics.Modulo2(vectors.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    Expand(ref MemoryMarshal.GetReference(vectors.Slice(vectors.Length - 1)));
+                    Expand(ref MemoryMarshal.GetReference(vectors[^1..]));
                 }
             }
             else
-#endif
             {
                 CompandScalar(vectors, ExpandTable);
             }
@@ -109,19 +105,17 @@ public static void Expand(Span<Vector4> vectors)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static unsafe void Compress(Span<Vector4> vectors)
         {
-#if SUPPORTS_RUNTIME_INTRINSICS
             if (Avx2.IsSupported && vectors.Length >= 2)
             {
                 CompandAvx2(vectors, CompressTable);
 
                 if (Numerics.Modulo2(vectors.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    Compress(ref MemoryMarshal.GetReference(vectors.Slice(vectors.Length - 1)));
+                    Compress(ref MemoryMarshal.GetReference(vectors[^1..]));
                 }
             }
             else
-#endif
             {
                 CompandScalar(vectors, CompressTable);
             }
@@ -171,8 +165,6 @@ public static float Expand(float channel)
         public static float Compress(float channel)
             => channel <= 0.0031308F ? 12.92F * channel : (1.055F * MathF.Pow(channel, 0.416666666666667F)) - 0.055F;
 
-#if SUPPORTS_RUNTIME_INTRINSICS
-
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private static unsafe void CompandAvx2(Span<Vector4> vectors, float[] table)
         {
@@ -204,7 +196,6 @@ private static unsafe void CompandAvx2(Span<Vector4> vectors, float[] table)
                 }
             }
         }
-#endif
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private static unsafe void CompandScalar(Span<Vector4> vectors, float[] table)

src/ImageSharp/ColorSpaces/Conversion/Implementation/VonKriesChromaticAdaptation.cs

@@ -75,7 +75,7 @@ public void Transform(
 
             if (sourceWhitePoint.Equals(destinationWhitePoint))
             {
-                source.CopyTo(destination.Slice(0, count));
+                source.CopyTo(destination[..count]);
                 return;
             }
 

src/ImageSharp/Common/Extensions/StreamExtensions.cs

@@ -70,51 +70,5 @@ public static void Skip(this Stream stream, int count)
                 ArrayPool<byte>.Shared.Return(buffer);
             }
         }
-
-#if !SUPPORTS_SPAN_STREAM
-        // This is a port of the CoreFX implementation and is MIT Licensed:
-        // https://github.com/dotnet/corefx/blob/17300169760c61a90cab8d913636c1058a30a8c1/src/Common/src/CoreLib/System/IO/Stream.cs#L742
-        public static int Read(this Stream stream, Span<byte> buffer)
-        {
-            // This uses ArrayPool<byte>.Shared, rather than taking a MemoryAllocator,
-            // in order to match the signature of the framework method that exists in
-            // .NET Core.
-            byte[] sharedBuffer = ArrayPool<byte>.Shared.Rent(buffer.Length);
-            try
-            {
-                int numRead = stream.Read(sharedBuffer, 0, buffer.Length);
-                if ((uint)numRead > (uint)buffer.Length)
-                {
-                    throw new IOException("Stream was too long.");
-                }
-
-                new Span<byte>(sharedBuffer, 0, numRead).CopyTo(buffer);
-                return numRead;
-            }
-            finally
-            {
-                ArrayPool<byte>.Shared.Return(sharedBuffer);
-            }
-        }
-
-        // This is a port of the CoreFX implementation and is MIT Licensed:
-        // https://github.com/dotnet/corefx/blob/17300169760c61a90cab8d913636c1058a30a8c1/src/Common/src/CoreLib/System/IO/Stream.cs#L775
-        public static void Write(this Stream stream, ReadOnlySpan<byte> buffer)
-        {
-            // This uses ArrayPool<byte>.Shared, rather than taking a MemoryAllocator,
-            // in order to match the signature of the framework method that exists in
-            // .NET Core.
-            byte[] sharedBuffer = ArrayPool<byte>.Shared.Rent(buffer.Length);
-            try
-            {
-                buffer.CopyTo(sharedBuffer);
-                stream.Write(sharedBuffer, 0, buffer.Length);
-            }
-            finally
-            {
-                ArrayPool<byte>.Shared.Return(sharedBuffer);
-            }
-        }
-#endif
     }
 }

src/ImageSharp/Common/Helpers/HexConverter.cs

@@ -30,7 +30,7 @@ public static int HexStringToBytes(ReadOnlySpan<char> chars, Span<byte> bytes)
             {
                 // Slightly better performance in the loop below, allows us to skip a bounds check
                 // while still supporting output buffers that are larger than necessary
-                bytes = bytes.Slice(0, chars.Length / 2);
+                bytes = bytes[..(chars.Length / 2)];
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]

src/ImageSharp/Common/Helpers/InliningOptions.cs

@@ -18,13 +18,11 @@ internal static class InliningOptions
         public const MethodImplOptions AlwaysInline = MethodImplOptions.AggressiveInlining;
 #if PROFILING
         public const MethodImplOptions HotPath = MethodImplOptions.NoInlining;
+
         public const MethodImplOptions ShortMethod = MethodImplOptions.NoInlining;
 #else
-#if SUPPORTS_HOTPATH
         public const MethodImplOptions HotPath = MethodImplOptions.AggressiveOptimization;
-#else
-        public const MethodImplOptions HotPath = MethodImplOptions.AggressiveInlining;
-#endif
+
         public const MethodImplOptions ShortMethod = MethodImplOptions.AggressiveInlining;
 #endif
         public const MethodImplOptions ColdPath = MethodImplOptions.NoInlining;