refactor(parser): centralize SSA name parsing in SsaName helper

dylan-sutton-chavez · dylan-sutton-chavez · commit 5e83a3500cb5 · 2026-05-10T12:59:00.000-06:00
diff --git a/compiler/src/modules/parser/types.rs b/compiler/src/modules/parser/types.rs
@@ -190,13 +190,13 @@ impl SSAChunk {
         // prev_slots[i]: slot of name i at version-1, if any.
         let mut ps: Vec<Option<u16>> = vec![None; n];
         for (i, name) in self.names.iter().enumerate() {
-            if let Some(pos) = name.rfind('_')
-                && let Ok(ver) = name[pos+1..].parse::<u32>()
-                && ver > 0 {
-                    let prev = s!(str &name[..pos], "_", int ver - 1);
-                    if let Some(&j) = self.name_index.get(&prev) {
-                        ps[i] = Some(j);
-                    }
+            if let Some(parsed) = SsaName::parse(name)
+                && parsed.version > 0
+            {
+                let prev = s!(str parsed.bare, "_", int parsed.version as i64 - 1);
+                if let Some(&j) = self.name_index.get(&prev) {
+                    ps[i] = Some(j);
+                }
             }
         }
 
@@ -255,16 +255,40 @@ pub(crate) struct JoinNode {
     pub(super) then: Option<HashMap<String, u32>>,
 }
 
+/* Parsed view of a `<bare>_<digits>` SSA-suffixed name. Returned by
+   `SsaName::parse` and used everywhere callers need the bare prefix
+   and/or the numeric version, instead of re-doing the rfind('_') +
+   ascii-digit + parse dance inline. */
+pub struct SsaName<'a> {
+    pub bare: &'a str,
+    pub version: u32,
+}
+
+impl<'a> SsaName<'a> {
+    /* Returns Some(parts) when `name` matches `<bare>_<digits>`; None
+       for synthetic temps (`#cmp`, `#match`) and any non-SSA name. */
+    pub fn parse(name: &'a str) -> Option<Self> {
+        let pos = name.rfind('_')?;
+        if pos + 1 >= name.len() { return None; }
+        let suffix = &name[pos + 1..];
+        if !suffix.bytes().all(|b| b.is_ascii_digit()) { return None; }
+        let version = suffix.parse().ok()?;
+        Some(Self { bare: &name[..pos], version })
+    }
+
+    /* Convenience for callers that want a (bare, version) pair for
+       every name, falling back to (name, 0) when no SSA suffix is
+       present. */
+    pub fn parse_or_bare(name: &'a str) -> (&'a str, u32) {
+        Self::parse(name)
+            .map(|s| (s.bare, s.version))
+            .unwrap_or((name, 0))
+    }
+}
+
 /* Strips `_<digits>` SSA suffix for user-facing diagnostics; returns input unchanged if absent. */
 pub fn ssa_strip(name: &str) -> &str {
-    if let Some(pos) = name.rfind('_')
-        && pos + 1 < name.len()
-        && name[pos + 1..].bytes().all(|b| b.is_ascii_digit())
-    {
-        &name[..pos]
-    } else {
-        name
-    }
+    SsaName::parse(name).map(|s| s.bare).unwrap_or(name)
 }
 
 /* Diagnostic with byte offsets; line/col computed at render time (UTF-8 safe). */
diff --git a/compiler/src/modules/vm/builtins/attr.rs b/compiler/src/modules/vm/builtins/attr.rs
@@ -153,11 +153,7 @@ impl<'a> VM<'a> {
                 Some(v) if !v.is_undef() => *v,
                 _ => continue,
             };
-            let bare = match name.rfind('_') {
-                Some(p) if name[p + 1..].chars().all(|c| c.is_ascii_digit()) =>
-                    name[..p].to_string(),
-                _ => name.clone(),
-            };
+            let bare = crate::modules::parser::ssa_strip(name).to_string();
             // User assignment overrides the builtin entry of the same name.
             out.insert(bare, v);
         }
@@ -191,11 +187,8 @@ impl<'a> VM<'a> {
             // scratch — never user-visible.
             if name.starts_with('#') { continue; }
             // Strip SSA version suffix.
-            let (bare, ver) = match name.rfind('_') {
-                Some(p) if name[p + 1..].chars().all(|c| c.is_ascii_digit()) =>
-                    (&name[..p], name[p + 1..].parse::<i64>().unwrap_or(0)),
-                _ => (name.as_str(), 0),
-            };
+            let (bare, ver) = crate::modules::parser::SsaName::parse_or_bare(name);
+            let ver = ver as i64;
             // Skip unmodified builtins: if the global registration for this
             // name points at the *same* Val we'd return, the user never
             // rebound it locally — exclude from locals().
diff --git a/compiler/src/modules/vm/init.rs b/compiler/src/modules/vm/init.rs
@@ -82,13 +82,12 @@ impl<'a> VM<'a> {
         // re-parsing each name on every miss.
         let mut name_versions: super::NameVersionIndex = crate::util::fx::FxHashMap::default();
         for (si, sname) in chunk.names.iter().enumerate() {
-            if let Some(p) = sname.rfind('_')
-                && let Ok(v) = sname[p+1..].parse::<i64>() {
-                    name_versions
-                        .entry(sname[..p].to_string())
-                        .or_default()
-                        .push((v, si));
-                }
+            if let Some(parsed) = crate::modules::parser::SsaName::parse(sname) {
+                name_versions
+                    .entry(parsed.bare.to_string())
+                    .or_default()
+                    .push((parsed.version as i64, si));
+            }
         }
         self.chunk_name_versions.insert(chunk as *const _, name_versions);
         for class_body in chunk.classes.iter() {
diff --git a/compiler/src/modules/vm/mod.rs b/compiler/src/modules/vm/mod.rs
@@ -237,7 +237,7 @@ impl<'a> VM<'a> {
                 // we explicitly require the suffix-bearing form here, not
                 // ssa_strip's "fall through to bare on missing suffix" shape.
                 let canon = body.names.iter().enumerate()
-                    .find(|(_, n)| n.rfind('_').map(|p| &n[..p]) == Some(base.as_str()))
+                    .find(|(_, n)| crate::modules::parser::SsaName::parse(n).map(|s| s.bare) == Some(base.as_str()))
                     .map(|(i, _)| body.alias_groups.get(i).and_then(|g| g.first().copied()).unwrap_or(i as u16) as usize)?;
                 Some((canon, canon))
             }).collect()
@@ -284,9 +284,8 @@ impl<'a> VM<'a> {
                 if canon != slot { return None; }
                 if param_bm.get(slot).copied().unwrap_or(false) { return None; }
                 if written.contains(&slot) { return None; }
-                let p = name.rfind('_')?;
-                name[p+1..].parse::<u32>().ok()?;
-                Some((name[..p].to_string(), slot))
+                let parsed = crate::modules::parser::SsaName::parse(name)?;
+                Some((parsed.bare.to_string(), slot))
             }).collect()
         }).collect();
 
