fix: clippy happy

Author: fffonion

pd-edge/src/runtime/vm_runner.rs

@@ -38,69 +38,60 @@ pub async fn execute_vm_with_context(
     let program = program.program.clone();
     let async_ops = new_shared_vm_async_ops();
 
-    if debug.attach_debugger {
-        let async_ops_for_debug = async_ops.clone();
-        let vm_context_for_debug = vm_context.clone();
-        let program_for_debug = program.clone();
-        let task = tokio::task::spawn_blocking(move || {
-            let mut vm = Vm::with_locals_shared(program_for_debug, local_count);
-            vm.set_async_bridge(Box::new(VmAsyncOpBridge::new(async_ops_for_debug.clone())));
-            register_host_modules(&mut vm, vm_context_for_debug.clone(), async_ops_for_debug)
-                .map_err(VmExecutionError::HostRegistration)?;
-
-            loop {
-                let status = run_vm_with_optional_debugger(
-                    &debug_session,
-                    &debug.request_headers,
-                    &debug.request_path,
-                    &debug.request_id,
-                    &mut vm,
-                )
-                .map_err(VmExecutionError::Vm)?;
-
-                match status {
-                    VmStatus::Halted => break,
-                    VmStatus::Yielded => continue,
-                    VmStatus::Waiting(_op_id) => tokio::runtime::Handle::current()
-                        .block_on(vm.await_waiting_host_op())
-                        .map_err(VmExecutionError::Vm)?,
-                }
-            }
-
-            Ok(snapshot_execution_outcome(&vm_context_for_debug))
-        });
+    let task = tokio::task::spawn_blocking(move || {
+        run_vm_blocking(
+            program,
+            local_count,
+            vm_context,
+            debug_session,
+            debug,
+            async_ops,
+            register_host_modules,
+        )
+    });
 
-        return task.await.map_err(|err| {
-            VmExecutionError::Vm(vm::VmError::HostError(format!(
-                "vm blocking execution task failed: {err}"
-            )))
-        })?;
-    }
+    task.await.map_err(|err| {
+        VmExecutionError::Vm(vm::VmError::HostError(format!(
+            "vm blocking execution task failed: {err}"
+        )))
+    })?
+}
 
+fn run_vm_blocking(
+    program: std::sync::Arc<vm::Program>,
+    local_count: usize,
+    vm_context: SharedProxyVmContext,
+    debug_session: SharedDebugSession,
+    debug: VmDebugInvocation,
+    async_ops: SharedVmAsyncOps,
+    register_host_modules: HostModuleRegistrar,
+) -> Result<VmExecutionOutcome, VmExecutionError> {
     let mut vm = Vm::with_locals_shared(program, local_count);
     vm.set_async_bridge(Box::new(VmAsyncOpBridge::new(async_ops.clone())));
     register_host_modules(&mut vm, vm_context.clone(), async_ops)
         .map_err(VmExecutionError::HostRegistration)?;
 
     loop {
-        let status = run_vm_with_optional_debugger(
-            &debug_session,
-            &debug.request_headers,
-            &debug.request_path,
-            &debug.request_id,
-            &mut vm,
-        )
+        let status = if debug.attach_debugger {
+            run_vm_with_optional_debugger(
+                &debug_session,
+                &debug.request_headers,
+                &debug.request_path,
+                &debug.request_id,
+                &mut vm,
+            )
+        } else {
+            vm.run()
+        }
         .map_err(VmExecutionError::Vm)?;
         match status {
             VmStatus::Halted => break,
             VmStatus::Yielded => {
-                tokio::task::yield_now().await;
-            }
-            VmStatus::Waiting(_op_id) => {
-                vm.await_waiting_host_op()
-                    .await
-                    .map_err(VmExecutionError::Vm)?;
+                std::thread::yield_now();
             }
+            VmStatus::Waiting(_op_id) => tokio::runtime::Handle::current()
+                .block_on(vm.await_waiting_host_op())
+                .map_err(VmExecutionError::Vm)?,
         }
     }
 

pd-vm/src/compiler/lifetime.rs

@@ -109,7 +109,7 @@ impl AvailabilityAnalyzer {
                 let after_possible = state.possible[slot];
                 let after_definite = state.definite[slot];
                 let entered_uncertain =
-                    after_possible && !after_definite && !(before_possible && !before_definite);
+                    after_possible && !after_definite && (!before_possible || before_definite);
                 if entered_uncertain {
                     rewritten.push(Stmt::Assign {
                         index: slot as u8,
@@ -198,8 +198,10 @@ impl AvailabilityAnalyzer {
                 // `for` loop condition executes before each iteration and at least once.
                 // Body/post execution is optional, so only condition-side availability is guaranteed after loop.
                 let mut possible = cond_state.possible.clone();
-                for slot in 0..self.local_count {
-                    possible[slot] = possible[slot] || post_state.possible[slot];
+                for (possible_slot, post_possible) in
+                    possible.iter_mut().zip(post_state.possible.iter())
+                {
+                    *possible_slot = *possible_slot || *post_possible;
                 }
                 let out = FlowState {
                     reachable: state.reachable && cond_state.reachable,
@@ -227,8 +229,10 @@ impl AvailabilityAnalyzer {
 
                 // `while` condition executes at least once; body execution is optional.
                 let mut possible = cond_state.possible.clone();
-                for slot in 0..self.local_count {
-                    possible[slot] = possible[slot] || body_state.possible[slot];
+                for (possible_slot, body_possible) in
+                    possible.iter_mut().zip(body_state.possible.iter())
+                {
+                    *possible_slot = *possible_slot || *body_possible;
                 }
                 let out = FlowState {
                     reachable: state.reachable && cond_state.reachable,

pd-vm/src/vm/jit/native/mod.rs

@@ -88,7 +88,7 @@ pub(super) enum CompiledNativeTrace {
         code: Vec<u8>,
     },
     #[cfg(feature = "cranelift-jit")]
-    Cranelift(CraneliftCompiledTrace),
+    Cranelift(Box<CraneliftCompiledTrace>),
 }
 
 pub(super) fn compile_native_trace(
@@ -139,9 +139,9 @@ pub(super) fn take_bridge_error() -> Option<VmError> {
 fn compile_native_trace_cranelift(trace: &super::JitTrace) -> VmResult<CompiledNativeTrace> {
     #[cfg(feature = "cranelift-jit")]
     {
-        return Ok(CompiledNativeTrace::Cranelift(cranelift::compile_trace(
-            trace,
-        )?));
+        Ok(CompiledNativeTrace::Cranelift(Box::new(
+            cranelift::compile_trace(trace)?,
+        )))
     }
 
     #[cfg(not(feature = "cranelift-jit"))]

pd-vm/src/vm/jit/runtime.rs

@@ -1,6 +1,8 @@
 use super::super::{ExecOutcome, HostCallExecOutcome, Vm, VmError, VmResult};
 use super::{JitTrace, JitTraceTerminal, TraceStep, native};
 use std::collections::HashMap;
+#[cfg(feature = "cranelift-jit")]
+use std::rc::Rc;
 use std::sync::Arc;
 #[cfg(any(
     all(
@@ -41,7 +43,7 @@ type NativeTraceEntry = unsafe extern "C" fn(*mut Vm) -> i32;
 type NativeTraceEntry = fn(*mut Vm) -> i32;
 
 #[cfg(feature = "cranelift-jit")]
-type MaybeCraneliftKeepalive = Option<Arc<native::CraneliftTraceKeepAlive>>;
+type MaybeCraneliftKeepalive = Option<Rc<native::CraneliftTraceKeepAlive>>;
 
 pub(crate) struct NativeTrace {
     #[cfg(any(
@@ -113,7 +115,7 @@ struct NativeTraceCache {
 #[derive(Clone)]
 struct CraneliftNativeTraceCacheEntry {
     entry: NativeTraceEntry,
-    keepalive: Arc<native::CraneliftTraceKeepAlive>,
+    keepalive: Rc<native::CraneliftTraceKeepAlive>,
     code: Arc<[u8]>,
 }
 
@@ -635,12 +637,12 @@ impl Vm {
                             std::mem::transmute::<*const u8, NativeTraceEntry>(compiled.entry)
                         };
                         let code = Arc::<[u8]>::from(compiled.code.into_boxed_slice());
-                        let keepalive = Arc::new(compiled.keepalive);
+                        let keepalive = Rc::new(compiled.keepalive);
                         #[cfg(feature = "cranelift-jit")]
                         {
                             let cached = CraneliftNativeTraceCacheEntry {
                                 entry,
-                                keepalive: Arc::clone(&keepalive),
+                                keepalive: Rc::clone(&keepalive),
                                 code: Arc::clone(&code),
                             };
                             let key = native_trace_cache_key(