Merge branch 'master' into float-round

Author: coolreader18

tests/snippets/builtin_complex.py

@@ -24,6 +24,11 @@
 assert complex(1, 2) != 'foo'
 assert complex(1, 2).__eq__('foo') == NotImplemented
 
+# __mul__
+
+assert complex(2, -3) * complex(-5, 7) == complex(11, 29)
+assert complex(2, -3) * 5 == complex(10, -15)
+
 # __neg__
 
 assert -complex(1, -1) == complex(-1, 1)

tests/snippets/builtin_range.py

@@ -27,6 +27,11 @@
 assert range(4, 10, 2).count(7) == 0
 assert range(10).count("foo") == 0
 
+# __eq__
+assert range(1, 2, 3) == range(1, 2, 3)
+assert range(1, 2, 1) == range(1, 2)
+assert range(2) == range(0, 2)
+
 # __bool__
 assert bool(range(1))
 assert bool(range(1, 2))
@@ -54,3 +59,9 @@
 # range retains the original int refs
 i = 2**64
 assert range(i).stop is i
+
+# negative index
+assert range(10)[-1] == 9
+assert_raises(IndexError, lambda: range(10)[-11], 'out of bound')
+assert range(10)[-2:4] == range(8, 4)
+assert range(10)[-6:-2] == range(4, 8)

tests/snippets/bytearray.py

@@ -65,3 +65,9 @@
     pass
 else:
     assert False
+
+a = bytearray(b'appen')
+assert len(a) == 5
+a.append(100)
+assert len(a) == 6
+assert a.pop() == 100

tests/snippets/floats.py

@@ -8,6 +8,7 @@
 b = 1.3
 c = 1.2
 z = 2
+ov = 10 ** 1000
 
 assert -a == -1.2
 
@@ -37,6 +38,20 @@
 assert 6 / a == 5.0
 assert 2.0 % z == 0.0
 assert z % 2.0 == 0.0
+assert_raises(OverflowError, lambda: a + ov)
+assert_raises(OverflowError, lambda: a - ov)
+assert_raises(OverflowError, lambda: a * ov)
+assert_raises(OverflowError, lambda: a / ov)
+assert_raises(OverflowError, lambda: a // ov)
+assert_raises(OverflowError, lambda: a % ov)
+assert_raises(OverflowError, lambda: a ** ov)
+assert_raises(OverflowError, lambda: ov + a)
+assert_raises(OverflowError, lambda: ov - a)
+assert_raises(OverflowError, lambda: ov * a)
+assert_raises(OverflowError, lambda: ov / a)
+assert_raises(OverflowError, lambda: ov // a)
+assert_raises(OverflowError, lambda: ov % a)
+# assert_raises(OverflowError, lambda: ov ** a)
 
 assert a < 5
 assert a <= 5
@@ -91,6 +106,8 @@
 assert 2.0.__rmul__(1.0) == 2.0
 assert 1.0.__truediv__(2.0) == 0.5
 assert 1.0.__rtruediv__(2.0) == 2.0
+assert 2.5.__divmod__(2.0) == (1.0, 0.5)
+assert 2.0.__rdivmod__(2.5) == (1.0, 0.5)
 
 assert 1.0.__add__(1) == 2.0
 assert 1.0.__radd__(1) == 2.0
@@ -105,6 +122,11 @@
 assert_raises(ZeroDivisionError, lambda: 2.0 / 0)
 assert_raises(ZeroDivisionError, lambda: 2.0 // 0)
 assert_raises(ZeroDivisionError, lambda: 2.0 % 0)
+assert_raises(ZeroDivisionError, lambda: divmod(2.0, 0))
+assert_raises(ZeroDivisionError, lambda: 2 / 0.0)
+assert_raises(ZeroDivisionError, lambda: 2 // 0.0)
+assert_raises(ZeroDivisionError, lambda: 2 % 0.0)
+# assert_raises(ZeroDivisionError, lambda: divmod(2, 0.0))
 
 assert 1.2.__int__() == 1
 assert 1.2.__float__() == 1.2
@@ -123,6 +145,10 @@
 assert_raises(OverflowError, float('inf').__round__)
 assert_raises(ValueError, float('nan').__round__)
 
+assert 1.2 ** 2 == 1.44
+assert_raises(OverflowError, lambda: 1.2 ** (10 ** 1000))
+assert 3 ** 2.0 == 9.0
+
 assert (1.7).real == 1.7
 assert (1.3).is_integer() == False
 assert (1.0).is_integer()    == True

tests/snippets/ints.py

@@ -74,3 +74,37 @@
 with assertRaises(TypeError):
     # check that first parameter is truly positional only
     int(val_options=1)
+
+class A(object):
+    def __int__(self):
+        return 10
+
+assert int(A()) == 10
+
+class B(object):
+    pass
+
+b = B()
+b.__int__ = lambda: 20
+
+with assertRaises(TypeError):
+    assert int(b) == 20
+
+class C(object):
+    def __int__(self):
+        return 'str'
+
+with assertRaises(TypeError):
+    int(C())
+
+class I(int):
+    def __int__(self):
+        return 3
+
+assert int(I(1)) == 3
+
+class F(float):
+    def __int__(self):
+        return 3
+
+assert int(F(1.2)) == 3

tests/snippets/testutils.py

@@ -14,9 +14,9 @@ def assert_raises(exc_type, expr, msg=None):
     except exc_type:
         pass
     else:
-        failmsg = '{!s} was not raised'.format(exc_type.__name__)
+        failmsg = '{} was not raised'.format(exc_type.__name__)
         if msg is not None:
-            failmsg += ': {!s}'.format(msg)
+            failmsg += ': {}'.format(msg)
         assert False, failmsg
 
 
@@ -29,8 +29,8 @@ def __enter__(self):
 
     def __exit__(self, exc_type, exc_val, exc_tb):
         if exc_type is None:
-            failmsg = '{!s} was not raised'.format(self.expected.__name__)
-            assert False, failmsg            
+            failmsg = '{} was not raised'.format(self.expected.__name__)
+            assert False, failmsg
         if not issubclass(exc_type, self.expected):
             return False
         return True

vm/src/builtins.rs

@@ -123,11 +123,14 @@ fn builtin_dir(vm: &VirtualMachine, args: PyFuncArgs) -> PyResult {
 }
 
 fn builtin_divmod(vm: &VirtualMachine, args: PyFuncArgs) -> PyResult {
-    arg_check!(vm, args, required = [(x, None), (y, None)]);
-    match vm.get_method(x.clone(), "__divmod__") {
-        Ok(attrib) => vm.invoke(attrib, vec![y.clone()]),
-        Err(..) => Err(vm.new_type_error("unsupported operand type(s) for divmod".to_string())),
-    }
+    arg_check!(vm, args, required = [(a, None), (b, None)]);
+    vm.call_or_reflection(
+        a.clone(),
+        b.clone(),
+        "__divmod__",
+        "__rdivmod__",
+        |vm, a, b| Err(vm.new_unsupported_operand_error(a, b, "divmod")),
+    )
 }
 
 /// Implements `eval`.

vm/src/obj/objbytearray.rs

@@ -7,7 +7,7 @@ use std::ops::{Deref, DerefMut};
 use num_traits::ToPrimitive;
 
 use crate::function::OptionalArg;
-use crate::pyobject::{PyContext, PyObjectRef, PyRef, PyResult, PyValue};
+use crate::pyobject::{PyClassImpl, PyContext, PyObjectRef, PyRef, PyResult, PyValue};
 use crate::vm::VirtualMachine;
 
 use super::objint;
@@ -79,15 +79,12 @@ pub fn init(context: &PyContext) {
         "istitle" =>context.new_rustfunc(PyByteArrayRef::istitle),
         "isupper" => context.new_rustfunc(PyByteArrayRef::isupper),
         "lower" => context.new_rustfunc(PyByteArrayRef::lower),
+        "append" => context.new_rustfunc(PyByteArrayRef::append),
         "pop" => context.new_rustfunc(PyByteArrayRef::pop),
         "upper" => context.new_rustfunc(PyByteArrayRef::upper)
     });
 
-    let bytearrayiterator_type = &context.bytearrayiterator_type;
-    extend_class!(context, bytearrayiterator_type, {
-        "__next__" => context.new_rustfunc(PyByteArrayIteratorRef::next),
-        "__iter__" => context.new_rustfunc(PyByteArrayIteratorRef::iter),
-    });
+    PyByteArrayIterator::extend_class(context, &context.bytearrayiterator_type);
 }
 
 fn bytearray_new(
@@ -213,6 +210,10 @@ impl PyByteArrayRef {
         self.value.borrow_mut().clear();
     }
 
+    fn append(self, x: u8, _vm: &VirtualMachine) {
+        self.value.borrow_mut().push(x);
+    }
+
     fn pop(self, vm: &VirtualMachine) -> PyResult<u8> {
         let mut bytes = self.value.borrow_mut();
         bytes
@@ -282,6 +283,7 @@ mod tests {
     }
 }
 
+#[pyclass]
 #[derive(Debug)]
 pub struct PyByteArrayIterator {
     position: Cell<usize>,
@@ -294,10 +296,10 @@ impl PyValue for PyByteArrayIterator {
     }
 }
 
-type PyByteArrayIteratorRef = PyRef<PyByteArrayIterator>;
-
-impl PyByteArrayIteratorRef {
-    fn next(self, vm: &VirtualMachine) -> PyResult<u8> {
+#[pyimpl]
+impl PyByteArrayIterator {
+    #[pymethod(name = "__next__")]
+    fn next(&self, vm: &VirtualMachine) -> PyResult<u8> {
         if self.position.get() < self.bytearray.value.borrow().len() {
             let ret = self.bytearray.value.borrow()[self.position.get()];
             self.position.set(self.position.get() + 1);
@@ -307,7 +309,8 @@ impl PyByteArrayIteratorRef {
         }
     }
 
-    fn iter(self, _vm: &VirtualMachine) -> Self {
-        self
+    #[pymethod(name = "__iter__")]
+    fn iter(zelf: PyRef<Self>, _vm: &VirtualMachine) -> PyRef<Self> {
+        zelf
     }
 }

vm/src/obj/objbytes.rs

@@ -64,11 +64,7 @@ pub fn init(context: &PyContext) {
     extend_class!(context, bytes_type, {
     "fromhex" => context.new_rustfunc(PyBytesRef::fromhex),
     });
-    let bytesiterator_type = &context.bytesiterator_type;
-    extend_class!(context, bytesiterator_type, {
-    "__next__" => context.new_rustfunc(PyBytesIteratorRef::next),
-    "__iter__" => context.new_rustfunc(PyBytesIteratorRef::iter),
-    });
+    PyBytesIterator::extend_class(context, &context.bytesiterator_type);
 }
 
 #[pyimpl]
@@ -271,6 +267,7 @@ impl PyBytesRef {
     }
 }
 
+#[pyclass]
 #[derive(Debug)]
 pub struct PyBytesIterator {
     position: Cell<usize>,
@@ -283,10 +280,10 @@ impl PyValue for PyBytesIterator {
     }
 }
 
-type PyBytesIteratorRef = PyRef<PyBytesIterator>;
-
-impl PyBytesIteratorRef {
-    fn next(self, vm: &VirtualMachine) -> PyResult<u8> {
+#[pyimpl]
+impl PyBytesIterator {
+    #[pymethod(name = "__next__")]
+    fn next(&self, vm: &VirtualMachine) -> PyResult<u8> {
         if self.position.get() < self.bytes.inner.len() {
             let ret = self.bytes[self.position.get()];
             self.position.set(self.position.get() + 1);
@@ -296,7 +293,8 @@ impl PyBytesIteratorRef {
         }
     }
 
-    fn iter(self, _vm: &VirtualMachine) -> Self {
-        self
+    #[pymethod(name = "__iter__")]
+    fn iter(zelf: PyRef<Self>, _vm: &VirtualMachine) -> PyRef<Self> {
+        zelf
     }
 }

vm/src/obj/objcomplex.rs

@@ -67,7 +67,9 @@ impl PyComplexRef {
 }
 
 fn to_complex(value: PyObjectRef, vm: &VirtualMachine) -> PyResult<Option<Complex64>> {
-    if objtype::isinstance(&value, &vm.ctx.int_type()) {
+    if objtype::isinstance(&value, &vm.ctx.complex_type()) {
+        Ok(Some(get_value(&value)))
+    } else if objtype::isinstance(&value, &vm.ctx.int_type()) {
         match objint::get_value(&value).to_f64() {
             Some(v) => Ok(Some(Complex64::new(v, 0.0))),
             None => Err(vm.new_overflow_error("int too large to convert to float".to_string())),
@@ -161,6 +163,28 @@ impl PyComplex {
         vm.ctx.new_bool(result)
     }
 
+    #[pymethod(name = "__float__")]
+    fn float(&self, vm: &VirtualMachine) -> PyResult {
+        return Err(vm.new_type_error(String::from("Can't convert complex to float")));
+    }
+
+    #[pymethod(name = "__int__")]
+    fn int(&self, vm: &VirtualMachine) -> PyResult {
+        return Err(vm.new_type_error(String::from("Can't convert complex to int")));
+    }
+
+    #[pymethod(name = "__mul__")]
+    fn mul(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        match to_complex(other, vm) {
+            Ok(Some(other)) => Ok(vm.ctx.new_complex(Complex64::new(
+                self.value.re * other.re - self.value.im * other.im,
+                self.value.re * other.im + self.value.im * other.re,
+            ))),
+            Ok(None) => Ok(vm.ctx.not_implemented()),
+            Err(err) => Err(err),
+        }
+    }
+
     #[pymethod(name = "__neg__")]
     fn neg(&self, _vm: &VirtualMachine) -> PyComplex {
         PyComplex::from(-self.value)

vm/src/obj/objenumerate.rs

@@ -5,13 +5,14 @@ use num_bigint::BigInt;
 use num_traits::Zero;
 
 use crate::function::OptionalArg;
-use crate::pyobject::{PyContext, PyObjectRef, PyRef, PyResult, PyValue};
+use crate::pyobject::{PyClassImpl, PyContext, PyObjectRef, PyRef, PyResult, PyValue};
 use crate::vm::VirtualMachine;
 
 use super::objint::PyIntRef;
 use super::objiter;
 use super::objtype::PyClassRef;
 
+#[pyclass]
 #[derive(Debug)]
 pub struct PyEnumerate {
     counter: RefCell<BigInt>,
@@ -44,8 +45,10 @@ fn enumerate_new(
     .into_ref_with_type(vm, cls)
 }
 
-impl PyEnumerateRef {
-    fn next(self, vm: &VirtualMachine) -> PyResult {
+#[pyimpl]
+impl PyEnumerate {
+    #[pymethod(name = "__next__")]
+    fn next(&self, vm: &VirtualMachine) -> PyResult {
         let iterator = &self.iterator;
         let counter = &self.counter;
         let next_obj = objiter::call_next(vm, iterator)?;
@@ -58,16 +61,15 @@ impl PyEnumerateRef {
         Ok(result)
     }
 
-    fn iter(self, _vm: &VirtualMachine) -> Self {
-        self
+    #[pymethod(name = "__iter__")]
+    fn iter(zelf: PyRef<Self>, _vm: &VirtualMachine) -> PyRef<Self> {
+        zelf
     }
 }
 
 pub fn init(context: &PyContext) {
-    let enumerate_type = &context.enumerate_type;
-    extend_class!(context, enumerate_type, {
+    PyEnumerate::extend_class(context, &context.enumerate_type);
+    extend_class!(context, &context.enumerate_type, {
         "__new__" => context.new_rustfunc(enumerate_new),
-        "__next__" => context.new_rustfunc(PyEnumerateRef::next),
-        "__iter__" => context.new_rustfunc(PyEnumerateRef::iter),
     });
 }