Fix order of attribute look ups for Super (#1686)

Author: DanielNoord

astroid/objects.py

@@ -135,10 +135,11 @@ def name(self):
     def qname(self):
         return "super"
 
-    def igetattr(self, name, context=None):
+    def igetattr(self, name: str, context: InferenceContext | None = None):
         """Retrieve the inferred values of the given attribute name."""
-
-        if name in self.special_attributes:
+        # '__class__' is a special attribute that should be taken directly
+        # from the special attributes dict
+        if name == "__class__":
             yield self.special_attributes.lookup(name)
             return
 
@@ -205,6 +206,12 @@ def igetattr(self, name, context=None):
                 else:
                     yield bases.BoundMethod(inferred, cls)
 
+        # 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
+
         if not found:
             raise AttributeInferenceError(target=self, attribute=name, context=context)
 

tests/unittest_inference.py

@@ -3808,6 +3808,50 @@ class A:  pass
         with pytest.raises(InferenceError):
             next(ast_node5.infer())
 
+        ast_nodes6 = extract_node(
+            """
+        class A:  pass
+        class B(A):  pass
+        class C: pass
+        A.__new__(A)  #@
+        A.__new__(B)  #@
+        B.__new__(A)  #@
+        B.__new__(B)  #@
+        C.__new__(A)  #@
+        """
+        )
+        instance_A1 = next(ast_nodes6[0].infer())
+        assert instance_A1._proxied.name == "A"
+        instance_B1 = next(ast_nodes6[1].infer())
+        assert instance_B1._proxied.name == "B"
+        instance_A2 = next(ast_nodes6[2].infer())
+        assert instance_A2._proxied.name == "A"
+        instance_B2 = next(ast_nodes6[3].infer())
+        assert instance_B2._proxied.name == "B"
+        instance_A3 = next(ast_nodes6[4].infer())
+        assert instance_A3._proxied.name == "A"
+
+        ast_nodes7 = extract_node(
+            """
+        import enum
+        class A(enum.EnumMeta): pass
+        class B(enum.EnumMeta):
+            def __new__(mcs, value, **kwargs):
+                return super().__new__(mcs, "str", (enum.Enum,), enum._EnumDict(), **kwargs)
+        class C(enum.EnumMeta):
+            def __new__(mcs, **kwargs):
+                return super().__new__(A, "str", (enum.Enum,), enum._EnumDict(), **kwargs)
+        B("")  #@
+        C()  #@
+        """
+        )
+        instance_B = next(ast_nodes7[0].infer())
+        assert instance_B._proxied.name == "B"
+        instance_C = next(ast_nodes7[1].infer())
+        # TODO: This should be A. However, we don't infer EnumMeta.__new__
+        # correctly.
+        assert instance_C._proxied.name == "C"
+
     @pytest.mark.xfail(reason="Does not support function metaclasses")
     def test_function_metaclasses(self):
         # These are not supported right now, although

tests/unittest_objects.py

@@ -6,7 +6,7 @@
 
 import unittest
 
-from astroid import bases, builder, nodes, objects
+from astroid import bases, builder, nodes, objects, util
 from astroid.exceptions import AttributeInferenceError, InferenceError, SuperError
 from astroid.objects import Super
 
@@ -552,6 +552,22 @@ def foo(self): return super()
         super_obj = next(builder.extract_node(code).infer())
         self.assertEqual(super_obj.qname(), "super")
 
+    def test_super_new_call(self) -> None:
+        """Test that __new__ returns an object or node and not a (Un)BoundMethod."""
+        new_call_result: nodes.Name = builder.extract_node(
+            """
+        import enum
+        class ChoicesMeta(enum.EnumMeta):
+            def __new__(metacls, classname, bases, classdict, **kwds):
+                cls = super().__new__(metacls, "str", (enum.Enum,), enum._EnumDict(), **kwargs)
+                cls #@
+        """
+        )
+        inferred = list(new_call_result.infer())
+        assert all(
+            isinstance(i, (nodes.NodeNG, type(util.Uninferable))) for i in inferred
+        )
+
 
 if __name__ == "__main__":
     unittest.main()