hecks 3.14.0 → 4.0.0

data/rust/codegen/src/exemplar.rs

@@ -52,25 +52,34 @@ fn scan_leftover_placeholders(text: &str) -> Vec<String> {
 
 impl Exemplar {
     pub fn load() -> Self {
-        Self::load_from(default_dir())
+        Self::load_from(&default_dir())
     }
 
-    pub fn load_from(dir: PathBuf) -> Self {
+    #[allow(
+        clippy::panic,
+        reason = "a drifted exemplar or invalid IR aborts generation on purpose"
+    )]
+    pub fn load_from(dir: &std::path::Path) -> Self {
         let mut shapes = HashMap::new();
-        let mut paths: Vec<_> = std::fs::read_dir(&dir)
+        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())
+            .filter_map(std::result::Result::ok)
             .map(|entry| entry.path())
-            .filter(|p| p.extension().map(|ext| ext == "rs").unwrap_or(false))
+            .filter(|p| p.extension().is_some_and(|ext| ext == "rs"))
             .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()));
+            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 }
     }
 
+    #[allow(
+        clippy::panic,
+        reason = "a drifted exemplar or invalid IR aborts generation on purpose"
+    )]
     pub fn raw(&self, shape_id: &str) -> &str {
         self.shapes
             .get(shape_id)
@@ -85,13 +94,31 @@ impl Exemplar {
         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)
+    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 {
+    #[allow(
+        clippy::panic,
+        reason = "a drifted exemplar or invalid IR aborts generation on purpose"
+    )]
+    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 {
@@ -103,10 +130,21 @@ impl Exemplar {
             });
             let reindented: String = content
                 .lines()
-                .map(|l| if l.trim().is_empty() { l.to_string() } else { format!("{indent}{l}") })
+                .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..]);
+            outer_text = format!(
+                "{}{}{}",
+                &outer_text[..line_start],
+                reindented,
+                &outer_text[line_end..]
+            );
         }
 
         render_subs(outer_id, "assemble", &mut outer_text, outer_subs);
@@ -114,7 +152,14 @@ impl Exemplar {
     }
 
     /// 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 {
+    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)])
     }
@@ -127,16 +172,12 @@ fn render_subs(shape_id: &str, caller: &str, text: &mut String, subs: &[(&str, S
     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");
-        }
+        assert!(text.contains(marker), "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");
-    }
+    assert!(leftover.is_empty(), "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)`.
@@ -191,29 +232,40 @@ fn dedent(lines: &[String]) -> String {
         .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("");
+        .map(|l| {
+            if l.is_empty() {
+                l.clone()
+            } else {
+                l.chars().skip(margin).collect::<String>()
+            }
+        })
+        .collect::<String>();
     joined.trim_end().to_string()
 }
 
+#[allow(
+    clippy::unwrap_used,
+    reason = "the value was checked just before; None would mean invalid IR"
+)]
 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();
+            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<_>>()
-                );
-            }
+            assert!(
+                !(stack.is_empty() || top != Some(id)),
+                "{}: 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);
@@ -224,7 +276,10 @@ fn parse_file(path: &std::path::Path, text: &str, result: &mut HashMap<String, S
             lines.push(line.to_string());
         }
     }
-    if !stack.is_empty() {
-        panic!("{}: unclosed TMPL region(s): {:?}", path.display(), stack.iter().map(|(i, _, _)| i.clone()).collect::<Vec<_>>());
-    }
+    assert!(
+        stack.is_empty(),
+        "{}: unclosed TMPL region(s): {:?}",
+        path.display(),
+        stack.iter().map(|(i, _, _)| i.clone()).collect::<Vec<_>>()
+    );
 }

data/rust/codegen/src/expr_emitter.rs

@@ -4,11 +4,24 @@
 use crate::json::Json;
 use crate::naming::ruby_inspect_string;
 
+#[allow(
+    clippy::panic,
+    reason = "a drifted exemplar or invalid IR aborts generation on purpose"
+)]
 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 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:?}")));
+    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")),
@@ -64,23 +77,54 @@ pub fn emit_ast(node: &Json) -> String {
 }
 
 // Fully qualified because the self-hosted grammar declares its own `Comparison` type.
+#[allow(
+    clippy::panic,
+    reason = "a drifted exemplar or invalid IR aborts generation on purpose"
+)]
 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"))
+    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")
+    )
 }
 
+#[allow(
+    clippy::panic,
+    reason = "a drifted exemplar or invalid IR aborts generation on purpose"
+)]
 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:?}"))
+    node.get(key)
+        .unwrap_or_else(|| panic!("{op} node has no {key:?} field: {node:?}"))
 }
 
+#[allow(
+    clippy::panic,
+    reason = "a drifted exemplar or invalid IR aborts generation on purpose"
+)]
 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:?}")))
+        .map(|segment| {
+            segment.as_str().map_or_else(
+                || panic!("{op}'s path has a non-string segment: {node:?}"),
+                str::to_string,
+            )
+        })
         .collect()
 }
 
+#[allow(
+    clippy::panic,
+    reason = "a drifted exemplar or invalid IR aborts generation on purpose"
+)]
 fn strip_side(node: &Json, op: &str) -> &'static str {
     match field(node, op, "side").as_str() {
         Some("both") => "Both",
@@ -90,6 +134,10 @@ fn strip_side(node: &Json, op: &str) -> &'static str {
     }
 }
 
+#[allow(
+    clippy::panic,
+    reason = "a drifted exemplar or invalid IR aborts generation on purpose"
+)]
 fn block_mode(node: &Json, op: &str) -> &'static str {
     match field(node, op, "mode").as_str() {
         Some("all") => "All",

data/rust/codegen/src/fielded.rs

@@ -6,13 +6,22 @@ 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,
-    }
+    value_objects_by_name
+        .get(attr_type)
+        .is_some_and(|vo| naming::fielded_capable_nested(vo))
 }
 
-pub fn emit_fielded_flat(exemplar: &Exemplar, struct_name: &str, attributes: &[Json], value_objects_by_name: &HashMap<String, &Json>, extra_arms: &[String]) -> String {
+#[allow(
+    clippy::unwrap_used,
+    reason = "the value was checked just before; None would mean invalid IR"
+)]
+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 {
@@ -23,28 +32,67 @@ pub fn emit_fielded_flat(exemplar: &Exemplar, struct_name: &str, attributes: &[J
         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)]))
+            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, &naming::deref_scalar(scalar, "v")).unwrap())],
+                "fielded_arm_list",
+                &[
+                    ("\"tmpl_field\"", naming::ruby_inspect_string(&key)),
+                    ("tmpl_ident", ident),
+                ],
             ))
+        } else if let (true, Some(scalar)) = (optional, 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, &naming::deref_scalar(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)]))
+                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())],
+                &[
+                    ("\"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)]))
+            Some(exemplar.render(
+                "fielded_arm_nested",
+                &[
+                    ("\"tmpl_field\"", naming::ruby_inspect_string(&key)),
+                    ("tmpl_ident", ident),
+                ],
+            ))
         } else {
             None
         };
@@ -69,19 +117,50 @@ pub fn emit_fielded_flat(exemplar: &Exemplar, struct_name: &str, attributes: &[J
             "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_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() }),
+                (
+                    "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 {
+#[allow(
+    clippy::unwrap_used,
+    reason = "the value was checked just before; None would mean invalid IR"
+)]
+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 attributes = aggregate.get("attributes").map_or_default(Json::each);
     let mut arms: Vec<String> = Vec::new();
 
     for attr in attributes {
@@ -90,17 +169,47 @@ pub fn emit_fielded_record(exemplar: &Exemplar, aggregate: &Json, value_objects_
         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)]))
+        let arm = if list
+            && crate::shared::list_attr_creation_optional(aggregate, crate::attr::name(attr))
+        {
+            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, &naming::deref_scalar(scalar, "v")).unwrap())],
+                "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, &naming::deref_scalar(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)]))
+            Some(exemplar.render(
+                "fielded_arm_optional_nested",
+                &[
+                    ("\"tmpl_field\"", naming::ruby_inspect_string(&key)),
+                    ("tmpl_ident", ident),
+                ],
+            ))
         } else {
             None
         };
@@ -114,25 +223,40 @@ pub fn emit_fielded_record(exemplar: &Exemplar, aggregate: &Json, value_objects_
         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)]));
+        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)]));
+        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(&[])
+        .map_or_default(Json::each)
         .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)
-    });
+    let items = items_arms(
+        exemplar,
+        attributes,
+        value_objects_by_name,
+        &entity_names,
+        |attr| crate::shared::list_attr_creation_optional(aggregate, crate::attr::name(attr)),
+    );
 
     format!(
         "{}\n",
@@ -140,8 +264,14 @@ pub fn emit_fielded_record(exemplar: &Exemplar, aggregate: &Json, value_objects_
             "fielded_record",
             &[
                 ("TmplRecordType", name),
-                ("\"tmpl_arms_placeholder\" => tmpl_arms_block(),", arms.join("\n")),
-                ("\"tmpl_items_placeholder\" => tmpl_items_block(),", items.join("\n")),
+                (
+                    "\"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)),
             ],
         )
@@ -167,7 +297,17 @@ fn as_scalar_expr(attributes: &[Json]) -> 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> {
+#[allow(
+    clippy::unwrap_used,
+    reason = "the value was checked just before; None would mean invalid IR"
+)]
+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) {
@@ -177,14 +317,26 @@ fn items_arms(exemplar: &Exemplar, attributes: &[Json], value_objects_by_name: &
         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);
+        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)];
+        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, &naming::deref_scalar(scalar, "v")).unwrap()));
+            subs.push((
+                "tmpl_value_expr_placeholder(v)",
+                naming::scalar_to_value(scalar, &naming::deref_scalar(scalar, "v")).unwrap(),
+            ));
         }
         arms.push(format!("            {}", exemplar.render(&shape, &subs)));
     }