Use Utf8Span for type system names

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;
 
@@ -142,11 +143,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);
         }
     }
 }

src/coreclr/tools/Common/Internal/Runtime/EETypeBuilderHelpers.cs

@@ -187,8 +187,8 @@ public static ushort ComputeFlagsEx(TypeDesc type)
 
             if (type is MetadataType mdType &&
                             mdType.Module == mdType.Context.SystemModule &&
-                            (mdType.Name.SequenceEqual("WeakReference"u8) || mdType.Name.SequenceEqual("WeakReference`1"u8)) &&
-                            mdType.Namespace.SequenceEqual("System"u8))
+                            (mdType.Name == "WeakReference"u8 || mdType.Name == "WeakReference`1"u8) &&
+                            mdType.Namespace == "System"u8)
             {
                 flagsEx |= (ushort)EETypeFlagsEx.HasEagerFinalizerFlag;
             }
@@ -273,8 +273,8 @@ private static bool HasCriticalFinalizer(TypeDesc type)
 
                 if (type is MetadataType mdType &&
                             mdType.Module == mdType.Context.SystemModule &&
-                            mdType.Name.SequenceEqual("CriticalFinalizerObject"u8) &&
-                            mdType.Namespace.SequenceEqual("System.Runtime.ConstrainedExecution"u8))
+                            mdType.Name == "CriticalFinalizerObject"u8 &&
+                            mdType.Namespace == "System.Runtime.ConstrainedExecution"u8)
                     return true;
 
                 type = type.BaseType;

src/coreclr/tools/Common/Internal/Text/Utf8Span.cs

@@ -0,0 +1,69 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Numerics;
+using System.Text;
+
+namespace Internal.Text
+{
+    public readonly ref struct Utf8Span
+    {
+        private readonly ReadOnlySpan<byte> _value;
+
+        public Utf8Span(ReadOnlySpan<byte> value) => _value = value;
+
+        public int Length => _value.Length;
+
+        public bool IsEmpty => _value.IsEmpty;
+
+        public ReadOnlySpan<byte> AsSpan() => _value;
+
+        public byte[] ToArray() => _value.ToArray();
+
+        public bool StartsWith(Utf8Span value) => _value.StartsWith(value.AsSpan());
+
+        public bool EndsWith(Utf8Span value) => _value.EndsWith(value.AsSpan());
+
+        // This is deliberately not a == operator because we don't want to make it easy
+        // to accidentally do UTF-8 vs UTF-16 string comparisons.
+        public bool StringEquals(string value)
+        {
+            if (_value.Length < value.Length)
+                return false;
+
+            for (int i = 0; i < value.Length; i++)
+            {
+                int ch = _value[i];
+                if (ch > 0x7F)
+                    return Encoding.UTF8.GetString(_value) == 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 _value.Length == value.Length; // All char ANSI, all matching
+        }
+
+        public override bool Equals(object obj) => false;
+
+        public override int GetHashCode()
+        {
+            HashCode h = default;
+            h.AddBytes(_value);
+            return h.ToHashCode();
+        }
+
+        public override string ToString() => Encoding.UTF8.GetString(_value);
+
+        public static implicit operator Utf8Span(ReadOnlySpan<byte> s) => new Utf8Span(s);
+
+        public static bool operator ==(Utf8Span left, Utf8Span right)
+            => left._value.SequenceEqual(right._value);
+
+        public static bool operator !=(Utf8Span left, Utf8Span right)
+            => !left._value.SequenceEqual(right._value);
+    }
+}

src/coreclr/tools/Common/Internal/Text/Utf8String.cs

@@ -29,6 +29,8 @@ public Utf8String(string s)
             _value = Encoding.UTF8.GetBytes(s);
         }
 
+        public static implicit operator Utf8Span(Utf8String s) => s._value;
+
         public int Length => _value.Length;
 
         public ReadOnlySpan<byte> AsSpan() => _value;

src/coreclr/tools/Common/Internal/Text/Utf8StringBuilder.cs

@@ -43,6 +43,11 @@ public Utf8StringBuilder Append(Utf8String value)
             return Append(value.AsSpan());
         }
 
+        public Utf8StringBuilder Append(Utf8Span value)
+        {
+            return Append(value.AsSpan());
+        }
+
         public Utf8StringBuilder Append(ReadOnlySpan<byte> value)
         {
             Ensure(value.Length);