yeast: Make translation failures panic

We catch any panics in `Runner::run_once`, and turn them into `Err`
results. This prevents them from affecting the extraction of other
files.

Author: tausbn

shared/yeast-macros/src/lower.rs

@@ -85,18 +85,18 @@ impl Rule {
                         #(#guard_bindings)*
                         let ast = __ast;
                         let #ctx = __user_ctx;
-                        Ok(#guard)
+                        let __guard: bool = #guard;
+                        __guard
                     }),
                     Box::new(|__ast: &yeast::Ast, __output: &mut yeast::OutputAst, __captures: yeast::captures::Captures, __source_range: Option<yeast::Range>, __user_ctx: &mut _, __translator: yeast::TranslatorHandle<'_, _>| {
                         let __skip: &[&str] = &[#(#raw_capture_names),*];
                         let __translated_captures =
-                            __translator.translate_captures(&__captures, __ast, __output, __user_ctx, __skip)?;
+                            __translator.translate_captures(&__captures, __ast, __output, __user_ctx, __skip);
                         #(#raw_bindings)*
                         #(#translated_bindings)*
                         let mut #ctx = yeast::build::BuildCtx::with_translator(__ast, __output, __source_range, __user_ctx, __translator);
                         let __result: Vec<yeast::OutputId> = { #replacement };
-                        let __result = #ctx.finish_rule(__result)?;
-                        Ok(__result)
+                        #ctx.finish_rule(__result)
                     }),
                 )
             }

shared/yeast/src/build.rs

@@ -28,7 +28,7 @@ use crate::{
 /// When constructed by the framework (via the rule! macro), `BuildCtx` also
 /// carries a [`TranslatorHandle`] that the [`translate`] method delegates
 /// to. When constructed by hand (e.g. in tests), the translator is `None`
-/// and [`translate`] returns an error.
+/// and [`translate`] panics.
 pub struct BuildCtx<'a, C: 'a = ()> {
     ast: &'a Ast,
     pub output: &'a mut OutputAst,
@@ -44,10 +44,6 @@ pub struct BuildCtx<'a, C: 'a = ()> {
     /// Optional translator handle, populated when the context is built by
     /// the framework's rule driver. None when the context is built by hand.
     pub(crate) translator: Option<TranslatorHandle<'a, C>>,
-    /// First failure encountered while auto-translating an input `Id` during
-    /// template construction. Templates remain infallible expressions, so
-    /// [`finish_rule`](Self::finish_rule) returns this error at the rule boundary.
-    deferred_translation_error: Option<String>,
     /// Nodes built directly through this context without an explicit source
     /// range in either their content or constructor argument. Recursive
     /// translations use their own context and therefore do not contribute to
@@ -64,7 +60,6 @@ impl<'a, C> BuildCtx<'a, C> {
             source_range: None,
             user_ctx,
             translator: None,
-            deferred_translation_error: None,
             created_nodes_without_source_range: BTreeSet::new(),
         }
     }
@@ -82,7 +77,6 @@ impl<'a, C> BuildCtx<'a, C> {
             source_range,
             user_ctx,
             translator: None,
-            deferred_translation_error: None,
             created_nodes_without_source_range: BTreeSet::new(),
         }
     }
@@ -102,7 +96,6 @@ impl<'a, C> BuildCtx<'a, C> {
             source_range,
             user_ctx,
             translator: Some(translator),
-            deferred_translation_error: None,
             created_nodes_without_source_range: BTreeSet::new(),
         }
     }
@@ -159,18 +152,15 @@ impl<'a, C> BuildCtx<'a, C> {
     /// Finish the current rule invocation by applying the matched source range
     /// to locally-created result roots.
     #[doc(hidden)]
-    pub fn finish_rule(self, results: Vec<OutputId>) -> Result<Vec<OutputId>, String> {
-        if let Some(error) = self.deferred_translation_error {
-            return Err(error);
-        }
+    pub fn finish_rule(self, results: Vec<OutputId>) -> Vec<OutputId> {
         if let Some(source_range) = self.source_range {
             for &id in &results {
                 if self.created_nodes_without_source_range.contains(&id) {
                     self.output.extend_source_range(id, source_range);
                 }
             }
         }
-        Ok(results)
+        results
     }
 
     /// Assign an explicit source range to a newly-built result root.
@@ -300,40 +290,31 @@ impl<C: Clone> BuildCtx<'_, C> {
 
     #[doc(hidden)]
     pub fn translate_into(&mut self, id: Id, out: &mut Vec<OutputId>) {
-        if self.deferred_translation_error.is_some() {
-            return;
-        }
-        match self.translate(id) {
-            Ok(ids) => out.extend(ids),
-            Err(error) => self.deferred_translation_error = Some(error),
-        }
+        out.extend(self.translate(id));
     }
 
     /// Recursively translate every id in the given iterable via the
     /// framework's rule machinery and return the accumulated resulting node
     /// ids in order.
     ///
     /// The single-`Id` case works too, because `Id: IntoIterator<Item
-    /// = Id>` is a singleton iterator — so `ctx.translate(some_id)?`
+    /// = Id>` is a singleton iterator — so `ctx.translate(some_id)`
     /// returns a `Vec<OutputId>` containing whatever `some_id` translated to.
     ///
-    /// Errors if this `BuildCtx` was constructed by hand (without a
+    /// Panics if this `BuildCtx` was constructed by hand (without a
     /// translator handle) — for example, in unit tests that don't go
     /// through the rule driver.
-    pub fn translate(
-        &mut self,
-        ids: impl IntoIterator<Item = Id>,
-    ) -> Result<Vec<OutputId>, String> {
+    pub fn translate(&mut self, ids: impl IntoIterator<Item = Id>) -> Vec<OutputId> {
         let translator = self
             .translator
             .as_ref()
-            .ok_or("translate() called on a BuildCtx without a translator handle")?;
+            .expect("translate() called on a BuildCtx without a translator handle");
         let mut out = Vec::new();
         for id in ids {
-            let translated = translator.translate(self.ast, self.output, self.user_ctx, id)?;
+            let translated = translator.translate(self.ast, self.output, self.user_ctx, id);
             out.extend(translated);
         }
-        Ok(out)
+        out
     }
 
     /// Run `f` with a temporary child [`BuildCtx`] whose `user_ctx` is
@@ -358,9 +339,9 @@ impl<C: Clone> BuildCtx<'_, C> {
     /// let val = ctx.scoped(|ctx| {
     ///     ctx.reset();
     ///     ctx.translate(val)
-    /// })?;
+    /// });
     /// // `ctx` here is untouched by the reset inside the closure.
-    /// let other = ctx.translate(other_id)?;
+    /// let other = ctx.translate(other_id);
     /// ```
     pub fn scoped<F, R>(&mut self, f: F) -> R
     where
@@ -373,15 +354,11 @@ impl<C: Clone> BuildCtx<'_, C> {
             source_range: self.source_range,
             user_ctx: &mut child_user_ctx,
             translator: self.translator,
-            deferred_translation_error: None,
             created_nodes_without_source_range: BTreeSet::new(),
         };
         let result = f(&mut child);
         let created_nodes_without_source_range =
             std::mem::take(&mut child.created_nodes_without_source_range);
-        if self.deferred_translation_error.is_none() {
-            self.deferred_translation_error = child.deferred_translation_error.take();
-        }
         drop(child);
         self.created_nodes_without_source_range
             .extend(created_nodes_without_source_range);

shared/yeast/src/captures.rs

@@ -54,23 +54,23 @@ impl Captures {
         self.captures.entry(key).or_default().push(id);
     }
 
-    pub(crate) fn try_translate_except<E>(
+    pub(crate) fn translate_except(
         &self,
         skip: &[&str],
-        mut f: impl FnMut(Id) -> Result<Vec<OutputId>, E>,
-    ) -> Result<TranslatedCaptures, E> {
+        mut f: impl FnMut(Id) -> Vec<OutputId>,
+    ) -> TranslatedCaptures {
         let mut translated = TranslatedCaptures::new();
         for (name, ids) in &self.captures {
             if skip.contains(name) {
                 continue;
             }
             for &id in ids {
-                for translated_id in f(id)? {
+                for translated_id in f(id) {
                     translated.insert(name, translated_id);
                 }
             }
         }
-        Ok(translated)
+        translated
     }
 
     pub fn merge(&mut self, other: &Captures) {

shared/yeast/src/lib.rs

@@ -1145,7 +1145,7 @@ impl<'a, C: Clone> TranslatorHandle<'a, C> {
         output: &mut OutputAst,
         user_ctx: &mut C,
         id: Id,
-    ) -> Result<Vec<OutputId>, String> {
+    ) -> Vec<OutputId> {
         apply_rules_inner(
             self.index,
             ast,
@@ -1163,10 +1163,10 @@ impl<'a, C: Clone> TranslatorHandle<'a, C> {
         output: &mut OutputAst,
         user_ctx: &mut C,
         skip: &[&str],
-    ) -> Result<TranslatedCaptures, String> {
-        captures.try_translate_except(skip, |id| {
+    ) -> TranslatedCaptures {
+        captures.translate_except(skip, |id| {
             if id == self.matched_root {
-                Err("cannot eagerly translate a capture of the matched rule root".to_string())
+                panic!("cannot eagerly translate a capture of the matched rule root")
             } else {
                 self.translate(ast, output, user_ctx, id)
             }
@@ -1178,7 +1178,7 @@ impl<'a, C: Clone> TranslatorHandle<'a, C> {
 ///
 /// Takes the immutable input AST, mutable output AST, raw captured variables,
 /// source range of the matched node, mutable user context, and a
-/// [`TranslatorHandle`]. Returns output IDs or an error.
+/// [`TranslatorHandle`]. Returns output IDs.
 ///
 /// Transforms receive raw input captures. Macro-generated transforms eagerly
 /// translate `@` captures and translate raw ids when they are returned or
@@ -1191,7 +1191,7 @@ pub type Transform<C = ()> = Box<
             Option<Range>,
             &mut C,
             TranslatorHandle<'_, C>,
-        ) -> Result<Vec<OutputId>, String>
+        ) -> Vec<OutputId>
         + Send
         + Sync,
 >;
@@ -1200,7 +1200,7 @@ pub type Transform<C = ()> = Box<
 /// runs. Returning `false` makes the rule behave as if its query did not
 /// match, so the driver continues to the next rule. Guards have read-only
 /// access to the shared user context.
-pub type Guard<C = ()> = Box<dyn Fn(&Ast, &Captures, &C) -> Result<bool, String> + Send + Sync>;
+pub type Guard<C = ()> = Box<dyn Fn(&Ast, &Captures, &C) -> bool + Send + Sync>;
 
 pub struct Rule<C = ()> {
     query: QueryNode,
@@ -1238,21 +1238,21 @@ impl<C> Rule<C> {
     /// Attempt to match this rule's query against `node`, returning the raw
     /// captures on success. Does not evaluate the guard or invoke the
     /// transform.
-    fn match_query(&self, ast: &Ast, node: Id) -> Result<Option<Captures>, String> {
+    fn match_query(&self, ast: &Ast, node: Id) -> Option<Captures> {
         let mut captures = Captures::new();
-        if !self.query.do_match(ast, node, &mut captures)? {
-            return Ok(None);
+        if !self.query.do_match(ast, node, &mut captures) {
+            return None;
         }
-        Ok(Some(captures))
+        Some(captures)
     }
 
     /// Evaluate this rule's guard against a successful query match. An
     /// unguarded rule always succeeds.
-    fn guard_matches(&self, ast: &Ast, captures: &Captures, user_ctx: &C) -> Result<bool, String> {
+    fn guard_matches(&self, ast: &Ast, captures: &Captures, user_ctx: &C) -> bool {
         if let Some(guard) = &self.guard {
             guard(ast, captures, user_ctx)
         } else {
-            Ok(true)
+            true
         }
     }
 
@@ -1266,7 +1266,7 @@ impl<C> Rule<C> {
         node: Id,
         user_ctx: &mut C,
         translator: TranslatorHandle<'_, C>,
-    ) -> Result<Vec<OutputId>, String> {
+    ) -> Vec<OutputId> {
         let source_range = ast.source_range_ignoring_fields(node, &self.ignored_location_fields);
         (self.transform)(ast, output, captures, source_range, user_ctx, translator)
     }
@@ -1306,14 +1306,14 @@ impl<'a, C> RuleIndex<'a, C> {
 
 /// Apply the first matching rule to each visited node. Recursion proceeds
 /// only through captured nodes (not through the input node's children
-/// directly), and an error is returned if no rule matches a visited node.
+/// directly), and panics if no rule matches a visited node.
 fn apply_rules<C: Clone>(
     rules: &[Rule<C>],
     ast: &Ast,
     output: &mut OutputAst,
     user_ctx: &mut C,
     id: Id,
-) -> Result<Vec<OutputId>, String> {
+) -> Vec<OutputId> {
     let index = RuleIndex::new(rules);
     apply_rules_inner(&index, ast, output, user_ctx, id, 0)
 }
@@ -1325,22 +1325,22 @@ fn apply_rules_inner<C: Clone>(
     user_ctx: &mut C,
     id: Id,
     rewrite_depth: usize,
-) -> Result<Vec<OutputId>, String> {
+) -> Vec<OutputId> {
     if rewrite_depth > MAX_REWRITE_DEPTH {
-        return Err(format!(
+        panic!(
             "Desugaring exceeded maximum rewrite depth ({MAX_REWRITE_DEPTH}). \
              This likely indicates a non-terminating rule cycle."
-        ));
+        );
     }
 
     let node_kind = ast.get_node(id).map(|n| n.kind_name()).unwrap_or("");
 
     for rule in index.rules_for_kind(node_kind) {
-        let Some(captures) = rule.match_query(ast, id)? else {
+        let Some(captures) = rule.match_query(ast, id) else {
             continue;
         };
 
-        if !rule.guard_matches(ast, &captures, user_ctx)? {
+        if !rule.guard_matches(ast, &captures, user_ctx) {
             continue;
         }
 
@@ -1355,11 +1355,11 @@ fn apply_rules_inner<C: Clone>(
             rewrite_depth,
             matched_root: id,
         };
-        let result = rule.run_transform(ast, output, captures, id, &mut local, translator)?;
-        return Ok(result);
+        let result = rule.run_transform(ast, output, captures, id, &mut local, translator);
+        return result;
     }
 
-    Err(format!("no rule matched node of kind '{node_kind}'"))
+    panic!("no rule matched node of kind '{node_kind}'")
 }
 
 /// A named bundle of exhaustive rules for the one-shot translation pass.
@@ -1617,23 +1617,40 @@ impl<'a, C: Clone> Runner<'a, C> {
     }
 
     fn run_once(&self, ast: Ast, user_ctx: &mut C) -> Result<OutputAst, String> {
-        if self.phases.len() != 1 {
-            return Err("YEAST requires exactly one translation phase".to_string());
-        }
+        std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
+            self.run_once_inner(ast, user_ctx)
+        }))
+        .map(Ok)
+        .unwrap_or_else(|payload| {
+            let message = if let Some(message) = payload.downcast_ref::<&str>() {
+                (*message).to_owned()
+            } else if let Some(message) = payload.downcast_ref::<String>() {
+                message.clone()
+            } else {
+                "unknown panic payload".to_owned()
+            };
+            Err(format!("YEAST translation panicked: {message}"))
+        })
+    }
+
+    fn run_once_inner(&self, ast: Ast, user_ctx: &mut C) -> OutputAst {
+        assert_eq!(
+            self.phases.len(),
+            1,
+            "YEAST requires exactly one translation phase"
+        );
         let phase = &self.phases[0];
         let mut output = OutputAst::with_schema(self.schema.clone());
-        let res = apply_rules(&phase.rules, &ast, &mut output, user_ctx, ast.get_root())
-            .map_err(|e| format!("Phase `{}`: {e}", phase.name))?;
-        if res.len() != 1 {
-            return Err(format!(
-                "Phase `{}`: expected exactly one result node, got {}",
-                phase.name,
-                res.len()
-            ));
-        }
+        let res = apply_rules(&phase.rules, &ast, &mut output, user_ctx, ast.get_root());
+        assert_eq!(
+            res.len(),
+            1,
+            "expected exactly one result node, got {}",
+            res.len()
+        );
         output.set_root(res[0]);
         output.set_source(ast.into_source());
-        Ok(output)
+        output
     }
 }