Fix each type's unary & ternary fields in PyNumberMethods def

Signed-off-by: snowapril <sinjihng@gmail.com>

Author: Snowapril

vm/src/builtins/complex.rs

@@ -421,7 +421,13 @@ impl AsNumber for PyComplex {
             add: Some(|a, b, vm| PyComplex::number_op(a, b, |a, b, _vm| a + b, vm)),
             subtract: Some(|a, b, vm| PyComplex::number_op(a, b, |a, b, _vm| a - b, vm)),
             multiply: Some(|a, b, vm| PyComplex::number_op(a, b, |a, b, _vm| a * b, vm)),
-            power: Some(|a, b, vm| PyComplex::number_op(a, b, inner_pow, vm)),
+            power: Some(|a, b, c, vm| {
+                if vm.is_none(c) {
+                    PyComplex::number_op(a, b, inner_pow, vm)
+                } else {
+                    Err(vm.new_value_error(String::from("complex modulo")))
+                }
+            }),
             negative: Some(|number, vm| {
                 let value = PyComplex::number_downcast(number).value;
                 (-value).to_pyresult(vm)

vm/src/builtins/float.rs

@@ -549,7 +549,16 @@ impl AsNumber for PyFloat {
             multiply: Some(|a, b, vm| PyFloat::number_op(a, b, |a, b, _vm| a * b, vm)),
             remainder: Some(|a, b, vm| PyFloat::number_op(a, b, inner_mod, vm)),
             divmod: Some(|a, b, vm| PyFloat::number_op(a, b, inner_divmod, vm)),
-            power: Some(|a, b, vm| PyFloat::number_op(a, b, float_pow, vm)),
+            power: Some(|a, b, c, vm| {
+                if vm.is_none(c) {
+                    PyFloat::number_op(a, b, float_pow, vm)
+                } else {
+                    Err(vm.new_type_error(String::from(
+                        "pow() 3rd argument not \\
+                    allowed unless all arguments are integers",
+                    )))
+                }
+            }),
             negative: Some(|num, vm| {
                 let value = PyFloat::number_downcast(num).value;
                 (-value).to_pyresult(vm)
@@ -562,9 +571,9 @@ impl AsNumber for PyFloat {
             boolean: Some(|num, _vm| Ok(PyFloat::number_downcast(num).value.is_zero())),
             int: Some(|num, vm| {
                 let value = PyFloat::number_downcast(num).value;
-                try_to_bigint(value, vm).map(|x| vm.ctx.new_int(x))
+                try_to_bigint(value, vm).map(|x| PyInt::from(x).into_pyobject(vm))
             }),
-            float: Some(|num, vm| Ok(PyFloat::number_downcast_exact(num, vm))),
+            float: Some(|num, vm| Ok(PyFloat::number_downcast_exact(num, vm).into())),
             floor_divide: Some(|a, b, vm| PyFloat::number_op(a, b, inner_floordiv, vm)),
             true_divide: Some(|a, b, vm| PyFloat::number_op(a, b, inner_div, vm)),
             ..PyNumberMethods::NOT_IMPLEMENTED

vm/src/builtins/int.rs

@@ -745,7 +745,7 @@ impl PyInt {
         multiply: Some(|a, b, vm| PyInt::number_op(a, b, |a, b, _vm| a * b, vm)),
         remainder: Some(|a, b, vm| PyInt::number_op(a, b, inner_mod, vm)),
         divmod: Some(|a, b, vm| PyInt::number_op(a, b, inner_divmod, vm)),
-        power: Some(|a, b, vm| PyInt::number_op(a, b, inner_pow, vm)),
+        power: Some(|a, b, _c, vm| PyInt::number_op(a, b, inner_pow, vm)), // TODO(snowapril) : use modulo
         negative: Some(|num, vm| (&PyInt::number_downcast(num).value).neg().to_pyresult(vm)),
         positive: Some(|num, vm| Ok(PyInt::number_downcast_exact(num, vm).into())),
         absolute: Some(|num, vm| PyInt::number_downcast(num).value.abs().to_pyresult(vm)),
@@ -756,14 +756,14 @@ impl PyInt {
         and: Some(|a, b, vm| PyInt::number_op(a, b, |a, b, _vm| a & b, vm)),
         xor: Some(|a, b, vm| PyInt::number_op(a, b, |a, b, _vm| a ^ b, vm)),
         or: Some(|a, b, vm| PyInt::number_op(a, b, |a, b, _vm| a | b, vm)),
-        int: Some(|num, vm| Ok(PyInt::number_downcast_exact(num, vm))),
+        int: Some(|num, vm| PyInt::number_downcast_exact(num, vm).to_pyresult(vm)),
         float: Some(|num, vm| {
             let zelf = PyInt::number_downcast(num);
-            try_to_float(&zelf.value, vm).map(|x| vm.ctx.new_float(x))
+            try_to_float(&zelf.value, vm).map(|x| vm.ctx.new_float(x).into_pyobject(vm))
         }),
         floor_divide: Some(|a, b, vm| PyInt::number_op(a, b, inner_floordiv, vm)),
         true_divide: Some(|a, b, vm| PyInt::number_op(a, b, inner_truediv, vm)),
-        index: Some(|num, vm| Ok(PyInt::number_downcast_exact(num, vm))),
+        index: Some(|num, vm| PyInt::number_downcast_exact(num, vm).to_pyresult(vm)),
         ..PyNumberMethods::NOT_IMPLEMENTED
     };