Chore: Address clippy warnings.

Author: dylan-sutton-chavez

compiler/src/modules/lexer/scan.rs

@@ -375,14 +375,13 @@ impl<'a> Scanner<'a> {
                 return self.pending.pop();
             }
 
-            if is_string_prefix(slice) {
-                if let Some(&q) = self.src.get(self.pos) {
-                    if q == b'"' || q == b'\'' {
-                        self.pos += 1;
-                        self.scan_string(q);
-                        return Some((TokenType::String, self.line, start, self.pos));
-                    }
-                }
+            if is_string_prefix(slice)
+                && let Some(&q) = self.src.get(self.pos)
+                && (q == b'"' || q == b'\'')
+            {
+                self.pos += 1;
+                self.scan_string(q);
+                return Some((TokenType::String, self.line, start, self.pos));
             }
 
             let kind = keyword(slice).unwrap_or(TokenType::Name);
@@ -403,7 +402,7 @@ impl<'a> Scanner<'a> {
         }
 
         // Dot-number (.123)
-        if b == b'.' && self.at(1).map_or(false, |c| BYTE_CLASS[c as usize] & DIGIT != 0) {
+        if b == b'.' && self.at(1).is_some_and(|c| BYTE_CLASS[c as usize] & DIGIT != 0) {
             self.pos += 1;
             let kind = self.scan_dot_number();
             return Some((kind, self.line, start, self.pos));

compiler/src/modules/parser/control.rs

@@ -204,11 +204,9 @@ impl<'src, I: Iterator<Item = Token>> Parser<'src, I> {
         self.chunk.emit(OpCode::Jump, loop_start);
         self.patch(fi);
 
-        if !is_async {
-            if self.eat_if(TokenType::Else) {
-                self.eat(TokenType::Colon);
-                self.compile_block();
-            }
+        if !is_async && self.eat_if(TokenType::Else) {
+            self.eat(TokenType::Colon);
+            self.compile_block();
         }
 
         self.loop_starts.pop();
@@ -318,7 +316,7 @@ impl<'src, I: Iterator<Item = Token>> Parser<'src, I> {
         }
     }
 
-    pub(super) fn from_stmt(&mut self) {
+    pub(super) fn parse_from_stmt(&mut self) {
         self.advance();
         let module = self.dotted_name();
         let mod_idx = self.chunk.push_name(&module);

compiler/src/modules/parser/expr.rs

@@ -62,9 +62,7 @@ impl<'src, I: Iterator<Item = Token>> Parser<'src, I> {
     }
 
     pub(super) fn infix_bp(&mut self, min_bp: u8) {
-        loop {
-            let Some(tok) = self.peek() else { break };
-
+        while let Some(tok) = self.peek() {
             // `is` / `is not`
             if tok == TokenType::Is {
                 if 7 < min_bp { break; }
@@ -169,7 +167,7 @@ impl<'src, I: Iterator<Item = Token>> Parser<'src, I> {
             }
             TokenType::Complex => {
                 let raw = self.lexeme(&t).replace('_', "");
-                let s = raw.trim_end_matches(|c: char| c == 'j' || c == 'J');
+                let s = raw.trim_end_matches(['j', 'J']);
                 self.emit_const(Value::Float(s.parse().unwrap_or(0.0)));
             }
             TokenType::Int | TokenType::Float => {

compiler/src/modules/parser/literals.rs

@@ -203,7 +203,7 @@ impl<'src, I: Iterator<Item = Token>> Parser<'src, I> {
                         let colon = self.advance();
                         let spec_start = colon.end;
                         loop {
-                            match self.tokens.peek().map(|t| t.kind.clone()) {
+                            match self.tokens.peek().map(|t| t.kind) {
                                 Some(TokenType::Rbrace) | None => break,
                                 _ => { self.tokens.next(); }
                             }
@@ -389,7 +389,7 @@ impl<'src, I: Iterator<Item = Token>> Parser<'src, I> {
         let fi = self.chunk.functions.len() as u16;
         let cur_ver = self.current_version(&fname);
         let mut buf = [0u8; 128];
-        let name_slot = self.chunk.push_name(Self::ssa_name(&fname, cur_ver + 1, &mut buf)) as u16;
+        let name_slot = self.chunk.push_name(Self::ssa_name(&fname, cur_ver + 1, &mut buf));
         self.chunk.functions.push((params, body, defaults, name_slot));
         self.chunk.emit(if is_async { OpCode::MakeCoroutine } else { OpCode::MakeFunction }, fi);
 

compiler/src/modules/parser/stmt.rs

@@ -115,7 +115,7 @@ impl<'src, I: Iterator<Item = Token>> Parser<'src, I> {
                 false
             }
             Some(TokenType::From) => {
-                self.from_stmt();
+                self.parse_from_stmt();
                 false
             }
             Some(TokenType::Global) => {

compiler/src/modules/parser/types.rs

@@ -136,15 +136,13 @@ impl SSAChunk {
     pub fn finalize_prev_slots(&mut self) {
         let mut ps: Vec<Option<u16>> = vec![None; self.names.len()];
         for (i, name) in self.names.iter().enumerate() {
-            if let Some(pos) = name.rfind('_') {
-                if let Ok(ver) = name[pos+1..].parse::<u32>() {
-                    if ver > 0 {
-                        let prev = format!("{}_{}", &name[..pos], ver - 1);
-                        if let Some(&j) = self.name_index.get(&prev) {
-                            ps[i] = Some(j);
-                        }
+            if let Some(pos) = name.rfind('_')
+                && let Ok(ver) = name[pos+1..].parse::<u32>()
+                && ver > 0 {
+                    let prev = format!("{}_{}", &name[..pos], ver - 1);
+                    if let Some(&j) = self.name_index.get(&prev) {
+                        ps[i] = Some(j);
                     }
-                }
             }
         }
         self.prev_slots = ps;

compiler/src/modules/vm/builtins.rs

@@ -83,13 +83,12 @@ impl<'a> VM<'a> {
 
     pub fn call_int(&mut self) -> Result<(), VmErr> {
         let o = self.pop()?;
-        if o.is_heap() {
-            if let HeapObj::BigInt(b) = self.heap.get(o) {
+        if o.is_heap()
+            && let HeapObj::BigInt(b) = self.heap.get(o) {
                 let b = b.clone();
                 let v = self.bigint_to_val(b)?;
                 self.push(v);
                 return Ok(());
-            }
         }
         let i = if o.is_int() { o.as_int() }
             else if o.is_float() { o.as_float() as i64 }
@@ -143,13 +142,12 @@ impl<'a> VM<'a> {
 
     pub fn call_ord(&mut self) -> Result<(), VmErr> {
         let o = self.pop()?;
-        if o.is_heap() {
-            if let HeapObj::Str(s) = self.heap.get(o) {
+        if o.is_heap()
+            && let HeapObj::Str(s) = self.heap.get(o) {
                 let mut cs = s.chars();
                 if let (Some(c), None) = (cs.next(), cs.next()) {
                     self.push(Val::int(c as i64)); return Ok(());
                 }
-            }
         }
         Err(VmErr::Type("ord() requires string of length 1"))
     }
@@ -182,7 +180,7 @@ impl<'a> VM<'a> {
 
     pub fn call_round(&mut self, op: u16) -> Result<(), VmErr> {
         let args = self.pop_n(op as usize)?;
-        let v = match (args.get(0), args.get(1)) {
+        let v = match (args.first(), args.get(1)) {
             (Some(o), Some(n)) if o.is_float() && n.is_int() => {
                 let factor = fpowi(10.0, n.as_int() as i32);
                 Val::float(fround(o.as_float() * factor) / factor)
@@ -334,7 +332,7 @@ impl<'a> VM<'a> {
 
         let check = |t: Val, heap: &HeapPool| -> Result<bool, VmErr> {
             match heap.get(t) {
-                HeapObj::Type(name) => Ok(name == &obj_ty),
+                HeapObj::Type(name) => Ok(name == obj_ty),
                 _ => Err(VmErr::Type("isinstance() arg 2 must be a type or tuple of types")),
             }
         };

compiler/src/modules/vm/collections.rs

@@ -123,25 +123,23 @@ impl<'a> VM<'a> {
         let obj = self.pop()?;
 
         // Slice dispatch
-        if idx.is_heap() {
-            if let HeapObj::Slice(start, stop, step) = self.heap.get(idx).clone() {
+        if idx.is_heap()
+            && let HeapObj::Slice(start, stop, step) = self.heap.get(idx).clone() {
                 let v = self.slice_val(obj, start, stop, step)?;
                 self.push(v);
                 return Ok(true);
-            }
         }
 
         // Str[int] needs heap alloc
-        if obj.is_heap() && idx.is_int() {
-            if let HeapObj::Str(s) = self.heap.get(obj) {
+        if obj.is_heap() && idx.is_int()
+            && let HeapObj::Str(s) = self.heap.get(obj) {
                 let i = idx.as_int();
                 let len = s.chars().count() as i64;
                 let ui = (if i < 0 { len + i } else { i }) as usize;
                 let c = s.chars().nth(ui).ok_or(VmErr::Value("string index out of range"))?;
                 let val = self.heap.alloc(HeapObj::Str(c.to_string()))?;
                 self.push(val);
                 return Ok(true);
-            }
         }
 
         let v = self.getitem_val(obj, idx)?;

compiler/src/modules/vm/mod.rs

@@ -125,7 +125,7 @@ impl<'a> VM<'a> {
         Merges two SSA branches into target slot and back-propagates through prev_slots chain.
     */
 
-    fn exec_phi(op: u16, rip: usize, phi_map: &[usize], slots: &mut Vec<Option<Val>>, prev_slots: &[Option<u16>], phi_sources: &[(u16, u16)]) {
+    fn exec_phi(op: u16, rip: usize, phi_map: &[usize], slots: &mut [Option<Val>], prev_slots: &[Option<u16>], phi_sources: &[(u16, u16)]) {
         let target = op as usize;
         let (ia, ib) = phi_sources[phi_map[rip]];
         let val = slots[ia as usize].or(slots[ib as usize]).unwrap_or(Val::none());
@@ -193,14 +193,14 @@ impl<'a> VM<'a> {
     #[inline] pub(crate) fn push(&mut self, v: Val) { self.stack.push(v); }
 
     #[inline] pub(crate) fn pop(&mut self) -> Result<Val, VmErr> {
-        self.stack.pop().ok_or_else(|| VmErr::Runtime("stack underflow"))
+        self.stack.pop().ok_or(VmErr::Runtime("stack underflow"))
     }
     #[inline] pub(crate) fn pop2(&mut self) -> Result<(Val, Val), VmErr> {
         let b = self.pop()?; let a = self.pop()?; Ok((a, b))
     }
     #[inline] pub(crate) fn pop_n(&mut self, n: usize) -> Result<Vec<Val>, VmErr> {
-        let at = self.stack.len().checked_sub(n)
-            .ok_or_else(|| VmErr::Runtime("stack underflow"))?;
+    let at = self.stack.len().checked_sub(n)
+        .ok_or(VmErr::Runtime("stack underflow"))?;
         Ok(self.stack.split_off(at))
     }
 
@@ -209,7 +209,7 @@ impl<'a> VM<'a> {
         Converts a parser-level Value into a runtime Val, allocating heap for strings.
     */
 
-    pub(crate) fn to_val(&mut self, v: &Value) -> Result<Val, VmErr> {
+    pub(crate) fn val_from(&mut self, v: &Value) -> Result<Val, VmErr> {
         Ok(match v {
             Value::Int(i) => {
                 if *i >= Val::INT_MIN && *i <= Val::INT_MAX {
@@ -278,7 +278,7 @@ impl<'a> VM<'a> {
         Fetches instructions by IP, routes each opcode to its handler arm.
     */
 
-    pub(crate) fn exec(&mut self, chunk: &SSAChunk, slots: &mut Vec<Option<Val>>) -> Result<Val, VmErr> {
+    pub(crate) fn exec(&mut self, chunk: &SSAChunk, slots: &mut [Option<Val>]) -> Result<Val, VmErr> {
         let slots_base = self.live_slots.len();
         let n = chunk.instructions.len();
 
@@ -320,7 +320,7 @@ impl<'a> VM<'a> {
             match ins.opcode {
 
                 // Loads
-                OpCode::LoadConst => { let v = self.to_val(&chunk.constants[op as usize])?; self.push(v); }
+                OpCode::LoadConst => { let v = self.val_from(&chunk.constants[op as usize])?; self.push(v); }
                 OpCode::LoadName => { let slot = op as usize; self.push(slots[slot].ok_or_else(|| VmErr::Name(chunk.names[slot].clone()))?); }
                 OpCode::StoreName => {
                     let v = self.pop()?;
@@ -355,8 +355,8 @@ impl<'a> VM<'a> {
                 }
                 OpCode::Pow => {
                     let (a, b) = self.pop2()?;
-                    if let Some(ba) = self.to_bigint(a) {
-                        if b.is_int() {
+                    if let Some(ba) = self.to_bigint(a)
+                        && b.is_int() {
                             let exp = b.as_int();
                             if exp >= 0 {
                                 let result = ba.pow_u32(exp as u32);
@@ -366,7 +366,6 @@ impl<'a> VM<'a> {
                             }
                             self.push(Val::float(fpowi(ba.to_f64(), exp as i32)));
                             continue;
-                        }
                     }
                     let fa = if a.is_int() { a.as_int() as f64 } else if a.is_float() { a.as_float() }
                             else { return Err(VmErr::Type("** requires numeric operands")); };
@@ -517,7 +516,7 @@ impl<'a> VM<'a> {
 
                 OpCode::ListAppend => {
                     let v = self.pop()?;
-                    let acc = *self.stack.last().ok_or_else(|| VmErr::Runtime("stack underflow"))?;
+                    let acc = *self.stack.last().ok_or(VmErr::Runtime("stack underflow"))?;
                     if !acc.is_heap() { return Err(VmErr::Runtime("list accumulator corrupted")); }
                     match self.heap.get(acc) {
                         HeapObj::List(rc) => rc.borrow_mut().push(v),
@@ -526,20 +525,18 @@ impl<'a> VM<'a> {
                 }
                 OpCode::SetAdd => {
                     let v = self.pop()?;
-                    let acc = *self.stack.last().ok_or_else(|| VmErr::Runtime("stack underflow"))?;
+                    let acc = *self.stack.last().ok_or(VmErr::Runtime("stack underflow"))?;
                     if !acc.is_heap() { return Err(VmErr::Runtime("set accumulator corrupted")); }
                     let already = match self.heap.get(acc) {
                         HeapObj::Set(rc) => rc.borrow().iter().any(|&x| eq_vals_with_heap(x, v, &self.heap)),
                         _ => return Err(VmErr::Runtime("set accumulator corrupted")),
                     };
-                    if !already {
-                        if let HeapObj::Set(rc) = self.heap.get(acc) { rc.borrow_mut().push(v); }
-                    }
+                    if !already && let HeapObj::Set(rc) = self.heap.get(acc) { rc.borrow_mut().push(v); }
                 }
                 OpCode::MapAdd => {
                     let value = self.pop()?;
                     let key = self.pop()?;
-                    let acc = *self.stack.last().ok_or_else(|| VmErr::Runtime("stack underflow"))?;
+                    let acc = *self.stack.last().ok_or(VmErr::Runtime("stack underflow"))?;
                     if !acc.is_heap() { return Err(VmErr::Runtime("dict accumulator corrupted")); }
                     match self.heap.get(acc) {
                         HeapObj::Dict(rc) => { rc.borrow_mut().insert(key, value); }
@@ -580,21 +577,22 @@ impl<'a> VM<'a> {
                     for (i, n) in body.names.iter().enumerate() { body_map.insert(n.as_str(), i); }
                     // Bind args to params: detects keyword args (HeapObj::Str matching a param name) and consumes key+value pairs
                     let mut pi = 0usize;
-                    for (_, p) in params.iter().enumerate() {
-                        if pi >= args.len() { break; }
-                        if args[pi].is_heap() {
-                            if let HeapObj::Str(k) = self.heap.get(args[pi]) {
-                                if params.iter().any(|p| p.trim_start_matches('*') == k.as_str()) && pi + 1 < args.len() {
-                                    let pname = format!("{}_0", k);
-                                    if let Some(&s) = body_map.get(pname.as_str()) { fn_slots[s] = Some(args[pi + 1]); }
-                                    pi += 2;
-                                    continue;
-                                }
-                            }
+                    for p in params.iter() {
+                        if pi < args.len()
+                            && args[pi].is_heap()
+                            && let HeapObj::Str(k) = self.heap.get(args[pi])
+                            && params.iter().any(|p| p.trim_start_matches('*') == k.as_str())
+                            && pi + 1 < args.len() {
+                                let pname = format!("{}_0", k);
+                                if let Some(&s) = body_map.get(pname.as_str()) { fn_slots[s] = Some(args[pi + 1]); }
+                                pi += 2;
+                                continue;
+                        }
+                        if pi < args.len() {
+                            let pname = format!("{}_0", p.trim_start_matches('*'));
+                            if let Some(&s) = body_map.get(pname.as_str()) { fn_slots[s] = Some(args[pi]); }
+                            pi += 1;
                         }
-                        let pname = format!("{}_0", p.trim_start_matches('*'));
-                        if let Some(&s) = body_map.get(pname.as_str()) { fn_slots[s] = Some(args[pi]); }
-                        pi += 1;
                     }
                     if pi < params.len() && !captured_defaults.is_empty() {
                         let d_start = captured_defaults.len().saturating_sub(params.len() - pi);