do not mangle TypedDict keywords

Author: tyralla

mypy/fastparse.py

@@ -359,20 +359,24 @@ def find_disallowed_expression_in_annotation_scope(expr: ast3.expr | None) -> as
 class NameMangler(ast3.NodeTransformer):
     """Mangle (nearly) all private identifiers within a class body (including nested classes)."""
 
+    mangled2unmangled: dict[str, str]
     _classname_complete: str
     _classname_trimmed: str
     _mangle_annotations: bool
     _unmangled_args: set[str]
 
     def __init__(self, classname: str, mangle_annotations: bool) -> None:
+        self.mangled2unmangled = {}
         self._classname_complete = classname
         self._classname_trimmed = classname.lstrip("_")
         self._mangle_annotations = mangle_annotations
         self._unmangled_args = set()
 
     def _mangle_name(self, name: str) -> str:
         if name.startswith("__") and not name.endswith("__"):
-            return f"_{self._classname_trimmed}{name}"
+            mangled = f"_{self._classname_trimmed}{name}"
+            self.mangled2unmangled[mangled] = name
+            return mangled
         return name
 
     def _mangle_slots(self, node: ast3.ClassDef) -> None:
@@ -1234,7 +1238,8 @@ def visit_ClassDef(self, n: ast3.ClassDef) -> ClassDef:
             and any(j[0] == "annotations" for j in i.names)
             for i in self.imports
         )
-        NameMangler(n.name, mangle_annotations).visit(n)
+        mangler = NameMangler(n.name, mangle_annotations)
+        mangler.visit(n)
 
         cdef = ClassDef(
             n.name,
@@ -1244,6 +1249,7 @@ def visit_ClassDef(self, n: ast3.ClassDef) -> ClassDef:
             metaclass=dict(keywords).get("metaclass"),
             keywords=keywords,
             type_args=explicit_type_params,
+            mangled2unmangled=mangler.mangled2unmangled,
         )
         cdef.decorators = self.translate_expr_list(n.decorator_list)
         self.set_line(cdef, n)

mypy/nodes.py

@@ -1136,6 +1136,7 @@ class ClassDef(Statement):
         "has_incompatible_baseclass",
         "docstring",
         "removed_statements",
+        "mangled2unmangled",
     )
 
     __match_args__ = ("name", "defs")
@@ -1159,6 +1160,7 @@ class ClassDef(Statement):
     has_incompatible_baseclass: bool
     # Used by special forms like NamedTuple and TypedDict to store invalid statements
     removed_statements: list[Statement]
+    mangled2unmangled: Final[dict[str, str]]
 
     def __init__(
         self,
@@ -1169,6 +1171,7 @@ def __init__(
         metaclass: Expression | None = None,
         keywords: list[tuple[str, Expression]] | None = None,
         type_args: list[TypeParam] | None = None,
+        mangled2unmangled: dict[str, str] | None = None,
     ) -> None:
         super().__init__()
         self.name = name
@@ -1186,6 +1189,7 @@ def __init__(
         self.has_incompatible_baseclass = False
         self.docstring: str | None = None
         self.removed_statements = []
+        self.mangled2unmangled = mangled2unmangled or {}
 
     @property
     def fullname(self) -> str:

mypy/semanal_typeddict.py

@@ -325,6 +325,7 @@ def analyze_typeddict_classdef_fields(
                 self.fail(TPDICT_CLASS_ERROR, stmt)
             else:
                 name = stmt.lvalues[0].name
+                name = defn.mangled2unmangled.get(name, name)
                 if name in (oldfields or []):
                     self.fail(f'Overwriting TypedDict field "{name}" while extending', stmt)
                 if name in fields:

test-data/unit/check-mangling.test

@@ -275,3 +275,74 @@ class G(A):
 G().__x = 1  # E: "G" has no attribute "__x"
 G()._G__x = 1
 [builtins fixtures/dict.pyi]
+
+[case testNameManglingTypedDictBasics]
+from typing import TypedDict
+
+class A(TypedDict):
+    __a: int
+
+a: A
+reveal_type(a)  # N: Revealed type is "TypedDict('__main__.A', {'__a': builtins.int})"
+reveal_type(a["__a"])  # N: Revealed type is "builtins.int"
+a = {"__a": 1}
+a = {"_A__a": 1}  # E: Missing key "__a" for TypedDict "A" \
+                  # E: Extra key "_A__a" for TypedDict "A"
+
+class B(A):
+    __b: int
+
+b: B
+reveal_type(b)  # N: Revealed type is "TypedDict('__main__.B', {'__a': builtins.int, '__b': builtins.int})"
+reveal_type(b["__a"] + b["__b"])  # N: Revealed type is "builtins.int"
+b = {"__a": 1, "__b": 2}
+b = {"_A__a": 1, "_B__b": 2}  # E: Missing keys ("__a", "__b") for TypedDict "B" \
+                              # E: Extra keys ("_A__a", "_B__b") for TypedDict "B"
+
+class C(TypedDict):
+    __c: int
+
+class D(B, C):
+    pass
+
+d: D
+reveal_type(d)  # N: Revealed type is "TypedDict('__main__.D', {'__c': builtins.int, '__a': builtins.int, '__b': builtins.int})"
+reveal_type(d["__a"] + d["__b"] + d["__c"])  # N: Revealed type is "builtins.int"
+d = {"__a": 1, "__b": 2, "__c": 3}
+d = {"_A__a": 1, "_B__b": 2, "_C__c": 3}  # E: Missing keys ("__c", "__a", "__b") for TypedDict "D" \
+                                          # E: Extra keys ("_A__a", "_B__b", "_C__c") for TypedDict "D"
+
+class E(D):
+    __a: int  # E: Overwriting TypedDict field "__a" while extending
+    __b: int  # E: Overwriting TypedDict field "__b" while extending
+    __c: int  # E: Overwriting TypedDict field "__c" while extending
+
+[typing fixtures/typing-typeddict.pyi]
+
+[case testNameManglingTypedDictNotTotal]
+from typing import TypedDict
+
+class A(TypedDict, total=False):
+    __a: int
+
+a: A
+reveal_type(a)  # N: Revealed type is "TypedDict('__main__.A', {'__a'?: builtins.int})"
+reveal_type(a["__a"])  # N: Revealed type is "builtins.int"
+a = {"__a": 1}
+a = {"_A__a": 1}  # E: Extra key "_A__a" for TypedDict "A"
+
+[typing fixtures/typing-typeddict.pyi]
+
+[case testNameManglingTypedDictAlternativeSyntax]
+from typing import TypedDict
+
+A = TypedDict("A", {"__a": int})
+
+a: A
+reveal_type(a)  # N: Revealed type is "TypedDict('__main__.A', {'__a': builtins.int})"
+reveal_type(a["__a"])  # N: Revealed type is "builtins.int"
+a = {"__a": 1}
+a = {"_A__a": 1}  # E: Missing key "__a" for TypedDict "A" \
+                  # E: Extra key "_A__a" for TypedDict "A"
+
+[typing fixtures/typing-typeddict.pyi]