
    \j                      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lRmSZSmTZT ddlUmVZV ddlWmXZXmYZYmZZZm[Z[m\Z\m]Z]m^Z^m_Z_m`Z` ddlambZbmcZc ddldmeZemfZfmgZgmhZhmiZimjZjmkZkmlZlmmZmmnZnmoZompZpmqZqmrZrmsZsmtZtmuZumvZvmwZwmxZxmyZymzZzm{Z{m|Z|m}Z}m~Z~mZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZm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)lmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZ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)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?          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ZOd dkZPddnZQddpZRddrZSdIdsddwZTdIdxddzZU	 ddd}ZVddZWd	dZXd
dZYddZZddZ[ddZ\ddZ] G d de          Z^ddZ_ddZ`	 dddZaddZbddZcddZdddZeddZfddZg	 dddZh G d de          Zi G d de          ZjddZkddZl ed          Zm ed          Zn G d deemenf                   Zodd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~ G d݄ de          ZddddddZd2e=d<    ee                                          Zd2e=d<   ddddddZd2e=d<   i eeZd2e=d<    G d d          Z G d d          Zd)dZd#dZd*dZd+dZd,dZd-dZdS (.  ak  Mypy type checker.

Infer types of expressions and type-check the AST. We use multi-pass architecture,
this means we re-visit the AST until either all types are inferred, or we hit the
upper limit on number of passes (currently 3). The number of passes is intentionally
low, mostly to keep performance predictable. An example of code where more than one
pass is needed:

    def foo() -> None:
        C().x += 1  # we don't know the type of x before we visit C

    class C:
        def __init__(self) -> None:
            self.x = <some non-literal expression>

In this example, encountering attribute C.x will trigger handle_cannot_determine_type()
which in turn will schedule foo() to be re-visited in the next pass. This process is
called deferring, some notes on it:
* Only a top-level function or method can be deferred. For historical reasons we don't
  defer module top-levels.
* There are two reasons that can trigger deferral: a type of name/attribute used in
  a function body is not inferred yet, or type of superclass node is not known when
  checking LSP.
* In first case, the actual deferred node will be always FuncDef, even if the actual
  top-level function is either a Decorator or an OverloadedFuncDef.
* In the second case, the deferred node will be actual top-level node, unless FuncDef
  is sufficient (in case when deferring a method of a class nested in function).
* When a function was deferred we suppress most errors, and infer all expressions as
  Any until the end of deferred function. This is done to avoid false positives. We may
  change this in future by adding a special kind of Any that signifies not ready type.

Second important aspect of architecture is two-phase checking. Currently, it is only
used in parallel type-checking mode, but at some point it will be the default in
sequential mode as well.

In first phase (called interface phase) we type-check only module top-levels, function
signatures, and bodies of functions/methods that were found during semantic analysis as
(possibly) affecting external module interface (most notably __init__ methods). This is
done by setting recurse_into_functions flag to False. We handle all deferrals triggered
during this phase (still with recurse_into_functions being False) before moving to
the next one.

In second phase (called implementation phase) we type-check only the bodies of functions
and methods not type-checked in interface phase. This is done by setting
recurse_into_functions to True, and gathering all functions/methods with def_or_infer_vars
flag being False. Note that we execute only parts of the relevant visit methods that
were not executed before (i.e. we don't handle function signatures twice), see
check_partial() method for more details.

The boundary between function signature logic and function body logic is somewhat arbitrary,
and currently mostly sits where it was historically. Some rules about this are:
* Any logic that can *change* function signature *must* be executed in phase one.
* In general, we want to put as much of logic into phase two for better performance.
* Try keeping things clear/consistent, right now the boundary always sits at the point when
  we push the function on the scope stack and call check_func_item().

Note: some parts of the type-checker live in other `check*.py` files, like `checkexpr.py`,
the orchestration between various type-checking phases and passes is done in `build.py`.
    )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_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_unannotated_any)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__     P/var/www/app.qaans.com/backend/venv/lib/python3.11/site-packages/mypy/checker.pyr  r  D  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   L  s*         %%%%$$$$$$r  r   TypeMapc                      e Zd Zd
dZd	S )PartialTypeScopemapdict[Var, Context]is_functionboolis_localreturnNonec                0    || _         || _        || _        d S N)r$  r&  r(  )selfr$  r&  r(  s       r  __init__zPartialTypeScope.__init__e  s    "-'r  N)r$  r%  r&  r'  r(  r'  r)  r*  r  r  r  r.  r  r  r  r#  r#  d  s(        ( ( ( ( ( (r  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TypeCheckerr)  r*  c                    || _         d S r,  )r2  )r-  r2  s     r  r.  zLocalTypeMap.__init__r  s    r  dict[Expression, Type]c                H    i }| j         j                            |           |S r,  )r2  
_type_mapsappend)r-  temp_type_maps     r  	__enter__zLocalTypeMap.__enter__u  s&    02""=111r  exc_typeobjectexc_valexc_tbLiteral[False]c                B    | j         j                                         dS NF)r2  r7  pop)r-  r;  r=  r>  s       r  __exit__zLocalTypeMap.__exit__z  s    !!!ur  N)r2  r3  r)  r*  )r)  r5  )r;  r<  r=  r<  r>  r<  r)  r?  )r  r  r  __doc__r.  r:  rC  r  r  r  r1  r1  k  sZ               
     r  r1  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<   dHd?ZedId@            ZedJdB            ZdKdCZdLdHZdMdNdKZ	 dOdIdIddLdPdQZdQdTZdRdWZdSdXZdTd\ZdUd`ZdVdbZ	 dOd(d(dcdWdkZdXdnZdXdoZedYdr            ZdZdwZ dXdx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`dadZ*dbdZ+edcd            Z,	 dddedZ-dfdZ.dgdZ/dhdZ0didZ1dOdjdZ2dkdZ3dkdZ4dldZ5dmdZ6dndZ7dodZ8dpdZ9dqdZ:drdZ;dsdZ<dsdZ=dtdZ>dudZ?	 dOdvdZ@dwdZAdxdZBdydZCdzdÄZDd{dńZEd|d̄ZFd}d̈́ZGd~dτZHddЄZId~dфZJddԄZKd~dՄZLddքZMddلZNd~dڄZOd~dۄZPd~d܄ZQdd݄ZRddZSddZTddZUddZVddZWddZXddZYddZZddZ[ddZ\ddZ]	 dMddZ^ddhZ_ded<   ddZ`dd ZaddZbddZcddd(d	ddZdddZeddZfddZgddZhedd            ZiddZjddZkddZlddZm	 dMddZn	 dOdd#Zo	 	 	 ddd&Zpdd)Zqdd*Zr	 dMdd,Zsdd-Ztdd3Zudd5Zv	 dMdd6Zw	 dOdd8Zxdd9Zydd;Zzdd<Z{dd?Z|dd@Z}ddAZ~ddBZddCZddIZej        dJdKfd(d(d(dLddSZddUZddWZdd\Zdd^Zdd`ZddaZddcZddeZddgZddkZddlZddnZddpZddrZddtZddvZddddy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͐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΄ZdIdϜddфZdI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Ze	 	 dd(d(d(ddd            Ze	 	 dd(d(ddd            Z	 	 dd(d(d(dddZ̐ddZedc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dOddZd(dddZ	 dd(dddZdd Zdd!ZdId"d	d$Zd
d&Ze	 dOdId'dd-            ZedId'dd.            Z	 dOdId'dd/Zdd0Z	 dMdd2Zdd4Zdd5Zdd6Zdd8Zdd9Zdd:ZdOdd<Zdd=Zdd>Zdd?ZddAZddCZddEZddGZd(S (  r3  zMypy type checker.

    Type check mypy source files that have been semantically analyzed.

    You must create a separate instance for each source file.
    Fr2   errorsrA   msgzlist[dict[Expression, Type]]r7  r   binder mypy.checkexpr.ExpressionChecker_expr_checkerr'   pattern_checkerr   tscoper   scope
list[Type]return_typesz
list[bool]dynamic_funcszlist[PartialTypeScope]partial_typeszset[Var]partial_reportedz	list[str]widened_varszlist[tuple[NameExpr, Type]]_globals_widened_in_funcr   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                F   || _         || _        || _        || _        || _        t          ||          | _        || _        t                      | _	        t          |          | _        t          |          | _        | j        | _        |j        | _        t#                      | _        g | _        g | _        g | _        t#                      | _        i | _        g | _        g | _        g | _        i g| _        t#                      | _        d| _        d| _        |j        | _        |                     |          | _!        d| _"        d| _#        tI          |           | _%        | j        j&        p*| j        | j        j         j'        v p| j        j(        o| j!        | _)        d| _*        d| _+        g | _,        d| _-        d| _.        t^          j0        1                    | | j        | j        |          | _2        tg          | | j        | j        |          | _4        d| _5        d| _6        d| _7        dS )zSConstruct a type checker.

        Use errors to report type check errors.
        r   FNT)8rF  rW  rY  rd  re  rA   rG  r_  r   rL  r   rM  r   rH  globals_bindernamesrU  setglobals_unreachablerO  rP  rQ  rR  r^  rX  rS  rT  r7  r]  pass_numcurrent_node_deferredis_stubis_typeshed_fileis_typeshed_stubrZ  allow_constructor_cacher1  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ExpressionCheckerrJ  r'   rK  ra  rc  assignment_expression_effect)r-  rF  rW  rY  rd  re  r_  rg  s           r  r.  zTypeChecker.__init__  s    		!&'22gg!$''
+G44"kz-0UU  #! (*%$55%*"| $ 5 5g > >(,%'+$*400 L& AyDHO99A%?$*? 	!
 '+# #
 8:  ',#
 $)  "^==$(DK)B
 
  .dDHdk7SS$(!
 -.)))r  c                    | j         S r,  )rJ  r-  s    r  expr_checkerzTypeChecker.expr_checker-      !!r  list[Type | None]c                    | j         j        S r,  )rJ  type_contextr  s    r  r  zTypeChecker.type_context1  s    !..r  c                   | j                                          | j                                         t          | j                  | _        g | j        dd<   | j        d                                          | j                                         g | _	        g | _
        d| _        t          | j                  | _        | 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   )rR  clearr]  r   rY  rH  r7  r  resetrX  rQ  rZ  r   rd  rM  rm  r  s    r  r  zTypeChecker.reset5  s     	##%%%   +DL99   """!!! (,%!$),,
 &&(((((r  blocklist[Statement]afterr   c                    |d         x}j         p|j        }| j                            t	          |j        |dz                        dS )zKMarks all statements in block after a given one (inclusive) as unreachable.r  N)end_linelinerm  updaterange)r-  r  r  last	last_lines        r  mark_unreachablezTypeChecker.mark_unreachableH  sG    "2Y&T0=DI	 ''ej)a-(H(HIIIIIr  Try  c           
     d   || _         t          j        | j        j                  5  t          j        |           5  | j                            | j	        | j
        j        | j        | j                   | j                            | j
        j                  5  |                                 5  | j                                        5  d}| j
        j        D ]}| j                                        rm|s#|                     | j
        j        |           d}|                                 s nH|                     |          s| j                            |            n|                     |           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                            d          }||j        |j        }|J |                     d|                     d          g          }tA          |j        |          sStC          ||j        | j        	          \  }}| "                    tF          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().
        rM  rY  Fr  TN__all__typing.Sequencebuiltins.strrY  )&ry  r   strict_optional_setrY  strict_optionalr!   rl  rF  set_filere  rd  fullnamerL  module_scopeenter_partial_typesrH  top_frame_contextdefsis_unreachabler   should_report_unreachable_issuesis_noop_for_reachabilityrG  unreachable_statementacceptro  rU  gettyper  named_generic_type
named_typer   rF   failr   ALL_MUST_BE_SEQ_STRformat)	r-  ry  marked_unreachabledall_all_nodeseq_str	str_seq_sall_ss	            r  check_first_passzTypeChecker.check_first_passM  s    '=#&t|'CDD #	 #	mFWX\F]F] #	 #	K  	49-T[$, !    ))$)*<==  --// + +1N1N1P1P + +).&!Y^ + +;5577 
+#5 : $ 5 5dinA 5 N N N59 2#'#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  ;              	#	 #	 #	 #	 #	 #	 #	 #	 #	 #	 #	 #	 #	 #	 #	 #	 #	 #	 #	 #	 #	 #	 #	 #	 #	 #	 #	 #	 #	 #	 #	 #	 #	s   J%AJI6,F	B-E?3F	?FF	FF	
I6FI6FCI6*J6I::J=I:>JJ%J	J%J	J%%J),J))rs  ry  	impl_onlytodo7Sequence[DeferredNode | FineGrainedDeferredNode] | Noners  r  c          
        || _         || _        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.
        NFr  r  )r  T)rs  ry  r   r  rY  r  r!   rl  rX  rF  r  re  rd  r  rL  r  rn  addr   enter_contextclass_scoperM  
push_classcheck_partial)	r-  r  rs  ry  r  doner  r  stacks	            r  check_second_passzTypeChecker.check_second_pass}  s    (?$&<#&t|'CDD 	 	mFWX\F]F] 	 	  3 	 	 	 	 	 	 	 	 	 	 	 	 	 	 K  	49-T[$, !    ))$)*<== F F" 3.DD#2222&(#LOEE-1 F F)D/t||  HHTNNN" F* X!//0G0G0X0XYYY!//
0E0Eo0V0VWWW**49*EEE	F F F F F F F F F F F F F F FFF F F F F F F F F F F F F F F( 5	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	s   G=G%G=%AG% A(G(A4F(G(F,,G/F,0G5G%GG%G	G%G=%G)	)G=,G)	-G==HHr  .DeferredNodeType | FineGrainedDeferredNodeTypec                   g | _         t          |t                    r|                     |           d S | j                                        5  |s#|                     |           	 d d d            d S |j        | j        v r	 d d d            d S t          |t          t          f          r|                     |           nt          |j                  D ]\  }}|j         p|dk    }t          |t                    sJ | j                            |j                  5  |                     |j        |j        |           d d d            n# 1 swxY w Y   |j        L|                     |j                  5  |                     |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 )Nr   nameallow_empty)rS  
isinstancer~   check_top_levelrH  r  r  r  rm  ro   rf   check_partial_impl	enumerateitemsis_propertyrL  function_scopefunccheck_func_itemr  implenter_overload_impl)r-  r  r  iitemr  s         r  r  zTypeChecker.check_partial  s    dH%% 	?  &&&&&..00 ? ?  KK%%%	? ? ? ? ? ? ? ?
 9 888? ? ? ? ? ? ? ? dWi$899 ?++D1111 $-TZ#8#8 	 	4*.*:&:&Ca!e)$	::::: "[77	BB   00 $		{ 1                  y,!55di@@ ? ? 33DI>>>? ? ? ? ? ? ? ? ? ? ? ? ? ? ?1? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?sg   F93F9BF9#EF9EF9E%F9:F!F9!F%	%F9(F%	)F99F= F=r  FuncDef | Decoratorc                Z   t          |t                    r|                     |           dS t          d |j        D                       rdS | j                            |j                  5  |                     |j        |j        j	                   ddd           dS # 1 swxY w Y   dS )zECheck only the body (not the signature) of a non-overloaded function.c              3  6   K   | ]}t          |d           V  dS ztyping.no_type_checkNr   .0r  s     r  	<genexpr>z1TypeChecker.check_partial_impl.<locals>.<genexpr>  s.      ZZQ%a)?@@ZZZZZZr  Nr  )
r  ro   visit_func_def_implany
decoratorsrL  r  r  r  r  r-  r  s     r  r  zTypeChecker.check_partial_impl  s   dG$$ 	E$$T*****ZZ$/ZZZZZ ++DI66 E E$$TYTY^$DDDE E E E E E E E E E E E E E E E E Es   ,'B  B$'B$c                   |                                  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.N)r  rH  r  r  r  ro  )r-  r  r  s      r  r  zTypeChecker.check_top_level  s   %%'' 	# 	#..00 # # # #AHHTNNNN## # # # # # # # # # # # # # #	# 	# 	# 	# 	# 	# 	# 	# 	# 	# 	# 	# 	# 	# 	#
 ------s4   A3 AA3A 	 A3#A 	$A33A7:A7r  enclosing_classr  c                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)rX  r8  r  )r-  r  r  s      r  
defer_nodezTypeChecker.defer_node  s+     	""<o#F#FGGGGGr  r  contextrd   c                *   | j                                         }| j        | j        k     rNt	          |t
                    r9| j                             |          }|                     ||           d| _        d S | j	        
                    ||           d S NT)rM  top_level_functionrn  	last_passr  ro   r  r  ro  rG  cannot_determine_type)r-  r  r  r  r  s        r  handle_cannot_determine_typez(TypeChecker.handle_cannot_determine_type  s    z,,..=4>))jw.G.G)
 #j88>>OOOD/222 *.D&&&H**499999r  stmtc                    	 |                     |            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   rF  filer  rY  )r-  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 r,  lenr$  r  ptss     r  r  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 r,  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)rH  frame_contextsumrQ  r  rS  r4   r5   rG  rF  r  last_pop_changedRuntimeErroriteration_dependent_errorsfind_isinstance_checkpush_type_map)r-  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                             |          5  |                     |           d d d            d S # 1 swxY w Y   d S r,  )rL  r  _visit_overloaded_func_def)r-  r  s     r  visit_overloaded_func_defz%TypeChecker.visit_overloaded_func_defB  s    
 [''-- 	2 	2++D111	2 	2 	2 	2 	2 	2 	2 	2 	2 	2 	2 	2 	2 	2 	2 	2 	2 	2s   >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 ]c\  }}t          |t                    sJ |j        rt          |j         d         t                    sJ |j         d         j	        j
        }	|	r|dk    s|	s|dk    r| j        s|                     |j                   | j        s|j        j        r| j         !                    |j                  5  | "                                5  | #                    |j        |j        j$        d	           d d d            n# 1 swxY w Y   d d d            n# 1 swxY w Y   n|                     |d
           |j        j%        tL          tN          fv r|dz  }e|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| /                    |          }|j0        r0|s.|,|j.        j1        s | j2        3                    |j$        |           | 4                    |||j)                   | 5                    |           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  )r  )6r  r  r  r   MULTIPLE_OVERLOADS_REQUIREDr  r  rf   visit_decoratorvaris_settable_propertyvisit_decorator_innersetterr  r   r   special_formr   rL   r  r   r  extract_callable_typer"  setter_typer   
definitionr  rx  check_default_paramsry  def_or_infer_varsrL  r  set_recurse_into_functionsr  r  abstract_statusrT   rR   INCONSISTENT_ABSTRACT_OVERLOADr  r  r  check_overlapping_overloadsr8  infocheck_method_overrideis_explicit_overridefallback_to_anyrG  no_overridable_method!check_explicit_override_decoratorcheck_inplace_operator_method)r-  r  num_abstractr/  any_typefallback_setter_typegetter_typer  fdefsettable
item_typesr  	item_typevar_typefound_method_base_classess                  r  r  z&TypeChecker._visit_overloaded_func_defJ  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 cQQUU  4 =11$)<<<2 cdi6Q c K66tyAAc c ;;==c c !00]a0bbb	c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c **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 	5sH   .M(L7+M7L;;M>L;?MM	M	+PPPr   Iterator[None]c              #     K   | j                             |           	 d V  | j                                         |k    sJ d S # | j                                         |k    sJ w xY wr,  )r{  r8  rB  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_typer2  )r   r  r   r   upper_boundr   r  analyze_type_type_calleer  r   r   r%   r   r   r  r.  r8  r   join_type_listrG  not_callabler   r   )
r-  rJ  rL  
outer_type
inner_call
union_typer  r  callable_itemjoined_types
             r  r.  z!TypeChecker.extract_callable_type  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 r,  r   lrs     r  <lambda>z9TypeChecker.check_overlapping_overloads.<locals>.<lambda>F  s    *Q2B2B r  )	is_compatr   is_compat_return)ignore_returnreturn_constraint_direction)r"  rf  r   rh  )%rx  r  r  ro   r  rf   r)  r.  r7  r  r  r  are_argument_counts_overlappingoverload_can_never_matchrG  %overloaded_signature_will_never_matchr  rM  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)r-  r  	impl_typerJ  is_descriptor_getr  r  sig1jitem2sig2current_classro  	flip_noter  s                  r  r6  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rP  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   r  r  )r-  rP  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   )r-  rP  r?  agts       r  is_async_generator_return_typez*TypeChecker.is_async_generator_return_type  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  r-  s     r  
<listcomp>z8TypeChecker.get_generator_yield_type.<locals>.<listcomp>  s)    aaat..t\BBaaar  r  r   )r   r  r   r   from_another_anyr   r   r  r  r  
from_errorr   r  r  r-  args)r-  r  r  r%  s   ` ` r  r  z$TypeChecker.get_generator_yield_type  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).r  c                <    g | ]}                     |          S r  )get_generator_receive_typer  s     r  r  z:TypeChecker.get_generator_receive_type.<locals>.<listcomp>  s)    ccc00|DDcccr  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  s   ` `r  r  z&TypeChecker.get_generator_receive_type  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 )Nr  z-Should only be called on coroutine functions.r  )r   r  r   r   r  r   r  )r-  r  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).r  c                <    g | ]}                     |          S r  )get_generator_return_typer  s     r  r  z9TypeChecker.get_generator_return_type.<locals>.<listcomp>  s)    bbb//lCCbbbr  r  r  r   r  r	  r  )r   r  r   r   r  r   r   r  r  r  r   r  r  r  r  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  ro   c                    | j         s|                     |           |j        r+|                     |          }|                     ||           | j        s	|j        sd S |                     |           d S r,  )rx  r1  original_defr   check_func_def_overridery  r2  r  )r-  r  new_types      r  visit_func_defzTypeChecker.visit_func_def*  s    ( 	,%%d+++ 	9))$//H((x888* 	43I 	F  &&&&&r  c                   | j                             |          5  |                                 5  |                     ||j                   | j        sU|j        rN|j        s2|j        s+| 	                    |          }| 
                    ||           |                     |           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 )Nr  )rL  r  r3  r  r  rx  r7  is_overloadis_decoratedr8  r<  r=  )r-  r  rG  s      r  r  zTypeChecker.visit_func_def_impl6  sj   [''-- 	= 	=t/N/N/P/P 	= 	=  DI 666, 
=9 	=+ `D4E `
 594N4Nt4T4T1>>tE^___66t<<<	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	=s5   CA9B5)C5B9	9C<B9	=CCCrp   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 supportedrC  __post_init__)rP  r8  
is_dynamicro  r  r   ru  r  r  r  r   !enter_attribute_inference_contextcheck_func_defr  rB  check__exit__return_typedataclasses_pluginis_processed_dataclassr7  check_post_init)r-  r  r  r  r  enclosing_node_deferredrP  s          r  r  zTypeChecker.check_func_itemE  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                    r{|j        K|j         }t          |t                    r|j
        }n|}|                     |          }|||_        ||= d S d S d|_        |                     t          j        |           d S |j        sbt!          |j                  }|j         |_        | j                            |||           |                     |||t          j        dd           d S d S )NTzredefinition with typezoriginal type)r  r  ro   r   r   rG  %incompatible_conditional_function_defr  r   rf   r)  find_partial_typesis_invalid_redefinitionr  r   INCOMPATIBLE_REDEFINITIONr   r  r  rH  assign_typecheck_subtype)	r-  r  r  old_type	orig_typeorig_defr)  rQ  	name_exprs	            r  r  z#TypeChecker.check_func_def_overrideh  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
 48D0II.H$OOOOO1 $TY//	!%!2	''	8YGGG""$>,#    	 r  c              #  <   K   | j         }i | _         d V  || _         d S r,  )rZ  )r-  	old_typess     r  r  z-TypeChecker.enter_attribute_inference_context  s-      1	(*%


(1%%%r  r   c                   |                      |j                   |                     ||          }|}|D ]\  }}| j        }t	          | j                  | _        | j                                        5  |j                            |           | j	        s| 
                    |||||           | j                            |j                   | j                            |          5  | j                                        }	ddd           n# 1 swxY w Y   |j        rd}
|		|j        rd}
|
t%          |j                  k     rt)          |j        |j        |
                   sj|                     t,          j                            t3          |j        | j                  t3          |j        |
         | j                            |           d}t5          |t6                    r|j        s|                     ||          }t=          t%          |j                            D ]}|j        |         }t5          |t>                    rd|j         tB          k    rT|j"        dvrKtG          |j"                  s7|dk    s|s/|}|j$        dk     r|}|                     t,          j%        |           tM          |||| j'                   	 ddd           n# 1 swxY w Y   | j                                        5  d}|j(        D ]}|j)        *                                D ]p\  }}tW          |          }|Z| ,                    ||j$                  s?|| j        -                                }||j)        |<   |j.        |         | j        j.        |<   q| j        j/        r`| j0        sY|j1        D ]Q}|j2        }|j3        Ati          |j"                  }||_5        | j        6                    ||j3        |j3                   R| j                            |          5  to          |          st%          |          dk    r| j        8                                 | j	        r(| j        j9        st5          |t6                    r|j:        r| ;                    |j<                   ddd           n# 1 swxY w Y   | j        =                                }|| j        >                    dd           ddd           n# 1 swxY w Y   |st          |j<                  }|j@        st          | j        d	         d
          r'| B                    | j        d	         |jC                  }n5|jC        r!| D                    | j        d	                   }n| j        d	         }t          |          }|p| j        jF        }| p0| o-t5          |t6                    o|jG        t          k     o| j0         }| j	        sw|jI        t          ur/|j"        |jI        jK        vsV|jI        jK        |j"                 jL        s:t5          |t6                    r|jM        s|rt)          t                      |          rd}|rr| jO        sj|o?|jI        t          uo1|jI        jP        duo#|jI        jP        j3        Q                    d          }| j        jR        rt5          |t          t          f          st5          |t                    rt,          jU        }nt,          jV        }|r t          |jX        t          jZ                  }|                     ||           |r | [                    t,          j\        |           nwt,          j]        }|r t          |jX        t          jZ                  }| ^                    dt                      d|||          s"|r | [                    t,          j\        |           | j        _                                 | j`        rO| j`        D ]@\  }}| ja        b                    ||           t          |          }||| ja        j.        |<   Ag | _`        || _        dS )z!Type check a function definition.)r  original_typNr   r  F)r.  __new__r  r  Tr  r  abc.ABCMetacodezimplicitly returnsexpected)subtype_labelsubtypesupertype_label	supertyper  rG  )dcheck_typevar_defaultsrr  expand_typevarsrH  r   rY  r  expandedr8  rx  check_funcdef_itemrO  r%  rM  push_functionactive_self_typetype_ishas_self_or_cls_argumentr  r"  r   r  r   NARROWED_TYPE_NOT_SUBTYPEr  rD   r  ro   r  require_correct_self_argumentr  r   variancerO   r  
is_privater  &FUNCTION_PARAMETER_CANNOT_BE_COVARIANTr  r  framestypesr  r9   !is_var_redefined_in_outer_context
push_framedeclarationsallow_redefinitionrp  	argumentsvariabler  r   r  r  _is_empty_generator_functionsuppress_unreachable_warningspreserve_astsr2  r  r  r  	pop_framer   is_generatorr   r  r  r  r   allow_empty_bodiesr4  rX   r7  rP   rk  plugin_generatedis_mypy_onlyr   ro  metaclass_typehas_basewarn_no_returnr   r   INVALID_IMPLICIT_RETURNMISSING_RETURN_STATEMENTr?   valuecodes
EMPTY_BODYnoteEMPTY_BODY_ABSTRACTINCOMPATIBLE_RETURN_VALUE_TYPEr  rB  rT  rj  putr;   ) r-  r  rP  r  r  r  r  r  
old_binderref_type	arg_index
found_selfr  arg_typerL  	new_frameframekeynarrowed_typekey_varargvnunreachablebody_is_trivialr  
show_errormay_be_abstractrG  lvaluewidened_typelits                                    r  r  zTypeChecker.check_func_def  s	   
 	##CM222''c22! T	% T	%ID#J/==DK..00 5O 5O$$T***
 0 c++D#t$Ua+bbb !((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!OK5O 5O 5O 5O 5O 5O 5O 5O 5O 5O 5O 5O 5O 5O 5Op ..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 <2 G4< 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  UR"1$)"<"<$ 	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. U&2395CS&T&T&T IIc4000. V $		*:*NPT U U U.M* Q".syu?O"P"P"PC !% 2 2.B(0

0:*5(,$' !3 ! !R !0R !II&6&JDQQQ!!### , 3,0,I M M(FL'++FLAAA&v..C@L+8=02-$DKKiT	% T	%sp   4A5K)DKDKDF.KK	K	6DS1BR$S1$R((S1+R(,9S11S5	8S5	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)r.  __init_subclass__r  r  zReturn typez	Argument r  z to ""r  )__getattr____getattribute____setattr__),r  ro   r7  r  r   r%  r   r   rP  r  r   MUST_HAVE_NONE_RETURN_TYPEr  check___new___signaturecheck_for_missing_annotationsrY  disallow_any_unimportedr  r   r   rG  unimported_type_becomes_anyr  r"  r   rr  is_reverse_op_methodr{  check_reverse_op_methodcheck_getattr_methodcheck_setattr_methodr   r  rN   #RETURN_TYPE_CANNOT_BE_CONTRAVARIANTcheck_unbound_return_typevarvaluesr  is_async_generatorr  'INVALID_RETURN_TYPE_FOR_ASYNC_GENERATORr  r  !INVALID_RETURN_TYPE_FOR_GENERATOR)r-  r  rP  r  r  r  rB  r%  idxr  prefixs              r  r  zTypeChecker.check_funcdef_itemy  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>   clsr-  )(r   r  r   rY  check_untyped_defsr  rP  r  r'  r"  rM  r  r  r  r#  r   rM   	ARG_STAR2r  rx  is_classr  r~  r  r   make_normalizedr   r*   r   r   r   r  is_protocolr  r$  r   ERASED_SELF_TYPE_NOT_SUPERTYPEr  str_with_optionsMISSING_OR_INVALID_SELF_TYPE)r-  r  r  r  r  erasedrG  s          r  r  z)TypeChecker.require_correct_self_argument  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                                         }|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.
        TF)rL  outer_functionsr  ro   find_last_var_assignment_liner  )r-  r  r1  outersouters        r  r  z-TypeChecker.is_var_redefined_in_outer_context  sk     ,,.. 	 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   rU  r   r  r  r  rD   rY  )r-  rP  arg_type_visitorargtyperU  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  bool | Nonec           
        |t          |j                  }| j                            |                                           |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|           | j                                         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  rG  lvalue_namervalue_namenotes)r   r  rP  r8  r  r  initializerr  ri   r  r  
startswithrY  implicit_optionalr   r  check_simple_assignmentr  r?   r  
ASSIGNMENTrB  )r-  r  r  paramr  rG  rF  s          r  r1  z TypeChecker.check_default_params&  s   "-di88O 	!!$//"3"3444^  	  	E ( :e.?#N#N >&D-C/00 -5$rss)555,T,,,,L2u0(;; %./AA], ((#!) 5+;<<<'% )     	     r  method_namec                    |t           j        v S r,  )r   reverse_op_methodsr-  rM  s     r  is_forward_op_methodz TypeChecker.is_forward_op_methodO  s    i:::r  c                    |t           j        v S r,  )r   reverse_op_method_setrP  s     r  r  z TypeChecker.is_reverse_op_methodR  s    i===r  rB  c                d   | j          p| j        j        }|sd S t          |j        t
                    o0t          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
                    r>t/          |j        j                  }t1          |          r!|                     t          j        |           n|j        rIt1          |                     ||j                            r |                     t          j        |           n^|j        rWt          |t6                    rBt1          |                     |                    r |                     t          j        |           t          d |j        j        D                       r&|                     t          j        |           d S d S d S d S )	Nc              3  6   K   | ]}t          |           V  d S r,  r   r  ts     r  r  z<TypeChecker.check_for_missing_annotations.<locals>.<genexpr>Z  sG       N
 N
*+"1%%%N
 N
 N
 N
 N
 N
r  r  r   r-  r'  z1Use "-> None" if function does not return a valuer  c              3  4   K   | ]}t          |          V  d S r,  rV  rW  s     r  r  z<TypeChecker.check_for_missing_annotations.<locals>.<genexpr>z  s+      JJ)!,,JJJJJJr  )rr  rY  warn_incomplete_stubr  r  r   r  r"  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   r  PARAM_TYPE_EXPECTED)r-  rB  show_untypedhas_explicit_annotationcheck_incomplete_defsr%  s         r  r  z)TypeChecker.check_for_missing_annotationsU  s   00UDL4U 	F",TY"E"E #
# 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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  r7  r   is_metaclassr  r%  	type_typer   INVALID_NEW_TYPEr  r   r   r   r   r   r   r  NON_INSTANCE_NEW_TYPEr  rD   rY  )r-  rB  rP  	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__r8  r   r  r  r"  r#  r$  r  rP  UnionType | Instancer  rf  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 r,  )r  r   r   r  has_readable_member)r  xrv  r  s     r  r  zSTypeChecker.check_reverse_op_method.<locals>.has_readable_member.<locals>.<genexpr>  s~          Ay))J.A.A!T.J.J Rq(++P0J0J40P0P     r  )r  r   r  rv  allr   relevant_items)rP  r  rv  s    `r  rv  z@TypeChecker.check_reverse_op_method.<locals>.has_readable_member  s    #x(( :x33D999      *#*<*<*>*>??     r  r  )rP  rs  r  rf  r)  r'  )(r7  r   r   r   r-  r   rL   r  r   rG  invalid_signaturer   r%  r  r   r  r  r#  rM   ru  r"  r$  r  r   normal_from_reverse_opr   rU  r   r   r   r   r   r&  r   r  r  r   r  analyze_external_member_accesscheck_overlapping_op_methods)r-  r  rm  rn  r  method_typer%  forward_nameforward_instr  opt_metaforward_baseforward_typerv  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   r  r  r  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_oprG  "operator_method_signatures_overlapr   r  r   forward_operator_not_callable)
r-  rm  rn  r  r  r  r  r  forward_itemr  s
             r  r}  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  r  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  rr  )partial_only)r  r"  r  r   r   ru  r   rL   r   r   rM  rn  r  ro  rp  )r-  r  r  rm  forward_base_erasedforward_tweakedreverse_tweakedreverse_base_erasedfirstsecondr~  ro  s               r  r  z$TypeChecker.is_unsafe_overlapping_op9  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  rn   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   r7  rv  r  r   r  r|  r  r   is_more_general_arg_prefixrG  signatures_incompatible)	r-  r  methodrP  r'  other_methodinstancetyp2r  s	            r  r=  z)TypeChecker.check_inplace_operator_methodm  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  rM  r  r  r   MODULE_LEVEL_GETATTRIBUTEr   r  r   rL   r   r   r-  rn  r   rG  $invalid_signature_for_special_method)r-  rP  r  r  r~  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  )rM  rn  r   r   r   r-  r  r   rL   r   r   rG  r  )r-  rP  r  r~  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  rK  )r-  rP  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 r,  )is_string_literalr  r  s     r  r  z/TypeChecker.check_match_args.<locals>.<genexpr>  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  )rM  rn  r   r  r   rx  r  rG  r  r  LITERAL_REQ)r-  r)  rP  r  s       r  check_match_argszTypeChecker.check_match_args  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  r  tvars     r  r  z/TypeChecker.expand_typevars.<locals>.<listcomp>  s     HHH5tw.HHHr  )listrr  r7  r  ro  r  r   r  r8  rY  mypycinspections	itertoolsproductdictexpand_funcr7   )	r-  r  rP  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 | OverloadedFuncDefrG  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r.  r  r   )	r7  r  r  r  r9  r  rG  #explicit_override_decorator_missingr  )r-  r  rG  r  r  r  s         r  r<  z-TypeChecker.check_explicit_override_decorator  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)r.  r  r  r  __replace__dataclass_tagr  )rx  r  rY  r(  r  r7  metadatar  mro*check_method_or_accessor_override_for_baser8  )r-  r  check_override_compatibilityrG  baser  s         r  r8  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  c                   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  rk  r  r   r  r  rG  cant_override_finalis_final$check_if_final_var_override_writable(check_method_override_for_base_with_namer   r  )r-  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  r7  r   rG  incompatible_setter_overrider,  )r-  r  r  rP  r  rT  s         r  check_setter_type_overridez&TypeChecker.check_setter_type_overrideN	  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_typrP  s     r  r  zGTypeChecker.check_method_override_for_base_with_name.<locals>.<genexpr>	  sF       :
 :
 sH4@@@:
 :
 :
 :
 :
 :
r  originaloverride)5rk  r  r  rf   r  ro   r   r*  	is_staticr  r  r7  r  rn  r  rM  r  r  r  r   r   r  r   r   r*  is_custom_settable_propertyr  r  r  r   rG  r  r  OVERRIDEr   check_overridemodule_namerd  r  MUTABLE_OVERRIDErY  enabled_error_codesis_writable_attributer   rF   r   'COVARIANT_OVERRIDE_OF_MUTABLE_ATTRIBUTEwith_additional_msgr   r  r  r   %signature_incompatible_with_supertype)r-  r  r  r  r  r  override_class_or_staticr  original_nodesupertype_readyrT  	top_levelalways_allow_covariantoriginal_class_or_staticrB  okbase_stroverride_strrG  rP  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  itr-  s     r  r  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  r  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#  rL   r*   r"  rr  r   r  r   )r-  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  NrX  r   r)  c                &    t          |           S )N)ids_to_erase)r*   )rX  override_idss    r  erase_overridez2TypeChecker.check_override.<locals>.erase_overridex
  s    )!,GGGGr  r  r  )origin_contextr  zHOverloaded operator methods can't have wider argument types in overridesr  )rX  r   r)  r   )0r   r  r   rQ  r  r   r   
type_guardr  r  unpack_kwargsrs  r  r"  min_argstype_var_idsr   ro   r7  r  r  zipr#  is_positionalis_namedr$  indexr  r  r  r  rf   r  r  boundr  rG  $argument_incompatible_with_supertyper%  'return_type_incompatible_with_supertyper  r8  sorted.overload_signature_incompatible_with_supertyper  r  r  r  ) r-  r  r  r  r  r  r  r  r  r  op_method_wider_noteoriginal_domainoverride_domainemitted_msgoffset_arguments	type_namer0  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>
  sR       
 
 sx**Tsx/@DT/T
 
 
 
 
 
r  )
r  r  r   r   r%  has_bool_itemr   rx  rG  incorrect__exit__return)r-  r  r%  rf  s       r  r  z$TypeChecker.check__exit__return_type
  s     y 	
49l C C 	F"49#566X&& 	F'-- 	F 
 

 
 
 
 
 	3 H,,T22222		3 	3r  rb   c           
     	   |j         }|j        dd         D ]A}|j        r8|                     t          j                            |j                  |           Bt          |j	                  s8|                     t          j
                            |j                  |           | j                            |j                   5  |                     d          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        rtA          |j                   }tC          |j                  D ]}tE          |tF                    rtE          |j$        tJ                    r2| j&                            |          }| '                    ||          }d}	tE          |tP                    r	|j)        pd}	| j*        }
d| _*        | j&        +                    ||gtX          j-        g||	          \  }}|
| _*        ddd           n# 1 swxY w Y   ddd           n# 1 swxY w Y   |j.        j/        r|j.        j0        |j	        D ]}tc          |j2        |j3        j.        j/                  D ]z\  }}tE          |th                    r`|j5        tl          k    rPtE          |th                    r;|j5        |j5        k    r+|                     d|j         d|tn          j8        	           {|j.        j/        r| 9                    |j.        j/                   |j:        r!|j.        j/        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  )>r7  r  r  r  r   CANNOT_INHERIT_FROM_FINALr  r  r   basesINCOMPATIBLE_DISJOINT_BASESrL  r  r  rH  r   rY  r  rM  r  r  r  rx  typeddict_type
tuple_typeis_enumcheck_init_subclasshas_incompatible_baseclasscheck_multiple_inheritancecheck_metaclass_compatibilitycheck_final_deletabler  r   reversedr  ra   analyzedr   r  	temp_noder   r  r}  
check_callr   rL   r  ro  	type_argsr  r  r  r   r  rS   r  r-   r  r,  check_protocol_variance
check_enumr   )r-  r  rP  r  r  sig	decoratordectempr  old_allow_abstract_callr  	base_inst	base_tvarbase_decl_tvars                  r  visit_class_defzTypeChecker.visit_class_def
  s   iGABBK 	^ 	^D} ^		*DKKDIVVX\]]],SY77 	[II&BII#(SSUYZZZ[$$TY// (	G (	G1I1ISW1I1X1X (	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77!)$/!:!: 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,,Q(	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V 8 	#("4"< Y  	14NIN$7$A2 2  -I~ #9k::%.);;&~{CC <*3y7III		;IN ; ; ;$(!&	 "    8 	<''(:;;;? 	/sx1 	/((.... 	"493D 	"OOD!!!di(((((s   L$:L E35E	E3E  E3#E $E3'L3E77L:E7;FLL$L	L$L	L$$L(+L(c                    |j         D ]i}|j                            |          }|rKt          |j        t
                    r1|j        j        r%|                     t          j	        |j                   jd S r,  )
deletable_attributesrk  r  r  r  r   r  r  r   CANNOT_MAKE_DELETABLE_FINAL)r-  rP  attrr  s       r  r:  z!TypeChecker.check_final_deletable5  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)r7  r  r  r  r  rk  r   r  r  r}   r  keywordsr  keysr  rB  rK   r  ra   r  r  r  r  r  )
r-  r  r  r  calleer  r$  r"  r#  	call_exprs
             r  r6  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 r,  )r   rC  )r  r  tvs     r  r  z5TypeChecker.check_typevar_defaults.<locals>.<genexpr>s  s/      $\$\\"*e%D%D$\$\$\$\$\$\r  z3TypeVar default must be one of the constraint types)	r  r   has_defaultr   rC  rU  r  r  r  )r-  r  r\  s     @r  r  z"TypeChecker.check_typevar_defaultsm  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)r7  r5  r  r   rk  r  r  r   has_explicit_valuer  r   $ENUM_MEMBERS_ATTR_WILL_BE_OVERRIDDENr  check_final_enumrp  rd  enum_membersr  check_enum_basescheck_enum_new)r-  r  r!  r  s       r  rA  zTypeChecker.check_enumv  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  )re  r  r  )r-  r  r  s      r  rd  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  rn   rf   r   r  r  r  r  r   r  r   rp  rb  )r-  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  )r7  r1  r  r5  r  r.  rY  )r-  r  	enum_baser  s       r  rf  zTypeChecker.check_enum_bases  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 )Nr7  r   r)  r'  c                x    |                      d          }t          |o|j        o|j        j        dk              S )Nr  zbuiltins.object.__new__)r  r'  r  r  )r7  
new_methods     r  has_new_methodz2TypeChecker.check_enum_new.<locals>.has_new_method  sG    ),,J JOJO,0II  r  Fc              3  >   K   | ]}|j          o
 |          V  d S r,  )r5  )r  brp  s     r  r  z-TypeChecker.check_enum_new.<locals>.<genexpr>  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)r7  r   r)  r'  )
r7  r1  r  r5  r  r  r  r  r.  rY  )r-  r  has_newr  	candidaterp  s        @r  rg  zTypeChecker.check_enum_new  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  r  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  rx  r  s      r  r  z7TypeChecker.check_protocol_variance.<locals>.<listcomp>  sI     % % %KO1aQ!VV!!!1D1D1F1F% % %r  T)ignore_declared_variance)rx  r?  r7  r   r  r  ro  rc  make_fake_typeinfor  r  r   r   rO   rN   rS   r  rG  bad_proto_variancer  )r-  r  r7  r  r  
dummy_infor  up_args	down_argsupdownr  rx  r  ry  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  rk  )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 r,  r  )r  r  r  r  s      r  r  z9TypeChecker.check_multiple_inheritance.<locals>.<genexpr>!  s7      YYDddjFXFXAt9FXFXFXFXYYr  )
r  r1  r  r  rk  rV  r  nextr  check_compatibility)r-  rP  r  	all_namesr  r  base2r  s          @r  r8  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  base1r  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
        )r.  r  r  N)r~  leftrightTr  z%Cannot override writeable attribute "z" in base "z#" with read-only property in base "r  r  )rk  r  r   r  r   is_type_objr   r  type_objectr  r  r   r  rf   r   rG  r  r  r  r  cannot_determine_type_in_baser   r  r  r  r   allow_incompatible_override#base_class_definitions_incompatible)r-  r  r  r  rL  r  r  
first_typer  second_typep_first_typep_second_typer  s                r  r  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 r,  )r  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  )rg  r,  is_named_tupler5  r3  r  r  r1  r  r  	METACLASSexplain_metaclass_conflictr  )r-  rP  explanations      r  r9  z)TypeChecker.check_metaclass_compatibility~  s    		 !	 {		
 !-F%# .
 .
=@Y.
 .
 .
 +
 +
% IIN_	     88::K B		+s	AAAAA &%%%B Br  rv   c                    |j         D ]<\  }}| j                            |          x}|                     |j        |           =|                     |           d S r,  )rk  rU  r  warn_deprecatedr  check_import)r-  r  r  r  r!  s        r  visit_import_fromzTypeChecker.visit_import_from  se    z 	5 	5GD!|''---:$$SXt444$r  rt   c                0    |                      |           d S r,  r  r-  r  s     r  visit_import_allzTypeChecker.visit_import_all      $r  rs   c                0    |                      |           d S r,  r  r  s     r  visit_importzTypeChecker.visit_import  r  r  ru   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)rG  rD  rE  )assignmentslvaluescheck_lvaluer   r   r-  r  rvaluer   r   INCOMPATIBLE_IMPORT_OFr  r  rJ  )r-  r  assignr	  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  rr  r^   c                    |j         r| j                                         d S d}|j        D ]}| j                                         r| j                                         |s|                     |j        |           d}|                                 s d S |                     |          s| j	        
                    |            d S |                     |           | j        j                                         d S )NFr  T)r  rH  r  r  rM  r  r  r  r  rG  r  r  r  
expr_cacher  )r-  rr  r  ss       r  visit_blockzTypeChecker.visit_block  s    	 K##%%%F" 	5 	5A{))++ 5:0022:CU:))!&):::)-&<<>> 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 r,  )in_checked_functionrY  warn_unreachablero  rH  !is_unreachable_warning_suppressedr  s    r  r  z,TypeChecker.should_report_unreachable_issues  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_typerR  NF)r  rZ   is_false_literalr)  r   is_literal_not_implementedr   rk   ra   r  rG  filter_errorsr   r  r   )r-  r  rP  s      r  r  z$TypeChecker.is_noop_for_reachability  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        s`|                     |j                  5  |                     |j        d         |j        |j        du            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        rMt9          |j                  s9| j                                         |                     t@          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_defrp  enter_final_contextis_final_defcheck_assignmentr  r  r  check_type_alias_rvaluerY  r  r   r  r   rG  r  r   r   r-  r   rr  r  has_typer  r  r=  lookup_typecheck_finalr  rM  rn  r  r   DEPENDENT_FINAL_IN_CLASS_BODYunanalyzed_typer   annotation_in_unchecked_function)r-  r  r  lvs       r  visit_assignment_stmtz!TypeChecker.visit_assignment_stmt  sx     	O4< 	O))!.99 O O%%aimQXqv~NNNO O O O O O O O O O O O O O O > 	,((+++ 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#   /A$$A(+A(9H$$H(	+H(	c                    | j                                         5  | j                            |j                  }d d d            n# 1 swxY w Y   |                     |j        d         |           d S Nr  )rG  r  r  r  r  
store_typer  )r-  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  rj   infer_lvalue_typec                2   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        |           |rt          |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          |                     nt          |t.                    rF|j+        ?| j
                            |j,                  }| -                    |||||	          \  }}}n$| j        j.        st_          |          rt          |t                    r|j+        t`          k    rt          |j        tb                    r|j        j        r|j        | j2        v rt          t7          |          tf                    so| j2        |j                 }d
}ti          | j(        j5                  D ]}|j6        |v r	|j7        } n|r+tU          |          }| %                    |j        ||           | 8                    |||||          \  }}d}t7          |          }t7          |          }t          |tr                    r|:                                r|;                                j<        s|;                                j=        rnt          |t|                    rYt          |j?        t                    r?|j?        j        j<        s|j?        j        j=        r| jA        B                    ||           dS |r|rt          |t2                    st          |t                    r|jC        s~| j(        D                    |||           t          |t                    rMt          |j        tb                    r3|j        jE        r'|j        jF        r|tG          |          |j        _        n| j        j.        rn|lt          |t2                    sWt          |t                    rBt          |j        tb                    r(|j        jE        r| j(        D                    |||           n|r| G                    |||           |r| H                    ||          }| j
                            ||          }|j         s6|jF        s/t          |t                    r|j	        dk    stG          |          }| I                    ||||           | J                    |           t          |t                    r?t          |t                    r|j	        dk    s#| jL        s| M                    ||           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  )Nr  r   rz   $check_assignment_to_multiple_lvaluesr  .try_infer_partial_generic_type_from_assignmentr  r   r  r  r  r  r  r  rM  rn  r  r  r  r  r  r   &DATACLASS_POST_INIT_MUST_BE_A_FUNCTIONr}   CANNOT_MODIFY_MATCH_ARGSr   r  r   r   r)  is_valid_inferred_typerY  r  r  ro  r+   r   set_inferred_typeinfer_partial_typeinference_error_fallback_typerH  r  r   kindr)  check_member_assignmentr  is_literal_nonerU   r   r^  r   r;  r  r  r   rJ  r   r  r  is_abstractr,  r   r  r   rG  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   rx  check_compatibility_all_supers)r-  r	  r  r  r  index_lvaluer  r  	signaturerP  rn  rvalue_typer)  rQ  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 x	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 ~Lk;77 N$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[@\@\]]]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3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   )r7  r  r  rk  r  r  	is_methodr  r   r&   invalid_partial_typer   r8  rM  rn  r  r  is_top_levelr   r   )r-  r  r  type_contextsr  	base_node	base_typer  r  rt  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   r  r   r}   r  get_partial_self_varr  r  r  r  r   r   r  rY  r   r  )r-  r	  r  r  r)  rP  rQ  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  r8  )r  Tr  )r  r  r   r  r  explicit_self_typer  rW   r  r7  r1  r  rk  r  r  "check_compatibility_classvar_supercheck_compatibility_final_superdirect_base_classesr  r   r  r  r  r  r  r  r  check_compatibility_superr   rG  r  )r-  r	  r  lvalue_noder  tnodedirect_baseslast_immediate_baseactual_lvalue_typerL  r  r  r  r  r  custom_setters                   r  r  z*TypeChecker.check_compatibility_all_supersG  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  rY  r  r  r  )r-  r  r  r  r  r  r  r  s           r  r  z%TypeChecker.check_compatibility_super  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)rQ  rR  rS  rT  r  r2  suppress_errorsfilter_deprecatedrP  )mcs_fallbackoverride_info)rk  r  r  r  r   rf   r  r   rM  current_self_typer  r   r   r"   r~  r  is_operator_methodrG  r  r  r  r#   r$   )r-  r  r  r  r/  r*  r~  r  rk  r  mxr&  r  s                r  r  zTypeChecker.node_type_from_base  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r-  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   rn   rf   r  r  r  rG  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  rG  final_cant_override_writable)r-  r  r  rL  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.rz  r  s    r  get_final_contextzTypeChecker.get_final_contextC  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.  )r-  r  old_ctxs      r  r  zTypeChecker.enter_final_contextG  sH       $)	)EEE!(DD((((s    	(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  rM  rn  r   r  r   final_unset_in_classfinal_set_in_initrp  r  r  rG  final_without_valuer  r  rk  r  r  cant_assign_to_finalr7  )
r-  r  lvsis_final_declrn  r  r  r'  r  r!  s
             r  r  zTypeChecker.check_finalQ  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_selfrU  r   r  slotsr  r  rk  r  is_assignable_slotr  r   NAME_NOT_IN_SLOTSr  r  )r-  r	  inst	base_infor0  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 r,  )r?  )r  ur	  r-  s     r  r  z1TypeChecker.is_assignable_slot.<locals>.<genexpr>  s3      MMat..vq99MMMMMMr  )getattrr   r  r   r   r  r  r   r   rx  r  )r-  r	  rP  s   `` r  r?  zTypeChecker.is_assignable_slot  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   r8  r   r  r  r)  r   r  r   r   r  r   rU  r   r  )r-  rH  new_rvaluesrvrP  rX  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  r  zDTypeChecker.check_assignment_to_multiple_lvalues.<locals>.<listcomp>  s&    ___Q8M4@@@___r  c              3  J   K   | ]\  }}t          |t                    |V  d S r,  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   rz   r  rO  r  r   r   r  r  r)  type_is_iterabler   iterable_item_typer  r   CONTIGUOUS_ITERABLE_EXPECTEDr8  ITERABLE_TYPE_EXPECTEDr  r  r   check_rvalue_count_in_assignmentr  r   split_around_starr  r  set_lineextendr  check_multi_assignment)r-  r  r  r  r  rH  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  rM  rT  rU  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 r,  rW  )r  es     r  r  z?TypeChecker.check_rvalue_count_in_assignment.<locals>.<genexpr>7  s,      @@1z!X..@@@@@@r  z/Variadic tuple unpacking requires a star targetFc              3  J   K   | ]\  }}t          |t                    |V  d S r,  rW  rX  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 r,  rW  )r  r	  s     r  r  z?TypeChecker.check_rvalue_count_in_assignment.<locals>.<genexpr>J  s,      BBz&(++BBBBBBr  )	r  r  r  r   $TOO_MANY_TARGETS_FOR_VARIADIC_UNPACKr  r  rG  wrong_number_values_to_unpack)
r-  r  rr  r  rs  left_star_indexleft_prefixleft_suffixright_prefixright_suffixs
             r  r]  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   Nr  r  ) r   r  r  r  r   rU  r   ry  r  r   r   r  r7   r   r   r)  r=  r   r  r  !check_multi_assignment_from_tuple!check_multi_assignment_from_unionr   r  r  last_known_valuerG  unpacking_strings_disallowedr   r  rf  $check_multi_assignment_from_iterable)r-  r  r  r  r  r  r  r  ry  r  r=  rvalue_literals               r  ra  z"TypeChecker.check_multi_assignmentS  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 r,  r  )r  r  s     r  r  z@TypeChecker.check_multi_assignment_from_union.<locals>.<genexpr>  s"      2]2]!22]2]2]2]2]2]r  )r  r  r  r  Nc              3  4   K   | ]}t          |          V  d S r,  )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)r[  tupler4  rH  accumulate_type_assignmentsr  ra  r  r8  r7  rB  r   r   r-  r  r   r)  r  r   r  r  r  r  )r-  r  r  r  r  r  
transposedr  r  rX  r  union_typesr)  r  clean_itemsr  declared_typer  declared_typesunion_1_2r  s                          r  r  z-TypeChecker.check_multi_assignment_from_union  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 r,  )	r  r   rz   r`  r4  r  r   r)  r8  )r-  r  resr  s       r  r4  zTypeChecker.flatten_lvalues  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)rs  c              3  J   K   | ]\  }}t          |t                    |V  d S r,  rW  rX  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   r  )r  r  r  r-  s     r  r  zATypeChecker.check_multi_assignment_from_tuple.<locals>.<listcomp>  si        $ $.gz#B#BQDNN7G<<<!)$..w*O*O!P!P	  r  r  )"r   r  r]  r  r  r  r   r   lvalue_type_for_inferencer   r  r  r  r   rU  r   ry  r  r   r   r^  r  r  r=  rz   r_  r)  r   r  r   r  r   r  r  )r-  r  r  r  r  r  r  rs  ri  rj  rk  rl  r  reinferred_rvalue_typery  left_rv_typesstar_rv_typesright_rv_typesr  r  	list_exprs   `   `                r  r  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 r,  rW  rX  s      r  r  z8TypeChecker.lvalue_type_for_inference.<locals>.<genexpr>A  s5      KK51b*R2J2JKQKKKKKKr  r  r:  rI  rv_typesrN  r)  r*  c                    t          | |          D ]`\  }}                    |          \  }}}|r+t          |t                    s                    |           K                    |           ad S r,  )r  r  r  r   r8  )	r:  r  r  r  sub_lvalue_type
index_exprr  r-  type_parameterss	          r  append_types_for_inferencezITypeChecker.lvalue_type_for_inference.<locals>.append_types_for_inferenceL  s    "311 4 4G8<8I8I"8M8M5X" 4:o{+S+S 4#**?;;;; $**733334 4r  rK  )r:  rI  r  rN  r)  r*  )r  r  r  r   r   r^  r  r  r)  r  r   r`  r   r  )r-  r  r  ri  rj  rk  rl  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]ri  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  )	r-  r  ri  r  nr_right_of_starright_indexr  starr  s	            r  r^  zTypeChecker.split_around_stare  sj     "J.2+;q+@+@'''c%jj[j[!Z+,kll#T5  r  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-  r-  r  s     r  rY  zTypeChecker.type_is_iterableu  sq    t$$dL)) 	!d.>.>.@.@ 	!=D$))*;giF\>]>]=^__
 
 	
r  c                   t          |          }|                     |          r|                     ||          }|D ]}t          |t                    rH|                     d|g          }|                     |j        |                     ||          |           _|                     ||                     ||          |           d S | j	        
                    ||           d S )Nr  )r   rY  rZ  r  r   r  r  r)  r=  rG  type_not_iterable)r-  r  r  r  r  rE  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_exprr-  s     r  r  z,TypeChecker.check_lvalue.<locals>.<listcomp>  sN       
 	 !!(++A. "  !!	  r  rK  )rY  r  r  r   r  r   r  r  r   r  is_definitionr}   r  r  r)  def_varrw   analyze_ordinary_member_accessr  analyze_ref_expris_argumentr   rz   r  r   r  r   r  )	r-  r	  r  r  r  r  skip_definitionr  r  s	   `        r  r  zTypeChecker.check_lvalue  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/'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   r  r}   )r-  r  r  s      r  r  zTypeChecker.is_definition  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   rG  deleted_as_rvaluer  rY  r  r}   rM  rn  r  r  r   r   r[  r  need_annotation_for_var!set_inference_error_fallback_typerZ  r  r   r   r   r  r  r  r  r  rH  r  )r-  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;;;|. 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 r,  )r  r   r   rW  s     r  r  z1TypeChecker.infer_partial_type.<locals>.<genexpr>+  sE         q8_"=>>     r  collections.defaultdictr   r  Fr  T)r   r  r   r}   rY  r  r   r   r  r  r   rx  r   r  r   'is_valid_defaultdict_partial_value_typer)   r  rQ  r$  )	r-  r  r	  r  partial_typer  is_refarg0arg1s	            r  r  zTypeChecker.infer_partial_type  s   #I..	i** %	vz**%	26,2Q%	
 '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  rX  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  r  r   rY  old_type_inferencer   r   r   )r-  rX  r  alloweds       r  r  z3TypeChecker.is_valid_defaultdict_partial_value_typeD  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>i  s    ,V,V,V%UX,V,V,Vr  Nr   )ro  r  r  is_readyr^  rH  r  r  r}   rZ  r  r  r   r   r0  r   r  is_node_staticis_staticmethodis_classmethod_nodere  r  r*  rf   r)  r/  )r-  r)  r	  r  p_typer0  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  )r-  r)  r	  r  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 r,  )r  SetNothingToAnyr*   )r-  r  r&  s      r  r  z)TypeChecker.inference_error_fallback_type  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 r,  rr  r  s     r  r  z,TypeChecker.simple_rvalue.<locals>.<genexpr>  s$      "H"Hd4>"H"H"H"H"H"Hr  F)r  rx   r   r`   rl   r   ra   rW  r  rY   r  r   rr  r   r  r  )r-  r  rP  s      r  simple_rvaluezTypeChecker.simple_rvalue  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 | NonerT  c                h   ||us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o,t          t          |          t                    o
|| 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  rT  N)rT  )r  rG  r  rt  r  r  r  r  rY  has_new_errorsr  r   r   r   r   r   store_types
add_errorsfiltered_errors)r-  r  r  r  r  r  rT  r  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_context  s     '88888 (,'H$ %H"""==	AM	#++22%6IY 3  K		 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 D  F((F*;EEE 	 D [X%9[l>Y>Y>[>[ 	' T) R?;77CCR,0QQ 	 -``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   A4AA4A!	!A4$A!	%A44A8;A8#E,+E	E,E	E,E	E,,E03E0r  
expression)rF  r	  r  r?   rD  rE  rF  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,                    rV|	S|	j        K|	j        sCt1          |          }|                     |          st          |	j        t"                    st5          ||	j                  s|                     ||	j                  rt9          |	j        |g          }|	j        s| j                            |	j                    | !                    |	||           |j"        tF          k    r5| j$        %                                | j&                            ||f           | j'        (                    ||           tS          |          }||| j'        j*        |<   t          |tV                    r| j        ,                    ||           t          |tV                    r| j        -                    ||           n$|r"| .                    ||||| d| d|           ||fS )Nr  z	 has type)rF  )/rp  r  ri   r   r   r-  r   r   r  is_typeddict_type_contextr  r  r  r  r  rY  r  r   r   rG  r  r  r   r  r+   refers_to_different_scoper   can_widen_in_scoper   r  rS  r8  r  r  r  rQ   rM  r  rT  rH  r  r;   r  r   r  deleted_as_lvaluer  )r-  r  r  r  rG  rD  rE  rF  r	  r  rT  r  r  	preferredr&  new_inferredr  s                    r  rJ  z#TypeChecker.check_simple_assignment   s    < a	,Jv|<< a	,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 //FF	D #88U"V"VK#0 @)00???**8V[III{d**tz/L/L/N/N/Z 5<<fk=RSSSKOOFK888 'v..C8C05+{33 A**;@@@+{33 **;@@@@ 
"""---"--- # 	 	 	 ++r  r   c                    |j         t          k    rdS | j                                        |j         t          k    rdS |j         t          k    r0|j                            d          d         | j        j        k    rdS dS )NFT.r   )r  rU   rM  r  rQ   r  
rpartitionrd  r-  r  s     r  r   z%TypeChecker.refers_to_different_scopep  st    95Z**,,8TY$=N=N4Y$4=#;#;C#@#@#CtyGY#Y#Y4ur  r  c                    |j         t          k    r=| j                                        $t	          t          |          t                    sdS dS )a:  Can a variable type be widened via assignment in the current scope?

        Globals can only be widened from within a function if the original type
        is None (backward compat with partial type handling of `x = None`).

        See test cases testNewRedefineGlobalVariableNoneInit[1-4], for example.
        NFT)r  rQ   rM  r  r  r   r   )r-  r  r  s      r  r  zTypeChecker.can_widen_in_scope|  sK     I
--//;y998DD < 5tr  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)rQ  N)r   r  r   r  r   rJ  rG  r  r  r  r   )	r-  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rw   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  r|  r~  check_method_callr  r   rL   r  r   	ambiguousrH  r  )r-  r	  r  r  basetyper~  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)	r  rH  versionrY  r  r   r  r  r  )r-  r)  r  rQ  r  s        r  replace_partial_typez TypeChecker.replace_partial_type  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  r  r   r  r  r  r  r  rY  ro  
value_typer   r  r  )
r-  r	  r  r)  rh  rQ  typenamekey_typer  r  s
             r  r  z:TypeChecker.try_infer_partial_type_from_indexed_assignment  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   r  r  r/   r  r.   )r-  rP  proper_types      r  type_requires_usagezTypeChecker.type_requires_usage  sl     &c**k8,, 	G (,>>>35EFF##K00<35EFFtr  rk   c                F   | j                             |j        dd          }|                     |          }|rg|\  }}|                     t
          j                            t          || j	                            ||           | 
                    |||           d S d S )NTrR  r  )r  r  r)  r   r  r   TYPE_MUST_BE_USEDr  rD   rY  r  )r-  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_stmtrH  r  r-  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rS  N)rG  r  rt  rH  r  r   r  r  r  r  r  r   r  )
r-  r)  r+  r,  rG  r  rP  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/  r8  gotr  )r  r  r  r  r  outer_contextrG  )2rM  current_functionr  r  rO  r  r  r   r  ry   r   r  r  r   NO_RETURN_EXPECTEDr)  r   r   ra   rz   r   rh   r   r   r]   r3  r  r  r   r  r  r   r   r-  r  RETURN_IN_ASYNC_GENERATORrY  warn_return_anyro  r   r  r   r  rG  incorrectly_returning_anyNO_RETURN_VALUE_EXPECTEDr  r  r  RETURN_VALUE_EXPECTED)	r-  r  r  r  	is_lambdadeclared_none_returndeclared_any_returnr,  rP  s	            r  r(  zTypeChecker.check_return_stmtG  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  rr   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  rC  from_assignmentN)rH  r  r  r)  r  r   r  r  r  r   rG  r  r  is_unreachable_mapunreachable_elser  r  )r-  r  rw  rr  rX  if_mapr  s          r  visit_if_stmtzTypeChecker.visit_if_stmt  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  )rr   r)  r  r_  r  r  )r-  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        |           nRt          |j        |j        |j                  }|                    |           |                     |j        |d           |                     |           dS )z9Type check an operator assignment statement, e.g. x += 1.T)r	  r  r  N)r  r	  r  r  r  r}   r  visit_member_exprr   infer_operator_assignment_methodcheck_opr   rG   incompatible_operator_assignmentr   r_  r  r  )r-  r  r  inplacer  r  r  r)  s           r  visit_operator_assignment_stmtz*TypeChecker.visit_operator_assignment_stmt  s>   ;;AHahPQPTUUUah
++ 	= +==ahMMKK+2218<<K:;MM 		X!.77QXWXYYNKk;77 C99!$BBB !$!(33DMM!!!$RV!WWWr  rZ   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  rG  analyze_cond_branchr  )r-  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_exprrH  r  r)  s     r  visit_raise_stmtzTypeChecker.visit_raise_stmt  sf    6 	-!!!&!,,,; 	A!!!+q4!@@@!!!!!r  rw  r\  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   rG  r  r  r   r8  r   r  r   
make_unionr   INVALID_EXCEPTIONr   r>  r   r  r  r   ra   rW  r   r  r  )r-  rw  r  r\  rP  r;  expected_type_itemss          r  r]  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   rD  )	try_frame)rH  r  visit_try_without_finallyr'  finally_bodyr4   r5   rG  rF  r  r  r  )r-  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*rg  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  rC  rg  TrB  N   rD  source)rH  r  r  r  r  r  handlersr  check_except_handler_testis_starvarsr  r  r=  r  r  r  r   r   r  rY  r  r  cleanser  )	r-  r  rg  r  rP  rX  r)  rn  r  s	            r  rh  z%TypeChecker.visit_try_without_finallyM  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#'<#B !U$(K$;$;C8$T$T$T#'<#B 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  rq  c                   | j                             |          }g }|                     ||          }t          |          D ]}t	          |t
                    r|                    |           .t	          |t                    rDt	          |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 |                    |           |rg }	|D ]}t+          ||                     d                    rM|                     t          j        |           |	                    t          t.          j                             r|	                    |           |                     |	          S t5          |          S )z,Type check an exception handler test clause.r   ra  builtins.BaseExceptionGroup)r  r  get_types_from_except_handlerr   r  r   r8  r   r   r  r  r  r   INVALID_EXCEPTION_TYPEdefault_exception_typer*   r%  r   r  r   r  r   INVALID_EXCEPTION_GROUPr   r  wrap_exception_groupr   )
r-  r  rq  rP  	all_types
test_typesttyper  r;  new_all_typess
             r  rp  z%TypeChecker.check_except_handler_test{  s_   &&q)) "	77Q??
%j11 	' 	'E%))   '''%11 %.. 
<{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   r  r  )r-  rq  r?  s      r  rx  z"TypeChecker.default_exception_type  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.Exceptionr  ru  )r   r   r  r  )r-  r  r  r  s       r  rz  z TypeChecker.wrap_exception_group  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.rK  r   c                F    g | ]}                     |          D ]}|S r  )rv  )r  r  	union_typr  r-  s      r  r  z=TypeChecker.get_types_from_except_handler.<locals>.<listcomp>  sP       !%!C!CD!!L!L      r  )	r   r  r   r   r  r   ry  r   r  )r-  rP  r  merged_types   ` ` r  rv  z)TypeChecker.get_types_from_except_handler  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  rm   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 r,  )analyze_index_variablesr  
index_type)rE  r  r-  s   r  re  z,TypeChecker.visit_for_stmt.<locals>.<lambda>  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  )r-  r  iterator_typerE  s   `` @r  visit_for_stmtzTypeChecker.visit_for_stmt  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)r-  r)  echkiterableiterator	awaitablerE  s          r  r  z,TypeChecker.analyze_async_iterable_item_type  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)r-  r)  r  r  int_types        r  r  z&TypeChecker.analyze_iterable_item_type  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   rK  __next__)
r  r   r  r  r   partial_fallbackr  r  r   r  )r-  r  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 r,  )rL   )r  r  s     r  r  z<TypeChecker.analyze_range_native_int_type.<locals>.<genexpr>  s&      ??DGO??????r  NTF)r  ra   rW  r   r  r  r  rx  r#  r   r  r   r  r   )r-  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_typer8  rc  r   r  r  r  r<   r  r  r   r   )r-  rP  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  rE  c                \    |                      ||                     ||          |           dS )z>Type check or infer for loop or list comprehension index vars.N)r  r=  )r-  r  rE  r  r  s        r  r  z#TypeChecker.analyze_index_variables7  s1     	eT^^Iw%G%GIZ[[[[[r  rg   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/  rm  )r  r)  rw   r}   r  r  r  ra   r  r   rL   r  r  flattenr   rH  r  r   r  r   )r-  r  rw  mc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  rf   c                    t          d |j        D                       r1t          t          j                  |j        _        d|j        _        d S |                     |           d S )Nc              3  6   K   | ]}t          |d           V  dS r  r  r  s     r  r  z.TypeChecker.visit_decorator.<locals>.<genexpr>P  s.      SS!!%;<<SSSSSSr  T)	r  r  r   r   r-  r)  r  r  r+  r-  rw  s     r  r(  zTypeChecker.visit_decoratorO  s_    SSalSSSSS 	 !788AEJ!AENF""1%%%%%r  r   c           	     
   |j         }|j        r|                     |          }t          |t                    sJ t          |j        d          s|j        }|j        }|                     ||          }| 	                    ||          }	|r| 
                    |          }
n|                     ||          }
|                     d||	|
|g          }|                    |          |_        | j        s|                     |           | 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}t1          |r|j        dd          n|j                  D ]W}t5          |d          rt5          |t6                    r#|s |                     t:          j        |           Ld}| j                             |          }| !                    ||          }d }t          |tD                    r	|j#        pd }d }|it          |tH                    rT| %                    |j&                  r:| '                    |j&                  }| j        (                    ||j                  }| )                    |j         ||           | j        *                    ||gtV          j,        g|||	          \  }}Y|r| -                    ||j                    | .                    ||j                    t_          ||j                   }t          |t                    r||_0        ||j1        _        d|j1        _2        |j         j3        rgt          |t                    r=ti          d
 |j5        D                       dk    r| j6                            d|           | 7                    |           |s|rd S |j         j8        r|j9        s{| :                    |          }|j         j;        r?|s=|;|j         j8        j<        s*| j6        =                    |j         j        |j                    | >                    |j         |           |j         j8        rc|j         j        dv rU|j        rNt          t          |j                  t          t          f          s |                     t:          jB        |           |j         jC        r2t          |t                    r| D                    |j         |           d S d S d S )Nr  )r%  r  Fr  zabc.abstractmethodTr  )r/  ry  c                :    g | ]}|                                 |S r  )is_required)r  ks     r  r  z5TypeChecker.visit_decorator_inner.<locals>.<listcomp>  s%    DDDaAMMOODDDDr  zToo many arguments for propertyr  )Er  is_awaitable_coroutiner   r  r   r   r%  r  r  r  r  r  r  ru  r  rx  r1  ry  r2  rL  r  r3  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   rL   check_untyped_after_decoratorr  r   r0  r)  r  r  r  r#  rG  $check_incompatible_property_overrider7  r  r8  r9  r:  r;  r<  r   r   r   BAD_CONSTRUCTOR_TYPEr  r  )r-  rw  r  r   r  rP  rX  r  tytctrr%  rB  non_trivial_decoratorr  rD  rE  r  ry  t2rG  s                        r  r+  z!TypeChecker.visit_decorator_innerV  s*    v& 	A$$T**Cc<00000 %S\3NOO 
AL%221a8844Q:: >77::BB771==B223NQSUWY[]^P_``--x-@@	 ( 	,%%d+++& 	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 	6s6   ;F(F8FF	FF	FF"F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 r,  )	rY  disallow_untyped_decoratorsis_typed_callabler  is_untyped_decoratorro  rG   typed_function_untyped_decoratorr  )r-  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  r7  r  r  rk  r  r  r  r   r  r   rf   r  r  r   'READ_ONLY_PROPERTY_OVERRIDES_READ_WRITE)r-  rw  r  r  r  s        r  r  z0TypeChecker.check_incompatible_property_override  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  rg  )r  r)  r5  r  check_async_with_itemr  check_with_itemr   r   r  r   r  r  r   r  rH  r  r  r  )r-  r  exceptions_maybe_suppressedr)  r5  exit_ret_types         r  visit_with_stmtzTypeChecker.visit_with_stmt  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 r,  )	rY  disallow_any_decoratedrp  ro  r~  r  has_any_typerG  untyped_decorated_function)r-  rP  r  s      r  r  z)TypeChecker.check_untyped_after_decorator  sg    |2 	dl 	dF` 	F>&&s++ 	;H//T:::::	; 	;r  r5  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   rL   &INCOMPATIBLE_TYPES_IN_ASYNC_WITH_AEXIT
r-  r)  r5  r  r  rL  objr  r  r  s
             r  r  z!TypeChecker.check_async_with_item  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 )Nr:  r   rC  r	  )
r  r  r  r  r=  r   r   r-  r   rL   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 r,  )rH  handle_breakr)  s     r  visit_break_stmtzTypeChecker.visit_break_stmt  s      """""r  re   c                8    | j                                          d S r,  )rH  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   rD  c                F    g | ]}j                             |          S r  )rK  r  )r  pr-  subject_types     r  r  z0TypeChecker.visit_match_stmt.<locals>.<listcomp>4  s,    ^^^aT188LII^^^r  c                    g | ]	}|j         
S r  )capturesrW  s     r  r  z0TypeChecker.visit_match_stmt.<locals>.<listcomp>5  s    'J'J'Jq
'J'J'Jr  Tr  rE  r	  ))collapse_walrussubject_make_named_statement_for_matchrH  r  r   r  r  r  r   rG  r  patterns#infer_variable_types_from_type_mapsr   r  guardsbodiesnarrow_type_from_binderrK  conditional_types_to_typemapsr  	rest_typepropagate_up_typemap_info"check_and_remove_capture_conflictsr  r  r  _get_recursive_sub_patterns_mapr  or_conditional_mapsr   patternr  r   r  r  rG  ro  r  "match_statement_inexhaustive_match)r-  r  unwrapped_subjectnamed_subjectpattern_types	type_mapsinferred_typesunmatched_typesr  grr  current_subject_typepattern_typepattern_mapr  r)  rP  r  	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;;L<QSabbb&&{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)rH  can_put_directlysubject_dummynew_unique_dummy_namer   r   r  )r-  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  r5  c                p   i }t          |          }t          |t                    rt          |t                    rzt	          |j                  t	          |j                  k    sJ t          |j        |j                  D ]3\  }}|||<   |                    |                     ||                     4|S r,  )	r   r  r   r   r  r  r  r  r  )r-  r)  rP  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                   t          t                    }|D ]h}t          |          sW|                                D ]B\  }}t	          |t
                    r(|j        }|J ||                             ||f           Cii }|                                D ]\  }}	d}
g }|	D ]\  }}|                    |           |                     |          \  }}}|Nd}
t	          |j        t                    r-|j        j
        r!| j                            |j        d|           |||<   |
sSt          j        |          }|	d         \  }}t	          |t                    sJ |||<   |                     ||||           |S )NFTr   )r   r  rG  r  r  r   r  r8  r  r   r  rG  r9  r  r   rc  r  )r-  r  all_capturestmr)  rP  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% 	8 	8	cS!!!&*&7&7&=&=#q! ,%)N!$)S11 Ndi6H N55diMMM*7N3'! \$/66&.qk# !!#s+++++&.s#((.>JZ[[[r  r  r!  r  c           	        t          |          rd S t          |                                          D ]T\  }}t          |t                    s|j        }||vs+|                     |||         |t          j        dd          s||= Ud S )Nzpattern captures typezvariable has type)rG  r  r  )	rG  r  r  r  r   r  r  r   INCOMPATIBLE_TYPES_IN_CAPTURE)r-  r  r  r)  rP  r  s         r  r  z.TypeChecker.check_and_remove_capture_conflicts  s     h'' 	Fhnn..// 	# 	#ID#dH-- 9D>))1C1Ct$$B5 3 2D 2 2) 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 r,  )
alias_noder  alias_tvarsrG  r  r  r  r  r-  r"  s     r  visit_type_alias_stmtz!TypeChecker.visit_type_alias_stmt  s    < 	B''(@AAAX##%% 	. 	.$$QW---	. 	. 	. 	. 	. 	. 	. 	. 	. 	. 	. 	. 	. 	. 	. 	. 	. 	.s     A--A14A1curr_module_fullnameclass_gen_nameclass_short_namer1  list[Instance]tuple[ClassDef, TypeInfo]c                   t          |t          g                     }|dz   |z   |_        t          t	                      ||          }||_        ||_        t          |           |                                |_	        ||fS )Nr  )
rb   r^   r  r   r   r7  r1  rJ   calculate_metaclass_typer  )r-  r(  r)  r*  r1  cdefr7  s          r  r|  zTypeChecker.make_fake_typeinfo  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_r1  r)  r+  c                    g }| D ]8}|j         j        r|j         j        }n|g}|D ]}|                    |           9|S r,  )r  is_intersectionr1  r8  )r6  base_classes_rA  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  r9  curr_module_r~   rY  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  )rY  	verbosity)rE   )r  rw  rY  s     r  r  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>)rH   rk  r  r  r  r   r|  r  )	r9  r<  rY  rk  r  symbolr/  info_r-  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)rY  barerA  zhave distinct disjoint basesNr  z
" is finalr  z/would have inconsistent method resolution orderz)would have incompatible method signatures)module_hiddenr  extra_attrs)r6  r1  r)  r+  )r9  r+  r<  r~   rY  r   r)  r=  )rM  r  r  r~   r   rH   rF   rY  r   r8  r  r  r  r`  rG  r  r8  r  r8  rI   r   rQ   rk  r   rI  )r-  r0  rF  curr_moduler  r  r;  rE  base_classespretty_names_list
new_errorsr  r7  	full_namer  s   `              r  intersect_instanceszTypeChecker.intersect_instances  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"          |          }	d|	_        |	|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 rB  rO  z	.__call__TrH  )rM  r  r  r~   gen_unique_namer  r  rk  rE   rY  r|  r  ro   r^   	_fullnamer7  r   rW   r  rQ   r   rI  )
r-  rP  rP  
cur_modulegen_name
short_namer/  r7  func_defr!  s
             r  intersect_instance_callablez'TypeChecker.intersect_instance_callableX  s    Z%a(
*h/////"#K38=#K#K#KZM]^^ &c4<88
,,Z-@(JY\X]^^
d :r599mDD!][8dH--#!$
:%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   rM   r)  rX  )r-  rP  r&  rP  s       r  make_fake_callablezTypeChecker.make_fake_callablev  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r]  rO  F)r   r  r   r   r   r   r   r  partition_by_callabler`  r   r   r   r   r   r  
get_methodr\  r4  )r-  rP  r]  	callablesuncallablesr  subcallablessubuncallablesitypr  fakes              r  ra  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.
        Fr`  )r  r   r   ra  r   rc  r   )r-  r)  ri  rc  rd  callable_mapuncallable_maps          r  conditional_callable_type_mapz)TypeChecker.conditional_callable_type_map  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  rT  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   ry  r   r   required_keysr8  r  r  rc  )	r-  rE  rT  if_types
else_typespossible_iterable_typesitem_str_literalspossible_iterable_typer  s	            r  conditional_types_for_iterablez*TypeChecker.conditional_types_for_iterable  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__r8  c              3  B   K   | ]}                     |          V  d S r,  )_is_truthy_typer  rX  r-  s     r  r  z.TypeChecker._is_truthy_type.<locals>.<genexpr>'  s1      SSA,,Q//SSSSSSr  )r  r   r'  r  rv  r  r   r   rx  r   r  r-  rX  s   ` r  r{  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)  rf  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 )	rD   rY  r  r}   r  r   r  ra   rW  )rP  r)  r-  rX  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  rD   rY  )r)  r-  rX  s   r  get_expr_namez8TypeChecker.check_for_truthy_type.<locals>.get_expr_nameK  sA    $: 677 4'49'''' #1dl333r  r  typing
Collection)r)  rf  )r   r  r   r{  r  r   r  r   FUNCTION_ALWAYS_TRUEr  r   TYPE_ALWAYS_TRUE_UNIONTYPEr   r  r  r|  ITERABLE_ALWAYS_TRUErD   r  rY  TYPE_ALWAYS_TRUE)r-  rX  r)  r  r  r  r7  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_contextr  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.
        r  )find_isinstance_check_helperr  )r-  r  r  rI  r  
new_if_mapnew_else_maps          r  r  z!TypeChecker.find_isinstance_checka  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  rO  TrS  guardnarrowerFis_upper_boundconsider_runtime_isinstancer  rA  coalesce_anyornotrx  rB  r  )Bis_true_literalr   r  r  ra   r  r  r  r   rW  r:   rV   r  #conditional_types_with_intersectionr  get_isinstance_typeinfer_issubclass_mapsrn  r   hasattr_type_mapslookup_type_or_noner   r   r   r   r  r  r   r#  r   rL   r   r  r$  r  r  r   TYPE_GUARD_POS_ARG_REQUIREDr  r   r    rc    comparison_type_narrowing_helperr[   r  r5  r  r  r   r  r  r  and_conditional_mapsr  r   r)  r  can_be_narrowed_with_lenr   rY  r  narrow_with_lenr   r   r  r   )r-  r  r  r)  vartyperN  r  r  called_typecallr  r"  r  rI  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  r  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  rc   c           	     &   d |j         D             }g }i }i }t          |          D ]6\  }}|                     |          si i fc S |                     |          }|                    |           t          |          t          k    rt          |          st          |          st          |          st          |          s|                     |          st          t          |          x}	t                    r|	                                sJt          |	t                     rt          |	j        t$                    st'          |          }
|

|
||<   |||
<   8t)          |                                |ddh          }g }|D ]\  }}|dv r0|                     |||||                                          \  }}n|dv rt1          |          dk    sJ |\  }}||         }||         }i }i }||v rt          t3          |                    }|v|                     d||         ||         g||gd	d
gd	h          \  }}|rDt          t          |          x}t4                    rt7          d |j        D                       si }||v r+|                     ||          \  }}||         }|||<   |||<   ni }i }|dv r||}}|                    ||f           t1          |          d
k    rQ|                                D ]<\  }}t'          |          }
|
|
|vr||
         }t=          ||         |          ||<   =t?          d |D                       rtA          |d          S tA          | !                    |          d          S )z2Infer type narrowing from a comparison expression.c                ,    g | ]}t          |          S r  r  )r  rw  s     r  r  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  c              3  N   K   | ] }t          t          |                    V  !d S r,  )r   r   r  s     r  r  z?TypeChecker.comparison_type_narrowing_helper.<locals>.<genexpr>  sF       $ $$( !;?4;P;P Q Q$ $ $ $ $ $r  >   r  r  r  c              3  j   K   | ].}t          |d                    pt          |d                   V  /dS )r   r  Nr  )r  r  s     r  r  z?TypeChecker.comparison_type_narrowing_helper.<locals>.<genexpr>  s;      AA!s1Q4yy%C!IIAAAAAAr  Tuse_meet)"r  r  r  r  r8  r:   rV   r  r  r  r  is_literal_enumr  r   r   r  r   r  r   r;   group_comparison_operandspairwise narrow_type_by_identity_equalityrV  r  builtin_item_typer   rx  r  rv  r>   r  reduce_conditional_mapsfind_tuple_len_narrowing)r-  r  r  r   narrowable_operand_index_to_hash narrowable_operand_hash_to_indexr  r)  r#  p_exprhsimplified_operator_listpartial_type_mapsoperatorr  rI  r  
left_indexr  rE  rT  collection_item_typep_typif_type	else_typeoperand_indexs                             r  r  z,TypeChecker.comparison_type_narrowing_helper#  s    ?>>>>+-(+-( ** 	< 	<GAt==&& 2v((..I  +++ --'-- .2488 . ).. . (--	 .
 ,,T22 . )C)CCv\RR . **,, . $FH55 . ;EV[R]:^:^ . !&&=:;4Q7:;4Q7$ $=MMOO=d|$
 $
  &> F	 F	"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 , ,( $ 
*&0N0N'NuPYZZ
* # $ $,1K$ $ $ ! !
* (*H"BBB)-)L)L!=* *&GY $K0D#*F4L%.HTN 555#+V$$fh%7888 +,,q00'-||~~  OD)$T**AyA-M$M$M $DQ$GM3=%m4i4 4M-00 AA/@AAAAA 	_*+<tLLLL +4+H+H+N+NY]^^^^r  r  r  r  r  	list[int]r  AbstractSet[int]c           
     ~   |dv }|rt           }d}t                      }	nq|dv rft          }d}|D ]K}
t          |
                   }t	          |          s!t          |t                    r|j        j        rd} nLfd|D             }	nt          g }g }|D ]r}
|
|vr|
|	v r|
         }|D ]Y}|
|k    r
||	v r|         }|rt          |          }t          |||          \  }}||x}}njt          t          |          d          }t          |t          |d          gd	          \  }}|&t          |p||g          }t          |p||g          }t!          ||
         ||          \  }} |t          |                    r,|                    |           |                    |           | j        j        rt)          | j        j                  d
k    st/          |          s|                    |           [t|	D ]}
|
|vrt          |
                   }t          |t0                    s|
         }|D ]}||	v r|         }|rt          |          }t          |d          } |t          |                    r<t!          ||
         gt          ||gd	          R  \  }}|                    |           g }g }|j        D ]}t5          |          r|                    ||
         |i           t          t          |d                    }|D ]}||	v rt|
|k    rt7          |          r@t7          |                   s+|                    ||
         t9          |          i           n|                    ||
         |i           {|         }|rt          |          }t          |||          \  }}||x}}ngt          t          |d                    }t          |t          |d          g|d          \  }}|"t          ||g          }t          ||g          }t!          ||
         ||          \  }}t          t          |          t:                    s|                    |            |t          |                    r|                    |           |                    t=          |                     |                    t=          |                     |D ]}
||
         }t          |t>                    r;tA          |j!        d          r&t)          |j"                  d
k    r|j"        d         }n)t          |tF                    r|j$        dk    r|j%        }nt          |
                   }t          |tL                    rt          |j'        tP                    r|D ]1}|
|k    r
||         }| )                    |                   }|0t          t          |j'                  t:                    rX| *                    |          } | +                    | |g|          \  }}|*|j,        s#t[          ||j'                  st]                      }t!          |||          \  }}t          |t^                    r&t          |j0        tb                    r|j0        j2        nd}!|                    |           |!r|                    |           3 tg          |t)          |          dk              }t=          |          }||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  T>   r  r  Fc                >    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  )is_identityNr  )from_equalityr  )rC  r  rP  r   	__class__r  r  )4r   rl  r   r   r   r  r   r  r5  AssertionErrorr   "partition_equality_ambiguous_typesr   conditional_typesr    r   r  r8  rY  r  r  rM  r  rG  r   r  r  r   r   r   reduce_or_conditional_type_mapsra   r   rW  r  r}   r  r)  r   r  r   get_type_range_of_typer  r  r  r   r   r   r  r   r   reduce_and_conditional_type_maps)"r-  r  r  r  r  r  is_identity_comparisonis_target_for_value_narrowingshould_coerce_literalscustom_eq_indicesr  rP  all_if_mapsall_else_mapsr#  r{  target_typenarrowable_expr_typeambiguous_expr_typer  r  rI  r  union_expr_typer5  
or_if_mapsor_else_maps	type_exprexpr_in_type_exprp_expr_typer)  current_type_ranger  r  s"      `                              r  r  z,TypeChecker.narrow_type_by_identity_equality  s	   ` "*-=!=! 	!,F)%)" #%%,F)%*"!  %mA&677',, C1J1J sxO_ -1*E c c c cL c c c  %'')  D	3 D	3A***%%%%a(I! <3 <366))) +A.) A"3K"@"@K =_{8N= = =9$&9 (/*==Gii+J)*>??, ,( *;,";uEEEF&** * *&GY
 +6"7$<(<>QR# # %:&>*>@ST% %	 $A!gW`#a#a 001M1MNN 3&&v...!((2222" 53:=dj>N:O:OST:T:T/77 ;U#**6222y<3@ # W	P W	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 56 5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@b!;<RA A A=(*= ,3.AA))/@;<PRVWW0 0, .?0&{5IIIJ$8*.	. . .* /:&;WFY<Z&[&[G(=yJ]>^(_(_I'D Wi( ($FH &oi&@&@'JJ 2 #))&11144_[5Q5QRR 6$++H555].6` >zJJKKK  !@!N!NOOOO  9	3 9	3A I9h//	&y'7II	 	''1,,$-N1$5!!Iz22 y~7T7T$-N!!)-*:;;K+x00 Z@PR]5^5^  ! %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                    |g}|                                 D ].\  }}|                    |                     ||                     /t          |d          S )a  Attempts refining parent expressions of any MemberExpr or IndexExprs in new_types.

        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'.
        Tr  )r  r8  refine_parent_typesr  )r-  r  all_mappingsr)  r#  s        r  r  z%TypeChecker.propagate_up_typemap_info  sd    * "{(00 	K 	KOD) 8 8y I IJJJJ/tLLLLr  r#  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)  rK  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  rP  r  rQ  rR  rS  rT  r2  in_literal_context)rG  r  r%   r  )r  wmember_typemember_nameparent_exprr-  s      r  replay_lookupz6TypeChecker.refine_parent_types.<locals>.replay_lookup  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  r  zJTypeChecker.refine_parent_types.<locals>.replay_lookup.<locals>.<listcomp>6  s!    +_+_+_3O,A#,F+_+_+_r  )r  r   r  r   )r  member_typesstr_literalss   ` r  r  z6TypeChecker.refine_parent_types.<locals>.replay_lookup1  sx    )/=II (#'4(#/#;#;#;+_+_+_+_R^+_+_+_LL' ( ( (#'44(4\BBBs   . 
<<c                
    t           t                    r4	 J  fdD             }n# t          $ r Y d S w xY wt          |          S t           t                    r" j        j        dv r j        r j        d         S d S )Nc                *    g | ]}j         |         S r  r  r  s     r  r  zJTypeChecker.refine_parent_types.<locals>.replay_lookup.<locals>.<listcomp>C  s.     4& 4& 4&GJ(=c(B4& 4& 4&r  )r  rK  r   )r  r   
IndexErrorr   r   r  r  r  )r  r	  int_literalss   ` r  r  z6TypeChecker.refine_parent_types.<locals>.replay_lookup?  s    )/9EE K!0+7+C+C+C4& 4& 4& 4&NZ4& 4& 4&LL (2 !0 !0 !0+/44!0'<\'J'J J *?H E E?$3$8$A#F%G %G$3$8%G (7';A'> >#'4s   , 
::)r  r   r)  rK  )r  r}   _propagate_walrus_assignmentsr)  r  r  rw   r  r  r   r   r   r   r   r  r=   r8  r   )r-  r)  r#  outputparent_typer  r  new_parent_typesr  r  r  r  r  r
  s   `         @@@@r  r  zTypeChecker.refine_parent_types  sX    *,q	V
 $
++ I"@@FSS"66{CC"i+ + + + + + + + +$ D),, 2"@@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#/( ( ( ( ( ( ((  & " *+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{+cq	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  )r-  r)  r  assigned_typer  s        r  r  z)TypeChecker._propagate_walrus_assignmentsz  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  ra   r   rW  r  r  r:   rV   r  r  r  )r-  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.
        ry  Fc              3  @   K   | ]}t          |t                    V  d S r,  )r  r   rW  s     r  r  z7TypeChecker.can_be_narrowed_with_len.<locals>.<genexpr>  s,      BB:a,,BBBBBBr  rK  Tc              3  B   K   | ]}                     |          V  d S r,  )r  r|  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   r  r  r  r  r  r   r  r   )r-  rP  r  s   `  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`  )r-  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  >   >=<rB  r  <=r  c              3  F   K   | ]}                     |          d uV  d S r,  )r  r  s     r  r  z7TypeChecker.find_tuple_len_narrowing.<locals>.<genexpr>  s6      MMt,,R00<MMMMMMr  c              3  B   K   | ]}                     |          V  d S r,  )r  r  s     r  r  z7TypeChecker.find_tuple_len_narrowing.<locals>.<genexpr>  s1      @@Bt++B//@@@@@@r  Nr   r  c                ,    i | ]}|t                      S r  )r   )r  tpls     r  
<dictcomp>z8TypeChecker.find_tuple_len_narrowing.<locals>.<dictcomp>  s     HHH#sO$5$5HHHr  )rl  r  r  r[   r  r  r8  r  r  r  r  ra   r  r  rB  r  r  r  r   r  )r-  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  r8  r  r   )r-  rP  r  r+  	yes_typesno_typesother_typesrX  ytntr  r  s               r  r  zTypeChecker.narrow_with_len"  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  rK  r   )r   r  r   r  r   r  r   r   r  r   r9  ru  r/  r   r   r  r  r  r8  r   rc  r  r  )r-  rP  r  r+  unpack_indexr  unpackrN  r9  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.rK  r   r7  )r  r&  r8  r   r  r&  )r<   lookup_typeinfor  r   rY  enable_incomplete_featurer  r  r   r   r  r  r8  r   rc  r  r  r0  r   )r-  rP  r  r+  r  r  allow_preciser;  r  r  r  r  s               r  r0  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  )rF  r  r6  r  r  r  r  ErrorCode | Noner6  c                   d S r,  r  )
r-  r  r  r  rG  r  r  rF  r  r6  s
             r  r  zTypeChecker.check_subtype  s	     sr  )rF  r6  c                   d S r,  r  )	r-  r  r  r  rG  r  r  rF  r6  s	            r  r  zTypeChecker.check_subtype  s	     sr  str | ErrorMessagec                  t          ||| j                  rdS t          |t                    rt	          ||          }| j                                        s|2| j                            |          s| 	                    ||           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          |t4          t          t6          t8          t:          f          r| j                            ||||           t          |t4                    rMt          |t                    r8t?          d||d          }|r#| j                             ||||j                   t          |t4          tB          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  NF  z (z, r  )parent_errorrO  r  )$r   rY  r  rf  r?   rG  prefer_simple_messagesrF  is_error_code_enabledr  r   &try_report_long_tuple_assignment_errorrF   r8  rG   r   rB   r   rC   r  r   r  r  maybe_note_concatenate_pos_argsr  r,  r   r   r   r   report_protocol_problemsr   	note_callr   protocol_memberscheck_possible_missing_await)r-  r  r  r  rG  r  r  rF  r  r6  orig_subtypeorig_supertype
extra_infonote_msgsubtype_strsupertype_strerrorr  r  s                      r  r  zTypeChecker.check_subtype  sL    gy$,??? 	4c3 	/s...C H++--	K55d;;   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.
        NrH  T)ignore_binder)
r  r   r   r  r  rd   r  r  r   r   )r-  rP  r  aw_types       r  get_precise_awaitable_typez&TypeChecker.get_precise_awaitable_type  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$  )r|  r  s    r  checking_await_setzTypeChecker.checking_await_set'  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)rG  )	r|  r_  rG  r  r]  r  r   INCOMPATIBLE_TYPESpossible_missing_await)r-  r  r  r  r  r  r\  s          r  rR  z(TypeChecker.check_possible_missing_await/  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  r8  )r   r  _named_typer   r  	bool_typery  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 r,  )lookup_qualifiedr  r  r   r5  r   r  r   r   r   from_omitted_genericsr  r  ro  )r-  r  r!  r  r?  s        r  re  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  r  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  r  z2TypeChecker.named_generic_type.<locals>.<listcomp>m  s!    GGG31#66GGGr  )r@  r   )r-  r  r  r7  s       r  r  zTypeChecker.named_generic_typef  s:     ##D))GG$GGGd###r  r  c                |    |                      |          }|j        }t          |t                    s
J |            |S r,  )rh  r  r  r   )r-  r  r!  r  s       r  r@  zTypeChecker.lookup_typeinfoq  s?    ##H--x$))//4///r  c                ,    |                      d          S )zReturn instance type 'type'.rP  r  r  s    r  rh  zTypeChecker.type_typex  s    ///r  c                ,    |                      d          S )zReturn instance type 'str'.r  rn  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)r7  )r-  r  rP  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 r,  r  )r  r  r  s     r  r  z'TypeChecker.has_type.<locals>.<genexpr>  s'      @@419@@@@@@r  )r  r;  r7  r  s    `r  r  zTypeChecker.has_type  s0    @@@@ht&?&?@@@@@@r  c                P    t          | j                  D ]}||v r
||         c S d S r,  )r;  r7  )r-  r  r  s      r  r  zTypeChecker.lookup_type_or_none  s;    $/** 	 	Aqyyw tr  c                    t          | j                  D ]}|                    |          }||c S t          |          r,  )r;  r7  r  r  )r-  r  r  rX  s       r  r  zTypeChecker.lookup_type  sI    $/** 	 	AdA} tnnr  r  c                F    | j         d                             |           d S r  )r7  r  )r-  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  )rY  r(  rP  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: )rU  r  r  r  r~   rk  r  )r-  r  rr  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  )builtinsr  z*, e.g. add '[{} fixtures/{}]' to your testrH  zmCould not find builtin symbol '{}' (If you are running a test case, use a fixture that defines this symbol{})z0Failed qualified lookup: '{}' (fullname = '{}').)rz  splitrW  r  r  rk  r  r  r  r~   r   r@   r  r  )
r-  r  partsr  r  r!  r  r  
suggestionrG  s
             r  rh  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	        }| 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)rQ  r(  r8  r#  rY  allow_untyped_globalsr(  rP  rB  r$  ro  r  r  r  r   r   rR  rG  r  r  r   r  )	r-  r&  r*  r(  
permissiverQ  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04) 	) - 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   rQ  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_scopesr  r   ro  rY  r  rG  r  rR  r  r  r  r   )r-  rP  rQ  r  r  in_scoper(  rQ  s           r  handle_partial_var_typez#TypeChecker.handle_partial_var_type  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 r,  )r  r  )r  r  r)  s     r  r  z7TypeChecker.is_defined_in_base_class.<locals>.<genexpr>  sG       /
 /
/3DHHSXd*/
 /
 /
 /
 /
 /
r  r  )r7  r:  r  r  )r-  r)  s    `r  is_defined_in_base_classz$TypeChecker.is_defined_in_base_class  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)r  )r-  r)  r  r  rQ  s        r  r  zTypeChecker.find_partial_types  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;  rQ  r$  rY  local_partial_typesr  r  r   r7  r(  )r-  r)  rM  disallow_other_scopesscope_actives        r  r  z,TypeChecker.find_partial_types_in_all_scopes  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  rS  )r-  rX  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?   rG  r  r  r  )r-  rG  r  r  s       r  r  zTypeChecker.failA  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?   rG  r  r  r  )r-  rG  r  r  r  s        r  r  zTypeChecker.noteI  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@  r  r   r   r  )r-  r  r  r  rE  s        r  rZ  zTypeChecker.iterable_item_typeW  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  )r-  r  s     r  r   zTypeChecker.function_typeb  s    T4??3F#G#GHHHr  rE  rF  c                   t          |          r| j                                         d S |                                D ]"\  }}| j                            |||           #d S )NrE  )rG  rH  r  r  r  )r-  r  rF  r)  r  s        r  r  zTypeChecker.push_type_mape  su    h'' 	MK##%%%%%&nn.. M M
ddOLLLLM Mr  ra   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  r8  )r  r  r  r  r   rU  r   r   r   r  r   r8  r  r   r  rg  r  r  r  r$  convert_to_typetype)r-  r  r)  r  r  
union_listrX  r  r  r*  r,  s              r  r  z!TypeChecker.infer_issubclass_mapsl  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] | NonerC  r  tuple[Type | None, Type | None]c                   d S r,  r  r-  r#  r  rL  rC  r  s         r  r  z/TypeChecker.conditional_types_with_intersection  s	     +.#r  c                   d S r,  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   ry  r  r   r   r8  r  r  rO  r  rG  impossible_intersectionr   )r-  r#  r  rL  rC  r  initial_typesr  r  r  possible_expr_typespossible_target_typesr  r  outrF  r  rX  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  rf   r)  )r-  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  r8  )r-  r)  r  r  r  r  rP  
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  r-  s     r  r  z6TypeChecker.get_type_range_of_type.<locals>.<listcomp>   s'    SSS466t<<SSSr  c                     g | ]}||j         S r,  r  rW  s     r  r  z6TypeChecker.get_type_range_of_type.<locals>.<listcomp>   s    )W)W)WQ!&r  Tr  FrP  r  ztypes.UnionTypeztyping._SpecialForm)r   r  r   rU  r   r  r   r    r   r  r  r  r   r*   r   r  r   r   r  r  r   r  r  r  r   r  r   )r-  rP  r  r  any_parameterizederased_typer  ry  s   `       r  r  z"TypeChecker.get_type_range_of_type   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&  r  r  )r-  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  r-  s     r  r  z9TypeChecker.add_any_attribute_to_type.<locals>.<listcomp>~   s)    TTTA66q$??TTTr  )rU  r  c                <    g | ]}                     |          S r  r  )r  rP  r  r-  s     r  r  z9TypeChecker.add_any_attribute_to_type.<locals>.<listcomp>   s)    ___3T;;CFF___r  )r   r   r   unannotatedr  r   copy_with_extra_attrrI  mod_namer   r  ru  r   r&  r   r  r+  r  r  r   rU  r  r   partition_union_by_attrr   )	r-  rP  r  r  r?  r  r&  	with_attrwithout_attrs	   ` `      r  r  z%TypeChecker.add_any_attribute_to_typed   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   )r-  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 r,  )r  r  r8  )r-  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)rQ  rR  rS  rT  r2  no_deferralmodule_symbol_table)r   r  r   r   rI  r  r  rk  rG  r  r%   r   r   r-  r  )r-  rP  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  )r-  r  r  s      r  get_expression_typezTypeChecker.get_expression_type   s     ''<'HHHr  c               :    | j         |j        j                 j        S r,  )rW  r  r  rp  )r-  rP  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  rf   r  ro   r   r   
deprecatedrd  importsrv   r  rk  r  )r-  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  rH  )r  r  r  s     r  r  z.TypeChecker.warn_deprecated.<locals>.<genexpr>   sY         "Gdm&>&>!www&G&G     r  r  )r  rf   r  ro   r   r   r  rr  r  rY  deprecated_calls_excludereport_deprecated_as_noterG  r  r  r  
DEPRECATED)r-  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  )ra  )r-  r  r  s      r  r  z!TypeChecker.new_unique_dummy_name   s.    5	55DO551r  r   c                   d S r,  r  r&  s     r  visit_pass_stmtzTypeChecker.visit_pass_stmt       tr  r   c                   d S r,  r  r&  s     r  visit_nonlocal_declzTypeChecker.visit_nonlocal_decl   r  r  rq   c                  | j         j        r|j        D ]}| j                            |          }|rt          |j        t                    rq|j        j        et          |          }|j        |_        t          |_        |j        j        |_        t          |          }|| j                            |||           d S d S r,  )rY  r  rk  rU  r  r  r  r   r  r   rQ   r  r  r   rH  r  )r-  r"  r  r!  r  rP  s         r  visit_global_declzTypeChecker.visit_global_decl   s    <* 	= 	= 	=l&&t,, =:ch44 =9R A XAF!AF!$!2AJ)!,,C//3<<<	= 	=	= 	=r  )rF  r2   rW  rV  rY  r   rd  r~   re  rf  r_  r   rg  rh  r)  r*  )r)  rI  )r)  r  r)  r*  )r  r  r  r   r)  r*  T)ry  r'  r)  r*  r,  )
r  r  rs  r'  ry  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  rf  r  rd   r)  r*  )r  r   r)  r*  )
r  r   r  r  r  r  r  r  r)  r*  )r  r   r)  r*  )r  r   r)  rH  )rJ  rK  rL  rd   r)  rM  )rP  r   r  r'  r)  r'  rP  r   r)  r'  )r  r   r  r'  r)  r   )r  r   r)  r   )r  ro   r)  r*  )NNF)
r  rp   r  rM  r  r  r  r'  r)  r*  )r  ro   r  r   r)  r*  )r)  rH  F)
r  rp   rP  r   r  r  r  r'  r)  r*  )r  rp   rP  r   r  r  r  rp   r  r   r)  r*  )r  r   r  ro   r)  r'  )r  r   r1  r`  r)  r'  )rP  r   r)  r*  )r  rp   r  r=  r)  r*  )rM  rf  r)  r'  )rB  rp   r)  r*  )rB  ro   rP  r   r)  r*  )
r  rp   rm  r   rn  rf  r  rd   r)  r*  )rm  r   rn  rf  r  r   r  r   r  rf  r  r   r  rd   r)  r*  )r  r   r  r   rm  r   r)  r'  )r  rn   r)  r*  )rP  r   r  rd   r  rf  r)  r*  )rP  r   r  rd   r)  r*  )r)  r   rP  r   r  rd   r)  r*  )r  rp   rP  r   r)  r  )r  r  rG  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  rf  r  r   r)  r'  )r  r   r)  rK  )r  r   r  r   r  rf  r  rf  r  rf  r  r'  r  r'  r  rd   r)  r'  )r  rp   r)  r*  )r  rb   r)  r*  )rP  r   r)  r*  )r  rY  r)  r*  )r  rb   r  r   r)  r*  )r!  r   r)  r'  )
r  rf  r  r   r  r   rL  r   r)  r*  )r  rv   r)  r*  )r  rt   r)  r*  )r  rs   r)  r*  )r  ru   r)  r*  )rr  r^   r)  r*  r)  r'  )r  r   r)  r'  r  r\   r)  r*  )r	  r{   r  rj   r  r'  r)  r*  )r  r   r  rj   r)  rK  )r	  r{   r  rj   r  rf  r)  r*  )r	  r   r  rj   r)  r*  )r  r   r  rj   r  r   r  r   r  r   r  r'  r)  r'  )r  rf  r  r   r  rd   r/  r'  r*  r'  r~  r  r)  r  )r  r   r  r   r  r"  r)  r'  )r  rf  r  r"  rL  rd   r)  r*  )r  r'  r)  rH  )r  r2  r)  r*  )r	  r{   r)  r*  )r	  r{   rP  rK  r)  r'  )rH  rI  r)  rI  )
r  rP  r  rj   r  rd   r  r'  r)  r*  )
r  rP  rr  r`  r  rd   rs  rt  r)  r'  )TNF)r  rP  r  rj   r  rd   r  r'  r  rK  r  r'  r)  r*  )r  rI  r  rj   r  r   r  rd   r  r'  r)  r*  )r  rI  r)  rI  )r  rP  r  rj   r  r   r  rd   r  r'  r  r'  r)  r*  )r  rP  r  r   r)  r   )r  r  ri  r`  r  r`  r)  r  )r  r   r)  r'  )
r  rP  r  r   r  rd   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'  )rX  r   r)  r'  )r)  r   r	  r{   r  r   r)  r*  r  r   r)  r   )r  rj   r)  r'  )r  rK  r  rj   r  rK  r  rK  r  r  rT  r'  r)  r   )r  rK  r  rj   r  rd   rG  r?   rD  rf  rE  rf  rF  r  r	  r  r  r  r)  r  )r  r   r)  r'  )r  r   r  r   r)  r'  )r	  r}   r  r   r
  r   r  rj   r  rd   r)  r  )r	  rw   r  rj   r  rd   r)  r*  )r)  r   r  r   rQ  r%  r)  r*  )r	  rw   r  rj   r)  r*  )rP  r   r)  r  )r  rk   r)  r*  )r  r   r)  r*  )r)  rj   r+  r   r,  r'  r)  r   )r  rr   r)  r*  )r  r   r)  r*  )r  r   r)  r*  )r  rZ   r)  r*  )r  r   r)  r*  )rw  rj   r  r   r\  r'  r)  r*  )r  r   r)  r*  )r  r   rg  r'  r)  r*  )r  rj   rq  r'  r)  r   )rq  r'  r)  r   )r  r  r)  r   )rP  r   r  rj   r)  rN  r  rm   r)  r*  )r)  rj   r)  r  )r  r   r  rd   r)  r  )r)  rj   r)  rK  )rP  r   r)  rK  )
r  rj   rE  r   r  r'  r  rd   r)  r*  )r  rg   r)  r*  )rw  rf   r)  r*  FF)rw  rf   r  r'  r   r'  r)  r*  )r  ro   r  r   r  rj   r)  r*  r  r   r)  r*  )rP  r   r  ro   r)  r*  )r)  rj   r5  r  r  r'  r)  r   )r  r_   r)  r*  )r  re   r)  r*  )r  r|   r)  r*  )r  r|   r  rj   r)  rj   )r)  rj   rP  r   r)  r5  )r  r  r)  r  )r  r!  r  r  r)  r*  )r"  r   r)  r*  )
r(  rf  r)  rf  r*  rf  r1  r+  r)  r,  )r0  r1  rF  r2  r)  rb  )rP  r   rP  r   r)  r   )rP  r   r)  r   )rP  r   r]  r'  r)  r^  )r)  rj   ri  rK  r)  rj  )rE  r   rT  r   r)  r  )rX  r   r)  rj   r)  r*  )r  rj   r  r'  r)  rj  )r  rc   r)  rj  )r  rf  r  rI  r  rN  r  r  r  r  r)  rj  )r  r!  r)  r!  )r)  rj   r#  r   r)  r!  )r)  rj   r  r5  r)  rj   )r)  rj   r)  r'  )r)  rj   r)  rt  )r  rc   r)  r  )rP  r   r  rf  r+  r`  r)  r  )rP  r   r  rf  r+  r`  r)  r  )rP  r   r  rf  r+  r`  r)  r  r  )r  r   r  r   r  rd   rG  rf  r  r  r  r  rF  r  r  rC  r6  r  r)  r'  )r  r   r  r   r  rd   rG  r?   r  r  r  r  rF  r  r6  r  r)  r'  )r  r   r  r   r  rd   rG  rF  r  r  r  r  rF  r  r  rC  r6  r  r)  r'  )rP  r   r  r3   r)  rK  )
r  r   r  r   r  rd   r  rC  r)  r*  )r  rf  r)  r   )r  rf  r  rN  r)  r   )r  rf  r)  r   )r)  r   )r  rj   rP  r   r)  r*  )r  rj   r)  r'  )r  rj   r)  rK  )r  rj   r)  r   )r  r5  r)  r*  )r  rf  r)  r   )r&  r'  r*  r'  r)  rH  )
rP  r   rQ  r'  r  r   r  rd   r)  r   )r)  r   r)  r'  )r)  r   r)  r  )r)  r   r)  r  )rX  r   r  r  r)  r   )rG  rF  r  rd   r  rC  r)  r1   r  )
rG  rF  r  rd   r  r`  r  rC  r)  r*  )r  r   r  rd   r)  r   )r  rn   r)  r   )r  r!  rF  r'  r)  r*  )r  ra   r)  rj   r)  rj  )r#  r   r  r  rL  rd   rC  r*  r  r'  r)  r  )r#  r   r  r  rL  rd   rC  r   r  r'  r)  r  )r#  r   r  r  rL  rd   rC  rK  r  r'  r)  r  )r  r   r)  r'  )r)  rj   r  r'  r)  r  )rP  r   r)  r  r  rj   r)  r'  )rP  r   r  rf  r)  r   )r)  rj   r  r   r  rf  r)  rj  )r  r   r  rf  r)  r^  )rP  r   r  rf  r)  r'  )r  rj   r  rK  r)  r   )rP  r   r)  r'  )r  r"  r  rd   r)  r*  )r  rf  r)  rf  )r"  r   r)  r*  )r"  r   r)  r*  )r"  rq   r)  r*  )r  r  r  rD  rp  r  rn  r  r  ro  rr  rZ  r[  r.  propertyr  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r   r  r.  r6  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r1  rQ  r  r  r  r  r}  r  r=  r  r  r  r  r  r<  r8  r  r  r  r  r  r  rJ  r:  r6  r  rA  rd  rj  rf  rg  r@  r8  r  r9  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  r  r]  ra  r  r4  r  r  r^  rY  r  r  r  r  r  r  r  r  r  r  r  r   r  rJ  r   r  r  r  r  r  r   r&  r*  r3  r(  rJ  rM  rT  rZ  r_  r]  rj  rh  rp  rx  rz  rv  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  rX  r\  ra  rn  rv  r{  r  r  r  r  r  r  r  r  r  r  r  r  r  r/  r0  r   r  r]  r_  rR  r  re  r  r@  rh  r  r  r  r  r  r  r  rz  rh  r  r  r  r  r  r=  r  r  rZ  r   r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r3  r3    sd          GNNN -,,, "!!!3333####MMM))))   :999     '&&&H!I " 8<;;;;"""""  )((( NNN OOO))))T. T. T. T.l " " " X" / / / X/) ) ) )&J J J J
. . . . .d IM( )-'+( ( ( ( ( (T ?  ?  ?  ?DE E E E. . . .H H H H: : : : _ _ _ _ '+;'
 -137;' ;' ;' ;' ;' ;'B2 2 2 2m5 m5 m5 m5^ : : : ^: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* * * *X 2 2 2 ^2 X]\% \% \% \% \%|DW DW DW DWL@ @ @ @D   "   ('! '! '! '! '!R; ; ; ;> > > >&J &J &J &JP" " " "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 32K) K) K) K)Z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 MQ|D |D |D |D |D~ *@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%'n, #'$(#n, n, n, n, n, n,`
 
 
 
    #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   ,% % % %" " " "    B'= '= '= '=R,) ,) ,) ,)\)0 )0 )0 )0V   4 4 4 4   .
 
 
 
"	# 	# 	# 	#" " " "& & & &&   6   ,\ \ \ \   $& & & & PU_6 _6 _6 _6 _6B	K 	K 	K 	K[ [ [ [#  #  #  # J; ; ; ;
 
 
 
&   # # # #   U U U Un! ! ! !$       % % % %N# # # #&. . . .   ,dd dd dd ddL? ? ? ?<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M_ M_ M_ M_^k  k  k  k Z	M M M M4V V V VB   $E E E E   ,! ! ! ! _ _ _ _B? ? ? ?4@% @% @% @%D% % % %H  %)&* #'!%(,     X  %)&* #'(,     X& %)&*P #'!%(,P P P P P Pd   , 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  r3  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.
    r3  _chkdict[str, SymbolTableNode]_namesr'  did_failr2  rk  r)  r*  c                0    || _         || _        d| _        d S rA  )r  r  r  )r-  r2  rk  s      r  r.  z&TypeCheckerAsSemanticAnalyzer.__init__!  s    	r  Fr  rf  rL  rd   r  SymbolTableNode | Nonec                R    | j                             |          }|
J |            |S r,  )r  r  )r-  r  rL  r  r!  s        r  rh  z.TypeCheckerAsSemanticAnalyzer.lookup_qualified!  s-     kood## 
r  r  r   c               H    |                      |          }|
J |            |S r,  )lookup_fully_qualified_or_none)r-  r  r*  s      r  lookup_fully_qualifiedz4TypeCheckerAsSemanticAnalyzer.lookup_fully_qualified !  s)    11(;;
r  c               Z    	 | j                             |          S # t          $ r Y d S w xY wr,  )r  rh  r  r-  r  s     r  r  z<TypeCheckerAsSemanticAnalyzer.lookup_fully_qualified_or_none%!  s?    	9--h777 	 	 	44	s    
**N)blockerr  rG  seriousr	  r  rC  c                   d| _         d S r  )r  )r-  rG  rL  r	  r	  r  s         r  r  z"TypeCheckerAsSemanticAnalyzer.fail+!  s     r  r  c                   d S r,  r  )r-  rG  rL  r  s       r  r  z"TypeCheckerAsSemanticAnalyzer.note6!      r  featurec                \    || j         j        j        vr|                     d|           dS dS )N__ignored__FT)r  rY  rA  r  )r-  r	  rL  s      r  incomplete_feature_enabledz8TypeCheckerAsSemanticAnalyzer.incomplete_feature_enabled9!  s3    $)+EEEIImS)))5tr  c                    d S r,  r  r  s    r  record_incomplete_refz3TypeCheckerAsSemanticAnalyzer.record_incomplete_ref?!  r	  r  debug_contextr  force_progressc                    d S r,  r  )r-  r	  r	  s      r  deferz#TypeCheckerAsSemanticAnalyzer.deferB!  r	  r  c                    dS rA  r  r	  s     r  is_incomplete_namespacez5TypeCheckerAsSemanticAnalyzer.is_incomplete_namespaceE!  s    ur  c                    dS r  r  r  s    r  final_iterationz-TypeCheckerAsSemanticAnalyzer.final_iterationH!      tr  flagc                @    | j         j                            |          S r,  )r  rd  is_future_flag_set)r-  r	  s     r  r	  z0TypeCheckerAsSemanticAnalyzer.is_future_flag_setL!  s    y~00666r  c                $    | j         j        j        S r,  )r  rd  rp  r  s    r  is_stub_filez*TypeCheckerAsSemanticAnalyzer.is_stub_fileO!  s    y~%%r  c                    dS rA  r  r  s    r  is_func_scopez+TypeCheckerAsSemanticAnalyzer.is_func_scopeS!  s	     ur  r  c                >    | j         j                                        S r,  )r  rM  r~  r  s    r  r  z"TypeCheckerAsSemanticAnalyzer.type[!  s    y,,...r  )r2  r3  rk  r  r)  r*  r  )r  rf  rL  rd   r  r'  r)  r  )r  rf  r)  r   )r  rf  r)  r  )rG  rf  rL  rd   r	  r'  r	  r'  r  rC  r)  r*  )rG  rf  rL  rd   r  rC  r)  r*  )r	  rf  rL  rd   r)  r'  r  rA  )r	  r  r	  r'  r)  r*  )r  rf  r)  r'  r  )r	  rf  r)  r'  )r)  r  )r  r  r  rD  r  r.  rh  r 	  r  r  r  r	  r	  r	  r	  r  r	  r	  r	  r	  r  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 )r9  z0Collects the non-nested argument types in a set.r)  r*  c                ,    t                      | _        d S r,  )rl  r"  r  s    r  r.  zCollectArgTypeVarTypes.__init__c!  s    +.55r  rX  r   c                :    | j                             |           d S r,  )r"  r  r}  s     r  visit_type_varz%CollectArgTypeVarTypes.visit_type_varf!  s    1r  Nr  )rX  r   r)  r*  )r  r  r  rD  r.  r"	  r  r  r  r9  r9  `!  sB        ::1 1 1 1     r  r9  TF)r  r  ri  r   proposed_type_rangesr  rC  r*  r  r'  r  r)  r  c                   d S r,  r  ri  r#	  rC  r  r  s        r  r  r  j!  s	     '*cr  r  c                   d S r,  r  r%	  s        r  r  r  u!  s	     r  rK  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 |rt=          |          }t?          | |d          st                      |fS t          j        d
 |D                       }t;          | ||	          }t3          ||d          r||n| }||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   )rC  r  r  c                    g | ]	}|j         
S r  r  r  r  s     r  r  z%conditional_types.<locals>.<listcomp>!  s    *b*b*bz:?*b*b*br  c              3  $   K   | ]}|j         V  d S r,  r  r)	  s     r  r  z$conditional_types.<locals>.<genexpr>!  s%      PPZz(PPPPPPr  Tr4  r  c                *    g | ]}|j         	|j        S r  )r  r  r)	  s     r  r  z%conditional_types.<locals>.<listcomp>!  s"    aaaZzG`aaaar  ) r   r  r  r   r  r   r  r  r'  r&  r  r  r   r   r  r  r8  r   r  r   
is_newtyper1  rc  r   r  r   r   r,  r   r   r,   r=   )ri  r#	  rC  r  r  r5  	enum_namep_current_typer=  no_items
union_itemr  r  proposed_typeremaining_typer  r  r  	remainderproposed_precise_types                       r  r  r  !  s   & #W$$ *  '))
  A%%%a(- ((fk** 	T""$$	T(26<(F(F	T ,5I:<SSL
 %\22N.),, - "	!(. 		% 		%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.'** +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%% G 8FFmtTTT *  ')) &0aa+?aaa  +$?  N $OOO I#*#6L.((r  r)  rj   r  r  rj  c                H    t          |           } |i n| |i}|i n| |i}||fS r,  r  )r)  r  r  r*  r,  s        r  r  r  !  s?     4  D$bb4*:G?RRwFF?r  r  rf  ry  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  )rf  )r  ry  r  s      r  rR  rR  "  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  rx   r  r  s    r  r  r  "  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   r8	  r9	  s    r  r  r  "  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.rA  r  r   r  r9	  s    r  r  r  "  s    a""Dqz_'DDr  r  c                B    t          | t                    o
| j        dk    S )Nrb  r<	  r9	  s    r  r  r  "  s    a""Nqz5N'NNr  r  rp   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  rk   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  rK  r  r  zbuiltins.frozensetz_collections_abc.dict_keysztyping.KeysViewNr   rK  c              3  B   K   | ]}t          |t                     V  d S r,  )r  r   r  s     r  r  z$builtin_item_type.<locals>.<genexpr>_"  s/      XXr:b'***XXXXXXr  typing.MappingFz2No Mapping base class found for TypedDict fallback)r   r  r   r  r  r  r   r   r  r   r   rU  r8  rx  r   r   r   r&  r  r<   )r  normalized_itemsr  rN  r  s        r  r  r  2"  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 r,  )r  r   r   r  s     r  r  z%is_unreachable_map.<locals>.<genexpr>l"  s4      UU1z/!,,o>>UUUUUUr  )r  r  )r$  s    r  rG  rG  k"  s'    UU

UUUUUUr  r  m1m2r  c               `   |                                 }d |D             }| D ]}t          |          }||vr| |         ||<   !|s| |         }t          |          }t          |t                    r|||<   U||         }	t          ||	                   }
t          |
t
                    r8t          |t                    rt          d |j        D                       s|||<   |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                .    i | ]}t          |          |S r  )r;   )r  e2s     r  r%  z(and_conditional_maps.<locals>.<dictcomp>w"  s"    222R  "222r  c              3  Z   K   | ]&}t          t          |          t                    V  'd S r,  )r  r   r   r  s     r  r  z'and_conditional_maps.<locals>.<genexpr>"  s4      ]]4Jt'<'<gFF]]]]]]r  )
copyr;   r   r  r   r   r   r  r  r>   )rH	  rI	  r  r  m2_exprse1e1_hasht1pt1rL	  pt2s              r  r  r  o"  sq    WWYYF22r222H $ $r""(""BF2J 	$ BB!"%%C#// 	$r

g&%bf--c7++ $sI..$]]SVS\]]]]]$ "$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.
    )rG  r;   r  r   r   r   )rH	  rI	  r  r  n1n2s         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_maprI  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 ]}|s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  "  sv    
2ww!||	
2ww!||!uUFV D D 	%fa(CCCMr  rX  c                J    t          | dd          pt          | dd          S )Nrp  F)	check_allrq  )r   rX  s    r  r  r  "  s:     H>>> BW	8uC C C 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 r,  )r  r  r   rU  r   r   r   r   r   r   r+  )r  converted_type_mapr)  rP  rX  s        r  r  r  "  s    13^^%%  	ca%% 	AA a)) 	'*t$$Ix:;; 	'/'?'D'Dt$$ IIIr  rI  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  arr  s      r  r  zflatten.<locals>.<listcomp>#  s+    777aGAJJ77q7777r  )r  r   rz   r  r   r  r)  r`	  s    r  r  r  #  sV    !i*++ 77177777	Ax	 	  qvs
r  rN  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  re	  s      r  r  z*flatten_types_if_tuple.<locals>.<listcomp>#  s/    %\%\%\ABXYZB[B[%\%\Qa%\%\%\%\r  c                6    g | ]}t          |          D ]}|S r  ri	  re	  s      r  r  z*flatten_types_if_tuple.<locals>.<listcomp>#  s.    FFFa,B1,E,EFFqFFFFr  rK  r   )r   r  r   rc  r  r   r   r  r`	  s    r  r  r  #  s    A!Y _$%\%\%\%\%\]]^^!Y FF17FFFF	1.	/	/ q	{3Jr  r  dict[TypeVarId, Type]c                |    t          |          }|                    |           }t          |t                    sJ |S r,  )TypeTransformVisitorr  r  rp   )r  r$  visitorr*  s       r  r  r  $#  s;    "3''G
,,t

Cc8$$$$$Jr  c                  (     e Zd Zd	 fdZd
dZ xZS )rm	  r$  rk	  r)  r*  c                V    t                                                       || _        d S r,  )superr.  r$  )r-  r$  r  s     r  r.  zTypeTransformVisitor.__init__,#  s$    r  r  r   c                ,    t          || j                  S r,  )r7   r$  r  s     r  r  zTypeTransformVisitor.type0#  s    4***r  )r$  rk	  r)  r*  r  )r  r  r  r.  r  __classcell__r  s   @r  rm	  rm	  +#  sQ             + + + + + + + +r  rm	  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)rX  r  r
  max_argss       r  rk  rk  4#  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  r=  r  s     r  r  z,expand_callable_variants.<locals>.<listcomp>B#  s'    HHHH1HHHr  r  c                $    i | ]\  }}|j         |S r  r  )r  r\  r  s      r  r%  z,expand_callable_variants.<locals>.<dictcomp>S#  s     RRR[b%BE5RRRr  )rr  r  r=  r7   rU  ru  
is_genericr  r   r  r8  r  r  r  )r  r\  tvar_valuesr  variantscombinationtvar_maps          r  expand_callable_variantsr	  ;#  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]r  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 r,  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 r,  r	  rb  s     r  re  z;is_unsafe_overlapping_overload_signatures.<locals>.<lambda>#  r	  r  )rf  r	  r   rh  r	  )detach_callabler	  r	  r%  r   !is_overlapping_types_for_overload)r  r  r	  r  other_expandedsig_variantother_variants          r  rp  rp  X#  s,   <  	?;;IE?33E
 .e44N/	:: ' '+ &	 &	M $K$8-:PQQ &!?+0&+%P%P*.   *!?+/&+%P%P*.  (    	'=.'+"'"&*( ( ( 	 ttt	;&	N 5r  rP  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  )rP  r	  s     r  r	  r	  #  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 r,  )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  rx  r  rX  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  r	  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&  )rP  r  r  existing_methods       r  rP  rP  #  s     #

C!(+FO#x   O.sFHEE	C	'	' O.s|VXNN"_$$&=r  rA  r   r  r  c                t    |t           j        v r)d|dd          z   }| j                            |          r|S d S )N__ir  )r   ops_with_inplace_methodr  rv  )rA  r  r  inplace_methods       r  r	  r	  #  sE    9444+9((88 	"!!4r  rY  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)rP  rY  r  r  r  s        r  r  r  $  so     "#&&K+x(( 
 W'7#7#VG<VW	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 r,  )rq	  r.  r   )r-  r  s    r  r.  zInvalidInferredTypes.__init__'$  s!    &&&&&r  rX  r   r'  c                    |j         S r,  )r  r}  s     r  visit_uninhabited_typez+InvalidInferredTypes.visit_uninhabited_type*$  s
    {r  r   c                    dS r  r  r}  s     r  visit_erased_typez&InvalidInferredTypes.visit_erased_type-$  r	  r  r   c                4    |j                                         S r,  )r  is_meta_varr}  s     r  r"	  z#InvalidInferredTypes.visit_type_var1$  s     t!!!r  r   c               6    |                      |j                  S r,  )query_typesr  r}  s     r  visit_tuple_typez%InvalidInferredTypes.visit_tuple_type6$  s    (((r  r  )rX  r   r)  r'  )rX  r   r)  r'  )rX  r   r)  r'  )rX  r   r)  r'  )
r  r  r  rD  r.  r	  r	  r"	  r	  rs	  rt	  s   @r  r	  r	   $  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).rX  r   r)  r   c                F    |j         rt          t          j                  S |S r,  )r  r   r   r  r}  s     r  r	  z&SetNothingToAny.visit_uninhabited_type>$  s"    ; 	19/000r  r   c                R     |                      fd|j        D                       S )Nc                :    g | ]}|                               S r  )r  )r  rf	  r-  s     r  r  z9SetNothingToAny.visit_type_alias_type.<locals>.<listcomp>F$  s#    $D$D$DQXXd^^$D$D$Dr  )r  )ru  r  r}  s   ` r  visit_type_alias_typez%SetNothingToAny.visit_type_alias_typeC$  s0     $D$D$D$DQV$D$D$DEEEr  N)rX  r   r)  r   )rX  r   r)  r   )r  r  r  rD  r	  r	  r  r  r  r  r  ;$  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  rf   r  ro   r*  r   re  r  s    r  r  r  I$  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  rf   r  ro   r  r   r  r	  s    r  r  r  T$  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 r,  )
_key_to_id_id_to_parent_id_root_id_to_valuesr  s    r  r.  zDisjointDict.__init__~$  s#    +-
 13 ;=r  rV  	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  r-  s     r  r  z,DisjointDict.add_mapping.<locals>.<listcomp>$  s'    KKKs55c::KKKr  r   r  )r	  r  r	  rB  )r-  rV  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_idrl  r  r  r8  r	  )r-  root_id_to_keysr  root_idr  rV  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 r,  )r	  r	  r  r	  rl  r	  )r-  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 r,  )r	  r	  )r-  r  r  
new_parents       r  r	  zDisjointDict._lookup_root_id$  sf    OC 4(+++ .t/DQ/GHJ'1D!!$A 4(+++ r  Nr  )rV  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	  c$  s         4
= 
= 
= 
=J J J J(           r  r	  pairwise_comparisons,Iterable[tuple[str, Expression, Expression]]operand_to_literal_hashMapping[int, Key]operators_to_groupr\  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>"%  s    471: r  )r  )	rl  r  r8  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_dictrV  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 r,  )r  r   type_of_anyr   r  rW  s     r  r  z$is_typed_callable.<locals>.<genexpr>*%  sO         	1gI1=I4I#I     r  )r   r  r   rx  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 )NTrO  c              3  4   K   | ]}t          |          V  d S r,  r  r  s     r  r  z'is_untyped_decorator.<locals>.<genexpr>?%  s+      TT$/55TTTTTTr  Fc              3  4   K   | ]}t          |          V  d S r,  r	  r  s     r  r  z'is_untyped_decorator.<locals>.<genexpr>E%  s+      DD$'--DDDDDDr  )r   r  r   r  r   r  rb  rf   r  r  r)  r   r  r  )rP  r  s     r  r  r  0%  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  rf   r  r  rn   r  )r  s    r  r  r  I%  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  ro   r  rf   r  r   r  r  s    r  r  r  Q%  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  rf   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  rf   r)  r  r/  r   r"  r   r   r   get_property_type)r  r  r)  r/  s       r  r  r  c%  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)r5  always_covariantra  r  s     r  r	  r	  %  s    dETDQQQQr  c                (    t          | |dd          S )NT)r5  overlap_for_overloads)r=   r  s     r  r	  r	  %  s      et[_````r  	node_namec                X    |                      d          o|                     d           S )z-Check if node is private to class definition.r  )rH  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  )rP  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   r  r  )rP  s    r  r+  r+  %  sP    o.. t#y!! SRR	RRRRRR5r  rw  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[   r5  )rw  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  r  )r  r  rn	  s      r  r4  r4  %  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)r-  r  s     r  r.  zVarAssignVisitor.__init__%  s    r  r  r\   c                `    d| _         |j        D ]}|                    |            d| _         d S r$  )r	  r  r  r-  r  r  s      r  r  z&VarAssignVisitor.visit_assignment_stmt%  s6    ) 	 	BIIdOOOOr  rw  r   c                v    | j         r/|j        | j        u r#t          | j        |j                  | _        d S d S d S r,  )r	  r  r
  rv	  r  r  r  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 rA  )r	  rq	  rO  r-  rw  
old_lvaluer  s      r  rO  z"VarAssignVisitor.visit_member_expr%  s4    [
!!!$$$ r  rw   c                t    | j         }d| _         t                                          |           || _         d S rA  )r	  rq	  visit_index_exprr
  s      r  r
  z!VarAssignVisitor.visit_index_expr%  s4    [
  ### r  r   c                    d| _         |j        D ]}||                    |            d| _         |j                            |            d S r$  )r	  r5  r  r  r
  s      r  r  z VarAssignVisitor.visit_with_stmt%  sP    ( 	  	 B~		$	dr  rm   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	  r5  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	  r-  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  )rw  r   r)  r*  )rw  r}   r)  r*  )rw  rw   r)  r*  r  r  )rw  r[   r)  r*  )r  r   r)  r*  )r  r   r)  r*  )r  r  r  r.  r  r
  rO  r
  r  r  r
  r
  r
  rs	  rt	  s   @r  r	
  r	
  %  s           
   9 9 9 9! ! ! ! ! !! ! ! ! ! !   % % % %                         r  r	
  r  zbuiltins.numeric)r  r  rd  zbuiltins.floatzbuiltins.complexOPEN_VALUE_EQUALITY_DOMAINS OPEN_VALUE_EQUALITY_DOMAIN_NAMESbuiltins.bytesrD	  typing.AbstractSet)r"
  zbuiltins.bytearrayzbuiltins.memoryviewrD	  r#
  CLOSED_VALUE_EQUALITY_DOMAINSVALUE_EQUALITY_DOMAINSc                      e Zd ZddZdS )	EqualityDomainInfo
type_namesr\  enum_type_namesr)  r*  c                "    || _         || _        d S r,  )r(
  r)
  )r-  r(
  r)
  s      r  r.  zEqualityDomainInfo.__init__&  s    $.r  N)r(
  r\  r)
  r\  r)  r*  r/  r  r  r  r'
  r'
  &  s(        / / / / / /r  r'
  c                      e Zd Zd	dZdS )
EqualityValueInfodomainsdict[str, EqualityDomainInfo]is_topr'  r)  r*  c                "    || _         || _        d S r,  )r-
  r/
  )r-  r-
  r/
  s      r  r.  zEqualityValueInfo.__init__&  s    r  N)r-
  r.
  r/
  r'  r)  r*  r/  r  r  r  r,
  r,
  &  s(             r  r,
  r  r  c               l   |r| dfS t          |           }t          |t                    r|                                n| g}g }g }|D ]=}t	          ||          r|                    |           (|                    |           >|rt          j        |          nd|rt          j        |          ndfS )a  Split current_type into ordinary-narrowable and equality-ambiguous pieces.

    Some values compare equal through a value domain broader than their nominal type. For
    example, an IntEnum member can compare equal to an int, and a StrEnum member can compare
    equal to a str. When narrowing `x: MyStrEnum | str` against `MyStrEnum.MEMBER`, we can
    still narrow the enum portion of the union, but we must keep the str portion in both
    branches.
    N)r   r  r   ry  #is_equality_ambiguous_for_narrowingr8  rc  )ri  r  r  rP  r  narrowable_itemsambiguous_itemsr  s           r  r  r   &  s      "T!!
,
'
'C$.sI$>$>RC   \NEO * *.t[AA 	*""4((((##D))))2BL	-...1@J	_---d r  c                8   t          |           }t          |          }|j        s|j        r;|j        r|n|}t          d |j                                        D                       S |j                                        |j                                        z  }|sdS |D ]x}|j        |         }|j        |         }|j        r1|j        |j        k    r!|j        |j        k    r|j        |j        k    rT|j        |j        k    r dS |j        s|j        r dS ydS )zOCan left compare equal to right through a value domain outside nominal overlap?c              3  <   K   | ]\  }}|t           v o|j        V  d S r,  )r!
  r)
  )r  domaindomain_infos      r  r  z6is_equality_ambiguous_for_narrowing.<locals>.<genexpr>F&  sH       
 
# 66V;;V
 
 
 
 
 
r  FT)equality_value_infor/
  r  r-
  r  rV  r)
  r(
  )	r  r  	left_info
right_info
other_infoshared_domainsr7
  left_domainright_domains	            r  r2
  r2
  =&  sh   #D))I$U++J 
:, 
 $-#3BZZ
 
 
'1'9'?'?'A'A
 
 
 
 
 	

 &++--
0B0G0G0I0IIN u   '/!)&1 '	+|/KKK&+*EEE'<+GGG !\%<<<44 & 	,*F 	44	 5r  c                   t          |           } t          | t                    rt          d | j        D                       S t          | t
                    r9| j        rt          d | j        D                       S t          | j                  S t          | t                    r| j
        t          | j
                  S t          | t                    rt          | j                  S t          | t                    r| j        j        dk    rt          i d          S | j        j        r| j        j        hnt#                      }i }| j        j        D ]A}t&                              |j                  x}rt+          | j        j        h|          ||<   Bt          |d          S t          | t,                    rt          i d          S t          i d          S )Nc              3  4   K   | ]}t          |          V  d S r,  r9
  r  s     r  r  z&equality_value_info.<locals>.<genexpr>i&  s+      *Y*Y+>t+D+D*Y*Y*Y*Y*Y*Yr  c              3  4   K   | ]}t          |          V  d S r,  rB
  r  s     r  r  z&equality_value_info.<locals>.<genexpr>l&  s+      .^.^T/B4/H/H.^.^.^.^.^.^r  r8  T)r/
  F)r   r  r   combine_equality_value_infor  r   r  r9
  rU  r   r  r   r&  r  r  r,
  r5  rl  r  r%
  r  r'
  r   )rX  r)
  r-
  r  r7
  s        r  r9
  r9
  f&  s   A!Y Z**Y*YQRQX*Y*Y*YYYY![!! 28 	_..^.^UVU].^.^.^^^^"1=111!X 71#5#A"1#5666![!! /"1:...!X 
86?///$R5555/0v~H16?++355FJ 	Y 	YD/33DMBBBv Y"4afo5F"X"X 7777!W 2 D1111R....r  infosIterable[EqualityValueInfo]c                   i }d}| D ]}|j                                         D ]\  }}|                    |          }|8t          t	          |j                  t	          |j                            ||<   T|j                            |j                   |j                            |j                   |p|j        }t          ||          S rA  )
r-
  r  r  r'
  rl  r(
  r)
  r  r/
  r,
  )rE
  r-
  r/
  r7  r7
  r8
  existing_domain_infos          r  rD
  rD
  &  s    -/GF 
' 
'#'<#5#5#7#7 	Y 	YFK#*;;v#6#6 #+"4.//[5P1Q1Q# # %/66{7MNNN$4;;K<WXXXX&4;Wf---r  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 r,  )r  r   r  rf   r)  ro   r	  s    r  r  r  &  sQ    $)** $###$	"" (8'''dG$$$r  r,  )ri  r   r#	  r  rC  r*  r  r'  r  r'  r)  r  )ri  r   r#	  r  rC  r   r  r'  r  r'  r)  r  )ri  r   r#	  r  rC  rK  r  r'  r  r'  r)  r  )r)  rj   r  rK  r  rK  r)  rj  )r  rf  ry  r   r)  rf  r  )r  r  r)  r'  )r  rp   r)  r'  )r  r   r)  rK  )r$  r!  r)  r'  )rH	  r!  rI	  r!  r  r'  r)  r!  )rH	  r!  rI	  r!  r  r'  r)  r!  r  )r  r  r  r'  r)  rj  )r[	  r  r)  r!  )r[	  r  r  r'  r)  r!  )rX  r   r)  r'  )r  r!  r)  r!  )rX  rj   r)  rI  )rX  r   r)  rN  )r  rp   r$  rk	  r)  rp   )rX  r   r  r   r)  r'  )r  r   r)  rz	  r  )
r  r   r  r   r	  r	  r  r'  r)  r'  )rP  r   r	  r	  r)  r   )r  r   r  r   r)  r'  )rX  r   r  r   r)  r'  )rP  r   r  rf  r)  r	  )rA  r   r  rf  r  rf  r)  r  r  )
rP  r   rY  r   r  r'  r  r'  r)  r'  )r  r	  r)  r=  )r	  r	  r	  r	  r	  r\  r)  r	  )r  rK  r)  r'  )rP  rK  r)  r'  )r  r	  r)  r'  )r  r   r)  r'  )r  r	  r)  r	  )r  r	  r)  r'  )rX  r   r)  r   )r  r   r  r   r)  r'  )r 
  rf  r)  r'  r  )rP  r   r)  r'  )rw  rj   r)  rj   )r  r   r  r   r)  r`  )ri  r   r  r   r  r'  r)  r  )rX  r   r)  r,
  )rE
  rF
  r)  r,
  )r  r   r)  r'  )r  r	  r)  r'  (  rD  
__future__r   r  collectionsr   collections.abcr   r   r   r   r	   r
   AbstractSet
contextlibr   r   r  r   r   r   r   r   r  r   r   r   r   mypy.checkexprr~  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>   mypy.message_registryr?   mypy.messagesr@   rA   rB   rC   rD   rE   rF   rG   rH   mypy.mrorI   rJ   
mypy.nodesrK   rL   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   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   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#  r1  r3  r  r9  r  r  rR  r  r  r  r  r  r  rG  r  r  r  r  r  r  r  r  r  r  rm	  rk  r	  rp  r	  rl  r  r	  rP  r	  r  r	  r  r  r  r	  r	  r	  r  r  r  r  r  r*  r  r	  r	  r	  r  r  r+  r  r4  r	
  r 
  	frozensetr  r!
  r$
  r%
  r'
  r,
  r  r2
  r9
  rD
  r  r  r  r  r  <module>ry
     s  : : :x # " " " " "     # # # # # # _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 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 6 6 6 6 6 6 6 6 . . . . . .
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 - , , , , , , ,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                                             .) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) )T 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+, , , , ,( ( ( ( ( ( ( (       (C~= C~= C~= C~= C~=+d#%9;K C~= C~= C~=L|X/ X/ X/ X/ X/$A X/ X/ X/v    1    
 *
 )-* * * * * 
* 
 )-     
  x)
 )-x) x) x) x) x) x)v      ] ] ] ]
^ ^ ^ ^
E E E E
O O O O    6 6 6 6rV V V V HM ( ( ( ( ( (V KP      6 @E$, $, $, $, $,N	 	 	 	         &   	 	 	 	   + + + + ++ + + +          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
/ / / /
      	 	 	 	>  >  >  >  > ' >  >  > H #'&(*& &      +4)4O4V4V4X4X*Y*Y   Y Y Y Y '*+&.( (      !a#> `B_ `  ` ` ` `/ / / / / / / /          :& & & &R/ / / /8. . . ."   % % % % % %r  