Use it in System.Collections.Immutable's KeyAnalyzer

Author: MihaZupan

src/libraries/Common/src/System/Text/AsciiPolyfills.cs

@@ -1,6 +1,8 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Runtime.CompilerServices;
+
 namespace System.Text
 {
     /// <summary>Provides downlevel polyfills for Ascii helper APIs.</summary>
@@ -11,17 +13,39 @@ public static bool IsValid(string value)
             return IsValid(value.AsSpan());
         }
 
-        public static bool IsValid(ReadOnlySpan<char> value)
+        public static unsafe bool IsValid(ReadOnlySpan<char> value)
         {
-            foreach (char c in value)
+            fixed (char* src = value)
             {
-                if (c > 127)
+                uint* ptrUInt32 = (uint*)src;
+                int length = value.Length;
+
+                while (length >= 4)
                 {
-                    return false;
+                    if (!AllCharsInUInt32AreAscii(ptrUInt32[0] | ptrUInt32[1]))
+                    {
+                        return false;
+                    }
+
+                    ptrUInt32 += 2;
+                    length -= 4;
+                }
+
+                char* ptrChar = (char*)ptrUInt32;
+                while (length-- > 0)
+                {
+                    char ch = *ptrChar++;
+                    if (ch >= 0x80)
+                    {
+                        return false;
+                    }
                 }
             }
 
             return true;
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            static bool AllCharsInUInt32AreAscii(uint value) => (value & ~0x007F_007Fu) == 0;
         }
     }
 }

src/libraries/System.Collections.Immutable/src/System.Collections.Immutable.csproj

@@ -8,6 +8,7 @@
     <PackageDescription>This package provides collections that are thread safe and guaranteed to never change their contents, also known as immutable collections. Like strings, any methods that perform modifications will not change the existing instance but instead return a new instance. For efficiency reasons, the implementation uses a sharing mechanism to ensure that newly created instances share as much data as possible with the previous instance while ensuring that operations have a predictable time complexity.
 
 The System.Collections.Immutable library is built-in as part of the shared framework in .NET Runtime. The package can be installed when you need to use it in other target frameworks.</PackageDescription>
+    <IncludeSpanPolyfills>true</IncludeSpanPolyfills>
   </PropertyGroup>
 
   <ItemGroup>

src/libraries/System.Collections.Immutable/src/System/Collections/Frozen/String/Hashing.cs

@@ -5,6 +5,7 @@
 using System.Diagnostics;
 using System.Numerics;
 using System.Runtime.InteropServices;
+using System.Text;
 
 namespace System.Collections.Frozen
 {
@@ -77,7 +78,7 @@ public static unsafe int GetHashCodeOrdinal(ReadOnlySpan<char> s)
         // useful if the string only contains ASCII characters
         public static unsafe int GetHashCodeOrdinalIgnoreCaseAscii(ReadOnlySpan<char> s)
         {
-            Debug.Assert(KeyAnalyzer.IsAllAscii(s));
+            Debug.Assert(Ascii.IsValid(s));
 
             // We "normalize to lowercase" every char by ORing with 0x20. This casts
             // a very wide net because it will change, e.g., '^' to '~'. But that should

src/libraries/System.Collections.Immutable/src/System/Collections/Frozen/String/KeyAnalyzer.cs

@@ -4,9 +4,7 @@
 using System.Buffers;
 using System.Collections.Generic;
 using System.Diagnostics;
-#if !NET
-using System.Runtime.CompilerServices;
-#endif
+using System.Text;
 
 namespace System.Collections.Frozen
 {
@@ -145,7 +143,7 @@ private static AnalysisResults CreateAnalysisResults(
                     // Get a span representing the slice of the uniqueString which will be hashed.
                     // If the slice isn't ASCII, bail out to return the results.
                     if (!allUniqueStringsAreConfirmedAscii &&
-                        !IsAllAscii(getHashString(uniqueString, index, count)))
+                        !Ascii.IsValid(getHashString(uniqueString, index, count)))
                     {
                         allAsciiIfIgnoreCase = false;
                         canSwitchIgnoreCaseHashToCaseSensitive = false;
@@ -161,7 +159,7 @@ private static AnalysisResults CreateAnalysisResults(
                         // and as we have just checked that IsAllAscii(hashString) is true
                         // then we know IsAllAscii(uniqueString) must be true,
                         // so we can skip the check.
-                        if ((count > 0 && !allUniqueStringsAreConfirmedAscii && !IsAllAscii(uniqueString.AsSpan())) ||
+                        if ((count > 0 && !allUniqueStringsAreConfirmedAscii && !Ascii.IsValid(uniqueString)) ||
                             ContainsAnyAsciiLetters(uniqueString.AsSpan()))
                         {
                             canSwitchIgnoreCaseHashToCaseSensitive = false;
@@ -190,7 +188,7 @@ private static bool AreAllAscii(ReadOnlySpan<string> strings)
         {
             foreach (string s in strings)
             {
-                if (!IsAllAscii(s.AsSpan()))
+                if (!Ascii.IsValid(s))
                 {
                     return false;
                 }
@@ -199,65 +197,13 @@ private static bool AreAllAscii(ReadOnlySpan<string> strings)
             return true;
         }
 
-        internal static unsafe bool IsAllAscii(ReadOnlySpan<char> s)
-        {
-#if NET
-            return System.Text.Ascii.IsValid(s);
-#else
-            fixed (char* src = s)
-            {
-                uint* ptrUInt32 = (uint*)src;
-                int length = s.Length;
-
-                while (length >= 4)
-                {
-                    if (!AllCharsInUInt32AreAscii(ptrUInt32[0] | ptrUInt32[1]))
-                    {
-                        return false;
-                    }
-
-                    ptrUInt32 += 2;
-                    length -= 4;
-                }
-
-                char* ptrChar = (char*)ptrUInt32;
-                while (length-- > 0)
-                {
-                    char ch = *ptrChar++;
-                    if (ch >= 0x80)
-                    {
-                        return false;
-                    }
-                }
-            }
-
-            return true;
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            static bool AllCharsInUInt32AreAscii(uint value) => (value & ~0x007F_007Fu) == 0;
-#endif
-        }
-
-#if NET
         private static readonly SearchValues<char> s_asciiLetters = SearchValues.Create("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz");
-#endif
+
         internal static bool ContainsAnyAsciiLetters(ReadOnlySpan<char> s)
         {
-            Debug.Assert(IsAllAscii(s));
+            Debug.Assert(Ascii.IsValid(s));
 
-#if NET
             return s.ContainsAny(s_asciiLetters);
-#else
-            foreach (char c in s)
-            {
-                Debug.Assert(c <= 0x7f);
-                if ((uint)((c | 0x20) - 'a') <= (uint)('z' - 'a'))
-                {
-                    return true;
-                }
-            }
-            return false;
-#endif
         }
 
         internal static bool HasSufficientUniquenessFactor(HashSet<string> set, ReadOnlySpan<string> uniqueStrings, int acceptableNonUniqueCount)

src/libraries/System.Collections.Immutable/tests/Frozen/KeyAnalyzerTests.cs

@@ -221,14 +221,6 @@ public static void FullCaseInsensitiveAscii()
             Assert.True(r.AllAsciiIfIgnoreCase);
         }
 
-        [Fact]
-        public static void IsAllAscii()
-        {
-            Assert.True(KeyAnalyzer.IsAllAscii("abc".AsSpan()));
-            Assert.True(KeyAnalyzer.IsAllAscii("abcdefghij".AsSpan()));
-            Assert.False(KeyAnalyzer.IsAllAscii("abcdéfghij".AsSpan()));
-        }
-
         [Fact]
         public static void ContainsAnyLetters()
         {

src/libraries/System.Collections.Immutable/tests/System.Collections.Immutable.Tests.csproj

@@ -8,6 +8,7 @@
     <!-- This test library intentionally references an inbox P2P as it needs the implementation, instead of the contract.
          Suppress the NU1511 warning in the whole project as putting it on a P2P doesn't work: https://github.com/NuGet/Home/issues/14121 -->
     <NoWarn>$(NoWarn);NU1511</NoWarn>
+    <IncludeSpanPolyfills>true</IncludeSpanPolyfills>
   </PropertyGroup>
 
   <ItemGroup>