Improve unstrip support

Il2CppInterop.Generator/Extensions/ILGeneratorEx.cs

@@ -172,14 +172,16 @@ public static void EmitObjectToPointer(this ILProcessor body, TypeReference orig
         }
 
         var imports = enclosingType.AssemblyContext.Imports;
-        if (originalType is ByReferenceType)
+        if (originalType is ByReferenceType originalRefType)
         {
-            if (newType.GetElementType().IsValueType)
+            if (newType is not ByReferenceType newRefType)
+                throw new ArgumentException($"{nameof(newType)} must be {nameof(ByReferenceType)} if {nameof(originalType)} is", nameof(newType));
+            if (newRefType.ElementType.IsValueType)
             {
                 body.Emit(OpCodes.Ldarg, argumentIndex);
                 body.Emit(OpCodes.Conv_I);
             }
-            else if (originalType.GetElementType().IsValueType)
+            else if (originalRefType.ElementType.IsValueType)
             {
                 body.Emit(OpCodes.Ldarg, argumentIndex);
                 body.Emit(OpCodes.Ldind_Ref);
@@ -192,7 +194,7 @@ public static void EmitObjectToPointer(this ILProcessor body, TypeReference orig
                 body.Body.Variables.Add(pointerVar);
                 body.Emit(OpCodes.Ldarg, argumentIndex);
                 body.Emit(OpCodes.Ldind_Ref);
-                if (originalType.GetElementType().FullName == "System.String")
+                if (originalRefType.ElementType.FullName == "System.String")
                     body.Emit(OpCodes.Call, imports.IL2CPP_ManagedStringToIl2Cpp.Value);
                 else
                     body.Emit(OpCodes.Call, imports.IL2CPP_Il2CppObjectBaseToPtr.Value);

Il2CppInterop.Generator/Passes/Pass20GenerateStaticConstructors.cs

@@ -191,7 +191,7 @@ private static void EmitLoadTypeNameString(this ILProcessor ctorBuilder, Runtime
                 imports.Module.ImportReference(new GenericInstanceMethod(imports.IL2CPP_RenderTypeName.Value)
                 {
                     GenericArguments =
-                        {newTypeReference.IsByReference ? newTypeReference.GetElementType() : newTypeReference}
+                        {newTypeReference is ByReferenceType newTypeRefType ? newTypeRefType.ElementType : newTypeReference}
                 }));
         }
     }

Il2CppInterop.Generator/Passes/Pass80UnstripMethods.cs

@@ -143,29 +143,44 @@ private static PropertyDefinition GetOrCreateProperty(MethodDefinition unityMeth
     }
 
     internal static TypeReference? ResolveTypeInNewAssemblies(RewriteGlobalContext context, TypeReference unityType,
-        RuntimeAssemblyReferences imports)
+        RuntimeAssemblyReferences imports, bool resolveValueTypes = false)
     {
-        var resolved = ResolveTypeInNewAssembliesRaw(context, unityType, imports);
+        return ResolveTypeInNewAssemblies(context, unityType, imports, out var _, resolveValueTypes);
+    }
+
+    internal static TypeReference? ResolveTypeInNewAssemblies(RewriteGlobalContext context, TypeReference unityType,
+        RuntimeAssemblyReferences imports, out TypeRewriteContext rwContext, bool resolveValueTypes = false)
+    {
+        var resolved = ResolveTypeInNewAssembliesRaw(context, unityType, imports, out rwContext, resolveValueTypes);
         return resolved != null ? imports.Module.ImportReference(resolved) : null;
     }
 
     internal static TypeReference? ResolveTypeInNewAssembliesRaw(RewriteGlobalContext context, TypeReference unityType,
-        RuntimeAssemblyReferences imports)
+        RuntimeAssemblyReferences imports, bool resolveValueTypes = false)
+    {
+        return ResolveTypeInNewAssembliesRaw(context, unityType, imports, out var _, resolveValueTypes);
+    }
+
+    internal static TypeReference? ResolveTypeInNewAssembliesRaw(RewriteGlobalContext context, TypeReference unityType,
+        RuntimeAssemblyReferences imports, out TypeRewriteContext rwContext, bool resolveValueTypes = false)
     {
-        if (unityType is ByReferenceType)
+        if (unityType is ByReferenceType unityRefType)
         {
-            var resolvedElementType = ResolveTypeInNewAssemblies(context, unityType.GetElementType(), imports);
+            var resolvedElementType = ResolveTypeInNewAssemblies(context, unityRefType.ElementType, imports, out rwContext);
             return resolvedElementType == null ? null : new ByReferenceType(resolvedElementType);
         }
 
         if (unityType is GenericParameter)
+        {
+            rwContext = null;
             return null;
+        }
 
         if (unityType is ArrayType arrayType)
         {
-            if (arrayType.Rank != 1) return null;
-            var resolvedElementType = ResolveTypeInNewAssemblies(context, unityType.GetElementType(), imports);
-            if (resolvedElementType == null) return null;
+            if (arrayType.Rank != 1) { rwContext = null; return null; }
+            var resolvedElementType = ResolveTypeInNewAssemblies(context, unityType.GetElementType(), imports, out rwContext, resolveValueTypes);
+            if (resolvedElementType == null) { rwContext = null; return null; }
             if (resolvedElementType.FullName == "System.String")
                 return imports.Il2CppStringArray;
             var genericBase = resolvedElementType.IsValueType
@@ -176,7 +191,7 @@ private static PropertyDefinition GetOrCreateProperty(MethodDefinition unityMeth
 
         if (unityType.DeclaringType != null)
         {
-            var enclosingResolvedType = ResolveTypeInNewAssembliesRaw(context, unityType.DeclaringType, imports);
+            var enclosingResolvedType = ResolveTypeInNewAssembliesRaw(context, unityType.DeclaringType, imports, out rwContext, resolveValueTypes);
             if (enclosingResolvedType == null) return null;
             var resolvedNestedType = enclosingResolvedType.Resolve().NestedTypes
                 .FirstOrDefault(it => it.Name == unityType.Name);
@@ -186,13 +201,13 @@ private static PropertyDefinition GetOrCreateProperty(MethodDefinition unityMeth
 
         if (unityType is PointerType)
         {
-            var resolvedElementType = ResolveTypeInNewAssemblies(context, unityType.GetElementType(), imports);
+            var resolvedElementType = ResolveTypeInNewAssemblies(context, unityType.GetElementType(), imports, out rwContext, resolveValueTypes);
             return resolvedElementType == null ? null : new PointerType(resolvedElementType);
         }
 
         if (unityType is GenericInstanceType genericInstance)
         {
-            var baseRef = ResolveTypeInNewAssembliesRaw(context, genericInstance.ElementType, imports);
+            var baseRef = ResolveTypeInNewAssembliesRaw(context, genericInstance.ElementType, imports, out rwContext, resolveValueTypes);
             if (baseRef == null) return null;
             var newInstance = new GenericInstanceType(baseRef);
             foreach (var unityGenericArgument in genericInstance.GenericArguments)
@@ -208,24 +223,29 @@ private static PropertyDefinition GetOrCreateProperty(MethodDefinition unityMeth
         var targetAssemblyName = unityType.Scope.Name;
         if (targetAssemblyName.EndsWith(".dll"))
             targetAssemblyName = targetAssemblyName.Substring(0, targetAssemblyName.Length - 4);
-        if ((targetAssemblyName == "mscorlib" || targetAssemblyName == "netstandard") &&
-            (unityType.IsValueType || unityType.FullName == "System.String" ||
-             unityType.FullName == "System.Void") && unityType.FullName != "System.RuntimeTypeHandle")
+        if ((targetAssemblyName == "mscorlib" || targetAssemblyName == "netstandard") && (
+                (!resolveValueTypes && (unityType.IsValueType || unityType.FullName == "System.String")) ||
+                 unityType.FullName == "System.Void" || unityType.IsPrimitive
+             ) && unityType.FullName != "System.RuntimeTypeHandle")
+        {
+            rwContext = null;
             return imports.Module.ImportCorlibReference(unityType.Namespace, unityType.Name);
+        }
 
         if (targetAssemblyName == "UnityEngine")
             foreach (var assemblyRewriteContext in context.Assemblies)
             {
                 if (!assemblyRewriteContext.NewAssembly.Name.Name.StartsWith("UnityEngine")) continue;
 
-                var newTypeInAnyUnityAssembly =
-                    assemblyRewriteContext.TryGetTypeByName(unityType.FullName)?.NewType;
+                rwContext = assemblyRewriteContext.TryGetTypeByName(unityType.FullName);
+                var newTypeInAnyUnityAssembly = rwContext?.NewType;
                 if (newTypeInAnyUnityAssembly != null)
                     return newTypeInAnyUnityAssembly;
             }
 
         var targetAssembly = context.TryGetAssemblyByName(targetAssemblyName);
-        var newType = targetAssembly?.TryGetTypeByName(unityType.FullName)?.NewType;
+        rwContext = targetAssembly?.TryGetTypeByName(unityType.FullName);
+        var newType = rwContext?.NewType;
 
         return newType;
     }

Il2CppInterop.Generator/Passes/Pass81FillUnstrippedMethodBodies.cs

@@ -1,9 +1,12 @@
 using System.Collections.Generic;
+using System.IO.Compression;
+using System.Text;
 using Il2CppInterop.Common;
 using Il2CppInterop.Generator.Contexts;
 using Il2CppInterop.Generator.Utils;
 using Microsoft.Extensions.Logging;
 using Mono.Cecil;
+using Mono.Cecil.Cil;
 
 namespace Il2CppInterop.Generator.Passes;
 
@@ -17,14 +20,14 @@ private static readonly
     public static void DoPass(RewriteGlobalContext context)
     {
         var methodsSucceeded = 0;
-        var methodsFailed = 0;
+        var methodsFailed = new List<(MethodDefinition method, UnstripTranslator.Result result)>();
 
         foreach (var (unityMethod, newMethod, processedType, imports) in StuffToProcess)
         {
-            var success = UnstripTranslator.TranslateMethod(unityMethod, newMethod, processedType, imports);
-            if (success == false)
+            var result = UnstripTranslator.TranslateMethod(unityMethod, newMethod, processedType, imports);
+            if (result.IsError)
             {
-                methodsFailed++;
+                methodsFailed.Add((unityMethod, result));
                 UnstripTranslator.ReplaceBodyWithException(newMethod, imports);
             }
             else
@@ -34,7 +37,83 @@ public static void DoPass(RewriteGlobalContext context)
         }
 
         Logger.Instance.LogInformation("IL unstrip statistics: {MethodsSucceeded} successful, {MethodsFailed} failed", methodsSucceeded,
-            methodsFailed);
+            methodsFailed.Count);
+
+        SaveResults(context, methodsFailed);
+    }
+
+    private static void SaveResults(RewriteGlobalContext context,
+        List<(MethodDefinition method, UnstripTranslator.Result result)> results)
+    {
+        var outPath = Path.GetDirectoryName(context.Options.OutputDir);
+        outPath = Path.Combine(outPath, "unstrip.json.gz");
+        outPath = Path.GetFullPath(outPath);
+        var cwd = Directory.GetCurrentDirectory() + Path.DirectorySeparatorChar;
+        if (!outPath.StartsWith(cwd))
+            outPath = "unstrip.json.gz";
+        else
+            outPath = outPath.Substring(cwd.Length);
+        Logger.Instance.LogInformation("Saving IL unstrip statistics to {OutPath}", outPath);
+
+        results.Sort((left, right) => StringComparer.OrdinalIgnoreCase
+            .Compare(left.method.MemberFullName(), right.method.MemberFullName()));
+        using (var gzStream =
+            new StreamWriter(
+                new GZipStream(
+                    File.Open(outPath, FileMode.Create),
+                CompressionLevel.Fastest),
+            new UTF8Encoding(false)))
+        {
+            using (var arr = SimpleJsonWriter.Create(gzStream).Array())
+            {
+                foreach (var (method, result) in results)
+                {
+                    using (var entry = arr.Object())
+                    {
+                        entry.Property("name")
+                            .Value(method.MemberFullName());
+                        entry.Property("fullName")
+                            .Value(method.FullName);
+                        entry.Property("scope")
+                            .Value(method.DeclaringType.Scope.Name);
+                        entry.Property("namespace")
+                            .Value(method.DeclaringType.Namespace);
+                        entry.Property("type")
+                            .Value(method.DeclaringType.Name);
+                        entry.Property("method")
+                            .Value(method.Name);
+                        var insProp = entry.Property("instruction");
+                        if (result.offendingInstruction == null)
+                            insProp.Value(null);
+                        else
+                            using (var ins = insProp.Object())
+                            {
+                                ins.Property("description")
+                                    .Value(result.offendingInstruction.ToString());
+                                ins.Property("opCode")
+                                    .Value(result.offendingInstruction.OpCode.Name);
+                                ins.Property("operandType")
+                                    .Value(Enum.GetName(typeof(OperandType), result.offendingInstruction.OpCode.OperandType));
+                                ins.Property("operandValueType")
+                                    .Value(result.offendingInstruction.Operand?.GetType().Name);
+                                ins.Property("operand")
+                                    .Value(result.offendingInstruction.Operand?.ToString());
+                            }
+                        entry.Property("result")
+                            .Value(Enum.GetName(typeof(UnstripTranslator.ErrorType), result.type));
+                        entry.Property("reason")
+                            .Value(result.reason);
+                    }
+                }
+            }
+        }
+    }
+
+    private static string MemberFullName(this MethodDefinition method)
+    {
+        if (method.DeclaringType == null)
+            return method.Name;
+        return $"{method.DeclaringType.FullName}::{method.Name}";
     }
 
     public static void PushMethod(MethodDefinition unityMethod, MethodDefinition newMethod,