Update public functions to return list of errors

Author: istathar

src/parsing/mod.rs

@@ -35,9 +35,13 @@ 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<'i>>> {
+    let result = parser::parse_with_recovery(filename, content);
 
     match result {
         Ok(document) => {
@@ -66,9 +70,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)
         }
     }
 }

src/parsing/parser.rs

@@ -4,36 +4,35 @@ use crate::language::*;
 use crate::regex::*;
 
 #[derive(Debug, PartialEq, Eq)]
-pub struct ParseResult<'i> {
+struct ParseResult<'i> {
     pub document: Document<'i>,
     pub errors: Vec<ParsingError<'i>>,
 }
 
-impl<'i> ParseResult<'i> {
-    pub fn has_errors(&self) -> bool {
-        !self
-            .errors
-            .is_empty()
-    }
-}
-
-pub fn parse_with_recovery<'i>(path: &'i Path, content: &'i str) -> ParseResult<'i> {
-    let mut input = Parser::new();
-    input.filename(path);
-    input.initialize(content);
-
-    input.parse_collecting_errors()
-}
-
-pub fn parse_via_taking<'i>(
+// This could be adapted to return both the partial document and the errors.
+// But for our purposes if the parse fails then there's no point trying to do
+// deeper validation or analysis; the input syntax is broken and the user
+// needs to fix it. Should a partial parse turn out have meaning then the
+// return type of this can change to ParseResult<'i> but for now it is fine
+// to use Result.
+pub fn parse_with_recovery<'i>(
     path: &'i Path,
     content: &'i str,
-) -> Result<Document<'i>, ParsingError<'i>> {
+) -> Result<Document<'i>, Vec<ParsingError<'i>>> {
     let mut input = Parser::new();
     input.filename(path);
     input.initialize(content);
 
-    input.parse_from_start()
+    let result = input.parse_collecting_errors();
+
+    if result
+        .errors
+        .is_empty()
+    {
+        Ok(result.document)
+    } else {
+        Err(result.errors)
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -140,8 +139,12 @@ impl<'i> Parser<'i> {
         self.offset += width;
     }
 
-    fn parse_from_start(&mut self) -> Result<Document<'i>, ParsingError<'i>> {
-        // Check if header is present by looking for magic line
+    fn parse_collecting_errors(&mut self) -> ParseResult<'i> {
+        // Clear any existing errors
+        self.problems
+            .clear();
+
+        // Parse header, collecting errors instead of propagating
         let header = if is_magic_line(self.source) {
             Some(self.read_technique_header()?)
         } else {

tests/parsing/parser.rs

@@ -4,7 +4,7 @@ mod verify {
     use std::vec;
 
     use technique::language::*;
-    use technique::parsing::parser::{self, Parser};
+    use technique::parsing::parser::Parser;
 
     fn trim(s: &str) -> &str {
         s.strip_prefix('\n')
@@ -1089,7 +1089,7 @@ before_leaving :
 
     #[test]
     fn section_parsing() {
-        let result = technique::parsing::parser::parse_via_taking(
+        let result = technique::parsing::parser::parse_with_recovery(
             Path::new(""),
             trim(
                 r#"
@@ -1177,7 +1177,7 @@ second_section_second_procedure :
 
     #[test]
     fn section_with_procedures_only() {
-        let result = technique::parsing::parser::parse_via_taking(
+        let result = technique::parsing::parser::parse_with_recovery(
             Path::new(""),
             trim(
                 r#"
@@ -1248,7 +1248,7 @@ procedure_four : Concept -> Architecture
 
     #[test]
     fn section_with_procedures() {
-        let result = parser::parse_via_taking(
+        let result = technique::parsing::parser::parse_with_recovery(
             Path::new(""),
             trim(
                 r#"