Merge branch 'metacall:develop' into mac_py

Author: k5602

.github/workflows/linux-test.yml

@@ -67,9 +67,30 @@ jobs:
           METACALL_BUILD_TYPE: debug
           METACALL_BASE_IMAGE: ${{ matrix.image }}
 
+  linux-memcheck-test:
+    name: Linux Valgrind Memcheck Test
+    runs-on: ubuntu-latest
+
+    strategy:
+      fail-fast: false
+      matrix:
+        image: ["debian:trixie-slim", "ubuntu:noble"]
+
+    steps:
+      - name: Check out the repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Install, build and run Valgrind memcheck tests
+        run: ./docker-compose.sh test-memcheck
+        env:
+          METACALL_BUILD_TYPE: debug
+          METACALL_BASE_IMAGE: ${{ matrix.image }}
+
   linux-distributable:
     name: Linux Distributable Dispatch
-    needs: [linux-test, linux-sanitizer-test]
+    needs: [linux-test, linux-sanitizer-test] # TODO: linux-memcheck-test
     runs-on: ubuntu-latest
     if: startsWith(github.ref, 'refs/tags/') || github.ref == 'refs/heads/master'
     steps:

docs/README.md

@@ -128,7 +128,7 @@ This section describes all programming languages that **METACALL** allows to loa
 | [Go](https://golang.org/)                                                     | Go Runtime                                                                                             |  go  |
 | [Haskell](https://www.haskell.org/)                                           | [Haskell FFI](https://wiki.haskell.org/GHC/Using_the_FFI)                                              |  hs  |
 | [Crystal](https://crystal-lang.org/)                                          | [Crystal Compiler Internals](https://github.com/crystal-lang/crystal/wiki/Compiler-internals)          |  cr  |
-| [JavaScript](https://developer.mozilla.org/bm/docs/Web/JavaScript)            | [SpiderMonkey](https://developer.mozilla.org/en-US/docs/Mozilla/Projects/SpiderMonkey/JSAPI_reference) | jsm  |
+| [JavaScript](https://developer.mozilla.org/bm/docs/Web/JavaScript)            | [SpiderMonkey](https://spidermonkey.dev/) | jsm  |
 | [Dart](https://dart.dev/)                                                     | [Dart VM](https://dart.dev/tools/dart-vm)                                                              | dart |
 | [LuaJIT](https://luajit.org/)                                                 | [LuaJIT2](https://github.com/openresty/luajit2)                                                        | lua  |
 | [LLVM IR](https://www.llvm.org/devmtg/2017-06/1-Davis-Chisnall-LLVM-2017.pdf) | [LLVM](https://llvm.org/)                                                                              | llvm |

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

@@ -92,13 +92,12 @@ extern "C" fn class_singleton_static_invoke(
             .expect("Unable to get method name");
         let ret = class.call(name, args);
         std::mem::forget(class);
-        std::mem::forget(name);
         ret
     };
     if let Ok(ret) = ret {
-        return ret;
+        ret
     } else {
-        return 0 as OpaqueType;
+        0 as OpaqueType
     }
 }
 
@@ -116,12 +115,10 @@ extern "C" fn class_singleton_static_await(
 
 #[no_mangle]
 extern "C" fn class_singleton_destroy(_klass: OpaqueType, class_impl: OpaqueType) {
-    if !rs_loader_destroyed() {
-        if !class_impl.is_null() {
-            unsafe {
-                let class = Box::from_raw(class_impl as *mut class::Class);
-                drop(class);
-            }
+    if !rs_loader_destroyed() && !class_impl.is_null() {
+        unsafe {
+            let class = Box::from_raw(class_impl as *mut class::Class);
+            drop(class);
         }
     }
 }
@@ -239,10 +236,8 @@ pub fn register_class(class_registration: ClassRegistration) {
                     loader_impl_type(class_registration.loader_impl, ret.as_ptr()),
                 );
             };
-        }
-        else {
-            let ret = CString::new("Null")
-            .expect("Failed to convert return type to C string");
+        } else {
+            let ret = CString::new("Null").expect("Failed to convert return type to C string");
 
             unsafe {
                 signature_set_return(
@@ -294,10 +289,8 @@ pub fn register_class(class_registration: ClassRegistration) {
                     loader_impl_type(class_registration.loader_impl, ret.as_ptr()),
                 );
             };
-        }
-        else {
-            let ret = CString::new("Null")
-            .expect("Failed to convert return type to C string");
+        } else {
+            let ret = CString::new("Null").expect("Failed to convert return type to C string");
 
             unsafe {
                 signature_set_return(

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

@@ -54,15 +54,12 @@ extern "C" fn function_singleton_await(
     0 as OpaqueType
 }
 
-
 #[no_mangle]
 extern "C" fn function_singleton_destroy(_func: OpaqueType, func_impl: OpaqueType) {
-    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);
-            }
+    if !rs_loader_destroyed() && !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

@@ -121,10 +121,7 @@ extern "C" {
 }
 
 pub fn get_loader_lifecycle_state(loader_impl: OpaqueType) -> *mut LoaderLifecycleState {
-    let loader_lifecycle_state =
-        unsafe { loader_impl_get(loader_impl) } as *mut LoaderLifecycleState;
-
-    loader_lifecycle_state
+    (unsafe { loader_impl_get(loader_impl) }) as *mut LoaderLifecycleState
 }
 
 static mut RS_LOADER_PTR: *mut c_void = std::ptr::null_mut();
@@ -142,7 +139,9 @@ pub fn loader_lifecycle_register(loader_impl: OpaqueType) {
 }
 
 pub fn loader_lifecycle_unload_children(loader_impl: OpaqueType) {
-    unsafe { loader_unload_children(loader_impl); }
+    unsafe {
+        loader_unload_children(loader_impl);
+    }
 }
 
 pub enum PrimitiveMetacallProtocolTypes {
@@ -182,7 +181,5 @@ pub fn define_type(
 }
 
 pub fn rs_loader_destroyed() -> bool {
-    unsafe {
-        loader_is_destroyed(RS_LOADER_PTR) == 0
-    }
+    unsafe { loader_is_destroyed(RS_LOADER_PTR) == 0 }
 }