Core: Factor out largely-incorrect IsPrimitive prop on TypeAnalysisContext

Author: SamboyCoding

Cpp2IL.Core/Model/Contexts/SystemTypesContext.cs

@@ -69,24 +69,6 @@ public SystemTypesContext(ApplicationAnalysisContext appContext)
         UnmanagedCallersOnlyAttributeType = systemAssembly.GetTypeByFullName("System.Runtime.InteropServices.UnmanagedCallersOnlyAttribute");
     }
 
-    public bool IsPrimitive(TypeAnalysisContext context)
-    {
-        return context == SystemBooleanType || 
-               context == SystemCharType || 
-               context == SystemSByteType || 
-               context == SystemByteType ||
-               context == SystemInt16Type || 
-               context == SystemUInt16Type || 
-               context == SystemInt32Type || 
-               context == SystemUInt32Type || 
-               context == SystemInt64Type ||
-               context == SystemUInt64Type || 
-               context == SystemSingleType || 
-               context == SystemDoubleType || 
-               context == SystemIntPtrType ||
-               context == SystemUIntPtrType;
-    }
-
     public bool TryGetIl2CppTypeEnum(TypeAnalysisContext context, out Il2CppTypeEnum value)
     {
         if (context == SystemBooleanType)

Cpp2IL.Core/Model/Contexts/TypeAnalysisContext.cs

@@ -76,21 +76,6 @@ public class TypeAnalysisContext : HasCustomAttributesAndName, ITypeInfoProvider
     public TypeAnalysisContext? BaseType => OverrideBaseType ?? (Definition == null ? null : DeclaringAssembly.ResolveIl2CppType(Definition.RawBaseType));
 
     public TypeAnalysisContext[] InterfaceContexts => (Definition?.RawInterfaces.Select(DeclaringAssembly.ResolveIl2CppType).ToArray() ?? [])!;
-    
-    public bool IsPrimitive
-    {
-        get
-        {
-            if (Definition == null)
-                return false;
-
-            if (Definition.RawType?.Type.IsIl2CppPrimitive() == true)
-                return true;
-            
-            //Might still be TYPE_CLASS but yet int or something, so check it directly
-            return AppContext.SystemTypes.IsPrimitive(this);
-        }
-    }
 
     public virtual Il2CppTypeEnum Type
     {

Cpp2IL.Core/Model/CustomAttributes/CustomAttributeTypeParameter.cs

@@ -54,7 +54,7 @@ public override string ToString()
         if (TypeContext == null)
             return "(Type) null";
 
-        if (TypeContext.IsPrimitive)
+        if (TypeContext.Type is var typeEnum && typeEnum.IsIl2CppPrimitive())
             return $"typeof({LibCpp2ILUtils.GetTypeName(TypeContext.Type)}";
 
         if (TypeContext is ReferencedTypeAnalysisContext)

Cpp2IL.Core/OutputFormats/WasmNameSectionOutputFormat.cs

@@ -60,8 +60,7 @@ public override void DoOutput(ApplicationAnalysisContext context, string outputR
                 if (!v.method.IsStatic)
                     parameters.Insert(0, "this");
 
-                if (v.method.ReturnTypeContext is
-                    { IsValueType: true, IsPrimitive: true, Definition: null or { Size: > 8 } })
+                if (v.method.ReturnTypeContext is { IsValueType: true, Definition: null or { Size: > 8 } } rt && rt.IsWasmPrimitive()) //TODO Check - I think this IsWasmPrimitive check is inverted but I just ported what it was
                     parameters.Insert(0, "out");
 
                 parameters.Add("methodInfo"); // Only for some methods...?

Cpp2IL.Core/Utils/WasmUtils.cs

@@ -5,6 +5,7 @@
 using System.Text.RegularExpressions;
 using Cpp2IL.Core.Model.Contexts;
 using LibCpp2IL;
+using LibCpp2IL.BinaryStructures;
 using LibCpp2IL.Metadata;
 using LibCpp2IL.Reflection;
 using LibCpp2IL.Wasm;
@@ -26,18 +27,28 @@ public static string BuildSignature(MethodAnalysisContext definition)
         //It feels like it's something to do with when DateTime is considered a struct and when it's considered a class.
         //But I can find no rhyme nor reason to it.
 
-        var returnTypeSignature = definition.ReturnTypeContext switch
-        {
-            { Namespace: nameof(System), Name: "Void" } => "v",
-            { IsValueType: true, IsPrimitive: false, 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, IsPrimitive: false, Definition.Size: > 4 } => "j", //Medium structs are returned as longs
-            { IsValueType: true, IsPrimitive: false, Definition.Size: <= 4 } => "i", //Small structs are returned as ints
-            _ => GetSignatureLetter(definition.ReturnTypeContext!)
-        };
+        var returnTypeSignature = definition.ReturnTypeContext.IsWasmPrimitive()
+            ? GetSignatureLetter(definition.ReturnTypeContext)
+            : definition.ReturnTypeContext 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.ReturnTypeContext!)
+            };
 
         return $"{returnTypeSignature}{instanceParam}{string.Join("", definition.Parameters!.Select(p => GetSignatureLetter(p.ParameterTypeContext, p.IsRef)))}i"; //Add an extra i on the end for the method info param
     }
 
+    public static bool IsWasmPrimitive(this TypeAnalysisContext type)
+    {
+        var typeEnum = type.Type;
+
+        //TODO Validate this, it's only the remnant from some poorly written logic for checking if a TypeAnalysisContext IsPrimitive.
+        return typeEnum is >= Il2CppTypeEnum.IL2CPP_TYPE_BOOLEAN and <= Il2CppTypeEnum.IL2CPP_TYPE_R8;
+    }
+
     private static string GetSignatureLetter(TypeAnalysisContext type, bool isRefOrOut = false)
     {
         if (isRefOrOut)
@@ -60,7 +71,7 @@ private static string GetSignatureLetter(TypeAnalysisContext type, bool isRefOrO
             "Single" => "f",
             "Double" => "d",
             "Int32" => "i",
-            _ when type is { IsValueType: true, IsPrimitive: false, 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?
+            _ 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"
         };
     }