integrate CodegenError to compiler-core::Error

youknowone · youknowone · commit 31f95eeb1ea8 · 2022-08-22T18:43:03.000+09:00
diff --git a/compiler/codegen/src/error.rs b/compiler/codegen/src/error.rs
@@ -1,12 +1,6 @@
-use rustpython_compiler_core::Location;
 use std::{error::Error, fmt};
 
-#[derive(Debug)]
-pub struct CodegenError {
-    pub error: CodegenErrorType,
-    pub location: Location,
-    pub source_path: String,
-}
+pub type CodegenError = rustpython_compiler_core::Error<CodegenErrorType>;
 
 #[derive(Debug)]
 #[non_exhaustive]
@@ -87,15 +81,3 @@ impl fmt::Display for CodegenErrorType {
 }
 
 impl Error for CodegenErrorType {}
-
-impl fmt::Display for CodegenError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        self.location.fmt_with(f, &self.error)
-    }
-}
-
-impl Error for CodegenError {
-    fn source(&self) -> Option<&(dyn Error + 'static)> {
-        None
-    }
-}
diff --git a/compiler/core/src/error.rs b/compiler/core/src/error.rs
@@ -1,3 +1,5 @@
+use std::fmt::Display;
+
 use crate::Location;
 
 #[derive(Debug, PartialEq, Eq)]
@@ -15,6 +17,24 @@ impl<T> std::ops::Deref for Error<T> {
     }
 }
 
+impl<T> std::error::Error for Error<T>
+where
+    T: std::fmt::Display + std::fmt::Debug,
+{
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        None
+    }
+}
+
+impl<T> Display for Error<T>
+where
+    T: std::fmt::Display,
+{
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        self.location.fmt_with(f, &self.error)
+    }
+}
+
 impl<T> Error<T> {
     pub fn error(self) -> T {
         self.error
diff --git a/compiler/parser/src/error.rs b/compiler/parser/src/error.rs
@@ -193,7 +193,7 @@ impl ParseError {
 
 impl fmt::Display for ParseError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        self.location.fmt_with(f, &self.error)
+        self.0.fmt(f)
     }
 }
 
diff --git a/compiler/src/lib.rs b/compiler/src/lib.rs
@@ -11,7 +11,7 @@ pub use rustpython_codegen::compile::CompileOpts;
 pub use rustpython_compiler_core::Mode;
 
 #[derive(Debug, thiserror::Error)]
-pub enum CodegenErrorType {
+pub enum CompileErrorType {
     #[error(transparent)]
     Compile(#[from] rustpython_codegen::error::CodegenErrorType),
     #[error(transparent)]
@@ -20,7 +20,7 @@ pub enum CodegenErrorType {
 
 #[derive(Debug, thiserror::Error)]
 pub struct CompileError {
-    pub error: CodegenErrorType,
+    pub error: CompileErrorType,
     pub source_path: String,
     pub location: Location,
     pub statement: Option<String>,
diff --git a/src/shell.rs b/src/shell.rs
@@ -4,7 +4,7 @@ use rustpython_parser::error::{LexicalErrorType, ParseErrorType};
 use rustpython_vm::readline::{Readline, ReadlineResult};
 use rustpython_vm::{
     builtins::PyBaseExceptionRef,
-    compile::{self, CodegenErrorType, CompileError},
+    compile::{self, CompileError, CompileErrorType},
     scope::Scope,
     AsObject, PyResult, VirtualMachine,
 };
@@ -22,11 +22,11 @@ fn shell_exec(vm: &VirtualMachine, source: &str, scope: Scope) -> ShellExecResul
             Err(err) => ShellExecResult::PyErr(err),
         },
         Err(CompileError {
-            error: CodegenErrorType::Parse(ParseErrorType::Lexical(LexicalErrorType::Eof)),
+            error: CompileErrorType::Parse(ParseErrorType::Lexical(LexicalErrorType::Eof)),
             ..
         })
         | Err(CompileError {
-            error: CodegenErrorType::Parse(ParseErrorType::Eof),
+            error: CompileErrorType::Parse(ParseErrorType::Eof),
             ..
         }) => ShellExecResult::Continue,
         Err(err) => ShellExecResult::PyErr(vm.new_syntax_error(&err)),
diff --git a/vm/src/vm/vm_new.rs b/vm/src/vm/vm_new.rs
@@ -1,5 +1,5 @@
 #[cfg(feature = "rustpython-compiler")]
-use crate::compile::{CodegenErrorType, CompileError};
+use crate::compile::{CompileError, CompileErrorType};
 use crate::{
     builtins::{
         pystr::IntoPyStrRef,
@@ -212,10 +212,10 @@ impl VirtualMachine {
     #[cfg(feature = "rustpython-compiler")]
     pub fn new_syntax_error(&self, error: &CompileError) -> PyBaseExceptionRef {
         let syntax_error_type = match &error.error {
-            CodegenErrorType::Parse(p) if p.is_indentation_error() => {
+            CompileErrorType::Parse(p) if p.is_indentation_error() => {
                 self.ctx.exceptions.indentation_error
             }
-            CodegenErrorType::Parse(p) if p.is_tab_error() => self.ctx.exceptions.tab_error,
+            CompileErrorType::Parse(p) if p.is_tab_error() => self.ctx.exceptions.tab_error,
             _ => self.ctx.exceptions.syntax_error,
         }
         .to_owned();
diff --git a/wasm/lib/src/convert.rs b/wasm/lib/src/convert.rs
@@ -4,7 +4,7 @@ use js_sys::{Array, ArrayBuffer, Object, Promise, Reflect, SyntaxError, Uint8Arr
 use rustpython_parser::error::ParseErrorType;
 use rustpython_vm::{
     builtins::PyBaseExceptionRef,
-    compile::{CodegenErrorType, CompileError},
+    compile::{CompileError, CompileErrorType},
     exceptions,
     function::{ArgBytesLike, FuncArgs},
     py_serde, AsObject, PyObjectRef, PyPayload, PyResult, TryFromBorrowedObject, VirtualMachine,
@@ -253,7 +253,7 @@ pub fn syntax_err(err: CompileError) -> SyntaxError {
         &"col".into(),
         &(err.location.column() as u32).into(),
     );
-    let can_continue = matches!(&err.error, CodegenErrorType::Parse(ParseErrorType::Eof));
+    let can_continue = matches!(&err.error, CompileErrorType::Parse(ParseErrorType::Eof));
     let _ = Reflect::set(&js_err, &"canContinue".into(), &can_continue.into());
     js_err
 }

Original file line number	Diff line number	Diff line change
`@@ -193,7 +193,7 @@ impl ParseError {`
`193`	`193`
`194`	`194`	`impl fmt::Display for ParseError {`
`195`	`195`	`fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {`
`196`		`- self.location.fmt_with(f, &self.error)`
	`196`	`+ self.0.fmt(f)`
`197`	`197`	`}`
`198`	`198`	`}`
`199`	`199`