[MONO] Partially revert "Add TypeName APIs to simplify metadata lookup" (#118761)

jkotas · web-flow · commit d1691e1cc3b4 · 2025-08-15T12:14:26.000-07:00
Mono specific changes in #111598 regressed Mono runtime performance significantly. Reverting the changes for now. Fixes #112763
diff --git a/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/Type/TypeTests.cs b/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/Type/TypeTests.cs
@@ -509,6 +509,29 @@ public void GetTypeByName_ValidType_ReturnsExpected(string typeName, Type expect
             Assert.Equal(expectedType, Type.GetType(typeName.ToLower(), throwOnError: false, ignoreCase: true));
         }
 
+        public static IEnumerable<object[]> GetTypeByName_InvalidElementType()
+        {
+            Type expectedException = PlatformDetection.IsMonoRuntime
+                ? typeof(ArgumentException) // https://github.com/dotnet/runtime/issues/45033
+                : typeof(TypeLoadException);
+
+            yield return new object[] { "System.Int32&&", expectedException, true };
+            yield return new object[] { "System.Int32&*", expectedException, true };
+            yield return new object[] { "System.Int32&[]", expectedException, true };
+            yield return new object[] { "System.Int32&[*]", expectedException, true };
+            yield return new object[] { "System.Int32&[,]", expectedException, true };
+
+            // https://github.com/dotnet/runtime/issues/45033
+            if (!PlatformDetection.IsMonoRuntime)
+            {
+                yield return new object[] { "..Outside`1", expectedException, false };
+                yield return new object[] { ".Outside`1+.Inside`1", expectedException, false };
+
+                yield return new object[] { "System.Void[]", expectedException, true };
+                yield return new object[] { "System.TypedReference[]", expectedException, true };
+            }
+        }
+
         [Theory]
         [InlineData("system.nullable`1[system.int32]", typeof(TypeLoadException), false)]
         [InlineData("System.NonExistingType", typeof(TypeLoadException), false)]
@@ -517,15 +540,7 @@ public void GetTypeByName_ValidType_ReturnsExpected(string typeName, Type expect
         [InlineData("Outside`2", typeof(TypeLoadException), false)]
         [InlineData("Outside`1[System.Boolean, System.Int32]", typeof(ArgumentException), true)]
         [InlineData(".System.Int32", typeof(TypeLoadException), false)]
-        [InlineData("..Outside`1", typeof(TypeLoadException), false)]
-        [InlineData(".Outside`1+.Inside`1", typeof(TypeLoadException), false)]
-        [InlineData("System.Int32&&", typeof(TypeLoadException), true)]
-        [InlineData("System.Int32&*", typeof(TypeLoadException), true)]
-        [InlineData("System.Int32&[]", typeof(TypeLoadException), true)]
-        [InlineData("System.Int32&[*]", typeof(TypeLoadException), true)]
-        [InlineData("System.Int32&[,]", typeof(TypeLoadException), true)]
-        [InlineData("System.Void[]", typeof(TypeLoadException), true)]
-        [InlineData("System.TypedReference[]", typeof(TypeLoadException), true)]
+        [MemberData(nameof(GetTypeByName_InvalidElementType))]
         public void GetTypeByName_Invalid(string typeName, Type expectedException, bool alwaysThrowsException)
         {
             if (!alwaysThrowsException)
diff --git a/src/mono/System.Private.CoreLib/src/System/Reflection/TypeNameResolver.Mono.cs b/src/mono/System.Private.CoreLib/src/System/Reflection/TypeNameResolver.Mono.cs
@@ -18,7 +18,6 @@ internal unsafe ref partial struct TypeNameResolver
         private Func<Assembly?, string, bool, Type?>? _typeResolver;
         private bool _throwOnError;
         private bool _ignoreCase;
-        private bool _extensibleParser;
         private ref StackCrawlMark _stackMark;
 
         [RequiresUnreferencedCode("The type might be removed")]
@@ -28,7 +27,6 @@ internal unsafe ref partial struct TypeNameResolver
             Func<Assembly?, string, bool, Type?>? typeResolver,
             bool throwOnError,
             bool ignoreCase,
-            bool extensibleParser,
             ref StackCrawlMark stackMark)
         {
             ArgumentNullException.ThrowIfNull(typeName);
@@ -54,7 +52,6 @@ internal unsafe ref partial struct TypeNameResolver
                 _typeResolver = typeResolver,
                 _throwOnError = throwOnError,
                 _ignoreCase = ignoreCase,
-                _extensibleParser = extensibleParser,
                 _stackMark = ref stackMark
             }.Resolve(parsed);
         }
@@ -144,16 +141,7 @@ internal unsafe ref partial struct TypeNameResolver
                 if (_ignoreCase)
                     bindingFlags |= BindingFlags.IgnoreCase;
 
-                if (type is RuntimeType rt)
-                {
-                    // Compat: Non-extensible parser allows ambiguous matches with ignore case lookup
-                    bool ignoreAmbiguousMatch = !_extensibleParser && _ignoreCase;
-                    type = rt.GetNestedType(nestedTypeNames[i], bindingFlags, ignoreAmbiguousMatch);
-                }
-                else
-                {
-                    type = type.GetNestedType(nestedTypeNames[i], bindingFlags);
-                }
+                type = type.GetNestedType(nestedTypeNames[i], bindingFlags);
 
                 if (type is null)
                 {
diff --git a/src/mono/System.Private.CoreLib/src/System/RuntimeType.Mono.cs b/src/mono/System.Private.CoreLib/src/System/RuntimeType.Mono.cs
@@ -679,17 +679,21 @@ private ListBuilder<FieldInfo> GetFieldCandidates(string? name, BindingFlags bin
             return candidates;
         }
 
-        private ListBuilder<Type> GetNestedTypeCandidates(string? name, BindingFlags bindingAttr, bool allowPrefixLookup)
+        private ListBuilder<Type> GetNestedTypeCandidates(string? fullname, BindingFlags bindingAttr, bool allowPrefixLookup)
         {
+            bool prefixLookup;
             bindingAttr &= ~BindingFlags.Static;
-            FilterHelper(bindingAttr, ref name, allowPrefixLookup, out bool prefixLookup, out _, out MemberListType listType);
+            string? name, ns;
+            MemberListType listType;
+            SplitName(fullname, out name, out ns);
+            FilterHelper(bindingAttr, ref name, allowPrefixLookup, out prefixLookup, out _, out listType);
 
             RuntimeType[] cache = GetNestedTypes_internal(name, bindingAttr, listType);
             ListBuilder<Type> candidates = new ListBuilder<Type>(cache.Length);
             for (int i = 0; i < cache.Length; i++)
             {
                 RuntimeType nestedClass = cache[i];
-                if (FilterApplyType(nestedClass, bindingAttr, name, prefixLookup, null))
+                if (FilterApplyType(nestedClass, bindingAttr, name, prefixLookup, ns))
                 {
                     candidates.Add(nestedClass);
                 }
@@ -1000,39 +1004,33 @@ public override MemberInfo[] GetMembers(BindingFlags bindingAttr)
         }
 
         [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicNestedTypes | DynamicallyAccessedMemberTypes.NonPublicNestedTypes)]
-        internal Type? GetNestedType([MaybeNull] string name, BindingFlags bindingAttr, bool ignoreAmbiguousMatch)
+        public override Type? GetNestedType(string fullname, BindingFlags bindingAttr)
         {
-            ArgumentNullException.ThrowIfNull(name);
+            ArgumentNullException.ThrowIfNull(fullname);
 
             bindingAttr &= ~BindingFlags.Static;
-            FilterHelper(bindingAttr, ref name, out _, out MemberListType listType);
+            string? name, ns;
+            MemberListType listType;
+            SplitName(fullname, out name, out ns);
+            FilterHelper(bindingAttr, ref name, out _, out listType);
             RuntimeType[] cache = GetNestedTypes_internal(name, bindingAttr, listType);
             RuntimeType? match = null;
 
             for (int i = 0; i < cache.Length; i++)
             {
                 RuntimeType nestedType = cache[i];
-                if (FilterApplyType(nestedType, bindingAttr, name, false, null))
+                if (FilterApplyType(nestedType, bindingAttr, name, false, ns))
                 {
                     if (match != null)
                         throw ThrowHelper.GetAmbiguousMatchException(match);
 
                     match = nestedType;
-
-                    if (ignoreAmbiguousMatch)
-                        break;
                 }
             }
 
             return match;
         }
 
-        [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicNestedTypes | DynamicallyAccessedMemberTypes.NonPublicNestedTypes)]
-        public override Type? GetNestedType(string name, BindingFlags bindingAttr)
-        {
-            return GetNestedType(name, bindingAttr, ignoreAmbiguousMatch: false);
-        }
-
         [DynamicallyAccessedMembers(GetAllMembers)]
         public override MemberInfo[] GetMember(string name, MemberTypes type, BindingFlags bindingAttr)
         {
diff --git a/src/mono/System.Private.CoreLib/src/System/Type.Mono.cs b/src/mono/System.Private.CoreLib/src/System/Type.Mono.cs
@@ -30,53 +30,53 @@ internal IntPtr GetUnderlyingNativeHandle()
         public static Type? GetType(string typeName, bool throwOnError, bool ignoreCase)
         {
             StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return GetType(typeName, null, null, throwOnError, ignoreCase, false, ref stackMark);
+            return RuntimeType.GetType(typeName, throwOnError, ignoreCase, ref stackMark);
         }
 
         [RequiresUnreferencedCode("The type might be removed")]
         [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
         public static Type? GetType(string typeName, bool throwOnError)
         {
             StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return GetType(typeName, null, null, throwOnError, false, false, ref stackMark);
+            return RuntimeType.GetType(typeName, throwOnError, false, ref stackMark);
         }
 
         [RequiresUnreferencedCode("The type might be removed")]
         [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
         public static Type? GetType(string typeName)
         {
             StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return GetType(typeName, null, null, false, false, false, ref stackMark);
+            return RuntimeType.GetType(typeName, false, false, ref stackMark);
         }
 
         [RequiresUnreferencedCode("The type might be removed")]
         [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
         public static Type? GetType(string typeName, Func<AssemblyName, Assembly?>? assemblyResolver, Func<Assembly?, string, bool, Type?>? typeResolver)
         {
             StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return GetType(typeName, assemblyResolver, typeResolver, false, false, true, ref stackMark);
+            return GetType(typeName, assemblyResolver, typeResolver, false, false, ref stackMark);
         }
 
         [RequiresUnreferencedCode("The type might be removed")]
         [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
         public static Type? GetType(string typeName, Func<AssemblyName, Assembly?>? assemblyResolver, Func<Assembly?, string, bool, Type?>? typeResolver, bool throwOnError)
         {
             StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return GetType(typeName, assemblyResolver, typeResolver, throwOnError, false, true, ref stackMark);
+            return GetType(typeName, assemblyResolver, typeResolver, throwOnError, false, ref stackMark);
         }
 
         [RequiresUnreferencedCode("The type might be removed")]
         [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
         public static Type? GetType(string typeName, Func<AssemblyName, Assembly?>? assemblyResolver, Func<Assembly?, string, bool, Type?>? typeResolver, bool throwOnError, bool ignoreCase)
         {
             StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return GetType(typeName, assemblyResolver, typeResolver, throwOnError, ignoreCase, true, ref stackMark);
+            return GetType(typeName, assemblyResolver, typeResolver, throwOnError, ignoreCase, ref stackMark);
         }
 
         [RequiresUnreferencedCode("The type might be removed")]
-        private static Type? GetType(string typeName, Func<AssemblyName, Assembly?>? assemblyResolver, Func<Assembly?, string, bool, Type?>? typeResolver, bool throwOnError, bool ignoreCase, bool extensibleParser, ref StackCrawlMark stackMark)
+        private static Type? GetType(string typeName, Func<AssemblyName, Assembly?>? assemblyResolver, Func<Assembly?, string, bool, Type?>? typeResolver, bool throwOnError, bool ignoreCase, ref StackCrawlMark stackMark)
         {
-            return TypeNameResolver.GetType(typeName, assemblyResolver, typeResolver, throwOnError, ignoreCase, extensibleParser, ref stackMark);
+            return TypeNameResolver.GetType(typeName, assemblyResolver, typeResolver, throwOnError, ignoreCase, ref stackMark);
         }
 
         public static Type? GetTypeFromHandle(RuntimeTypeHandle handle)

Original file line number	Diff line number	Diff line change
`@@ -679,17 +679,21 @@ private ListBuilder<FieldInfo> GetFieldCandidates(string? name, BindingFlags bin`
`679`	`679`	`return candidates;`
`680`	`680`	`}`
`681`	`681`
`682`		`- private ListBuilder<Type> GetNestedTypeCandidates(string? name, BindingFlags bindingAttr, bool allowPrefixLookup)`
	`682`	`+ private ListBuilder<Type> GetNestedTypeCandidates(string? fullname, BindingFlags bindingAttr, bool allowPrefixLookup)`
`683`	`683`	`{`
	`684`	`+ bool prefixLookup;`
`684`	`685`	`bindingAttr &= ~BindingFlags.Static;`
`685`		`- FilterHelper(bindingAttr, ref name, allowPrefixLookup, out bool prefixLookup, out _, out MemberListType listType);`
	`686`	`+ string? name, ns;`
	`687`	`+ MemberListType listType;`
	`688`	`+ SplitName(fullname, out name, out ns);`
	`689`	`+ FilterHelper(bindingAttr, ref name, allowPrefixLookup, out prefixLookup, out _, out listType);`
`686`	`690`
`687`	`691`	`RuntimeType[] cache = GetNestedTypes_internal(name, bindingAttr, listType);`
`688`	`692`	`ListBuilder<Type> candidates = new ListBuilder<Type>(cache.Length);`
`689`	`693`	`for (int i = 0; i < cache.Length; i++)`
`690`	`694`	`{`
`691`	`695`	`RuntimeType nestedClass = cache[i];`
`692`		`- if (FilterApplyType(nestedClass, bindingAttr, name, prefixLookup, null))`
	`696`	`+ if (FilterApplyType(nestedClass, bindingAttr, name, prefixLookup, ns))`
`693`	`697`	`{`
`694`	`698`	`candidates.Add(nestedClass);`
`695`	`699`	`}`
`@@ -1000,39 +1004,33 @@ public override MemberInfo[] GetMembers(BindingFlags bindingAttr)`
`1000`	`1004`	`}`
`1001`	`1005`
`1002`	`1006`	`[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicNestedTypes \| DynamicallyAccessedMemberTypes.NonPublicNestedTypes)]`
`1003`		`- internal Type? GetNestedType([MaybeNull] string name, BindingFlags bindingAttr, bool ignoreAmbiguousMatch)`
	`1007`	`+ public override Type? GetNestedType(string fullname, BindingFlags bindingAttr)`
`1004`	`1008`	`{`
`1005`		`- ArgumentNullException.ThrowIfNull(name);`
	`1009`	`+ ArgumentNullException.ThrowIfNull(fullname);`
`1006`	`1010`
`1007`	`1011`	`bindingAttr &= ~BindingFlags.Static;`
`1008`		`- FilterHelper(bindingAttr, ref name, out _, out MemberListType listType);`
	`1012`	`+ string? name, ns;`
	`1013`	`+ MemberListType listType;`
	`1014`	`+ SplitName(fullname, out name, out ns);`
	`1015`	`+ FilterHelper(bindingAttr, ref name, out _, out listType);`
`1009`	`1016`	`RuntimeType[] cache = GetNestedTypes_internal(name, bindingAttr, listType);`
`1010`	`1017`	`RuntimeType? match = null;`
`1011`	`1018`
`1012`	`1019`	`for (int i = 0; i < cache.Length; i++)`
`1013`	`1020`	`{`
`1014`	`1021`	`RuntimeType nestedType = cache[i];`
`1015`		`- if (FilterApplyType(nestedType, bindingAttr, name, false, null))`
	`1022`	`+ if (FilterApplyType(nestedType, bindingAttr, name, false, ns))`
`1016`	`1023`	`{`
`1017`	`1024`	`if (match != null)`
`1018`	`1025`	`throw ThrowHelper.GetAmbiguousMatchException(match);`
`1019`	`1026`
`1020`	`1027`	`match = nestedType;`
`1021`		`-`
`1022`		`- if (ignoreAmbiguousMatch)`
`1023`		`- break;`
`1024`	`1028`	`}`
`1025`	`1029`	`}`
`1026`	`1030`
`1027`	`1031`	`return match;`
`1028`	`1032`	`}`
`1029`	`1033`
`1030`		`- [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicNestedTypes \| DynamicallyAccessedMemberTypes.NonPublicNestedTypes)]`
`1031`		`- public override Type? GetNestedType(string name, BindingFlags bindingAttr)`
`1032`		`- {`
`1033`		`- return GetNestedType(name, bindingAttr, ignoreAmbiguousMatch: false);`
`1034`		`- }`
`1035`		`-`
`1036`	`1034`	`[DynamicallyAccessedMembers(GetAllMembers)]`
`1037`	`1035`	`public override MemberInfo[] GetMember(string name, MemberTypes type, BindingFlags bindingAttr)`
`1038`	`1036`	`{`
Original file line number	Diff line number	Diff line change
`@@ -30,53 +30,53 @@ internal IntPtr GetUnderlyingNativeHandle()`
`30`	`30`	`public static Type? GetType(string typeName, bool throwOnError, bool ignoreCase)`
`31`	`31`	`{`
`32`	`32`	`StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;`
`33`		`- return GetType(typeName, null, null, throwOnError, ignoreCase, false, ref stackMark);`
	`33`	`+ return RuntimeType.GetType(typeName, throwOnError, ignoreCase, ref stackMark);`
`34`	`34`	`}`
`35`	`35`
`36`	`36`	`[RequiresUnreferencedCode("The type might be removed")]`
`37`	`37`	`[System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod`
`38`	`38`	`public static Type? GetType(string typeName, bool throwOnError)`
`39`	`39`	`{`
`40`	`40`	`StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;`
`41`		`- return GetType(typeName, null, null, throwOnError, false, false, ref stackMark);`
	`41`	`+ return RuntimeType.GetType(typeName, throwOnError, false, ref stackMark);`
`42`	`42`	`}`
`43`	`43`
`44`	`44`	`[RequiresUnreferencedCode("The type might be removed")]`
`45`	`45`	`[System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod`
`46`	`46`	`public static Type? GetType(string typeName)`
`47`	`47`	`{`
`48`	`48`	`StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;`
`49`		`- return GetType(typeName, null, null, false, false, false, ref stackMark);`
	`49`	`+ return RuntimeType.GetType(typeName, false, false, ref stackMark);`
`50`	`50`	`}`
`51`	`51`
`52`	`52`	`[RequiresUnreferencedCode("The type might be removed")]`
`53`	`53`	`[System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod`
`54`	`54`	`public static Type? GetType(string typeName, Func<AssemblyName, Assembly?>? assemblyResolver, Func<Assembly?, string, bool, Type?>? typeResolver)`
`55`	`55`	`{`
`56`	`56`	`StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;`
`57`		`- return GetType(typeName, assemblyResolver, typeResolver, false, false, true, ref stackMark);`
	`57`	`+ return GetType(typeName, assemblyResolver, typeResolver, false, false, ref stackMark);`
`58`	`58`	`}`
`59`	`59`
`60`	`60`	`[RequiresUnreferencedCode("The type might be removed")]`
`61`	`61`	`[System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod`
`62`	`62`	`public static Type? GetType(string typeName, Func<AssemblyName, Assembly?>? assemblyResolver, Func<Assembly?, string, bool, Type?>? typeResolver, bool throwOnError)`
`63`	`63`	`{`
`64`	`64`	`StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;`
`65`		`- return GetType(typeName, assemblyResolver, typeResolver, throwOnError, false, true, ref stackMark);`
	`65`	`+ return GetType(typeName, assemblyResolver, typeResolver, throwOnError, false, ref stackMark);`
`66`	`66`	`}`
`67`	`67`
`68`	`68`	`[RequiresUnreferencedCode("The type might be removed")]`
`69`	`69`	`[System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod`
`70`	`70`	`public static Type? GetType(string typeName, Func<AssemblyName, Assembly?>? assemblyResolver, Func<Assembly?, string, bool, Type?>? typeResolver, bool throwOnError, bool ignoreCase)`
`71`	`71`	`{`
`72`	`72`	`StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;`
`73`		`- return GetType(typeName, assemblyResolver, typeResolver, throwOnError, ignoreCase, true, ref stackMark);`
	`73`	`+ return GetType(typeName, assemblyResolver, typeResolver, throwOnError, ignoreCase, ref stackMark);`
`74`	`74`	`}`
`75`	`75`
`76`	`76`	`[RequiresUnreferencedCode("The type might be removed")]`
`77`		`- private static Type? GetType(string typeName, Func<AssemblyName, Assembly?>? assemblyResolver, Func<Assembly?, string, bool, Type?>? typeResolver, bool throwOnError, bool ignoreCase, bool extensibleParser, ref StackCrawlMark stackMark)`
	`77`	`+ private static Type? GetType(string typeName, Func<AssemblyName, Assembly?>? assemblyResolver, Func<Assembly?, string, bool, Type?>? typeResolver, bool throwOnError, bool ignoreCase, ref StackCrawlMark stackMark)`
`78`	`78`	`{`
`79`		`- return TypeNameResolver.GetType(typeName, assemblyResolver, typeResolver, throwOnError, ignoreCase, extensibleParser, ref stackMark);`
	`79`	`+ return TypeNameResolver.GetType(typeName, assemblyResolver, typeResolver, throwOnError, ignoreCase, ref stackMark);`
`80`	`80`	`}`
`81`	`81`
`82`	`82`	`public static Type? GetTypeFromHandle(RuntimeTypeHandle handle)`