Core: Fix wasm signature calculation (hopefully for good?)

Author: SamboyCoding

Cpp2IL.Core/InstructionSets/WasmInstructionSet.cs

@@ -20,12 +20,12 @@ public override Memory<byte> GetRawBytesForMethod(MethodAnalysisContext context,
 
             if (wasmDef == null)
             {
-                Logger.WarnNewline($"Could not find WASM definition for method {methodDefinition.HumanReadableSignature} in {methodDefinition.DeclaringType?.FullName}, probably incorrect signature calculation (signature was {WasmUtils.BuildSignature(context)})", "WasmInstructionSet");
+                Logger.WarnNewline($"Could not find WASM definition for method {methodDefinition.HumanReadableSignature} in {methodDefinition.DeclaringType?.FullName}, probably incorrect signature calculation (signature was {WasmUtils.BuildSignature(context)}, index is {context.UnderlyingPointer})", "WasmInstructionSet");
                 return Array.Empty<byte>();
             }
 
             if (wasmDef.AssociatedFunctionBody == null)
-                throw new($"WASM definition {wasmDef}, resolved from MethodAnalysisContext {context.Definition.HumanReadableSignature} in {context.DeclaringType?.FullName} has no associated function body (signature was {WasmUtils.BuildSignature(context)})");
+                throw new($"WASM definition {wasmDef}, resolved from MethodAnalysisContext {context.Definition.HumanReadableSignature} in {context.DeclaringType?.FullName} has no associated function body (signature was {WasmUtils.BuildSignature(context)}, index is {context.UnderlyingPointer})");
 
             return wasmDef.AssociatedFunctionBody.Instructions;
         }

Cpp2IL.Core/Utils/WasmUtils.cs

@@ -32,10 +32,9 @@ public static string BuildSignature(MethodAnalysisContext definition)
             : definition.ReturnType switch
             {
                 { Namespace: nameof(System), Name: "Void" } => "v",
-                { IsValueType: true, Definition: null or { Size: < 0 or > 8 } } => "vi", //Large or Generic Struct returns have a void return type, but the actual return value is the first parameter.
-                { IsValueType: true, Definition.Size: > 4 } => "j", //Medium structs are returned as longs
-                { IsValueType: true, Definition.Size: <= 4 } => "i", //Small structs are returned as ints
-                _ => GetSignatureLetter(definition.ReturnType!)
+                { IsValueType: true, Definition: null or { Size: > 8 } } => "vi", //Large or Generic Struct returns have a void return type, but the actual return value is the first parameter.
+                { IsValueType: true, Definition.Size: > 0 and < 4 } => "i", //Small structs are returned as ints
+                _ => GetSignatureLetter(definition.ReturnType!, forReturn: true)
             };
 
         return $"{returnTypeSignature}{instanceParam}{string.Join("", definition.Parameters!.Select(p => GetSignatureLetter(p.ParameterType, p.IsRef)))}i"; //Add an extra i on the end for the method info param
@@ -49,7 +48,7 @@ public static bool IsWasmPrimitive(this TypeAnalysisContext type)
         return typeEnum is >= Il2CppTypeEnum.IL2CPP_TYPE_BOOLEAN and <= Il2CppTypeEnum.IL2CPP_TYPE_R8;
     }
 
-    private static string GetSignatureLetter(TypeAnalysisContext type, bool isRefOrOut = false)
+    private static string GetSignatureLetter(TypeAnalysisContext type, bool isRefOrOut = false, bool forReturn = false)
     {
         if (isRefOrOut)
             //ref/out params are passed as pointers 
@@ -62,6 +61,13 @@ private static string GetSignatureLetter(TypeAnalysisContext type, bool isRefOrO
         if (type.IsEnumType)
             type = type.EnumUnderlyingType ?? throw new($"Enum type {type} has no underlying type");
 
+        if (type.IsValueType && type is { Namespace: nameof(System), Name: nameof(DateTime) or nameof(TimeSpan) })
+            return "j"; //gross hardcoding but i think this is literally the only 2 cases?
+        
+        if(forReturn && type.IsValueType && type.Fields.Count(f => !f.IsStatic && (f.Attributes & FieldAttributes.Literal) == 0) > 1)
+            //this seems to work in my testing, at least
+            return "vi";
+
         // var typeDefinition = type.BaseType ?? type.AppContext.SystemTypes.SystemInt32Type;
 
         return type.Name switch
@@ -71,7 +77,6 @@ private static string GetSignatureLetter(TypeAnalysisContext type, bool isRefOrO
             "Single" => "f",
             "Double" => "d",
             "Int32" => "i",
-            _ when !type.IsWasmPrimitive() && type is { IsValueType: true, IsEnumType: false, Definition.Size: <= 8 and > 0 } => "j", //TODO check - value types < 16 bytes (including base object header which is irrelevant here) are passed directly as long?
             _ => "i"
         };
     }