hecks 2.8.0 → 3.0.0

data/rust/codegen/src/exemplar.rs

@@ -0,0 +1,230 @@
+//! Port of `rust/project/exemplar.rb`: loads the template shapes in `rust/src/exemplar/*.rs`.
+//! Both codegens read those files at runtime, so the shapes cannot drift.
+use std::collections::HashMap;
+use std::path::PathBuf;
+
+pub struct Exemplar {
+    shapes: HashMap<String, String>,
+}
+
+// True for any placeholder word the template vocabulary can produce.
+fn is_leftover_placeholder(word: &str) -> bool {
+    (word.starts_with("Tmpl") && word.len() > 4)
+        || (word.starts_with("tmpl_") && word.len() > 5)
+        || (word.starts_with("TMPL_") && word.len() > 5)
+}
+
+// Finds `Tmpl*`, `tmpl_*` and `TMPL_*` words; hand-rolled because this crate has no regex
+// dependency.
+fn scan_leftover_placeholders(text: &str) -> Vec<String> {
+    // Skip non-char-boundary positions: generated text contains multi-byte UTF-8 (an em dash),
+    // and slicing `&text[i..]` inside a character panics.
+    let mut found = Vec::new();
+    let bytes = text.as_bytes();
+    let is_word_byte = |b: u8| b.is_ascii_alphanumeric() || b == b'_';
+    let mut i = 0;
+    while i < bytes.len() {
+        if !text.is_char_boundary(i) {
+            i += 1;
+            continue;
+        }
+        let at_boundary = i == 0 || !is_word_byte(bytes[i - 1]);
+        if at_boundary {
+            let rest = &text[i..];
+            if rest.starts_with("Tmpl") || rest.starts_with("tmpl_") || rest.starts_with("TMPL_") {
+                let start = i;
+                let mut j = i;
+                while j < bytes.len() && is_word_byte(bytes[j]) {
+                    j += 1;
+                }
+                let word = &text[start..j];
+                if is_leftover_placeholder(word) && !found.iter().any(|w| w == word) {
+                    found.push(word.to_string());
+                }
+                i = j;
+                continue;
+            }
+        }
+        i += 1;
+    }
+    found
+}
+
+impl Exemplar {
+    pub fn load() -> Self {
+        Self::load_from(default_dir())
+    }
+
+    pub fn load_from(dir: PathBuf) -> Self {
+        let mut shapes = HashMap::new();
+        let mut paths: Vec<_> = std::fs::read_dir(&dir)
+            .unwrap_or_else(|e| panic!("Exemplar: cannot read {}: {e}", dir.display()))
+            .filter_map(|entry| entry.ok())
+            .map(|entry| entry.path())
+            .filter(|p| p.extension().map(|ext| ext == "rs").unwrap_or(false))
+            .collect();
+        paths.sort();
+        for path in paths {
+            let text = std::fs::read_to_string(&path).unwrap_or_else(|e| panic!("Exemplar: cannot read {}: {e}", path.display()));
+            parse_file(&path, &text, &mut shapes);
+        }
+        Self { shapes }
+    }
+
+    pub fn raw(&self, shape_id: &str) -> &str {
+        self.shapes
+            .get(shape_id)
+            .unwrap_or_else(|| panic!("Exemplar: no shape {shape_id:?} — checked rust/src/exemplar/*.rs for `// TMPL:{shape_id} BEGIN`"))
+    }
+
+    /// Substitutes `subs` into one shape, longest marker first; panics on a missing marker
+    /// or a leftover placeholder.
+    pub fn render(&self, shape_id: &str, subs: &[(&str, String)]) -> String {
+        let mut text = self.raw(shape_id).to_string();
+        render_subs(shape_id, "render", &mut text, subs);
+        text
+    }
+
+    pub fn render_each(&self, shape_id: &str, subs_list: &[Vec<(&str, String)>], join_with: &str) -> String {
+        subs_list.iter().map(|subs| self.render(shape_id, subs)).collect::<Vec<_>>().join(join_with)
+    }
+
+    /// Fills nested slots (reindented to the slot's position) before the outer substitutions,
+    /// so an outer marker cannot match text from a rendered slot.
+    pub fn assemble(&self, outer_id: &str, outer_subs: &[(&str, String)], slots: &[(&str, String)]) -> String {
+        let mut outer_text = self.raw(outer_id).to_string();
+
+        for (field_id, content) in slots {
+            let slot = format!("<<TMPL_SLOT:{field_id}>>");
+            let (line_start, line_end, indent) = find_slot_line(&outer_text, &slot).unwrap_or_else(|| {
+                panic!(
+                    "Exemplar.assemble({outer_id:?}): no nested slot for {field_id:?} — expected a `// TMPL:{field_id} BEGIN/END` region nested inside `// TMPL:{outer_id} BEGIN/END`"
+                )
+            });
+            let reindented: String = content
+                .lines()
+                .map(|l| if l.trim().is_empty() { l.to_string() } else { format!("{indent}{l}") })
+                .collect::<Vec<_>>()
+                .join("\n");
+            outer_text = format!("{}{}{}", &outer_text[..line_start], reindented, &outer_text[line_end..]);
+        }
+
+        render_subs(outer_id, "assemble", &mut outer_text, outer_subs);
+        outer_text
+    }
+
+    /// Renders `field_id` once per entry of `field_subs_list` and assembles it into `outer_id`.
+    pub fn compose(&self, outer_id: &str, outer_subs: &[(&str, String)], field_id: &str, field_subs_list: &[Vec<(&str, String)>], join_with: &str) -> String {
+        let content = self.render_each(field_id, field_subs_list, join_with);
+        self.assemble(outer_id, outer_subs, &[(field_id, content)])
+    }
+}
+
+// Longest-marker-first substitution, then the leftover-placeholder scan; shared by
+// `render` and `assemble`.
+fn render_subs(shape_id: &str, caller: &str, text: &mut String, subs: &[(&str, String)]) {
+    let mut ordered: Vec<&(&str, String)> = subs.iter().collect();
+    ordered.sort_by_key(|(marker, _)| std::cmp::Reverse(marker.len()));
+
+    for (marker, value) in ordered {
+        if !text.contains(marker) {
+            panic!("Exemplar.{caller}({shape_id:?}): marker {marker:?} not found in shape text — exemplar and caller have drifted");
+        }
+        *text = text.replace(marker, value);
+    }
+
+    let leftover = scan_leftover_placeholders(text);
+    if !leftover.is_empty() {
+        panic!("Exemplar.{caller}({shape_id:?}): unrendered placeholder(s) {leftover:?} — subs is missing a marker this shape actually contains");
+    }
+}
+
+// Finds the line holding only `slot` after indentation; returns `(byte_start, byte_end, indent)`.
+fn find_slot_line(text: &str, slot: &str) -> Option<(usize, usize, String)> {
+    let mut offset = 0usize;
+    for line in text.split_inclusive('\n') {
+        let trimmed_end = line.trim_end_matches('\n').trim_end_matches('\r');
+        if let Some(rest) = trimmed_end.strip_suffix(slot) {
+            if rest.chars().all(|c| c == ' ' || c == '\t') {
+                let line_len = trimmed_end.len();
+                return Some((offset, offset + line_len, rest.to_string()));
+            }
+        }
+        offset += line.len();
+    }
+    None
+}
+
+fn default_dir() -> PathBuf {
+    PathBuf::from(concat!(env!("CARGO_MANIFEST_DIR"), "/../src/exemplar"))
+}
+
+fn begin_marker(line: &str) -> Option<&str> {
+    marker_id(line, "BEGIN")
+}
+
+fn end_marker(line: &str) -> Option<&str> {
+    marker_id(line, "END")
+}
+
+// Returns the id from a `TMPL:<id> <kind>` line comment.
+fn marker_id<'a>(line: &'a str, kind: &str) -> Option<&'a str> {
+    let idx = line.find("//")?;
+    let mut rest = line[idx + 2..].trim_start();
+    rest = rest.strip_prefix("TMPL:")?;
+    let sp = rest.find(char::is_whitespace)?;
+    let (id, tail) = rest.split_at(sp);
+    if tail.trim() == kind {
+        Some(id)
+    } else {
+        None
+    }
+}
+
+// Drops the leading whitespace every non-blank line shares, like Ruby's `<<~`.
+fn dedent(lines: &[String]) -> String {
+    let margin = lines
+        .iter()
+        .filter(|l| !l.trim().is_empty())
+        .map(|l| l.len() - l.trim_start_matches([' ', '\t']).len())
+        .min()
+        .unwrap_or(0);
+    let joined: String = lines
+        .iter()
+        .map(|l| if l.is_empty() { l.clone() } else { l.chars().skip(margin).collect::<String>() })
+        .collect::<Vec<_>>()
+        .join("");
+    joined.trim_end().to_string()
+}
+
+fn parse_file(path: &std::path::Path, text: &str, result: &mut HashMap<String, String>) {
+    // Each frame is (id, lines, begin_indent).
+    let mut stack: Vec<(String, Vec<String>, String)> = Vec::new();
+    for raw_line in text.split_inclusive('\n') {
+        let line = raw_line;
+        if let Some(id) = begin_marker(line) {
+            let indent: String = line.chars().take_while(|c| *c == ' ' || *c == '\t').collect();
+            stack.push((id.to_string(), Vec::new(), indent));
+        } else if let Some(id) = end_marker(line) {
+            let top = stack.last().map(|(top_id, _, _)| top_id.as_str());
+            if stack.is_empty() || top != Some(id) {
+                panic!(
+                    "{}: TMPL:{id} END with no matching BEGIN (stack: {:?})",
+                    path.display(),
+                    stack.iter().map(|(i, _, _)| i.clone()).collect::<Vec<_>>()
+                );
+            }
+            let (id, lines, begin_indent) = stack.pop().unwrap();
+            let dedented = dedent(&lines);
+            result.insert(id.clone(), dedented);
+            if let Some((_, parent_lines, _)) = stack.last_mut() {
+                parent_lines.push(format!("{begin_indent}<<TMPL_SLOT:{id}>>\n"));
+            }
+        } else if let Some((_, lines, _)) = stack.last_mut() {
+            lines.push(line.to_string());
+        }
+    }
+    if !stack.is_empty() {
+        panic!("{}: unclosed TMPL region(s): {:?}", path.display(), stack.iter().map(|(i, _, _)| i.clone()).collect::<Vec<_>>());
+    }
+}

data/rust/codegen/src/expr_emitter.rs

@@ -0,0 +1,87 @@
+//! Port of `rust/project/expr_emitter.rb`: turns each IR rule's `ast` tree into `Expr` source.
+//! A literal-array `include?` never reaches here; `AstJson` rewrites it to an or of equalities.
+
+use crate::json::Json;
+use crate::naming::ruby_inspect_string;
+
+pub fn emit_ast(node: &Json) -> String {
+    let op = node.get("op").and_then(Json::as_str).unwrap_or_else(|| panic!("ast node has no string \"op\": {node:?}"));
+    let sub = |key: &str| emit_ast(field(node, op, key));
+    let boxed = |key: &str| format!("Box::new({})", sub(key));
+    let text = |key: &str| ruby_inspect_string(field(node, op, key).as_str().unwrap_or_else(|| panic!("{op}'s {key:?} isn't a string: {node:?}")));
+
+    match op {
+        "or" => format!("Expr::Or({}, {})", boxed("left"), boxed("right")),
+        "and" => format!("Expr::And({}, {})", boxed("left"), boxed("right")),
+        "not" => format!("Expr::Not({})", boxed("expr")),
+        "compare" => format!("Expr::Compare {{ op: {}, left: {}, right: {} }}", emit_comparison(field(node, op, "cmp")), boxed("left"), boxed("right")),
+        "include" => format!("Expr::Include {{ haystack: {}, needle: {} }}", boxed("haystack"), boxed("needle")),
+        "int" => format!("Expr::Int({})", field(node, op, "value").to_s()),
+        "float" => format!("Expr::Float({}f64)", field(node, op, "value").to_s()),
+        "str" => format!("Expr::Str({}.to_string())", text("value")),
+        "bool" => format!("Expr::Bool({})", field(node, op, "value").to_s()),
+        "nil" => "Expr::Nil".to_string(),
+        "lookup" => format!("Expr::Lookup({})", ruby_inspect_string(&path_of(node, op).join("."))),
+        "add" => format!("Expr::Add({}, {})", boxed("left"), boxed("right")),
+        "sign_test" => format!("Expr::SignTest {{ op: {}, receiver: {} }}", emit_comparison(field(node, op, "cmp")), boxed("receiver")),
+        "empty" => format!("Expr::Empty({})", boxed("receiver")),
+        "to_s" => format!("Expr::ToS({})", boxed("receiver")),
+        "modulo" => format!("Expr::Modulo {{ receiver: {}, divisor: {} }}", boxed("receiver"), boxed("divisor")),
+        "size" => format!("Expr::Size({})", boxed("receiver")),
+        "block_predicate" => format!(
+            "Expr::BlockPredicate {{ mode: crate::kernel::BlockMode::{}, receiver: {}, param: {}, predicate: {} }}",
+            block_mode(node, op),
+            boxed("receiver"),
+            text("param"),
+            boxed("predicate")
+        ),
+        "find" => format!(
+            "Expr::Find {{ receiver: {}, param: {}, predicate: {}, path: &[{}] }}",
+            boxed("receiver"),
+            text("param"),
+            boxed("predicate"),
+            path_of(node, op).iter().map(|segment| ruby_inspect_string(segment)).collect::<Vec<_>>().join(", ")
+        ),
+        "array" => format!(
+            "Expr::Array(vec![{}])",
+            field(node, op, "elements").each().iter().map(emit_ast).collect::<Vec<_>>().join(", ")
+        ),
+        "matches_regex" => format!("Expr::MatchesRegex {{ receiver: {}, pattern: {}.to_string(), flags: {}.to_string() }}", boxed("receiver"), text("pattern"), text("flags")),
+        "presence" => format!("Expr::Presence {{ receiver: {}, negated: {} }}", boxed("receiver"), field(node, op, "negated").to_s()),
+        "assignment" => format!("Expr::Assignment {{ receiver: {}, negated: {} }}", boxed("receiver"), field(node, op, "negated").to_s()),
+        "split" => format!("Expr::Split {{ receiver: {}, separator: {}.to_string() }}", boxed("receiver"), text("separator")),
+        "starts_with" => format!("Expr::StartsWith {{ receiver: {}, substring: {}.to_string() }}", boxed("receiver"), text("substring")),
+        "ends_with" => format!("Expr::EndsWith {{ receiver: {}, substring: {}.to_string() }}", boxed("receiver"), text("substring")),
+        "first" => format!("Expr::First({})", boxed("receiver")),
+        "last" => format!("Expr::Last({})", boxed("receiver")),
+        // Every op in `AstJson::OPS` has an arm above; reaching here is a hard failure.
+        other => panic!("unhandled ast op {other:?} — no Rust rendering exists for it in this generator (rust/codegen/src/expr_emitter.rs#emit_ast)"),
+    }
+}
+
+// Fully qualified because the self-hosted grammar declares its own `Comparison` type.
+pub fn emit_comparison(cmp: &Json) -> String {
+    let flag = |key: &str| cmp.get(key).unwrap_or_else(|| panic!("cmp has no {key:?}: {cmp:?}")).to_s();
+    format!("crate::kernel::Comparison {{ less_than: {}, equal: {}, negated: {} }}", flag("less_than"), flag("equal"), flag("negated"))
+}
+
+fn field<'a>(node: &'a Json, op: &str, key: &str) -> &'a Json {
+    node.get(key).unwrap_or_else(|| panic!("{op} node has no {key:?} field: {node:?}"))
+}
+
+fn path_of(node: &Json, op: &str) -> Vec<String> {
+    field(node, op, "path")
+        .each()
+        .iter()
+        .map(|segment| segment.as_str().map(str::to_string).unwrap_or_else(|| panic!("{op}'s path has a non-string segment: {node:?}")))
+        .collect()
+}
+
+fn block_mode(node: &Json, op: &str) -> &'static str {
+    match field(node, op, "mode").as_str() {
+        Some("all") => "All",
+        Some("any") => "Any",
+        Some("none") => "None",
+        other => panic!("block_predicate's mode {other:?} is none of all/any/none: {node:?}"),
+    }
+}

data/rust/codegen/src/fielded.rs

@@ -0,0 +1,192 @@
+//! Port of `rust/project/fielded.rb`: emits the `Fielded` impls for structs and records.
+
+use crate::exemplar::Exemplar;
+use crate::json::Json;
+use crate::naming;
+use std::collections::HashMap;
+
+fn is_fielded_nested(attr_type: &str, value_objects_by_name: &HashMap<String, &Json>) -> bool {
+    match value_objects_by_name.get(attr_type) {
+        Some(vo) => naming::fielded_capable_nested(vo),
+        None => false,
+    }
+}
+
+pub fn emit_fielded_flat(exemplar: &Exemplar, struct_name: &str, attributes: &[Json], value_objects_by_name: &HashMap<String, &Json>, extra_arms: &[String]) -> String {
+    let mut arms: Vec<String> = Vec::new();
+
+    for attr in attributes {
+        let key = naming::rust_field(crate::attr::name(attr));
+        let ident = naming::rust_ident_field(crate::attr::name(attr));
+        let scalar = naming::effective_scalar_type(crate::attr::type_name(attr));
+        let list = crate::attr::list(attr);
+        let optional = crate::attr::optional(attr);
+
+        let arm = if list && optional {
+            Some(exemplar.render("fielded_arm_list_optional", &[("\"tmpl_field\"", naming::ruby_inspect_string(&key)), ("tmpl_ident", ident)]))
+        } else if list {
+            Some(exemplar.render("fielded_arm_list", &[("\"tmpl_field\"", naming::ruby_inspect_string(&key)), ("tmpl_ident", ident)]))
+        } else if optional && scalar.is_some() {
+            let scalar = scalar.unwrap();
+            Some(exemplar.render(
+                "fielded_arm_optional_scalar",
+                &[("\"tmpl_field\"", naming::ruby_inspect_string(&key)), ("tmpl_ident", ident.clone()), ("tmpl_value_expr_placeholder(v)", naming::scalar_to_value(scalar, "v").unwrap())],
+            ))
+        } else if optional {
+            if is_fielded_nested(crate::attr::type_name(attr), value_objects_by_name) {
+                Some(exemplar.render("fielded_arm_optional_nested", &[("\"tmpl_field\"", naming::ruby_inspect_string(&key)), ("tmpl_ident", ident)]))
+            } else {
+                None
+            }
+        } else if let Some(scalar) = scalar {
+            Some(exemplar.render(
+                "fielded_arm_scalar",
+                &[("\"tmpl_field\"", naming::ruby_inspect_string(&key)), ("tmpl_value_expr_placeholder(&self.tmpl_ident)", naming::scalar_to_value(scalar, &format!("self.{ident}")).unwrap())],
+            ))
+        } else if is_fielded_nested(crate::attr::type_name(attr), value_objects_by_name) {
+            Some(exemplar.render("fielded_arm_nested", &[("\"tmpl_field\"", naming::ruby_inspect_string(&key)), ("tmpl_ident", ident)]))
+        } else {
+            None
+        };
+
+        if let Some(a) = arm {
+            arms.push(a);
+        }
+    }
+
+    let mut arms: Vec<String> = arms.iter().map(|a| format!("            {a}")).collect();
+    arms.extend(extra_arms.iter().cloned());
+    // Scan the assembled arm list (including `extra_arms`) rather than tracking per branch:
+    // a plain scalar arm also emits `Value::...`.
+    let uses_value = arms.iter().any(|a| a.contains("Value"));
+    // A struct with no fielded-capable attributes never constructs `Field::...`, so the
+    // import would be unused.
+    let uses_field = arms.iter().any(|a| a.contains("Field"));
+
+    format!(
+        "{}\n",
+        exemplar.render(
+            "fielded_flat",
+            &[
+                ("TmplFlatType", struct_name.to_string()),
+                ("\"tmpl_arms_placeholder\" => tmpl_arms_block(),", arms.join("\n")),
+                ("\"tmpl_items_placeholder\" => tmpl_items_block(),", items_arms(exemplar, attributes, value_objects_by_name, &[], |attr| crate::attr::optional(attr)).join("\n")),
+                ("tmpl_as_scalar_placeholder()", as_scalar_expr(attributes)),
+                ("use crate::kernel::Field;", if uses_field { "use crate::kernel::Field;".to_string() } else { String::new() }),
+                ("use crate::kernel::Value;", if uses_value { "use crate::kernel::Value;".to_string() } else { String::new() }),
+            ],
+        )
+    )
+}
+
+pub fn emit_fielded_record(exemplar: &Exemplar, aggregate: &Json, value_objects_by_name: &HashMap<String, &Json>) -> String {
+    let name = naming::rust_ident(aggregate.get("name").and_then(Json::as_str).unwrap_or(""));
+    let attributes = aggregate.get("attributes").map(Json::each).unwrap_or(&[]);
+    let mut arms: Vec<String> = Vec::new();
+
+    for attr in attributes {
+        let key = naming::rust_field(crate::attr::name(attr));
+        let ident = naming::rust_ident_field(crate::attr::name(attr));
+        let scalar = naming::effective_scalar_type(crate::attr::type_name(attr));
+        let list = crate::attr::list(attr);
+
+        let arm = if list && crate::shared::list_attr_creation_optional(aggregate, crate::attr::name(attr), value_objects_by_name) {
+            Some(exemplar.render("fielded_arm_list_optional", &[("\"tmpl_field\"", naming::ruby_inspect_string(&key)), ("tmpl_ident", ident)]))
+        } else if list {
+            Some(exemplar.render("fielded_arm_list", &[("\"tmpl_field\"", naming::ruby_inspect_string(&key)), ("tmpl_ident", ident)]))
+        } else if let Some(scalar) = scalar {
+            Some(exemplar.render(
+                "fielded_arm_optional_scalar",
+                &[("\"tmpl_field\"", naming::ruby_inspect_string(&key)), ("tmpl_ident", ident.clone()), ("tmpl_value_expr_placeholder(v)", naming::scalar_to_value(scalar, "v").unwrap())],
+            ))
+        } else if is_fielded_nested(crate::attr::type_name(attr), value_objects_by_name) {
+            Some(exemplar.render("fielded_arm_optional_nested", &[("\"tmpl_field\"", naming::ruby_inspect_string(&key)), ("tmpl_ident", ident)]))
+        } else {
+            None
+        };
+
+        if let Some(a) = arm {
+            arms.push(a);
+        }
+    }
+
+    if let Some(lifecycle) = aggregate.get("lifecycle") {
+        let field = lifecycle.get("field").and_then(Json::as_str).unwrap_or("");
+        let key = naming::rust_field(field);
+        let ident = naming::rust_ident_field(field);
+        arms.push(exemplar.render("fielded_lifecycle_arm", &[("\"tmpl_field\"", naming::ruby_inspect_string(&key)), ("tmpl_ident", ident)]));
+    }
+    for ev in crate::bridging::correctable_event_names(aggregate) {
+        let ident = crate::bridging::corrects_flag_field(&ev);
+        arms.push(exemplar.render("fielded_corrects_flag_arm", &[("\"tmpl_field\"", naming::ruby_inspect_string(&ident)), ("tmpl_ident", ident)]));
+    }
+
+    let arms: Vec<String> = arms.iter().map(|a| format!("            {a}")).collect();
+
+    let entity_names: Vec<String> = aggregate
+        .get("entities")
+        .map(Json::each)
+        .unwrap_or(&[])
+        .iter()
+        .filter_map(|e| e.get("name").and_then(Json::as_str).map(str::to_string))
+        .collect();
+    let items = items_arms(exemplar, attributes, value_objects_by_name, &entity_names, |attr| {
+        crate::shared::list_attr_creation_optional(aggregate, crate::attr::name(attr), value_objects_by_name)
+    });
+
+    format!(
+        "{}\n",
+        exemplar.render(
+            "fielded_record",
+            &[
+                ("TmplRecordType", name),
+                ("\"tmpl_arms_placeholder\" => tmpl_arms_block(),", arms.join("\n")),
+                ("\"tmpl_items_placeholder\" => tmpl_items_block(),", items.join("\n")),
+                ("tmpl_as_scalar_placeholder()", as_scalar_expr(attributes)),
+            ],
+        )
+    )
+}
+
+// A struct with exactly one scalar attribute reads as that attribute's value, whatever its
+// name. A sole value-object attribute emits a literal `None` rather than a match that
+// could never bind.
+fn as_scalar_expr(attributes: &[Json]) -> String {
+    let sole = attributes.len() == 1
+        && !crate::attr::list(&attributes[0])
+        && naming::effective_scalar_type(crate::attr::type_name(&attributes[0])).is_some();
+    if sole {
+        format!(
+            "match self.field(\"{}\") {{ Some(crate::kernel::Field::Value(v)) => Some(v), _ => None }}",
+            naming::rust_field(crate::attr::name(&attributes[0]))
+        )
+    } else {
+        "None".to_string()
+    }
+}
+
+// One `Fielded::items` arm per list attribute whose element is a scalar, value object or
+// entity; other lists stay length-only.
+fn items_arms(exemplar: &Exemplar, attributes: &[Json], value_objects_by_name: &HashMap<String, &Json>, entity_names: &[String], optional: impl Fn(&Json) -> bool) -> Vec<String> {
+    let mut arms = Vec::new();
+    for attr in attributes {
+        if !crate::attr::list(attr) {
+            continue;
+        }
+        let key = naming::rust_field(crate::attr::name(attr));
+        let ident = naming::rust_ident_field(crate::attr::name(attr));
+        let type_name = crate::attr::type_name(attr);
+        let scalar = naming::effective_scalar_type(type_name);
+        let fielded_element = scalar.is_some() || is_fielded_nested(type_name, value_objects_by_name) || entity_names.iter().any(|e| e == type_name);
+        if !fielded_element {
+            continue;
+        }
+        let shape = format!("fielded_items_arm_list_{}{}", if optional(attr) { "optional_" } else { "" }, if scalar.is_some() { "scalar" } else { "nested" });
+        let mut subs: Vec<(&str, String)> = vec![("\"tmpl_field\"", naming::ruby_inspect_string(&key)), ("tmpl_ident", ident)];
+        if let Some(scalar) = scalar {
+            subs.push(("tmpl_value_expr_placeholder(v)", naming::scalar_to_value(scalar, "v").unwrap()));
+        }
+        arms.push(format!("            {}", exemplar.render(&shape, &subs)));
+    }
+    arms
+}

data/rust/codegen/src/hecks_naming.rs

@@ -0,0 +1,33 @@
+//! Port of the subset of `lib/hecks/naming.rb` that codegen calls:
+//! `snake`, `demodulise` and `reference_key`.
+
+/// `type.to_s.split("::").last.to_s`
+pub fn demodulise(type_name: &str) -> String {
+    type_name.rsplit("::").next().unwrap_or(type_name).to_string()
+}
+
+/// `snake(demodulise(type)).to_sym`
+pub fn reference_key(type_name: &str) -> String {
+    snake(&demodulise(type_name))
+}
+
+/// CamelCase to snake_case, matching Ruby's two-gsub `Naming.snake` in a single pass.
+///
+/// Inserts `_` before an uppercase letter that follows a lowercase letter or digit, or that
+/// ends an acronym (uppercase before, lowercase after).
+pub fn snake(text: &str) -> String {
+    let chars: Vec<char> = text.chars().collect();
+    let mut out = String::new();
+    for (i, &c) in chars.iter().enumerate() {
+        if c.is_ascii_uppercase() && i > 0 {
+            let prev = chars[i - 1];
+            let next = chars.get(i + 1).copied();
+            let insert = (prev.is_ascii_lowercase() || prev.is_ascii_digit()) || (prev.is_ascii_uppercase() && next.map(|n| n.is_ascii_lowercase()).unwrap_or(false));
+            if insert {
+                out.push('_');
+            }
+        }
+        out.push(c);
+    }
+    out.to_lowercase()
+}