yeast: Catch translation panics before they get printed

When `panic!` gets called, the default Rust panic handler prints out the
error (and possibly a backtrace) to stderr. This means even if we handle
the panics in `run_once`, we still get the printed output.

To avoid this, we use `resume_unwind` (which foregoes the default
behaviour) instead, and add a helper function called
`translation_failure` that takes care of the places where translation
could previously panic.

Author: tausbn

shared/yeast/src/lib.rs

@@ -20,6 +20,13 @@ pub use yeast_macros::{query, rule, rules, tree, trees};
 use captures::{Captures, TranslatedCaptures};
 use query::QueryNode;
 
+#[derive(Debug)]
+struct TranslationFailure(String);
+
+pub(crate) fn translation_failure(message: impl Into<String>) -> ! {
+    std::panic::resume_unwind(Box::new(TranslationFailure(message.into())))
+}
+
 impl From<tree_sitter::Point> for Point {
     fn from(p: tree_sitter::Point) -> Self {
         Point {
@@ -1166,7 +1173,7 @@ impl<'a, C: Clone> TranslatorHandle<'a, C> {
     ) -> TranslatedCaptures {
         captures.translate_except(skip, |id| {
             if id == self.matched_root {
-                panic!("cannot eagerly translate a capture of the matched rule root")
+                translation_failure("cannot eagerly translate a capture of the matched rule root")
             } else {
                 self.translate(ast, output, user_ctx, id)
             }
@@ -1327,10 +1334,10 @@ fn apply_rules_inner<C: Clone>(
     rewrite_depth: usize,
 ) -> Vec<OutputId> {
     if rewrite_depth > MAX_REWRITE_DEPTH {
-        panic!(
+        translation_failure(format!(
             "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("");
@@ -1359,7 +1366,7 @@ fn apply_rules_inner<C: Clone>(
         return result;
     }
 
-    panic!("no rule matched node of kind '{node_kind}'")
+    translation_failure(format!("no rule matched node of kind '{node_kind}'"))
 }
 
 /// A named bundle of exhaustive rules for the one-shot translation pass.
@@ -1617,37 +1624,39 @@ impl<'a, C: Clone> Runner<'a, C> {
     }
 
     fn run_once(&self, ast: Ast, user_ctx: &mut C) -> Result<OutputAst, String> {
-        std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
+        match 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}"))
-        })
+        })) {
+            Ok(output) => Ok(output),
+            Err(payload) => match payload.downcast::<TranslationFailure>() {
+                Ok(failure) => Err(failure.0),
+                Err(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"
-        );
+        if self.phases.len() != 1 {
+            translation_failure("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());
-        assert_eq!(
-            res.len(),
-            1,
-            "expected exactly one result node, got {}",
-            res.len()
-        );
+        if res.len() != 1 {
+            translation_failure(format!(
+                "expected exactly one result node, got {}",
+                res.len()
+            ));
+        }
         output.set_root(res[0]);
         output.set_source(ast.into_source());
         output

shared/yeast/src/query.rs

@@ -79,16 +79,16 @@ impl QueryNode {
             }
             QueryNode::Node { kind, children } => {
                 let node = ast.get_node(node).unwrap();
-                let target_kind = ast
-                    .id_for_node_kind(kind)
-                    .unwrap_or_else(|| panic!("Node kind {kind} not found in language"));
+                let target_kind = ast.id_for_node_kind(kind).unwrap_or_else(|| {
+                    crate::translation_failure(format!("Node kind {kind} not found in language"))
+                });
                 if node.kind != target_kind {
                     return false;
                 }
                 for (field, field_children) in children {
-                    let field_id = ast
-                        .field_id_for_name(field)
-                        .unwrap_or_else(|| panic!("Field {field} not found in language"));
+                    let field_id = ast.field_id_for_name(field).unwrap_or_else(|| {
+                        crate::translation_failure(format!("Field {field} not found in language"))
+                    });
                     let empty = Vec::new();
                     let mut child_iter =
                         node.fields.get(&field_id).unwrap_or(&empty).iter().cloned();
@@ -100,9 +100,11 @@ impl QueryNode {
             }
             QueryNode::UnnamedNode { kind } => {
                 let node = ast.get_node(node).unwrap();
-                let target_kind = ast
-                    .id_for_unnamed_node_kind(kind)
-                    .unwrap_or_else(|| panic!("unnamed Node kind {kind} not found in language"));
+                let target_kind = ast.id_for_unnamed_node_kind(kind).unwrap_or_else(|| {
+                    crate::translation_failure(format!(
+                        "unnamed Node kind {kind} not found in language"
+                    ))
+                });
                 node.kind == target_kind
             }
             QueryNode::Capture {

shared/yeast/tests/test.rs

@@ -1385,10 +1385,7 @@ fn test_translation_phase_errors_when_no_rule_matches() {
     let err = runner
         .run("x = 1")
         .expect_err("expected translation to error on unmatched node");
-    assert!(
-        err.contains("no rule matched") && err.contains("integer"),
-        "error should describe the unmatched node kind, got: {err}"
-    );
+    assert_eq!(err, "no rule matched node of kind 'integer'");
 }
 
 #[test]