hecks 2.8.0 → 3.0.0

data/rust/parser/src/ruby_value.rs

@@ -0,0 +1,422 @@
+//! Mirror of `Hecks::Literal` (lib/hecks/literal.rb): the pinned wire spelling of a captured
+//! Ruby literal, independent of the Ruby version's `Hash#inspect` format.
+
+/// A captured Ruby literal.
+#[derive(Debug, Clone, PartialEq)]
+pub enum Value {
+    Nil,
+    Bool(bool),
+    Int(i64),
+    Float(f64),
+    Str(String),
+    Symbol(String),
+    Hash(Vec<(String, Value)>),
+    Array(Vec<Value>),
+    /// A bare word `Literal.read` tolerates; kept apart from `Str` so `render` adds no quotes.
+    Bare(String),
+}
+
+pub fn render(value: &Value) -> String {
+    match value {
+        Value::Nil => "nil".to_string(),
+        Value::Bool(b) => b.to_string(),
+        Value::Int(n) => n.to_string(),
+        Value::Float(f) => format_ruby_float(*f),
+        Value::Symbol(name) => format!(":{name}"),
+        Value::Str(text) => quote(text),
+        Value::Bare(text) => text.clone(),
+        Value::Hash(pairs) => {
+            let body = pairs
+                .iter()
+                .map(|(key, held)| format!("{key}: {}", render(held)))
+                .collect::<Vec<_>>()
+                .join(", ");
+            format!("{{{body}}}")
+        }
+        Value::Array(items) => {
+            let body = items.iter().map(render).collect::<Vec<_>>().join(", ");
+            format!("[{body}]")
+        }
+    }
+}
+
+/// Ruby's `Float#to_s` always keeps a digit after the point (`1.0`); Rust prints `1`.
+fn format_ruby_float(value: f64) -> String {
+    let text = format!("{value}");
+    if text.contains('.') || text.contains('e') || text.contains("inf") || text.contains("NaN") {
+        text
+    } else {
+        format!("{text}.0")
+    }
+}
+
+pub fn quote(text: &str) -> String {
+    let mut out = String::with_capacity(text.len() + 2);
+    out.push('"');
+    for ch in text.chars() {
+        match ch {
+            '"' => out.push_str("\\\""),
+            '\\' => out.push_str("\\\\"),
+            other => out.push(other),
+        }
+    }
+    out.push('"');
+    out
+}
+
+/// Ruby's `#to_s` of a `Value`: no colon on a Symbol, no quotes on a String.
+/// For where Ruby calls `.to_s` rather than `Literal.render`, e.g. `IR::ValueObject#to_h`.
+pub fn to_s(value: &Value) -> String {
+    match value {
+        Value::Nil => String::new(),
+        Value::Bool(b) => b.to_string(),
+        Value::Int(n) => n.to_string(),
+        Value::Float(f) => format_ruby_float(*f),
+        Value::Symbol(name) => name.clone(),
+        Value::Str(text) => text.clone(),
+        Value::Bare(text) => text.clone(),
+        // Ruby's `Hash#to_s`/`Array#to_s` is version-dependent; use the pinned `render` form.
+        Value::Hash(_) | Value::Array(_) => render(value),
+    }
+}
+
+/// Unescapes the inner text of a quoted symbol in bluebook source, `:"a.b"` -> `a.b`.
+/// `rest` is the text after the leading `:`, already confirmed to start and end with `"`.
+pub fn unquote_for_symbol(rest: &str) -> String {
+    unquote(rest)
+}
+
+pub fn read(text: &str) -> Value {
+    let raw = text.trim();
+    if raw.is_empty() || raw == "nil" {
+        return Value::Nil;
+    }
+    if raw == "true" {
+        return Value::Bool(true);
+    }
+    if raw == "false" {
+        return Value::Bool(false);
+    }
+    if is_integer(raw) {
+        if let Ok(n) = raw.parse::<i64>() {
+            return Value::Int(n);
+        }
+    }
+    if is_float(raw) {
+        if let Ok(f) = raw.parse::<f64>() {
+            return Value::Float(f);
+        }
+    }
+    if let Some(name) = raw.strip_prefix(':') {
+        return Value::Symbol(name.to_string());
+    }
+    // Adjacent literals (`"a" "b"`) concatenate in Ruby; check before the single-literal
+    // branches, which would slice `a" "b` out of the middle.
+    if raw.starts_with('"') || raw.starts_with('\'') {
+        if let Some((joined, consumed)) = scan_adjacent_strings(raw) {
+            if consumed == raw.chars().count() {
+                return Value::Str(joined);
+            }
+        }
+    }
+    if is_quoted(raw) {
+        return Value::Str(unquote(raw));
+    }
+    // Single-quoted literals appear in source (e.g. regex patterns) though `Literal.render`
+    // never emits them. Only `\\` and `\'` are escapes, so this is not `unquote`.
+    if is_single_quoted(raw) {
+        return Value::Str(unquote_single(raw));
+    }
+    if raw.starts_with('{') && raw.ends_with('}') {
+        return read_hash(raw);
+    }
+    if raw.starts_with('[') && raw.ends_with(']') {
+        return read_array(raw);
+    }
+    Value::Bare(raw.to_string())
+}
+
+fn is_integer(raw: &str) -> bool {
+    let body = raw.strip_prefix('-').unwrap_or(raw);
+    !body.is_empty() && body.chars().all(|c| c.is_ascii_digit())
+}
+
+fn is_float(raw: &str) -> bool {
+    let body = raw.strip_prefix('-').unwrap_or(raw);
+    let Some((int_part, frac_part)) = body.split_once('.') else {
+        return false;
+    };
+    !int_part.is_empty()
+        && !frac_part.is_empty()
+        && int_part.chars().all(|c| c.is_ascii_digit())
+        && frac_part.chars().all(|c| c.is_ascii_digit())
+}
+
+fn is_quoted(raw: &str) -> bool {
+    raw.len() >= 2 && raw.starts_with('"') && raw.ends_with('"')
+}
+
+fn is_single_quoted(raw: &str) -> bool {
+    raw.len() >= 2 && raw.starts_with('\'') && raw.ends_with('\'')
+}
+
+/// Unescapes a Ruby single-quoted body: only `\\` and `\'` are escapes, other backslashes stay.
+fn unquote_single(raw: &str) -> String {
+    unescape_single_quoted_inner(&raw[1..raw.len() - 1])
+}
+
+fn unescape_single_quoted_inner(inner: &str) -> String {
+    let mut out = String::with_capacity(inner.len());
+    let mut chars = inner.chars().peekable();
+    while let Some(ch) = chars.next() {
+        if ch == '\\' {
+            match chars.peek() {
+                Some('\\') => {
+                    out.push('\\');
+                    chars.next();
+                }
+                Some('\'') => {
+                    out.push('\'');
+                    chars.next();
+                }
+                _ => out.push('\\'),
+            }
+        } else {
+            out.push(ch);
+        }
+    }
+    out
+}
+
+fn unquote(raw: &str) -> String {
+    unescape_double_quoted_inner(&raw[1..raw.len() - 1])
+}
+
+fn unescape_double_quoted_inner(inner: &str) -> String {
+    let mut out = String::with_capacity(inner.len());
+    let mut chars = inner.chars();
+    while let Some(ch) = chars.next() {
+        if ch == '\\' {
+            if let Some(next) = chars.next() {
+                out.push(next);
+            }
+        } else {
+            out.push(ch);
+        }
+    }
+    out
+}
+
+/// Scans adjacent quoted literals (either quote style, whitespace-separated) from index 0.
+/// Returns their unescaped concatenation and the chars consumed, or `None` if `raw` does not
+/// start with a closed literal. Callers compare `consumed` to the full length to tell a whole
+/// string expression from trailing text.
+fn scan_adjacent_strings(raw: &str) -> Option<(String, usize)> {
+    let chars: Vec<char> = raw.chars().collect();
+    let mut i = 0usize;
+    let mut out = String::new();
+    let mut matched_any = false;
+
+    loop {
+        if matched_any {
+            let mut j = i;
+            while j < chars.len() && chars[j].is_whitespace() {
+                j += 1;
+            }
+            if j >= chars.len() || (chars[j] != '"' && chars[j] != '\'') {
+                break;
+            }
+            i = j;
+        }
+
+        // Defensive: return `None` rather than panic on an empty or odd `raw`.
+        let Some(&quote) = chars.get(i).filter(|c| **c == '"' || **c == '\'') else {
+            return None;
+        };
+
+        let start = i;
+        i += 1;
+        let mut escaping = false;
+        let mut closed = false;
+        while i < chars.len() {
+            let ch = chars[i];
+            if escaping {
+                escaping = false;
+                i += 1;
+                continue;
+            }
+            if ch == '\\' {
+                escaping = true;
+                i += 1;
+                continue;
+            }
+            if ch == quote {
+                i += 1;
+                closed = true;
+                break;
+            }
+            i += 1;
+        }
+        if !closed {
+            return None;
+        }
+
+        let inner: String = chars[start + 1..i - 1].iter().collect();
+        out.push_str(&if quote == '"' {
+            unescape_double_quoted_inner(&inner)
+        } else {
+            unescape_single_quoted_inner(&inner)
+        });
+        matched_any = true;
+    }
+
+    Some((out, i))
+}
+
+fn read_hash(raw: &str) -> Value {
+    let inner = &raw[1..raw.len() - 1];
+    let pairs = split_items(inner)
+        .into_iter()
+        .map(|item| {
+            let (key, held) = item.split_once(':').unwrap_or((item.as_str(), ""));
+            (key.trim().to_string(), read(held.trim()))
+        })
+        .collect();
+    Value::Hash(pairs)
+}
+
+fn read_array(raw: &str) -> Value {
+    let inner = &raw[1..raw.len() - 1];
+    Value::Array(
+        split_items(inner)
+            .into_iter()
+            .map(|item| read(item.trim()))
+            .collect(),
+    )
+}
+
+/// Splits on commas outside quotes and nested braces, brackets and parens.
+///
+/// Unlike `Hecks::Literal.split_items` it also tracks parens, so a nested call such as
+/// `one_of("a", "b")` inside an argument list stays in one segment.
+pub fn split_items(body: &str) -> Vec<String> {
+    let mut items = Vec::new();
+    let mut current = String::new();
+    let mut depth: i32 = 0;
+    let mut quoting = false;
+    let mut escaping = false;
+
+    for ch in body.chars() {
+        current.push(ch);
+        if escaping {
+            escaping = false;
+            continue;
+        }
+        if quoting && ch == '\\' {
+            escaping = true;
+            continue;
+        }
+        if ch == '"' {
+            quoting = !quoting;
+            continue;
+        }
+        if quoting {
+            continue;
+        }
+        if ch == '{' || ch == '[' || ch == '(' {
+            depth += 1;
+        }
+        if ch == '}' || ch == ']' || ch == ')' {
+            depth -= 1;
+        }
+        if ch == ',' && depth == 0 {
+            current.pop();
+            items.push(current.clone());
+            current.clear();
+        }
+    }
+    items.push(current);
+    items
+        .into_iter()
+        .map(|s| s.trim().to_string())
+        .filter(|s| !s.is_empty())
+        .collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn renders_the_pinned_spellings() {
+        assert_eq!(render(&Value::Nil), "nil");
+        assert_eq!(render(&Value::Bool(true)), "true");
+        assert_eq!(render(&Value::Bool(false)), "false");
+        assert_eq!(render(&Value::Symbol("amount".to_string())), ":amount");
+        assert_eq!(render(&Value::Int(0)), "0");
+        assert_eq!(render(&Value::Float(0.0)), "0.0");
+        assert_eq!(render(&Value::Str("credit".to_string())), "\"credit\"");
+        assert_eq!(
+            render(&Value::Str("a\"b\\c".to_string())),
+            "\"a\\\"b\\\\c\""
+        );
+        assert_eq!(
+            render(&Value::Hash(vec![(
+                "value".to_string(),
+                Value::Str("credit".to_string())
+            )])),
+            "{value: \"credit\"}"
+        );
+        assert_eq!(
+            render(&Value::Array(vec![Value::Int(1), Value::Int(2)])),
+            "[1, 2]"
+        );
+    }
+
+    #[test]
+    fn reads_back_what_render_wrote() {
+        assert_eq!(read("nil"), Value::Nil);
+        assert_eq!(read("true"), Value::Bool(true));
+        assert_eq!(read(":amount"), Value::Symbol("amount".to_string()));
+        assert_eq!(read("0"), Value::Int(0));
+        assert_eq!(read("0.0"), Value::Float(0.0));
+        assert_eq!(read("\"credit\""), Value::Str("credit".to_string()));
+        assert_eq!(
+            read("{value: \"credit\"}"),
+            Value::Hash(vec![(
+                "value".to_string(),
+                Value::Str("credit".to_string())
+            )])
+        );
+        assert_eq!(
+            read("[1, 2]"),
+            Value::Array(vec![Value::Int(1), Value::Int(2)])
+        );
+        // a bare word never rendered stays a string reading, not nil/symbol
+        assert_eq!(read("open"), Value::Bare("open".to_string()));
+    }
+
+    #[test]
+    fn splits_only_top_level_commas() {
+        assert_eq!(
+            split_items("\"a, b\", 1"),
+            vec!["\"a, b\"".to_string(), "1".to_string()]
+        );
+        assert_eq!(
+            split_items("{a: 1, b: 2}, 3"),
+            vec!["{a: 1, b: 2}".to_string(), "3".to_string()]
+        );
+    }
+
+    #[test]
+    fn concatenates_three_adjacent_literals_mixing_quote_styles() {
+        assert_eq!(read("\"a\" 'b' \"c\""), Value::Str("abc".to_string()));
+    }
+
+    #[test]
+    fn does_not_treat_a_quoted_string_followed_by_other_text_as_concatenation() {
+        // `"a" foo` is not two adjacent literals: `scan_adjacent_strings` consumes less than
+        // the whole input, so `read` falls through to `Value::Bare`.
+        assert_eq!(read("\"a\" foo"), Value::Bare("\"a\" foo".to_string()));
+    }
+}

data/rust/project/bridging.rb

@@ -0,0 +1,257 @@
+module RustProjection
+  module Projector
+    module_function
+
+    # `use` statements for value-object types this aggregate's commands
+    # reference by name but don't declare locally (same chapter only).
+    def cross_aggregate_vo_imports(aggregate, domain_value_object_owner, mod_name)
+      local_names = aggregate[:value_objects].map { |vo| vo[:name] }.to_set
+      attrs = (aggregate[:commands] + aggregate[:entities].flat_map { |e| e[:commands] } +
+               aggregate[:ports].flat_map { |p| p[:operations] })
+              .flat_map { |c| c[:attributes] }
+
+      # A locally-declared type is never "foreign", even if some other
+      # aggregate owns a VO of the same name domain-wide.
+      foreign_types = attrs.map { |a| a[:type] }.uniq.reject { |type| local_names.include?(type) }
+      foreign_types.filter_map { |type| domain_value_object_owner[type] && [type, domain_value_object_owner[type]] }
+                   .sort_by { |(type, owner)| [owner, type] }
+                   .map { |(type, owner)| "use crate::generated::#{mod_name}::#{owner.downcase}::#{rust_ident(type)};" }
+    end
+
+    # Whether target_vo's fields can all be filled from source_vo's fields
+    # (matched by name) or the target's own defaults.
+    def vo_field_bridgeable?(source_vo, target_vo)
+      return false unless source_vo && target_vo
+      return closed_sets_bridgeable?(source_vo, target_vo) if source_vo[:closed_set] || target_vo[:closed_set]
+
+      target_vo[:attributes].all? do |t_attr|
+        source_vo[:attributes].any? { |s_attr| s_attr[:name] == t_attr[:name] } || !t_attr[:default].nil?
+      end
+    end
+
+    # Source closed-set members mappable to target members, or nil unless
+    # every source member is also a target member (so the bridge can't fail).
+    def closed_set_bridge_members(source_vo, target_vo)
+      return nil unless source_vo[:closed_set] && target_vo[:closed_set]
+      return nil unless source_vo[:attributes].size == 1 && target_vo[:attributes].size == 1
+
+      target_values = target_vo[:members].map { |row| row.to_h.values.first.to_s }
+      source_rows   = source_vo[:members]
+      return nil unless source_rows.all? { |row| target_values.include?(row.to_h.values.first.to_s) }
+
+      source_rows
+    end
+
+    def closed_sets_bridgeable?(source_vo, target_vo)
+      !closed_set_bridge_members(source_vo, target_vo).nil?
+    end
+
+    def vo_field_rhs(source_expr, source_vo, target_type, value_objects_by_name)
+      target_vo = value_objects_by_name[target_type]
+      if (rows = closed_set_bridge_members(source_vo, target_vo))
+        arms = rows.map { |row| "#{rust_ident(source_vo[:name])}::#{closed_set_variant(row)} => #{rust_ident(target_type)}::#{closed_set_variant(row)}" }
+        return "match &#{source_expr} { #{arms.join(', ')} }"
+      end
+
+      fields = target_vo[:attributes].map do |t_attr|
+        field = rust_ident_field(t_attr[:name])
+        if source_vo[:attributes].any? { |s_attr| s_attr[:name] == t_attr[:name] }
+          "#{field}: #{source_expr}.#{field}.clone()"
+        else
+          "#{field}: #{literal_rhs(t_attr[:default])}"
+        end
+      end
+      "#{rust_ident(target_type)} { #{fields.join(', ')} }"
+    end
+
+    # Whether a value can move from source_type to target_type. Shared
+    # with `value_rhs`, which performs the bridge this checks for.
+    def bridgeable_value_types?(source_type, target_type, value_objects_by_name)
+      return true if source_type == target_type
+      # Compares Rust representations, not declared type names: a
+      # `Reference<T>` and a bare `String` are both just `String`.
+      return true if effective_scalar_type(source_type) && effective_scalar_type(source_type) == effective_scalar_type(target_type)
+
+      source_vo = value_objects_by_name[source_type]
+      target_vo = value_objects_by_name[target_type]
+      return vo_field_bridgeable?(source_vo, target_vo) if target_vo
+
+      # A single-field source VO unwraps into a bare scalar target when
+      # that one field's own Rust representation already matches it.
+      return false unless source_vo && !source_vo[:closed_set] && source_vo[:attributes].size == 1
+
+      unwrapped_type = source_vo[:attributes].first[:type]
+      unwrapped_type == target_type ||
+        (effective_scalar_type(unwrapped_type) && effective_scalar_type(unwrapped_type) == effective_scalar_type(target_type))
+    end
+
+    def value_rhs(source_expr, source_type, target_type, value_objects_by_name)
+      return "#{source_expr}.clone()" if source_type == target_type
+      return "#{source_expr}.clone()" if effective_scalar_type(source_type) && effective_scalar_type(source_type) == effective_scalar_type(target_type)
+
+      source_vo = value_objects_by_name[source_type]
+      target_vo = value_objects_by_name[target_type]
+      return vo_field_rhs(source_expr, source_vo, target_type, value_objects_by_name) if target_vo
+
+      raise "unsupported coercion #{source_type} -> #{target_type} — bridgeable_value_types? should have caught this" unless source_vo && !source_vo[:closed_set] && source_vo[:attributes].size == 1
+
+      "#{source_expr}.#{rust_ident_field(source_vo[:attributes].first[:name])}.clone()"
+    end
+
+    # Whether a list `:set` needs per-element rebuilding, rather than one
+    # `.clone()`, because source and target elements differ in representation.
+    def list_bridge_requires_element_mapping?(source_type, target_type)
+      return false if source_type == target_type
+
+      !(effective_scalar_type(source_type) && effective_scalar_type(source_type) == effective_scalar_type(target_type))
+    end
+
+    # `value_rhs`, mapped over each element of a list `:set` whose source
+    # and target element types differ.
+    def list_value_rhs(source_expr, source_type, target_type, value_objects_by_name)
+      "#{source_expr}.iter().map(|item| #{value_rhs('item', source_type, target_type, value_objects_by_name)}).collect()"
+    end
+
+    def literal_set_bridgeable?(value, target_type, value_objects_by_name)
+      return literal_hash_bridgeable?(value, target_type, value_objects_by_name) if value.is_a?(Hash) && target_type
+      return false if value.is_a?(Hash)
+      return false unless value.is_a?(String) || value.is_a?(Numeric) || value == true || value == false
+      return true unless target_type && value_objects_by_name[target_type]
+
+      # A scalar literal into a single-field VO stands for that field's
+      # value (mirrors `Value.for_attribute`'s runtime rewrap).
+      sole = sole_field_of(target_type, value_objects_by_name)
+      return false unless sole
+
+      literal_hash_bridgeable?({ sole => value }, target_type, value_objects_by_name)
+    end
+
+    # The right-hand side for a literal into target_type: a Hash, a
+    # scalar rewrapped into a single-field VO, or the scalar itself.
+    def literal_rhs_for(value, target_type, value_objects_by_name)
+      return literal_hash_rhs(value, target_type, value_objects_by_name) if value.is_a?(Hash)
+
+      sole = target_type && value_objects_by_name[target_type] && sole_field_of(target_type, value_objects_by_name)
+      return literal_hash_rhs({ sole => value }, target_type, value_objects_by_name) if sole
+
+      literal_rhs(value)
+    end
+
+    # Whether a literal Hash supplies every field a target VO (or one
+    # of its closed-set members) needs.
+    def literal_hash_bridgeable?(hash, target_type, value_objects_by_name)
+      vo = value_objects_by_name[target_type]
+      return false unless vo
+
+      if vo[:closed_set]
+        vo[:members].any? { |member| member.all? { |field, value| [hash[field.to_sym], hash[field.to_s]].include?(value) } }
+      else
+        vo[:attributes].all? { |attr| hash.key?(attr[:name].to_sym) || hash.key?(attr[:name].to_s) }
+      end
+    end
+
+    def literal_hash_rhs(hash, target_type, value_objects_by_name)
+      vo = value_objects_by_name[target_type]
+      raise "unsupported literal hash source #{hash.inspect} -> #{target_type} — literal_hash_bridgeable? should have caught this" unless vo
+
+      if vo[:closed_set]
+        row = vo[:members].find { |member| member.all? { |field, value| [hash[field.to_sym], hash[field.to_s]].include?(value) } }
+        raise "literal #{hash.inspect} matches no member of #{target_type} — literal_hash_bridgeable? should have caught this" unless row
+
+        "#{rust_ident(target_type)}::#{closed_set_variant(row)}"
+      else
+        fields = vo[:attributes].map do |attr|
+          key = [attr[:name].to_sym, attr[:name].to_s].find { |k| hash.key?(k) }
+          raise "literal #{hash.inspect} missing field #{attr[:name]} for #{target_type} — literal_hash_bridgeable? should have caught this" unless key
+
+          "#{rust_ident_field(attr[:name])}: #{literal_rhs(hash[key])}"
+        end
+        "#{rust_ident(target_type)} { #{fields.join(', ')} }"
+      end
+    end
+
+    def integer_field_of(vo)
+      return nil unless vo && !vo[:closed_set]
+
+      attr = vo[:attributes].find { |a| a[:type] == "Integer" }
+      attr && attr[:name]
+    end
+
+    # The attribute and its one Integer field an `:increment`/`:decrement`
+    # touches, or nil unless the target is a single-field integer VO.
+    def arithmetic_target_field(mutation, aggregate, value_objects_by_name)
+      target_attr = aggregate[:attributes].find { |a| a[:name].to_s == mutation[:target].to_s }
+      return nil unless target_attr && !target_attr[:list]
+
+      field = integer_field_of(value_objects_by_name[target_attr[:type]])
+      field && [target_attr, field]
+    end
+
+    # The amount side of an `:increment`/`:decrement` as a raw Rust
+    # integer expression. Returns nil, not raise, when nothing bridges.
+    def arithmetic_amount_expr(source, command, value_objects_by_name, target_integer_field)
+      if source[:kind] == "literal"
+        value = source[:value]
+        return literal_rhs(value) if value.is_a?(Integer)
+        return nil unless value.is_a?(Hash)
+
+        key = [target_integer_field.to_sym, target_integer_field.to_s].find { |k| value.key?(k) }
+        key && value[key].is_a?(Integer) ? literal_rhs(value[key]) : nil
+      elsif source[:kind] == "argument"
+        arg_attr = command[:attributes].find { |a| a[:name].to_s == source[:name] }
+        return nil unless arg_attr
+        return "args.#{rust_ident_field(arg_attr[:name])}" if arg_attr[:type] == "Integer"
+
+        field = integer_field_of(value_objects_by_name[arg_attr[:type]])
+        field && "args.#{rust_ident_field(arg_attr[:name])}.#{rust_ident_field(field)}"
+      end
+    end
+
+    # `clamp:`'s literal `[min, max]` bounds, or nil for anything else
+    # (non-literal source, wrong length, non-Integer bound).
+    def clamp_bounds_ints(source)
+      return nil unless source[:kind] == "literal"
+
+      value = source[:value]
+      return nil unless value.is_a?(Array) && value.size == 2 && value.all? { |v| v.is_a?(Integer) }
+
+      value
+    end
+
+    # The default for an attribute a creating command's arguments don't
+    # mention: its own default, or one built from its VO's field defaults.
+    def creation_default_rhs(attr, value_objects_by_name)
+      default = attr[:default]
+      unless default.nil?
+        return literal_rhs(default) unless default.is_a?(Hash)
+
+        # Completes a partial Hash default with the target VO's own
+        # per-field defaults first; `literal_hash_rhs` requires every
+        # field present.
+        return literal_hash_rhs(complete_hash_default(default, attr[:type], value_objects_by_name), attr[:type], value_objects_by_name)
+      end
+
+      vo = value_objects_by_name[attr[:type]]
+      return nil unless vo && !vo[:closed_set] && vo[:attributes].all? { |f| !f[:default].nil? }
+
+      fields = vo[:attributes].map { |f| "#{rust_ident_field(f[:name])}: #{literal_rhs(f[:default])}" }
+      "#{rust_ident(attr[:type])} { #{fields.join(', ')} }"
+    end
+
+    # Fields present in `hash`, plus any the target VO defaults on its
+    # own; a field with neither is left out, not set to nil.
+    def complete_hash_default(hash, target_type, value_objects_by_name)
+      vo = value_objects_by_name[target_type]
+      return hash unless vo && !vo[:closed_set]
+
+      vo[:attributes].each_with_object({}) do |field, completed|
+        key = [field[:name].to_sym, field[:name].to_s].find { |k| hash.key?(k) }
+        if key
+          completed[field[:name].to_sym] = hash[key]
+        elsif !field[:default].nil?
+          completed[field[:name].to_sym] = field[:default]
+        end
+      end
+    end
+  end
+end