new_rustfunc -> new_function & new_method to distinguish bindable functions

Author: youknowone

derive/src/pyclass.rs

@@ -306,7 +306,7 @@ pub fn impl_pyimpl(_attr: AttributeArgs, item: Item) -> Result<TokenStream2, Dia
             item_ident,
             py_name,
         } => Some(quote! {
-            class.set_str_attr(#py_name, ctx.new_rustfunc(Self::#item_ident));
+            class.set_str_attr(#py_name, ctx.new_method(Self::#item_ident));
         }),
         ClassItem::ClassMethod {
             item_ident,

vm/src/builtins.rs

@@ -760,13 +760,13 @@ pub fn make_module(vm: &VirtualMachine, module: PyObjectRef) {
     #[cfg(target_arch = "wasm32")]
     let open = vm.ctx.none();
     #[cfg(not(target_arch = "wasm32"))]
-    let open = vm.ctx.new_rustfunc(io_open);
+    let open = vm.ctx.new_function(io_open);
 
     #[cfg(feature = "rustpython-compiler")]
     {
         extend_module!(vm, module, {
-            "eval" => ctx.new_rustfunc(builtin_eval),
-            "exec" => ctx.new_rustfunc(builtin_exec),
+            "eval" => ctx.new_function(builtin_eval),
+            "exec" => ctx.new_function(builtin_exec),
         });
     }
 
@@ -776,73 +776,73 @@ pub fn make_module(vm: &VirtualMachine, module: PyObjectRef) {
         //set __name__ fixes: https://github.com/RustPython/RustPython/issues/146
         "__name__" => ctx.new_str(String::from("__main__")),
 
-        "abs" => ctx.new_rustfunc(builtin_abs),
-        "all" => ctx.new_rustfunc(builtin_all),
-        "any" => ctx.new_rustfunc(builtin_any),
-        "ascii" => ctx.new_rustfunc(builtin_ascii),
-        "bin" => ctx.new_rustfunc(builtin_bin),
+        "abs" => ctx.new_function(builtin_abs),
+        "all" => ctx.new_function(builtin_all),
+        "any" => ctx.new_function(builtin_any),
+        "ascii" => ctx.new_function(builtin_ascii),
+        "bin" => ctx.new_function(builtin_bin),
         "bool" => ctx.bool_type(),
         "bytearray" => ctx.bytearray_type(),
         "bytes" => ctx.bytes_type(),
-        "callable" => ctx.new_rustfunc(builtin_callable),
-        "chr" => ctx.new_rustfunc(builtin_chr),
+        "callable" => ctx.new_function(builtin_callable),
+        "chr" => ctx.new_function(builtin_chr),
         "classmethod" => ctx.classmethod_type(),
-        "compile" => ctx.new_rustfunc(builtin_compile),
+        "compile" => ctx.new_function(builtin_compile),
         "complex" => ctx.complex_type(),
-        "delattr" => ctx.new_rustfunc(builtin_delattr),
+        "delattr" => ctx.new_function(builtin_delattr),
         "dict" => ctx.dict_type(),
-        "divmod" => ctx.new_rustfunc(builtin_divmod),
-        "dir" => ctx.new_rustfunc(builtin_dir),
+        "divmod" => ctx.new_function(builtin_divmod),
+        "dir" => ctx.new_function(builtin_dir),
         "enumerate" => ctx.enumerate_type(),
         "float" => ctx.float_type(),
         "frozenset" => ctx.frozenset_type(),
         "filter" => ctx.filter_type(),
-        "format" => ctx.new_rustfunc(builtin_format),
-        "getattr" => ctx.new_rustfunc(builtin_getattr),
-        "globals" => ctx.new_rustfunc(builtin_globals),
-        "hasattr" => ctx.new_rustfunc(builtin_hasattr),
-        "hash" => ctx.new_rustfunc(builtin_hash),
-        "hex" => ctx.new_rustfunc(builtin_hex),
-        "id" => ctx.new_rustfunc(builtin_id),
+        "format" => ctx.new_function(builtin_format),
+        "getattr" => ctx.new_function(builtin_getattr),
+        "globals" => ctx.new_function(builtin_globals),
+        "hasattr" => ctx.new_function(builtin_hasattr),
+        "hash" => ctx.new_function(builtin_hash),
+        "hex" => ctx.new_function(builtin_hex),
+        "id" => ctx.new_function(builtin_id),
         "int" => ctx.int_type(),
-        "isinstance" => ctx.new_rustfunc(builtin_isinstance),
-        "issubclass" => ctx.new_rustfunc(builtin_issubclass),
-        "iter" => ctx.new_rustfunc(builtin_iter),
-        "len" => ctx.new_rustfunc(builtin_len),
+        "isinstance" => ctx.new_function(builtin_isinstance),
+        "issubclass" => ctx.new_function(builtin_issubclass),
+        "iter" => ctx.new_function(builtin_iter),
+        "len" => ctx.new_function(builtin_len),
         "list" => ctx.list_type(),
-        "locals" => ctx.new_rustfunc(builtin_locals),
+        "locals" => ctx.new_function(builtin_locals),
         "map" => ctx.map_type(),
-        "max" => ctx.new_rustfunc(builtin_max),
+        "max" => ctx.new_function(builtin_max),
         "memoryview" => ctx.memoryview_type(),
-        "min" => ctx.new_rustfunc(builtin_min),
+        "min" => ctx.new_function(builtin_min),
         "object" => ctx.object(),
-        "oct" => ctx.new_rustfunc(builtin_oct),
+        "oct" => ctx.new_function(builtin_oct),
         "open" => open,
-        "ord" => ctx.new_rustfunc(builtin_ord),
-        "next" => ctx.new_rustfunc(builtin_next),
-        "pow" => ctx.new_rustfunc(builtin_pow),
-        "print" => ctx.new_rustfunc(builtin_print),
+        "ord" => ctx.new_function(builtin_ord),
+        "next" => ctx.new_function(builtin_next),
+        "pow" => ctx.new_function(builtin_pow),
+        "print" => ctx.new_function(builtin_print),
         "property" => ctx.property_type(),
         "range" => ctx.range_type(),
-        "repr" => ctx.new_rustfunc(builtin_repr),
-        "reversed" => ctx.new_rustfunc(builtin_reversed),
-        "round" => ctx.new_rustfunc(builtin_round),
+        "repr" => ctx.new_function(builtin_repr),
+        "reversed" => ctx.new_function(builtin_reversed),
+        "round" => ctx.new_function(builtin_round),
         "set" => ctx.set_type(),
-        "setattr" => ctx.new_rustfunc(builtin_setattr),
-        "sorted" => ctx.new_rustfunc(builtin_sorted),
+        "setattr" => ctx.new_function(builtin_setattr),
+        "sorted" => ctx.new_function(builtin_sorted),
         "slice" => ctx.slice_type(),
         "staticmethod" => ctx.staticmethod_type(),
         "str" => ctx.str_type(),
-        "sum" => ctx.new_rustfunc(builtin_sum),
+        "sum" => ctx.new_function(builtin_sum),
         "super" => ctx.super_type(),
         "tuple" => ctx.tuple_type(),
         "type" => ctx.type_type(),
-        "vars" => ctx.new_rustfunc(builtin_vars),
+        "vars" => ctx.new_function(builtin_vars),
         "zip" => ctx.zip_type(),
-        "exit" => ctx.new_rustfunc(builtin_exit),
-        "quit" => ctx.new_rustfunc(builtin_exit),
-        "__import__" => ctx.new_rustfunc(builtin_import),
-        "__build_class__" => ctx.new_rustfunc(builtin_build_class_),
+        "exit" => ctx.new_function(builtin_exit),
+        "quit" => ctx.new_function(builtin_exit),
+        "__import__" => ctx.new_function(builtin_import),
+        "__build_class__" => ctx.new_function(builtin_build_class_),
 
         // Constants
         "NotImplemented" => ctx.not_implemented(),

vm/src/exceptions.rs

@@ -624,7 +624,7 @@ pub fn init(ctx: &PyContext) {
     });
 
     extend_class!(ctx, &excs.import_error, {
-        "__init__" => ctx.new_rustfunc(import_error_init),
+        "__init__" => ctx.new_method(import_error_init),
         "msg" => ctx.new_property(make_arg_getter(0)),
     });
 

vm/src/frame.rs

@@ -1146,7 +1146,7 @@ impl Frame {
         let scope = self.scope.clone();
         let func_obj = vm
             .ctx
-            .new_function(code_obj, scope, defaults, kw_only_defaults);
+            .new_pyfunction(code_obj, scope, defaults, kw_only_defaults);
 
         let name = qualified_name.as_str().split('.').next_back().unwrap();
         vm.set_attr(&func_obj, "__name__", vm.new_str(name.to_string()))?;

vm/src/obj/objbool.rs

@@ -88,14 +88,14 @@ The class bool is a subclass of the class int, and cannot be subclassed.";
     let bool_type = &context.types.bool_type;
     extend_class!(context, bool_type, {
         (slot new) => bool_new,
-        "__repr__" => context.new_rustfunc(bool_repr),
-        "__format__" => context.new_rustfunc(bool_format),
-        "__or__" => context.new_rustfunc(bool_or),
-        "__ror__" => context.new_rustfunc(bool_or),
-        "__and__" => context.new_rustfunc(bool_and),
-        "__rand__" => context.new_rustfunc(bool_and),
-        "__xor__" => context.new_rustfunc(bool_xor),
-        "__rxor__" => context.new_rustfunc(bool_xor),
+        "__repr__" => context.new_method(bool_repr),
+        "__format__" => context.new_method(bool_format),
+        "__or__" => context.new_method(bool_or),
+        "__ror__" => context.new_method(bool_or),
+        "__and__" => context.new_method(bool_and),
+        "__rand__" => context.new_method(bool_and),
+        "__xor__" => context.new_method(bool_xor),
+        "__rxor__" => context.new_method(bool_xor),
         "__doc__" => context.new_str(bool_doc.to_string()),
     });
 }

vm/src/obj/objbuiltinfunc.rs

@@ -1,12 +1,16 @@
 use std::fmt;
 
-use crate::function::PyNativeFunc;
+use crate::function::{PyFuncArgs, PyNativeFunc};
 use crate::obj::objtype::PyClassRef;
-use crate::pyobject::PyValue;
+use crate::pyobject::{
+    IdProtocol, PyClassImpl, PyContext, PyObjectRef, PyRef, PyResult, PyValue, TypeProtocol,
+};
 use crate::vm::VirtualMachine;
 
+#[pyclass]
 pub struct PyBuiltinFunction {
     value: PyNativeFunc,
+    bindable: bool,
 }
 
 impl PyValue for PyBuiltinFunction {
@@ -22,11 +26,37 @@ impl fmt::Debug for PyBuiltinFunction {
 }
 
 impl PyBuiltinFunction {
-    pub fn new(value: PyNativeFunc) -> Self {
-        Self { value }
+    pub fn new(value: PyNativeFunc, bindable: bool) -> Self {
+        Self { value, bindable }
     }
 
     pub fn as_func(&self) -> &PyNativeFunc {
         &self.value
     }
 }
+
+#[pyimpl]
+impl PyBuiltinFunction {
+    #[pymethod(name = "__call__")]
+    pub fn call(&self, args: PyFuncArgs, vm: &VirtualMachine) -> PyResult {
+        (self.value)(vm, args)
+    }
+
+    #[pymethod(name = "__get__")]
+    fn bind_method(
+        function: PyRef<Self>,
+        obj: PyObjectRef,
+        cls: PyObjectRef,
+        vm: &VirtualMachine,
+    ) -> PyResult {
+        if !function.bindable || obj.is(&vm.get_none()) && !cls.is(&obj.class()) {
+            Ok(function.into_object())
+        } else {
+            Ok(vm.ctx.new_bound_method(function.into_object(), obj))
+        }
+    }
+}
+
+pub fn init(context: &PyContext) {
+    PyBuiltinFunction::extend_class(context, &context.types.builtin_function_or_method_type);
+}

vm/src/obj/objbytearray.rs

@@ -83,8 +83,8 @@ pub fn init(context: &PyContext) {
     PyByteArrayRef::extend_class(context, &context.types.bytearray_type);
     let bytearray_type = &context.types.bytearray_type;
     extend_class!(context, bytearray_type, {
-    "fromhex" => context.new_rustfunc(PyByteArrayRef::fromhex),
-    "maketrans" => context.new_rustfunc(PyByteInner::maketrans),
+    "fromhex" => context.new_method(PyByteArrayRef::fromhex),
+    "maketrans" => context.new_method(PyByteInner::maketrans),
     });
 
     PyByteArrayIterator::extend_class(context, &context.types.bytearrayiterator_type);

vm/src/obj/objbytes.rs

@@ -80,8 +80,8 @@ pub fn init(context: &PyContext) {
     PyBytesRef::extend_class(context, &context.types.bytes_type);
     let bytes_type = &context.types.bytes_type;
     extend_class!(context, bytes_type, {
-    "fromhex" => context.new_rustfunc(PyBytesRef::fromhex),
-    "maketrans" => context.new_rustfunc(PyByteInner::maketrans),
+    "fromhex" => context.new_method(PyBytesRef::fromhex),
+    "maketrans" => context.new_method(PyByteInner::maketrans),
 
     });
     PyBytesIterator::extend_class(context, &context.types.bytesiterator_type);

vm/src/obj/objcode.rs

@@ -95,7 +95,7 @@ impl PyCodeRef {
 pub fn init(context: &PyContext) {
     extend_class!(context, &context.types.code_type, {
         (slot new) => PyCodeRef::new,
-        "__repr__" => context.new_rustfunc(PyCodeRef::repr),
+        "__repr__" => context.new_method(PyCodeRef::repr),
 
         "co_argcount" => context.new_property(PyCodeRef::co_argcount),
         "co_consts" => context.new_property(PyCodeRef::co_consts),

vm/src/obj/objdict.rs

@@ -596,30 +596,30 @@ dict_iterator! {
 
 pub fn init(context: &PyContext) {
     extend_class!(context, &context.types.dict_type, {
-        "__bool__" => context.new_rustfunc(PyDictRef::bool),
-        "__len__" => context.new_rustfunc(PyDictRef::len),
-        "__sizeof__" => context.new_rustfunc(PyDictRef::sizeof),
-        "__contains__" => context.new_rustfunc(PyDictRef::contains),
-        "__delitem__" => context.new_rustfunc(PyDictRef::inner_delitem),
-        "__eq__" => context.new_rustfunc(PyDictRef::eq),
-        "__ne__" => context.new_rustfunc(PyDictRef::ne),
-        "__getitem__" => context.new_rustfunc(PyDictRef::inner_getitem),
-        "__iter__" => context.new_rustfunc(PyDictRef::iter),
+        "__bool__" => context.new_method(PyDictRef::bool),
+        "__len__" => context.new_method(PyDictRef::len),
+        "__sizeof__" => context.new_method(PyDictRef::sizeof),
+        "__contains__" => context.new_method(PyDictRef::contains),
+        "__delitem__" => context.new_method(PyDictRef::inner_delitem),
+        "__eq__" => context.new_method(PyDictRef::eq),
+        "__ne__" => context.new_method(PyDictRef::ne),
+        "__getitem__" => context.new_method(PyDictRef::inner_getitem),
+        "__iter__" => context.new_method(PyDictRef::iter),
         (slot new) => PyDictRef::new,
-        "__repr__" => context.new_rustfunc(PyDictRef::repr),
-        "__setitem__" => context.new_rustfunc(PyDictRef::inner_setitem),
-        "__hash__" => context.new_rustfunc(PyDictRef::hash),
-        "clear" => context.new_rustfunc(PyDictRef::clear),
-        "values" => context.new_rustfunc(PyDictRef::values),
-        "items" => context.new_rustfunc(PyDictRef::items),
-        "keys" => context.new_rustfunc(PyDictRef::keys),
+        "__repr__" => context.new_method(PyDictRef::repr),
+        "__setitem__" => context.new_method(PyDictRef::inner_setitem),
+        "__hash__" => context.new_method(PyDictRef::hash),
+        "clear" => context.new_method(PyDictRef::clear),
+        "values" => context.new_method(PyDictRef::values),
+        "items" => context.new_method(PyDictRef::items),
+        "keys" => context.new_method(PyDictRef::keys),
         "fromkeys" => context.new_classmethod(PyDictRef::fromkeys),
-        "get" => context.new_rustfunc(PyDictRef::get),
-        "setdefault" => context.new_rustfunc(PyDictRef::setdefault),
-        "copy" => context.new_rustfunc(PyDictRef::copy),
-        "update" => context.new_rustfunc(PyDictRef::update),
-        "pop" => context.new_rustfunc(PyDictRef::pop),
-        "popitem" => context.new_rustfunc(PyDictRef::popitem),
+        "get" => context.new_method(PyDictRef::get),
+        "setdefault" => context.new_method(PyDictRef::setdefault),
+        "copy" => context.new_method(PyDictRef::copy),
+        "update" => context.new_method(PyDictRef::update),
+        "pop" => context.new_method(PyDictRef::pop),
+        "popitem" => context.new_method(PyDictRef::popitem),
     });
 
     PyDictKeys::extend_class(context, &context.types.dictkeys_type);

vm/src/obj/objellipsis.rs

@@ -5,8 +5,8 @@ use crate::vm::VirtualMachine;
 pub fn init(context: &PyContext) {
     extend_class!(context, &context.ellipsis_type, {
         (slot new) => ellipsis_new,
-        "__repr__" => context.new_rustfunc(ellipsis_repr),
-        "__reduce__" => context.new_rustfunc(ellipsis_reduce),
+        "__repr__" => context.new_method(ellipsis_repr),
+        "__reduce__" => context.new_method(ellipsis_reduce),
     });
 }
 

vm/src/obj/objfunction.rs

@@ -85,22 +85,16 @@ impl PyValue for PyMethod {
 pub fn init(context: &PyContext) {
     let function_type = &context.types.function_type;
     extend_class!(context, function_type, {
-        "__get__" => context.new_rustfunc(bind_method),
-        "__call__" => context.new_rustfunc(PyFunctionRef::call),
+        "__get__" => context.new_method(bind_method),
+        "__call__" => context.new_method(PyFunctionRef::call),
         "__code__" => context.new_property(PyFunctionRef::code),
         "__defaults__" => context.new_property(PyFunctionRef::defaults),
         "__kwdefaults__" => context.new_property(PyFunctionRef::kwdefaults),
     });
 
-    let builtin_function_or_method_type = &context.types.builtin_function_or_method_type;
-    extend_class!(context, builtin_function_or_method_type, {
-        "__get__" => context.new_rustfunc(bind_method),
-        "__call__" => context.new_rustfunc(PyFunctionRef::call),
-    });
-
     let method_type = &context.types.bound_method_type;
     extend_class!(context, method_type, {
-        "__getattribute__" => context.new_rustfunc(PyMethod::getattribute),
+        "__getattribute__" => context.new_method(PyMethod::getattribute),
     });
 }
 

vm/src/obj/objmodule.rs

@@ -91,7 +91,7 @@ impl PyModuleRef {
 pub fn init(context: &PyContext) {
     extend_class!(&context, &context.types.module_type, {
         (slot new) => PyModuleRef::new,
-        "__getattribute__" => context.new_rustfunc(PyModuleRef::getattribute),
-        "__repr__" => context.new_rustfunc(PyModuleRef::repr),
+        "__getattribute__" => context.new_method(PyModuleRef::getattribute),
+        "__repr__" => context.new_method(PyModuleRef::repr),
     });
 }