Fix linting (#2418)

lib/ffi/src/cps/async_stack.rs

@@ -41,8 +41,9 @@ impl<V> AsyncStack<V> {
     }
 
     pub fn context(&mut self) -> Option<&mut Context<'_>> {
-        self.context
-            .map(|context| unsafe { &mut *transmute::<_, *mut _>(context) })
+        self.context.map(|context| unsafe {
+            &mut *transmute::<*mut Context<'_>, *mut Context<'_>>(context)
+        })
     }
 
     pub fn run_with_context<T>(

lib/ffi/src/future/call.rs

@@ -32,7 +32,7 @@ macro_rules! call {
                 let closure = $closure;
 
                 (unsafe {
-                    transmute::<_, InitialStepFunction<_>>(closure.entry_function())
+                    transmute::<*const u8, InitialStepFunction<$result_type>>(closure.entry_function())
                 })(stack, resolve, closure, $($argument),*);
             });
             let mut trampoline: Option<Trampoline> = None;
@@ -77,15 +77,15 @@ mod tests {
 
     #[tokio::test]
     async fn call_thunk() {
-        let value = 42.0;
+        let value = Number::new(42.0);
 
         assert_eq!(
             call!(
                 fn() -> Number,
                 Closure::new(thunk_entry_function as *const u8, value),
             )
             .await,
-            value.into()
+            value
         );
     }
 
@@ -105,7 +105,7 @@ mod tests {
         assert_eq!(
             call!(
                 fn(Number) -> Number,
-                Closure::new(closure_entry_function as *const u8, ()),
+                Closure::new(closure_entry_function as *const u8, Default::default()),
                 value.into(),
             )
             .await,
@@ -128,7 +128,10 @@ mod tests {
         assert_eq!(
             call!(
                 fn(Number, Number) -> Number,
-                Closure::new(closure_2_arity_entry_function as *const u8, ()),
+                Closure::new(
+                    closure_2_arity_entry_function as *const u8,
+                    Default::default()
+                ),
                 40.0.into(),
                 2.0.into(),
             )
@@ -162,7 +165,10 @@ mod tests {
         assert_eq!(
             call!(
                 fn() -> Number,
-                Closure::new(closure_entry_function_with_suspension as *const u8, ()),
+                Closure::new(
+                    closure_entry_function_with_suspension as *const u8,
+                    Default::default()
+                ),
             )
             .await,
             42.0.into()
@@ -185,7 +191,10 @@ mod tests {
         assert_eq!(
             call!(
                 fn(ByteString) -> ByteString,
-                Closure::new(closure_entry_function_with_string as *const u8, ()),
+                Closure::new(
+                    closure_entry_function_with_string as *const u8,
+                    Default::default()
+                ),
                 value.into(),
             )
             .await,
@@ -200,7 +209,10 @@ mod tests {
         assert_eq!(
             call!(
                 fn(ByteString) -> ByteString,
-                Closure::new(closure_entry_function_with_string as *const u8, ()),
+                Closure::new(
+                    closure_entry_function_with_string as *const u8,
+                    Default::default()
+                ),
                 value.clone(),
             )
             .await,

lib/ffi/src/future/from_closure.rs

@@ -23,8 +23,9 @@ pub async fn from_closure<T, V>(closure: Closure<T>) -> V {
                 step(stack, continue_);
             } else {
                 let closure = closure.take().unwrap();
-                let entry_function =
-                    unsafe { transmute::<_, InitialStepFunction<V, T>>(closure.entry_function()) };
+                let entry_function = unsafe {
+                    transmute::<*const u8, InitialStepFunction<V, T>>(closure.entry_function())
+                };
 
                 entry_function(stack, resolve, closure);
             }

packages/core/ffi/src/bit.rs

@@ -2,32 +2,32 @@ use core::mem::transmute;
 
 #[ffi::bindgen]
 fn _pen_core_bit_and(x: ffi::Number, y: ffi::Number) -> ffi::Number {
-    unsafe { transmute(transmute::<_, u64>(x) & transmute::<_, u64>(y)) }
+    unsafe { transmute(transmute::<ffi::Number, u64>(x) & transmute::<ffi::Number, u64>(y)) }
 }
 
 #[ffi::bindgen]
 fn _pen_core_bit_or(x: ffi::Number, y: ffi::Number) -> ffi::Number {
-    unsafe { transmute(transmute::<_, u64>(x) | transmute::<_, u64>(y)) }
+    unsafe { transmute(transmute::<ffi::Number, u64>(x) | transmute::<ffi::Number, u64>(y)) }
 }
 
 #[ffi::bindgen]
 fn _pen_core_bit_xor(x: ffi::Number, y: ffi::Number) -> ffi::Number {
-    unsafe { transmute(transmute::<_, u64>(x) ^ transmute::<_, u64>(y)) }
+    unsafe { transmute(transmute::<ffi::Number, u64>(x) ^ transmute::<ffi::Number, u64>(y)) }
 }
 
 #[ffi::bindgen]
 fn _pen_core_bit_not(x: ffi::Number) -> ffi::Number {
-    unsafe { transmute(!transmute::<_, u64>(x)) }
+    unsafe { transmute(!transmute::<ffi::Number, u64>(x)) }
 }
 
 #[ffi::bindgen]
 fn _pen_core_bit_left_shift(x: ffi::Number, count: ffi::Number) -> ffi::Number {
-    unsafe { transmute(transmute::<_, u64>(x) << (f64::from(count) as u64)) }
+    unsafe { transmute(transmute::<ffi::Number, u64>(x) << (f64::from(count) as u64)) }
 }
 
 #[ffi::bindgen]
 fn _pen_core_bit_right_shift(x: ffi::Number, count: ffi::Number) -> ffi::Number {
-    unsafe { transmute(transmute::<_, u64>(x) >> (f64::from(count) as u64)) }
+    unsafe { transmute(transmute::<ffi::Number, u64>(x) >> (f64::from(count) as u64)) }
 }
 
 #[ffi::bindgen]
@@ -37,7 +37,7 @@ fn _pen_core_bit_to_integer_64(x: ffi::Number) -> ffi::Number {
 
 #[ffi::bindgen]
 fn _pen_core_bit_from_integer_64(x: ffi::Number) -> ffi::Number {
-    (unsafe { transmute::<_, u64>(x) } as f64).into()
+    (unsafe { transmute::<ffi::Number, u64>(x) } as f64).into()
 }
 
 #[cfg(test)]

packages/os-sync/ffi/Cargo.toml

@@ -1,2 +1,3 @@
 [workspace]
+resolver = "2"
 members = ["application", "library"]