GetType: keep throwing same exceptions as .NET 8 (#114228)

When using Type.GetType, always throw FileLoadException for invalid assembly names no matter what throwOnError is set to.
When using Assembly.GetType, throw only when throwOnError is set, and ArgumentException (not FileLoadException)

Fixes #113534

Author: adamsitnik

src/coreclr/System.Private.CoreLib/src/System/Reflection/TypeNameResolver.CoreCLR.cs

@@ -80,13 +80,13 @@ internal partial struct TypeNameResolver
             bool ignoreCase,
             Assembly topLevelAssembly)
         {
-            TypeName? parsed = TypeNameParser.Parse(typeName, throwOnError);
+            TypeName? parsed = TypeNameParser.Parse(typeName, throwOnError, new() { IsAssemblyGetType = true });
 
             if (parsed is null)
             {
                 return null;
             }
-            else if (topLevelAssembly is not null && parsed.AssemblyName is not null)
+            else if (parsed.AssemblyName is not null)
             {
                 return throwOnError ? throw new ArgumentException(SR.Argument_AssemblyGetTypeCannotSpecifyAssembly) : null;
             }

src/libraries/System.Private.CoreLib/src/System/Reflection/TypeNameResolver.cs

@@ -20,6 +20,8 @@ public int MaxNodes
             }
         }
 #pragma warning restore CA1822
+
+        internal bool IsAssemblyGetType { get; set; }
     }
 }
 

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

@@ -188,14 +188,24 @@ private TypeNameParser(ReadOnlySpan<char> name, bool throwOnError, TypeNameParse
             if (allowFullyQualifiedName && !TryParseAssemblyName(ref assemblyName))
             {
 #if SYSTEM_PRIVATE_CORELIB
-                // backward compat: throw FileLoadException for non-empty invalid strings
-                if (_throwOnError || !_inputString.TrimStart().StartsWith(","))
+                // Backward compatibility: throw for non-empty invalid assembly names.
+                if (!_inputString.TrimStart().StartsWith(","))
                 {
+                    // Reject attempt to provide top-level assembly name to Assembly.GetType
+                    if (_parseOptions.IsAssemblyGetType)
+                    {
+                        if (_throwOnError)
+                        {
+                            throw new ArgumentException(SR.Argument_AssemblyGetTypeCannotSpecifyAssembly);
+                        }
+                        return null;
+                    }
+
+                    // Otherwise, no matter what throwOnError is set to, we throw FileLoadException for invalid assembly names.
                     throw new IO.FileLoadException(SR.InvalidAssemblyName, _inputString.ToString());
                 }
-#else
-                return null;
 #endif
+                return null;
             }
 
             // No matter what was parsed, the full name string is allocated only once.

src/libraries/System.Runtime/tests/System.Reflection.Tests/GetTypeTests.cs

@@ -276,6 +276,8 @@ public void GetType_CoreAssembly()
         {
             Assert.Equal(typeof(int), Type.GetType("System.Int32", throwOnError: true));
             Assert.Equal(typeof(int), Type.GetType("system.int32", throwOnError: true, ignoreCase: true));
+            Assert.Null(typeof(int).Assembly.GetType("a,b", throwOnError: false, ignoreCase: false));
+            Assert.Null(typeof(int).Assembly.GetType("a,b,c", throwOnError: false, ignoreCase: false));
         }
 
         [Fact]
@@ -294,7 +296,15 @@ public void GetType_InvalidAssemblyName()
             Assert.Null(Type.GetType("MissingAssemblyName, "));
             Assert.Null(Type.GetType("ExtraComma, ,"));
             Assert.Null(Type.GetType("ExtraComma, , System.Runtime"));
-            Assert.Throws<FileLoadException>(() => Type.GetType("System.Object, System.Runtime, Version=x.y"));
+
+            // Backward compat: no matter what throwOnError is set to, CLR throws FileLoadException for invalid assembly names.
+            Assert.Throws<FileLoadException>(() => Type.GetType("System.Object, System.Runtime, Version=x.y", throwOnError: false));
+            Assert.Throws<FileLoadException>(() => Type.GetType("System.Object, System.Runtime, Version=x.y", throwOnError: true));
+
+            // Backward compat: when using Assembly.GetType, throwOnError is not ignored and ArgumentException can be thrown.
+            Assembly coreLib = typeof(int).Assembly;
+            Assert.Null(coreLib.GetType("System.Object, System.Runtime, Version=x.y", throwOnError: false));
+            Assert.Throws<ArgumentException>(() => coreLib.GetType("System.Object, System.Runtime, Version=x.y", throwOnError: true));
         }
 
         [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsTypeEquivalenceSupported))]