Collect and display all detected errors in an input document

Cargo.toml

@@ -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" ]

src/main.rs

@@ -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/parsing/mod.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)
         }
     }
 }