RustPython · windelbouwman · Mar 11, 2019 · Mar 10, 2019 · Mar 10, 2019 · Mar 10, 2019
diff --git a/vm/src/compile.rs b/vm/src/compile.rs
@@ -8,7 +8,7 @@
 use crate::bytecode::{self, CallType, CodeObject, Instruction};
 use crate::error::CompileError;
 use crate::obj::objcode;
-use crate::pyobject::{PyObject, PyObjectPayload, PyObjectRef};
+use crate::pyobject::{PyObject, PyObjectRef};
 use num_complex::Complex64;
 use rustpython_parser::{ast, parser};
 
@@ -49,12 +49,7 @@ pub fn compile(
 
     let code = compiler.pop_code_object();
     trace!("Compilation completed: {:?}", code);
-    Ok(PyObject::new(
-        PyObjectPayload::AnyRustValue {
-            value: Box::new(objcode::PyCode::new(code)),
-        },
-        code_type,
-    ))
+    Ok(PyObject::new(objcode::PyCode::new(code), code_type))
 }
 
 pub enum Mode {

diff --git a/vm/src/frame.rs b/vm/src/frame.rs
@@ -22,8 +22,8 @@ use crate::obj::objslice::PySlice;
 use crate::obj::objstr;
 use crate::obj::objtype;
 use crate::pyobject::{
-    DictProtocol, IdProtocol, PyContext, PyFuncArgs, PyObject, PyObjectPayload, PyObjectPayload2,
-    PyObjectRef, PyResult, TryFromObject, TypeProtocol,
+    DictProtocol, IdProtocol, PyContext, PyFuncArgs, PyObject, PyObjectRef, PyResult, PyValue,
+    TryFromObject, TypeProtocol,
 };
 use crate::vm::VirtualMachine;
 
@@ -181,7 +181,7 @@ pub struct Frame {
     pub lasti: RefCell<usize>,        // index of last instruction ran
 }
 
-impl PyObjectPayload2 for Frame {
+impl PyValue for Frame {
     fn required_type(ctx: &PyContext) -> PyObjectRef {
         ctx.frame_type()
     }
@@ -407,12 +407,7 @@ impl Frame {
                 let stop = out[1].take();
                 let step = if out.len() == 3 { out[2].take() } else { None };
 
-                let obj = PyObject::new(
-                    PyObjectPayload::AnyRustValue {
-                        value: Box::new(PySlice { start, stop, step }),
-                    },
-                    vm.ctx.slice_type(),
-                );
+                let obj = PyObject::new(PySlice { start, stop, step }, vm.ctx.slice_type());
                 self.push_value(obj);
                 Ok(None)
             }
@@ -706,11 +701,7 @@ impl Frame {
             }
             bytecode::Instruction::LoadBuildClass => {
                 let rustfunc = PyObject::new(
-                    PyObjectPayload::AnyRustValue {
-                        value: Box::new(PyBuiltinFunction::new(Box::new(
-                            builtins::builtin_build_class_,
-                        ))),
-                    },
+                    PyBuiltinFunction::new(Box::new(builtins::builtin_build_class_)),
                     vm.ctx.type_type(),
                 );
                 self.push_value(rustfunc);

diff --git a/vm/src/function.rs b/vm/src/function.rs
diff --git a/vm/src/lib.rs b/vm/src/lib.rs
@@ -41,7 +41,6 @@ pub mod eval;
 mod exceptions;
 pub mod format;
 pub mod frame;
-pub mod function;
 pub mod import;
 pub mod obj;
 pub mod pyobject;

diff --git a/vm/src/obj/objbuiltinfunc.rs b/vm/src/obj/objbuiltinfunc.rs
@@ -1,13 +1,13 @@
 use std::fmt;
 
-use crate::pyobject::{PyContext, PyNativeFunc, PyObjectPayload2, PyObjectRef};
+use crate::pyobject::{PyContext, PyNativeFunc, PyObjectRef, PyValue};
 
 pub struct PyBuiltinFunction {
     // TODO: shouldn't be public
     pub value: PyNativeFunc,
 }
 
-impl PyObjectPayload2 for PyBuiltinFunction {
+impl PyValue for PyBuiltinFunction {
     fn required_type(ctx: &PyContext) -> PyObjectRef {
         ctx.builtin_function_or_method_type()
     }

diff --git a/vm/src/obj/objbytearray.rs b/vm/src/obj/objbytearray.rs
@@ -5,8 +5,7 @@ use std::fmt::Write;
 use std::ops::{Deref, DerefMut};
 
 use crate::pyobject::{
-    PyContext, PyFuncArgs, PyObject, PyObjectPayload, PyObjectPayload2, PyObjectRef, PyResult,
-    TypeProtocol,
+    PyContext, PyFuncArgs, PyObject, PyObjectRef, PyResult, PyValue, TypeProtocol,
 };
 
 use super::objint;
@@ -29,7 +28,7 @@ impl PyByteArray {
     }
 }
 
-impl PyObjectPayload2 for PyByteArray {
+impl PyValue for PyByteArray {
     fn required_type(ctx: &PyContext) -> PyObjectRef {
         ctx.bytearray_type()
     }
@@ -173,12 +172,7 @@ fn bytearray_new(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     } else {
         vec![]
     };
-    Ok(PyObject::new(
-        PyObjectPayload::AnyRustValue {
-            value: Box::new(PyByteArray::new(value)),
-        },
-        cls.clone(),
-    ))
+    Ok(PyObject::new(PyByteArray::new(value), cls.clone()))
 }
 
 fn bytesarray_len(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {

diff --git a/vm/src/obj/objbytes.rs b/vm/src/obj/objbytes.rs
@@ -5,8 +5,7 @@ use std::ops::Deref;
 use super::objint;
 use super::objtype;
 use crate::pyobject::{
-    PyContext, PyFuncArgs, PyIteratorValue, PyObject, PyObjectPayload, PyObjectPayload2,
-    PyObjectRef, PyResult, TypeProtocol,
+    PyContext, PyFuncArgs, PyIteratorValue, PyObject, PyObjectRef, PyResult, PyValue, TypeProtocol,
 };
 use crate::vm::VirtualMachine;
 use num_traits::ToPrimitive;
@@ -30,7 +29,7 @@ impl Deref for PyBytes {
     }
 }
 
-impl PyObjectPayload2 for PyBytes {
+impl PyValue for PyBytes {
     fn required_type(ctx: &PyContext) -> PyObjectRef {
         ctx.bytes_type()
     }
@@ -95,12 +94,7 @@ fn bytes_new(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
         vec![]
     };
 
-    Ok(PyObject::new(
-        PyObjectPayload::AnyRustValue {
-            value: Box::new(PyBytes::new(value)),
-        },
-        cls.clone(),
-    ))
+    Ok(PyObject::new(PyBytes::new(value), cls.clone()))
 }
 
 fn bytes_eq(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
@@ -209,11 +203,9 @@ 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(
-        PyObjectPayload::AnyRustValue {
-            value: Box::new(PyIteratorValue {
-                position: Cell::new(0),
-                iterated_obj: obj.clone(),
-            }),
+        PyIteratorValue {
+            position: Cell::new(0),
+            iterated_obj: obj.clone(),
         },
         vm.ctx.iter_type(),
     );

diff --git a/vm/src/obj/objcode.rs b/vm/src/obj/objcode.rs
@@ -4,7 +4,7 @@
 
 use crate::bytecode;
 use crate::pyobject::{
-    IdProtocol, PyContext, PyFuncArgs, PyObjectPayload2, PyObjectRef, PyResult, TypeProtocol,
+    IdProtocol, PyContext, PyFuncArgs, PyObjectRef, PyResult, PyValue, TypeProtocol,
 };
 use crate::vm::VirtualMachine;
 use std::fmt;
@@ -25,7 +25,7 @@ impl fmt::Debug for PyCode {
     }
 }
 
-impl PyObjectPayload2 for PyCode {
+impl PyValue for PyCode {
     fn required_type(ctx: &PyContext) -> PyObjectRef {
         ctx.code_type()
     }

diff --git a/vm/src/obj/objcomplex.rs b/vm/src/obj/objcomplex.rs
@@ -2,8 +2,7 @@ use super::objfloat;
 use super::objint;
 use super::objtype;
 use crate::pyobject::{
-    PyContext, PyFuncArgs, PyObject, PyObjectPayload, PyObjectPayload2, PyObjectRef, PyResult,
-    TypeProtocol,
+    PyContext, PyFuncArgs, PyObject, PyObjectRef, PyResult, PyValue, TypeProtocol,
 };
 use crate::vm::VirtualMachine;
 use num_complex::Complex64;
@@ -14,7 +13,7 @@ pub struct PyComplex {
     value: Complex64,
 }
 
-impl PyObjectPayload2 for PyComplex {
+impl PyValue for PyComplex {
     fn required_type(ctx: &PyContext) -> PyObjectRef {
         ctx.complex_type()
     }
@@ -90,12 +89,7 @@ fn complex_new(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
 
     let value = Complex64::new(real, imag);
 
-    Ok(PyObject::new(
-        PyObjectPayload::AnyRustValue {
-            value: Box::new(PyComplex { value }),
-        },
-        cls.clone(),
-    ))
+    Ok(PyObject::new(PyComplex { value }, cls.clone()))
 }
 
 fn complex_real(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {