Merge branch 'argkinds' of https://github.com/BobTheBuidler/mypy into argkinds

Author: BobTheBuidler

mypy/nodes.py

@@ -6,9 +6,9 @@
 import os
 from abc import abstractmethod
 from collections import defaultdict
-from collections.abc import Iterator, Sequence
+from collections.abc import Iterable, Iterator, Sequence
 from enum import Enum, unique
-from typing import TYPE_CHECKING, Any, Callable, Final, Iterable, Optional, TypeVar, Union, cast
+from typing import TYPE_CHECKING, Any, Callable, Final, Optional, TypeVar, Union, cast
 from typing_extensions import TypeAlias as _TypeAlias, TypeGuard
 
 from mypy_extensions import mypyc_attr, trait
@@ -2210,29 +2210,38 @@ def is_star(self) -> bool:
 @mypyc_attr(native_class=False)
 class ArgKinds(list[ArgKind]):
     def __init__(self, values: Iterable[ArgKind] = None) -> None:
-        self._count_cache: dict[ArgKind, int] = {}
-        self._index_cache: dict[ArgKind, int] = {}
+        self.__count_cache: dict[ArgKind, int] = {}
+        self.__index_cache: dict[ArgKind, int] = {}
+
     @property
     def positional_only(self) -> bool:
         return all(kind == ARG_POS for kind in self)
+
     @property
     def has_star(self) -> bool:
         return ARG_STAR in self
+
     @property
     def has_star2(self) -> bool:
         return ARG_STAR2 in self
+
     @property
     def has_any_star(self) -> bool:
         return any(kind.is_star() for kind in self)
+
+    def copy(self) -> ArgKinds:
+        return ArgKinds(kind for kind in self)
+
     def count(self, kind: ArgKind) -> int:
-        count = self._count_cache.get(kind)
+        count = self.__count_cache.get(kind)
         if count is None:
-            count = self._count_cache[kind] = super().count(kind)
+            count = self.__count_cache[kind] = super().count(kind)
         return count
+
     def index(self, kind: ArgKind) -> int:
-        index = self._index_cache.get(kind)
+        index = self.__index_cache.get(kind)
         if index is None:
-            index = self._index_cache[kind] = super().index(kind)
+            index = self.__index_cache[kind] = super().index(kind)
         return index
 
 
@@ -4827,9 +4836,7 @@ def get_member_expr_fullname(expr: MemberExpr) -> str | None:
 }
 
 
-def check_arg_kinds(
-    arg_kinds: ArgKinds, nodes: list[T], fail: Callable[[str, T], None]
-) -> None:
+def check_arg_kinds(arg_kinds: ArgKinds, nodes: list[T], fail: Callable[[str, T], None]) -> None:
     is_var_arg = False
     is_kw_arg = False
     seen_named = False

mypy/test/testinfer.py

@@ -5,7 +5,16 @@
 from mypy.argmap import map_actuals_to_formals
 from mypy.checker import DisjointDict, group_comparison_operands
 from mypy.literals import Key
-from mypy.nodes import ARG_NAMED, ARG_OPT, ARG_POS, ARG_STAR, ARG_STAR2, ArgKind, ArgKinds, NameExpr
+from mypy.nodes import (
+    ARG_NAMED,
+    ARG_OPT,
+    ARG_POS,
+    ARG_STAR,
+    ARG_STAR2,
+    ArgKind,
+    ArgKinds,
+    NameExpr,
+)
 from mypy.test.helpers import Suite, assert_equal
 from mypy.test.typefixture import TypeFixture
 from mypy.types import AnyType, TupleType, Type, TypeOfAny
@@ -118,9 +127,7 @@ def assert_vararg_map(
         assert_equal(result, expected)
 
 
-def expand_caller_kinds(
-    kinds_or_names: list[ArgKind | str],
-) -> tuple[ArgKinds, list[str | None]]:
+def expand_caller_kinds(kinds_or_names: list[ArgKind | str]) -> tuple[ArgKinds, list[str | None]]:
     kinds = []
     names: list[str | None] = []
     for k in kinds_or_names:

mypy/types.py

@@ -32,7 +32,16 @@
     write_str_opt_list,
     write_tag,
 )
-from mypy.nodes import ARG_KINDS, ARG_POS, ARG_STAR, ARG_STAR2, INVARIANT, ArgKind, ArgKinds, SymbolNode
+from mypy.nodes import (
+    ARG_KINDS,
+    ARG_POS,
+    ARG_STAR,
+    ARG_STAR2,
+    INVARIANT,
+    ArgKind,
+    ArgKinds,
+    SymbolNode,
+)
 from mypy.options import Options
 from mypy.state import state
 from mypy.util import IdMapper

mypyc/irbuild/function.py

@@ -693,9 +693,7 @@ def f(builder: IRBuilder, x: object) -> int: ...
 
     # We can do a passthrough *args/**kwargs with a native call, but if the
     # args need to get distributed out to arguments, we just let python handle it
-    if arg_kinds.has_any_star and any(
-        not arg.kind.is_star() for arg in target.decl.sig.args
-    ):
+    if arg_kinds.has_any_star and any(not arg.kind.is_star() for arg in target.decl.sig.args):
         do_pycall = True
 
     if do_pycall: