don't enforce the back tick convention

src/libraries/Common/src/System/Reflection/Metadata/TypeName.cs

@@ -3,10 +3,15 @@
 
 #nullable enable
 
+using System.Collections.Generic;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.Text;
 
+#if !SYSTEM_PRIVATE_CORELIB
+using System.Collections.Immutable;
+#endif
+
 namespace System.Reflection.Metadata
 {
     [DebuggerDisplay("{AssemblyQualifiedName}")]
@@ -28,16 +33,24 @@ sealed class TypeName : IEquatable<TypeName>
         /// So when the name is needed, a substring is being performed.
         /// </summary>
         private readonly int _nestedNameLength;
-        private readonly TypeName[]? _genericArguments;
         private readonly TypeName? _elementOrGenericType;
         private readonly TypeName? _declaringType;
+#if SYSTEM_PRIVATE_CORELIB
+        private readonly IReadOnlyList<TypeName> _genericArguments;
+#else
+        private readonly ImmutableArray<TypeName> _genericArguments;
+#endif
         private string? _name, _fullName, _assemblyQualifiedName;
 
         internal TypeName(string? fullName,
             AssemblyNameInfo? assemblyName,
             TypeName? elementOrGenericType = default,
             TypeName? declaringType = default,
-            TypeName[]? genericTypeArguments = default,
+#if SYSTEM_PRIVATE_CORELIB
+            List<TypeName>? genericTypeArguments = default,
+#else
+            ImmutableArray<TypeName>.Builder? genericTypeArguments = default,
+#endif
             sbyte rankOrModifier = default,
             int nestedNameLength = -1)
         {
@@ -46,11 +59,15 @@ internal TypeName(string? fullName,
             _rankOrModifier = rankOrModifier;
             _elementOrGenericType = elementOrGenericType;
             _declaringType = declaringType;
-            _genericArguments = genericTypeArguments;
             _nestedNameLength = nestedNameLength;
 
-            Debug.Assert(!(IsArray || IsPointer || IsByRef) || _elementOrGenericType is not null);
-            Debug.Assert(_genericArguments is null || _elementOrGenericType is not null);
+#if SYSTEM_PRIVATE_CORELIB
+            _genericArguments = genericTypeArguments is not null ? genericTypeArguments : Array.Empty<TypeName>();
+#else
+            _genericArguments = genericTypeArguments is null
+                ? ImmutableArray<TypeName>.Empty
+                : genericTypeArguments.Count == genericTypeArguments.Capacity ? genericTypeArguments.MoveToImmutable() : genericTypeArguments.ToImmutableArray();
+#endif
         }
 
         /// <summary>
@@ -100,7 +117,7 @@ public string FullName
             {
                 if (_fullName is null)
                 {
-                    if (_genericArguments is not null)
+                    if (IsConstructedGenericType)
                     {
                         _fullName = TypeNameParserHelpers.GetGenericTypeFullName(GetGenericTypeDefinition().FullName.AsSpan(), _genericArguments);
                     }
@@ -138,7 +155,12 @@ public string FullName
         /// <remarks>
         /// Returns false for open generic types (e.g., "Dictionary&lt;,&gt;").
         /// </remarks>
-        public bool IsConstructedGenericType => _genericArguments is not null;
+        public bool IsConstructedGenericType =>
+#if SYSTEM_PRIVATE_CORELIB
+            _genericArguments.Count > 0;
+#else
+            _genericArguments.Length > 0;
+#endif
 
         /// <summary>
         /// Returns true if this is a "plain" type; that is, not an array, not a pointer, not a reference, and
@@ -274,12 +296,9 @@ public int GetNodeCount()
                 result = checked(result + GetElementType().GetNodeCount());
             }
 
-            if (_genericArguments is not null)
+            foreach (TypeName genericArgument in _genericArguments)
             {
-                foreach (TypeName genericArgument in _genericArguments)
-                {
-                    result = checked(result + genericArgument.GetNodeCount());
-                }
+                result = checked(result + genericArgument.GetNodeCount());
             }
 
             return result;
@@ -358,16 +377,12 @@ public int GetArrayRank()
         /// <para>For example, given "Dictionary&lt;string, int&gt;", returns a 2-element array containing
         /// string and int.</para>
         /// </remarks>
+        public
 #if SYSTEM_PRIVATE_CORELIB
-        public TypeName[] GetGenericArguments() => _genericArguments ?? Array.Empty<TypeName>();
+        IReadOnlyList<TypeName>
 #else
-        public Collections.Immutable.ImmutableArray<TypeName> GetGenericArguments()
-            => _genericArguments is null ? Collections.Immutable.ImmutableArray<TypeName>.Empty :
-    #if NET8_0_OR_GREATER
-            Runtime.InteropServices.ImmutableCollectionsMarshal.AsImmutableArray(_genericArguments);
-    #else
-            Collections.Immutable.ImmutableArray.Create(_genericArguments);
-    #endif
+        ImmutableArray<TypeName>
 #endif
+        GetGenericArguments() => _genericArguments;
     }
 }

src/libraries/Common/src/System/Reflection/Metadata/TypeNameParser.cs

@@ -5,6 +5,10 @@
 using System.Diagnostics;
 using System.Text;
 
+#if !SYSTEM_PRIVATE_CORELIB
+using System.Collections.Immutable;
+#endif
+
 using static System.Reflection.Metadata.TypeNameParserHelpers;
 
 #nullable enable
@@ -66,17 +70,20 @@ private TypeNameParser(ReadOnlySpan<char> name, bool throwOnError, TypeNameParse
             }
 
             List<int>? nestedNameLengths = null;
-            if (!TryGetTypeNameInfo(ref _inputString, ref nestedNameLengths, out int fullTypeNameLength, out int genericArgCount))
+            if (!TryGetTypeNameInfo(ref _inputString, ref nestedNameLengths, out int fullTypeNameLength))
             {
                 return null;
             }
 
             ReadOnlySpan<char> fullTypeName = _inputString.Slice(0, fullTypeNameLength);
             _inputString = _inputString.Slice(fullTypeNameLength);
 
-            int genericArgIndex = 0;
-            // Don't allocate now, as it may be an open generic type like "List`1"
-            TypeName[]? genericArgs = null;
+            // Don't allocate now, as it may be an open generic type like "Name`1"
+#if SYSTEM_PRIVATE_CORELIB
+            List<TypeName>? genericArgs = null;
+#else
+            ImmutableArray<TypeName>.Builder? genericArgs = null;
+#endif
 
             // Are there any captured generic args? We'll look for "[[" and "[".
             // There are no spaces allowed before the first '[', but spaces are allowed
@@ -85,36 +92,18 @@ private TypeNameParser(ReadOnlySpan<char> name, bool throwOnError, TypeNameParse
             ReadOnlySpan<char> capturedBeforeProcessing = _inputString;
             if (IsBeginningOfGenericArgs(ref _inputString, out bool doubleBrackets))
             {
-                int startingRecursionCheck = recursiveDepth;
-                int maxObservedRecursionCheck = recursiveDepth;
-
             ParseAnotherGenericArg:
 
-                // Invalid generic argument count provided after backtick.
-                // Examples:
-                // - too many: List`1[[a], [b]]
-                // - not expected: NoBacktick[[a]]
-                if (genericArgIndex >= genericArgCount)
-                {
-                    return null;
-                }
-
-                recursiveDepth = startingRecursionCheck;
-                // Namespace.Type`1[[GenericArgument1, AssemblyName1],[GenericArgument2, AssemblyName2]] - double square bracket syntax allows for fully qualified type names
-                // Namespace.Type`1[GenericArgument1,GenericArgument2] - single square bracket syntax is legal only for non-fully qualified type names
-                // Namespace.Type`1[[GenericArgument1, AssemblyName1], GenericArgument2] - mixed mode
-                // Namespace.Type`1[GenericArgument1, [GenericArgument2, AssemblyName2]] - mixed mode
+                // Namespace.Type`2[[GenericArgument1, AssemblyName1],[GenericArgument2, AssemblyName2]] - double square bracket syntax allows for fully qualified type names
+                // Namespace.Type`2[GenericArgument1,GenericArgument2] - single square bracket syntax is legal only for non-fully qualified type names
+                // Namespace.Type`2[[GenericArgument1, AssemblyName1], GenericArgument2] - mixed mode
+                // Namespace.Type`2[GenericArgument1, [GenericArgument2, AssemblyName2]] - mixed mode
                 TypeName? genericArg = ParseNextTypeName(allowFullyQualifiedName: doubleBrackets, ref recursiveDepth);
                 if (genericArg is null) // parsing failed
                 {
                     return null;
                 }
 
-                if (recursiveDepth > maxObservedRecursionCheck)
-                {
-                    maxObservedRecursionCheck = recursiveDepth;
-                }
-
                 // For [[, there had better be a ']' after the type name.
                 if (doubleBrackets && !TryStripFirstCharAndTrailingSpaces(ref _inputString, ']'))
                 {
@@ -123,17 +112,13 @@ private TypeNameParser(ReadOnlySpan<char> name, bool throwOnError, TypeNameParse
 
                 if (genericArgs is null)
                 {
-                    // Parsing the rest would hit the limit.
-                    // -1 because the first generic arg has been already parsed.
-                    if (maxObservedRecursionCheck + genericArgCount - 1 > _parseOptions.MaxNodes)
-                    {
-                        recursiveDepth = _parseOptions.MaxNodes;
-                        return null;
-                    }
-
-                    genericArgs = new TypeName[genericArgCount];
+#if SYSTEM_PRIVATE_CORELIB
+                    genericArgs = new List<TypeName>(2);
+#else
+                    genericArgs = ImmutableArray.CreateBuilder<TypeName>(2);
+#endif
                 }
-                genericArgs[genericArgIndex++] = genericArg;
+                genericArgs.Add(genericArg);
 
                 // Is there a ',[' indicating fully qualified generic type arg?
                 // Is there a ',' indicating non-fully qualified generic type arg?
@@ -150,16 +135,6 @@ private TypeNameParser(ReadOnlySpan<char> name, bool throwOnError, TypeNameParse
                 {
                     return null;
                 }
-
-                // We have reached the end of generic arguments, but parsed fewer than expected.
-                // Example: A`2[[b]]
-                if (genericArgIndex != genericArgCount)
-                {
-                    return null;
-                }
-
-                // And now that we're at the end, restore the max observed recursion count.
-                recursiveDepth = maxObservedRecursionCheck;
             }
 
             // If there was an error stripping the generic args, back up to

src/libraries/Common/src/System/Reflection/Metadata/TypeNameParserHelpers.cs

@@ -24,54 +24,7 @@ internal static class TypeNameParserHelpers
         private static readonly SearchValues<char> _endOfFullTypeNameDelimitersSearchValues = SearchValues.Create("[]&*,+\\");
 #endif
 
-        /// <returns>
-        /// <para>Negative value for invalid type names.</para>
-        /// <para>Zero for valid non-generic type names.</para>
-        /// <para>Positive value for valid generic type names.</para>
-        /// </returns>
-        internal static int GetGenericArgumentCount(ReadOnlySpan<char> fullTypeName)
-        {
-            const int ShortestInvalidTypeName = 2; // Back tick and one digit. Example: "`1"
-            if (fullTypeName.Length < ShortestInvalidTypeName || !IsAsciiDigit(fullTypeName[fullTypeName.Length - 1]))
-            {
-                return 0;
-            }
-
-            int backtickIndex = fullTypeName.Length - 2; // we already know it's true for the last one
-            for (; backtickIndex >= 0; backtickIndex--)
-            {
-                if (fullTypeName[backtickIndex] == '`')
-                {
-                    if (backtickIndex == 0)
-                    {
-                        return -1; // illegal name, example "`1"
-                    }
-                    else if (fullTypeName[backtickIndex - 1] == EscapeCharacter)
-                    {
-                        return 0; // legal name, but not a generic type definition. Example: "Escaped\\`1"
-                    }
-                    else if (TryParse(fullTypeName.Slice(backtickIndex + 1), out int value))
-                    {
-                        // From C# 2.0 language spec: 8.16.3 Multiple type parameters Generic type declarations can have any number of type parameters.
-                        // There is no special treatment for values larger than Array.MaxLength,
-                        // as the parser should simply prevent from parsing that many nodes.
-                        // The value can still be negative, but it's fine as the caller should treat that as an error.
-                        return value;
-                    }
-
-                    // most likely the value was too large to be parsed as an int
-                    return -1;
-                }
-                else if (!IsAsciiDigit(fullTypeName[backtickIndex]) && fullTypeName[backtickIndex] != '-')
-                {
-                    break;
-                }
-            }
-
-            return 0;
-        }
-
-        internal static string GetGenericTypeFullName(ReadOnlySpan<char> fullTypeName, TypeName[] genericArgs)
+        internal static string GetGenericTypeFullName(ReadOnlySpan<char> fullTypeName, IReadOnlyList<TypeName> genericArgs)
         {
             ValueStringBuilder result = new(stackalloc char[128]);
             result.Append(fullTypeName);
@@ -239,12 +192,10 @@ internal static bool IsBeginningOfGenericArgs(ref ReadOnlySpan<char> span, out b
             return false;
         }
 
-        internal static bool TryGetTypeNameInfo(ref ReadOnlySpan<char> input, ref List<int>? nestedNameLengths,
-            out int totalLength, out int genericArgCount)
+        internal static bool TryGetTypeNameInfo(ref ReadOnlySpan<char> input, ref List<int>? nestedNameLengths, out int totalLength)
         {
             bool isNestedType;
             totalLength = 0;
-            genericArgCount = 0;
             do
             {
                 int length = GetFullTypeNameLength(input.Slice(totalLength), out isNestedType);
@@ -267,14 +218,6 @@ internal static bool TryGetTypeNameInfo(ref ReadOnlySpan<char> input, ref List<i
                     length--;
                 }
 #endif
-
-                int generics = GetGenericArgumentCount(input.Slice(totalLength, length));
-                if (generics < 0 || (generics > 0 && ((long)genericArgCount + generics > int.MaxValue)))
-                {
-                    return false; // invalid type name detected!
-                }
-                genericArgCount += generics;
-
                 if (isNestedType)
                 {
                     // do not validate the type name now, it will be validated as a whole nested type name later

src/libraries/Common/src/System/Reflection/TypeNameParser.Helpers.cs

@@ -160,8 +160,13 @@ private static (string typeNamespace, string name) SplitFullTypeName(string type
             else if (typeName.IsConstructedGenericType)
             {
                 var genericArgs = typeName.GetGenericArguments();
-                Type[] genericTypes = new Type[genericArgs.Length];
-                for (int i = 0; i < genericArgs.Length; i++)
+#if SYSTEM_PRIVATE_CORELIB
+                int size = genericArgs.Count;
+#else
+                int size = genericArgs.Length;
+#endif
+                Type[] genericTypes = new Type[size];
+                for (int i = 0; i < size; i++)
                 {
                     Type? genericArg = Resolve(genericArgs[i]);
                     if (genericArg is null)

src/libraries/System.Reflection.Metadata/ref/System.Reflection.Metadata.cs

@@ -2429,7 +2429,7 @@ public sealed partial class TypeName : System.IEquatable<System.Reflection.Metad
     {
         internal TypeName() { }
         public string AssemblyQualifiedName { get { throw null; } }
-        public string? AssemblySimpleName { get { throw null; } }
+        public AssemblyNameInfo? AssemblyName { get { throw null; } }
         public System.Reflection.Metadata.TypeName? DeclaringType { get { throw null; } }
         public string FullName { get { throw null; } }
         public bool IsArray { get { throw null; } }
@@ -2447,7 +2447,6 @@ internal TypeName() { }
         public bool Equals(System.Reflection.Metadata.TypeName? other) { throw null; }
         public override int GetHashCode() { throw null; }
         public int GetArrayRank() { throw null; }
-        public System.Reflection.AssemblyName? GetAssemblyName() { throw null; }
         public System.Collections.Immutable.ImmutableArray<System.Reflection.Metadata.TypeName> GetGenericArguments() { throw null; }
         public System.Reflection.Metadata.TypeName GetGenericTypeDefinition() { throw null; }
         public System.Reflection.Metadata.TypeName GetElementType() { throw null; }