From c0a00a9bd3dfe44f0f4fb1527bcc4b107149e2b7 Mon Sep 17 00:00:00 2001
From: Taus <tausbn@github.com>
Date: Thu, 15 Oct 2026 12:04:04 +0000
Subject: [PATCH 1/2] yeast: Get rid of postfix `?` operator

This will be superseded by the next commit, which generalised the
mechanism and also makes the implementation simpler.
---
 shared/yeast-macros/src/ast.rs            |   4 +-
 shared/yeast-macros/src/lib.rs            |  27 ------
 shared/yeast-macros/src/lower.rs          | 101 ++++-----------------
 shared/yeast-macros/src/template_parse.rs |  60 +-----------
 shared/yeast/doc/yeast.md                 |  42 ---------
 shared/yeast/src/lib.rs                   |  79 +---------------
 shared/yeast/tests/test.rs                | 106 ----------------------
 7 files changed, 24 insertions(+), 395 deletions(-)

diff --git a/shared/yeast-macros/src/ast.rs b/shared/yeast-macros/src/ast.rs
index f400257fd1d4..09746b550235 100644
--- a/shared/yeast-macros/src/ast.rs
+++ b/shared/yeast-macros/src/ast.rs
@@ -121,15 +121,13 @@ pub(crate) enum Content {
 
 pub(crate) enum Field {
     /// A named field such as `argument: {args}` or
-    /// `label: (identifier #{name})?`.
+    /// `label: (identifier #{name})`.
     Named {
         /// The field name before `:`, such as `argument`.
         name: Ident,
         /// The node or Rust splice after `:`, such as `(identifier "x")` or
         /// `{args}`.
         value: Template,
-        /// Whether the field value has a trailing `?`.
-        optional: bool,
     },
     /// Source-location metadata such as `location: {source}`.
     Location {
diff --git a/shared/yeast-macros/src/lib.rs b/shared/yeast-macros/src/lib.rs
index 75d737372965..aeb7b0a5df56 100644
--- a/shared/yeast-macros/src/lib.rs
+++ b/shared/yeast-macros/src/lib.rs
@@ -63,37 +63,10 @@ pub fn query(input: TokenStream) -> TokenStream {
 ///                                `Option<OutputId>`, iterator chains) splice
 ///                                their elements
 /// field: {expr}                - extend a named field with `{expr}`'s ids
-/// field: (kind ...)?           - set the field only if every `#{expr}`
-///                                beneath it has a value (see below)
 /// location: {expr}             - override this node's source range with the
 ///                                span of one or more nodes; may be repeated
 /// ```
 ///
-/// # Optional fields
-///
-/// A `?` on a field's value makes that field fallible: if a `#{expr}`
-/// anywhere beneath it interpolates an absent value — an `Option` that is
-/// `None` — the subtree is abandoned and the field is left unset. This
-/// replaces the surrounding `Option::map` that would otherwise be needed:
-///
-/// ```text
-/// (break_expr label: {lbl.map(|l| tree!((identifier #{l})))})   // before
-/// (break_expr label: (identifier #{lbl})?)                      // after
-/// ```
-///
-/// The value may be nested arbitrarily deeply, and a nested `?` catches
-/// first, so an inner absent value need not discard the outer node:
-///
-/// ```text
-/// (parameter pattern: (name_pattern identifier: (identifier #{name}))? type: {ty})
-/// ```
-///
-/// Only `#{expr}` propagates absence. A `{expr}` splice is unaffected, since
-/// yielding no ids already leaves a field unset, and `?` is rejected on one.
-/// Outside a `?`, interpolating an `Option` with `#{expr}` remains a compile
-/// error, so the choice between "unset the field" and "unwrap it" stays
-/// explicit.
-///
 /// Uses the `BuildCtx` binding named `ctx` from the surrounding scope:
 ///
 /// ```text
diff --git a/shared/yeast-macros/src/lower.rs b/shared/yeast-macros/src/lower.rs
index 6bf22c7e8b9e..89bfdf0a6e76 100644
--- a/shared/yeast-macros/src/lower.rs
+++ b/shared/yeast-macros/src/lower.rs
@@ -1,21 +1,8 @@
 use proc_macro2::{Ident, Span, TokenStream};
 use quote::quote;
-use std::sync::atomic::{AtomicUsize, Ordering};
-use syn::Lifetime;
 
 use crate::ast::{Cardinality, Content, Field, Node, Pattern, Replacement, Rule, Template};
 
-struct LoweringContext<'a> {
-    /// Enclosing optional-field label to exit when a computed value is absent.
-    fallible_scope: Option<&'a Lifetime>,
-}
-
-fn fresh_fallible_label() -> Lifetime {
-    static COUNTER: AtomicUsize = AtomicUsize::new(0);
-    let n = COUNTER.fetch_add(1, Ordering::Relaxed);
-    Lifetime::new(&format!("'__yeast_field_{n}"), Span::call_site())
-}
-
 #[derive(Clone)]
 struct CaptureBinding {
     name: Ident,
@@ -286,20 +273,15 @@ fn capture_bindings<'a>(
 
 impl Template {
     pub(crate) fn lower_root(&self) -> TokenStream {
-        self.lower(&LoweringContext {
-            fallible_scope: None,
-        })
+        self.lower()
     }
 
     pub(crate) fn lower_list(templates: &[Self]) -> TokenStream {
-        let context = LoweringContext {
-            fallible_scope: None,
-        };
         let items = templates
             .iter()
             .map(|template| match template {
                 Template::Node(node) => {
-                    let node = node.lower(&context);
+                    let node = node.lower();
                     quote! { __nodes.push(#node); }
                 }
                 Template::Splice(block) => {
@@ -322,9 +304,9 @@ impl Template {
         }
     }
 
-    fn lower(&self, context: &LoweringContext<'_>) -> TokenStream {
+    fn lower(&self) -> TokenStream {
         match self {
-            Template::Node(node) => node.lower(context),
+            Template::Node(node) => node.lower(),
             Template::Splice(block) => {
                 let block = rust_block(block);
                 quote! { ::std::convert::Into::<yeast::OutputId>::into(#block) }
@@ -334,7 +316,7 @@ impl Template {
 }
 
 impl Node {
-    fn lower(&self, context: &LoweringContext<'_>) -> TokenStream {
+    fn lower(&self) -> TokenStream {
         let ctx = Ident::new("ctx", Span::call_site());
         let kind_str = self.kind.to_string();
 
@@ -343,40 +325,18 @@ impl Node {
                 Content::Static(lit) => quote! { #ctx.literal(#kind_str, #lit) },
                 Content::Computed(block) => {
                     let block = rust_block(block);
-                    if let Some(label) = context.fallible_scope {
-                        quote! {
-                            {
-                                let __expr = #block;
-                                let ::std::option::Option::Some(__value_ref) =
-                                    yeast::MaybeYeastValue::maybe_yeast_value(&__expr)
-                                else {
-                                    break #label ::std::option::Option::None;
-                                };
-                                let __value =
-                                    yeast::YeastDisplay::yeast_to_string(__value_ref, &#ctx);
-                                let __source_range =
-                                    yeast::YeastSourceRange::yeast_source_range(__value_ref, &#ctx);
-                                #ctx.literal_with_source_range(
-                                    #kind_str,
-                                    &__value,
-                                    __source_range,
-                                )
-                            }
-                        }
-                    } else {
-                        quote! {
-                            {
-                                let __expr = #block;
-                                let __value =
-                                    yeast::YeastDisplay::yeast_to_string(&__expr, &#ctx);
-                                let __source_range =
-                                    yeast::YeastSourceRange::yeast_source_range(&__expr, &#ctx);
-                                #ctx.literal_with_source_range(
-                                    #kind_str,
-                                    &__value,
-                                    __source_range,
-                                )
-                            }
+                    quote! {
+                        {
+                            let __expr = #block;
+                            let __value =
+                                yeast::YeastDisplay::yeast_to_string(&__expr, &#ctx);
+                            let __source_range =
+                                yeast::YeastSourceRange::yeast_source_range(&__expr, &#ctx);
+                            #ctx.literal_with_source_range(
+                                #kind_str,
+                                &__value,
+                                __source_range,
+                            )
                         }
                     }
                 }
@@ -399,11 +359,7 @@ impl Node {
                         #ctx.extend_location_ranges(__value, &mut __location_ranges);
                     });
                 }
-                Field::Named {
-                    name,
-                    value,
-                    optional,
-                } => {
+                Field::Named { name, value } => {
                     let field_name = name.to_string();
                     let field_str = field_name
                         .strip_prefix("r#")
@@ -413,10 +369,8 @@ impl Node {
                         &format!("__field_{field_str}_{field_counter}"),
                         Span::call_site(),
                     );
-
                     match value {
                         Template::Splice(block) => {
-                            debug_assert!(!optional);
                             let block = rust_block(block);
                             stmts.push(quote! {
                                 let mut #temp: Vec<yeast::OutputId> = Vec::new();
@@ -430,25 +384,8 @@ impl Node {
                                 }
                             });
                         }
-                        Template::Node(child) if *optional => {
-                            let label = fresh_fallible_label();
-                            let value = child.lower(&LoweringContext {
-                                fallible_scope: Some(&label),
-                            });
-                            stmts.push(quote! {
-                                #[allow(unused_labels)]
-                                let #temp: ::std::option::Option<yeast::OutputId> = #label: {
-                                    ::std::option::Option::Some(#value)
-                                };
-                            });
-                            field_args.push(quote! {
-                                if let ::std::option::Option::Some(__id) = #temp {
-                                    __fields.push((#field_str, vec![__id]));
-                                }
-                            });
-                        }
                         Template::Node(child) => {
-                            let value = child.lower(context);
+                            let value = child.lower();
                             stmts.push(quote! { let #temp: yeast::OutputId = #value; });
                             field_args.push(quote! {
                                 __fields.push((#field_str, vec![#temp]));
diff --git a/shared/yeast-macros/src/template_parse.rs b/shared/yeast-macros/src/template_parse.rs
index 782407466a46..8a7d176809ef 100644
--- a/shared/yeast-macros/src/template_parse.rs
+++ b/shared/yeast-macros/src/template_parse.rs
@@ -9,7 +9,6 @@ type Result<T> = std::result::Result<T, syn::Error>;
 pub(crate) fn parse_template(input: TokenStream) -> Result<Template> {
     let mut tokens = input.into_iter().peekable();
     let template = parse_one(&mut tokens)?;
-    reject_stray_optional(&mut tokens, false)?;
     if let Some(token) = tokens.next() {
         return Err(syn::Error::new_spanned(
             token,
@@ -93,33 +92,12 @@ fn parse_node(group: proc_macro2::Group) -> Result<Node> {
                 return Err(error);
             }
             let block = parse_block(expect_group(&mut tokens, Delimiter::Brace)?)?;
-            if let Some(TokenTree::Punct(punctuation)) = tokens.peek() {
-                if punctuation.as_char() == '?' {
-                    return Err(syn::Error::new_spanned(
-                        punctuation.clone(),
-                        "`?` is not valid on a `location` field",
-                    ));
-                }
-            }
             fields.push(Field::Location { block });
             continue;
         }
 
         let value = parse_one(&mut tokens)?;
-        let optional = if matches!(value, Template::Splice(_)) {
-            reject_stray_optional(&mut tokens, true)?;
-            false
-        } else if peek_is_punct(&mut tokens, '?') {
-            tokens.next();
-            true
-        } else {
-            false
-        };
-        fields.push(Field::Named {
-            name,
-            value,
-            optional,
-        });
+        fields.push(Field::Named { name, value });
     }
 
     if let Some(token) = tokens.next() {
@@ -146,7 +124,6 @@ fn parse_list(tokens: &mut Tokens) -> Result<Vec<Template>> {
                 continue;
             }
             templates.push(Template::Node(parse_node(group)?));
-            reject_stray_optional(tokens, false)?;
             continue;
         }
 
@@ -155,7 +132,6 @@ fn parse_list(tokens: &mut Tokens) -> Result<Vec<Template>> {
                 tokens,
                 Delimiter::Brace,
             )?)?));
-            reject_stray_optional(tokens, true)?;
             continue;
         }
 
@@ -164,23 +140,6 @@ fn parse_list(tokens: &mut Tokens) -> Result<Vec<Template>> {
     Ok(templates)
 }
 
-fn reject_stray_optional(tokens: &mut Tokens, after_splice: bool) -> Result<()> {
-    let Some(TokenTree::Punct(punctuation)) = tokens.peek() else {
-        return Ok(());
-    };
-    if punctuation.as_char() != '?' {
-        return Ok(());
-    }
-    let message = if after_splice {
-        "`?` is not valid on a `{...}` splice; a splice that yields no value \
-         already leaves its field unset"
-    } else {
-        "`?` is only valid on the value of a named field, as in \
-         `label: (identifier #{lbl})?`"
-    };
-    Err(syn::Error::new_spanned(punctuation.clone(), message))
-}
-
 fn parse_block(group: proc_macro2::Group) -> Result<syn::Block> {
     syn::parse2(TokenStream::from(TokenTree::Group(group)))
 }
@@ -201,10 +160,6 @@ fn peek_is_group(tokens: &mut Tokens, delimiter: Delimiter) -> bool {
     matches!(tokens.peek(), Some(TokenTree::Group(group)) if group.delimiter() == delimiter)
 }
 
-fn peek_is_punct(tokens: &mut Tokens, expected: char) -> bool {
-    matches!(tokens.peek(), Some(TokenTree::Punct(punctuation)) if punctuation.as_char() == expected)
-}
-
 fn expect_ident(tokens: &mut Tokens, message: &str) -> Result<Ident> {
     match tokens.next() {
         Some(TokenTree::Ident(identifier)) => Ok(identifier),
@@ -256,7 +211,7 @@ mod tests {
         let template = parse_template(quote! {
             (call
                 argument: {args}
-                method: (identifier #{name})?)
+                method: (identifier #{name}))
         })
         .unwrap();
 
@@ -297,17 +252,6 @@ mod tests {
         );
     }
 
-    #[test]
-    fn rejects_optional_location_fields() {
-        let result = parse_template(quote! {
-            (identifier "name" location: {source}?)
-        });
-        let Err(error) = result else {
-            panic!("expected an optional location field to be rejected");
-        };
-        assert_eq!(error.to_string(), "`?` is not valid on a `location` field");
-    }
-
     #[test]
     fn parses_lists_and_skips_empty_nodes() {
         let templates = parse_templates(quote! {
diff --git a/shared/yeast/doc/yeast.md b/shared/yeast/doc/yeast.md
index a58949db4438..b3387b9925bf 100644
--- a/shared/yeast/doc/yeast.md
+++ b/shared/yeast/doc/yeast.md
@@ -331,48 +331,6 @@ accessor_declaration source="⟨accessor_kind⟩"
 Node and child ranges are still validated against the source text and UTF-8
 boundaries.
 
-### Optional fields (`?`)
-
-A `?` on a field's value makes that field fallible. If a `#{expr}` anywhere
-beneath it interpolates an absent value — an `Option` that is `None` — the
-subtree is abandoned and the field is left unset:
-
-```rust
-rule!((breakStmt label: _? @@lbl) => (break_expr label: (identifier #{lbl})?))
-```
-
-Here an optional capture is being wrapped in a leaf, which without `?` needs
-an `Option::map` to build the leaf only in the `Some` case:
-
-```rust
-// Equivalent, but the intent is buried in the closure:
-(break_expr label: {lbl.map(|l| tree!((identifier #{l})))})
-```
-
-The marker mirrors the query language, where a quantifier likewise follows the
-value it applies to (`label: _? @@lbl`). Note that the schema puts it on the
-other side of the colon — `external_name?: identifier` — because it is
-*declaring* a field's cardinality rather than supplying a value for it.
-
-Absence propagates outwards through as many levels as necessary, and a nested
-`?` catches first, so an inner absent value need not discard the outer node:
-
-```rust
-// If `name` is absent, `pattern` is left unset — but `type` is still set.
-(parameter pattern: (name_pattern identifier: (identifier #{name}))? type: {ty})
-```
-
-Only `#{expr}` propagates absence, because it supplies a node's *content*: with
-no value there is no leaf to build. A `{expr}` splice supplies *children*, where
-yielding nothing already leaves the field unset (see below), so `?` is rejected
-on one. Repetition has no marker at all, in templates or elsewhere: how many
-children a `{expr}` contributes is a property of the expression rather than of
-the syntax.
-
-Outside a `?`, interpolating an `Option` with `#{expr}` remains a compile error.
-That is deliberate: it keeps the choice between "leave the field unset" and
-"unwrap it" explicit at every interpolation.
-
 ### Embedded Rust expressions
 
 `{expr}` embeds a Rust expression whose value is appended to the
diff --git a/shared/yeast/src/lib.rs b/shared/yeast/src/lib.rs
index d950504b4e2a..e5044e188660 100644
--- a/shared/yeast/src/lib.rs
+++ b/shared/yeast/src/lib.rs
@@ -248,8 +248,8 @@ where
 /// blanket `impl<T: Display>`, so additional types must be added explicitly.
 #[diagnostic::on_unimplemented(
     message = "`{Self}` cannot be interpolated with `#{{...}}`",
-    note = "if the value is optional, mark the enclosing field's value with `?` to leave \
-            that field unset when it is absent, as in `label: (identifier #{{lbl}})?`"
+    note = "optional values must be unwrapped explicitly or converted to an optional \
+            node through a `{{...}}` field splice"
 )]
 pub trait YeastDisplay {
     fn yeast_to_string<C>(&self, ctx: &build::BuildCtx<'_, C>) -> String;
@@ -326,81 +326,6 @@ impl<T: YeastSourceRange + ?Sized> YeastSourceRange for &T {
     }
 }
 
-/// Normalizes a `#{expr}` interpolation to an optional value, so that a
-/// fallible field — `field: (kind #{expr})?` — can tell "there is a value to
-/// interpolate" apart from "there is none, so leave the field unset".
-///
-/// Implemented for every [`YeastDisplay`] type, which always yields a value,
-/// and for `Option` of the same, which yields one only when it is `Some`.
-///
-/// The implementations are enumerated rather than blanket: a blanket
-/// `impl<T: YeastDisplay>` would overlap with the `Option<T>` impl, since
-/// coherence cannot rule out a future `impl YeastDisplay for Option<T>`.
-/// [`YeastDisplay`] itself is enumerated for the same reason.
-///
-/// Note that this is used *only* inside a fallible field. Elsewhere `#{expr}`
-/// still goes directly through [`YeastDisplay`], so interpolating an `Option`
-/// without a `?` remains a compile error rather than silently dropping a node.
-pub trait MaybeYeastValue {
-    /// The interpolated value's type, which knows how to render itself.
-    type Value: YeastDisplay + YeastSourceRange + ?Sized;
-
-    /// Returns the value to interpolate, or `None` to leave the field unset.
-    fn maybe_yeast_value(&self) -> Option<&Self::Value>;
-}
-
-macro_rules! impl_maybe_yeast_value {
-    ($($t:ty),* $(,)?) => {
-        $(
-            impl MaybeYeastValue for $t {
-                type Value = $t;
-                fn maybe_yeast_value(&self) -> Option<&$t> {
-                    Some(self)
-                }
-            }
-
-            impl MaybeYeastValue for Option<$t> {
-                type Value = $t;
-                fn maybe_yeast_value(&self) -> Option<&$t> {
-                    self.as_ref()
-                }
-            }
-        )*
-    };
-}
-
-impl_maybe_yeast_value! {
-    OutputId, Id,
-    i8, i16, i32, i64, i128, isize,
-    u8, u16, u32, u64, u128, usize,
-    f32, f64,
-    bool, char,
-    String,
-}
-
-// `str` is unsized, so it has no `Option<str>` counterpart; `Option<&str>` is
-// covered by the reference impls below.
-impl MaybeYeastValue for str {
-    type Value = str;
-    fn maybe_yeast_value(&self) -> Option<&str> {
-        Some(self)
-    }
-}
-
-impl<T: MaybeYeastValue + ?Sized> MaybeYeastValue for &T {
-    type Value = T::Value;
-    fn maybe_yeast_value(&self) -> Option<&T::Value> {
-        (**self).maybe_yeast_value()
-    }
-}
-
-impl<T: MaybeYeastValue + ?Sized> MaybeYeastValue for Option<&T> {
-    type Value = T::Value;
-    fn maybe_yeast_value(&self) -> Option<&T::Value> {
-        (*self).and_then(MaybeYeastValue::maybe_yeast_value)
-    }
-}
-
 #[derive(Debug)]
 pub struct AstCursor<'a, Id: TreeId = crate::Id> {
     ast: &'a Ast<Id>,
diff --git a/shared/yeast/tests/test.rs b/shared/yeast/tests/test.rs
index 68a83db8ab91..ba39ab0685a6 100644
--- a/shared/yeast/tests/test.rs
+++ b/shared/yeast/tests/test.rs
@@ -713,112 +713,6 @@ fn test_tree_builder() {
     );
 }
 
-/// Builds `(assignment left: … right: (integer #{value})?)`, where a `None`
-/// `value` leaves `right` unset rather than producing an `integer` with no
-/// content.
-fn build_optional_right(
-    input_ast: &Ast,
-    ast: &mut OutputAst,
-    value: Option<yeast::OutputId>,
-) -> (yeast::OutputId, yeast::OutputId) {
-    let mut user_ctx = ();
-    let mut ctx = yeast::build::BuildCtx::new(input_ast, ast, &mut user_ctx);
-    let left = yeast::tree!((identifier "x"));
-    let root = yeast::tree!(
-        (assignment
-            left: {left}
-            right: (integer #{value})?
-        )
-    );
-    (root, left)
-}
-
-#[test]
-fn test_optional_field_is_set_when_the_value_is_present() {
-    let input_ast = parse_input("x = 1");
-    let mut ast = empty_output_ast("x = 1");
-
-    let some = ast.create_named_token("identifier", "x = 1".to_string());
-
-    let (root, _) = build_optional_right(&input_ast, &mut ast, Some(some));
-    assert_dump_eq(
-        &dump_ast(&ast, root, "x = 1"),
-        r#"
-        assignment
-          left: identifier "x"
-          right: integer "x = 1"
-    "#,
-    );
-}
-
-#[test]
-fn test_optional_field_is_unset_when_the_value_is_absent() {
-    let input_ast = parse_input("x = 1");
-    let mut ast = empty_output_ast("x = 1");
-
-    let (root, _) = build_optional_right(&input_ast, &mut ast, None);
-    assert_dump_eq(
-        &dump_ast(&ast, root, "x = 1"),
-        r#"
-        assignment
-          left: identifier "x"
-    "#,
-    );
-}
-
-#[test]
-fn test_optional_field_propagates_through_nested_nodes() {
-    let input_ast = parse_input("x = 1");
-    let mut ast = empty_output_ast("x = 1");
-
-    let mut user_ctx = ();
-    let mut ctx = yeast::build::BuildCtx::new(&input_ast, &mut ast, &mut user_ctx);
-
-    // The absent value sits two levels below the `?`, so the whole
-    // `left_assignment_list` subtree is abandoned along with it.
-    let absent: Option<yeast::OutputId> = None;
-    let right = yeast::tree!((integer "1"));
-    let root = yeast::tree!(
-        (assignment
-            left: (left_assignment_list child: (identifier #{absent}))?
-            right: {right}
-        )
-    );
-
-    assert_dump_eq(
-        &dump_ast(&ast, root, "x = 1"),
-        r#"
-        assignment
-          right: integer "1"
-    "#,
-    );
-}
-
-#[test]
-fn test_innermost_optional_field_catches_first() {
-    let input_ast = parse_input("x = 1");
-    let mut ast = empty_output_ast("x = 1");
-
-    let mut user_ctx = ();
-    let mut ctx = yeast::build::BuildCtx::new(&input_ast, &mut ast, &mut user_ctx);
-
-    // The inner `?` catches, so only `child` is dropped; `left` survives.
-    let absent: Option<yeast::OutputId> = None;
-    let root = yeast::tree!(
-        (assignment
-            left: (left_assignment_list child: (identifier #{absent})?)?
-        )
-    );
-
-    assert_dump_eq(
-        &dump_ast(&ast, root, "x = 1"),
-        r#"
-        assignment
-          left: left_assignment_list
-    "#,
-    );
-}
-
 // ---- Rule tests ----
 
 // These rules use field names from node-types.yml, which extends the

From 7027a7668f4c639681f7b19764e72606fc35bdd3 Mon Sep 17 00:00:00 2001
From: Taus <tausbn@github.com>
Date: Fri, 16 Oct 2026 11:59:14 +0000
Subject: [PATCH 2/2] yeast: Add support for output template choices

Adds a new syntactic form
```
[tree1 if {cond1}
 tree2
 tree3 if {cond3}
]
```
to the language, the intended semantics being that we output the first
tree that is usable. Two things can prevent a tree from being used:

- the guard condition (a Rust expression evaluating to a boolean) may
  fail;
- a string interpolation (e.g. `#{name}`) may fail to have a value.

If all of the alternatives fail, then the result is `None`. This makes
the syntax a generalisation of the `?` postfix operator that was removed
in the previous commit. `(foo)?` can be replaced with a single-element
alternative `[(foo)]`.

As the changes to swift.rs show, this can clean up a bunch of
constructions where we currently rely on helper functions or somewhat
complicated Rust blocks.

In terms of the implementation, we go through the alternatives in turn,
first evaluating the guard condition. If this succeeds, we evaluate (and
temporarily store) all of the `#{...}` interpolations, and if those all
return `Some(...)` values, we instantiate the template itself. A benefit
of this implementation compared to the one for `?` (which used named
labels and `break`s) is that if either requirement fails, no AST nodes
are constructed. (The `?` implementation would eagerly construct the
tree, and then abort if any of the interpolations failed. This could
leave orphaned nodes in the AST arena.)

A choice cannot contain another choice as an immediate child (as that
choice could simply have its branches inlined in the parent), but
nesting further down is allow. In that case, the inner choice takes care
of handling its internal "failures", and these do not bubble up to the
outer choice.
---
 shared/yeast-macros/src/ast.rs                |   9 +
 shared/yeast-macros/src/lib.rs                |  36 +++
 shared/yeast-macros/src/lower.rs              | 199 +++++++++++-
 shared/yeast-macros/src/template_parse.rs     | 106 ++++++-
 shared/yeast/doc/yeast.md                     |  58 +++-
 shared/yeast/src/lib.rs                       |  80 ++++-
 shared/yeast/tests/test.rs                    | 299 ++++++++++++++++++
 .../extractor/src/languages/swift/swift.rs    |  66 ++--
 8 files changed, 787 insertions(+), 66 deletions(-)

diff --git a/shared/yeast-macros/src/ast.rs b/shared/yeast-macros/src/ast.rs
index 09746b550235..a08d56e9661d 100644
--- a/shared/yeast-macros/src/ast.rs
+++ b/shared/yeast-macros/src/ast.rs
@@ -100,6 +100,15 @@ pub(crate) enum Template {
     Node(Node),
     /// An embedded Rust block such as `{args}`.
     Splice(syn::Block),
+    /// Ordered alternatives such as `[(identifier #{name}) (missing)]`.
+    Choice(Vec<Alternative>),
+}
+
+pub(crate) struct Alternative {
+    /// Template to construct when the guard and dependencies succeed.
+    pub(crate) template: Template,
+    /// Optional postfix guard such as `if { name.is_some() }`.
+    pub(crate) guard: Option<syn::Block>,
 }
 
 pub(crate) struct Node {
diff --git a/shared/yeast-macros/src/lib.rs b/shared/yeast-macros/src/lib.rs
index aeb7b0a5df56..ad686403a3d4 100644
--- a/shared/yeast-macros/src/lib.rs
+++ b/shared/yeast-macros/src/lib.rs
@@ -52,6 +52,8 @@ pub fn query(input: TokenStream) -> TokenStream {
 
 /// Build a single AST node from a template, returning its `OutputId`.
 ///
+/// A top-level choice returns `Option<OutputId>`.
+///
 /// # Template syntax
 ///
 /// ```text
@@ -65,8 +67,42 @@ pub fn query(input: TokenStream) -> TokenStream {
 /// field: {expr}                - extend a named field with `{expr}`'s ids
 /// location: {expr}             - override this node's source range with the
 ///                                span of one or more nodes; may be repeated
+/// field: [(kind ...)]          - set the field only if the alternative can
+///                                be constructed (see below)
+/// field: [(a) (b)]             - use the first constructible alternative
+/// field: [(a) if {guard} (b)]  - skip an alternative when its guard is false
+/// ```
+///
+/// # Template choices
+///
+/// Brackets contain one or more ordered alternatives. For each alternative,
+/// its optional `if {guard}` is evaluated first, followed by every `#{expr}`
+/// dependency beneath it. An absent dependency — an `Option` that is `None` —
+/// skips the alternative without constructing any of its template nodes. The
+/// first alternative whose guard and dependencies succeed is constructed:
+///
+/// ```text
+/// (break_expr label: {lbl.map(|l| tree!((identifier #{l})))})   // before
+/// (break_expr label: [(identifier #{lbl})])                     // after
 /// ```
 ///
+/// Dependencies may be nested arbitrarily deeply. A nested choice handles its
+/// own dependencies, so an inner absent value need not discard an outer node:
+///
+/// ```text
+/// (parameter pattern: [
+///     (name_pattern identifier: [(identifier #{name})])
+/// ] type: {ty})
+/// ```
+///
+/// Only `#{expr}` is treated as a dependency. A `{expr}` splice is unaffected,
+/// since yielding no ids already leaves its field unset. Outside a choice,
+/// interpolating an `Option` with `#{expr}` remains a compile error.
+///
+/// A choice used as a field or list item contributes zero or one node. A
+/// top-level choice passed to `tree!` returns `Option<OutputId>`; ordinary
+/// templates continue to return `OutputId`.
+///
 /// Uses the `BuildCtx` binding named `ctx` from the surrounding scope:
 ///
 /// ```text
diff --git a/shared/yeast-macros/src/lower.rs b/shared/yeast-macros/src/lower.rs
index 89bfdf0a6e76..6ed98725a086 100644
--- a/shared/yeast-macros/src/lower.rs
+++ b/shared/yeast-macros/src/lower.rs
@@ -1,7 +1,33 @@
 use proc_macro2::{Ident, Span, TokenStream};
 use quote::quote;
+use std::cell::RefCell;
+use std::sync::atomic::{AtomicUsize, Ordering};
 
-use crate::ast::{Cardinality, Content, Field, Node, Pattern, Replacement, Rule, Template};
+use crate::ast::{
+    Alternative, Cardinality, Content, Field, Node, Pattern, Replacement, Rule, Template,
+};
+
+#[derive(Clone, Copy, Default)]
+struct LoweringContext<'a> {
+    dependency_scope: Option<DependencyScope<'a>>,
+}
+
+#[derive(Clone, Copy)]
+struct DependencyScope<'a> {
+    preparations: &'a RefCell<Vec<DependencyPreparation>>,
+}
+
+struct DependencyPreparation {
+    value: Ident,
+    source_range: Ident,
+    expression: TokenStream,
+}
+
+fn fresh_prepared_ident(suffix: &str) -> Ident {
+    static COUNTER: AtomicUsize = AtomicUsize::new(0);
+    let n = COUNTER.fetch_add(1, Ordering::Relaxed);
+    Ident::new(&format!("__yeast_prepared_{suffix}_{n}"), Span::call_site())
+}
 
 #[derive(Clone)]
 struct CaptureBinding {
@@ -273,15 +299,19 @@ fn capture_bindings<'a>(
 
 impl Template {
     pub(crate) fn lower_root(&self) -> TokenStream {
-        self.lower()
+        match self {
+            Template::Choice(alternatives) => Self::lower_choice(alternatives),
+            _ => self.lower_single(LoweringContext::default()),
+        }
     }
 
     pub(crate) fn lower_list(templates: &[Self]) -> TokenStream {
+        let context = LoweringContext::default();
         let items = templates
             .iter()
             .map(|template| match template {
                 Template::Node(node) => {
-                    let node = node.lower();
+                    let node = node.lower(context);
                     quote! { __nodes.push(#node); }
                 }
                 Template::Splice(block) => {
@@ -292,6 +322,14 @@ impl Template {
                         ctx.extend_field_ids(__value, &mut __nodes);
                     }
                 }
+                Template::Choice(alternatives) => {
+                    let pick = Self::lower_choice(alternatives);
+                    quote! {
+                        if let ::std::option::Option::Some(__id) = #pick {
+                            __nodes.push(__id);
+                        }
+                    }
+                }
             })
             .collect::<Vec<_>>();
 
@@ -304,19 +342,102 @@ impl Template {
         }
     }
 
-    fn lower(&self) -> TokenStream {
+    fn lower_single(&self, context: LoweringContext<'_>) -> TokenStream {
         match self {
-            Template::Node(node) => node.lower(),
+            Template::Node(node) => node.lower(context),
             Template::Splice(block) => {
                 let block = rust_block(block);
                 quote! { ::std::convert::Into::<yeast::OutputId>::into(#block) }
             }
+            Template::Choice(_) => {
+                unreachable!("choices are lowered through Template::lower_choice")
+            }
+        }
+    }
+
+    fn lower_choice(alternatives: &[Alternative]) -> TokenStream {
+        let pick = alternatives.iter().rev().fold(
+            quote! { ::std::option::Option::None },
+            |fallback, alternative| {
+                alternative.lower_candidate(fallback)
+            },
+        );
+        quote! {{ #pick }}
+    }
+}
+
+impl Alternative {
+    fn lower_candidate(&self, fallback: TokenStream) -> TokenStream {
+        let preparations = RefCell::new(Vec::new());
+        let context = LoweringContext {
+            dependency_scope: Some(DependencyScope {
+                preparations: &preparations,
+            }),
+        };
+        let value = self.template.lower_single(context);
+        let preparations = preparations.into_inner();
+        let prepared_values = preparations
+            .iter()
+            .flat_map(|preparation| {
+                [
+                    preparation.value.clone(),
+                    preparation.source_range.clone(),
+                ]
+            })
+            .collect::<Vec<_>>();
+        let prepared = quote! {
+            ::std::option::Option::Some((#(#prepared_values),*))
+        };
+
+        // Nest dependency matches around preparation in reverse, so they are
+        // evaluated in source order. Construction happens only after the
+        // resulting option has been matched, keeping it in a separate branch
+        // from the fallback.
+        let prepared = preparations.into_iter().rev().fold(
+            prepared,
+            |candidate, preparation| {
+                let DependencyPreparation {
+                    value,
+                    source_range,
+                    expression,
+                } = preparation;
+                // Do not use `map`/`and_then` here: `candidate` may contain
+                // embedded user Rust, and putting it in a closure would change
+                // the target of `return` and the result type seen by `?`.
+                quote! {
+                    match #expression {
+                        ::std::option::Option::Some((#value, #source_range)) => #candidate,
+                        ::std::option::Option::None => ::std::option::Option::None,
+                    }
+                }
+            },
+        );
+        let prepared = if let Some(guard) = &self.guard {
+            let guard = rust_block(guard);
+            quote! {
+                if #guard {
+                    #prepared
+                } else {
+                    ::std::option::Option::None
+                }
+            }
+        } else {
+            prepared
+        };
+
+        quote! {
+            match #prepared {
+                ::std::option::Option::Some((#(#prepared_values),*)) => {
+                    ::std::option::Option::Some(#value)
+                }
+                ::std::option::Option::None => #fallback,
+            }
         }
     }
 }
 
 impl Node {
-    fn lower(&self) -> TokenStream {
+    fn lower(&self, context: LoweringContext<'_>) -> TokenStream {
         let ctx = Ident::new("ctx", Span::call_site());
         let kind_str = self.kind.to_string();
 
@@ -325,19 +446,54 @@ impl Node {
                 Content::Static(lit) => quote! { #ctx.literal(#kind_str, #lit) },
                 Content::Computed(block) => {
                     let block = rust_block(block);
-                    quote! {
-                        {
-                            let __expr = #block;
-                            let __value =
-                                yeast::YeastDisplay::yeast_to_string(&__expr, &#ctx);
-                            let __source_range =
-                                yeast::YeastSourceRange::yeast_source_range(&__expr, &#ctx);
+                    if let Some(scope) = context.dependency_scope {
+                        let value = fresh_prepared_ident("value");
+                        let source_range = fresh_prepared_ident("source_range");
+                        scope.preparations.borrow_mut().push(DependencyPreparation {
+                            value: value.clone(),
+                            source_range: source_range.clone(),
+                            expression: quote! {
+                                {
+                                    let __expr = #block;
+                                    yeast::MaybeYeastValue::maybe_yeast_value(&__expr).map(
+                                        |__value_ref| {
+                                            (
+                                                yeast::YeastDisplay::yeast_to_string(
+                                                    __value_ref,
+                                                    &#ctx,
+                                                ),
+                                                yeast::YeastSourceRange::yeast_source_range(
+                                                    __value_ref,
+                                                    &#ctx,
+                                                ),
+                                            )
+                                        },
+                                    )
+                                }
+                            },
+                        });
+                        quote! {
                             #ctx.literal_with_source_range(
                                 #kind_str,
-                                &__value,
-                                __source_range,
+                                &#value,
+                                #source_range,
                             )
                         }
+                    } else {
+                        quote! {
+                            {
+                                let __expr = #block;
+                                let __value =
+                                    yeast::YeastDisplay::yeast_to_string(&__expr, &#ctx);
+                                let __source_range =
+                                    yeast::YeastSourceRange::yeast_source_range(&__expr, &#ctx);
+                                #ctx.literal_with_source_range(
+                                    #kind_str,
+                                    &__value,
+                                    __source_range,
+                                )
+                            }
+                        }
                     }
                 }
             };
@@ -384,8 +540,19 @@ impl Node {
                                 }
                             });
                         }
+                        Template::Choice(alternatives) => {
+                            let pick = Template::lower_choice(alternatives);
+                            stmts.push(quote! {
+                                let #temp: ::std::option::Option<yeast::OutputId> = #pick;
+                            });
+                            field_args.push(quote! {
+                                if let ::std::option::Option::Some(__id) = #temp {
+                                    __fields.push((#field_str, vec![__id]));
+                                }
+                            });
+                        }
                         Template::Node(child) => {
-                            let value = child.lower();
+                            let value = child.lower(context);
                             stmts.push(quote! { let #temp: yeast::OutputId = #value; });
                             field_args.push(quote! {
                                 __fields.push((#field_str, vec![#temp]));
diff --git a/shared/yeast-macros/src/template_parse.rs b/shared/yeast-macros/src/template_parse.rs
index 8a7d176809ef..5d63a1e45c27 100644
--- a/shared/yeast-macros/src/template_parse.rs
+++ b/shared/yeast-macros/src/template_parse.rs
@@ -1,7 +1,7 @@
 use proc_macro2::{Delimiter, Ident, Literal, Span, TokenStream, TokenTree};
 use std::iter::Peekable;
 
-use crate::ast::{Content, Field, Node, Template};
+use crate::ast::{Alternative, Content, Field, Node, Template};
 
 type Tokens = Peekable<proc_macro2::token_stream::IntoIter>;
 type Result<T> = std::result::Result<T, syn::Error>;
@@ -40,9 +40,13 @@ fn parse_one(tokens: &mut Tokens) -> Result<Template> {
             let group = expect_group(tokens, Delimiter::Parenthesis)?;
             Ok(Template::Node(parse_node(group)?))
         }
+        Some(TokenTree::Group(group)) if group.delimiter() == Delimiter::Bracket => {
+            let group = expect_group(tokens, Delimiter::Bracket)?;
+            Ok(Template::Choice(parse_alternatives(group)?))
+        }
         Some(token) => Err(syn::Error::new_spanned(
             token.clone(),
-            "expected `(` or `{` in tree template",
+            "expected `(`, `{`, or `[` in tree template",
         )),
         None => Err(syn::Error::new(
             Span::call_site(),
@@ -115,6 +119,42 @@ fn parse_node(group: proc_macro2::Group) -> Result<Node> {
     })
 }
 
+fn parse_alternatives(group: proc_macro2::Group) -> Result<Vec<Alternative>> {
+    let mut tokens = group.stream().into_iter().peekable();
+    let mut alternatives = Vec::new();
+    while tokens.peek().is_some() {
+        if peek_is_group(&mut tokens, Delimiter::Bracket) {
+            let nested = expect_group(&mut tokens, Delimiter::Bracket)?;
+            return Err(syn::Error::new(
+                nested.span(),
+                "a choice cannot be used directly as another choice's alternative; \
+                 list its alternatives directly in the enclosing choice",
+            ));
+        }
+        let template = parse_one(&mut tokens)?;
+        let guard = if peek_is_ident(&mut tokens, "if") {
+            tokens.next();
+            let group = expect_group(&mut tokens, Delimiter::Brace).map_err(|error| {
+                syn::Error::new(
+                    error.span(),
+                    "expected `{ ... }` guard condition after `if`",
+                )
+            })?;
+            Some(parse_block(group)?)
+        } else {
+            None
+        };
+        alternatives.push(Alternative { template, guard });
+    }
+    if alternatives.is_empty() {
+        return Err(syn::Error::new(
+            group.span(),
+            "template choices must contain at least one alternative",
+        ));
+    }
+    Ok(alternatives)
+}
+
 fn parse_list(tokens: &mut Tokens) -> Result<Vec<Template>> {
     let mut templates = Vec::new();
     while tokens.peek().is_some() {
@@ -135,6 +175,14 @@ fn parse_list(tokens: &mut Tokens) -> Result<Vec<Template>> {
             continue;
         }
 
+        if peek_is_group(tokens, Delimiter::Bracket) {
+            templates.push(Template::Choice(parse_alternatives(expect_group(
+                tokens,
+                Delimiter::Bracket,
+            )?)?));
+            continue;
+        }
+
         break;
     }
     Ok(templates)
@@ -160,6 +208,10 @@ fn peek_is_group(tokens: &mut Tokens, delimiter: Delimiter) -> bool {
     matches!(tokens.peek(), Some(TokenTree::Group(group)) if group.delimiter() == delimiter)
 }
 
+fn peek_is_ident(tokens: &mut Tokens, expected: &str) -> bool {
+    matches!(tokens.peek(), Some(TokenTree::Ident(identifier)) if identifier == expected)
+}
+
 fn expect_ident(tokens: &mut Tokens, message: &str) -> Result<Ident> {
     match tokens.next() {
         Some(TokenTree::Ident(identifier)) => Ok(identifier),
@@ -211,7 +263,7 @@ mod tests {
         let template = parse_template(quote! {
             (call
                 argument: {args}
-                method: (identifier #{name}))
+                method: [(identifier #{name})])
         })
         .unwrap();
 
@@ -252,6 +304,54 @@ mod tests {
         );
     }
 
+    #[test]
+    fn parses_choice_guards() {
+        let template = parse_template(quote! {
+            [
+                (parameter type: {ty}) if { in_function_type }
+                (argument value: {ty})
+            ]
+        })
+        .unwrap();
+
+        let Template::Choice(alternatives) = template else {
+            panic!("expected template choice");
+        };
+        assert_eq!(alternatives.len(), 2);
+        assert!(alternatives[0].guard.is_some());
+        assert!(alternatives[1].guard.is_none());
+    }
+
+    #[test]
+    fn rejects_empty_choices() {
+        let result = parse_template(quote! { [] });
+        let Err(error) = result else {
+            panic!("expected empty choice to be rejected");
+        };
+        assert_eq!(
+            error.to_string(),
+            "template choices must contain at least one alternative"
+        );
+    }
+
+    #[test]
+    fn rejects_choice_as_direct_alternative() {
+        let result = parse_template(quote! {
+            [
+                [(identifier "nested")]
+                (identifier "fallback")
+            ]
+        });
+        let Err(error) = result else {
+            panic!("expected a direct nested choice to be rejected");
+        };
+        assert_eq!(
+            error.to_string(),
+            "a choice cannot be used directly as another choice's alternative; \
+             list its alternatives directly in the enclosing choice"
+        );
+    }
+
     #[test]
     fn parses_lists_and_skips_empty_nodes() {
         let templates = parse_templates(quote! {
diff --git a/shared/yeast/doc/yeast.md b/shared/yeast/doc/yeast.md
index b3387b9925bf..78e4e1c21d71 100644
--- a/shared/yeast/doc/yeast.md
+++ b/shared/yeast/doc/yeast.md
@@ -331,6 +331,57 @@ accessor_declaration source="⟨accessor_kind⟩"
 Node and child ranges are still validated against the source text and UTF-8
 boundaries.
 
+### Template choices (`[]`)
+
+Brackets contain one or more ordered template alternatives. For each
+alternative, Yeast evaluates its optional `if {guard}` and preflights every
+`#{expr}` beneath it. If the guard is false or an interpolation produces
+`None`, that alternative is skipped without constructing any of its template
+nodes. The first alternative that can be constructed is emitted:
+
+```rust
+rule!((breakStmt label: _? @@lbl) => (break_expr label: [(identifier #{lbl})]))
+```
+
+Here an optional capture is being wrapped in a leaf. A multi-way choice can
+provide a fallback, and alternatives can have explicit guards:
+
+```rust
+(import_declaration
+    pattern: [
+        (identifier #{last}) if { kind.is_some() }
+        (bulk_importing_pattern)
+    ])
+```
+
+A choice may contain any nonzero number of alternatives. A single-alternative
+choice expresses an optional tree. Nested choices handle their own
+dependencies, so an inner absent value need not discard the outer node:
+
+```rust
+// If `name` is absent, `pattern` is left unset — but `type` is still set.
+(parameter
+    pattern: [
+        (name_pattern identifier: [(identifier #{name})])
+    ]
+    type: {ty})
+```
+
+Only `#{expr}` propagates absence, because it supplies a node's *content*: with
+no value there is no leaf to build. A `{expr}` splice supplies *children*, where
+yielding nothing already leaves the field unset (see below). How many children
+a `{expr}` contributes is a property of the expression rather than of the
+template syntax.
+
+Outside a choice, interpolating an `Option` with `#{expr}` remains a compile
+error. That is deliberate: it keeps the choice between rejecting an
+alternative and unwrapping the value explicit at every interpolation.
+
+Choice dependencies are evaluated before construction begins. A rejected
+alternative therefore leaves no partially constructed template nodes in the
+AST. Guards and dependencies are evaluated once, in source order. A nested
+choice is a separate dependency boundary.
+
 ### Embedded Rust expressions
 
 `{expr}` embeds a Rust expression whose value is appended to the
@@ -357,9 +408,10 @@ yeast::trees!(
 ```
 
 Because an `Option<Id>` splices as zero or one id, `field: {opt}` already
-leaves the field unset when `opt` is `None`. Use [`?`](#optional-fields-)
-instead when the optional value has to be *wrapped* in a node first, so that
-there is nothing to wrap when it is absent.
+leaves the field unset when `opt` is `None`. Use a
+[single-alternative template choice](#template-choices-) instead when the
+optional value has to be *wrapped* in a node first, so that there is nothing
+to wrap when it is absent.
 
 The contents of `{…}` are treated as a Rust block, so multi-statement
 expressions (with `let` bindings) work too:
diff --git a/shared/yeast/src/lib.rs b/shared/yeast/src/lib.rs
index e5044e188660..6f2a7e821b99 100644
--- a/shared/yeast/src/lib.rs
+++ b/shared/yeast/src/lib.rs
@@ -248,8 +248,8 @@ where
 /// blanket `impl<T: Display>`, so additional types must be added explicitly.
 #[diagnostic::on_unimplemented(
     message = "`{Self}` cannot be interpolated with `#{{...}}`",
-    note = "optional values must be unwrapped explicitly or converted to an optional \
-            node through a `{{...}}` field splice"
+    note = "if the value is optional, place the node in a template choice to leave \
+            that field unset when it is absent, as in `label: [(identifier #{{lbl}})]`"
 )]
 pub trait YeastDisplay {
     fn yeast_to_string<C>(&self, ctx: &build::BuildCtx<'_, C>) -> String;
@@ -326,6 +326,82 @@ impl<T: YeastSourceRange + ?Sized> YeastSourceRange for &T {
     }
 }
 
+/// Normalizes a `#{expr}` interpolation to an optional value, so that a
+/// template choice — `field: [(kind #{expr})]` — can tell "there is a value
+/// to interpolate" apart from "there is none, so try the next alternative".
+///
+/// Implemented for every [`YeastDisplay`] type, which always yields a value,
+/// and for `Option` of the same, which yields one only when it is `Some`.
+///
+/// The implementations are enumerated rather than blanket: a blanket
+/// `impl<T: YeastDisplay>` would overlap with the `Option<T>` impl, since
+/// coherence cannot rule out a future `impl YeastDisplay for Option<T>`.
+/// [`YeastDisplay`] itself is enumerated for the same reason.
+///
+/// Note that this is used *only* while preparing a choice alternative.
+/// Elsewhere `#{expr}` still goes directly through [`YeastDisplay`], so
+/// interpolating an `Option` outside a choice remains a compile error rather
+/// than silently dropping a node.
+pub trait MaybeYeastValue {
+    /// The interpolated value's type, which knows how to render itself.
+    type Value: YeastDisplay + YeastSourceRange + ?Sized;
+
+    /// Returns the value to interpolate, or `None` to reject the alternative.
+    fn maybe_yeast_value(&self) -> Option<&Self::Value>;
+}
+
+macro_rules! impl_maybe_yeast_value {
+    ($($t:ty),* $(,)?) => {
+        $(
+            impl MaybeYeastValue for $t {
+                type Value = $t;
+                fn maybe_yeast_value(&self) -> Option<&$t> {
+                    Some(self)
+                }
+            }
+
+            impl MaybeYeastValue for Option<$t> {
+                type Value = $t;
+                fn maybe_yeast_value(&self) -> Option<&$t> {
+                    self.as_ref()
+                }
+            }
+        )*
+    };
+}
+
+impl_maybe_yeast_value! {
+    OutputId, Id,
+    i8, i16, i32, i64, i128, isize,
+    u8, u16, u32, u64, u128, usize,
+    f32, f64,
+    bool, char,
+    String,
+}
+
+// `str` is unsized, so it has no `Option<str>` counterpart; `Option<&str>` is
+// covered by the reference impls below.
+impl MaybeYeastValue for str {
+    type Value = str;
+    fn maybe_yeast_value(&self) -> Option<&str> {
+        Some(self)
+    }
+}
+
+impl<T: MaybeYeastValue + ?Sized> MaybeYeastValue for &T {
+    type Value = T::Value;
+    fn maybe_yeast_value(&self) -> Option<&T::Value> {
+        (**self).maybe_yeast_value()
+    }
+}
+
+impl<T: MaybeYeastValue + ?Sized> MaybeYeastValue for Option<&T> {
+    type Value = T::Value;
+    fn maybe_yeast_value(&self) -> Option<&T::Value> {
+        (*self).and_then(MaybeYeastValue::maybe_yeast_value)
+    }
+}
+
 #[derive(Debug)]
 pub struct AstCursor<'a, Id: TreeId = crate::Id> {
     ast: &'a Ast<Id>,
diff --git a/shared/yeast/tests/test.rs b/shared/yeast/tests/test.rs
index ba39ab0685a6..a63a05f2e4af 100644
--- a/shared/yeast/tests/test.rs
+++ b/shared/yeast/tests/test.rs
@@ -713,6 +713,283 @@ fn test_tree_builder() {
     );
 }
 
+/// Builds `(assignment left: … right: [(integer #{value})])`, where a `None`
+/// `value` leaves `right` unset rather than producing an `integer` with no
+/// content.
+fn build_choice_right(
+    input_ast: &Ast,
+    ast: &mut OutputAst,
+    value: Option<yeast::Id>,
+) -> (yeast::OutputId, yeast::OutputId) {
+    let mut user_ctx = ();
+    let mut ctx = yeast::build::BuildCtx::new(input_ast, ast, &mut user_ctx);
+    let left = yeast::tree!((identifier "x"));
+    let root = yeast::tree!(
+        (assignment
+            left: {left}
+            right: [(integer #{value})]
+        )
+    );
+    (root, left)
+}
+
+#[test]
+fn test_choice_is_set_when_the_value_is_present() {
+    let input = "x = 1";
+    let input_ast = parse_input(input);
+    let mut ast = empty_output_ast(input);
+
+    // Any node will do as the interpolated value; `#{…}` renders its source text.
+    let mut cursor = AstCursor::new(&input_ast);
+    cursor.goto_first_child();
+    let some = cursor.node_id();
+
+    let (root, _) = build_choice_right(&input_ast, &mut ast, Some(some));
+    assert_dump_eq(
+        &dump_ast(&ast, root, input),
+        r#"
+        assignment
+          left: identifier "x"
+          right: integer "x = 1"
+    "#,
+    );
+}
+
+#[test]
+fn test_choice_is_unset_when_the_value_is_absent() {
+    let input = "x = 1";
+    let input_ast = parse_input(input);
+    let mut ast = empty_output_ast(input);
+
+    let (root, _) = build_choice_right(&input_ast, &mut ast, None);
+    assert_dump_eq(
+        &dump_ast(&ast, root, input),
+        r#"
+        assignment
+          left: identifier "x"
+    "#,
+    );
+}
+
+#[test]
+fn test_choice_uses_first_constructible_alternative() {
+    let input = "x = 1";
+    let input_ast = parse_input(input);
+    let mut ast = empty_output_ast(input);
+
+    let mut user_ctx = ();
+    let mut ctx = yeast::build::BuildCtx::new(&input_ast, &mut ast, &mut user_ctx);
+    let absent: Option<yeast::Id> = None;
+    let root = yeast::tree!(
+        (assignment
+            left: [
+                (identifier #{absent})
+                (identifier "fallback")
+            ]
+        )
+    );
+
+    assert_dump_eq(
+        &dump_ast(ctx.output, root, input),
+        r#"
+        assignment
+          left: identifier "fallback"
+    "#,
+    );
+}
+
+#[test]
+fn test_choice_guard_skips_an_alternative() {
+    let input = "x = 1";
+    let input_ast = parse_input(input);
+    let mut ast = empty_output_ast(input);
+
+    let mut user_ctx = ();
+    let mut ctx = yeast::build::BuildCtx::new(&input_ast, &mut ast, &mut user_ctx);
+    let use_first = false;
+    let root = yeast::tree!(
+        (assignment
+            left: [
+                (identifier "first") if { use_first }
+                (identifier "fallback")
+            ]
+        )
+    );
+
+    assert_dump_eq(
+        &dump_ast(ctx.output, root, input),
+        r#"
+        assignment
+          left: identifier "fallback"
+    "#,
+    );
+}
+
+#[test]
+fn test_choice_fallback_can_reuse_consumed_splice() {
+    let input = "x = 1";
+    let input_ast = parse_input(input);
+    let mut ast = empty_output_ast(input);
+
+    let mut user_ctx = ();
+    let mut ctx = yeast::build::BuildCtx::new(&input_ast, &mut ast, &mut user_ctx);
+    let items = vec![
+        yeast::tree!((identifier "x")),
+        yeast::tree!((identifier "y")),
+    ];
+    let use_first = false;
+    let root = yeast::tree!(
+        (assignment
+            left: [
+                (left_assignment_list
+                    child: {items}
+                    child: (identifier "first")) if { use_first }
+                (left_assignment_list
+                    child: {items}
+                    child: (identifier "fallback"))
+            ]
+        )
+    );
+
+    assert_dump_eq(
+        &dump_ast(ctx.output, root, input),
+        r#"
+        assignment
+          left:
+            left_assignment_list
+              identifier "x"
+              identifier "y"
+              identifier "fallback"
+    "#,
+    );
+}
+
+#[test]
+fn test_root_choice_returns_an_optional_node() {
+    let input = "x = 1";
+    let input_ast = parse_input(input);
+    let mut ast = empty_output_ast(input);
+    let node_count = ast.nodes().len();
+
+    let mut user_ctx = ();
+    let mut ctx = yeast::build::BuildCtx::new(&input_ast, &mut ast, &mut user_ctx);
+    let absent: Option<yeast::Id> = None;
+    let missing = yeast::tree!([(identifier #{absent})]);
+    assert_eq!(missing, None);
+    assert_eq!(ctx.output.nodes().len(), node_count);
+
+    let root = yeast::tree!([
+        (identifier #{absent})
+        (identifier "fallback")
+    ])
+    .unwrap();
+    assert_dump_eq(
+        &dump_ast(ctx.output, root, input),
+        r#"
+        identifier "fallback"
+    "#,
+    );
+
+    let source = ctx.ast().get_root();
+    let located = yeast::tree!([
+        (identifier #{absent})
+        (identifier "located fallback" location: {source})
+    ])
+    .unwrap();
+    assert_eq!(
+        ctx.output.get_node(located).unwrap().source_range(),
+        ctx.ast().get_node(source).unwrap().source_range()
+    );
+}
+
+#[test]
+fn test_choice_preflights_dependencies_before_constructing() {
+    let input = "x = 1";
+    let input_ast = parse_input(input);
+    let mut ast = empty_output_ast(input);
+    let node_count = ast.nodes().len();
+
+    let mut user_ctx = ();
+    let mut ctx = yeast::build::BuildCtx::new(&input_ast, &mut ast, &mut user_ctx);
+    let absent: Option<yeast::Id> = None;
+    let root = yeast::tree!(
+        (assignment
+            left: [
+                (left_assignment_list
+                    child: (identifier "would-be-orphan")
+                    child: (identifier #{absent}))
+                (identifier "fallback")
+            ]
+        )
+    );
+
+    assert_eq!(ctx.output.nodes().len(), node_count + 2);
+    assert_dump_eq(
+        &dump_ast(ctx.output, root, input),
+        r#"
+        assignment
+          left: identifier "fallback"
+    "#,
+    );
+}
+
+#[test]
+fn test_choice_propagates_through_nested_nodes() {
+    let input = "x = 1";
+    let input_ast = parse_input(input);
+    let mut ast = empty_output_ast(input);
+
+    let mut user_ctx = ();
+    let mut ctx = yeast::build::BuildCtx::new(&input_ast, &mut ast, &mut user_ctx);
+
+    // The absent value sits two levels below the choice, so the whole
+    // `left_assignment_list` subtree is abandoned along with it.
+    let absent: Option<yeast::Id> = None;
+    let right = yeast::tree!((integer "1"));
+    let root = yeast::tree!(
+        (assignment
+            left: [(left_assignment_list child: (identifier #{absent}))]
+            right: {right}
+        )
+    );
+
+    assert_dump_eq(
+        &dump_ast(ctx.output, root, input),
+        r#"
+        assignment
+          right: integer "1"
+    "#,
+    );
+}
+
+#[test]
+fn test_innermost_choice_catches_first() {
+    let input = "x = 1";
+    let input_ast = parse_input(input);
+    let mut ast = empty_output_ast(input);
+
+    let mut user_ctx = ();
+    let mut ctx = yeast::build::BuildCtx::new(&input_ast, &mut ast, &mut user_ctx);
+
+    // The inner choice catches, so only `child` is dropped; `left` survives.
+    let absent: Option<yeast::Id> = None;
+    let root = yeast::tree!(
+        (assignment
+            left: [
+                (left_assignment_list child: [(identifier #{absent})])
+            ]
+        )
+    );
+
+    assert_dump_eq(
+        &dump_ast(ctx.output, root, input),
+        r#"
+        assignment
+          left: left_assignment_list
+    "#,
+    );
+}
+
 // ---- Rule tests ----
 
 // These rules use field names from node-types.yml, which extends the
@@ -1383,6 +1660,28 @@ fn test_hash_brace_renders_capture_source_text() {
     );
 }
 
+#[test]
+fn test_choice_accepts_optional_translated_capture() {
+    let rule: Rule = rule!(
+        (call method: (identifier) @name)
+        =>
+        (call
+            method: [(identifier #{Some(name)})]
+            arguments: (argument_list)
+        )
+    );
+    let dump = run_and_dump("foo()", vec![rule]);
+    assert_dump_eq(
+        &dump,
+        r#"
+        program
+          call
+            arguments: argument_list
+            method: identifier "foo"
+    "#,
+    );
+}
+
 /// Regression test: non-`OutputId` values in `#{expr}` still render via their
 /// `Display` impl (covered by `YeastDisplay`'s blanket impls for primitives).
 #[test]
diff --git a/unified/extractor/src/languages/swift/swift.rs b/unified/extractor/src/languages/swift/swift.rs
index 75b7c4e9c5c5..d492c078147f 100644
--- a/unified/extractor/src/languages/swift/swift.rs
+++ b/unified/extractor/src/languages/swift/swift.rs
@@ -60,18 +60,6 @@ impl SwiftContext {
     }
 }
 
-/// Build a freshly-created `chained_declaration` modifier node if
-/// `ctx.is_chained`, else `None`. Used by inner declaration rules to
-/// emit the chained tag for non-first children of a flattening outer
-/// rule. Returns `Option<OutputId>` so it splices via `{…}` to 0 or 1 ids.
-fn chained_modifier(ctx: &mut yeast::build::BuildCtx<'_, SwiftContext>) -> Option<yeast::OutputId> {
-    if ctx.is_chained {
-        Some(tree!((modifier "chained_declaration")))
-    } else {
-        None
-    }
-}
-
 fn implicit_parameterless_initializer(
     ctx: &mut yeast::build::BuildCtx<'_, SwiftContext>,
     members: &[yeast::OutputId],
@@ -411,7 +399,7 @@ fn translation_rules() -> Vec<Rule<SwiftContext>> {
                         Vec::new()
                     }
                 }
-                modifier: {chained_modifier(&mut ctx)}
+                modifier: [(modifier "chained_declaration") if { ctx.is_chained }]
                 name_node: {
                     ctx.property_name_node
                         .ok_or("accessor outside property context")?
@@ -437,7 +425,7 @@ fn translation_rules() -> Vec<Rule<SwiftContext>> {
             =>
             (variable_declaration
                 modifier: {ctx.outer_modifiers.clone()}
-                modifier: {chained_modifier(&mut ctx)}
+                modifier: [(modifier "chained_declaration") if { ctx.is_chained }]
                 pattern: {pattern}
                 type: {ty}
                 value: {ctx.reset(); val})
@@ -474,7 +462,7 @@ fn translation_rules() -> Vec<Rule<SwiftContext>> {
         rule!(
             (enumCaseParameter firstName: _? @@name type: @ty)
             =>
-            (parameter pattern: (identifier #{name})? type: {ty})
+            (parameter pattern: [(identifier #{name})] type: {ty})
         ),
         // An enum element with associated values (`case circle(radius: Double)`)
         // becomes a nested `class_like_declaration` whose constructor carries the
@@ -496,7 +484,7 @@ fn translation_rules() -> Vec<Rule<SwiftContext>> {
                     location: {clause}));
                 tree!((class_like_declaration
                     modifier: {ctx.outer_modifiers.clone()}
-                    modifier: {chained_modifier(&mut ctx)}
+                    modifier: [(modifier "chained_declaration") if { ctx.is_chained }]
                     modifier: (modifier "enum_case")
                     name_node: (identifier #{name})
                     member: {constructor}))
@@ -507,7 +495,7 @@ fn translation_rules() -> Vec<Rule<SwiftContext>> {
             =>
             (variable_declaration
                 modifier: {ctx.outer_modifiers.clone()}
-                modifier: {chained_modifier(&mut ctx)}
+                modifier: [(modifier "chained_declaration") if { ctx.is_chained }]
                 modifier: (modifier "enum_case")
                 pattern: (identifier #{name})
                 value: {val})
@@ -517,7 +505,7 @@ fn translation_rules() -> Vec<Rule<SwiftContext>> {
             =>
             (variable_declaration
                 modifier: {ctx.outer_modifiers.clone()}
-                modifier: {chained_modifier(&mut ctx)}
+                modifier: [(modifier "chained_declaration") if { ctx.is_chained }]
                 modifier: (modifier "enum_case")
                 pattern: (identifier #{name}))
         ),
@@ -566,7 +554,7 @@ fn translation_rules() -> Vec<Rule<SwiftContext>> {
         rule!(
             (tuplePatternElement label: _? @@label pattern: @p)
             =>
-            (argument name_node: (identifier #{label})? value: {p})
+            (argument name_node: [(identifier #{label})] value: {p})
         ),
         // A type-casting pattern (`case is T`). Not yet supported, so it is
         // mapped to `unsupported_node` — an explicit reminder that this needs
@@ -720,7 +708,7 @@ fn translation_rules() -> Vec<Rule<SwiftContext>> {
         rule!(
             (labeledExpr label: _? @@lbl expression: @val)
             =>
-            (argument name_node: (identifier #{lbl})? value: {val})
+            (argument name_node: [(identifier #{lbl})] value: {val})
         ),
         // An additional labeled trailing closure, such as the `c: { ... }` in
         // `foo { 42 } c: { ... }`, is turned into an argument to the function.
@@ -781,8 +769,8 @@ fn translation_rules() -> Vec<Rule<SwiftContext>> {
         // value; `break` / `continue` an optional target label; `throw` its
         // thrown expression.
         rule!((returnStmt expression: _? @val) => (return_expr value: {val})),
-        rule!((breakStmt label: _? @@lbl) => (break_expr label_name_node: (identifier #{lbl})?)),
-        rule!((continueStmt label: _? @@lbl) => (continue_expr label_name_node: (identifier #{lbl})?)),
+        rule!((breakStmt label: _? @@lbl) => (break_expr label_name_node: [(identifier #{lbl})])),
+        rule!((continueStmt label: _? @@lbl) => (continue_expr label_name_node: [(identifier #{lbl})])),
         rule!((throwStmt expression: @val) => (throw_expr value: {val})),
         // ---- Closures ----
         // A closure (`{ (x: Int) -> Int in … }`) becomes a `function_expr`. The
@@ -816,7 +804,7 @@ fn translation_rules() -> Vec<Rule<SwiftContext>> {
                 initializer: (initializerClause value: @val)?)
             =>
             (variable_declaration
-                modifier: (modifier #{spec})?
+                modifier: [(modifier #{spec})]
                 pattern: (identifier #{name})
                 value: {
                     // Expand [x] into [x = x]
@@ -1127,20 +1115,16 @@ fn translation_rules() -> Vec<Rule<SwiftContext>> {
             =>
             import_declaration {
                 let last = *parts.last().ok_or("import has no path")?;
-                let pattern = match kind {
-                    None => {
-                        let bulk = tree!((bulk_importing_pattern location: {decl}));
-                        tree!((named_pattern
-                            name_node: (identifier #{last})
-                            sub_pattern: {bulk}))
-                    }
-                    Some(_) => tree!((identifier #{last})),
-                };
                 tree!((import_declaration
-                    modifier: (modifier #{kind})?
+                    modifier: [(modifier #{kind})]
                     modifier: {attrs}
                     modifier: {mods}
-                    pattern: {pattern}
+                    pattern: [
+                        (identifier #{last}) if { kind.is_some() }
+                        (named_pattern
+                            name_node: (identifier #{last})
+                            sub_pattern: (bulk_importing_pattern location: {decl}))
+                    ]
                     imported_expr: {member_chain(&mut ctx, parts)}))
             }
         ),
@@ -1247,13 +1231,11 @@ fn translation_rules() -> Vec<Rule<SwiftContext>> {
                 firstName: _? @@name
                 type: @ty)
             =>
-            argument {
-                if ctx.in_function_type {
-                    tree!((parameter external_name_node: (identifier #{name})? type: {ty}))
-                } else {
-                    tree!((argument name_node: (identifier #{name})? value: {ty}))
-                }
-            }
+            [
+                (parameter external_name_node: [(identifier #{name})] type: {ty})
+                    if { ctx.in_function_type }
+                (argument name_node: [(identifier #{name})] value: {ty})
+            ]
         ),
         // A nominal type's `inheritanceClause` (`: Base, Proto`) becomes a list
         // of `base_type`s, one per inherited type. Each declaration keyword
@@ -1267,7 +1249,7 @@ fn translation_rules() -> Vec<Rule<SwiftContext>> {
             =>
             (type_parameter
                 modifier: {attrs}
-                modifier: (modifier #{spec})?
+                modifier: [(modifier #{spec})]
                 name_node: (identifier #{name})
                 bound: {bound})
         ),