Fix and test unsafe_impl_type macros on generic types

Author: raftario

README.md

@@ -43,11 +43,6 @@ use quest_hook::hook;
 use quest_hook::libil2cpp::{Il2CppObject, Il2CppString};
 use tracing::debug;
 
-#[no_mangle]
-pub extern "C" fn setup() {
-    quest_hook::setup("hello world");
-}
-
 #[hook("UnityEngine.SceneManagement", "SceneManager", "SetActiveScene")]
 fn set_active_scene(scene: &mut Il2CppObject) -> bool {
     let name: &Il2CppString = scene.invoke("get_name", ()).unwrap();
@@ -60,6 +55,11 @@ fn set_active_scene(scene: &mut Il2CppObject) -> bool {
 pub extern "C" fn load() {
     set_active_scene.install().unwrap();
 }
+
+#[no_mangle]
+pub extern "C" fn setup() {
+    quest_hook::setup("hello world");
+}
 ```
 
 Check out the [`examples`](./examples/) directory for more examples.

examples/custom_type.rs

@@ -1,14 +1,10 @@
-#![feature(generic_associated_types)]
+#![feature(generic_associated_types, once_cell)]
 
+use libil2cpp::{Il2CppArray, Type};
 use quest_hook::hook;
-use quest_hook::libil2cpp::{unsafe_impl_value_type, Il2CppObject};
+use quest_hook::libil2cpp::{unsafe_impl_reference_type, unsafe_impl_value_type, Il2CppObject};
 use tracing::debug;
 
-#[no_mangle]
-pub extern "C" fn setup() {
-    quest_hook::setup("custom type");
-}
-
 #[derive(Debug)]
 #[repr(C)]
 pub struct Vector3 {
@@ -26,7 +22,20 @@ fn set_position(this: &mut Il2CppObject, new_position: Vector3) {
     set_position.original(this, new_position)
 }
 
+#[no_mangle]
+pub extern "C" fn setup() {
+    quest_hook::setup("custom type");
+}
+
 #[no_mangle]
 pub extern "C" fn load() {
     set_position.install().unwrap();
 }
+
+#[repr(C)]
+pub struct List<T: Type> {
+    object: Il2CppObject,
+    items: *mut Il2CppArray<T>,
+    size: i32,
+}
+unsafe_impl_reference_type!(in quest_hook::libil2cpp for List<T> => System.Collections.Generic.List<T>);

examples/hello_world.rs

@@ -2,11 +2,6 @@ use quest_hook::hook;
 use quest_hook::libil2cpp::{Il2CppObject, Il2CppString};
 use tracing::debug;
 
-#[no_mangle]
-pub extern "C" fn setup() {
-    quest_hook::setup("hello world");
-}
-
 #[hook("UnityEngine.SceneManagement", "SceneManager", "SetActiveScene")]
 fn set_active_scene(scene: &mut Il2CppObject) -> bool {
     let name: &Il2CppString = scene.invoke("get_name", ()).unwrap();
@@ -15,6 +10,11 @@ fn set_active_scene(scene: &mut Il2CppObject) -> bool {
     set_active_scene.original(scene)
 }
 
+#[no_mangle]
+pub extern "C" fn setup() {
+    quest_hook::setup("hello world");
+}
+
 #[no_mangle]
 pub extern "C" fn load() {
     set_active_scene.install().unwrap();

libil2cpp/src/array.rs

@@ -11,18 +11,15 @@ pub struct Il2CppArray<T: Type>(raw::Il2CppArray, PhantomData<[T]>);
 
 impl<T: Type> Il2CppArray<T> {
     /// Creates an array from a slice
-    pub fn from_slice<'a>(slice: &'a [T::Held<'a>]) -> &'a Self
-    where
-        T::Held<'a>: Clone,
-    {
-        let len = slice.len();
+    pub fn new<'a>(items: Vec<T::Held<'a>>) -> &'a mut Self {
+        let len = items.len();
         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() {
+        for (i, elem) in items.into_iter().enumerate() {
             unsafe {
                 let ptr = data_ptr.add(i);
-                ptr::write_unaligned(ptr, elem.clone());
+                ptr::write_unaligned(ptr, elem);
             }
         }
         unsafe { Self::wrap_mut(arr) }

libil2cpp/src/class.rs

@@ -16,6 +16,9 @@ type FieldInfoSlice<'a> = &'a [&'static FieldInfo];
 #[repr(transparent)]
 pub struct Il2CppClass(raw::Il2CppClass);
 
+unsafe impl Send for Il2CppClass {}
+unsafe impl Sync for Il2CppClass {}
+
 impl Il2CppClass {
     /// Find a class by namespace and name
     #[crate::instrument(level = "debug")]

libil2cpp/src/field_info.rs

@@ -9,6 +9,9 @@ use crate::{raw, Argument, Il2CppClass, Il2CppObject, Il2CppType, Type, WrapRaw}
 #[repr(transparent)]
 pub struct FieldInfo(raw::FieldInfo);
 
+unsafe impl Send for FieldInfo {}
+unsafe impl Sync for FieldInfo {}
+
 impl FieldInfo {
     /// Store a typechecked value into a field
     pub fn store<A>(&self, instance: &mut Il2CppObject, val: A)

libil2cpp/src/lib.rs

@@ -70,7 +70,7 @@
     rustdoc::broken_intra_doc_links,
     rustdoc::private_intra_doc_links
 )]
-#![allow(clippy::single_component_path_imports)]
+#![allow(clippy::mut_from_ref, clippy::single_component_path_imports)]
 
 //! Wrappers and raw bindings for Unity's libil2cpp
 

libil2cpp/src/method_info.rs

@@ -21,6 +21,9 @@ type ParameterInfoSlice<'a> = &'a [&'static ParameterInfo];
 #[repr(transparent)]
 pub struct MethodInfo(raw::MethodInfo);
 
+unsafe impl Send for MethodInfo {}
+unsafe impl Sync for MethodInfo {}
+
 impl MethodInfo {
     /// Invoke this method, type checking against its signature with the
     /// provided instance, arguments and return type
@@ -81,7 +84,7 @@ impl MethodInfo {
     // }
 
     /// [`Il2CppReflectionMethod`] which represents the method
-    pub fn reflection_object(&self) -> &'static mut Il2CppReflectionMethod {
+    pub fn reflection_object(&self) -> &mut Il2CppReflectionMethod {
         unsafe { Il2CppReflectionMethod::wrap_mut(raw::method_get_object(self.raw(), None)) }
     }
 

libil2cpp/src/parameter_info.rs

@@ -8,6 +8,9 @@ use crate::{raw, Il2CppType, WrapRaw};
 #[repr(transparent)]
 pub struct ParameterInfo(raw::ParameterInfo);
 
+unsafe impl Send for ParameterInfo {}
+unsafe impl Sync for ParameterInfo {}
+
 impl ParameterInfo {
     /// Name of the parameter
     pub fn name(&self) -> Cow<'_, str> {

libil2cpp/src/ty.rs

@@ -19,6 +19,9 @@ use crate::{Il2CppClass, Il2CppObject, WrapRaw};
 #[repr(transparent)]
 pub struct Il2CppType(raw::Il2CppType);
 
+unsafe impl Send for Il2CppType {}
+unsafe impl Sync for Il2CppType {}
+
 impl Il2CppType {
     /// Class of the type
     pub fn class(&self) -> &Il2CppClass {
@@ -42,7 +45,7 @@ impl Il2CppType {
     }
 
     /// [`Il2CppReflectionType`] which represents the type
-    pub fn reflection_object(&self) -> &'static mut Il2CppReflectionType {
+    pub fn reflection_object(&self) -> &mut Il2CppReflectionType {
         unsafe { Il2CppReflectionType::wrap_mut(raw::type_get_object(self.raw())) }
     }
 }

proc_macros/src/impl_type.rs

@@ -146,7 +146,7 @@ impl Input {
 
     fn reflection_type_ty(&self) -> TokenStream2 {
         let path = &self.path;
-        quote!(#path :: Il2CppType)
+        quote!(#path :: Il2CppReflectionType)
     }
 
     fn array_ty(&self) -> TokenStream2 {
@@ -192,14 +192,14 @@ impl Input {
 
         Some(quote! {
             fn class() -> &'static #class_ty {
-                static CLASS: ::std::lazy::SyncLazy<&'static Il2CppClass> = ::std::lazy::SyncLazy::new(|| {
+                static CLASS: ::std::lazy::SyncOnceCell<&'static #class_ty> = ::std::lazy::SyncOnceCell::new();
+                CLASS.get_or_init(|| {
                     let reflection_type_class = <#reflection_type_ty as #type_trait>::class();
                     let generic_ty = #class_ty::find(#namespace, #generic_class).unwrap().ty().reflection_object();
-                    let generic_ty = unsafe { &mut *(generic_ty as *const _ as *mut _)  };
-                    let generics = #array_ty::from_slice(&[#(<#generics as #type_trait>::class()),*]);
-                    reflection_type_class.invoke("MakeGenericType", (generic_ty, generics)).unwrap()
-                });
-                *class
+                    let generics = #array_ty::<#reflection_type_ty>::new(vec![#(Some(<#generics as #type_trait>::class().ty().reflection_object())),*]);
+                    let reflection_type: &#reflection_type_ty = reflection_type_class.invoke("MakeGenericType", (generic_ty, generics)).unwrap();
+                    reflection_type.ty().class()
+                })
             }
         })
     }