* Reduce allocations

* Ensure correct return type
* Ensure correct declaring type
* Improve output in call analysis

Author: ds5678

Cpp2IL.Core/Model/Contexts/ConcreteGenericMethodAnalysisContext.cs

@@ -35,20 +35,25 @@ private ConcreteGenericMethodAnalysisContext(Cpp2IlMethodRef methodRef, Assembly
         DeclaringAsm = declaringAssembly;
         BaseMethodContext = ResolveBaseMethod(methodRef, declaringAssembly.GetTypeByDefinition(methodRef.DeclaringType)!);
 
+        var genericTypeParameters = ResolveTypeArray(methodRef.TypeGenericParams, declaringAssembly);
+        var genericMethodParameters = ResolveTypeArray(methodRef.MethodGenericParams, declaringAssembly);
+
         for (var i = 0; i < BaseMethodContext.Parameters.Count; i++)
         {
             var parameter = BaseMethodContext.Parameters[i];
             var parameterType = parameter.ParameterTypeContext;
             var instantiatedType = GenericInstantiation.Instantiate(
                 parameter.ParameterTypeContext,
-                ResolveTypeArray(methodRef.TypeGenericParams, declaringAssembly),
-                ResolveTypeArray(methodRef.MethodGenericParams, declaringAssembly));
+                genericTypeParameters,
+                genericMethodParameters);
 
             Parameters.Add(parameterType == instantiatedType
                 ? parameter
                 : new InjectedParameterAnalysisContext(parameter.Name, instantiatedType, i, BaseMethodContext));
         }
 
+        InjectedReturnType = GenericInstantiation.Instantiate(BaseMethodContext.ReturnTypeContext, genericTypeParameters, genericMethodParameters);
+
         if (UnderlyingPointer != 0)
             rawMethodBody = AppContext.InstructionSet.GetRawBytesForMethod(this, false);
     }
@@ -64,13 +69,19 @@ private static TypeAnalysisContext ResolveDeclaringType(Cpp2IlMethodRef methodRe
         var baseType = declaringAssembly.AppContext.ResolveContextForType(methodRef.DeclaringType)
                        ?? throw new($"Unable to resolve declaring type {methodRef.DeclaringType.FullName} for generic method {methodRef}");
 
+        if (methodRef.TypeGenericParams.Length == 0)
+            return baseType;
+
         var genericParams = ResolveTypeArray(methodRef.TypeGenericParams, declaringAssembly);
 
         return new GenericInstanceTypeAnalysisContext(baseType, genericParams, declaringAssembly);
     }
 
     private static TypeAnalysisContext[] ResolveTypeArray(Il2CppTypeReflectionData[] array, AssemblyAnalysisContext declaringAssembly)
     {
+        if (array.Length == 0)
+            return [];
+
         var ret = new TypeAnalysisContext[array.Length];
         for (var i = 0; i < array.Length; i++)
         {

Cpp2IL.Core/ProcessingLayers/CallAnalysisProcessingLayer.cs

@@ -195,10 +195,8 @@ private static void AddAttribute((InjectedMethodAnalysisContext, InjectedFieldAn
 
         var memberField = (callsAttributeInfo.Item2[1], targetMethod.Name);
 
-        var concreteMethod = targetMethod as ConcreteGenericMethodAnalysisContext;
-
         (FieldAnalysisContext, object)? typeParametersField;
-        if (concreteMethod is not null)
+        if (targetMethod is ConcreteGenericMethodAnalysisContext concreteMethod)
         {
             if (concreteMethod.MethodRef.MethodGenericParams.Length > 0)
             {
@@ -269,10 +267,6 @@ private static void AddAttribute((InjectedMethodAnalysisContext, InjectedFieldAn
         {
             returnType = targetMethod.InjectedReturnType;
         }
-        else if (concreteMethod is { BaseMethodContext: { Definition: not null } or { InjectedReturnType: not null } })
-        {
-            returnType = concreteMethod.BaseMethodContext.ReturnTypeContext;
-        }
         else if (targetMethod.Definition is null)
         {
             returnType = null;