Improvements to struct interop for DOTS

Il2CppInterop.Generator/Contexts/AssemblyRewriteContext.cs

@@ -32,7 +32,7 @@ public AssemblyRewriteContext(RewriteGlobalContext globalContext, AssemblyDefini
             mod => new RuntimeAssemblyReferences(mod, globalContext));
     }
 
-    public IEnumerable<TypeRewriteContext> Types => myOldTypeMap.Values;
+    public IEnumerable<TypeRewriteContext> Types => myNewTypeMap.Values;
 
     public TypeRewriteContext GetContextForOriginalType(TypeDefinition type)
     {
@@ -51,10 +51,12 @@ public TypeRewriteContext GetContextForNewType(TypeDefinition type)
 
     public void RegisterTypeRewrite(TypeRewriteContext context)
     {
-        if (context.OriginalType != null)
+        var exists = context.OriginalType != null && myOldTypeMap.ContainsKey(context.OriginalType);
+        if (context.OriginalType != null && !exists)
             myOldTypeMap[context.OriginalType] = context;
         myNewTypeMap[context.NewType] = context;
-        myNameTypeMap[(context.OriginalType ?? context.NewType).FullName] = context;
+        if (!exists)
+            myNameTypeMap[(context.OriginalType ?? context.NewType).FullName] = context;
     }
 
     public MethodReference RewriteMethodRef(MethodReference methodRef)
@@ -63,7 +65,7 @@ public MethodReference RewriteMethodRef(MethodReference methodRef)
         return newType.GetMethodByOldMethod(methodRef.Resolve()).NewMethod;
     }
 
-    public TypeReference RewriteTypeRef(TypeReference? typeRef)
+    public TypeReference RewriteTypeRef(TypeReference? typeRef, bool typeIsBoxed)
     {
         if (typeRef == null) return Imports.Il2CppObjectBase;
 
@@ -78,7 +80,7 @@ public TypeReference RewriteTypeRef(TypeReference? typeRef)
             if (elementType.FullName == "System.String")
                 return Imports.Il2CppStringArray;
 
-            var convertedElementType = RewriteTypeRef(elementType);
+            var convertedElementType = RewriteTypeRef(elementType, typeIsBoxed);
             if (elementType.IsGenericParameter)
                 return new GenericInstanceType(Imports.Il2CppArrayBase) { GenericArguments = { convertedElementType } };
 
@@ -92,24 +94,36 @@ public TypeReference RewriteTypeRef(TypeReference? typeRef)
         {
             var genericParameterDeclaringType = genericParameter.DeclaringType;
             if (genericParameterDeclaringType != null)
-                return RewriteTypeRef(genericParameterDeclaringType).GenericParameters[genericParameter.Position];
+                return RewriteTypeRef(genericParameterDeclaringType, typeIsBoxed).GenericParameters[genericParameter.Position];
 
             return RewriteMethodRef(genericParameter.DeclaringMethod).GenericParameters[genericParameter.Position];
         }
 
         if (typeRef is ByReferenceType byRef)
-            return new ByReferenceType(RewriteTypeRef(byRef.ElementType));
+            return new ByReferenceType(RewriteTypeRef(byRef.ElementType, typeIsBoxed));
 
         if (typeRef is PointerType pointerType)
-            return new PointerType(RewriteTypeRef(pointerType.ElementType));
+            return new PointerType(RewriteTypeRef(pointerType.ElementType, typeIsBoxed));
 
         if (typeRef is GenericInstanceType genericInstance)
         {
-            var newRef = new GenericInstanceType(RewriteTypeRef(genericInstance.ElementType));
-            foreach (var originalParameter in genericInstance.GenericArguments)
-                newRef.GenericArguments.Add(RewriteTypeRef(originalParameter));
-
-            return newRef;
+            var genericTypeContext = GetTypeContext(genericInstance);
+            if (genericTypeContext.ComputedTypeSpecifics == TypeRewriteContext.TypeSpecifics.GenericBlittableStruct && !IsUnmanaged(typeRef, typeIsBoxed))
+            {
+                var newRef = new GenericInstanceType(sourceModule.ImportReference(genericTypeContext.BoxedTypeContext.NewType));
+                foreach (var originalParameter in genericInstance.GenericArguments)
+                    newRef.GenericArguments.Add(RewriteTypeRef(originalParameter, typeIsBoxed));
+
+                return newRef;
+            }
+            else
+            {
+                var newRef = new GenericInstanceType(RewriteTypeRef(genericInstance.ElementType, typeIsBoxed));
+                foreach (var originalParameter in genericInstance.GenericArguments)
+                    newRef.GenericArguments.Add(RewriteTypeRef(originalParameter, typeIsBoxed));
+
+                return newRef;
+            }
         }
 
         if (typeRef.IsPrimitive || typeRef.FullName == "System.TypedReference")
@@ -129,11 +143,44 @@ public TypeReference RewriteTypeRef(TypeReference? typeRef)
             return sourceModule.ImportReference(GlobalContext.GetAssemblyByName("mscorlib")
                 .GetTypeByName("System.Attribute").NewType);
 
-        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.ImportReference(target.NewType);
+    }
+
+    private TypeRewriteContext GetTypeContext(TypeReference typeRef)
+    {
+        var typeDef = typeRef.Resolve();
+        var targetAssembly = GlobalContext.GetNewAssemblyForOriginal(typeDef.Module.Assembly);
+        var typeContext = targetAssembly.GetContextForOriginalType(typeDef);
+
+        return typeContext;
+    }
+
+    private bool IsUnmanaged(TypeReference originalType, bool typeIsBoxed)
+    {
+        if (originalType is GenericParameter genericParameter)
+        {
+            GenericParameter newGenericParameter = (GenericParameter)RewriteTypeRef(genericParameter, typeIsBoxed);
+            return newGenericParameter.CustomAttributes.Any(attribute => attribute.AttributeType.Name.Equals("IsUnmanagedAttribute"));
+        }
+
+        if (originalType is GenericInstanceType genericInstanceType)
+        {
+            foreach (TypeReference genericArgument in genericInstanceType.GenericArguments)
+            {
+                if (!IsUnmanaged(genericArgument, typeIsBoxed))
+                    return false;
+            }
+        }
 
-        return sourceModule.ImportReference(target);
+        var paramTypeContext = GetTypeContext(originalType);
+        return paramTypeContext.ComputedTypeSpecifics.IsBlittable();
     }
 
     public TypeRewriteContext GetTypeByName(string name)

Il2CppInterop.Generator/Contexts/FieldRewriteContext.cs

@@ -48,7 +48,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.FieldType).GetUnmangledName();
+               DeclaringType.AssemblyContext.RewriteTypeRef(field.FieldType, false).GetUnmangledName();
     }
 
     private string UnmangleFieldName(FieldDefinition field, GeneratorOptions options,

Il2CppInterop.Generator/Contexts/MethodRewriteContext.cs

@@ -100,7 +100,7 @@ public void CtorPhase2()
         UnmangledNameWithSignature = UnmangleMethodNameWithSignature();
 
         NewMethod.Name = UnmangledName;
-        NewMethod.ReturnType = DeclaringType.AssemblyContext.RewriteTypeRef(OriginalMethod.ReturnType);
+        NewMethod.ReturnType = DeclaringType.AssemblyContext.RewriteTypeRef(OriginalMethod.ReturnType, DeclaringType.isBoxedTypeVariant);
 
         var nonGenericMethodInfoPointerField = new FieldDefinition(
             "NativeMethodInfoPtr_" + UnmangledNameWithSignature,
@@ -140,7 +140,7 @@ public void CtorPhase2()
                         oldConstraint.ConstraintType.Resolve()?.IsInterface == true) continue;
 
                     newParameter.Constraints.Add(new GenericParameterConstraint(
-                        DeclaringType.AssemblyContext.RewriteTypeRef(oldConstraint.ConstraintType)));
+                        DeclaringType.AssemblyContext.RewriteTypeRef(oldConstraint.ConstraintType, DeclaringType.isBoxedTypeVariant)));
                 }
             }
 
@@ -220,12 +220,12 @@ private string ProduceMethodSignatureBase()
                 builder.Append(str);
 
         builder.Append('_');
-        builder.Append(DeclaringType.AssemblyContext.RewriteTypeRef(method.ReturnType).GetUnmangledName());
+        builder.Append(DeclaringType.AssemblyContext.RewriteTypeRef(method.ReturnType, DeclaringType.isBoxedTypeVariant).GetUnmangledName());
 
         foreach (var param in method.Parameters)
         {
             builder.Append('_');
-            builder.Append(DeclaringType.AssemblyContext.RewriteTypeRef(param.ParameterType).GetUnmangledName());
+            builder.Append(DeclaringType.AssemblyContext.RewriteTypeRef(param.ParameterType, DeclaringType.isBoxedTypeVariant).GetUnmangledName());
         }
 
         var address = Rva;

Il2CppInterop.Generator/Contexts/TypeRewriteContext.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using Il2CppInterop.Generator.Passes;
 using Il2CppInterop.Generator.Utils;
 using Mono.Cecil;
 
@@ -13,6 +14,7 @@ public enum TypeSpecifics
         Computing,
         ReferenceType,
         BlittableStruct,
+        GenericBlittableStruct,
         NonBlittableStruct
     }
 
@@ -22,6 +24,8 @@ public enum TypeSpecifics
     private readonly Dictionary<MethodDefinition, MethodRewriteContext> myMethodContexts = new();
     private readonly Dictionary<string, MethodRewriteContext> myMethodContextsByName = new();
     public readonly TypeDefinition NewType;
+    public TypeRewriteContext BoxedTypeContext;
+    public bool isBoxedTypeVariant;
 
     public readonly bool OriginalNameWasObfuscated;
     public readonly TypeDefinition OriginalType;
@@ -37,7 +41,8 @@ public TypeRewriteContext(AssemblyRewriteContext assemblyContext, TypeDefinition
 
         if (OriginalType == null) return;
 
-        OriginalNameWasObfuscated = OriginalType.Name != NewType.Name;
+        OriginalNameWasObfuscated = OriginalType.Name != NewType.Name &&
+                                    Pass12CreateGenericNonBlittableTypes.GetNewName(originalType.Name) != NewType.Name;
         if (OriginalNameWasObfuscated)
             NewType.CustomAttributes.Add(new CustomAttribute(assemblyContext.Imports.ObfuscatedNameAttributector.Value)
             {
@@ -49,8 +54,6 @@ public TypeRewriteContext(AssemblyRewriteContext assemblyContext, TypeDefinition
             ComputedTypeSpecifics = TypeSpecifics.ReferenceType;
         else if (OriginalType.IsEnum)
             ComputedTypeSpecifics = TypeSpecifics.BlittableStruct;
-        else if (OriginalType.HasGenericParameters)
-            ComputedTypeSpecifics = TypeSpecifics.NonBlittableStruct; // not reference type, covered by first if
     }
 
     public FieldReference ClassPointerFieldRef { get; private set; }

Il2CppInterop.Generator/Extensions/EnumEx.cs

@@ -1,3 +1,4 @@
+using Il2CppInterop.Generator.Contexts;
 using Mono.Cecil;
 
 namespace Il2CppInterop.Generator.Extensions;
@@ -16,4 +17,10 @@ public static GenericParameterAttributes StripValueTypeConstraint(
         return parameterAttributes & ~(GenericParameterAttributes.NotNullableValueTypeConstraint |
                                        GenericParameterAttributes.VarianceMask);
     }
+
+    public static bool IsBlittable(this TypeRewriteContext.TypeSpecifics typeSpecifics)
+    {
+        return typeSpecifics == TypeRewriteContext.TypeSpecifics.BlittableStruct ||
+               typeSpecifics == TypeRewriteContext.TypeSpecifics.GenericBlittableStruct;
+    }
 }

Il2CppInterop.Generator/Extensions/ILGeneratorEx.cs

@@ -223,6 +223,12 @@ public static void EmitObjectToPointer(this ILProcessor body, TypeReference orig
             body.Emit(OpCodes.Ldarg, argumentIndex);
             body.Emit(OpCodes.Call, imports.IL2CPP_ManagedStringToIl2Cpp.Value);
         }
+        else if (originalType.IsPointer)
+        {
+            body.Emit(OpCodes.Ldarg, argumentIndex);
+            body.Emit(OpCodes.Call, new MethodReference("op_Explicit", imports.Module.IntPtr(), imports.Module.IntPtr())
+            { Parameters = { new ParameterDefinition(imports.Module.ImportReference(typeof(void*))) } });
+        }
         else
         {
             body.Emit(OpCodes.Ldarg, argumentIndex);
@@ -352,6 +358,13 @@ public static void EmitPointerToObject(this ILProcessor body, TypeReference orig
             { HasThis = false, Parameters = { new ParameterDefinition(imports.Module.IntPtr()) } };
             body.Emit(OpCodes.Call, methodRef);
         }
+        else if (originalReturnType.IsPointer)
+        {
+            body.Append(loadPointer);
+            body.Emit(OpCodes.Call,
+                new MethodReference("op_Explicit", imports.Module.ImportReference(typeof(void*)), imports.Module.IntPtr())
+                { Parameters = { new ParameterDefinition(imports.Module.IntPtr()) } });
+        }
         else
         {
             var createRealObject = body.Create(OpCodes.Newobj,
@@ -383,6 +396,7 @@ private static void EmitPointerToObjectGeneric(ILProcessor body, TypeReference o
 
         body.Emit(extraDerefForNonValueTypes ? OpCodes.Ldc_I4_1 : OpCodes.Ldc_I4_0);
         body.Emit(unboxValueType ? OpCodes.Ldc_I4_1 : OpCodes.Ldc_I4_0);
+
         body.Emit(OpCodes.Call,
             imports.Module.ImportReference(new GenericInstanceMethod(imports.IL2CPP_PointerToValueGeneric.Value)
             { GenericArguments = { newReturnType } }));