hecks 2.9.0 → 3.0.1

data/rust/codegen/src/reserved_names.rs

@@ -0,0 +1,76 @@
+// GENERATED by hecks project_reserved_names from the RustReservedWord and
+// CargoReservedName vocabularies (lib/hecks/language/bluebook/
+// vocabulary.bluebook). Do not hand-edit — re-run hecks project_reserved_names.
+
+/// The `RustReservedWord` vocabulary, 49 entries.
+pub const RUST_KEYWORDS: &[&str] = &[
+    "as",
+    "break",
+    "const",
+    "continue",
+    "crate",
+    "dyn",
+    "else",
+    "enum",
+    "extern",
+    "false",
+    "fn",
+    "for",
+    "if",
+    "impl",
+    "in",
+    "let",
+    "loop",
+    "match",
+    "mod",
+    "move",
+    "mut",
+    "pub",
+    "ref",
+    "return",
+    "self",
+    "Self",
+    "static",
+    "struct",
+    "super",
+    "trait",
+    "true",
+    "type",
+    "unsafe",
+    "use",
+    "where",
+    "while",
+    "abstract",
+    "become",
+    "box",
+    "do",
+    "final",
+    "macro",
+    "override",
+    "priv",
+    "typeof",
+    "unsized",
+    "virtual",
+    "yield",
+    "try",
+];
+
+/// The `CargoReservedName` vocabulary, 16 entries.
+pub const CARGO_RESERVED_DOMAIN_NAMES: &[&str] = &[
+    "name",
+    "version",
+    "edition",
+    "path",
+    "authors",
+    "license",
+    "description",
+    "default",
+    "features",
+    "package",
+    "lib",
+    "bin",
+    "dependencies",
+    "dev-dependencies",
+    "build-dependencies",
+    "workspace",
+];

data/rust/codegen/src/shared.rs

@@ -0,0 +1,93 @@
+//! Predicates ported from `rust/project/mutations.rb` that `types.rs` and `json_codec.rs` share.
+
+use crate::json::Json;
+use std::collections::HashMap;
+
+/// Argument names claimed by an append, so an append's element-field argument never bare-name-
+/// matches an unrelated owner field. Shared by `creates_owner` and `identity_components`.
+pub fn append_claimed_names(command: &Json) -> std::collections::HashSet<String> {
+    let mut claimed = std::collections::HashSet::new();
+    for m in command.get("mutations").map(Json::each).unwrap_or(&[]) {
+        if m.get("op").map(Json::to_s).as_deref() != Some("append") {
+            continue;
+        }
+        if let Some(Json::Object(pairs)) = m.get("fields") {
+            for (_, wire_value) in pairs {
+                let literal = crate::literal::read(wire_value.as_str().unwrap_or(""));
+                if let crate::literal::Literal::Symbol(s) = literal {
+                    claimed.insert(s);
+                }
+            }
+        }
+    }
+    claimed
+}
+
+/// Whether `command` builds the owner record from scratch (`mutations.rb#creates_owner?`).
+///
+/// A command with `references` acts on an existing record. Otherwise it creates when it supplies,
+/// via a `:set` mutation or a same-named argument, a required non-list owner field, ignoring
+/// arguments claimed by an append (`append_claimed_names`).
+pub fn creates_owner(aggregate: &Json, command: &Json, _value_objects_by_name: &HashMap<String, &Json>) -> bool {
+    if command.get("references").is_some() {
+        return false;
+    }
+
+    let attrs = aggregate.get("attributes").map(Json::each).unwrap_or(&[]);
+    let owner_fields: std::collections::HashSet<String> = attrs.iter().map(|a| crate::attr::name(a).to_string()).collect();
+    let required_fields: std::collections::HashSet<String> =
+        attrs.iter().filter(|a| !crate::attr::list(a) && !crate::attr::optional(a)).map(|a| crate::attr::name(a).to_string()).collect();
+
+    let append_claimed = append_claimed_names(command);
+
+    let mut known_writes: std::collections::HashSet<String> = std::collections::HashSet::new();
+    for attr in command.get("attributes").map(Json::each).unwrap_or(&[]) {
+        let name = crate::attr::name(attr).to_string();
+        if owner_fields.contains(&name) && !append_claimed.contains(&name) {
+            known_writes.insert(name);
+        }
+    }
+    for m in command.get("mutations").map(Json::each).unwrap_or(&[]) {
+        if m.get("op").map(Json::to_s).as_deref() != Some("set") {
+            continue;
+        }
+        let target = m.get("target").map(Json::to_s).unwrap_or_default();
+        if owner_fields.contains(&target) {
+            known_writes.insert(target);
+        }
+    }
+
+    required_fields.iter().any(|field| known_writes.contains(field))
+}
+
+/// Whether a list-typed attribute reads `nil` rather than `[]` in Ruby; see
+/// `mutations.rb#list_attr_creation_optional?`.
+pub fn list_attr_creation_optional(aggregate: &Json, attr_name: &str, value_objects_by_name: &HashMap<String, &Json>) -> bool {
+    let commands = aggregate.get("commands").map(Json::each).unwrap_or(&[]);
+    commands.iter().any(|command| {
+        if !creates_owner(aggregate, command, value_objects_by_name) {
+            return false;
+        }
+        let mutations = command.get("mutations").map(Json::each).unwrap_or(&[]);
+        mutations.iter().any(|m| {
+            let op = m.get("op").map(Json::to_s).unwrap_or_default();
+            let target = m.get("target").map(Json::to_s).unwrap_or_default();
+            if op != "set" || target != attr_name {
+                return false;
+            }
+            let source = match m.get("source") {
+                Some(s) => s,
+                None => return false,
+            };
+            if source.get("kind").map(Json::to_s).unwrap_or_default() != "argument" {
+                return false;
+            }
+            let source_name = source.get("name").map(Json::to_s).unwrap_or_default();
+            let attrs = command.get("attributes").map(Json::each).unwrap_or(&[]);
+            match attrs.iter().find(|a| crate::attr::name(a) == source_name) {
+                Some(source_attr) => crate::attr::optional(source_attr),
+                None => false,
+            }
+        })
+    })
+}

data/rust/codegen/src/skip_reason.rs

@@ -0,0 +1,25 @@
+//! A skip decision plus the construct family that forced it (`rust/project/skip_reason.rb`).
+//! `construct` goes to `manifest.json` beside the reason so tools read the family, not the prose.
+
+use std::fmt;
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct SkipReason {
+    pub construct: String,
+    pub text: String,
+}
+
+pub fn skip(construct: impl Into<String>, text: impl Into<String>) -> SkipReason {
+    SkipReason { construct: construct.into(), text: text.into() }
+}
+
+/// Keeps `inner`'s construct with new wording.
+pub fn reskip(inner: &SkipReason, text: impl Into<String>) -> SkipReason {
+    SkipReason { construct: inner.construct.clone(), text: text.into() }
+}
+
+impl fmt::Display for SkipReason {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(&self.text)
+    }
+}

data/rust/codegen/src/types.rs

@@ -0,0 +1,362 @@
+//! Type emitters ported from `rust/project/types.rb`: records, entities, value objects and
+//! closed-set tables.
+
+use crate::exemplar::Exemplar;
+use crate::fielded;
+use crate::json::Json;
+use crate::naming;
+use std::collections::HashMap;
+
+pub fn emit_check_invariants(exemplar: &Exemplar, vo: &Json, value_objects_by_name: &HashMap<String, &Json>, aggregates_by_name: &HashMap<String, &Json>) -> String {
+    let name = naming::rust_ident(vo.get("name").and_then(Json::as_str).unwrap_or(""));
+    let type_name = vo.get("name").and_then(Json::as_str).unwrap_or("").to_string();
+    let invariants = vo.get("invariants").map(Json::each).unwrap_or(&[]);
+
+    // The block is flush left to match the Ruby heredoc's dedent; re-indenting it mismatches.
+    // Order: nested value objects, then `admits`/`pattern`, then invariants.
+    let mut body: Vec<String> = Vec::new();
+    let attributes = vo.get("attributes").map(Json::each).unwrap_or(&[]);
+
+    for attr in attributes {
+        if naming::effective_scalar_type(crate::attr::type_name(attr)).is_some() {
+            continue;
+        }
+        let is_plain_nested = matches!(value_objects_by_name.get(crate::attr::type_name(attr)), Some(v) if !v.get("closed_set").map(Json::as_bool).unwrap_or(false));
+        if !is_plain_nested {
+            continue;
+        }
+        let field = naming::rust_ident_field(crate::attr::name(attr));
+        if crate::attr::list(attr) {
+            body.push(format!("        for item in &self.{field} {{ item.check_invariants()?; }}"));
+        } else {
+            body.push(format!("        self.{field}.check_invariants()?;"));
+        }
+    }
+
+    for attr in attributes {
+        if crate::attr::list(attr) {
+            continue;
+        }
+        let field = format!("self.{}", naming::rust_ident_field(crate::attr::name(attr)));
+        if let Some(line) = crate::constraints::emit_admits_check(exemplar, &field, attr, aggregates_by_name, value_objects_by_name) {
+            body.push(format!("        {line}"));
+        }
+        if let Some(line) = crate::constraints::emit_pattern_check(exemplar, &field, attr, &name, value_objects_by_name) {
+            body.push(format!("        {line}"));
+        }
+    }
+
+    let invariant_lines: Vec<String> = invariants
+        .iter()
+        .map(|inv| {
+            let ast = inv.get("ast").unwrap_or_else(|| panic!("invariant row has no ast: {inv:?}"));
+            let description = inv.get("description").and_then(Json::as_str).unwrap_or("");
+            let expr = crate::expr_emitter::emit_ast(ast);
+            format!(
+                "{{\n    let ctx = crate::kernel::EvalContext {{ args: &crate::kernel::NoFields, instance: self }};\n    if !crate::kernel::interpret(&{expr}, &ctx)?.truthy() {{\n        let mut offered = self.to_json();\n        if let crate::kernel::Json::Object(fields) = &mut offered {{\n            fields.sort_by(|a, b| a.0.cmp(&b.0));\n        }}\n        let offered = offered.to_json_string();\n        return Err(crate::kernel::Refusal::InvariantViolation(crate::kernel::refusal_wording::InvariantViolationValueObjectInvariantArgs {{\n            name: {},\n            description: {},\n            offered: offered.as_str(),\n        }}.render_args()));\n    }}\n}}",
+                naming::ruby_inspect_string(&type_name),
+                naming::ruby_inspect_string(description),
+            )
+        })
+        .collect();
+    body.extend(invariant_lines);
+
+    format!("impl {name} {{\n    pub fn check_invariants(&self) -> Result<(), crate::kernel::Refusal> {{\n{}\n        Ok(())\n    }}\n}}\n", body.join("\n"))
+}
+
+pub fn emit_closed_set_table(exemplar: &Exemplar, vo: &Json) -> String {
+    let name = naming::rust_ident(vo.get("name").and_then(Json::as_str).unwrap_or(""));
+    let attributes = vo.get("attributes").map(Json::each).unwrap_or(&[]);
+
+    let field_subs_list: Vec<Vec<(&str, String)>> = attributes
+        .iter()
+        .map(|attr| {
+            let mut ty = naming::rust_type(crate::attr::type_name(attr), crate::attr::list(attr));
+            if ty == "String" {
+                ty = "&'static str".to_string();
+            }
+            vec![("TmplFieldType", ty), ("tmpl_field", naming::rust_ident_field(crate::attr::name(attr)))]
+        })
+        .collect();
+    let struct_part = exemplar.compose("plain_struct", &[("TmplType", name.clone())], "struct_field", &field_subs_list, "\n");
+
+    let members = vo.get("members").map(Json::each).unwrap_or(&[]);
+    let member_literals: Vec<String> = members
+        .iter()
+        .map(|row| {
+            let pairs = row.as_array().unwrap_or(&[]);
+            let present: HashMap<String, &Json> = pairs
+                .iter()
+                .filter_map(|pair| {
+                    let kv = pair.as_array()?;
+                    let key = kv.first()?.as_str()?.to_string();
+                    let val = kv.get(1)?;
+                    Some((key, val))
+                })
+                .collect();
+
+            let fields: Vec<String> = attributes
+                .iter()
+                .map(|attr| {
+                    let field_name = crate::attr::name(attr).to_string();
+                    let raw_str: String = match present.get(&field_name) {
+                        Some(v) => v.to_s(),
+                        None => match crate::attr::default(attr) {
+                            Some(d) => d.to_s(),
+                            None => String::new(),
+                        },
+                    };
+                    let literal = match crate::attr::type_name(attr) {
+                        "Integer" => ruby_to_i(&raw_str).to_string(),
+                        "Float" => format!("{}f64", ruby_to_f(&raw_str)),
+                        _ => naming::ruby_inspect_string(&raw_str),
+                    };
+                    exemplar.render("closed_set_table_row_field", &[("tmpl_field", naming::rust_ident_field(&field_name)), ("tmpl_value_placeholder()", literal)])
+                })
+                .collect();
+            format!("    {name} {{ {} }},", fields.join(", "))
+        })
+        .collect();
+
+    format!("{struct_part}\n\npub const {}: &[{name}] = &[\n{}\n];", naming::screaming_snake(vo.get("name").and_then(Json::as_str).unwrap_or("")), member_literals.join("\n"))
+}
+
+/// Ruby's `String#to_i`: parses a leading integer prefix, 0 when there is none.
+fn ruby_to_i(s: &str) -> i64 {
+    let trimmed = s.trim_start();
+    let mut end = 0;
+    let bytes = trimmed.as_bytes();
+    if end < bytes.len() && (bytes[end] == b'-' || bytes[end] == b'+') {
+        end += 1;
+    }
+    let digits_start = end;
+    while end < bytes.len() && bytes[end].is_ascii_digit() {
+        end += 1;
+    }
+    if end == digits_start {
+        return 0;
+    }
+    trimmed[..end].parse().unwrap_or(0)
+}
+
+/// Ruby's `String#to_f`: parses a leading float prefix, 0.0 when there is none.
+fn ruby_to_f(s: &str) -> f64 {
+    let trimmed = s.trim_start();
+    let mut end = 0;
+    let bytes = trimmed.as_bytes();
+    if end < bytes.len() && (bytes[end] == b'-' || bytes[end] == b'+') {
+        end += 1;
+    }
+    let mut seen_digit = false;
+    while end < bytes.len() && bytes[end].is_ascii_digit() {
+        end += 1;
+        seen_digit = true;
+    }
+    if end < bytes.len() && bytes[end] == b'.' {
+        let mut peek = end + 1;
+        let mut frac_digit = false;
+        while peek < bytes.len() && bytes[peek].is_ascii_digit() {
+            peek += 1;
+            frac_digit = true;
+        }
+        if frac_digit {
+            end = peek;
+            seen_digit = true;
+        }
+    }
+    if !seen_digit {
+        return 0.0;
+    }
+    trimmed[..end].parse().unwrap_or(0.0)
+}
+
+pub fn emit_value_object(exemplar: &Exemplar, vo: &Json, value_objects_by_name: &HashMap<String, &Json>, aggregates_by_name: &HashMap<String, &Json>) -> String {
+    let name = naming::rust_ident(vo.get("name").and_then(Json::as_str).unwrap_or(""));
+    let closed_set = vo.get("closed_set").map(Json::as_bool).unwrap_or(false);
+    let attributes = vo.get("attributes").map(Json::each).unwrap_or(&[]);
+
+    if closed_set {
+        if attributes.len() > 1 {
+            return emit_closed_set_table(exemplar, vo);
+        }
+
+        let members = vo.get("members").map(Json::each).unwrap_or(&[]);
+        let variants: Vec<String> = members
+            .iter()
+            .map(|row| {
+                let pairs = row.as_array().unwrap_or(&[]);
+                let first = pairs.first().and_then(Json::as_array).unwrap_or(&[]);
+                let value = first.get(1).map(Json::to_s).unwrap_or_default();
+                naming::closed_set_variant(&value)
+            })
+            .collect();
+        let field_subs_list: Vec<Vec<(&str, String)>> = variants.iter().map(|v| vec![("TmplMemberA", v.clone())]).collect();
+        let enum_part = exemplar.compose("closed_set_enum", &[("TmplKind", name)], "closed_set_enum:VARIANT", &field_subs_list, "\n");
+        return format!("{enum_part}\n\n{}", naming::emit_closed_set_fielded_impl(vo));
+    }
+
+    let field_subs_list: Vec<Vec<(&str, String)>> = attributes
+        .iter()
+        .map(|attr| {
+            let mut ty = naming::rust_type(crate::attr::type_name(attr), crate::attr::list(attr));
+            if crate::attr::optional(attr) {
+                ty = format!("Option<{ty}>");
+            }
+            vec![("TmplFieldType", ty), ("tmpl_field", naming::rust_ident_field(crate::attr::name(attr)))]
+        })
+        .collect();
+    let struct_part = exemplar.compose("plain_struct", &[("TmplType", name.clone())], "struct_field", &field_subs_list, "\n");
+
+    let fielded_part = fielded::emit_fielded_flat(exemplar, &name, attributes, value_objects_by_name, &[]);
+    let invariants_part = emit_check_invariants(exemplar, vo, value_objects_by_name, aggregates_by_name);
+
+    format!("{struct_part}\n\n{fielded_part}\n\n{invariants_part}")
+}
+
+/// Attribute type names on `aggregate` that have no Rust mapping.
+pub fn unsupported_attribute_types(aggregate: &Json, value_objects_by_name: &HashMap<String, &Json>) -> Vec<String> {
+    let entity_names: Vec<&str> = aggregate.get("entities").map(Json::each).unwrap_or(&[]).iter().map(|e| e.get("name").and_then(Json::as_str).unwrap_or("")).collect();
+    let mut seen = Vec::new();
+    for attr in aggregate.get("attributes").map(Json::each).unwrap_or(&[]) {
+        let ty = crate::attr::type_name(attr);
+        let supported = naming::effective_scalar_type(ty).is_some() || value_objects_by_name.contains_key(ty) || (crate::attr::list(attr) && entity_names.contains(&ty));
+        if !supported && !seen.iter().any(|s| s == ty) {
+            seen.push(ty.to_string());
+        }
+    }
+    seen
+}
+
+pub fn emit_entity(exemplar: &Exemplar, entity: &Json, value_objects_by_name: &HashMap<String, &Json>) -> String {
+    let name = naming::rust_ident(entity.get("name").and_then(Json::as_str).unwrap_or(""));
+    let attributes = entity.get("attributes").map(Json::each).unwrap_or(&[]);
+
+    let mut field_subs_list: Vec<Vec<(&str, String)>> = attributes
+        .iter()
+        .map(|attr| {
+            let mut ty = naming::rust_type(crate::attr::type_name(attr), crate::attr::list(attr));
+            if crate::attr::optional(attr) {
+                ty = format!("Option<{ty}>");
+            }
+            vec![("TmplFieldType", ty), ("tmpl_field", naming::rust_ident_field(crate::attr::name(attr)))]
+        })
+        .collect();
+
+    let mut lifecycle_arm: Vec<String> = Vec::new();
+    if let Some(lifecycle) = entity.get("lifecycle") {
+        let field = lifecycle.get("field").and_then(Json::as_str).unwrap_or("");
+        field_subs_list.push(vec![("TmplFieldType", "String".to_string()), ("tmpl_field", naming::rust_ident_field(field))]);
+        let ident = naming::rust_ident_field(field);
+        lifecycle_arm.push(format!("            \"{field}\" => Some(Field::Value(Value::Str(self.{ident}.clone()))),"));
+    }
+
+    let struct_part = exemplar.compose("plain_struct", &[("TmplType", name.clone())], "struct_field", &field_subs_list, "\n");
+    let fielded_part = fielded::emit_fielded_flat(exemplar, &name, attributes, value_objects_by_name, &lifecycle_arm);
+
+    format!("{struct_part}\n\n{fielded_part}")
+}
+
+pub fn emit_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 field_subs_list: Vec<Vec<(&str, String)>> = attributes
+        .iter()
+        .map(|attr| {
+            let list = crate::attr::list(attr);
+            let mut ty = naming::rust_type(crate::attr::type_name(attr), list);
+            if !list || crate::shared::list_attr_creation_optional(aggregate, crate::attr::name(attr), value_objects_by_name) {
+                ty = format!("Option<{ty}>");
+            }
+            vec![("TmplFieldType", ty), ("tmpl_field", naming::rust_ident_field(crate::attr::name(attr)))]
+        })
+        .collect();
+
+    if let Some(lifecycle) = aggregate.get("lifecycle") {
+        let field = lifecycle.get("field").and_then(Json::as_str).unwrap_or("");
+        field_subs_list.push(vec![("TmplFieldType", "String".to_string()), ("tmpl_field", naming::rust_ident_field(field))]);
+    }
+    for ev in crate::bridging::correctable_event_names(aggregate) {
+        field_subs_list.push(vec![("TmplFieldType", "bool".to_string()), ("tmpl_field", crate::bridging::corrects_flag_field(&ev))]);
+    }
+
+    let struct_part = exemplar.compose("plain_struct", &[("TmplType", name)], "struct_field", &field_subs_list, "\n");
+    let fielded_part = fielded::emit_fielded_record(exemplar, aggregate, value_objects_by_name);
+
+    format!("{struct_part}\n\n{fielded_part}")
+}
+
+/// Port of `rust/project/types.rb#projected_field_pseudo_attributes` (ADR 0025).
+pub fn projected_field_pseudo_attributes(aggregate: &Json) -> Vec<Json> {
+    aggregate
+        .get("projected_fields")
+        .map(Json::each)
+        .unwrap_or(&[])
+        .iter()
+        .map(|field| {
+            let name = field.get("name").and_then(Json::as_str).unwrap_or("").to_string();
+            Json::Object(vec![
+                ("name".to_string(), Json::String(name)),
+                ("type".to_string(), Json::String("String".to_string())),
+                ("list".to_string(), Json::Bool(false)),
+                ("optional".to_string(), Json::Bool(true)),
+            ])
+        })
+        .collect()
+}
+
+/// Copy of `aggregate` whose `attributes` also list the projected-field pseudo-attributes, so
+/// `emit_record` and `emit_fielded_record` see them (`domain_generator.rb#record_for_struct`).
+pub fn with_projected_field_pseudo_attributes(aggregate: &Json) -> Json {
+    let mut attributes: Vec<Json> = aggregate.get("attributes").map(Json::each).unwrap_or(&[]).to_vec();
+    attributes.extend(projected_field_pseudo_attributes(aggregate));
+    let mut pairs: Vec<(String, Json)> = match aggregate {
+        Json::Object(pairs) => pairs.iter().filter(|(k, _)| k != "attributes").cloned().collect(),
+        _ => Vec::new(),
+    };
+    pairs.push(("attributes".to_string(), Json::Array(attributes)));
+    Json::Object(pairs)
+}
+
+/// Port of `rust/project/types.rb#emit_set_projected_field`.
+pub fn emit_set_projected_field(aggregate: &Json) -> String {
+    let name = naming::rust_ident(aggregate.get("name").and_then(Json::as_str).unwrap_or(""));
+    let arms: Vec<String> = aggregate
+        .get("projected_fields")
+        .map(Json::each)
+        .unwrap_or(&[])
+        .iter()
+        .map(|field| {
+            let field_name = field.get("name").and_then(Json::as_str).unwrap_or("");
+            let ident = naming::rust_ident_field(field_name);
+            format!("            {} => self.{} = value,", naming::ruby_inspect_string(field_name), ident)
+        })
+        .collect();
+    format!(
+        "impl crate::kernel::SetProjectedField for {name} {{\n    fn set_projected_field(&mut self, name: &'static str, value: Option<String>) {{\n        match name {{\n{}\n            _ => {{}}\n        }}\n    }}\n}}\n",
+        arms.join("\n")
+    )
+}
+
+/// Port of `rust/project/types.rb#emit_projected_field_table`.
+pub fn emit_projected_field_table(aggregate: &Json) -> String {
+    let name = naming::screaming_snake(aggregate.get("name").and_then(Json::as_str).unwrap_or(""));
+    let rows: Vec<String> = aggregate
+        .get("projected_fields")
+        .map(Json::each)
+        .unwrap_or(&[])
+        .iter()
+        .map(|field| {
+            let field_name = field.get("name").and_then(Json::as_str).unwrap_or("");
+            let reference = field.get("reference").and_then(Json::as_str).unwrap_or("");
+            let remote_field = field.get("remote_field").and_then(Json::as_str).unwrap_or("");
+            format!(
+                "    crate::kernel::ProjectedFieldSpec {{ field: {}, reference: {}, remote_field: {} }},",
+                naming::ruby_inspect_string(field_name),
+                naming::ruby_inspect_string(reference),
+                naming::ruby_inspect_string(remote_field)
+            )
+        })
+        .collect();
+    format!("pub static {name}_PROJECTED_FIELDS: &[crate::kernel::ProjectedFieldSpec] = &[\n{}\n];\n", rows.join("\n"))
+}

data/rust/host/.cargo/config.toml

@@ -0,0 +1,3 @@
+# Link with lld. Postgres goes over rustls, so no native TLS library is involved.
+[target.x86_64-unknown-linux-gnu]
+rustflags = ["-C", "link-arg=-fuse-ld=lld"]

data/rust/host/.gitignore

@@ -0,0 +1 @@
+/target