Remove None and NotImplemented payloads and replace with NoPayload

Author: cthulahoops

vm/src/frame.rs

@@ -285,10 +285,14 @@ impl Frame {
 
                 let mut out: Vec<Option<BigInt>> = elements
                     .into_iter()
-                    .map(|x| match x.payload {
-                        PyObjectPayload::Integer { ref value } => Some(value.clone()),
-                        PyObjectPayload::None => None,
-                        _ => panic!("Expect Int or None as BUILD_SLICE arguments, got {:?}", x),
+                    .map(|x| {
+                        if x.is(&vm.get_none()) {
+                            None
+                        } else if let PyObjectPayload::Integer { ref value } = x.payload {
+                            Some(value.clone())
+                        } else {
+                            panic!("Expect Int or None as BUILD_SLICE arguments, got {:?}", x);
+                        }
                     })
                     .collect();
 
@@ -574,18 +578,15 @@ impl Frame {
             }
             bytecode::Instruction::PrintExpr => {
                 let expr = self.pop_value();
-                match expr.payload {
-                    PyObjectPayload::None => (),
-                    _ => {
-                        let repr = vm.to_repr(&expr)?;
-                        builtins::builtin_print(
-                            vm,
-                            PyFuncArgs {
-                                args: vec![repr],
-                                kwargs: vec![],
-                            },
-                        )?;
-                    }
+                if !expr.is(&vm.get_none()) {
+                    let repr = vm.to_repr(&expr)?;
+                    builtins::builtin_print(
+                        vm,
+                        PyFuncArgs {
+                            args: vec![repr],
+                            kwargs: vec![],
+                        },
+                    )?;
                 }
                 Ok(None)
             }

vm/src/pyobject.rs

@@ -155,7 +155,7 @@ pub struct PyContext {
 
 fn _nothing() -> PyObjectRef {
     PyObject {
-        payload: PyObjectPayload::None,
+        payload: PyObjectPayload::NoPayload,
         typ: None,
     }
     .into_ref()
@@ -223,14 +223,14 @@ impl PyContext {
         let exceptions = exceptions::ExceptionZoo::new(&type_type, &object_type, &dict_type);
 
         let none = PyObject::new(
-            PyObjectPayload::None,
+            PyObjectPayload::NoPayload,
             create_type("NoneType", &type_type, &object_type, &dict_type),
         );
 
-        let ellipsis = PyObject::new(PyObjectPayload::None, ellipsis_type.clone());
+        let ellipsis = PyObject::new(PyObjectPayload::NoPayload, ellipsis_type.clone());
 
         let not_implemented = PyObject::new(
-            PyObjectPayload::NotImplemented,
+            PyObjectPayload::NoPayload,
             create_type("NotImplementedType", &type_type, &object_type, &dict_type),
         );
 
@@ -1484,8 +1484,7 @@ pub enum PyObjectPayload {
         name: String,
         scope: ScopeRef,
     },
-    None,
-    NotImplemented,
+    NoPayload,
     Class {
         name: String,
         dict: RefCell<PyAttributes>,
@@ -1531,8 +1530,7 @@ impl fmt::Debug for PyObjectPayload {
                 ref object,
             } => write!(f, "bound-method: {:?} of {:?}", function, object),
             PyObjectPayload::Module { .. } => write!(f, "module"),
-            PyObjectPayload::None => write!(f, "None"),
-            PyObjectPayload::NotImplemented => write!(f, "NotImplemented"),
+            PyObjectPayload::NoPayload => write!(f, "NoPayload"),
             PyObjectPayload::Class { ref name, .. } => write!(f, "class {:?}", name),
             PyObjectPayload::Instance { .. } => write!(f, "instance"),
             PyObjectPayload::RustFunction { .. } => write!(f, "rust function"),

vm/src/stdlib/json.rs

@@ -11,7 +11,7 @@ use crate::obj::{
     objtype,
 };
 use crate::pyobject::{
-    create_type, DictProtocol, PyContext, PyFuncArgs, PyObjectPayload, PyObjectRef, PyResult,
+    create_type, DictProtocol, IdProtocol, PyContext, PyFuncArgs, PyObjectRef, PyResult,
     TypeProtocol,
 };
 use crate::VirtualMachine;
@@ -69,7 +69,7 @@ impl<'s> serde::Serialize for PyObjectSerializer<'s> {
                 map.serialize_entry(&key, &self.clone_with_object(&e.1))?;
             }
             map.end()
-        } else if let PyObjectPayload::None = self.pyobject.payload {
+        } else if self.pyobject.is(&self.vm.get_none()) {
             serializer.serialize_none()
         } else {
             Err(serde::ser::Error::custom(format!(

vm/src/vm.rs

@@ -473,10 +473,12 @@ impl VirtualMachine {
         // Add missing positional arguments, if we have fewer positional arguments than the
         // function definition calls for
         if nargs < nexpected_args {
-            let available_defaults = match defaults.payload {
-                PyObjectPayload::Sequence { ref elements } => elements.borrow().clone(),
-                PyObjectPayload::None => vec![],
-                _ => panic!("function defaults not tuple or None"),
+            let available_defaults = if defaults.is(&self.get_none()) {
+                vec![]
+            } else if let PyObjectPayload::Sequence { ref elements } = defaults.payload {
+                elements.borrow().clone()
+            } else {
+                panic!("function defaults not tuple or None");
             };
 
             // Given the number of defaults available, check all the arguments for which we