Refactor: Clean code, refactor docs and address linter comments.

Author: dylan-sutton-chavez

compiler/src/modules/parser/literals.rs

@@ -5,7 +5,6 @@ use super::types::{OpCode, Value, SSAChunk};
 use super::types::builtin;
 use crate::modules::lexer::{Token, TokenType};
 use alloc::{string::{String, ToString}, vec::Vec, format};
-use hashbrown::HashMap;
 
 impl<'src, I: Iterator<Item = Token>> Parser<'src, I> {
 
@@ -323,7 +322,7 @@ impl<'src, I: Iterator<Item = Token>> Parser<'src, I> {
 
         self.compile_block();
 
-        let mut body = core::mem::take(&mut self.chunk);
+        let body = core::mem::take(&mut self.chunk);
         self.chunk = saved_chunk;
         self.ssa_versions  = saved_ver;
 

compiler/src/modules/parser/types.rs

@@ -196,7 +196,7 @@ fn unescape(s: &str) -> String {
     let mut out = String::with_capacity(s.len());
     let mut chars = s.chars().peekable();
 
-    let mut take_hex = |chars: &mut core::iter::Peekable<core::str::Chars>, n: usize| -> char {
+    let take_hex = |chars: &mut core::iter::Peekable<core::str::Chars>, n: usize| -> char {
         let hex: String = chars.by_ref().take(n).collect();
         u32::from_str_radix(&hex, 16).ok().and_then(char::from_u32).unwrap_or('\u{FFFD}')
     };

compiler/src/modules/vm/builtins.rs

@@ -110,7 +110,7 @@ impl<'a> VM<'a> {
 
     pub fn call_float(&mut self) -> Result<(), VmErr> {
         let o = self.pop()?;
-        let f = if o.is_float()  { o.as_float() }
+        let f = if o.is_float() { o.as_float() }
             else if o.is_int() { o.as_int() as f64 }
             else if o.is_heap() { match self.heap.get(o) {
                 HeapObj::Str(s) => s.trim().parse().map_err(|_| VmErr::Value(format!("float: '{}'", s)))?,

compiler/src/modules/vm/cache.rs

@@ -1,4 +1,5 @@
 // vm/cache.rs
+
 use super::types::{Val, eq_vals_deep};
 use crate::modules::parser::OpCode;
 use alloc::{vec, vec::Vec};
@@ -64,10 +65,6 @@ impl OpcodeCache {
         if let Some(s) = self.slots.get_mut(ip) { *s = CacheSlot::empty(); }
     }
 
-    pub fn specialized_count(&self) -> usize {
-        self.slots.iter().filter(|s| s.hot_fast.is_some()).count()
-    }
-
     fn specialize(opcode: &OpCode, ta: u8, tb: u8) -> Option<FastOp> {
         match (opcode, ta, tb) {
             (OpCode::Add, 1, 1) => Some(FastOp::AddInt), (OpCode::Add, 2, 2) => Some(FastOp::AddFloat),

compiler/src/modules/vm/collections.rs

@@ -30,8 +30,8 @@ impl<'a> VM<'a> {
     */
 
     pub fn build_slice(&mut self, op: u16) -> Result<(), VmErr> {
-        let step  = if op == 3 { self.pop()? } else { Val::none() };
-        let stop  = self.pop()?;
+        let step = if op == 3 { self.pop()? } else { Val::none() };
+        let stop = self.pop()?;
         let start = self.pop()?;
         let val = self.heap.alloc(HeapObj::Slice(start, stop, step))?;
         self.push(val); Ok(())
@@ -52,7 +52,7 @@ impl<'a> VM<'a> {
             _ => return Err(VmErr::Type("cannot unpack".into())),
         };
         let before = (op >> 8) as usize;
-        let after  = (op & 0xFF) as usize;
+        let after = (op & 0xFF) as usize;
         if items.len() < before + after {
             return Err(VmErr::Value("not enough values to unpack".into()));
         }
@@ -239,9 +239,9 @@ impl<'a> VM<'a> {
     */
 
     pub fn store_item(&mut self) -> Result<(), VmErr> {
-        let value   = self.pop()?;
+        let value = self.pop()?;
         let idx_val = self.pop()?;
-        let cont    = self.pop()?;
+        let cont = self.pop()?;
         if !cont.is_heap() { return Err(VmErr::Type("item assignment on non-container".into())); }
         match self.heap.get_mut(cont) {
             HeapObj::List(v) => {

compiler/src/modules/vm/mod.rs

@@ -30,11 +30,11 @@ pub struct VM<'a> {
     pub(crate) chunk: &'a SSAChunk,
     pub(crate) globals: HashMap<String, Val>,
     pub(crate) live_slots: Vec<Val>,
+    pub output: Vec<String>,
     templates: Templates,
     budget:usize,
     depth: usize,
-    max_calls: usize,
-    pub output: Vec<String>,
+    max_calls: usize
 }
 
 impl<'a> VM<'a> {
@@ -83,7 +83,6 @@ impl<'a> VM<'a> {
             HeapObj::Set(s)   => IterFrame::Seq { items: s.borrow().clone(), idx: 0 },
             HeapObj::Str(s) => {
                 let chars: Vec<char> = s.chars().collect();
-                drop(s);
                 let mut items = Vec::with_capacity(chars.len());
                 for c in chars { items.push(self.heap.alloc(HeapObj::Str(c.to_string()))?); }
                 IterFrame::Seq { items, idx: 0 }
@@ -105,7 +104,6 @@ impl<'a> VM<'a> {
             HeapObj::Tuple(v) => v.clone(),
             HeapObj::Str(s) => {
                 let chars: Vec<char> = s.chars().collect();
-                drop(s);
                 if chars.len() != expected {
                     return Err(VmErr::Value(format!("expected {} values to unpack, got {}", expected, chars.len())));
                 }
@@ -168,7 +166,8 @@ impl<'a> VM<'a> {
         self.exec(self.chunk, &mut slots)
     }
 
-    fn collect(&mut self, current_slots: &[Option<Val>]) { // Marks all reachable values from stack, globals, iterators and slots, then sweeps.
+    // Marks all reachable values from stack, globals, iterators and slots, then sweeps.
+    fn collect(&mut self, current_slots: &[Option<Val>]) {
         for &v in &self.stack { self.heap.mark(v); }
         for &v in self.globals.values() { self.heap.mark(v); }
         for frame in &self.iter_stack {

compiler/src/modules/vm/ops.rs

@@ -97,7 +97,7 @@ impl<'a> VM<'a> {
                 .map(|x| self.repr(*x)).collect::<Vec<_>>().join(", ")),
             HeapObj::Slice(s, e, st) => format!("slice({}, {}, {})",
                 self.display(*s), self.display(*e), self.display(*st)),
-            HeapObj::BigInt(b)  => b.to_decimal(),
+            HeapObj::BigInt(b) => b.to_decimal(),
             HeapObj::Type(name) => format!("<class '{}'>", name)
         }
     }
@@ -127,7 +127,8 @@ impl<'a> VM<'a> {
         Err(VmErr::Type(format!("'<' not supported between '{}' and '{}'", self.type_name(a), self.type_name(b))))
     }
 
-    pub fn contains(&self, container: Val, item: Val) -> bool { // Checks item presence in list, tuple, dict, set, or substring in str
+    // Checks item presence in list, tuple, dict, set, or substring in string.
+    pub fn contains(&self, container: Val, item: Val) -> bool {
         if !container.is_heap() { return false; }
         match self.heap.get(container) {
             HeapObj::List(v) => v.borrow().iter().any(|x| self.eq_vals(*x, item)),
@@ -216,10 +217,6 @@ impl<'a> VM<'a> {
         None
     }
 
-    pub(crate) fn is_int_type(&self, v: Val) -> bool {
-        v.is_int() || (v.is_heap() && matches!(self.heap.get(v), HeapObj::BigInt(_)))
-    }
-
     pub(crate) fn bigint_to_val(&mut self, b: BigInt) -> Result<Val, VmErr> {
         if let Some(i) = b.to_i64_checked() {
             if i >= Val::INT_MIN && i <= Val::INT_MAX { return Ok(Val::int(i)); }