Integrate CompileError to compiler-core::BaseError

Author: youknowone

core/src/error.rs

@@ -3,21 +3,21 @@ use std::fmt::Display;
 use crate::Location;
 
 #[derive(Debug, PartialEq, Eq)]
-pub struct Error<T> {
+pub struct BaseError<T> {
     pub error: T,
     pub location: Location,
     pub source_path: String,
 }
 
-impl<T> std::ops::Deref for Error<T> {
+impl<T> std::ops::Deref for BaseError<T> {
     type Target = T;
 
     fn deref(&self) -> &Self::Target {
         &self.error
     }
 }
 
-impl<T> std::error::Error for Error<T>
+impl<T> std::error::Error for BaseError<T>
 where
     T: std::fmt::Display + std::fmt::Debug,
 {
@@ -26,7 +26,7 @@ where
     }
 }
 
-impl<T> Display for Error<T>
+impl<T> Display for BaseError<T>
 where
     T: std::fmt::Display,
 {
@@ -35,8 +35,26 @@ where
     }
 }
 
-impl<T> Error<T> {
+impl<T> BaseError<T> {
     pub fn error(self) -> T {
         self.error
     }
+
+    pub fn from<U>(obj: BaseError<U>) -> Self
+    where
+        U: Into<T>,
+    {
+        Self {
+            error: obj.error.into(),
+            location: obj.location,
+            source_path: obj.source_path,
+        }
+    }
+
+    pub fn into<U>(self) -> BaseError<U>
+    where
+        T: Into<U>,
+    {
+        BaseError::from(self)
+    }
 }

core/src/lib.rs

@@ -7,6 +7,6 @@ mod location;
 mod mode;
 
 pub use bytecode::*;
-pub use error::Error;
+pub use error::BaseError;
 pub use location::Location;
 pub use mode::Mode;

parser/src/error.rs

@@ -118,7 +118,7 @@ impl From<FStringError> for LalrpopError<Location, Tok, LexicalError> {
 
 /// Represents an error during parsing
 #[derive(Debug, PartialEq)]
-pub struct ParseError(rustpython_compiler_core::Error<ParseErrorType>);
+pub struct ParseError(rustpython_compiler_core::BaseError<ParseErrorType>);
 
 #[derive(Debug, PartialEq)]
 pub enum ParseErrorType {
@@ -134,7 +134,7 @@ pub enum ParseErrorType {
     Lexical(LexicalErrorType),
 }
 
-impl From<ParseError> for rustpython_compiler_core::Error<ParseErrorType> {
+impl From<ParseError> for rustpython_compiler_core::BaseError<ParseErrorType> {
     fn from(err: ParseError) -> Self {
         err.0
     }
@@ -149,7 +149,7 @@ impl From<ParseError> for ParseErrorType {
 /// 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 {
+        Self(rustpython_compiler_core::BaseError {
             error,
             location,
             source_path,
@@ -239,7 +239,7 @@ impl ParseErrorType {
 }
 
 impl std::ops::Deref for ParseError {
-    type Target = rustpython_compiler_core::Error<ParseErrorType>;
+    type Target = rustpython_compiler_core::BaseError<ParseErrorType>;
     fn deref(&self) -> &Self::Target {
         &self.0
     }