Merge remote-tracking branch 'origin/master' into joey/pyobject-function-split

Conflicts:
      vm/src/frame.rs
      vm/src/obj/objbytearray.rs
      vm/src/obj/objbytes.rs
      vm/src/obj/objcomplex.rs

Author: OddCoincidence

.travis.yml

@@ -115,6 +115,26 @@ matrix:
         - TRAVIS_RUST_VERSION=nightly
         - REGULAR_TEST=false
         - CODE_COVERAGE=true
+    - name: test WASM
+      language: python
+      python: 3.6
+      cache:
+        pip: true
+        # Because we're using the Python Travis environment, we can't use
+        # the built-in cargo cacher
+        directories:
+          - /home/travis/.cargo
+          - target
+      addons:
+        firefox: latest
+      install:
+        - nvm install node
+        - pip install pipenv
+      script:
+        - wasm/tests/.travis-runner.sh
+      env:
+        - REGULAR_TEST=true
+        - TRAVIS_RUST_VERSION=stable
   allow_failures:
     - rust: nightly
       env: REGULAR_TEST=true

tests/snippets/builtin_any.py

@@ -0,0 +1,13 @@
+assert any([1]);
+assert not any([]);
+assert not any([0,0,0,0]);
+assert any([0,0,1,0,0]);
+def anything(a):
+    return a
+
+class Test:
+ def __iter__(self):
+   while True:
+    yield True
+
+assert any(map(anything, Test()))

vm/src/builtins.rs

@@ -65,13 +65,19 @@ fn builtin_all(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
 
 fn builtin_any(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     arg_check!(vm, args, required = [(iterable, None)]);
-    let items = vm.extract_elements(iterable)?;
-    for item in items {
+    let iterator = objiter::get_iter(vm, iterable)?;
+
+    loop {
+        let item = match objiter::get_next_object(vm, &iterator)? {
+            Some(obj) => obj,
+            None => break,
+        };
         let result = objbool::boolval(vm, item)?;
         if result {
             return Ok(vm.new_bool(true));
         }
     }
+
     Ok(vm.new_bool(false))
 }
 

vm/src/frame.rs

@@ -21,8 +21,8 @@ use crate::obj::objslice::PySlice;
 use crate::obj::objstr;
 use crate::obj::objtype;
 use crate::pyobject::{
-    AttributeProtocol, DictProtocol, IdProtocol, PyContext, PyObject, PyObjectRef, PyResult,
-    PyValue, TryFromObject, TypeProtocol,
+    AttributeProtocol, DictProtocol, IdProtocol, PyContext, PyObjectRef, PyResult, PyValue,
+    TryFromObject, TypeProtocol,
 };
 use crate::vm::VirtualMachine;
 
@@ -410,8 +410,8 @@ impl Frame {
                 let stop = out[1].take();
                 let step = if out.len() == 3 { out[2].take() } else { None };
 
-                let obj = PyObject::new(PySlice { start, stop, step }, vm.ctx.slice_type());
-                self.push_value(obj);
+                let obj = PySlice { start, stop, step }.into_ref(vm);
+                self.push_value(obj.into_object());
                 Ok(None)
             }
             bytecode::Instruction::ListAppend { i } => {
@@ -692,22 +692,17 @@ impl Frame {
                 let expr = self.pop_value();
                 if !expr.is(&vm.get_none()) {
                     let repr = vm.to_repr(&expr)?;
-                    builtins::builtin_print(
-                        vm,
-                        PyFuncArgs {
-                            args: vec![repr],
-                            kwargs: vec![],
-                        },
-                    )?;
+                    // TODO: implement sys.displayhook
+                    if let Some(print) = vm.ctx.get_attr(&vm.builtins, "print") {
+                        vm.invoke(print, vec![repr])?;
+                    }
                 }
                 Ok(None)
             }
             bytecode::Instruction::LoadBuildClass => {
-                let rustfunc = PyObject::new(
-                    PyBuiltinFunction::new(Box::new(builtins::builtin_build_class_)),
-                    vm.ctx.type_type(),
-                );
-                self.push_value(rustfunc);
+                let rustfunc =
+                    PyBuiltinFunction::new(Box::new(builtins::builtin_build_class_)).into_ref(vm);
+                self.push_value(rustfunc.into_object());
                 Ok(None)
             }
             bytecode::Instruction::UnpackSequence { size } => {

vm/src/obj/objbytearray.rs

@@ -6,18 +6,19 @@ use std::ops::{Deref, DerefMut};
 
 use num_traits::ToPrimitive;
 
-use crate::function::PyFuncArgs;
-use crate::pyobject::{PyContext, PyObject, PyObjectRef, PyResult, PyValue, TypeProtocol};
+use crate::function::{OptionalArg, PyFuncArgs};
+use crate::pyobject::{PyContext, PyObjectRef, PyRef, PyResult, PyValue, TypeProtocol};
 use crate::vm::VirtualMachine;
 
 use super::objint;
-use super::objtype;
+use super::objtype::{self, PyClassRef};
 
 #[derive(Debug)]
 pub struct PyByteArray {
     // TODO: shouldn't be public
     pub value: RefCell<Vec<u8>>,
 }
+type PyByteArrayRef = PyRef<PyByteArray>;
 
 impl PyByteArray {
     pub fn new(data: Vec<u8>) -> Self {
@@ -143,20 +144,14 @@ pub fn init(context: &PyContext) {
     );
 }
 
-fn bytearray_new(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
-    arg_check!(
-        vm,
-        args,
-        required = [(cls, None)],
-        optional = [(val_option, None)]
-    );
-    if !objtype::issubclass(cls, &vm.ctx.bytearray_type()) {
-        return Err(vm.new_type_error(format!("{:?} is not a subtype of bytearray", cls)));
-    }
-
+fn bytearray_new(
+    cls: PyClassRef,
+    val_option: OptionalArg<PyObjectRef>,
+    vm: &mut VirtualMachine,
+) -> PyResult<PyByteArrayRef> {
     // Create bytes data:
-    let value = if let Some(ival) = val_option {
-        let elements = vm.extract_elements(ival)?;
+    let value = if let OptionalArg::Present(ival) = val_option {
+        let elements = vm.extract_elements(&ival)?;
         let mut data_bytes = vec![];
         for elem in elements.iter() {
             let v = objint::to_int(vm, elem, 10)?;
@@ -171,7 +166,7 @@ fn bytearray_new(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     } else {
         vec![]
     };
-    Ok(PyObject::new(PyByteArray::new(value), cls.clone()))
+    PyByteArray::new(value).into_ref_with_type(vm, cls.clone())
 }
 
 fn bytesarray_len(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {

vm/src/obj/objbytes.rs

@@ -4,19 +4,20 @@ use std::ops::Deref;
 
 use num_traits::ToPrimitive;
 
-use crate::function::PyFuncArgs;
+use crate::function::{OptionalArg, PyFuncArgs};
 use crate::pyobject::{
-    PyContext, PyIteratorValue, PyObject, PyObjectRef, PyResult, PyValue, TypeProtocol,
+    PyContext, PyIteratorValue, PyObjectRef, PyRef, PyResult, PyValue, TypeProtocol,
 };
 use crate::vm::VirtualMachine;
 
 use super::objint;
-use super::objtype;
+use super::objtype::{self, PyClassRef};
 
 #[derive(Debug)]
 pub struct PyBytes {
     value: Vec<u8>,
 }
+type PyBytesRef = PyRef<PyBytes>;
 
 impl PyBytes {
     pub fn new(data: Vec<u8>) -> Self {
@@ -72,20 +73,14 @@ pub fn init(context: &PyContext) {
     );
 }
 
-fn bytes_new(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
-    arg_check!(
-        vm,
-        args,
-        required = [(cls, None)],
-        optional = [(val_option, None)]
-    );
-    if !objtype::issubclass(cls, &vm.ctx.bytes_type()) {
-        return Err(vm.new_type_error(format!("{:?} is not a subtype of bytes", cls)));
-    }
-
+fn bytes_new(
+    cls: PyClassRef,
+    val_option: OptionalArg<PyObjectRef>,
+    vm: &mut VirtualMachine,
+) -> PyResult<PyBytesRef> {
     // Create bytes data:
-    let value = if let Some(ival) = val_option {
-        let elements = vm.extract_elements(ival)?;
+    let value = if let OptionalArg::Present(ival) = val_option {
+        let elements = vm.extract_elements(&ival)?;
         let mut data_bytes = vec![];
         for elem in elements.iter() {
             let v = objint::to_int(vm, elem, 10)?;
@@ -97,7 +92,7 @@ fn bytes_new(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
         vec![]
     };
 
-    Ok(PyObject::new(PyBytes::new(value), cls.clone()))
+    PyBytes::new(value).into_ref_with_type(vm, cls)
 }
 
 fn bytes_eq(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
@@ -202,16 +197,9 @@ fn bytes_repr(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     Ok(vm.new_str(format!("b'{}'", data)))
 }
 
-fn bytes_iter(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
-    arg_check!(vm, args, required = [(obj, Some(vm.ctx.bytes_type()))]);
-
-    let iter_obj = PyObject::new(
-        PyIteratorValue {
-            position: Cell::new(0),
-            iterated_obj: obj.clone(),
-        },
-        vm.ctx.iter_type(),
-    );
-
-    Ok(iter_obj)
+fn bytes_iter(obj: PyBytesRef, _vm: &mut VirtualMachine) -> PyIteratorValue {
+    PyIteratorValue {
+        position: Cell::new(0),
+        iterated_obj: obj.into_object(),
+    }
 }

vm/src/obj/objcomplex.rs

@@ -1,18 +1,19 @@
 use num_complex::Complex64;
 use num_traits::ToPrimitive;
 
-use crate::function::PyFuncArgs;
-use crate::pyobject::{PyContext, PyObject, PyObjectRef, PyResult, PyValue, TypeProtocol};
+use crate::function::{OptionalArg, PyFuncArgs};
+use crate::pyobject::{PyContext, PyObjectRef, PyRef, PyResult, PyValue, TypeProtocol};
 use crate::vm::VirtualMachine;
 
 use super::objfloat;
 use super::objint;
-use super::objtype;
+use super::objtype::{self, PyClassRef};
 
 #[derive(Debug, Copy, Clone, PartialEq)]
 pub struct PyComplex {
     value: Complex64,
 }
+type PyComplexRef = PyRef<PyComplex>;
 
 impl PyValue for PyComplex {
     fn class(vm: &mut VirtualMachine) -> PyObjectRef {
@@ -66,31 +67,24 @@ pub fn get_value(obj: &PyObjectRef) -> Complex64 {
     obj.payload::<PyComplex>().unwrap().value
 }
 
-fn complex_new(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
-    arg_check!(
-        vm,
-        args,
-        required = [(cls, None)],
-        optional = [(real, None), (imag, None)]
-    );
-
-    if !objtype::issubclass(cls, &vm.ctx.complex_type()) {
-        return Err(vm.new_type_error(format!("{:?} is not a subtype of complex", cls)));
-    }
-
+fn complex_new(
+    cls: PyClassRef,
+    real: OptionalArg<PyObjectRef>,
+    imag: OptionalArg<PyObjectRef>,
+    vm: &mut VirtualMachine,
+) -> PyResult<PyComplexRef> {
     let real = match real {
-        None => 0.0,
-        Some(value) => objfloat::make_float(vm, value)?,
+        OptionalArg::Missing => 0.0,
+        OptionalArg::Present(ref value) => objfloat::make_float(vm, value)?,
     };
 
     let imag = match imag {
-        None => 0.0,
-        Some(value) => objfloat::make_float(vm, value)?,
+        OptionalArg::Missing => 0.0,
+        OptionalArg::Present(ref value) => objfloat::make_float(vm, value)?,
     };
 
     let value = Complex64::new(real, imag);
-
-    Ok(PyObject::new(PyComplex { value }, cls.clone()))
+    PyComplex { value }.into_ref_with_type(vm, cls)
 }
 
 fn complex_real(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {