hecks 3.14.0 → 5.0.0

data/rust/codegen/src/naming.rs

@@ -19,7 +19,9 @@ pub fn reference_type(type_name: &str) -> bool {
 /// `X` out of `Reference<X>` — `None` for anything that isn't a reference
 /// type at all.
 pub fn reference_target(type_name: &str) -> Option<&str> {
-    type_name.strip_prefix("Reference<").and_then(|rest| rest.strip_suffix('>'))
+    type_name
+        .strip_prefix("Reference<")
+        .and_then(|rest| rest.strip_suffix('>'))
 }
 
 pub fn effective_scalar_type(type_name: &str) -> Option<&'static str> {
@@ -36,12 +38,16 @@ pub fn effective_scalar_type(type_name: &str) -> Option<&'static str> {
     }
 }
 
+#[allow(
+    clippy::unwrap_used,
+    reason = "the value was checked just before; None would mean invalid IR"
+)]
 pub fn rust_type(type_name: &str, list: bool) -> String {
     let scalar = effective_scalar_type(type_name);
-    let inner = match scalar {
-        Some(s) => scalar_rust_type(s).unwrap().to_string(),
-        None => rust_ident(type_name),
-    };
+    let inner = scalar.map_or_else(
+        || rust_ident(type_name),
+        |s| scalar_rust_type(s).unwrap().to_string(),
+    );
     if list {
         format!("Vec<{inner}>")
     } else {
@@ -50,7 +56,7 @@ pub fn rust_type(type_name: &str, list: bool) -> String {
 }
 
 pub fn rust_ident(name: &str) -> String {
-    name.chars().filter(|c| c.is_ascii_alphanumeric()).collect()
+    name.chars().filter(char::is_ascii_alphanumeric).collect()
 }
 
 /// `cmd.gsub(/(?<=.)([A-Z])/, '_\1').downcase` — insert `_` before every
@@ -103,12 +109,18 @@ pub fn legal_aggregate_mod_identifier(name: &str) -> bool {
 /// Mirrors `valid_domain_mod_name?` — shape, and neither a Rust keyword nor
 /// a reserved Cargo.toml key.
 pub fn valid_domain_mod_name(name: &str) -> bool {
-    plain_lower_identifier(name) && !RUST_KEYWORDS.contains(&name) && !CARGO_RESERVED_DOMAIN_NAMES.contains(&name)
+    plain_lower_identifier(name)
+        && !RUST_KEYWORDS.contains(&name)
+        && !CARGO_RESERVED_DOMAIN_NAMES.contains(&name)
 }
 
 /// `None` when every aggregate name and the domain's module name are usable, else the
 /// refusal text the Ruby generator raises, byte for byte. Aggregates are checked first.
-pub fn reserved_name_refusal(source_label: &str, mod_name: &str, aggregate_names: &[&str]) -> Option<String> {
+pub fn reserved_name_refusal(
+    source_label: &str,
+    mod_name: &str,
+    aggregate_names: &[&str],
+) -> Option<String> {
     let refused: Vec<&str> = aggregate_names
         .iter()
         .copied()
@@ -118,7 +130,11 @@ pub fn reserved_name_refusal(source_label: &str, mod_name: &str, aggregate_names
         })
         .collect();
     if let Some(first) = refused.first() {
-        let names = refused.iter().map(|name| format!("{name:?}")).collect::<Vec<_>>().join(", ");
+        let names = refused
+            .iter()
+            .map(|name| format!("{name:?}"))
+            .collect::<Vec<_>>()
+            .join(", ");
         return Some(format!(
             "{source_label}: aggregate name(s) {names} can't be used as-is — downcased, each becomes a bare Rust \
              module identifier (`pub mod {};`) and a generated file name, and at least one is not a plain identifier \
@@ -180,7 +196,11 @@ pub fn unsafe_name_refusal(source_label: &str, ir: &Json) -> Option<String> {
     if refused.is_empty() {
         return None;
     }
-    let list = refused.iter().map(|name| ruby_inspect_string(name)).collect::<Vec<_>>().join(", ");
+    let list = refused
+        .iter()
+        .map(|name| ruby_inspect_string(name))
+        .collect::<Vec<_>>()
+        .join(", ");
     Some(format!(
         "{source_label}: declared name(s) {list} can't be used as-is — each is written into the generated Rust as \
          an identifier, and at least one is not a plain identifier (letters, digits and underscores, not starting \
@@ -194,7 +214,10 @@ pub fn rust_field(name: &str) -> String {
 
 pub fn rust_ident_field(name: &str) -> String {
     let field = rust_field(name);
-    if RUST_KEYWORDS.contains(&field.as_str()) {
+    if matches!(field.as_str(), "crate" | "self" | "Self" | "super") {
+        // Rust refuses these as raw identifiers, so they take a trailing underscore.
+        format!("{field}_")
+    } else if RUST_KEYWORDS.contains(&field.as_str()) {
         format!("r#{field}")
     } else {
         field
@@ -208,45 +231,22 @@ pub fn closed_set_variant(value: &str) -> String {
         .split(|c: char| !c.is_ascii_alphanumeric())
         .filter(|s| !s.is_empty())
         .map(capitalize)
-        .collect::<Vec<_>>()
-        .join("");
+        .collect::<String>();
     if variant != "Self" {
         return variant;
     }
-    if value.starts_with('S') { "SelfType".to_string() } else { "SelfValue".to_string() }
+    if value.starts_with('S') {
+        "SelfType".to_string()
+    } else {
+        "SelfValue".to_string()
+    }
 }
 
 fn capitalize(word: &str) -> String {
     let mut chars = word.chars();
-    match chars.next() {
-        None => String::new(),
-        Some(first) => first.to_uppercase().collect::<String>() + &chars.as_str().to_lowercase(),
-    }
-}
-
-/// Port of `Hecks::Naming.snake` —
-/// `gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').gsub(/([a-z\d])([A-Z])/, '\1_\2').downcase`.
-pub fn snake(text: &str) -> String {
-    let chars: Vec<char> = text.chars().collect();
-    let mut first = String::new();
-    for (i, &c) in chars.iter().enumerate() {
-        let next_upper = chars.get(i + 1).is_some_and(|n| n.is_ascii_uppercase());
-        let then_lower = chars.get(i + 2).is_some_and(|n| n.is_ascii_lowercase());
-        first.push(c);
-        if c.is_ascii_uppercase() && next_upper && then_lower {
-            first.push('_');
-        }
-    }
-    let chars: Vec<char> = first.chars().collect();
-    let mut second = String::new();
-    for (i, &c) in chars.iter().enumerate() {
-        second.push(c);
-        let next_upper = chars.get(i + 1).is_some_and(|n| n.is_ascii_uppercase());
-        if (c.is_ascii_lowercase() || c.is_ascii_digit()) && next_upper {
-            second.push('_');
-        }
-    }
-    second.to_lowercase()
+    chars.next().map_or_else(String::new, |first| {
+        first.to_uppercase().collect::<String>() + &chars.as_str().to_lowercase()
+    })
 }
 
 /// `name.to_s.gsub(/([a-z0-9])([A-Z])/, '\1_\2').upcase`
@@ -289,18 +289,36 @@ pub fn scalar_to_value(type_name: &str, rust_expr: &str) -> Option<String> {
 /// single-field closed-set enums implement `Fielded`; multi-field closed-set
 /// tables do not.
 pub fn fielded_capable_nested(vo: &crate::json::Json) -> bool {
-    !vo.get("closed_set").map(crate::json::Json::as_bool).unwrap_or(false)
-        || vo.get("attributes").map(crate::json::Json::each).unwrap_or(&[]).len() == 1
+    !vo.get("closed_set").is_some_and(crate::json::Json::as_bool)
+        || vo
+            .get("attributes")
+            .map_or_default(crate::json::Json::each)
+            .len()
+            == 1
 }
 
 /// The `Fielded` impl emitted beside a single-field closed-set enum, exposing `"value"`.
 pub fn emit_closed_set_fielded_impl(vo: &crate::json::Json) -> String {
-    let name = rust_ident(vo.get("name").and_then(crate::json::Json::as_str).unwrap_or(""));
-    let arms = vo.get("members").map(crate::json::Json::each).unwrap_or(&[]).iter().filter_map(|row| {
-        let pair = row.as_array()?.first()?.as_array()?;
-        let raw = pair.get(1)?.to_s();
-        Some(format!("{name}::{} => {}.to_string(),", closed_set_variant(&raw), ruby_inspect_string(&raw)))
-    }).collect::<Vec<_>>().join(" ");
+    let name = rust_ident(
+        vo.get("name")
+            .and_then(crate::json::Json::as_str)
+            .unwrap_or(""),
+    );
+    let arms = vo
+        .get("members")
+        .map_or_default(crate::json::Json::each)
+        .iter()
+        .filter_map(|row| {
+            let pair = row.as_array()?.first()?.as_array()?;
+            let raw = pair.get(1)?.to_s();
+            Some(format!(
+                "Self::{} => {}.to_string(),",
+                closed_set_variant(&raw),
+                ruby_inspect_string(&raw)
+            ))
+        })
+        .collect::<Vec<_>>()
+        .join(" ");
 
     format!(
         "impl crate::kernel::Fielded for {name} {{\n    fn field(&self, name: &str) -> Option<crate::kernel::Field<'_>> {{\n        use crate::kernel::{{Field, Value}};\n        match name {{\n            \"value\" => Some(Field::Value(Value::Str(match self {{ {arms} }}))),\n            _ => None,\n        }}\n    }}\n    fn as_scalar(&self) -> Option<crate::kernel::Value> {{\n        match self.field(\"value\") {{ Some(crate::kernel::Field::Value(v)) => Some(v), _ => None }}\n    }}\n}}"
@@ -308,6 +326,10 @@ pub fn emit_closed_set_fielded_impl(vo: &crate::json::Json) -> String {
 }
 
 /// A literal mutation-source RHS; `literal` is a String/Integer/Float/Bool read from `ir.json`.
+#[allow(
+    clippy::panic,
+    reason = "a drifted exemplar or invalid IR aborts generation on purpose"
+)]
 pub fn literal_rhs(literal: &crate::json::Json) -> String {
     match literal {
         crate::json::Json::String(s) => format!("{}.to_string()", ruby_inspect_string(s)),
@@ -346,11 +368,23 @@ mod tests {
     #[test]
     fn a_scalar_reached_through_a_reference_is_dereferenced_when_it_is_a_copy_type() {
         // `self.level.as_ref().map(|v| Field::Value(Value::Int(v)))` does not compile: `v` is `&i64`.
-        assert_eq!(scalar_to_value("Integer", &deref_scalar("Integer", "v")).as_deref(), Some("Value::Int(*v)"));
-        assert_eq!(scalar_to_value("Float", &deref_scalar("Float", "v")).as_deref(), Some("Value::Float(*v)"));
-        assert_eq!(scalar_to_value("TrueClass", &deref_scalar("TrueClass", "v")).as_deref(), Some("Value::Bool(*v)"));
+        assert_eq!(
+            scalar_to_value("Integer", &deref_scalar("Integer", "v")).as_deref(),
+            Some("Value::Int(*v)")
+        );
+        assert_eq!(
+            scalar_to_value("Float", &deref_scalar("Float", "v")).as_deref(),
+            Some("Value::Float(*v)")
+        );
+        assert_eq!(
+            scalar_to_value("TrueClass", &deref_scalar("TrueClass", "v")).as_deref(),
+            Some("Value::Bool(*v)")
+        );
         // A String is cloned, so the reference is left alone.
-        assert_eq!(scalar_to_value("String", &deref_scalar("String", "v")).as_deref(), Some("Value::Str(v.clone())"));
+        assert_eq!(
+            scalar_to_value("String", &deref_scalar("String", "v")).as_deref(),
+            Some("Value::Str(v.clone())")
+        );
     }
 
     #[test]
@@ -368,8 +402,12 @@ mod tests {
 
     #[test]
     fn refuses_an_aggregate_whose_module_name_is_a_rust_keyword() {
-        let refusal = reserved_name_refusal("shop", "shop", &["Pizza", "Match", "Type"]).expect("refused");
-        assert!(refusal.starts_with("shop: aggregate name(s) \"Match\", \"Type\" can't be used as-is"), "{refusal}");
+        let refusal =
+            reserved_name_refusal("shop", "shop", &["Pizza", "Match", "Type"]).expect("refused");
+        assert!(
+            refusal.starts_with("shop: aggregate name(s) \"Match\", \"Type\" can't be used as-is"),
+            "{refusal}"
+        );
         assert!(refusal.contains("`pub mod match;`"), "{refusal}");
         assert!(refusal.contains("Rust keyword"), "{refusal}");
     }
@@ -381,7 +419,12 @@ mod tests {
         )
         .unwrap();
         let refusal = unsafe_name_refusal("shop", &ir).expect("refused");
-        assert!(refusal.starts_with("shop: declared name(s) \"a: String, pub evil: u8\" can't be used as-is"), "{refusal}");
+        assert!(
+            refusal.starts_with(
+                "shop: declared name(s) \"a: String, pub evil: u8\" can't be used as-is"
+            ),
+            "{refusal}"
+        );
     }
 
     #[test]
@@ -412,12 +455,20 @@ mod tests {
     fn refuses_a_domain_module_name_that_is_a_keyword_or_a_cargo_key() {
         for name in ["crate", "type", "package", "default", "version"] {
             let refusal = reserved_name_refusal("label", name, &["Widget"]).expect("refused");
-            assert!(refusal.starts_with(&format!("label: domain module name {name:?} can't be used as-is")), "{refusal}");
+            assert!(
+                refusal.starts_with(&format!(
+                    "label: domain module name {name:?} can't be used as-is"
+                )),
+                "{refusal}"
+            );
         }
     }
 
     #[test]
     fn accepts_ordinary_names_and_cargo_keys_as_aggregate_names() {
-        assert_eq!(reserved_name_refusal("shop", "shop", &["Pizza", "Version", "Default"]), None);
+        assert_eq!(
+            reserved_name_refusal("shop", "shop", &["Pizza", "Version", "Default"]),
+            None
+        );
     }
 }

data/rust/codegen/src/optional_pass.rs

@@ -27,7 +27,7 @@ pub fn run(ir: &mut Json) {
 }
 
 fn list<'a>(node: &'a Json, key: &str) -> &'a [Json] {
-    node.get(key).map(Json::each).unwrap_or(&[])
+    node.get(key).map_or_default(Json::each)
 }
 
 fn name_of(node: &Json) -> Option<&str> {
@@ -47,15 +47,28 @@ fn domain_wide_value_objects(aggregates: &[Json]) -> HashMap<&str, (usize, usize
     by_name
 }
 
-fn find_element(aggregates: &[Json], a: usize, domain_wide: &HashMap<&str, (usize, usize)>, type_name: &str) -> Option<Element> {
+fn find_element(
+    aggregates: &[Json],
+    a: usize,
+    domain_wide: &HashMap<&str, (usize, usize)>,
+    type_name: &str,
+) -> Option<Element> {
     let aggregate = &aggregates[a];
-    if let Some(e) = list(aggregate, "entities").iter().position(|entity| name_of(entity) == Some(type_name)) {
+    if let Some(e) = list(aggregate, "entities")
+        .iter()
+        .position(|entity| name_of(entity) == Some(type_name))
+    {
         return Some(Element::Entity(a, e));
     }
-    if let Some(v) = list(aggregate, "value_objects").iter().rposition(|value_object| name_of(value_object) == Some(type_name)) {
+    if let Some(v) = list(aggregate, "value_objects")
+        .iter()
+        .rposition(|value_object| name_of(value_object) == Some(type_name))
+    {
         return Some(Element::ValueObject(a, v));
     }
-    domain_wide.get(type_name).map(|&(owner, v)| Element::ValueObject(owner, v))
+    domain_wide
+        .get(type_name)
+        .map(|&(owner, v)| Element::ValueObject(owner, v))
 }
 
 // Read first, write after: the commands are read while the elements they mark are mutated.
@@ -66,8 +79,15 @@ fn collect_marks(ir: &Json) -> Vec<Mark> {
 
     for (a, aggregate) in aggregates.iter().enumerate() {
         for attribute in list(aggregate, "attributes") {
-            let (Some(attr_name), Some(type_name)) = (name_of(attribute), attribute.get("type").and_then(Json::as_str)) else { continue };
-            let Some(element) = find_element(aggregates, a, &domain_wide, type_name) else { continue };
+            let (Some(attr_name), Some(type_name)) = (
+                name_of(attribute),
+                attribute.get("type").and_then(Json::as_str),
+            ) else {
+                continue;
+            };
+            let Some(element) = find_element(aggregates, a, &domain_wide, type_name) else {
+                continue;
+            };
 
             for field in collect_fields_to_mark(aggregate, attr_name) {
                 marks.push(Mark { element, field });
@@ -90,15 +110,21 @@ fn collect_fields_to_mark(aggregate: &Json, target_attr_name: &str) -> Vec<Strin
                 continue;
             }
 
-            let Some(fields) = mutation.get("fields").and_then(Json::as_object) else { continue };
+            let Some(fields) = mutation.get("fields").and_then(Json::as_object) else {
+                continue;
+            };
             for (field_name, source) in fields {
                 // Only a Symbol (an argument name) renders with a leading `:` in `Literal.render`.
-                let Some(source_text) = source.as_str() else { continue };
-                let Some(arg_name) = source_text.strip_prefix(':') else { continue };
-
-                let source_is_optional = command_attrs
-                    .iter()
-                    .any(|a| name_of(a) == Some(arg_name) && a.get("optional").map(Json::as_bool).unwrap_or(false));
+                let Some(source_text) = source.as_str() else {
+                    continue;
+                };
+                let Some(arg_name) = source_text.strip_prefix(':') else {
+                    continue;
+                };
+
+                let source_is_optional = command_attrs.iter().any(|a| {
+                    name_of(a) == Some(arg_name) && a.get("optional").is_some_and(Json::as_bool)
+                });
                 if source_is_optional {
                     out.push(field_name.clone());
                 }
@@ -110,17 +136,31 @@ fn collect_fields_to_mark(aggregate: &Json, target_attr_name: &str) -> Vec<Strin
 }
 
 fn apply_marks(ir: &mut Json, marks: &[Mark]) {
-    let Some(aggregates) = ir.get_mut("aggregates").and_then(Json::as_array_mut) else { return };
+    let Some(aggregates) = ir.get_mut("aggregates").and_then(Json::as_array_mut) else {
+        return;
+    };
 
     for mark in marks {
         let (a, key, index) = match mark.element {
             Element::ValueObject(a, v) => (a, "value_objects", v),
             Element::Entity(a, e) => (a, "entities", e),
         };
-        let element = aggregates.get_mut(a).and_then(|aggregate| aggregate.get_mut(key)).and_then(Json::as_array_mut).and_then(|elements| elements.get_mut(index));
-        let Some(attrs) = element.and_then(|element| element.get_mut("attributes")).and_then(Json::as_array_mut) else { continue };
+        let element = aggregates
+            .get_mut(a)
+            .and_then(|aggregate| aggregate.get_mut(key))
+            .and_then(Json::as_array_mut)
+            .and_then(|elements| elements.get_mut(index));
+        let Some(attrs) = element
+            .and_then(|element| element.get_mut("attributes"))
+            .and_then(Json::as_array_mut)
+        else {
+            continue;
+        };
 
-        if let Some(field_attr) = attrs.iter_mut().find(|a| name_of(a) == Some(mark.field.as_str())) {
+        if let Some(field_attr) = attrs
+            .iter_mut()
+            .find(|a| name_of(a) == Some(mark.field.as_str()))
+        {
             field_attr.set_bool("optional", true);
         }
     }
@@ -163,12 +203,16 @@ mod tests {
     }
 
     fn domain(aggregates: &[String]) -> Json {
-        Json::parse(&format!(r#"{{"aggregates": [{}]}}"#, aggregates.join(","))).expect("fixture parses")
+        Json::parse(&format!(r#"{{"aggregates": [{}]}}"#, aggregates.join(",")))
+            .expect("fixture parses")
     }
 
     fn amount_optional(ir: &Json, aggregate: usize, key: &str) -> bool {
         let element = &list(&list(ir, "aggregates")[aggregate], key)[0];
-        let amount = list(element, "attributes").iter().find(|a| name_of(a) == Some("amount")).unwrap();
+        let amount = list(element, "attributes")
+            .iter()
+            .find(|a| name_of(a) == Some("amount"))
+            .unwrap();
         amount.get("optional").unwrap().as_bool()
     }
 
@@ -176,8 +220,12 @@ mod tests {
     // recorded from it. Read at test time, not compiled in: an installed gem has no `spec/`.
     #[test]
     fn marks_what_the_ruby_pass_marks_on_the_shared_fixture() {
-        let dir = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../../spec/fixtures/append_optionals");
-        let read = |name: &str| Json::parse(&std::fs::read_to_string(dir.join(name)).expect("reads the fixture")).expect("parses");
+        let dir = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
+            .join("../../spec/fixtures/append_optionals");
+        let read = |name: &str| {
+            Json::parse(&std::fs::read_to_string(dir.join(name)).expect("reads the fixture"))
+                .expect("parses")
+        };
 
         let mut ir = read("input.json");
         run(&mut ir);
@@ -197,28 +245,42 @@ mod tests {
 
     #[test]
     fn marks_a_value_object_another_aggregate_declares() {
-        let owner = r#"{"attributes": [], "value_objects": [LEDGER], "entities": [], "commands": []}"#.replace("LEDGER", &element(false));
+        let owner =
+            r#"{"attributes": [], "value_objects": [LEDGER], "entities": [], "commands": []}"#
+                .replace("LEDGER", &element(false));
         let appender = aggregate_with("", "", "LedgerEntry");
         let mut ir = domain(&[appender, owner]);
         run(&mut ir);
 
-        assert!(amount_optional(&ir, 1, "value_objects"), "the value object lives in the second aggregate");
+        assert!(
+            amount_optional(&ir, 1, "value_objects"),
+            "the value object lives in the second aggregate"
+        );
     }
 
     #[test]
     fn prefers_a_local_entity_over_a_value_object_of_the_same_name() {
         let local = aggregate_with(&element(false), "", "LedgerEntry");
-        let owner = r#"{"attributes": [], "value_objects": [LEDGER], "entities": [], "commands": []}"#.replace("LEDGER", &element(false));
+        let owner =
+            r#"{"attributes": [], "value_objects": [LEDGER], "entities": [], "commands": []}"#
+                .replace("LEDGER", &element(false));
         let mut ir = domain(&[local, owner]);
         run(&mut ir);
 
-        assert!(amount_optional(&ir, 0, "entities"), "the local entity is the one marked");
-        assert!(!amount_optional(&ir, 1, "value_objects"), "the domain-wide value object is left alone");
+        assert!(
+            amount_optional(&ir, 0, "entities"),
+            "the local entity is the one marked"
+        );
+        assert!(
+            !amount_optional(&ir, 1, "value_objects"),
+            "the domain-wide value object is left alone"
+        );
     }
 
     #[test]
     fn leaves_a_field_alone_when_its_argument_is_required() {
-        let mut ir = domain(&[aggregate_with(&element(false), "", "LedgerEntry").replace("\"optional\": true", "\"optional\": false")]);
+        let mut ir = domain(&[aggregate_with(&element(false), "", "LedgerEntry")
+            .replace("\"optional\": true", "\"optional\": false")]);
         run(&mut ir);
 
         assert!(!amount_optional(&ir, 0, "entities"));

data/rust/codegen/src/ports.rs

@@ -17,7 +17,7 @@ pub fn port_operation_skip_reason(
     _owner_name: &str,
     value_objects_by_name: &HashMap<String, &Json>,
 ) -> Option<SkipReason> {
-    let attrs = operation.get("attributes").map(Json::each).unwrap_or(&[]);
+    let attrs = operation.get("attributes").map_or_default(Json::each);
     let unresolved: Vec<&Json> = attrs
         .iter()
         .filter(|attr| {
@@ -63,7 +63,7 @@ pub fn emit_port_operation(
         naming::rust_ident(operation.get("name").and_then(Json::as_str).unwrap_or(""))
     );
     let qualified = format!("{domain_name}::{owner_name}");
-    let attrs = operation.get("attributes").map(Json::each).unwrap_or(&[]);
+    let attrs = operation.get("attributes").map_or_default(Json::each);
     // A self-reference on a port operation is a migration-era spelling of
     // its receiver, never an external fact. Keep accepting old IR while
     // excluding that field from the typed args and event payload.
@@ -109,7 +109,7 @@ pub fn emit_port_operation(
         ))
     );
 
-    let emits = operation.get("emits").map(Json::each).unwrap_or(&[]);
+    let emits = operation.get("emits").map_or_default(Json::each);
     let events: Vec<String> = emits
         .iter()
         .map(|event_name| {
@@ -130,7 +130,7 @@ pub fn emit_port_operation(
     let operation_name = operation.get("name").and_then(Json::as_str).unwrap_or("");
     [
         format!("#[derive(Debug, Clone)]\n{}", struct_lines.join("\n")),
-        crate::json_codec::emit_to_json_flat(exemplar, &args_struct, &fact_attrs, value_objects_by_name, false, &[], None),
+        crate::json_codec::emit_to_json_flat(exemplar, &args_struct, &fact_attrs, false, &[], None),
         crate::json_codec::emit_from_json_flat(
             exemplar,
             &args_struct,
@@ -141,6 +141,7 @@ pub fn emit_port_operation(
             false,
             true,
             Some(aggregates_by_name),
+            None,
         ),
         dispatch_fn,
     ]