[Backport maintenance/4.1.x] Prevent Unknown from leaking via special attribute lookup (#2973)

Prevent Unknown from leaking via special attribute lookup (#2963)


(cherry picked from commit ffbdccf)

Signed-off-by: Emmanuel Ferdman <emmanuelferdman@gmail.com>
Co-authored-by: Emmanuel Ferdman <emmanuelferdman@gmail.com>

Author: pylint-backport[bot]

ChangeLog

@@ -16,6 +16,9 @@ Release date: TBA
 * Let `UnboundMethodModel` inherit from `FunctionModel` to improve inference of
   dunder methods for unbound methods.
 
+* Filter ``Unknown`` from ``UnboundMethod`` and ``Super`` special attribute
+  lookup to prevent placeholder nodes from leaking during inference.
+
 What's New in astroid 4.1.0?
 ============================
 Release date: 2026-02-08

astroid/bases.py

@@ -462,14 +462,18 @@ def is_bound(self) -> bool:
 
     def getattr(self, name: str, context: InferenceContext | None = None):
         if name in self.special_attributes:
-            return [self.special_attributes.lookup(name)]
+            special_attr = self.special_attributes.lookup(name)
+            if not isinstance(special_attr, nodes.Unknown):
+                return [special_attr]
         return self._proxied.getattr(name, context)
 
     def igetattr(
         self, name: str, context: InferenceContext | None = None
     ) -> Iterator[InferenceResult]:
         if name in self.special_attributes:
-            return iter((self.special_attributes.lookup(name),))
+            special_attr = self.special_attributes.lookup(name)
+            if not isinstance(special_attr, nodes.Unknown):
+                return iter((special_attr,))
         return self._proxied.igetattr(name, context)
 
     def infer_call_result(

astroid/objects.py

@@ -222,8 +222,10 @@ def igetattr(  # noqa: C901
         # Only if we haven't found any explicit overwrites for the
         # attribute we look it up in the special attributes
         if not found and name in self.special_attributes:
-            yield self.special_attributes.lookup(name)
-            return
+            special_attr = self.special_attributes.lookup(name)
+            if not isinstance(special_attr, node_classes.Unknown):
+                yield special_attr
+                return
 
         if not found:
             raise AttributeInferenceError(target=self, attribute=name, context=context)

tests/test_object_model.py

@@ -948,3 +948,53 @@ def test_hash_none_for_unhashable_builtins() -> None:
         hash_attr = cls.getattr("__hash__")[0]
         assert isinstance(hash_attr, nodes.Const)
         assert hash_attr.value is None
+
+
+def test_unbound_method_object_dunders_return_uninferable() -> None:
+    """Test that ObjectModel-only dunders on unbound methods return Uninferable."""
+    node = builder.extract_node("""
+    class A:
+        def test(self): pass
+    A.test  #@
+    """)
+    unbound = next(node.infer())
+    assert isinstance(unbound, bases.UnboundMethod)
+
+    for dunder in (
+        "__eq__",
+        "__ne__",
+        "__lt__",
+        "__le__",
+        "__gt__",
+        "__ge__",
+        "__repr__",
+        "__str__",
+        "__hash__",
+    ):
+        inferred = next(unbound.igetattr(dunder))
+        assert inferred is util.Uninferable, f"{dunder} should be Uninferable"
+
+        attrs = unbound.getattr(dunder)
+        assert attrs, f"{dunder} getattr should return results"
+
+
+def test_super_special_attributes_fallback() -> None:
+    """Test that super() special attributes use the fallback path correctly."""
+    doc_node = builder.extract_node("""
+    class Base:
+        def method(self):
+            return super().__doc__
+    Base().method()  #@
+    """)
+    doc_inferred = next(doc_node.infer())
+    assert doc_inferred is util.Uninferable
+
+    thisclass_node = builder.extract_node("""
+    class Base:
+        def method(self):
+            return super().__thisclass__
+    Base().method()  #@
+    """)
+    thisclass_inferred = next(thisclass_node.infer())
+    assert isinstance(thisclass_inferred, nodes.ClassDef)
+    assert thisclass_inferred.name == "Base"