Refactor: Use DictExpr attribute to validate string keys, including bytes and nested unpacking

Author: Vikash-Kumar-23

mypy/checkexpr.py

@@ -5436,6 +5436,15 @@ def visit_dict_expr(self, e: DictExpr) -> Type:
                 expected_types.append(
                     self.chk.named_generic_type("_typeshed.SupportsKeysAndGetItem", [kt, vt])
                 )
+                # If this DictExpr came from a dict() call translation, validate that
+                # any unpacked dict has string keys (keywords must be strings)
+                if e.from_dict_call:
+                    value_type = self.accept(value)
+                    if not self.is_valid_keyword_var_arg(value_type):
+                        is_mapping = is_subtype(
+                            value_type, self.chk.named_type("_typeshed.SupportsKeysAndGetItem")
+                        )
+                        self.msg.invalid_keyword_var_arg(value_type, is_mapping, value)
             else:
                 tup = TupleExpr([key, value])
                 if key.line >= 0:

mypy/nodes.py

@@ -2672,15 +2672,17 @@ def accept(self, visitor: ExpressionVisitor[T]) -> T:
 class DictExpr(Expression):
     """Dictionary literal expression {key: value, ...}."""
 
-    __slots__ = ("items",)
+    __slots__ = ("items", "from_dict_call")
 
     __match_args__ = ("items",)
 
     items: list[tuple[Expression | None, Expression]]
+    from_dict_call: bool  # True if this came from a dict(...) call translation
 
     def __init__(self, items: list[tuple[Expression | None, Expression]]) -> None:
         super().__init__()
         self.items = items
+        self.from_dict_call = False
 
     def accept(self, visitor: ExpressionVisitor[T]) -> T:
         return visitor.visit_dict_expr(self)

mypy/semanal.py

@@ -6056,9 +6056,9 @@ def translate_dict_call(self, call: CallExpr) -> DictExpr | None:
         # will catch the "keywords must be strings" error.
         for kind, arg in zip(call.arg_kinds, call.args):
             if kind == ARG_STAR2 and isinstance(arg, DictExpr):
-                # Check if all keys in the dict literal are strings
+                # Check if all keys in the dict literal are strings (not bytes!)
                 for key, _ in arg.items:
-                    if key is not None and not isinstance(key, (StrExpr, BytesExpr)):
+                    if key is not None and not isinstance(key, StrExpr):
                         # Non-string key found, don't translate
                         for a in call.args:
                             a.accept(self)
@@ -6070,6 +6070,7 @@ def translate_dict_call(self, call: CallExpr) -> DictExpr | None:
             ]
         )
         expr.set_line(call)
+        expr.from_dict_call = True
         expr.accept(self)
         return expr
 

test-data/unit/check-expressions.test

@@ -2587,4 +2587,6 @@ def last_known_value() -> None:
 [case testDictUnpackNonStringKey]
 def f() -> None:
     dict(**{10: 20})  # E: Argument after ** must have string keys
+    dict(**{**{1: 1}})  # E: Argument after ** must have string keys
+    dict(**{b'a': 1})  # E: Argument after ** must have string keys
 [builtins fixtures/dict.pyi]