22
33from __future__ import annotations
44
5- from collections .abc import Collection
6- from typing import Final
5+ from typing import Final , NamedTuple
76
87from mypy import errorcodes as codes , message_registry
98from mypy .errorcodes import ErrorCode
109from mypy .expandtype import expand_type
1110from mypy .exprtotype import TypeTranslationError , expr_to_unanalyzed_type
12- from mypy .message_registry import TYPEDDICT_OVERRIDE_MERGE
1311from mypy .messages import MessageBuilder
1412from mypy .nodes import (
1513 ARG_NAMED ,
4139 require_bool_literal_argument ,
4240)
4341from mypy .state import state
42+ from mypy .subtypes import is_equivalent , is_subtype
4443from mypy .typeanal import check_for_explicit_any , has_any_from_unimported_type
4544from mypy .types import (
4645 TPDICT_NAMES ,
5958)
6059
6160
61+ class FieldSource (NamedTuple ):
62+ field_type : Type
63+ is_readonly : bool
64+ is_required : bool
65+ base_name : str | None = None
66+ child_field_ctx : AssignmentStmt | None = None
67+
68+
6269class TypedDictAnalyzer :
6370 def __init__ (
6471 self , options : Options , api : SemanticAnalyzerInterface , msg : MessageBuilder
@@ -101,20 +108,20 @@ def analyze_typeddict_classdef(self, defn: ClassDef) -> tuple[bool, TypeInfo | N
101108 if isinstance (defn .analyzed , TypedDictExpr ):
102109 existing_info = defn .analyzed .info
103110
104- field_types : dict [str , Type ] | None
105111 if (
106112 len (defn .base_type_exprs ) == 1
107113 and isinstance (defn .base_type_exprs [0 ], RefExpr )
108114 and defn .base_type_exprs [0 ].fullname in TPDICT_NAMES
109115 ):
110116 # Building a new TypedDict
111- field_types , statements , required_keys , readonly_keys = (
112- self .analyze_typeddict_classdef_fields (defn )
113- )
114- if field_types is None :
117+ field_sources , statements = self .analyze_typeddict_classdef_fields (defn )
118+ if field_sources is None :
115119 return True , None # Defer
116120 if self .api .is_func_scope () and "@" not in defn .name :
117121 defn .name += "@" + str (defn .line )
122+ field_types = {key : source .field_type for (key , source ) in field_sources .items ()}
123+ required_keys = {key for (key , source ) in field_sources .items () if source .is_required }
124+ readonly_keys = {key for (key , source ) in field_sources .items () if source .is_readonly }
118125 info = self .build_typeddict_typeinfo (
119126 defn .name , field_types , required_keys , readonly_keys , defn .line , existing_info
120127 )
@@ -154,45 +161,41 @@ def analyze_typeddict_classdef(self, defn: ClassDef) -> tuple[bool, TypeInfo | N
154161 else :
155162 self .fail ("All bases of a new TypedDict must be TypedDict types" , defn )
156163
157- field_types = {}
158- required_keys = set ()
159- readonly_keys = set ()
160- # Iterate over bases in reverse order so that leftmost base class' keys take precedence
161- for base in reversed (typeddict_bases ):
162- self .add_keys_and_types_from_base (
163- base , field_types , required_keys , readonly_keys , defn
164- )
165- new_field_types , new_statements , new_required_keys , new_readonly_keys = (
166- self .analyze_typeddict_classdef_fields (defn , oldfields = field_types )
167- )
168- if new_field_types is None :
164+ bases_info : list [tuple [TypeInfo , dict [str , Type ]]] = []
165+ for base in typeddict_bases :
166+ base_info = self .fetch_keys_and_types_from_base (base , defn )
167+ if base_info is not None :
168+ bases_info .append (base_info )
169+ new_field_sources , new_statements = self .analyze_typeddict_classdef_fields (defn )
170+ if new_field_sources is None :
169171 return True , None # Defer
170- field_types . update ( new_field_types )
171- required_keys . update ( new_required_keys )
172- readonly_keys . update ( new_readonly_keys )
172+ field_types , required_keys , readonly_keys , any_placeholders = (
173+ self . resolve_field_inheritance ( bases_info , new_field_sources , defn )
174+ )
173175 info = self .build_typeddict_typeinfo (
174- defn .name , field_types , required_keys , readonly_keys , defn .line , existing_info
176+ defn .name ,
177+ field_types ,
178+ required_keys ,
179+ readonly_keys ,
180+ defn .line ,
181+ existing_info ,
182+ analysis_incomplete = any_placeholders ,
175183 )
176184 defn .analyzed = TypedDictExpr (info )
177185 defn .analyzed .line = defn .line
178186 defn .analyzed .column = defn .column
179187 defn .defs .body = new_statements
180188 return True , info
181189
182- def add_keys_and_types_from_base (
183- self ,
184- base : Expression ,
185- field_types : dict [str , Type ],
186- required_keys : set [str ],
187- readonly_keys : set [str ],
188- ctx : Context ,
189- ) -> None :
190+ def fetch_keys_and_types_from_base (
191+ self , base : Expression , ctx : Context
192+ ) -> tuple [TypeInfo , dict [str , Type ]] | None :
190193 info = self ._parse_typeddict_base (base , ctx )
191194 base_args : list [Type ] = []
192195 if isinstance (base , IndexExpr ):
193196 args = self .analyze_base_args (base , ctx )
194197 if args is None :
195- return
198+ return None
196199 base_args = args
197200
198201 assert info .typeddict_type is not None
@@ -211,13 +214,159 @@ def add_keys_and_types_from_base(
211214
212215 with state .strict_optional_set (self .options .strict_optional ):
213216 valid_items = self .map_items_to_base (valid_items , tvars , base_args )
214- for key in base_items :
215- if key in field_types :
216- self .fail (TYPEDDICT_OVERRIDE_MERGE .format (key ), ctx )
217217
218- field_types .update (valid_items )
219- required_keys .update (base_typed_dict .required_keys )
220- readonly_keys .update (base_typed_dict .readonly_keys )
218+ return info , valid_items
219+
220+ def field_sources_in_reverse_mro (
221+ self ,
222+ bases : list [tuple [TypeInfo , dict [str , Type ]]],
223+ child_field_sources : dict [str , FieldSource ],
224+ ) -> dict [str , list [FieldSource ]]:
225+ """Find all keys in bases and child, mapping them to a list of sources.
226+
227+ Iterate bases in reverse order to preserve key ordering for display.
228+ """
229+ result : dict [str , list [FieldSource ]] = {}
230+ for base_info , base_fields in reversed (bases ):
231+ assert base_info .typeddict_type is not None
232+ for field_name , field_type in base_fields .items ():
233+ source = FieldSource (
234+ base_name = base_info .name ,
235+ field_type = field_type ,
236+ is_readonly = field_name in base_info .typeddict_type .readonly_keys ,
237+ is_required = field_name in base_info .typeddict_type .required_keys ,
238+ )
239+ result .setdefault (field_name , []).append (source )
240+ for field_name , source in child_field_sources .items ():
241+ result .setdefault (field_name , []).append (source )
242+ return result
243+
244+ def primary_source (self , sources : list [FieldSource ]) -> FieldSource :
245+ """Select a primary source from a reverse-MRO-ordered list of sources.
246+
247+ The primary source will be the last in the MRO list, skipping readonly
248+ base class sources unless they are the only available option.
249+ """
250+ if sources [- 1 ].child_field_ctx :
251+ return sources [- 1 ]
252+ mutable_sources = (s for s in reversed (sources ) if not s .is_readonly )
253+ return next (mutable_sources , sources [- 1 ])
254+
255+ def verify_field_compatibility (
256+ self ,
257+ field_name : str ,
258+ source : FieldSource ,
259+ field_type : Type ,
260+ is_readonly : bool ,
261+ is_required : bool ,
262+ primary_source_base_name : str | None ,
263+ ctx : Context ,
264+ ) -> None :
265+ """Verify compatibility of the final child type field with a base class source.
266+
267+ Verifies type compatibility, requiredness, and mutability.
268+ """
269+ if has_placeholder (field_type ) or has_placeholder (source .field_type ):
270+ # Cannot verify type compatibility yet, but analysis will be deferred
271+ # and rerun later
272+ is_type_compatible = True
273+ elif source .is_readonly :
274+ is_type_compatible = is_subtype (field_type , source .field_type )
275+ else :
276+ is_type_compatible = is_equivalent (field_type , source .field_type )
277+ if not is_type_compatible :
278+ if primary_source_base_name is None :
279+ self .fail (
280+ f'Definition of field "{ field_name } " incompatible with base class "{ source .base_name } "' ,
281+ ctx ,
282+ )
283+ else :
284+ self .fail (
285+ f'Incompatible definitions of field "{ field_name } " in base classes "{ source .base_name } " and "{ primary_source_base_name } "' ,
286+ ctx ,
287+ )
288+ if is_readonly :
289+ self .note (
290+ f'This can be resolved by redeclaring the field "{ field_name } " with a mutually compatible type' ,
291+ ctx ,
292+ )
293+ elif source .is_required and not is_required :
294+ if primary_source_base_name is None :
295+ self .fail (
296+ f'Field "{ field_name } " is required in base class "{ source .base_name } "' , ctx
297+ )
298+ else :
299+ self .fail (
300+ f'Field "{ field_name } " is required in base class "{ source .base_name } " but not in base class "{ primary_source_base_name } "' ,
301+ ctx ,
302+ )
303+ elif not source .is_required and not source .is_readonly and is_required :
304+ if primary_source_base_name is None :
305+ self .fail (
306+ f'Field "{ field_name } " is not required and not readonly in base class "{ source .base_name } "' ,
307+ ctx ,
308+ )
309+ else :
310+ self .fail (
311+ f'Field "{ field_name } " is required in base class "{ primary_source_base_name } " but not in base class "{ source .base_name } "' ,
312+ ctx ,
313+ )
314+
315+ def resolve_field_inheritance (
316+ self ,
317+ bases : list [tuple [TypeInfo , dict [str , Type ]]],
318+ child_field_sources : dict [str , FieldSource ],
319+ ctx : Context ,
320+ ) -> tuple [dict [str , Type ], set [str ], set [str ], bool ]:
321+ """Determine field types, requiredness, and readonlyness.
322+
323+ Additionally returns if any placeholders were seen, as they will prevent full
324+ analysis, but may not result in placeholders in the final type.
325+ """
326+ field_sources = self .field_sources_in_reverse_mro (bases , child_field_sources )
327+ field_types : dict [str , Type ] = {}
328+ required_keys : set [str ] = set ()
329+ readonly_keys : set [str ] = set ()
330+ any_placeholders = False
331+
332+ for field_name , sources in field_sources .items ():
333+ primary_source = self .primary_source (sources )
334+ # If a read-only field is only defined in base classes, joining the types
335+ # is unlikely to produce a tight enough result. We could check all the
336+ # candidates from the base classes, but it would be O(n^2) complexity
337+ # to find out which is a supertype of all the others. Instead, use the
338+ # first definition in MRO order, and let the user provide the correct
339+ # definition in the subclass if this fails.
340+ field_types [field_name ] = primary_source .field_type
341+
342+ if primary_source .is_readonly :
343+ # If the primary source is readonly, all sources are readonly
344+ is_readonly = True
345+ is_required = any (source .is_required for source in sources )
346+ else :
347+ is_readonly = False
348+ is_required = primary_source .is_required
349+
350+ if is_required :
351+ required_keys .add (field_name )
352+ if is_readonly :
353+ readonly_keys .add (field_name )
354+
355+ for source in sources :
356+ if has_placeholder (source .field_type ):
357+ any_placeholders = True
358+ if source is not primary_source :
359+ self .verify_field_compatibility (
360+ field_name ,
361+ source ,
362+ field_types [field_name ],
363+ is_readonly ,
364+ is_required ,
365+ primary_source .base_name ,
366+ primary_source .child_field_ctx or ctx ,
367+ )
368+
369+ return field_types , required_keys , readonly_keys , any_placeholders
221370
222371 def _parse_typeddict_base (self , base : Expression , ctx : Context ) -> TypeInfo :
223372 if isinstance (base , RefExpr ):
@@ -288,22 +437,19 @@ def map_items_to_base(
288437 return mapped_items
289438
290439 def analyze_typeddict_classdef_fields (
291- self , defn : ClassDef , oldfields : Collection [ str ] | None = None
292- ) -> tuple [dict [str , Type ] | None , list [Statement ], set [ str ], set [ str ]]:
440+ self , defn : ClassDef
441+ ) -> tuple [dict [str , FieldSource ] | None , list [Statement ]]:
293442 """Analyze fields defined in a TypedDict class definition.
294443
295444 This doesn't consider inherited fields (if any). Also consider totality,
296445 if given.
297446
298447 Return tuple with these items:
299- * Dict of key -> type (or None if found an incomplete reference -> deferral)
448+ * Dict of key -> field source (or None if found an incomplete reference -> deferral)
300449 * List of statements from defn.defs.body that are legally allowed to be a
301450 part of a TypedDict definition
302- * Set of required keys
303451 """
304- fields : dict [str , Type ] = {}
305- readonly_keys = set [str ]()
306- required_keys = set [str ]()
452+ fields : dict [str , FieldSource ] = {}
307453 statements : list [Statement ] = []
308454
309455 total : bool | None = True
@@ -333,8 +479,6 @@ def analyze_typeddict_classdef_fields(
333479 self .fail (TPDICT_CLASS_ERROR , stmt )
334480 else :
335481 name = stmt .lvalues [0 ].name
336- if name in (oldfields or []):
337- self .fail (f'Overwriting TypedDict field "{ name } " while extending' , stmt )
338482 if name in fields :
339483 self .fail (f'Duplicate TypedDict key "{ name } "' , stmt )
340484 continue
@@ -353,18 +497,18 @@ def analyze_typeddict_classdef_fields(
353497 prohibit_special_class_field_types = "TypedDict" ,
354498 )
355499 if analyzed is None :
356- return None , [], set (), set () # Need to defer
500+ return None , [] # Need to defer
357501 field_type = analyzed
358502 if not has_placeholder (analyzed ):
359503 stmt .type = self .extract_meta_info (analyzed , stmt )[0 ]
360504
361505 field_type , required , readonly = self .extract_meta_info (field_type )
362- fields [name ] = field_type
363-
364- if (total or required is True ) and required is not False :
365- required_keys . add ( name )
366- if readonly :
367- readonly_keys . add ( name )
506+ fields [name ] = FieldSource (
507+ field_type = field_type ,
508+ is_required = (total or required is True ) and required is not False ,
509+ is_readonly = readonly ,
510+ child_field_ctx = stmt ,
511+ )
368512
369513 # ...despite possible minor failures that allow further analysis.
370514 if stmt .type is None or hasattr (stmt , "new_syntax" ) and not stmt .new_syntax :
@@ -373,7 +517,7 @@ def analyze_typeddict_classdef_fields(
373517 # x: int assigns rvalue to TempNode(AnyType())
374518 self .fail ("Right hand side values are not supported in TypedDict" , stmt )
375519
376- return fields , statements , required_keys , readonly_keys
520+ return fields , statements
377521
378522 def extract_meta_info (
379523 self , typ : Type , context : Context | None = None
@@ -597,6 +741,7 @@ def build_typeddict_typeinfo(
597741 readonly_keys : set [str ],
598742 line : int ,
599743 existing_info : TypeInfo | None ,
744+ analysis_incomplete : bool = False ,
600745 ) -> TypeInfo :
601746 # Prefer typing then typing_extensions if available.
602747 fallback = (
@@ -607,7 +752,8 @@ def build_typeddict_typeinfo(
607752 assert fallback is not None
608753 info = existing_info or self .api .basic_new_typeinfo (name , fallback , line )
609754 typeddict_type = TypedDictType (item_types , required_keys , readonly_keys , fallback )
610- if has_placeholder (typeddict_type ):
755+ if has_placeholder (typeddict_type ) or analysis_incomplete :
756+ typeddict_type .analysis_incomplete = True
611757 self .api .process_placeholder (
612758 None , "TypedDict item" , info , force_progress = typeddict_type != info .typeddict_type
613759 )
0 commit comments