All tests passing in rust loader.

Author: viferga

source/loaders/rs_loader/rust/compiler/src/api/class.rs

@@ -29,7 +29,6 @@ pub struct ClassInterface {
 
 #[no_mangle]
 extern "C" fn class_singleton_create(_klass: OpaqueType, _class_impl: OpaqueType) -> c_int {
-    println!("create class");
     0
 }
 #[no_mangle]
@@ -41,7 +40,6 @@ extern "C" fn class_singleton_constructor(
     class_args: OpaqueTypeList,
     size: usize,
 ) -> OpaqueType {
-    println!("invoke class constructor");
     unsafe {
         let class_impl_ptr = class_impl as *mut class::Class;
         let class = Box::from_raw(class_impl_ptr);
@@ -63,7 +61,7 @@ extern "C" fn class_singleton_static_set(
     _accessor: OpaqueType,
     _value: OpaqueType,
 ) -> c_int {
-    println!("class static set");
+    eprintln!("Rust Loader: Class static set not implemented");
     0
 }
 
@@ -73,7 +71,7 @@ extern "C" fn class_singleton_static_get(
     _class_impl: OpaqueType,
     _accessor: OpaqueType,
 ) -> OpaqueType {
-    println!("class static get");
+    eprintln!("Rust Loader: Class static get not implemented");
     0 as OpaqueType
 }
 
@@ -85,7 +83,6 @@ extern "C" fn class_singleton_static_invoke(
     args_p: OpaqueTypeList,
     size: usize,
 ) -> OpaqueType {
-    println!("class static invoke");
     let ret = unsafe {
         let class_impl_ptr = class_impl as *mut class::Class;
         let class = Box::from_raw(class_impl_ptr);
@@ -113,19 +110,20 @@ extern "C" fn class_singleton_static_await(
     _args_p: OpaqueTypeList,
     _size: usize,
 ) -> OpaqueType {
-    println!("class static await");
+    eprintln!("Rust Loader: Class static await not implemented");
     0 as OpaqueType
 }
 
 #[no_mangle]
 extern "C" fn class_singleton_destroy(_klass: OpaqueType, class_impl: OpaqueType) {
-    if !class_impl.is_null() {
-        unsafe {
-            let class = Box::from_raw(class_impl as *mut class::Class);
-            drop(class);
+    if !rs_loader_destroyed() {
+        if !class_impl.is_null() {
+            unsafe {
+                let class = Box::from_raw(class_impl as *mut class::Class);
+                drop(class);
+            }
         }
     }
-    println!("class destroy");
 }
 
 #[no_mangle]
@@ -164,10 +162,9 @@ pub fn register_class(class_registration: ClassRegistration) {
         class_info,
     } = class_registration.class_create;
     let name = CString::new(name).expect("Failed to convert function name to C string");
-    // dbg!(&class_info);
     let class = unsafe { class_create(name.as_ptr(), 0, class_impl, singleton) };
 
-    // register ctor:
+    // Register ctor
     if let Some(constructor) = class_info.constructor {
         let ctor = unsafe { constructor_create(constructor.args.len(), 0) };
         for (idx, arg) in constructor.args.iter().enumerate() {
@@ -188,9 +185,10 @@ pub fn register_class(class_registration: ClassRegistration) {
         unsafe { class_register_constructor(class, ctor) };
     } else {
         // TODO: add default constructor
-        println!("should add default constructor");
+        eprintln!("Rust Loader: Class default constructor not implemented");
     }
-    // register attrs
+
+    // Register attrs
     for attr in class_info.attributes.iter() {
         let name =
             CString::new(attr.name.clone()).expect("Failed to convert function name to C string");
@@ -208,11 +206,13 @@ pub fn register_class(class_registration: ClassRegistration) {
         };
         unsafe { class_register_attribute(class, attribute) };
     }
-    // we don't have static attributes in rust for now.
+
+    // TODO: We don't have static attributes in rust for now.
     // for attr in class_info.static_attributes.iter() {
     //     let static_attribute = unsafe { attribute_create(class, name, ty, null, 0, null) };
     //     unsafe { class_register_static_attribute(class, static_attribute) };
     // }
+
     for method in class_info.methods.iter() {
         let name =
             CString::new(method.name.clone()).expect("Failed to convert function name to C string");

source/loaders/rs_loader/rust/compiler/src/api/function.rs

@@ -50,16 +50,19 @@ extern "C" fn function_singleton_await(
     _reject: extern "C" fn(OpaqueType, OpaqueType) -> OpaqueType,
     _data: OpaqueType,
 ) -> OpaqueType {
-    println!("rs_loader: await function");
+    eprintln!("Rust Loader: Function await not implemented");
     0 as OpaqueType
 }
 
+
 #[no_mangle]
 extern "C" fn function_singleton_destroy(_func: OpaqueType, func_impl: OpaqueType) {
-    if !func_impl.is_null() {
-        unsafe {
-            let func_ptr = Box::from_raw(func_impl as *mut class::Function);
-            drop(func_ptr);
+    if !rs_loader_destroyed() {
+        if !func_impl.is_null() {
+            unsafe {
+                let func_ptr = Box::from_raw(func_impl as *mut class::Function);
+                drop(func_ptr);
+            }
         }
     }
 }

source/loaders/rs_loader/rust/compiler/src/api/mod.rs

@@ -73,7 +73,6 @@ extern "C" {
     fn loader_impl_type(loader_impl: OpaqueType, name: *const c_char) -> OpaqueType;
 
     fn scope_define(scope: OpaqueType, key: *mut c_char, value: OpaqueType) -> c_int;
-    // REFLECT_API klass class_create(const char *name, enum accessor_type_id accessor, class_impl impl, class_impl_interface_singleton singleton);
     fn class_create(
         name: *const c_char,
         accessor_type_id: c_int,
@@ -82,7 +81,6 @@ extern "C" {
     ) -> OpaqueType;
     fn value_create_class(class: OpaqueType) -> OpaqueType;
     fn class_name(class: OpaqueType) -> *mut c_char;
-    // constructor constructor_create(size_t count, enum class_visibility_id visibility);
     fn constructor_create(count: usize, visibility: c_int) -> OpaqueType;
     fn constructor_set(ctor: OpaqueType, index: usize, name: *const c_char, t: OpaqueType);
     fn class_register_constructor(class: OpaqueType, ctor: OpaqueType) -> c_int;
@@ -118,6 +116,8 @@ extern "C" {
         class: OpaqueType,
     ) -> OpaqueType;
 
+    fn metacall_loader(tag: *const c_char) -> OpaqueType;
+    fn loader_is_destroyed(loader_impl: OpaqueType) -> i32;
 }
 
 pub fn get_loader_lifecycle_state(loader_impl: OpaqueType) -> *mut LoaderLifecycleState {
@@ -127,12 +127,22 @@ pub fn get_loader_lifecycle_state(loader_impl: OpaqueType) -> *mut LoaderLifecyc
     loader_lifecycle_state
 }
 
+static mut RS_LOADER_PTR: *mut c_void = std::ptr::null_mut();
+
 pub fn loader_lifecycle_register(loader_impl: OpaqueType) {
-    unsafe { loader_initialization_register(loader_impl) };
+    const TAG: *const c_char = "rs\0".as_ptr() as *const c_char;
+    unsafe {
+        loader_initialization_register(loader_impl);
+
+        // Get rust loader pointer
+        if RS_LOADER_PTR.is_null() {
+            RS_LOADER_PTR = metacall_loader(TAG);
+        }
+    }
 }
 
 pub fn loader_lifecycle_unload_children(loader_impl: OpaqueType) {
-    unsafe { loader_unload_children(loader_impl) };
+    unsafe { loader_unload_children(loader_impl); }
 }
 
 pub enum PrimitiveMetacallProtocolTypes {
@@ -170,3 +180,9 @@ pub fn define_type(
         loader_impl_type_define(loader_impl, type_name(t), t)
     };
 }
+
+pub fn rs_loader_destroyed() -> bool {
+    unsafe {
+        loader_is_destroyed(RS_LOADER_PTR) == 0
+    }
+}

source/loaders/rs_loader/rust/compiler/src/api/object.rs

@@ -23,7 +23,6 @@ pub struct Object {
 
 #[no_mangle]
 extern "C" fn object_singleton_create(_object: OpaqueType, _object_impl: OpaqueType) -> c_int {
-    println!("object create");
     0
 }
 
@@ -41,7 +40,6 @@ extern "C" fn object_singleton_set(
         let name = CStr::from_ptr(get_attr_name(accessor))
             .to_str()
             .expect("Unable to get attr name");
-        println!("object set attr: {}", name);
         obj.instance.set_attr(name, value, &class);
 
         std::mem::forget(class);
@@ -64,7 +62,6 @@ extern "C" fn object_singleton_get(
         let name = CStr::from_ptr(get_attr_name(accessor))
             .to_str()
             .expect("Unable to get attr name");
-        println!("object get attr: {}", name);
         let ret = obj.instance.get_attr(name, &class);
 
         std::mem::forget(class);
@@ -95,7 +92,6 @@ extern "C" fn object_singleton_method_invoke(
         let name = CStr::from_ptr(method_name(method))
             .to_str()
             .expect("Unable to get method name");
-        println!("object invoke: {}", name);
         let ret = obj.instance.call(name, args, &class);
 
         std::mem::forget(class);
@@ -118,23 +114,25 @@ extern "C" fn object_singleton_method_await(
     _args_p: OpaqueTypeList,
     _size: usize,
 ) -> OpaqueType {
-    println!("object await");
+    eprintln!("Rust Loader: Object await not implemented");
     0 as OpaqueType
 }
 #[no_mangle]
-extern "C" fn object_singleton_destructor(_object: OpaqueType, object_impl: OpaqueType) -> c_int {
-    if !object_impl.is_null() {
-        unsafe {
-            let object = Box::from_raw(object_impl as *mut Object);
-            drop(object);
-        }
-    }
-    println!("destruct object");
+extern "C" fn object_singleton_destructor(_object: OpaqueType, _object_impl: OpaqueType) -> c_int {
+    eprintln!("Rust Loader: Object destructor not implemented");
     0
 }
+
 #[no_mangle]
-extern "C" fn object_singleton_destroy(_object: OpaqueType, _object_impl: OpaqueType) {
-    println!("destroy object");
+extern "C" fn object_singleton_destroy(_object: OpaqueType, object_impl: OpaqueType) {
+    if !rs_loader_destroyed() {
+        if !object_impl.is_null() {
+            unsafe {
+                let object = Box::from_raw(object_impl as *mut Object);
+                drop(object);
+            }
+        }
+    }
 }
 
 #[no_mangle]

source/loaders/rs_loader/rust/compiler/src/lib.rs

@@ -286,7 +286,7 @@ impl Drop for DynlinkLibrary {
     fn drop(&mut self) {
         unsafe {
             if !self.instance.is_null() {
-                // Call the C function to unload the dynamic library
+                // Unload the dynamic library
                 dynlink_unload(self.instance);
 
                 // Set the instance to null for safety

source/loaders/rs_loader/rust/compiler/src/middle.rs

@@ -48,7 +48,7 @@ pub fn handle_ty(ty: &TyS) -> FunctionParameter {
                     if let GenericArgKind::Type(ty) = gen_arg.unpack() {
                         result.generic.push(handle_ty(ty));
                     } else {
-                        println!("expect generic arg, get nothing");
+                        eprintln!("Rust Loader: Expect generic arg, get nothing");
                     }
                 }
                 "std::collections::HashMap" => {
@@ -57,13 +57,13 @@ pub fn handle_ty(ty: &TyS) -> FunctionParameter {
                     if let GenericArgKind::Type(ty) = key.unpack() {
                         result.generic.push(handle_ty(ty));
                     } else {
-                        println!("expect key, get nothing");
+                        eprintln!("Rust Loader: Expect key, get nothing");
                     }
                     let value = gen[1];
                     if let GenericArgKind::Type(ty) = value.unpack() {
                         result.generic.push(handle_ty(ty));
                     } else {
-                        println!("expect value, get nothing");
+                        eprintln!("Rust Loader: Expect value, get nothing");
                     }
                 }
                 "std::string::String" => result.ty = FunctionType::String,

source/loaders/rs_loader/rust/compiler/src/wrapper/class.rs

@@ -509,7 +509,6 @@ impl ToMetaResult for char {
 
 impl ToMetaResult for usize {
     fn to_meta_result(self) -> Result<MetacallValue> {
-        println!("get usize: {self}");
         // FIXME: convert usize to i32?
         Ok(unsafe { metacall_value_create_int(self as i32) })
     }
@@ -697,7 +696,7 @@ macro_rules! convert_to {
                     Ok(metacall_value_to_double($val) as $t)
                 }
                 Err(_) => {
-                    println!("receive id: {}, should be [2-6]", id);
+                    eprintln!("Rust Loader: Return type with id #{} is not implemented, ", id);
                     panic!("received mismatch type");
                 }
             }
@@ -809,7 +808,6 @@ where
 //                 .iter()
 //                 .map(|p| metacall_value_to_int(*p))
 //                 .collect::<Vec<i32>>();
-//             println!("{:?}", vec);
 //             vec
 //         })
 //     }