simplify assembly ResolveHandler, and use official assembly name parsing method

lostmsu · lostmsu · commit 0a68ca7a1d47 · 2021-09-23T21:08:22.000-07:00
diff --git a/src/python_tests_runner/PythonTestRunner.cs b/src/python_tests_runner/PythonTestRunner.cs
@@ -34,7 +34,7 @@ static IEnumerable<string[]> PythonTestCases()
         {
             // Add the test that you want to debug here.
             yield return new[] { "test_enum", "test_enum_standard_attrs" };
-            yield return new[] { "test_generic", "test_missing_generic_type" };
+            yield return new[] { "test_module", "test_explicit_assembly_load" };
         }
 
         /// <summary>
diff --git a/src/runtime/assemblymanager.cs b/src/runtime/assemblymanager.cs
@@ -110,16 +110,15 @@ private static void AssemblyLoadHandler(object ob, AssemblyLoadEventArgs args)
         /// </summary>
         private static Assembly ResolveHandler(object ob, ResolveEventArgs args)
         {
-            string name = args.Name.ToLower();
-            foreach (Assembly a in assemblies)
+            var name = new AssemblyName(args.Name);
+            foreach (var alreadyLoaded in assemblies)
             {
-                string full = a.FullName.ToLower();
-                if (full.StartsWith(name))
+                if (AssemblyName.ReferenceMatchesDefinition(name, alreadyLoaded.GetName()))
                 {
-                    return a;
+                    return alreadyLoaded;
                 }
             }
-            return LoadAssemblyPath(args.Name);
+            return LoadAssemblyPath(name.Name);
         }
 
 
@@ -154,6 +153,17 @@ internal static void UpdatePath()
             }
         }
 
+        /// <summary>
+        /// Given an assembly name, try to find this assembly file using the
+        /// PYTHONPATH. If not found, return null to indicate implicit load
+        /// using standard load semantics (app base directory then GAC, etc.)
+        /// </summary>
+        public static string FindAssembly(AssemblyName name)
+        {
+            if (name is null) throw new ArgumentNullException(nameof(name));
+
+            return FindAssembly(name.Name);
+        }
 
         /// <summary>
         /// Given an assembly name, try to find this assembly file using the
@@ -162,8 +172,13 @@ internal static void UpdatePath()
         /// </summary>
         public static string FindAssembly(string name)
         {
-            char sep = Path.DirectorySeparatorChar;
+            if (name is null) throw new ArgumentNullException(nameof(name));
 
+            return FindAssemblyCandidates(name).FirstOrDefault();
+        }
+
+        static IEnumerable<string> FindAssemblyCandidates(string name)
+        {
             foreach (string head in pypath)
             {
                 string path;
@@ -173,22 +188,21 @@ public static string FindAssembly(string name)
                 }
                 else
                 {
-                    path = head + sep + name;
+                    path = Path.Combine(head, name);
                 }
 
                 string temp = path + ".dll";
                 if (File.Exists(temp))
                 {
-                    return temp;
+                    yield return temp;
                 }
 
                 temp = path + ".exe";
                 if (File.Exists(temp))
                 {
-                    return temp;
+                    yield return temp;
                 }
             }
-            return null;
         }
 
 
diff --git a/tests/test_module.py b/tests/test_module.py
@@ -232,11 +232,11 @@ def test_explicit_assembly_load():
     from System.Reflection import Assembly
     import System, sys
 
-    assembly = Assembly.LoadWithPartialName('System.Runtime')
+    assembly = Assembly.LoadWithPartialName('Microsoft.CSharp')
     assert assembly is not None
 
-    import System.Runtime
-    assert 'System.Runtime' in sys.modules
+    import Microsoft.CSharp
+    assert 'Microsoft.CSharp' in sys.modules
 
     assembly = Assembly.LoadWithPartialName('SpamSpamSpamSpamEggsAndSpam')
     assert assembly is None

Original file line number	Diff line number	Diff line change
`@@ -34,7 +34,7 @@ static IEnumerable<string[]> PythonTestCases()`
`34`	`34`	`{`
`35`	`35`	`// Add the test that you want to debug here.`
`36`	`36`	`yield return new[] { "test_enum", "test_enum_standard_attrs" };`
`37`		`- yield return new[] { "test_generic", "test_missing_generic_type" };`
	`37`	`+ yield return new[] { "test_module", "test_explicit_assembly_load" };`
`38`	`38`	`}`
`39`	`39`
`40`	`40`	`/// <summary>`
Original file line number	Diff line number	Diff line change
`@@ -110,16 +110,15 @@ private static void AssemblyLoadHandler(object ob, AssemblyLoadEventArgs args)`
`110`	`110`	`/// </summary>`
`111`	`111`	`private static Assembly ResolveHandler(object ob, ResolveEventArgs args)`
`112`	`112`	`{`
`113`		`- string name = args.Name.ToLower();`
`114`		`- foreach (Assembly a in assemblies)`
	`113`	`+ var name = new AssemblyName(args.Name);`
	`114`	`+ foreach (var alreadyLoaded in assemblies)`
`115`	`115`	`{`
`116`		`- string full = a.FullName.ToLower();`
`117`		`- if (full.StartsWith(name))`
	`116`	`+ if (AssemblyName.ReferenceMatchesDefinition(name, alreadyLoaded.GetName()))`
`118`	`117`	`{`
`119`		`- return a;`
	`118`	`+ return alreadyLoaded;`
`120`	`119`	`}`
`121`	`120`	`}`
`122`		`- return LoadAssemblyPath(args.Name);`
	`121`	`+ return LoadAssemblyPath(name.Name);`
`123`	`122`	`}`
`124`	`123`
`125`	`124`
`@@ -154,6 +153,17 @@ internal static void UpdatePath()`
`154`	`153`	`}`
`155`	`154`	`}`
`156`	`155`
	`156`	`+ /// <summary>`
	`157`	`+ /// Given an assembly name, try to find this assembly file using the`
	`158`	`+ /// PYTHONPATH. If not found, return null to indicate implicit load`
	`159`	`+ /// using standard load semantics (app base directory then GAC, etc.)`
	`160`	`+ /// </summary>`
	`161`	`+ public static string FindAssembly(AssemblyName name)`
	`162`	`+ {`
	`163`	`+ if (name is null) throw new ArgumentNullException(nameof(name));`
	`164`	`+`
	`165`	`+ return FindAssembly(name.Name);`
	`166`	`+ }`
`157`	`167`
`158`	`168`	`/// <summary>`
`159`	`169`	`/// Given an assembly name, try to find this assembly file using the`
`@@ -162,8 +172,13 @@ internal static void UpdatePath()`
`162`	`172`	`/// </summary>`
`163`	`173`	`public static string FindAssembly(string name)`
`164`	`174`	`{`
`165`		`- char sep = Path.DirectorySeparatorChar;`
	`175`	`+ if (name is null) throw new ArgumentNullException(nameof(name));`
`166`	`176`
	`177`	`+ return FindAssemblyCandidates(name).FirstOrDefault();`
	`178`	`+ }`
	`179`	`+`
	`180`	`+ static IEnumerable<string> FindAssemblyCandidates(string name)`
	`181`	`+ {`
`167`	`182`	`foreach (string head in pypath)`
`168`	`183`	`{`
`169`	`184`	`string path;`
`@@ -173,22 +188,21 @@ public static string FindAssembly(string name)`
`173`	`188`	`}`
`174`	`189`	`else`
`175`	`190`	`{`
`176`		`- path = head + sep + name;`
	`191`	`+ path = Path.Combine(head, name);`
`177`	`192`	`}`
`178`	`193`
`179`	`194`	`string temp = path + ".dll";`
`180`	`195`	`if (File.Exists(temp))`
`181`	`196`	`{`
`182`		`- return temp;`
	`197`	`+ yield return temp;`
`183`	`198`	`}`
`184`	`199`
`185`	`200`	`temp = path + ".exe";`
`186`	`201`	`if (File.Exists(temp))`
`187`	`202`	`{`
`188`		`- return temp;`
	`203`	`+ yield return temp;`
`189`	`204`	`}`
`190`	`205`	`}`
`191`		`- return null;`
`192`	`206`	`}`
`193`	`207`
`194`	`208`