Merge branch 'master' into pyrange-extend

tests/snippets/builtin_complex.py

@@ -24,6 +24,11 @@ assert complex(1, 2) != complex(1, 1)
 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/bytearray.py

@@ -65,3 +65,9 @@ except IndexError:
     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 @@ a = 1.2
 b = 1.3
 c = 1.2
 z = 2
+ov = 10 ** 1000
 
 assert -a == -1.2
 
@@ -37,6 +38,20 @@ assert a / z == 0.6
 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.__sub__(1.0) == 1.0
 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,13 +122,32 @@ assert 2.0.__rmod__(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_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
 assert 1.2.__trunc__() == 1
 assert int(1.2) == 1
 assert float(1.2) == 1.2
-# assert math.trunc(1.2) == 1
+assert math.trunc(1.2) == 1
+assert_raises(OverflowError, float('inf').__trunc__)
+assert_raises(ValueError, float('nan').__trunc__)
+assert 0.5.__round__() == 0.0
+assert 1.5.__round__() == 2.0
+assert 0.5.__round__(0) == 0.0
+assert 1.5.__round__(0) == 2.0
+assert 0.5.__round__(None) == 0.0
+assert 1.5.__round__(None) == 2.0
+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

tests/snippets/ints.py

@@ -74,3 +74,37 @@ with assertRaises(TypeError):
 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/math_basics.py

@@ -1,4 +1,4 @@
-from testutils import assertRaises
+from testutils import assert_raises
 
 a = 4
 
@@ -18,3 +18,23 @@ assert 2 == a / 2
 assert a - 3 == 1
 assert -a == -4
 assert +a == 4
+
+assert round(1.2) == 1
+assert round(1.8) == 2
+assert round(0.5) == 0
+assert round(1.5) == 2
+assert round(-0.5) == 0
+assert round(-1.5) == -2
+
+assert_raises(
+    ValueError,
+    lambda: round(float('nan')),
+    'ValueError: cannot convert float NaN to integer')
+assert_raises(
+    OverflowError,
+    lambda: round(float('inf')),
+    'OverflowError: cannot convert float NaN to integer')
+assert_raises(
+    OverflowError,
+    lambda: round(-float('inf')),
+    'OverflowError: cannot convert float NaN to integer')

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 @@ class assertRaises:
 
     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),
     });
 }

vm/src/obj/objfilter.rs

@@ -1,4 +1,4 @@
-use crate::pyobject::{IdProtocol, PyContext, PyObjectRef, PyRef, PyResult, PyValue};
+use crate::pyobject::{IdProtocol, PyClassImpl, PyContext, PyObjectRef, PyRef, PyResult, PyValue};
 use crate::vm::VirtualMachine; // Required for arg_check! to use isinstance
 
 use super::objbool;
@@ -7,6 +7,11 @@ use crate::obj::objtype::PyClassRef;
 
 pub type PyFilterRef = PyRef<PyFilter>;
 
+/// filter(function or None, iterable) --> filter object
+///
+/// Return an iterator yielding those items of iterable for which function(item)
+/// is true. If function is None, return the items that are true.
+#[pyclass]
 #[derive(Debug)]
 pub struct PyFilter {
     predicate: PyObjectRef,
@@ -34,8 +39,10 @@ fn filter_new(
     .into_ref_with_type(vm, cls)
 }
 
-impl PyFilterRef {
-    fn next(self, vm: &VirtualMachine) -> PyResult {
+#[pyimpl]
+impl PyFilter {
+    #[pymethod(name = "__next__")]
+    fn next(&self, vm: &VirtualMachine) -> PyResult {
         let predicate = &self.predicate;
         let iterator = &self.iterator;
         loop {
@@ -53,23 +60,15 @@ impl PyFilterRef {
         }
     }
 
-    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 filter_type = &context.filter_type;
-
-    let filter_doc =
-        "filter(function or None, iterable) --> filter object\n\n\
-         Return an iterator yielding those items of iterable for which function(item)\n\
-         is true. If function is None, return the items that are true.";
-
-    extend_class!(context, filter_type, {
+    PyFilter::extend_class(context, &context.filter_type);
+    extend_class!(context, &context.filter_type, {
         "__new__" => context.new_rustfunc(filter_new),
-        "__doc__" => context.new_str(filter_doc.to_string()),
-        "__next__" => context.new_rustfunc(PyFilterRef::next),
-        "__iter__" => context.new_rustfunc(PyFilterRef::iter),
     });
 }

vm/src/obj/objfloat.rs

@@ -2,14 +2,16 @@ use super::objbytes;
 use super::objint;
 use super::objstr;
 use super::objtype;
+use crate::function::OptionalArg;
 use crate::obj::objtype::PyClassRef;
 use crate::pyobject::{
-    IntoPyObject, PyClassImpl, PyContext, PyObjectRef, PyRef, PyResult, PyValue, TypeProtocol,
+    IdProtocol, IntoPyObject, PyClassImpl, PyContext, PyObjectRef, PyRef, PyResult, PyValue,
+    TypeProtocol,
 };
 use crate::vm::VirtualMachine;
 use num_bigint::{BigInt, ToBigInt};
 use num_rational::Ratio;
-use num_traits::ToPrimitive;
+use num_traits::{ToPrimitive, Zero};
 
 #[pyclass(name = "float")]
 #[derive(Debug, Copy, Clone, PartialEq)]
@@ -41,14 +43,70 @@ impl From<f64> for PyFloat {
     }
 }
 
-fn mod_(v1: f64, v2: f64, vm: &VirtualMachine) -> PyResult {
+fn try_float(value: &PyObjectRef, vm: &VirtualMachine) -> PyResult<Option<f64>> {
+    Ok(if objtype::isinstance(&value, &vm.ctx.float_type()) {
+        Some(get_value(&value))
+    } else if objtype::isinstance(&value, &vm.ctx.int_type()) {
+        Some(objint::get_float_value(&value, vm)?)
+    } else {
+        None
+    })
+}
+
+fn inner_div(v1: f64, v2: f64, vm: &VirtualMachine) -> PyResult<f64> {
     if v2 != 0.0 {
-        Ok(vm.ctx.new_float(v1 % v2))
+        Ok(v1 / v2)
+    } else {
+        Err(vm.new_zero_division_error("float division by zero".to_string()))
+    }
+}
+
+fn inner_mod(v1: f64, v2: f64, vm: &VirtualMachine) -> PyResult<f64> {
+    if v2 != 0.0 {
+        Ok(v1 % v2)
     } else {
         Err(vm.new_zero_division_error("float mod by zero".to_string()))
     }
 }
 
+fn try_to_bigint(value: f64, vm: &VirtualMachine) -> PyResult<BigInt> {
+    match value.to_bigint() {
+        Some(int) => Ok(int),
+        None => {
+            if value.is_infinite() {
+                Err(vm.new_overflow_error(
+                    "OverflowError: cannot convert float NaN to integer".to_string(),
+                ))
+            } else if value.is_nan() {
+                Err(vm
+                    .new_value_error("ValueError: cannot convert float NaN to integer".to_string()))
+            } else {
+                // unreachable unless BigInt has a bug
+                unreachable!(
+                    "A finite float value failed to be converted to bigint: {}",
+                    value
+                )
+            }
+        }
+    }
+}
+
+fn inner_floordiv(v1: f64, v2: f64, vm: &VirtualMachine) -> PyResult<f64> {
+    if v2 != 0.0 {
+        Ok((v1 / v2).floor())
+    } else {
+        Err(vm.new_zero_division_error("float floordiv by zero".to_string()))
+    }
+}
+
+fn inner_divmod(v1: f64, v2: f64, vm: &VirtualMachine) -> PyResult<(f64, f64)> {
+    if v2 != 0.0 {
+        Ok(((v1 / v2).floor(), v1 % v2))
+    } else {
+        Err(vm.new_zero_division_error("float divmod()".to_string()))
+    }
+}
+
 #[pyimpl]
 impl PyFloat {
     #[pymethod(name = "__eq__")]
@@ -129,20 +187,15 @@ impl PyFloat {
     }
 
     #[pymethod(name = "__add__")]
-    fn add(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyObjectRef {
-        let v1 = self.value;
-        if objtype::isinstance(&other, &vm.ctx.float_type()) {
-            vm.ctx.new_float(v1 + get_value(&other))
-        } else if objtype::isinstance(&other, &vm.ctx.int_type()) {
-            vm.ctx
-                .new_float(v1 + objint::get_value(&other).to_f64().unwrap())
-        } else {
-            vm.ctx.not_implemented()
-        }
+    fn add(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        try_float(&other, vm)?.map_or_else(
+            || Ok(vm.ctx.not_implemented()),
+            |other| (self.value + other).into_pyobject(vm),
+        )
     }
 
     #[pymethod(name = "__radd__")]
-    fn radd(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyObjectRef {
+    fn radd(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult {
         self.add(other, vm)
     }
 
@@ -153,45 +206,51 @@ impl PyFloat {
 
     #[pymethod(name = "__divmod__")]
     fn divmod(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        if objtype::isinstance(&other, &vm.ctx.float_type())
-            || objtype::isinstance(&other, &vm.ctx.int_type())
-        {
-            let r1 = self.floordiv(other.clone(), vm)?;
-            let r2 = self.mod_(other, vm)?;
-            Ok(vm.ctx.new_tuple(vec![r1, r2]))
-        } else {
-            Ok(vm.ctx.not_implemented())
-        }
+        try_float(&other, vm)?.map_or_else(
+            || Ok(vm.ctx.not_implemented()),
+            |other| {
+                let (r1, r2) = inner_divmod(self.value, other, vm)?;
+                Ok(vm
+                    .ctx
+                    .new_tuple(vec![vm.ctx.new_float(r1), vm.ctx.new_float(r2)]))
+            },
+        )
+    }
+
+    #[pymethod(name = "__rdivmod__")]
+    fn rdivmod(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        try_float(&other, vm)?.map_or_else(
+            || Ok(vm.ctx.not_implemented()),
+            |other| {
+                let (r1, r2) = inner_divmod(other, self.value, vm)?;
+                Ok(vm
+                    .ctx
+                    .new_tuple(vec![vm.ctx.new_float(r1), vm.ctx.new_float(r2)]))
+            },
+        )
     }
 
     #[pymethod(name = "__floordiv__")]
     fn floordiv(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        let v1 = self.value;
-        let v2 = if objtype::isinstance(&other, &vm.ctx.float_type) {
-            get_value(&other)
-        } else if objtype::isinstance(&other, &vm.ctx.int_type) {
-            objint::get_float_value(&other, vm)?
-        } else {
-            return Ok(vm.ctx.not_implemented());
-        };
+        try_float(&other, vm)?.map_or_else(
+            || Ok(vm.ctx.not_implemented()),
+            |other| inner_floordiv(self.value, other, vm)?.into_pyobject(vm),
+        )
+    }
 
-        if v2 != 0.0 {
-            Ok(vm.ctx.new_float((v1 / v2).floor()))
-        } else {
-            Err(vm.new_zero_division_error("float floordiv by zero".to_string()))
-        }
+    #[pymethod(name = "__rfloordiv__")]
+    fn rfloordiv(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        try_float(&other, vm)?.map_or_else(
+            || Ok(vm.ctx.not_implemented()),
+            |other| inner_floordiv(other, self.value, vm)?.into_pyobject(vm),
+        )
     }
 
     fn new_float(cls: PyClassRef, arg: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyFloatRef> {
         let value = if objtype::isinstance(&arg, &vm.ctx.float_type()) {
             get_value(&arg)
         } else if objtype::isinstance(&arg, &vm.ctx.int_type()) {
-            match objint::get_float_value(&arg, vm) {
-                Ok(f) => f,
-                Err(e) => {
-                    return Err(e);
-                }
-            }
+            objint::get_float_value(&arg, vm)?
         } else if objtype::isinstance(&arg, &vm.ctx.str_type()) {
             match lexical::try_parse(objstr::get_value(&arg)) {
                 Ok(f) => f,
@@ -222,28 +281,18 @@ impl PyFloat {
 
     #[pymethod(name = "__mod__")]
     fn mod_(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        let v1 = self.value;
-        let v2 = if objtype::isinstance(&other, &vm.ctx.float_type) {
-            get_value(&other)
-        } else if objtype::isinstance(&other, &vm.ctx.int_type) {
-            objint::get_float_value(&other, vm)?
-        } else {
-            return Ok(vm.ctx.not_implemented());
-        };
-
-        mod_(v1, v2, vm)
+        try_float(&other, vm)?.map_or_else(
+            || Ok(vm.ctx.not_implemented()),
+            |other| inner_mod(self.value, other, vm)?.into_pyobject(vm),
+        )
     }
 
     #[pymethod(name = "__rmod__")]
     fn rmod(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        let v2 = self.value;
-        let v1 = if objtype::isinstance(&other, &vm.ctx.int_type) {
-            objint::get_float_value(&other, vm)?
-        } else {
-            return Ok(vm.ctx.not_implemented());
-        };
-
-        mod_(v1, v2, vm)
+        try_float(&other, vm)?.map_or_else(
+            || Ok(vm.ctx.not_implemented()),
+            |other| inner_mod(other, self.value, vm)?.into_pyobject(vm),
+        )
     }
 
     #[pymethod(name = "__neg__")]
@@ -252,44 +301,35 @@ impl PyFloat {
     }
 
     #[pymethod(name = "__pow__")]
-    fn pow(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyObjectRef {
-        let v1 = self.value;
-        if objtype::isinstance(&other, &vm.ctx.float_type()) {
-            vm.ctx.new_float(v1.powf(get_value(&other)))
-        } else if objtype::isinstance(&other, &vm.ctx.int_type()) {
-            let result = v1.powf(objint::get_value(&other).to_f64().unwrap());
-            vm.ctx.new_float(result)
-        } else {
-            vm.ctx.not_implemented()
-        }
+    fn pow(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        try_float(&other, vm)?.map_or_else(
+            || Ok(vm.ctx.not_implemented()),
+            |other| self.value.powf(other).into_pyobject(vm),
+        )
+    }
+
+    #[pymethod(name = "__rpow__")]
+    fn rpow(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        try_float(&other, vm)?.map_or_else(
+            || Ok(vm.ctx.not_implemented()),
+            |other| other.powf(self.value).into_pyobject(vm),
+        )
     }
 
     #[pymethod(name = "__sub__")]
     fn sub(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        let v1 = self.value;
-        if objtype::isinstance(&other, &vm.ctx.float_type()) {
-            Ok(vm.ctx.new_float(v1 - get_value(&other)))
-        } else if objtype::isinstance(&other, &vm.ctx.int_type()) {
-            Ok(vm
-                .ctx
-                .new_float(v1 - objint::get_value(&other).to_f64().unwrap()))
-        } else {
-            Ok(vm.ctx.not_implemented())
-        }
+        try_float(&other, vm)?.map_or_else(
+            || Ok(vm.ctx.not_implemented()),
+            |other| (self.value - other).into_pyobject(vm),
+        )
     }
 
     #[pymethod(name = "__rsub__")]
     fn rsub(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        let v1 = self.value;
-        if objtype::isinstance(&other, &vm.ctx.float_type()) {
-            Ok(vm.ctx.new_float(get_value(&other) - v1))
-        } else if objtype::isinstance(&other, &vm.ctx.int_type()) {
-            Ok(vm
-                .ctx
-                .new_float(objint::get_value(&other).to_f64().unwrap() - v1))
-        } else {
-            Ok(vm.ctx.not_implemented())
-        }
+        try_float(&other, vm)?.map_or_else(
+            || Ok(vm.ctx.not_implemented()),
+            |other| (other - self.value).into_pyobject(vm),
+        )
     }
 
     #[pymethod(name = "__repr__")]
@@ -299,52 +339,26 @@ impl PyFloat {
 
     #[pymethod(name = "__truediv__")]
     fn truediv(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        let v1 = self.value;
-        let v2 = if objtype::isinstance(&other, &vm.ctx.float_type) {
-            get_value(&other)
-        } else if objtype::isinstance(&other, &vm.ctx.int_type) {
-            objint::get_float_value(&other, vm)?
-        } else {
-            return Ok(vm.ctx.not_implemented());
-        };
-
-        if v2 != 0.0 {
-            Ok(vm.ctx.new_float(v1 / v2))
-        } else {
-            Err(vm.new_zero_division_error("float division by zero".to_string()))
-        }
+        try_float(&other, vm)?.map_or_else(
+            || Ok(vm.ctx.not_implemented()),
+            |other| inner_div(self.value, other, vm)?.into_pyobject(vm),
+        )
     }
 
     #[pymethod(name = "__rtruediv__")]
     fn rtruediv(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        let v1 = self.value;
-        let v2 = if objtype::isinstance(&other, &vm.ctx.float_type) {
-            get_value(&other)
-        } else if objtype::isinstance(&other, &vm.ctx.int_type) {
-            objint::get_float_value(&other, vm)?
-        } else {
-            return Ok(vm.ctx.not_implemented());
-        };
-
-        if v1 != 0.0 {
-            Ok(vm.ctx.new_float(v2 / v1))
-        } else {
-            Err(vm.new_zero_division_error("float division by zero".to_string()))
-        }
+        try_float(&other, vm)?.map_or_else(
+            || Ok(vm.ctx.not_implemented()),
+            |other| inner_div(other, self.value, vm)?.into_pyobject(vm),
+        )
     }
 
     #[pymethod(name = "__mul__")]
     fn mul(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        let v1 = self.value;
-        if objtype::isinstance(&other, &vm.ctx.float_type) {
-            Ok(vm.ctx.new_float(v1 * get_value(&other)))
-        } else if objtype::isinstance(&other, &vm.ctx.int_type) {
-            Ok(vm
-                .ctx
-                .new_float(v1 * objint::get_value(&other).to_f64().unwrap()))
-        } else {
-            Ok(vm.ctx.not_implemented())
-        }
+        try_float(&other, vm)?.map_or_else(
+            || Ok(vm.ctx.not_implemented()),
+            |other| (self.value * other).into_pyobject(vm),
+        )
     }
 
     #[pymethod(name = "__rmul__")]
@@ -353,12 +367,54 @@ impl PyFloat {
     }
 
     #[pymethod(name = "__trunc__")]
-    fn trunc(&self, _vm: &VirtualMachine) -> BigInt {
-        self.value.to_bigint().unwrap()
+    fn trunc(&self, vm: &VirtualMachine) -> PyResult<BigInt> {
+        try_to_bigint(self.value, vm)
+    }
+
+    #[pymethod(name = "__round__")]
+    fn round(&self, ndigits: OptionalArg<PyObjectRef>, vm: &VirtualMachine) -> PyResult {
+        let ndigits = match ndigits {
+            OptionalArg::Missing => None,
+            OptionalArg::Present(ref value) => {
+                if !vm.get_none().is(value) {
+                    let ndigits = if objtype::isinstance(value, &vm.ctx.int_type()) {
+                        objint::get_value(value)
+                    } else {
+                        return Err(vm.new_type_error(format!(
+                            "TypeError: '{}' object cannot be interpreted as an integer",
+                            value.class().name
+                        )));
+                    };
+                    if ndigits.is_zero() {
+                        None
+                    } else {
+                        Some(ndigits)
+                    }
+                } else {
+                    None
+                }
+            }
+        };
+        if ndigits.is_none() {
+            let fract = self.value.fract();
+            let value = if fract.abs() == 0.5 {
+                if self.value.trunc() % 2.0 == 0.0 {
+                    self.value - fract
+                } else {
+                    self.value + fract
+                }
+            } else {
+                self.value.round()
+            };
+            let int = try_to_bigint(value, vm)?;
+            Ok(vm.ctx.new_int(int))
+        } else {
+            Ok(vm.ctx.not_implemented())
+        }
     }
 
     #[pymethod(name = "__int__")]
-    fn int(&self, vm: &VirtualMachine) -> BigInt {
+    fn int(&self, vm: &VirtualMachine) -> PyResult<BigInt> {
         self.trunc(vm)
     }
 

vm/src/obj/objint.rs

@@ -1,12 +1,12 @@
 use std::fmt;
 use std::hash::{Hash, Hasher};
 
-use num_bigint::{BigInt, ToBigInt};
+use num_bigint::BigInt;
 use num_integer::Integer;
 use num_traits::{Pow, Signed, ToPrimitive, Zero};
 
 use crate::format::FormatSpec;
-use crate::function::OptionalArg;
+use crate::function::{OptionalArg, PyFuncArgs};
 use crate::pyobject::{
     IntoPyObject, PyClassImpl, PyContext, PyObjectRef, PyRef, PyResult, PyValue, TryFromObject,
     TypeProtocol,
@@ -510,11 +510,8 @@ fn int_new(cls: PyClassRef, options: IntOptions, vm: &VirtualMachine) -> PyResul
 }
 
 // Casting function:
-// TODO: this should just call `__int__` on the object
 pub fn to_int(vm: &VirtualMachine, obj: &PyObjectRef, base: u32) -> PyResult<BigInt> {
     match_class!(obj.clone(),
-        i @ PyInt => Ok(i.as_bigint().clone()),
-        f @ PyFloat => Ok(f.to_f64().to_bigint().unwrap()),
         s @ PyString => {
             i32::from_str_radix(s.as_str(), base)
                 .map(BigInt::from)
@@ -523,10 +520,21 @@ pub fn to_int(vm: &VirtualMachine, obj: &PyObjectRef, base: u32) -> PyResult<Big
                     base, s
                 )))
         },
-        obj => Err(vm.new_type_error(format!(
-            "int() argument must be a string or a number, not '{}'",
-            obj.class().name
-        )))
+        obj => {
+            if let Ok(f) = vm.get_method(obj.clone(), "__int__") {
+                let int_res = vm.invoke(f, PyFuncArgs::default())?;
+                match int_res.payload::<PyInt>() {
+                    Some(i) => Ok(i.as_bigint().clone()),
+                    None => Err(vm.new_type_error(format!(
+                        "TypeError: __int__ returned non-int (type '{}')", int_res.class().name))),
+                }
+            } else {
+                Err(vm.new_type_error(format!(
+                    "int() argument must be a string or a number, not '{}'",
+                    obj.class().name
+                )))
+            }
+        }
     )
 }
 

vm/src/obj/objiter.rs

@@ -4,7 +4,9 @@
 
 use std::cell::Cell;
 
-use crate::pyobject::{PyContext, PyObjectRef, PyRef, PyResult, PyValue, TypeProtocol};
+use crate::pyobject::{
+    PyClassImpl, PyContext, PyObjectRef, PyRef, PyResult, PyValue, TypeProtocol,
+};
 use crate::vm::VirtualMachine;
 
 use super::objtype;
@@ -75,6 +77,7 @@ pub fn new_stop_iteration(vm: &VirtualMachine) -> PyObjectRef {
     vm.new_exception(stop_iteration_type, "End of iterator".to_string())
 }
 
+#[pyclass]
 #[derive(Debug)]
 pub struct PySequenceIterator {
     pub position: Cell<usize>,
@@ -87,10 +90,10 @@ impl PyValue for PySequenceIterator {
     }
 }
 
-type PySequenceIteratorRef = PyRef<PySequenceIterator>;
-
-impl PySequenceIteratorRef {
-    fn next(self, vm: &VirtualMachine) -> PyResult {
+#[pyimpl]
+impl PySequenceIterator {
+    #[pymethod(name = "__next__")]
+    fn next(&self, vm: &VirtualMachine) -> PyResult {
         let number = vm.ctx.new_int(self.position.get());
         match vm.call_method(&self.obj, "__getitem__", vec![number]) {
             Ok(val) => {
@@ -105,16 +108,12 @@ impl PySequenceIteratorRef {
         }
     }
 
-    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 iter_type = &context.iter_type;
-
-    extend_class!(context, iter_type, {
-        "__next__" => context.new_rustfunc(PySequenceIteratorRef::next),
-        "__iter__" => context.new_rustfunc(PySequenceIteratorRef::iter),
-    });
+    PySequenceIterator::extend_class(context, &context.iter_type);
 }

vm/src/obj/objlist.rs

@@ -8,7 +8,8 @@ use num_traits::{One, Signed, ToPrimitive, Zero};
 
 use crate::function::{OptionalArg, PyFuncArgs};
 use crate::pyobject::{
-    IdProtocol, PyContext, PyIterable, PyObjectRef, PyRef, PyResult, PyValue, TryFromObject,
+    IdProtocol, PyClassImpl, PyContext, PyIterable, PyObjectRef, PyRef, PyResult, PyValue,
+    TryFromObject,
 };
 use crate::vm::{ReprGuard, VirtualMachine};
 
@@ -776,6 +777,7 @@ fn list_sort(vm: &VirtualMachine, args: PyFuncArgs) -> PyResult {
     Ok(vm.get_none())
 }
 
+#[pyclass]
 #[derive(Debug)]
 pub struct PyListIterator {
     pub position: Cell<usize>,
@@ -788,10 +790,10 @@ impl PyValue for PyListIterator {
     }
 }
 
-type PyListIteratorRef = PyRef<PyListIterator>;
-
-impl PyListIteratorRef {
-    fn next(self, vm: &VirtualMachine) -> PyResult {
+#[pyimpl]
+impl PyListIterator {
+    #[pymethod(name = "__next__")]
+    fn next(&self, vm: &VirtualMachine) -> PyResult {
         if self.position.get() < self.list.elements.borrow().len() {
             let ret = self.list.elements.borrow()[self.position.get()].clone();
             self.position.set(self.position.get() + 1);
@@ -801,8 +803,9 @@ impl PyListIteratorRef {
         }
     }
 
-    fn iter(self, _vm: &VirtualMachine) -> Self {
-        self
+    #[pymethod(name = "__iter__")]
+    fn iter(zelf: PyRef<Self>, _vm: &VirtualMachine) -> PyRef<Self> {
+        zelf
     }
 }
 
@@ -848,9 +851,5 @@ pub fn init(context: &PyContext) {
         "remove" => context.new_rustfunc(PyListRef::remove)
     });
 
-    let listiterator_type = &context.listiterator_type;
-    extend_class!(context, listiterator_type, {
-        "__next__" => context.new_rustfunc(PyListIteratorRef::next),
-        "__iter__" => context.new_rustfunc(PyListIteratorRef::iter),
-    });
+    PyListIterator::extend_class(context, &context.listiterator_type);
 }

vm/src/obj/objmap.rs

@@ -1,10 +1,15 @@
 use crate::function::Args;
-use crate::pyobject::{PyContext, PyObjectRef, PyRef, PyResult, PyValue};
+use crate::pyobject::{PyClassImpl, PyContext, PyObjectRef, PyRef, PyResult, PyValue};
 use crate::vm::VirtualMachine;
 
 use super::objiter;
 use super::objtype::PyClassRef;
 
+/// map(func, *iterables) --> map object
+///
+/// Make an iterator that computes the function using arguments from
+/// each of the iterables.  Stops when the shortest iterable is exhausted.
+#[pyclass]
 #[derive(Debug)]
 pub struct PyMap {
     mapper: PyObjectRef,
@@ -35,8 +40,10 @@ fn map_new(
     .into_ref_with_type(vm, cls.clone())
 }
 
-impl PyMapRef {
-    fn next(self, vm: &VirtualMachine) -> PyResult {
+#[pyimpl]
+impl PyMap {
+    #[pymethod(name = "__next__")]
+    fn next(&self, vm: &VirtualMachine) -> PyResult {
         let next_objs = self
             .iterators
             .iter()
@@ -47,22 +54,15 @@ impl PyMapRef {
         vm.invoke(self.mapper.clone(), next_objs)
     }
 
-    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 map_type = &context.map_type;
-
-    let map_doc = "map(func, *iterables) --> map object\n\n\
-                   Make an iterator that computes the function using arguments from\n\
-                   each of the iterables.  Stops when the shortest iterable is exhausted.";
-
-    extend_class!(context, map_type, {
+    PyMap::extend_class(context, &context.map_type);
+    extend_class!(context, &context.map_type, {
         "__new__" => context.new_rustfunc(map_new),
-        "__next__" => context.new_rustfunc(PyMapRef::next),
-        "__iter__" => context.new_rustfunc(PyMapRef::iter),
-        "__doc__" => context.new_str(map_doc.to_string())
     });
 }

vm/src/obj/objrange.rs

@@ -113,6 +113,7 @@ type PyRangeRef = PyRef<PyRange>;
 
 #[pyimpl]
 impl PyRange {
+    #[pymethod(name = "__new__")]
     fn new(cls: PyClassRef, stop: PyIntRef, vm: &VirtualMachine) -> PyResult<PyRangeRef> {
         PyRange {
             start: PyInt::new(BigInt::zero()).into_ref(vm),

vm/src/obj/objtuple.rs

@@ -3,7 +3,7 @@ use std::fmt;
 use std::hash::{Hash, Hasher};
 
 use crate::function::OptionalArg;
-use crate::pyobject::{IdProtocol, PyContext, PyObjectRef, PyRef, PyResult, PyValue};
+use crate::pyobject::{IdProtocol, PyClassImpl, PyContext, PyObjectRef, PyRef, PyResult, PyValue};
 use crate::vm::{ReprGuard, VirtualMachine};
 
 use super::objbool;
@@ -224,6 +224,7 @@ fn tuple_new(
     PyTuple::from(elements).into_ref_with_type(vm, cls)
 }
 
+#[pyclass]
 #[derive(Debug)]
 pub struct PyTupleIterator {
     position: Cell<usize>,
@@ -236,10 +237,10 @@ impl PyValue for PyTupleIterator {
     }
 }
 
-type PyTupleIteratorRef = PyRef<PyTupleIterator>;
-
-impl PyTupleIteratorRef {
-    fn next(self, vm: &VirtualMachine) -> PyResult {
+#[pyimpl]
+impl PyTupleIterator {
+    #[pymethod(name = "__next__")]
+    fn next(&self, vm: &VirtualMachine) -> PyResult {
         if self.position.get() < self.tuple.elements.borrow().len() {
             let ret = self.tuple.elements.borrow()[self.position.get()].clone();
             self.position.set(self.position.get() + 1);
@@ -249,8 +250,9 @@ impl PyTupleIteratorRef {
         }
     }
 
-    fn iter(self, _vm: &VirtualMachine) -> Self {
-        self
+    #[pymethod(name = "__iter__")]
+    fn iter(zelf: PyRef<Self>, _vm: &VirtualMachine) -> PyRef<Self> {
+        zelf
     }
 }
 
@@ -282,9 +284,5 @@ If the argument is a tuple, the return value is the same object.";
         "index" => context.new_rustfunc(PyTupleRef::index)
     });
 
-    let tupleiterator_type = &context.tupleiterator_type;
-    extend_class!(context, tupleiterator_type, {
-        "__next__" => context.new_rustfunc(PyTupleIteratorRef::next),
-        "__iter__" => context.new_rustfunc(PyTupleIteratorRef::iter),
-    });
+    PyTupleIterator::extend_class(context, &context.tupleiterator_type);
 }

vm/src/obj/objzip.rs

@@ -1,5 +1,5 @@
 use crate::function::Args;
-use crate::pyobject::{PyContext, PyObjectRef, PyRef, PyResult, PyValue};
+use crate::pyobject::{PyClassImpl, PyContext, PyObjectRef, PyRef, PyResult, PyValue};
 use crate::vm::VirtualMachine;
 
 use super::objiter;
@@ -7,6 +7,7 @@ use crate::obj::objtype::PyClassRef;
 
 pub type PyZipRef = PyRef<PyZip>;
 
+#[pyclass]
 #[derive(Debug)]
 pub struct PyZip {
     iterators: Vec<PyObjectRef>,
@@ -26,8 +27,10 @@ fn zip_new(cls: PyClassRef, iterables: Args, vm: &VirtualMachine) -> PyResult<Py
     PyZip { iterators }.into_ref_with_type(vm, cls)
 }
 
-impl PyZipRef {
-    fn next(self, vm: &VirtualMachine) -> PyResult {
+#[pyimpl]
+impl PyZip {
+    #[pymethod(name = "__next__")]
+    fn next(&self, vm: &VirtualMachine) -> PyResult {
         if self.iterators.is_empty() {
             Err(objiter::new_stop_iteration(vm))
         } else {
@@ -41,16 +44,15 @@ impl PyZipRef {
         }
     }
 
-    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 zip_type = &context.zip_type;
-    extend_class!(context, zip_type, {
+    PyZip::extend_class(context, &context.zip_type);
+    extend_class!(context, &context.zip_type, {
         "__new__" => context.new_rustfunc(zip_new),
-        "__next__" => context.new_rustfunc(PyZipRef::next),
-        "__iter__" => context.new_rustfunc(PyZipRef::iter),
     });
 }

vm/src/stdlib/os.rs

@@ -15,7 +15,7 @@ use crate::obj::objiter;
 use crate::obj::objstr;
 use crate::obj::objstr::PyStringRef;
 use crate::obj::objtype::PyClassRef;
-use crate::pyobject::{ItemProtocol, PyObjectRef, PyRef, PyResult, PyValue};
+use crate::pyobject::{ItemProtocol, PyClassImpl, PyObjectRef, PyRef, PyResult, PyValue};
 use crate::vm::VirtualMachine;
 
 #[cfg(unix)]
@@ -232,6 +232,7 @@ impl DirEntryRef {
     }
 }
 
+#[pyclass]
 #[derive(Debug)]
 struct ScandirIterator {
     entries: RefCell<fs::ReadDir>,
@@ -243,10 +244,10 @@ impl PyValue for ScandirIterator {
     }
 }
 
-type ScandirIteratorRef = PyRef<ScandirIterator>;
-
-impl ScandirIteratorRef {
-    fn next(self, vm: &VirtualMachine) -> PyResult {
+#[pyimpl]
+impl ScandirIterator {
+    #[pymethod(name = "__next__")]
+    fn next(&self, vm: &VirtualMachine) -> PyResult {
         match self.entries.borrow_mut().next() {
             Some(entry) => match entry {
                 Ok(entry) => Ok(DirEntry { entry }.into_ref(vm).into_object()),
@@ -256,8 +257,9 @@ impl ScandirIteratorRef {
         }
     }
 
-    fn iter(self, _vm: &VirtualMachine) -> Self {
-        self
+    #[pymethod(name = "__iter__")]
+    fn iter(zelf: PyRef<Self>, _vm: &VirtualMachine) -> PyRef<Self> {
+        zelf
     }
 }
 
@@ -418,10 +420,8 @@ pub fn make_module(vm: &VirtualMachine) -> PyObjectRef {
 
     let environ = _os_environ(vm);
 
-    let scandir_iter = py_class!(ctx, "ScandirIter", ctx.object(), {
-         "__iter__" => ctx.new_rustfunc(ScandirIteratorRef::iter),
-         "__next__" => ctx.new_rustfunc(ScandirIteratorRef::next),
-    });
+    let scandir_iter = ctx.new_class("ScandirIter", ctx.object());
+    ScandirIterator::extend_class(ctx, &scandir_iter);
 
     let dir_entry = py_class!(ctx, "DirEntry", ctx.object(), {
          "name" => ctx.new_property(DirEntryRef::name),