Fixes mypy crash on dataclasses.field(**unpack)

mypy/plugins/dataclasses.py

@@ -460,7 +460,11 @@ def _collect_field_args(expr: Expression) -> Tuple[bool, Dict[str, Expression]]:
         # field() only takes keyword arguments.
         args = {}
         for name, arg in zip(expr.arg_names, expr.args):
-            assert name is not None
+            if name is None:
+                # This means that `field` is used with `**` unpacking,
+                # the best we can do for now is not to fail.
+                # TODO: we can infer what's inside `**` and try to collect it.
+                return True, {}
             args[name] = arg
         return True, args
     return False, {}

test-data/unit/check-dataclasses.test

@@ -1300,3 +1300,38 @@ a.x = x
 a.x = x2 # E: Incompatible types in assignment (expression has type "Callable[[str], str]", variable has type "Callable[[int], int]")
 
 [builtins fixtures/dataclasses.pyi]
+
+
+[case testDataclassFieldDoesNotFailOnKwargsUnpacking]
+# flags: --python-version 3.7
+# https://github.com/python/mypy/issues/10879
+from dataclasses import dataclass, field
+
+@dataclass
+class Foo:
+    bar: float = field(**{"repr": False})
+[out]
+main:7: error: No overload variant of "field" matches argument type "Dict[str, bool]"
+main:7: note: Possible overload variants:
+main:7: note:     def [_T] field(*, default: _T, init: bool = ..., repr: bool = ..., hash: Optional[bool] = ..., compare: bool = ..., metadata: Optional[Mapping[str, Any]] = ..., kw_only: bool = ...) -> _T
+main:7: note:     def [_T] field(*, default_factory: Callable[[], _T], init: bool = ..., repr: bool = ..., hash: Optional[bool] = ..., compare: bool = ..., metadata: Optional[Mapping[str, Any]] = ..., kw_only: bool = ...) -> _T
+main:7: note:     def field(*, init: bool = ..., repr: bool = ..., hash: Optional[bool] = ..., compare: bool = ..., metadata: Optional[Mapping[str, Any]] = ..., kw_only: bool = ...) -> Any
+[builtins fixtures/dataclasses.pyi]
+
+
+[case testDataclassFieldWithTypedDictUnpacking]
+# flags: --python-version 3.7
+from dataclasses import dataclass, field
+from typing_extensions import TypedDict
+
+class FieldKwargs(TypedDict):
+    repr: bool
+
+field_kwargs: FieldKwargs = {"repr": False}
+
+@dataclass
+class Foo:
+    bar: float = field(**field_kwargs)
+
+reveal_type(Foo(bar=1.5))  # N: Revealed type is "__main__.Foo"
+[builtins fixtures/dataclasses.pyi]

test-data/unit/fixtures/dataclasses.pyi

@@ -1,7 +1,12 @@
-from typing import Generic, Sequence, TypeVar
+from typing import (
+    Generic, Iterator, Iterable, Mapping, Optional, Sequence, Tuple,
+    TypeVar, Union, overload,
+)
 
 _T = TypeVar('_T')
 _U = TypeVar('_U')
+KT = TypeVar('KT')
+VT = TypeVar('VT')
 
 class object:
     def __init__(self) -> None: pass
@@ -15,7 +20,23 @@ class int: pass
 class float: pass
 class str: pass
 class bool(int): pass
-class dict(Generic[_T, _U]): pass
+
+class dict(Mapping[KT, VT]):
+    @overload
+    def __init__(self, **kwargs: VT) -> None: pass
+    @overload
+    def __init__(self, arg: Iterable[Tuple[KT, VT]], **kwargs: VT) -> None: pass
+    def __getitem__(self, key: KT) -> VT: pass
+    def __setitem__(self, k: KT, v: VT) -> None: pass
+    def __iter__(self) -> Iterator[KT]: pass
+    def __contains__(self, item: object) -> int: pass
+    def update(self, a: Mapping[KT, VT]) -> None: pass
+    @overload
+    def get(self, k: KT) -> Optional[VT]: pass
+    @overload
+    def get(self, k: KT, default: Union[KT, _T]) -> Union[VT, _T]: pass
+    def __len__(self) -> int: ...
+
 class list(Generic[_T], Sequence[_T]): pass
 class function: pass
 class classmethod: pass