Rework trait system (again) BUT generics (yay)

Author: raftario

libil2cpp/src/array.rs

@@ -3,40 +3,43 @@ use std::mem::transmute;
 use std::ops::{Deref, DerefMut};
 use std::{fmt, ptr, slice};
 
-use crate::{raw, Il2CppObject, Type, WrapRaw};
+use crate::{raw, Il2CppClass, Il2CppObject, Type, WrapRaw};
 
 /// An il2cpp array
 #[repr(transparent)]
-pub struct Il2CppArray<T>(raw::Il2CppArray, PhantomData<[T]>);
+pub struct Il2CppArray<T: Type>(raw::Il2CppArray, PhantomData<[T]>);
 
-impl<T> Il2CppArray<T> {
+impl<T: Type> Il2CppArray<T> {
     /// Creates an array from a slice
-    pub fn from_slice(slice: &[T]) -> &Self
+    pub fn from_slice<'a>(slice: &'a [T::Held<'a>]) -> &'a Self
     where
-        T: Clone + Type,
+        T::Held<'a>: Clone,
     {
         let len = slice.len();
-        let arr = unsafe { raw::array_new(T::class().raw(), len) };
-        let data_ptr = ((arr as isize) + (raw::kIl2CppSizeOfArray as isize)) as *mut T;
+        let arr = unsafe { raw::array_new(T::class().raw(), len) }.unwrap();
+        let data_ptr =
+            ((arr as *mut _ as isize) + (raw::kIl2CppSizeOfArray as isize)) as *mut T::Held<'a>;
         for (i, elem) in slice.iter().enumerate() {
             unsafe {
                 let ptr = data_ptr.add(i);
                 ptr::write_unaligned(ptr, elem.clone());
             }
         }
-        unsafe { Self::wrap_ptr_mut(arr) }.unwrap()
+        unsafe { Self::wrap_mut(arr) }
     }
 
     /// Slice of values in the array
-    pub fn as_slice(&self) -> &[T] {
-        let ptr = ((self as *const _ as isize) + (raw::kIl2CppSizeOfArray as isize)) as *const T;
+    pub fn as_slice(&self) -> &[T::Held<'_>] {
+        let ptr = ((self as *const _ as isize) + (raw::kIl2CppSizeOfArray as isize))
+            as *const T::Held<'_>;
         let len = self.len();
         unsafe { slice::from_raw_parts(ptr, len) }
     }
 
     /// Mutable slice of values in the array
-    pub fn as_mut_slice(&mut self) -> &mut [T] {
-        let ptr = ((self as *mut _ as isize) + (raw::kIl2CppSizeOfArray as isize)) as *mut T;
+    pub fn as_mut_slice(&mut self) -> &mut [T::Held<'_>] {
+        let ptr =
+            ((self as *mut _ as isize) + (raw::kIl2CppSizeOfArray as isize)) as *mut T::Held<'_>;
         let len = self.len();
         unsafe { slice::from_raw_parts_mut(ptr, len) }
     }
@@ -57,38 +60,59 @@ impl<T> Il2CppArray<T> {
     }
 }
 
-unsafe impl<T> WrapRaw for Il2CppArray<T> {
+unsafe impl<T: Type> WrapRaw for Il2CppArray<T> {
     type Raw = raw::Il2CppArray;
 }
 
-impl<T: fmt::Debug> fmt::Debug for Il2CppArray<T> {
+unsafe impl<T: Type> Type for Il2CppArray<T> {
+    type Held<'a> = Option<&'a mut Self>;
+
+    const NAMESPACE: &'static str = "System";
+    const CLASS_NAME: &'static str = "Array";
+
+    fn class() -> &'static Il2CppClass {
+        let class = unsafe { raw::array_class_get(T::class().raw(), 0, false) };
+        unsafe { Il2CppClass::wrap(class) }
+    }
+
+    fn matches_reference_argument(ty: &crate::Il2CppType) -> bool {
+        ty.class().is_assignable_from(Self::class())
+    }
+
+    fn matches_value_argument(_: &crate::Il2CppType) -> bool {
+        false
+    }
+
+    fn matches_reference_parameter(ty: &crate::Il2CppType) -> bool {
+        Self::class().is_assignable_from(ty.class())
+    }
+
+    fn matches_value_parameter(_: &crate::Il2CppType) -> bool {
+        false
+    }
+}
+
+impl<T: Type> fmt::Debug for Il2CppArray<T>
+where
+    for<'a> T::Held<'a>: fmt::Debug,
+{
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_tuple("Il2CppArray").field(&self.as_ref()).finish()
+        f.debug_tuple("Il2CppArray")
+            .field(&self.as_slice())
+            .finish()
     }
 }
 
-impl<T> Deref for Il2CppArray<T> {
+impl<T: Type> Deref for Il2CppArray<T> {
     type Target = Il2CppObject;
 
     fn deref(&self) -> &Self::Target {
         unsafe { Il2CppObject::wrap(&self.raw().obj) }
     }
 }
 
-impl<T> DerefMut for Il2CppArray<T> {
+impl<T: Type> DerefMut for Il2CppArray<T> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         unsafe { Il2CppObject::wrap_mut(&mut self.raw_mut().obj) }
     }
 }
-
-impl<T> AsRef<[T]> for Il2CppArray<T> {
-    fn as_ref(&self) -> &[T] {
-        self.as_slice()
-    }
-}
-
-impl<T> AsMut<[T]> for Il2CppArray<T> {
-    fn as_mut(&mut self) -> &mut [T] {
-        self.as_mut_slice()
-    }
-}

libil2cpp/src/field_info.rs

@@ -3,7 +3,7 @@ use std::ffi::CStr;
 use std::fmt;
 use std::mem::MaybeUninit;
 
-use crate::{raw, Argument, Il2CppClass, Il2CppObject, Il2CppType, Returned, WrapRaw};
+use crate::{raw, Argument, Il2CppClass, Il2CppObject, Il2CppType, Type, WrapRaw};
 
 /// Information about a C# field
 #[repr(transparent)]
@@ -16,10 +16,7 @@ impl FieldInfo {
         A: Argument,
     {
         assert!(A::matches(self.ty()));
-
-        unsafe {
-            self.store_unchecked(instance, val);
-        }
+        unsafe { self.store_unchecked(instance, val) };
     }
 
     /// Store a value into a field without type checking
@@ -34,24 +31,23 @@ impl FieldInfo {
     }
 
     /// Load a typechecked value from a field
-    pub fn load<R>(&self, instance: &mut Il2CppObject) -> R
+    pub fn load<'a, T>(&self, instance: &'a mut Il2CppObject) -> T::Held<'a>
     where
-        R: Returned,
+        T: Type,
     {
-        assert!(R::matches(self.ty()));
-
-        unsafe { self.load_unchecked(instance) }
+        assert!(T::class().is_assignable_from(self.ty().class()));
+        unsafe { self.load_unchecked::<T>(instance) }
     }
 
     /// Load a value from a field without type checking
     ///
     /// # Safety
     /// To be safe, the provided type has to match the field signature
-    pub unsafe fn load_unchecked<R>(&self, instance: &mut Il2CppObject) -> R
+    pub unsafe fn load_unchecked<'a, T>(&self, instance: &'a mut Il2CppObject) -> T::Held<'a>
     where
-        R: Returned,
+        T: Type,
     {
-        let mut val: MaybeUninit<R> = MaybeUninit::uninit();
+        let mut val: MaybeUninit<T::Held<'a>> = MaybeUninit::uninit();
         raw::field_get_value(instance.raw_mut(), self.raw(), val.as_mut_ptr().cast());
         val.assume_init()
     }

libil2cpp/src/lib.rs

@@ -1,4 +1,4 @@
-#![feature(once_cell, generic_associated_types)]
+#![feature(once_cell, generic_associated_types, never_type)]
 #![doc(html_root_url = "https://stackdoubleflow.github.io/quest-hook-rs/libil2cpp")]
 #![warn(
     clippy::all,
@@ -114,4 +114,4 @@ pub use string::Il2CppString;
 pub use ty::{Builtin, Il2CppReflectionType, Il2CppType};
 pub use typecheck::callee::{Parameter, Parameters, Return, ThisParameter};
 pub use typecheck::caller::{Argument, Arguments, Returned, ThisArgument};
-pub use typecheck::ty::{Reference, Type, Value};
+pub use typecheck::ty::Type;

libil2cpp/src/object.rs

@@ -1,6 +1,6 @@
 use std::fmt;
 
-use crate::{raw, Argument, Arguments, Il2CppClass, Il2CppException, Returned, WrapRaw};
+use crate::{raw, Argument, Arguments, Il2CppClass, Il2CppException, Returned, Type, WrapRaw};
 
 /// An il2cpp object
 #[repr(transparent)]
@@ -55,12 +55,12 @@ impl Il2CppObject {
     /// # Panics
     ///
     /// This method will panic if the given field can't be found
-    pub fn load<R>(&mut self, field: &str) -> R
+    pub fn load<T>(&mut self, field: &str) -> T::Held<'_>
     where
-        R: Returned,
+        T: Type,
     {
         let field = self.class().find_field(field).unwrap();
-        field.load(self)
+        field.load::<T>(self)
     }
 
     /// Stores a given value into a field of `self` with the given name, with

libil2cpp/src/raw/functions.rs

@@ -26,7 +26,8 @@ il2cpp_functions! {
     pub fn method_get_object(method: &MethodInfo, refclass: Option<&Il2CppClass>) -> &'static Il2CppReflectionMethod;
     pub fn method_get_from_reflection(method: &Il2CppReflectionMethod) -> &'static MethodInfo;
     pub fn method_is_generic(method: &MethodInfo) -> bool;
-    pub fn array_new(elem_type: &Il2CppClass, length: usize) -> *mut Il2CppArray;
+    pub fn array_new(element_class: &Il2CppClass, length: usize) -> Option<&'static mut Il2CppArray>;
+    pub fn array_class_get(element_class: &Il2CppClass, rank: u32, bounded: bool) -> &'static Il2CppClass;
     pub fn type_get_name(ty: &Il2CppType) -> *const c_char;
     pub fn type_get_object(ty: &Il2CppType) -> &'static Il2CppReflectionType;
     pub fn runtime_invoke(method: &MethodInfo, instance: *mut c_void, params: *mut *mut c_void, exception: &mut Option<&mut Il2CppException>) -> Option<&'static mut Il2CppObject>;

libil2cpp/src/typecheck/callee.rs

@@ -2,8 +2,6 @@ use std::fmt;
 
 use crate::{Builtin, Il2CppType, MethodInfo, Type};
 
-use super::ty::semantics;
-
 /// Trait implemented by types that can be used as C# `this` method parameters
 ///
 /// # Note
@@ -125,20 +123,25 @@ where
 }
 
 unsafe impl ThisParameter for () {
-    type Actual = ();
+    type Actual = !;
 
     fn matches(method: &MethodInfo) -> bool {
         method.is_static()
     }
 
-    fn from_actual((): ()) {}
-    fn into_actual(self) {}
+    fn from_actual(_: !) {
+        unreachable!();
+    }
+    fn into_actual(self) -> ! {
+        unreachable!()
+    }
 }
 
-unsafe impl<T, S> Parameter for Option<&mut T>
+// TODO: Remove this once rustfmt stops dropping generics on GATs
+#[rustfmt::skip]
+unsafe impl<T> Parameter for Option<&mut T>
 where
-    T: Type<Semantics = S>,
-    S: semantics::ReferenceParameter,
+    T: for<'a> Type<Held<'a> = Option<&'a mut T>>,
 {
     type Actual = Self;
 
@@ -154,10 +157,11 @@ where
     }
 }
 
-unsafe impl<T, S> Parameter for &mut T
+// TODO: Remove this once rustfmt stops dropping generics on GATs
+#[rustfmt::skip]
+unsafe impl<T> Parameter for &mut T
 where
-    T: Type<Semantics = S>,
-    S: semantics::ReferenceParameter,
+    T: for<'a> Type<Held<'a> = Option<&'a mut T>>,
 {
     type Actual = Option<Self>;
 
@@ -173,15 +177,16 @@ where
     }
 }
 
-unsafe impl<T, S> Return for Option<&mut T>
+// TODO: Remove this once rustfmt stops dropping generics on GATs
+#[rustfmt::skip]
+unsafe impl<T> Return for Option<&mut T>
 where
-    T: Type<Semantics = S>,
-    S: semantics::ReferenceReturn,
+    T: for<'a> Type<Held<'a> = Option<&'a mut T>>,
 {
     type Actual = Self;
 
     fn matches(ty: &Il2CppType) -> bool {
-        T::matches_reference_return(ty)
+        T::matches_return(ty)
     }
 
     fn into_actual(self) -> Self::Actual {
@@ -192,15 +197,16 @@ where
     }
 }
 
-unsafe impl<T, S> Return for &mut T
+// TODO: Remove this once rustfmt stops dropping generics on GATs
+#[rustfmt::skip]
+unsafe impl<T> Return for &mut T
 where
-    T: Type<Semantics = S>,
-    S: semantics::ReferenceReturn,
+    T: for<'a> Type<Held<'a> = Option<&'a mut T>>,
 {
     type Actual = Option<Self>;
 
     fn matches(ty: &Il2CppType) -> bool {
-        T::matches_reference_return(ty)
+        T::matches_return(ty)
     }
 
     fn into_actual(self) -> Self::Actual {