Remove compiler_core::CompileError

Author: youknowone

Cargo.lock

@@ -17,10 +17,10 @@ members = [
 ]
 
 [workspace.dependencies]
-rustpython-literal = { git = "https://github.com/RustPython/Parser.git", rev = "6b60f85cc4ca248af9b787697c41be2adb7a3ec8" }
-rustpython-compiler-core = { git = "https://github.com/RustPython/Parser.git", rev = "6b60f85cc4ca248af9b787697c41be2adb7a3ec8" }
-rustpython-parser = { git = "https://github.com/RustPython/Parser.git", rev = "6b60f85cc4ca248af9b787697c41be2adb7a3ec8" }
-rustpython-ast = { git = "https://github.com/RustPython/Parser.git", rev = "6b60f85cc4ca248af9b787697c41be2adb7a3ec8" }
+rustpython-literal = { git = "https://github.com/RustPython/Parser.git", rev = "48920a034e93ae7c737129ea427c068dc30e2da5" }
+rustpython-compiler-core = { git = "https://github.com/RustPython/Parser.git", rev = "48920a034e93ae7c737129ea427c068dc30e2da5" }
+rustpython-parser = { git = "https://github.com/RustPython/Parser.git", rev = "48920a034e93ae7c737129ea427c068dc30e2da5" }
+rustpython-ast = { git = "https://github.com/RustPython/Parser.git", rev = "48920a034e93ae7c737129ea427c068dc30e2da5" }
 # rustpython-literal = { path = "../RustPython-parser/literal" }
 # rustpython-compiler-core = { path = "../RustPython-parser/core" }
 # rustpython-parser = { path = "../RustPython-parser/parser" }

Cargo.toml

@@ -2,7 +2,7 @@ use rustpython_codegen::{compile, symboltable};
 use rustpython_parser::ast::{fold::Fold, ConstantOptimizer};
 
 pub use rustpython_codegen::compile::CompileOpts;
-pub use rustpython_compiler_core::{BaseError as CompileErrorBody, CodeObject, Mode};
+pub use rustpython_compiler_core::{CodeObject, Mode};
 
 // these modules are out of repository. re-exporting them here for convenience.
 pub use rustpython_codegen as codegen;
@@ -45,12 +45,7 @@ impl From<parser::ParseErrorType> for CompileErrorType {
     }
 }
 
-pub type CompileError = rustpython_compiler_core::CompileError<CompileErrorType>;
-
-fn error_from_parse(error: parser::ParseError, source: &str) -> CompileError {
-    let error: CompileErrorBody<parser::ParseErrorType> = error.into();
-    CompileError::from(error, source)
-}
+pub type CompileError = rustpython_compiler_core::BaseError<CompileErrorType>;
 
 /// Compile a given source code into a bytecode object.
 pub fn compile(
@@ -61,31 +56,30 @@ pub fn compile(
 ) -> Result<CodeObject, CompileError> {
     let mut ast = match parser::parse(source, mode.into(), &source_path) {
         Ok(x) => x,
-        Err(e) => return Err(error_from_parse(e, source)),
+        Err(e) => return Err(e.into()),
     };
     if opts.optimize > 0 {
         ast = ConstantOptimizer::new()
             .fold_mod(ast)
             .unwrap_or_else(|e| match e {});
     }
-    compile::compile_top(&ast, source_path, mode, opts).map_err(|e| CompileError::from(e, source))
+    compile::compile_top(&ast, source_path, mode, opts).map_err(|e| e.into())
 }
 
 pub fn compile_symtable(
     source: &str,
     mode: compile::Mode,
     source_path: &str,
 ) -> Result<symboltable::SymbolTable, CompileError> {
-    let parse_err = |e| error_from_parse(e, source);
     let res = match mode {
         compile::Mode::Exec | compile::Mode::Single | compile::Mode::BlockExpr => {
-            let ast = parser::parse_program(source, source_path).map_err(parse_err)?;
+            let ast = parser::parse_program(source, source_path).map_err(|e| e.into())?;
             symboltable::SymbolTable::scan_program(&ast)
         }
         compile::Mode::Eval => {
-            let expr = parser::parse_expression(source, source_path).map_err(parse_err)?;
+            let expr = parser::parse_expression(source, source_path).map_err(|e| e.into())?;
             symboltable::SymbolTable::scan_expr(&expr)
         }
     };
-    res.map_err(|e| CompileError::from(e.into_codegen_error(source_path.to_owned()), source))
+    res.map_err(|e| e.into_codegen_error(source_path.to_owned()).into())
 }

compiler/src/lib.rs

@@ -3,14 +3,10 @@ use rustpython_vm as vm;
 fn main() -> vm::PyResult<()> {
     vm::Interpreter::without_stdlib(Default::default()).enter(|vm| {
         let scope = vm.new_scope_with_builtins();
-
+        let source = r#"print("Hello World!")"#;
         let code_obj = vm
-            .compile(
-                r#"print("Hello World!")"#,
-                vm::compiler::Mode::Exec,
-                "<embedded>".to_owned(),
-            )
-            .map_err(|err| vm.new_syntax_error(&err))?;
+            .compile(source, vm::compiler::Mode::Exec, "<embedded>".to_owned())
+            .map_err(|err| vm.new_syntax_error(&err, Some(source)))?;
 
         vm.run_code_obj(code_obj, scope)?;
 

examples/hello_embed.rs

@@ -65,7 +65,7 @@ def fib(n):
         // (note that this is only the case when compiler::Mode::Single is passed to vm.compile)
         match vm
             .compile(&input, vm::compiler::Mode::Single, "<embedded>".to_owned())
-            .map_err(|err| vm.new_syntax_error(&err))
+            .map_err(|err| vm.new_syntax_error(&err, Some(&input)))
             .and_then(|code_obj| vm.run_code_obj(code_obj, scope.clone()))
         {
             Ok(output) => {

examples/mini_repl.rs

@@ -3,7 +3,7 @@ mod helper;
 use rustpython_parser::{lexer::LexicalErrorType, ParseErrorType, Tok};
 use rustpython_vm::{
     builtins::PyBaseExceptionRef,
-    compiler::{self, CompileError, CompileErrorBody, CompileErrorType},
+    compiler::{self, CompileError, CompileErrorType},
     readline::{Readline, ReadlineResult},
     scope::Scope,
     AsObject, PyResult, VirtualMachine,
@@ -36,19 +36,11 @@ fn shell_exec(
             }
         }
         Err(CompileError {
-            body:
-                CompileErrorBody {
-                    error: CompileErrorType::Parse(ParseErrorType::Lexical(LexicalErrorType::Eof)),
-                    ..
-                },
+            error: CompileErrorType::Parse(ParseErrorType::Lexical(LexicalErrorType::Eof)),
             ..
         })
         | Err(CompileError {
-            body:
-                CompileErrorBody {
-                    error: CompileErrorType::Parse(ParseErrorType::Eof),
-                    ..
-                },
+            error: CompileErrorType::Parse(ParseErrorType::Eof),
             ..
         }) => ShellExecResult::Continue,
         Err(err) => {
@@ -57,13 +49,13 @@ fn shell_exec(
             // since indentations errors on columns other than 0 should be ignored.
             // if its an unrecognized token for dedent, set to false
 
-            let bad_error = match err.body.error {
+            let bad_error = match err.error {
                 CompileErrorType::Parse(ref p) => {
                     if matches!(
                         p,
                         ParseErrorType::Lexical(LexicalErrorType::IndentationError)
                     ) {
-                        continuing && err.body.location.column() != 0
+                        continuing && err.location.column() != 0
                     } else {
                         !matches!(p, ParseErrorType::UnrecognizedToken(Tok::Dedent, _))
                     }
@@ -73,7 +65,7 @@ fn shell_exec(
 
             // If we are handling an error on an empty line or an error worthy of throwing
             if empty_line_given || bad_error {
-                ShellExecResult::PyErr(vm.new_syntax_error(&err))
+                ShellExecResult::PyErr(vm.new_syntax_error(&err, Some(source)))
             } else {
                 ShellExecResult::Continue
             }

src/shell.rs

@@ -16,7 +16,7 @@ mod decl {
         } else if let Ok(co_str) = PyStrRef::try_from_object(vm, obj.clone()) {
             // String:
             vm.compile(co_str.as_str(), compiler::Mode::Exec, "<dis>".to_owned())
-                .map_err(|err| vm.new_syntax_error(&err))?
+                .map_err(|err| vm.new_syntax_error(&err, Some(co_str.as_str())))?
         } else {
             PyRef::try_from_object(vm, obj)?
         };

stdlib/src/dis.rs

@@ -26,8 +26,8 @@ mod error {
 #[cfg(not(feature = "rustpython-compiler"))]
 pub use error::{CompileError, CompileErrorType};
 
-impl ToPyException for CompileError {
+impl ToPyException for (CompileError, Option<&str>) {
     fn to_pyexception(&self, vm: &VirtualMachine) -> PyBaseExceptionRef {
-        vm.new_syntax_error(self)
+        vm.new_syntax_error(&self.0, self.1)
     }
 }

vm/src/compiler.rs

@@ -6,7 +6,7 @@ pub fn eval(vm: &VirtualMachine, source: &str, scope: Scope, source_path: &str)
             debug!("Code object: {:?}", bytecode);
             vm.run_code_obj(bytecode, scope)
         }
-        Err(err) => Err(vm.new_syntax_error(&err)),
+        Err(err) => Err(vm.new_syntax_error(&err, Some(source))),
     }
 }
 

vm/src/eval.rs

@@ -118,7 +118,7 @@ pub fn import_file(
             file_path,
             vm.compile_opts(),
         )
-        .map_err(|err| vm.new_syntax_error(&err))?;
+        .map_err(|err| vm.new_syntax_error(&err, Some(&content)))?;
     import_codeobj(vm, module_name, code, true)
 }