refactor(vm): address clippy linter comments.

Author: dylan-sutton-chavez

compiler/src/modules/vm/builtins.rs

@@ -1072,7 +1072,7 @@ impl<'a> VM<'a> {
                 if was_yielded {
                     // Check if it yielded a sleep request (negative int = sleep cycles)
                     let new_sleep = if result.is_int() && result.as_int() < 0 {
-                        (-result.as_int()) as i64
+                        -result.as_int()
                     } else { 0 };
                     next_queue.push((coro, new_sleep));
                 } else if result.is_none() {

compiler/src/modules/vm/handlers/function.rs

@@ -147,7 +147,7 @@ impl<'a> VM<'a> {
                 args.extend_from_slice(&positional);
                 for a in &args { self.push(*a); }
                 let argc = args.len() as u16;
-                let encoded = ((0u16) << 8) | argc;
+                let encoded = argc;
                 self.exec_call(encoded, chunk, slots)?;
                 self.pop()?; // discard __init__ return
             }

compiler/src/modules/vm/handlers/methods.rs

@@ -88,14 +88,13 @@ impl<'a> VM<'a> {
                     return Ok(());
                 }
                 if cls_val.is_heap()
-                    && let HeapObj::Class(_, methods) = self.heap.get(cls_val) {
-                        if let Some((_, mv)) = methods.iter().find(|(n, _)| n == name) {
-                            let mv = *mv;
+                    && let HeapObj::Class(_, methods) = self.heap.get(cls_val)
+                    && let Some((_, mv)) = methods.iter().find(|(n, _)| n == name) {
+                        let mv = *mv;
                             let bound = self.heap.alloc(HeapObj::BoundUserMethod(obj, mv))?;
                             self.push(bound);
                             return Ok(());
                         }
-                    }
                 return Err(VmErr::Type("attribute not found"));
             }
 

compiler/src/modules/vm/mod.rs

@@ -251,11 +251,11 @@ impl<'a> VM<'a> {
             let (params, _, _, _) = vm.functions[fi];
             let bm = &vm.body_maps[fi];
             params.iter().map(|p| {
-                if p.starts_with("**") {
-                    let slot = bm.get(&alloc::format!("{}_0", &p[2..])).copied().unwrap_or(usize::MAX);
+                if let Some(stripped) = p.strip_prefix("**") {
+                    let slot = bm.get(&alloc::format!("{}_0", stripped)).copied().unwrap_or(usize::MAX);
                     (ParamKind::DoubleStar, slot)
-                } else if p.starts_with('*') {
-                    let slot = bm.get(&alloc::format!("{}_0", &p[1..])).copied().unwrap_or(usize::MAX);
+                } else if let Some(stripped) = p.strip_prefix('*') {
+                    let slot = bm.get(&alloc::format!("{}_0", stripped)).copied().unwrap_or(usize::MAX);
                     (ParamKind::Star, slot)
                 } else {
                     let slot = bm.get(&alloc::format!("{}_0", p)).copied().unwrap_or(usize::MAX);
@@ -566,10 +566,10 @@ impl<'a> VM<'a> {
         if obj.is_heap()
             && let HeapObj::Instance(cls_val, _) = self.heap.get(obj) {
                 let cls_val = *cls_val;
-                if cls_val.is_heap() {
-                    if let HeapObj::Class(_, methods) = self.heap.get(cls_val)
-                        && let Some((_, mv)) = methods.iter().find(|(n, _)| n == name.as_str()) {
-                            let mv = *mv;
+                if cls_val.is_heap()
+                    && let HeapObj::Class(_, methods) = self.heap.get(cls_val)
+                    && let Some((_, mv)) = methods.iter().find(|(n, _)| n == name.as_str()) {
+                        let mv = *mv;
                             // Call the method with self prepended
                             self.push(mv);
                             self.push(obj);
@@ -578,7 +578,6 @@ impl<'a> VM<'a> {
                             let encoded = ((kw_flat.len() as u16 / 2) << 8) | argc;
                             return self.exec_call(encoded, chunk, slots);
                         }
-                }
             }
         let method_id = handlers::methods::lookup_method(ty, name.as_str())
             .ok_or(VmErr::Type("'object' has no attribute"))?;

compiler/src/modules/vm/ops.rs

@@ -99,8 +99,7 @@ impl<'a> VM<'a> {
             HeapObj::BoundMethod(..) => "builtin_function_or_method",
             HeapObj::NativeFn(_) => "builtin_function_or_method",
             HeapObj::Class(_name, _) => "type",
-
-            HeapObj::BoundUserMethod(_, _) => "<bound method>".into(),
+            HeapObj::BoundUserMethod(_, _) => "<bound method>",
             HeapObj::Instance(..) => "object",
             HeapObj::Coroutine(..) => "coroutine",
         }}