Add __new__ and __call__ toObjectModel and ClassModel (#1606)

Author: DanielNoord

ChangeLog

@@ -67,6 +67,8 @@ Release date: TBA
 * Rename ``ModuleSpec`` -> ``module_type`` constructor parameter to match attribute
   name and improve typing. Use ``type`` instead.
 
+* ``ObjectModel`` and ``ClassModel`` now know about their ``__new__`` and ``__call__`` attributes.
+
 * Fixed pylint ``not-callable`` false positive with nested-tuple assignment in a for-loop.
 
   Refs PyCQA/pylint#5113

astroid/bases.py

@@ -10,9 +10,9 @@
 import collections
 import collections.abc
 from collections.abc import Sequence
-from typing import TYPE_CHECKING, Any
+from typing import Any
 
-from astroid import decorators
+from astroid import decorators, nodes
 from astroid.const import PY310_PLUS
 from astroid.context import (
     CallContext,
@@ -33,9 +33,6 @@
 helpers = lazy_import("helpers")
 manager = lazy_import("manager")
 
-if TYPE_CHECKING:
-    from astroid import nodes
-
 
 # TODO: check if needs special treatment
 BOOL_SPECIAL_METHOD = "__bool__"
@@ -271,10 +268,20 @@ def _wrap_attr(self, attrs, context=None):
             else:
                 yield attr
 
-    def infer_call_result(self, caller, context=None):
+    def infer_call_result(
+        self, caller: nodes.Call | Proxy, context: InferenceContext | None = None
+    ):
         """infer what a class instance is returning when called"""
         context = bind_context_to_node(context, self)
         inferred = False
+
+        # If the call is an attribute on the instance, we infer the attribute itself
+        if isinstance(caller, nodes.Call) and isinstance(caller.func, nodes.Attribute):
+            for res in self.igetattr(caller.func.attrname, context):
+                inferred = True
+                yield res
+
+        # Otherwise we infer the call to the __call__ dunder normally
         for node in self._proxied.igetattr("__call__", context):
             if node is Uninferable or not node.callable():
                 continue
@@ -418,9 +425,6 @@ def _infer_builtin_new(
     ) -> collections.abc.Generator[
         nodes.Const | Instance | type[Uninferable], None, None
     ]:
-        # pylint: disable-next=import-outside-toplevel; circular import
-        from astroid import nodes
-
         if not caller.args:
             return
         # Attempt to create a constant

astroid/interpreter/objectmodel.py

@@ -118,6 +118,19 @@ def lookup(self, name):
             return getattr(self, IMPL_PREFIX + name)
         raise AttributeInferenceError(target=self._instance, attribute=name)
 
+    @property
+    def attr___new__(self):
+        """Calling cls.__new__(cls) on an object returns an instance of that object.
+
+        Instance is either an instance or a class definition of the instance to be
+        created.
+        """
+        # TODO: Use isinstance instead of try ... except after _instance has typing
+        try:
+            return self._instance._proxied.instantiate_class()
+        except AttributeError:
+            return self._instance.instantiate_class()
+
 
 class ModuleModel(ObjectModel):
     def _builtins(self):
@@ -389,7 +402,6 @@ def attr___ne__(self):
     attr___repr__ = attr___ne__
     attr___reduce__ = attr___ne__
     attr___reduce_ex__ = attr___ne__
-    attr___new__ = attr___ne__
     attr___lt__ = attr___ne__
     attr___eq__ = attr___ne__
     attr___gt__ = attr___ne__
@@ -512,6 +524,11 @@ def infer_call_result(self, caller, context=None):
     def attr___dict__(self):
         return node_classes.Dict(parent=self._instance)
 
+    @property
+    def attr___call__(self):
+        """Calling a class A() returns an instance of A."""
+        return self._instance.instantiate_class()
+
 
 class SuperModel(ObjectModel):
     @property

astroid/nodes/scoped_nodes/scoped_nodes.py

@@ -2298,7 +2298,12 @@ def infer_call_result(self, caller, context=None):
         try:
             metaclass = self.metaclass(context=context)
             if metaclass is not None:
-                dunder_call = next(metaclass.igetattr("__call__", context))
+                # Only get __call__ if it's defined locally for the metaclass.
+                # Otherwise we will find ObjectModel.__call__ which will
+                # return an instance of the metaclass. Instantiating the class is
+                # handled later.
+                if "__call__" in metaclass.locals:
+                    dunder_call = next(metaclass.igetattr("__call__", context))
         except (AttributeInferenceError, StopIteration):
             pass
 
@@ -2550,7 +2555,11 @@ def getattr(self, name, context=None, class_context=True):
         if not name:
             raise AttributeInferenceError(target=self, attribute=name, context=context)
 
-        values = self.locals.get(name, [])
+        # don't modify the list in self.locals!
+        values = list(self.locals.get(name, []))
+        for classnode in self.ancestors(recurs=True, context=context):
+            values += classnode.locals.get(name, [])
+
         if name in self.special_attributes and class_context and not values:
             result = [self.special_attributes.lookup(name)]
             if name == "__bases__":
@@ -2559,11 +2568,6 @@ def getattr(self, name, context=None, class_context=True):
                 result += values
             return result
 
-        # don't modify the list in self.locals!
-        values = list(values)
-        for classnode in self.ancestors(recurs=True, context=context):
-            values += classnode.locals.get(name, [])
-
         if class_context:
             values += self._metaclass_lookup_attribute(name, context)
 

tests/unittest_objects.py

@@ -32,6 +32,24 @@ def test_frozenset(self) -> None:
         self.assertEqual(inferred.qname(), "builtins.frozenset")
         self.assertIsInstance(proxied, nodes.ClassDef)
 
+    def test_lookup_regression_slots(self) -> None:
+        """Regression test for attr__new__ of ObjectModel.
+
+        ObjectModel._instance is not always an bases.Instance, so we can't
+        rely on the ._proxied attribute of an Instance.
+        """
+
+        node = builder.extract_node(
+            """
+        class ClassHavingUnknownAncestors(Unknown):
+            __slots__ = ["yo"]
+
+            def test(self):
+                self.not_yo = 42
+        """
+        )
+        assert node.getattr("__new__")
+
 
 class SuperTests(unittest.TestCase):
     def test_inferring_super_outside_methods(self) -> None: