Enable resolving of .netmodule references (#5767)

4 files changed, 38 insertions, 18 deletions

diff --git a/src/ILVerification/src/ILVerifyTypeSystemContext.cs b/src/ILVerification/src/ILVerifyTypeSystemContext.cs
index 528dc6a90..96aaa3fd9 100644
--- a/src/ILVerification/src/ILVerifyTypeSystemContext.cs
+++ b/src/ILVerification/src/ILVerifyTypeSystemContext.cs
@@ -4,6 +4,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.IO;
 using System.Reflection;
 using System.Reflection.Metadata;
 using System.Reflection.PortableExecutable;
@@ -29,18 +30,39 @@ namespace ILVerify
 
         public override ModuleDesc ResolveAssembly(AssemblyName name, bool throwIfNotFound = true)
         {
-            PEReader peReader = _resolver.Resolve(name);
-            if (peReader == null && throwIfNotFound)
+            // Note: we use simple names instead of full names to resolve, because we can't get a full name from an assembly without reading it
+            string simpleName = name.Name;
+            return ResolveAssemblyOrNetmodule(simpleName, simpleName, throwIfNotFound);
+        }
+
+        internal override ModuleDesc ResolveModule(ModuleDesc referencingModule, string fileName, bool throwIfNotFound = true)
+        {
+            // Referenced modules are stored without their extension (see CommandLineHelpers.cs), so we have to drop
+            // the extension here as well to find a match.
+            string simpleName = Path.GetFileNameWithoutExtension(fileName);
+            // The referencing module is not getting verified currently.
+            // However, netmodules are resolved in the context of assembly, not in the global context.
+            EcmaModule module = ResolveAssemblyOrNetmodule(simpleName, fileName, throwIfNotFound);
+            if (module.MetadataReader.IsAssembly)
             {
-                throw new VerifierException("Assembly or module not found: " + name.Name);
+                throw new VerifierException($"The module '{fileName}' is not expected to be an assembly");
             }
+            return module;
+        }
 
+        private EcmaModule ResolveAssemblyOrNetmodule(string simpleName, string verificationName, bool throwIfNotFound)
+        {
+            PEReader peReader = _resolver.Resolve(simpleName);
+            if (peReader == null && throwIfNotFound)
+            {
+                throw new VerifierException("Assembly or module not found: " + simpleName);
+            }
             var module = GetModule(peReader);
-            VerifyModuleName(name, module);
+            VerifyModuleName(verificationName, module);
             return module;
         }
 
-        private static void VerifyModuleName(AssemblyName name, EcmaModule module)
+        private static void VerifyModuleName(string simpleName, EcmaModule module)
         {
             MetadataReader metadataReader = module.MetadataReader;
             StringHandle nameHandle = metadataReader.IsAssembly
@@ -48,9 +70,9 @@ namespace ILVerify
                 : metadataReader.GetModuleDefinition().Name;
 
             string actualSimpleName = metadataReader.GetString(nameHandle);
-            if (!actualSimpleName.Equals(name.Name, StringComparison.OrdinalIgnoreCase))
+            if (!actualSimpleName.Equals(simpleName, StringComparison.OrdinalIgnoreCase))
             {
-                throw new VerifierException($"Actual PE name '{actualSimpleName}' does not match provided name '{name}'");
+                throw new VerifierException($"Actual PE name '{actualSimpleName}' does not match provided name '{simpleName}'");
             }
         }
 
diff --git a/src/ILVerification/src/IResolver.cs b/src/ILVerification/src/IResolver.cs
index f3706cf3b..aec09c82a 100644
--- a/src/ILVerification/src/IResolver.cs
+++ b/src/ILVerification/src/IResolver.cs
@@ -13,7 +13,7 @@ namespace ILVerify
         /// <summary>
         /// This method should return the same instance when queried multiple times.
         /// </summary>
-        PEReader Resolve(AssemblyName name);
+        PEReader Resolve(string simpleName);
     }
 
     /// <summary>
@@ -23,16 +23,14 @@ namespace ILVerify
     {
         private readonly Dictionary<string, PEReader> _resolverCache = new Dictionary<string, PEReader>();
 
-        public PEReader Resolve(AssemblyName name)
+        public PEReader Resolve(string simpleName)
         {
-            // Note: we use simple names instead of full names to resolve, because we can't get a full name from an assembly without reading it
-            string simpleName = name.Name;
             if (_resolverCache.TryGetValue(simpleName, out PEReader peReader))
             {
                 return peReader;
             }
 
-            PEReader result = ResolveCore(name);
+            PEReader result = ResolveCore(simpleName);
             if (result != null)
             {
                 _resolverCache.Add(simpleName, result);
@@ -42,6 +40,6 @@ namespace ILVerify
             return null;
         }
 
-        protected abstract PEReader ResolveCore(AssemblyName name);
+        protected abstract PEReader ResolveCore(string simpleName);
     }
 }
diff --git a/src/ILVerification/src/Verifier.cs b/src/ILVerification/src/Verifier.cs
index 9341ef395..7f693a594 100644
--- a/src/ILVerification/src/Verifier.cs
+++ b/src/ILVerification/src/Verifier.cs
@@ -34,7 +34,7 @@ namespace ILVerify
 
         public void SetSystemModuleName(AssemblyName name)
         {
-            _typeSystemContext.SetSystemModule(_typeSystemContext.GetModule(_typeSystemContext._resolver.Resolve(name)));
+            _typeSystemContext.SetSystemModule(_typeSystemContext.GetModule(_typeSystemContext._resolver.Resolve(name.Name)));
         }
 
         internal EcmaModule GetModule(PEReader peReader)
diff --git a/src/ILVerification/tests/TestDataLoader.cs b/src/ILVerification/tests/TestDataLoader.cs
index 91a1195f8..a91132b91 100644
--- a/src/ILVerification/tests/TestDataLoader.cs
+++ b/src/ILVerification/tests/TestDataLoader.cs
@@ -178,9 +178,9 @@ namespace ILVerification.Tests
 
             var resolver = new TestResolver(simpleNameToPathMap);
             var typeSystemContext = new ILVerifyTypeSystemContext(resolver);
-            typeSystemContext.SetSystemModule(typeSystemContext.GetModule(resolver.Resolve(coreAssembly.GetName())));
+            typeSystemContext.SetSystemModule(typeSystemContext.GetModule(resolver.Resolve(coreAssembly.GetName().Name)));
 
-            return typeSystemContext.GetModule(resolver.Resolve(new AssemblyName(Path.GetFileNameWithoutExtension(assemblyName))));
+            return typeSystemContext.GetModule(resolver.Resolve(new AssemblyName(Path.GetFileNameWithoutExtension(assemblyName)).Name));
         }
 
         private sealed class TestResolver : ResolverBase
@@ -191,9 +191,9 @@ namespace ILVerification.Tests
                 _simpleNameToPathMap = simpleNameToPathMap;
             }
 
-            protected override PEReader ResolveCore(AssemblyName name)
+            protected override PEReader ResolveCore(string simpleName)
             {
-                if (_simpleNameToPathMap.TryGetValue(name.Name, out string path))
+                if (_simpleNameToPathMap.TryGetValue(simpleName, out string path))
                 {
                     return new PEReader(File.OpenRead(path));
                 }