Change compile::compile() to take a Mode instead of an &Mode

Author: coolreader18

benchmarks/bench.rs

@@ -94,7 +94,7 @@ fn bench_rustpy_nbody(b: &mut test::Bencher) {
 
     let vm = VirtualMachine::default();
 
-    let code = match vm.compile(source, &compile::Mode::Single, "<stdin>".to_string()) {
+    let code = match vm.compile(source, compile::Mode::Single, "<stdin>".to_string()) {
         Ok(code) => code,
         Err(e) => panic!("{:?}", e),
     };
@@ -113,7 +113,7 @@ fn bench_rustpy_mandelbrot(b: &mut test::Bencher) {
 
     let vm = VirtualMachine::default();
 
-    let code = match vm.compile(source, &compile::Mode::Single, "<stdin>".to_string()) {
+    let code = match vm.compile(source, compile::Mode::Single, "<stdin>".to_string()) {
         Ok(code) => code,
         Err(e) => panic!("{:?}", e),
     };

compiler/src/compile.rs

@@ -31,7 +31,7 @@ struct Compiler<O: OutputStream = BasicOutputStream> {
 /// Compile a given sourcecode into a bytecode object.
 pub fn compile(
     source: &str,
-    mode: &Mode,
+    mode: Mode,
     source_path: String,
     optimize: u8,
 ) -> Result<CodeObject, CompileError> {
@@ -102,6 +102,7 @@ pub fn compile_program_single(
     })
 }
 
+#[derive(Clone, Copy)]
 pub enum Mode {
     Exec,
     Eval,

derive/src/compile_bytecode.rs

@@ -41,7 +41,7 @@ impl CompilationSource {
     fn compile_string(
         &self,
         source: &str,
-        mode: &compile::Mode,
+        mode: compile::Mode,
         module_name: String,
     ) -> Result<CodeObject, Diagnostic> {
         compile::compile(source, mode, module_name, 0)
@@ -50,7 +50,7 @@ impl CompilationSource {
 
     fn compile(
         &self,
-        mode: &compile::Mode,
+        mode: compile::Mode,
         module_name: String,
     ) -> Result<HashMap<String, FrozenModule>, Diagnostic> {
         Ok(match &self.kind {
@@ -94,7 +94,7 @@ impl CompilationSource {
         &self,
         path: &Path,
         parent: String,
-        mode: &compile::Mode,
+        mode: compile::Mode,
     ) -> Result<HashMap<String, FrozenModule>, Diagnostic> {
         let mut code_map = HashMap::new();
         let paths = fs::read_dir(&path).map_err(|err| {
@@ -225,7 +225,7 @@ impl PyCompileInput {
                 )
             })?
             .compile(
-                &mode.unwrap_or(compile::Mode::Exec),
+                mode.unwrap_or(compile::Mode::Exec),
                 module_name.unwrap_or_else(|| "frozen".to_string()),
             )
     }

src/main.rs

@@ -333,7 +333,7 @@ fn run_rustpython(vm: &VirtualMachine, matches: &ArgMatches) -> PyResult<()> {
 
 fn _run_string(vm: &VirtualMachine, scope: Scope, source: &str, source_path: String) -> PyResult {
     let code_obj = vm
-        .compile(source, &compile::Mode::Exec, source_path.clone())
+        .compile(source, compile::Mode::Exec, source_path.clone())
         .map_err(|err| vm.new_syntax_error(&err))?;
     // trace!("Code object: {:?}", code_obj.borrow());
     scope
@@ -426,7 +426,7 @@ fn test_run_script() {
 }
 
 fn shell_exec(vm: &VirtualMachine, source: &str, scope: Scope) -> Result<(), CompileError> {
-    match vm.compile(source, &compile::Mode::Single, "<stdin>".to_string()) {
+    match vm.compile(source, compile::Mode::Single, "<stdin>".to_string()) {
         Ok(code) => {
             match vm.run_code_obj(code, scope.clone()) {
                 Ok(value) => {

vm/src/builtins.rs

@@ -127,7 +127,7 @@ fn builtin_compile(args: CompileArgs, vm: &VirtualMachine) -> PyResult<PyCodeRef
 
     let mode = get_compile_mode(vm, &args.mode.value)?;
 
-    vm.compile(&source, &mode, args.filename.value.to_string())
+    vm.compile(&source, mode, args.filename.value.to_string())
         .map_err(|err| vm.new_syntax_error(&err))
 }
 
@@ -175,7 +175,7 @@ fn builtin_eval(vm: &VirtualMachine, args: PyFuncArgs) -> PyResult {
     } else if objtype::isinstance(source, &vm.ctx.str_type()) {
         let mode = compile::Mode::Eval;
         let source = objstr::get_value(source);
-        vm.compile(&source, &mode, "<string>".to_string())
+        vm.compile(&source, mode, "<string>".to_string())
             .map_err(|err| vm.new_syntax_error(&err))?
     } else {
         return Err(vm.new_type_error("code argument must be str or code object".to_string()));
@@ -202,7 +202,7 @@ fn builtin_exec(vm: &VirtualMachine, args: PyFuncArgs) -> PyResult {
     let code_obj = if objtype::isinstance(source, &vm.ctx.str_type()) {
         let mode = compile::Mode::Exec;
         let source = objstr::get_value(source);
-        vm.compile(&source, &mode, "<string>".to_string())
+        vm.compile(&source, mode, "<string>".to_string())
             .map_err(|err| vm.new_syntax_error(&err))?
     } else if let Ok(code_obj) = PyCodeRef::try_from_object(vm, source.clone()) {
         code_obj

vm/src/eval.rs

@@ -4,7 +4,7 @@ use crate::vm::VirtualMachine;
 use rustpython_compiler::compile;
 
 pub fn eval(vm: &VirtualMachine, source: &str, scope: Scope, source_path: &str) -> PyResult {
-    match vm.compile(source, &compile::Mode::Eval, source_path.to_string()) {
+    match vm.compile(source, compile::Mode::Eval, source_path.to_string()) {
         Ok(bytecode) => {
             debug!("Code object: {:?}", bytecode);
             vm.run_code_obj(bytecode, scope)

vm/src/import.rs

@@ -68,7 +68,7 @@ pub fn import_file(
 ) -> PyResult {
     let code_obj = compile::compile(
         &content,
-        &compile::Mode::Exec,
+        compile::Mode::Exec,
         file_path,
         vm.settings.optimize,
     )

vm/src/vm.rs

@@ -877,7 +877,7 @@ impl VirtualMachine {
     pub fn compile(
         &self,
         source: &str,
-        mode: &compile::Mode,
+        mode: compile::Mode,
         source_path: String,
     ) -> Result<PyCodeRef, CompileError> {
         compile::compile(source, mode, source_path, self.settings.optimize)

wasm/lib/src/lib.rs

@@ -63,7 +63,7 @@ const TS_CMT_START: &'static str = "/*";
 ///     receive the Python kwargs as the `this` argument.
 /// -   `stdout?`: `(out: string) => void`: A function to replace the native print
 ///     function, by default `console.log`.
-pub fn eval_py(source: String, options: Option<Object>) -> Result<JsValue, JsValue> {
+pub fn eval_py(source: &str, options: Option<Object>) -> Result<JsValue, JsValue> {
     let options = options.unwrap_or_else(Object::new);
     let js_vars = {
         let prop = Reflect::get(&options, &"vars".into())?;

wasm/lib/src/vm_class.rs

@@ -271,13 +271,13 @@ impl WASMVirtualMachine {
         })?
     }
 
-    fn run(&self, source: String, mode: compile::Mode) -> Result<JsValue, JsValue> {
+    fn run(&self, source: &str, mode: compile::Mode) -> Result<JsValue, JsValue> {
         self.assert_valid()?;
         self.with_unchecked(
             |StoredVirtualMachine {
                  ref vm, ref scope, ..
              }| {
-                let code = vm.compile(&source, &mode, "<wasm>".to_string());
+                let code = vm.compile(source, mode, "<wasm>".to_string());
                 let code = code.map_err(|err| {
                     let js_err = SyntaxError::new(&format!("Error parsing Python code: {}", err));
                     let _ =
@@ -295,16 +295,16 @@ impl WASMVirtualMachine {
         )
     }
 
-    pub fn exec(&self, source: String) -> Result<JsValue, JsValue> {
+    pub fn exec(&self, source: &str) -> Result<JsValue, JsValue> {
         self.run(source, compile::Mode::Exec)
     }
 
-    pub fn eval(&self, source: String) -> Result<JsValue, JsValue> {
+    pub fn eval(&self, source: &str) -> Result<JsValue, JsValue> {
         self.run(source, compile::Mode::Eval)
     }
 
     #[wasm_bindgen(js_name = execSingle)]
-    pub fn exec_single(&self, source: String) -> Result<JsValue, JsValue> {
+    pub fn exec_single(&self, source: &str) -> Result<JsValue, JsValue> {
         self.run(source, compile::Mode::Single)
     }
 }