ensure Python fallback has same behavior as _PyObject_LookupSpecialMethod() on classmethod, staticmethod, and property

Author: tanloong

Lib/test/test_types.py

@@ -747,12 +747,15 @@ def __enter__(self):
         cm1 = CM1()
         meth = lookup(cm1, "__enter__")
         self.assertIsNotNone(meth)
+        with self.assertRaisesRegex(
+                TypeError, "missing 1 required positional argument") as cm:
+            meth()
         self.assertEqual(meth(cm1), "__enter__ from class __dict__")
 
         meth = lookup(cm1, "__missing__")
         self.assertIsNone(meth)
 
-        with self.assertRaises(TypeError):
+        with self.assertRaisesRegex(TypeError, "attribute name must be string"):
             lookup(cm1, 123)
 
         cm2 = CM2()
@@ -768,6 +771,27 @@ def __enter__(self):
         self.assertIsNotNone(meth)
         self.assertEqual(meth([]), 0)
 
+        class Person:
+            @classmethod
+            def hi(cls):
+                return f"hi from {cls.__name__}"
+            @staticmethod
+            def hello():
+                return "hello from static method"
+            @property
+            def name(self):
+                return "name from property"
+        p = Person()
+        meth = lookup(p, "hi")
+        self.assertIsNotNone(meth)
+        self.assertEqual(meth(), "hi from Person")
+
+        meth = lookup(p, "hello")
+        self.assertIsNotNone(meth)
+        self.assertEqual(meth(), "hello from static method")
+
+        self.assertEqual(lookup(p, "name"), "name from property")
+
     def test_lookup_special_method(self):
         c_lookup = getattr(c_types, "lookup_special_method")
         py_lookup = getattr(py_types, "lookup_special_method")

Lib/types.py

@@ -110,11 +110,11 @@ def lookup_special_method(obj, attr, /):
         >>> enter_b(b)
         'B.__enter__'
 
-        For other descriptors (property, etc.), it returns the result of the
-        descriptor's `__get__` method. Returns `None` if the method is not
-        found.
+        For other descriptors (classmethod, staticmethod, property, etc.), it
+        returns the result of the descriptor's `__get__` method. Returns `None`
+        if the method is not found.
         """
-        from inspect import getattr_static, isfunction, ismethoddescriptor
+        from inspect import getattr_static, isfunction
         cls = type(obj)
         if not isinstance(attr, str):
             raise TypeError(
@@ -125,7 +125,8 @@ def lookup_special_method(obj, attr, /):
         except AttributeError:
             return None
         if hasattr(descr, "__get__"):
-            if isfunction(descr) or ismethoddescriptor(descr):
+            if isfunction(descr) or isinstance(descr,(
+                MethodDescriptorType, WrapperDescriptorType)):
                 # do not create bound method to mimic the behavior of
                 # _PyObject_LookupSpecialMethod
                 return descr