
    iՑ                      U d Z ddlmZ ddlZddlmZ ddlmZmZm	Z	m
Z
mZmZ ddlmZmZ ddlmZmZmZmZmZmZmZmZmZ ddlZddlmZm Z m!Z!m"Z"m#Z# dd	l$m%Z%m&Z&m'Z' dd
l(m)Z)m*Z*m+Z+ ddl,m-Z- ddl.m/Z/m0Z0m1Z1m2Z2m3Z3 ddl4m5Z5 ddl6m7Z7 ddl8m9Z9m:Z:m;Z;m<Z< ddl=m>Z>m?Z?m@Z@mAZA ddlBmCZCmDZDmEZEmFZFmGZGmHZH ddlImJZJ ddlKmLZLmMZMmNZNmOZO ddlPmQZQ ddlRmSZSmTZTmUZU ddlVmWZW ddlXmYZYmZZZm[Z[m\Z\m]Z]m^Z^m_Z_m`Z`maZa ddlbmcZcmdZd ddlemfZfmgZgmhZhmiZimjZjmkZkmlZlmmZmmnZnmoZompZpmqZqmrZrmsZsmtZtmuZumvZvmwZwmxZxmyZymzZzm{Z{m|Z|m}Z}m~Z~mZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZ ddlmZmZmZ ddlmZmZ ddlmZmZ ddlmZ ddlmZ ddlmZ dd lmZmZmZ dd!lmZmZ dd"lmZ dd#lmZ dd$lmZ dd%lmZmZmZmZmZmZmZmZmZmZ dd&lmZmZmZ dd'lmZ dd(lmZmZmZ dd)lmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZm Z mZmZ dd*lmZmZmZmZmZm	Z	m
Z
mZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z* dd+l+m,Z,m-Z-m.Z.m/Z/ dd,l0m1Z1 dd-l2m3Z3m4Z4m5Z5 dd.l6m7Z7m8Z8 dd/l9m:Z:  ed0          Z;d1Z<d2e=d3<   d4Z>d2e=d5<   eez  ez  Z?d6e=d7<   eez  ez  Z@d6e=d8<    G d9 d:e          ZA G d; d<e          ZBeCeef         ZDd6e=d=<    G d> d?e          ZE G d@ dA          ZF G dB dCe:d         e*e          ZG G dD dEeӦ          ZH G dF dGe1          ZIe	 ddHdIdJddV            ZJedHdIdJddX            ZJ	 ddHdIdJddZZJdd`ZKddeZLddgZMddhZNddiZOddkZPddnZQddpZRddrZSdIdsddwZTdIdxddzZU	 ddd}ZVddZWddZXddhZYd2e=d<   ddZZddZ[ddZ\ddZ]ddZ^ G d de          Z_ddZ`ddZa	 dddZbd dZcddZdddZeddZfddZgddZh	 dddZi G d de	          Zj G d de          ZkddZlddZm ed          Zn ed          Zo G d deeneof                   ZpddńZqd	dƄZrd
dǄZsddɄZtdd˄Zudd̈́Zvdd΄ZwddЄZxddӄZyddԄZzddքZ{ddׄZ|dd؄Z}ddڄZ~dd߄Z G d de          ZddZddZddZdS (  zMypy type checker.    )annotationsN)defaultdict)CallableIterableIteratorMappingSequenceSet)	ExitStackcontextmanager)	FinalGenericLiteral
NamedTuple	TypeAlias	TypeGuardTypeVarcastoverload)
errorcodesjoinmessage_registrynodes	operators)ConditionalTypeBinderFrameget_declaration)CheckerScopeTypeCheckerSharedApi	TypeRange)checker_state)MemberContextanalyze_class_attribute_accessanalyze_instance_member_accessanalyze_member_accessis_instance_var)PatternChecker)SUPERTYPE_OF)
erase_typeerase_typevars!remove_instance_last_known_valuesshallow_erase_type_for_equality)TYPE_VARUNUSED_AWAITABLEUNUSED_COROUTINE	ErrorCode)	ErrorInfoErrorsErrorWatcherIterationDependentErrorsIterationErrorWatcherreport_internal_error)expand_type)Keyextract_var_from_literal_hashliteralliteral_hash)map_instance_to_supertype)is_overlapping_erased_typesis_overlapping_types
meet_types)ErrorMessage)	SUGGESTED_TEST_FIXTURESMessageBuilderappend_invariance_notesappend_union_noteformat_typeformat_type_bareformat_type_distinctlymake_inferred_type_note
pretty_seq)MroErrorcalculate_mro)U	ARG_NAMEDARG_POSARG_STARCONTRAVARIANT	COVARIANTFUNC_NO_INFOGDEFIMPLICITLY_ABSTRACT	INVARIANTIS_ABSTRACTLDEFLITERAL_TYPEMDEFNOT_ABSTRACTSYMBOL_FUNCBASE_TYPES
AssertStmtAssignmentExprAssignmentStmt	AwaitExprBlock	BreakStmt	BytesExprCallExprClassDefComparisonExprContextContinueStmt	DecoratorDelStmtDictExprEllipsisExpr
ExpressionExpressionStmt	FloatExprForStmtFuncBaseFuncDefFuncItem
GlobalDeclIfStmtImport	ImportAll
ImportBase
ImportFrom	IndexExprIntExpr
LambdaExprListExprLvalue	MatchStmt
MemberExprMypyFileNameExprNodeNonlocalDeclOperatorAssignmentStmtOpExprOverloadedFuncDefOverloadPartPassStmtPromoteExpr	RaiseStmtRefExpr
ReturnStmtSetExprSplittingVisitorStarExpr	StatementStrExpr
SymbolNodeSymbolTableSymbolTableNodeTempNodeTryStmt	TupleExprr   TypeAliasStmtTypeInfo	UnaryExprVar	WhileStmtWithStmt	YieldExprget_func_defis_final_node)flip_opsint_op_to_methodneg_ops)PRECISE_TUPLE_TYPESOptions)	AsPatternStarredPattern)Plugin)dataclasses)Scope)is_trivial_bodyrefers_to_fullnameset_callable_name)
ENUM_BASESENUM_SPECIAL_PROPS)SemanticAnalyzerCoreInterface)BINARY_MAGIC_METHODS)state)
find_memberinfer_class_variancesis_callable_compatibleis_equivalentis_more_preciseis_proper_subtypeis_same_type
is_subtyperestrict_subtype_awayunify_generic_callable)TraverserVisitorall_return_statementshas_return_statement)TransformVisitor)check_for_explicit_anyhas_any_from_unimported_typemake_optional_type)	bind_selfcan_have_shared_disjoint_basecoerce_to_literalcustom_special_methoderase_def_to_union_or_bounderase_to_bounderase_to_union_or_bound
false_onlyfixup_partial_typefunction_typeis_literal_type_likeis_singleton_equality_typeis_singleton_identity_typemake_simplified_union	true_onlytry_expanding_sum_type_to_union"try_getting_int_literals_from_typetry_getting_str_literals"try_getting_str_literals_from_typetuple_fallbacktype_object_type)'ANY_STRATEGYMYPYC_NATIVE_INT_NAMESNOT_IMPLEMENTED_TYPE_NAMESOVERLOAD_NAMESAnyTypeBoolTypeQueryCallableTypeDeletedType
ErasedTypeFunctionLikeInstanceLiteralTypeNoneType
OverloadedPartialType
ProperType	TupleTypeTypeTypeAliasTypeTypedDictTypeTypeGuardedType	TypeOfAnyTypeTranslatorTypeType	TypeVarIdTypeVarLikeTypeTypeVarTupleTypeTypeVarTypeUnboundTypeUninhabitedType	UnionType
UnpackTypefind_unpack_in_listflatten_nested_unionsget_proper_typeget_proper_typesinstance_cacheis_literal_typeis_named_instance)is_overlapping_noneremove_optionalstore_argument_type
strip_type)TypeTraverserVisitor)fill_typevarsfill_typevars_with_anyhas_no_typevars)	is_dunder	is_sunder)NodeVisitorT   r   DEFAULT_LAST_PASS   MAX_PRECISE_TUPLE_SIZE
_TypeAliasDeferredNodeTypeFineGrainedDeferredNodeTypec                  $    e Zd ZU ded<   ded<   dS )DeferredNoder  nodeTypeInfo | Noneactive_typeinfoN__name__
__module____qualname____annotations__     K/root/projects/qq-shell/venv/lib64/python3.11/site-packages/mypy/checker.pyr  r  	  s*         $$$$$$r  r  c                  $    e Zd ZU ded<   ded<   dS )FineGrainedDeferredNoder  r  r  r  Nr  r  r  r  r   r     s*         %%%%$$$$$$r  r   TypeMapc                  .    e Zd ZU ded<   ded<   ded<   dS )PartialTypeScopedict[Var, Context]mapboolis_functionis_localNr  r  r  r  r#  r#  )  s1         NNNNNr  r#  c                  *    e Zd ZdZddZddZddZdS )LocalTypeMapzStore inferred types into a temporary type map (returned).

    This can be used to perform type checking "experiments" without
    affecting exported types (which are used by mypyc).
    chkTypeCheckerreturnNonec                    || _         d S N)r+  )selfr+  s     r  __init__zLocalTypeMap.__init__6  s    r  dict[Expression, Type]c                H    i }| j         j                            |           |S r0  )r+  
_type_mapsappend)r1  temp_type_maps     r  	__enter__zLocalTypeMap.__enter__9  s&    02""=111r  exc_typeobjectexc_valexc_tbLiteral[False]c                B    | j         j                                         dS NF)r+  r5  pop)r1  r9  r;  r<  s       r  __exit__zLocalTypeMap.__exit__>  s    !!!ur  N)r+  r,  r-  r.  )r-  r3  )r9  r:  r;  r:  r<  r:  r-  r=  )r  r  r  __doc__r2  r8  rA  r  r  r  r*  r*  /  sZ               
     r  r*  c                     e Zd ZU dZdZded<   ded<   ded<   d	ed
<   ded<   ded<   ded<   ded<   ded<   ded<   ded<   ded<   ded<   ded<   ded <   d!ed"<   d#ed$<   d%ZeZdZ	dZ
d&ed'<   d(Zd)ed*<   dZd+ed,<   d-ed.<   d/ed0<   d1ed2<   d3ed4<   d5ed6<   d>d?Zed?d@            Zed@dB            ZdAdCZdAdDZ	 dBdEdFdCdJZdDdMZdEdNZdFdQZdGdUZdHdXZ	 dBd(d(dYdIdaZdJddZdJdeZedKdi            ZdLdnZdJdoZdMdsZ dNdtZ!dOdvZ"dOdwZ#dPdxZ$dOdyZ%dQd{Z&	 	 	 dRdSdZ'dTdZ(edUd            Z)	 dVdWdZ*dXdZ+dYdZ,dZdZ-d[dZ.d\dZ/d]dZ0d]dZ1d^dZ2d_dZ3d`dZ4dadZ5dbdZ6dcdZ7dddZ8dedZ9dedZ:dfdZ;dgdZ<	 dBdhdZ=didZ>djdZ?dkdZ@dldZAdmdZBdndZCdodÄZDdpdńZEedqdƄ            ZFdrdǄZGdpdȄZHdsd˄ZIdpd̄ZJdtd̈́ZKdudЄZLdpdфZMdpd҄ZNdpdӄZOdrdԄZPdvdׄZQdrd؄ZRdwdڄZSdxd܄ZTdydބZUdzdZVd{dZWd|dZXd}dZYd~dZZd~dZ[	 	 dddZ\ddhZ]ded<   ddZ^ddZ_ddZ`dd Zaddd(dddZbddZcdd	Zddd
Zed|dZfedd            ZgddZhddZiddZjddZk	 dddZl	 dBddZm	 	 	 dddZndd!Zodd"Zp	 ddd$Zqdd%Zrdd+Zsdd,Zt	 ddd-Zu	 dBdd/Zvdd0Zwdd2Zxdd3Zydd6Zzdd7Z{dd8Z|dd9Z}dd:Z~dd@Zej        dAdBfd(d(d(dCddJZddLZddQZddSZddUZddVZddXZddZZdd\Zdd`ZddaZddcZddeZddgZddiZddkZdVddnZddpZddrZdduZddvZddyZddzZdd|Zdd~ZddZddZddZddZddZddZddZ	 dddZddZddZdÐdZdĐdZdŐdZdŐdZdƐdZdǐdZdȐdZdɐdZdʐdZdːdZd̐dZd͐dZdΐdZdϐdZdАdZdѐdZdҐdZdӐdZdԐdZddZdՐdÄZdEdĜd֐dƄZdEdĜd֐dǄZdאdɄZdؐdфZdِdӄZdڐdքZdېdׄZdܐd؄ZdNdلZdݐdڄZÐdސd܄ZĐdߐdބZŐdd߄ZƐddZe	 	 dd(d(d(ddd            Ze	 	 dd(d(ddd            Z	 	 dd(d(d(dddZɐddZedUd            ZːddZ̐ddZ͐ddZΐddZϐddZАddZѐddZҐddZӐddZԐddZՐddZ֐ddZאd|d ZؐddZِddZeddddd            ZېddZܐdd	ZݐddZސddZߐdBddZd(dddZ	 dd(dddZddZddZdEdddZddZe	 dBdEddd#            ZedEdd d$            Z	 dBdEddd%Zdd&Z	 ddd(Zdd*Zdd+Zdd,Zdd.Zdd/Zd	d0ZdBd
d2Zdd3Zdd4Zdd5Zdd7Zdd9Zdd;Zdd=Zd(S (  r,  zMypy type checker.

    Type check mypy source files that have been semantically analyzed.

    You must create a separate instance for each source file.
    Fr2   errorsrB   msgzlist[dict[Expression, Type]]r5  r   binder mypy.checkexpr.ExpressionChecker_expr_checkerr'   pattern_checkerr   tscoper   scoper  type
list[Type]return_typesz
list[bool]dynamic_funcszlist[PartialTypeScope]partial_typeszset[Var]partial_reportedz	list[str]widened_varsr   globalsdict[str, MypyFile]moduleszlist[DeferredNode]deferred_nodesr   r   optionsNzdict[Var, Type] | Noneinferred_attribute_typesr&  no_partial_typesset[str]module_refszdict[Var, set[int]]var_decl_framesr   pluginint
_unique_idInstance | None_variance_dummy_typetreer   pathstrper_line_checking_time_nsdict[int, int]r-  r.  c                   || _         || _        || _        || _        || _        t          ||          | _        || _        t                      | _	        t          |          | _        t          |          | _        |j        | _        d| _        g | _        g | _        g | _        t)                      | _        i | _        g | _        g | _        i g| _        t)                      | _        d| _        d| _        |j        | _        |                    |          | _        d| _         d| _!        tE          |           | _#        | j        j$        p*| j        | j        j         j%        v p| j        j&        o| j        | _'        d| _(        d| _)        g | _*        d| _+        d| _,        tZ          j.        /                    | | j        | j        |          | _0        tc          | | j        | j        |          | _2        d| _3        d| _4        dS )zSConstruct a type checker.

        Use errors to report type check errors.
        Nr   FT)5rD  rU  rW  rb  rc  rB   rE  r]  r   rJ  r   rK  r   rF  namesrS  rL  rN  rO  rP  setrQ  r\  rV  rR  r5  r[  pass_numcurrent_node_deferredis_stubis_typeshed_fileis_typeshed_stubrX  allow_constructor_cacher*  local_type_mapignore_errorsignored_filestest_envcan_skip_diagnosticsrecurse_into_functions_is_final_defoverload_impl_stackchecking_missing_awaitallow_abstract_callmypy	checkexprExpressionCheckerrH  r'   rI  r_  ra  )r1  rD  rU  rW  rb  rc  r]  re  s           r  r2  zTypeChecker.__init__  s    		!&'22gg!$''
+G44z	 #! $55%*"| $ 5 5g > >(,%'+$*400 L& AyDHO99A%?$*? 	!
 '+# #
 8:  ',#
 $)  "^==$(DK)B
 
  .dDHdk7SS$(!!!r  c                    | j         S r0  )rH  r1  s    r  expr_checkerzTypeChecker.expr_checker      !!r  list[Type | None]c                    | j         j        S r0  )rH  type_contextr~  s    r  r  zTypeChecker.type_context  s    !..r  c                   | j                                          | j                                         t          | j                  | _        g | j        dd<   | j        d                                          | j                                         g | _	        g | _
        d| _        t          | j                  | _        dS )zCleanup stale state that might be left over from a typechecking run.

        This allows us to reuse TypeChecker objects in fine-grained
        incremental mode.
           Nr   )rQ  clearr[  r   rW  rF  r5  r  resetrV  rP  rX  r   rb  rK  r~  s    r  r  zTypeChecker.reset  s     	##%%%   +DL99   """!!! (,%!$),,


r  c           
        d| _         t          j        | j        j                  5  t          j        |           5  | j                            | j	        | j
        j        | j        | j                   | j                            | j
        j                  5  |                                 5  | j                                        5  | j
        j        D ]x}| j                                        rH|                                 s nH|                     |          s| j                            |            nc|                     |           yddd           n# 1 swxY w Y   ddd           n# 1 swxY w Y   | j        rJ | j                            d          }||j        |j        }|J |                     d|                     d          g          }t?          |j        |          sStA          ||j        | j                  \  }}| !                    tD          j#        $                    ||          |           ddd           n# 1 swxY w Y   ddd           n# 1 swxY w Y   ddd           dS # 1 swxY w Y   dS )a  Type check the entire file, but defer functions with unresolved references.

        Unresolved references are forward references to variables
        whose types haven't been inferred yet.  They may occur later
        in the same file or in a different file that's being processed
        later (usually due to an import cycle).

        Deferred functions will be processed by check_second_pass().
        TrK  rW  N__all__typing.Sequencebuiltins.strrW  )%ru  r   strict_optional_setrW  strict_optionalr!   ri  rD  set_filerc  rb  fullnamerJ  module_scopeenter_partial_typesrF  top_frame_contextdefsis_unreachable should_report_unreachable_issuesis_noop_for_reachabilityrE  unreachable_statementacceptrk  rS  getrL  r  named_generic_type
named_typer   rG   failr   ALL_MUST_BE_SEQ_STRformat)r1  dall_all_nodeseq_str	str_seq_sall_ss          r  check_first_passzTypeChecker.check_first_pass  s    '+#&t|'CDD 	 	mFWX\F]F] 	 	K  	49-T[$, !    ))$)*<==  --// 	+ 	+1N1N1P1P 	+ 	+!Y^ + +;5577 +#'#H#H#J#J & %#'#@#@#C#C & $ > >q A A A %& !KKNNNN	+ 	+ 	+ 	+ 	+ 	+ 	+ 	+ 	+ 	+ 	+ 	+ 	+ 	+ 	+ 	+ 	+ 	+ 	+ 	+ 	+ 	+ 	+ 	+ 	+ 	+ 	+ 	+ 	+ 	+  5555|''	22#	(=#yH#///"55)DOON,K,K+L G &di99 +A#TY, , ,(	5 		,@GG	SXYY[c  3              		 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	s   I>AI&I,E/	BEE/	EE/	E E/	#I/E33I6E37CII&II&II&I>&I*	*I>-I*	.I>>JJT)ro  todo7Sequence[DeferredNode | FineGrainedDeferredNode] | Nonero  c          
        || _         d| _        t          j        | j        j                  5  t          j        |           5  |s | j        s	 ddd           ddd           dS | j	        
                    | j        | j        j        | j        | j                   | j                            | j        j                  5  | xj        dz  c_        |s| j        }n	| j        rJ g | _        t                      }|D ]\  }}||v r
|                    |           t%                      5 }|rZ|                    | j                            |                     |                    | j                            |                     |                     |           ddd           n# 1 swxY w Y   	 ddd           n# 1 swxY w Y   	 ddd           ddd           dS # 1 swxY w Y   ddd           dS # 1 swxY w Y   dS )zRun second or following pass of type checking.

        This goes through deferred nodes, returning True if there were any.
        TNFr  r  )ro  ru  r   r  rW  r  r!   ri  rV  rD  r  rc  rb  r  rJ  r  rj  addr   enter_contextclass_scoperK  
push_classcheck_partial)r1  r  ro  doner  r  stacks          r  check_second_passzTypeChecker.check_second_pass/  sX    (?$&*#&t|'CDD 	 	mFWX\F]F] 	 	  3 	 	 	 	 	 	 	 	 	 	 	 	 	 	 K  	49-T[$, !    ))$)*<== 1 1" 3.DD#2222&(#LOEE-1 1 1)D/t||  HHTNNN" 1* X!//0G0G0X0XYYY!//
0E0Eo0V0VWWW**4000	1 1 1 1 1 1 1 1 1 1 1 1 1 1 111 1 1 1 1 1 1 1 1 1 1 1 1 1 1( 5	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	s   G;G#G;%AG# A(F?(A2F&F?&F**F?-F*.F?3G#?GG#GG#G;#G'	'G;*G'	+G;;G?G?r  .DeferredNodeType | FineGrainedDeferredNodeTypec                   g | _         t          |t                    r|                     |           d S d| _        | j                                        5  |                     |           d d d            d S # 1 swxY w Y   d S NT)rR  
isinstancer   check_top_levelru  rF  r  r  r1  r  s     r  r  zTypeChecker.check_partialW  s    dH%% 	"  &&&&&*.D'..00 " "D!!!" " " " " " " " " " " " " " " " " "s   A77A;>A;c                    d| _         |                                 5  | j                                        5  |j        D ]}|                    |            	 ddd           n# 1 swxY w Y   ddd           n# 1 swxY w Y   | j        rJ dS )zDCheck only the top-level of a module, skipping function definitions.FN)ru  r  rF  r  r  r  rk  )r1  r  r  s      r  r  zTypeChecker.check_top_level`  s   &+#%%'' 	# 	#..00 # # # #AHHTNNNN## # # # # # # # # # # # # # #	# 	# 	# 	# 	# 	# 	# 	# 	# 	# 	# 	# 	# 	# 	#
 ------s4   A: A#A:#A'	'A:*A'	+A::A>A>r  enclosing_classc                V    | j                             t          ||                     dS )a  Defer a node for processing during next type-checking pass.

        Args:
            node: function/method being deferred
            enclosing_class: for methods, the class where the method is defined
        NOTE: this can't handle nested functions/methods.
        N)rV  r6  r  )r1  r  r  s      r  
defer_nodezTypeChecker.defer_nodek  s+     	""<o#F#FGGGGGr  namecontextre   c                *   | j                                         }| j        | j        k     rNt	          |t
                    r9| j                             |          }|                     ||           d| _        d S | j	        
                    ||           d S r  )rK  top_level_functionrj  	last_passr  rp   r  r  rk  rE  cannot_determine_type)r1  r  r  r  r  s        r  handle_cannot_determine_typez(TypeChecker.handle_cannot_determine_typex  s    z,,..=4>))jw.G.G)
 #j88>>OOOD/222 *.D&&&H**499999r  stmtr   c                    	 |                     |            dS # t          $ r7}t          || j        j        |j        | j        | j                   Y d}~dS d}~ww xY w)z,Type check a node in the given type context.N)r  	Exceptionr6   rD  filelinerW  )r1  r  errs      r  r  zTypeChecker.accept  sx    	_KK 	_ 	_ 	_!#t{'7DKQUQ]^^^^^^^^^	_s    
A,AA)exit_conditionon_enter_bodybody	else_bodyStatement | Noner  Expression | Noner  Callable[[], None] | Nonec                  | j                             dd          5  t          d | j        D                       }t	          | j                  }t                      }d}	 | j                             ddd          5  |
 |             t          | j        j	        |          5  | 
                    |           ddd           n# 1 swxY w Y   ddd           n# 1 swxY w Y   t          d	 | j        D                       }	t	          | j                  }
|	|k    r| j         j        r|d
k    r|
|k    s|dk    rn|	}|
}|dz  }|dk    rt          d          | j                            |           |r-|                     |          \  }}|                     |           |r| 
                    |           ddd           dS # 1 swxY w Y   dS )zARepeatedly type check a loop body until the frame doesn't change.FT)can_skipconditional_framec              3  >   K   | ]}t          |j                  V  d S r0  lenr%  .0ptss     r  	<genexpr>z*TypeChecker.accept_loop.<locals>.<genexpr>  s*      JJs37||JJJJJJr  r  r  )r  break_framecontinue_frameNc              3  >   K   | ]}t          |j                  V  d S r0  r  r  s     r  r  z*TypeChecker.accept_loop.<locals>.<genexpr>  s*      "N"NC3sw<<"N"N"N"N"N"Nr        z(Too many iterations when checking a loop)rF  frame_contextsumrP  r  rR  r4   r5   rE  rD  r  last_pop_changedRuntimeErroriteration_dependent_errorsfind_isinstance_checkpush_type_map)r1  r  r  r  r  partials_oldwidened_olditer_errorsiterpartials_newwidened_new_else_maps                r  accept_loopzTypeChecker.accept_loop  s    [&&&NN 0	' 0	' JJt7IJJJJJL d/00K244KDS[..!\].^^ * *$0%.txLL * *D)))* * * * * * * * * * * * * * *	* * * * * * * * * * * * * * *  #"N"N4;M"N"N"NNN!$"344 "\11![9 2=AAXX$33taxx+)	2::&'QRRR5S8 H//<<<  -"88HH8""8,,,  'I&&&a0	' 0	' 0	' 0	' 0	' 0	' 0	' 0	' 0	' 0	' 0	' 0	' 0	' 0	' 0	' 0	' 0	' 0	's[   A!G>'C%C;CCCCCGC"	"G%C"	&CGGGdefnr   c                   | j         s	|j        sd S | j                            |          5  |                                 5  |                     |           d d d            n# 1 swxY w Y   d d d            d S # 1 swxY w Y   d S r0  )ru  def_or_infer_varsrJ  function_scopeset_recurse_into_functions_visit_overloaded_func_def)r1  r  s     r  visit_overloaded_func_defz%TypeChecker.visit_overloaded_func_def  s    * 	43I 	F[''-- 	2 	2t/N/N/P/P 	2 	2++D111	2 	2 	2 	2 	2 	2 	2 	2 	2 	2 	2 	2 	2 	2 	2 	2 	2 	2 	2 	2 	2 	2 	2 	2 	2 	2 	2 	2 	2 	2 	2 	2 	2s5   A: A"A:"A&	&A:)A&	*A::A>A>c           	     
   d}|j         sd S t          |j                   dk    r |                     t          j        |           |j        rt          |j         d         t                    sJ |                     |j         d                    |j         d         j	        j
        rs|                     |j        d           |j        j	        j        }t          t          j                  }t#          ||gt$          t$          gd d g||                     d                    }|r0t)          ||          s |                     d|j        j                   |                     ||          }t          |t"                    rt          |j                  dk    r|}||j         d         j	        _        t          |j        t2                    rN|                     |j         d         j	        j        |          }|!|j         d         |_        ||j        j         d<   t7          |j                   D ]\  }}t          |t                    sJ |j        rqt          |j         d         t                    sJ |j         d         j	        j
        }	|	r|dk    s|	s-|dk    r'|                     |j        |j        j        d	           n|                     |d
           |j        j        t>          t@          fv r|dz  }|dt          |j                   fvr |                     t          j!        |           |j"        rL| #                    |j"                  5  |j"        $                    |            d d d            n# 1 swxY w Y   |j        s| %                    |           |j        wg }
|j         D ]W}t          |t                    sJ |                     |j	        j        |          }|||_        |
&                    |           X|
rt3          |
          |_        n|j        t          |j         d         t                    sJ |                     |j         d         j	        j        |          }t          |t"                    sHt          t          j                  }t#          |gt$          gd g||                     d                    }t3          |g          |_        | j'        s|j(        r| )                    |          }|j*        r0|s.|,|j(        j+        s | j,        -                    |j        |           | .                    |||j"                   | /                    |           d S d S d S )Nr   r  T)skip_first_itembuiltins.function)	arg_types	arg_kinds	arg_namesret_typefallbackz!Invalid property setter signaturer  r  allow_empty)r   )0itemsr  r  r   MULTIPLE_OVERLOADS_REQUIREDis_propertyr  rg   visit_decoratorvaris_settable_propertyvisit_decorator_innersetterrL  r   r   special_formr   rM   r  r   funcextract_callable_typer  setter_typer   
definition	enumeratecheck_func_itemr  abstract_statusrU   rS   INCONSISTENT_ABSTRACT_OVERLOADimplenter_overload_implr  check_overlapping_overloadsr6  rt  infocheck_method_overrideis_explicit_overridefallback_to_anyrE  no_overridable_method!check_explicit_override_decoratorcheck_inplace_operator_method)r1  r  num_abstractr  any_typefallback_setter_typegetter_typeifdefsettable
item_typesitem	item_typevar_typefound_method_base_classess                  r  r  z&TypeChecker._visit_overloaded_func_def  s   z 	 Ftz??aII&BDIII 	9djmY77777  A///z!} 5 9**4;*MMM"ko2"9#9::'3'2&0#Tl%!__-@AA( ( ($  Uz+?S'T'T UIIA4;CSTTT"88dKK!+|<< 7KDY@Z@Z^_@_@_"6K0;
1!-di44 9"&"<"<TZ]=N=SUY"Z"ZK".15A.-8	* ,, 	" 	"GAtdI..... 	C!$*Q-;;;;;:a=,A [QQUU((UY(ZZZ **4T*BBBy([:M,NNN!3tz??333II&EtLLL9 	'))$)44 ' '	  &&&' ' ' ' ' ' ' ' ' ' ' ' ' ' ' 	/,,T222y 
 J 5 5D%dI66666 $ : :48=$ O OI ,/3	,")))444 7 *: 6 6DIY djmY7777711$*Q-2C2H$OOHh55 	"9#9::''j&i#f%!__-@AA   #H:..DI( 	5TY 	5(,(B(B4(H(H%)@1@ .9 	1 :
 ..ty$???2249RTXT]^^^..t44444	5 	5 	5 	5s   M88M<?M<r  r   Iterator[None]c              #     K   | j                             |           	 d V  | j                                         |k    sJ d S # | j                                         |k    sJ w xY wr0  )rw  r6  r@  )r1  r  s     r  r  zTypeChecker.enter_overload_impl=  s}       ''---	:EEE+//11T9999994+//11T99999999s   A !A$
inner_typeType | NonectxCallableType | Nonec                .   t          |          }d}|t          |t                    rdS t          |t                    rt          |j                  }t          |t
                    r-t          | j                            |j        |                    }t          |t                    r|}nt          |t                    r<t          t          d||ddd||                     }t          |t                    r|}nt          |t                    rt          |j                  }t          |t                    rtg }|j        D ]1}|                     ||          }| nN|                    |           2t          t#          j        |                    }	t          |	t                    r|	}n|                     ||          S || j                            ||           dS t          |t*                    rdS t          |t,                    sJ |S )z,Get type as seen by an overload item caller.N__call__FT)r  typr  	is_lvalueis_superis_operatororiginal_typer+  )r   r  r   r   upper_boundr   r  analyze_type_type_calleer$  r   r   r%   r   r   r  r  r6  r   join_type_listrE  not_callabler   r   )
r1  r*  r,  
outer_type
inner_call
union_typer  r$  callable_itemjoined_types
             r  r  z!TypeChecker.extract_callable_typeE  s*   $Z00
*.
J!@!@4j/22 	A()?@@Jj(++ 	(!:::?CPP J j,// 	C#JJ
H-- 	C(%#"#" $",	 	 	 J *l33 ('

I.. 	C.z/?@@J*i00 C&, 1 1D$($>$>tS$I$IM$,LL////"1$2Ee2L2L"M"MK!+|<< 1%0
11*cBBBH!!*c2224j*-- 	4*l33333r  c           	        | j         rd S d }|j        rxt          |j        t                    r|j        j        }n6t          |j        t
                    r|j        j        j        }n
J d            |                     ||j                  }|j        o
|j	        dk    }t          |j                  D ]\  }}t          |t
                    sJ |                     |j        j        |          }|@t          |j        |dz   d                    D ]H\  }}	t          |	t
                    sJ |                     |	j        j        |	          }
|
@t          ||
          sQt          ||
          r+| j                            |dz   ||z   dz   |	j                   |s| j                                        }|r|j        j        ng }t+          j        d          5  t/          ||
|          rT|dk    o"t/          |
||           ot          |
|           }| j                            |dz   ||z   dz   ||j                   d d d            n# 1 swxY w Y   J|e|j        J t3          ||t4          dd 	          r|j        rdt9          |                                |                                dt<          
          }|%| j                            |dz   |j                   ;n|}|j         r9|j        r2|!                    |j         d         g|j         dd          z             }t3          ||t4          dd          s#| j        "                    |dz   |j                   t5          |j#        |j#                  s=t5          |j#        |j#                  s#| j        $                    |dz   |j                   d S )NFzImpl isn't the right type__get__r  r  Tr   c                "    t          ||           S r0  r   lrs     r  <lambda>z9TypeChecker.check_overlapping_overloads.<locals>.<lambda>  s    *Q2B2B r  )	is_compatr   is_compat_return)ignore_returnreturn_constraint_direction)r  rF  r   rH  )%rt  r  r  rp   rL  rg   r  r  r  r  r  r  are_argument_counts_overlappingoverload_can_never_matchrE  %overloaded_signature_will_never_matchr
  rK  active_classr  	type_varsr   r  )is_unsafe_overlapping_overload_signaturesoverloaded_signatures_overlapr   r   	variablesr   with_unpacked_kwargsr(   &overloaded_signatures_typevar_specificr  copy_modified$overloaded_signatures_param_specificr  "overloaded_signatures_ret_specific)r1  r  	impl_typer*  is_descriptor_getr   r$  sig1jitem2sig2current_classrO  	flip_noter  s                  r  r  z'TypeChecker.check_overlapping_overloads|  s    $ 	F *.	9 
	J$)W-- :*.).

DIy11 :!Y]/

99999 22:tyIII I@$)y*@ ,, c	R c	RGAtdI.....--dhmTBBD|%djQ&9:: & &5!%3333311%).%HH<6tTBB +D$77 HBB1q5!a%RS)UZU_````*  %)J$;$;$=$=M@M U 2 < <SUI2488  DT4QZ[[ 
 !Q !M(Q$($	)" )" %"!M )At(L(L$L & !HBB !Aq1uqy)TY                 $y,,, *(&+%B%B     & %0F!66881133&+4@1 1 1D |GGAtyYYY  $ %D > bdi b--9J8Kdn]^]_]_N`8`-aaD .$*]a   T HAA!a%SSS t}dm<<R!$-??R H??AtyQQQGc	R c	Rs   A&IIIr0  r   is_coroutinec                x   t          |          }|rA|                     dt          t          j                  g          }t          ||          rdS nDt          t          j                  }|                     d|||g          }t          ||          rdS t          |t                    o|j        j	        dk    S )zIs `typ` a valid type for a generator/coroutine?

        True if `typ` is a *supertype* of Generator or Awaitable.
        Also true it it's *exactly* AwaitableGenerator (modulo type parameters).
        typing.AwaitableTtyping.Generatortyping.AwaitableGenerator)
r   r  r   r   r	  r   r  r   rL  r  )r1  r0  r`  atr  gts         r  is_generator_return_typez$TypeChecker.is_generator_return_type"  s     c"" 		(();giF\>]>]=^__B"c"" t y566H(();hRZ=[\\B"c"" t#x((]SX->B]-]]r  c                    	 t          t          j                  }|                     d||g          }n# t          $ r Y dS w xY wt          ||          S )zoIs `typ` a valid type for an async generator?

        True if `typ` is a supertype of AsyncGenerator.
        typing.AsyncGeneratorF)r   r   r	  r  KeyErrorr   )r1  r0  r  agts       r  is_async_generator_return_typez*TypeChecker.is_async_generator_return_type5  sh    
	y566H))*AHhCWXXCC 	 	 	55	 #s###s   14 
AAreturn_typec                    t          |          }t          |t                    rt          t          j        |          S t          |t
                    r!t           fd|j        D                       S                      |          s. 	                    |          st          t          j
                  S t          |t                    st          t          j
                  S |j        j        dk    rt          t          j                  S |j        r|j        d         }|S t          t          j                  S )zRGiven the declared return type of a generator (t), return the type it yields (ty).
source_anyc                <    g | ]}                     |          S r  )get_generator_yield_typer  r$  r`  r1  s     r  
<listcomp>z8TypeChecker.get_generator_yield_type.<locals>.<listcomp>J  s)    aaat..t\BBaaar  rb  r   )r   r  r   r   from_another_anyr   r   r  rg  rl  
from_errorr   rL  r  r	  args)r1  rm  r`  r  s   ` ` r  rr  z$TypeChecker.get_generator_yield_typeB  s8   %k22k7++ 	395+NNNNY// 	3(aaaaa{O`aaa   ..
 
 	355kBB	3
 9/000K22 	39/000&*<<<91222 
	3"'*HO 91222r  c                    t          |          }t          |t                    rt          t          j        |          S t          |t
                    r!t           fd|j        D                       S                      |          s. 	                    |          st          t          j
                  S t          |t                    st          t          j
                  S |j        j        dk    rt          t          j                  S |j        j        dv r%t          |j                  dk    r|j        d         S |j        j        dk    r%t          |j                  dk    r|j        d         S t#                      S )	zTGiven a declared generator return type (t), return the type its yield receives (tc).ro  c                <    g | ]}                     |          S r  )get_generator_receive_typers  s     r  rt  z:TypeChecker.get_generator_receive_type.<locals>.<listcomp>l  s)    ccc00|DDcccr  rb  rc  rd  r  r  ri  r  )r   r  r   r   ru  r   r   r  rg  rl  rv  r   rL  r  r	  r  rw  r   r1  rm  r`  s   ` `r  rz  z&TypeChecker.get_generator_receive_typed  s   %k22k7++ 	95+NNNNY// 	(cccccQ\Qbccc   ..
 
 	55kBB	
 9/000K22 	9/000&*<<<91222%)ZZZK$%%** #A&&&*AAAc+JZF[F[_`F`F`#A&& ::r  c                    t          |          }t          |t                    rt          t          j        |          S t          |t
                    s
J d            |j        d         S )Nro  z-Should only be called on coroutine functions.r  )r   r  r   r   ru  r   rw  )r1  rm  s     r  get_coroutine_return_typez%TypeChecker.get_coroutine_return_type  se    %k22k7++ 	O95+NNNN+x00aa2aaaa""r  c                    t          |          }t          |t                    rt          t          j        |          S t          |t
                    r!t           fd|j        D                       S                      |          st          t          j	                  S t          |t                    st          t          j	                  S |j        j        dk    r%t          |j                  dk    r|j        d         S |j        j        dv r%t          |j                  dk    r|j        d         S t                      S )	zSGiven the declared return type of a generator (t), return the type it returns (tr).ro  c                <    g | ]}                     |          S r  )get_generator_return_typers  s     r  rt  z9TypeChecker.get_generator_return_type.<locals>.<listcomp>  s)    bbb//lCCbbbr  rb  r  r   r{  r  r  )r   r  r   r   ru  r   r   r  rg  rv  r   rL  r  r  rw  r   r|  s   ` `r  r  z%TypeChecker.get_generator_return_type  sE   %k22k7++ 	95+NNNNY// 	(bbbbbP[Pabbb   ..{LII 	 9/000K22 	9/000&*<<<[EUAVAVZ[A[A[#A&&%)ZZZK$%%** #A&& ::r  rp   c                8   | j         s	|j        sd S | j                            |          5  |                                 5  |                     ||j                   | j        sU|j        rN|j	        s2|j
        s+|                     |          }|                     ||           |                     |           |j        r+|                     |          }|                     ||           d d d            n# 1 swxY w Y   d d d            d S # 1 swxY w Y   d S )Nr  )ru  r  rJ  r  r  r  r  rt  r  is_overloadis_decoratedr  r  r  original_defr   check_func_def_override)r1  r  r'  new_types       r  visit_func_defzTypeChecker.visit_func_def  s   * 	43I 	F[''-- 	= 	=t/N/N/P/P 	= 	=  DI 666, 	=9 =+ `D4E `
 594N4Nt4T4T1>>tE^___66t<<<  =--d33,,T8<<<	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	=s6   D B+C7+D7C;	;D>C;	?DDDrq   type_override
str | Noner   c                   | j                             |                                o|            | j        }|                     d          5  |                     |          }|r!|                    |j        |j                  }t          |t                    rE|                                 5  |                     ||||           ddd           n# 1 swxY w Y   nt          d          ddd           n# 1 swxY w Y   | j                                          || _        |dk    r|                     |           |dk    r6t!          j        |j                  rt!          j        | ||j                   dS dS dS )zcType check a function.

        If type_override is provided, use it as the function type.
        T)r'  )r  columnNzNot supportedrA  __post_init__)rO  r6  
is_dynamicrk  r  r   rU  r  r  r  r   !enter_attribute_inference_contextcheck_func_defr  r@  check__exit__return_typedataclasses_pluginis_processed_dataclassr  check_post_init)r1  r  r  r  r   enclosing_node_deferredr0  s          r  r  zTypeChecker.check_func_item  s!    	!!$//"3"3"IM8IJJJ"&"<%%$%77 	4 	4$$T**C T#11sx
1SS#|,, 4;;== F F''c4EEEF F F F F F F F F F F F F F F #?333	4 	4 	4 	4 	4 	4 	4 	4 	4 	4 	4 	4 	4 	4 	4 	   %<":))$/// ?""!8CC J"24tyIIIII #"J Js7   A"C;/CC;C	C;C	C;;C?C?r  r   c                   |j         J t          |j         t                    rJ|                     |j                   }t	          ||          s| j                            |||           d S d S |j         j        }|d S t          |t                    rt|j        K|j         }t          |t                    r|j
        }n|}|                     |          }|||_        ||= d S d S |                     t          j        |           d S t          |j                  }|j         |_        | j                            |||           |                     |||t          j        dd           d S )Nzredefinition with typezoriginal type)r  r  rp   r   r   rE  %incompatible_conditional_function_defrL  r   rg   r  find_partial_typesr  r   INCOMPATIBLE_REDEFINITIONr   r  r  rF  assign_typecheck_subtype)	r1  r  r  old_type	orig_typeorig_defr  rP  	name_exprs	            r  r  z#TypeChecker.check_func_def_override  s    ,,,d'11 '	))$*;<<H(33 Y>>tXxXXXXXY Y
 ).I  )[11 >)#0H!(I66 '&l&$($;$;C$@$@M$0#+)#... 10
 II.H$OOOOO$TY//	!%!2	''	8YGGG""$>,#    r  c              #  <   K   | j         }i | _         d V  || _         d S r0  )rX  )r1  	old_typess     r  r  z-TypeChecker.enter_attribute_inference_context  s-      1	(*%


(1%%%r  r   c                z   |                      |j                   |                     ||          }|}|D ]\  }}| j        }t	          | j                  | _        | j                                        5  |j                            |           | j	        s| 
                    |||||           |j        r|j        }	|j        }
|                     |	|
          }|                     |	|
          }|
r|                     |	          }n|                     |	|
          }|                     d||||	g          }|                    |          }||_        | j                            |j                   | j                            |          5  | j                                        }ddd           n# 1 swxY w Y   |j        rd}|	|j        rd}|t7          |j                  k     rt;          |j        |j        |                   sj|                     t>          j         !                    tE          |j        | j                  tE          |j        |         | j                            |           d}tG          |tH                    r|j%        s| &                    ||          }tO          t7          |j                            D ]}|j        |         }tG          |tP                    rd|j)        tT          k    rT|j+        dvrKtY          |j+                  s7|dk    s|s/|}|j-        dk     r|}|                     t>          j.        |           t_          |||| j                   ta          |j1                  }| j	        s| 2                    ||           ddd           n# 1 swxY w Y   | j                                        5  d}|j3        D ]}|j4        5                                D ]p\  }}tm          |          }|Z| 7                    ||j-                  s?|| j        8                                }||j4        |<   |j9        |         | j        j9        |<   q| j        j:        r`| j;        sY|j<        D ]Q}|j=        }|j        At}          |j+                  }||_?        | j        @                    ||j        |j                   R| j                            |          5  t          |          st7          |          d	k    r| j        B                                 | j	        r(| j        jC        stG          |tH                    r|jD        r| E                    |j1                   ddd           n# 1 swxY w Y   | j        F                                }|| j        G                    d
d           ddd           n# 1 swxY w Y   |s|jH        st          | j        d         d          r'|                     | j        d         |j                  }n5|j        r!|                     | j        d                   }n| j        d         }t          |          }|p| j        jK        }| p0| o-tG          |tH                    o|jL        t          k     o| j;         } | j	        sw|jN        t          ur/|j+        |jN        jP        vsV|jN        jP        |j+                 jQ        s:tG          |tH                    r|jR        s|rt;          t                      |          rd} | rr| jT        sj|o?|jN        t          uo1|jN        jU        duo#|jN        jU        j        V                    d          }!| j        jW        rtG          |t          t          f          stG          |t                    rt>          jZ        }"nt>          j[        }"|r |"\                    t          j^                  }"|                     |"|           |!r | _                    t>          j`        |           nwt>          ja        }"|r |"\                    t          j^                  }"| b                    dt                      d|||"          s"|!r | _                    t>          j`        |           | j        c                                 || _        dS )z!Type check a function definition.)r  original_typrd  )r  Nr   r  F)r2  __new__r  r  Tabc.ABCMetacodezimplicitly returnsexpected)subtype_labelsubtypesupertype_label	supertyper  rE  )dcheck_typevar_defaultsrR  expand_typevarsrF  r   rW  r  expandedr6  rt  check_funcdef_itemis_awaitable_coroutiner  r`  rr  rz  r~  r  r  rU  rL  rN  rK  push_functionactive_self_typetype_ishas_self_or_cls_argumentr  r  r   r  r   NARROWED_TYPE_NOT_SUBTYPEr  rE   r  rp   r  require_correct_self_argumentranger   variancerP   r  
is_privater  &FUNCTION_PARAMETER_CANNOT_BE_COVARIANTr  r   r  check_default_paramsframestypesr  r9   !is_var_redefined_in_outer_context
push_framedeclarationsallow_redefinition_newrl  	argumentsvariabler   r  r  _is_empty_generator_functionsuppress_unreachable_warningspreserve_astsr  r  r  	pop_frameis_generatorr   r   allow_empty_bodiesr  rY   r  rQ   rh  plugin_generatedis_mypy_onlyr   rk  metaclass_typehas_basewarn_no_returnr   r   INVALID_IMPLICIT_RETURNMISSING_RETURN_STATEMENT_replacecodes
EMPTY_BODYnoteEMPTY_BODY_ABSTRACTINCOMPATIBLE_RETURN_VALUE_TYPEr  r@  )#r1  r  r0  r  r   r  r  r$  
old_bindertctytctrr  ref_type	arg_index
found_selfr   arg_typer,  body_is_trivial	new_frameframekeynarrowed_typekey_varargvnunreachablerm  
show_errormay_be_abstractrE  s#                                      r  r  zTypeChecker.check_func_def  sw
   
 	##CM222''c22! `	% `	%ID#J/==DK..00 LE LE$$T***
 0 c++D#t$Ua+bbb . $ A)A66q!<<B88A>>B B!;;A>>!;;AqAA#663b"b!_   H ++X+>>C #DI !((666Z--d33 J J -1J,G,G,I,IHJ J J J J J J J J J J J J J J
 ;  !I+0M+$%	 3s}#5#555jS]9%=? ?5 		,FMM +CK F F +CM),Ddl S S  !   #
dG,, OT5F O!%!C!CC!N!NJs3=1122 O OA"}Q/H!(K88 d %-:: $	1Y Y Y$.ty$9$9 !Z!"az+3C"x!||&) II&6&]_bccc'ad6MNNNN #2$)"<"<0 E--dODDDYLE LE LE LE LE LE LE LE LE LE LE LE LE LE LE^ ..00 43 43 +/	'. 
Y 
YE.3k.?.?.A.A 	Y 	Y*]"?"D"D".t7]7]#TY8 8.  )0,0K,B,B,D,D	3@IOC0<F<STW<XDK4S9	Y <6 Gt| G#~ G GL6- ( 0 0A%&AF K33AqvqvFFFZ--d33 / / 4D99 DS]]a=O=OAACCC
 !5/<5/  *$88/  1	/ DI...-/ / / / / / / / / / / / / / /. #k88::(K))$222i43 43 43 43 43 43 43 43 43 43 43 43 43 43 43l  TR$ 	8(9%b)+F) ) 	8 #'"@"@)"-t/@# #KK & 8"&"@"@ARSUAV"W"WKK"&"3B"7K-k::)LT\-L (' 	 ( -&tW55^$:NR^:^- !%,  -' 	55 ITY_<<#yty9J = #411 = 7;6G = ( = -7xzz;,O,O = "'J %Rd&@ %R' R I\9R I4D@R !I49BB=QQ	 $ |2 R)+'7JKK V  *+GG P&6&N&6&O. J&)ll8Hl&I&I IIc4000. V $		*:*NPT U U U.M* F"%,,E4D,"E"EC !% 2 2.B(0

0:*5(,$' !3 ! !R !0R !II&6&JDQQQ!!###$DKKA`	% `	%sp   4DN(F5)N(5F99N(<F9=GN((N,	/N,	DW)BU:.W:U>>WU>9WW	W	r$  r  c                  t          |t                    r|}|j        r||j        dv rst          t	          |j                  t          t          f          sE| j        d         s8| 	                    t          j                            |j                  |           |j        r!|j        dk    r|                     ||           |                     |           | j        j        r|j        rt          |j        t$                    r|j        j        }t'          |          r| j                            d||           t-          |j        j                  D ]A\  }}	t'          |	          r-d|dz    d|j         d}
| j                            |
|	|           Bt1          |j        | j        | j        | j        |	           |rv|j        r7|                     |          r"|| j        vr|                     ||||           n8|d
v r|                     |||           n|dk    r|                     ||           t          |j        t>                    rP|j        j         tB          k    r%| 	                    t          j"        |j                   | #                    |           n;t          |j        t>                    r!|j        j$        r| #                    |           |j%        r|j&        r>| '                    |j                  s"| 	                    t          j(        |           d S d S | )                    |j        |j*                  s$| 	                    t          j+        |           d S d S d S )N)r2  __init_subclass__r  r  zReturn typez	Argument r  z to ""r  )__getattr____getattribute____setattr__),r  rp   r  r  r   r  r   r   rO  r  r   MUST_HAVE_NONE_RETURN_TYPEr  check___new___signaturecheck_for_missing_annotationsrW  disallow_any_unimportedrL  r   r   rE  unimported_type_becomes_anyr  r  r   rn  is_reverse_op_methodrw  check_reverse_op_methodcheck_getattr_methodcheck_setattr_methodr   r  rO   #RETURN_TYPE_CANNOT_BE_CONTRAVARIANTcheck_unbound_return_typevarvaluesr  is_async_generatorrl  'INVALID_RETURN_TYPE_FOR_ASYNC_GENERATORrg  r`  !INVALID_RETURN_TYPE_FOR_GENERATOR)r1  r$  r0  r  r  r  r!  r  idxr  prefixs              r  r  zTypeChecker.check_funcdef_item  s    dG$$ 	D 	_I!BBB"?3<#@#@8_B]^^ C*2. C 		*ELLTYWWY]^^^ y 8TY)33,,T3777..t444|3 Y9 YDI|!D!D Y#y1H3H== \<<]HVZ[[[)2493F)G)G Y YX7AA Y%Kq%K%Kty%K%K%KF H@@SWXXX"	4<)>RV     
	5		5--d33	5  888,,T3dCCCC<<<))#tT::::&&))#t444 clK00 	<|$55		*NPSP\]]]--c2222-{;; 	<@U@\ 	< --l;;;  	W& W::3<HH ]II.VX[\\\\\] ] 44S\4CTUU WII.PRUVVVVV	W 	W
W Wr  r
  c                f   t          |          }t          |t                    sdS | j        j        sMt          | j                  dk     s5| j        d         r(|                                rt          |j	                  S | j
                            |          5  | j
                                        }|	 d d d            dS 	 d d d            n# 1 swxY w Y   |j        r,|j        r'|j        d         t          j        t          j        fv rdS |j	        s|                     d|           dS | j        rdS |j	        d         }|j        s|j        dk    r$t,          j        j                            |          }t5          ||          rdS t          t7          t9          |                              }t;          ||d          st          |t<                    r|j        j         s@t          |t0                    r.t          |j!        t<                    r|j!        j        j         rd }nl|j"        d         d	v rQtF          j$        %                    |&                    | j                  |&                    | j                            }ntF          j'        }|r|                     ||           dS )
NFr  r   zKMethod must have at least one argument. Did you forget the "self" argument?Tr  )ignore_type_params>   clsr1  )(r   r  r   rW  check_untyped_defsr  rO  r  r&  r  rK  r  r  r  r  r   rN   	ARG_STAR2r  rt  is_classr  rz  r  r   make_normalizedr   r*   r   r   r   rL  is_protocolr$  r  r   ERASED_SELF_TYPE_NOT_SUPERTYPEr  str_with_optionsMISSING_OR_INVALID_SELF_TYPE)r1  r
  r  r  r  erasedrE  s          r  r  z)TypeChecker.require_correct_self_argumentF  s   t$$$-- 	5 L+	(4%&&**%b) +??$$ + '''Z%%d++ 	 	 %)J$?$?$A$AH	 	 	 	 	 	 	 	  		 	 	 	 	 	 	 	 	 	 	 	 	 	 	 , 	N	#~a0U^U_4UUU5~ 	II]_c   5$ 	4>!$= 	EDI22z*::8DDH(++ 	4 !x0H0H!I!IJJ(FtDDD 	%68,,DK+D fh//D v{H55	D
 K$0D "o55&ELL++DL998;T;TUYUa;b;b  'C %		#t$$$ts   CCCr  r   
after_linec                    |j         rdS | j                                        }|sdS |D ]3}t          |t                    rt          |j        |          |k    r dS 4dS )zCan the variable be assigned to at module top level or outer function?

        Note that this doesn't do a full CFG analysis but uses a line number based
        heuristic that isn't correct in some (rare) cases.
        FT)is_finalrJ  outer_functionsr  rp   find_last_var_assignment_liner  )r1  r  r  outersouters        r  r  z-TypeChecker.is_var_redefined_in_outer_context  sz     : 	5,,.. 	 4 	  	 E%))  0Q??:MM44ur  c                *   t          |j        t                    r|j        |j        v rt	                      }|j        D ]}|                    |           |j        |j        vr|                     t          j	        |j        t                     t          |j        j                  }t          |t                    r|j        j        dk    sE|                     dt#          |j        j        | j                   d|j                   dS dS dS dS dS )z:Fails when the return typevar is not defined in arguments.r  builtins.objectzConsider using the upper bound z insteadr  N)r  r  r   rR  CollectArgTypeVarTypesr  r  r  r   UNBOUND_TYPEVARr-   r   r5  r   rL  r  r  rE   rW  )r1  r0  arg_type_visitorargtyper5  s        r  r  z(TypeChecker.check_unbound_return_typevar  s3   clK00 	S\S]5R5R577= 1 1/0000|#3#===		*:CLx	XXX-cl.FGG{H55#(15FFFIIY&s|'?NNY Y Y #      	 	5R5R
 >=
 GFr  r  c           
        |j         D ]}|j        
|rt          |j        t                    r'|j        j        }d}|                    d          r|d|dd           z  }n	|d| dz  }| j        j        s/t          |j        t                    r|j        j
        dk    rdd	g}nd }|                     |j        j        |j        |j        t          |t          j        
          dd|           d S )NzIncompatible default for __tuple_param_ztuple parameter    zparameter "r  builtins.NonezkPEP 484 prohibits implicit Optional. Accordingly, mypy has changed its default to no_implicit_optional=Truez_Use https://github.com/hauntsaninja/no_implicit_optional to automatically upgrade your codebaser  	parameterdefault)r  rE  lvalue_namervalue_namenotes)r  initializerr  rj   r  r  
startswithrW  implicit_optionalr   r  check_simple_assignmentrL  r@   r  
ASSIGNMENT)r1  r$  r  paramr  rE  r*  s          r  r  z TypeChecker.check_default_params  sA   ^  	  	E ( :e.?#N#N >&D-C/00 -5$rss)555,T,,,,L2u0(;; %./AA], ((#!) 5+;<<<'% )    1 	  	r  method_namec                    |t           j        v S r0  )r   reverse_op_methodsr1  r1  s     r  is_forward_op_methodz TypeChecker.is_forward_op_method  s    i:::r  c                    |t           j        v S r0  )r   reverse_op_method_setr4  s     r  r  z TypeChecker.is_reverse_op_method  s    i===r  r!  c                ^   | j          p| j        j        }|sd S ddt          |j        t
                    o2t          fd|j        j        |j        j        gz   D                       }| j        j	        o|}| j        j
        s|r!|j        | j        j
        r|j        r:t          |j                  dk    r|j        d         d	k    s|j        d         d
k    r^|                     t          j        |           t#          |          s+|j        s&|                     d|t(          j                   d S d S d S |                     t          j        |           d S t          |j        t
                    r4t/          |j        j                  } |          r!|                     t          j        |           n|j        rE |                     ||j                            r |                     t          j        |           nZ|j        rSt          |t4                    r> |                     |                    r |                     t          j        |           t          fd|j        j        D                       r&|                     t          j        |           d S d S d S d S )Nr  r   r-  r&  c                    t          | t                    sdS t          | t                    o| j        t          j        k    S r?  )r  r   r   type_of_anyr   unannotatedr  s    r  is_unannotated_anyzETypeChecker.check_for_missing_annotations.<locals>.is_unannotated_any  s8    a,, ua))Tamy?T.TTr  c              3  0   K   | ]} |           V  d S r0  r  r  r  r=  s     r  r  z<TypeChecker.check_for_missing_annotations.<locals>.<genexpr>  sK       N
 N
*+""1%%%N
 N
 N
 N
 N
 N
r  r  r   r1  r  z1Use "-> None" if function does not return a valuer  c              3  .   K   | ]} |          V  d S r0  r  r?  s     r  r  z<TypeChecker.check_for_missing_annotations.<locals>.<genexpr>  s/      JJ))!,,JJJJJJr  r  r   r-  r&  )rn  rW  warn_incomplete_stubr  rL  r   anyr  r  disallow_incomplete_defsdisallow_untyped_defsr  r  r  r  r   RETURN_TYPE_EXPECTEDr   r  r  r  NO_UNTYPED_DEFFUNCTION_TYPE_EXPECTEDr   r  r`  r   r~  PARAM_TYPE_EXPECTED)r1  r!  show_untypedhas_explicit_annotationcheck_incomplete_defsr  r=  s         @r  r  z)TypeChecker.check_for_missing_annotations  s'   00UDL4U 	F	U 	U 	U 	U
 #-TY"E"E #
# N
 N
 N
 N
/3y/BdiFXEY/YN
 N
 N
 K
 K
 !% E aJa<- 	J1F 	Jy T\%G ~ M''1,,*f44q8IU8R8RII.CTJJJ/55 d>O 		O !&!5 "         II.EtLLLLLDI|44 J*49+=>>%%h// 	OII.CTJJJJ& O))66xARSS  O 		"2"GNNN& O:h+I+I O))$*H*H*R*RSS O		"2"GNNNJJJJdi6IJJJJJ JII.BDIIIII9	J 	JJ JJ Jr  c                j   t          |j                  }t          ||d          }|j                                        r=|                     |j        |                                 |t          j        dd           d S t          t          |j                  t          t          t          t          t          f          sM|                     t          j                            t'          |j        | j                            |           d S |                     |j        ||t          j        dd           d S )NT)is_classmethodreturnszbut must return a subtype of)r  r  r   is_metaclassr  r  	type_typer   INVALID_NEW_TYPEr  r   r   r   r   r   r   r  NON_INSTANCE_NEW_TYPEr  rE   rW  )r1  r!  r0  	self_type
bound_types        r  r  z#TypeChecker.check___new___signature  s<   *4955	sIdCCC
 9!!## 	#   1.     J/00h	?KH
 
 	 II 6==
 3T\BB  	     # 1.    r  reverse_typereverse_namec           	        |j         sJ t          t          t          j                  t          t          j                  gt
          j        t
          j        gddgt          t          j                  |                     d                    }t          ||          s| j	        
                    ||           dS |dv rdS t          |j                  }t          |t                    rdS t          |t                    r|j        j        dk    rdS |j        d         t$          k    r=|                    |j        d         gdz  t          gdz  |j        d         dg          }t-          |j                  dk    sJ t.          j        |         }t          |j        d	                   }t          |t2                    rt          |j                  }nNt          |t6                    rt9          |          }n)t          |t:          t<          t>          f          r|j         }t          |tB                    r,|j"        }	t          |	t                    r|	j        j#        }
|
|
}dfdt          |t          tH          f          r ||          sdS |j        d	         }| j%        &                    |||          }| '                    |||j         ||||           dS )z1Check a reverse operator method such as __radd__.Nr  )__eq____ne__r  r   r  r  r  r  r  r  r0  UnionType | Instancer  rd  r-  r&  c                    t          | t                    r| j                                      S t	          fdt          |                                           D                       S )Nc              3     K   | ]T}t          |t                    r |          p.t          |t                    o|j                                      V  Ud S r0  )r  r   r   rL  has_readable_member)r  xr_  r  s     r  r  zSTypeChecker.check_reverse_op_method.<locals>.has_readable_member.<locals>.<genexpr>k  s~          Ay))J.A.A!T.J.J Rq(++P0J0J40P0P     r  )r  r   rL  r_  allr   relevant_items)r0  r  r_  s    `r  r_  z@TypeChecker.check_reverse_op_method.<locals>.has_readable_memberg  s    #x(( :x33D999      *#*<*<*>*>??     r  r  )r0  r\  r  rd  r-  r&  )(r  r   r   r   r	  r   rM   r  r   rE  invalid_signaturer   r  r  r   rL  r  r  rN   rU  r  r  r  r   normal_from_reverse_opr   r5  r   r   r   r   r   r  r   r$  r  r   r  analyze_external_member_accesscheck_overlapping_op_methods)r1  r  rV  rW  r  method_typer  forward_nameforward_instr$  opt_metaforward_baseforward_typer_  s                @r  r  z#TypeChecker.check_reverse_op_method,  s    y #Y+,,gi6L.M.MN]EM*4LI*++OO/00
 
 ,44 	H&&|W===F///F #<#899h(( 	Fh)) 	}%):::!!$00'55'1!459")a-'1!4c: 6  L
 <)**a//// 7E&|'=a'@AAlK00 	1*<+CDDLLi00 	1),77LL|]K&PQQ 	1'0LlH-- 	,$D$)) ,93'#+L	 	 	 	 	 	 |h	%:;;	##L,??	 F#-a0(GG, H 
 
 	))I 	* 	
 	
 	
 	
 	
r  reverse_classr   rl  rh  rk  c           	        t          |g          D ]}t          |          }t          |t                    r6|                     |||          r| j                            |||||           \t          |t                    r@|j        D ]7}	|                     |	||          r| j                            |||||           8t          |t                    s| j        
                    ||           dS )a  Check for overlapping method and reverse method signatures.

        This function assumes that:

        -   The reverse method has valid argument count and kinds.
        -   If the reverse operator method accepts some argument of type
            X, the forward operator method also belong to class X.

            For example, if we have the reverse operator `A.__radd__(B)`, then the
            corresponding forward operator must have the type `B.__add__(...)`.
        N)r   r   r  r   is_unsafe_overlapping_oprE  "operator_method_signatures_overlapr   r  r   forward_operator_not_callable)
r1  rV  rW  rm  rl  rh  rk  r  forward_itemr$  s
             r  rf  z(TypeChecker.check_overlapping_op_methods  s(   ` 2<.AA 	N 	NL*<88L,55 N00|\ZZ H??%|\<QX   L*55 N(.  D44T<VV CC)<|U\  
  g66 N66|WMMM	N 	Nr  rr  c                   t          |j                  dk     rdS |}t          |t                    rt	          |          }|                    ||j        d         gt          j        gdz  d gdz            }|                    |j        d         |j        d         gt          j        gdz  d gdz            }|j        d         }t          |t                    rt	          |          }t          ||          rdS t          ||          r|}|}	n|}|}	| j
                                        }
|
r|
j        j        ng }t          ||	|d          S )Nr  Fr   r  r[  )partial_only)r  r  r  r   r   rU  r   rM   r   r   rK  rN  r  rO  rP  )r1  rr  rk  rV  forward_base_erasedforward_tweakedreverse_tweakedreverse_base_erasedfirstsecondr^  rO  s               r  ro  z$TypeChecker.is_unsafe_overlapping_op  s    |%&&**5
 +lK00 	?"0">"> '44*L,B1,EF}o)fqj 5 
 

 '44#-a0,2H2KL}o)fqj 5 
 
 +4Q7);77 	F"01D"E"E+-@AA 	%5+-@AA 	%#E$FF#E$F
//114AIM&00r	8695
 
 
 	
r  ro   c                   |j         }|t          j        vrdS t          |                     |                    }|j        }d|dd         z   }|                    |          rt          |          }t          | j	        
                    |||                    }d}t          |t                    rt          ||          sd}nd}|r | j                            |||           dS dS dS )zrCheck an inplace operator method such as __iadd__.

        They cannot arbitrarily overlap with __add__.
        N__r  FT)r  r   inplace_operator_methodsr   r   r  r_  r  r   r  re  r  r   is_more_general_arg_prefixrE  signatures_incompatible)	r1  r  methodr0  r  other_methodinstancetyp2r  s	            r  r  z)TypeChecker.check_inplace_operator_method  s   
 ;;;F**40011ifQRRj(""<00 	M$S))H"!@@xY]^^ D D$-- 1#t<<  D  M00tLLLLL	M 	MM Mr  c           	        t          | j        j                  dk    r|dk    r"|                     t          j        |           d S t          |                     d          gt          j	        gd gt          t          j                  |                     d                    }n| j                                        rt          t          t          j                  |                     d          gt          j	        t          j	        gd d gt          t          j                  |                     d                    }nd S t          ||          s| j                            |||           d S d S )Nr  r  r  r  )r  rK  r  r  r   MODULE_LEVEL_GETATTRIBUTEr   r  r   rM   r   r   r	  rN  r   rE  $invalid_signature_for_special_method)r1  r0  r  r  rg  s        r  r  z TypeChecker.check_getattr_method  sQ   tz  A%%)))		*DgNNN '001	.// 344 KK Z$$&& 		&/00$//.2Q2QR.t	.// 344 KK F#{++ 	NH99#wMMMMM	N 	Nr  c           	        | j                                         sd S t          t          t          j                  |                     d          t          t          j                  gt          j        t          j        t          j        gg dt                      |                     d                    }t          ||          s| j                            ||d           d S d S )Nr  )NNNr  r  )rK  rN  r   r   r   r	  r  r   rM   r   r   rE  r  )r1  r0  r  rg  s       r  r  z TypeChecker.check_setattr_method/  s    z&&(( 	F"	.////	.//
 ]EM5=9JJOO/00

 

 #{++ 	WH99#wVVVVV	W 	Wr  c           	         |                      d          }t          ||                     d|g          g          }|                     |||t          j        ddt          j                   dS )zCheck the type of __slots__.r  typing.Iterablezactual typezexpected typer  N)r  r   r  r  r   INVALID_TYPE_FOR_SLOTSr  r/  )r1  r0  r  str_typeexpected_types        r  check_slots_definitionz"TypeChecker.check_slots_definition@  s    ??>22!t../@8*MMN
 
 	3! 	 	
 	
 	
 	
 	
r  r  c                   | j                                         sdS t          |          }t          |t                    rt          d |j        D                       s)| j                            d|t          j
                   dS dS )z2Check that __match_args__ contains literal stringsNc              3  4   K   | ]}t          |          V  d S r0  )is_string_literalr  r$  s     r  r  z/TypeChecker.check_match_args.<locals>.<genexpr>U  s<       5
 5
(,d##5
 5
 5
 5
 5
 5
r  zb__match_args__ must be a tuple containing string literals for checking of match statements to workr  )rK  rN  r   r  r   ra  r  rE  r  r  LITERAL_REQ)r1  r  r0  r  s       r  check_match_argszTypeChecker.check_match_argsP  s    z&&(( 	Fc""#y)) 	 5
 5
03	5
 5
 5
 2
 2
 	 HMM.&	      	 	r  #list[tuple[FuncItem, CallableType]]c                   g }t          |j                  pg }|j        r||j        j        j        pg z  }|D ]Dt          t                    r-j        r&|                    fdj        D                        E|ro| j	        j
        sc| j	        j        sWg }t          j        | D ]D}t          |          }|                    t          ||          t!          ||          f           E|S ||fgS )Nc                "    g | ]}j         |fS r  id)r  valuetvars     r  rt  z/TypeChecker.expand_typevars.<locals>.<listcomp>j  s     HHH5tw.HHHr  )listrR  r  r  rO  r  r   r  r6  rW  mypycinspections	itertoolsproductdictexpand_funcr7   )	r1  r  r0  substtvarsresultsubstitutionsmappingr  s	           @r  r  zTypeChecker.expand_typevars_  s"    57S]##)r9 	4TY^-33E 	J 	JD$,, J JHHHHDKHHHIII  	!$,, 	!0H 	!:<F!*!2E!: W W}--{499;sG;T;TUVVVVM3K= r  FuncDef | OverloadedFuncDefr'  list[TypeInfo] | NoneContext | Nonec                ,   d}|j         r*|j                             |j                  x}r	|j        rd}|sV|rV|j        sQ|j        dvrJt          |j                  s8| j                            |j        |d         j        |p|           d S d S d S d S d S d S )NFTr2  r  r   )	r  r  r  r  r  r  rE  #explicit_override_decorator_missingr  )r1  r  r'  r  r  r  s         r  r  z-TypeChecker.check_explicit_override_decoratorw  s     !9 	$$)--	":"::$ 	$@U 	$  $ !		)		 -		 	!888ty)) 9 H88	4Q7@'/T    		 		 		 		 		 		 9888r  'FuncDef | OverloadedFuncDef | Decoratorc                \   | j         rdS |j        dvoL| j        j        p|                                 o+|j        dk    p |j        j                            d          du }g }|j        j        dd         D ]5}| 	                    |||          }| dS |r|
                    |           6|S )a&  Check if function definition is compatible with base classes.

        This may defer the method if a signature is not available in at least one base class.
        Return ``None`` if that happens.

        Return a list of base classes which contain an attribute with the method name.
        N)r2  r  r  r  __replace__dataclass_tagr  )rt  r  rW  r  r  r  metadatar  mro*check_method_or_accessor_override_for_baser6  )r1  r  check_override_compatibilityr'  baser  s         r  r  z!TypeChecker.check_method_override  s     $ 	4 IZZ 0I8I8I4I 	]* C9%))/::dB 	% 57!IM!""% 	7 	7DDDd8 F ~tt 7)00666((r  r  r  bool | Nonec                   d}|r|j         }|j                            |          }|rit          |j                  r0t          |          s!| j                            ||j         |           |j        r| 	                    ||j        |           d}|rM| 
                    |||          rdS |t          j        v r&d|dd         z   }| 
                    |||          rdS |S )a  Check if method definition is compatible with a base class.

        Return ``None`` if the node was deferred because one of the corresponding
        superclass nodes is not ready.

        Return ``True`` if an attribute with the method name was found in the base class.
        FTNr|  r  )r  rh  r  r   r  r  rE  cant_override_finalr  $check_if_final_var_override_writable(check_method_override_for_base_with_namer   r}  )r1  r  r  r  found_base_methodr  	base_attrr  s           r  r  z6TypeChecker.check_method_or_accessor_override_for_base  s    " 	$9D
t,,I ) 00 HD9I9I HH00ty$GGG= Z==dINTXYYY$(!+ $ @@tTRR  49===!DH_F
 DDT6SWXX $#t  r  c                   |                      |j        |j        |d          \  }}|                      |j        ||d          \  }}||J t          ||          s$| j                            |j        |||           dS dS )a&  Check override of a setter type of a mutable attribute.

        Currently, this should be only called when either base node or the current node
        is a custom settable property (i.e. where setter type is different from getter type).
        Note that this check is contravariant.
        Tr  N)node_type_from_baser  r  r   rE  incompatible_setter_overrider  )r1  r  r  r0  r  r4  s         r  check_setter_type_overridez&TypeChecker.check_setter_type_override  s     ))$)TYRV)WWQ33DItTW[3\\q=#<#<#<--- 	YH11$+sMSWXXXXX	Y 	Yr  c           
        |j                             |          }|sdS t          |t                    s|}n|j        }t          |t
          t          f          r|j        p|j        }n|j        j        p|j        j        }| 	                    |j
        |j        |          \  }|j
         d|j        j         v sJ dS |j        }d}	| 	                    |||          \  }
}|
<d}	| j        | j        k     rz| j                                        }t          |t
                    r/|                     || j                            |                     n|                     ||j                   dS t          |t
          t          f          r|                     |          }
n~t          |t                    r|                     |j                  }
nNt          |t(                    r+|j        t-          |j                  }
nt/                      }
nt/                      }
d}t1          |          r\t1          |          st          |t(                    r8t3          |          st3          |          r|	rd}|                     ||           t          |t
          t          f          r|j        p|j        }n-t          |t                    r|j        }|j        p|j        }nd}t-                    t-          |
          }
t7          |          rt          |t(                    rk|j        sd|j        r|j        rVt          |t                    rAt          |
t:                    s,| j                            d|j        t@          j!                   t          |
t:                    st          t:                    rn;t          |
tD                    rt          tD                    r| #                    |
|j
        ||j$        | j%        j&        k    r|j
        n|j&        |||          }|r|rt@          j'        | j(        j)        v r| *                    |          rr|sptW          |
d          s^tY          |
| j(                  \  }}tZ          j.        /                    d	|j
         d
| d| d          }|                     ||           n*t          |
t`                    rtc          fd|
j2        D                       r|rt@          j'        | j(        j)        v ru| *                    |          r`|s^tY          |
| j(                  \  }}tZ          j.        /                    d	|j
         d
| d| d          }|                     ||           netg          |
          rnT|r(| *                    |          r|rtW          |
          rn*| j        4                    |j
        ||j
        ||
           dS )zCheck if overriding an attribute `name` of `base` with `defn` is valid.

        Return True if the supertype node was not analysed yet, and `defn` was deferred.
        FNz-redefinitionTz;Cannot override writeable attribute with read-only propertyr  ignore_pos_arg_namesr  z (base class "z" defined the type as z, override has type )c              3  <   K   | ]}t          |d           V  dS )Tr  NrA  )r  orig_typr0  s     r  r  zGTypeChecker.check_method_override_for_base_with_name.<locals>.<genexpr>u	  sF       :
 :
 sH4@@@:
 :
 :
 :
 :
 :
r  originaloverride)5rh  r  r  rg   r
  rp   r   r  	is_staticr  r  r  r  rj  r  rK  r  r  r  r   r   rL  r   r   r  is_custom_settable_propertyr  r  r  r   rE  r  r  OVERRIDEr   check_overridemodule_namerb  r  MUTABLE_OVERRIDErW  enabled_error_codesis_writable_attributer   rG   r   'COVARIANT_OVERRIDE_OF_MUTABLE_ATTRIBUTEwith_additional_msgr   rC  r  r   %signature_incompatible_with_supertype)r1  r  r  r  r  r  override_class_or_staticr  original_nodesupertype_readyr4  	top_levelalways_allow_covariantoriginal_class_or_staticr!  okbase_stroverride_strrE  r0  s                      @r  r  z4TypeChecker.check_method_override_for_base_with_name  s    JNN4((	 	5
 $	** 	 GGiG dW&7899 	Q'+}'F$$'+y'9'PTY=P$))$)TYEEQ; i...$)/AAAA5! 33D$EEq #O}t~-- !J99;;	i11 5OOItz/I/I)/T/TUUUU OOD$)444tMG5F+GHH + $ 2 2= A AM955 + $ 2 2=3E F FM3// + !%1$3M4F$G$GMM$,JJMM !)

!&%% 		@ //		@3=mS3Q3Q		@ +400 @5PQ^5_5_ @ # @-1*33D$???mg/@%ABB 	-'4'='XAX$$y11 	- %D'+}'F$$',$c""'66 	=#..	 "*	 #.		 3@2T		
 4++	 mW55 QI	     mW-- B	C1I1I B	|44 @	C9V9V @	$$	!-1CCC		((	 	B (!( *dl.NNN..}== O. O #=#DQQQ O
 *@!3* * *&, 'Nbb:TY : :h : :*6: : :  		#w'''y11 #	c :
 :
 :
 :
)/:
 :
 :
 7
 7
 #	 (*dl.NNN..}== O. O
 *@!3* * *&, 'Nbb:TY : :h : :*6: : :  		#w'''=#.. 	 
	//>>
	BX
	 3..
	 H::	4GmVY ;    ur  tpc                b    t          |t                    rI|j        r@|j        d         t          k    r*t	          |j        d         d |j        D                       S d S t          |t                    r2 fd|j        D             }d |D             }|rt          |          S d S J d            )Nr   c                    h | ]	}|j         
S r  r  r  r  s     r  	<setcomp>z2TypeChecker.get_op_other_domain.<locals>.<setcomp>	  s    7S7S7S7S7S7Sr  c                :    g | ]}                     |          S r  )get_op_other_domainr  itr1  s     r  rt  z3TypeChecker.get_op_other_domain.<locals>.<listcomp>	  s'    III"11"55IIIr  c                    g | ]}||S r  r  r  r  s     r  rt  z3TypeChecker.get_op_other_domain.<locals>.<listcomp>	  s    222Br2R222r  Fz,Need to check all FunctionLike subtypes here)
r  r   r  rM   r*   r  rR  r   r  r   )r1  r  	raw_itemsr  s   `   r  r  zTypeChecker.get_op_other_domain	  s    b,'' 	I| UQ7 : : &bl1o7S7Sbl7S7S7STTT4J'' 	IIIIIIIII22)222E 4,U3334HHHHHr  r  r  name_in_superr  r  r  c	                
   d}	d}
t          ||d          sd}	nlt          |t                    rW|                     |          rB|                     |          }|                     |          }|r|rt          ||          sd}	d}
t          |t
                    rQ|r|sd}	nJt          |t                    r5t          |t                    r |j        	|j        d}	|j        	|j        d}	t          |          rd}	|	r\d}t          |t                    o|j
        }t          |t          t          f          r|                                }t          |t          t          f          r|                                }t          |t                    rt          |t                    rt          |j                  t          |j                  k    rs|j        |j        k    rb|                                d}t!          |          }t          |t"                    r|j        j        }dfd}t)          t+          |j        |j                            D ]\  }\  }}|                                r/|                                r|j        |         }|j        |         }nw|                                rb|                                rN|sL|j        |         }||j        v r5|j        |         }|j                            |          }|j        |         }nt          | ||                    s|}t          |t"                    r|j        s}|j        rG|j                            |j                  x}r&t          |j        t>                    r|j        j         s/|j!        ||"                                z            }|j#        d	k    r|}| j$        %                    |d
z   |||||||           d}t           ||j&                  |j&                  s+| j$        '                    ||||j&        |j&        |           d}nt          |t                    rt          |t                    rg }|j(        D ]C}t)          |j(                  D ],\  }}t          ||          r|)                    |            n-Dt          |          t          |j(                  k    r2|tU          |          k    r| j$        +                    ||||           d}|s | j$        ,                    ||||||           |
r"| -                    d|t\          j/                   |	 S )a  Check a method override with given signatures.

        Arguments:
          override:                 The signature of the overriding method.
          original:                 The signature of the original supertype method.
          name:                     The name of the overriding method.
                                    Used primarily for generating error messages.
          name_in_super:            The name of the overridden in the superclass.
                                    Used for generating error messages only.
          supertype:                The name of the supertype.
          original_class_or_static: Indicates whether the original method (from the superclass)
                                    is either a class method or a static method.
          override_class_or_static: Indicates whether the overriding method (from the subclass)
                                    is either a class method or a static method.
          node:                     Context node.
        FTr  Nr  r   r-  c                &    t          |           S )N)ids_to_erase)r*   )r  override_idss    r  erase_overridez2TypeChecker.check_override.<locals>.erase_override
  s    )!,GGGGr  r  r  )origin_contextr  zHOverloaded operator methods can't have wider argument types in overridesr  )r  r   r-  r   )0r   r  r   r5  r  r   r   
type_guardr  r  unpack_kwargsrS  r  r  min_argstype_var_idsr   rp   r  r  r  zipr  is_positionalis_namedr  indexr  r  r  r  rg   
decoratorsr  boundr  rE  $argument_incompatible_with_supertyper  'return_type_incompatible_with_supertyper  r6  sorted.overload_signature_incompatible_with_supertyper  r  r  r  ) r1  r  r  r  r  r  r  r  r  r  op_method_wider_noteoriginal_domainoverride_domainemitted_msgoffset_arguments	type_namer  r  r   sub_kind
super_kindoverride_arg_typeoriginal_arg_typearg_name
original_ir  symarg_nodeorderchild_variantparent_variantr  s                                   @r  r  zTypeChecker.check_override	  s   8 $(H4HHH 	,DD*-- 	,$2K2KD2Q2Q 	, #66x@@O"66x@@O,#, #?ODD,
 '+$h-- 	 '  0H  Hl33  
8\8Z8Z  &2x7J7RD#/H4D4LDd 	D t	K)(LAA\hF\(\:$>?? ;#88::(\:$>?? ;#88:: 8\22^'x66^' *++s83E/F/FFF%):::  (4466 	)(33
j'22 5 * 4IH H H H H H 2;*H,>??2 2 ++ ++-A-*  --// !J4L4L4N4N !,4,>q,A),4,>q,A))!**,, 	!1D1D1F1F 	!O_ 	!#+#5a#8#x'999080B10E-)1);)A)A()K)KJ080B:0N--$ %&7HY9Z9Z[[ ++/&tW553$($43 %)$5	3 04y}}TY/G/G(G3 (2#(I'F'F3 (+x':3 (,~a(..:J:J6J'KH'}22*2EEE %)-%#+/ F 	 	 	 '+!..1B"C"CXEVWW 'HDDmY8I8K\^b   #'KHj11 'j:6V6V ' %-^ " "M-6x~-F-F " ")>%m^DD "!LLOOO!E" u::X^!4!444&--9O9OHKKmY   #'K >>-D8V^ ?    $ 		^    
 xr  c                0   |j         rt          |j         t                    sdS t          |j         j                  }t          |          sdS t          |          }|sdS t          d |D                       r| j        	                    |           dS dS )a;  Generate error if the return type of __exit__ is problematic.

        If __exit__ always returns False but the return type is declared
        as bool, mypy thinks that a with statement may "swallow"
        exceptions even though this is not the case, resulting in
        invalid reachability inference.
        Nc              3  j   K   | ].}t          |j        t                    o|j        j        d k    V  /dS )builtins.FalseN)r  exprr   r  )r  rets     r  r  z7TypeChecker.check__exit__return_type.<locals>.<genexpr>m
  sR       
 
 sx**Tsx/@DT/T
 
 
 
 
 
r  )
rL  r  r   r   r  has_bool_itemr   ra  rE  incorrect__exit__return)r1  r  r  rO  s       r  r  z$TypeChecker.check__exit__return_typeZ
  s     y 	
49l C C 	F"49#566X&& 	F'-- 	F 
 

 
 
 
 
 	3 H,,T22222		3 	3r  rc   c                r	   |j         }|j        dd         D ]A}|j        r8|                     t          j                            |j                  |           Bt          |j	                  s8|                     t          j
                            |j                  |           | j                            |j                   5  |                     d          5  |                     |j                   5  | j        }t!          | j                  | _        | j                                        5  | j                            |j                   5  |                     |j                   ddd           n# 1 swxY w Y   ddd           n# 1 swxY w Y   || _        | j        s|j         j        s-|j         j        s!|j         j        s|                     |           |j        s|                     |           |                     |           |                     |           |j         rtC          |j         | j"                  }tG          |j                   D ]}tI          |tJ                    rtI          |j&        tN                    r2| j(                            |          }| )                    ||          }d}	tI          |tT                    r	|j+        pd}	| j,        }
d| _,        | j(        -                    ||gt\          j/        g||	          \  }}|
| _,        ddd           n# 1 swxY w Y   ddd           n# 1 swxY w Y   ddd           n# 1 swxY w Y   |j0        j1        r|j0        j2        |j	        D ]}tg          |j4        |j5        j0        j1                  D ]z\  }}tI          |tl                    r`|j7        tp          k    rPtI          |tl                    r;|j7        |j7        k    r+|                     d|j         d|tr          j:        	           {|j0        j1        r| ;                    |j0        j1                   |j<        r!|j0        j1        r| =                    |           |j        s!|j         j        r| >                    |           t          |j                    dS )
zType check a class definition.r  NTr  r  )callable_namezVariance of TypeVar "z+" incompatible with variance in parent type)r  r  )@r  r  r  r  r   CANNOT_INHERIT_FROM_FINALr  r  r   basesINCOMPATIBLE_DISJOINT_BASESrJ  r  r  enter_classrF  r   rW  r  rK  r  r  r  rt  typeddict_type
tuple_typeis_enumcheck_init_subclasshas_incompatible_baseclasscheck_multiple_inheritancecheck_metaclass_compatibilitycheck_final_deletabler  r   r  reversedr  rb   analyzedr   r  	temp_noder   r  ry  
check_callr   rM   r  rO  	type_argsr  rw  rL  r   r  rT   r  r-   r  r  check_protocol_variance
check_enumr   )r1  r  r0  r  r  sig	decoratordectempr  old_allow_abstract_callr  	base_inst	base_tvarbase_decl_tvars                  r  visit_class_defzTypeChecker.visit_class_defs
  s!   iGABBK 	^ 	^D} ^		*DKKDIVVX\]]],SY77 	[II&BII#(SSUYZZZK##DI..,	G ,	G$$d$33,	G ,	G TY'',	G ,	G
 J/==DK..00 + +Z**4955 + +KK	***+ + + + + + + + + + + + + + ++ + + + + + + + + + + + + + + %DK, 0	0 3DI4H 3DIL] 3,,T2226 933C888223777**3/// G,TYHH!)$/!:!: G GI!)X66 !:!*K< < ! !+229==C>>#y>AAD#H!)W55 >#,#5#= /3.F+/3D,!.99dVem_d( :  FC 0GD,,Y,	G ,	G ,	G ,	G ,	G ,	G ,	G ,	G ,	G ,	G ,	G ,	G ,	G ,	G ,	G ,	G ,	G ,	G ,	G ,	G ,	G ,	G ,	G ,	G ,	G ,	G ,	G ,	G ,	G ,	G ,	G ,	G ,	G ,	G ,	G ,	G ,	G ,	G ,	G ,	G ,	G ,	G ,	G ,	G ,	G^ 8 	#("4"< Y  	14NIN$7$A2 2  -I~ #9k::%.);;&~{CC <*3y7III		;IN ; ; ;$(!&	 "    8 	<''(:;;;? 	/sx1 	/((.... 	"493D 	"OOD!!!di(((((s   MM6:L.0 F	E7+F	7E;;F	>E;?F	L.FL.FFL."M.L22M5L26M9MM			MM		MM #M c              #  V   K   | j         }|| _         	 d V  || _         d S # || _         w xY wr0  )rL  )r1  rL  r4  s      r  r  zTypeChecker.enter_class
  s@      			&EEE%DIIIDI%%%%    	(c                    |j         D ]i}|j                            |          }|rKt          |j        t
                    r1|j        j        r%|                     t          j	        |j                   jd S r0  )
deletable_attributesrh  r  r  r  r   r  r  r   CANNOT_MAKE_DELETABLE_FINAL)r1  r0  attrr  s       r  r&  z!TypeChecker.check_final_deletable
  s|     , 	S 	SD9==&&D S
49c22 Sty7I S		*F	RRR	S 	Sr  c                   |j         j        r|j         j        j        j        dvrdS |j         j        dd         D ]3}d|j        vrt          |j                  }||_        t          |d          }t          |j                                                  }t          |j                                                  }d|v r?|                    d          }|                    |           |                    |           t           gt#          |          z  }t%          ||||          }	|j        |	_        |j        |	_        |j        |	_        | j                            |	dd            dS dS )a  Check that keywords in a class definition are valid arguments for __init_subclass__().

        In this example:
            1   class Base:
            2       def __init_subclass__(cls, thing: int):
            3           pass
            4   class Child(Base, thing=5):
            5       def __init_subclass__(cls):
            6           pass
            7   Child()

        Base.__init_subclass__(thing=5) is called at line 4. This is what we simulate here.
        Child.__init_subclass__ is never called.
        )builtins.typer  Nr  r  	metaclassTallow_none_returnalways_allow_any)r  r  rL  r  r  rh  r   r  r  r~   r  keywordsr  keysr  r@  rL   r  rb   r  r  end_liner  r  )
r1  r  r  r  calleerw  r  r  r  	call_exprs
             r  r"  zTypeChecker.check_init_subclass
  sr    9# 		(@(E(N W
 )
 )
 F IM!""% 	 	D"$*44 ++I!IN	+>??F,,..//D*.t}/A/A/C/C*D*DI i''ook22c""""c$ii/I y)DDI!YIN#{I!%I$$Y$Y]$^^^ EE-	 	r  r  Sequence[TypeVarLikeType]c                @   |D ]t          t                    r                                s,t          j        j                  s|                     d           j        r6t          fdj        D                       s|                     d           d S )Nz3TypeVar default must be a subtype of the bound typec              3  B   K   | ]}t          j        |          V  d S r0  )r   r'  )r  r  tvs     r  r  z5TypeChecker.check_typevar_defaults.<locals>.<genexpr>  s/      $\$\\"*e%D%D$\$\$\$\$\$\r  z3TypeVar default must be one of the constraint types)	r  r   has_defaultr   r'  r5  r  r  rC  )r1  r  rK  s     @r  r  z"TypeChecker.check_typevar_defaults  s     	U 	UBr;// BNN4D4D bj".99 U		OQSTTTy U$\$\$\$\RTR[$\$\$\!\!\ U		OQSTTT	U 	Ur  c                   |j         j        sJ |j         j        t          vrkd|j         j        v r]|j         j        d         }t          |j        t                    r1|j        j        r%| 	                    t          j        |j                   |j         j        dd         D ]-}|j        r$|j        t          vr|                     ||           .| j        rT| j        j        dvrF|j         j        s:| 	                    d|j         j         d|           |                     d|           |                     |           |                     |           d S )N__members__r  r  >   enum	_typeshedzDetected enum "z" in a type stub with zero members. There is a chance this is due to a recent change in the semantics of enum membership. If so, use `member = value` to mark an enum member, instead of `member: type`zLSee https://typing.readthedocs.io/en/latest/spec/enums.html#defining-members)r  r!  r  r   rh  r  r  r   has_explicit_valuer  r   $ENUM_MEMBERS_ATTR_WILL_BE_OVERRIDDENr  check_final_enumrl  rb  enum_membersr  check_enum_basescheck_enum_new)r1  r  r  r  s       r  r-  zTypeChecker.check_enum  ss   y    9Z//MTY_4T4T)/-0C#(C(( [SX-H [ 		*OQTQYZZZIM!B$' 	2 	2D| 2Z ? ?%%dD111< 	DI.6KKK9) 		0di&8 0 0 0    		b  
 	d###D!!!!!r  c                V    |j         r!|                     d|j         d|           d S d S )Nz+Cannot extend enum with existing members: "r  )rT  r  r  )r1  r  r  s      r  rS  zTypeChecker.check_final_enum+  sC     	XIIPDIPPPRVWWWWW	X 	Xr  r  r   c                   t          |j        t          t          f          rdS t          |j        t                    sdS t          |j        j                  s^t          |j        j                  sEt          |j        j                  s,t          t          |j        j
                  t                    rdS | j        p|j        j        S )NFT)r  r  ro   rg   r   r  r  r  r  r   rL  r   rl  rQ  )r1  r  s     r  is_final_enum_valuezTypeChecker.is_final_enum_value/  s    ch9 566 	5#(C(( 	4 sx}%%		''		 ''		 /#(-88,GG		 5|:sx::r  c                    d}|j         j        D ]V}||j        j        r|}|A|j        j        s5|                     d|                    | j                   d|            dS WdS )a  
        Non-enum mixins cannot appear after enum bases; this is disallowed at runtime:

            class Foo: ...
            class Bar(enum.Enum, Foo): ...

        But any number of enum mixins can appear in a class definition
        (even if multiple enum bases define __new__). So this is fine:

            class Foo(enum.Enum):
                def __new__(cls, val): ...
            class Bar(enum.Enum):
                def __new__(cls, val): ...
            class Baz(int, Foo, Bar, enum.Flag): ...
        Nz-No non-enum mixin classes are allowed after "r  )r  r  rL  r!  r  r  rW  )r1  r  	enum_baser  s       r  rU  zTypeChecker.check_enum_basesG  s      &*	IO 		 		D TY%6  	&ty/@&		oID^D^_c_kDlDlooo   		 		r  c                ^   ddd}|j         j        D ]}d}|j        j        r.t	          fd|j        j        dd	         D                       }n |j                  }|rD|rB|                     d
                    |                    | j	                            |           |rd}d S )Nr  r   r-  r&  c                x    |                      d          }t          |o|j        o|j        j        dk              S )Nr  zbuiltins.object.__new__)r  r&  r  r  )r  
new_methods     r  has_new_methodz2TypeChecker.check_enum_new.<locals>.has_new_methodd  sG    ),,J JOJO,0II  r  Fc              3  >   K   | ]}|j          o
 |          V  d S r0  )r!  )r  br_  s     r  r  z-TypeChecker.check_enum_new.<locals>.<genexpr>r  s6      aaAI C..2C2Caaaaaar  r  r  zLOnly a single data type mixin is allowed for Enum subtypes, found extra "{}"T)r  r   r-  r&  )
r  r  rL  r!  rC  r  r  r  r  rW  )r1  r  has_newr  	candidater_  s        @r  rV  zTypeChecker.check_enum_newc  s    	 	 	 	 IO 	 	DIy  6aaaaTY][\]_[_M`aaaaa		*N4955	 W 		''-vd.C.CDL.Q.Q'R'R   
  !	 	r  c                   | j         rdS |j        dS |j        }t          |j        d         g           |j        j        }| j        0|                     dddg           \  }}t          |g           | _        | j        t          |          D ]\  }t          |t                    sfdt          |          D             }fdt          |          D             }t          ||          t          ||          }
}	t          |
|	d          rt          }n!t          |	|
d          rt          }nt          }||j        k    r'| j                            |j        |j        ||           dS )	a/  Check that protocol definition is compatible with declared
        variances of type variables.

        Note that we also prohibit declaring protocol classes as invariant
        if they are actually covariant/contravariant, since this may break
        transitivity of subtyping, see PEP 544.
        Nr  z<dummy>Dummyc                N    g | ]!\  }}|k    rn                                 "S r  )rU  )r  r[  r  dummyr   object_types      r  rt  z7TypeChecker.check_protocol_variance.<locals>.<listcomp>  sB     # # #EIQqAvv5+>+>+@+@# # #r  c                f    g | ]-\  }}|k    rt                      n                                .S r  )r   rU  )r  r[  r  rg  r   s      r  rt  z7TypeChecker.check_protocol_variance.<locals>.<listcomp>  sI     % % %KO1aQ!VV!!!1D1D1F1F% % %r  T)ignore_declared_variance)rt  r+  r  r   r  r  rO  ra  make_fake_typeinfor  r  r   r   rP   rO   rT   r  rE  bad_proto_variancer  )r1  r  r  r  r  
dummy_infor  up_args	down_argsupdownr  rg  r   rh  s               @@@r  r,  z#TypeChecker.check_protocol_variance  s    $ 	F>%Fytx|R00	#$, 33IwQSTTMAz(0R(@(@D%) '' 	V 	VGAtdK00 # # # # # #MVW\M]M]# # #G% % % % %S\]bScSc% % %I  g..y0I0IB$TBBB %$BtDDD %($4=((++DM49hPTUUU'	V 	Vr  c                   t          |j                  dk    rdS |j        dd         }d |D             }t          ||j                                        z
            D ]wt                    rt          fdt          |          D                       \  }}||dz   d         D ],}|j        v r!||j        vr| 	                    |||           -xdS )z.Check for multiple inheritance related errors.r  Nc                &    h | ]}|j         D ]}|S r  rh  )r  r  r  s      r  r  z9TypeChecker.check_multiple_inheritance.<locals>.<setcomp>  s'    AAAddjAAdTAAAAr  c              3  8   K   | ]\  }}|j         v ||fV  d S r0  rt  )r  r   r  r  s      r  r  z9TypeChecker.check_multiple_inheritance.<locals>.<genexpr>  s7      YYDddjFXFXAt9FXFXFXFXYYr  )
r  r  r  r  rh  rD  r  nextr  check_compatibility)r1  r0  r  	all_namesr   r  base2r  s          @r  r$  z&TypeChecker.check_multiple_inheritance  s   sy>>QFgabbkAAcAAA	9sy~~'7'7788 	E 	ED $  YYYYIcNNYYYYYGAtQUWW E E5;&&5+@+@,,T4DDDE	E 	Er  base1ry  c           	     T   |dv rdS |j         |         }|j         |         }|                     ||||          \  }}|                     ||||          \  }	}t          |          }
t          |	          }t          |
t                    rt          |t                    r|
                                re|                                rQt          t          |
                                          t          |                                                    }nQ|r|	sJ t          ||	d          }n7|r|	r|j	        +| 
                    |j	                  st          ||	          }nt          ||	          }|r|j	        r|j	        r| 
                    |j	                  r~t          |j	                  rjt          |j	        t                    rPt          |t                    s;| j                            d| d|j         d	|j         d
|t$          j                   nH|!| j                            ||j        |           |	!| j                            ||j        |           d}t+          |j	                  r0t-          |          s!| j                            ||j        |           t+          |j	                  r|                     ||j	        |           t          |j	        t2                    r|j	        j        rd}|s| j                            ||||           dS dS )ay  Check if attribute name in base1 is compatible with base2 in multiple inheritance.

        Assume base1 comes before base2 in the MRO, and that base1 and base2 don't have
        a direct subclass relationship (i.e., the compatibility requirement only derives from
        multiple inheritance).

        This check verifies that a definition taken from base1 (and mapped to the current
        class ctx), is type compatible with the definition taken from base2 (also mapped), so
        that unsafe subclassing like this can be detected:
            class A(Generic[T]):
                def foo(self, x: T) -> None: ...

            class B:
                def foo(self, x: str) -> None: ...

            class C(B, A[int]): ...  # this is unsafe because...

            x: A[int] = C()
            x.foo  # ...runtime type is (str) -> None, while static type is (int) -> None
        )r2  r  r  N)r^  leftrightTr  z%Cannot override writeable attribute "z" in base "z#" with read-only property in base "r  r  )rh  r  r   r  r   is_type_objr   r  type_objectr  r  r   r  rg   r   rE  r  r  r  r  cannot_determine_type_in_baser   r  r  r  r   allow_incompatible_override#base_class_definitions_incompatible)r1  r  rz  ry  r,  ry  rz  
first_typer  second_typep_first_typep_second_typer  s                r  rw  zTypeChecker.check_compatibility  s   . ???FD!T"00ucQT0UU
A11$sRU1VVQ 'z22'44lL11 $	jP\6]6] $	'')) 	Tm.G.G.I.I 	T  /0H0H0J0JKK01J1J1L1LMM  
 "1k111
KdSSS 	K 	{&t/I/I&+/V/V&
K88":{;; J 226;?? $EJ//	
 #5:y99 '}g>> HMMK K KQVQ[ K K=BZK K K"^	 "    !66tUZMMM"66tUZMMMB %% 	@j.>.> 	@H((uz3???$$ 	N55dFKMMM fk3'' 	FK,S 	B 	RH88ueSQQQQQ	R 	Rr  c                t   |                                 s|j        s|j        s|j        s|j        dS |j        zt          d |j        D                       r^|                     d|t          j
                   |                                }|r(|                     ||t          j
                   dS dS dS dS )z<Ensures that metaclasses of all parent types are compatible.Nc              3  2   K   | ]}|j         j        d uV  d S r0  )rL  r  r  r  s     r  r  z<TypeChecker.check_metaclass_compatibility.<locals>.<genexpr>!  s=       .
 .
59DI$D0.
 .
 .
 .
 .
 .
r  zxMetaclass conflict: the metaclass of a derived class must be a (non-strict) subclass of the metaclasses of all its basesr  )rP  r  is_named_tupler!  r  r  rC  r  r  r  	METACLASSexplain_metaclass_conflictr  )r1  r0  explanations      r  r%  z)TypeChecker.check_metaclass_compatibility  s    		 !	 {		
 !-F%# .
 .
=@Y.
 .
 .
 +
 +
% IIN_	     88::K B		+s	AAAAA &%%%B Br  rw   c                    |j         D ]<\  }}| j                            |          x}|                     |j        |           =|                     |           d S r0  )rh  rS  r  warn_deprecatedr  check_import)r1  r  r  r  r  s        r  visit_import_fromzTypeChecker.visit_import_from.  se    z 	5 	5GD!|''---:$$SXt444$r  ru   c                0    |                      |           d S r0  r  r  s     r  visit_import_allzTypeChecker.visit_import_all4      $r  rt   c                0    |                      |           d S r0  r  r  s     r  visit_importzTypeChecker.visit_import7  r  r  rv   c           	     f   |j         D ]}|j        d         }|                     |          \  }}}|t          t          j                  }t          |j        t                    sJ t          j
                            |j        j                  }|                     ||j        ||dd           d S )Nr   z
local namezimported name)rE  r(  r)  )assignmentslvaluescheck_lvaluer   r   r	  r  rvaluer   r   INCOMPATIBLE_IMPORT_OFr  r  r.  )r1  r  assignlvaluelvalue_typer  r|  messages           r  r  zTypeChecker.check_import:  s    & 	 	F^A&F!%!2!26!:!:KB"%i&<==fmX66666&=DDV]EWXXG(((+ )    	 	r  ra  r_   c                   |j         r| j                                         d S |j        D ]}| j                                         rJ|                                 s d S |                     |          s| j                            |            d S e|                     |           | j	        j
                                         d S r0  )r  rF  r  r  r  r  rE  r  r  r  
expr_cacher  )r1  ra  ss      r  visit_blockzTypeChecker.visit_blockP  s     	 K##%%%F 
	5 
	5A{))++ 	5<<>> EE44Q77 H221555EE A!,224444
	5 
	5r  c                    |                                  o-| j        j        o!| j         o| j                                         S r0  )in_checked_functionrW  warn_unreachablerk  rF  !is_unreachable_warning_suppressedr~  s    r  r  z,TypeChecker.should_report_unreachable_issuesc  sO    $$&& D-D..D KAACCC		
r  r  c                :   t          |t                    rt          |j                  rdS t          |t                    rt          |j                  rdS t          |t                    rdS t          |t                    rt          |j        t                    r~| j	        j
                            d          5  t          | j	                            |j        dd                    }ddd           n# 1 swxY w Y   t          |t                    rdS dS )a  Returns 'true' if the given statement either throws an error of some kind
        or is a no-op.

        We use this function while handling the '--warn-unreachable' flag. When
        that flag is present, we normally report an error on any unreachable statement.
        But if that statement is just something like a 'pass' or a just-in-case 'assert False',
        reporting an error would be annoying.
        T)filter_revealed_typer@  NF)r  r[   is_false_literalr  r   is_literal_not_implementedr   rl   rb   r  rE  filter_errorsr   r  r   )r1  r  r0  s      r  r  z$TypeChecker.is_noop_for_reachabilityk  sV    a$$ 	 )9!&)A)A 	 4:&& 	 +Eaf+M+M 	 49%% 	 4>** 
	 !&(++ 	 &*88d8SS  ))00FdT 1   C               c?33  4us   =0C99C= C=r]   c                   |j         r| j        sf|                     |j                  5  |                     |j        d         |j        |j        du |j                   ddd           n# 1 swxY w Y   |j         r| 	                    |           |j        | j
        j        rt          |j                  rut          |j        d         t                    r4| j                            dt#          t$          j                  |           n!| j                            d|j        |           t)          |j        | j
        | j        | j        |           t-          |j                  dk    r|                     |j                  s| j                            |j                   |                     |                     |j                  |          }|j        dd         D ]R}|                     |j                  5  |                     |||j        du            ddd           n# 1 swxY w Y   S|                     |           |j        rT|j        rMt;          |j                  s9| j                                         |                      tB          j"        |           |j#        r1| $                                s| j        %                    |           dS dS dS )z|Type check an assignment statement.

        Handle all kinds of assignment statements (simple, indexed, multiple).
        r  NzA type on this linezType of variabler  r  )&is_alias_defrl  enter_final_contextis_final_defcheck_assignmentr  r  rL  
new_syntaxcheck_type_alias_rvaluerW  r  r   r  r   rE  r  r   r   r	  r   rn  r  has_typer  r  r)  lookup_typecheck_finalr  rK  rN  r  r   DEPENDENT_FINAL_IN_CLASS_BODYunanalyzed_typer   annotation_in_unchecked_function)r1  r  r  lvs       r  visit_assignment_stmtz!TypeChecker.visit_assignment_stmt  s|     	]4< 	]))!.99 ] ]%%aimQXqv~q|\\\] ] ] ] ] ] ] ] ] ] ] ] ] ] ] > 	,((+++ F4 ,QV44  !)B-33 T 44)793I+J+JA    445GQRSSSqvt|T5JDH^_````qy>>A ==** 3!((222^^D$4$4QX$>$>BBFin F F--an== F F))"fafnEEEF F F F F F F F F F F F F F F 	N	I	I $AF++	I 
''))5II&DaHHH 	AT%=%=%?%? 	AH55a5@@@@@	A 	A 	A 	As#   5A**A.1A.?H**H.	1H.	c                    | j                                         5  | j                            |j                  }d d d            n# 1 swxY w Y   |                     |j        d         |           d S Nr  )rE  r  r  r  r  
store_typer  )r1  r  
alias_types      r  r  z#TypeChecker.check_type_alias_rvalue  s    X##%% 	< 	<*11!(;;J	< 	< 	< 	< 	< 	< 	< 	< 	< 	< 	< 	< 	< 	< 	<	"z22222s    AA
A
r  r|   r  rk   infer_lvalue_typer  c                   t          |t          t          f          r|                     |j        |||           dS |                     ||d           |                     ||          \  }}}t          |t                    rL|j        rD|j        j	        }|dv rU|r|}	n| j
                            |          }	|	r4|dk    r|                     |	|           n|                     |	||           |dk    rK| j                                        2|p| j
                            |          }
|                     |
|           |dk    r3|1| j
                            |          }
|                     ||
|           |dk    rO| j                                        }|r4t%          j        |          r |                     t*          j        |           t          |t.                    r+|j	        dk    r |                     t*          j        |           |rFt          |t2                    rK|j        C| j
                            |          }t          t7          |          t8                    rdS |j        }t=          || j        |j                   ru| !                    |          }|\| j"        sDtG          |          }tI          |t9                      g          }| %                    |||           nd|_        ||= |j        }n<| &                    |||          sT| '                    |          }| j(        )                    ||           | %                    ||tU          |                     ntW          |          rAt          |t                    r,t          |j        tX                    r|j        j-        r|s|}nt          |t.                    rF|j.        ?| j
                            |j/                  }| 0                    |||||	          \  }}}n$| j        j1        stW          |          rt          |t                    r|j.        td          k    rt          |j        tX                    r|j        j        r|j        | j3        v rt          t7          |          th                    so| j3        |j                 }d
}tk          | j(        j6                  D ]}|j7        |v r	|j8        } n|r+tU          |          }| %                    |j        ||           | 9                    |||||          \  }}d}t7          |          }t7          |          }t          |tt                    r|;                                r|<                                j=        s|<                                j>        rnt          |t~                    rYt          |j@        t                    r?|j@        j        j=        s|j@        j        j>        r| jB        C                    ||           dS |r|rt          |t2                    st          |t                    r|jD        s~| j(        E                    |||           t          |t                    rMt          |j        tX                    r3|j        jF        r'|j        jG        r|tG          |          |j        _        n| j        j1        rn|lt          |t2                    sWt          |t                    rBt          |j        tX                    r(|j        jF        r| j(        E                    |||           n|r| H                    |||           |r| I                    ||          }| j
                            ||          }|j         s6|jG        s/t          |t                    r|j	        dk    stG          |          }| J                    ||||           | K                    |           t          |t                    r?t          |t                    r|j	        dk    s#| jM        s| N                    ||           dS dS dS dS )z0Type check a single assignment: lvalue = rvalue.=)r  r  r  r  	__slots__N__match_args__r  )is_lvalue_finalr  F)r  inferredr  r  )Or  r   r{   $check_assignment_to_multiple_lvaluesr  .try_infer_partial_generic_type_from_assignmentr  r   r  r  r  r  r  r  rK  rN  r  r  r  r  r  r   &DATACLASS_POST_INIT_MUST_BE_A_FUNCTIONr~   CANNOT_MODIFY_MATCH_ARGSr   rL  r   r   r  is_valid_inferred_typerW  r  r  rk  r+   r   set_inferred_typeinfer_partial_typeinference_error_fallback_typerF  putr   is_literal_noner   is_initialized_in_classkindr  check_member_assignmentr  rV   r\  r   r'  r  r  r  r.  r   r  r  is_abstractr  r   r$  r   rE  concrete_only_assignis_special_formr  is_inferredis_index_varcheck_indexed_assignmentget_variable_type_contextinfer_variable_typecheck_assignment_to_slotsr   rt  check_compatibility_all_supers)r1  r  r  r  r  r  index_lvaluer  r  	signaturer0  rN  rvalue_typer  rP  inferred_typer  instance_typedecl_frame_maphas_if_ancestorr  p_rvalue_typep_lvalue_typer  s                           r  r  zTypeChecker.check_assignment  s&	    fy(344 A	D55ff.?     ??PSTTT262C2CFF2S2S/Kx &(++ c c{'MMM" E$/		$($5$<$<V$D$D	  O=00 55iHHHH 55iNNN;&&4:+B+B+D+D+P%I):)A)A&)I)IC//V<<<+++0D+226::C))(C@@@?**#':#:#:#<#<L# c(:(QR^(_(_ c		"2"Y[abbb&*-- M&+AQ2Q2Q		*CVLLL GLk;77 W$K<L<T"&"3":":6"B"BK!/+">">II  %/C-#T\3<   ^ )-(?(?(D(D(4#'#= 0.OP[.\.\0E{T\T^T^F_0`0` $ 6 6sFM R R R R+/ -c 2*-(K  $66sFKPP ^
 (,'I'I+'V'VH KOOFH===
 !223@RS[@\@\]]]#F++2$"68442$ #6;442$ ;	2$
 '2$ #.KKvz22)$7={7J$($5$<$<V[$I$IMBFB^B^{FF C_ C C?K.?.? !L?U+F33U 'vx88U #K4//&v{C88 0"K, 0 #K4+??? *?;+G+G Q Q @ *.)=fk)J +0%-dk.@%A%A & &E$x>99272I %  : + U*<[*I*IK 226;TTT/3/K/K#VVhW] 0L 0 0,K
  $H !0 < < / < <}l;;%1133 &1133?	
 )4466B #=(;; #=#5x@@ &*/; @M?Q?V?b H11-HHHF N#4 NZU`=a=a N&vx88 	^V=S 	^//[QQQ&vx88^ *6; < <^ !' 7^ !' 8	^
 !, 7/PQ\/]/]FK,L7N#/&{K@@ 0 #6844	 0
 #6;44 0 / 0 K++FKMMM L--lFFKKK 	P#==hOO"/66vL6YY%Q,Q #6844Q :@HX9X9X"CK"P"PK((6;OOO**622267++D#FH55D:@+IY:Y:Y1 ;Z 33FFCCCCCD D:Y:Y:Y:Yr  )builtins.list+)builtins.set|r   partial_type_augmented_opsr  c           
     v   g }|j         r|j         j        dd          D ]}|j        |j        vr|j        |j                 j        }|                     |j        ||t          |          p$t          |t                    ot          |                     \  }}|rFt          |t                    r|j
        s*t          |t                    s|                    |           |s|j        dk    rE| j                                        ,|                     d          }|                     d|g          S |j        dk    rE| j                                        r,|                     d          }|                     d|g          S d S |d         }	|D ](}
t%          |
|	          r|
}	t'          |	|
          s d S )|	S )	Nr  r  r  r  r  r  r  r   )r  r  r  rh  r  r  	is_methodr  r   r&   invalid_partial_typer   r6  rK  rN  r  r  is_top_levelr   r   )r1  r  r  type_contextsr  	base_node	base_typer  r  rc  others              r  r  z%TypeChecker.get_variable_type_context  s   = 	4 )!""- 4 4=
22 !Jx}5:	#77M&y11 7!)S11 7+I666  8    	1 4'	3774<E<Z4 'y+>>4
 "((333 	}++
0G0G0I0I0U??>::../@8*MMM}	))dj.E.E.G.G)??>::../@8*MMM4!!$	" 	 	E 	22 !			511 tt r  opc                $   d}t          |t                    rAt          |j        t                    r't          |j        j        t
                    r|j        }n/t          |t                    r| j                            |          }||j        }t          |t
                    sJ |j        dS |dk    r|j        j	        |f| j
        vrdS |                     |          }|dS | j                            |          }t          |          }t          |t                    r5|j        |j        k    r!t          || j                  r||_        ||= dS dS dS t          |t"                    r t%          |j                  |_        ||= dS dS dS )aE  Try to infer a precise type for partial generic type from assignment.

        'op' is '=' for normal assignment and a binary operator ('+', ...) for
        augmented assignment.

        Example where this happens:

            x = []
            if foo():
                x = [1]  # Infer List[int] as type of 'x'
        Nr  )r  r   r  r   rL  r   r~   r  get_partial_self_varr  r  r  r  r   r   r  rW  r   r  )r1  r  r  r  r  r0  rP  r  s           r  r  z:TypeChecker.try_infer_partial_generic_type_from_assignment  s    vx((	A6;,,	A 6;+[99	A
 +CC
++ 	A#88@@C?(Cc;/////xSyych/4D<[[[ !33C88M$+226::K)+66K+x00 '#sx//4J5 5/  +CH%c***	 0///
 K11 '1#(;;!#&&&/ ?*' 'r  r   c           	        |j         }t          |t                    r|j        |j        k    s|j        r|j        s||j        t          d fv rgt          |j	        j
                  dk    rO|j	        j        dd          D ]_}|j                            |j                  }|<|                     |||j                   s n|                     |||j                   s n`|j	                                        }|r|d         nd }d }|j        rS|j        sLt          |j        t&                    s|j        nd }	| j                            ||	          }
|j        }|
|_        |                     |j        |j	        |          \  }}|j        r|j        s||_        |sd S |j	        j        dd          D ]	}|j        r|j        dk    r|j        dk    s!t3          |j                  r6|                     |j        ||          \  }}t5          |          }t          |t&                    rd }|r|J |                     ||||||          s d S |rW|rU|                     |j        ||d          \  }}|J t9          ||          s | j                            ||||            d S ||u r d S d S d S d S d S d S d S )	Nr   r  r  r  r  )r  Tr  )r  r  r   r  r  explicit_self_typer  rX   r  r  r  r  rh  r  r  "check_compatibility_classvar_supercheck_compatibility_final_superdirect_base_classesrL  r   r  r  r  r  r  r  r  check_compatibility_superr   rE  r  )r1  r  r  lvalue_noder  tnodedirect_baseslast_immediate_baseactual_lvalue_typer,  r  r  r  r  r  custom_setters                   r  r  z*TypeChecker.check_compatibility_all_supers  s   k {C((Z	  FK//* 0#6 0 d|++K$*++a//#(,QRR0 	 	
{'788$BB;PTV[V`aa ??TSXS]^^ &+??AAL6B"L,r"2"2
 "&& /{/M /.89I;.W.Wak&&]a"/66vsCC%0%5"#. !55k6FHXZ`aaNK& 6{/M 6#5  #(,QRR0 . . : $33IZ8Z8Zk.// '+'?'?@PRVX^'_'_$	9 ;I F Fi55 % $I $00099#!!/< :   
 " #} #'+'?'?',dF (@ ( (	1
  )444))[AA # HAA &Y   #FF222 uZ	 Z	 ,+	 0///
 0/B. .r  compare_typer  r  r   r  c           
        |                      |||t          j        dd|j         d          }|r\t          j        | j        j        v rD|                     |          r/|s-|                      |||t          j	        d|j         dd          }|S )Nzexpression has typezbase class "z" defined the type as)
r  r    INCOMPATIBLE_TYPES_IN_ASSIGNMENTr  r  r  rW  r  r  r  )r1  r  r  r  r  r  r  r  s           r  r   z%TypeChecker.check_compatibility_superG  s     =!;49;;;
 
 	&$,*JJJ**955 K* K ## H?ty???% B 	r  )r  r  r^  r  r  r^  %tuple[Type | None, SymbolNode | None]c          	        |j                             |          }|rNt          |j        t          t
          f          r|j        r&t          |j        t                    r|j        j        dS || j        	                                }nt          |          }|
J d            t          |t                    rt          |          }	n|}	t          |dt          j                            |          ||| d          }
| j                            d          5  |r6|	j        j        p|
                    d          }t+          |	||
||	          }nt-          ||	|
|          }ddd           n# 1 swxY w Y   ||j        fS )
a  Find a type for a name in base class.

        Return the type found and the corresponding node defining the name or None
        for both if the name is not defined in base or the node type is not known (yet).
        The type returned is already properly mapped/bound to the subclass.
        If setter_type is True, return setter types for settable properties (otherwise the
        getter type is returned).
        NNNz)Internal error: base lookup outside classFT)r1  r2  r3  r4  r  r+  suppress_errorsfilter_deprecatedr>  )mcs_fallbackoverride_info)rh  r  r  r  r   rg   rL  r   rK  current_self_typer  r   r   r"   rz  r{  is_operator_methodrE  r  r  r  r#   r$   )r1  r  r  r  r  r  r^  r  rT  r  mxr  r  s                r  r  zTypeChecker.node_type_from_basej  s   $ JNN4((	 	).3	*:;;	 N	 ).+66		
 #/: 
4466II%m44I$$&Q$$$i++ 	!%i00HH H!99$??# 
 
 
 X##d#;; 	U 	U U#=7Y2==;Y;Y:dBXT  		 ;42tTT		U 	U 	U 	U 	U 	U 	U 	U 	U 	U 	U 	U 	U 	U 	U ).((s   AE00E47E4Node | Nonec                T   t          |t                    sdS |j        rA|j        s:|                     t          j                            |j                  |           dS |j        sA|j        r:|                     t          j                            |j                  |           dS dS NTF)	r  r   is_classvarr  r   CANNOT_OVERRIDE_INSTANCE_VARr  r  CANNOT_OVERRIDE_CLASS_VARr1  r  r  r  s       r  r  z.TypeChecker.check_compatibility_classvar_super  s     )S)) 	4 	I$9 	II&CJJ49UUW[\\\5! 	i&; 	II&@GG	RRTXYYY5tr  c                   t          |t          t          t          f          sdS t	          |j                  rdS |j        rD|j        st          |t                    s(| j                            |j        |j        |           dS |j        r:|j	        t          v s|j        t          v rdS |                     |j        ||           dS )a  Check if an assignment overrides a final attribute in a base class.

        This only checks situations where either a node in base class is not a variable
        but a final method, or where override is explicitly declared as final.
        In these cases we give a more detailed error message. In addition, we check that
        a final variable doesn't override writeable attribute, which is not safe.

        Other situations are checked in `check_final()`.
        TF)r  r   ro   rg   r  r  r  rE  r  r  r   r   r  r  s       r  r  z+TypeChecker.check_compatibility_final_super  s     )c8Y%?@@ 	4di   	4 	4= 	
9c8R8R 	
 H((DItDDD5= 	R}
**di;M.M.Mt55diDQQQtr  c                v    d}|r|                      |          }|r| j                            ||           dS dS )a  Check that a final variable doesn't override writeable attribute.

        This is done to prevent situations like this:
            class C:
                attr = 1
            class D(C):
                attr: Final = 2

            x: C = D()
            x.attr = 3  # Oops!
        TN)r  rE  final_cant_override_writable)r1  r  r  r,  writables        r  r  z0TypeChecker.check_if_final_var_override_writable  sT      	=11)<<H 	=H11$<<<<<	= 	=r  c                    | j         S )z:Check whether we a currently checking a final declaration.rv  r~  s    r  get_final_contextzTypeChecker.get_final_context  r  r  r  c              #  V   K   | j         }|| _         	 dV  || _         dS # || _         w xY w)zDStore whether the current checked assignment is a final declaration.Nr!  )r1  r  old_ctxs      r  r  zTypeChecker.enter_final_context  sH       $)	)EEE!(DD((((r8  8AssignmentStmt | OperatorAssignmentStmt | AssignmentExprc                   t          |t                    r|                     |j                  }n&t          |t                    r	|j        g}n|j        g}t          |t                    r|j        nd}|r| j        	                                x}r|d         }t          |t                    sJ |j        xt          |j        t                    sJ |j        j        rP|j        j        sD| j        s=t          |t                    r(|j        !|j        s| j                            |           |D ]}t          |t                    rt          |j        t                    r|j        j        }| j        	                                }||j        dd         D ]p}|j                            |          }	|	rRt          |	j        t                    r8|	j        j        r,|s*| j                            ||	j        j        du |            nq|j        j        r*|s(| j                            ||j        j        du |           dS )a  Check if this assignment does not assign to a final attribute.

        This function performs the check only for name assignments at module
        and class scope. The assignments to `obj.attr` and `Cls.attr` are checked
        in checkmember.py.
        Fr   Nr  )r  r]   flatten_lvaluesr  r\   targetr  r  rK  rN  r   r  r   final_unset_in_classfinal_set_in_initrl  rL  r  rE  final_without_valuer  r  rh  r  r  cant_assign_to_finalr  )
r1  r  lvsis_final_declrN  r  r  r  r  r  s
             r  r  zTypeChecker.check_final  s`    a(( 	&&qy11CC>** 	8*CC8*C*4Q*G*GRU 	4dj.E.E.G.GGl 	4QBb'*****w"!"'3/////G04G54 !L4 q.114 * )7 +
 H00333 	Q 	QB"g&& Q:bgs+C+C Qw|j--//? !$ 	& 	&"jnnT22  &:ch#<#< &"x0 & & $ = =dCHMUYDY[\ ] ] ] %7# QM QH11$8LaPPP'	Q 	Qr  c                   t          |t                    sd S t          | j                            |j                            }t          |t                    r-|j                                        rt          |j	                  }t          |t                    sd S |j        j        d S |j        |j        j        v rd S |j        j        d d         D ]}|j                            d           d S  |j                            |j                  }|d S |                     ||j                  rd S |                     t&          j                            |j        |j        j                  |           d S )Nr  r  )r  r~   r   r  r  r  r   r  is_selfr5  r   rL  slotsr  r  rh  r  is_assignable_slotr  r   NAME_NOT_IN_SLOTSr  r  )r1  r  inst	base_infor  s        r  r  z%TypeChecker.check_assignment_to_slots(  sm   &*-- 	Ft077DDEEdK(( 	5TW__->-> 	5"4#344D$)) 	F9?"F;$)/))Fss+ 	 	I""=11= 	 > Y]]6;//
 F""6:?;; 	F		.55fk49CUVVX^	
 	
 	
 	
 	
r  c                |    t          dd           rdS t          |          }|t          |t                    rdS t          |t                    r|j                            d          d uS t          |t                    rdS t          |t                    r!t           fd|j
        D                       S dS )Nr  FT__set__c              3  D   K   | ]}                     |          V  d S r0  )r2  )r  ur  r1  s     r  r  z1TypeChecker.is_assignable_slot.<locals>.<genexpr>Z  s3      MMat..vq99MMMMMMr  )getattrr   r  r   r   rL  r  r   r   ra  r  )r1  r  r0  s   `` r  r2  zTypeChecker.is_assignable_slotJ  s    664(( 	5c"";*S'22;4c8$$ 	7
 8<<	**$66c<(( 	4c9%% 	NMMMMM39MMMMMMur  rvalueslist[Expression]c           	        g }|D ]P}t          |t                    s|                    |           .t          | j                            |j                            }t          |t                    s|                    |           |j        D ]}t          |t                    s#|                    t          |                     :t          |j                  }t          |t                    r|j        }n)t          |t                    r|j        j        dk    sJ |}|                    t          t          |                               ĐR|S )zFlatten expression list by expanding those * items that have tuple type.

        For each regular type item in the tuple type use a TempNode(), for an Unpack
        item use a corresponding StarExpr(TempNode()).
        builtins.tuple)r  r   r6  r   r  r  r  r   r  r   r   rL  r   r5  r   r  )r1  r;  new_rvaluesrvr0  r  unpackedr  s           r  flatten_rvalueszTypeChecker.flatten_rvalues]  s`     	E 	EBb(++ ""2&&&!$"3":":27"C"CDDCc9-- ""2&&&Y E E!!Z00 E&&x{{3333.qv66H!(,<== ,#+#7 'x:: ( 6:J J J J J#+&&x0B0B'C'CDDDDE r  r  list[Lvalue]c                >   t          |t          t          f          rg }d d }t          |                     |j                            D ]T\  }t          t                    r#t          | j        	                    j
                            }|                     |          rt          |t                    r;|                     ||          k    r!|                     t          j        |           |	|dz   |k    r.|                               |}|                     ||          |                     t          j        |           
|                     t          j                            |          |           ?|                               Vd }	d }
t          |          D ]v\  }t          t                    r\t          | j        	                    j
                            }|                     |          rt          |t                    r|	|}	|}
w|	i|
ge|
|	z
  dz   }t)          |          t)          |          |z
  z
  }|dk    r5|d|	         fdt+          |          D             z   ||
dz   d          z   }|                     |t)          |          |          rDt/          d t          |          D             t)          |                    }|d |         }|t)          |          k    rt1          t          ||                   nd }||dz   d          }|                     ||t)          |                    \  }}}t5          t7          ||                    }|r@t          |          }|                    |           |                    |j
        |f           |                    t7          ||                     |D ]\  }}|                     |||           d S d S |                     ||||           d S )Nr  r   c                2    g | ]}t                     S )r  r   )r  r  iterable_typervals     r  rt  zDTypeChecker.check_assignment_to_multiple_lvalues.<locals>.<listcomp>  s&    ___Q8M4@@@___r  c              3  J   K   | ]\  }}t          |t                    |V  d S r0  r  r   r  r   r  s      r  r  zCTypeChecker.check_assignment_to_multiple_lvalues.<locals>.<genexpr>  s5      SS51b*R:R:RSQSSSSSSr  ) r  r   r{   r  rB  r  r   r   r  r  r  type_is_iterabler   iterable_item_typer  r   CONTIGUOUS_ITERABLE_EXPECTEDr6  ITERABLE_TYPE_EXPECTEDr  r  r   check_rvalue_count_in_assignmentrv  r   split_around_starr  r  set_lineextendr  check_multi_assignment)r1  r  r  r  r  r;  last_idxidx_rvaltypsiterable_startiterable_endr   iterable_numrvalue_needed
star_indexleft_lvsstar_lv	right_lvsleft_rvsstar_rvs	right_rvslr_pairsrv_listr  r@  rG  rH  s                            @@r  r  z0TypeChecker.check_assignment_to_multiple_lvalues|  s|    fy(344 K	U
 )+G)-M#'H"+D,@,@,N,N"O"O ) )$dH-- )*4+<+C+CDI+N+NOOD,,T22 az$7Q7Q a(4$JaJa &K K : : !II&6&SU\]]]]'/8a<83K3K 't 4 4 4+3040G0Gf0U0U $		*:*WY` a a a a		"2"I"P"PQU"V"VX_````NN4(((()-N'+L$W-- ) )4dH-- )*4+<+C+CDI+N+NOOD,,T22 )z$7Q7Q ))1-.N'(* ,!-+n<q@ #GG|0K L 1$$. 01_____%P]J^J^___`!,"2"4"456  44Wc'llGTT E!SSIg$6$6SSSUXY`UaUa 
 #;J;/;EW;U;UD7:#6777[_  $JN$4$45	040F0FZW1 1-(I  Hh 7 788 =&x00G$$V,,,OOW\7$;<<<Iy 9 9:::& E EFB))"b2CDDDD/E E,E E ''BSTTTTTr  rvalue_countrvalue_unpack
int | Nonec                   |t          d |D                       s|                     d|           dS t          |          |k    r"|                     t          j        |           dS t          d t          |          D                       }|}t          |          |z
  dz
  }|}||z
  dz
  }	||	k    s||k    r |                     t          j        |           dS t          d |D                       rEt          |          dz
  |k    r.| j                            |t          |          dz
  |           dS n>|t          |          k    r+| j                            |t          |          |           dS dS )Nc              3  @   K   | ]}t          |t                    V  d S r0  rJ  )r  es     r  r  z?TypeChecker.check_rvalue_count_in_assignment.<locals>.<genexpr>  s,      @@1z!X..@@@@@@r  z/Variadic tuple unpacking requires a star targetFc              3  J   K   | ]\  }}t          |t                    |V  d S r0  rJ  rK  s      r  r  z?TypeChecker.check_rvalue_count_in_assignment.<locals>.<genexpr>  s7      "a"aB
SUW_H`H`"a1"a"a"a"a"a"ar  r  Tc              3  @   K   | ]}t          |t                    V  d S r0  rJ  )r  r  s     r  r  z?TypeChecker.check_rvalue_count_in_assignment.<locals>.<genexpr>  s,      BBz&(++BBBBBBr  )	rC  r  r  r   $TOO_MANY_TARGETS_FOR_VARIADIC_UNPACKrv  r  rE  wrong_number_values_to_unpack)
r1  r  re  r  rf  left_star_indexleft_prefixleft_suffixright_prefixright_suffixs
             r  rP  z,TypeChecker.check_rvalue_count_in_assignment  s    $@@@@@@@ 		KWUUUu7||l**		*OQXYYYu""a"a)G2D2D"a"a"aaaO)Kg,,81<K(L'-7!;L\))[<-G-G 		*OQXYYY4BB'BBBBB 	7||a,..66|S\\TUEUW^___u / S\\))H22<WwWWW5tr  rv_typeundefined_rvaluec                (   t          |p| j                            |                    }t          |t                    rt          |j                  }t          |t                    r<|                                }t          |          dk    rt          |d                   }t          |t                    r$t          |j                  t          |i           }t          |t                    ri|D ]d}	t          |	t                    r|	j        }	|                     t          t"          j        |          |          }
|                     |	|
|           edS t          |t                    r|                     ||||||           dS t          |t                    r|                     |||||           dS |}t          |t,                    r9|j        j        dk    r)|j        | j                            |           n|j        }t          |t8                    rYt          |j        t<                    r?t          |          t          |j                  k    r| j                            |           |                     ||||           dS )z:Check the assignment of one rvalue to a number of lvalues.r  r   Nro  r  ) r   r  r  r  r   r5  r   rb  r  r   r   r  r7   r   r   r  r)  r   ru  r  !check_multi_assignment_from_tuple!check_multi_assignment_from_unionr   rL  r  last_known_valuerE  unpacking_strings_disallowedr   r  rd  $check_multi_assignment_from_iterable)r1  r  r  r  r  rt  ru  r  rb  r  r)  rvalue_literals               r  rT  z"TypeChecker.check_multi_assignment  s    &g&Q1B1I1I&1Q1QRRk?33 	C)+*ABBKk9-- 	A(7799N>""a''-nQ.?@@ {I..	7#K$566B &k266Kk7++  	 H Hb(++ !B NNI6;OOOQX 	 %%b)5FGGGGH H Y// 	22g7GIZ     Y// 	22g7H     )N+x00 B[5E5NR`5`5`/7H99'BBBB%0%AN>;77?~3S99? LLC(<$=$===55g>>>55g/@    r  r  r   c                   d| _         t          d |                     |          D                       }| j                                        5 }|j        D ]}|                     |||||d           t          ||                     |                    D ]P\  }	}
|	                    | j	        d         
                    |
t          t          j                                       Q	 ddd           n# 1 swxY w Y   t          d |D                       }|                                D ]\  }}t          |t                    r|j        }g }|D ] \  }}|J |                    ||f           !t          | \  }}| j                            |t%          t'          |                    t%          t'          |                               t          ||                     |                    D ]N\  }}
|                     |
          \  }}}|r|                     ||
|           8|                     |
|           Od| _         dS )a  Check assignment to multiple lvalue targets when rvalue type is a Union[...].
        For example:

            t: Union[Tuple[int, int], Tuple[str, str]]
            x, y = t
            reveal_type(x)  # Union[int, str]

        The idea in this case is to process the assignment for every item of the union.
        Important note: the types are collected in two places, 'union_types' contains
        inferred types for first assignments, 'assignments' contains the narrowed types
        for binder.
        Tc              3     K   | ]}g V  d S r0  r  )r  r  s     r  r  z@TypeChecker.check_multi_assignment_from_union.<locals>.<genexpr>J  s"      2]2]!22]2]2]2]2]2]r  )r  rt  ru  r  Nc              3  4   K   | ]}t          |          V  d S r0  )r   )r  cols     r  r  z@TypeChecker.check_multi_assignment_from_union.<locals>.<genexpr>\  s+      MM31#66MMMMMMr  F)rY  tupler'  rF  accumulate_type_assignmentsr  rT  r  r6  r5  r@  r   r   r	  r  r   r  r  r   r  r  r  r  )r1  r  r  r  r  r  
transposedr  r$  r  r  union_typesr  r  clean_itemsrL  declared_typer  declared_typesunion_1_2r  s                          r  rx  z-TypeChecker.check_multi_assignment_from_union5  s   ( !%-22]2]t?S?ST[?\?\2]2]2]-]-]
[4466 	[+#) [ [ ++&7 %) ,    !T-A-A'-J-JKK [ [EAr HHT_R044RAW9X9XYYZZZZ[[	[ 	[ 	[ 	[ 	[ 	[ 	[ 	[ 	[ 	[ 	[ 	[ 	[ 	[ 	[  MM*MMMMM&,,.. 	 	KD%$)) !y 46K', : :#m$000""D-#89999$'$5!E>K##%d5kk22%d>&:&:;;   
 [$*>*>w*G*GHH 	+ 	+IE2#0044BH +&&xU;;;;E**** %s   BC44C8;C8c                   g }|D ]|}t          |t          t          f          r-|                    |                     |j                             t          |t                    r|j        }|                    |           }|S r0  )	r  r   r{   rS  r'  r  r   r  r6  )r1  r  resr  s       r  r'  zTypeChecker.flatten_lvaluesx  s~     " 	 	B"y(344 ;

4//99:::"h'' WJJrNNNN
r  r   c                    t          |j                  }                     |t          |j                  |          rt	          d t          |          D             t          |                    }|d |         }	|t          |          k    rt          t          ||                   nd }
||dz   d          }|s                     ||          }t           j
                            ||                    }t          |t                    rt          |j                  }t          |t                    r<|                                }t          |          dk    rt          |d                   }t          |t                    r                     ||||           d S t          |t$                    rd S t          |t&                    sJ |}                     |j        |t          |                    \  }}}t+          |	|          D ]0\  }}                     |                     |          |           1|
rMt1           fd|D                       }|                                                    |
j        ||           t+          ||          D ]0\  }}                     |                     |          |           1d S |r |D ]}t          |t6                    rJt          |j        t:                    r0|j        j        $t%          t>          j                   |j        _        at          |t                    rt          |j        t6                    rmt          |j        j        t:                    rN|j        j        j        = !                    dt%          t>          j                   g          |j        j        _        d S d S )N)rf  c              3  J   K   | ]\  }}t          |t                    |V  d S r0  rJ  rK  s      r  r  z@TypeChecker.check_multi_assignment_from_tuple.<locals>.<genexpr>  s5      OOuq"jX6N6NOOOOOOOr  r  r   c                    g | ]U}t          |t                    s                    |          n't                              |j                            VS r  )r  r   r)  r   rL  )r  rt  r  r1  s     r  rt  zATypeChecker.check_multi_assignment_from_tuple.<locals>.<listcomp>  si        $ $.gz#B#BQDNN7G<<<!)$..w*O*O!P!P	  r  r  )"r   r  rP  r  rv  r  r   r   lvalue_type_for_inferencer   r  r  r  r   r5  r   rb  rx  r   r   rQ  r  r  r)  r{   rR  r  r   r  r   rL  r   rv  r  )r1  r  r  r  r  ru  r  rf  r\  r]  r^  r_  r  reinferred_rvalue_typerb  left_rv_typesstar_rv_typesright_rv_typesr  rt  	list_exprs   `   `                r  rw  z-TypeChecker.check_multi_assignment_from_tuple  s*    ,K,=>>00S*++WM 1 
 
 Q	 OO	' 2 2OOOQTU\Q]Q] J {
{+H=G3w<<=W=Wd8WZ%8999]aG
Q 0 01I# 5"<<WkRR)8%,,V[AA* *& 4oFF a-<=S=_-`-`*4i@@ T%;%J%J%L%LN>**a//1@PQAR1S1S.4i@@ ::)?J[   F4g>>  F!"8)DDDDD4;?;Q;Q!:s7||< <8M=.  #8];; _ _G%%b$..'*J*JL]^^^^ R$     (5  	 		 ""7+++%%glI?PQQQ"9n== _ _G%%b$..'*J*JL]^^^^_ _
 ! !  B"2x00&rw44 GL0'.y/C'D'D#B11 &rw99 *27< = = !# 1 9040G0G /'):N2O2O1P1 1BGL-  r  c                    t          d t          |          D             t          |                    }|d |         }|t          |          k    rt          t          ||                   nd }||dz   d          }                     |j        |t          |                    \  }}}	g d fd	}
 |
||           |rq                     |j                  \  }}}|r<t          |t                    s'                    |gt          |          z             n                    |            |
||	           t                               d
                    S )Nc              3  J   K   | ]\  }}t          |t                    |V  d S r0  rJ  rK  s      r  r  z8TypeChecker.lvalue_type_for_inference.<locals>.<genexpr>  s5      KK51b*R2J2JKQKKKKKKr  r  r-  r<  rv_typesrM  r-  r.  c                    t          | |          D ]`\  }}                    |          \  }}}|r+t          |t                    s                    |           K                    |           ad S r0  )r  r  r  r   r6  )	r-  r  r  rt  sub_lvalue_type
index_exprr  r1  type_parameterss	          r  append_types_for_inferencezITypeChecker.lvalue_type_for_inference.<locals>.append_types_for_inference  s    "311 4 4G8<8I8I"8M8M5X" 4:o{+S+S 4#**?;;;; $**733334 4r  r>  )r-  r<  r  rM  r-  r.  )rv  r  r  r   r   rQ  r  r  r  r  r   rS  r   r  )r1  r  r  r\  r]  r^  r_  r  r  r  r  r  r  r  r  s   `             @r  r  z%TypeChecker.lvalue_type_for_inference  s   KKIg..KKKSQX\\
 

 ;J;'9Cs7||9S9S$x!4555Y]JN,,-	7;7M7Mz3w<<8
 8
4}n ')	4 	4 	4 	4 	4 	4 	4 	#"8];;; 	6484E4Egl4S4S1OZ 6z/;'O'O 6&&'83};M;M'MNNNN  &&}555""9n===$//:J*K*KLLLr  r  list[T]r\  length tuple[list[T], list[T], list[T]]c                    ||z
  dz
  }|dk    r| nt          |          }|d|         }|||         }||d         }|||fS )a  Splits a list of items in three to match another list of length 'length'
        that contains a starred expression at 'star_index' in the following way:

        star_index = 2, length = 5 (i.e., [a,b,*,c,d]), items = [1,2,3,4,5,6,7]
        returns in: ([1,2], [3,4,5], [6,7])
        r  r   N)r  )	r1  r  r\  r  nr_right_of_starright_indexr}  starr~  s	            r  rQ  zTypeChecker.split_around_star  sj     "J.2+;q+@+@'''c%jj[j[!Z+,kll#T5  r  c           	         t          |          }t          |t                    r|                                r|j        }t          ||                     dt          t          j	                  g                    S )Nr  )
r   r  r   r  r  r   r  r   r   r	  r1  rL  s     r  rL  zTypeChecker.type_is_iterable  sq    t$$dL)) 	!d.>.>.@.@ 	!=D$))*;giF\>]>]=^__
 
 	
r  c                   t          |          }|                     |          r|                     ||          }|D ]}t          |t                    rH|                     d|g          }|                     |j        |                     ||          |           _|                     ||                     ||          |           d S | j	        
                    ||           d S )Nr  )r   rL  rM  r  r   r  r  r  r)  rE  type_not_iterable)r1  r  r  r  r  r%  r  
items_types           r  r{  z0TypeChecker.check_multi_assignment_from_iterable  s    &k22  -- 	=//WEEI 	 	b(++ !%!8!89+!V!VJ))
G!D!DFW    ))DNN9g>>@Q   	 	 H&&{G<<<<<r  0tuple[Type | None, IndexExpr | None, Var | None]c                    d }d }d } j         j        out          |t                    o`t          |j        t
                    oF|j        j        o:|j        j        d uo,t          |j        j        t                     o|j        j	         } 
                    |          rt          |t                    rt          |j        t
                    r{|syt          |t                    r%t          |j        t
                    sJ |j        }nt          |t                    sJ  j                            |j                   |j        }nt          |t                     r|}nwt          |t                    r4 j                            |d|          }                     ||           n.t          |t                    rx j                            |d          } j         j        r9t          |j        t
                    r|j        j        s|j        j        r|j        }                     ||           nt          |t*          t,          f          r7 fd|j        D             }t1          |                     d                    }nNt          |t4                    r                     |j                  \  }}}n j                            |          }|||fS )NT)r  c                b    g | ]+}                     |          d          pt                      ,S r   )r  r   )r  sub_exprr1  s     r  rt  z,TypeChecker.check_lvalue.<locals>.<listcomp>h  sN       
 	 !!(++A. "  !!	  r  r>  )rW  r  r  r   r  r   r  rL  r   r  is_definitionr~   r  r  r  def_varrx   analyze_ordinary_member_accessr  analyze_ref_expris_argumentr   r{   r  r   r  r   r  )	r1  r  r  r  r  r  skip_definitionr  r  s	   `        r  r  zTypeChecker.check_lvalue5  s    
 L/ -68,,-6;,,- '-  ,	-
 v{/===- K,, 	 v&&)	;11)	;5?S5Q5Q)	; $)	;
 &(++ *!&+s33333!;!&*55555!((555!>	** 	;!LL
++ 	;+JJ6SWY_``KOOFK0000)) 	;+<<VD<QQK3'v{C00' [,' 170G' ";OOFK0000H 566 	;   
 !'  E $E4??;K+L+LMMKK)) 	; $ 1 1&+ > >KAA+226::KL(22r  c                    t          |t                    r/|j        rdS |j        }t          |t                    r	|j        d u S nt          |t                    r|j        S dS r  )r  r   is_inferred_defr  r   rL  r~   )r1  r  r  s      r  r  zTypeChecker.is_definitionw  sq    a"" 	%  t 6D$$$ )yD(():&& 	%$$ur  	init_typec           	        t          |t                    r| j                            ||           dS t	          || j        |j        t          |t                              s| j        	                                r6t          |j                  r"t          t          |          t                    sg| j        s`|j        dk    rQ|                     |||          s<| j                            ||| j                   |                     |||           dS dS dS t          |t                    r}| j        v|j        ro|j        | j        v rat)          | j        |j                 |          sA| j                            ||| j                   t+          t,          j                  |_        dS t3          |          }|                     |||           | j        j        r| j                            |||           dS dS )z>Infer the type of initialized variables from initializer type.)r  is_lvalue_memberr  N)r  r   rE  deleted_as_rvaluer  rW  r  r~   rK  rN  r  r  r   r   rY  r  need_annotation_for_var!set_inference_error_fallback_typerX  r  r   r   r   rv  rL  r  r  r  rF  r  )r1  r  r  r  r  s        r  r  zTypeChecker.infer_variable_type  s    i-- ,	FH&&y':::::& $!+FJ!?!?	  *	F 
''))*	F di((*	F y998DD*	F )*	F* yC(?(?fi(X(X00wMMM66tVYOOOOO   vz**	F-9 :$"??? !>v~!NPYZZ @ H,,T7DLIII	 455DIII
 #9--I""4;;;|2 F''	9EEEEEF Fr  c                   t          |          }t          |t                    r3t          |t                    s| j        j        st          d |          }nBt          |t                    r*|j        j	        }t          |t                    }|rY|dk    s|dk    s|dk    s|dk    rAt          d t          |j                  D                       rt          |j        |          }n|r|dk    rt          |j        d                   }t          |j        d                   }t          |t          t          f          rR|                     |          r=t!          |          }t          |t                    sJ t          |j        ||          }nd	S d	S d	S |                     |||           || j        d
         j        |<   dS )Nr  r  builtins.dictcollections.OrderedDictc              3  N   K   | ] }t          |t          t          f          V  !d S r0  )r  r   r   r  r  s     r  r  z1TypeChecker.infer_partial_type.<locals>.<genexpr>  sE         q8_"=>>     r  collections.defaultdictr   r  Fr  T)r   r  r   r~   rW  r  r   r   rL  r  r   ra  r   rw  r   'is_valid_defaultdict_partial_value_typer)   r  rP  r%  )	r1  r  r  r  partial_typer  is_refarg0arg1s	            r  r  zTypeChecker.infer_partial_type  s   #I..	i** %	vz**%	26,2U%	
 'tT22LL	8,, 	 ~.H00F //>11?22#<<<  -in==     =  +9>4@@ H(AAA&y~a'899&y~a'8998_5  !BB4HH! &d++D%dH55555#.y~tT#J#JLL 5u5tV\:::+12"4(tr  r  r   c                j   t          |t                    sdS t          |j                  dk    rdS t          |j                  dk    rit	          |j        d                   }| j        j        r#t          |t          t          t          f          }nt          |t          t          f          }|rdS dS )a  Check if t can be used as the basis for a partial defaultdict value type.

        Examples:

          * t is 'int' --> True
          * t is 'list[Never]' --> True
          * t is 'dict[...]' --> False (only generic types with a single type
            argument supported)
        Fr   Tr  )
r  r   r  rw  r   rW  old_type_inferencer   r   r   )r1  r  r  alloweds       r  r  z3TypeChecker.is_valid_defaultdict_partial_value_type  s     !X&& 	5qv;;!4qv;;!!!&),,C|. G$S?Hk*RSS$S?H*EFF tur  c                
   |rw| j         sq||_        d|_        d|_        || j        vrd | j        j        D             | j        |<   t          |t                    r| j	        |j
        || j	        |j
        <   |                     ||           t          |          }d}t          |t                    r|j        }n't          |t                    r|j        d         j        }|rt#          |          r	d|_        dS t'          |          r	d|_        dS t+          |          r[d|_        t          |t                    rAd|_        t          |t.                    s
J |            |j        j        |_        dS dS dS dS dS dS )zStore inferred variable type.

        Store the type to both the variable node and the expression node that
        refers to the variable (lvalue). If var is None, do nothing.
        Tc                    h | ]	}|j         
S r  r  )r  r  s     r  r  z0TypeChecker.set_inferred_type.<locals>.<setcomp>
  s    ,V,V,V%UX,V,V,Vr  Nr   )rk  rL  r  is_readyr\  rF  r  r  r~   rX  r  r  r   r   r  r   r  is_node_staticis_staticmethodis_classmethod_noderN  r  r  rg   r  r  )r1  r  r  rL  p_typer  s         r  r  zTypeChecker.set_inferred_type  s     	Et1 	ECH"COCL$...,V,V4;CU,V,V,V$S)&*-- I$2O2[>-DHD1&.AOOFD)))$T**FJ&,// 8#.

FJ// 8 $\!_7
 E!*-- 
E*.C'''(44 E)-C&&& ,, E&*CO!&*55 E370)*i@@LL*LLL*4.*D?	E 	E 	E 	E(E E
E EE Er  c                ^    |                      |          }|                     |||           dS )a  Store best known type for variable if type inference failed.

        If a program ignores error on type inference error, the variable should get some
        inferred type so that it can be used later on in the program. Example:

          x = []  # type: ignore
          x.append(1)   # Should be ok!

        We implement this here by giving x a valid type (replacing inferred Never with Any).
        N)r  r  )r1  r  r  rL  r  s        r  r  z-TypeChecker.set_inference_error_fallback_type%  s5     55d;;sFH55555r  c                b    |                     t                                }t          |          S r0  )r  SetNothingToAnyr*   )r1  rL  r  s      r  r  z)TypeChecker.inference_error_fallback_type3  s)    ;;0011 h'''r  c                   t          |t          t          t          t          t
          f          rdS t          |t                    rt          |j        t
                    rt          |j        j        t                    rb|j        j        j
        }t          |t                    r|j         S t          |t                    rt          d |j        D                        S dS )a  Returns True for expressions for which inferred type should not depend on context.

        Note that this function can still return False for some expressions where inferred type
        does not depend on context. It only exists for performance optimizations.
        Tc              3  $   K   | ]}|j         V  d S r0  rR  r  s     r  r  z,TypeChecker.simple_rvalue.<locals>.<genexpr>I  s$      "H"Hd4>"H"H"H"H"H"Hr  F)r  ry   r   ra   rm   r   rb   rF  r  rZ   rL  r   rR  r   rC  r  )r1  r  r0  s      r  simple_rvaluezTypeChecker.simple_rvalue9  s     fwIwOPP 	4fh'' 	I&-11 Ij"$97 7 I m(-c<00 I"},,Z00 I""H"Hci"H"H"HHHHHur  r  preferred_contextfallback_context
Var | NonerB  c                |   ||usJ | j         j        }d}| j                            d          5 }	| j        5 }
| j                            |||          }ddd           n# 1 swxY w Y   ddd           n# 1 swxY w Y   |duo|j         ot          || j	                   }|duo|j        o|	
                                }|duo1t          t          |          t                    o|| j         j        k    }|p|p|}|rt          |          s| j                            d          5 }| j        5 }| j                            |||          }ddd           n# 1 swxY w Y   ddd           n# 1 swxY w Y   |
                                sdt          || j	                  rO|s4|s2t          t          |          t                    s)t!          ||          rd}|}|                     |           |sA| j                            |	                                           |                     |
           |S )zInfer rvalue type in two type context and select the best one.

        See comments below for supported fallback scenarios.
        FT)save_filtered_errorsr  rB  N)rB  )rF  versionrE  r  rp  r  r  r  r  rW  has_new_errorsr  r   r   r   r   r   store_types
add_errorsfiltered_errors)r1  r  r  r  r  r  rB  binder_versionfallback_context_usedlocal_errorstype_mapr  redefinition_fallbackargument_redefinition_fallbackunion_fallbacktry_fallbackalt_local_errorsalt_type_mapalt_rvalue_types                      r  "infer_rvalue_with_fallback_contextz.TypeChecker.infer_rvalue_with_fallback_contextL  s     '88888 , %H"""==	AM	#++22%6IY 3  K		 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 D  F((F*;EEE 	 D [X%9[l>Y>Y>[>[ 	' T) 6?;77CC6$+"55 	 -``B` 	/ 4[ A A 	/&&D&AAEU#'3"&"3":":,?O #; # #	                              %3355/*?DLII/
 */ 6/ &oo&F&FPP/ */;GG/ )-%-  ...$ 	'H < < > >???X&&&sj   A9A"A9"A&	&A9)A&	*A99A= A=-E65EE6E#	#E6&E#	'E66E:=E:r  
expression)r*  r  r  r@   r(  r)  r*  list[str] | Nonetuple[Type, Type | None]c          	     ,   | j         r0t          |t                    rt          t          j                  |fS |d uo"t          t          |          t                     }
|	d up!t          t          |          t                    o|                     |           }|r|t          |          r| j
                            |||
          }n,|	|	j        sd }|}n|}d }|                     |||||	|
          }|	t          || j                  sx|	j        r/t          |	j        t"                    st%          ||	j                  sB| j                            |	|	| j                   |                    t+                                }t          |t,                    r|	|	j        |	j        st1          |          }|                     |          st          |	j        t"                    st5          ||	j                  st7          |	j        |g          }|	j        s| j                            |	j                   |                      |	||           | j!        "                    ||           tG          |          }||| j!        j$        |<   t          |tJ                    r| j        &                    ||           t          |tJ                    r| j        '                    ||           n$|r"| (                    ||||| d| d|           ||fS )Nr  z	 has type)r*  ))rl  r  rj   r   r   r	  r   r   r  is_typeddict_type_contextr  r  r  r  r  rW  rL  r   r   rE  r  r  r   r  r+   refers_to_different_scoper   r   r  rR  r6  r  r  rF  r  r;   r  r   r  deleted_as_lvaluer  )r1  r  r  r  rE  r(  r)  r*  r  r  rB  r  r  	preferredr  new_inferredlits                    r  r.  z#TypeChecker.check_simple_assignment  s    < \	,Jv|<< \	,9122K??*$6  z,,g@ @ < $[
?;3O3OQZ([([1((000    ;#6:ST_:`:`#6"/66GW 7   '0D' $I*HH +I#H"EEHhHX 
 $.{DLII % ! % "(-==	 % &k8=AA % 008T\RRR)001B1BCC 68,,D(M- ) .  AMM
 66v>>D&x}kBBD .lHMJJD
 #88U"V"VK#0 @)00???**8V[IIIKOOFK888 'v..C8C05+{33 A**;@@@+{33 **;@@@@ 
"""---"--- # 	 	 	 ++r  r   c                    |j         t          k    rdS | j                                        dS |j         t          k    r0|j                            d          d         | j        j        k    rdS dS )NFT.r   )r  rV   rK  r  rR   r  
rpartitionrb  r1  r  s     r  r  z%TypeChecker.refers_to_different_scope  sh    95Z**,,84Y$4=#;#;C#@#@#CtyGY#Y#Y4ur  r~   r  set_lvalue_typetuple[Type, Type, bool]c                   t          |          }t          |t                    r|                                st          |t                    r|                     |||          \  }}||dfS | j                            d          5  | j        	                    |d          }ddd           n# 1 swxY w Y   |                     |||          \  }}t          ||          r|n|}||t          ||          fS )a:  Type member assignment.

        This defers to check_simple_assignment, unless the member expression
        is a descriptor, in which case this checks descriptor semantics as well.

        Return the inferred rvalue_type, inferred lvalue_type, and whether to use the binder
        for this assignment.
        Tr  F)r1  N)r   r  r   r  r   r.  rE  r  r  r  r   )	r1  r  r  r  r  r  r  r  get_lvalue_types	            r  r  z#TypeChecker.check_member_assignment  sX     (66}l33 	68Q8Q8S8S 	6Xb8Y
 Y
 	6 "99/6SZ[[NK55X##d#;; 	 	"/NN% O  O	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 55ovwWWQ%/_%M%MbkkSbOZ-Y-YYYs   B11B58B5rx   c                   |                      ||           t          | j                            |j                            }| j                            d||          }||_        | j                            d|||j        |gt          j
        t          j
        g|          \  }}t          |          }t          |t                    r"|j        s| j                                         dS dS dS )zxType check indexed assignment base[index] = rvalue.

        The lvalue argument is the base[index] expression.
        __setitem__N).try_infer_partial_type_from_indexed_assignmentr   r  r  r  re  rg  check_method_callr  r   rM   r  r   	ambiguousrF  r  )r1  r  r  r  basetyperg  res_typer  s           r  r  z$TypeChecker.check_indexed_assignment=  s     	;;FFKKK"4#4#;#;FK#H#HII'FF8V
 
 )'99\6"]EM*
 
! #8,,h00 	&9K 	&K##%%%%%	& 	& 	& 	&r  r$  c                    ||_         | j        xj        dz  c_        ||= | j        j        r9t          |j                  }||_        | j                            |||           dS dS )z8Replace the partial type of var with a non-partial type.r  N)	rL  rF  r  rW  r  r   r  r  r  )r1  r  r  rP  r  s        r  replace_partial_typez TypeChecker.replace_partial_typeW  sx     q #<. 	; ""AAFK##Ax:::::	; 	;r  c                   d }t          |j        t                    r,t          |j        j        t                    r|j        j        }n9t          |j        t
                    r| j                            |j                  }t          |t                    r$t          |j        t                    r|j        j        }|d S | 
                    |          }|d S |j        }|dk    s|dk    s|dk    r| j                            |j                  }| j                            |          }t          || j                  r}t          || j                  rl| j        sg|dk    r&|j        j        t%          ||j        j                  r=|                     |||g          }	|                     ||	|           d S d S d S d S d S d S d S d S )Nr  r  r  )r  r  r   r  r   r~   r  r  rL  r   r  r  r  r  r  rW  rk  
value_typer   r  r
  )
r1  r  r  r  rQ  rP  typenamekey_typer  r  s
             r  r  z:TypeChecker.try_infer_partial_type_from_indexed_assignmentf  s    fk7++ 	F
6;;KS0Q0Q 	F+"CCZ00 	F#88EECc3 	P#(K00 PHM	$F $ 7 7 < < (F$-//#<<<#<<<  $077EEH!%!2!9!9&!A!AJ.xFFP2:t|LLP !% :P
 %(AAA # 3 ?$1*ch>Q$R$R !@ $(#:#:8hPZE[#\#\11#xOOOOO9	P 	PP P P P =<
P P P P !@ ?r  tuple[str, ErrorCode] | Nonec                    t          |          }t          |t                    r<|j        j        dk    r	dt
          fS |j                            d          	dt          fS dS )zSome types require usage in all cases. The classic example is
        an unused coroutine.

        In the case that it does require usage, returns a note to attach
        to the error message.
        ztyping.CoroutinezAre you missing an await?	__await__N)r   r  r   rL  r  r/   r  r.   )r1  r0  proper_types      r  type_requires_usagezTypeChecker.type_requires_usage  sl     &c**k8,, 	G (,>>>35EFF##K00<35EFFtr  rl   c                F   | j                             |j        dd          }|                     |          }|rg|\  }}|                     t
          j                            t          || j	                            ||           | 
                    |||           d S d S )NTr@  r  )r  r  r  r  r  r   TYPE_MUST_BE_USEDr  rE   rW  r  )r1  r  	expr_typeerror_note_and_code
error_noter  s         r  visit_expression_stmtz!TypeChecker.visit_expression_stmt  s    %,,QVt^b,cc	"66yAA 	02JII 299+iQUQ]:^:^__    
 IIj!$I/////	0 	0r  r   c                b    |                      |           | j                                         dS )zType check a return statement.N)check_return_stmtrF  r  r1  r  s     r  visit_return_stmtzTypeChecker.visit_return_stmt  s0    q!!!!!!!!r  r  type_ctxallow_none_func_callc           
        | j                             dd          5 }| j        5 }| j                            dd          5  t          | j                            |||                    }ddd           n# 1 swxY w Y   ddd           n# 1 swxY w Y   ddd           n# 1 swxY w Y   |                                s| 	                    |           |S |
                                }|}| j                             dd          5 }| j        5 }t          | j                            |d|                    }	ddd           n# 1 swxY w Y   ddd           n# 1 swxY w Y   |                                s't          |	|          r| 	                    |           |	S | j                             |           | 	                    |           |S )z=Infer type of expression with fallback to empty type context.T)r  r  F)r  discardrA  N)rE  r  rp  rF  r  r   r  r  r  r  r  r   r  )
r1  r  r  r  rE  r  r0  original_messagesoriginal_type_mapalt_typs
             r  infer_context_dependentz#TypeChecker.infer_context_dependent  s$    X##dQU#VV 
	Z]#	'/))5$)GG	 	
 &%,,h:N -   	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	
	 
	 
	 
	 
	 
	 
	 
	 
	 
	 
	 
	 
	 
	 
	 !!## 	X&&&J  //11$X##dQU#VV 	Z]$ )%,,T4K_,``               	 	 	 	 	 	 	 	 	 	 	 	 	 	 	
 !!## 	
7H(E(E 	X&&&N 	-...*+++
s   B'B+A9-B9A==B A=BB'B	B'B	B''B+.B+E%+EE%E	E%E	E%%E),E)c           	        | j                                         }||j        r'|                     | j        d         |j                  }n5|j        r!|                     | j        d                   }n| j        d         }t          |          }t          |t                    }t          |t                    r+|s)|j        s"|                     t          j        |           d S |j        rwt          |t                     }t          |t"                    }|p|p|}t          |j        t$          t&          t(          t*          t,          t.          f          s9t          |j        t0                    r<t          |j        j        t$                    r|                     |j        ||          }n/t          | j                            |j        ||                    }t          |t8                    r,|j        j        t>          v rt#          t@          j!                  }|j"        r"|                     t          j#        |           d S t          |t"                    r| j$        j%        r| j&        stO          t#          t@          j!                  |          sd|j(        tR          v rtU          |j                  sBt          |t8                    r|j        j        dk    s|s| j+        ,                    ||           d S |r;|st          |t                     rd S |                     t          j-        |           d S | .                    d|d||j        |t          j/                   d S |j        r|j        st          |t"                    rd S t          |t           t"          f          rd S | 0                                r$|                     t          j1        |           d S d S d S )Nr  r"  r  gotr  )r  r  r  r  r  outer_contextrE  )2rK  current_functionr  r  rN  r`  r~  r   r  rz   r   r  r  r   NO_RETURN_EXPECTEDr  r   r   rb   r{   r   ri   r   r   r^   r&  r  r  r   rL  r  r   r   r	  r  RETURN_IN_ASYNC_GENERATORrW  warn_return_anyrk  r   r  r   r  rE  incorrectly_returning_anyNO_RETURN_VALUE_EXPECTEDr  r  r  RETURN_VALUE_EXPECTED)	r1  r  r  rm  	is_lambdadeclared_none_returndeclared_any_returnr  r0  s	            r  r  zTypeChecker.check_return_stmt  s   z**,,  4"<<%b)4+<  " 4"<<T=Nr=RSS"/3)+66K"444I+77   )> II.A1EEEFv YI'1+x'H'H$&0g&F&F# (1'_4H'_L_$ qv(IxQXZ`'abb!!&)44 #16;99 66qv{L`aaCC))00FKCW 1   C c8,, :1BF`1`1`!)"899C* II.H!LLLFc7++  4K $ :K !2'):P2Q2QS^ _ _K
 !I)=== :16 B B > '{H==	 >
 !, 0 9=N N N ) !O ::;JJJF (  ! JsH$=$= II.GKKKKK&&&+ #(2"- !&',K '      % - #;88
 FkHg+>?? F++-- III.DaHHHHHW TI Ir  rs   c                T   | j                             ddd          5  t          |j        |j                  D ] \  }}t          | j                            |                    }t          |t                    r| j
                            ||           |                     |          \  }}t          |          |_        | j                             dd          5  |                     |d           |                     |           ddd           n# 1 swxY w Y   |                     |d           | j                             dd          5  |j        r|                     |j                   ddd           n# 1 swxY w Y   ddd           dS # 1 swxY w Y   dS )	zType check an if statement.FTr   r  r  fall_throughr  r  r6  from_assignmentN)rF  r  r  r  r  r   r  r  r  r   rE  r  r  is_unreachable_mapunreachable_elser  r  )r1  r  rj  ra  r  if_mapr  s          r  visit_if_stmtzTypeChecker.visit_if_stmtB  s_    [&&\]&^^ 	- 	-AFAF++ D D1#D$5$<$<Q$?$?@@a-- 5H..q!444#'#=#=a#@#@ %7%A%A" [..1.MM # #&&vu&EEEKKNNN# # # # # # # # # # # # # # #
 ""8U"CCCC**E*JJ - -; -KK,,,- - - - - - - - - - - - - - -'	- 	- 	- 	- 	- 	- 	- 	- 	- 	- 	- 	- 	- 	- 	- 	- 	- 	-sZ   C F-DFDFD8F"F9FF			FF		FF!$F!r   c                    t          |j        g|j        gd          }|                    |           |                     ||j        |j                   dS )zType check a while statement.N)r  )rs   r  r  rR  r  r  )r1  r  if_stmts      r  visit_while_stmtzTypeChecker.visit_while_stmt]  sT    !&AF8T22!+afEEEEEr  r   c                   |                      |j        |j        |j                   t	          |j        t
                    r!| j                            |j        d          }n| j                            |j                  }t          ||j                  \  }}|rV| j        
                    |||j        |          \  }}t          ||          s | j                            |j        |           nSt          |j        |j        |j                  }|                    |           |                     |j        |dd           |                     |           dS )z9Type check an operator assignment statement, e.g. x += 1.TF)r  r  r  r  N)r  r  r  r  r  r~   r  visit_member_exprr   infer_operator_assignment_methodcheck_opr   rE   incompatible_operator_assignmentr   rR  r  r  )r1  r  r  inplacer  r  r  r  s           r  visit_operator_assignment_stmtz*TypeChecker.visit_operator_assignment_stmtc  sJ   ;;AHahPQPTUUUah
++ 	= +==ahMMKK+2218<<K:;MM 	!.77QXWXYYNKk;77 C99!$BBB !$!(33DMM!!!xQV "    	r  r[   c                   | j                             |j                   t          |j        t                    r=t          |j        j                  dk    r |                     t          j	        |           | 
                    |j                  \  }}|j        #| j                             ||j        d d           |                     |           d S )Nr   F)suppress_unreachable_errors)r  r  r  r  r   r  r  r  r   MALFORMED_ASSERTr  rE  analyze_cond_branchr  )r1  r  true_mapr  s       r  visit_assert_stmtzTypeChecker.visit_assert_stmt{  s      (((afi(( 	<S->->-B-BII&7;;; "77??(511!%5 2    	8$$$$$r  r   c                    |j         r|                     |j         |           |j        r|                     |j        |d           | j                                         dS )zType check a raise statement.T)optionalN)r  type_check_raise	from_exprrF  r  r  s     r  visit_raise_stmtzTypeChecker.visit_raise_stmt  sf    6 	-!!!&!,,,; 	A!!!+q4!@@@!!!!!r  rj  rO  c                V   t          | j                            |                    }t          |t                    r| j                            ||           d S |                     d          }|t          |          g}|r!|	                    t                                 |                     |t          j        |          |t          j                   t          |t                     r| j                            |g g |           t          |t$                    r|j        j        t*          v s?t          |t,                    r_t          |j        t0                    rG|j        j        dk    r9|                     t          j                            d          |           d S d S d S d S )Nbuiltins.BaseExceptionbuiltins.NotImplementedz%; did you mean "NotImplementedError"?)r   r  r  r  r   rE  r  r  r   r6  r   r  r   
make_unionr   INVALID_EXCEPTIONr   r*  r   rL  r  r   rb   rF  r   r  r  )r1  rj  r  rO  r0  r9  expected_type_itemss          r  rP  zTypeChecker.type_check_raise  s   d/66q99::c;'' 	H&&sA...F??#;<<'(););< 	3  &&xzz222%&9::A?O?a	
 	
 	
 c<(( 	9((b"a888sH%% 
	#(*;?Y*Y*Yq(## +Z18W-- +Z !%>>>II 2FF;  	     +Z*Y*Y*Y ?>r  r   c                   d}| j                             dd          5  |                     |t          |j                             |j        rZt                      }t          | j        j        |          5  | 	                    |j                   ddd           n# 1 swxY w Y   ddd           n# 1 swxY w Y   |j        r|J | j         
                                sLt          | j        j        |          5  | 	                    |j                   ddd           n# 1 swxY w Y   | j                            |           dS dS )zType check a try statement.NFr   r7  )	try_frame)rF  r  visit_try_without_finallyr&  finally_bodyr4   r5   rE  rD  r  r  r  )r1  r  r  s      r  visit_try_stmtzTypeChecker.visit_try_stmt  s    
 [&&A&FF 	0 	0 **1Q^8L8L*MMM~ 0688*48?KHH 0 0KK///0 0 0 0 0 0 0 0 0 0 0 0 0 0 0	0 	0 	0 	0 	0 	0 	0 	0 	0 	0 	0 	0 	0 	0 	0 > 	= ***;--// 0*48?KHH 0 0KK///0 0 0 0 0 0 0 0 0 0 0 0 0 0 0H//<<<<<!	= 	=sH   AB68BB6B#	#B6&B#	'B66B:=B:?D&&D*-D*rZ  c                   | j                             dd|          5  | j                             ddd          5  | j                             ddd          5  |                     |j                   ddd           n# 1 swxY w Y   t	          t          |j                            D ][}| j                             dd          5  |j        |         }|r[|                     ||j	                  }|j
        |         }|r1d|_        |                     ||                     ||                     |                     |j        |                    |j
        |         }|r|j        }t          |j        t"                    rDt%          |	          }||j        _        | j        j        r| j                             |||           | j        j        s| j                             |           ddd           n# 1 swxY w Y   ]	 ddd           n# 1 swxY w Y   |j        r|                     |j                   ddd           dS # 1 swxY w Y   dS )
a2  Type check a try statement, ignoring the finally block.

        On entry, the top frame should receive all flow that exits the
        try block abnormally (i.e., such that the else block does not
        execute), and its parent should receive all flow that exits
        the try block normally.
        Fr  )r  r6  rZ  Tr5  N   r7  source)rF  r  r  r  r  r  handlersr  check_except_handler_testis_starvarsr  r  r)  r  r  r  r   r   rL  rW  r  r  cleanser  )	r1  r  rZ  r   r0  r  r  ra  r  s	            r  r[  z%TypeChecker.visit_try_without_finally  sP    [&&AQZ&[[ !	) !	)**ET`a*bb 9 9[..AY].^^ ( (KK'''( ( ( ( ( ( ( ( ( ( ( ( ( ( (s1:// 9 9A22Dq2QQ 9 9gaj S $ > >sAI N NA"#&)C" S 7; 3 $ 5 5c4>>!S;Q;Q R R RAJqM222fQi 9 &)XF)#(C88 U+6f+E+E+E08#'<#F !U$(K$;$;C8$T$T$T#'<#F 9 $ 3 3C 8 8 819 9 9 9 9 9 9 9 9 9 9 9 9 9 99	9 9 9 9 9 9 9 9 9 9 9 9 9 9 9< { )AK(((C!	) !	) !	) !	) !	) !	) !	) !	) !	) !	) !	) !	) !	) !	) !	) !	) !	) !	)s~   IHB5HBHB	AHD%G=	1H=HHHHIH	IH	$IIIr  rd  c                   | j                             |          }g }|                     ||          }t          |          D ]s}t	          |t
                    r|                    |           .t	          |t                    rm|j        d         }|	                                s7| 
                    t          j        |           |                     |          c S t          |j                  }nTt	          |t                     r|j        }n7| 
                    t          j        |           |                     |          c S t%          ||                     d                    s7| 
                    t          j        |           |                     |          c S |                    |           u|rg }	|D ]}t)          ||                     d                    rM| 
                    t          j        |           |	                    t          t,          j                             r|	                    |           |                     |	          S t3          |          S )z,Type check an exception handler test clause.r   rT  builtins.BaseExceptionGroup)r  r  get_types_from_except_handlerr   r  r   r6  r   r  r  r  r   INVALID_EXCEPTION_TYPEdefault_exception_typer*   r  r   r$  r   r  r   INVALID_EXCEPTION_GROUPr   rv  wrap_exception_groupr   )
r1  r  rd  r0  	all_types
test_typesttyper$  r9  new_all_typess
             r  rc  z%TypeChecker.check_except_handler_test	  sJ   &&q)) "	77Q??
%j11 	' 	'E%))   '''%.. 
<{1~'')) @II.EqIII66w?????)$-88E8,, < :		*A1EEE227;;;;;h8P(Q(QRR <		*A1EEE227;;;;;X&&&& 	<(*M  . .$S$//:W*X*XYY .II.FJJJ!((1E)F)FGGGG!((----,,];;;$Y///r  c                j    t          t          j                  }|r|                     d|g          S |S )z:Exception type to return in case of a previous type error.builtins.ExceptionGroup)r   r   rv  r  )r1  rd  r  s      r  rk  z"TypeChecker.default_exception_type2  s9    9/00 	R**+DxjQQQr  r  Sequence[Type]c                    t          |          }t          ||                     d                    rd}nd}|                     ||g          S )zDTransform except* variable type into an appropriate exception group.zbuiltins.Exceptionrs  rh  )r   r   r  r  )r1  r  r  r  s       r  rm  z TypeChecker.wrap_exception_group9  sR    #E**c4??+?@@AA 	1,DD0D&&tcU333r  c                    t          |          }t          |t                    r@t          |j                  }t          |t
                    r|                                S |gS t          |d          rGt          |j        d         f          }t          |t
                    r|                                S |gS t          |t
                    r! fd|                                D             S |gS )z?Helper for check_except_handler_test to retrieve handler types.r>  r   c                F    g | ]}                     |          D ]}|S r  )ri  )r  r$  	union_typr  r1  s      r  rt  z=TypeChecker.get_types_from_except_handler.<locals>.<listcomp>Q  sP       !%!C!CD!!L!L      r  )	r   r  r   r   r  r   rb  r   rw  )r1  r0  r  merged_types   ` ` r  ri  z)TypeChecker.get_types_from_except_handlerB  s	   c""c9%% 	/	::K+y11 4"11333= s$455 	/!??K+y11 4"11333= Y'' 	    ..00    5Lr  rn   c                     j         r                     j                  \  }n                     j                  \  }_        |_                             j        j         fd           dS )zType check a for statement.c                 L                         j         j        d u           S r0  )analyze_index_variablesr  
index_type)r%  r  r1  s   r  rE  z,TypeChecker.visit_for_stmt.<locals>.<lambda>e  s)    $">">ALD$8!# # r  )r  N)	is_async analyze_async_iterable_item_typer  analyze_iterable_item_typeinferred_item_typeinferred_iterator_typer  r  r  )r1  r  iterator_typer%  s   `` @r  visit_for_stmtzTypeChecker.visit_for_stmtY  s    : 	O'+'L'LQV'T'T$M99'+'F'Fqv'N'N$M9(#0 FK      	 	
 	
 	
 	
 	
r  tuple[Type, Type]c                    | j         }|                    |          }|                    d|g g |          d         }|                    d|g g |          d         }|                    ||t          j                  }||fS )zNAnalyse async iterable expression and return iterator and iterator item types.	__aiter__r   	__anext__)r  r  check_method_call_by_namecheck_awaitable_exprr   INCOMPATIBLE_TYPES_IN_ASYNC_FOR)r1  r  echkiterableiterator	awaitabler%  s          r  r  z,TypeChecker.analyze_async_iterable_item_typej  s     ;;t$$11+xRQUVVWXY22;"bRVWWXYZ	--t-M
 
	 ""r  c                    |                      | j                            |          |          \  }}|                     |          }|r||fS ||fS )zHAnalyse iterable expression and return iterator and iterator item types.r  )-analyze_iterable_item_type_without_expressionr  r  analyze_range_native_int_type)r1  r  r  r  int_types        r  r  z&TypeChecker.analyze_iterable_item_typeu  sk    !OO$$T**D P 
 
( 55d;; 	&X%%!!r  c                >   | j         }t          |          }|                    d|g g |          d         }t          |t                    r1|j        j        j        dk    r|t          |          j	        d         fS |                    d|g g |          d         }||fS )zBAnalyse iterable type and return iterator and iterator item types.__iter__r   r>  __next__)
r  r   r  r  r   partial_fallbackrL  r  r   rw  )r1  rL  r  r  r  r  s         r  r  z9TypeChecker.analyze_iterable_item_type_without_expression  s      "4((11*hBPWXXYZ[ x++	&).7;KKK^H55:1=== 55j(BPRT[\\]^_HX%%r  c                   t          |t                    rt          |j        t                    r|j        j        dk    rdt          |j                  cxk    rdk    rn nt          d |j        D                       rkd}d}|j        D ]Y}t          | 
                    |                    }t          |t                    r |j        j        t          v r||}Q||k    rd}Z|r|r|S dS )zTry to infer native int item type from arguments to range(...).

        For example, return i64 if the expression is "range(0, i64(n))".

        Return None if unsuccessful.
        zbuiltins.ranger  r  c              3  ,   K   | ]}|t           k    V  d S r0  )rM   )r  r  s     r  r  z<TypeChecker.analyze_range_native_int_type.<locals>.<genexpr>  s&      ??DGO??????r  NTF)r  rb   rF  r   r  r  rw  ra  r  r   r  r   rL  r   )r1  r  
native_intr  r  argts         r  r  z)TypeChecker.analyze_range_native_int_type  s    tX&&	"4;00	" $(888S^^((((q(((((??????? ) '+JBy # #&t'7'7'<'<==dH-- #$)2DH^2^2^!)%)

++" "j "!!tr  c                T   t          |          }t          |t                    rLg }|j        D ].}|                     |          }|r|                    |           /t          j        |          S t          |t                    rk|j        	                    d          rQ| 
                    d          j        }t          ||          }t          |j                  dk    sJ |j        d         S t          |t                    r"|                     t          |                    S dS )zzCheck if a type is a nominal container of a union of such.

        Return the corresponding container item type.
        ztyping.Containerr  r   N)r   r  r   r  analyze_container_item_typer6  rV  r   rL  r  r  r<   r  rw  r   r   )r1  r0  r  r$  c_typer  super_instances          r  r  z'TypeChecker.analyze_container_item_type  s$   
 c""c9%% 	/ "E	 ) )99$?? )LL((('...c8$$ 	*):):;M)N)N 	*(:;;@I6sIFFN~*++q0000!&q))c9%% 	I33N34G4GHHHtr  r  r%  c                \    |                      ||                     ||          |           dS )z>Type check or infer for loop or list comprehension index vars.N)r  r)  )r1  r  r%  r  r  s        r  r|  z#TypeChecker.analyze_index_variables  s1     	eT^^Iw%G%GIZ[[[[[r  rh   c                d   t          |j        t                    r|j        }t          |j        d          }|j        |_        |j        |_        t          ||j        gt          j
        gd g          }|j        |_        |j        |_        | j                            |d           d S |j                            | j                   t          |j                  D ]S}t          |t                    r<| j                            |t#          |j                  t'          |                     Td S )N__delitem__Tr"  r`  )r  r  rx   r~   r  r  r  rb   r  r   rM   r  r  flattenr   rF  r  r   r  r   )r1  r  rj  mr  elts         r  visit_del_stmtzTypeChecker.visit_del_stmt  s   afi(( 	A16=11AVAFxAHQWI??AVAFxAH$$Q$$?????FMM$+,,,qv  c8,, K++[999?3;O;O   r  rg   c                    |j         D ]T}t          |t                    r=|j        dk    r2t	          t
          j                  |j        _        d|j        _	         d S U| 
                    |           d S )Nztyping.no_type_checkT)r  r  r   r  r   r   r	  r  rL  r  r  )r1  rj  r  s      r  r  zTypeChecker.visit_decorator  sr     	 	A!W%% :!777!()?!@!@AEJ%)AENFF""1%%%%%r  r  c           	        | j         s|j        j        r| j                            |j                  5  |                                 5  |                     |j        |j        j        |           d d d            n# 1 swxY w Y   d d d            n# 1 swxY w Y   |                     |j                  }d}t          |r|j
        dd          n|j
                  D ]W}t          |d          rt          |t                    r#|s |                     t          j        |           Ld}| j                            |          }|                     ||          }d }	t'          |t(                    r	|j        pd }	d }
|	it'          |t,                    rT|                     |j                  r:|                     |j                  }
| j                            |
|j                  }	|                     |j        ||           | j                            ||gt:          j        g||	|
          \  }}Y|r|                     ||j                   |                      ||j                   tC          ||j                  }t'          |tD                    r||_#        ||j$        _%        d|j$        _&        |j        j'        rgt'          |tD                    r=tQ          d |j)        D                       dk    r| j*                            d	|           | +                    |           |s|rd S |j        j,        r|j-        s{| .                    |          }|j        j/        r?|s=|;|j        j,        j0        s*| j*        1                    |j        j        |j                   | 2                    |j        |           |j        j,        rc|j        j        d
v rU|j%        rNt'          tg          |j%                  th          tj          f          s |                     t          j6        |           |j        j7        r2t'          |th                    r| 8                    |j        |           d S d S d S )Nr  Fr  zabc.abstractmethodTr  )r  rh  c                :    g | ]}|                                 |S r  )is_required)r  ks     r  rt  z5TypeChecker.visit_decorator_inner.<locals>.<listcomp>  s%    DDDaAMMOODDDDr  zToo many arguments for propertyr  )9ru  r
  r  rJ  r  r  r  r  r   r'  r  r   r   r  r   r  r  r  r)  r  r   r  r~   r  r  r  method_fullnamecheck_for_untyped_decoratorr*  r   rM   check_untyped_after_decoratorr  r   r   r  r  rL  r  r  r  r  rE  $check_incompatible_property_overrider  r  r  r  r  r  r  r   r   r   BAD_CONSTRUCTOR_TYPEr  r  )r1  rj  r   r  r.  non_trivial_decoratorr  r0  r1  r  rh  t2r'  s                r  r  z!TypeChecker.visit_decorator_inner  s    & 	X!&*B 	X++AF33 X XT5T5T5V5V X X$$QV!&+;$WWWX X X X X X X X X X X X X X X X X X X X X X X X X X X X X X
 &&qv.. %oO!,qrr**1<PP 	 	A!!%9::  !!^44 " OII.JANNN$(!#**1--C>>#q>11DH!W%% .:- (,KJq*$=$=$--PQPVBWBW"..qv66,<<[!&QQ,,QVS!<<<'22dVem_axU` 3  GC ! 	<..sAF;;;**3777QV,,c<(( 	CN
6 	9#|,, HDD3=DDDEEIIHMM"CQGGG55a888 	/ 	F6; 	Vq} 	V(,(B(B1(E(E%+D1D .9 3 :
 ..qv{AFCCC2216;TUUU6; 	D16;*AAAv Dj)@)@<QXBYZZ D		*?CCC6 	6:c<#@#@ 	6((55555	6 	6 	6 	6s5   B(A<0B<B 	 BB 	BBBdec_typedec_exprc                    | j         j        rLt          |j                  r:t	          |          r-| j        s(| j                            |j        |           d S d S d S d S d S r0  )	rW  disallow_untyped_decoratorsis_typed_callablerL  is_untyped_decoratorrk  rE   typed_function_untyped_decoratorr  )r1  r
  r  r  s       r  r  z'TypeChecker.check_for_untyped_decorator.  s     L4	K!$),,	K %X..	K .		K H55diJJJJJ	K 	K 	K 	K 	K 	K 	K 	Kr  c                   |j         j        s|j        j        r|j        j        }|j        j        j        dd          D ]}|j                            |          }|st          |j	        t                    r[|j	        j        rOt          t          |j	        j        d                   j         j        r |                     t           j        |           d S d S d S Nr  r   )r  r  r
  r  r  r  rh  r  r  r  r   r  r   rg   r  r  r   'READ_ONLY_PROPERTY_OVERRIDES_READ_WRITE)r1  rj  r  r  r  s        r  r  z0TypeChecker.check_incompatible_property_override9  s    u) 	[afk 	[6;D+ 	[ 	[ JNN400	  y~/@AA[!2[ Y	(<Q(?@@DY[
 II.VXYZZZ	[ 	[ 	[ 	[	[ 	[r  r   c                v   d}t          |j        |j                  D ]\  }}|j        r|                     |||j        d u           }n|                     |||j        d u           }t          |          }t          |dd          rjt          |dd          s1t          |t                    r|j        j        dk    rt          j        rd}|rQ| j                            dd          5  |                     |j                   d d d            d S # 1 swxY w Y   d S |                     |j                   d S )NFbuiltins.boolT)r  rZ  )r  r  r(  r~  check_async_with_itemr  check_with_itemr   r   r  r   rL  r  r   r  rF  r  r  r  )r1  r  exceptions_maybe_suppressedr  r(  exit_ret_types         r  visit_with_stmtzTypeChecker.visit_with_stmtG  s   &+#11 	3 	3LD&z ^ $ : :4IZ^bIb c c $ 4 4T61CTX\C\ ] ] ,M::M}ouEE }otDD 3=(333!&/?BB) C
 /3+& 	  **DD*II $ $AF###$ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ KKs   *DDDc                    | j         j        r| j        s| j        rd S t          j                            |          r| j                            ||           d S d S r0  )	rW  disallow_any_decoratedrl  rk  rz  r{  has_any_typerE  untyped_decorated_function)r1  r0  r
  s      r  r  z)TypeChecker.check_untyped_after_decoratorl  sg    |2 	dl 	dF` 	F>&&s++ 	;H//T:::::	; 	;r  r(  c                   | j         }|                    |          }|                    d|g g |          d         }|                    ||t          j                  }|r+|                     ||                     ||          |           |                     t          t          j
                  |          }|                    d||gdz  t          j        gdz  |          \  }}	|                    ||t          j                  S )N
__aenter__r   	__aexit__r  )r  r  r  r  r   'INCOMPATIBLE_TYPES_IN_ASYNC_WITH_AENTERr  r)  r   r   r	  r   rM   &INCOMPATIBLE_TYPES_IN_ASYNC_WITH_AEXIT
r1  r  r(  r  r  r,  objr  r  r  s
             r  r  z!TypeChecker.check_async_with_items  s     kk$,,\3BMMaP'''O
 
  	X!!&$..d*C*CEVWWWnnWY%;<<dCC//seai%-1)<d
 
Q (('N
 
 	
r  c                   | j         }|                    |          }|                    d|g g |          d         }|r+|                     ||                     ||          |           |                     t          t          j                  |          }|                    d||gdz  t          j	        gdz  |          \  }}	|S )Nr8  r   rA  r  )
r  r  r  r  r)  r   r   r	  r   rM   r  s
             r  r  zTypeChecker.check_with_item  s      kk$,,[#r2tLLQO 	X!!&$..d*C*CEVWWWnnWY%;<<dCC//cUQY!(;T
 
Q 
r  r`   c                8    | j                                          d S r0  )rF  handle_breakr  s     r  visit_break_stmtzTypeChecker.visit_break_stmt  s      """""r  rf   c                8    | j                                          d S r0  )rF  handle_continuer  s     r  visit_continue_stmtzTypeChecker.visit_continue_stmt  s    ##%%%r  r}   c           
     P	    t          |j                  }                     ||          } j                            dd          5  t           j                            |j                            t          t                    r j
                            |            fd|j        D             }d |D             }                     |          }|j        t                      i}t          |j        |j        |j                  D ]\  }}	}
 j                            |          } j                            ||          } j                            dd          5  t)          ||j        |j                  \  }}||v r||         ||<   ||v r||         ||<                        |          }                     |          }                     |j        |                                |d           |rE|                                D ]0\  }}                                          ||          d           1                     |j        d           |	b j                            dd	          5  t           j                            |	                    }t          |t                    r j
                            ||                                |	          \  }}t=          ||          }t          |t>                    rm|j         p|j!        }t          |tD                    rJ||fD ]E}tG          |          D ]3}t          |tD                    r|j$        |j$        k    s(||         ||<   4F                     |d                                |
           d d d            n# 1 swxY w Y   n                     |
           d d d            n# 1 swxY w Y                        |d           |}tK          |          s9 j&        s2|'                                D ]} j
        (                    ||            j                            dd          5  	 d d d            n# 1 swxY w Y   d d d            d S # 1 swxY w Y   d S )
NFr   r7  c                F    g | ]}j                             |          S r  )rI  r  )r  pr1  subject_types     r  rt  z0TypeChecker.visit_match_stmt.<locals>.<listcomp>  s,    ^^^aT188LII^^^r  c                    g | ]	}|j         
S r  )capturesr  s     r  rt  z0TypeChecker.visit_match_stmt.<locals>.<listcomp>  s    'J'J'Jq
'J'J'Jr  Tr  r8  r  ))collapse_walrussubject_make_named_statement_for_matchrF  r  r   r  r  r  r   rE  r  patterns#infer_variable_types_from_type_mapsr   r  guardsbodiesnarrow_type_from_binderrI  conditional_types_to_typemapsrL  	rest_typepropagate_up_typemap_inforemove_capture_conflictsr  r  r  _get_recursive_sub_patterns_mapr  or_conditional_mapsr   patternr  r   r  r  r:  rk  r  "match_statement_inexhaustive_match)r1  r  unwrapped_subjectnamed_subjectpattern_types	type_mapsinferred_typesunmatched_typesr  gra  current_subject_typepattern_typepattern_mapr  r  r0  rf  	guard_mapguard_else_mapcase_targetr  r  s   `                     @r  visit_match_stmtzTypeChecker.visit_match_stmt  s    ,AI66<<Q@QRR[&&A&FF P	 P	*4+<+C+CAI+N+NOOL,44 <**<;;; _^^^^STS]^^^M'J'JM'J'J'JI!EEiPPN )*	?3D3D'EOqz18QX>> 6+ 6+1a'+'8'P'P!<( ($  $3::1>RSS[..1.MM /' /',I%|'8,:P- -)K
 %339D]9S$56$006>}6M!23"&"@"@"M"MK#==hGGH11,2GXXX&&{E&JJJ" )4):):)<)<  ID# .. $ D DT3 O O05 /     &&|'<e&TTT}![66TU6VV + +!01B1I1I!1L1L!M!MB)"k:: B $ : :2q A A A8<8R8RST8U8U5I~':8^'T'TH  *!Y77 
U./i.A16#-k8#D#D !U5>4I %U %U48NN )U )UD0:40J0J-948M[EY4Y4Y08FNtnH],C,C)U !..y%.PPP KKNNN/+ + + + + + + + + + + + + + +2 A_/' /' /' /' /' /' /' /' /' /' /' /' /' /' /'` ""8U"CCC"*%o66 Ht?Y H*1133 H HCH??QGGGG **E*JJ                _P	 P	 P	 P	 P	 P	 P	 P	 P	 P	 P	 P	 P	 P	 P	 P	 P	 P	s   	D R)DO+D.N>	2O+>OO+OO+R+O//R2O/3BR5R7RR	R
R	RR"Rr  c                    | j                             |          r|S |j        |j        S |                     d          }t	          |          }t          |          }||_        ||_        |S )zEConstruct a fake NameExpr for inference if a match clause is complex.Nmatch)rF  can_put_directlysubject_dummynew_unique_dummy_namer   r   r  )r1  r  r  r  r  r  s         r  r  z+TypeChecker._make_named_statement_for_match  so    ;''00 	!N_(?"
 --g66DD		A$TNNM!"M+AO  r  r3  c                p   i }t          |          }t          |t                    rt          |t                    rzt	          |j                  t	          |j                  k    sJ t          |j        |j                  D ]3\  }}|||<   |                    |                     ||                     4|S r0  )	r   r  r   r   r  r  r  updater  )r1  r  r0  sub_patterns_maptyp_	item_expritem_typs          r  r  z+TypeChecker._get_recursive_sub_patterns_map  s     46s##dI&& 	c:dI+F+F 	ctz??c$*oo5555'*4:tz'B'B c c#	8.6 + ''(L(LYX`(a(abbbbr  r  list[TypeMap]dict[SymbolNode, Type]c           
     H   t          t                    }|D ]h}t          |          sW|                                D ]B\  }}t	          |t
                    r(|j        }|J ||                             ||f           Cii }|                                D ]
\  }}	d}
g }|	D ]\  }}|                    |           |                     |          \  }}}|sd}
t	          |j        t                    r-|j        j
        r!| j                            |j        d|           |                     |||t          j        dd          r|||<   |
sSt#          j        |          }|	d         \  }}t	          |t                    sJ |||<   |                     ||||           |S )NFTzpattern captures typezvariable has type)rE  r  r  r   )r   r  r:  r  r  r   r  r6  r  r   r  rE  r,  r  r  r   INCOMPATIBLE_TYPES_IN_CAPTUREr   rV  r  )r1  r  all_capturestmr  r0  r  r  r  r  already_existsr  previous_typer  r  first_occurrences                   r  r  z/TypeChecker.infer_variable_types_from_type_maps  s   
 GRRVFWFW 	? 	?B%b)) ?!# ? ?ID#!$11 ?#y#///$T*114+>>>13)//11 	\ 	\MC"N "E% < <	cS!!!&*&7&7&=&=#q! ,%)N!$)S11 Ndi6H N55diMMM))%,J&=(; *   < /<s+! \$/66&.qk# !!#s+++++&.s#((.>JZ[[[r  r  r!  r  c                    t          |          s`t          |                                          D ]@\  }}t          |t                    r$|j        }||vst          |||                   s||= ?d S d S r0  )r:  r  r  r  r   r  r   )r1  r  r  r  r0  r  s         r  r  z$TypeChecker.remove_capture_conflicts@  s     "(++ 	+!(.."2"233 + +	cdH-- +9D>11CX\I]9^9^1$TN	+ 	++ +r  or   c                    |j         r|                     |j         j                   | j                                        5  | j                            |j                   d d d            d S # 1 swxY w Y   d S r0  )
alias_noder  alias_tvarsrE  r  r  r  r  r1  r  s     r  visit_type_alias_stmtz!TypeChecker.visit_type_alias_stmtJ  s    < 	B''(@AAAX##%% 	. 	.$$QW---	. 	. 	. 	. 	. 	. 	. 	. 	. 	. 	. 	. 	. 	. 	. 	. 	. 	.s     A--A14A1curr_module_fullnameclass_gen_nameclass_short_namer  list[Instance]tuple[ClassDef, TypeInfo]c                   t          |t          g                     }|dz   |z   |_        t          t	                      ||          }||_        ||_        t          |           |                                |_	        ||fS )Nr  )
rc   r_   r  r   r   r  r  rK   calculate_metaclass_typer  )r1  r  r  r  r  cdefr  s          r  rk  zTypeChecker.make_fake_typeinfoQ  s{     (%))44,s2^Ct-ABB	
d";;==Tzr  	instancestuple[Instance, Instance]list[tuple[str, str]]c                     j         j        d         }t          |t                    sJ |\  }}t	          ||d          r|S t	          ||d          r|S dd}d fd} ||          }t          t          | j        ddd          }	t          |          s|	                    |	df           dS g }
|D ]3}|j
        j        r%|
	                    |	d|j
        j         df           4|
r|                    |
           dS 	  ||| j                  \  }} j                                        5 }                     |           ddd           n# 1 swxY w Y   |                                ro ||ddd                   } ||| j                  \  }} j                                        5 }                     |           ddd           n# 1 swxY w Y   d|_        n(# t&          $ r |	                    |	df           Y dS w xY w|                                r|	                    |	df           dS t)          t*          |dd          |j        |<   t/          |g |d         j        p|d         j                  S )a  Try creating an ad-hoc intersection of the given instances.

        Note that this function does *not* try and create a full-fledged
        intersection type. Instead, it returns an instance of a new ad-hoc
        subclass of the given instances.

        This is mainly useful when you need a way of representing some
        theoretical subclass of the instances the user may be trying to use
        the generated intersection can serve as a placeholder.

        This function will create a fresh subclass the first time you call it.
        So this means calling `self.intersect_intersection([inst_1, inst_2], ctx)`
        twice will return the same subclass of inst_1 and inst_2.

        Returns None if creating the subclass is impossible (e.g. due to
        MRO errors or incompatible signatures). If we do successfully create
        a subclass, its TypeInfo will automatically be added to the global scope.
        r   Fignore_promotions
instances_r  r-  r  c                    g }| D ]8}|j         j        r|j         j        }n|g}|D ]}|                    |           9|S r0  )rL  is_intersectionr  r6  )r#  base_classes_r4  r  expanded_insts        r  _get_base_classesz:TypeChecker.intersect_instances.<locals>._get_base_classes  sf    M" 8 89, &#yHH $vH%- 8 8M!((77778  r  r&  curr_module_r   rW  r   tuple[TypeInfo, str]c                   fd| D             }dt          |d           d}|j                            |          x}%t          |j        t
                    sJ |j        |fS                     |j        |||           \  }}||fS )Nc                4    g | ]}t          |d           S )r  )rW  	verbosity)rF   )r  r`  rW  s     r  rt  z^TypeChecker.intersect_instances.<locals>._make_fake_typeinfo_and_full_name.<locals>.<listcomp>  s)    ^^^1%aAFFF^^^r  z<subclass of and>)rI   rh  r  r  r  r   rk  r  )	r&  r)  rW  rh  r  symbolr  info_r1  s	     `     r  !_make_fake_typeinfo_and_full_namezJTypeChecker.intersect_instances.<locals>._make_fake_typeinfo_and_full_name  s     _^^^P]^^^E>:eU#;#;>>>D&,00666C!&+x88888{D((11,2GtUbccKD%$;r  T)rW  barer.  zhave distinct disjoint basesNr  z
" is finalr  z/would have inconsistent method resolution orderz)would have incompatible method signatures)module_hiddenr  extra_attrs)r#  r  r-  r  )r&  r  r)  r   rW  r   r-  r*  )rK  r  r  r   r   rI   rG   rW  r   r6  rL  r  r  rS  rE  r  r$  r  r%  rJ   r   rR   rh  r   r6  )r1  r  rD  curr_moduler}  r~  r(  r2  base_classespretty_names_list
new_errorsr  r  	full_namer  s   `              r  intersect_instanceszTypeChecker.intersect_instancesg  s   * j&q)+x00000  eT5EBBB 	KUDEBBB 	L
	! 
	! 
	! 
	!		 		 		 		 		 		 )(33 '"L$,TRRRTY
 
 -\:: 	MM,.LMNNN4
  	W 	WDy! W!!#46T$).6T6T6T"UVVV 	MM*%%%4	??k4< OD) '')) 6\//5556 6 6 6 6 6 6 6 6 6 6 6 6 6 6**,, :0044R4AA"C"C +t|# #i X++-- :33D999: : : : : : : : : : : : : : :#'D   	 	 	MM,._`aaa44	 &&(( 	MM,.YZ[[[4'6tT5X\']']'])$bil.F.b)TU,Jbccccs[   .G- 5EG- EG- EAG- 8GG- GG- !G"
G- -!HHr   callable_typec                   | j         j        d         }t          |t                    sJ t	          d|j        j         d|j                  }t          || j	                  }| 
                    |j        |||g          \  }}t          dg t          g           |          }|j        dz   |_        ||_        t!          t"          |          |j        d<   t!          t$          |          |j        |<   t'          |g |j                  S )zCreates a fake type that represents the intersection of an Instance and a CallableType.

        It operates by creating a bare-minimum dummy TypeInfo that
        subclasses type and adds a __call__ method matching callable_type.
        r   z<callable subtype of r/  r/  z	.__call__r5  )rK  r  r  r   gen_unique_namerL  r  rh  rF   rW  rk  r  rp   r_   	_fullnamer  r   rX   rR   r   r6  )	r1  r0  r=  
cur_modulegen_name
short_namer  r  func_defs	            r  intersect_instance_callablez'TypeChecker.intersect_instance_callable  s     Z%a(
*h/////"#K38=#K#K#KZM]^^ &c4<88
,,Z-@(JY\X]^^
d :r599mDD!][8!0x!@!@
:%4T4%@%@
"bco>>>>r  c                @   |                      d          }t          t          t          j                  t          t          j                  gt
          j        t
          j        gddgt          t          j                  |d          }|                     ||          S )zIProduce a new type that makes type Callable with a generic callable type.r  NT)r  r  is_ellipsis_args)	r  r   r   r   explicitr   rN   r  rE  )r1  r0  r  r=  s       r  make_fake_callablezTypeChecker.make_fake_callable  s     ??#677$Y'((')2D*E*EF^U_-4LY/00!
 
 
 //]CCCr  unsound_partitiontuple[list[Type], list[Type]]c                   t          |          }t          |t          t          f          r|gg fS t          |t                    r|g|gfS t          |t
                    rg |gfS t          |t                    rVg }g }|j        D ]F}|                     |d          \  }}|	                    |           |	                    |           G||fS t          |t                    r1|                     t          |          |          \  }}|r|gng }||fS |}t          |t                    rt          |          }t          |t                    r|j                            d          }	|	r/|	j        r(|                     |	j        d          \  }}|r|s|gg fS |s_|                     |          }
t          |t                    r/t          |j        |
          |
j        _        |
j        j        g|gfS |
g|gfS |rg |gfS |g|gfS )a(  Partitions a type into callable subtypes and uncallable subtypes.

        Thus, given:
        `callables, uncallables = partition_by_callable(type)`

        If we assert `callable(type)` then `type` has type Union[*callables], and
        If we assert `not callable(type)` then `type` has type Union[*uncallables]

        If unsound_partition is set, assume that anything that is not
        clearly callable is in fact not callable. Otherwise we generate a
        new subtype that *is* callable.

        Guaranteed to not return [], [].
        TrJ  r/  F)r   r  r   r   r   r   r   r  partition_by_callablerS  r   r   r   r   r   rL  
get_methodrI  r   )r1  r0  rJ  	callablesuncallablesr  subcallablessubuncallablesitypr  fakes              r  rN  z!TypeChecker.partition_by_callable  s   " c""cL(344 	5"9c7## 	 53%<c8$$ 	u9c9%% 	*I&(K9 3 3 04/I/It 0J 0 0,n   ..."">2222k))c;'' 	* &*%?%?',,.?& &"I{ $/63%%BKk)) c9%% 	'!#&&DdH%% 	%Y))*55F %&+ %)-)C)CK5 *D * *&	;  %[ %  5"9$$ %..t44c9-- 9+4SY+E+EDI( I01C588vu}$ 	 u9 53%<r  current_typetuple[TypeMap, TypeMap]c                B   |si i fS t          t          |          t                    ri i fS |                     |d          \  }}|r2|r0|t	          j        |          i}|t	          j        |          i}||fS |ri |t                      ifS |t                      ii fS )a8  Takes in an expression and the current type of the expression.

        Returns a 2-tuple: The first element is a map from the expression to
        the restricted type if it were callable. The second element is a
        map from the expression to the type it would hold if it weren't
        callable.
        FrM  )r  r   r   rN  r   rV  r   )r1  r  rV  rP  rQ  callable_mapuncallable_maps          r  conditional_callable_type_mapz)TypeChecker.conditional_callable_type_mapN  s      	r6Mol33W== 	r6M!%!;!;L\a!;!b!b	; 	1 	1 )"6y"A"ABL"I$8$E$EFN// 	1o//000o''(",,r  rG  c                   g }g }t          |          }t          |t                    r"t          |                                          }n|g}t          |          }|D ]}|rt          |t                    ru|D ]q}||j        v r|                    |           !||j	        v s|j
        s+|                    |           |                    |           \|                    |           r|                    |           |                    |           t          j        |          t          j        |          fS )z
        Narrows the type of `iterable_type` based on the type of `item_type`.
        For now, we only support narrowing unions of TypedDicts based on left operand being literal string(s).
        )r   r  r   r   rb  r   r   required_keysr6  r  r  rV  )	r1  r%  rG  if_types
else_typespossible_iterable_typesitem_str_literalspossible_iterable_typer  s	            r  conditional_types_for_iterablez*TypeChecker.conditional_types_for_iterablej  so     "!#
'66mY// 	6&6}7S7S7U7U&V&V##'4o#>yII&= 	: 	:"  :Z0F%V%V :, 	B 	BC4BBB (>????5;;;CYCb; (>???"))*@AAAA"))*@AAAA	B  6777!!"89999#H--y/CJ/O/OOOr  c                    t          |t                    oYt          |j                  oE|j                            d           o*|j                            d           o|j        j        dk    pVt          |t                    pAt          |t                    o,t           fdt          |j
                  D                       S )N__bool____len__r  c              3  B   K   | ]}                     |          V  d S r0  )_is_truthy_typer  r  r1  s     r  r  z.TypeChecker._is_truthy_type.<locals>.<genexpr>  s1      SSA,,Q//SSSSSSr  )r  r   r&  rL  r_  r  r   r   ra  r   r  r1  r  s   ` r  rh  zTypeChecker._is_truthy_type  s     1h'' 9LL922:>>>9 229===9 FO'88 !\** 1i(( TSSSS9I!'9R9RSSSSS	
r  c                    t           j        sdS t                                                   sdS d	 fd}d	 fd}t	          t
                    r=                     t          j        	                     |                                 dS t	          t                    r=                     t          j        	                     |                                 dS t	          t                    rj        j        dk    r                     dddg           \  }}                     t          j        	                     |            t#          t          |j                   j                                       dS                      t          j        	                     |                                 dS )
z
        Check if a type can have a truthy value.

        Used in checks like::

            if x: # <---

            not x  # <---
        Nr-  rd  c                    t          j                  } t          t                    rdj         d|  S t          t
                    rj        rdj         d|  S t          t                    rit          j        t                    rdj        j         d|  S t          j        t
                    rj        j        rdj        j         d|  S d|  S d|  S )NzMember "z" has type r  z
" returns zCall returns zExpression has type )	rE   rW  r  r~   r  r   r  rb   rF  )r0  r  r1  r  s    r  format_expr_typez;TypeChecker.check_for_truthy_type.<locals>.format_expr_type  s   a..C$
++ 4=$)=====D'** 	4t} 	4:4=::S:::D(++ 4dk:66 E@t{/@@3@@@W55 E$+:N EDt{3DDsDDD,s,,,3c333r  c                 |    t           t          t          f          rd j         dS t	          j                  S )Nr  )r  r   r~   r  rE   rW  )r  r1  r  s   r  get_expr_namez8TypeChecker.check_for_truthy_type.<locals>.get_expr_name  sA    $: 677 4'49'''' #1dl333r  r  typing
Collection)r-  rd  )r   r  r   rh  r  r   r  r   FUNCTION_ALWAYS_TRUEr  r   TYPE_ALWAYS_TRUE_UNIONTYPEr   rL  r  rk  ITERABLE_ALWAYS_TRUErE   rw  rW  TYPE_ALWAYS_TRUE)r1  r  r  rm  ro  r  r  s   ```    r  check_for_truthy_typez!TypeChecker.check_for_truthy_type  s    $ 	FA##A&& 	F	4 	4 	4 	4 	4 	4 	4 	4	4 	4 	4 	4 	4 	4 	4 	4 a&& 	ZII&;BB==??SSUYZZZZZ9%% 	ZII&AHHIYIYI[I[\\^bccccc8$$ 		Z<M)M)M--hlTVWWGAtII 5<<$$&&HT164J4JDL(Y(Y  	     II&7>>?O?O?Q?QRRTXYYYYYr  in_boolean_contextrx  c                   |                      ||          \  }}|                     |          }|                     |          }||fS )a  Find any isinstance checks (within a chain of ands).  Includes
        implicit and explicit checks for None and calls to callable.
        Also includes TypeGuard and TypeIs functions.

        Return value is a map of variables to their types if the condition
        is true and a map of variables to their types if the condition is false.

        If either of the values in the tuple is None, then that particular
        branch can never occur.

        If `in_boolean_context=True` is passed, it means that we handle
        a walrus expression. We treat rhs values
        in expressions like `(a := A())` specially:
        for example, some errors are suppressed.

        May return {}, {}.
        Can return None, None in situations involving NoReturn.
        rw  )find_isinstance_check_helperr  )r1  r  rx  r<  r  
new_if_mapnew_else_maps          r  r  z!TypeChecker.find_isinstance_check  s\    *  <<%7 = 
 
 33F;;
55h??<''r  c          
     2   t          |          ri |t                      ifS t          |          r|t                      ii fS t          |t                    rxt          |j                  dk    r_t          |j        d                   }t          |j	        d          rt          |j                  dk    ri i fS t          |          t          k    rSt          |g|                     |                     |          |                     |j        d                   |          R  S nt          |j	        d          rLt          |j                  dk    ri i fS t          |          t          k    r|                     ||          S n+t          |j	        d          rat          |j                  dk    ri i fS t          |          t          k    r+|                     |          }|                     ||          S nt          |j	        d          rt          |j                  dk    ri i fS t%          |j        d         |                     |j        d                             }t          |          t          k    rE|rCt          |          dk    r0|                     ||                     |          |d                   S nd\  }}|                     |j	                  }|kt+          |          }t          |t,                    r$t/          d	||d
          }	|	t+          |	          }t          |t0                    r|j        |j        }}t          |j	        t6                    r|j	        j        |j	        j        }}||B|j        d         t:          j        k    rt          |t0          t>          f          r|j         d         j!        d         }
|
|j!        v r5|j!        "                    |
          }t          |j        |                   }n=|dnd}| #                    tH          j%        &                    |          |           i i fS t          |          t          k    r`||tO          |          ii fS |J t          |g|                     |                     |          tQ          |d          g|d          R  S nt          |tR                    r| *                    |          S t          |tV                    ri }i }| ,                    |j-                  \  }}|.                    |           |.                    |           | ,                    |j/        d          \  }}|.                    |           |.                    |           ||fS t          |t`                    rg|j1        dk    r\| ,                    |j2                  \  }}| ,                    |j3                  \  }}ti          ||          tk          ||d
          fS t          |t`                    re|j1        dk    rZ| ,                    |j2                  \  }}| ,                    |j3                  \  }}tk          ||          ti          ||          fS t          |tl                    r,|j1        dk    r!| ,                    |j7                  \  }}||fS t          |          t          k    r| 8                    |          r| 9                    |                     |                    rtu          |                     |          d          s_| j;        j<        rS| =                    |                     |          dd          \  }}|t}          |          i}|t          |          i}||fS |                     |          }|r| @                    ||           t          |d          }|t}          |          i}|t          |          i}||fS )Nr   zbuiltins.isinstancer  r  zbuiltins.issubclasszbuiltins.callablezbuiltins.hasattrr  r/  Tr3  guardnarrowerFis_upper_boundconsider_runtime_isinstancerw  r.  coalesce_anyornotre  r/  r  )Bis_true_literalr   r  r  rb   r  rw  r  r   rF  r:   rW   r  #conditional_types_with_intersectionr  get_isinstance_typeinfer_issubclass_mapsr[  r   hasattr_type_mapslookup_type_or_noner   r   r   r   r  r  r   r  r   rM   r   r  r  r  r  r   TYPE_GUARD_POS_ARG_REQUIREDr  r   r    rd    comparison_type_narrowing_helperr\   r  r(  r   r  r   r  r}  r~  and_conditional_mapsr  r   r  r  can_be_narrowed_with_lenr   rW  r  narrow_with_lenr   r   rv  r   )r1  r  rx  r  vartyper<  r  r  called_typecallr  r  r  r<  r  if_assignment_mapelse_assignment_mapif_condition_mapelse_condition_mapleft_if_varsleft_else_varsright_if_varsright_else_varsr}  r~  yes_typeno_typeoriginal_vartypes                               r  rz  z(TypeChecker.find_isinstance_check_helper  sB    4   	1o//000D!! 	1/++,b00dH%% O	$#di..A*=*="49Q<00D!$+/DEE Rty>>Q&&r6M4==L008AA ,,T22D4L4LTYWX\4Z4Z\`     1 $DK1FGG Hty>>Q&&r6M4==L0055dDAAA 1#DK1DEE Cty>>Q&&r6M4==L00"..t44G==dGLLL 1 $DK1CDD =ty>>Q&&r6M/	!d>N>NtyYZ|>\>\]]4==L00T0c$ii1nn11$8H8H8N8NPTUVPWXXX&0#"66t{CC*"1+">">K "+x88 @*:{K]abbb+*9$*?*?K!+|<< Z.9.A;CY dk733 V*.+*=t{?UZG)W-@~a(EM99 &kL*3MNN .#.#4Q#7#A!#DD#t~55&*n&:&:4&@&@'6ty~'F'F2<2Hwwj $		$4$P$W$WX\$]$]_c!" !" !" (*2vt}}44 &1$(/**E*E#F#JJ#*#6#6#6#@ $$!%!I!I$($4$4T$:$:%.wu%M%M%M$N$(@E	 "J "" ""$ $ $  n-- :	$88>>>n-- 8	$ FH595O5OPTP[5\5\22MM+,,,OO/000373M3M
u 4N 4 400 MM*+++OO.///8##f%% &	$$'U*:*:+/+E+Edi+P+P(L.-1-G-G
-S-S*M?
 %\=AA $NORVWWW  f%% 	$$'T//+/+E+Edi+P+P(L.-1-G-G
-S-S*M?
 $L-@@$^_EE  i(( 	$TW-=-=44TY??KD%$;DMM\))d## *--d.>.>t.D.DEE * *$*:*:4*@*@*MM	 *
 , * !% 4 4T5E5Ed5K5KSRS T THgIh//0Fj112H8##  ++D11 	? &&'7>>>12BOTT	'**+*W--.xr  rd   c           	        d |j         D             }g }i }t          |          D ]1\  }}|                     |          si i fc S |                     |          }|                    |           t          |          t          k    rt          |          st          |          st          |          st          |          s|                     |          s}t          t          |          x}t                    r|                                sEt          |t                     rt          |j        t$                    st'          |          }	|	|	||<   3t)          |                                |ddh          }
g }|
D ]\  }}|dv r1|                     |||||                                          \  }}n3|dv r*t1          |          dk    sJ |\  }}||         }||         }i }i }||v rt          t3          |                    }||                     d||         ||         g||gd	d
gd	h          \  }}t5          |          skt7          |          r\t7          |          sMt          |t8                    r|j        j        dk    s(t?          ||          rtA          |          |||         <   ||v r+| !                    ||          \  }}||         }|||<   |||<   ni }i }|dv r||}}|                    ||f           tE          d |D                       rtG          |          S tG          | $                    |          d          S )z2Infer type narrowing from a comparison expression.c                ,    g | ]}t          |          S r  r  )r  r`  s     r  rt  z@TypeChecker.comparison_type_narrowing_helper.<locals>.<listcomp>  s     >>>1OA&&>>>r  N==is>   r  !=r  is not)narrowable_indices>   innot inr  r   r  )operandsoperand_typesexpr_indicesr  r  >   r  r  r  c              3  &   K   | ]}|i i fk    V  d S r0  r  )r  r  s     r  r  z?TypeChecker.comparison_type_narrowing_helper.<locals>.<genexpr>  s*      88qRH}888888r  Tuse_meet)%r  r  r  r  r6  r:   rW   r  r  r  r  is_literal_enumr  r   r   r  r   r$  r   r;   group_comparison_operandspairwise narrow_type_by_identity_equalityrD  r  builtin_item_typer:  r   r   rL  r  r=   r   rc  rC  reduce_conditional_mapsfind_tuple_len_narrowing)r1  r  r  r   narrowable_operand_index_to_hashr   r  r  p_exprhsimplified_operator_listpartial_type_mapsoperatorr  r<  r  
left_indexr  r%  rG  collection_item_typeif_type	else_types                          r  r  z,TypeChecker.comparison_type_narrowing_helper  s5    ?>>>>+-( ** 	< 	<GAt==&& 2v((..I  +++ --'-- .2488 . ).. . (--	 .
 ,,T22 . )C)CCv\RR . **,, . $FH55 . ;EV[R]:^:^ . !&&=:;4Q7$ $=MMOO=d|$
 $
  &> ?	9 ?	9"Hl 777#'#H#H! 'G'L'L'N'N $I $ $  ---<((A----*6'
K)*5	 -k :!AAA+:;L];[;[+\+\(+7+/+P+P &.z&:H[<Q%R+46J*K*+Q01s ,Q , ,( !36 : :
V 3I > >
V %88L$M$M
V
 !++? J J
V %9$=$FJ[$[$[ ;IG[ \ \ %\ <K9;U;UF8J#78"BBB)-)L)L!=* *&GY $K0D#*F4L%.HTN 555#+V$$fh%78888
 88&788888 	_*+<=== +4+H+H+N+NY]^^^^r  r  r  r  r  	list[int]r  AbstractSet[int]c                   |dv rt           }d}t                      }d}	ns|dv rht          }d}|D ]K}
t          |
                   }t	          |          s!t          |t                    r|j        j        rd} nLfd|D             }d}	nt          g }g }|D ]<}
|
|vr|
|v r|
         }t          |          }t          t          |          d          }|D ]}|
|k    r	||v r|         }|rt          |          }|	r$t          |t          |          z            dk    rMt          |d          }t          ||
         gt!          ||gd	          R  \  }} |t          |                    r+|                    |           |                    |           | j        j        st)          |          s|                    |           >|D ]s}
|
|vrt          |
                   }t          |t*                    s|
         }|D ]}||v r|         }|rt          |          }t          |d          } |t          |                    r<t          ||
         gt!          ||gd	          R  \  }}|                    |           g }g }|j        D ]_}t/          |          r|                    ||
         |i           t          t          |d                    }|D ]}||v rt|
|k    rt1          |          r@t1          |                   s+|                    ||
         t3          |          i           n|                    ||
         |i           {|         }|rt          |          }t          |d          }t          ||
         gt!          ||g|d
          R  \  }}|                    |            |t          |                    r|                    |           a|                    t5          |                     |                    t5          |                     u|D ]}
||
         }t          |t6                    r;t9          |j        d          r&t          |j                  dk    r|j        d         }n)t          |t>                    r|j         dk    r|j!        }n|D ]1}|
|k    r
||         }| "                    |                   }|0t          t          |j#                  tH                    rX| %                    |          }| &                    ||g|          \  }}|*|j'        s#tQ          ||j#                  stS                      }t          |||          \  }}t          |tT                    r&t          |j+        tX                    r|j+        j-        nd}|                    |           |r|                    |           3t]          |t          |          dk              }t5          |          }||fS )a  
        Calculate type maps for '==', '!=', 'is' or 'is not' expression, ignoring `type(x)` checks.

        The 'operands' and 'operand_types' lists should be the full list of operands used
        in the overall comparison expression. The 'chain_indices' list is the list of indices
        actually used within this identity comparison chain.

        So if we have the expression:

            a <= b is c is d <= e

        ...then 'operands' and 'operand_types' would be lists of length 5 and 'chain_indices'
        would be the list [1, 2, 3].

        The 'narrowable_indices' parameter is the set of all indices we are allowed
        to refine the types of: that is, all operands that will potentially be a part of
        the output TypeMaps.

        >   r  r  TF>   r  r  c                >    h | ]}t          |                   |S r  )has_custom_eq_checks)r  r   r  s     r  r  z?TypeChecker.narrow_type_by_identity_equality.<locals>.<setcomp>_  s.     c c cq<PQ^_`Qa<b<b c c c cr  Nr  r  )from_equality)r'  r  r>  r   	__class__r  r  )/r   ri  r   r   r   r  r   rL  r!  AssertionErrorambiguous_enum_equality_keysr   r   r  r    r  conditional_typesr6  rW  r  r:  r   r  r  r   r   reduce_or_conditional_type_mapsrb   r   rF  rw  r~   r  r  get_type_range_of_typer$  r   r  r  r  r   r   r   r  r   r   reduce_and_conditional_type_maps) r1  r  r  r  r  r  is_target_for_value_narrowingshould_coerce_literalscustom_eq_indicesenum_comparison_is_ambiguousr   r0  all_if_mapsall_else_mapsr  expr_enum_keysr[  target_typer(  r<  r  union_expr_type
or_if_mapsor_else_maps	type_exprexpr_in_type_exprr  current_type_ranger  r  r  r  s       `                            r  r  z,TypeChecker.narrow_type_by_identity_equality  s   f ''',F)%)" #+0((%%,F)%*"!  %mA&677',, C1J1J sxO_ -1*E c c c cL c c c+/((  %'')  3	3 3	3A***%%%%a(I9)DDN78I)8T8TVZ[[I! )3 )366))) +A.) A"3K"@"@K 1 N-I+-V-VVWWZ[[[";uEEE#@QK$"3IxW["\"\"\$ $ $  101M1MNN 3&&v...!((2222 |4 3<Nv<V<V 3#**6222S)3Z # D	P D	PA***-mA.>??Ooy99  *!,	% 7 7A--- "/"2K- E&7&D&D&{5IIIF44_[5Q5QRR 7+H$QK,.y6(RVWWW, , ,( &,,X666
 )+J*,L,2 "6 "6	'	22 @ %%x{I&>???-.MiY].^.^__	% 6 6A---66$.y99 HBU)!,C C H
 '--x{OI<V<V.WXXXX&--x{I.FGGG "/"2K- E&7&D&D&{5IIIF'D (*%xRV  ( ( ($FH %%f---44_[5Q5QRR 6$++H55576: >zJJKKK  !@!N!NOOOO  1	3 1	3A I9h//	&y'7II	 	''1,,$-N1$5!!Iz22 y~7T7T$-N!!! %3 %366{%)%@%@qAQ%R%R"%-o.@.EFFPP  ++,=>>%)%M%M124E& &" &*9 ')'3E3JKK '
 .//G#@%w	$ $  "$005?	85T5TDI&& 
 ""6*** 3!((222K%3R 2+HXYHYZZZ2=AAxr  	new_typesc                    i }|                                 D ]D\  }}|||<   |                     ||          }|                                 D ]\  }}||v r
|||<   E|S )a  Attempts refining parent expressions of any MemberExpr or IndexExprs in new_types.

        Specifically, this function accepts two mappings of expression to original types:
        the original mapping (existing_types), and a new mapping (new_types) intended to
        update the original.

        This function iterates through new_types and attempts to use the information to try
        refining any parent types that happen to be unions.

        For example, suppose there are two types "A = Tuple[int, int]" and "B = Tuple[str, str]".
        Next, suppose that 'new_types' specifies the expression 'foo[0]' has a refined type
        of 'int' and that 'foo' was previously deduced to be of type Union[A, B].

        Then, this function will observe that since A[0] is an int and B[0] is not, the type of
        'foo' can be further refined from Union[A, B] into just B.

        We perform this kind of "parent narrowing" for member lookup expressions and indexing
        expressions into tuples, namedtuples, and typeddicts. We repeat this narrowing
        recursively if the parent is also a "lookup expression". So for example, if we have
        the expression "foo['bar'].baz[0]", we'd potentially end up refining types for the
        expressions "foo", "foo['bar']", and "foo['bar'].baz".

        We return the newly refined map. This map is guaranteed to be a superset of 'new_types'.
        )r  refine_parent_types)r1  r  
output_mapr  r  new_mappingparent_exprproposed_parent_types           r  r  z%TypeChecker.propagate_up_typemap_info   s    2 
(00 	? 	?OD)(Jt 224CCK5@5F5F5H5H ? ?11 )++*>
;''? r  r  Mapping[Expression, Type]c                d   
 i }	 t          |t                    r@                     |j        |                                         }|j        d
 fd}nt          |t                    r                     |j        |                                         }                     |j        |                                |j                  }||S t          |          d
fd}nt          |          

d

fd	}n|S |S ||S t          |          }t          |t                    s|S g }t          |j                  D ]E} |t          |                    }	|	|c S t          |	|          r|                    |           F|s|S }t#          |          x}|<   )a  Checks if the given expr is a 'lookup operation' into a union and iteratively refines
        the parent types based on the 'expr_type'.

        For example, if 'expr' is an expression like 'a.b.c.d', we'll potentially return refined
        types for expressions 'a', 'a.b', and 'a.b.c'.

        For more details about what a 'lookup operation' is and how we use the expr_type to refine
        the parent types of lookup_expr, see the docstring in 'propagate_up_typemap_info'.
        Tnew_parent_typer   r-  r+  c                    j                                         5 }t          | ddd| d	  	        }d d d            n# 1 swxY w Y   |                                rd S |S )NF)	r  r0  r  r1  r2  r3  r4  r+  in_literal_context)rE  r  r%   r  )r  wmember_typemember_namer  r1  s      r  replay_lookupz6TypeChecker.refine_parent_types.<locals>.replay_lookupa  s    //11 Q&;!, /$/&+%*(-*9 $/4
' 
' 
'               '')) +#t**s   A  AANc                     t           t                    sd S 	 J  fdD             }n# t          $ r Y d S w xY wt          |          S )Nc                *    g | ]}j         |         S r  r  r  r  r  s     r  rt  zJTypeChecker.refine_parent_types.<locals>.replay_lookup.<locals>.<listcomp>  s!    +_+_+_3O,A#,F+_+_+_r  )r  r   rj  r   )r  member_typesstr_literalss   ` r  r  z6TypeChecker.refine_parent_types.<locals>.replay_lookup  sx    )/=II (#'4(#/#;#;#;+_+_+_+_R^+_+_+_LL' ( ( (#'44(4\BBB   . 
<<c                     t           t                    sd S 	 J  fdD             }n# t          $ r Y d S w xY wt          |          S )Nc                *    g | ]}j         |         S r  r  r  s     r  rt  zJTypeChecker.refine_parent_types.<locals>.replay_lookup.<locals>.<listcomp>  s!    /c/c/cs0Ec0J/c/c/cr  )r  r   
IndexErrorr   )r  r  int_literalss   ` r  r  z6TypeChecker.refine_parent_types.<locals>.replay_lookup  sx    #-oy#I#I ,'+t,'3'?'?'?/c/c/c/cVb/c/c/c#- , , ,'+tt,#8#F#FFr  )r  r   r-  r+  )r  r~   _propagate_walrus_assignmentsr  r  r  rx   r  r  r   r   r   r   r   r  r>   r6  r   )r1  r  r  outputparent_typer  r}  new_parent_typesr$  r  r  r  r  r  s   `         @@@@r  r  zTypeChecker.refine_parent_typesI  s_    *,h	V
 $
++ @"@@FSS"66{CC"i+ + + + + + + + +$ D),, )"@@FSS"66{CC224:vFFF!55djAA
%!MA*MM+C C C C C C C $Fj#Q#QL#/G G G G G G G  & " *+66Kk955   "-k.?@@ 2 2+mOD,A,ABB& "MMM'Y?? 2$++D111
 $ D.CDT.U.UUI{+Qh	Vr  c                    t          |t                    rgt          |j        t                    r|                     |j        |           |                     |j                  }t          |          }||||<   |S |S )zAdd assignments from walrus expressions to inferred types.

        Only considers nested assignment exprs, does not recurse into other types.
        This may be added later if necessary by implementing a dedicated visitor.
        )r  r\   r  r  r  r  )r1  r  r  assigned_typer  s        r  r  z)TypeChecker._propagate_walrus_assignments  s     dN++ 	$*n55 I224:xHHH 44TZ@@M)$//K((5%r  c                ^   t          |t                    sdS t          |j        d          sdS t	          |j                  dk    rdS |j        d         }t          |          t          k    rdS |                     |          sdS | 	                    | 
                    |                    S )zIIs this expression a `len(x)` call where x is a tuple or union of tuples?Fzbuiltins.lenr  r   )r  rb   r   rF  r  rw  r:   rW   r  r  r  )r1  r  s     r  is_len_of_tuplezTypeChecker.is_len_of_tuple  s    $)) 	5!$+~>> 	5ty>>Q5y|4==L((5}}T"" 	5,,T-=-=d-C-CDDDr  c                    t          |d          rdS t          |          }t          |t                    r5t	          d |j        D                       r|j        j        j        dk    S dS t          |t                    r|j        
                    d          S t          |t                    r t	           fd|j        D                       S dS )zIs this a type that can benefit from length check type restrictions?

        Currently supported types are TupleTypes, Instances of builtins.tuple, and
        unions involving such types.
        rf  Fc              3  @   K   | ]}t          |t                    V  d S r0  )r  r   r  s     r  r  z7TypeChecker.can_be_narrowed_with_len.<locals>.<genexpr>  s,      BB:a,,BBBBBBr  r>  Tc              3  B   K   | ]}                     |          V  d S r0  )r  ri  s     r  r  z7TypeChecker.can_be_narrowed_with_len.<locals>.<genexpr>  s1      MMAt44Q77MMMMMMr  )r   r   r  r   rC  r  r  rL  r  r   r  r   )r1  r0  p_typs   `  r  r  z$TypeChecker.can_be_narrowed_with_len  s     !i00 	5$$ eY'' 	BBekBBBBB P-2;?OOO4eX&& 	9:&&'7888eY'' 	NMMMMMMMMMMur  c                
   |                      |          sdS |                     |          }t          |          }t          |          }t	          |t
                    sdS t	          |j        t                    sdS |j        S )zIs this expression an int literal, or a reference to an int constant?

        If yes, return the corresponding int value, otherwise return None.
        N)r  r  r   r   r  r   r  r^  )r1  r  r  r  s       r  literal_int_exprzTypeChecker.literal_int_expr  s    
 }}T"" 	4$$T**	%i00	%i00+{33 	4++S11 	4  r  list[tuple[TypeMap, TypeMap]]c                    g }t                      }|                                D ]\  }}}t          |t                    r|j        }t          |t                    r|j        }|dv r+|                    |           |                    |           m|r2|                    dt          |          f           t                      }|dv r|                    |||gf           |r$|                    dt          |          f           g }|D ]H\  }}t           fd|D                       s"t           fd|D                       s>|dv r(t                      }	g }
|D ]{} 	                    |          }||	                    |           / 
                    |          r7t          |t                    sJ |
                    |j        d                    |t          |	          dk    rd	 |
D             }|i fgc S |	                                }|t          k    r|
D ]N}                                          |          ||          \  }}||i}||i}|                    ||f           Ok|\  }} 
                    |          r||}}t%          j        ||          } 	                    |          }|J |t          k    rt          |t                    sJ                                           |j        d                   ||          \  }}|j        d         |i}|j        d         |i}|                    ||f           J|S )
a  Top-level logic to find type restrictions from a length check on tuples.

        We try to detect `if` checks like the following:
            x: tuple[int, int] | tuple[int, int, int]
            y: tuple[int, int] | tuple[int, int, int]
            if len(x) == len(y) == 2:
                a, b = x  # OK
                c, d = y  # OK

            z: tuple[int, ...]
            if 1 < len(z) < 4:
                x = z  # OK
        and report corresponding type restrictions to the binder.
        )r  r  r  >   >=<r/  r  <=r  c              3  F   K   | ]}                     |          d uV  d S r0  )r  r  s     r  r  z7TypeChecker.find_tuple_len_narrowing.<locals>.<genexpr>6  s6      MMt,,R00<MMMMMMr  c              3  B   K   | ]}                     |          V  d S r0  )r   r  s     r  r  z7TypeChecker.find_tuple_len_narrowing.<locals>.<genexpr>8  s1      @@Bt++B//@@@@@@r  Nr   r  c                ,    i | ]}|t                      S r  )r   )r  tpls     r  
<dictcomp>z8TypeChecker.find_tuple_len_narrowing.<locals>.<dictcomp>J  s     HHH#sO$5$5HHHr  )ri  r  r  r\   r  r  r6  r  rC  r  r   rb   rw  r  r@  r  r  r  r   r  )r1  r  chained
last_groupr  r}  r~  r  r  literal_valuestuplesr  r  yes_mapsizer  r  r  no_mapr_sizes   `                   r  r  z$TypeChecker.find_tuple_len_narrowing  s   ( UU
#}} 	8 	8OBe$// "z%00 $\!!t$$$u%%%% 'NND$z*:*:#;<<<!$J???NNBu#6777 	5NND$z"2"23444 	  2	4 2	4IBMMMMuMMMMM @@@@%@@@@@  \!!!$ 2 2B//33C&**3/// ++B// 2)"h77777bgaj111~&&** IHHHHG$bM?***%))++000! 8 8C(,(<(<T=M=Mc=R=RTVX\(](]%Hg"HoG!7^F$$gv%67777	8 $e''.. ."'%D!b"--B..u55)))222!$11111$($8$8$$TYq\22B% %!'  9Q<2)A,0  '6!23333r  r  c                d   t          |          }t          |t                    r|                     |||          S t          |t                    r|                     |||          S t          |t                    rg }g }g }|j        D ]q}|                     |          s|	                    |           -| 
                    |||          \  }}	|	                    |           |	                    |	           r||z  }||z  }t          |          }
t          |          }|
|fS J d            )zIDispatch tuple type narrowing logic depending on the kind of type we got.Fz"Unsupported type for len narrowing)r   r  r   refine_tuple_type_with_lenr   refine_instance_type_with_lenr   r  r  r6  r  r   )r1  r0  r  r  	yes_typesno_typesother_typesr  ytntr  r  s               r  r  zTypeChecker.narrow_with_leni  sN   c""c9%% 	?223DAAAX&& 	?55c2tDDDY'' 	?IHKY $ $44Q77 &&q)))--aT::B  $$$####$I#H,Y77H+H55GW$$>>>>>r  c                   t          |j                  }|Kt          |         } ||                                |          r|t	                      fS t	                      |fS |j        |         }t          |t                    sJ t          |j                  }t          |t                    r|                                dz
  |j
        z   }|dv r||k    r||fS t	                      |fS |dv r|dk    r|dz  }||k     r{|j        d|         }	|j        |dz   d         }
t          |                    ||                                z
  dz                       }||                    |	|gz   |
z             fS t	                      |fS |                     |t          |         |          \  }}||fS t          |t                    r|j        j        dk    sJ |                                dz
  }|j        d	         }|j        d|         }	|j        |dz   d         }
|dv r;||k    r%|                    |	|g||z
  z  z   |
z             |fS t	                      |fS |dv r|dk    r|dz  }||k     r|                    |	|g||z
  z  z   |gz   |
z             }g }t#          ||z
            D ]5}|                    |                    |	|g|z  z   |
z                        6t'          j        ||j        |j                  |fS t	                      |fS |                     |t          |         |          \  }}||fS )
z-Narrow a TupleType using length restrictions.Nr  r  r  r
  r  r  )min_lenr  r>  r   )r   r  r   r  r   r  r   r   rL  r   r$  rU  r  r   r   r  rw  r  r6  r   rV  r  r  )r1  r0  r  r  unpack_indexr  unpackrA  r$  r  suffixr  r  r  	yes_itemsr  s                   r  r  z&TypeChecker.refine_tuple_type_with_len  s   *3955 &b)FvcjjllD)) .O----"$$c))<(&*-----"6;//h 011 	) jjllQ&)99G\!!d??8O&((#--{""::AIDT>> Y}}5F Y|a'7'9'9:F'(>(>tcjjllGZ]^G^(>(_(_``F 1 1&8IF8R 1 S SSS&((#--$($C$CCQSVZ$[$[!'(( (H--\(-2HL\2\2\2\2\**,,"mA=L=)<!+--.$((v8P/PSY/Y(ZZ\___"$$c));Tzz	~~ ++ C5D7N#;;vhFO ,   	tg~.. [ [A$$S%6%6Vseai=ORX=X%6%Y%YZZZZ +IsxLLgUU"$$c)) $ ? ?WR[RV W WHgH$$r  c                   t          ||                     d                    }|j        d         }t          | j        j        v o|j        j        dk    }|dv rt          |g|z  |          |fS |dv r|dk    r|dz  }|r>t          | 
                    d|g                    }t          |g|z  |gz   |          }n|}|r]g }	t          |          D ]*}
|	                    t          |g|
z  |                     +t          j        |	|j        |j                  }n|}||fS |                     |t$          |         |          \  }}||fS )	z5Narrow a homogeneous tuple using length restrictions.r>  r   r"  )r  r  r#  r  r  r  )r<   lookup_typeinforw  r   rW  enable_incomplete_featurerL  r  r   r   r  r  r6  r   rV  r  r  r  r   )r1  r0  r  r  r  r  allow_preciser&  r  r  r  r  s               r  r  z)TypeChecker.refine_instance_type_with_len  s    )d.B.BCS.T.TUUil  4<#II4h#33 	 C54<#>>>CC;Tzz	 #D$;$;<Lse$T$TUU )x0GRU V V V t E EALLC519s!C!C!CDDDD!*!5eSXsz!R!RW$$ $ B B3PRUY Z ZHgH$$r  )r*  r  r)  r  r  r  r  ErrorCode | Noner)  c                   d S r0  r  )
r1  r  r  r  rE  r  r  r*  r  r)  s
             r  r  zTypeChecker.check_subtype  s	     sr  )r*  r)  c                   d S r0  r  )	r1  r  r  r  rE  r  r  r*  r)  s	            r  r  zTypeChecker.check_subtype  s	     sr  str | ErrorMessagec                  t          ||| j                  rdS t          |t                    rt	          ||          }| j                                        r|                     ||           dS |}
t          |          }|}t          |          }| j        	                    ||||||          rdS g }d}|pg }||t          |
|| j                  \  }}||                    |dz   |z              ||                    |dz   |z              t          |	p||||          }t          |t                    r&t          |t                    rt          |||          }t          |t                    r,t          |t                    rt!          |||| j                  }|r.|                    dd	                    |          z   d
z             }|                     ||          }|D ]$}| j                            |||j                   %|r|                     |||j                   | j                            ||||j                   t          |t                    rX|j        j        rLt          |t0          t          t2          t4          t6          f          r| j                            ||||           t          |t0                    rMt          |t                    r8t;          d||d          }|r#| j                            ||||j                   t          |t0          t>          f          rt          |t                    rk|j        j        r_d|j        j         v rQt;          d||d          }|J t          ||| j                  s#| j                            ||||j                   | !                    ||||j                   dS )zBGenerate an error if the subtype is not compatible with supertype.r  Tr  F N z (z, r  )parent_errorr/  r~  )"r   rW  r  rd  r@   rE  prefer_simple_messagesr  r   &try_report_long_tuple_assignment_errorrG   r6  rH   r   rC   r   rD   r  r   r  r  maybe_note_concatenate_pos_argsrL  r  r   r   r   r   report_protocol_problemsr   	note_callr   protocol_memberscheck_possible_missing_await)r1  r  r  r  rE  r  r  r*  r  r)  orig_subtypeorig_supertype
extra_infonote_msgsubtype_strsupertype_strerrorr  r  s                      r  r  zTypeChecker.check_subtype  s*    gy$,??? 	4c3 	/s...C8**,, 	IIc7###5!'**"#I..	8::Ym_
 
 	 5 "
$(C)?ndl* * *&K (!!-#"5"CDDD*!!/C"7-"GHHH.('9m H '8,, KIx1P1P K/w	JJ'9-- S*Y	2R2R S)%)T\RR 	N))$:1F1F*F*LMMC		#w'' 	8 	8DHMM$chM7777 	8IIhchI77700)WSVS[0\\\y(++	_*	_ 7\8YW_$`aa	_
 H--gy'X]-^^^i.. 	J:gx3P3P 	Jz7GNNND J""7D'"IIIgj9:: 	Pz)U]?^?^ 	P~) PjIN<[.[.[":y'tTTT'''!'4FFF PH&&y$ch&OOO))'9gCH)UUUur  r  r3   c                J   t          t          |          t                    rdS 	 | j                            |t                      dd          }n# t          $ r Y dS w xY w|                                rdS t          t          |          t          t          f          rdS |S )zIf type implements Awaitable[X] with non-Any X, return X.

        In all other cases return None. This method must be called in context
        of local_errors.
        Nr3  T)ignore_binder)
r  r   r   r  r  re   rj  r  r   r   )r1  r0  r  aw_types       r  get_precise_awaitable_typez&TypeChecker.get_precise_awaitable_typeT  s     oc**K88 	4	'<<WYY$ =  GG  	 	 	44	 &&(( 	4og..+0FGG 	4s   *A 
AAc              #  H   K   d| _         	 d V  d| _         d S # d| _         w xY wr  )rx  r~  s    r  checking_await_setzTypeChecker.checking_await_setj  s>      &*#	0EEE*/D'''%D'////s    	!c                   | j         rdS |                                 5  | j                                        5 }|                     ||          }|	 ddd           ddd           dS |                     |||t          j                  s	 ddd           ddd           dS 	 ddd           n# 1 swxY w Y   ddd           n# 1 swxY w Y   | j                            ||           dS )z7Check if the given type becomes a subtype when awaited.N)rE  )	rx  rI  rE  r  rG  r  r   INCOMPATIBLE_TYPESpossible_missing_await)r1  r  r  r  r  r  rF  s          r  r<  z(TypeChecker.check_possible_missing_awaitr  s    & 	F$$&& 	 	(>(>(@(@ 	L55g|LLG	 	 	 	 	 	 	 	 	 	 	 	 	 	 %%G1A1T &    	 	 	 	 	 	 	 	 	 	 	 	 	 			 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	''66666sF   C
B3C
*$B3C
'C
3B7	7C
:B7	;C

CCc                   |dk    r7t           j        |                     |          t           _        t           j        S |dk    r7t           j        |                     |          t           _        t           j        S |dk    r7t           j        |                     |          t           _        t           j        S |dk    r7t           j        |                     |          t           _        t           j        S |dk    r7t           j        |                     |          t           _        t           j        S |                     |          S )zReturn an instance type with given name and implicit Any type args.

        For example, named_type('builtins.object') produces the 'object' type.
        r  Nr  builtins.intr  r  )r   r  _named_typer   r  	bool_typerh  r  s     r  r  zTypeChecker.named_type  s   
 >!!&.*.*:*:4*@*@'!**&&&+3/3/?/?/E/E,!//>!!&.*.*:*:4*@*@'!**?""'/+/+;+;D+A+A(!++$$$)1-1-=-=d-C-C*!--%%%r  c                z   |                      |          }|j        }t          |t                    r(t          |j        t
                    sJ |j        j        }t          |t                    s
J |            t          t          j
                  }t          ||gt          |j        j                  z            S r0  )lookup_qualifiedr  r  r   r(  r   rL  r   r   r   from_omitted_genericsr  r  rO  )r1  r  r  r  r  s        r  rO  zTypeChecker._named_type  s    ##D))xdI&& 	$dk844444;#D$))//4///9:;;xj3ty/B+C+CCDDDr  rw  c                d    |                      |          }d |D             }t          ||          S )zReturn an instance with the given name and type arguments.

        Assume that the number of arguments is correct.  Assume that
        the name refers to a compatible generic type.
        c                ,    g | ]}t          |          S r  )r+   )r  r  s     r  rt  z2TypeChecker.named_generic_type.<locals>.<listcomp>  s!    GGG31#66GGGr  )r+  r   )r1  r  rw  r  s       r  r  zTypeChecker.named_generic_type  s:     ##D))GG$GGGd###r  r  c                |    |                      |          }|j        }t          |t                    s
J |            |S r0  )rR  r  r  r   )r1  r  r  r  s       r  r+  zTypeChecker.lookup_typeinfo  s?    ##H--x$))//4///r  c                ,    |                      d          S )zReturn instance type 'type'.r>  r  r~  s    r  rQ  zTypeChecker.type_type  s    ///r  c                ,    |                      d          S )zReturn instance type 'str'.r  rX  r~  s    r  r  zTypeChecker.str_type  s    ~...r  c                &    || j         d         |<   dS )z)Store the type of a node in the type map.r  N)r5  )r1  r  r0  s      r  r  zTypeChecker.store_type  s    $'D!!!r  c                ^    t          fdt          | j                  D                       S )Nc              3      K   | ]}|v V  	d S r0  r  )r  r  r  s     r  r  z'TypeChecker.has_type.<locals>.<genexpr>  s'      @@419@@@@@@r  )rC  r'  r5  r  s    `r  r  zTypeChecker.has_type  s0    @@@@ht&?&?@@@@@@r  c                P    t          | j                  D ]}||v r
||         c S d S r0  )r'  r5  )r1  r  r  s      r  r  zTypeChecker.lookup_type_or_none  s;    $/** 	 	Aqyyw tr  c                    t          | j                  D ]}|                    |          }||c S t          |          r0  )r'  r5  r  rj  )r1  r  r  r  s       r  r  zTypeChecker.lookup_type  sI    $/** 	 	AdA} tnnr  r  c                F    | j         d                             |           d S r  )r5  r   )r1  r  s     r  r  zTypeChecker.store_types  s#    ""1%%%%%r  c                F    | j         j        p| j         p| j        d          S )zShould we type-check the current function?

        - Yes if --check-untyped-defs is set.
        - Yes outside functions.
        - Yes in annotated functions.
        - No otherwise.
        r  )rW  r  rO  r~  s    r  r  zTypeChecker.in_checked_function  s-     L+c43E/EcTM_`bMcIc	
r  c                    || j         v r| j         |         S | j                             dd          }|r4t          |j        t                    sJ |j        j        }||v r||         S t          d|           )z?Look up a definition from the symbol table with the given name.__builtins__NzFailed lookup: )rS  r  r  r  r   rh  rj  )r1  r  ra  tables       r  lookupzTypeChecker.lookup  s    4<<%%  66A '!!&(333335== ;&3T33444r  c                   d|vr|                      |          S |                    d          }| j        |d                  }t          dt	          |          dz
            D ]Q}|j                            ||                   }|
J d            t          |j        t                    sJ |j        }R|d         }||j        v r|j        |         S t	          |          dk    ru|d         dv rkd
                    |          }|t          v r(d                    |d         t          |                   }nd	}t          d
                    ||                    d}	t          |	                    ||                    )Nr  r   r  z0Internal error: attempted lookup of unknown namer  r  )builtinsrp  z*, e.g. add '[{} fixtures/{}]' to your testr3  zmCould not find builtin symbol '{}' (If you are running a test case, use a fixture that defines this symbol{})z0Failed qualified lookup: '{}' (fullname = '{}').)rd  splitrU  r  r  rh  r  r  r  r   r   rA   r  rj  )
r1  r  partsr  r   r  lastr  
suggestionrE  s
             r  rR  zTypeChecker.lookup_qualified  sw   d??;;t$$$JJsOOEU1X&A1c%jj1n--  gkk%(++(Z!#(H55555H9Dqwwt}$UqU1X1G%G%G88E??666!M!T!Ta"9("C" "JJ "$J--3VD*-E-E   Iszz$55666r  )r'  r  r'  c             #    K   | j         r| j         d         j        p|}| j                             t          i ||                     dV  | j        j        r| p| j        j        o| j        o| j        d         }| j                                         \  }}}| j	        s|
                                D ]\  }}t          |j        t                    r"|j        j        |st                      |_        A|| j        vr=|s;| j                            ||| j                   | j                            |           |j        r+t'          |j                  }	|	|j        k    |_        |	|_        dS dS )zEnter a new scope for collecting partial types.

        Also report errors for (some) variables which still have partial
        types, i.e. we couldn't infer a complete type.
        r  N)rP  r(  r6  r#  rW  allow_untyped_globalsr  rO  r@  rk  r  r  rL  r   r   rQ  rE  r  r  r   r  )
r1  r'  r  r(  
permissiverP  r  r  r  fixeds
             r  r  zTypeChecker.enter_partial_types  s      &J4+=b+A+JZ{!!"22{H"M"MNNN
 l8I\ 
L+]0B]tGYZ\G] 	 #04466q!) 	) - 3 3 5 5 
) 
)Wch44 	)9NWa9N'zzCHH$"777
788gt|TTT-11#666x ) 238 < <38CH3D0#(	) 	)
) 
)r  r   r1  c                x   |                      |          \  }}}|j        |r|st                      S |S |v| j        so|rR||         }|s| j        j        s;| j                            ||| j                   | j        	                    |           n| 
                    |j        |           t          |          S )zjHandle a reference to a partial type through a var.

        (Used by checkexpr and checkmember.)
        ) find_partial_types_in_all_scopesrL  r   rk  rW  rl  rE  r  rQ  r  r  r  r   )r1  r0  r1  r  r  in_scoper(  rP  s           r  handle_partial_var_typez#TypeChecker.handle_partial_var_type4  s     -1,Q,QRV,W,W)(M8  zz!
(1K( J+D1G 8t|'I 888wUUU-11$777 55diIII%c***r  c                    j         sdS j         j        p,t          fdj         j        dd          D                       S )NFc              3  P   K   | ] }|                     j                  d uV  !d S r0  )r  r  )r  r  r  s     r  r  z7TypeChecker.is_defined_in_base_class.<locals>.<genexpr>R  sG       /
 /
/3DHHSXd*/
 /
 /
 /
 /
 /
r  r  )r  r  rC  r  )r1  r  s    `r  is_defined_in_base_classz$TypeChecker.is_defined_in_base_classO  sc    x 	5x' 
3 /
 /
 /
 /
7:x|ABB7G/
 /
 /
 ,
 ,
 	
r  dict[Var, Context] | Nonec                @    |                      |          \  }}}|r|S dS )a  Look for an active partial type scope containing variable.

        A scope is active if assignments in the current context can refine a partial
        type originally defined in the scope. This is affected by the local_partial_types
        configuration option.
        N)rp  )r1  r  rq  r  rP  s        r  r  zTypeChecker.find_partial_typesV  s1     &*%J%J3%O%O"!] 	!  tr  ,tuple[bool, bool, dict[Var, Context] | None]c                j   t          | j                  D ]}||j        v r| j        j        }t          |j        t                    r|j        j        	|j        rd}t          |j        t                    r|j        j        d}| p|j	        | j        d         j	        k    }||j	        |j        fc S dS )zLook for partial type scope containing variable.

        Return tuple (is the scope active, is the scope a local scope, scope).
        NTFr  )FFN)
r'  rP  r%  rW  local_partial_typesr  rL  r   r  r(  )r1  r  rK  disallow_other_scopesscope_actives        r  rp  z,TypeChecker.find_partial_types_in_all_scopesb  s     d011 	? 	?Eei )-(H% ch44 19RWZW_9R -1)ch44 29N -2) .-b4CUVXCYCb1b  $U^UY>>>>'  ( "!r  r   c                $    t          ||          S )z3Create a temporary node with the given, fixed type.r  rF  )r1  r  r  s      r  r)  zTypeChecker.temp_node  s    7++++r  r  r1   c                   t          |t                    r'| j                            |j        ||j                  S | j                            |||          S )zProduce an error message.r  )r  r@   rE  r  r  r  )r1  rE  r  r  s       r  r  zTypeChecker.fail  sO     c<(( 	D8==G#(=CCCx}}S'}555r  offsetc                   t          |t                    r)| j                            |j        ||j                   dS | j                            ||||           dS )zProduce a note.r  N)r  r  )r  r@   rE  r  r  r  )r1  rE  r  r  r  s        r  r  zTypeChecker.note  s[     c<(( 	HMM#)W38M<<<Fc76=====r  r  c                   t          |t                    rTt          ||                     d                    }|j        d         }t          t          |          t                    s|S |                     ||          d         S )Nr  r   r  )r  r   r<   r+  rw  r   r   r  )r1  r  r  r  r%  s        r  rM  zTypeChecker.iterable_item_type  s{    b(## 	!0T5I5IJ[5\5\]]H a(Ioi88'BB ! ! AA"gNNqQQr  c                H    t          ||                     d                    S )Nr  )r   r  )r1  r
  s     r  r   zTypeChecker.function_type  s    T4??3F#G#GHHHr  r8  r9  c                   t          |          r| j                                         d S |                                D ]"\  }}| j                            |||           #d S )Nr8  )r:  rF  r  r  r  )r1  r  r9  r  rL  s        r  r  zTypeChecker.push_type_map  su    h'' 	MK##%%%%%&nn.. M M
ddOLLLLM Mr  rb   c                
   |                      |          }|                     |j        d                   }t          |t                    r|j        }t          |          }t          |t                    r^g }t          |j	                  D ]7}t          |t                    r|                    |j                   2i i fc S t          |          }net          |t                    r|j        }nHt          |t                    r/|j                                        r|                     d          }ni i fS |                     |||          \  }}t%          |||          \  }	}
t'          t(          |	|
f          \  }	}
|	|
fS )z=Infer type restrictions for an expression in issubclass call.r  r  )r  r  rw  r  r   r5  r   r   r   r  r   r6  r$  r   rL  rP  r  r  r  r%  convert_to_typetype)r1  r  r  r  rL  
union_listr  r  r  r  r  s              r  r  z!TypeChecker.infer_issubclass_maps  s   ""4((''	!55g{++ 	*)G!'**gy)) 	J%gm44 " "a** "%%af---- r6MMM
++GG** 	lGG** 	w|/H/H/J/J 	oo&788GG r6M DDWdTXYY'7hPP1GV3DEEr  r  type_rangeslist[TypeRange] | Noner'  r  tuple[Type | None, Type | None]c                   d S r0  r  r1  r  r  r,  r'  r  s         r  r  z/TypeChecker.conditional_types_with_intersection  s	     +.#r  c                   d S r0  r  r  s         r  r  z/TypeChecker.conditional_types_with_intersection  s	      Cr  c                  t          ||||          }|d         }|d         }t          t          |          t                    r|||fS t          |          }	t          |	t                    r"t          |	                                          }
n|	g}
g }|D ]G}t          |j                  }t          |t          t          f          r|
                    |           H|s||fS g }g }|
D ]}t          |t                    s||fc S |D ]m}t          |t                    r&|
                    d|j        j         ddf           =|                     ||f|          }|X|
                    |           n|sH|                                 r$|D ]!\  }}| j                            |||           "t                      |fS t#          |          }||fS )Nr  r   r  r  z" and "NoneType"z"NoneType" is final)r  r  r   r   r   r   rb  r$  r   r   r6  rL  r  r<  r  rE  impossible_intersectionr   )r1  r  r  r,  r'  r  initial_typesr  r  r  possible_expr_typespossible_target_typesr  r$  outrD  r  r  intersectionr  reasonnew_yes_types                         r  r  z/TypeChecker.conditional_types_with_intersection  sK    *(C	
 
 
 !.a 0,Q//(33_EE 	%I\W$$ &i00k9-- 	0"2;3M3M3O3O"P"P#.- " 	3 	3B"27++D$8 455 3%,,T222$ 	%W$$(*$ 
	) 
	)Aa** )((((* ) )a** MM#Dqv{#D#D#DF["\]]]#77AGG'

<(((()  	04466 I%+ I IME6H44UFCHHHH"$$i//,S11Y&&r  c                    t          |t                    r|j        r	|j        sdS dS t          |t                    r7|j        r0|j        d         }t          |t                    sJ |j        j        S dS )z!Check if an attribute is writableFTr   )r  r   r  r  r   r  rg   r  )r1  r  
first_items      r  r  z!TypeChecker.is_writable_attribute"  s    dC   	7 (A u4/00 	7T5E 	7AJj)44444>66ur  flatten_tuplesc                   t          |t                    r|j        dk    rt          |j                  rt          t                      d          g}n|                     |j        d          }t          |j                  rt          t                      d          g}n|                     |j        d          }||dS ||z   S |rXg }t          | 
                    |                    D ]1}|                     |          }| dS |                    |           2|S |                     | 
                    |                    }|dS |gS )zrGet the type(s) resulting from an isinstance check.

        Returns an empty list for isinstance(x, ()).
        r  Fr  )r  N)r  r   r  r  r}  r    r   r  r~  flatten_types_if_tupler  r  r6  )r1  r  r  r}  r~  r  r0  
type_ranges           r  r  zTypeChecker.get_isinstance_type.  so    dF## 	 3 ty)) Q!(**UCCCD//	%/PPtz** S"8::eDDDE00E0RR|u}t%< 	 K-d.>.>t.D.DEE / /!88==
%44"":.... 44T5E5Ed5K5KLLJ!t<r  TypeRange | Nonec                p    t          |          }t          |t                    rt          |j                  }t          |t                    r= fd|j        D             }t          d |D                       }t          |d          S t          |t                    rm|	                                rYt          |                                          }t          |t                    rt          |          }n|}t          |d          S t          |t                    rad}t          |j        t                     rd}t          |j        t"                    r|j        j        j        rd}t          |j        |          S t          |t(                    rt          |d          S t          |t"                    rA|j        j        dk    r1t#          |j        j        d         g           }t          |d          S t          |t"                    r:|j        j        dk    r*|j        r#t          t	          |j                  d          S t          |t"                    r|j        j        d	k    rd S t1                               d          |          st          t5                      d          S d S )
Nc                :    g | ]}                     |          S r  )r  )r  r$  r1  s     r  rt  z6TypeChecker.get_type_range_of_type.<locals>.<listcomp>Y  s'    SSS466t<<SSSr  c                     g | ]}||j         S r0  r$  r  s     r  rt  z6TypeChecker.get_type_range_of_type.<locals>.<listcomp>Z  s    )W)W)WQ!&r  Tr  Fr>  r  ztypes.UnionTypeztyping._SpecialForm)r   r  r   r5  r   r  r   r    r   r  r  r  r   r*   r   r$  r   r   rL  r  r   r  r  rw  r   r  r   )r1  r0  r  r$  any_parameterizederased_typer  rh  s   `       r  r  z"TypeChecker.get_type_range_of_typeS  s   c""c;'' 	3!#/22Cc9%% 	8SSSSSSSK()W)W+)W)W)WXXDT$7777c<(( 	@S__->-> 	@ 6s7H7H I I+Y77 0,->??/[????c8$$ 		F "N#(H-- '!&#(H-- '#(-2H '!&SXnEEEEc7## 	8S7777c8$$ 	?):o)M)M"38<#3R88K[>>>>c8$$ 	H):>O)O)OTWT\)OYsx00GGGGc8$$ 	):>S)S)S 4$///::C@@ 	F_..uEEEE tr  c                   t          |t                    rt          |j        t                    sdS |                     |j                  }|                     |          }||dS t          |          }t          t          |                    }t          |t                    rt          |t                    sdS |	                                sdS |
                                o!|j        j        |                                k    S )a  Returns true if this expression (with the given type context) is an Enum literal.

        For example, if we had an enum:

            class Foo(Enum):
                A = 1
                B = 2

        ...and if the expression 'Foo' referred to that enum within the current type context,
        then the expression 'Foo.A' would be a literal enum. However, if we did 'a = Foo.A',
        then the variable 'a' would *not* be a literal enum.

        We occasionally special-case expressions like 'Foo.A' and treat them as a single primitive
        unit for the same reasons we sometimes treat 'True', 'False', or 'None' as a single
        primitive unit.
        F)r  r~   r  r   r  r   r   r   r   r  is_enum_literalr  rL  r  )r1  r  r  r  s       r  r  zTypeChecker.is_literal_enum  s   " !Z(( 	
1680L0L 	5..qv66..q11+"55%k22%&7&D&DEE+|44 	J{T_<`<` 	5&&(( 	5 '')) G$)[-D-D-F-FF	
r  c                    |}t          |          }t          t          j                  }t	          |t
                    r-|                    |          }|j        J d|j        _        |S t	          |t                    r1|j
                            |          }|                    |          S t	          |t                    r1|j                            |          }|                    |          S t	          |t                    rNt	          |j        t
                    r4t          j                             |j                  |j                  S t	          |t&                    rB|                                         |j                   fd|j        D                       S t	          |t,                    r8                     |          \  }}t1          | fd|D             z             S |S )z8Inject an extra attribute with Any type using fallbacks.Nr*  )is_type_formc                <    g | ]}                     |          S r  add_any_attribute_to_type)r  r  r  r1  s     r  rt  z9TypeChecker.add_any_attribute_to_type.<locals>.<listcomp>  s)    TTTA66q$??TTTr  )r5  r  c                <    g | ]}                     |          S r  r  )r  r0  r  r1  s     r  rt  z9TypeChecker.add_any_attribute_to_type.<locals>.<listcomp>  s)    ___3T;;CFF___r  )r   r   r   r;  r  r   copy_with_extra_attrr6  mod_namer   r  rU  r   r  r   r$  r  r  r  r   r5  r  r   partition_union_by_attrr   )	r1  r0  r  r  r  r  r  	with_attrwithout_attrs	   ` `      r  r  z%TypeChecker.add_any_attribute_to_type  s   c""9011c8$$ 	--dH==F %111*.F'Mc9%% 	8+@@xPPH$$h$777c<(( 	8|88xHHH$$h$777c8$$ 	CHh)G)G 	+..sx>>SM]    c;'' 	$$ ::3?DQQTTTTTTTT %    c9%% 	&*&B&B3&M&M#I|(_____R^____   r  source_typec                V   |                      ||          r||ii fS t          |          }t          |t                    rD|                     ||          \  }}||                     ||          i}||t          |          ifS |                     ||          }||k    r||ii fS i i fS )af  Simple support for hasattr() checks.

        Essentially the logic is following:
            * In the if branch, keep types that already has a valid attribute as is,
              for other inject an attribute with `Any` type.
            * In the else branch, remove types that already have a valid attribute,
              while keeping the rest.
        )has_valid_attributer   r  r   r  r  r   )r1  r  r  r  r  r  r  type_with_attrs           r  r  zTypeChecker.hasattr_type_maps  s     ##K66 	++&**%k22k9-- 	H"::;MMOA|T;;KNNOGT#8#F#FGGG77TJJ[((.)2--2vr  c                    g }g }|j         D ]C}|                     ||          r|                    |           .|                    |           D||fS r0  )r  r  r6  )r1  r  r  r  r  r$  s         r  r  z#TypeChecker.partition_union_by_attr  sq     	% 	* 	*D''d33 *  &&&&##D)))),&&r  c                   t          |          }t          |t                    rdS t          |t                    r |j        r|j        j        r|j        j        }nd }| j        	                                5 }t          ||t          t          t          j                            ddd|| d|
  
         d d d            n# 1 swxY w Y   |                                 S )NFT)r1  r2  r3  r4  r+  no_deferralmodule_symbol_table)r   r  r   r   r6  r  rL  rh  rE  r  r%   r   r   r	  r  )r1  r0  r  r  r  watchers         r  r  zTypeChecker.has_valid_attribute  s(   $$eW%% 	5eX&& 	'5+< 	'ARA[ 	'"'*"2"&X##%% 	!!78899!! $7   	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 ))++++s   7>CCCr  c                :    | j                             ||          S )Nr  )r  r  )r1  r  r  s      r  get_expression_typezTypeChecker.get_expression_type   s     ''<'HHHr  c               :    | j         |j        j                 j        S r0  )rU  rL  r  rl  )r1  r0  s     r  is_defined_in_stubzTypeChecker.is_defined_in_stub   s    |CH0199r  c                T   t          t                    rj        t          t          t          t
          f          rfj        a| j        j        D ]:}t          |t                    r#t          fd|j        D                       r dS ;|                     |           dS dS dS )zEWarn if deprecated and not directly imported with a `from` statement.Nc              3  :   K   | ]}j         |d          k    V  dS )r   Nr  )r  r  r  s     r  r  z/TypeChecker.check_deprecated.<locals>.<genexpr>   s.      6\6\QtyAaD7H6\6\6\6\6\6\r  )r  rg   r
  rp   r   r   
deprecatedrb  importsrw   rC  rh  r  )r1  r  r  imps    `  r  check_deprecatedzTypeChecker.check_deprecated   s    dI&& 	9DdW&7BCC 	4O'y( 4 4c:.. 36\6\6\6\RUR[6\6\6\3\3\ EE$$T733333	4 	4''r  c                v   t          t                    rj        t          t          t          t
          f          rsj        x}l| j        sgt          fd| j	        j
        D                       sD| j	        j        r| j        j        n| j        j        } |||t          j                   dS dS dS dS dS )zWarn if deprecated.Nc              3  h   K   | ],}j         |k    pj                             | d           V  -dS )r  N)r  r,  )r  r  r  s     r  r  z.TypeChecker.warn_deprecated.<locals>.<genexpr>#   sY         "Gdm&>&>!www&G&G     r  r  )r  rg   r
  rp   r   r   r  rn  rC  rW  deprecated_calls_excludereport_deprecated_as_noterE  r  r  r  
DEPRECATED)r1  r  r  r  warns    `   r  r  zTypeChecker.warn_deprecated   s    dI&& 	9Dtg'8(CDD
	=#.;) <    >     < %)L$J]48==PTPXP]DDW5+;<<<<<<
	= 
	=;;;;;;r  	namespacec                @    d| d| j          }| xj         dz  c_         |S )zNGenerate a name that is guaranteed to be unique for this TypeChecker instance.zdummy--r  )r_  )r1  r  r  s      r  r  z!TypeChecker.new_unique_dummy_name+   s.    5	55DO551r  r   c                   d S r0  r  r  s     r  visit_pass_stmtzTypeChecker.visit_pass_stmt3       tr  r   c                   d S r0  r  r  s     r  visit_nonlocal_declzTypeChecker.visit_nonlocal_decl6   r  r  rr   c                   d S r0  r  r  s     r  visit_global_declzTypeChecker.visit_global_decl9   r  r  )rD  r2   rU  rT  rW  r   rb  r   rc  rd  r]  r   re  rf  r-  r.  )r-  rG  )r-  r  r-  r.  r0  )r  r  ro  r&  r-  r&  )r  r  r-  r.  )r  r   r-  r.  )r  r  r  r  r-  r.  )r  rd  r  re   r-  r.  )r  r   r-  r.  )
r  r   r  r  r  r  r  r  r-  r.  )r  r   r-  r.  )r  r   r-  r(  )r*  r+  r,  re   r-  r-  )r0  r   r`  r&  r-  r&  r0  r   r-  r&  )rm  r   r`  r&  r-  r   )rm  r   r-  r   )r  rp   r-  r.  )NNF)
r  rq   r  r-  r  r  r   r&  r-  r.  )r  rp   r  r   r-  r.  )r-  r(  F)
r  rq   r0  r   r  r  r   r&  r-  r.  )r$  rq   r0  r   r  r  r  rq   r  r   r-  r.  )r
  r   r  rp   r-  r&  )r  r   r  r^  r-  r&  )r0  r   r-  r.  )r$  rq   r  r&  r-  r.  )r1  rd  r-  r&  )r!  rq   r-  r.  )r!  rp   r0  r   r-  r.  )
r  rq   rV  r   rW  rd  r  re   r-  r.  )rV  r   rW  rd  rm  r   rl  r   rh  rd  rk  r   r  re   r-  r.  )rr  r   rk  r   rV  r   r-  r&  )r  ro   r-  r.  )r0  r   r  re   r  rd  r-  r.  )r0  r   r  re   r-  r.  )r  r   r0  r   r  re   r-  r.  )r  rq   r0  r   r-  r  )r  r  r'  r  r  r  r-  r.  )r  r  r-  r  )r  r  r  r   r  r&  r-  r  )r  r   r  r   r-  r.  )r  r  r  rd  r  r   r-  r&  )r  r   r-  r+  )r  r   r  r   r  rd  r  rd  r  rd  r  r&  r  r&  r  re   r-  r&  )r  rq   r-  r.  )r  rc   r-  r.  )rL  r   r-  r(  )r0  r   r-  r.  )r  rH  r-  r.  )r  rc   r  r   r-  r.  )r  r   r-  r&  )
r  rd  rz  r   ry  r   r,  r   r-  r.  )r  rw   r-  r.  )r  ru   r-  r.  )r  rt   r-  r.  )r  rv   r-  r.  )ra  r_   r-  r.  r-  r&  )r  r   r-  r&  r  r]   r-  r.  )TF)
r  r|   r  rk   r  r&  r  r&  r-  r.  )r  r   r  rk   r-  r+  )r  r|   r  rk   r  rd  r-  r.  )r  r   r  rk   r-  r.  )r  r   r  rk   r  r   r  r   r  r   r  r&  r-  r&  )r  rd  r  r   r  re   r  r&  r  r&  r^  r  r-  r
  )r  r   r  r   r  r  r-  r&  )r  rd  r  r  r,  re   r-  r.  )r  r&  r-  r(  )r  r%  r-  r.  )r  r|   r-  r.  )r  r|   r0  r+  r-  r&  )r;  r<  r-  r<  T)
r  rC  r  rk   r  re   r  r&  r-  r.  )
r  rC  re  r^  r  re   rf  rg  r-  r&  )TNF)r  rC  r  rk   r  re   r  r&  rt  r+  ru  r&  r-  r.  )r  r<  r  rk   r  r   r  re   r  r&  r-  r.  )r  r<  r-  r<  )r  rC  r  rk   r  r   r  re   ru  r&  r  r&  r-  r.  )r  rC  r  r   r-  r   )r  r  r\  r^  r  r^  r-  r  )rL  r   r-  r&  )
r  rC  r  r   r  re   r  r&  r-  r.  )r  r|   r  r  r-  r  )r  r|   r-  r&  )
r  r   r  r|   r  r   r  re   r-  r.  )r  r   r  r|   r  r   r-  r&  )r  r   r-  r&  )r  r   r  r|   rL  r   r-  r.  rL  r   r-  r   )r  rk   r-  r&  )r  r+  r  rk   r  r+  r  r+  r  r  rB  r&  r-  r   )r  r+  r  rk   r  re   rE  r@   r(  rd  r)  rd  r*  r  r  r  r  r  r-  r  )r  r   r-  r&  )r  r~   r  r   r  r   r  rk   r  re   r-  r  )r  rx   r  rk   r  re   r-  r.  )r  r   r  r   rP  r$  r-  r.  )r  rx   r  rk   r-  r.  )r0  r   r-  r  )r  rl   r-  r.  )r  r   r-  r.  )r  rk   r  r   r  r&  r-  r   )r  rs   r-  r.  )r  r   r-  r.  )r  r   r-  r.  )r  r[   r-  r.  )r  r   r-  r.  )rj  rk   r  r   rO  r&  r-  r.  )r  r   r-  r.  )r  r   rZ  r&  r-  r.  )r  rk   rd  r&  r-  r   )rd  r&  r-  r   )r  rt  r-  r   )r0  r   r  rk   r-  rM  r  rn   r-  r.  )r  rk   r-  r  )rL  r   r  re   r-  r  )r  rk   r-  r+  )r0  r   r-  r+  )
r  rk   r%  r   r  r&  r  re   r-  r.  )r  rh   r-  r.  )rj  rg   r-  r.  FF)rj  rg   r   r&  r  r&  r-  r.  )r
  rp   r  r   r  rk   r-  r.  r  r   r-  r.  )r0  r   r
  rp   r-  r.  )r  rk   r(  r  r  r&  r-  r   )r  r`   r-  r.  )r  rf   r-  r.  )r  r}   r-  r.  )r  r}   r  rk   r-  rk   )r  rk   r0  r   r-  r3  )r  r  r-  r  )r  r!  r  r  r-  r.  )r  r   r-  r.  )
r  rd  r  rd  r  rd  r  r  r-  r  )r  r  rD  r  r-  r`  )r0  r   r=  r   r-  r   )r0  r   r-  r   )r0  r   rJ  r&  r-  rK  )r  rk   rV  r+  r-  rW  )r%  r   rG  r   r-  r  )r  r   r  rk   r-  r.  )r  rk   rx  r&  r-  rW  )r  rd   r-  rW  )r  rd  r  r<  r  rM  r  r  r  r  r-  rW  )r  r!  r-  r!  )r  rk   r  r   r-  r  )r  rk   r  r3  r-  rk   )r  rk   r-  r&  )r  rk   r-  rg  )r  rd   r-  r  )r0  r   r  rd  r  r^  r-  r  )r0  r   r  rd  r  r^  r-  r  )r0  r   r  rd  r  r^  r-  r  r  )r  r   r  r   r  re   rE  rd  r  r  r  r  r*  r  r  r.  r)  r  r-  r&  )r  r   r  r   r  re   rE  r@   r  r  r  r  r*  r  r)  r  r-  r&  )r  r   r  r   r  re   rE  r1  r  r  r  r  r*  r  r  r.  r)  r  r-  r&  )r0  r   r  r3   r-  r+  )
r  r   r  r   r  re   r  r.  r-  r.  )r  rd  r-  r   )r  rd  rw  rM  r-  r   )r  rd  r-  r   )r-  r   )r  rk   r0  r   r-  r.  )r  rk   r-  r&  )r  rk   r-  r+  )r  rk   r-  r   )r  r3  r-  r.  )r  rd  r-  r   )r'  r&  r  r&  r-  r(  )
r0  r   r1  r&  r  r   r  re   r-  r   )r  r   r-  r&  )r  r   r-  rv  )r  r   r-  rx  )r  r   r  r  r-  r   )rE  r1  r  re   r  r.  r-  r1   r  )
rE  r1  r  re   r  r^  r  r.  r-  r.  )r  r   r  re   r-  r   )r
  ro   r-  r   )r  r!  r9  r&  r-  r.  )r  rb   r  rk   r-  rW  )r  r   r  r  r,  re   r'  r.  r  r&  r-  r  )r  r   r  r  r,  re   r'  r   r  r&  r-  r  )r  r   r  r  r,  re   r'  r+  r  r&  r-  r  )r  r   r-  r&  )r  rk   r  r&  r-  r  )r0  r   r-  r  r  rk   r-  r&  )r0  r   r  rd  r-  r   )r  rk   r  r   r  rd  r-  rW  )r  r   r  rd  r-  rK  )r0  r   r  rd  r-  r&  )r  rk   r  r+  r-  r   )r0  r   r-  r&  )r  r  r  re   r-  r.  )r  rd  r-  rd  )r  r   r-  r.  )r  r   r-  r.  )r  rr   r-  r.  )r  r  r  rB  rl  r  rj  r  r  rk  rn  rX  rY  r2  propertyr  r  r  r  r  r  r  r  r  r  r  r  r  r   r  r  r  rg  rl  rr  rz  r~  r  r  r  r  r  r  r  r  r  r  r  r5  r  r  r  r  rf  ro  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r6  r  r&  r"  r  r-  rS  rY  rU  rV  r,  r$  rw  r%  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r   r  r  r  r  r"  r  r  r  r2  rB  r  rP  rT  rx  r'  rw  r  rQ  rL  r{  r  r  r  r  r  r  r  r  r  r  r   r	  r.  r  r  r  r
  r  r  r  r  r&  r  r=  r@  rG  rM  rR  rP  r]  r[  rc  rk  rm  ri  r  r  r  r  r  r  r|  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  rk  r<  rE  rI  rN  r[  rc  rh  rv  r  rz  r  r  r  r  r  r   r  r  r  r  r  r  r   r  rG  rI  r<  r  rO  r  r+  rQ  r  r  r  r  r  r  r  rd  rR  r  rr  ru  r  rp  r)  r  r  rM  r   r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r,  r,  C  s          GNNN -,,, "!!!3333####MMM))))       '&&&H!I " 8<;;;;"""""  )((( NNN OOO))))M) M) M) M)^ " " " X" / / / X/- - - -$* * * *\ IM& )-	& & & & & &P" " " ". . . .H H H H: : : : _ _ _ _ '+;'
 -137;' ;' ;' ;' ;' ;'B2 2 2 2c5 c5 c5 c5J : : : ^:5 5 5 5nyR yR yR yRL^ ^ ^ ^&$ $ $ $ 3  3  3  3D! ! ! !F# # # #   >= = = =. .2!!J !J !J !J !JF) ) ) )V 2 2 2 ^2 X]h% h% h% h% h%TCW CW CW CWJ@ @ @ @D   *   (! ! ! !F; ; ; ;> > > >,J ,J ,J ,J\" " " "HV
 V
 V
 V
p>N >N >N >N@2
 2
 2
 2
hM M M M4N N N N:W W W W"
 
 
 
    ! ! ! !8 #'	    . )  )  )  )D'! '! '! '!RY Y Y Yq q q qfI I I I m m m m^3 3 3 32O) O) O) O)b & & & ^&S S S S. . . .`U U U U" " " ":X X X X; ; ; ;0   8   8'V 'V 'V 'VRE E E E,VR VR VR VRpB B B B0                        ,5 5 5 5&
 
 
 
   83A 3A 3A 3Aj3 3 3 3 #' ID ID ID ID IDX *@AV(WWWWW' ' ' 'R.' .' .' .'`] ] ] ]~! ! ! !R ")-:) :) :) :) :) :)x      := = = =(" " " " ) ) ) ^)4Q 4Q 4Q 4Ql 
  
  
  
D   &   H #'RU RU RU RU RUr %)" " " " "R #'#!&? ? ? ? ?BA& A& A& A&F	 	 	 	$ #'[ [ [ [ [z$M $M $M $ML! ! ! ! 
 
 
 
 #'= = = = =0 ;?@3 @3 @3 @3 @3D    0F 0F 0F 0Fd* * * *X   2%E %E %E %EN6 6 6 6( ( ( (   &S S S St -M%'i, #'$(#i, i, i, i, i, i,V
 
 
 
#Z #Z #Z #ZJ& & & &4; ; ; ;%P %P %P %PN   "
0 
0 
0 
0" " " "
" " " "HmI mI mI mI^- - - -6F F F F   0% % % %" " " "    B'= '= '= '=R,) ,) ,) ,)\'0 '0 '0 '0R   4 4 4 4   .
 
 
 
"	# 	# 	# 	#" " " "& & & &&   6   ,\ \ \ \   $& & & & PUH6 H6 H6 H6 H6T	K 	K 	K 	K[ [ [ [#  #  #  # J; ; ; ;
 
 
 
&   # # # #   U U U Un! ! ! !$       , , , ,\+ + + +. . . .   ,dd dd dd ddL? ? ? ?8D D D DT  T  T  T l- - - -8"P "P "P "PH
 
 
 
 4Z 4Z 4Z 4Zn ?C( ( ( ( ( (: ?Cd  d  d  d  d  d LD_ D_ D_ D_LB  B  B  B H' ' ' 'RvV vV vV vVp   $E E E E   ,! ! ! ! _ _ _ _B? ? ? ?4@% @% @% @%D% % % %H  %)&* #'!%(,     X  %)&* #'(,     X& %)&*L #'!%(,L L L L L L\   , 0 0 0 ^07 7 7 7"& & & &6	E 	E 	E 	E	$ 	$ 	$ 	$   0 0 0 0/ / / /( ( ( (A A A A      & & & &

 

 

 

5 5 5 57 7 7 7> %*U) ) ) ) ) ^)B+ + + +6
 
 
 

 
 
 
" " " "<, , , , ,
 VZ6 6 6 6 6 6 	> "&> > > > > >	R 	R 	R 	RI I I I KO M M M M M M   <  . -1. . . . . X.  -1          X   $=' -1=' =' =' =' =' ='~
 
 
 
 8<#  #  #  #  # J, , , ,\$
 $
 $
 $
L! ! ! !F   2
' 
' 
' 
', , , ,2I I I I I: : : :4 4 4 4= = = =               r  r,  c                      e Zd ZU dZded<   ded<   ded<   d2dZ	 d3d4dZd5dZd6dZ	 d3dddd7d Z	dd!d8d"Z
d9d$Zd:d%Zd;d<d)Zd=d*Zed>d+            Zd?d-Zed>d.            Zd>d/Zed@d1            ZdS )ATypeCheckerAsSemanticAnalyzerz
    Adapts TypeChecker to the SemanticAnalyzerCoreInterface,
    allowing most type expressions to be parsed during the TypeChecker pass.

    See ExpressionChecker.try_parse_as_type_expression() to understand how this
    class is used.
    r,  _chkdict[str, SymbolTableNode]_namesr&  did_failr+  rh  r-  r.  c                0    || _         || _        d| _        d S r?  )r  r  r  )r1  r+  rh  s      r  r2  z&TypeCheckerAsSemanticAnalyzer.__init__J   s    	r  Fr  rd  r,  re   r  SymbolTableNode | Nonec                R    | j                             |          }|
J |            |S r0  )r  r  )r1  r  r,  r  r  s        r  rR  z.TypeCheckerAsSemanticAnalyzer.lookup_qualifiedO   s-     kood## 
r  r  r   c               H    |                      |          }|
J |            |S r0  )lookup_fully_qualified_or_none)r1  r  r  s      r  lookup_fully_qualifiedz4TypeCheckerAsSemanticAnalyzer.lookup_fully_qualifiedX   s)    11(;;
r  c               Z    	 | j                             |          S # t          $ r Y d S w xY wr0  )r  rR  rj  r1  r  s     r  r  z<TypeCheckerAsSemanticAnalyzer.lookup_fully_qualified_or_none]   s?    	9--h777 	 	 	44	s    
**N)blockerr  rE  seriousr  r  r.  c                   d| _         d S r  )r  )r1  rE  r,  r  r  r  s         r  r  z"TypeCheckerAsSemanticAnalyzer.failc   s     r  r  c                   d S r0  r  )r1  rE  r,  r  s       r  r  z"TypeCheckerAsSemanticAnalyzer.noten       r  featurec                \    || j         j        j        vr|                     d|           dS dS )N__ignored__FT)r  rW  r,  r  )r1  r  r,  s      r  incomplete_feature_enabledz8TypeCheckerAsSemanticAnalyzer.incomplete_feature_enabledq   s3    $)+EEEIImS)))5tr  c                    d S r0  r  r~  s    r  record_incomplete_refz3TypeCheckerAsSemanticAnalyzer.record_incomplete_refw   r  r  debug_contextr  force_progressc                    d S r0  r  )r1  r  r  s      r  deferz#TypeCheckerAsSemanticAnalyzer.deferz   r  r  c                    dS r?  r  r  s     r  is_incomplete_namespacez5TypeCheckerAsSemanticAnalyzer.is_incomplete_namespace}   s    ur  c                    dS r  r  r~  s    r  final_iterationz-TypeCheckerAsSemanticAnalyzer.final_iteration       tr  flagc                @    | j         j                            |          S r0  )r  rb  is_future_flag_set)r1  r	  s     r  r	  z0TypeCheckerAsSemanticAnalyzer.is_future_flag_set   s    y~00666r  c                $    | j         j        j        S r0  )r  rb  rl  r~  s    r  is_stub_filez*TypeCheckerAsSemanticAnalyzer.is_stub_file   s    y~%%r  c                    dS r?  r  r~  s    r  is_func_scopez+TypeCheckerAsSemanticAnalyzer.is_func_scope   s	     ur  r  c                    | j         j        S r0  )r  rL  r~  s    r  rL  z"TypeCheckerAsSemanticAnalyzer.type   s    y~r  )r+  r,  rh  r  r-  r.  r  )r  rd  r,  re   r  r&  r-  r  )r  rd  r-  r   )r  rd  r-  r  )rE  rd  r,  re   r  r&  r  r&  r  r.  r-  r.  )rE  rd  r,  re   r  r.  r-  r.  )r  rd  r,  re   r-  r&  r  r?  )r  r  r  r&  r-  r.  )r  rd  r-  r&  r  )r	  rd  r-  r&  )r-  r  )r  r  r  rB  r  r2  rR  r  r  r  r  r  r  r  r  r  r  r	  r	  r	  rL  r  r  r  r  r  =   s          &&&&NNN    @E       
    		 !%	 	 	 	 	 	 HL                       X7 7 7 7 & & & X&       X  r  r  c                  "    e Zd ZdZd	dZd
dZdS )r  z0Collects the non-nested argument types in a set.r-  r.  c                ,    t                      | _        d S r0  )ri  r  r~  s    r  r2  zCollectArgTypeVarTypes.__init__   s    +.55r  r  r   c                :    | j                             |           d S r0  )r  r  rj  s     r  visit_type_varz%CollectArgTypeVarTypes.visit_type_var   s    1r  Nr  )r  r   r-  r.  )r  r  r  rB  r2  r	  r  r  r  r  r     sB        ::1 1 1 1     r  r  TF)r  r  rV  r   proposed_type_rangesr  r'  r.  r  r&  r  r-  r  c                   d S r0  r  rV  r	  r'  r  r  s        r  r  r     s	     '*cr  r  c                   d S r0  r  r	  s        r  r  r     s	     r  r+  c               ,   || |fS |st                      |fS t          |          dk    r|d         j        }t          |          }t	          |t
                    rO|                                st	          |j        t                    r!|j	        j
        j        }t          | |          } t          |           }t	          |t                    rqg }g }	|j        D ]C}
t          |
||
||          \  }}|                    |           |	                    |           Dt#          |          }t#          |	          }||fS t#          d |D                       }t	          |t                    r|j        n|g}t%          t          |                    D ]p}t          ||                   }t	          |t&                    r?|j
        j        r3|j
        j        d         }t	          |t&                    r|j
        j        3|||<   qt          t          j        |                    }t	          |t.                    r|| fS t	          |t.                    r||fS t1          d |D                       st3          | |d          r|t                      fS t	          |t4                    s!t	          |t&                    r8|j
        j        r,t9          | |d          rt;          | ||n||	          }||fS |rHt=          |          }t?          | |d
          st                      |fS t?          | |d          s||fS n"t?          | |d          st                      |fS t          j        d |D                       }t;          | ||	          }||fS )aA  Takes in the current type and a proposed type of an expression.

    Returns a 2-tuple:
        The first element is the proposed type, if the expression can be the proposed type.
            (or default, if default is set and the expression is a subtype of the proposed type).
        The second element is the type it would hold if it was not the proposed type, if any.
            (or default, if default is set and the expression is not a subtype of the proposed type).

        UninhabitedType means unreachable.
        None means no new information can be inferred.
    Nr  r   )r'  r  r  c                    g | ]	}|j         
S r  r  r  r  s     r  rt  z%conditional_types.<locals>.<listcomp>   s    *b*b*bz:?*b*b*br  c              3  $   K   | ]}|j         V  d S r0  r  r	  s     r  r  z$conditional_types.<locals>.<genexpr>!  s%      PPZz(PPPPPPr  Tr!  r  Fc                *    g | ]}|j         	|j        S r  )r  r$  r	  s     r  rt  z%conditional_types.<locals>.<listcomp>+!  s"    aaaZzG`aaaar  ) r   r  r$  r   r  r   r  r  r&  r  rL  r  r   r   r  r  r6  r   r  r   
is_newtyper  rV  r   rC  r   r   r  r   r   r,   r>   )rV  r	  r'  r  r  r(  	enum_namer  r(  no_items
union_itemr  r  proposed_typeremaining_typer  r   r$  	remainderproposed_precise_types                       r  r  r     s4   & #W$$ *  '))
  A%%%a(- ((fk** 	T""$$	T(26<(F(F	T ,5I:<SSL
 ",//K+y)) - "	!%+ 		% 		%J 1$",G+! ! !Hg X&&&OOG$$$$-i88.x88n,,)*b*bMa*b*b*bccM#-mY#G#G\Mm_E3u::  uQx(( x(( 	&TY-A 	&9?1%D x(( 	&TY-A 	&a#I$8$?$?@@M+w'' +l**-)) & g%%PP;OPPPPP &\=DQQQ 	.O---- }l33	&=(33	&8E8J8V	& }MMM	& .".M,G  I
 I%% . 8FF#L-SXYYY 	. #$$g--#L-SWXXX 	$G##	$ $L-SWXXX 	."$$g-- &0aa+?aaa  +$?  N
 .((r  r  rk   r  r  rW  c                H    t          |           } |i n| |i}|i n| |i}||fS r0  r  )r  r  r  r  r  s        r  r  r  5!  s?     4  D$bb4*:G?RRwFF?r  r  rd  rc  r   c                    | |vr| S d}| t          |          z   |v r|dz  }| t          |          z   |v | t          |          z   S )zKGenerate a name that does not appear in table by appending numbers to base.r  )rd  )r  rc  r   s      r  r?  r?  ?!  s\    5	A
Q-5
 
 	Q Q-5
 
 #a&&=r  r  c                b    t          | d          pt          | t                    o
| j        dk    S )z>Returns true if this expression is the 'True' literal/keyword.zbuiltins.Truer   r   r  ry   r  r  s    r  r  r  I!  s0    a11\Z75K5K5\PQPW[\P\\r  c                b    t          | d          pt          | t                    o
| j        dk    S )z?Returns true if this expression is the 'False' literal/keyword.r  r   r!	  r"	  s    r  r  r  N!  s1    a!122]jG6L6L6]QRQX\]Q]]r  c                B    t          | t                    o
| j        dk    S )z>Returns true if this expression is the 'None' literal/keyword.r%  r  r   r  r"	  s    r  r  r  S!  s    a""Dqz_'DDr  r  c                B    t          | t                    o
| j        dk    S )NrU  r%	  r"	  s    r  r  r  X!  s    a""Nqz5N'NNr  r
  rq   c                `   | j         j         }t          |          dk    ot          |d         x}t                    or|j        du pt          |j                  oUt          |d         x}t                    o8t          |j        x}t                    o|j        du pt          |j                  S )z
    Checks whether a function's body is 'return; yield' (the yield being added only
    to promote the function into a generator function).
    r  r   Nr  )r  r  r  r   r  r  rl   r   )r
  r  ret_stmt	expr_stmt
yield_exprs        r  r  r  \!  s    
 9>DD		Q 	J47*xJ77	J]d"Dohm&D&D	J DG+y^<<	J Y^3zY??		J
 _$H
(H(Hr  r  c                   t          |           } t          | t                    rS| j        j        dv rC| j        sdS t          t          | j        d                   t                    s| j        d         S nft          | t                    rg }| j        D ]}t          |t                    rt          |j                  }t          |t                    rt          |j                  }t          |t                    r|j        j        dk    sJ |                    |j        d                    |                    |           t          d t          |          D                       rt          |          S n`t          | t                     rK| j        j        j        D ]/}|j        dk    r"t'          | j        |          j        d         c S 0J d            dS )	a  Get the item type of a builtin container.

    If 'tp' is not one of the built containers (these includes NamedTuple and TypedDict)
    or if the container is not parameterized (like List or List[Any])
    return None. This function is used to narrow optional types in situations like this:

        x: Optional[int]
        if x in (1, 2, 3):
            x + 42  # OK

    Note: this is only OK for built-in containers, where we know the behavior
    of __contains__.
    )r  r>  r  r  zbuiltins.frozensetz_collections_abc.dict_keysztyping.KeysViewNr   r>  c              3  B   K   | ]}t          |t                     V  d S r0  )r  r   r  s     r  r  z$builtin_item_type.<locals>.<genexpr>!  s/      XXr:b'***XXXXXXr  ztyping.MappingFz2No Mapping base class found for TypedDict fallback)r   r  r   rL  r  rw  r   r   r  r   r   r5  r6  ra  r   r   r   r  r  r<   )r  normalized_itemsr  rA  r  s        r  r  r  l!  s    
		B"h %K7  
 
 
 7 tobgaj997CC "wqz!	B		"	" K( 	, 	,B"j)) 	,*2733h(899 E.x/CDDHx227?}7MQa7a7a7a7a ''a(89999 ''++++XX5EFV5W5WXXXXX 	;()9:::	;	B	&	& K K$( 	L 	LD} 0000dCCHKKKK 1JJJJJ4r  r%  c                X    t          d |                                 D                       S )Nc              3  Z   K   | ]&}t          t          |          t                    V  'd S r0  )r  r   r   r  s     r  r  z%is_unreachable_map.<locals>.<genexpr>!  s4      UU1z/!,,o>>UUUUUUr  )rC  r  )r%  s    r  r:  r:  !  s'    UU

UUUUUUr  r  m1m2r  c               |   |                                 }d |D             }| D ]M}t          |          |vs/t          t          | |                   t          t
          f          r| |         ||<   N|rI| D ]F}|D ]A}t          |          t          |          k    rt          | |         ||                   ||<   BG|S )zCalculate what information we can learn from the truth of (e1 and e2)
    in terms of the information that we can learn from the truth of e1 and
    the truth of e2.
    c                ,    h | ]}t          |          S r  )r;   )r  n2s     r  r  z'and_conditional_maps.<locals>.<setcomp>!  s     ---B|B---r  )copyr;   r  r   r   r   r?   )r0	  r1	  r  r  m2_keysn1r4	  s          r  r  r  !  s     WWYYF--"---G    7**jBrF##g%?/
 /
* BF2J <  	< 	<B < <##|B'7'777!+BrFBrF!;!;F2J< Mr  r  r  c               N   t          |           r|S t          |          r| S i }| D ]}}|D ]x}t          |          t          |          k    rV|r4t          t          | |                   t                    r| |         ||<   Xt          | |         ||         g          ||<   y~|S )zCalculate what information we can learn from the truth of (e1 or e2)
    in terms of the information that we can learn from the truth of e1 and
    the truth of e2. If coalesce_any is True, consider Any a supertype when
    joining restrictions.
    )r:  r;   r  r   r   r   )r0	  r1	  r  r  r7	  r4	  s         r  r  r  !  s     " 	" 	
 &(F I I 	I 	IBB<#3#333 IJr"v/F/F$P$P I!#BF2JJ!6227G!H!HF2J	I Mr  r  r  c                    t          |           dk    ri i fS t          |           dk    r| d         S | d         \  }}| dd         D ]'\  }}t          |||          }t          ||          }(||fS )a  Reduces a list containing pairs of if/else TypeMaps into a single pair.

    We "and" together all of the if TypeMaps and "or" together the else TypeMaps. So
    for example, if we had the input:

        [
            ({x: TypeIfX, shared: TypeIfShared1}, {x: TypeElseX, shared: TypeElseShared1}),
            ({y: TypeIfY, shared: TypeIfShared2}, {y: TypeElseY, shared: TypeElseShared2}),
        ]

    ...we'd return the output:

        (
            {x: TypeIfX,   y: TypeIfY,   shared: PseudoIntersection[TypeIfShared1, TypeIfShared2]},
            {shared: Union[TypeElseShared1, TypeElseShared2]},
        )

    ...where "PseudoIntersection[X, Y] == Y" because mypy actually doesn't understand intersections
    yet, so we settle for just arbitrarily picking the right expr's type.

    We only retain the shared expression in the 'else' case because we don't actually know
    whether x was refined or y was refined -- only just that one of the two was refined.
    r   r  Nr  )r  r  r  )r  r  final_if_mapfinal_else_mapr<  r  s         r  r  r  !  s    4 9~~2v	Y1		|'0|$n )!"" 	K 	KFH/fxXXXL0JJNN^++r  msr  c                    t          |           dk    ri S t          |           dk    r| d         S | d         }| dd         D ]}t          ||          }|S )zKReduces a list of TypeMaps into a single TypeMap by "or"-ing them together.r   r  N)r  r  )r<	  r  r  s      r  r  r  "  sd    
2ww!||	
2ww!||!uUFV 0 0$VQ//Mr  c                   t          |           dk    ri S t          |           dk    r| d         S | d         }| dd         D ]}t          |||          }|S )zLReduces a list of TypeMaps into a single TypeMap by "and"-ing them together.r   r  Nr  )r  r  )r<	  r  r  r  s       r  r  r  "  sk    
2ww!||	
2ww!||!uUFV D D%fa(CCCMr  zbuiltins.bytearrayzbuiltins.memoryviewBUILTINS_CUSTOM_EQ_CHECKSr  c                    t          | dd          pHt          | dd          p6t          t          |           x}t                    o|j        j        t          v S )NrY  F)	check_allrZ  )r   r  r   r   rL  r  r?	  )r  pts     r  r  r  !"  sd    aU;;; 		
 H>>>		
 _Q///r:: > $==r  r  c                H   i }|                                  D ]\  }}|}t          |t                    r|j        }t	          |          }t          |t
                    r|||<   Mt          |t          t          t          f          rt          j
        |          ||<   i c S |S r0  )r  r  r   r5  r   r   r   r   r   r   r  )r  converted_type_mapr  r0  r  s        r  r  r  0"  s    13^^%%  	ca%% 	AA a)) 	'*t$$Ix:;; 	'/'?'D'Dt$$ IIIr  r<  c                    t          | t          t          f          rd | j        D             S t          | t                    rt          | j                  S | gS )zAFlatten a nested sequence of tuples/lists into one list of nodes.c                6    g | ]}t          |          D ]}|S r  )r  r  ara  s      r  rt  zflatten.<locals>.<listcomp>F"  s+    777aGAJJ77q7777r  )r  r   r{   r  r   r  r  r<  s    r  r  r  C"  sV    !i*++ 77177777	Ax	 	  qvs
r  rM  c                    t          |           } t          | t                    r$t          j        d | j        D                       gS t          | t
                    rd | j        D             S t          | d          r| j        d         gS | gS )z;Flatten a nested sequence of tuples into one list of nodes.c                6    g | ]}t          |          D ]}|S r  r  rG	  s      r  rt  z*flatten_types_if_tuple.<locals>.<listcomp>Q"  s/    %\%\%\ABXYZB[B[%\%\Qa%\%\%\%\r  c                6    g | ]}t          |          D ]}|S r  rK	  rG	  s      r  rt  z*flatten_types_if_tuple.<locals>.<listcomp>S"  s.    FFFa,B1,E,EFFqFFFFr  r>  r   )r   r  r   rV  r  r   r   rw  r<  s    r  r  r  M"  s    A!Y _$%\%\%\%\%\]]^^!Y FF17FFFF	1.	/	/ q	{3Jr  r  dict[TypeVarId, Type]c                |    t          |          }|                    |           }t          |t                    sJ |S r0  )TypeTransformVisitorr  r  rq   )r  r%  visitorr  s       r  r  r  Y"  s;    "3''G
,,t

Cc8$$$$$Jr  c                  (     e Zd Zd	 fdZd
dZ xZS )rO	  r%  rM	  r-  r.  c                V    t                                                       || _        d S r0  )superr2  r%  )r1  r%  r  s     r  r2  zTypeTransformVisitor.__init__a"  s$    r  rL  r   c                ,    t          || j                  S r0  )r7   r%  r  s     r  rL  zTypeTransformVisitor.typee"  s    4***r  )r%  rM	  r-  r.  r  )r  r  r  r2  rL  __classcell__r  s   @r  rO	  rO	  `"  sQ             + + + + + + + +r  rO	  r   r  c                    t          | j        |j                  }t          |                                 |                                          }||k    S )zOCan a single call match both t and s, based just on positional argument counts?)maxr  minmax_possible_positional_args)r  r  r  max_argss       r  rK  rK  i"  sG    1:qz**H11133Q5S5S5U5UVVHxr  r  list[CallableType]c                   | j         D ]\}|j                                        rAt          | |j        |j        i                              d | j         D                       }  n]|                                 s| gS g }| j         D ]T}t          |t                    r"|j	        r|
                    |j	                   9|
                    |j        g           Ug }t          j        | D ]X}d t          | j         |          D             }|
                    t          | |                              g                      Y|S )zRExpand a generic callable using all combinations of type variables' values/bounds.c                D    g | ]}|j                                         |S r  )r  r0  r  s     r  rt  z,expand_callable_variants.<locals>.<listcomp>w"  s'    HHHH1HHHr  r  c                $    i | ]\  }}|j         |S r  r  )r  rK  r  s      r  r  z,expand_callable_variants.<locals>.<dictcomp>"  s     RRR[b%BE5RRRr  )rR  r  r0  r7   r5  rU  
is_genericr  r   r  r6  r  r  r  )r  rK  tvar_valuesr  variantscombinationtvar_maps          r  expand_callable_variantsre	  p"  sf   k   5==?? 	Ar~677EEHHakHHH F  A E		 <<>> s
K 3 3dK(( 	3T[ 	3t{++++ 012222H (+6 N NRRC[4Q4QRRRAx00>>>LLMMMMOr  r  r  class_type_varslist[TypeVarLikeType]rt  c                |   t          | |          } t          ||          }t          |          }t          |           D ]|}|D ]w}t          |j        |j                  rt	          ||t
          ddd d          st	          ||t
          ddd d          sV|rt	          ||t          dddd          s  dS x}dS )aS  Check if two overloaded signatures are unsafely overlapping or partially overlapping.

    We consider two functions 's' and 't' to be unsafely overlapping if three
    conditions hold:

    1.  s's parameters are partially overlapping with t's. i.e. there are calls that are
        valid for both signatures.
    2.  for these common calls, some of t's parameters types are wider that s's.
    3.  s's return type is NOT a subset of t's.

    Note that we use subset rather than subtype relationship in these checks because:
    * Overload selection happens at runtime, not statically.
    * This results in more lenient behavior.
    This can cause false negatives (e.g. if overloaded function returns an externally
    visible attribute with invariant type), but such situations are rare. In general,
    overloads in Python are generally unsafe, so we intentionally try to avoid giving
    non-actionable errors (see more details in comments below).

    Assumes that 'signature' appears earlier in the list of overload
    alternatives then 'other' and that their argument counts are overlapping.
    Fc                $    t          | |           S r0  is_subset_no_promoterB  s     r  rE  z;is_unsafe_overlapping_overload_signatures.<locals>.<lambda>"      6J1a6P6P2P r  T)rF  check_args_covariantlyr   rG  allow_partial_overlapc                $    t          ||            S r0  rj	  rB  s     r  rE  z;is_unsafe_overlapping_overload_signatures.<locals>.<lambda>"  rl	  r  )rF  rm	  r   rH  rn	  )detach_callablere	  rk	  r  r   !is_overlapping_types_for_overload)r  r  rf	  rt  other_expandedsig_variantother_variants          r  rP  rP  "  s,   <  	?;;IE?33E
 .e44N/	:: ' '+ &	 &	M $K$8-:PQQ &!?+0&+%P%P*.   *!?+/&+%P%P*.  (    	'=.'+"'"&*( ( ( 	 ttt	;&	N 5r  r0  c                `    |s| S |                      t          | j                  |z             S )aw  Ensures that the callable's type variables are 'detached' and independent of the context.

    A callable normally keeps track of the type variables it uses within its 'variables' field.
    However, if the callable is from a method and that method is using a class type variable,
    the callable will not keep track of that type variable since it belongs to the class.
    r  )rU  r  rR  )r0  rf	  s     r  rp	  rp	  "  s7      
tCM':':_'LMMMr  c                r    t          | d | j        D                       }t          ||t          dd          S )zCheck if the 'other' method can never be matched due to 'signature'.

    This can happen if signature's parameters are all strictly broader then
    other's parameters.

    Assumes that both signatures have overlapping argument counts.
    c                8    i | ]}|j         t          |          S r  )r  r   )r  r  s     r  r  z,overload_can_never_match.<locals>.<dictcomp>"  s%    ___4DG8>>___r  TrJ  )r7   rR  r   r   )r  r  exp_signatures      r  rL  rL  "  sO      __9K^___ M "u4_c   r  r   c                   t          | t                    r/t          |t                    rt          | |t          dd          S nt          | t                    rpt          |t                    r[t          | j                  t          |j                  k    r1t          d t          | j        |j                  D                       S dS )z#Does t have wider arguments than s?TrJ  c              3  <   K   | ]\  }}t          ||          V  d S r0  )is_same_arg_prefix)r  r  itemts      r  r  z-is_more_general_arg_prefix.<locals>.<genexpr>#  sB        9E&ue44     r  F)	r  r   r   r   r   r  r  ra  r  r  r  s     r  r~  r~  #  s     !\"" 
a&& 	)1 1TY]   	 
A|	$	$ a&& 	17||s17||++  ILQWVWV]I^I^      5r  c           	     8    t          | |t          dddd          S )NT)rF  r   rH  rm	  r  )r   r   r}	  s     r  r{	  r{	  #  s.    !		#!   r  r  tuple[bool, str]c                    t          |           } t          j        |         }d}t          | t                    rt          | ||          }n+t          | t                    rt          | j        ||          }|d|fS d|fS )zDetermine if operator assignment on given value type is in-place, and the method name.

    For example, if operator is '+', return (True, '__iadd__') or (False, '__add__')
    depending on which method is supported by the type.
    NTF)r   r   
op_methodsr  r   _find_inplace_methodr   r  )r0  r  r  existing_methods       r  rC  rC  #  s     #

C!(+FO#x   O.sFHEE	C	'	' O.s|VXNN"_$$&=r  r4  r   r  r  c                t    |t           j        v r)d|dd          z   }| j                            |          r|S d S )N__ir  )r   ops_with_inplace_methodrL  r_  )r4  r  r  inplace_methods       r  r	  r	  2#  sE    9444+9((88 	"!!4r  rW  r   r  r  c                    t          |           }t          |t                    r|p	| o|j        S t          |t                    rdS |                     t                                 S )a  Is an inferred type valid and needs no further refinement?

    Examples of invalid types include the None type (when we are not assigning
    None to a final lvalue) or List[<uninhabited>].

    When not doing strict Optional checking, all types containing None are
    invalid.  When doing strict Optional checking, only None and types that are
    incompletely defined (i.e. contain UninhabitedType) are invalid.
    F)r   r  r   r  r   r  InvalidInferredTypes)r0  rW  r  r  r  s        r  r  r  :#  so     "#&&K+x(( 
 ['7#7#ZG<Z[	K	1	1 uzz.001111r  c                  D     e Zd ZdZd fdZddZdd
ZddZddZ xZ	S )r	  zFind type components that are not valid for an inferred type.

    These include <Erased> type, and any uninhabited types resulting from failed
    (ambiguous) type inference.
    r-  r.  c                T    t                                          t                     d S r0  )rS	  r2  r   )r1  r  s    r  r2  zInvalidInferredTypes.__init__\#  s!    &&&&&r  r  r   r&  c                    |j         S r0  )r  rj  s     r  visit_uninhabited_typez+InvalidInferredTypes.visit_uninhabited_type_#  s
    {r  r   c                    dS r  r  rj  s     r  visit_erased_typez&InvalidInferredTypes.visit_erased_typeb#  r 	  r  r   c                4    |j                                         S r0  )r  is_meta_varrj  s     r  r	  z#InvalidInferredTypes.visit_type_varf#  s     t!!!r  r   c               6    |                      |j                  S r0  )query_typesr  rj  s     r  visit_tuple_typez%InvalidInferredTypes.visit_tuple_typek#  s    (((r  r  )r  r   r-  r&  )r  r   r-  r&  )r  r   r-  r&  )r  r   r-  r&  )
r  r  r  rB  r2  r	  r	  r	  r	  rU	  rV	  s   @r  r	  r	  U#  s         ' ' ' ' ' '      " " " "
) ) ) ) ) ) ) )r  r	  c                  "    e Zd ZdZd
dZddZd	S )r  zRReplace all ambiguous Uninhabited types with Any (to avoid spurious extra errors).r  r   r-  r   c                F    |j         rt          t          j                  S |S r0  )r  r   r   rv  rj  s     r  r	  z&SetNothingToAny.visit_uninhabited_types#  s"    ; 	19/000r  r   c                R     |                      fd|j        D                       S )Nc                :    g | ]}|                               S r  )r  )r  rH	  r1  s     r  rt  z9SetNothingToAny.visit_type_alias_type.<locals>.<listcomp>{#  s#    $D$D$DQXXd^^$D$D$Dr  )rw  )rU  rw  rj  s   ` r  visit_type_alias_typez%SetNothingToAny.visit_type_alias_typex#  s0     $D$D$D$DQV$D$D$DEEEr  N)r  r   r-  r   )r  r   r-  r   )r  r  r  rB  r	  r	  r  r  r  r  r  p#  sH        \\   
F F F F F Fr  r  r  SymbolNode | Noner  c                    t          | t                    r| j        } t          | t                    r| j        S t          | t
                    r| j        S dS )z+Find out if a node describes a classmethod.N)r  rg   r
  rp   r  r   rN  r  s    r  r  r  ~#  sU    $	"" y$   }$ #""4r  c                    t          | t                    r| j        } t          | t                    r| j        S t          | t
                    r| j        S dS )z6Find out if a node describes a static function method.N)r  rg   r
  rp   r  r   r  r	  s    r  r  r  #  sU    $	"" y$   ~$ $##4r  TKeyTValuec                  :    e Zd ZdZddZdd	ZddZddZddZdS )DisjointDictai  An variation of the union-find algorithm/data structure where instead of keeping
    track of just disjoint sets, we keep track of disjoint dicts -- keep track of multiple
    Set[Key] -> Set[Value] mappings, where each mapping's keys are guaranteed to be disjoint.

    This data structure is currently used exclusively by 'group_comparison_operands' below
    to merge chains of '==' and 'is' comparisons when two or more chains use the same expression
    in best-case O(n), where n is the number of operands.

    Specifically, the `add_mapping()` function and `items()` functions will take on average
    O(k + v) and O(n) respectively, where k and v are the number of keys and values we're adding
    for a given chain. Note that k <= n and v <= n.

    We hit these average/best-case scenarios for most user code: e.g. when the user has just
    a single chain like 'a == b == c == d == ...' or multiple disjoint chains like
    'a==b < c==d < e==f < ...'. (Note that a naive iterative merging would be O(n^2) for
    the latter case).

    In comparison, this data structure will make 'group_comparison_operands' have a worst-case
    runtime of O(n*log(n)): 'add_mapping()' and 'items()' are worst-case O(k*log(n) + v) and
    O(k*log(n)) respectively. This happens only in the rare case where the user keeps repeatedly
    making disjoint mappings before merging them in a way that persistently dodges the path
    compression optimization in '_lookup_root_id', which would end up constructing a single
    tree of height log_2(n). This makes root lookups no longer amoritized constant time when we
    finally call 'items()'.
    r-  r.  c                0    i | _         i | _        i | _        d S r0  )
_key_to_id_id_to_parent_id_root_id_to_valuesr~  s    r  r2  zDisjointDict.__init__#  s#    +-
 13 ;=r  rD  	set[TKey]r  set[TValue]c                (    |sdS  fd|D             }|d         } j         |         }|                    |           |dd         D ]I}||k    s	| j         vr| j        |<   |                     j                             |                     JdS )a  Adds a 'Set[TKey] -> Set[TValue]' mapping. If there already exists a mapping
        containing one or more of the given keys, we merge the input mapping with the old one.

        Note that the given set of keys must be non-empty -- otherwise, nothing happens.
        Nc                :    g | ]}                     |          S r  )_lookup_or_make_root_id)r  r  r1  s     r  rt  z,DisjointDict.add_mapping.<locals>.<listcomp>#  s'    KKKs55c::KKKr  r   r  )r	  r   r	  r@  )r1  rD  r  subtree_rootsnew_rootroot_valuessubtree_roots   `      r  add_mappingzDisjointDict.add_mapping#  s      	FKKKKdKKK #-h76""")!""- 	J 	JLx''<t?V+V+V2:D!,/t6::<HHIIII		J 	Jr  #list[tuple[set[TKey], set[TValue]]]c                $   i }| j         D ]G}|                     |          }||vrt                      ||<   ||                             |           Hg }|                                D ]'\  }}|                    || j        |         f           (|S )z1Returns all disjoint mappings in key-value pairs.)r	  _lookup_root_idri  r  r  r6  r	  )r1  root_id_to_keysr  root_idr  rD  s         r  r  zDisjointDict.items#  s    02? 	. 	.C**3//Go--+.55(G$((----,2244 	D 	DMGTMM4!8!ABCCCCr  r  r	  r^  c                    || j         v r|                     |          S t          | j                   }|| j         |<   || j        |<   t	                      | j        |<   |S r0  )r	  r	  r  r	  ri  r	  )r1  r  new_ids      r  r	  z$DisjointDict._lookup_or_make_root_id#  sa    $/!!'',,,))F#)DOC ,2D!&).1eeD#F+Mr  c                    | j         |         }|| j        |         k    r5| j        | j        |                  }|| j        |<   |}|| j        |         k    5|S r0  )r	  r	  )r1  r  r   
new_parents       r  r	  zDisjointDict._lookup_root_id#  sf    OC 4(+++ .t/DQ/GHJ'1D!!$A 4(+++ r  Nr  )rD  r	  r  r	  r-  r.  )r-  r	  )r  r	  r-  r^  )	r  r  r  rB  r2  r	  r  r	  r	  r  r  r  r	  r	  #  s         4
= 
= 
= 
=J J J J(           r  r	  pairwise_comparisons,Iterable[tuple[str, Expression, Expression]]operand_to_literal_hashMapping[int, Key]operators_to_grouprZ  list[tuple[str, list[int]]]c                   d |D             }g }d}t                      }t                      }t          |           D ]\  }\  }	}
}||	}|rk|	|k    s|	|vra|s%|                    |t          |          f           n||                             ||           |	}t                      }t                      }|                    |           |                    |dz              |	|v r[|                    |          }||                    |           |                    |dz             }||                    |           	|C|s%|                    |t          |          f           n||                             ||           |                                D ]C\  }	}|                                D ])\  }}|                    |	t          |          f           *D|                    d            |S )a  Group a series of comparison operands together chained by any operand
    in the 'operators_to_group' set. All other pairwise operands are kept in
    groups of size 2.

    For example, suppose we have the input comparison expression:

        x0 == x1 == x2 < x3 < x4 is x5 is x6 is not x7 is not x8

    If we get these expressions in a pairwise way (e.g. by calling ComparisonExpr's
    'pairwise()' method), we get the following as input:

        [('==', x0, x1), ('==', x1, x2), ('<', x2, x3), ('<', x3, x4),
         ('is', x4, x5), ('is', x5, x6), ('is not', x6, x7), ('is not', x7, x8)]

    If `operators_to_group` is the set {'==', 'is'}, this function will produce
    the following "simplified operator list":

       [("==", [0, 1, 2]), ("<", [2, 3]), ("<", [3, 4]),
        ("is", [4, 5, 6]), ("is not", [6, 7]), ("is not", [7, 8])]

    Note that (a) we yield *indices* to the operands rather then the operand
    expressions themselves and that (b) operands used in a consecutive chain
    of '==' or 'is' are grouped together.

    If two of these chains happen to contain operands with the same underlying
    literal hash (e.g. are assignable and correspond to the same expression),
    we combine those chains together. For example, if we had:

        same == x < y == same

    ...and if 'operand_to_literal_hash' contained the same values for the indices
    0 and 3, we'd produce the following output:

        [("==", [0, 1, 2, 3]), ("<", [1, 2])]

    But if the 'operand_to_literal_hash' did *not* contain an entry, we'd instead
    default to returning:

        [("==", [0, 1]), ("<", [1, 2]), ("==", [2, 3])]

    This function is currently only used to assist with type-narrowing refinements
    and is extracted out to a helper function so we can unit test it.
    c                ,    i | ]}|t                      S r  )r	  )r  r  s     r  r  z-group_comparison_operands.<locals>.<dictcomp>'$  s    0a0a0a\^^0a0a0ar  Nr  c                    | d         d         S r  r  r  s    r  rE  z+group_comparison_operands.<locals>.<lambda>W$  s    471: r  )r  )	ri  r  r6  r  r	  r  r  r  sort)r	  r	  r	  groupsr  last_operatorcurrent_indicescurrent_hashesr   r  	left_expr
right_expr	left_hash
right_hashdisjoint_dictrD  indicess                    r  r  r  #  sY   ` 1b0aN`0a0a0aF<> $M #O"uuN09:N0O0O / /,,Hi $M 		#M 9 9XM_=_=_ " S(//@W@W0XYYYY}%11./RRR$M!eeO UUN 	AAE""" )))/33A66I$""9---044QU;;J%"":...  	O$++]F?<S<S,TUUUU=!--noNNN $*<<>> I I-*0022 	I 	IMD'$++Xvg,GHHHH	I !!&=&=!>>>##r  c                    t          |           } | rt          | t                    sdS t          d t	          | j        | j        gz             D                        S )NFc              3  j   K   | ].}t          |t                    o|j        t          j        k    V  /d S r0  )r  r   r:  r   r;  r  s     r  r  z$is_typed_callable.<locals>.<genexpr>_$  sO         	1gI1=I4I#I     r  )r   r  r   ra  r   r  r  )r  s    r  r  r  [$  ss    A Jq,// u  !!+"<==      r  c                t   t          |           } | sdS t          | t                    rt          |            S t          | t                    r| j                            d          }|rt          |t                    r2t          |j	        j                  pt          |j
        j                  S t          |j        t                    r#t          d |j        j        D                       S t          |j                   S dS t          | t                    rt          d | j        D                       S dS )NTr/  c              3  4   K   | ]}t          |          V  d S r0  r  r  s     r  r  z'is_untyped_decorator.<locals>.<genexpr>t$  s+      TT$/55TTTTTTr  Fc              3  4   K   | ]}t          |          V  d S r0  r	  r  s     r  r  z'is_untyped_decorator.<locals>.<genexpr>z$  s+      DD$'--DDDDDDr  )r   r  r   r  r   rL  rO  rg   r  r
  r  r   rC  r  )r0  r  s     r  r  r  e$  s:   
#

C Et	C	&	& E$S))))	C	"	" E$$Z00 	&),, +FK,<== AUJOB B  &+z22 :TT&+BSTTTTTT,V[99995	C	$	$ EDD#)DDDDDD4r  FuncBase | Decoratorc                    t          | t                    rt          | j                  S t          | t                    r| j        S J dt          |                        )NFzUnexpected func type: )r  rg   r  r
  ro   rL  )r
  s    r  r  r  ~$  s[    $	"" ###	D(	#	# ~774::77777r  r   c                &   t          | t                    r| j        S t          | t                    r| j        j        S t          | t
                    r>| j        r7t          | j        d         t                    r| j        d         j        j        S dS Nr   F)r  rp   r  rg   r
  r   r  r  s    r  r  r  $  s    $    $	"" %y$$$)** 2: 	2*TZ]I>> 	2:a=%115r  TypeGuard[OverloadedFuncDef]c                    t          | t                    r>| j        r7t          | j        d         t                    r| j        d         j        j        S dS r	  )r  r   r  rg   r
  r  r	  s    r  r  r  $  sM    $)** 2: 	2*TZ]I>> 	2:a=%115r  c                   | dS t          |           sdS | j        d         }t          |t                    sJ |j        j         sdS |j        }|j        !|j        t          |j        t                    rdS |j        j        d         }t          t          |          t                    rdS t          t          t          |j                            |           S )zCheck if a node is a settable property with a non-trivial setter type.

    By non-trivial here we mean that it is known (i.e. definition was already type
    checked), it is not Any, and it is different from the property getter type.
    NFr   r  )r  r  r  rg   r  rL  r  r   r  r   r   r   get_property_type)r  r  r  r  s       r  r  r  $  s     |u%% uAJj),,,,,>. u
.C
x3?2j;6W6W2u/+A.K/+..88 u-och.G.GHH+VVVVr  r   c                    t          | t                    rt          | j                  S t          | t                    rt          | j        d         j                  S | S )Nr   )r  r   r   r  r   r  r<  s    r  r	  r	  $  sR    !\"" +qz***!Z   4qwqz2333Hr  r}  r~  c                (    t          | |dd          S )NT)r"  always_covariantrA  r|  s     r  rk	  rk	  $  s    dETDQQQQr  c                (    t          | |dd          S )NT)r"  overlap_for_overloads)r>   r|  s     r  rq	  rq	  $  s      et[_````r  	node_namec                X    |                      d          o|                     d           S )z-Check if node is private to class definition.r|  )r,  endswith)r	  s    r  r  r  $  s,    %%Fi.@.@.F.F*FFr  c                N    t          |           }|d uot          |          dk    S )Nr  )r   r  )r0  strss     r  r  r  $  s)    -c22Dt.D		Q.r  c                    t          | d          rdS t          | t                    rt          d | j        D                       S dS )z<Return True if type is 'bool' or a union with a 'bool' item.r  Tc              3  6   K   | ]}t          |d           V  dS )r  N)r   r  s     r  r  z has_bool_item.<locals>.<genexpr>$  s-      RR$T?;;RRRRRRr  F)r   r  r   rC  r  )r0  s    r  r  r  $  sP    o.. t#y!! SRR	RRRRRR5r  rj  c                >    t          | t                    r| j        S | S )zIf an expression is an AssignmentExpr, pull out the assignment target.

    We don't make any attempt to pull out all the targets in code like `x := (y := z)`.
    We could support narrowing those if that sort of code turns out to be common.
    )r  r\   r(  )rj  s    r  r  r  $  s"     !^$$ xHr  r   r  r   r^  c                X    t          |          }|                     |           |j        S )zFind the highest line number of a potential assignment to variable within node.

    This supports local and global variables.

    Return -1 if no assignment was found.
    )VarAssignVisitorr  	last_line)r  r  rP	  s      r  r  r  $  s,     q!!GHHWr  c                  l     e Zd ZddZddZddZd fdZd fdZd dZd!dZ	d"dZ
d#dZd$dZ xZS )%r	  r  r   r-  r.  c                0    d| _         d| _        || _        d S )Nr  F)r	  r  var_node)r1  r  s     r  r2  zVarAssignVisitor.__init__$  s    r  r  r]   c                `    d| _         |j        D ]}|                    |            d| _         d S r  )r  r  r  r1  r  r  s      r  r  z&VarAssignVisitor.visit_assignment_stmt$  s6    ) 	 	BIIdOOOOr  rj  r   c                v    | j         r/|j        | j        u r#t          | j        |j                  | _        d S d S d S r0  )r  r  r	  rX	  r	  r  r1  rj  s     r  visit_name_exprz VarAssignVisitor.visit_name_expr$  sC    ; 	916T]22 88DNNN	9 	922r  r~   c                t    | j         }d| _         t                                          |           || _         d S r?  )r  rS	  rB  r1  rj  
old_lvaluer  s      r  rB  z"VarAssignVisitor.visit_member_expr%  s4    [
!!!$$$ r  rx   c                t    | j         }d| _         t                                          |           || _         d S r?  )r  rS	  visit_index_exprr	  s      r  r	  z!VarAssignVisitor.visit_index_expr%  s4    [
  ### r  r   c                    d| _         |j        D ]}||                    |            d| _         |j                            |            d S r  )r  r(  r  r  r	  s      r  r  z VarAssignVisitor.visit_with_stmt%  sP    ( 	  	 B~		$	dr  rn   c                    d| _         |j                            |            d| _         |j                            |            |j        r|j                            |            d S d S r  )r  r  r  r  r  r  s     r  r  zVarAssignVisitor.visit_for_stmt%  sh    	t	d; 	%Kt$$$$$	% 	%r  r\   c                    d| _         |j                            |            d| _         |j                            |            d S r  )r  r(  r  r  r	  s     r  visit_assignment_exprz&VarAssignVisitor.visit_assignment_expr%  s>    		tr  r  r   c                    |j         |j                             |            |j        *d| _        |j                            |            d| _        d S d S r  )r  r  r  r  r1  r  s     r  visit_as_patternz!VarAssignVisitor.visit_as_pattern#%  sV    9 IT"""6DKFMM$DKKK r  r   c                h    |j         *d| _        |j                             |            d| _        d S d S r  )capturer  r  r	  s     r  visit_starred_patternz&VarAssignVisitor.visit_starred_pattern+%  s:    9 DKIT"""DKKK ! r  )r  r   r-  r.  r  )rj  r   r-  r.  )rj  r~   r-  r.  )rj  rx   r-  r.  r  r  )rj  r\   r-  r.  )r  r   r-  r.  )r  r   r-  r.  )r  r  r  r2  r  r	  rB  r	  r  r  r	  r	  r
  rU	  rV	  s   @r  r	  r	  $  s           
   9 9 9 9! ! ! ! ! !! ! ! ! ! !   % % % %                         r  r	  c                    t                      }t          |           } t          | t                    r.| j        D ]$}|                    t          |                     %nt          | t                    r| j        r(|                    t          | j                             n| j	        j
        rCt          d | j	        j        D                       r |                    | j	        j                   n| j	        j
        s|                    d           nht          | t                    r(|                    t          | j                             n+t          | t"                    rn|                    d           |S )a  
    Used when narrowing types based on equality.

    Certain kinds of enums can compare equal to values of other types, so doing type math
    the way `conditional_types` does will be misleading if you expect it to correspond to
    conditions based on equality comparisons.

    For example, StrEnum classes can compare equal to str values. So if we see
    `val: StrEnum; if val == "foo": ...` we currently avoid narrowing.
    Note that we do wish to continue narrowing for `if val == StrEnum.MEMBER: ...`
    c              3  (   K   | ]}|j         d v V  dS ))zenum.IntEnumzenum.StrEnumr  rN  N)r  r  s     r  r  z/ambiguous_enum_equality_keys.<locals>.<genexpr>I%  s>       $
 $
 M]]$
 $
 $
 $
 $
 $
r  z<other>)ri  r   r  r   r  r   r  r   ry  rL  r!  rC  r  r  r  r   r  r   )r  r  r$  s      r  r  r  2%  su    UUFA!Y G 	> 	>DMM6t<<====	>	Ax	 	   
	"MM6q7IJJKKKKV^ 	" $
 $

$
 $
 $
 !
 !
 	" JJqv'''' 	" JJy!!!	A{	#	# 21:>>????	Ax	 	  

9Mr  r  c                    t          |           } t          | t                    rdS t          | t                    r| j        D ]}t          |          r dS dS r  )r   r  r   r   r  r  )r  r$  s     r  r  r  [%  sk    !+..K+}-- t+y)) % 	 	D(.. tt5r  c                    t          | t                    r| j         S t          | t                    r| j        j         S t          | t
                    S r0  )r  r   r  rg   r  rp   r	  s    r  r  r  f%  sQ    $)** $###$	"" (8'''dG$$$r  r0  )rV  r   r	  r  r'  r.  r  r&  r  r&  r-  r  )rV  r   r	  r  r'  r   r  r&  r  r&  r-  r  )rV  r   r	  r  r'  r+  r  r&  r  r&  r-  r  )r  rk   r  r+  r  r+  r-  rW  )r  rd  rc  r   r-  rd  r  )r  r  r-  r&  )r
  rq   r-  r&  )r  r   r-  r+  )r%  r!  r-  r&  )r0	  r!  r1	  r!  r  r&  r-  r!  )r0	  r!  r1	  r!  r  r&  r-  r!  r  )r  r  r  r&  r-  rW  )r<	  r  r-  r!  )r<	  r  r  r&  r-  r!  rA  )r  r!  r-  r!  )r  rk   r-  r<  )r  r   r-  rM  )r  rq   r%  rM	  r-  rq   )r  r   r  r   r-  r&  )r  r   r-  r\	  r  )
r  r   r  r   rf	  rg	  rt  r&  r-  r&  )r0  r   rf	  rg	  r-  r   )r  r   r  r   r-  r&  )r  r   r  r   r-  r&  )r0  r   r  rd  r-  r	  )r4  r   r  rd  r  rd  r-  r  r  )
r0  r   rW  r   r  r&  r  r&  r-  r&  )r  r	  r-  r  )r	  r	  r	  r	  r	  rZ  r-  r	  )r  r+  r-  r&  )r0  r+  r-  r&  )r
  r	  r-  r&  )r  r   r-  r&  )r  r	  r-  r	  )r  r	  r-  r&  )r  r   r-  r   )r}  r   r~  r   r-  r&  )r	  rd  r-  r&  r  )r0  r   r-  r&  )rj  rk   r-  rk   )r  r   r  r   r-  r^  )r  r   r-  rZ  )r  r   r-  r&  )r  r	  r-  r&  (  rB  
__future__r   r  collectionsr   collections.abcr   r   r   r   r	   r
   AbstractSet
contextlibr   r   rp  r   r   r   r   r   r  r   r   r   r   mypy.checkexprrz  r   r  r   r   r   r   mypy.binderr   r   r   mypy.checker_sharedr   r   r    mypy.checker_stater!   mypy.checkmemberr"   r#   r$   r%   r&   mypy.checkpatternr'   mypy.constraintsr(   mypy.erasetyper)   r*   r+   r,   mypy.errorcodesr-   r.   r/   r0   mypy.errorsr1   r2   r3   r4   r5   r6   mypy.expandtyper7   mypy.literalsr8   r9   r:   r;   mypy.maptyper<   	mypy.meetr=   r>   r?   mypy.message_registryr@   mypy.messagesrA   rB   rC   rD   rE   rF   rG   rH   rI   mypy.mrorJ   rK   
mypy.nodesrL   rM   rN   rO   rP   rQ   rR   rS   rT   rU   rV   rW   rX   rY   rZ   r[   r\   r]   r^   r_   r`   ra   rb   rc   rd   re   rf   rg   rh   ri   rj   rk   rl   rm   rn   ro   rp   rq   rr   rs   rt   ru   rv   rw   rx   ry   rz   r{   r|   r}   r~   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   mypy.operatorsr   r   r   mypy.optionsr   r   mypy.patternsr   r   mypy.pluginr   mypy.pluginsr   r  
mypy.scoper   mypy.semanalr   r   r   mypy.semanal_enumr   r   mypy.semanal_sharedr   mypy.sharedparser   
mypy.stater   mypy.subtypesr   r   r   r   r   r   r   r   r   r   mypy.traverserr   r   r   mypy.treetransformr   mypy.typeanalr   r   r   mypy.typeopsr   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   
mypy.typesr   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   mypy.types_utilsr   r   r  r  mypy.typetraverserr  mypy.typevarsr  r  r  	mypy.utilr  r  mypy.visitorr	  r
  r  r  r  r  r  r  r   r  r!  r#  r*  r,  r  r  r  r  r?  r  r  r  r  r  r  r:  r  r  r  r  r  r?	  r  r  r  r  r  rO	  rK  re	  rP  rp	  rL  r~  r{	  rC  r	  r  r	  r  r  r  r	  r	  r	  r  r  r  r  r  r  r  r	  rk	  rq	  r  r  r  r  r  r	  r  r  r  r  r  r  <module>r4
     si      " " " " " "     # # # # # # _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 0 0 0 0 0 0 0 0
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
     N N N N N N N N N N N N N N E E E E E E E E E E M M M M M M M M M M , , , , , ,              - , , , , , ) ) ) ) ) )            T S S S S S S S S S S S                ( ' ' ' ' ' S S S S S S S S S S S S 2 2 2 2 2 2 S S S S S S S S S S . . . . . .
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 - , , , , , , ,V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V Vn ? > > > > > > > > > 5 5 5 5 5 5 5 5 3 3 3 3 3 3 3 3       : : : : : :       O O O O O O O O O O < < < < < < < < = = = = = = 1 1 1 1 1 1                              Y X X X X X X X X X / / / / / / b b b b b b b b b b                                             .( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (R c b b b b b b b b b b b 3 3 3 3 3 3 P P P P P P P P P P * * * * * * * * $ $ $ $ $ $GCLL      !"  ! ! ! !&)::YF  F F F F*1H*<?P*P  P P P P% % % % %: % % %% % % % %j % % %$ :t+, , , , ,    z          (w{ w{ w{ w{ w{+d#%9;K w{ w{ w{twX X X X X$A X X Xv    1    
 *
 )-* * * * * 
* 
 )-     
  z)
 )-z) z) z) z) z) z)z      ] ] ] ]
^ ^ ^ ^
E E E E
O O O O    6 6 6 6rV V V V HM      8 KP      6 @E$, $, $, $, $,N	 	 	 		 	 	 	 %9:O#P  P P P P      &   	 	 	 	   + + + + ++ + + +          B 	M M M M M`
N 
N 
N 
N   .   $	 	 	 	   &    Z_2 2 2 2 26) ) ) ) )= ) ) )6F F F F Fn F F F       wv			\ \ \ \ \74<( \ \ \~a$ a$ a$ a$H      28 8 8 8      W W W W0   R R R Ra a a aG G G G
/ / / /
      	 	 	 	>  >  >  >  > ' >  >  > B& & & &R   % % % % % %r  