Fix interrupted InferenceContext call chains (#2209)

ClassDef.getitem() and infer_argument() both had
interrupted call chains where InferenceContext wasn't
passed all the way through to infer(). This caused
performance problems in packages such as sqlalchemy
needing these features.

Author: jacobtylerwalls

ChangeLog

@@ -30,6 +30,11 @@ Release date: TBA
   Closes pylint-dev/pylint#7464
   Closes pylint-dev/pylint#8074
 
+* Fix interrupted ``InferenceContext`` call chains, thereby addressing performance
+  problems when linting ``sqlalchemy``.
+
+  Closes pylint-dev/pylint#8150
+
 * ``nodes.FunctionDef`` no longer inherits from ``nodes.Lambda``.
   This is a breaking change but considered a bug fix as the nodes did not share the same
   API and were not interchangeable.

astroid/arguments.py

@@ -215,7 +215,7 @@ def infer_argument(
                     # `cls.metaclass_method`. In this case, the
                     # first argument is always the class.
                     method_scope = funcnode.parent.scope()
-                    if method_scope is boundnode.metaclass():
+                    if method_scope is boundnode.metaclass(context=context):
                         return iter((boundnode,))
 
                 if funcnode.type == "method":

astroid/interpreter/dunder_lookup.py

@@ -12,11 +12,18 @@
 As such, the lookup for the special methods is actually simpler than
 the dot attribute access.
 """
+from __future__ import annotations
+
 import itertools
+from typing import TYPE_CHECKING
 
 import astroid
 from astroid.exceptions import AttributeInferenceError
 
+if TYPE_CHECKING:
+    from astroid import nodes
+    from astroid.context import InferenceContext
+
 
 def _lookup_in_mro(node, name) -> list:
     attrs = node.locals.get(name, [])
@@ -31,7 +38,9 @@ def _lookup_in_mro(node, name) -> list:
     return values
 
 
-def lookup(node, name) -> list:
+def lookup(
+    node: nodes.NodeNG, name: str, context: InferenceContext | None = None
+) -> list:
     """Lookup the given special method name in the given *node*.
 
     If the special method was found, then a list of attributes
@@ -45,13 +54,15 @@ def lookup(node, name) -> list:
     if isinstance(node, astroid.Instance):
         return _lookup_in_mro(node, name)
     if isinstance(node, astroid.ClassDef):
-        return _class_lookup(node, name)
+        return _class_lookup(node, name, context=context)
 
     raise AttributeInferenceError(attribute=name, target=node)
 
 
-def _class_lookup(node, name) -> list:
-    metaclass = node.metaclass()
+def _class_lookup(
+    node: nodes.ClassDef, name: str, context: InferenceContext | None = None
+) -> list:
+    metaclass = node.metaclass(context=context)
     if metaclass is None:
         raise AttributeInferenceError(attribute=name, target=node)
 

astroid/nodes/scoped_nodes/scoped_nodes.py

@@ -1666,7 +1666,7 @@ def _rec_get_names(args, names: list[str] | None = None) -> list[str]:
     return names
 
 
-def _is_metaclass(klass, seen=None) -> bool:
+def _is_metaclass(klass, seen=None, context: InferenceContext | None = None) -> bool:
     """Return if the given class can be
     used as a metaclass.
     """
@@ -1676,7 +1676,7 @@ def _is_metaclass(klass, seen=None) -> bool:
         seen = set()
     for base in klass.bases:
         try:
-            for baseobj in base.infer():
+            for baseobj in base.infer(context=context):
                 baseobj_name = baseobj.qname()
                 if baseobj_name in seen:
                     continue
@@ -1691,21 +1691,21 @@ def _is_metaclass(klass, seen=None) -> bool:
                     continue
                 if baseobj._type == "metaclass":
                     return True
-                if _is_metaclass(baseobj, seen):
+                if _is_metaclass(baseobj, seen, context=context):
                     return True
         except InferenceError:
             continue
     return False
 
 
-def _class_type(klass, ancestors=None):
+def _class_type(klass, ancestors=None, context: InferenceContext | None = None):
     """return a ClassDef node type to differ metaclass and exception
     from 'regular' classes
     """
     # XXX we have to store ancestors in case we have an ancestor loop
     if klass._type is not None:
         return klass._type
-    if _is_metaclass(klass):
+    if _is_metaclass(klass, context=context):
         klass._type = "metaclass"
     elif klass.name.endswith("Exception"):
         klass._type = "exception"
@@ -2502,7 +2502,7 @@ def getitem(self, index, context: InferenceContext | None = None):
             ``__getitem__`` method.
         """
         try:
-            methods = lookup(self, "__getitem__")
+            methods = lookup(self, "__getitem__", context=context)
         except AttributeInferenceError as exc:
             if isinstance(self, ClassDef):
                 # subscripting a class definition may be

tests/test_inference.py

@@ -4235,7 +4235,7 @@ class Clazz(metaclass=_Meta):
         Clazz() #@
         """
         ).inferred()[0]
-        assert isinstance(cls, nodes.ClassDef) and cls.name == "Clazz"
+        assert isinstance(cls, Instance) and cls.name == "Clazz"
 
     def test_infer_subclass_attr_outer_class(self) -> None:
         node = extract_node(
@@ -4908,6 +4908,21 @@ def __class_getitem__(cls, *args, **kwargs):
         self.assertIsInstance(inferred, nodes.ClassDef)
         self.assertEqual(inferred.name, "Foo")
 
+    def test_class_subscript_inference_context(self) -> None:
+        """Context path has a reference to any parents inferred by getitem()."""
+        code = """
+        class Parent: pass
+
+        class A(Parent):
+            def __class_getitem__(self, value):
+                return cls
+        """
+        klass = extract_node(code)
+        context = InferenceContext()
+        _ = klass.getitem(0, context=context)
+
+        assert list(context.path)[0][0].name == "Parent"
+
 
 class TestType(unittest.TestCase):
     def test_type(self) -> None: