Adds __qualname__ to PyBuiltinMethod

Author: sobolevn

derive/src/pyclass.rs

@@ -317,18 +317,25 @@ where
         let item_meta = MethodItemMeta::from_attr(ident.clone(), &item_attr)?;
 
         let py_name = item_meta.method_name()?;
-        let build_func = Ident::new(&format!("build_{}", &self.method_type), args.item.span());
         let tokens = {
             let doc = args.attrs.doc().map_or_else(
                 TokenStream::new,
                 |doc| quote!(.with_doc(#doc.to_owned(), ctx)),
             );
+            let build_func = match self.method_type.as_str() {
+                "method" => quote!(.build_method(ctx, class.clone())),
+                "classmethod" => quote!(.build_classmethod(ctx, class.clone())),
+                other => unreachable!(
+                    "Only 'method' and 'classmethod' are supported, got {}",
+                    other
+                ),
+            };
             quote! {
                 class.set_str_attr(
                     #py_name,
                     ctx.make_funcdef(#py_name, Self::#ident)
                         #doc
-                        .#build_func(ctx),
+                        #build_func
                 );
             }
         };

extra_tests/snippets/builtin_type.py

@@ -44,3 +44,60 @@ class D:
 assert iter.__class__.__qualname__ == 'builtin_function_or_method'
 assert type(iter).__module__ == 'builtins'
 assert type(iter).__qualname__ == 'builtin_function_or_method'
+
+
+# Regression to
+# https://github.com/RustPython/RustPython/issues/2767
+
+# Marked as `#[pymethod]`:
+assert str.replace.__qualname__ == 'str.replace'
+assert str().replace.__qualname__ == 'str.replace'
+assert int.to_bytes.__qualname__ == 'int.to_bytes'
+assert int().to_bytes.__qualname__ == 'int.to_bytes'
+
+# Marked as `#[pyclassmethod]`:
+assert dict.fromkeys.__qualname__ == 'dict.fromkeys'
+assert object.__init_subclass__.__qualname__ == 'object.__init_subclass__'
+
+# Dynamic with `#[extend_class]`:
+assert bytearray.maketrans.__qualname__ == 'bytearray.maketrans'
+
+
+# Third-party:
+class MyTypeWithMethod:
+    def method(self):
+        pass
+
+    @classmethod
+    def clsmethod(cls):
+        pass
+
+    @staticmethod
+    def stmethod():
+        pass
+
+    class N:
+        def m(self):
+            pass
+
+        @classmethod
+        def c(cls):
+            pass
+
+        @staticmethod
+        def s():
+            pass
+
+assert MyTypeWithMethod.method.__qualname__ == 'MyTypeWithMethod.method'
+assert MyTypeWithMethod().method.__qualname__ == 'MyTypeWithMethod.method'
+assert MyTypeWithMethod.clsmethod.__qualname__ == 'MyTypeWithMethod.clsmethod'
+assert MyTypeWithMethod().clsmethod.__qualname__ == 'MyTypeWithMethod.clsmethod'
+assert MyTypeWithMethod.stmethod.__qualname__ == 'MyTypeWithMethod.stmethod'
+assert MyTypeWithMethod().stmethod.__qualname__ == 'MyTypeWithMethod.stmethod'
+
+assert MyTypeWithMethod.N.m.__qualname__ == 'MyTypeWithMethod.N.m'
+assert MyTypeWithMethod().N.m.__qualname__ == 'MyTypeWithMethod.N.m'
+assert MyTypeWithMethod.N.c.__qualname__ == 'MyTypeWithMethod.N.c'
+assert MyTypeWithMethod().N.c.__qualname__ == 'MyTypeWithMethod.N.c'
+assert MyTypeWithMethod.N.s.__qualname__ == 'MyTypeWithMethod.N.s'
+assert MyTypeWithMethod().N.s.__qualname__ == 'MyTypeWithMethod.N.s'

vm/src/builtins/builtinfunc.rs

@@ -38,17 +38,17 @@ impl PyNativeFuncDef {
     pub fn build_function(self, ctx: &PyContext) -> PyObjectRef {
         self.into_function().build(ctx)
     }
-    pub fn build_method(self, ctx: &PyContext) -> PyObjectRef {
+    pub fn build_method(self, ctx: &PyContext, class: PyTypeRef) -> PyObjectRef {
         PyObject::new(
-            PyBuiltinMethod::from(self),
+            PyBuiltinMethod { value: self, class },
             ctx.types.method_descriptor_type.clone(),
             None,
         )
     }
-    pub fn build_classmethod(self, ctx: &PyContext) -> PyObjectRef {
+    pub fn build_classmethod(self, ctx: &PyContext, class: PyTypeRef) -> PyObjectRef {
         // TODO: classmethod_descriptor
         PyObject::new(
-            PyClassMethod::from(self.build_method(ctx)),
+            PyClassMethod::from(self.build_method(ctx, class)),
             ctx.types.classmethod_type.clone(),
             None,
         )
@@ -140,9 +140,12 @@ impl PyBuiltinFunction {
     }
 }
 
+// PyCMethodObject in
+// https://github.com/python/cpython/blob/main/Include/cpython/methodobject.h
 #[pyclass(module = false, name = "method_descriptor")]
 pub struct PyBuiltinMethod {
     value: PyNativeFuncDef,
+    class: PyTypeRef,
 }
 
 impl PyValue for PyBuiltinMethod {
@@ -157,12 +160,6 @@ impl fmt::Debug for PyBuiltinMethod {
     }
 }
 
-impl From<PyNativeFuncDef> for PyBuiltinMethod {
-    fn from(value: PyNativeFuncDef) -> Self {
-        Self { value }
-    }
-}
-
 impl SlotDescriptor for PyBuiltinMethod {
     fn descr_get(
         zelf: PyObjectRef,
@@ -195,6 +192,11 @@ impl PyBuiltinMethod {
         self.value.name.clone()
     }
     #[pyproperty(magic)]
+    fn qualname(&self, vm: &VirtualMachine) -> PyObjectRef {
+        vm.ctx
+            .new_str(format!("{}.{}", self.class.name, &self.value.name))
+    }
+    #[pyproperty(magic)]
     fn doc(&self) -> Option<PyStrRef> {
         self.value.doc.clone()
     }

vm/src/builtins/bytearray.rs

@@ -93,7 +93,7 @@ pub(crate) fn init(context: &PyContext) {
     PyByteArray::extend_class(context, &context.types.bytearray_type);
     let bytearray_type = &context.types.bytearray_type;
     extend_class!(context, bytearray_type, {
-        "maketrans" => context.new_method("maketrans", PyBytesInner::maketrans),
+        "maketrans" => context.new_method("maketrans", PyBytesInner::maketrans, bytearray_type.clone()),
     });
 
     PyByteArrayIterator::extend_class(context, &context.types.bytearray_iterator_type);

vm/src/builtins/bytes.rs

@@ -93,7 +93,7 @@ pub(crate) fn init(context: &PyContext) {
     PyBytes::extend_class(context, &context.types.bytes_type);
     let bytes_type = &context.types.bytes_type;
     extend_class!(context, bytes_type, {
-        "maketrans" => context.new_method("maketrans", PyBytesInner::maketrans),
+        "maketrans" => context.new_method("maketrans", PyBytesInner::maketrans, bytes_type.clone()),
     });
     PyBytesIterator::extend_class(context, &context.types.bytes_iterator_type);
 }

vm/src/exceptions.rs

@@ -666,7 +666,7 @@ impl ExceptionZoo {
         });
 
         extend_class!(ctx, &excs.import_error, {
-            "__init__" => ctx.new_method("__init__", import_error_init),
+            "__init__" => ctx.new_method("__init__", import_error_init, excs.import_error.clone()),
             "msg" => ctx.new_readonly_getset("msg", make_arg_getter(0)),
         });
 
@@ -675,7 +675,7 @@ impl ExceptionZoo {
         });
 
         extend_class!(ctx, &excs.key_error, {
-            "__str__" => ctx.new_method("__str__", key_error_str),
+            "__str__" => ctx.new_method("__str__", key_error_str, excs.key_error.clone()),
         });
 
         let errno_getter = ctx.new_readonly_getset("errno", |exc: PyBaseExceptionRef| {

vm/src/pyobject.rs

@@ -296,25 +296,40 @@ impl PyContext {
         self.make_funcdef(name, f).build_function(self)
     }
 
-    pub fn new_method<F, FKind>(&self, name: impl Into<String>, f: F) -> PyObjectRef
+    pub fn new_method<F, FKind>(
+        &self,
+        name: impl Into<String>,
+        f: F,
+        class: PyTypeRef,
+    ) -> PyObjectRef
     where
         F: IntoPyNativeFunc<FKind>,
     {
-        self.make_funcdef(name, f).build_method(self)
+        self.make_funcdef(name, f).build_method(self, class)
     }
 
-    pub fn new_classmethod<F, FKind>(&self, name: impl Into<String>, f: F) -> PyObjectRef
+    pub fn new_classmethod<F, FKind>(
+        &self,
+        name: impl Into<String>,
+        f: F,
+        class: PyTypeRef,
+    ) -> PyObjectRef
     where
         F: IntoPyNativeFunc<FKind>,
     {
-        self.make_funcdef(name, f).build_classmethod(self)
-    }
-    pub fn new_staticmethod<F, FKind>(&self, name: impl Into<String>, f: F) -> PyObjectRef
+        self.make_funcdef(name, f).build_classmethod(self, class)
+    }
+    pub fn new_staticmethod<F, FKind>(
+        &self,
+        name: impl Into<String>,
+        f: F,
+        class: PyTypeRef,
+    ) -> PyObjectRef
     where
         F: IntoPyNativeFunc<FKind>,
     {
         PyObject::new(
-            PyStaticMethod::from(self.new_method(name, f)),
+            PyStaticMethod::from(self.new_method(name, f, class)),
             self.types.staticmethod_type.clone(),
             None,
         )

wasm/lib/src/convert.rs

@@ -216,7 +216,7 @@ pub fn js_to_py(vm: &VirtualMachine, js_val: JsValue) -> PyObjectRef {
         }
     } else if js_val.is_function() {
         let func = js_sys::Function::from(js_val);
-        vm.ctx.new_method(
+        vm.ctx.new_function(
             func.name(),
             move |args: FuncArgs, vm: &VirtualMachine| -> PyResult {
                 let this = Object::new();

wasm/lib/src/wasm_builtins.rs

@@ -24,16 +24,18 @@ pub fn make_stdout_object(
     write_f: impl Fn(&str, &VirtualMachine) -> PyResult<()> + 'static,
 ) -> PyObjectRef {
     let ctx = &vm.ctx;
+    // there's not really any point to storing this class so that there's a consistent type object,
+    // we just want a half-decent repr() output
+    let cls = py_class!(ctx, "JSStdout", &vm.ctx.types.object_type, {});
     let write_method = ctx.new_method(
         "write",
         move |_self: PyObjectRef, data: PyStrRef, vm: &VirtualMachine| -> PyResult<()> {
             write_f(data.as_str(), vm)
         },
+        cls.clone(),
     );
-    let flush_method = ctx.new_method("flush", |_self: PyObjectRef| {});
-    // there's not really any point to storing this class so that there's a consistent type object,
-    // we just want a half-decent repr() output
-    let cls = py_class!(ctx, "JSStdout", &vm.ctx.types.object_type, {
+    let flush_method = ctx.new_method("flush", |_self: PyObjectRef| {}, cls.clone());
+    extend_class!(ctx, cls, {
         "write" => write_method,
         "flush" => flush_method,
     });