builtin_function_or_method

OddCoincidence · OddCoincidence · commit c1180fc56401 · 2019-03-09T08:45:46.000-08:00
diff --git a/vm/src/frame.rs b/vm/src/frame.rs
@@ -11,6 +11,7 @@ use crate::builtins;
 use crate::bytecode;
 use crate::import::{import, import_module};
 use crate::obj::objbool;
+use crate::obj::objbuiltinfunc::PyBuiltinFunction;
 use crate::obj::objcode;
 use crate::obj::objdict;
 use crate::obj::objdict::PyDict;
@@ -592,8 +593,10 @@ impl Frame {
             }
             bytecode::Instruction::LoadBuildClass => {
                 let rustfunc = PyObject::new(
-                    PyObjectPayload::RustFunction {
-                        function: Box::new(builtins::builtin_build_class_),
+                    PyObjectPayload::AnyRustValue {
+                        value: Box::new(PyBuiltinFunction::new(Box::new(
+                            builtins::builtin_build_class_,
+                        ))),
                     },
                     vm.ctx.type_type(),
                 );
diff --git a/vm/src/obj/mod.rs b/vm/src/obj/mod.rs
@@ -1,6 +1,7 @@
 //! This package contains the python basic/builtin types
 
 pub mod objbool;
+pub mod objbuiltinfunc;
 pub mod objbytearray;
 pub mod objbytes;
 pub mod objcode;
diff --git a/vm/src/obj/objbuiltinfunc.rs b/vm/src/obj/objbuiltinfunc.rs
@@ -0,0 +1,26 @@
+use std::fmt;
+
+use crate::pyobject::{PyContext, PyNativeFunc, PyObjectPayload2, PyObjectRef};
+
+pub struct PyBuiltinFunction {
+    // TODO: shouldn't be public
+    pub value: PyNativeFunc,
+}
+
+impl PyObjectPayload2 for PyBuiltinFunction {
+    fn required_type(ctx: &PyContext) -> PyObjectRef {
+        ctx.builtin_function_or_method_type()
+    }
+}
+
+impl fmt::Debug for PyBuiltinFunction {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "builtin function")
+    }
+}
+
+impl PyBuiltinFunction {
+    pub fn new(value: PyNativeFunc) -> Self {
+        Self { value }
+    }
+}
diff --git a/vm/src/pyobject.rs b/vm/src/pyobject.rs
@@ -14,6 +14,7 @@ use crate::bytecode;
 use crate::exceptions;
 use crate::frame::{Frame, Scope, ScopeRef};
 use crate::obj::objbool;
+use crate::obj::objbuiltinfunc::PyBuiltinFunction;
 use crate::obj::objbytearray;
 use crate::obj::objbytes;
 use crate::obj::objcode;
@@ -615,8 +616,8 @@ impl PyContext {
         F: IntoPyNativeFunc<T, R>,
     {
         PyObject::new(
-            PyObjectPayload::RustFunction {
-                function: f.into_func(),
+            PyObjectPayload::AnyRustValue {
+                value: Box::new(PyBuiltinFunction::new(f.into_func())),
             },
             self.builtin_function_or_method_type(),
         )
@@ -1516,9 +1517,6 @@ pub enum PyObjectPayload {
     WeakRef {
         referent: PyObjectWeakRef,
     },
-    RustFunction {
-        function: PyNativeFunc,
-    },
     AnyRustValue {
         value: Box<dyn std::any::Any>,
     },
@@ -1540,7 +1538,6 @@ impl fmt::Debug for PyObjectPayload {
             PyObjectPayload::Iterator { .. } => write!(f, "iterator"),
             PyObjectPayload::Slice { .. } => write!(f, "slice"),
             PyObjectPayload::Generator { .. } => write!(f, "generator"),
-            PyObjectPayload::RustFunction { .. } => write!(f, "rust function"),
             PyObjectPayload::Frame { .. } => write!(f, "frame"),
             PyObjectPayload::AnyRustValue { value } => value.fmt(f),
         }
diff --git a/vm/src/vm.rs b/vm/src/vm.rs
@@ -16,6 +16,7 @@ use crate::bytecode;
 use crate::frame::ExecutionResult;
 use crate::frame::{Scope, ScopeRef};
 use crate::obj::objbool;
+use crate::obj::objbuiltinfunc::PyBuiltinFunction;
 use crate::obj::objcode;
 use crate::obj::objframe;
 use crate::obj::objfunction::{PyFunction, PyMethod};
@@ -28,8 +29,8 @@ use crate::obj::objstr;
 use crate::obj::objtuple::PyTuple;
 use crate::obj::objtype;
 use crate::pyobject::{
-    AttributeProtocol, DictProtocol, IdProtocol, PyContext, PyFuncArgs, PyObjectPayload,
-    PyObjectRef, PyResult, TypeProtocol,
+    AttributeProtocol, DictProtocol, IdProtocol, PyContext, PyFuncArgs, PyObjectRef, PyResult,
+    TypeProtocol,
 };
 use crate::stdlib;
 use crate::sysmodule;
@@ -305,14 +306,13 @@ impl VirtualMachine {
         {
             return self.invoke(function.clone(), args.insert(object.clone()));
         }
-        match func_ref.payload {
-            PyObjectPayload::RustFunction { ref function } => function(self, args),
-            ref payload => {
-                // TODO: is it safe to just invoke __call__ otherwise?
-                trace!("invoke __call__ for: {:?}", payload);
-                self.call_method(&func_ref, "__call__", args)
-            }
+        if let Some(PyBuiltinFunction { ref value }) = func_ref.payload() {
+            return value(self, args);
         }
+
+        // TODO: is it safe to just invoke __call__ otherwise?
+        trace!("invoke __call__ for: {:?}", func_ref.payload);
+        self.call_method(&func_ref, "__call__", args)
     }
 
     fn invoke_python_function(
