Add mode to ast::parse

Author: youknowone

compiler/src/compile.rs

@@ -6,6 +6,7 @@
 //!   https://github.com/micropython/micropython/blob/master/py/compile.c
 
 use crate::error::{CompileError, CompileErrorType};
+pub use crate::mode::Mode;
 use crate::output_stream::{CodeObjectStream, OutputStream};
 use crate::peephole::PeepholeOptimizer;
 use crate::symboltable::{
@@ -105,36 +106,6 @@ pub fn compile_program_single(
     })
 }
 
-#[derive(Clone, Copy)]
-pub enum Mode {
-    Exec,
-    Eval,
-    Single,
-}
-
-impl std::str::FromStr for Mode {
-    type Err = ModeParseError;
-    fn from_str(s: &str) -> Result<Self, ModeParseError> {
-        match s {
-            "exec" => Ok(Mode::Exec),
-            "eval" => Ok(Mode::Eval),
-            "single" => Ok(Mode::Single),
-            _ => Err(ModeParseError { _priv: () }),
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct ModeParseError {
-    _priv: (),
-}
-
-impl std::fmt::Display for ModeParseError {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-        write!(f, r#"mode should be "exec", "eval", or "single""#)
-    }
-}
-
 impl<O> Default for Compiler<O>
 where
     O: OutputStream,

compiler/src/lib.rs

@@ -8,6 +8,7 @@ extern crate log;
 
 pub mod compile;
 pub mod error;
+pub mod mode;
 pub(crate) mod output_stream;
 pub mod peephole;
 pub mod symboltable;

compiler/src/mode.rs

@@ -0,0 +1,40 @@
+use rustpython_parser::parser;
+
+#[derive(Clone, Copy)]
+pub enum Mode {
+    Exec,
+    Eval,
+    Single,
+}
+
+impl std::str::FromStr for Mode {
+    type Err = ModeParseError;
+    fn from_str(s: &str) -> Result<Self, ModeParseError> {
+        match s {
+            "exec" => Ok(Mode::Exec),
+            "eval" => Ok(Mode::Eval),
+            "single" => Ok(Mode::Single),
+            _ => Err(ModeParseError { _priv: () }),
+        }
+    }
+}
+
+impl Mode {
+    pub fn to_parser_mode(self) -> parser::Mode {
+        match self {
+            Self::Exec | Self::Single => parser::Mode::Program,
+            Self::Eval => parser::Mode::Statement,
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct ModeParseError {
+    _priv: (),
+}
+
+impl std::fmt::Display for ModeParseError {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, r#"mode should be "exec", "eval", or "single""#)
+    }
+}

parser/src/lib.rs

@@ -11,6 +11,7 @@ mod fstring;
 mod function;
 pub mod lexer;
 pub mod location;
+pub mod mode;
 pub mod parser;
 lalrpop_mod!(
     #[allow(clippy::all)]

parser/src/mode.rs

@@ -0,0 +1,27 @@
+#[derive(Clone, Copy)]
+pub enum Mode {
+    Program,
+    Statement,
+}
+
+impl std::str::FromStr for Mode {
+    type Err = ModeParseError;
+    fn from_str(s: &str) -> Result<Self, ModeParseError> {
+        match s {
+            "exec" | "single" => Ok(Mode::Program),
+            "eval" => Ok(Mode::Statement),
+            _ => Err(ModeParseError { _priv: () }),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct ModeParseError {
+    _priv: (),
+}
+
+impl std::fmt::Display for ModeParseError {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, r#"mode should be "exec", "eval", or "single""#)
+    }
+}

parser/src/parser.rs

@@ -3,6 +3,7 @@ use std::iter;
 use crate::ast;
 use crate::error::ParseError;
 use crate::lexer;
+pub use crate::mode::Mode;
 use crate::python;
 use crate::token;
 
@@ -73,6 +74,20 @@ pub fn parse_expression(source: &str) -> Result<ast::Expression, ParseError> {
     do_lalr_parsing!(source, Expression, StartExpression)
 }
 
+// Parse a given source code
+pub fn parse(source: &str, mode: Mode) -> Result<ast::Top, ParseError> {
+    Ok(match mode {
+        Mode::Program => {
+            let ast = parse_program(source)?;
+            ast::Top::Program(ast)
+        }
+        Mode::Statement => {
+            let statement = parse_statement(source)?;
+            ast::Top::Statement(statement)
+        }
+    })
+}
+
 #[cfg(test)]
 mod tests {
     use super::ast;

vm/src/builtins.rs

@@ -29,10 +29,10 @@ use crate::pyobject::{
     TryFromObject, TypeProtocol,
 };
 use crate::scope::Scope;
-use crate::vm::VirtualMachine;
 use crate::stdlib::ast;
 #[cfg(not(target_arch = "wasm32"))]
 use crate::stdlib::io::io_open;
+use crate::vm::VirtualMachine;
 
 fn builtin_abs(x: PyObjectRef, vm: &VirtualMachine) -> PyResult {
     let method = vm.get_method_or_type_error(x.clone(), "__abs__", || {
@@ -143,11 +143,11 @@ fn builtin_compile(args: CompileArgs, vm: &VirtualMachine) -> PyResult {
         .map_or(Ok(0), |v| i32::try_from_object(vm, v.into_object()))?;
 
     if (flags & ast::PY_COMPILE_FLAG_AST_ONLY).is_zero() {
-        vm.compile(&source, mode, args.filename.value.to_string())
+        vm.compile(&source, mode, args.filename.as_str().to_string())
             .map(|o| o.into_object())
             .map_err(|err| vm.new_syntax_error(&err))
     } else {
-        ast::source_to_ast(&vm, &source)
+        ast::parse(&vm, &source, mode.to_parser_mode())
     }
 }
 

vm/src/stdlib/ast.rs

@@ -7,7 +7,7 @@ use std::ops::Deref;
 
 use num_complex::Complex64;
 
-use rustpython_parser::{ast, parser};
+use rustpython_parser::{ast, mode::Mode, parser};
 
 use crate::obj::objlist::PyListRef;
 use crate::obj::objtype::PyClassRef;
@@ -50,11 +50,12 @@ macro_rules! node {
     }
 }
 
-pub(crate) fn source_to_ast(vm: &VirtualMachine, source: &str) -> PyResult {
-    let internal_ast =
-        parser::parse_program(source).map_err(|err| vm.new_value_error(format!("{}", err)))?;
-    let py_body = statements_to_ast(vm, &internal_ast.statements)?;
-    Ok(node!(vm, Module, { body => py_body }).into_object())
+fn top_to_ast(vm: &VirtualMachine, top: &ast::Top) -> PyResult<PyListRef> {
+    match top {
+        ast::Top::Program(program) => statements_to_ast(vm, &program.statements),
+        ast::Top::Statement(statements) => statements_to_ast(vm, statements),
+        ast::Top::Expression(_) => unimplemented!("top_to_ast unimplemented ast::Top::Expression"),
+    }
 }
 
 // Create a node class instance
@@ -634,6 +635,12 @@ fn string_to_ast(vm: &VirtualMachine, string: &ast::StringGroup) -> PyResult<Ast
     Ok(string)
 }
 
+pub(crate) fn parse(vm: &VirtualMachine, source: &str, mode: Mode) -> PyResult {
+    let ast = parser::parse(source, mode).map_err(|err| vm.new_value_error(format!("{}", err)))?;
+    let py_body = top_to_ast(vm, &ast)?;
+    Ok(node!(vm, Module, { body => py_body }).into_object())
+}
+
 pub fn make_module(vm: &VirtualMachine) -> PyObjectRef {
     let ctx = &vm.ctx;