Integrate ParseError to compiler-core::Error

core/src/error.rs

@@ -0,0 +1,22 @@
+use crate::Location;
+
+#[derive(Debug, PartialEq, Eq)]
+pub struct Error<T> {
+    pub error: T,
+    pub location: Location,
+    pub source_path: String,
+}
+
+impl<T> std::ops::Deref for Error<T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        &self.error
+    }
+}
+
+impl<T> Error<T> {
+    pub fn error(self) -> T {
+        self.error
+    }
+}

core/src/lib.rs

@@ -2,9 +2,11 @@
 #![doc(html_root_url = "https://docs.rs/rustpython-compiler-core/")]
 
 mod bytecode;
+mod error;
 mod location;
 mod mode;
 
 pub use bytecode::*;
+pub use error::Error;
 pub use location::Location;
 pub use mode::Mode;

parser/Cargo.toml

@@ -16,6 +16,7 @@ tiny-keccak = { version = "2", features = ["sha3"] }
 
 [dependencies]
 rustpython-ast = { path = "../ast" }
+rustpython-compiler-core = { path = "../core" }
 
 ahash = "0.7.6"
 itertools = "0.10.3"

parser/src/error.rs

@@ -118,11 +118,7 @@ impl From<FStringError> for LalrpopError<Location, Tok, LexicalError> {
 
 /// Represents an error during parsing
 #[derive(Debug, PartialEq)]
-pub struct ParseError {
+pub struct ParseError(rustpython_compiler_core::Error<ParseErrorType>);
-    pub error: ParseErrorType,
-    pub location: Location,
-    pub source_path: String,
-}
 
 #[derive(Debug, PartialEq)]
 pub enum ParseErrorType {
@@ -138,8 +134,28 @@ pub enum ParseErrorType {
     Lexical(LexicalErrorType),
 }
 
+impl From<ParseError> for rustpython_compiler_core::Error<ParseErrorType> {
+    fn from(err: ParseError) -> Self {
+        err.0
+    }
+}
+
+impl From<ParseError> for ParseErrorType {
+    fn from(err: ParseError) -> Self {
+        err.0.error
+    }
+}
+
 /// Convert `lalrpop_util::ParseError` to our internal type
 impl ParseError {
+    fn new(error: ParseErrorType, location: Location, source_path: String) -> Self {
+        Self(rustpython_compiler_core::Error {
+            error,
+            location,
+            source_path,
+        })
+    }
+
     pub(crate) fn from_lalrpop(
         err: LalrpopError<Location, Tok, LexicalError>,
         source_path: &str,
@@ -147,36 +163,30 @@ impl ParseError {
         let source_path = source_path.to_owned();
         match err {
             // TODO: Are there cases where this isn't an EOF?
-            LalrpopError::InvalidToken { location } => ParseError {
+            LalrpopError::InvalidToken { location } => {
-                error: ParseErrorType::Eof,
+                ParseError::new(ParseErrorType::Eof, location, source_path)
-                location,
+            }
+            LalrpopError::ExtraToken { token } => {
+                ParseError::new(ParseErrorType::ExtraToken(token.1), token.0, source_path)
+            }
+            LalrpopError::User { error } => ParseError::new(
+                ParseErrorType::Lexical(error.error),
+                error.location,
                 source_path,
-            },
+            ),
-            LalrpopError::ExtraToken { token } => ParseError {
-                error: ParseErrorType::ExtraToken(token.1),
-                location: token.0,
-                source_path,
-            },
-            LalrpopError::User { error } => ParseError {
-                error: ParseErrorType::Lexical(error.error),
-                location: error.location,
-                source_path,
-            },
             LalrpopError::UnrecognizedToken { token, expected } => {
                 // Hacky, but it's how CPython does it. See PyParser_AddToken,
                 // in particular "Only one possible expected token" comment.
                 let expected = (expected.len() == 1).then(|| expected[0].clone());
-                ParseError {
+                ParseError::new(
-                    error: ParseErrorType::UnrecognizedToken(token.1, expected),
+                    ParseErrorType::UnrecognizedToken(token.1, expected),
-                    location: token.0,
+                    token.0,
                     source_path,
-                }
+                )
+            }
+            LalrpopError::UnrecognizedEOF { location, .. } => {
+                ParseError::new(ParseErrorType::Eof, location, source_path)
             }
-            LalrpopError::UnrecognizedEOF { location, .. } => ParseError {
-                error: ParseErrorType::Eof,
-                location,
-                source_path,
-            },
         }
     }
 }
@@ -229,9 +239,9 @@ impl ParseErrorType {
 }
 
 impl std::ops::Deref for ParseError {
-    type Target = ParseErrorType;
+    type Target = rustpython_compiler_core::Error<ParseErrorType>;
     fn deref(&self) -> &Self::Target {
-        &self.error
+        &self.0
     }
 }
 

parser/src/fstring.rs

@@ -186,7 +186,7 @@ impl<'a> FStringParser<'a> {
                         vec![self.expr(ExprKind::FormattedValue {
                             value: Box::new(
                                 parse_fstring_expr(&expression)
-                                    .map_err(|e| InvalidExpression(Box::new(e.error)))?,
+                                    .map_err(|e| InvalidExpression(Box::new(e.into())))?,
                             ),
                             conversion: conversion as _,
                             format_spec: spec,
@@ -204,7 +204,7 @@ impl<'a> FStringParser<'a> {
                             self.expr(ExprKind::FormattedValue {
                                 value: Box::new(
                                     parse_fstring_expr(&expression)
-                                        .map_err(|e| InvalidExpression(Box::new(e.error)))?,
+                                        .map_err(|e| InvalidExpression(Box::new(e.into())))?,
                                 ),
                                 conversion: (if conversion == ConversionFlag::None && spec.is_none()
                                 {