hecks 5.0.0 → 7.0.0

data/rust/codegen/src/registry.rs

@@ -12,6 +12,13 @@ pub struct ReferenceCheck {
     pub optional: bool,
     /// `Some(element key expression)` for a list (`has_many`) check.
     pub list_item: Option<String>,
+    /// `Some(variant)` for a tagged `one_of` reference: the check runs only when the argument's
+    /// `type` names this variant (ADR 0127).
+    pub union_tag: Option<String>,
+    /// True for a reference a command sets through a plain value object: Ruby checks it on the
+    /// settled state at `save`, after hydrate, givens and invariants, so the router defers it
+    /// to `Save` beside the tenant boundary instead of running it with the argument gates.
+    pub settled: bool,
     pub target_mod: String,
     pub target_name: String,
     pub heads: String,
@@ -47,6 +54,8 @@ pub struct CommandEntry {
     /// role and reference checks. `commands.rs::emit_command` repeats them in the dispatch fn.
     pub invariant_check_lines: Vec<String>,
     pub role: Option<String>,
+    /// Every role that may run the command, when more than one may; `role` is then the first.
+    pub roles: Vec<String>,
 }
 
 pub struct EntityCommandEntry {
@@ -62,6 +71,8 @@ pub struct EntityCommandEntry {
     /// See `CommandEntry::invariant_check_lines`.
     pub invariant_check_lines: Vec<String>,
     pub role: Option<String>,
+    /// Every role that may run the command, when more than one may; `role` is then the first.
+    pub roles: Vec<String>,
     /// Carried for shape parity with `domain_generator.rb`'s `entity_commands`; unread here.
     pub entity_name: String,
     pub entity_identity_reading: String,
@@ -80,6 +91,8 @@ pub struct NestedEntityCommandEntry {
     pub reference_specs: Vec<ReferenceSpec>,
     pub invariant_check_lines: Vec<String>,
     pub role: Option<String>,
+    /// Every role that may run the command, when more than one may; `role` is then the first.
+    pub roles: Vec<String>,
     pub entity_name: String,
     pub entity_identity_reading: String,
     pub nested_name: String,
@@ -115,7 +128,7 @@ pub struct AggregateEntry {
     pub entity_commands: Vec<EntityCommandEntry>,
     pub nested_entity_commands: Vec<NestedEntityCommandEntry>,
     pub ports: Vec<PortEntry>,
-    pub chapter_mod: String,
+    pub bluebook_mod: String,
     pub domain_name: String,
     /// Reference-typed attributes; this aggregate's row in `REFERENCE_TABLE`.
     pub reference_specs: Vec<ReferenceSpec>,
@@ -125,11 +138,30 @@ pub struct AggregateEntry {
     pub entities: Vec<EntityIdentityEntry>,
 }
 
+/// The call that refuses a caller who may not run the command: against its one `role`, or, when
+/// `roles` lists several, against all of them at once (any one lets the caller through).
 pub fn emit_role_check(
     exemplar: &Exemplar,
     role: Option<&str>,
+    roles: &[String],
     command_name: &str,
 ) -> Option<String> {
+    if roles.len() > 1 {
+        let listed: Vec<String> = roles
+            .iter()
+            .map(|r| naming::ruby_inspect_string(r))
+            .collect();
+        return Some(exemplar.render(
+            "role_check_any",
+            &[
+                ("\"TmplRoles\"", listed.join(", ")),
+                (
+                    "\"TmplCommandName\"",
+                    naming::ruby_inspect_string(command_name),
+                ),
+            ],
+        ));
+    }
     let role = role?;
     Some(exemplar.render(
         "role_check",
@@ -260,6 +292,28 @@ fn squeeze(text: &str) -> String {
 
 pub fn emit_reference_check(exemplar: &Exemplar, check: &ReferenceCheck) -> String {
     let ident = naming::rust_ident_field(&check.field);
+    if check.union_tag.is_some() {
+        let (shape, slot) = if check.optional {
+            (
+                "reference_check_one_of_optional",
+                "tmpl_union_optional_field",
+            )
+        } else {
+            ("reference_check_one_of", "tmpl_union_field")
+        };
+        return exemplar.render(
+            shape,
+            &[
+                (
+                    "\"TmplTarget\"",
+                    naming::ruby_inspect_string(&check.target_name),
+                ),
+                ("\"tmpl_heads\"", naming::ruby_inspect_string(&check.heads)),
+                ("tmpl_target_mod", check.target_mod.clone()),
+                (slot, ident),
+            ],
+        );
+    }
     if let Some(list_item) = &check.list_item {
         exemplar.render(
             "reference_check_list",
@@ -303,8 +357,8 @@ pub fn emit_reference_check(exemplar: &Exemplar, check: &ReferenceCheck) -> Stri
     }
 }
 
-fn chapter_path(a: &AggregateEntry) -> String {
-    format!("crate::generated::{}::{}", a.chapter_mod, a.module_name)
+fn bluebook_path(a: &AggregateEntry) -> String {
+    format!("crate::generated::{}::{}", a.bluebook_mod, a.module_name)
 }
 
 /// One `"verb" => { .. }` arm of the registry's dispatch match, its body lines indented.
@@ -326,7 +380,7 @@ pub fn emit_registry(exemplar: &Exemplar, aggregates: &[AggregateEntry]) -> Stri
             format!(
                 "    pub {}: crate::kernel::InMemoryRepository<{}::{}>,",
                 a.module_name,
-                chapter_path(a),
+                bluebook_path(a),
                 a.record
             )
         })
@@ -356,7 +410,7 @@ pub fn emit_registry(exemplar: &Exemplar, aggregates: &[AggregateEntry]) -> Stri
     let seed_arms: Vec<String> = aggregates
         .iter()
         .map(|a| {
-            let mod_path = chapter_path(a);
+            let mod_path = bluebook_path(a);
             let prefix = format!("{}::{}#", a.domain_name, a.name);
             format!(
                 "if let Some(id) = key.strip_prefix({}) {{\n    store.{}.save(id, {mod_path}::{}::from_json(value)?);\n    continue;\n}}",
@@ -393,7 +447,7 @@ pub fn emit_registry(exemplar: &Exemplar, aggregates: &[AggregateEntry]) -> Stri
 
     let mut aggregate_arms: Vec<String> = Vec::new();
     for a in aggregates {
-        let mod_path = chapter_path(a);
+        let mod_path = bluebook_path(a);
         for c in &a.commands {
             let extra_names = &c.identity_extra_params;
             let extra_idents: Vec<String> = extra_names
@@ -456,9 +510,10 @@ pub fn emit_registry(exemplar: &Exemplar, aggregates: &[AggregateEntry]) -> Stri
                 emit_argument_gates_literal(
                     &format!("{mod_path}::{}", c.args_struct),
                     &c.invariant_check_lines,
-                    emit_role_check(exemplar, c.role.as_deref(), &c.name),
+                    emit_role_check(exemplar, c.role.as_deref(), &c.roles, &c.name),
                     &c.reference_checks
                         .iter()
+                        .filter(|check| !check.settled)
                         .map(|check| emit_reference_check(exemplar, check))
                         .collect::<Vec<_>>()
                 )
@@ -471,9 +526,15 @@ pub fn emit_registry(exemplar: &Exemplar, aggregates: &[AggregateEntry]) -> Stri
 
             // Checks come from `ir.json` at codegen time; none means `Ok(())`, else one closure.
             let tenant_boundary_check_bodies: Vec<String> = c
-                .tenant_boundary_checks
+                .reference_checks
                 .iter()
-                .map(emit_tenant_boundary_check)
+                .filter(|check| check.settled)
+                .map(|check| emit_reference_check(exemplar, check))
+                .chain(
+                    c.tenant_boundary_checks
+                        .iter()
+                        .map(emit_tenant_boundary_check),
+                )
                 .collect();
             let tenant_boundary_check_line = if tenant_boundary_check_bodies.is_empty() {
                 "let tenant_boundary_check: Result<(), crate::kernel::Refusal> = Ok(());"
@@ -531,7 +592,7 @@ pub fn emit_registry(exemplar: &Exemplar, aggregates: &[AggregateEntry]) -> Stri
 
     let mut entity_arms: Vec<String> = Vec::new();
     for a in aggregates {
-        let mod_path = chapter_path(a);
+        let mod_path = bluebook_path(a);
         for c in &a.entity_commands {
             // The argument gates; `kernel::decode_entity_arguments` walks `EntityStep::ORDER`.
             let gates_line = format!(
@@ -539,7 +600,7 @@ pub fn emit_registry(exemplar: &Exemplar, aggregates: &[AggregateEntry]) -> Stri
                 emit_argument_gates_literal(
                     &format!("{mod_path}::{}", c.args_struct),
                     &c.invariant_check_lines,
-                    emit_role_check(exemplar, c.role.as_deref(), &c.name),
+                    emit_role_check(exemplar, c.role.as_deref(), &c.roles, &c.name),
                     &c.reference_checks
                         .iter()
                         .map(|check| emit_reference_check(exemplar, check))
@@ -566,14 +627,19 @@ pub fn emit_registry(exemplar: &Exemplar, aggregates: &[AggregateEntry]) -> Stri
                 c.name, c.entity_name, c.entity_identity_reading
             );
             // `element_id` uses `extract_id_lenient` (absent vs blank element identity);
-            // `parent_id` stays strict.
+            // `parent_id` stays strict. An element identity the arguments lack refuses as the
+            // missing parent when there is none, since Ruby hydrates the parent before it
+            // locates the element.
             let body_entity_match = format!(
-                "let (parent_id, element_id, element_wants) = match route {{ Some(route) => {{ let element_id = route.entities()[0].clone(); (route.aggregate().to_string(), element_id.clone(), element_id) }}, None => {{ let parent_id = {mod_path}::{}::extract_id(facts_json).map_err(|_| crate::kernel::Refusal::NotFound({}.to_string()))?; let element_id = {mod_path}::{}::extract_id_lenient(facts_json).map_err(|_| crate::kernel::Refusal::NotFound({}.to_string()))?; let element_wants = {mod_path}::{}::extract_wants(facts_json); (parent_id, element_id, element_wants) }}, }};",
+                "let (parent_id, element_id, element_wants) = match route {{ Some(route) => {{ let element_id = route.entities()[0].clone(); (route.aggregate().to_string(), element_id.clone(), element_id) }}, None => {{ let parent_id = {mod_path}::{}::extract_id(facts_json).map_err(|_| crate::kernel::Refusal::NotFound({}.to_string()))?; let element_id = {mod_path}::{}::extract_id_lenient(facts_json).map_err(|_| {{ if store.{module}.find(&parent_id).is_none() {{ crate::kernel::Refusal::NotFound(crate::kernel::refusal_wording::NotFoundRecordMissingArgs {{ aggregate: {record_name}, identity: {identity_reading}, offered: &format!(\"{{parent_id:?}}\") }}.render_args()) }} else {{ crate::kernel::Refusal::NotFound({}.to_string()) }} }})?; let element_wants = {mod_path}::{}::extract_wants(facts_json); (parent_id, element_id, element_wants) }}, }};",
                 a.record,
                 naming::ruby_inspect_string(&entity_parent_no_identity_message),
                 c.entity_record,
                 naming::ruby_inspect_string(&entity_element_no_identity_message),
-                c.entity_record
+                c.entity_record,
+                module = a.module_name,
+                record_name = naming::ruby_inspect_string(&a.record),
+                identity_reading = naming::ruby_inspect_string(&a.identified_by.join(", ")),
             );
 
             let mut body: Vec<String> = vec![
@@ -614,7 +680,7 @@ pub fn emit_registry(exemplar: &Exemplar, aggregates: &[AggregateEntry]) -> Stri
     // that accepts a route or flat args; otherwise the command is routed-only.
     let mut nested_entity_arms: Vec<String> = Vec::new();
     for a in aggregates {
-        let mod_path = chapter_path(a);
+        let mod_path = bluebook_path(a);
         for c in &a.nested_entity_commands {
             // The argument gates; see the entity arm's `gates_line`.
             let gates_line = format!(
@@ -622,7 +688,7 @@ pub fn emit_registry(exemplar: &Exemplar, aggregates: &[AggregateEntry]) -> Stri
                 emit_argument_gates_literal(
                     &format!("{mod_path}::{}", c.args_struct),
                     &c.invariant_check_lines,
-                    emit_role_check(exemplar, c.role.as_deref(), &c.name),
+                    emit_role_check(exemplar, c.role.as_deref(), &c.roles, &c.name),
                     &c.reference_checks
                         .iter()
                         .map(|check| emit_reference_check(exemplar, check))
@@ -707,7 +773,7 @@ pub fn emit_registry(exemplar: &Exemplar, aggregates: &[AggregateEntry]) -> Stri
 
     let mut port_arms: Vec<String> = Vec::new();
     for a in aggregates {
-        let mod_path = chapter_path(a);
+        let mod_path = bluebook_path(a);
         for p in &a.ports {
             let reference_lines: Vec<String> = p
                 .reference_checks
@@ -828,6 +894,25 @@ pub fn emit_reference_lookup(aggregates: &[AggregateEntry]) -> String {
 mod tests {
     use super::*;
 
+    #[test]
+    fn a_command_with_one_role_checks_that_role_and_one_with_several_checks_any_of_them() {
+        let exemplar = crate::exemplar::Exemplar::load();
+        let one = emit_role_check(&exemplar, Some("Chef"), &[], "AddTopping").unwrap_or_default();
+        assert!(
+            one.contains("check_role_via(Some(\"Chef\"), \"AddTopping\""),
+            "{one}"
+        );
+
+        let roles = vec!["Customer".to_string(), "Sales Rep".to_string()];
+        let any = emit_role_check(&exemplar, Some("Customer"), &roles, "Open").unwrap_or_default();
+        assert!(
+            any.contains("check_roles_via(&[\"Customer\", \"Sales Rep\"], \"Open\""),
+            "{any}"
+        );
+
+        assert!(emit_role_check(&exemplar, None, &[], "Open").is_none());
+    }
+
     #[test]
     fn generated_router_separates_routes_and_supports_compound_create_facts() {
         let aggregate = AggregateEntry {
@@ -851,6 +936,7 @@ mod tests {
                     attributes: Vec::new(),
                     invariant_check_lines: Vec::new(),
                     role: None,
+                    roles: Vec::new(),
                 },
                 CommandEntry {
                     verb: "Banking::SafeDepositBox.Close".to_string(),
@@ -865,6 +951,7 @@ mod tests {
                     attributes: Vec::new(),
                     invariant_check_lines: Vec::new(),
                     role: None,
+                    roles: Vec::new(),
                 },
             ],
             entity_commands: vec![EntityCommandEntry {
@@ -878,6 +965,7 @@ mod tests {
                 attributes: Vec::new(),
                 invariant_check_lines: Vec::new(),
                 role: None,
+                roles: Vec::new(),
                 entity_name: "Visit".to_string(),
                 entity_identity_reading: "date, sequence".to_string(),
             }],
@@ -890,7 +978,7 @@ mod tests {
                 legacy_receiver_field: None,
                 to_receiver_field: None,
             }],
-            chapter_mod: "banking".to_string(),
+            bluebook_mod: "banking".to_string(),
             domain_name: "Banking".to_string(),
             reference_specs: Vec::new(),
             identified_by: vec!["branch_code".to_string(), "box_number".to_string()],
@@ -950,11 +1038,12 @@ mod tests {
                 attributes: vec!["priority".to_string()],
                 invariant_check_lines: Vec::new(),
                 role: None,
+                roles: Vec::new(),
             }],
             entity_commands: Vec::new(),
             nested_entity_commands: Vec::new(),
             ports: Vec::new(),
-            chapter_mod: "fixture".to_string(),
+            bluebook_mod: "fixture".to_string(),
             domain_name: "Fixture".to_string(),
             reference_specs: Vec::new(),
             identified_by: vec!["code".to_string()],
@@ -989,11 +1078,12 @@ mod tests {
                 attributes: Vec::new(),
                 invariant_check_lines: Vec::new(),
                 role: None,
+                roles: Vec::new(),
             }],
             entity_commands: Vec::new(),
             nested_entity_commands: Vec::new(),
             ports: Vec::new(),
-            chapter_mod: "banking".to_string(),
+            bluebook_mod: "banking".to_string(),
             domain_name: "Banking".to_string(),
             reference_specs: Vec::new(),
             identified_by: vec![

data/rust/codegen/src/sidecars.rs

@@ -1,4 +1,4 @@
-//! Writes each chapter's `ir.json` and `metadata.rs` sidecars, from the IR as generated (marked).
+//! Writes each bluebook's `ir.json` and `metadata.rs` sidecars, from the IR as generated (marked).
 
 use crate::json::{self, Json};
 use std::fmt::Write as _;

data/rust/expr/Cargo.lock

@@ -0,0 +1,54 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "aho-corasick"
+version = "1.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c982642fa9e8606056828ee9a8505737230110bb1099153c79efe865c59d12ba"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "hecks_expr"
+version = "0.1.0"
+dependencies = [
+ "regex",
+]
+
+[[package]]
+name = "memchr"
+version = "2.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98"
+
+[[package]]
+name = "regex"
+version = "1.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f020237b6c8eed93db2e2cb53c00c60a8e1bc73da7d073199a1180401450218d"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-automata",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.4.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ad8553b9b26413251cbf30e620595c7a41b3887f03da04579c0e6b0d6a06b4b2"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.8.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4"

data/rust/expr/Cargo.toml

@@ -0,0 +1,52 @@
+[package]
+name = "hecks_expr"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+name = "hecks_expr"
+path = "src/lib.rs"
+
+# The expression evaluator: `Expr`, `Value`, the operators and shapes it dispatches to, and the
+# `Refusal` it fails with. One copy, shared by the kernel (compiled into every domain's wasm) and
+# the host. std-only apart from `regex`, which `expression_operators/pattern_match.rs` needs for
+# `.match?` (ADR 0012's one dependency exception); `default-features = false` keeps out the SIMD
+# `perf` feature.
+[dependencies]
+regex = { version = "1", default-features = false, features = ["std", "unicode"] }
+
+# Clippy beyond its defaults: pedantic and nursery, plus the restriction lints that keep a panic
+# out of library code. `hecks gate_run.gate! stage=ci only=rust_clippy` makes each of these an error.
+# The same table is in every crate's Cargo.toml; change them together.
+[lints.clippy]
+pedantic = { level = "warn", priority = -1 }
+nursery = { level = "warn", priority = -1 }
+unwrap_used = "warn"
+expect_used = "warn"
+panic = "warn"
+dbg_macro = "warn"
+todo = "warn"
+unimplemented = "warn"
+# Lints that ask for prose or an attribute on every item rather than for better code.
+missing_errors_doc = "allow"
+missing_panics_doc = "allow"
+must_use_candidate = "allow"
+return_self_not_must_use = "allow"
+module_name_repetitions = "allow"
+too_many_lines = "allow"
+too_long_first_doc_paragraph = "allow"
+doc_markdown = "allow"
+# Numeric conversions here are deliberate: JSON numbers are f64 and ids are small.
+cast_possible_truncation = "allow"
+cast_possible_wrap = "allow"
+cast_precision_loss = "allow"
+cast_sign_loss = "allow"
+# Naming heuristics that fire on ordinary short names.
+similar_names = "allow"
+many_single_char_names = "allow"
+struct_field_names = "allow"
+# Heuristics that cost more clarity than they buy here.
+redundant_pub_crate = "allow"
+future_not_send = "allow"
+significant_drop_tightening = "allow"
+match_same_arms = "allow"

data/rust/{src/kernel → expr/src}/attribute_shapes/composite.rs

@@ -1,25 +1,45 @@
 // The `:composite` shape of `Runtime::Value::Coercion::SHAPES`: per-segment dotted-path walking.
 
-use crate::kernel::expr::{eval_error, Field, Value};
-use crate::kernel::Refusal;
+use crate::expr::{eval_error, Field, Value};
+use crate::rendering;
+use crate::Refusal;
 
-/// A scalar (or `Nil`) with segments left resolves to `Nil`, like Ruby's `walk_path`.
-/// This makes `flag.nil?` read as a value instead of a refusal.
+/// Ruby's `Resolver.walk_path`, one segment at a time. A nested object reads the field; a string
+/// answers the segment when it is a substring (`String#[]`), else nil; a list or an integer cannot
+/// be indexed by name and refuses; nil, floats and booleans end the walk in nil, which is what makes
+/// `flag.nil?` read as a value instead of a refusal.
 pub fn step<'a>(current: &Field<'a>, seg: &str, head: &str) -> Result<Field<'a>, Refusal> {
     match current {
         Field::Nested(obj) => (*obj)
             .field(seg)
             .ok_or_else(|| eval_error(format!("cannot resolve {seg:?} on {head:?}"))),
-        Field::Value(_) => Ok(Field::Value(Value::Nil)),
+        Field::Value(v) => step_value(v, seg),
     }
 }
 
-/// A path may end on a nested object only if it collapses via `Fielded::as_scalar`.
+fn step_value<'a>(value: &Value, seg: &str) -> Result<Field<'a>, Refusal> {
+    match value {
+        Value::Str(text) if text.contains(seg) => Ok(Field::Value(Value::Str(seg.to_string()))),
+        Value::Str(_) | Value::Nil | Value::Float(_) | Value::Bool(_) => {
+            Ok(Field::Value(Value::Nil))
+        }
+        Value::Object(fields) => Ok(Field::Value(fields.get(seg).cloned().unwrap_or(Value::Nil))),
+        Value::Int(_) | Value::List(_) | Value::Array(_) => Err(eval_error(format!(
+            "cannot read {} from {}",
+            rendering::ruby_inspect(seg),
+            rendering::describe(value)
+        ))),
+    }
+}
+
+/// A path may end on a nested object only if it collapses via `Fielded::as_scalar` (or reads as an
+/// object value through `Fielded::to_value`).
 pub fn finish(current: Field<'_>, path: &str) -> Result<Value, Refusal> {
     match current {
         Field::Value(v) => Ok(v),
         Field::Nested(obj) => obj
             .as_scalar()
+            .or_else(|| obj.to_value())
             .ok_or_else(|| eval_error(format!("{path} resolved to an object, not a scalar"))),
     }
 }
@@ -27,7 +47,7 @@ pub fn finish(current: Field<'_>, path: &str) -> Result<Value, Refusal> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::kernel::expr::Fielded;
+    use crate::expr::Fielded;
 
     // Hand-built stand-in for a generated composite's `Fielded` impl.
     struct Customer {
@@ -73,13 +93,8 @@ mod tests {
     }
 
     #[test]
-    fn this_holds_for_every_scalar_shape_not_just_bool() {
-        for value in [
-            Value::Int(0),
-            Value::Float(1.5),
-            Value::Str("x".to_string()),
-            Value::List(3),
-        ] {
+    fn floats_strings_without_the_segment_and_nil_end_the_walk_in_nil() {
+        for value in [Value::Float(1.5), Value::Str("x".to_string()), Value::Nil] {
             assert_eq!(
                 stepped_value(&Field::Value(value.clone()), "nil?", "head"),
                 Value::Nil,
@@ -88,6 +103,22 @@ mod tests {
         }
     }
 
+    #[test]
+    fn a_string_answers_a_segment_it_contains_as_ruby_string_index_does() {
+        assert_eq!(
+            stepped_value(&Field::Value(Value::Str("abc".to_string())), "bc", "head"),
+            Value::Str("bc".to_string())
+        );
+    }
+
+    #[test]
+    fn an_integer_or_a_list_cannot_be_read_by_name_and_refuses() {
+        for value in [Value::Int(0), Value::List(3), Value::Array(vec![])] {
+            let stepped = step(&Field::Value(value.clone()), "nil?", "head");
+            assert!(stepped.is_err(), "expected a refusal for {value:?}");
+        }
+    }
+
     #[test]
     fn a_further_segment_on_an_already_nil_value_stays_nil() {
         // An unset optional field already reads as `Nil` before `step` runs.

data/rust/{src/kernel → expr/src}/attribute_shapes/list.rs

@@ -1,7 +1,7 @@
 // The `:list` shape of `Runtime::Value::Coercion::SHAPES`.
 // Expressions see a list as its length only (`Value::List(usize)`): just `size` and `empty?`.
 
-use crate::kernel::expr::Value;
+use crate::expr::Value;
 
 pub const fn is_empty(v: &Value) -> Option<bool> {
     match v {

data/rust/{src/kernel → expr/src}/attribute_shapes/mod.rs

@@ -13,7 +13,7 @@ pub mod scalar;
 
 /// One variant per real attribute shape the Ruby
 /// grammar admits, in the order Coercion::SHAPES declares them. Every match
-/// over this enum in the kernel (rust/src/kernel/expr.rs) is written
+/// over this enum in the kernel (rust/expr/src/expr.rs) is written
 /// WITHOUT a wildcard `_ =>` arm — see expr.rs's own header for why:
 /// a wildcard here would let a newly-admitted capability compile
 /// silently into a router that never calls the new file this same
@@ -27,7 +27,7 @@ pub enum AttributeShape {
 }
 
 impl AttributeShape {
-    /// The `rust/src/kernel/attribute_shapes/<name>.rs` file this
+    /// The `rust/expr/src/attribute_shapes/<name>.rs` file this
     /// variant names — `hecks measure_kernel_coverage`'s own existence
     /// check reads this, so the file-name spelling here is the ONE
     /// place that ever needs to change if a name is renamed.

data/rust/{src/kernel → expr/src}/attribute_shapes/optional.rs

@@ -1,7 +1,7 @@
 // The `:optional` shape of `Runtime::Value::Coercion::SHAPES`.
 // `Value::Nil` covers both an unset `optional:` field and a literal `nil`, as in Ruby.
 
-use crate::kernel::expr::Value;
+use crate::expr::Value;
 
 // `nil.to_s == ""`; `None` for anything but `Value::Nil`.
 pub fn to_s(v: &Value) -> Option<Value> {

data/rust/{src/kernel → expr/src}/attribute_shapes/scalar.rs

@@ -1,7 +1,7 @@
 // The `:scalar` shape of `Runtime::Value::Coercion::SHAPES`: `Value::{Str,Int,Float,Bool}`.
 // `List` and `Nil` belong to the other shapes, so every function here returns `None` for them.
 
-use crate::kernel::expr::Value;
+use crate::expr::Value;
 
 // Mirrors `Resolver.numeric`: `Int` and `Float` mix freely; any other `Value` is not a number.
 pub const fn numeric(v: &Value) -> Option<f64> {
@@ -17,9 +17,9 @@ pub fn to_s(v: &Value) -> Option<Value> {
     match v {
         Value::Str(s) => Some(Value::Str(s.clone())),
         Value::Int(i) => Some(Value::Str(i.to_string())),
-        Value::Float(f) => Some(Value::Str(f.to_string())),
+        Value::Float(f) => Some(Value::Str(crate::ruby_float::to_s(*f))),
         Value::Bool(b) => Some(Value::Str(b.to_string())),
-        Value::List(_) | Value::Nil | Value::Array(_) => None,
+        Value::List(_) | Value::Nil | Value::Array(_) | Value::Object(_) => None,
     }
 }