Refactor chalk-parse/src/lib.rs

Author: Kinrany

chalk-parse/src/lib.rs

@@ -9,54 +9,50 @@ pub mod ast;
 lalrpop_mod!(pub parser);
 
 use lalrpop_util::ParseError;
-use std::fmt::Write;
 
 type Result<T> = std::result::Result<T, Box<dyn std::error::Error>>;
 
 pub fn parse_program(text: &str) -> Result<ast::Program> {
-    match parser::ProgramParser::new().parse(text) {
-        Ok(v) => Ok(v),
-        Err(e) => Err(format!("parse error: {}", e).into()),
-    }
+    parser::ProgramParser::new()
+        .parse(text)
+        .map_err(|e| format!("parse error: {}", e).into())
 }
 
 pub fn parse_ty(text: &str) -> Result<ast::Ty> {
-    match parser::TyParser::new().parse(text) {
-        Ok(v) => Ok(v),
-        Err(e) => Err(format!("error parsing `{}`: {}", text, e).into()),
-    }
+    parser::TyParser::new()
+        .parse(text)
+        .map_err(|e| format!("error parsing `{}`: {}", text, e).into())
 }
 
 pub fn parse_goal(text: &str) -> Result<Box<ast::Goal>> {
-    match parser::GoalParser::new().parse(text) {
-        Ok(v) => Ok(v),
-        Err(e) => {
-            let position_string = |start: usize, end: usize| {
-                let mut output = String::new();
-                let text = text.replace("\n", " ").replace("\r", " ");
-                writeln!(output, "position: `{}`", text).expect("str-write cannot fail");
-                output.push_str(&" ".repeat(11 + start));
-                output.push_str(&"^".repeat(end - start));
-                output.push_str("\n");
-                output
-            };
-            match e {
-                ParseError::InvalidToken { location } => Err(format!(
-                    "parse error: {}\n{}",
-                    e,
-                    position_string(location, location + 1)
-                )
-                .into()),
-                ParseError::UnrecognizedToken {
-                    token: (start, _, end),
-                    ..
-                } => Err(format!("parse error: {}\n{}", e, position_string(start, end)).into()),
-                ParseError::ExtraToken {
-                    token: (start, _, end),
-                    ..
-                } => Err(format!("parse error: {}\n{}", e, position_string(start, end)).into()),
-                _ => Err(format!("parse error: {}", e).into()),
+    parser::GoalParser::new().parse(text).map_err(|e| {
+        let mut output = format!("parse error: {}", &e);
+        if let Some(s) = match e {
+            ParseError::InvalidToken { location } => {
+                Some(position_string(text, location, location + 1))
             }
+            ParseError::UnrecognizedToken {
+                token: (start, _, end),
+                ..
+            } => Some(position_string(text, start, end)),
+            ParseError::ExtraToken {
+                token: (start, _, end),
+                ..
+            } => Some(position_string(text, start, end)),
+            _ => None,
+        } {
+            output.push('\n');
+            output += &s;
         }
-    }
+        output.into()
+    })
+}
+
+fn position_string(text: &str, start: usize, end: usize) -> String {
+    let text = text.replace('\n', " ").replace('\r', " ");
+    let mut output = format!("position: `{}`", text);
+    output += &" ".repeat(11 + start);
+    output += &"^".repeat(end - start);
+    output.push('\n');
+    output
 }