Delay subtype validation to TypeChecker

Calling is_subtype during semantic analysis is not legal; verifying type
compatibility of a TypedDict subtype field definition with its
supertypes needs to be done in TypeChecker. To avoid duplicating all the
logic for determining sources, add a non-persisted field_constraints
field to TypedDictType.

Author: alicederyn

mypy/checker.py

@@ -2813,6 +2813,8 @@ def visit_class_def(self, defn: ClassDef) -> None:
                     self.check_multiple_inheritance(typ)
                 self.check_metaclass_compatibility(typ)
                 self.check_final_deletable(typ)
+                if typ.typeddict_type:
+                    self.check_typeddict_inheritance(defn)
 
             if defn.decorators:
                 sig: Type = type_object_type(defn.info)
@@ -3219,6 +3221,22 @@ def check_metaclass_compatibility(self, typ: TypeInfo) -> None:
             if explanation:
                 self.note(explanation, typ, code=codes.METACLASS)
 
+    def check_typeddict_inheritance(self, defn: ClassDef) -> None:
+        """Ensure that the final definition of a TypedDict is compatible with its base classes."""
+        assert defn.info.typeddict_type
+        td = defn.info.typeddict_type
+        for constraint in td.field_constraints:
+            field_name = constraint.field_name
+            field_type = td.items[field_name]
+            if constraint.is_readonly:
+                is_compatible = is_subtype(field_type, constraint.field_type)
+            else:
+                is_compatible = is_equivalent(field_type, constraint.field_type)
+            if not is_compatible:
+                self.fail(constraint.failure_message, constraint.ctx)
+                if constraint.failure_note:
+                    self.note(constraint.failure_note, constraint.ctx)
+
     def visit_import_from(self, node: ImportFrom) -> None:
         for name, _ in node.names:
             if (sym := self.globals.get(name)) is not None:

mypy/semanal_typeddict.py

@@ -40,14 +40,14 @@
     require_bool_literal_argument,
 )
 from mypy.state import state
-from mypy.subtypes import is_equivalent, is_subtype
 from mypy.typeanal import check_for_explicit_any, has_any_from_unimported_type
 from mypy.types import (
     TPDICT_NAMES,
     AnyType,
     ReadOnlyType,
     RequiredType,
     Type,
+    TypedDictFieldConstraint,
     TypedDictType,
     TypeOfAny,
     TypeVarLikeType,
@@ -182,7 +182,7 @@ def analyze_typeddict_classdef(self, defn: ClassDef) -> tuple[bool, TypeInfo | N
         new_field_sources, new_statements = self.analyze_typeddict_classdef_fields(defn)
         if new_field_sources is None:
             return True, None  # Defer
-        field_types, required_keys, readonly_keys, is_closed, any_placeholders = (
+        field_types, required_keys, readonly_keys, is_closed, constraints = (
             self.resolve_field_inheritance(bases_info, new_field_sources, is_closed, defn)
         )
         info = self.build_typeddict_typeinfo(
@@ -193,7 +193,7 @@ def analyze_typeddict_classdef(self, defn: ClassDef) -> tuple[bool, TypeInfo | N
             is_closed,
             defn.line,
             existing_info,
-            analysis_incomplete=any_placeholders,
+            constraints=constraints,
         )
         defn.analyzed = TypedDictExpr(info)
         defn.analyzed.line = defn.line
@@ -266,45 +266,16 @@ def primary_source(self, sources: list[FieldSource]) -> FieldSource:
         mutable_sources = (s for s in reversed(sources) if not s.is_readonly)
         return next(mutable_sources, sources[-1])
 
-    def verify_field_compatibility(
+    def verify_requiredness_compatibility(
         self,
         field_name: str,
         source: FieldSource,
-        field_type: Type,
-        is_readonly: bool,
         is_required: bool,
         primary_source_base_name: str | None,
         ctx: Context,
     ) -> None:
-        """Verify compatibility of the final child type field with a base class source.
-
-        Verifies type compatibility, requiredness, and mutability.
-        """
-        if has_placeholder(field_type) or has_placeholder(source.field_type):
-            # Cannot verify type compatibility yet, but analysis will be deferred
-            # and rerun later
-            is_type_compatible = True
-        elif source.is_readonly:
-            is_type_compatible = is_subtype(field_type, source.field_type)
-        else:
-            is_type_compatible = is_equivalent(field_type, source.field_type)
-        if not is_type_compatible:
-            if primary_source_base_name is None:
-                self.fail(
-                    f'Definition of field "{field_name}" incompatible with base class "{source.base_name}"',
-                    ctx,
-                )
-            else:
-                self.fail(
-                    f'Incompatible definitions of field "{field_name}" in base classes "{source.base_name}" and "{primary_source_base_name}"',
-                    ctx,
-                )
-                if is_readonly:
-                    self.note(
-                        f'This can be resolved by redeclaring the field "{field_name}" with a mutually compatible type',
-                        ctx,
-                    )
-        elif source.is_required and not is_required:
+        """Verify requiredness compatibility of the final child type field with a base class source."""
+        if source.is_required and not is_required:
             if primary_source_base_name is None:
                 self.fail(
                     f'Field "{field_name}" is required in base class "{source.base_name}"', ctx
@@ -325,6 +296,36 @@ def verify_field_compatibility(
                     ctx,
                 )
 
+    def field_compatibility_constraint(
+        self,
+        field_name: str,
+        source: FieldSource,
+        is_readonly: bool,
+        primary_source_base_name: str | None,
+        ctx: Context,
+    ) -> TypedDictFieldConstraint:
+        """Information needed to verify compatibility of the final child type field with a base class source.
+
+        This cannot be done during semantic analysis, as it is not safe to check subtyping.
+        """
+        failure_note = None
+        if primary_source_base_name is None:
+            failure_message = f'Definition of field "{field_name}" incompatible with base class "{source.base_name}"'
+        else:
+            failure_message = f'Incompatible definitions of field "{field_name}" in base classes "{source.base_name}" and "{primary_source_base_name}"'
+            if is_readonly:
+                failure_note = f'This can be resolved by redeclaring the field "{field_name}" with a mutually compatible type'
+
+        constraint = TypedDictFieldConstraint(
+            field_name=field_name,
+            field_type=source.field_type,
+            is_readonly=source.is_readonly,
+            failure_message=failure_message,
+            failure_note=failure_note,
+            ctx=ctx,
+        )
+        return constraint
+
     def verify_field_against_closed_bases(
         self,
         field_name: str,
@@ -353,17 +354,13 @@ def resolve_field_inheritance(
         child_field_sources: dict[str, FieldSource],
         child_is_closed: bool | None,
         ctx: Context,
-    ) -> tuple[dict[str, Type], set[str], set[str], bool, bool]:
-        """Determine field types, requiredness, readonlyness, and closedness.
-
-        Additionally returns if any placeholders were seen, as they will prevent full
-        analysis, but may not result in placeholders in the final type.
-        """
+    ) -> tuple[dict[str, Type], set[str], set[str], bool, list[TypedDictFieldConstraint]]:
+        """Determine field types, requiredness, readonlyness, closedness, and delayed constraints."""
         field_sources = self.field_sources_in_reverse_mro(bases, child_field_sources)
         field_types: dict[str, Type] = {}
         required_keys: set[str] = set()
         readonly_keys: set[str] = set()
-        any_placeholders = False
+        constraints: list[TypedDictFieldConstraint] = []
         closed_bases = [
             (base_info, base_fields.keys())
             for (base_info, base_fields) in bases
@@ -401,18 +398,22 @@ def resolve_field_inheritance(
                 readonly_keys.add(field_name)
 
             for source in sources:
-                if has_placeholder(source.field_type):
-                    any_placeholders = True
                 if source is not primary_source:
-                    self.verify_field_compatibility(
+                    self.verify_requiredness_compatibility(
                         field_name,
                         source,
-                        field_types[field_name],
-                        is_readonly,
                         is_required,
                         primary_source.base_name,
                         primary_source.child_field_ctx or ctx,
                     )
+                    constraint = self.field_compatibility_constraint(
+                        field_name,
+                        source,
+                        is_readonly,
+                        primary_source.base_name,
+                        primary_source.child_field_ctx or ctx,
+                    )
+                    constraints.append(constraint)
             self.verify_field_against_closed_bases(
                 field_name,
                 closed_bases,
@@ -421,7 +422,7 @@ def resolve_field_inheritance(
             )
 
         is_closed = bool(closed_bases) if child_is_closed is None else child_is_closed
-        return field_types, required_keys, readonly_keys, is_closed, any_placeholders
+        return field_types, required_keys, readonly_keys, is_closed, constraints
 
     def _parse_typeddict_base(self, base: Expression, ctx: Context) -> TypeInfo:
         if isinstance(base, RefExpr):
@@ -814,7 +815,7 @@ def build_typeddict_typeinfo(
         is_closed: bool,
         line: int,
         existing_info: TypeInfo | None,
-        analysis_incomplete: bool = False,
+        constraints: list[TypedDictFieldConstraint] | None = None,
     ) -> TypeInfo:
         # Prefer typing then typing_extensions if available.
         fallback = (
@@ -827,7 +828,11 @@ def build_typeddict_typeinfo(
         typeddict_type = TypedDictType(
             item_types, required_keys, readonly_keys, is_closed, fallback
         )
-        if has_placeholder(typeddict_type) or analysis_incomplete:
+        if constraints:
+            typeddict_type.field_constraints.extend(constraints)
+        if has_placeholder(typeddict_type) or any(
+            has_placeholder(c.field_type) for c in typeddict_type.field_constraints
+        ):
             typeddict_type.analysis_incomplete = True
             self.api.process_placeholder(
                 None, "TypedDict item", info, force_progress=typeddict_type != info.typeddict_type

mypy/types.py

@@ -2924,6 +2924,15 @@ def slice(
         return TupleType(slice_items, fallback, self.line, self.column, self.implicit)
 
 
+class TypedDictFieldConstraint(NamedTuple):
+    field_name: str
+    field_type: Type
+    is_readonly: bool
+    failure_message: str
+    failure_note: str | None
+    ctx: mypy.nodes.Context
+
+
 class TypedDictItem(NamedTuple):
     """Type, mutability and requiredness of an item in a TypedDict.
 
@@ -2973,6 +2982,7 @@ class TypedDictType(ProperType):
         "extra_items_from",
         "to_be_mutated",
         "analysis_incomplete",
+        "field_constraints",
     )
 
     items: dict[str, Type]  # item_name -> item_type
@@ -2983,6 +2993,9 @@ class TypedDictType(ProperType):
     extra_items_from: list[ProperType]  # only used during semantic analysis
     to_be_mutated: bool  # only used in a plugin for `.update`, `|=`, etc
     analysis_incomplete: bool  # a placeholder type prevented complete analysis checking
+    field_constraints: list[
+        TypedDictFieldConstraint
+    ]  # delayed constraints to validate later in checking
 
     def __init__(
         self,
@@ -3005,6 +3018,7 @@ def __init__(
         self.extra_items_from = []
         self.to_be_mutated = False
         self.analysis_incomplete = False
+        self.field_constraints = []
 
     def accept(self, visitor: TypeVisitor[T]) -> T:
         return visitor.visit_typeddict_type(self)