Collect and display all detected errors in an input document (#76)

Until now we have just exited on detecting the first parsing or
validation error, but the forthcoming language server will need to know
where all the problems are. So the next step in maturing the parser is
collecting more than a single error at a time when checking the validity
of a document.

The Parser state object is updated to include a Vec<ParsingError> that
the parser (and subparsers) can contribute to.

Finally, when reporting errors we deduplicate, with more specific
messages overriding enclosing general ones. This is an admittedly rare
occurrence, as usually fail-fast short-circuiting will cause a single
error to propagate, but in the event nesting results in multiple errors
at the same site we trim it down to a single message.

Author: istathar

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "technique"
-version = "0.4.0"
+version = "0.4.1"
 edition = "2021"
 description = "A domain specific language for procedures."
 authors = [ "Andrew Cowie" ]

Cargo.toml

@@ -160,16 +160,26 @@ fn main() {
                     std::process::exit(1);
                 }
             };
+
             let technique = match parsing::parse(&filename, &content) {
                 Ok(document) => document,
-                Err(error) => {
-                    eprintln!(
-                        "{}",
-                        problem::full_parsing_error(&error, &filename, &content, &Terminal)
-                    );
+                Err(errors) => {
+                    for (i, error) in errors
+                        .iter()
+                        .enumerate()
+                    {
+                        if i > 0 {
+                            eprintln!();
+                        }
+                        eprintln!(
+                            "{}",
+                            problem::full_parsing_error(&error, &filename, &content, &Terminal)
+                        );
+                    }
                     std::process::exit(1);
                 }
             };
+
             // TODO continue with validation of the returned technique
 
             eprintln!("{}", "ok".bright_green());
@@ -205,12 +215,26 @@ fn main() {
                     std::process::exit(1);
                 }
             };
+
             let technique = match parsing::parse(&filename, &content) {
                 Ok(document) => document,
-                Err(error) => {
+                Err(errors) => {
+                    for (i, error) in errors
+                        .iter()
+                        .enumerate()
+                    {
+                        if i > 0 {
+                            eprintln!();
+                        }
+                        eprintln!(
+                            "{}",
+                            problem::concise_parsing_error(&error, &filename, &content, &Terminal)
+                        );
+                    }
+
                     eprintln!(
-                        "{}",
-                        problem::concise_parsing_error(&error, &filename, &content, &Terminal)
+                        "\nUnable to parse input file. Try `technique check {}` for details.",
+                        &filename.to_string_lossy()
                     );
                     std::process::exit(1);
                 }
@@ -251,16 +275,27 @@ fn main() {
                     std::process::exit(1);
                 }
             };
+
             let technique = match parsing::parse(&filename, &content) {
                 Ok(document) => document,
-                Err(error) => {
+                Err(errors) => {
                     // It is possible that we will want to render the error
                     // into the PDF document rather than crashing here. We'll
                     // see in the future.
-                    eprintln!(
-                        "{}",
-                        problem::full_parsing_error(&error, &filename, &content, &Terminal)
-                    );
+
+                    for (i, error) in errors
+                        .iter()
+                        .enumerate()
+                    {
+                        if i > 0 {
+                            eprintln!();
+                        }
+
+                        eprintln!(
+                            "{}",
+                            problem::concise_parsing_error(&error, &filename, &content, &Terminal)
+                        );
+                    }
                     std::process::exit(1);
                 }
             };

src/main.rs

@@ -35,9 +35,10 @@ pub fn load(filename: &Path) -> Result<String, LoadingError<'_>> {
     }
 }
 
-/// Parse text into a Technique object, or error out.
-pub fn parse<'i>(filename: &'i Path, content: &'i str) -> Result<Document<'i>, ParsingError<'i>> {
-    let result = parser::parse_via_taking(filename, content);
+/// Parse text into a Document object, or return the list of errors
+/// encountered.
+pub fn parse<'i>(filename: &'i Path, content: &'i str) -> Result<Document<'i>, Vec<ParsingError>> {
+    let result = parser::parse_with_recovery(filename, content);
 
     match result {
         Ok(document) => {
@@ -66,9 +67,9 @@ pub fn parse<'i>(filename: &'i Path, content: &'i str) -> Result<Document<'i>, P
             }
             Ok(document)
         }
-        Err(error) => {
-            debug!("error: {:?}", error);
-            Err(error)
+        Err(errors) => {
+            debug!("errors: {}", errors.len());
+            Err(errors)
         }
     }
 }