chore: cargo fmt

src/eval/jit/helpers.rs

@@ -1,6 +1,6 @@
+use core::{slice, str};
 use std::alloc::Layout;
 use std::alloc::alloc;
-use core::{slice, str};
 use std::mem::MaybeUninit;
 use std::ptr::NonNull;
 
@@ -18,50 +18,68 @@ pub extern "C" fn helper_call(
     // TODO: Error Handling
     let args = core::ptr::slice_from_raw_parts_mut(args_ptr, args_len);
     let args = unsafe { Box::from_raw(args) };
-    func.call(
-        args.into_iter().map(Value::from).collect(),
-        engine,
-        env
-    )
-    .unwrap();
+    func.call(args.into_iter().map(Value::from).collect(), engine, env)
+        .unwrap();
 }
 
 pub extern "C" fn helper_lookup_arg(env: &Env, level: usize, ret: &mut MaybeUninit<Value>) {
     ret.write(env.lookup_arg(level as usize));
 }
 
-pub extern "C" fn helper_lookup(env: &Env, sym_ptr: *const u8, sym_len: usize, ret: &mut MaybeUninit<Value>) {
+pub extern "C" fn helper_lookup(
+    env: &Env,
+    sym_ptr: *const u8,
+    sym_len: usize,
+    ret: &mut MaybeUninit<Value>,
+) {
     // TODO: Error Handling
     unsafe {
-        ret.write(env
-            .lookup_with(str::from_utf8_unchecked(slice::from_raw_parts(sym_ptr, sym_len)))
-            .unwrap());
+        ret.write(
+            env.lookup_with(str::from_utf8_unchecked(slice::from_raw_parts(
+                sym_ptr, sym_len,
+            )))
+            .unwrap(),
+        );
     }
 }
 
-pub extern "C" fn helper_select(val: &mut Value, path_ptr: *mut Value, path_len: usize, engine: &mut Engine, env: &mut Env) {
+pub extern "C" fn helper_select(
+    val: &mut Value,
+    path_ptr: *mut Value,
+    path_len: usize,
+    engine: &mut Engine,
+    env: &mut Env,
+) {
     let path = core::ptr::slice_from_raw_parts_mut(path_ptr, path_len);
     let path = unsafe { Box::from_raw(path) };
     val.select(path.into_iter().map(|mut val| {
         val.force(engine, env)?.coerce_to_string();
         Ok(val.unwrap_string())
-    })).unwrap();
+    }))
+    .unwrap();
 }
 
-pub extern "C" fn helper_select_with_default(val: &mut Value, path_ptr: *mut Value, path_len: usize, default: NonNull<Value>, engine: &mut Engine, env: &mut Env) {
-    let path = core::ptr::slice_from_raw_parts_mut(path_ptr, path_len);
-    let path = unsafe { Box::from_raw(path) };
-    val.select_with_default(path.into_iter().map(|mut val| {
-        val.force(engine, env)?.coerce_to_string();
-        Ok(val.unwrap_string())
-    }), unsafe { default.read() }).unwrap();
-}
-
-pub extern "C" fn helper_force(
-    thunk: &mut Value,
+pub extern "C" fn helper_select_with_default(
+    val: &mut Value,
+    path_ptr: *mut Value,
+    path_len: usize,
+    default: NonNull<Value>,
     engine: &mut Engine,
     env: &mut Env,
 ) {
+    let path = core::ptr::slice_from_raw_parts_mut(path_ptr, path_len);
+    let path = unsafe { Box::from_raw(path) };
+    val.select_with_default(
+        path.into_iter().map(|mut val| {
+            val.force(engine, env)?.coerce_to_string();
+            Ok(val.unwrap_string())
+        }),
+        unsafe { default.read() },
+    )
+    .unwrap();
+}
+
+pub extern "C" fn helper_force(thunk: &mut Value, engine: &mut Engine, env: &mut Env) {
     thunk.force(engine, env).unwrap();
 }
 
@@ -69,9 +87,15 @@ pub extern "C" fn helper_eq(lhs: &mut Value, rhs: &Value) {
     lhs.eq(rhs);
 }
 
-pub unsafe extern "C" fn helper_create_string(ptr: *const u8, len: usize, ret: &mut MaybeUninit<Value>) {
+pub unsafe extern "C" fn helper_create_string(
+    ptr: *const u8,
+    len: usize,
+    ret: &mut MaybeUninit<Value>,
+) {
     unsafe {
-        ret.write(Value::String(str::from_utf8_unchecked(slice::from_raw_parts(ptr, len)).to_string()));
+        ret.write(Value::String(
+            str::from_utf8_unchecked(slice::from_raw_parts(ptr, len)).to_string(),
+        ));
     }
 }