Generic fixes

SamboyCoding · Sep 23, 2021 · 5278fc8 · 5278fc8
1 parent 07808f2
commit 5278fc8
Show file tree

Hide file tree

Showing 6 changed files with 9 additions and 6 deletions.
diff --git a/Cpp2IL.Core/Analysis/Actions/ARM64/Arm64MetadataUsageMethodRefToRegisterAction.cs b/Cpp2IL.Core/Analysis/Actions/ARM64/Arm64MetadataUsageMethodRefToRegisterAction.cs
@@ -60,7 +60,7 @@ public Arm64MetadataUsageMethodRefToRegisterAction(MethodAnalysis<Arm64Instructi
             if (genericTypeParams.Count > 0)
             {
                 declaringType = declaringType.MakeGenericInstanceType(genericTypeParams.ToArray());
-                method = method.MakeGeneric(genericTypeParams.ToArray());
+                method = method.MakeMethodOnGenericType(genericTypeParams.ToArray());
             }
 
             if (genericMethodParams.Count > 0)

diff --git a/Cpp2IL.Core/Analysis/Actions/Base/AbstractCallAction.cs b/Cpp2IL.Core/Analysis/Actions/Base/AbstractCallAction.cs
@@ -118,6 +118,9 @@ public override Mono.Cecil.Cil.Instruction[] ToILInstructions(MethodAnalysis<T>
             if(toCall is GenericInstanceMethod gim2)
                 toCall = processor.ImportRecursive(gim2);
 
+            // if (toCall.DeclaringType is GenericInstanceType git2)
+            //     toCall.DeclaringType = processor.ImportRecursive(git2);
+
             result.Add(processor.Create(ShouldUseCallvirt ? OpCodes.Callvirt : OpCodes.Call, processor.ImportReference(toCall)));
 
             if (ManagedMethodBeingCalled.ReturnType.FullName == "System.Void")

diff --git a/Cpp2IL.Core/Analysis/Actions/Base/AbstractNewObjAction.cs b/Cpp2IL.Core/Analysis/Actions/Base/AbstractNewObjAction.cs
@@ -40,7 +40,7 @@ public override Instruction[] ToILInstructions(MethodAnalysis<T> context, ILProc
                 ctorToCall = TypeCreated?.Resolve()?.Methods.FirstOrDefault(m => m.Name == ".ctor" && m.Parameters.Count == ctorToCall.Parameters.Count) ?? throw new TaintedInstructionException($"Could not resolve a constructor with {ctorToCall.Parameters.Count} parameters.");
 
             if (ctorToCall.HasGenericParameters && TypeCreated is GenericInstanceType git)
-                ctorToCall = ctorToCall.MakeGeneric(git.GenericArguments.ToArray());
+                ctorToCall = ctorToCall.MakeMethodOnGenericType(git.GenericArguments.ToArray());
 
             result.Add(processor.Create(OpCodes.Newobj, processor.ImportReference(ctorToCall)));
 

diff --git a/Cpp2IL.Core/Analysis/Actions/x86/Important/CallMethodSpecAction.cs b/Cpp2IL.Core/Analysis/Actions/x86/Important/CallMethodSpecAction.cs
@@ -29,7 +29,7 @@ public CallMethodSpecAction(MethodAnalysis<Instruction> context, Instruction ins
             ShouldUseCallvirt = true;
 
             if (methodSpec.classIndexIndex != -1)
-                ManagedMethodBeingCalled = ManagedMethodBeingCalled.MakeGeneric(methodSpec.GenericClassParams.Select(p => Utils.TryResolveTypeReflectionData(p, ManagedMethodBeingCalled)).ToArray()!);
+                ManagedMethodBeingCalled = ManagedMethodBeingCalled.MakeMethodOnGenericType(methodSpec.GenericClassParams.Select(p => Utils.TryResolveTypeReflectionData(p, ManagedMethodBeingCalled)).ToArray()!);
 
             CreateLocalForReturnType(context);
             RegisterLocals();

diff --git a/Cpp2IL.Core/AssemblyPopulator.cs b/Cpp2IL.Core/AssemblyPopulator.cs
@@ -163,7 +163,7 @@ private static void FixupExplicitOverridesInType(TypeDefinition ilTypeDefinition
                     {
                         //Non-null assertion because we've null-checked the params above.
                         genericParams = genericParams.Select(p => p is GenericParameter ? p : ilTypeDefinition.Module.ImportReference(p, currentlyFixingUp)).ToList()!;
-                        baseRef = nonGenericRef.MakeGeneric(genericParams.ToArray()!);
+                        baseRef = nonGenericRef.MakeMethodOnGenericType(genericParams.ToArray()!);
                     }
                     else
                     {

diff --git a/Cpp2IL.Core/Utils.cs b/Cpp2IL.Core/Utils.cs
@@ -442,11 +442,11 @@ private static TypeReference MakeGenericType(this TypeReference self, params Typ
             return instance;
         }
 
-        public static MethodReference MakeGeneric(this MethodReference self, params TypeReference[] arguments)
+        public static MethodReference MakeMethodOnGenericType(this MethodReference self, params TypeReference[] typeParams)
         {
             var reference = new MethodReference(self.Name, self.ReturnType)
             {
-                DeclaringType = self.DeclaringType.MakeGenericType(arguments),
+                DeclaringType = self.DeclaringType.MakeGenericType(typeParams),
                 HasThis = self.HasThis,
                 ExplicitThis = self.ExplicitThis,
                 CallingConvention = self.CallingConvention