Improvements to struct interop for DOTS

Il2CppInterop.Generator/Contexts/AssemblyRewriteContext.cs

@@ -1,6 +1,8 @@
 using System.Diagnostics;
 using AsmResolver.DotNet;
+using AsmResolver.DotNet.Code.Cil;
 using AsmResolver.DotNet.Signatures;
+using AsmResolver.PE.DotNet.Metadata.Tables;
 using Il2CppInterop.Generator.Extensions;
 using Il2CppInterop.Generator.Utils;
 
@@ -14,6 +16,7 @@
     public readonly RuntimeAssemblyReferences Imports;
     private readonly Dictionary<string, TypeRewriteContext> myNameTypeMap = new();
     private readonly Dictionary<TypeDefinition, TypeRewriteContext> myNewTypeMap = new();
+    private TypeDefinition? isUnmanagedAttributeType;
 
     private readonly Dictionary<TypeDefinition, TypeRewriteContext> myOldTypeMap = new();
     public readonly AssemblyDefinition NewAssembly;
@@ -31,7 +34,8 @@
             mod => new RuntimeAssemblyReferences(mod, globalContext));
     }
 
-    public IEnumerable<TypeRewriteContext> Types => myOldTypeMap.Values;
+    public IEnumerable<TypeRewriteContext> Types => myNewTypeMap.Values;
+    public IEnumerable<TypeRewriteContext> OriginalTypes => myOldTypeMap.Values;
 
     public TypeRewriteContext GetContextForOriginalType(TypeDefinition type)
     {
@@ -48,6 +52,11 @@
         return myNewTypeMap[type];
     }
 
+    public void RegisterTypeContext(TypeRewriteContext context)
+    {
+        myNewTypeMap.Add(context.NewType, context);
+    }
+
     public void RegisterTypeRewrite(TypeRewriteContext context)
     {
         if (context.OriginalType != null)
@@ -63,12 +72,26 @@
         return NewAssembly.ManifestModule!.DefaultImporter.ImportMethod(newMethod);
     }
 
-    public ITypeDefOrRef RewriteTypeRef(ITypeDescriptor typeRef)
+    /// <summary>
+    /// Rewrite passes type
+    /// </summary>
+    /// <param name="typeRef">type</param>
+    /// <param name="context">generic context. Ensure you pass NEW types here</param>
+    /// <param name="typeIsBoxed">are we rewriting boxed variant</param>
+    /// <returns>new type</returns>
+    public ITypeDefOrRef RewriteTypeRef(ITypeDescriptor typeRef, GenericParameterContext context = default, bool typeIsBoxed = false)
     {
-        return RewriteTypeRef(typeRef?.ToTypeSignature()).ToTypeDefOrRef();
+        return RewriteTypeRef(typeRef?.ToTypeSignature(), context, typeIsBoxed).ToTypeDefOrRef();
     }
 
-    public TypeSignature RewriteTypeRef(TypeSignature? typeRef)
+    /// <summary>
+    /// Rewrite passes type
+    /// </summary>
+    /// <param name="typeRef">type</param>
+    /// <param name="context">generic context. Ensure you pass NEW types here</param>
+    /// <param name="typeIsBoxed">are we rewriting boxed variant</param>
+    /// <returns>new type</returns>
+    public TypeSignature RewriteTypeRef(TypeSignature? typeRef, GenericParameterContext context = default, bool typeIsBoxed = false)
     {
         if (typeRef == null)
             return Imports.Il2CppObjectBase;
@@ -84,7 +107,7 @@
             if (elementType.FullName == "System.String")
                 return Imports.Il2CppStringArray;
 
-            var convertedElementType = RewriteTypeRef(elementType);
+            var convertedElementType = RewriteTypeRef(elementType, context, typeIsBoxed);
             if (elementType is GenericParameterSignature)
                 return new GenericInstanceTypeSignature(Imports.Il2CppArrayBase.ToTypeDefOrRef(), false, convertedElementType);
 
@@ -94,24 +117,35 @@
         }
 
         if (typeRef is GenericParameterSignature genericParameter)
-        {
             return new GenericParameterSignature(sourceModule, genericParameter.ParameterType, genericParameter.Index);
-        }
 
         if (typeRef is ByReferenceTypeSignature byRef)
-            return new ByReferenceTypeSignature(RewriteTypeRef(byRef.BaseType));
+            return new ByReferenceTypeSignature(RewriteTypeRef(byRef.BaseType, context, typeIsBoxed));
 
         if (typeRef is PointerTypeSignature pointerType)
-            return new PointerTypeSignature(RewriteTypeRef(pointerType.BaseType));
+            return new PointerTypeSignature(RewriteTypeRef(pointerType.BaseType, context, typeIsBoxed));
 
         if (typeRef is GenericInstanceTypeSignature genericInstance)
         {
-            var genericType = RewriteTypeRef(genericInstance.GenericType.ToTypeSignature()).ToTypeDefOrRef();
-            var newRef = new GenericInstanceTypeSignature(genericType, genericType.IsValueType);
-            foreach (var originalParameter in genericInstance.TypeArguments)
-                newRef.TypeArguments.Add(RewriteTypeRef(originalParameter));
-
-            return newRef;
+            var genericTypeContext = GetTypeContext(genericInstance);
+            if (genericTypeContext.ComputedTypeSpecifics == TypeRewriteContext.TypeSpecifics.GenericBlittableStruct && !IsUnmanaged(typeRef, context))
+            {
+                var type = sourceModule.DefaultImporter.ImportType(genericTypeContext.BoxedTypeContext.NewType);
+                var newRef = new GenericInstanceTypeSignature(type, type.IsValueType);
+                foreach (var originalParameter in genericInstance.TypeArguments)
+                    newRef.TypeArguments.Add(RewriteTypeRef(originalParameter, context, typeIsBoxed));
+
+                return newRef;
+            }
+            else
+            {
+                var genericType = RewriteTypeRef(genericInstance.GenericType.ToTypeSignature(), context, typeIsBoxed).ToTypeDefOrRef();
+                var newRef = new GenericInstanceTypeSignature(genericType, genericType.IsValueType);
+                foreach (var originalParameter in genericInstance.TypeArguments)
+                    newRef.TypeArguments.Add(RewriteTypeRef(originalParameter, context, typeIsBoxed));
+
+                return newRef;
+            }
         }
 
         if (typeRef.IsPrimitive() || typeRef.FullName == "System.TypedReference")
@@ -131,11 +165,76 @@
             return sourceModule.DefaultImporter.ImportType(GlobalContext.GetAssemblyByName("mscorlib")
                 .GetTypeByName("System.Attribute").NewType).ToTypeSignature();
 
-        var originalTypeDef = typeRef.Resolve()!;
-        var targetAssembly = GlobalContext.GetNewAssemblyForOriginal(originalTypeDef.Module!.Assembly!);
-        var target = targetAssembly.GetContextForOriginalType(originalTypeDef).NewType;
+        var target = GetTypeContext(typeRef);
+
+        if (typeIsBoxed && target.BoxedTypeContext != null)
+        {
+            target = target.BoxedTypeContext;
+        }
+
+        return sourceModule.DefaultImporter.ImportType(target.NewType).ToTypeSignature();
+    }
+
+    private TypeRewriteContext GetTypeContext(TypeSignature typeRef)
+    {
+        return GlobalContext.GetNewTypeForOriginal(typeRef.Resolve()!);
+    }
+
+    private bool IsUnmanaged(TypeSignature originalType, GenericParameterContext context)
+    {
+        if (originalType is GenericParameterSignature parameterSignature)
+        {
+            var genericParameter = context.GetGenericParameter(parameterSignature)!;
+            return genericParameter.IsUnmanaged();
+        }
+
+        if (originalType is GenericInstanceTypeSignature genericInstanceType)
+        {
+            foreach (TypeSignature genericArgument in genericInstanceType.TypeArguments)
+            {
+                if (!IsUnmanaged(genericArgument, context))
+                    return false;
+            }
+        }
+
+        var paramTypeContext = GetTypeContext(originalType);
+        return paramTypeContext.ComputedTypeSpecifics.IsBlittable();
+    }
+
+    public TypeDefinition GetOrInjectIsUnmanagedAttribute()
+    {
+        if (isUnmanagedAttributeType != null)
+            return isUnmanagedAttributeType;
+
+        var importer = NewAssembly.ManifestModule!.DefaultImporter;
+
+        isUnmanagedAttributeType = new TypeDefinition(
+            "System.Runtime.CompilerServices",
+            "IsUnmanagedAttribute",
+            TypeAttributes.AnsiClass | TypeAttributes.BeforeFieldInit | TypeAttributes.Public | TypeAttributes.Sealed,
+            importer.ImportType(typeof(Attribute)));
+
+        NewAssembly.ManifestModule!.TopLevelTypes.Add(isUnmanagedAttributeType);
+
+        var attributeCctr = new MethodDefinition(
+            ".ctor",
+            MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.RuntimeSpecialName | MethodAttributes.SpecialName,
+            MethodSignature.CreateInstance(NewAssembly.ManifestModule.Void()));
+        attributeCctr.CilMethodBody = new CilMethodBody(attributeCctr);
+
+        isUnmanagedAttributeType.Methods.Add(attributeCctr);
+        var ilProcessor = attributeCctr.CilMethodBody!.Instructions;
+        ilProcessor.Add(OpCodes.Ldarg_0);
+
+        var method = new MemberReference(
+            isUnmanagedAttributeType.BaseType!,
+            ".ctor",
+            MethodSignature.CreateInstance(NewAssembly.ManifestModule.Void()));
+
+        ilProcessor.Add(OpCodes.Call, importer.ImportMethod(method));
+        ilProcessor.Add(OpCodes.Ret);
 
-        return sourceModule.DefaultImporter.ImportType(target).ToTypeSignature();
+        return isUnmanagedAttributeType;
     }
 
     public TypeRewriteContext GetTypeByName(string name)

Il2CppInterop.Generator/Contexts/FieldRewriteContext.cs

@@ -51,7 +51,7 @@ private string UnmangleFieldNameBase(FieldDefinition field, GeneratorOptions opt
         var accessModString = MethodAccessTypeLabels[(int)(field.Attributes & FieldAttributes.FieldAccessMask)];
         var staticString = field.IsStatic ? "_Static" : "";
         return "field_" + accessModString + staticString + "_" +
-               DeclaringType.AssemblyContext.RewriteTypeRef(field.Signature!.FieldType).GetUnmangledName(field.DeclaringType);
+               DeclaringType.AssemblyContext.RewriteTypeRef(field.Signature!.FieldType, field.DeclaringType!.GetGenericParameterContext()).GetUnmangledName(field.DeclaringType);
     }
 
     private string UnmangleFieldName(FieldDefinition field, GeneratorOptions options,

Il2CppInterop.Generator/Contexts/MethodRewriteContext.cs

@@ -3,6 +3,7 @@
 using System.Text;
 using AsmResolver;
 using AsmResolver.DotNet;
+using AsmResolver.DotNet.Collections;
 using AsmResolver.DotNet.Signatures;
 using AsmResolver.PE.DotNet.Metadata.Tables;
 using Il2CppInterop.Common.XrefScans;
@@ -74,15 +75,24 @@ public MethodRewriteContext(TypeRewriteContext declaringType, MethodDefinition o
 
             foreach (var oldParameter in genericParams)
             {
-                newMethod.GenericParameters.Add(new GenericParameter(
-                    oldParameter.Name.MakeValidInSource(),
-                    oldParameter.Attributes.StripValueTypeConstraint()));
+                var genericParameter = new GenericParameter(oldParameter.Name.MakeValidInSource());
+                if (ShouldParameterBeBlittable(originalMethod, oldParameter.ToTypeSignature()))
+                {
+                    genericParameter.Attributes = oldParameter.Attributes;
+                    genericParameter.MakeUnmanaged(DeclaringType.AssemblyContext);
+                }
+                else
+                {
+                    genericParameter.Attributes = oldParameter.Attributes.StripValueTypeConstraint();
+                }
+
+                newMethod.GenericParameters.Add(genericParameter);
             }
         }
 
-        if (!Pass15GenerateMemberContexts.HasObfuscatedMethods && !passthroughNames &&
+        if (!Pass16GenerateMemberContexts.HasObfuscatedMethods && !passthroughNames &&
             originalMethod.Name.IsObfuscated(declaringType.AssemblyContext.GlobalContext.Options))
-            Pass15GenerateMemberContexts.HasObfuscatedMethods = true;
+            Pass16GenerateMemberContexts.HasObfuscatedMethods = true;
 
         FileOffset = originalMethod.ExtractOffset();
         // Workaround for garbage file offsets passed by Cpp2IL
@@ -92,6 +102,38 @@ public MethodRewriteContext(TypeRewriteContext declaringType, MethodDefinition o
             declaringType.AssemblyContext.GlobalContext.MethodStartAddresses.Add(FileOffset);
     }
 
+    private bool ShouldParameterBeBlittable(MethodDefinition method, GenericParameterSignature genericParameter)
+    {
+        if (HasGenericParameter(method.Signature!.ReturnType, genericParameter, out GenericParameter? parameter))
+        {
+            return parameter!.IsUnmanaged();
+        }
+
+        foreach (Parameter methodParameter in method.Parameters)
+        {
+            if (HasGenericParameter(methodParameter.ParameterType, genericParameter, out parameter))
+            {
+                return parameter!.IsUnmanaged();
+            }
+        }
+
+        return false;
+    }
+
+    private bool HasGenericParameter(TypeSignature typeReference, GenericParameterSignature inputGenericParameter, out GenericParameter? typeGenericParameter)
+    {
+        typeGenericParameter = null;
+        if (typeReference is not GenericInstanceTypeSignature genericInstance) return false;
+
+        var index = genericInstance.TypeArguments.IndexOf(inputGenericParameter);
+        if (index < 0) return false;
+
+        var globalContext = DeclaringType.AssemblyContext.GlobalContext;
+        var returnTypeContext = globalContext.GetNewTypeForOriginal(typeReference.Resolve()!);
+        typeGenericParameter = returnTypeContext.NewType.GenericParameters[index];
+        return true;
+    }
+
     public Utf8String? UnmangledName { get; private set; }
     public string? UnmangledNameWithSignature { get; private set; }
 
@@ -104,11 +146,14 @@ public MethodRewriteContext(TypeRewriteContext declaringType, MethodDefinition o
 
     public void CtorPhase2()
     {
-        UnmangledName = UnmangleMethodName();
-        UnmangledNameWithSignature = UnmangleMethodNameWithSignature();
+        // Make context manually, NewMethod.DeclaringType is null for now
+        var genericContext = new GenericParameterContext(DeclaringType.NewType, NewMethod);
+
+        UnmangledName = UnmangleMethodName(genericContext);
+        UnmangledNameWithSignature = UnmangleMethodNameWithSignature(genericContext);
 
         NewMethod.Name = UnmangledName;
-        NewMethod.Signature!.ReturnType = DeclaringType.AssemblyContext.RewriteTypeRef(OriginalMethod.Signature?.ReturnType);
+        NewMethod.Signature!.ReturnType = DeclaringType.AssemblyContext.RewriteTypeRef(OriginalMethod.Signature?.ReturnType, genericContext, DeclaringType.isBoxedTypeVariant);
 
         var nonGenericMethodInfoPointerField = new FieldDefinition(
             "NativeMethodInfoPtr_" + UnmangledNameWithSignature,
@@ -153,8 +198,9 @@ public void CtorPhase2()
                         continue;
                     }
 
-                    newParameter.Constraints.Add(new GenericParameterConstraint(
-                        DeclaringType.AssemblyContext.RewriteTypeRef(oldConstraint.Constraint?.ToTypeSignature()).ToTypeDefOrRef()));
+                    var newType = DeclaringType.AssemblyContext.RewriteTypeRef(oldConstraint.Constraint?.ToTypeSignature(), default, DeclaringType.isBoxedTypeVariant)
+                        .ToTypeDefOrRef();
+                    newParameter.Constraints.Add(new GenericParameterConstraint(newType));
                 }
             }
 
@@ -184,7 +230,7 @@ private MethodAttributes AdjustAttributes(MethodAttributes original, bool stripV
         return original;
     }
 
-    private string UnmangleMethodName()
+    private string UnmangleMethodName(GenericParameterContext context)
     {
         var method = OriginalMethod;
 
@@ -198,12 +244,12 @@ private string UnmangleMethodName()
             return ".ctor";
 
         if (method.Name.IsObfuscated(DeclaringType.AssemblyContext.GlobalContext.Options))
-            return UnmangleMethodNameWithSignature();
+            return UnmangleMethodNameWithSignature(context);
 
         return method.Name.MakeValidInSource();
     }
 
-    private string ProduceMethodSignatureBase()
+    private string ProduceMethodSignatureBase(GenericParameterContext context)
     {
         var method = OriginalMethod;
 
@@ -231,25 +277,25 @@ private string ProduceMethodSignatureBase()
                     builder.Append(str);
 
         builder.Append('_');
-        builder.Append(DeclaringType.AssemblyContext.RewriteTypeRef(method.Signature?.ReturnType).GetUnmangledName(method.DeclaringType, method));
+        builder.Append(DeclaringType.AssemblyContext.RewriteTypeRef(method.Signature?.ReturnType, context, DeclaringType.isBoxedTypeVariant).GetUnmangledName(method.DeclaringType, method));
 
         foreach (var param in method.Parameters)
         {
             builder.Append('_');
-            builder.Append(DeclaringType.AssemblyContext.RewriteTypeRef(param.ParameterType).GetUnmangledName(method.DeclaringType, method));
+            builder.Append(DeclaringType.AssemblyContext.RewriteTypeRef(param.ParameterType, context, DeclaringType.isBoxedTypeVariant).GetUnmangledName(method.DeclaringType, method));
         }
 
         var address = Rva;
-        if (address != 0 && Pass15GenerateMemberContexts.HasObfuscatedMethods &&
-            !Pass16ScanMethodRefs.NonDeadMethods.Contains(address)) builder.Append("_PDM");
+        if (address != 0 && Pass16GenerateMemberContexts.HasObfuscatedMethods &&
+            !Pass17ScanMethodRefs.NonDeadMethods.Contains(address)) builder.Append("_PDM");
 
         return builder.ToString();
     }
 
 
-    private string UnmangleMethodNameWithSignature()
+    private string UnmangleMethodNameWithSignature(GenericParameterContext context)
     {
-        var unmangleMethodNameWithSignature = ProduceMethodSignatureBase() + "_" + DeclaringType.Methods
+        var unmangleMethodNameWithSignature = ProduceMethodSignatureBase(context) + "_" + DeclaringType.Methods
             .Where(ParameterSignatureMatchesThis).TakeWhile(it => it != this).Count();
 
         if (DeclaringType.AssemblyContext.GlobalContext.Options.RenameMap.TryGetValue(
@@ -296,13 +342,13 @@ private bool ParameterSignatureMatchesThis(MethodRewriteContext otherRewriteCont
             if (a[i].ParameterType.FullName != b[i].ParameterType.FullName)
                 return false;
 
-        if (Pass15GenerateMemberContexts.HasObfuscatedMethods)
+        if (Pass16GenerateMemberContexts.HasObfuscatedMethods)
         {
             var addressA = otherRewriteContext.Rva;
             var addressB = Rva;
             if (addressA != 0 && addressB != 0)
-                if (Pass16ScanMethodRefs.NonDeadMethods.Contains(addressA) !=
-                    Pass16ScanMethodRefs.NonDeadMethods.Contains(addressB))
+                if (Pass17ScanMethodRefs.NonDeadMethods.Contains(addressA) !=
+                    Pass17ScanMethodRefs.NonDeadMethods.Contains(addressB))
                     return false;
         }