Infer instances of builtins created by __new__() (#1590)

Author: jacobtylerwalls

ChangeLog

@@ -47,6 +47,8 @@ Release date: TBA
 
   Refs PyCQA/pylint#5113
 
+* Instances of builtins created with ``__new__(cls, value)`` are now inferred.
+
 * Infer the return value of the ``.copy()`` method on ``dict``, ``list``, ``set``,
   and ``frozenset``.
 

astroid/bases.py

@@ -5,8 +5,11 @@
 """This module contains base classes and functions for the nodes and some
 inference utils.
 """
+from __future__ import annotations
 
 import collections
+import collections.abc
+from typing import TYPE_CHECKING
 
 from astroid import decorators
 from astroid.const import PY310_PLUS
@@ -28,6 +31,9 @@
 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__"
@@ -372,25 +378,50 @@ def infer_call_result(self, caller, context):
         on ``object.__new__`` will be of type ``object``,
         which is incorrect for the argument in general.
         If no context is given the ``object.__new__`` call argument will
-        correctly inferred except when inside a call that requires
+        be correctly inferred except when inside a call that requires
         the additional context (such as a classmethod) of the boundnode
         to determine which class the method was called from
         """
 
-        # If we're unbound method __new__ of builtin object, the result is an
+        # If we're unbound method __new__ of a builtin, the result is an
         # instance of the class given as first argument.
-        if (
-            self._proxied.name == "__new__"
-            and self._proxied.parent.frame(future=True).qname() == "builtins.object"
-        ):
-            if caller.args:
-                node_context = context.extra_context.get(caller.args[0])
-                infer = caller.args[0].infer(context=node_context)
-            else:
-                infer = []
-            return (Instance(x) if x is not Uninferable else x for x in infer)
+        if self._proxied.name == "__new__":
+            qname = self._proxied.parent.frame(future=True).qname()
+            # Avoid checking builtins.type: _infer_type_new_call() does more validation
+            if qname.startswith("builtins.") and qname != "builtins.type":
+                return self._infer_builtin_new(caller, context)
         return self._proxied.infer_call_result(caller, context)
 
+    def _infer_builtin_new(
+        self,
+        caller: nodes.Call,
+        context: InferenceContext,
+    ) -> 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
+        if len(caller.args) > 1:
+            value = None
+            if isinstance(caller.args[1], nodes.Const):
+                value = caller.args[1].value
+            else:
+                inferred_arg = next(caller.args[1].infer(), None)
+                if isinstance(inferred_arg, nodes.Const):
+                    value = inferred_arg.value
+            if value is not None:
+                yield nodes.const_factory(value)
+                return
+
+        node_context = context.extra_context.get(caller.args[0])
+        infer = caller.args[0].infer(context=node_context)
+
+        yield from (Instance(x) if x is not Uninferable else x for x in infer)
+
     def bool_value(self, context=None):
         return True
 

tests/unittest_inference.py

@@ -3768,6 +3768,33 @@ class MetaBook(type):
         ]
         self.assertEqual(titles, ["Catch 22", "Ubik", "Grimus"])
 
+    @staticmethod
+    def test_builtin_new() -> None:
+        ast_node = extract_node("int.__new__(int, 42)")
+        inferred = next(ast_node.infer())
+        assert isinstance(inferred, nodes.Const)
+        assert inferred.value == 42
+
+        ast_node2 = extract_node("int.__new__(int)")
+        inferred2 = next(ast_node2.infer())
+        assert isinstance(inferred2, Instance)
+        assert not isinstance(inferred2, nodes.Const)
+        assert inferred2._proxied is inferred._proxied
+
+        ast_node3 = extract_node(
+            """
+        x = 43
+        int.__new__(int, x)  #@
+        """
+        )
+        inferred3 = next(ast_node3.infer())
+        assert isinstance(inferred3, nodes.Const)
+        assert inferred3.value == 43
+
+        ast_node4 = extract_node("int.__new__()")
+        with pytest.raises(InferenceError):
+            next(ast_node4.infer())
+
     @pytest.mark.xfail(reason="Does not support function metaclasses")
     def test_function_metaclasses(self):
         # These are not supported right now, although