WIP: V2 Rewrite

.editorconfig

@@ -11,10 +11,29 @@ insert_final_newline = true
 indent_style = space
 indent_size = 4
 trim_trailing_whitespace = true
+end_of_line = lf
 
 # Generated code
 [*{_AssemblyInfo.cs,.notsupported.cs,AsmOffsets.cs}]
 generated_code = true
+dotnet_style_coalesce_expression = true:suggestion
+dotnet_style_null_propagation = true:suggestion
+dotnet_style_prefer_is_null_check_over_reference_equality_method = true:suggestion
+dotnet_style_prefer_auto_properties = true:suggestion
+dotnet_style_object_initializer = true:suggestion
+dotnet_style_collection_initializer = true:suggestion
+dotnet_style_prefer_simplified_boolean_expressions = true:suggestion
+dotnet_style_prefer_conditional_expression_over_assignment = true:silent
+dotnet_style_prefer_conditional_expression_over_return = true:silent
+dotnet_style_explicit_tuple_names = true:suggestion
+dotnet_style_prefer_inferred_tuple_names = true:suggestion
+dotnet_style_prefer_inferred_anonymous_type_member_names = true:suggestion
+dotnet_style_prefer_compound_assignment = true:suggestion
+dotnet_style_operator_placement_when_wrapping = beginning_of_line
+tab_width = 4
+end_of_line = lf
+dotnet_style_prefer_simplified_interpolation = true:suggestion
+dotnet_style_prefer_collection_expression = when_types_loosely_match:suggestion
 
 # C# files
 [*.cs]
@@ -54,15 +73,15 @@ dotnet_style_predefined_type_for_member_access = true:suggestion
 # name all constant fields using PascalCase
 dotnet_naming_rule.constant_fields_should_be_pascal_case.severity = suggestion
 dotnet_naming_rule.constant_fields_should_be_pascal_case.symbols  = constant_fields
-dotnet_naming_rule.constant_fields_should_be_pascal_case.style    = pascal_case_style
+dotnet_naming_rule.constant_fields_should_be_pascal_case.style = pascal_case_style
 dotnet_naming_symbols.constant_fields.applicable_kinds   = field
 dotnet_naming_symbols.constant_fields.required_modifiers = const
 dotnet_naming_style.pascal_case_style.capitalization = pascal_case
 
 # static fields should have s_ prefix
 dotnet_naming_rule.static_fields_should_have_prefix.severity = suggestion
 dotnet_naming_rule.static_fields_should_have_prefix.symbols  = static_fields
-dotnet_naming_rule.static_fields_should_have_prefix.style    = static_prefix_style
+dotnet_naming_rule.static_fields_should_have_prefix.style = static_prefix_style
 dotnet_naming_symbols.static_fields.applicable_kinds   = field
 dotnet_naming_symbols.static_fields.required_modifiers = static
 dotnet_naming_symbols.static_fields.applicable_accessibilities = private, internal, private_protected
@@ -72,7 +91,7 @@ dotnet_naming_style.static_prefix_style.capitalization = camel_case
 # internal and private fields should be _camelCase
 dotnet_naming_rule.camel_case_for_private_internal_fields.severity = suggestion
 dotnet_naming_rule.camel_case_for_private_internal_fields.symbols  = private_internal_fields
-dotnet_naming_rule.camel_case_for_private_internal_fields.style    = camel_case_underscore_style
+dotnet_naming_rule.camel_case_for_private_internal_fields.style = camel_case_underscore_style
 dotnet_naming_symbols.private_internal_fields.applicable_kinds = field
 dotnet_naming_symbols.private_internal_fields.applicable_accessibilities = private, internal
 dotnet_naming_style.camel_case_underscore_style.required_prefix = _
@@ -150,6 +169,11 @@ csharp_space_between_method_declaration_name_and_open_parenthesis = false
 csharp_space_between_method_declaration_parameter_list_parentheses = false
 csharp_space_between_parentheses = false
 csharp_space_between_square_brackets = false
+csharp_style_namespace_declarations = block_scoped:silent
+csharp_style_prefer_method_group_conversion = true:silent
+csharp_style_prefer_top_level_statements = true:silent
+csharp_style_prefer_primary_constructors = true:suggestion
+csharp_prefer_system_threading_lock = true:suggestion
 
 # C++ Files
 [*.{cpp,h,in}]

.github/workflows/dotnet.yml

@@ -16,7 +16,7 @@ jobs:
       - name: Setup .NET
         uses: actions/setup-dotnet@v4
         with:
-          global-json-file: global.json
+          dotnet-version: 10.0.x
 
       - name: Extract Release Version
         id: get_version

.github/workflows/format_check.yml

@@ -16,7 +16,7 @@ jobs:
       - name: Setup .NET
         uses: actions/setup-dotnet@v4
         with:
-          global-json-file: global.json
+          dotnet-version: 10.0.x
 
       - name: Check format
         run: |

Directory.Build.props

@@ -7,7 +7,6 @@
     <LangVersion>latest</LangVersion>
     <Nullable>disable</Nullable>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <RootNamespace>Il2CppInterop</RootNamespace>
     <LangVersion>latest</LangVersion>
     <PackageIcon>logo_icon.png</PackageIcon>
     <PackageLicenseExpression>LGPL-3.0-only</PackageLicenseExpression>

Documentation/Design/Arrays.md

@@ -0,0 +1,10 @@
+# Arrays
+
+## Array Types
+
+Il2Cpp arrays are represented with a closed type hierarchy.
+
+* `Il2CppArrayBase`
+* `Il2CppArrayBase<T>`
+
+`Il2CppArrayBase<T>` is the type used everywhere. `Il2CppArrayBase` is just for unstripping certain op codes.

Documentation/Design/Attributes.md

@@ -0,0 +1,3 @@
+# Attributes
+
+Attributes are not applied to types.

Documentation/Design/CorLibTypes.md

@@ -0,0 +1,187 @@
+# Core Library Types
+
+## Numeric Primitives, `char`, and `bool`
+
+These are blittable and should be directly reused, kind of. Signatures will use the Il2Cpp types, but implicit conversions will be used inside unstripped method bodies.
+
+```cs
+public static Il2CppSystem.Int32 Add(Il2CppSystem.Int32 x, Il2CppSystem.Int32 y)
+{
+    // Conversions to Managed are applied on function entry
+    ref 
+    int x2 = (int)x;
+    int y2 = (int)y;
+
+    // All operations are done with managed types
+    int z = x2 + y2;
+
+    // If an Il2Cpp primitive must be returned, conversion back is applied right before the return instruction.
+    return (Il2CppSystem.Int32)z;
+}
+```
+
+This ensures that CIL opcodes function as expected. However, it can cause some complexities with instance methods on the corlib types. For that, unsafe helpers are used.
+
+```cs
+public static Il2CppSystem.String Sum(Il2CppSystem.Int32 x, Il2CppSystem.Int32 y)
+{
+    int z = (int)x + (int)y;
+    return Unsafe.As<int, Il2CppSystem.Int32>(ref z).ToString();
+}
+```
+
+## `string`
+
+Strings should not be implicitly marshalled. In other words, `Il2CppSystem.String` should be used.
+
+## `object`
+
+For compatibility with interfaces and value types, this should be emitted as-is, despite the more complicated marshalling involved.
+
+## `Attribute`
+
+## `ValueType` and `Enum`
+
+Boxing to these types is invalid.
+
+## `Exception`
+
+## Counterargument to all of the above
+
+```cs
+// Original code
+public static void DoSomething<T>(T value) where T : System.IConvertible
+{
+}
+public static void DoSomethingElse()
+{
+    DoSomething<System.Enum>(System.StringComparison.Ordinal);
+    DoSomething<System.StringComparison>(default);
+    DoSomething<int>(default);
+}
+
+// Unstripped code
+public static void DoSomething<T>() where T : Il2CppSystem.IConvertible
+{
+}
+public static void DoSomethingElse()
+{
+    // Which is correct?
+    // System.Enum fails the constraint check.
+    // Il2CppSystem.Enum makes the method unusable because boxed enums inherit from `System.Enum` not `Il2CppSystem.Enum`.
+    DoSomething<System.Enum>(Il2CppSystem.StringComparison.Ordinal);
+    DoSomething<Il2CppSystem.Enum>(Il2CppSystem.StringComparison.Ordinal);
+    DoSomething<Il2CppSystem.Enum>(Cast(Il2CppSystem.StringComparison.Ordinal)); // Maybe this is the way it should be emitted?
+
+    // If the type is a real enum, it fails the constraint check.
+    DoSomething<Il2CppSystem.StringComparison>(default);
+
+    // Which is correct?
+    // int fails the constraint check, but is what we currently do.
+    DoSomething<int>(default);
+    DoSomething<Il2CppSystem.Int32>(default);
+}
+private static Il2CppSystem.Enum Cast(object value)
+{
+   if (value is Il2CppSystem.Enum il2cppEnum)
+    {
+        return il2cppEnum;
+    }
+    if (value is System.Enum sysEnum)
+    {
+        throw new NotImplementedException("Cannot cast System.Enum to Il2CppSystem.Enum");
+    }
+    throw new InvalidCastException("Cannot cast to Il2CppSystem.Enum");
+}
+
+// Proposal
+public static void DoSomething<T>() where T : Il2CppSystem.IConvertible
+{
+}
+public static void DoSomethingElse()
+{
+    DoSomething<Il2CppSystem.IEnum>(Il2CppSystem.StringComparison.Ordinal);
+    DoSomething<Il2CppSystem.StringComparison>(default);
+    DoSomething<Il2CppSystem.Int32>(default);
+}
+namespace Il2CppSystem
+{
+    public interface IObject
+    {
+        // Instance members of Il2CppSystem.Object
+    }
+    public interface IValueType : IObject
+    {
+        // No members
+    }
+    public interface IEnum : IValueType, Il2CppSystem.IComparable, Il2CppSystem.IFormattable, Il2CppSystem.IConvertible
+    {
+        // Instance members of Il2CppSystem.Enum, except for interface implementations
+    }
+    public class Object : IObject
+    {
+        // A static method should be generated for each instance method
+    }
+    public abstract class ValueType : Object, IValueType
+    {
+        // A static method should be generated for each instance method
+    }
+    public abstract class Enum : ValueType, IEnum
+    {
+        // A static method should be generated for each instance method
+    }
+    public readonly struct StringComparison : IEnum // Maybe inject other interfaces like System.IEquatable<> for user convenience
+    {
+        // [System.Flags] // Only if the Il2Cpp enum has the Flags attribute
+        private enum __Internal
+        {
+            CurrentCulture = 0,
+            CurrentCultureIgnoreCase = 1,
+            InvariantCulture = 2,
+            InvariantCultureIgnoreCase = 3,
+            Ordinal = 4,
+            OrdinalIgnoreCase = 5
+        }
+
+        // Might make this `int` instead. The only reason to use `__Internal` is to have a more efficient ToString implementation.
+        private readonly __Internal value__;
+
+        // Sacrifice the ability to use Il2Cpp enums in constants.
+        public static readonly StringComparison CurrentCulture = new StringComparison(__Internal.CurrentCulture);
+        public static readonly StringComparison CurrentCultureIgnoreCase = new StringComparison(__Internal.CurrentCultureIgnoreCase);
+        public static readonly StringComparison InvariantCulture = new StringComparison(__Internal.InvariantCulture);
+        public static readonly StringComparison InvariantCultureIgnoreCase = new StringComparison(__Internal.InvariantCultureIgnoreCase);
+        public static readonly StringComparison Ordinal = new StringComparison(__Internal.Ordinal);
+        public static readonly StringComparison OrdinalIgnoreCase = new StringComparison(__Internal.OrdinalIgnoreCase);
+
+        private StringComparison(__Internal value) => value__ = value;
+        public StringComparison(int value) => value__ = unchecked((__Internal)value);
+        public static explicit operator int(StringComparison value) => unchecked((int)value.value__);
+        public static explicit operator StringComparison(int value) => new StringComparison(value);
+
+        // Numerical operators like shift
+
+        // Override ToString, GetHashCode, Equals, etc.
+        public override int GetHashCode()
+        {
+            // Use the static method from Il2CppSystem.Enum
+            // We need to ensure that behavior is consistent with the native method.
+            return Il2CppSystem.Enum.GetHashCode(this);
+        }
+
+        static StringComparison()
+        {
+            // OriginalNameAttribute no longer needed.
+        }
+    }
+    public interface ICloneable : IObject, System.ICloneable
+    {
+        IObject Clone();
+
+        object System.ICloneable.Clone()
+        {
+            return Clone();
+        }
+    }
+}
+```

Documentation/Design/Delegates.md

@@ -0,0 +1,3 @@
+# Delegates
+
+All Il2Cpp delegates have a generated conversion to a system delegate, which might be generated if necessary.

Documentation/Design/Enums.md

@@ -0,0 +1,29 @@
+# Enums
+
+Enums are converted to readonly structs.
+
+```cs
+// Original
+public enum ElectricityType
+{
+    Off = 0,
+    On = 1
+}
+
+// Converted
+public struct ElectricityType : IObject, IValueType, IEnum, IComparable, IFormattable, IConvertible
+{
+    private readonly Int32 value__;
+
+    public static readonly ElectricityType Off = (ElectricityType)0;
+    public static readonly ElectricityType On = (ElectricityType)1;
+}
+```
+
+## Generic constraint
+
+`Il2CppSystem.Enum` should be replaced with `Il2CppSystem.IEnum` in generic constraints.
+
+## Interfaces
+
+Additional interfaces like `IEquatable<>`, `IEqualityOperators<,,>`, and `IBitwiseOperators<,,>` could be introduced for user convenience.

Documentation/Design/Exceptions.md

@@ -0,0 +1,7 @@
+# Exceptions
+
+Il2Cpp exceptions each have a cooresponding system exception generated, making up a full hierarchy and enabling try catch support in unstripped code.
+
+## Runtime exceptions
+
+Unstripped code currently allows exceptions (such as `NullReferenceException`) to be thrown by the .NET runtime. Ideally, all such exceptions would be handled.

Documentation/Design/Fields.md

@@ -0,0 +1,19 @@
+# Fields
+
+## Generated code
+
+```cs
+// Reference type
+public FieldType fieldName
+{
+    get => throw null;
+    set => throw null;
+}
+public static ByReference<FieldType> UnsafeField_fieldName(Class obj) => throw null;
+private static readonly IntPtr FieldInfoPtr_fieldIndex;
+
+// Value type
+public FieldType fieldName;
+public static ByReference<FieldType> UnsafeField_fieldName(ByRerefence<Struct> obj) => throw null;
+private static readonly IntPtr FieldInfoPtr_fieldIndex;
+```

Documentation/Design/GenericMethods.md

@@ -0,0 +1,22 @@
+# Generic Methods
+
+## Pointers
+
+Pointers are resolved as needed using Il2Cpp reflection. It's fine to do this initialization lazily because all generic type instances are known in advance.
+
+```cs
+private static class MethodInfoStoreGeneric_Aggregate<TSource, TAccumulate>
+{
+    internal static System.IntPtr Pointer = IL2CPP.il2cpp_method_get_from_reflection(IL2CPP.Il2CppObjectBaseToPtrNotNull(new MethodInfo(IL2CPP.il2cpp_method_get_object(NativeMethodInfoPtr_Aggregate, Il2CppClassPointerStore<Enumerable>.NativeClassPtr))
+    .MakeGenericMethod(new Il2CppReferenceArray<Type>(new Type[2]
+    {
+        Type.internal_from_handle(IL2CPP.il2cpp_class_get_type(Il2CppClassPointerStore<TSource>.NativeClassPtr)),
+        Type.internal_from_handle(IL2CPP.il2cpp_class_get_type(Il2CppClassPointerStore<TAccumulate>.NativeClassPtr))
+    }))));
+}
+```
+
+If a modder tries to use a generic method instantiation that doesn't exist, an exception is thrown.
+
+* <https://github.com/dreamanlan/il2cpp_ref/blob/09316fe508773b8ced098dae6147b44ee1f6516c/libil2cpp/icalls/mscorlib/System.Reflection/MonoMethod.cpp#L253>
+* <https://github.com/dreamanlan/il2cpp_ref/blob/09316fe508773b8ced098dae6147b44ee1f6516c/libil2cpp/icalls/mscorlib/System.Reflection/MonoMethod.cpp#L305>

Documentation/Design/GenericTypes.md

@@ -0,0 +1,10 @@
+# Generic Types
+
+```cs
+Il2CppClassPointerStore<Dictionary<TKey, TValue>>.NativeClassPtr = IL2CPP.il2cpp_class_from_type(Type.internal_from_handle(IL2CPP.il2cpp_class_get_type(IL2CPP.GetIl2CppClass("mscorlib.dll", "System.Collections.Generic", "Dictionary`2"))).MakeGenericType(new Il2CppReferenceArray<Type>(new Type[2]
+{
+    Type.internal_from_handle(IL2CPP.il2cpp_class_get_type(Il2CppClassPointerStore<TKey>.NativeClassPtr)),
+    Type.internal_from_handle(IL2CPP.il2cpp_class_get_type(Il2CppClassPointerStore<TValue>.NativeClassPtr))
+})).TypeHandle.value);
+IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<Dictionary<TKey, TValue>>.NativeClassPtr);
+```