Bump to latest Cpp2IL and AsmResolver

Author: ds5678

Il2CppInterop.Generator/ContextResolver.cs

@@ -12,27 +12,31 @@ public readonly struct ContextResolver
     private readonly AssemblyAnalysisContext referencedFrom;
     private readonly TypeAnalysisContext? referencingType;
     private readonly MethodAnalysisContext? referencingMethod;
+    private readonly RuntimeContext runtimeContext;
 
-    public ContextResolver(AssemblyAnalysisContext referencedFrom)
+    public ContextResolver(AssemblyAnalysisContext referencedFrom, RuntimeContext runtimeContext)
     {
         this.referencedFrom = referencedFrom;
+        this.runtimeContext = runtimeContext;
     }
 
-    public ContextResolver(TypeAnalysisContext referencingType)
+    public ContextResolver(TypeAnalysisContext referencingType, RuntimeContext runtimeContext)
     {
         if (referencingType is ReferencedTypeAnalysisContext)
             throw new ArgumentException("Must be a simple type", nameof(referencingType));
         referencedFrom = referencingType.DeclaringAssembly;
         this.referencingType = referencingType;
+        this.runtimeContext = runtimeContext;
     }
 
-    public ContextResolver(MethodAnalysisContext referencingMethod)
+    public ContextResolver(MethodAnalysisContext referencingMethod, RuntimeContext runtimeContext)
     {
         if (referencingMethod is ConcreteGenericMethodAnalysisContext)
             throw new ArgumentException("Must be a simple method", nameof(referencingMethod));
         referencedFrom = referencingMethod.CustomAttributeAssembly;
         referencingType = referencingMethod.DeclaringType;
         this.referencingMethod = referencingMethod;
+        this.runtimeContext = runtimeContext;
     }
 
     public TypeAnalysisContext? Resolve(TypeSignature? type) => type switch
@@ -86,6 +90,16 @@ public bool TryResolve(TypeSignature? type, [NotNullWhen(true)] out TypeAnalysis
 
     private TypeAnalysisContext? Resolve(TypeDefOrRefSignature typeDefOrRef)
     {
+        return Resolve(typeDefOrRef.Type);
+    }
+
+    private TypeAnalysisContext? Resolve(ITypeDefOrRef typeDefOrRef)
+    {
+        if (typeDefOrRef is TypeSpecification typeSpecification)
+        {
+            return Resolve(typeSpecification.Signature);
+        }
+
         if (typeDefOrRef.DeclaringType is not null)
         {
             if (!TryResolve(typeDefOrRef.DeclaringType, out var declaringType))
@@ -102,9 +116,9 @@ public bool TryResolve(TypeSignature? type, [NotNullWhen(true)] out TypeAnalysis
             return null;
         }
 
-        if (typeDefOrRef.Type is not TypeDefinition)
+        if (typeDefOrRef is not TypeDefinition)
         {
-            typeDefOrRef = (TypeDefOrRefSignature?)typeDefOrRef.Resolve()?.ToTypeSignature() ?? typeDefOrRef;
+            typeDefOrRef = typeDefOrRef.TryResolve(runtimeContext) ?? typeDefOrRef;
         }
 
         var assemblyName = GetName(typeDefOrRef.Scope);
@@ -132,7 +146,12 @@ public bool TryResolve(TypeSignature? type, [NotNullWhen(true)] out TypeAnalysis
 
     public TypeAnalysisContext? Resolve(ITypeDescriptor? type)
     {
-        return Resolve(type?.ToTypeSignature());
+        return type switch
+        {
+            TypeSignature signature => Resolve(signature),
+            ITypeDefOrRef typeDefOrRef => Resolve(typeDefOrRef),
+            _ => null,
+        };
     }
 
     public bool TryResolve(ITypeDescriptor? type, [NotNullWhen(true)] out TypeAnalysisContext? result)
@@ -169,7 +188,7 @@ public bool TryResolve(IEnumerable<TypeSignature?> types, [NotNullWhen(true)] ou
 
     public FieldAnalysisContext? Resolve(IFieldDescriptor fieldDescriptor)
     {
-        var declaringType = Resolve(fieldDescriptor.DeclaringType?.ToTypeSignature());
+        var declaringType = Resolve(fieldDescriptor.DeclaringType);
         if (declaringType is null)
             return null;
 
@@ -222,7 +241,7 @@ public bool TryResolve(IFieldDescriptor fieldDescriptor, [NotNullWhen(true)] out
 
         Debug.Assert(nonGenericDeclaringType is not ReferencedTypeAnalysisContext);
 
-        var targetMethod = new ContextResolver(nonGenericDeclaringType).ResolveInType(methodDefOrRef);
+        var targetMethod = new ContextResolver(nonGenericDeclaringType, runtimeContext).ResolveInType(methodDefOrRef);
         if (targetMethod is null)
             return null;
 
@@ -245,7 +264,7 @@ public bool TryResolve(IMethodDescriptor methodDescriptor, [NotNullWhen(true)] o
     public MethodAnalysisContext? Resolve(MethodDefinition methodDefinition)
     {
         // The declaring type can be resolved with nothing, but resolution for the method itself requires a context.
-        return TryResolve(methodDefinition.DeclaringType, out var declaringType) ? new ContextResolver(declaringType).ResolveInType(methodDefinition) : null;
+        return TryResolve(methodDefinition.DeclaringType, out var declaringType) ? new ContextResolver(declaringType, runtimeContext).ResolveInType(methodDefinition) : null;
     }
 
     public MethodAnalysisContext? ResolveInType(IMethodDefOrRef methodDefOrRef)
@@ -274,7 +293,7 @@ public bool TryResolve(IMethodDescriptor methodDescriptor, [NotNullWhen(true)] o
                 continue;
 
             // We need to use a resolver for the method context to resolve potential method generic parameters correctly.
-            var methodResolver = new ContextResolver(methodContext);
+            var methodResolver = new ContextResolver(methodContext, runtimeContext);
 
             if (!methodResolver.TryResolve(methodDefOrRef.Signature.ReturnType, out var returnType) ||
                 !TypeAnalysisContextEqualityComparer.Instance.Equals(methodContext.ReturnType, returnType))
@@ -304,62 +323,4 @@ public bool TryResolve(IMethodDescriptor methodDescriptor, [NotNullWhen(true)] o
 
         return baseMethod.MakeGenericInstanceMethod(methodTypeArguments);
     }
-
-    public TypeAnalysisContext ResolveOrThrow(Type? type, bool allowGenericInstance = true)
-    {
-        return Resolve(type, allowGenericInstance) ?? throw new($"Unable to resolve type {type?.FullName}");
-    }
-
-    public TypeAnalysisContext? Resolve(Type? type) => Resolve(type, true);
-    public TypeAnalysisContext? Resolve(Type? type, bool allowGenericInstance)
-    {
-        if (type is null)
-            return null;
-
-        if (type.IsSZArray)
-            return Resolve(type.GetElementType())?.MakeSzArrayType();
-
-        if (type.IsByRef)
-            return Resolve(type.GetElementType())?.MakeByReferenceType();
-
-        if (type.IsPointer)
-            return Resolve(type.GetElementType())?.MakePointerType();
-
-        if (type.IsArray)
-            return Resolve(type.GetElementType())?.MakeArrayType(type.GetArrayRank());
-
-        if (type.IsGenericParameter)
-        {
-            if (type.IsGenericTypeParameter)
-            {
-                return TryGetGenericParameter(referencingType?.GenericParameters, type.GenericParameterPosition);
-            }
-            else
-            {
-                Debug.Assert(type.IsGenericMethodParameter);
-                return TryGetGenericParameter(referencingMethod?.GenericParameters, type.GenericParameterPosition);
-            }
-        }
-
-        if (type.IsGenericType && allowGenericInstance)
-        {
-            var genericArguments = type.GetGenericArguments().Select(Resolve).ToArray();
-            if (genericArguments.Any(x => x is null))
-                return null;
-
-            var genericType = type.GetGenericTypeDefinition();
-            return Resolve(genericType, false)?.MakeGenericInstanceType(genericArguments!);
-        }
-
-        if (type.IsFunctionPointer)
-            throw new NotSupportedException($"Function pointers are not supported: {type.Name}");
-
-        // Custom modifiers might be possible to support, but probably not necessary
-
-        var assemblyName = type.Assembly.GetName().Name!;
-        if (assemblyName == "System.Private.CoreLib")
-            assemblyName = "mscorlib";
-        var assembly = referencedFrom.AppContext.GetAssemblyByName(assemblyName);
-        return assembly?.GetTypeByFullName(type.FullName!);
-    }
 }

Il2CppInterop.Generator/Extensions/AsmResolverExtensions.cs

@@ -1,4 +1,6 @@
-namespace Il2CppInterop.Generator.Extensions;
+using AsmResolver.DotNet;
+
+namespace Il2CppInterop.Generator.Extensions;
 
 internal static class AsmResolverExtensions
 {
@@ -9,4 +11,9 @@ public bool IsLoadConstantI4
             get => opCode.Code is (>= CilCode.Ldc_I4_M1 and <= CilCode.Ldc_I4_8) or CilCode.Ldc_I4_S or CilCode.Ldc_I4;
         }
     }
+
+    public static TypeDefinition? TryResolve(this ITypeDescriptor typeDescriptor, RuntimeContext? runtimeContext)
+    {
+        return typeDescriptor.TryResolve(runtimeContext, out var resolvedType) ? resolvedType : null;
+    }
 }

Il2CppInterop.Generator/Extensions/InjectedTypeAnalysisContextExtensions.cs

@@ -1,7 +1,6 @@
 using System.Reflection;
 using System.Runtime.CompilerServices;
 using Cpp2IL.Core.Model.Contexts;
-using Il2CppInterop.Generator;
 using LibCpp2IL.BinaryStructures;
 
 namespace Il2CppInterop.Generator.Extensions;
@@ -18,15 +17,15 @@ public void InjectContentFromSourceType()
             var appContext = type.AppContext;
 
             type.SetDefaultBaseType(sourceType.BaseType != null
-                ? new ContextResolver(type).ResolveOrThrow(sourceType.BaseType)
+                ? new SystemTypeResolver(type).ResolveOrThrow(sourceType.BaseType)
                 : null);
 
             foreach (var fieldInfo in sourceType.GetFields())
             {
                 if (fieldInfo.DeclaringType != sourceType)
                     continue;
 
-                var resolver = new ContextResolver(type);
+                var resolver = new SystemTypeResolver(type);
 
                 type.InjectFieldContext(
                     fieldInfo.Name,
@@ -67,7 +66,7 @@ public void InjectContentFromSourceType()
 
                 methodMap.Add(method, methodContext);
 
-                var resolver = new ContextResolver(methodContext);
+                var resolver = new SystemTypeResolver(methodContext);
 
                 var returnType = method switch
                 {
@@ -94,7 +93,7 @@ public void InjectContentFromSourceType()
                 if (getMethod == null && setMethod == null)
                     continue;
 
-                var resolver = new ContextResolver(type);
+                var resolver = new SystemTypeResolver(type);
 
                 var propertyType = resolver.ResolveOrThrow(property.PropertyType);
                 type.InjectPropertyContext(
@@ -116,7 +115,7 @@ public void InjectContentFromSourceType()
                 if (addMethod == null && removeMethod == null && raiseMethod == null)
                     continue;
 
-                var resolver = new ContextResolver(type);
+                var resolver = new SystemTypeResolver(type);
                 var eventType = resolver.ResolveOrThrow(eventInfo.EventHandlerType!);
                 type.InjectEventContext(
                     eventInfo.Name,

Il2CppInterop.Generator/Il2CppInterop.Generator.csproj

@@ -13,7 +13,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="AssetRipper.Cpp2IL.Core" Version="1.0.0" />
+    <PackageReference Include="AssetRipper.Cpp2IL.Core" Version="1.0.2" />
     <PackageReference Include="PolySharp" Version="1.15.0">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>

Il2CppInterop.Generator/MscorlibAssemblyInjectionProcessingLayer.cs

@@ -24,7 +24,7 @@ public override void Process(ApplicationAnalysisContext appContext, Action<int,
 
             assemblyList = Directory.GetFiles(directoryPath, "*.dll", SearchOption.AllDirectories)
                 .Where(x => x.Contains("mscorlib", StringComparison.OrdinalIgnoreCase))
-                .Select(AssemblyDefinition.FromFile)
+                .Select(path => AssemblyDefinition.FromFile(path))
                 .ToList();
         }
 

Il2CppInterop.Generator/OriginalMethodBody.cs

@@ -9,9 +9,9 @@ namespace Il2CppInterop.Generator;
 
 public class OriginalMethodBody : MethodBodyBase
 {
-    public static bool MaybeStoreOriginalMethodBody(MethodDefinition originalMethod, MethodAnalysisContext methodContext)
+    public static bool MaybeStoreOriginalMethodBody(MethodDefinition originalMethod, MethodAnalysisContext methodContext, RuntimeContext runtimeContext)
     {
-        if (TryResolveOriginalMethodBody(originalMethod, methodContext, out var originalMethodBody))
+        if (TryResolveOriginalMethodBody(originalMethod, methodContext, runtimeContext, out var originalMethodBody))
         {
             methodContext.PutExtraData(originalMethodBody);
             return true;
@@ -22,7 +22,7 @@ public static bool MaybeStoreOriginalMethodBody(MethodDefinition originalMethod,
         }
     }
 
-    private static bool TryResolveOriginalMethodBody(MethodDefinition method, MethodAnalysisContext methodContext, [NotNullWhen(true)] out OriginalMethodBody? originalMethodBody)
+    private static bool TryResolveOriginalMethodBody(MethodDefinition method, MethodAnalysisContext methodContext, RuntimeContext runtimeContext, [NotNullWhen(true)] out OriginalMethodBody? originalMethodBody)
     {
         var body = method.CilMethodBody;
         if (body is null)
@@ -31,7 +31,7 @@ private static bool TryResolveOriginalMethodBody(MethodDefinition method, Method
             return false;
         }
 
-        var resolver = new ContextResolver(methodContext);
+        var resolver = new ContextResolver(methodContext, runtimeContext);
 
         var originalInstructions = body.Instructions;
         originalInstructions.ExpandMacrosBackport();
@@ -79,7 +79,7 @@ private static bool TryResolveOriginalMethodBody(MethodDefinition method, Method
             }
             else
             {
-                exceptionType = resolver.Resolve(exceptionHandler.ExceptionType.ToTypeSignature());
+                exceptionType = resolver.Resolve(exceptionHandler.ExceptionType);
                 if (exceptionType is null)
                 {
                     originalMethodBody = default;
@@ -109,7 +109,7 @@ private static bool TryResolveOriginalMethodBody(MethodDefinition method, Method
                 AsmResolver.Utf8String utf8String => utf8String.ToString(),
                 CilLocalVariable localVariable => newLocalVariables[localVariable.Index],
                 Parameter parameter => parameter == method.Parameters.ThisParameter ? This.Instance : methodContext.Parameters[parameter.Index],
-                ITypeDescriptor typeDescriptor => resolver.Resolve(typeDescriptor.ToTypeSignature()),
+                ITypeDescriptor typeDescriptor => resolver.Resolve(typeDescriptor),
                 IFieldDescriptor { Signature: not null } fieldDescriptor => resolver.Resolve(fieldDescriptor),
                 IMethodDescriptor { Signature: not null } methodDescriptor => resolver.Resolve(methodDescriptor),
                 ICilLabel label => ResolveLabel(newInstructions, originalInstructions, label),