Stop TypedDictAnalyzer from leaking synthetic types

mypy/semanal_typeddict.py

@@ -311,6 +311,18 @@ def analyze_typeddict_classdef_fields(
                     )
                     if analyzed is None:
                         return None, [], [], set()  # Need to defer
+                    # TypedDictAnalyzer sets the AssignmentStmt type here, but
+                    # NamedTupleAnalyzer doesn't and instead has semanal.py set it
+                    # by calling analyze_class_body_common after.
+                    #
+                    # This is because unlike TypedDicts, NamedTuples support method
+                    # definitions. So, we must handle some of what analyze_class_body_common
+                    # does here -- including modifying `stmt.type`.
+                    #
+                    # TODO: Find some way of refactoring and partially unifying
+                    #       these two codepaths?
+                    if not has_placeholder(analyzed):
+                        stmt.type = analyzed
                     types.append(analyzed)
                 # ...despite possible minor failures that allow further analysis.
                 if stmt.type is None or hasattr(stmt, "new_syntax") and not stmt.new_syntax:

test-data/unit/check-semanal-error.test

@@ -152,3 +152,33 @@ class C:
 x: P[int] = C()
 [builtins fixtures/tuple.pyi]
 [out]
+
+[case testSemanalDoesNotLeakSyntheticTypes]
+# flags: --cache-fine-grained
+from typing import Generic, NamedTuple, TypedDict, TypeVar
+from dataclasses import dataclass
+
+T = TypeVar('T')
+class Wrap(Generic[T]): pass
+
+invalid_1: 1 + 2        # E: Invalid type comment or annotation
+invalid_2: Wrap[1 + 2]  # E: Invalid type comment or annotation
+
+class A:
+    invalid_1: 1 + 2        # E: Invalid type comment or annotation
+    invalid_2: Wrap[1 + 2]  # E: Invalid type comment or annotation
+
+class B(NamedTuple):
+    invalid_1: 1 + 2        # E: Invalid type comment or annotation
+    invalid_2: Wrap[1 + 2]  # E: Invalid type comment or annotation
+
+class C(TypedDict):
+    invalid_1: 1 + 2        # E: Invalid type comment or annotation
+    invalid_2: Wrap[1 + 2]  # E: Invalid type comment or annotation
+
+@dataclass
+class D:
+    invalid_1: 1 + 2        # E: Invalid type comment or annotation
+    invalid_2: Wrap[1 + 2]  # E: Invalid type comment or annotation
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]

test-data/unit/check-typeddict.test

@@ -2189,6 +2189,27 @@ Foo = TypedDict('Foo', {'camelCaseKey': str})
 value: Foo = {}  # E: Missing key "camelCaseKey" for TypedDict "Foo"
 [builtins fixtures/dict.pyi]
 
+[case testTypedDictWithDeferredFieldTypeEval]
+from typing import Generic, TypeVar, TypedDict, NamedTuple
+
+class Foo(TypedDict):
+    # Inner[ForceDeferredEval] will be a placeholder type on first pass;
+    # confirm we infer the correct type on the second.
+    x: Outer[Inner[ForceDeferredEval]]
+
+var: Foo
+reveal_type(var)  # N: Revealed type is "TypedDict('__main__.Foo', {'x': __main__.Outer[__main__.Inner[__main__.ForceDeferredEval]]})"
+
+T1 = TypeVar("T1")
+class Outer(Generic[T1]): pass
+
+T2 = TypeVar("T2", bound=ForceDeferredEval)
+class Inner(Generic[T2]): pass
+
+class ForceDeferredEval: pass
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
 -- Required[]
 
 [case testDoesRecognizeRequiredInTypedDictWithClass]

test-data/unit/semanal-typeddict.test

@@ -42,4 +42,4 @@ MypyFile:1(
       NameExpr(x)
       TempNode:4(
         Any)
-      str?)))
+      builtins.str)))