Allow closed TypedDict in typing-only contexts

Author: vetrovk

mypy/nodes.py

@@ -1664,6 +1664,7 @@ class ClassDef(Statement):
         "has_incompatible_baseclass",
         "docstring",
         "removed_statements",
+        "is_mypy_only",
     )
 
     __match_args__ = ("name", "defs")
@@ -1714,6 +1715,7 @@ def __init__(
         self.has_incompatible_baseclass = False
         self.docstring: str | None = None
         self.removed_statements = []
+        self.is_mypy_only = False
 
     @property
     def fullname(self) -> str:
@@ -1862,6 +1864,7 @@ class AssignmentStmt(Statement):
         "is_alias_def",
         "is_final_def",
         "invalid_recursive_alias",
+        "is_mypy_only",
     )
 
     __match_args__ = ("lvalues", "rvalues", "type")
@@ -1904,6 +1907,7 @@ def __init__(
         self.is_alias_def = False
         self.is_final_def = False
         self.invalid_recursive_alias = False
+        self.is_mypy_only = False
 
     def accept(self, visitor: StatementVisitor[T]) -> T:
         return visitor.visit_assignment_stmt(self)

mypy/reachability.py

@@ -8,8 +8,10 @@
 from mypy.nodes import (
     LITERAL_YES,
     AssertStmt,
+    AssignmentStmt,
     Block,
     CallExpr,
+    ClassDef,
     ComparisonExpr,
     Expression,
     FuncDef,
@@ -56,6 +58,8 @@ def infer_reachability_of_if_statement(s: IfStmt, options: Options) -> None:
         if result in (ALWAYS_FALSE, MYPY_FALSE):
             # The condition is considered always false, so we skip the if/elif body.
             mark_block_unreachable(s.body[i])
+            if result == MYPY_FALSE and i == len(s.expr) - 1 and s.else_body:
+                mark_block_mypy_only(s.else_body)
         elif result in (ALWAYS_TRUE, MYPY_TRUE):
             # This condition is considered always true, so all of the remaining
             # elif/else bodies should not be checked.
@@ -368,3 +372,12 @@ def visit_import_all(self, node: ImportAll) -> None:
 
     def visit_func_def(self, node: FuncDef) -> None:
         node.is_mypy_only = True
+        super().visit_func_def(node)
+
+    def visit_class_def(self, node: ClassDef) -> None:
+        node.is_mypy_only = True
+        super().visit_class_def(node)
+
+    def visit_assignment_stmt(self, node: AssignmentStmt) -> None:
+        node.is_mypy_only = True
+        super().visit_assignment_stmt(node)

mypy/semanal.py

@@ -3676,7 +3676,7 @@ def analyze_typeddict_assign(self, s: AssignmentStmt) -> bool:
         namespace = self.qualified_name(name)
         with self.tvar_scope_frame(self.tvar_scope.class_frame(namespace)):
             is_typed_dict, info, tvar_defs = self.typed_dict_analyzer.check_typeddict(
-                s.rvalue, name
+                s.rvalue, name, s.is_mypy_only
             )
             if not is_typed_dict:
                 return False

mypy/semanal_typeddict.py

@@ -112,25 +112,30 @@ def analyze_typeddict_classdef(self, defn: ClassDef) -> tuple[bool, TypeInfo | N
         if isinstance(defn.analyzed, TypedDictExpr):
             existing_info = defn.analyzed.info
 
-        base_fullname: str | None = None
-        if (
-            len(defn.base_type_exprs) == 1
-            and isinstance(defn.base_type_exprs[0], RefExpr)
-            and defn.base_type_exprs[0].fullname in TPDICT_NAMES
-        ):
-            base_fullname = defn.base_type_exprs[0].fullname
-
         is_closed: bool | None = None
         if "closed" in defn.keywords:
-            is_closed = self.parse_typeddict_closed_argument(
-                defn.keywords["closed"], base_fullname
+            is_closed = require_bool_literal_argument(
+                self.api, defn.keywords["closed"], "closed", False
             )
 
         if (
             len(defn.base_type_exprs) == 1
             and isinstance(defn.base_type_exprs[0], RefExpr)
             and defn.base_type_exprs[0].fullname in TPDICT_NAMES
         ):
+            if (
+                is_closed is not None
+                and parse_bool(defn.keywords["closed"]) is not None
+                and defn.base_type_exprs[0].fullname == "typing.TypedDict"
+                and self.options.python_version < (3, 15)
+                and not self.api.is_stub_file
+                and not defn.is_mypy_only
+            ):
+                self.fail(
+                    '"closed" argument to TypedDict is only available in Python 3.15 and later',
+                    defn.keywords["closed"],
+                )
+                is_closed = None
             # Building a new TypedDict
             field_sources, statements = self.analyze_typeddict_classdef_fields(defn)
             if field_sources is None:
@@ -157,7 +162,9 @@ def analyze_typeddict_classdef(self, defn: ClassDef) -> tuple[bool, TypeInfo | N
         typeddict_bases: list[Expression] = []
         typeddict_bases_set = set()
         for i, expr in enumerate(defn.base_type_exprs):
-            ok, maybe_type_info, _ = self.check_typeddict(expr, inline_base(defn.name, i))
+            ok, maybe_type_info, _ = self.check_typeddict(
+                expr, inline_base(defn.name, i), defn.is_mypy_only
+            )
             if ok and maybe_type_info is not None:
                 # expr is a CallExpr
                 info = maybe_type_info
@@ -585,7 +592,7 @@ def extract_meta_info(
         return typ, is_required, readonly
 
     def check_typeddict(
-        self, node: Expression, name: str
+        self, node: Expression, name: str, is_mypy_only: bool = False
     ) -> tuple[bool, TypeInfo | None, list[TypeVarLikeType]]:
         """Check if a call defines a TypedDict.
 
@@ -608,7 +615,7 @@ def check_typeddict(
         fullname = callee.fullname
         if fullname not in TPDICT_NAMES:
             return False, None, []
-        res = self.parse_typeddict_args(call, fullname)
+        res = self.parse_typeddict_args(call, fullname, is_mypy_only)
         if res is None:
             # This is a valid typed dict, but some type is not ready.
             # The caller should defer this until next iteration.
@@ -671,7 +678,7 @@ def check_typeddict(
         return True, info, tvar_defs
 
     def parse_typeddict_args(
-        self, call: CallExpr, fullname: str
+        self, call: CallExpr, fullname: str, is_mypy_only: bool
     ) -> tuple[str, list[str], list[Type], bool, bool, list[TypeVarLikeType], bool] | None:
         """Parse typed dict call expression.
 
@@ -712,7 +719,19 @@ def parse_typeddict_args(
         for arg_name, arg in zip(call.arg_names[2:], call.args[2:]):
             assert arg_name
             if arg_name == "closed":
-                value = self.parse_typeddict_closed_argument(arg, fullname)
+                value = require_bool_literal_argument(self.api, arg, "closed", False)
+                if (
+                    parse_bool(arg) is not None
+                    and fullname == "typing.TypedDict"
+                    and self.options.python_version < (3, 15)
+                    and not self.api.is_stub_file
+                    and not is_mypy_only
+                ):
+                    self.fail(
+                        '"closed" argument to TypedDict is only available in Python 3.15 and later',
+                        arg,
+                    )
+                    return "", [], [], True, False, [], False
             else:
                 value = require_bool_literal_argument(self.api, arg, arg_name)
             if value is None:
@@ -731,22 +750,6 @@ def parse_typeddict_args(
         assert total is not None
         return args[0].value, items, types, total, closed, tvar_defs, ok
 
-    def parse_typeddict_closed_argument(
-        self, arg: Expression, fullname: str | None
-    ) -> bool | None:
-        literal_value = parse_bool(arg)
-        value = require_bool_literal_argument(self.api, arg, "closed", False)
-        if (
-            literal_value is not None
-            and fullname == "typing.TypedDict"
-            and self.options.python_version < (3, 15)
-        ):
-            self.fail(
-                '"closed" argument to TypedDict is only available in Python 3.15 and later', arg
-            )
-            return None
-        return value
-
     def parse_typeddict_fields_with_types(
         self, dict_items: list[tuple[Expression | None, Expression]]
     ) -> tuple[list[str], list[Type], bool] | None:

mypy/treetransform.py

@@ -272,6 +272,7 @@ def visit_class_def(self, node: ClassDef) -> ClassDef:
         new.fullname = node.fullname
         new.info = node.info
         new.decorators = [self.expr(decorator) for decorator in node.decorators]
+        new.is_mypy_only = node.is_mypy_only
         return new
 
     def visit_global_decl(self, node: GlobalDecl) -> GlobalDecl:
@@ -327,6 +328,7 @@ def duplicate_assignment(self, node: AssignmentStmt) -> AssignmentStmt:
         )
         new.line = node.line
         new.is_final_def = node.is_final_def
+        new.is_mypy_only = node.is_mypy_only
         new.type = self.optional_type(node.type)
         return new
 

test-data/unit/check-typeddict.test

@@ -5233,6 +5233,7 @@ reveal_type(e)  # N: Revealed type is "TypedDict('__main__.E', {'x': builtins.in
 [case testTypedDictClosedArgumentBeforePython315]
 # flags: --python-version 3.14
 from typing import TypedDict
+from typing_extensions import TYPE_CHECKING
 
 class ClassClosed(TypedDict, closed=True):  # E: "closed" argument to TypedDict is only available in Python 3.15 and later
     x: int
@@ -5244,8 +5245,38 @@ class InvalidClosed(TypedDict, closed=0):  # E: "closed" argument must be a True
     x: int
 class WithoutClosed(TypedDict):
     x: int
+
+if TYPE_CHECKING:
+    class TypeCheckingClassClosed(TypedDict, closed=True):
+        x: int
+    class TypeCheckingClassOpen(TypedDict, closed=False):
+        x: int
+    TypeCheckingFunctionalClosed = TypedDict('TypeCheckingFunctionalClosed', {'x': int}, closed=True)
+    TypeCheckingFunctionalOpen = TypedDict('TypeCheckingFunctionalOpen', {'x': int}, closed=False)
+    class TypeCheckingInvalidClosed(TypedDict, closed=0):  # E: "closed" argument must be a True or False literal
+        x: int
+    def type_checking_function() -> None:
+        class NestedClassClosed(TypedDict, closed=True):
+            x: int
+        NestedFunctionalOpen = TypedDict('NestedFunctionalOpen', {'x': int}, closed=False)
+if not TYPE_CHECKING:
+    pass
+else:
+    class ElseClassClosed(TypedDict, closed=True):
+        x: int
+    ElseFunctionalOpen = TypedDict('ElseFunctionalOpen', {'x': int}, closed=False)
+from stub import StubClassClosed, StubClassOpen, StubFunctionalClosed, StubFunctionalOpen
 [builtins fixtures/dict.pyi]
 [typing fixtures/typing-typeddict.pyi]
+[file stub.pyi]
+from typing import TypedDict
+
+class StubClassClosed(TypedDict, closed=True):
+    x: int
+class StubClassOpen(TypedDict, closed=False):
+    x: int
+StubFunctionalClosed = TypedDict('StubFunctionalClosed', {'x': int}, closed=True)
+StubFunctionalOpen = TypedDict('StubFunctionalOpen', {'x': int}, closed=False)
 
 [case testTypingExtensionsTypedDictClosedArgumentBeforePython315]
 # flags: --python-version 3.14