Use Utf8Span for type system names (#128969)

Contributes to #122363.

This addresses two issues with the current "the exchange type for UTF-8
strings is `ReadOnlySpan<byte>`":

* Debugger now shows the strings: the `ToString` is more meaningful than
the one on `ReadOnlySpan<T>`.
* We can now use `==` to compare strings, no more
`x.SequenceEqual("y"u8)`

Migrate type system name surfaces and related callers from
`ReadOnlySpan<byte>` to `Utf8StringRef`, adding helper APIs to keep call
sites explicit and avoid unnecessary span conversions.

---------

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: MichalStrehovsky

src/coreclr/nativeaot/System.Private.TypeLoader/src/Internal/TypeSystem/RuntimeMethodDesc.cs

@@ -4,6 +4,7 @@
 
 using System;
 
+using Internal.Text;
 using Internal.Runtime.CompilerServices;
 using Internal.Runtime.TypeLoader;
 
@@ -91,7 +92,7 @@ public override MethodNameAndSignature NameAndSignature
             }
         }
 
-        public override ReadOnlySpan<byte> Name
+        public override Utf8Span Name
         {
             get
             {

src/coreclr/nativeaot/System.Private.TypeLoader/src/System.Private.TypeLoader.csproj

@@ -54,6 +54,9 @@
     <Compile Include="$(LibrariesProjectRoot)\System.Private.CoreLib\src\System\Runtime\CompilerServices\IntrinsicAttribute.cs">
       <Link>IntrinsicAttribute.cs</Link>
     </Compile>
+    <Compile Include="$(CompilerCommonPath)\Internal\Text\Utf8Span.cs">
+      <Link>Internal\Text\Utf8Span.cs</Link>
+    </Compile>
     <Compile Include="$(CompilerCommonPath)\TypeSystem\Canon\ArrayType.Canon.cs">
       <Link>Internal\TypeSystem\ArrayType.Canon.cs</Link>
     </Compile>

src/coreclr/tools/Common/Compiler/AsyncContinuationType.cs

@@ -6,6 +6,7 @@
 using System.Diagnostics;
 using System.Text;
 
+using Internal.Text;
 using Internal.TypeSystem;
 
 namespace ILCompiler
@@ -21,8 +22,8 @@ public sealed partial class AsyncContinuationType : MetadataType
         public GCPointerMap PointerMap { get; }
 
         public override DefType[] ExplicitlyImplementedInterfaces => [];
-        public override ReadOnlySpan<byte> Name => Encoding.UTF8.GetBytes(DiagnosticName);
-        public override ReadOnlySpan<byte> Namespace => [];
+        public override Utf8Span Name => Encoding.UTF8.GetBytes(DiagnosticName);
+        public override Utf8Span Namespace => Array.Empty<byte>();
 
         // We don't lay these out using MetadataType metadata.
         // Autolayout (which we'd get due to GC pointers) would likely not match what codegen expects.
@@ -49,9 +50,9 @@ public AsyncContinuationType(MetadataType continuationBaseType, GCPointerMap poi
 
         public override bool HasCustomAttribute(string attributeNamespace, string attributeName) => false;
         public override IEnumerable<MetadataType> GetNestedTypes() => [];
-        public override MetadataType GetNestedType(ReadOnlySpan<byte> name) => null;
+        public override MetadataType GetNestedType(Utf8Span name) => null;
         protected override MethodImplRecord[] ComputeVirtualMethodImplsForType() => [];
-        public override MethodImplRecord[] FindMethodsImplWithMatchingDeclName(ReadOnlySpan<byte> name) => [];
+        public override MethodImplRecord[] FindMethodsImplWithMatchingDeclName(Utf8Span name) => [];
 
         protected override int CompareToImpl(TypeDesc other, TypeSystemComparer comparer)
         {

src/coreclr/tools/Common/Compiler/Dataflow/TypeExtensions.cs

@@ -53,23 +53,5 @@ public static bool IsDeclaredOnType(this MethodDesc method, string fullTypeName)
             return method.OwningType.IsTypeOf(fullTypeName);
         }
 
-        public static bool StringEquals(this ReadOnlySpan<byte> utf8bytes, string value)
-        {
-            if (utf8bytes.Length < value.Length)
-                return false;
-
-            for (int i = 0; i < value.Length; i++)
-            {
-                int ch = utf8bytes[i];
-                if (ch > 0x7F)
-                    return System.Text.Encoding.UTF8.GetString(utf8bytes) == value;
-
-                // We are assuming here that valid UTF8 encoded byte > 0x7F cannot map to a character with code point <= 0x7F
-                if (ch != value[i])
-                    return false;
-            }
-
-            return utf8bytes.Length == value.Length; // All char ANSI, all matching
-        }
     }
 }

src/coreclr/tools/Common/Compiler/InstructionSetSupport.cs

@@ -61,7 +61,7 @@ public static string GetHardwareIntrinsicId(TargetArchitecture architecture, Typ
                 return "";
 
             // 64-bit ISA variants are not included in the mapping dictionary, so we use the containing type instead
-            if (potentialType.Name.SequenceEqual("X64"u8) || potentialType.Name.SequenceEqual("Arm64"u8))
+            if (potentialType.Name == "X64"u8 || potentialType.Name == "Arm64"u8)
             {
                 if (architecture is TargetArchitecture.X64 or TargetArchitecture.ARM64)
                     potentialType = potentialType.ContainingType;
@@ -79,12 +79,12 @@ public static string GetHardwareIntrinsicId(TargetArchitecture architecture, Typ
 
             if (architecture is TargetArchitecture.X64 or TargetArchitecture.X86)
             {
-                if (!potentialType.Namespace.SequenceEqual("System.Runtime.Intrinsics.X86"u8))
+                if (potentialType.Namespace != "System.Runtime.Intrinsics.X86"u8)
                     return "";
             }
             else if (architecture is TargetArchitecture.ARM64 or TargetArchitecture.ARM)
             {
-                if (!potentialType.Namespace.SequenceEqual("System.Runtime.Intrinsics.Arm"u8))
+                if (potentialType.Namespace != "System.Runtime.Intrinsics.Arm"u8)
                     return "";
             }
             else if (architecture is TargetArchitecture.LoongArch64)

src/coreclr/tools/Common/Compiler/Int128FieldLayoutAlgorithm.cs

@@ -84,8 +84,8 @@ public override ValueTypeShapeCharacteristics ComputeValueTypeShapeCharacteristi
         public static bool IsIntegerType(DefType type)
         {
             return type.IsIntrinsic
-                && type.Namespace.SequenceEqual("System"u8)
-                && (type.Name.SequenceEqual("Int128"u8) || type.Name.SequenceEqual("UInt128"u8));
+                && type.Namespace == "System"u8
+                && (type.Name == "Int128"u8 || type.Name == "UInt128"u8);
         }
     }
 }

src/coreclr/tools/Common/Compiler/MethodExtensions.cs

@@ -3,6 +3,7 @@
 
 using System;
 using ILCompiler.DependencyAnalysis;
+using Internal.Text;
 using Internal.TypeSystem;
 using Internal.TypeSystem.Ecma;
 
@@ -159,11 +160,11 @@ public static bool ReturnsTaskOrValueTask(this MethodSignature method)
 
             if (ret is MetadataType md
                 && md.Module == method.Context.SystemModule
-                && md.Namespace.SequenceEqual("System.Threading.Tasks"u8))
+                && md.Namespace == "System.Threading.Tasks"u8)
             {
-                ReadOnlySpan<byte> name = md.Name;
-                if (name.SequenceEqual("Task"u8) || name.SequenceEqual("Task`1"u8)
-                    || name.SequenceEqual("ValueTask"u8) || name.SequenceEqual("ValueTask`1"u8))
+                Utf8Span name = md.Name;
+                if (name == "Task"u8 || name == "Task`1"u8
+                    || name == "ValueTask"u8 || name == "ValueTask`1"u8)
                 {
                     return true;
                 }

src/coreclr/tools/Common/Compiler/NativeAotNameMangler.cs

@@ -40,8 +40,10 @@ public override Utf8String CompilationUnitPrefix
         public override Utf8String SanitizeName(Utf8String s)
             => SanitizeName(s.AsSpan());
 
-        private static Utf8String SanitizeName(ReadOnlySpan<byte> s)
+        private static Utf8String SanitizeName(Utf8Span n)
         {
+            ReadOnlySpan<byte> s = n.AsSpan();
+
             Utf8StringBuilder sb = null;
             for (int i = 0; i < s.Length; i++)
             {
@@ -98,7 +100,7 @@ private static bool ContainsUtf8ReplacementCharacter(ReadOnlySpan<byte> bytes)
             return bytes.IndexOf(replacementCharacter) >= 0;
         }
 
-        private Utf8String SanitizeNameWithHash(Utf8String literal, byte[] hash = null)
+        private static Utf8String SanitizeNameWithHash(Utf8String literal, byte[] hash = null)
         {
             Utf8String mangledName = SanitizeName(literal);
 
@@ -242,7 +244,7 @@ static void AppendTypeName(Utf8StringBuilder sb, MetadataType t)
                                 }
                                 else
                                 {
-                                    ReadOnlySpan<byte> ns = t.Namespace;
+                                    Utf8Span ns = t.Namespace;
                                     if (ns.Length > 0)
                                         sb.Append(SanitizeName(ns)).Append('_');
                                 }

src/coreclr/tools/Common/Compiler/TypeMapMetadata.cs

@@ -6,6 +6,7 @@
 using System.Diagnostics;
 using System.Reflection.Metadata;
 using ILCompiler.DependencyAnalysis;
+using Internal.Text;
 using Internal.IL;
 using Internal.IL.Stubs;
 using Internal.TypeSystem;
@@ -26,13 +27,13 @@ private enum TypeMapAttributeKind
         private static TypeMapAttributeKind LookupTypeMapType(TypeDesc attrType)
         {
             var typeDef = attrType.GetTypeDefinition() as MetadataType;
-            if (typeDef != null && typeDef.Namespace.SequenceEqual("System.Runtime.InteropServices"u8))
+            if (typeDef != null && typeDef.Namespace == "System.Runtime.InteropServices"u8)
             {
-                if (typeDef.Name.SequenceEqual("TypeMapAssemblyTargetAttribute`1"u8))
+                if (typeDef.Name == "TypeMapAssemblyTargetAttribute`1"u8)
                     return TypeMapAttributeKind.TypeMapAssemblyTarget;
-                else if (typeDef.Name.SequenceEqual("TypeMapAttribute`1"u8))
+                else if (typeDef.Name == "TypeMapAttribute`1"u8)
                     return TypeMapAttributeKind.TypeMap;
-                else if (typeDef.Name.SequenceEqual("TypeMapAssociationAttribute`1"u8))
+                else if (typeDef.Name == "TypeMapAssociationAttribute`1"u8)
                     return TypeMapAttributeKind.TypeMapAssociation;
             }
             return TypeMapAttributeKind.None;
@@ -66,7 +67,7 @@ public ThrowingMethodStub(TypeDesc owningType, TypeDesc typeMapGroup, bool exter
                 }
 
                 public TypeSystemException Exception { get; }
-                public override ReadOnlySpan<byte> Name => _name;
+                public override Utf8Span Name => _name;
                 public override MethodIL EmitIL()
                 {
 #if READYTORUN
@@ -78,7 +79,7 @@ public override MethodIL EmitIL()
 
                 protected override int CompareToImpl(MethodDesc other, TypeSystemComparer comparer)
                 {
-                    return Name.SequenceCompareTo(other.Name);
+                    return Name.AsSpan().SequenceCompareTo(other.Name.AsSpan());
                 }
 
                 public override bool IsPInvoke => false;

src/coreclr/tools/Common/Compiler/VectorFieldLayoutAlgorithm.cs

@@ -27,11 +27,11 @@ public override ComputedInstanceFieldLayout ComputeInstanceLayout(DefType defTyp
 
             LayoutInt alignment;
 
-            if (defType.Name.SequenceEqual("Vector64`1"u8))
+            if (defType.Name == "Vector64`1"u8)
             {
                 alignment = new LayoutInt(8);
             }
-            else if (defType.Name.SequenceEqual("Vector128`1"u8))
+            else if (defType.Name == "Vector128`1"u8)
             {
                 if (defType.Context.Target.Architecture == TargetArchitecture.ARM)
                 {
@@ -43,7 +43,7 @@ public override ComputedInstanceFieldLayout ComputeInstanceLayout(DefType defTyp
                     alignment = new LayoutInt(16);
                 }
             }
-            else if (defType.Name.SequenceEqual("Vector256`1"u8))
+            else if (defType.Name == "Vector256`1"u8)
             {
                 if (defType.Context.Target.Architecture == TargetArchitecture.ARM)
                 {
@@ -76,7 +76,7 @@ public override ComputedInstanceFieldLayout ComputeInstanceLayout(DefType defTyp
             }
             else
             {
-                Debug.Assert(defType.Name.SequenceEqual("Vector512`1"u8));
+                Debug.Assert(defType.Name == "Vector512`1"u8);
 
                 if (defType.Context.Target.Architecture == TargetArchitecture.ARM)
                 {
@@ -164,11 +164,11 @@ public override ValueTypeShapeCharacteristics ComputeValueTypeShapeCharacteristi
         public static bool IsVectorType(DefType type)
         {
             return type.IsIntrinsic &&
-                type.Namespace.SequenceEqual("System.Runtime.Intrinsics"u8) &&
-                (type.Name.SequenceEqual("Vector64`1"u8) ||
-                 type.Name.SequenceEqual("Vector128`1"u8) ||
-                 type.Name.SequenceEqual("Vector256`1"u8) ||
-                 type.Name.SequenceEqual("Vector512`1"u8));
+                type.Namespace == "System.Runtime.Intrinsics"u8 &&
+                (type.Name == "Vector64`1"u8 ||
+                 type.Name == "Vector128`1"u8 ||
+                 type.Name == "Vector256`1"u8 ||
+                 type.Name == "Vector512`1"u8);
         }
     }
 }