Improve typing of builtins brain (#2214)

Resolves 14 mypy errors

Author: jacobtylerwalls

astroid/arguments.py

@@ -86,7 +86,11 @@ def has_invalid_keywords(self) -> bool:
         """
         return len(self.keyword_arguments) != len(self._unpacked_kwargs)
 
-    def _unpack_keywords(self, keywords, context: InferenceContext | None = None):
+    def _unpack_keywords(
+        self,
+        keywords: list[tuple[str | None, nodes.NodeNG]],
+        context: InferenceContext | None = None,
+    ):
         values = {}
         context = context or InferenceContext()
         context.extra_context = self.argument_context_map

astroid/brain/brain_builtin_inference.py

@@ -7,11 +7,11 @@
 from __future__ import annotations
 
 import itertools
-from collections.abc import Callable, Iterable, Iterator
+from collections.abc import Callable, Iterator
 from functools import partial
-from typing import Any
+from typing import Any, Type, Union, cast
 
-from astroid import arguments, bases, helpers, inference_tip, nodes, objects, util
+from astroid import arguments, helpers, inference_tip, nodes, objects, util
 from astroid.builder import AstroidBuilder
 from astroid.context import InferenceContext
 from astroid.exceptions import (
@@ -23,7 +23,25 @@
 )
 from astroid.manager import AstroidManager
 from astroid.nodes import scoped_nodes
-from astroid.typing import InferenceResult, SuccessfulInferenceResult
+from astroid.typing import (
+    ConstFactoryResult,
+    InferenceResult,
+    SuccessfulInferenceResult,
+)
+
+ContainerObjects = Union[
+    objects.FrozenSet,
+    objects.DictItems,
+    objects.DictKeys,
+    objects.DictValues,
+]
+
+BuiltContainers = Union[
+    Type[tuple],
+    Type[list],
+    Type[set],
+    Type[frozenset],
+]
 
 OBJECT_DUNDER_NEW = "object.__new__"
 
@@ -232,18 +250,19 @@ def _container_generic_inference(
     return transformed
 
 
-def _container_generic_transform(  # pylint: disable=inconsistent-return-statements
+def _container_generic_transform(
     arg: SuccessfulInferenceResult,
     context: InferenceContext | None,
     klass: type[nodes.BaseContainer],
-    iterables: tuple[type[nodes.NodeNG] | type[bases.Proxy], ...],
-    build_elts: type[Iterable[Any]],
+    iterables: tuple[type[nodes.BaseContainer] | type[ContainerObjects], ...],
+    build_elts: BuiltContainers,
 ) -> nodes.BaseContainer | None:
     if isinstance(arg, klass):
         return arg
     if isinstance(arg, iterables):
+        arg = cast(ContainerObjects, arg)
         if all(isinstance(elt, nodes.Const) for elt in arg.elts):
-            elts = [elt.value for elt in arg.elts]
+            elts = [cast(nodes.Const, elt).value for elt in arg.elts]
         else:
             # TODO: Does not handle deduplication for sets.
             elts = []
@@ -264,16 +283,16 @@ def _container_generic_transform(  # pylint: disable=inconsistent-return-stateme
     elif isinstance(arg, nodes.Const) and isinstance(arg.value, (str, bytes)):
         elts = arg.value
     else:
-        return
+        return None
     return klass.from_elements(elts=build_elts(elts))
 
 
 def _infer_builtin_container(
     node: nodes.Call,
     context: InferenceContext | None,
     klass: type[nodes.BaseContainer],
-    iterables: tuple[type[nodes.NodeNG] | type[bases.Proxy], ...],
-    build_elts: type[Iterable[Any]],
+    iterables: tuple[type[nodes.NodeNG] | type[ContainerObjects], ...],
+    build_elts: BuiltContainers,
 ) -> nodes.BaseContainer:
     transform_func = partial(
         _container_generic_transform,
@@ -944,8 +963,8 @@ def _build_dict_with_elements(elements):
 
 
 def _infer_copy_method(
-    node: nodes.Call, context: InferenceContext | None = None
-) -> Iterator[nodes.NodeNG]:
+    node: nodes.Call, context: InferenceContext | None = None, **kwargs: Any
+) -> Iterator[InferenceResult]:
     assert isinstance(node.func, nodes.Attribute)
     inferred_orig, inferred_copy = itertools.tee(node.func.expr.infer(context=context))
     if all(
@@ -973,33 +992,44 @@ def _is_str_format_call(node: nodes.Call) -> bool:
 
 
 def _infer_str_format_call(
-    node: nodes.Call, context: InferenceContext | None = None
-) -> Iterator[nodes.Const | util.UninferableBase]:
+    node: nodes.Call, context: InferenceContext | None = None, **kwargs: Any
+) -> Iterator[ConstFactoryResult | util.UninferableBase]:
     """Return a Const node based on the template and passed arguments."""
     call = arguments.CallSite.from_call(node, context=context)
+    assert isinstance(node.func, (nodes.Attribute, nodes.AssignAttr, nodes.DelAttr))
+
+    value: nodes.Const
     if isinstance(node.func.expr, nodes.Name):
-        value: nodes.Const | None = helpers.safe_infer(node.func.expr)
-        if value is None:
+        if not (inferred := helpers.safe_infer(node.func.expr)) or not isinstance(
+            inferred, nodes.Const
+        ):
             return iter([util.Uninferable])
-    else:
+        value = inferred
+    elif isinstance(node.func.expr, nodes.Const):
         value = node.func.expr
+    else:  # pragma: no cover
+        return iter([util.Uninferable])
 
     format_template = value.value
 
     # Get the positional arguments passed
-    inferred_positional = [
-        helpers.safe_infer(i, context) for i in call.positional_arguments
-    ]
-    if not all(isinstance(i, nodes.Const) for i in inferred_positional):
-        return iter([util.Uninferable])
+    inferred_positional: list[nodes.Const] = []
+    for i in call.positional_arguments:
+        one_inferred = helpers.safe_infer(i, context)
+        if not isinstance(one_inferred, nodes.Const):
+            return iter([util.Uninferable])
+        inferred_positional.append(one_inferred)
+
     pos_values: list[str] = [i.value for i in inferred_positional]
 
     # Get the keyword arguments passed
-    inferred_keyword = {
-        k: helpers.safe_infer(v, context) for k, v in call.keyword_arguments.items()
-    }
-    if not all(isinstance(i, nodes.Const) for i in inferred_keyword.values()):
-        return iter([util.Uninferable])
+    inferred_keyword: dict[str, nodes.Const] = {}
+    for k, v in call.keyword_arguments.items():
+        one_inferred = helpers.safe_infer(v, context)
+        if not isinstance(one_inferred, nodes.Const):
+            return iter([util.Uninferable])
+        inferred_keyword[k] = one_inferred
+
     keyword_values: dict[str, str] = {k: v.value for k, v in inferred_keyword.items()}
 
     try: