hecks 3.14.0 → 5.0.0

data/rust/parser/src/parse/entity.rs

@@ -123,6 +123,8 @@ pub fn entity_at_path_mut<'a>(
     entities: &'a mut [ir::Entity],
     path: &[usize],
 ) -> &'a mut ir::Entity {
+    // reason: documented under `# Panics`; paths are built internally, never from input.
+    #[allow(clippy::expect_used)]
     let (first, rest) = path
         .split_first()
         .expect("entity_path must have at least one segment");
@@ -140,6 +142,7 @@ pub fn entity_at_path_mut<'a>(
 /// type-form `identified_by` resolves against it. `entity_named_givens` is one pool shared by
 /// every piece under the root aggregate; a sibling's command reads it back through
 /// `command::try_reference_named_given`.
+#[allow(clippy::too_many_arguments)] // established signature
 pub fn parse_body(
     file: &str,
     lines: &[SourceLine],
@@ -175,12 +178,9 @@ pub fn parse_body(
     loop {
         // Peeked before `next_line`: the grammar row still requires a block for `given`, so a
         // bare reference must be consumed here.
-        if let Some(outcome) = try_reference_named_chapter_entity_given(
-            file,
-            lines,
-            pos,
-            chapter_entity_named_givens,
-        )? {
+        if let Some(outcome) =
+            try_reference_named_chapter_entity_given(file, lines, pos, chapter_entity_named_givens)?
+        {
             match outcome {
                 ChapterEntityGivenLookup::Resolved(given) => {
                     entity.preconditions.push(given.clone());
@@ -230,7 +230,7 @@ pub fn parse_body(
                     "description",
                     &gated.args,
                     1,
-                )?)
+                )?);
             }
             "attribute" => entity
                 .attributes
@@ -359,9 +359,13 @@ pub fn parse_body(
                 }
                 // Chapter-wide pool, keyed by "Aggregate.Entity" plus description.
                 let owner = format!("{aggregate_name}.{name}");
-                if !chapter_entity_named_givens.iter().any(|(candidate_owner, g)| {
-                    candidate_owner == &owner && g.description.as_deref() == Some(description.as_str())
-                }) {
+                if !chapter_entity_named_givens
+                    .iter()
+                    .any(|(candidate_owner, g)| {
+                        candidate_owner == &owner
+                            && g.description.as_deref() == Some(description.as_str())
+                    })
+                {
                     chapter_entity_named_givens.push((owner, built));
                 }
             }
@@ -517,7 +521,13 @@ pub fn parse_body(
         }
     }
 
-    lifecycle::seal_commands(file, *pos, &entity.name, entity.lifecycle.as_ref(), &entity.commands)?;
+    lifecycle::seal_commands(
+        file,
+        *pos,
+        &entity.name,
+        entity.lifecycle.as_ref(),
+        &entity.commands,
+    )?;
 
     Ok((
         entity,

data/rust/parser/src/parse/hecksagon.rs

@@ -32,7 +32,7 @@ pub fn apply(
 ) -> ParseResult<()> {
     loop {
         let line = *lines.get(*pos).ok_or_else(|| {
-            let last = lines.last().map(|l| l.number).unwrap_or(0);
+            let last = lines.last().map_or(0, |l| l.number);
             Diagnostic::new(
                 file,
                 last,
@@ -115,8 +115,13 @@ pub fn apply(
                 // fact collected for `resolve`, absent from `ir.json`. Only `from: :vendor`
                 // is admitted as a source, and anything else is refused.
                 "attaches" => {
-                    let name =
-                        super::positional_text(file, gated.line.number, "attaches", &gated.args, 1)?;
+                    let name = super::positional_text(
+                        file,
+                        gated.line.number,
+                        "attaches",
+                        &gated.args,
+                        1,
+                    )?;
                     match super::named_symbol(&gated.args, "from").as_deref() {
                         None => gem_chapter_names.push(name),
                         Some("vendor") => vendored_bluebook_names.push(name),
@@ -149,6 +154,7 @@ pub fn apply(
 
 /// `<Domain>::<Aggregate>.<verb>`: `port` attaches a port to the named aggregate; any other
 /// verb is a generic adapter-bind, shape-matched and dropped.
+#[allow(clippy::too_many_arguments)] // established signature
 fn apply_aggregate_qualified(
     file: &str,
     lines: &[SourceLine],
@@ -216,7 +222,7 @@ fn skip_dropped_body(file: &str, lines: &[SourceLine], pos: &mut usize) -> Parse
     let mut depth = 1;
     while depth > 0 {
         let line = *lines.get(*pos).ok_or_else(|| {
-            let last = lines.last().map(|l| l.number).unwrap_or(0);
+            let last = lines.last().map_or(0, |l| l.number);
             Diagnostic::new(
                 file,
                 last,

data/rust/parser/src/parse/lifecycle.rs

@@ -41,10 +41,10 @@ pub fn parse_body(
                 let (command_raw, to_state_raw) = super::split_top_level_rocket(pair_text);
                 let command = text_value(command_raw);
                 let to_state = text_value(to_state_raw);
-                let from_states = match super::named_raw(&gated.args, "from") {
-                    None => vec![None],
-                    Some(raw) => from_values(raw).into_iter().map(Some).collect(),
-                };
+                let from_states = super::named_raw(&gated.args, "from").map_or_else(
+                    || vec![None],
+                    |raw| from_values(raw).into_iter().map(Some).collect(),
+                );
 
                 for from_state in from_states {
                     lifecycle.transitions.push(ir::StateTransitionRow {
@@ -117,7 +117,11 @@ fn is_lowercase_word(name: &str) -> bool {
 
 // Refuses a mark naming a state that is neither the default nor a transition target. Wording
 // matches Ruby's.
-fn refuse_unknown_mark_states(file: &str, line: usize, lifecycle: &ir::Lifecycle) -> ParseResult<()> {
+fn refuse_unknown_mark_states(
+    file: &str,
+    line: usize,
+    lifecycle: &ir::Lifecycle,
+) -> ParseResult<()> {
     let mut known: Vec<&str> = vec![lifecycle.default.as_str()];
     for row in &lifecycle.transitions {
         if !known.contains(&row.to_state.as_str()) {

data/rust/parser/src/parse/mod.rs

@@ -1,6 +1,7 @@
 //! Word, body, and argument gates, plus the recursive body walker.
 //! Per-construct modules build IR; a word they do not build fails with `not_yet_implemented`.
 
+pub mod adapter;
 pub mod aggregate;
 pub mod chapter;
 pub mod command;
@@ -15,6 +16,7 @@ pub mod process_manager;
 pub mod query;
 pub mod read_model;
 pub mod value_object;
+pub mod world;
 
 use crate::diag::{Diagnostic, ParseResult};
 use crate::ir;
@@ -176,11 +178,7 @@ pub(crate) fn classify_lexical_kind(token: &str) -> &'static str {
     if t.starts_with('{') && t.ends_with('}') {
         return "pairs";
     }
-    if t.chars()
-        .next()
-        .map(|c| c.is_ascii_uppercase())
-        .unwrap_or(false)
-    {
+    if t.chars().next().is_some_and(|c| c.is_ascii_uppercase()) {
         return "constant";
     }
     if type_context_call_word(t).is_some() {
@@ -564,12 +562,7 @@ pub(crate) fn split_top_level_rocket(segment: &str) -> (&str, &str) {
 
 /// The field name of a pair key, a bare or quoted Symbol literal (`:status`, `:"a.b"`).
 /// Any other key is refused; pair keys are always symbols.
-fn rocket_key_name<'a>(
-    file: &str,
-    word: &str,
-    key_text: &'a str,
-    line: usize,
-) -> ParseResult<String> {
+fn rocket_key_name(file: &str, word: &str, key_text: &str, line: usize) -> ParseResult<String> {
     let Some(rest) = key_text.strip_prefix(':') else {
         return Err(Diagnostic::new(file, line, format!("'{word}'s key '{key_text}' is not a symbol — a pair's key is always :name or :\"a.dotted.path\"")));
     };
@@ -677,7 +670,7 @@ pub(crate) fn next_line<'src>(
     context: &'static str,
 ) -> ParseResult<Option<GatedLine<'src>>> {
     let line = *lines.get(*pos).ok_or_else(|| {
-        let last = lines.last().map(|l| l.number).unwrap_or(0);
+        let last = lines.last().map_or(0, |l| l.number);
         Diagnostic::new(
             file,
             last,
@@ -807,7 +800,7 @@ pub(crate) fn positional_constant<'a>(
     args: &'a ArgumentGateResult,
     at: usize,
 ) -> ParseResult<&'a str> {
-    positional_raw(file, line, word, args, at).map(|s| s.trim())
+    positional_raw(file, line, word, args, at).map(str::trim)
 }
 
 /// A command reference: bare constant (`trigger Account::Debit`) or quoted (`"Account.Debit"`).
@@ -847,7 +840,7 @@ pub(crate) fn named_raw<'a>(args: &'a ArgumentGateResult, name: &str) -> Option<
 
 /// A named constant argument (`to: Payment`): raw text, trimmed; resolved downstream.
 pub(crate) fn named_constant<'a>(args: &'a ArgumentGateResult, name: &str) -> Option<&'a str> {
-    named_raw(args, name).map(|s| s.trim())
+    named_raw(args, name).map(str::trim)
 }
 
 /// A named symbol argument without its colon (`as: :name`); bare or quoted.
@@ -865,9 +858,7 @@ pub(crate) fn named_text(args: &ArgumentGateResult, name: &str) -> Option<String
 
 /// A named flag (`true`/`false`) argument — `optional: true`.
 pub(crate) fn named_flag(args: &ArgumentGateResult, name: &str) -> bool {
-    named_raw(args, name)
-        .map(|raw| raw.trim() == "true")
-        .unwrap_or(false)
+    named_raw(args, name).is_some_and(|raw| raw.trim() == "true")
 }
 
 /// Raw text of a `source`-shaped body written as `{ ... }` or `do ... end`.
@@ -1036,6 +1027,7 @@ pub(crate) enum PendingIdentity {
 /// Parses `identified_by` in its three forms: a value object type (`PizzaName, as: :name`), one or
 /// more field symbols (`:a, :b`), or a `{ ... }`/`do ... end` block declaring an inline value
 /// object named `inline_type_name`.
+#[allow(clippy::too_many_arguments)] // established signature
 pub(crate) fn parse_identified_by(
     file: &str,
     lines: &[SourceLine],
@@ -1072,9 +1064,10 @@ pub(crate) fn parse_identified_by(
             }
             // An identity block's own `one_of(...)` sets are not installed (its builder is not
             // the aggregate's `value_object` verb).
-            let (value_object, _) = parse_nested_body(file, lines, pos, opener, line, |f, l, p| {
-                value_object::parse_body(f, l, p, inline_type_name, owner_value_objects)
-            })?;
+            let (value_object, _) =
+                parse_nested_body(file, lines, pos, opener, line, |f, l, p| {
+                    value_object::parse_body(f, l, p, inline_type_name, owner_value_objects)
+                })?;
             if value_object.attributes.is_empty() {
                 return Err(Diagnostic::new(
                     file,
@@ -1138,7 +1131,11 @@ pub(crate) fn build_attribute(
     let pattern = match named_symbol(args, "matches") {
         Some(given) => {
             if named_text(args, "pattern").is_some() {
-                return Err(Diagnostic::new(file, line, "matches: and pattern: both state the pattern".to_string()));
+                return Err(Diagnostic::new(
+                    file,
+                    line,
+                    "matches: and pattern: both state the pattern".to_string(),
+                ));
             }
             match crate::build::named_pattern::source(&given) {
                 Some(source) => Some(source.to_string()),
@@ -1199,6 +1196,8 @@ pub(crate) fn resolve_type_expression(
     let trimmed = text.trim();
     match type_context_call_word(trimmed) {
         Some("list_of") => {
+            // reason: `type_context_call_word` already confirmed a '(' in `trimmed`.
+            #[allow(clippy::expect_used)]
             let open = trimmed
                 .find('(')
                 .expect("type_context_call_word already confirmed a '('");
@@ -1213,6 +1212,8 @@ pub(crate) fn resolve_type_expression(
             Ok((inner.to_string(), true, None))
         }
         Some("one_of") => {
+            // reason: `type_context_call_word` already confirmed a '(' in `trimmed`.
+            #[allow(clippy::expect_used)]
             let open = trimmed
                 .find('(')
                 .expect("type_context_call_word already confirmed a '('");
@@ -1251,73 +1252,3 @@ pub(crate) fn resolve_type_expression(
         None => Ok((trimmed.to_string(), false, None)),
     }
 }
-
-/// Walks lines inside an open `context` up to and including the matching `end`, gating each one.
-/// The first gate failure or not-yet-implemented construct, at any depth, aborts the walk.
-pub fn walk_body(
-    file: &str,
-    lines: &[SourceLine],
-    pos: &mut usize,
-    context: &'static str,
-) -> ParseResult<()> {
-    loop {
-        let line = *lines.get(*pos).ok_or_else(|| {
-            let last = lines.last().map(|l| l.number).unwrap_or(0);
-            Diagnostic::new(
-                file,
-                last,
-                format!("unexpected end of file — still inside {context}"),
-            )
-        })?;
-
-        let shape = lex::classify(file, &line)?;
-        *pos += 1;
-
-        match shape {
-            LineShape::End => return Ok(()),
-            LineShape::Call(call) => handle_call(file, lines, pos, context, &line, call)?,
-        }
-    }
-}
-
-fn handle_call(
-    file: &str,
-    lines: &[SourceLine],
-    pos: &mut usize,
-    context: &'static str,
-    line: &SourceLine,
-    call: Call,
-) -> ParseResult<()> {
-    let candidates = word_gate(file, &call.word, context, line.number)?;
-    let row = body_gate(file, &candidates, &call.opener, line.number, &call.word)?;
-    argument_gate(file, &call.word, context, &call.args, line.number)?;
-
-    match &call.opener {
-        Opener::DoBlock { .. } => {
-            if row.inner.is_empty() {
-                return Err(dispatch_stub(context, file, line.number, &call.word));
-            }
-            let inner_context = keywords::CONTEXTS
-                .iter()
-                .find(|c| **c == row.inner)
-                .copied()
-                .ok_or_else(|| {
-                    Diagnostic::new(
-                        file,
-                        line.number,
-                        format!(
-                            "'{}' opens an undeclared context '{}'",
-                            call.word, row.inner
-                        ),
-                    )
-                })?;
-            walk_body(file, lines, pos, inner_context)?;
-            // The nested body gated cleanly but builds nothing yet, so the failure is reported at
-            // the construct just entered rather than the outer `context`.
-            Err(dispatch_stub(inner_context, file, line.number, &call.word))
-        }
-        Opener::BraceBlock { .. } | Opener::None => {
-            Err(dispatch_stub(context, file, line.number, &call.word))
-        }
-    }
-}

data/rust/parser/src/parse/needs.rs

@@ -22,7 +22,10 @@ pub fn declare(
 ) -> ParseResult<()> {
     let fact = super::positional_symbol(file, line, "needs", args, 1)?;
     if !NEEDABLE_FACTS.contains(&fact.as_str()) {
-        let supplied: Vec<String> = NEEDABLE_FACTS.iter().map(|known| format!(":{known}")).collect();
+        let supplied: Vec<String> = NEEDABLE_FACTS
+            .iter()
+            .map(|known| format!(":{known}"))
+            .collect();
         return Err(Diagnostic::new(
             file,
             line,
@@ -33,7 +36,11 @@ pub fn declare(
         ));
     }
     if needs.contains(&fact) {
-        return Err(Diagnostic::new(file, line, format!("{owner} declares needs :{fact} twice")));
+        return Err(Diagnostic::new(
+            file,
+            line,
+            format!("{owner} declares needs :{fact} twice"),
+        ));
     }
     needs.push(fact);
     Ok(())
@@ -47,14 +54,16 @@ pub fn refuse_undeclared(
     needs: &[String],
     attributes: &[ir::Attribute],
 ) -> ParseResult<()> {
-    match needs.iter().find(|fact| !attributes.iter().any(|a| &a.name == *fact)) {
-        Some(fact) => Err(Diagnostic::new(
-            file,
-            line,
-            format!(
-                "{owner} needs :{fact} but declares no attribute :{fact} for the runtime to fill — add `attribute :{fact}, <type>`"
-            ),
-        )),
-        None => Ok(()),
-    }
+    needs
+        .iter()
+        .find(|fact| !attributes.iter().any(|a| &a.name == *fact))
+        .map_or(Ok(()), |fact| {
+            Err(Diagnostic::new(
+                file,
+                line,
+                format!(
+                    "{owner} needs :{fact} but declares no attribute :{fact} for the runtime to fill — add `attribute :{fact}, <type>`"
+                ),
+            ))
+        })
 }

data/rust/parser/src/parse/policy.rs

@@ -36,7 +36,7 @@ pub fn parse_body(
                     "on",
                     &gated.args,
                     1,
-                )?)
+                )?);
             }
             "trigger" => {
                 policy.trigger_command = Some(super::positional_command_ref(
@@ -82,7 +82,7 @@ pub fn parse_body(
                     "for_each",
                     &gated.args,
                     1,
-                )?)
+                )?);
             }
             _ => {
                 return Err(super::not_built_yet(

data/rust/parser/src/parse/process_manager.rs

@@ -34,7 +34,7 @@ pub fn parse_body(
             // A dotted symbol (`:"reference.value"`), which only `positional_symbol` can spell.
             "correlates_by" => {
                 pm.correlates_by =
-                    super::positional_symbol(file, line, "correlates_by", &gated.args, 1)?
+                    super::positional_symbol(file, line, "correlates_by", &gated.args, 1)?;
             }
             // Event references keep only the bare final segment (`Naming.event_name_ref`);
             // `SagaInterpreter` matches them against a bare `event.name`.
@@ -45,7 +45,7 @@ pub fn parse_body(
                     "starts_on",
                     &gated.args,
                     1,
-                )?)
+                )?);
             }
             "ends_on" => {
                 pm.ends_on = Some(super::positional_event_name_ref(
@@ -54,17 +54,15 @@ pub fn parse_body(
                     "ends_on",
                     &gated.args,
                     1,
-                )?)
+                )?);
             }
             "transition" => {
                 for handler in parse_transition(file, lines, pos, line, &gated)? {
                     // Two legs on one (event, state) pair would be picked by declaration order;
                     // mirrors `ProcessManagerBuilder#refuse_ambiguous_legs!`.
-                    if let Some(earlier) = pm
-                        .handlers
-                        .iter()
-                        .find(|h| h.event_type == handler.event_type && h.from_state == handler.from_state)
-                    {
+                    if let Some(earlier) = pm.handlers.iter().find(|h| {
+                        h.event_type == handler.event_type && h.from_state == handler.from_state
+                    }) {
                         return Err(Diagnostic::new(
                             file,
                             line,
@@ -208,9 +206,9 @@ fn parse_dispatches(
                     Opener::DoBlock { .. } => {
                         parse_compensates_block(file, lines, pos)?.map(Box::new)
                     }
-                    Opener::BraceBlock { .. } => unreachable!(
-                        "body_gate never admits a BraceBlock for 'dispatch'/Handler"
-                    ),
+                    Opener::BraceBlock { .. } => {
+                        unreachable!("body_gate never admits a BraceBlock for 'dispatch'/Handler")
+                    }
                 };
                 dispatches.push(ir::DispatchSpec {
                     command_name,

data/rust/parser/src/parse/query.rs

@@ -39,7 +39,7 @@ pub fn parse_body(
                     "description",
                     &gated.args,
                     1,
-                )?)
+                )?);
             }
             "attribute" => query
                 .attributes
@@ -48,7 +48,7 @@ pub fn parse_body(
                 query_derive::refuse_on_target(file, line, "where", &gated.args.named)?;
                 query
                     .wheres
-                    .extend(query_derive::where_clauses(&gated.args.named, None))
+                    .extend(query_derive::where_clauses(&gated.args.named, None));
             }
             "order_by" => {
                 // The gate already refuses an undeclared `on:`; only `where` needs a check.
@@ -57,7 +57,11 @@ pub fn parse_body(
                     Some((_, text)) => text.trim().trim_start_matches(':').to_string(),
                     None => "asc".to_string(),
                 };
-                query.order_by = Some(ir::OrderBy { field, direction, target: None });
+                query.order_by = Some(ir::OrderBy {
+                    field,
+                    direction,
+                    target: None,
+                });
             }
             // `positional_constant` only fetches raw text; the gate already checked it is numeric.
             "limit" => {
@@ -87,7 +91,7 @@ pub fn parse_body(
             }
             "needs" => super::needs::declare(file, line, name, &gated.args, &mut query.needs)?,
             word if OPTION_WORDS.contains(&word) => {
-                query_options::apply(file, line, word, &gated.args, &mut query.options)?
+                query_options::apply(file, line, word, &gated.args, &mut query.options)?;
             }
             _ => {
                 return Err(super::not_built_yet(

data/rust/parser/src/parse/read_model.rs

@@ -41,10 +41,7 @@ pub fn parse_body(
     let mut options = ir::QueryOptions::default();
     let mut last_line = 0usize;
 
-    loop {
-        let Some(gated) = super::next_line(file, lines, pos, "ReadModel")? else {
-            break;
-        };
+    while let Some(gated) = super::next_line(file, lines, pos, "ReadModel")? {
         last_line = gated.line.number;
 
         match gated.row.word {
@@ -55,7 +52,7 @@ pub fn parse_body(
                     "description",
                     &gated.args,
                     1,
-                )?)
+                )?);
             }
             // Ruby refuses a second `reference_to`; that seal is out of scope for this parser.
             "reference_to" => {
@@ -93,19 +90,43 @@ pub fn parse_body(
                     "median",
                     &gated.args,
                     1,
-                )?)
+                )?);
             }
             "sum" => {
-                sum_field = Some(super::positional_symbol(file, last_line, "sum", &gated.args, 1)?)
+                sum_field = Some(super::positional_symbol(
+                    file,
+                    last_line,
+                    "sum",
+                    &gated.args,
+                    1,
+                )?);
             }
             "avg" => {
-                avg_field = Some(super::positional_symbol(file, last_line, "avg", &gated.args, 1)?)
+                avg_field = Some(super::positional_symbol(
+                    file,
+                    last_line,
+                    "avg",
+                    &gated.args,
+                    1,
+                )?);
             }
             "min" => {
-                min_field = Some(super::positional_symbol(file, last_line, "min", &gated.args, 1)?)
+                min_field = Some(super::positional_symbol(
+                    file,
+                    last_line,
+                    "min",
+                    &gated.args,
+                    1,
+                )?);
             }
             "max" => {
-                max_field = Some(super::positional_symbol(file, last_line, "max", &gated.args, 1)?)
+                max_field = Some(super::positional_symbol(
+                    file,
+                    last_line,
+                    "max",
+                    &gated.args,
+                    1,
+                )?);
             }
             "percentile" => {
                 percentile_field = Some(super::positional_symbol(
@@ -116,14 +137,30 @@ pub fn parse_body(
                     1,
                 )?);
                 percentile_at = Some(super::named_text(&gated.args, "at").ok_or_else(|| {
-                    Diagnostic::new(file, last_line, "'percentile' needs an at: argument".to_string())
+                    Diagnostic::new(
+                        file,
+                        last_line,
+                        "'percentile' needs an at: argument".to_string(),
+                    )
                 })?);
             }
             "any" => {
-                any_field = Some(super::positional_symbol(file, last_line, "any", &gated.args, 1)?)
+                any_field = Some(super::positional_symbol(
+                    file,
+                    last_line,
+                    "any",
+                    &gated.args,
+                    1,
+                )?);
             }
             "all" => {
-                all_field = Some(super::positional_symbol(file, last_line, "all", &gated.args, 1)?)
+                all_field = Some(super::positional_symbol(
+                    file,
+                    last_line,
+                    "all",
+                    &gated.args,
+                    1,
+                )?);
             }
             "where" => {
                 // ADR 0055: `on:` is a recognized named argument for `where` in ReadModel
@@ -138,7 +175,7 @@ pub fn parse_body(
                     .filter(|(name, _)| name != "on")
                     .cloned()
                     .collect();
-                wheres.extend(query_derive::where_clauses(&field_pairs, target.as_deref()))
+                wheres.extend(query_derive::where_clauses(&field_pairs, target.as_deref()));
             }
             "order_by" => {
                 let field = super::positional_symbol(file, last_line, "order_by", &gated.args, 1)?;
@@ -147,7 +184,11 @@ pub fn parse_body(
                     None => "asc".to_string(),
                 };
                 let target = super::named_constant(&gated.args, "on").map(naming::demodulise);
-                order_by = Some(ir::OrderBy { field, direction, target });
+                order_by = Some(ir::OrderBy {
+                    field,
+                    direction,
+                    target,
+                });
             }
             "limit" => {
                 let raw = super::positional_constant(file, last_line, "limit", &gated.args, 1)?;
@@ -158,7 +199,7 @@ pub fn parse_body(
                 });
             }
             word if OPTION_WORDS.contains(&word) => {
-                query_options::apply(file, last_line, word, &gated.args, &mut options)?
+                query_options::apply(file, last_line, word, &gated.args, &mut options)?;
             }
             _ => {
                 return Err(super::not_built_yet(

data/rust/parser/src/parse/value_object.rs

@@ -98,7 +98,8 @@ pub fn parse_body(
             // An inline type-position `one_of(...)` set is returned beside the value object (see
             // build/closed_sets.rs); `ValueObject` has no nested-value-objects field.
             "attribute" => {
-                let (attribute, one_of, closed_set) = build_value_object_attribute(file, &gated.args)?;
+                let (attribute, one_of, closed_set) =
+                    build_value_object_attribute(file, &gated.args)?;
                 synthesized.extend(closed_set);
                 if let Some(values) = one_of {
                     let vo_name = vo.name.clone();
@@ -140,7 +141,11 @@ pub fn parse_body(
 fn build_value_object_attribute(
     file: &str,
     args: &super::ArgumentGateResult,
-) -> ParseResult<(ir::Attribute, Option<Vec<ruby_value::Value>>, Option<ir::ValueObject>)> {
+) -> ParseResult<(
+    ir::Attribute,
+    Option<Vec<ruby_value::Value>>,
+    Option<ir::ValueObject>,
+)> {
     let (attribute, closed_set) = super::build_attribute(file, 0, "attribute", args)?;
     let one_of = super::named_raw(args, "one_of").map(|raw| {
         let trimmed = raw.trim();