Refactor: utilize standard CallExpr validation by aborting translation in semanal.py

Author: Vikash-Kumar-23

mypy/checkexpr.py

@@ -5432,17 +5432,6 @@ def visit_dict_expr(self, e: DictExpr) -> Type:
         expected_types: list[Type] = []
         for key, value in e.items:
             if key is None:
-                # This is a **expr unpacking.
-                # If this DictExpr came from a dict() call, we need to check that
-                # the expression has string keys (since dict() uses keyword args).
-                # For plain dict literals like {**mapping}, non-string keys are valid.
-                if e.from_dict_call:
-                    value_type = get_proper_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)
                 args.append(value)
                 expected_types.append(
                     self.chk.named_generic_type("_typeshed.SupportsKeysAndGetItem", [kt, vt])

mypy/nodes.py

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

mypy/semanal.py

@@ -6051,12 +6051,23 @@ def translate_dict_call(self, call: CallExpr) -> DictExpr | None:
             for a in call.args:
                 a.accept(self)
             return None
+        # Check if any **kwargs argument is a dict literal with non-string keys.
+        # In that case, don't translate so that normal function call type checking
+        # 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
+                for key, _ in arg.items:
+                    if key is not None and not isinstance(key, (StrExpr, BytesExpr)):
+                        # Non-string key found, don't translate
+                        for a in call.args:
+                            a.accept(self)
+                        return None
         expr = DictExpr(
             [
                 (StrExpr(key) if key is not None else None, value)
                 for key, value in zip(call.arg_names, call.args)
-            ],
-            from_dict_call=True,
+            ]
         )
         expr.set_line(call)
         expr.accept(self)