Merge branch 'master' into coolreader18/update-deps

Author: coolreader18

Cargo.lock

@@ -6,10 +6,10 @@ build = "build.rs"
 edition = "2018"
 
 [build-dependencies]
-lalrpop="0.15.1"
+lalrpop="0.16.3"
 
 [dependencies]
-lalrpop-util="0.15.1"
+lalrpop-util="0.16.3"
 log="0.4.1"
 regex="0.2.2"
 num-bigint = "0.2"

parser/Cargo.toml

@@ -1,5 +1,8 @@
 use lalrpop;
 
 fn main() {
-    lalrpop::process_root().unwrap();
+    lalrpop::Configuration::new()
+        .generate_in_source_tree()
+        .process()
+        .unwrap();
 }

parser/build.rs

@@ -3,7 +3,7 @@
 use num_bigint::BigInt;
 
 /// Python source code can be tokenized in a sequence of these tokens.
-#[derive(Debug, PartialEq)]
+#[derive(Clone, Debug, PartialEq)]
 pub enum Tok {
     Name { name: String },
     Int { value: BigInt },

parser/src/token.rs

@@ -13,6 +13,7 @@ pip install pipenv
 if [ $CODE_COVERAGE = "true" ]
 then
     find . -name '*.gcda' -delete
+    find . -name '*.gcno' -delete
 
     export CARGO_INCREMENTAL=0
     export RUSTFLAGS="-Zprofile -Ccodegen-units=1 -Cinline-threshold=0 -Clink-dead-code -Coverflow-checks=off -Zno-landing-pads"

tests/.travis-runner.sh

@@ -11,6 +11,7 @@ use num_traits::{Signed, ToPrimitive};
 use crate::compile;
 use crate::import::import_module;
 use crate::obj::objbool;
+use crate::obj::objdict::PyDictRef;
 use crate::obj::objint;
 use crate::obj::objiter;
 use crate::obj::objstr::{self, PyStringRef};
@@ -27,14 +28,6 @@ use crate::obj::objcode::PyCodeRef;
 #[cfg(not(target_arch = "wasm32"))]
 use crate::stdlib::io::io_open;
 
-fn get_locals(vm: &VirtualMachine) -> PyObjectRef {
-    vm.get_locals()
-}
-
-fn dir_locals(vm: &VirtualMachine) -> PyObjectRef {
-    get_locals(vm)
-}
-
 fn builtin_abs(vm: &VirtualMachine, args: PyFuncArgs) -> PyResult {
     arg_check!(vm, args, required = [(x, None)]);
     match vm.get_method(x.clone(), "__abs__") {
@@ -88,7 +81,7 @@ fn builtin_bin(vm: &VirtualMachine, args: PyFuncArgs) -> PyResult {
 
 fn builtin_callable(vm: &VirtualMachine, args: PyFuncArgs) -> PyResult {
     arg_check!(vm, args, required = [(obj, None)]);
-    let is_callable = objtype::class_has_attr(&obj.type_pyref(), "__call__");
+    let is_callable = objtype::class_has_attr(&obj.class(), "__call__");
     Ok(vm.new_bool(is_callable))
 }
 
@@ -146,7 +139,7 @@ fn builtin_delattr(vm: &VirtualMachine, args: PyFuncArgs) -> PyResult {
 
 fn builtin_dir(vm: &VirtualMachine, args: PyFuncArgs) -> PyResult {
     if args.args.is_empty() {
-        Ok(dir_locals(vm))
+        Ok(vm.get_locals().into_object())
     } else {
         let obj = args.args.into_iter().next().unwrap();
         let seq = vm.call_method(&obj, "__dir__", vec![])?;
@@ -240,7 +233,7 @@ fn make_scope(
             } else if vm.isinstance(arg, &dict_type)? {
                 Some(arg)
             } else {
-                let arg_typ = arg.typ();
+                let arg_typ = arg.class();
                 let actual_type = vm.to_pystr(&arg_typ)?;
                 let expected_type_name = vm.to_pystr(&dict_type)?;
                 return Err(vm.new_type_error(format!(
@@ -254,11 +247,11 @@ fn make_scope(
 
     let current_scope = vm.current_scope();
     let globals = match globals {
-        Some(dict) => dict.clone(),
+        Some(dict) => dict.clone().downcast().unwrap(),
         None => current_scope.globals.clone(),
     };
     let locals = match locals {
-        Some(dict) => Some(dict.clone()),
+        Some(dict) => dict.clone().downcast().ok(),
         None => current_scope.get_only_locals(),
     };
 
@@ -300,7 +293,7 @@ fn builtin_getattr(
     }
 }
 
-fn builtin_globals(vm: &VirtualMachine, _args: PyFuncArgs) -> PyResult {
+fn builtin_globals(vm: &VirtualMachine) -> PyResult<PyDictRef> {
     Ok(vm.current_scope().globals.clone())
 }
 
@@ -368,15 +361,14 @@ fn builtin_len(vm: &VirtualMachine, args: PyFuncArgs) -> PyResult {
         Ok(value) => vm.invoke(value, PyFuncArgs::default()),
         Err(..) => Err(vm.new_type_error(format!(
             "object of type '{}' has no method {:?}",
-            objtype::get_type_name(&obj.typ()),
+            obj.class().name,
             len_method_name
         ))),
     }
 }
 
-fn builtin_locals(vm: &VirtualMachine, args: PyFuncArgs) -> PyResult {
-    arg_check!(vm, args);
-    Ok(vm.get_locals())
+fn builtin_locals(vm: &VirtualMachine) -> PyDictRef {
+    vm.get_locals()
 }
 
 fn builtin_max(vm: &VirtualMachine, args: PyFuncArgs) -> PyResult {
@@ -605,10 +597,9 @@ fn builtin_reversed(vm: &VirtualMachine, args: PyFuncArgs) -> PyResult {
     match vm.get_method(obj.clone(), "__reversed__") {
         Ok(value) => vm.invoke(value, PyFuncArgs::default()),
         // TODO: fallback to using __len__ and __getitem__, if object supports sequence protocol
-        Err(..) => Err(vm.new_type_error(format!(
-            "'{}' object is not reversible",
-            objtype::get_type_name(&obj.typ()),
-        ))),
+        Err(..) => {
+            Err(vm.new_type_error(format!("'{}' object is not reversible", obj.class().name)))
+        }
     }
 }
 // builtin_reversed
@@ -802,9 +793,9 @@ pub fn builtin_build_class_(vm: &VirtualMachine, mut args: PyFuncArgs) -> PyResu
     };
 
     for base in bases.clone() {
-        if objtype::issubclass(&base.type_pyref(), &metaclass) {
-            metaclass = base.type_pyref();
-        } else if !objtype::issubclass(&metaclass, &base.type_pyref()) {
+        if objtype::issubclass(&base.class(), &metaclass) {
+            metaclass = base.class();
+        } else if !objtype::issubclass(&metaclass, &base.class()) {
             return Err(vm.new_type_error("metaclass conflict: the metaclass of a derived class must be a (non-strict) subclass of the metaclasses of all its bases".to_string()));
         }
     }
@@ -815,13 +806,15 @@ pub fn builtin_build_class_(vm: &VirtualMachine, mut args: PyFuncArgs) -> PyResu
     let prepare = vm.get_attribute(metaclass.clone().into_object(), "__prepare__")?;
     let namespace = vm.invoke(prepare, vec![name_arg.clone(), bases.clone()])?;
 
+    let namespace: PyDictRef = TryFromObject::try_from_object(vm, namespace)?;
+
     let cells = vm.ctx.new_dict();
 
-    vm.invoke_with_locals(function, cells.clone().into_object(), namespace.clone())?;
+    vm.invoke_with_locals(function, cells.clone(), namespace.clone())?;
     let class = vm.call_method(
         metaclass.as_object(),
         "__call__",
-        vec![name_arg, bases, namespace],
+        vec![name_arg, bases, namespace.into_object()],
     )?;
     cells.set_item(&vm.ctx, "__class__", class.clone());
     Ok(class)

vm/src/builtins.rs

@@ -68,7 +68,6 @@ fn exception_str(vm: &VirtualMachine, args: PyFuncArgs) -> PyResult {
         args,
         required = [(exc, Some(vm.ctx.exceptions.exception_type.clone()))]
     );
-    let type_name = objtype::get_type_name(&exc.typ());
     let msg = if let Ok(m) = vm.get_attribute(exc.clone(), "msg") {
         match vm.to_pystr(&m) {
             Ok(msg) => msg,
@@ -77,7 +76,7 @@ fn exception_str(vm: &VirtualMachine, args: PyFuncArgs) -> PyResult {
     } else {
         panic!("Error message must be set");
     };
-    let s = format!("{}: {}", type_name, msg);
+    let s = format!("{}: {}", exc.class().name, msg);
     Ok(vm.new_str(s))
 }
 

vm/src/exceptions.rs

@@ -12,8 +12,7 @@ use crate::function::PyFuncArgs;
 use crate::obj::objbool;
 use crate::obj::objbuiltinfunc::PyBuiltinFunction;
 use crate::obj::objcode::PyCodeRef;
-use crate::obj::objdict;
-use crate::obj::objdict::PyDict;
+use crate::obj::objdict::{self, PyDictRef};
 use crate::obj::objint::PyInt;
 use crate::obj::objiter;
 use crate::obj::objlist;
@@ -80,8 +79,8 @@ impl<'a, T> Iterator for Iter<'a, T> {
 
 #[derive(Clone)]
 pub struct Scope {
-    locals: RcList<PyObjectRef>,
-    pub globals: PyObjectRef,
+    locals: RcList<PyDictRef>,
+    pub globals: PyDictRef,
 }
 
 impl fmt::Debug for Scope {
@@ -92,34 +91,34 @@ impl fmt::Debug for Scope {
 }
 
 impl Scope {
-    pub fn new(locals: Option<PyObjectRef>, globals: PyObjectRef) -> Scope {
+    pub fn new(locals: Option<PyDictRef>, globals: PyDictRef) -> Scope {
         let locals = match locals {
             Some(dict) => RcList::new().insert(dict),
             None => RcList::new(),
         };
         Scope { locals, globals }
     }
 
-    pub fn get_locals(&self) -> PyObjectRef {
+    pub fn get_locals(&self) -> PyDictRef {
         match self.locals.iter().next() {
             Some(dict) => dict.clone(),
             None => self.globals.clone(),
         }
     }
 
-    pub fn get_only_locals(&self) -> Option<PyObjectRef> {
+    pub fn get_only_locals(&self) -> Option<PyDictRef> {
         self.locals.iter().next().cloned()
     }
 
-    pub fn child_scope_with_locals(&self, locals: PyObjectRef) -> Scope {
+    pub fn child_scope_with_locals(&self, locals: PyDictRef) -> Scope {
         Scope {
             locals: self.locals.clone().insert(locals),
             globals: self.globals.clone(),
         }
     }
 
     pub fn child_scope(&self, ctx: &PyContext) -> Scope {
-        self.child_scope_with_locals(ctx.new_dict().into_object())
+        self.child_scope_with_locals(ctx.new_dict())
     }
 }
 
@@ -949,7 +948,7 @@ impl Frame {
         // let args = PyFuncArgs::default();
         // TODO: what happens when we got an error during handling exception?
         let args = if let Some(exc) = exc {
-            let exc_type = exc.typ();
+            let exc_type = exc.class().into_object();
             let exc_val = exc.clone();
             let exc_tb = vm.ctx.none(); // TODO: retrieve traceback?
             vec![exc_type, exc_val, exc_tb]
@@ -1093,7 +1092,7 @@ impl Frame {
             Ok(found) => Ok(found),
             Err(_) => Err(vm.new_type_error(format!(
                 "{} has no __contains__ method",
-                objtype::get_type_name(&haystack.typ())
+                haystack.class().name
             ))),
         }
     }
@@ -1103,7 +1102,7 @@ impl Frame {
             Ok(found) => Ok(vm.ctx.new_bool(!objbool::get_value(&found))),
             Err(_) => Err(vm.new_type_error(format!(
                 "{} has no __contains__ method",
-                objtype::get_type_name(&haystack.typ())
+                haystack.class().name
             ))),
         }
     }
@@ -1232,13 +1231,11 @@ impl fmt::Debug for Frame {
             .iter()
             .map(|elem| format!("\n  > {:?}", elem))
             .collect::<String>();
-        let local_str = match self.scope.get_locals().payload::<PyDict>() {
-            Some(dict) => objdict::get_key_value_pairs_from_content(&dict.entries.borrow())
-                .iter()
-                .map(|elem| format!("\n  {:?} = {:?}", elem.0, elem.1))
-                .collect::<String>(),
-            None => panic!("locals unexpectedly not wrapping a dict!",),
-        };
+        let dict = self.scope.get_locals();
+        let local_str = objdict::get_key_value_pairs_from_content(&dict.entries.borrow())
+            .iter()
+            .map(|elem| format!("\n  {:?} = {:?}", elem.0, elem.1))
+            .collect::<String>();
         write!(
             f,
             "Frame Object {{ \n Stack:{}\n Blocks:{}\n Locals:{}\n}}",

vm/src/frame.rs

@@ -99,7 +99,7 @@ impl PyFuncArgs {
                     Ok(Some(kwarg))
                 } else {
                     let expected_ty_name = vm.to_pystr(&ty)?;
-                    let actual_ty_name = vm.to_pystr(&kwarg.typ())?;
+                    let actual_ty_name = vm.to_pystr(&kwarg.class())?;
                     Err(vm.new_type_error(format!(
                         "argument of type {} is required for named parameter `{}` (got: {})",
                         expected_ty_name, key, actual_ty_name

vm/src/function.rs

@@ -40,7 +40,7 @@ fn import_uncached_module(vm: &VirtualMachine, current_path: PathBuf, module: &s
 
     let attrs = vm.ctx.new_dict();
     attrs.set_item(&vm.ctx, "__name__", vm.new_str(module.to_string()));
-    vm.run_code_obj(code_obj, Scope::new(None, attrs.clone().into_object()))?;
+    vm.run_code_obj(code_obj, Scope::new(None, attrs.clone()))?;
     Ok(vm.ctx.new_module(module, attrs))
 }
 

vm/src/import.rs

@@ -20,7 +20,7 @@ macro_rules! type_check {
             let arg = &$args.args[$arg_count];
 
             if !$crate::obj::objtype::isinstance(arg, &expected_type) {
-                let arg_typ = arg.typ();
+                let arg_typ = arg.class();
                 let expected_type_name = $vm.to_pystr(&expected_type)?;
                 let actual_type = $vm.to_pystr(&arg_typ)?;
                 return Err($vm.new_type_error(format!(

vm/src/macros.rs

@@ -190,8 +190,7 @@ impl PyFloatRef {
                 }
             }
         } else {
-            let type_name = objtype::get_type_name(&arg.typ());
-            return Err(vm.new_type_error(format!("can't convert {} to float", type_name)));
+            return Err(vm.new_type_error(format!("can't convert {} to float", arg.class().name)));
         };
         PyFloat { value }.into_ref_with_type(vm, cls)
     }