Enhance virtual function resolution logic to be roughly correct.

src/ILToNative/src/Compiler/AsmWriter.cs

@@ -312,7 +312,7 @@ void OutputVirtualSlots(TypeDesc implType, TypeDesc declType)
                 {
                     MethodDesc declMethod = reg.VirtualSlots[i];
 
-                    MethodDesc implMethod = ResolveVirtualMethod(implType, declMethod);
+                    MethodDesc implMethod = VirtualFunctionResolution.FindVirtualFunctionTargetMethodOnObjectType(declMethod, implType.GetClosestDefType());
 
                     Out.Write(".quad ");
                     Out.WriteLine(NameMangler.GetMangledMethodName(implMethod));

src/ILToNative/src/Compiler/Compilation.cs

@@ -241,7 +241,7 @@ void ExpandVirtualMethods()
                         {
                             MethodDesc declMethod = declReg.VirtualSlots[i];
 
-                            AddMethod(ResolveVirtualMethod(reg.Type, declMethod));
+                            AddMethod(VirtualFunctionResolution.FindVirtualFunctionTargetMethodOnObjectType(declMethod, reg.Type.GetClosestDefType()));
                         }
                     }
 
@@ -357,22 +357,6 @@ public void AddField(FieldDesc field)
             }
         }
 
-        internal MethodDesc ResolveVirtualMethod(TypeDesc implType, MethodDesc declMethod)
-        {
-            // TODO: Proper virtual method resolution
-            string name = declMethod.Name;
-            MethodSignature sig = declMethod.Signature;
-
-            MethodDesc implMethod;
-            TypeDesc t = implType;
-            for (;;)
-            {
-                implMethod = t.GetMethod(name, sig);
-                if (implMethod != null)
-                    return implMethod;
-                t = t.BaseType;
-            }
-        }
 
         struct ReadyToRunHelperKey : IEquatable<ReadyToRunHelperKey>
         {

src/ILToNative/src/CppCodeGen/CppWriter.cs

@@ -729,8 +729,7 @@ void AppendVirtualSlots(StringBuilder sb, TypeDesc implType, TypeDesc declType)
                 for (int i = 0; i < reg.VirtualSlots.Count; i++)
                 {
                     MethodDesc declMethod = reg.VirtualSlots[i];
-
-                    MethodDesc implMethod = _compilation.ResolveVirtualMethod(implType, declMethod);
+                    MethodDesc implMethod = VirtualFunctionResolution.FindVirtualFunctionTargetMethodOnObjectType(declMethod, implType.GetClosestDefType());
 
                     sb.Append("(void*)&");
                     sb.Append(GetCppTypeName(implMethod.OwningType));

src/ILToNative/src/ILToNative.csproj

@@ -128,6 +128,12 @@
     <Compile Include="..\..\TypeSystem\src\Common\TypeDesc.cs">
       <Link>TypeSystem\TypeDesc.cs</Link>
     </Compile>
+    <Compile Include="..\..\TypeSystem\src\Common\TypeDesc.MethodImpls.cs">
+      <Link>TypeSystem\TypeDesc.MethodImpls.cs</Link>
+    </Compile>
+    <Compile Include="..\..\TypeSystem\src\Common\VirtualFunctionResolution.cs">
+      <Link>TypeSystem\VirtualFunctionResolution.cs</Link>
+    </Compile>
   </ItemGroup>
   <ItemGroup>
     <Compile Include="..\..\TypeSystem\src\Ecma\EcmaField.cs">

src/NuGet.config

@@ -1,16 +1,15 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <configuration>
   <!-- NOTE: Leave this file here and keep it in sync with list in dir.props. -->
   <!-- The command-line doesn't need it, but the IDE does.                    -->
+  <config>
+    <add key="repositoryPath" value="..\packages" />
+  </config>
   <packageSources>
-    <clear/>
     <add key="myget.org dotnet-core" value="https://www.myget.org/F/dotnet-core/" />
     <add key="myget.org dotnet-coreclr" value="https://www.myget.org/F/dotnet-coreclr/" />
     <add key="myget.org dotnet-corefxtestdata" value="https://www.myget.org/F/dotnet-corefxtestdata/" />
     <add key="myget.org dotnet-buildtools" value="https://www.myget.org/F/dotnet-buildtools/" />
     <add key="nuget.org" value="https://www.nuget.org/api/v2/" />
   </packageSources>
-  <config>
-    <add key="repositoryPath" value="..\packages" />
-  </config>
 </configuration>

src/TypeSystem/src/Common/TypeDesc.MethodImpls.cs

@@ -0,0 +1,85 @@
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
+
+namespace Internal.TypeSystem
+{
+    public struct MethodImplRecord
+    {
+        public MethodDesc Decl;
+        public MethodDesc Body;
+    }
+
+    // MethodImpl api surface for types.
+    public partial class MetadataType
+    {
+        /// <summary>
+        /// Compute an array of all MethodImpls that pertain to overriding virtual (non-interface methods) on this type.
+        /// May be expensive.
+        /// </summary>
+        protected abstract MethodImplRecord[] ComputeVirtualMethodImplsForType();
+
+        private MethodImplRecord[] _allVirtualMethodImplsForType;
+        /// <summary>
+        /// Get an array of all MethodImpls that pertain to overriding virtual (non-interface methods) on this type. 
+        /// Expected to cache results so this api can be used repeatedly.
+        /// </summary>
+        public MethodImplRecord[] VirtualMethodImplsForType
+        {
+            get
+            {
+                if (_allVirtualMethodImplsForType == null)
+                {
+                    _allVirtualMethodImplsForType = ComputeVirtualMethodImplsForType();
+                }
+
+                return _allVirtualMethodImplsForType;
+            }
+        }
+
+        /// <summary>
+        /// Get an array of MethodImpls where the Decl method matches by name with the specified name.
+        /// </summary>
+        /// <param name="name"></param>
+        /// <returns></returns>
+        public abstract MethodImplRecord[] FindMethodsImplWithMatchingDeclName(string name);
+    }
+
+    // Implementation of MethodImpl api surface implemented without metadata access.
+    public partial class InstantiatedType
+    {
+        /// <summary>
+        /// Instantiate a MethodImplRecord from uninstantiated form to instantiated form
+        /// </summary>
+        /// <param name="uninstMethodImpls"></param>
+        /// <returns></returns>
+        private MethodImplRecord[] InstantiateMethodImpls(MethodImplRecord[] uninstMethodImpls)
+        {
+            if (uninstMethodImpls.Length == 0)
+                return uninstMethodImpls;
+
+            MethodImplRecord[] instMethodImpls = new MethodImplRecord[uninstMethodImpls.Length];
+
+            for (int i = 0; i < uninstMethodImpls.Length; i++)
+            {
+                instMethodImpls[i].Decl = _typeDef.Context.GetMethodForInstantiatedType(uninstMethodImpls[i].Decl, this);
+                instMethodImpls[i].Body = _typeDef.Context.GetMethodForInstantiatedType(uninstMethodImpls[i].Body, this);
+            }
+
+            return instMethodImpls;
+        }
+
+        protected override MethodImplRecord[] ComputeVirtualMethodImplsForType()
+        {
+            MethodImplRecord[] uninstMethodImpls = _typeDef.VirtualMethodImplsForType;
+            return InstantiateMethodImpls(uninstMethodImpls);
+        }
+
+        public override MethodImplRecord[] FindMethodsImplWithMatchingDeclName(string name)
+        {
+            MethodImplRecord[] uninstMethodImpls = _typeDef.FindMethodsImplWithMatchingDeclName(name);
+            return InstantiateMethodImpls(uninstMethodImpls);
+        }
+    }
+}

src/TypeSystem/src/Common/TypeSystemHelpers.cs

@@ -1,6 +1,8 @@
 // Copyright (c) Microsoft. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
+using System.Diagnostics;
+
 namespace Internal.TypeSystem
 {
     static public class TypeSystemHelpers
@@ -29,5 +31,57 @@ static public TypeDesc MakePointerType(this TypeDesc type)
         {
             return type.Context.GetPointerType(type);
         }
+
+        static public MetadataType GetClosestDefType(this TypeDesc type)
+        {
+            if (type is MetadataType)
+                return (MetadataType)type;
+            else
+                return type.BaseType;
+        }
+
+
+        static private MethodDesc FindMethodOnExactTypeWithMatchingTypicalMethod(this TypeDesc type, MethodDesc method)
+        {
+            // Assert that either type is instantiated and its type definition is the type that defines the typical
+            // method definition of method, or that the owning type of the method typical definition is exactly type
+            Debug.Assert((type is InstantiatedType) ? 
+                ((InstantiatedType)type).GetTypeDefinition() == method.GetTypicalMethodDefinition().OwningType :
+                type == method.GetTypicalMethodDefinition().OwningType);
+
+            MethodDesc methodTypicalDefinition = method.GetTypicalMethodDefinition();
+
+            foreach (MethodDesc methodToExamine in type.GetMethods())
+            {
+                if (methodToExamine.GetTypicalMethodDefinition() == methodTypicalDefinition)
+                    return methodToExamine;
+            }
+
+            Debug.Assert(false, "Behavior of typical type not as expected.");
+            return null;
+        }
+
+        static public MethodDesc FindMethodOnTypeWithMatchingTypicalMethod(this TypeDesc typeExamine, MethodDesc method)
+        {
+            TypeDesc typicalTypeInHierarchyOfTargetMethod = method.GetTypicalMethodDefinition().OwningType;
+            TypeDesc typeInHierarchyOfTypeExamine = typeExamine;
+            do
+            {
+                TypeDesc typicalTypeInHierarchyOfTypeExamine = typeInHierarchyOfTypeExamine;
+                if (typicalTypeInHierarchyOfTypeExamine is InstantiatedType)
+                {
+                    typicalTypeInHierarchyOfTypeExamine = typicalTypeInHierarchyOfTypeExamine.GetTypeDefinition();
+                }
+                if (typicalTypeInHierarchyOfTypeExamine == typicalTypeInHierarchyOfTargetMethod)
+                {
+                    // set targetMethod to method on 
+                    return typeInHierarchyOfTypeExamine.FindMethodOnTypeWithMatchingTypicalMethod(method);
+                }
+                typeInHierarchyOfTypeExamine = typeInHierarchyOfTypeExamine.BaseType;
+            } while (typeInHierarchyOfTypeExamine != null);
+
+            Debug.Assert(false, "method has no related type in the type hierarchy of type");
+            return null;
+        }
     }
 }