Merge branch 'master' into coolreader18/proc-macro-span-errors

coolreader18 · coolreader18 · commit 48b0a17e4d70 · 2019-04-17T20:45:50.000-05:00
diff --git a/src/main.rs b/src/main.rs
@@ -65,11 +65,8 @@ fn main() {
 }
 
 fn _run_string(vm: &VirtualMachine, source: &str, source_path: String) -> PyResult {
-    let code_obj =
-        compile::compile(vm, source, &compile::Mode::Exec, source_path).map_err(|err| {
-            let syntax_error = vm.context().exceptions.syntax_error.clone();
-            vm.new_exception(syntax_error, err.to_string())
-        })?;
+    let code_obj = compile::compile(vm, source, &compile::Mode::Exec, source_path)
+        .map_err(|err| vm.new_syntax_error(&err))?;
     // trace!("Code object: {:?}", code_obj.borrow());
     let vars = vm.ctx.new_scope(); // Keep track of local variables
     vm.run_code_obj(code_obj, vars)
@@ -120,8 +117,7 @@ fn shell_exec(vm: &VirtualMachine, source: &str, scope: Scope) -> Result<(), Com
         // Don't inject syntax errors for line continuation
         Err(err @ CompileError::Parse(ParseError::EOF(_))) => Err(err),
         Err(err) => {
-            let syntax_error = vm.context().exceptions.syntax_error.clone();
-            let exc = vm.new_exception(syntax_error, format!("{}", err));
+            let exc = vm.new_syntax_error(&err);
             print_exception(vm, &exc);
             Err(err)
         }
diff --git a/tests/snippets/builtin_slice.py b/tests/snippets/builtin_slice.py
@@ -11,6 +11,7 @@
 b = [1, 2]
 
 assert b[:] == [1, 2]
+assert b[slice(None)] == [1, 2]
 assert b[: 2 ** 100] == [1, 2]
 assert b[-2 ** 100 :] == [1, 2]
 assert b[2 ** 100 :] == []
@@ -60,6 +61,12 @@
 assert slice_c.stop == 5
 assert slice_c.step == 2
 
+a = object()
+slice_d = slice(a, "v", 1.0)
+assert slice_d.start is a
+assert slice_d.stop == "v"
+assert slice_d.step == 1.0
+
 
 class SubScript(object):
     def __getitem__(self, item):
@@ -74,6 +81,18 @@ def __setitem__(self, key, value):
 ss[:1] = 1
 
 
+class CustomIndex:
+    def __init__(self, x):
+        self.x = x
+
+    def __index__(self):
+        return self.x
+
+
+assert c[CustomIndex(1):CustomIndex(3)] == [1, 2]
+assert d[CustomIndex(1):CustomIndex(3)] == "23"
+
+
 def test_all_slices():
     """
     test all possible slices except big number
diff --git a/tests/snippets/global_nonlocal.py b/tests/snippets/global_nonlocal.py
@@ -11,3 +11,13 @@ def b():
 b()
 assert a == 4
 
+def x():
+    def y():
+        nonlocal b
+        b = 3
+    b = 2
+    y()
+    return b
+
+res = x()
+assert res == 3, str(res)
diff --git a/tests/snippets/import.py b/tests/snippets/import.py
@@ -3,6 +3,7 @@
 from import_target import func as aliased_func, other_func as aliased_other_func
 from import_star import *
 
+import import_mutual1
 assert import_target.X == import_target.func()
 assert import_target.X == func()
 
diff --git a/tests/snippets/import_mutual1.py b/tests/snippets/import_mutual1.py
@@ -0,0 +1,4 @@
+
+# Mutual recursive import:
+import import_mutual2
+
diff --git a/tests/snippets/import_mutual2.py b/tests/snippets/import_mutual2.py
@@ -0,0 +1,3 @@
+
+# Mutual recursive import:
+import import_mutual1
diff --git a/tests/snippets/stdlib_os.py b/tests/snippets/stdlib_os.py
@@ -51,6 +51,10 @@ def __exit__(self, exc_type, exc_val, exc_tb):
 assert ENV_KEY in os.environ
 assert os.getenv(ENV_KEY) == ENV_VALUE
 del os.environ[ENV_KEY]
-os.unsetenv(ENV_KEY)
 assert ENV_KEY not in os.environ
 assert os.getenv(ENV_KEY) == None
+
+if os.name == "posix":
+	os.putenv(ENV_KEY, ENV_VALUE)
+	os.unsetenv(ENV_KEY)
+	assert os.getenv(ENV_KEY) == None
diff --git a/vm/src/bytecode.rs b/vm/src/bytecode.rs
@@ -41,6 +41,7 @@ pub type Label = usize;
 #[derive(Debug, Clone, PartialEq)]
 pub enum NameScope {
     Local,
+    NonLocal,
     Global,
 }
 
diff --git a/vm/src/compile.rs b/vm/src/compile.rs
@@ -179,12 +179,12 @@ impl Compiler {
         let role = self.lookup_name(name);
         match role {
             SymbolRole::Global => bytecode::NameScope::Global,
+            SymbolRole::Nonlocal => bytecode::NameScope::NonLocal,
             _ => bytecode::NameScope::Local,
         }
     }
 
     fn load_name(&mut self, name: &str) {
-        // TODO: if global, do something else!
         let scope = self.scope_for_name(name);
         self.emit(Instruction::LoadName {
             name: name.to_string(),
diff --git a/vm/src/frame.rs b/vm/src/frame.rs
@@ -2,8 +2,6 @@ use std::cell::RefCell;
 use std::fmt;
 use std::rc::Rc;
 
-use num_bigint::BigInt;
-
 use rustpython_parser::ast;
 
 use crate::builtins;
@@ -12,7 +10,6 @@ use crate::function::PyFuncArgs;
 use crate::obj::objbool;
 use crate::obj::objcode::PyCodeRef;
 use crate::obj::objdict::{PyDict, PyDictRef};
-use crate::obj::objint::PyInt;
 use crate::obj::objiter;
 use crate::obj::objlist;
 use crate::obj::objslice::PySlice;
@@ -129,6 +126,7 @@ pub trait NameProtocol {
     fn store_name(&self, vm: &VirtualMachine, name: &str, value: PyObjectRef);
     fn delete_name(&self, vm: &VirtualMachine, name: &str);
     fn load_cell(&self, vm: &VirtualMachine, name: &str) -> Option<PyObjectRef>;
+    fn store_cell(&self, vm: &VirtualMachine, name: &str, value: PyObjectRef);
     fn load_global(&self, vm: &VirtualMachine, name: &str) -> Option<PyObjectRef>;
     fn store_global(&self, vm: &VirtualMachine, name: &str, value: PyObjectRef);
 }
@@ -157,6 +155,16 @@ impl NameProtocol for Scope {
         None
     }
 
+    fn store_cell(&self, vm: &VirtualMachine, name: &str, value: PyObjectRef) {
+        self.locals
+            .iter()
+            .skip(1)
+            .next()
+            .expect("no outer scope for non-local")
+            .set_item(name, value, vm)
+            .unwrap();
+    }
+
     fn store_name(&self, vm: &VirtualMachine, key: &str, value: PyObjectRef) {
         self.get_locals().set_item(key, value, vm).unwrap();
     }
@@ -435,26 +443,21 @@ impl Frame {
             }
             bytecode::Instruction::BuildSlice { size } => {
                 assert!(*size == 2 || *size == 3);
-                let elements = self.pop_multiple(*size);
 
-                let mut out: Vec<Option<BigInt>> = elements
-                    .into_iter()
-                    .map(|x| {
-                        if x.is(&vm.ctx.none()) {
-                            None
-                        } else if let Some(i) = x.payload::<PyInt>() {
-                            Some(i.as_bigint().clone())
-                        } else {
-                            panic!("Expect Int or None as BUILD_SLICE arguments")
-                        }
-                    })
-                    .collect();
-
-                let start = out[0].take();
-                let stop = out[1].take();
-                let step = if out.len() == 3 { out[2].take() } else { None };
+                let step = if *size == 3 {
+                    Some(self.pop_value())
+                } else {
+                    None
+                };
+                let stop = self.pop_value();
+                let start = self.pop_value();
 
-                let obj = PySlice { start, stop, step }.into_ref(vm);
+                let obj = PySlice {
+                    start: Some(start),
+                    stop,
+                    step,
+                }
+                .into_ref(vm);
                 self.push_value(obj.into_object());
                 Ok(None)
             }
@@ -1037,8 +1040,11 @@ impl Frame {
             bytecode::NameScope::Global => {
                 self.scope.store_global(vm, name, obj);
             }
+            bytecode::NameScope::NonLocal => {
+                self.scope.store_cell(vm, name, obj);
+            }
             bytecode::NameScope::Local => {
-                self.scope.store_name(&vm, name, obj);
+                self.scope.store_name(vm, name, obj);
             }
         }
         Ok(None)
@@ -1057,6 +1063,7 @@ impl Frame {
     ) -> FrameResult {
         let optional_value = match name_scope {
             bytecode::NameScope::Global => self.scope.load_global(vm, name),
+            bytecode::NameScope::NonLocal => self.scope.load_cell(vm, name),
             bytecode::NameScope::Local => self.scope.load_name(&vm, name),
         };
 
diff --git a/vm/src/function.rs b/vm/src/function.rs
@@ -1,4 +1,5 @@
 use std::collections::HashMap;
+use std::mem;
 use std::ops::RangeInclusive;
 
 use crate::obj::objtype::{isinstance, PyClassRef};
@@ -48,6 +49,12 @@ impl From<(&Args, &KwArgs)> for PyFuncArgs {
     }
 }
 
+impl FromArgs for PyFuncArgs {
+    fn from_args(_vm: &VirtualMachine, args: &mut PyFuncArgs) -> Result<Self, ArgumentError> {
+        Ok(mem::replace(args, Default::default()))
+    }
+}
+
 impl PyFuncArgs {
     pub fn new(mut args: Vec<PyObjectRef>, kwarg_names: Vec<String>) -> PyFuncArgs {
         let mut kwargs = vec![];
diff --git a/vm/src/import.rs b/vm/src/import.rs
@@ -11,44 +11,47 @@ use crate::pyobject::{ItemProtocol, PyResult};
 use crate::util;
 use crate::vm::VirtualMachine;
 
-fn import_uncached_module(vm: &VirtualMachine, current_path: PathBuf, module: &str) -> PyResult {
-    // Check for Rust-native modules
-    if let Some(module) = vm.stdlib_inits.borrow().get(module) {
-        return Ok(module(vm).clone());
-    }
+pub fn import_module(vm: &VirtualMachine, current_path: PathBuf, module_name: &str) -> PyResult {
+    // Cached modules:
+    let sys_modules = vm.get_attribute(vm.sys_module.clone(), "modules").unwrap();
 
-    let notfound_error = vm.context().exceptions.module_not_found_error.clone();
-    let import_error = vm.context().exceptions.import_error.clone();
+    // First, see if we already loaded the module:
+    if let Ok(module) = sys_modules.get_item(module_name.to_string(), vm) {
+        Ok(module)
+    } else if let Some(make_module_func) = vm.stdlib_inits.borrow().get(module_name) {
+        let module = make_module_func(vm);
+        sys_modules.set_item(module_name, module.clone(), vm)?;
+        Ok(module)
+    } else {
+        let notfound_error = vm.context().exceptions.module_not_found_error.clone();
+        let import_error = vm.context().exceptions.import_error.clone();
 
-    // Time to search for module in any place:
-    let file_path = find_source(vm, current_path, module)
-        .map_err(|e| vm.new_exception(notfound_error.clone(), e))?;
-    let source = util::read_file(file_path.as_path())
-        .map_err(|e| vm.new_exception(import_error.clone(), e.to_string()))?;
-    let code_obj = compile::compile(
-        vm,
-        &source,
-        &compile::Mode::Exec,
-        file_path.to_str().unwrap().to_string(),
-    )
-    .map_err(|err| vm.new_syntax_error(&err))?;
-    // trace!("Code object: {:?}", code_obj);
+        // Time to search for module in any place:
+        let file_path = find_source(vm, current_path, module_name)
+            .map_err(|e| vm.new_exception(notfound_error.clone(), e))?;
+        let source = util::read_file(file_path.as_path())
+            .map_err(|e| vm.new_exception(import_error.clone(), e.to_string()))?;
+        let code_obj = compile::compile(
+            vm,
+            &source,
+            &compile::Mode::Exec,
+            file_path.to_str().unwrap().to_string(),
+        )
+        .map_err(|err| vm.new_syntax_error(&err))?;
+        // trace!("Code object: {:?}", code_obj);
 
-    let attrs = vm.ctx.new_dict();
-    attrs.set_item("__name__", vm.new_str(module.to_string()), vm)?;
-    vm.run_code_obj(code_obj, Scope::new(None, attrs.clone()))?;
-    Ok(vm.ctx.new_module(module, attrs))
-}
+        let attrs = vm.ctx.new_dict();
+        attrs.set_item("__name__", vm.new_str(module_name.to_string()), vm)?;
+        let module = vm.ctx.new_module(module_name, attrs.clone());
 
-pub fn import_module(vm: &VirtualMachine, current_path: PathBuf, module_name: &str) -> PyResult {
-    // First, see if we already loaded the module:
-    let sys_modules = vm.get_attribute(vm.sys_module.clone(), "modules")?;
-    if let Ok(module) = sys_modules.get_item(module_name.to_string(), vm) {
-        return Ok(module);
+        // Store module in cache to prevent infinite loop with mutual importing libs:
+        sys_modules.set_item(module_name, module.clone(), vm)?;
+
+        // Execute main code in module:
+        vm.run_code_obj(code_obj, Scope::new(None, attrs))?;
+
+        Ok(module)
     }
-    let module = import_uncached_module(vm, current_path, module_name)?;
-    sys_modules.set_item(module_name, module.clone(), vm)?;
-    Ok(module)
 }
 
 fn find_source(vm: &VirtualMachine, current_path: PathBuf, name: &str) -> Result<PathBuf, String> {
diff --git a/vm/src/obj/objlist.rs b/vm/src/obj/objlist.rs
@@ -210,12 +210,12 @@ impl PyListRef {
     }
 
     fn setslice(self, slice: PySliceRef, sec: PyIterable, vm: &VirtualMachine) -> PyResult {
-        let step = slice.step.clone().unwrap_or_else(BigInt::one);
+        let step = slice.step_index(vm)?.unwrap_or_else(BigInt::one);
 
         if step.is_zero() {
             Err(vm.new_value_error("slice step cannot be zero".to_string()))
         } else if step.is_positive() {
-            let range = self.get_slice_range(&slice.start, &slice.stop);
+            let range = self.get_slice_range(&slice.start_index(vm)?, &slice.stop_index(vm)?);
             if range.start < range.end {
                 match step.to_i32() {
                     Some(1) => self._set_slice(range, sec, vm),
@@ -237,14 +237,14 @@ impl PyListRef {
         } else {
             // calculate the range for the reverse slice, first the bounds needs to be made
             // exclusive around stop, the lower number
-            let start = &slice.start.as_ref().map(|x| {
+            let start = &slice.start_index(vm)?.as_ref().map(|x| {
                 if *x == (-1).to_bigint().unwrap() {
                     self.get_len() + BigInt::one() //.to_bigint().unwrap()
                 } else {
                     x + 1
                 }
             });
-            let stop = &slice.stop.as_ref().map(|x| {
+            let stop = &slice.stop_index(vm)?.as_ref().map(|x| {
                 if *x == (-1).to_bigint().unwrap() {
                     self.get_len().to_bigint().unwrap()
                 } else {
@@ -552,9 +552,9 @@ impl PyListRef {
     }
 
     fn delslice(self, slice: PySliceRef, vm: &VirtualMachine) -> PyResult {
-        let start = &slice.start;
-        let stop = &slice.stop;
-        let step = slice.step.clone().unwrap_or_else(BigInt::one);
+        let start = slice.start_index(vm)?;
+        let stop = slice.stop_index(vm)?;
+        let step = slice.step_index(vm)?.unwrap_or_else(BigInt::one);
 
         if step.is_zero() {
             Err(vm.new_value_error("slice step cannot be zero".to_string()))
diff --git a/vm/src/obj/objrange.rs b/vm/src/obj/objrange.rs
diff --git a/vm/src/obj/objsequence.rs b/vm/src/obj/objsequence.rs
diff --git a/vm/src/obj/objslice.rs b/vm/src/obj/objslice.rs

-Original file line number
+Diff line change
@@ @@ -0,0 +1,4 @@ @@
++
 +# Mutual recursive import:
 +import import_mutual2
++
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+`
	`2`	`+# Mutual recursive import:`
	`3`	`+import import_mutual1`
Original file line number	Diff line number	Diff line change
`@@ -41,6 +41,7 @@ pub type Label = usize;`
`41`	`41`	`#[derive(Debug, Clone, PartialEq)]`
`42`	`42`	`pub enum NameScope {`
`43`	`43`	`Local,`
	`44`	`+ NonLocal,`
`44`	`45`	`Global,`
`45`	`46`	`}`
`46`	`47`
Original file line number	Diff line number	Diff line change
`@@ -179,12 +179,12 @@ impl Compiler {`
`179`	`179`	`let role = self.lookup_name(name);`
`180`	`180`	`match role {`
`181`	`181`	`SymbolRole::Global => bytecode::NameScope::Global,`
	`182`	`+ SymbolRole::Nonlocal => bytecode::NameScope::NonLocal,`
`182`	`183`	`_ => bytecode::NameScope::Local,`
`183`	`184`	`}`
`184`	`185`	`}`
`185`	`186`
`186`	`187`	`fn load_name(&mut self, name: &str) {`
`187`		`- // TODO: if global, do something else!`
`188`	`188`	`let scope = self.scope_for_name(name);`
`189`	`189`	`self.emit(Instruction::LoadName {`
`190`	`190`	`name: name.to_string(),`