docs(fstr): refactor comments.

Author: dylan-sutton-chavez

compiler/src/abi.rs

@@ -93,7 +93,7 @@ struct HandleSlot {
     rc: u32,
 }
 
-// Refcounted u32→u64 (Val bits) map; single instance per script run, cleared between runs.
+// Refcounted u32->u64 (Val bits) map; single instance per script run, cleared between runs.
 pub struct HandleTable {
     slots: Vec<HandleSlot>,
     free_list: Vec<u32>,

compiler/src/modules/fstr.rs

@@ -1,15 +1,14 @@
-/* Format an f64 to a Python-display string (NaN, ±inf, ±0.0,
-   whole-number floats with trailing ".0", else Rust's default). */
+/* f64 -> Python-style string: nan/±inf/±0.0/whole->".0" suffix/else default. */
 pub fn format_f64(f: f64) -> alloc::string::String {
-    // Lowercase per CPython repr/str semantics (was "NaN" — capitalised mismatch).
+    // Lowercase per CPython semantics; "NaN" was a mismatch.
     if f.is_nan() { return alloc::string::String::from("nan"); }
     if f == f64::INFINITY { return alloc::string::String::from("inf"); }
     if f == f64::NEG_INFINITY { return alloc::string::String::from("-inf"); }
     if f == 0.0 {
         return if f.is_sign_negative() { alloc::string::String::from("-0.0") } else { alloc::string::String::from("0.0") };
     }
 
-    // Whole-number floats: itoa + ".0" avoids Rust's "1" output for 1.0.
+    // Whole float: itoa + ".0" avoids Rust's bare "1" for 1.0.
     const I64_UPPER: f64 = i64::MAX as f64;
     if f.is_finite() && f >= (i64::MIN as f64) && f < I64_UPPER && f == (f as i64) as f64 {
         let mut b = itoa::Buffer::new();
@@ -23,7 +22,7 @@ pub fn format_f64(f: f64) -> alloc::string::String {
     format_general(f)
 }
 
-/* 32-byte stack buffer is enough for any f64 in default formatting. */
+/* 32-byte stack buffer fits any f64 default format. */
 fn format_general(f: f64) -> alloc::string::String {
     let mut buf = FmtBuf::new();
     let _ = core::fmt::write(&mut buf, core::format_args!("{}", f));
@@ -71,8 +70,7 @@ macro_rules! s {
     ($($t:tt)*) => {{ let mut _s = alloc::string::String::new(); $crate::s!(@b _s; $($t)*); _s }};
 }
 
-/* Format little-endian base-10⁹ digit groups as a decimal string.
-   Highest group is unpadded; the rest are zero-padded to width 9. */
+/* Formats little-endian base-10⁹ groups as decimal; highest unpadded, rest zero-padded to 9. */
 pub fn format_dec_groups(groups: &[u32]) -> alloc::string::String {
     let mut out = alloc::string::String::new();
     for (i, &g) in groups.iter().rev().enumerate() {

compiler/src/modules/parser/literals.rs

@@ -280,7 +280,7 @@ impl<'src, I: Iterator<Item = Token>> Parser<'src, I> {
         }
     }
 
-    /* Dispatches call: print/range→dedicated opcodes; builtins→table; natives→CallExtern; else LoadName+Call. */
+    /* Dispatches call: print/range->dedicated opcodes; builtins->table; natives->CallExtern; else LoadName+Call. */
     pub(super) fn call(&mut self, name: String) -> bool {
         let call_pos = self.last_end as u32;
         if name == "print" {

compiler/src/modules/parser/mod.rs

@@ -313,7 +313,7 @@ impl<'src, I: Iterator<Item = Token>> Parser<'src, I> {
         self.lexeme(&t).to_string()
     }
 
-    /* Skips Newline/Nl/Comment; maps Endmarker→None; latches saw_newline for ternary detection. */
+    /* Skips Newline/Nl/Comment; maps Endmarker->None; latches saw_newline for ternary detection. */
     pub(super) fn peek(&mut self) -> Option<TokenType> {
         loop {
             match self.tokens.peek().map(|t| t.kind) {

compiler/src/modules/parser/stmt.rs

@@ -11,7 +11,7 @@ impl<'src, I: Iterator<Item = Token>> Parser<'src, I> {
 
     /* Statement dispatch; returns true if a value is left on the stack for caller to PopTop. */
     pub(super) fn stmt(&mut self) -> bool {
-        // Record ip→source offset before any emit so resolve() can map ip to source.
+        // Record ip->source offset before any emit so resolve() can map ip to source.
         let ip = self.chunk.instructions.len() as u32;
         let pos = self.tokens.peek().map(|t| t.start as u32).unwrap_or(self.last_end as u32);
         self.chunk.stmt_pos.push((ip, pos));

compiler/src/modules/parser/types.rs

@@ -119,9 +119,9 @@ pub struct SSAChunk {
     pub phi_map: Vec<usize>,
     pub nonlocals: Vec<String>,
     pub(super) name_index: HashMap<String, u16>,
-    /* stmt ip→byte_offset map; binary-searched on error path; hot dispatch never touches it. */
+    /* stmt ip->byte_offset map; binary-searched on error path; hot dispatch never touches it. */
     pub stmt_pos: Vec<(u32, u32)>,
-    /* Call ip→byte_offset map; finer than stmt_pos; traceback caret lands under the call. */
+    /* Call ip->byte_offset map; finer than stmt_pos; traceback caret lands under the call. */
     pub call_byte_pos: Vec<(u32, u32)>,
     /* Source text; shared via Arc across sub-chunks. Empty for manually constructed chunks. */
     pub source: alloc::sync::Arc<alloc::string::String>,
@@ -135,7 +135,7 @@ pub struct SSAChunk {
 }
 
 impl SSAChunk {
-    /* Binary-searches stmt_pos to map ip→byte offset; statement-level precision. */
+    /* Binary-searches stmt_pos to map ip->byte offset; statement-level precision. */
     pub fn resolve(&self, ip: u32) -> Option<u32> {
         let i = self.stmt_pos.partition_point(|&(s, _)| s <= ip).checked_sub(1)?;
         Some(self.stmt_pos[i].1)
@@ -304,7 +304,7 @@ fn display_width(s: &str) -> usize {
 }
 
 impl Diagnostic {
-    /* Byte offset → (line, col), 1-indexed; col counts display cells for wide-char alignment. */
+    /* Byte offset -> (line, col), 1-indexed; col counts display cells for wide-char alignment. */
     fn line_col(src: &str, byte: usize) -> (usize, usize) {
         let byte = byte.min(src.len());
         let line = src[..byte].matches('\n').count() + 1;