Merge pull request #133 from oli-obk/cleanups

Make parser errors readable in ui tests

Author: nikomatsakis

Cargo.toml

@@ -22,6 +22,7 @@ formality-rust = { version = "0.1.0", path = "crates/formality-rust" }
 formality-types = { version = "0.1.0", path = "crates/formality-types" }
 formality-check = { version = "0.1.0", path = "crates/formality-check" }
 formality-prove = { version = "0.1.0", path = "crates/formality-prove" }
+formality-core = { version = "0.1.0", path = "crates/formality-core" }
 ui_test = "0.12"
 
 [workspace]

crates/formality-types/src/parse.rs

@@ -14,6 +14,15 @@ mod test;
 /// Parses `text` as a term with no bindings in scope.
 #[track_caller]
 pub fn term<T>(text: &str) -> T
+where
+    T: Parse,
+{
+    try_term(text).unwrap()
+}
+
+/// Parses `text` as a term with no bindings in scope.
+#[track_caller]
+pub fn try_term<T>(text: &str) -> anyhow::Result<T>
 where
     T: Parse,
 {
@@ -25,7 +34,7 @@ where
 /// References to the given string will be replaced with the given parameter
 /// when parsing types, lifetimes, etc.
 #[track_caller]
-pub fn term_with<T, B>(bindings: impl IntoIterator<Item = B>, text: &str) -> T
+pub fn term_with<T, B>(bindings: impl IntoIterator<Item = B>, text: &str) -> anyhow::Result<T>
 where
     T: Parse,
     B: Upcast<(String, Parameter)>,
@@ -34,13 +43,17 @@ where
     let (t, remainder) = match T::parse(&scope, text) {
         Ok(v) => v,
         Err(errors) => {
-            panic!("failed to parse {text:?}: {errors:#?}");
+            let mut err = anyhow::anyhow!("failed to parse {text}");
+            for error in errors {
+                err = err.context(error.text.to_owned()).context(error.message);
+            }
+            return Err(err);
         }
     };
     if !skip_whitespace(remainder).is_empty() {
-        panic!("extra tokens after parsing {text:?} to {t:?}: {remainder:?}");
+        anyhow::bail!("extra tokens after parsing {text:?} to {t:?}: {remainder:?}");
     }
-    t
+    Ok(t)
 }
 
 /// Trait for parsing a [`Term`](`crate::term::Term`) as input.

src/lib.rs

@@ -4,7 +4,7 @@ use clap::Parser;
 use formality_check::check_all_crates;
 use formality_prove::{test_util::TestAssertion, Constraints};
 use formality_rust::grammar::Program;
-use formality_types::{collections::Set, parse::term};
+use formality_types::{collections::Set, parse::try_term};
 
 #[derive(Parser, Debug)]
 #[command(author, version, about, long_about = None)]
@@ -30,7 +30,7 @@ struct Args {
 pub fn main() -> anyhow::Result<()> {
     let args = Args::parse();
     let input: String = std::fs::read_to_string(&args.input_path)?;
-    let program: Program = term(&input);
+    let program: Program = try_term(&input)?;
 
     if args.print_rust {
         eprintln!("{:#?}", program);
@@ -40,14 +40,14 @@ pub fn main() -> anyhow::Result<()> {
 }
 
 pub fn test_program_ok(input: &str) -> anyhow::Result<()> {
-    let program: Program = term(&input);
+    let program: Program = try_term(&input)?;
     check_all_crates(&program)
 }
 
 pub fn test_where_clause(program: &str, assertion: &str) -> anyhow::Result<Set<Constraints>> {
-    let program: Program = term(&program);
+    let program: Program = try_term(&program)?;
     check_all_crates(&program)?;
-    let assertion: Arc<TestAssertion> = term(assertion);
+    let assertion: Arc<TestAssertion> = try_term(assertion)?;
     let decls = program.to_prove_decls();
     Ok(formality_prove::test_util::test_prove(decls, assertion))
 }

src/main.rs

@@ -1,3 +1,3 @@
 fn main() -> anyhow::Result<()> {
-    formality::main()
+    formality_core::with_tracing_logs(|| formality::main())
 }

tests/ui/parser.stderr

@@ -0,0 +1,13 @@
+Error: expected `:`
+
+Caused by:
+    0:  ] {}
+           }
+       ]
+       
+    1: failed to parse [
+           crate Foo {        
+               trait Baz<> where [ cake ] {}
+           }
+       ]
+       

tests/ui/parser.🔬

@@ -0,0 +1,5 @@
+[
+    crate Foo {        
+        trait Baz<> where [ cake ] {}
+    }
+]