RustPython
diff --git a/‎derive/src/lib.rs
Lines changed: 1 addition & 1 deletion b/‎derive/src/lib.rs
Lines changed: 1 addition & 1 deletion
diff --git a/‎src/main.rs
Lines changed: 13 additions & 13 deletions b/‎src/main.rs
Lines changed: 13 additions & 13 deletions
@@ -38,7 +38,7 @@ fn impl_from_args(input: &DeriveInput) -> TokenStream2 {
     quote! {
         impl crate::function::FromArgs for #name {
             fn from_args(
-                vm: &mut crate::vm::VirtualMachine,
+                vm: &crate::vm::VirtualMachine,
                 args: &mut crate::function::PyFuncArgs
             ) -> Result<Self, crate::function::ArgumentError> {
                 Ok(#name { #(#fields)* })
 
@@ -51,26 +51,26 @@ fn main() {
         .get_matches();
 
     // Construct vm:
-    let mut vm = VirtualMachine::new();
+    let vm = VirtualMachine::new();
 
     // Figure out if a -c option was given:
     let result = if let Some(command) = matches.value_of("c") {
-        run_command(&mut vm, command.to_string())
+        run_command(&vm, command.to_string())
     } else if let Some(module) = matches.value_of("m") {
-        run_module(&mut vm, module)
+        run_module(&vm, module)
     } else {
         // Figure out if a script was passed:
         match matches.value_of("script") {
-            None => run_shell(&mut vm),
-            Some(filename) => run_script(&mut vm, filename),
+            None => run_shell(&vm),
+            Some(filename) => run_script(&vm, filename),
         }
     };
 
     // See if any exception leaked out:
-    handle_exception(&mut vm, result);
+    handle_exception(&vm, result);
 }
 
-fn _run_string(vm: &mut VirtualMachine, source: &str, source_path: String) -> PyResult {
+fn _run_string(vm: &VirtualMachine, source: &str, source_path: String) -> PyResult {
     let code_obj = compile::compile(
         source,
         &compile::Mode::Exec,
@@ -86,28 +86,28 @@ fn _run_string(vm: &mut VirtualMachine, source: &str, source_path: String) -> Py
     vm.run_code_obj(code_obj, vars)
 }
 
-fn handle_exception(vm: &mut VirtualMachine, result: PyResult) {
+fn handle_exception(vm: &VirtualMachine, result: PyResult) {
     if let Err(err) = result {
         print_exception(vm, &err);
         std::process::exit(1);
     }
 }
 
-fn run_command(vm: &mut VirtualMachine, mut source: String) -> PyResult {
+fn run_command(vm: &VirtualMachine, mut source: String) -> PyResult {
     debug!("Running command {}", source);
 
     // This works around https://github.com/RustPython/RustPython/issues/17
     source.push('\n');
     _run_string(vm, &source, "<stdin>".to_string())
 }
 
-fn run_module(vm: &mut VirtualMachine, module: &str) -> PyResult {
+fn run_module(vm: &VirtualMachine, module: &str) -> PyResult {
     debug!("Running module {}", module);
     let current_path = PathBuf::from(".");
     import::import_module(vm, current_path, module)
 }
 
-fn run_script(vm: &mut VirtualMachine, script_file: &str) -> PyResult {
+fn run_script(vm: &VirtualMachine, script_file: &str) -> PyResult {
     debug!("Running file {}", script_file);
     // Parse an ast from it:
     let file_path = Path::new(script_file);
@@ -120,7 +120,7 @@ fn run_script(vm: &mut VirtualMachine, script_file: &str) -> PyResult {
     }
 }
 
-fn shell_exec(vm: &mut VirtualMachine, source: &str, scope: Scope) -> Result<(), CompileError> {
+fn shell_exec(vm: &VirtualMachine, source: &str, scope: Scope) -> Result<(), CompileError> {
     match compile::compile(
         source,
         &compile::Mode::Single,
@@ -159,7 +159,7 @@ fn get_history_path() -> PathBuf {
     xdg_dirs.place_cache_file("repl_history.txt").unwrap()
 }
 
-fn run_shell(vm: &mut VirtualMachine) -> PyResult {
+fn run_shell(vm: &VirtualMachine) -> PyResult {
     println!(
         "Welcome to the magnificent Rust Python {} interpreter",
         crate_version!()