yeast: Get rid of postfix ? operator

This will be superseded by the next commit, which generalised the
mechanism and also makes the implementation simpler.

Author: tausbn

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 {

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

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]));

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! {

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