Pass more information in user defined parse error

RustPython · windelbouwman · Jul 6, 2019 · Jul 5, 2019 · Jul 6, 2019 · Jul 6, 2019
commit ef1d5433df31a3c4ba7e58250b75de85ca76eaa1
diff --git a/compiler/src/error.rs b/compiler/src/error.rs
@@ -56,7 +56,10 @@ impl fmt::Display for CompileError {
         }?;
 
         // Print line number:
-        write!(f, " at line {:?}", self.location.row())
+        match &self.error {
+            CompileErrorType::Parse(..) => Ok(()),
 location: Default::default(), // TODO: extract location from parse error! 
 location: Default::default(), // TODO: extract location from parse error! 
+            _ => write!(f, " at line {:?}", self.location.row()),
+        }
     }
 }
 

diff --git a/parser/src/error.rs b/parser/src/error.rs
@@ -24,7 +24,7 @@ pub enum ParseError {
     /// Parser encountered an unexpected token
     UnrecognizedToken(TokSpan, Vec<String>),
     /// Maps to `User` type from `lalrpop-util`
-    Other,
+    Other(LexicalError),
 }
 
 /// Convert `lalrpop_util::ParseError` to our internal type
@@ -34,8 +34,7 @@ impl From<InnerError<Location, Tok, LexicalError>> for ParseError {
             // TODO: Are there cases where this isn't an EOF?
             InnerError::InvalidToken { location } => ParseError::EOF(Some(location)),
             InnerError::ExtraToken { token } => ParseError::ExtraToken(token),
-            // Inner field is a unit-like enum `LexicalError::StringError` with no useful info
-            InnerError::User { .. } => ParseError::Other,
+            InnerError::User { error } => ParseError::Other(error),
             InnerError::UnrecognizedToken { token, expected } => {
                 match token {
                     Some(tok) => ParseError::UnrecognizedToken(tok, expected),
@@ -66,8 +65,7 @@ impl fmt::Display for ParseError {
             ParseError::UnrecognizedToken(ref t_span, _) => {
                 write!(f, "Got unexpected token: {:?} at {:?}", t_span.1, t_span.0)
             }
-            // This is user defined, it probably means a more useful error should have been given upstream.
-            ParseError::Other => write!(f, "Got unsupported token(s)"),
+            ParseError::Other(ref error) => write!(f, "{}", error),
         }
     }
 }

diff --git a/parser/src/lexer.rs b/parser/src/lexer.rs
@@ -10,6 +10,7 @@ use num_traits::Num;
 use serde::{Deserialize, Serialize};
 use std::cmp::Ordering;
 use std::collections::HashMap;
+use std::fmt;
 use std::str::FromStr;
 use unic_emoji_char::is_emoji_presentation;
 use unicode_xid::UnicodeXID;
@@ -59,13 +60,13 @@ pub struct Lexer<T: Iterator<Item = char>> {
     keywords: HashMap<String, Tok>,
 }
 
-#[derive(Debug)]
+#[derive(Debug, PartialEq)]
 pub struct LexicalError {
     pub error: LexicalErrorType,
     pub location: Location,
 }
 
-#[derive(Debug)]
+#[derive(Debug, PartialEq)]
 pub enum LexicalErrorType {
     StringError,
     UnicodeError,
@@ -74,6 +75,26 @@ pub enum LexicalErrorType {
     OtherError(String),
 }
 
+impl fmt::Display for LexicalError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self.error {
+            LexicalErrorType::StringError => write!(f, "Got unexpected string"),
+            LexicalErrorType::UnicodeError => write!(f, "Got unexpected unicode"),
+            LexicalErrorType::NestingError => write!(f, "Got unexpected nesting"),
+            LexicalErrorType::UnrecognizedToken { tok } => {
+                write!(f, "Got unexpected token {}", tok)
+            }
+            LexicalErrorType::OtherError(ref msg) => write!(f, "{}", msg),
+        }?;
+        write!(
+            f,
+            " at line {} column {}",
+            self.location.row(),
+            self.location.column()
+        )
+    }
+}
+
 #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
 pub struct Location {
     row: usize,