Ë
    pPê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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§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¼ ddl½m¾Z¾m¿Z¿ ddlÀmÁZÁmÂZÂ ddlÃmÄZÄ ddlÅmÆZÇ ddlÈmÉZÉ dd lÊmËZËmÌZÌmÍZÍ dd!lÎmÏZÏmÐZÐ dd"lÑmÒZÒ dd#lÓmÔZÔ dd$lÕ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á dd&lâmãZãmäZämåZå dd'læmçZç dd(lèméZémêZêmëZë dd)lìmíZímîZîmïZïmðZðmñZñmòZòmóZómôZômõZõmöZöm÷Z÷møZømùZùmúZúmûZûmüZümýZýmþZþmÿZÿ�m �Z �m�Z 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*�m+�Z+�m,�Z, dd+�l-�m.�Z.�m/�Z/�m0�Z0�m1�Z1 dd,�l2�m3�Z3 dd-�l4�m5�Z5�m6�Z6�m7�Z7 dd.�l8�m9�Z9�m:�Z: dd/�l;�m<�Z<  ed0«      �Z=d1�Z>d2�e?d3<   d4�Z@d2�e?d5<   e‰ežz  e€z  �ZAd6�e?d7<   e‰e˜z  ežz  �ZBd6�e?d8<    G d9„ d:e«      �ZC G d;„ d<e«      �ZD�eEe„�ef   �ZFd6�e?d=<    G d>„ d?«      �ZG G d@„ dA«      �ZH G dB„ dC�e<d   e*e¦«      �ZI G dD„ dEeÒ«      �ZJ G dF„ dG�e3«      �ZKe	 dŸdHdIdJœ	 	 	 	 	 	 	 	 	 	 	 d dK„«       �ZLedHdIdJœ	 	 	 	 	 	 	 	 	 	 	 d¡dL„«       �ZL	 dŸdHdIdJœ	 	 	 	 	 	 	 	 	 	 	 d¢dM„�ZL	 	 	 	 	 	 	 	 d£dN„�ZMd¤dO„�ZNd¥dP„�ZOd¥dQ„�ZPd¥dR„�ZQd¦dS„�ZRd§dT„�ZSd¨dU„�ZTd©dV„�ZUdIdWœdªdX„�ZVdIdYœd«dZ„�ZW	 d¬	 	 	 	 	 d­d[„�ZXd®d\„�ZYd¯d]„�ZZd°d^„�Z[d±d_„�Z\d²d`„�Z]d³da„�Z^d´db„�Z_ G dc„ ddeç«      �Z`dµde„�Zad¶df„�Zb	 d·	 	 	 	 	 	 	 	 	 d¸dg„�Zcd¹dh„�Zddºdi„�Zed»dj„�Zfdµdk„�Zgd¼dl„�Zhd½dm„�Zi	 d¾	 	 	 	 	 	 	 	 	 d¿dn„�Zj G do„ dp�e«      �Zk G dq„ dr�e«      �ZldÀds„�ZmdÀdt„�Zn edu«      �Zo edv«      �Zp G dw„ dxe�eo�epf   «      �Zq	 	 	 	 	 	 	 	 dÁdy„�ZrdÂdz„�ZsdÃd{„�ZtdÄd|„�ZudÅd}„�ZvdÆd~„�ZwdÇd„�ZxdÈd€„�ZydÉd�„�ZzdÉd‚„�Z{dÊdƒ„�Z|dËd„„�Z}dÌd…„�Z~dÍd†„�ZdÎd‡„�Z€ G dˆ„ d‰eã«      �Z�dŠd‹d‹d‹d‹dŒœ�Z‚d2�e?d�<    �eƒ�e‚�j	                  «       «      �Z…d2�e?dŽ<   d�d�d�d�d‘d’œ�Z†d2�e?d“<   i �e‚¥�e†¥�Z‡d2�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ž„�Z�y)Ô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Ú!extend_args_for_prefix_and_suffixÚfind_unpack_in_listÚflatten_nested_unionsÚget_proper_typeÚget_proper_typesÚget_variadic_itemÚ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<   y)ÚDeferredNoder  ÚnodeúTypeInfo | NoneÚactive_typeinfoN©Ú__name__Ú
__module__Ú__qualname__Ú__annotations__© ó    úQ/home/oem/CyberBrain26-unified/.venv/lib/python3.12/site-packages/mypy/checker.pyr  r  F  s   … Ø
Óà$Ô$r  r  c                  ó"   — e Zd ZU ded<   ded<   y)ÚFineGrainedDeferredNoder  r  r  r  Nr  r  r  r   r"  r"  N  s   … Ø
%Ó%Ø$Ô$r  r"  ÚTypeMapc                  ó   — e Zd Zdd„Zy)ÚPartialTypeScopec                ó.   — || _         || _        || _        y ©N)ÚmapÚis_functionÚis_local)Úselfr(  r)  r*  s       r   Ú__init__zPartialTypeScope.__init__g  s   € ØˆŒØ"-ˆÔØ'ˆ�r  N)r(  údict[Var, Context]r)  Úboolr*  r.  ÚreturnÚNone©r  r  r  r,  r  r  r   r%  r%  f  s   „ ô(r  r%  c                  ó(   — e Zd ZdZdd„Zdd„Zdd„Zy)	ÚLocalTypeMapz¼Store 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).
    c                ó   — || _         y r'  )Úchk)r+  r5  s     r   r,  zLocalTypeMap.__init__t  s	   € Øˆ�r  c                óT   — i }| j                   j                  j                  |«       |S r'  )r5  Ú
_type_mapsÚappend)r+  Útemp_type_maps     r   Ú	__enter__zLocalTypeMap.__enter__w  s%   € Ø02ˆØ�‰×Ñ×"Ñ" =Ô1ØÐr  c                óL   — | j                   j                  j                  «        y©NF)r5  r7  Úpop)r+  Úexc_typeÚexc_valÚexc_tbs       r   Ú__exit__zLocalTypeMap.__exit__|  s   € Ø�‰×Ñ×ÑÔ!Ør  N)r5  ÚTypeCheckerr/  r0  )r/  údict[Expression, Type])r>  Úobjectr?  rD  r@  rD  r/  zLiteral[False])r  r  r  Ú__doc__r,  r:  rA  r  r  r   r3  r3  m  s   „ ñóóô
r  r3  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<   	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 �d7d7„Ze�d8d8„«       Ze�d9d9„«       Z�d:d:„Z�d;d;„Z�d<�d=d=„Z	 �d>d<d<dd>œ	 	 	 	 	 	 	 	 	 �d?d?„Z	 	 	 	 	 	 �d@d@„Z�dAdA„Z�dBdB„Z�dCdC„Z�dDdD„Z�dEdE„Z	 �d>d(d(dFœ	 	 	 	 	 	 	 	 	 �dFdG„Z�dGdH„Z�dGdI„Ze�dHdJ„«       Z�dIdK„Z �dGdL„Z!�dJdM„Z"�dKdN„Z#�dLdO„Z$�dLdP„Z%�dMdQ„Z&�dLdR„Z'�dNdS„Z(�dNdT„Z)	 	 	 �dO	 	 	 	 	 	 	 	 	 �dPdU„Z*�dQdV„Z+e�dRdW„«       Z,	 �dS	 	 	 	 	 	 	 	 	 �dTdX„Z-	 	 	 	 	 	 	 	 	 	 	 	 �dUdY„Z.�dVdZ„Z/�dWd[„Z0�dXd\„Z1�d>�dYd]„Z2�dZd^„Z3�dZd_„Z4�d[d`„Z5�d\da„Z6	 	 	 	 	 	 	 	 	 	 �d]db„Z7	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 �d^dc„Z8	 	 	 	 	 	 	 	 �d_dd„Z9�d`de„Z:�dadf„Z;�dbdg„Z<�dbdh„Z=�dcdi„Z>	 	 	 	 	 	 �dddj„Z?	 �d>	 	 	 	 	 	 	 �dedk„Z@	 	 	 	 �dfdl„ZA	 	 	 	 	 	 	 	 �dgdm„ZB�dhdn„ZC	 	 	 	 	 	 	 	 �dido„ZD�djdp„ZE	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 �dkdq„ZF�dldr„ZG�dmds„ZH�dndt„ZI�dmdu„ZJ�dodv„ZK�dmdw„ZL�dpdx„ZM�dqdy„ZN�dmdz„ZO�dmd{„ZP�dmd|„ZQ�dnd}„ZR	 	 	 	 	 	 	 	 	 	 �drd~„ZS�dnd„ZT�dmd€„ZU�dsd�„ZV�dtd‚„ZW�dudƒ„ZX�dvd„„ZY�dwd…„ZZ�dxd†„Z[�dyd‡„Z\�dzdˆ„Z]�dzd‰„Z^	 �d<	 	 	 	 	 	 	 �d{dŠ„Z_d‹dŒhZ`d�edŽ<   �d|d�„Za	 	 	 	 	 	 	 	 �d}d�„Zb�d~d‘„Zc	 	 	 	 	 	 	 	 	 	 	 	 	 	 �dd’„Zdddd(d“œ	 	 	 	 	 	 	 	 	 	 	 	 	 �d€d”„Ze	 	 	 	 	 	 	 	 �d�d•„Zf	 	 	 	 	 	 	 	 �d�d–„Zg	 	 	 	 	 	 	 	 �d‚d—„Zh�dxd˜„Zie�dƒd™„«       Zj�d„dš„Zk�d…d›„Zl�d†dœ„Zm�d‡d�„Zn	 �d<	 	 	 	 	 	 	 	 	 �dˆdž„Zo	 �d>	 	 	 	 	 	 	 	 	 �d‰dŸ„Zp	 	 	 �dŠ	 	 	 	 	 	 	 	 	 	 	 	 	 �d‹d „Zq	 	 	 	 	 	 	 	 	 	 	 	 �dŒd¡„Zr�d�d¢„Zs	 	 	 	 	 	 �dŽd£„Zt	 �d<	 	 	 	 	 	 	 	 	 	 	 	 	 �d�d¤„Zu�d�d¥„Zv	 	 	 	 	 	 	 	 �d‘d¦„Zw�d’d§„Zx	 �d<	 	 	 	 	 	 	 	 	 �d“d¨„Zy	 �d>	 	 	 	 	 �d”d©„Zz�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ƒe„�j
                  d³d´fd(d(d(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–�dS�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½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î„Z¾d<dïœ	 	 	 	 	 �dÒdð„Z¿d<dïœ	 	 	 	 	 �dÒdñ„ZÀ�dÓdò„ZÁ	 	 	 	 	 	 	 	 	 	 	 	 �dÔdó„ZÂ�dÕdô„ZÃ�dÖdõ„ZÄ	 	 	 	 	 	 �d×dö„ZÅ�dØd÷„ZÆ�dKdø„ZÇ�dÙdù„ZÈ�dÚdú„ZÉ�dÛdû„ZÊ�dÜdü„ZË	 	 	 	 	 	 	 	 �dÝdý„ZÌeÍ	 	 �dÞd(d(d(dþœ	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 �dßdÿ„«       ZÎeÍ	 	 �dÞd(d(�d œ	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 �dà�d„«       ZÎ	 	 �dÞd(d(d(dþœ	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 �dá�d„ZÎ�dâ�d„ZÏe�dR�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Ü�dx�d„ZÝ�dí�d„ZÞ�dí�d„Zßedd�dœ	 	 	 	 	 �dî�d„«       Zà	 	 	 	 	 	 	 	 	 	 �dï�d„Zá�dð�d„Zâ�dñ�d„Zã	 	 	 	 �dò�d„Zä�d>�dó�d„Zåd(�dœ	 	 	 	 	 	 	 �dô�d„Zæ	 �dõd(�dœ	 	 	 	 	 	 	 	 	 �dö�d„Zç�d÷�d„Zè�dø�d„Zéd<�d œ�dù�d!„Zê�dú�d"„ZëeÍ	 �d>d<�d#œ	 	 	 	 	 	 	 	 	 	 	 �dû�d$„«       ZìeÍd<�d#œ	 	 	 	 	 	 	 	 	 	 	 �dü�d%„«       Zì	 �d>d<�d#œ	 	 	 	 	 	 	 	 	 	 	 �dý�d&„Zì�dþ�d'„Zí	 �d<	 	 	 	 	 �dÿ�d(„Zî�d �d)„Zï�d�d*„Zð�d�d+„Zñ	 	 	 	 	 	 	 	 �d�d,„Zò	 	 	 	 	 	 �d�d-„Zó�d�d.„Zô�d>�d�d/„Zõ�d�d0„Zö�d�d1„Z÷�d�d2„Zø�d	�d3„Zù�d
�d4„Zú�d�d5„Zû�d�d6„Züy((  rB  zžMypy 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_typec                ó   — || _         || _        || _        || _        || _        t        ||«      | _        || _        t        «       | _	        t        |«      | _        t        |«      | _        | j                  | _        |j                  | _        t#        «       | _        g | _        g | _        g | _        t#        «       | _        i | _        g | _        g | _        g | _        i g| _        t#        «       | _        d| _        d| _        |j>                  | _        |jA                  |«      | _!        d| _"        d| _#        tI        | «      | _%        | j                  jL                  xsR | j                  | j                  j                   jN                  v xs$ | j                  jP                  xr | jB                  | _)        d| _*        d| _+        g | _,        d| _-        d| _.        t^        j`                  jc                  | | j                  | j                  |«      | _2        tg        | | j                  | j                  |«      | _4        d| _5        d| _6        d| _7        y)zSConstruct a type checker.

        Use errors to report type check errors.
        r   FNT)8rG  rX  rZ  ÚtreeÚpathrA   rH  r`  r¨   rM  r   rN  r   rI  Úglobals_binderÚnamesrV  ÚsetÚglobals_unreachablerP  rQ  rR  rS  r_  rY  rT  rU  r7  r^  Úpass_numÚcurrent_node_deferredÚis_stubÚis_typeshed_fileÚis_typeshed_stubr[  Úallow_constructor_cacher3  Ú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ÚExpressionCheckerrK  r'   rL  rb  rd  Úassignment_expression_effect)r+  rG  rX  rZ  rf  rg  r`  Úper_line_checking_time_nss           r   r,  zTypeChecker.__init__Ù  s  € ð ˆŒØˆŒØˆŒØˆŒ	ØˆŒ	Ü! &¨'Ó2ˆŒØˆŒÜ“gˆŒÜ! $Ó'ˆŒ
Ü+¨GÓ4ˆŒØ"Ÿk™kˆÔØ—z‘zˆŒÜ-0«UˆÔ ØˆÔØˆÔØˆÔÜ #£ˆÔØ!ˆÔØ ˆÔØˆÔØ(*ˆÔ%Ø˜$ˆŒÜ›5ˆÔØˆŒØ%*ˆÔ"Ø—|‘|ˆŒØ $× 5Ñ 5°gÓ >ˆÔØ(,ˆÔ%Ø'+ˆÔ$Ü*¨4Ó0ˆÔð �L‰L×&Ñ&ò AØ�y‰y˜DŸH™HŸO™O×9Ñ9Ð9òAà—‘×%Ñ%Ò?¨$×*?Ñ*?ð 	Ô!ð
 '+ˆÔ#ð #ˆÔð
 8:ˆÔ ð ',ˆÔ#ð
 $)ˆÔ ô "Ÿ^™^×=Ñ=Ø�$—(‘(˜DŸK™KÐ)Bó
ˆÔô  .¨d°D·H±H¸d¿k¹kÈ7ÓSˆÔØˆŒØ$(ˆÔ!ð
 -.ˆÕ)r  c                ó   — | j                   S r'  )rK  ©r+  s    r   Úexpr_checkerzTypeChecker.expr_checker/  ó   € à×!Ñ!Ð!r  c                ó.   — | j                   j                  S r'  )rK  Útype_contextr‚  s    r   r†  zTypeChecker.type_context3  s   € à×!Ñ!×.Ñ.Ð.r  c                ó¾  — | j                   j                  «        | j                  j                  «        t        | j                  «      | _        g | j                  dd | j                  d   j                  «        | j                  j                  «        g | _	        g | _
        d| _        t        | j                  «      | _        | j                  j                  «        y)z¬Cleanup stale state that might be left over from a typechecking run.

        This allows us to reuse TypeChecker objects in fine-grained
        incremental mode.
        é   Nr   )rS  Úclearr^  r   rZ  rI  r7  rƒ  ÚresetrY  rR  r[  r   rf  rN  rk  r‚  s    r   rŠ  zTypeChecker.reset7  s©   € ð 	×Ñ×#Ñ#Ô%Ø×Ñ×ÑÔ Ü+¨D¯L©LÓ9ˆŒØ ˆ�‰˜˜ÐØ�‰˜Ñ× Ñ Ô"Ø×Ñ×ÑÔ!Ø ˆÔØˆÔØ(,ˆÔ%Ü! $§)¡)Ó,ˆŒ
Ø× Ñ ×&Ñ&Õ(r  c                ó¦   — |d   x}j                   xs |j                  }| j                  j                  t	        |j                  |dz   «      «       y)zKMarks all statements in block after a given one (inclusive) as unreachable.éÿÿÿÿrˆ  N)Úend_lineÚlinerk  ÚupdateÚrange)r+  ÚblockÚafterÚlastÚ	last_lines        r   Úmark_unreachablezTypeChecker.mark_unreachableJ  sB   € à" 2™YÐ&�T×0Ñ0Ò=°D·I±Iˆ	Ø× Ñ ×'Ñ'¬¨e¯j©j¸)Àa¹-Ó(HÕIr  Tc           
     ón  — || _         t        j                  | j                  j                  «      5  t        j                  | «      5  | j                  j                  | j                  | j                  j                  | j                  | j                  ¬«       | j                  j                  | j                  j                  «      5  | j                  «       5  | j                  j!                  «       5  d}d}| j                  j"                  D ]ë  }| j                  j%                  «       r¾d}|s)| j'                  | j                  j"                  |¬«       d}| j)                  «       sd}|sL|sJ| j+                  |«      s9| j,                  j/                  |«       | j                  j1                  «        d}d}|r| j                  j2                  s n*| j                  j2                  sŒÛ| j5                  |«       Œí ddd«       ddd«       | j6                  rJ ‚| j8                  j;                  d«      }|�©|j<                  ��|j>                  }|€J ‚| jA                  d| jC                  d«      g«      }tE        |j<                  |«      sUtG        ||j<                  | j                  ¬	«      \  }	}
| jI                  tJ        jL                  jO                  |	|
«      |«       ddd«       ddd«       ddd«       y# 1 sw Y   ŒþxY w# 1 sw Y   �ŒxY w# 1 sw Y   Œ3xY w# 1 sw Y   Œ7xY w# 1 sw Y   yxY w)
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().
        ©rN  rZ  F©r’  TNÚ__all__útyping.Sequenceúbuiltins.str©rZ  )(rw  r°   Ústrict_optional_setrZ  Ústrict_optionalr!   rj  rG  Úset_filerg  rf  ÚfullnamerM  Úmodule_scopeÚenter_partial_typesrI  Útop_frame_contextÚdefsÚis_unreachabler•  Ú should_report_unreachable_issuesÚis_noop_for_reachabilityrH  Úunreachable_statementÚsuppress_unreachable_warningsÚcheck_unreachableÚacceptrm  rV  ÚgetÚtyper  Únamed_generic_typeÚ
named_typer¸   rF   Úfailr   ÚALL_MUST_BE_SEQ_STRÚformat)r+  rw  Úmarked_unreachableÚreported_unreachableÚdÚfinishÚall_Úall_nodeÚseq_strÚ	str_seq_sÚall_ss              r   Úcheck_first_passzTypeChecker.check_first_passO  s«  € ð '=ˆÔ#Ü×&Ñ& t§|¡|×'CÑ'CÓDñ 1	Äm×FWÑFWÐX\ÓF]ñ 1	Ø�K‰K× Ñ Ø—	‘	˜4Ÿ9™9×-Ñ-°T·[±[È$Ï,É,ð !ô ð —‘×)Ñ)¨$¯)©)×*<Ñ*<Ó=ñ -Ø×-Ñ-Ó/ñ '°·±×1NÑ1NÓ1Pñ 'Ø).Ð&Ø+0Ð(Ø!ŸY™YŸ^™^ò '˜ØŸ;™;×5Ñ5Ô7Ø%*˜FÙ#5Ø $× 5Ñ 5°d·i±i·n±nÈAÐ 5Ô NØ59Ð 2Ø#'×#HÑ#HÔ#JØ)- á$*Ù(<Ø(,×(EÑ(EÀaÔ(Hà $§¡× >Ñ >¸qÔ AØ $§¡× IÑ IÔ KØ)- Ø7;Ð 4á%¨d¯l©l×.LÒ.LÙ %à#'§<¡<×#AÒ#AØ (àŸ™ A�ð1'÷'÷ 'ð:  ×5Ò5Ð5Ð5à—|‘|×'Ñ'¨	Ó2�ØÐ#¨¯	©	Ð(=Ø#Ÿy™y�HØ#Ð/Ð/Ð/Ø"×5Ñ5Ø)¨D¯O©O¸NÓ,KÐ+Ló�Gô & d§i¡i°Ô9Ü+AØ# T§Y¡Y¸¿¹ô,Ñ(˜	 5ð Ÿ	™	Ü,×@Ñ@×GÑGÈ	ÐSXÓYÐ[cô÷W-÷	1	÷ 1	ð 1	÷
'ð 'ú÷ 'ñ 'ú÷-ð -ú÷	1	ð 1	ú÷ 1	ð 1	úsn   ±L+ÁBLÃLÃL	Ã4D	K:Ç=L	ÈCLË!LË)L+Ë:LË?L	ÌLÌLÌLÌLÌL(	Ì$L+Ì+L4)rq  rw  Ú	impl_onlyc          
     óF  — || _         || _        t        j                  | j                  j
                  «      5  t        j                  | «      5  |s| j                  s	 ddd«       ddd«       y| j                  j                  | 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Œ|j#                  |«       t%        «       5 }|rT|j'                  | j                  j)                  |«      «       |j'                  | j*                  j-                  |«      «       | j/                  ||¬«       ddd«       Œ™ 	 ddd«       	 ddd«       ddd«       y# 1 sw Y   Œ¾xY w# 1 sw Y   Œ'xY w# 1 sw Y   nxY wddd«       y# 1 sw Y   yxY w)z„Run second or following pass of type checking.

        This goes through deferred nodes, returning True if there were any.
        NFr—  rˆ  )r½  T)rq  rw  r°   r�  rZ  rž  r!   rj  rY  rG  rŸ  rg  rf  r   rM  r¡  rl  Úaddr   Úenter_contextÚclass_scoperN  Ú
push_classÚcheck_partial)	r+  Útodorq  rw  r½  Údoner  r  Ústacks	            r   Úcheck_second_passzTypeChecker.check_second_pass�  sÜ  € ð (?ˆÔ$Ø&<ˆÔ#Ü×&Ñ& t§|¡|×'CÑ'CÓDñ 	Äm×FWÑFWÐX\ÓF]ñ 	Ù × 3Ò 3Ø÷	÷ 	ð 	ð �K‰K× Ñ Ø—	‘	˜4Ÿ9™9×-Ñ-°T·[±[È$Ï,É,ð !ô ð —‘×)Ñ)¨$¯)©)×*<Ñ*<Ó=ñ FØ—’ Ñ"•ÙØ×.Ñ.‘Dà#×2Ò2Ð2Ð2Ø&(�Ô#ÜLOËE�Ø-1ò FÑ)�D˜/Ø˜t‘|Ø ð —H‘H˜T”NÜ"›ð F¨Ù*Ø!×/Ñ/°·±×0GÑ0GÈÓ0XÔYØ!×/Ñ/°·
±
×0EÑ0EÀoÓ0VÔWØ×*Ñ*¨4¸9Ð*ÔE÷	Fð FñF÷Fð( ÷5	÷ 	ð 	÷*Fð Fú÷Fð Fú÷	ð 	ú÷ 	÷ 	ñ 	úsb   ¸HÁHÁHÁ/B HÃ/A,G6ÅA*G*Ç
G6Ç	HÇHÇ*G3Ç/G6Ç6G?Ç;HÈH	ÈHÈH c                óz  — g | _         t        |t        «      r| j                  |«       y | j                  j                  «       5  |s| j                  |«       	 d d d «       y |j                  | j                  v r
	 d d d «       y t        |t        t        f«      r| j                  |«       nät        |j                  «      D ]�  \  }}|j                   xs |dkD  }t        |t        «      sJ ‚| j                  j!                  |j"                  «      5  | j%                  |j"                  |j&                  |¬«       d d d «       Œƒ |j(                  �?| j+                  |j(                  «      5  | j                  |j(                  «       d d d «       d d d «       y # 1 sw Y   ŒáxY w# 1 sw Y   ŒxY w# 1 sw Y   y xY w)Nr   ©ÚnameÚallow_empty)rT  Ú
isinstancer~   Úcheck_top_levelrI  r£  r«  rŽ  rk  ro   rf   Úcheck_partial_implÚ	enumerateÚitemsÚis_propertyrM  Úfunction_scopeÚfuncÚcheck_func_itemrÊ  ÚimplÚenter_overload_impl)r+  r  r½  ÚiÚitemrË  s         r   rÃ  zTypeChecker.check_partial·  sˆ  € ð ˆÔÜ�dœHÔ%Ø× Ñ  Õ&à—‘×.Ñ.Ó0ñ ?á Ø—K‘K Ô%Ø÷	?ð ?ð
 —9‘9 × 8Ñ 8Ñ8Ø÷?ð ?ô ˜d¤W¬iÐ$8Ô9Ø×+Ñ+¨DÕ1ô $-¨T¯Z©ZÓ#8ò 	™˜˜4à*.×*:Ñ*:Ð&:Ò&C¸aÀ!¹e˜Ü)¨$´	Ô:Ð:Ð:ð "Ÿ[™[×7Ñ7¸¿	¹	ÓBñ Ø ×0Ñ0Ø $§	¡	°·	±	À{ð 1ô ÷ð ð	ð —y‘yÐ,à!×5Ñ5°d·i±iÓ@ñ ?Ø ×3Ñ3°D·I±IÔ>÷?÷1?ð ?÷$ð ú÷?ð ?ú÷1?ð ?úsI   ÁF1Á"F1ÂBF1Ä)FÄ;1F1Å,F%ÆF1ÆF"ÆF1Æ%F.	Æ*F1Æ1F:c                óX  — t        |t        «      r| j                  |«       yt        d„ |j                  D «       «      ry| j
                  j                  |j                  «      5  | j                  |j                  |j                  j                  ¬«       ddd«       y# 1 sw Y   yxY w)zECheck only the body (not the signature) of a non-overloaded function.c              3  ó4   K  — | ]  }t        |d «      –— Œ y­w©ztyping.no_type_checkN©rª   ©Ú.0rµ  s     r   ú	<genexpr>z1TypeChecker.check_partial_impl.<locals>.<genexpr>Þ  s   è ø€ ÒZÀQÔ% aÐ)?×@ÑZùó   ‚N©rÊ  )
rÌ  ro   Úvisit_func_def_implÚanyÚ
decoratorsrM  rÒ  rÓ  rÔ  rÊ  ©r+  rÕ  s     r   rÎ  zTypeChecker.check_partial_implÙ  s}   € ä�dœGÔ$Ø×$Ñ$ TÕ*äÑZÈ$Ï/É/ÔZÔZØØ—‘×+Ñ+¨D¯I©IÓ6ñ EØ×$Ñ$ T§Y¡Y°T·Y±Y·^±^Ð$ÔD÷E÷ Eñ Eús   Á%2B Â B)c                ó  — | j                  «       5  | j                  j                  «       5  |j                  D ]  }|j	                  | «       Œ 	 ddd«       ddd«       | j
                  rJ ‚y# 1 sw Y   Œ xY w# 1 sw Y   Œ$xY w)zDCheck only the top-level of a module, skipping function definitions.N)r¢  rI  r£  r¤  r«  rm  )r+  r  rµ  s      r   rÍ  zTypeChecker.check_top_levelã  sz   € à×%Ñ%Ó'ñ 	#Ø—‘×.Ñ.Ó0ñ #ØŸ™ò #�AØ—H‘H˜T•Nñ#÷#÷	#ð
 ×-Ò-Ð-Ð-Ð-÷	#ð #ú÷	#ð 	#ús"   ‘A;¬#A/ÁA;Á/A8	Á4A;Á;Bc                óN   — | j                   j                  t        ||«      «       y)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)rY  r8  r  )r+  r  Úenclosing_classs      r   Ú
defer_nodezTypeChecker.defer_nodeí  s   € ð 	×Ñ×"Ñ"¤<°°oÓ#FÕGr  c                ó,  — | j                   j                  «       }| j                  | j                  k  rEt	        |t
        «      r5| j                   j                  |«      }| j                  ||«       d| _        y | j                  j                  ||«       y ©NT)rN  Útop_level_functionrl  Ú	last_passrÌ  ro   rè  ré  rm  rH  Úcannot_determine_type)r+  rÊ  Úcontextr  rè  s        r   Úhandle_cannot_determine_typez(TypeChecker.handle_cannot_determine_typeú  so   € Ø�z‰z×,Ñ,Ó.ˆØ�=‰=˜4Ÿ>™>Ò)¬j¸¼wÔ.Gð
 #Ÿj™j×8Ñ8¸Ó>ˆOØ�O‰O˜D /Ô2ð *.ˆDÕ&à�H‰H×*Ñ*¨4°Õ9r  c                óÖ   — 	 |j                  | «       y# t        $ rK}t        || j                  j                  |j
                  | j                  | j                  «       Y d}~yd}~ww xY w)z,Type check a node in the given type context.N)r«  Ú	Exceptionr6   rG  ÚfilerŽ  rZ  )r+  ÚstmtÚerrs      r   r«  zTypeChecker.accept
  sR   € ð	_Ø�K‰K˜ÕøÜò 	_Ü! # t§{¡{×'7Ñ'7¸¿¹ÀDÇKÁKÐQU×Q]ÑQ]×^Ñ^ûð	_ús   ‚ ”	A(�AA#Á#A()Úexit_conditionÚon_enter_bodyc               ó~  — | j                   j                  dd¬«      5  t        d„ | j                  D «       «      }t	        | j
                  «      }t        «       }d}	 | j                   j                  ddd¬«      5  |� |«        t        | j                  j                  |«      5  | j                  |«       ddd«       ddd«       t        d	„ | j                  D «       «      }	t	        | j
                  «      }
|	|k(  r&| j                   j                  r|d
kD  r|
|k(  s|dkD  rn|	}|
}|dz  }|dk(  rt        d«      ‚Œà| j                  j                  |«       |r%| j                  |«      \  }}| j                  |«       |r| j                  |«       ddd«       y# 1 sw Y   ŒåxY w# 1 sw Y   ŒéxY w# 1 sw Y   yxY w)zARepeatedly type check a loop body until the frame doesn't change.FT)Úcan_skipÚconditional_framec              3  óF   K  — | ]  }t        |j                  «      –— Œ y ­wr'  ©Úlenr(  ©rÞ  Úptss     r   rß  z*TypeChecker.accept_loop.<locals>.<genexpr>  s   è ø€ ÒJ°œs 3§7¡7Ÿ|ÑJùó   ‚!rˆ  r  )rù  Úbreak_frameÚcontinue_frameNc              3  óF   K  — | ]  }t        |j                  «      –— Œ y ­wr'  rü  rþ  s     r   rß  z*TypeChecker.accept_loop.<locals>.<genexpr>/  s   è ø€ Ò"N°C¤3 s§w¡w§<Ñ"Nùr   é   é   z(Too many iterations when checking a loop)rI  Úframe_contextÚsumrR  rý  rT  r4   r5   rH  rG  r«  Úlast_pop_changedÚRuntimeErrorÚiteration_dependent_errorsÚfind_isinstance_checkÚpush_type_map)r+  ÚbodyÚ	else_bodyrö  r÷  Úpartials_oldÚwidened_oldÚiter_errorsÚiterÚpartials_newÚwidened_newÚ_Úelse_maps                r   Úaccept_loopzTypeChecker.accept_loop  sª  € ð �[‰[×&Ñ&°ÈÐ&ÓNñ 0	'ô ÑJ°t×7IÑ7IÔJÓJˆLô ˜d×/Ñ/Ó0ˆKä2Ó4ˆKØˆDØØ—[‘[×.Ñ.¸È!Ð\]Ð.Ó^ñ *Ø$Ð0Ù%œä.¨t¯x©x¯©ÀÓLñ *ØŸ™ DÔ)÷*÷	*ô  #Ñ"N¸4×;MÑ;MÔ"NÓN�Ü! $×"3Ñ"3Ó4�ð " \Ò1Ø!Ÿ[™[×9Ò9¸TÀAºXØ$¨Ò3°t¸a²xàØ+�Ø)�Ø˜‘	�Ø˜2’:Ü&Ð'QÓRÐRð5 ð8 �H‰H×/Ñ/°Ô<ñ Ø"×8Ñ8¸ÓH‘��8Ø×"Ñ" 8Ô,ñ Ø—‘˜IÔ&÷a0	'ð 0	'÷ *ð *ú÷	*ð *ú÷0	'ð 0	'ús=   žAF3Á;*F'Â%FÂ7F'Â?CF3ÆF$Æ F'Æ'F0	Æ,F3Æ3F<c                ó†   — | j                   j                  |«      5  | j                  |«       d d d «       y # 1 sw Y   y xY wr'  )rM  rÒ  Ú_visit_overloaded_func_def)r+  Údefns     r   Úvisit_overloaded_func_defz%TypeChecker.visit_overloaded_func_defR  s9   € ð
 �[‰[×'Ñ'¨Ó-ñ 	2Ø×+Ñ+¨DÔ1÷	2÷ 	2ñ 	2ús	   œ7·A c           	     ó  — d}|j                   sy t        |j                   «      dk(  r | j                  t        j                  |«       |j
                  �rît        |j                   d   t        «      sJ ‚| j                  |j                   d   «       |j                   d   j                  j                  �r�| j                  |j                  d¬«       |j                  j                  j                  }t        t        j                   «      }t#        ||gt$        t$        gd d g|| j'                  d«      ¬«      }|r2t)        ||«      s&| j                  d|j                  j*                  «       | j-                  ||«      }t        |t"        «      rt        |j.                  «      dk7  r|}||j                   d   j                  _        t        |j                  t2        «      rb| j-                  |j                   d   j                  j                  |«      }|�-|j                   d   |_        ||j                  j                   d<   t7        |j                   «      D �]t  \  }}t        |t        «      sJ ‚|j
                  �rt        |j                   d   t        «      sJ ‚|j                   d   j                  j                  }	|	r|dkD  s|	sÛ|dkD  rÖ| j8                  s| j;                  |j*                  «       | j<                  s|j*                  j>                  r�| j@                  jC                  |j*                  «      5  | jE                  «       5  | jG                  |j*                  |j*                  jH                  d¬	«       d d d «       d d d «       n| j                  |d¬
«       |j*                  jJ                  tL        tN        fv s�Œp|dz  }�Œw |dt        |j                   «      fvr | j                  t        jP                  |«       |jR                  r?| jU                  |jR                  «      5  |jR                  jW                  | «       d d d «       |j
                  s—| jY                  |«       |j                  �€7g }
|j                   D ]U  }t        |t        «      sJ ‚| j-                  |j                  j                  |«      }|€Œ>||_        |
j[                  |«       ŒW |
rÏt3        |
«      |_        n¾|j                  €²t        |j                   d   t        «      sJ ‚| j-                  |j                   d   j                  j                  |«      }t        |t"        «      s?t        t        j                   «      }t#        |gt$        gd g|| j'                  d«      ¬«      }t3        |g«      |_        | j8                  s™|j\                  rŒ| j_                  |«      }|j`                  r@|s>|�<|j\                  jb                  s&| jd                  jg                  |jH                  |«       | ji                  |||jR                  «       | jk                  |«       y y y # 1 sw Y   �ŒÝxY w# 1 sw Y   �ŒÎxY w# 1 sw Y   �Œ+xY w)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Ï  rv  Úcheck_default_paramsrw  Údef_or_infer_varsrM  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_anyrH  Ú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_defZ  sB  € ØˆØ�zŠzð Üˆt�z‰z‹?˜aÒØ�I‰IÔ&×BÑBÀDÔIà×Óä˜dŸj™j¨™m¬YÔ7Ð7Ð7Ø× Ñ  §¡¨A¡Ô/Ø�z‰z˜!‰}× Ñ ×5Ó5à×*Ñ*¨4¯;©;ÈÐ*ÔMØ"Ÿk™kŸo™o×2Ñ2�ä"¤9×#9Ñ#9Ó:�Ü'3Ø'¨Ð2Ü&¬Ð0Ø# T˜lØ%Ø!Ÿ_™_Ð-@ÓAô(Ð$ñ ¤z°+Ð?SÔ'TØ—I‘IÐAÀ4Ç;Á;×CSÑCSÔTØ"×8Ñ8¸ÀdÓK�Ü! +¬|Ô<ÄÀK×DYÑDYÓ@ZÐ^_Ò@_à"6�KØ0;�—
‘
˜1‘×!Ñ!Ô-Ü˜dŸi™i¬Ô4à"&×"<Ñ"<¸T¿Z¹ZÈ¹]×=NÑ=N×=SÑ=SÐUYÓ"Z�KØ"Ð.Ø15·±¸A±˜Ô.Ø-8˜Ÿ	™	Ÿ™¨Ñ*Ü  §¡Ó,ó 	"‰GˆAˆtÜ˜d¤IÔ.Ð.Ð.Ø×ÓÜ! $§*¡*¨Q¡-´Ô;Ð;Ð;ØŸ:™: a™=×,Ñ,×AÑA�á  Q¢±¸QÀºUð  ×4Ò4Ø×1Ñ1°$·)±)Ô<Ø×2Ò2°d·i±i×6QÒ6Qà ŸK™K×6Ñ6°t·y±yÓAñcà ×;Ñ;Ó=ñcð !×0Ñ0°·±ÀÇÁÇÁÐ]aÐ0Ôb÷	c÷ cð cð ×*Ñ*¨4¸TÐ*ÔBØ�y‰y×(Ñ(¬[Ô:MÐ,NÓNØ Ñ!’ð/	"ð0  ¤3 t§z¡z£?Ð3Ñ3Ø�I‰IÔ&×EÑEÀtÔLØ�9Š9Ø×)Ñ)¨$¯)©)Ó4ñ 'Ø—	‘	× Ñ  Ô&÷'à×ÒØ×,Ñ,¨TÔ2Ø�y‰yÑ Ø�
Ø ŸJ™Jò 5�DÜ% d¬IÔ6Ð6Ð6Ø $× :Ñ :¸4¿8¹8¿=¹=È$Ó O�IØ Ñ,Ø/3˜	Ô,Ø"×)Ñ)¨)Õ4ð5ñ Ü *¨:Ó 6�D•IØ�Y‰YÐô ˜dŸj™j¨™m¬YÔ7Ð7Ð7Ø×1Ñ1°$·*±*¸Q±-×2CÑ2C×2HÑ2HÈ$ÓOˆHÜ˜h¬Ô5ä"¤9×#9Ñ#9Ó:�Ü'Ø'˜jÜ&˜iØ#˜fØ%Ø!Ÿ_™_Ð-@ÓAô�ô # H :Ó.ˆDŒIà×(Ò(¨T¯YªYØ(,×(BÑ(BÀ4Ó(HÐ%à×)Ò)Ù1Ø-Ð9ð Ÿ	™	×1Ò1à—‘×.Ñ.¨t¯y©y¸$Ô?Ø×2Ñ2°4Ð9RÐTX×T]ÑT]Ô^Ø×.Ñ.¨tÕ4ð .7Ð(÷[cñ cú÷ cñ cú÷'ñ 'ús0   Ì<Y(Í3YÎ Y(Ð0Y5ÙY%Ù Y(Ù(Y2	Ù5Y?c              #  óÒ   K  — | j                   j                  |«       	 d –— | j                   j                  «       |k(  sJ ‚y # | j                   j                  «       |k(  sJ ‚w xY w­wr'  )ry  r8  r=  rå  s     r   rÖ  zTypeChecker.enter_overload_implÉ  s\   è ø€ à× Ñ ×'Ñ'¨Ô-ð	:Ûà×+Ñ+×/Ñ/Ó1°TÒ9Ð9Ñ9ø�4×+Ñ+×/Ñ/Ó1°TÒ9Ð9Ñ9üs   ‚A'ŸA £ A'Á!A$Á$A'c                óš  — t        |«      }d}|�t        |t        «      ryt        |t        «      rt        |j                  «      }t        |t
        «      r/t        | j                  j                  |j                  |«      «      }t        |t        «      r|}nñt        |t        «      r/t        t        d||ddd|| ¬«      «      }t        |t        «      rµ|}n²t        |t        «      r¢t        |j                  «      }t        |t        «      rkg }|j                  D ])  }| j                  ||«      }|€ nV|j!                  |«       Œ+ t        t#        j$                  |«      «      }	t        |	t        «      r|	}n| j                  ||«      S |€| j&                  j)                  ||«       yt        |t*        «      ry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_typer5  )rú   rÌ  rÛ   rð   Úupper_boundrî   rƒ  Úanalyze_type_type_calleerØ  rà   rá   r%   rõ   rÏ   rÐ  r+  r8  r   Újoin_type_listrH  Únot_callablerä   rÝ   )
r+  Ú
inner_typeÚctxÚ
outer_typeÚ
inner_callÚ
union_typerÐ  rØ  Úcallable_itemÚjoined_types
             r   r+  z!TypeChecker.extract_callable_typeÑ  sŸ  € ä$ ZÓ0ˆ
Ø*.ˆ
ØÐ¤¨J¼Ô!@ØÜ�j¤/Ô2Ü(¨×)?Ñ)?Ó@ˆJÜ�j¤(Ô+Ü(Ø×!Ñ!×:Ñ:¸:¿?¹?ÈCÓPóˆJô �j¤,Ô/Ø#‰JÜ˜
¤HÔ-Ü(Ü%Ø#Ø"ØØ#Ø"Ø $Ø",Øô	óˆJô ˜*¤lÔ3Ø'‘
Ü˜
¤IÔ.Ü.¨z×/?Ñ/?Ó@ˆJÜ˜*¤iÔ0Ø�Ø&×,Ñ,ò 1�DØ$(×$>Ñ$>¸tÀSÓ$I�MØ$Ð,ÙØ—L‘L Õ/ð	1ô #2´$×2EÑ2EÀeÓ2LÓ"M�KÜ! +¬|Ô<Ø%0™
à×1Ñ1°*¸cÓBÐBàÐØ�H‰H×!Ñ! *¨cÔ2ØÜ�j¤*Ô-Øä˜*¤lÔ3Ð3Ð3ØÐr  c           	     ó,  — | j                   ry d }|j                  r�t        |j                  t        «      r|j                  j                  }nBt        |j                  t
        «      r!|j                  j                  j                  }nJ d«       ‚| j                  ||j                  «      }|j                  xr |j                  dk(  }t        |j                  «      D �]'  \  }}t        |t
        «      sJ ‚| j                  |j                  j                  |«      }|€ŒBt        |j                  |dz   d  «      D �]B  \  }}	t        |	t
        «      sJ ‚| j                  |	j                  j                  |	«      }
|
€ŒBt        ||
«      sŒOt        ||
«      r1| j                  j                  |dz   ||z   dz   |	j                   «       ŒŒ|rŒ�| j"                  j%                  «       }|r|j&                  j(                  ng }t+        j,                  d«      5  t/        ||
|«      rU|dk(  xr t/        |
||«       xr t        |
|«       }| j                  j1                  |dz   ||z   dz   ||j                   «       d d d «       �ŒE |€�Œ§|j                  €J ‚t3        ||t4        dd„ ¬	«      r�ŒÌ|j6                  r\t9        |j;                  «       |j;                  «       dt<        ¬
«      }|€-| j                  j?                  |dz   |j                  «       �Œ4|}|j@                  r<|j                  r0|jC                  |j@                  d   g|j@                  dd  z   ¬«      }t3        ||t4        dd¬«      s)| j                  jE                  |dz   |j                  «       t5        |jF                  |jF                  «      r�ŒÝt5        |jF                  |jF                  «      r�Œÿ| j                  jI                  |dz   |j                  «       �Œ* y # 1 sw Y   �ŒÙxY w)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>V  s   € ´*¸QÀÓ2B€ r  )Ú	is_compatr¶   Úis_compat_return)Úignore_returnÚreturn_constraint_direction)r  ©r`  r¶   rb  )%rv  rÕ  rÌ  ro   r­  rf   r&  r+  r4  rÊ  rÏ  rÐ  Úare_argument_counts_overlappingÚoverload_can_never_matchrH  Ú%overloaded_signature_will_never_matchrÓ  rN  Ú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_typerQ  Úis_descriptor_getr×  rØ  Úsig1ÚjÚitem2Úsig2Úcurrent_classri  Ú	flip_noterÕ  s                  r   r3  z'TypeChecker.check_overlapping_overloads  s™  € ð ×$Ò$Øð *.ˆ	Ø�9Š9Ü˜$Ÿ)™)¤WÔ-Ø*.¯)©)¯.©.‘
Ü˜DŸI™I¤yÔ1Ø!ŸY™YŸ]™]×/Ñ/‘
à9Ð9Ó9�uð ×2Ñ2°:¸t¿y¹yÓIˆIà ŸI™IÒ@¨$¯)©)°yÑ*@ÐÜ  §¡Ó,ó c	R‰GˆAˆtÜ˜d¤IÔ.Ð.Ð.Ø×-Ñ-¨d¯h©h¯m©m¸TÓBˆDØˆ|Øä% d§j¡j°°Q±°Ð&9Ó:ó &‘��5Ü! %¬Ô3Ð3Ð3Ø×1Ñ1°%·)±)·.±.À%ÓH�Ø�<Øä6°t¸TÔBØä+¨D°$Ô7Ø—H‘H×BÑBÀ1ÀqÁ5È!ÈaÉ%ÐRSÉ)ÐUZ×U_ÑU_Õ`Ú*ð %)§J¡J×$;Ñ$;Ó$=�MÙ@M × 2Ñ 2× <Ò <ÐSU�IÜ×2Ñ2°4Ó8ñ ÜDÀTÈ4ÐQZÔ[à ! Q¡ò !MÜ(QØ$(¨$°	ó)"ð %"ò!Mô )AÀÀtÓ(LÐ$Lð &ð !ŸH™H×BÑBØ ! A¡ q¨1¡u¨q¡y°)¸T¿Y¹Yô÷ñ ð7&ðP Ò$Ø—y‘yÐ,Ð,Ð,ô *ØØÜ(Ø&+Ù%Bõñ ð ×&Ò&Ü0Fà!×6Ñ6Ó8Ø×1Ñ1Ó3Ø&+Ü4@ô1�Dð �|ØŸ™×GÑGÈÈAÉÈtÏyÉyÔYÙ à$�Dð —>’> d§i¢iØ×-Ñ-¸¿¹ÈÑ9JÐ8KÈdÏnÉnÐ]^Ð]_ÐN`Ñ8`Ð-Óa�Dô .Ø˜$¬*ÈÐ]aõð —H‘H×AÑAÀ!ÀaÁ%ÈÏÉÔSô ˜tŸ}™}¨d¯m©mÖ<Ü! $§-¡-°·±Ö?à—H‘H×?Ñ?ÀÀAÁÀtÇyÁyÖQñGc	R÷Bñ ús   ÈA#P	Ð	Pc                óV  — t        |«      }|r7| j                  dt        t        j                  «      g«      }t        ||«      r<yt        t        j                  «      }| j                  d|||g«      }t        ||«      ryt        |t        «      xr |j                  j                  dk(  S )zÍIs `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+  rH  Úis_coroutineÚatr<  Úgts         r   Úis_generator_return_typez$TypeChecker.is_generator_return_type®  s™   € ô ˜cÓ"ˆÙà×(Ñ(Ð);¼gÄi×F\ÑF\Ó>]Ð=^Ó_ˆBÜ˜"˜cÔ"Øäœy×5Ñ5Ó6ˆHØ×(Ñ(Ð);¸hÈÐRZÐ=[Ó\ˆBÜ˜"˜cÔ"ØÜ˜#œxÓ(Ò]¨S¯X©X×->Ñ->ÐB]Ñ-]Ð]r  c                ó”   — 	 t        t        j                  «      }| j                  d||g«      }t        ||«      S # t        $ r Y yw xY w)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+  rH  r<  Úagts       r   Úis_async_generator_return_typez*TypeChecker.is_async_generator_return_typeÁ  sR   € ð
	Üœy×5Ñ5Ó6ˆHØ×)Ñ)Ð*AÀHÈhÐCWÓXˆCô ˜#˜sÓ#Ð#øô ò 	áð	ús   ‚-; »	AÁAc           	     ó˜  — t        |«      }t        |t        «      rt        t        j                  |¬«      S t        |t
        «      r3t        |j                  D �cg c]  }| j                  ||«      ‘Œ c}«      S | j                  ||«      s*| j                  |«      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 c c}w )zRGiven the declared return type of a generator (t), return the type it yields (ty).©Ú
source_anyr{  r   )rú   rÌ  rÛ   rì   Úfrom_another_anyrõ   rÏ   rÐ  Úget_generator_yield_typer�  r†  Ú
from_errorrá   r­  r   r*  Úargs)r+  Úreturn_typer~  rØ  r"  s        r   r‹  z$TypeChecker.get_generator_yield_typeÎ  s  € ä% kÓ2ˆä�k¤7Ô+Üœ9×5Ñ5À+ÔNÐNÜ˜¤YÔ/Ü(ØOZ×O`ÑO`ÖaÀt�×.Ñ.¨t°\ÕBÒaóð ð ×.Ñ.Ø˜ô
à×5Ñ5°kÔBô œ9×/Ñ/Ó0Ð0Ü˜K¬Ô2äœ9×/Ñ/Ó0Ð0Ø×Ñ×&Ñ&Ð*<Ò<äœ9×1Ñ1Ó2Ð2Ø×Òà"×'Ñ'¨Ñ*ˆHàˆOô œ9×1Ñ1Ó2Ð2ùò1 bs   ÁEc           	     ó>  — t        |«      }t        |t        «      rt        t        j                  |¬«      S t        |t
        «      r3t        |j                  D �cg c]  }| j                  ||«      ‘Œ c}«      S | j                  ||«      s*| j                  |«      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 c c}w )zTGiven a declared generator return type (t), return the type its yield receives (tc).rˆ  r{  ©r|  r}  r  rˆ  rƒ  r  )rú   rÌ  rÛ   rì   rŠ  rõ   rÏ   rÐ  Úget_generator_receive_typer�  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ˆä�k¤7Ô+Üœ9×5Ñ5À+ÔNÐNÜ˜¤YÔ/Ü(ØQ\×QbÑQbÖcÈ�×0Ñ0°°|ÕDÒcóð ð ×.Ñ.Ø˜ô
à×5Ñ5°kÔBô œ9×/Ñ/Ó0Ð0Ü˜K¬Ô2äœ9×/Ñ/Ó0Ð0Ø×Ñ×&Ñ&Ð*<Ò<äœ9×1Ñ1Ó2Ð2à×Ñ×%Ñ%Ð)ZÑZÜ�K×$Ñ$Ó%¨Ò*ð ×#Ñ# AÑ&Ð&Ø×Ñ×&Ñ&Ð*AÒAÄcÈ+×JZÑJZÓF[Ð_`ÒF`Ø×#Ñ# AÑ&Ð&ô “:Ðùò3 ds   ÁF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  sP   € Ü% kÓ2ˆÜ�k¤7Ô+Üœ9×5Ñ5À+ÔNÐNÜ˜+¤xÔ0ÐaÐ2aÓaÐ0à×Ñ Ñ"Ð"r  c           	     ó¸  — t        |«      }t        |t        «      rt        t        j                  |¬«      S t        |t
        «      r3t        |j                  D �cg c]  }| j                  ||«      ‘Œ c}«      S | j                  ||«      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 c c}w )zSGiven the declared return type of a generator (t), return the type it returns (tr).rˆ  r{  rˆ  r   r�  r  r  )rú   rÌ  rÛ   rì   rŠ  rõ   rÏ   rÐ  Úget_generator_return_typer�  rŒ  rá   r­  r   rý  r�  rã   r’  s       r   r–  z%TypeChecker.get_generator_return_type  s%  € ä% kÓ2ˆä�k¤7Ô+Üœ9×5Ñ5À+ÔNÐNÜ˜¤YÔ/Ü(ØP[×PaÑPaÖbÈ�×/Ñ/°°lÕCÒbóð ð ×.Ñ.¨{¸LÔIô œ9×/Ñ/Ó0Ð0Ü˜K¬Ô2äœ9×/Ñ/Ó0Ð0Ø×Ñ×&Ñ&Ð*<Ò<ÄÀ[×EUÑEUÓAVÐZ[ÒA[à×#Ñ# AÑ&Ð&à×Ñ×%Ñ%Ð)ZÑZÜ�K×$Ñ$Ó%¨Ò*ð ×#Ñ# AÑ&Ð&ô “:Ðùò+ cs   ÁEc                óð   — | j                   s| j                  |«       |j                  r#| j                  |«      }| j	                  ||«       | j
                  s|j                  sy | j                  |«       y r'  )rv  r.  Úoriginal_defrË   Úcheck_func_def_overriderw  r/  râ  )r+  r  Únew_types      r   Úvisit_func_defzTypeChecker.visit_func_def:  sd   € à×(Ò(Ø×%Ñ% dÔ+Ø×Òà×)Ñ)¨$Ó/ˆHØ×(Ñ(¨¨xÔ8Ø×*Ò*°4×3IÒ3IØØ× Ñ  Õ&r  c                ó°  — | j                   j                  |«      5  | j                  «       5  | j                  ||j                  ¬«       | j
                  sX|j                  rL|j                  s/|j                  s#| j                  |«      }| j                  ||«       | j                  |«       d d d «       d d d «       y # 1 sw Y   ŒxY w# 1 sw Y   y xY w)Nrá  )rM  rÒ  r0  rÔ  rÊ  rv  r4  Úis_overloadÚis_decoratedr5  r9  r:  )r+  r  rD  s      r   râ  zTypeChecker.visit_func_def_implF  s³   € Ø�[‰[×'Ñ'¨Ó-ñ 	=¨t×/NÑ/NÓ/Pñ 	=Ø× Ñ  ¨D¯I©IÐ Ô6Ø×,Ò,Ø—9’9Ø×+Ò+°D×4EÒ4Eð
 59×4NÑ4NÈtÓ4TÐ1Ø×>Ñ>¸tÐE^Ô_à×6Ñ6°tÔ<÷	=÷ 	=÷ 	=ñ 	=ú÷ 	=ð 	=ús#   œC­BC Â/CÃ C		ÃCÃCc                óà  — | j                   j                  |j                  «       xr | «       | j                  }| j	                  d¬«      5  | j                  |«      }|r'|j                  |j                  |j                  ¬«      }t        |t        «      r.| j                  «       5  | j                  ||||«       ddd«       nt        d«      ‚ddd«       | j                   j                  «        || _        |dk(  r| j                  |«       |dk(  rBt!        j"                  |j$                  «      r"t!        j&                  | ||j$                  «       yyy# 1 sw Y   Œ�xY w# 1 sw Y   Œ”xY w)zcType check a function.

        If type_override is provided, use it as the function type.
        T)r)  )rŽ  ÚcolumnNzNot supportedrA  Ú__post_init__)rQ  r8  Ú
is_dynamicrm  r¢  rË   ro  rŽ  r   rÌ  rÝ   Ú!enter_attribute_inference_contextÚcheck_func_defr	  r=  Úcheck__exit__return_typeÚdataclasses_pluginÚis_processed_dataclassr4  Úcheck_post_init)r+  r  Útype_overriderÊ  rË  Úenclosing_node_deferredrH  s          r   rÔ  zTypeChecker.check_func_itemU  sN  € ð 	×Ñ×!Ñ! $§/¡/Ó"3Ò"I¸MÐ8IÔJà"&×"<Ñ"<ÐØ×%Ñ%°$Ð%Ó7ñ 	4Ø×$Ñ$ TÓ*ˆCÙØ#×1Ñ1°s·x±xÈÏ
É
Ð1ÓS�Ü˜#œ|Ô,Ø×;Ñ;Ó=ñ FØ×'Ñ'¨¨c°4¸ÔE÷Fð Fô # ?Ó3Ð3÷	4ð 	×Ñ×ÑÔ Ø%<ˆÔ"à�:ÒØ×)Ñ)¨$Ô/ð �?Ò"Ü!×8Ñ8¸¿¹ÔCÜ"×2Ñ2°4¸¸t¿y¹yÕIð Dð #÷Fð Fú÷	4ð 	4ús%   ÁAE$Â(EÂ=E$ÅE!	ÅE$Å$E-c                ó  — |j                   €J ‚t        |j                   t        «      rF| j                  |j                   «      }t	        ||«      s| j
                  j                  |||«       y y |j                   j                  }|€y t        |t        «      r~|j                  €I|j                   }t        |t        «      r|j                  }n|}| j                  |«      }|�3||_        ||= y d|_        | j                  t        j                  |«       y y |j                  sht!        |j"                  «      }|j                   |_        | j&                  j)                  |||«       | j+                  |||t        j                  dd«       y y )NTzredefinition with typezoriginal type)r˜  rÌ  ro   rË   r·   rH  Ú%incompatible_conditional_function_defr­  rå   rf   r&  Úfind_partial_typesÚis_invalid_redefinitionr°  r   ÚINCOMPATIBLE_REDEFINITIONr   rÊ  r  rI  Úassign_typeÚcheck_subtype)	r+  r  rš  Úold_typeÚ	orig_typeÚorig_defr&  rR  Ú	name_exprs	            r   r™  z#TypeChecker.check_func_def_overridex  sd  € Ø× Ñ Ð,Ð,Ð,Ü�d×'Ñ'¬Ô1à×)Ñ)¨$×*;Ñ*;Ó<ˆHÜ ¨(Ô3Ø—‘×>Ñ>¸tÀXÈxÕXð 4ð
 ×)Ñ)×.Ñ.ˆIØÐ ð Ü˜)¤[Ô1Ø—>‘>Ð)à#×0Ñ0�HÜ! (¬IÔ6Ø&Ÿl™l™à&˜Ø$(×$;Ñ$;¸CÓ$@�MØ$Ð0Ø#+˜œØ)¨#Ñ.ð 48�DÔ0Ø—I‘IÔ.×HÑHÈ$ÕOð 1ð ×1Ò1Ü$ T§Y¡YÓ/�	Ø!%×!2Ñ!2�	”Ø—‘×'Ñ'¨	°8¸YÔGØ×"Ñ"ØØØÜ$×>Ñ>Ø,Ø#õð	 2r  c              #  óH   K  — | j                   }i | _         d –— || _         y ­wr'  )r[  )r+  Ú	old_typess     r   r£  z-TypeChecker.enter_attribute_inference_context¤  s&   è ø€ à×1Ñ1ˆ	Ø(*ˆÔ%ØŠ
Ø(1ˆÕ%ùó   ‚ "c                óŒ  — | j                  |j                  «       | j                  ||«      }|}|D �]Û  \  }}| j                  }t	        | j
                  «      | _        | j                  j                  «       5  |j                  j                  |«       | j                  s| j                  |||||¬«       | j                  j                  |j                  «       | j                  j                  |«      5  | j                  j                  «       }	ddd«       |j                   r¼d}
	�|j"                  rd}
|
t%        |j&                  «      k  r’t)        |j                   |j&                  |
   «      so| j+                  t,        j.                  j1                  t3        |j                   | j
                  «      t3        |j&                  |
   | j
                  «      «      |«       d}t5        |t6        «      r|j8                  s| j;                  ||«      }t=        t%        |j&                  «      «      D ]©  }|j&                  |   }t5        |t>        «      rp|j@                  tB        k(  r]|jD                  dvrOtG        |jD                  «      s:|dk7  s|s3|}|jH                  dk  r|}| j+                  t,        jJ                  |«       tM        |||| jN                  «       Œ« 	 ddd«       | j                  j                  «       5  d}|jP                  D ]   }|jR                  jU                  «       D ]�  \  }}tW        |«      }|€Œ| jY                  ||jH                  «      rŒ1|€| j                  j[                  «       }||jR                  |<   |j\                  |   | j                  j\                  |<   Œƒ Œ¢ | j
                  j^                  rƒ| j`                  sw|jb                  D ]h  }|jd                  }|jf                  €Œti        |jD                  «      }||_5        | j                  jm                  ||jf                  |jf                  «       Œj | j                  j                  |«      5  to        |«      st%        |«      dk\  r| j                  jq                  «        | j                  r2| j
                  jr                  st5        |t6        «      r|jt                  r| jw                  |jx                  «       ddd«       | j                  j{                  «       }|�| j                  j}                  dd«       ddd«       �sFt        |jx                  «      }|j€                  stƒ        | j                  d	   d
«      r*| j…                  | j                  d	   |j†                  «      }n:|j†                  r| j‰                  | j                  d	   «      }n| j                  d	   }t‹        |«      }|xs | j
                  jŒ                  }| xs: | xr5 t5        |t6        «      xr |jŽ                  t�        k7   xr | j`                   }| j                  s“|j’                  t”        urO|jD                  |j’                  j–                  vs_|j’                  j–                  |jD                     j˜                  s2t5        |t6        «      r|jš                  s|rt)        t�        «       |«      rd}|�r | jž                  �s“|xr] |j’                  t”        uxrI |j’                  j                   duxr/ |j’                  j                   jf                  j£                  d«      }| j
                  j¤                  r¤t5        |tœ        t¦        f«      �st5        |t¨        «      rt,        jª                  }nt,        j¬                  }|r%t¯        |j°                  t²        j´                  ¬«      }| j+                  ||«       |r™| j·                  t,        j¸                  |«       nxt,        jº                  }|r%t¯        |j°                  t²        j´                  ¬«      }| j½                  dt�        «       d|||¬«      s"|r | j·                  t,        j¸                  |«       | j                  j¿                  «        | jÀ                  r^| jÀ                  D ]H  \  }}| jÂ                  jÅ                  ||«       tÇ        |«      }|€Œ0|| jÂ                  j\                  |<   ŒJ g | _`        || _        �ŒÞ y# 1 sw Y   �ŒxY w# 1 sw Y   �ŒDxY w# 1 sw Y   �Œ<xY w# 1 sw Y   �Œ	xY w)z!Type check a function definition.)r  Úoriginal_typNr   rˆ  F>   Ú__new__r,  Ú__replace__r¡  r  TrŒ  r}  úabc.ABCMeta©Úcodezimplicitly returnsÚexpected)Úsubtype_labelÚsubtypeÚsupertype_labelÚ	supertyperï  rH  )dÚcheck_typevar_defaultsrl  Úexpand_typevarsrI  r   rZ  r£  Úexpandedr8  rv  Úcheck_funcdef_itemrP  r"  rN  Ú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_redefinitionrn  Ú	argumentsÚvariabler­  r   r  r°  Ú_is_empty_generator_functionr©  Úpreserve_astsr/  r«  r  r¥  Ú	pop_framer©   Úis_generatorrÿ   r–  r~  r”  rú   Úallow_empty_bodiesr1  rX   r4  rP   ri  Úplugin_generatedÚis_mypy_onlyrã   rm  Ú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±  r=  rU  rh  Úputr;   ) r+  r  rH  rÊ  rË  rÇ  rº  rØ  Ú
old_binderÚref_typeÚ	arg_indexÚ
found_selfr×  Úarg_typerR  Ú	new_frameÚframeÚkeyÚnarrowed_typeÚkey_varÚargÚvÚnÚunreachableÚbody_is_trivialrŽ  Ú
show_errorÚmay_be_abstractrH  ÚlvalueÚwidened_typeÚlits                                    r   r¤  zTypeChecker.check_func_def«  sÈ  € ð
 	×#Ñ# C§M¡MÔ2Ø×'Ñ'¨¨cÓ2ˆØˆØ!ó U	%‰IˆD�#ØŸ™ˆJÜ/°·±Ó=ˆDŒKØ—‘×.Ñ.Ó0ñ 6OØ—‘×$Ñ$ TÔ*ð
 ×0Ò0Ø×+Ñ+¨D°#°tÀ$ÐUaÐ+Ôbð ×!Ñ!×(Ñ(¨¯©Ô6à—Z‘Z×-Ñ-¨dÓ3ñ Jð -1¯J©J×,GÑ,GÓ,I�H÷Jð
 —;’;Ø !�IàÐ+°×0MÒ0MØ$%˜	Ø ¤3 s§}¡}Ó#5Ò5¼jØŸ™ S§]¡]°9Ñ%=ô?ð Ÿ	™	Ü,×FÑF×MÑMÜ +¨C¯K©K¸¿¹Ó FÜ +¨C¯M©M¸)Ñ,DÀdÇlÁlÓ Sóð !ôð #�
Ü˜d¤GÔ,°T×5FÒ5FØ!%×!CÑ!CÀCÈÓ!N�JÜœs 3§=¡=Ó1Ó2ò O�AØ"Ÿ}™}¨QÑ/�HÜ! (¬KÔ8ð %×-Ñ-´Ò:Ø $§	¡	Ø#Zñ![ä$.¨t¯y©yÔ$9Ø!" a¢©zà+3˜CØ"Ÿx™x¨!š|Ø&) Ø ŸI™IÔ&6×&]Ñ&]Ð_bÔcä'¨¨a°°d×6MÑ6MÕNñ#O÷K6Oðr —‘×.Ñ.Ó0ñ 43ð +/�	Ø'×.Ñ.ò 
Y�EØ.3¯k©k×.?Ñ.?Ó.Aò 	YÑ*˜˜]Ü"?ÀÓ"D˜Ø"Ñ.°t×7]Ñ7]Ø# T§Y¡Yõ8ð  )Ð0Ø,0¯K©K×,BÑ,BÓ,D 	Ø3@˜IŸO™O¨CÑ0Ø<F×<SÑ<SÐTWÑ<X˜DŸK™K×4Ñ4°SÒ9ñ	Yð
Yð —<‘<×2Ò2¸4¿<º<à#Ÿ~™~ò G˜àŸL™L˜ØŸ6™6Ñ-Ü (¨¯©Ó 0˜AØ%&˜AœFØ ŸK™K×3Ñ3°A°q·v±v¸q¿v¹vÕFðGð —Z‘Z×-Ñ-¨dÓ3ñ /ô 4°DÔ9¼SÀ»]ÈaÒ=OØŸ™×AÑAÔCð
 !×5Ò5ØŸ<™<×5Ò5Ü)¨$´Ô8Ø×1Ò1àŸ™ D§I¡IÔ.÷-/ð. #Ÿk™k×8Ñ8Ó:�ØÐ(Ø—K‘K×)Ñ)¨$°Ô2÷i43òl Ü"1°$·)±)Ó"<�Ø×$Ò$Ô(9Ø×%Ñ% bÑ)Ð+Fô)ð #'×"@Ñ"@Ø×)Ñ)¨"Ñ-¨t×/@Ñ/@ó#‘Kð ×&Ò&Ø"&×"@Ñ"@À×ARÑARÐSUÑAVÓ"W‘Kà"&×"3Ñ"3°BÑ"7�KÜ-¨kÓ:�à)ÒL¨T¯\©\×-LÑ-L�ð (Ð'ò 	ð (˜ò -ä& t¬WÓ5Ò^¸$×:NÑ:NÔR^Ñ:^ðò-ð !%§¡Ð,ð ð ×-Ò-ð Ÿ	™	¬Ñ5à ŸI™I¨T¯Y©Y¯_©_Ñ<Ø#Ÿy™yŸ™¨t¯y©yÑ9×JÒJô
 # 4¬Ô1°d×6GÒ6Gñ (¬J´x³zÀ;Ô,Oà!&�Jâ d×&@Ó&@à'ò RØ ŸI™I¬\Ð9òRà ŸI™I×4Ñ4¸DÐ@òRð !ŸI™I×4Ñ4×9Ñ9×BÑBÀ=ÓQð	 $ð —|‘|×2Ò2Ü)¨+¼Ä'Ð7JÕKô  *¨+´ÔGä&6×&NÑ&N¡ä&6×&OÑ&O Ù.Ü&2°3·9±9Ä5×CSÑCSÔ&T Ø ŸI™I c¨4Ô0Ù.Ø $§	¡	Ô*:×*NÑ*NÐPTÕ Uä.×MÑM˜Ù*Ü".¨s¯y©y¼u×?OÑ?OÔ"P˜Cð !%× 2Ñ 2Ø.BÜ(0«
Ø0:Ø*5Ø(,Ø$'ð !3ô !ñ !0à ŸI™IÔ&6×&JÑ&JÈDÔQà×Ñ×!Ñ!Ô#ð ×,Ò,Ø,0×,IÑ,Iò MÑ(�F˜LØ×'Ñ'×+Ñ+¨F°LÔAÜ& vÓ.�CØ‘Ø@L˜×+Ñ+×8Ñ8¸Ò=ð	Mð
 13�Ô-à$ˆDŽKñkU	%÷Jñ Jú÷6Oñ 6Oú÷h/ñ /ú÷743ñ 43ús`   Á9A>dÃ7dÄG
dË??d9Ì?d9ÍBd9Ï;A*d9Ñ%Bd,Ó2A d9ädädäd)	ä,d6ä1d9ä9e	c               óp  — t        |t        «      �rã|}|j                  r|j                  dv rqt        t	        |j
                  «      t        t        f«      sH| j                  d   s9| j                  t        j                  j                  |j                  «      |«       |j                  r!|j                  dk(  r| j                  ||«       | j                  |«       | j                  j                   rÊ|j"                  r¾t        |j"                  t$        «      r¤|j"                  j
                  }t'        |«      r| j(                  j+                  d||«       t-        |j"                  j.                  «      D ]D  \  }}	t'        |	«      sŒd|dz   › d|j                  › d�}
| j(                  j+                  |
|	|«       ŒF t1        |j"                  | j                  | j2                  | j(                  |¬	«       |ro|j                  r4| j5                  |«      r#|| j6                  vr| j9                  ||||«       n/|d
v r| j;                  |||«       n|dk(  r| j=                  ||«       t        |j
                  t>        «      rY|j
                  j@                  tB        k(  r*| j                  t        jD                  |j
                  «       | jG                  |«       nAt        |j
                  t>        «      r'|j
                  jH                  r| jG                  |«       |jJ                  r‘|jL                  r=| jO                  |j
                  «      s!| j                  t        jP                  |«       y y | jS                  |j
                  |jT                  «      s!| j                  t        jV                  |«       y y y )N)r,  Ú__init_subclass__rŒ  r»  zReturn typez	Argument rˆ  z to "ú"©rï  )Ú__getattr__Ú__getattribute__Ú__setattr__),rÌ  ro   r4  rÊ  rú   r"  rã   rô   rQ  r°  r   ÚMUST_HAVE_NONE_RETURN_TYPEr²  Úcheck___new___signatureÚcheck_for_missing_annotationsrZ  Údisallow_any_unimportedr­  rÝ   rÀ   rH  Úunimported_type_becomes_anyrÏ  r  r¿   rp  Úis_reverse_op_methodry  Ú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Ø  rH  rÊ  r  rº  r?  r"  Úidxrñ  Úprefixs              r   rÈ  zTypeChecker.check_funcdef_itemŠ  sæ  € ô �dœGÕ$ØˆDð —	’	Ø—I‘IÐ!BÑBÜ"¤?°3·<±<Ó#@Ä8Ì_ÐB]Ô^Ø×*Ñ*¨2Ò.à—	‘	Ô*×EÑE×LÑLÈTÏYÉYÓWÐY]Ô^ð �yŠy˜TŸY™Y¨)Ò3Ø×,Ñ,¨T°3Ô7à×.Ñ.¨tÔ4Ø�|‰|×3Ò3Ø—9’9¤¨D¯I©I´|Ô!DØ#Ÿy™y×1Ñ1�HÜ3°HÔ=ØŸ™×<Ñ<¸]ÈHÐVZÔ[Ü)2°4·9±9×3FÑ3FÓ)Gò Y™˜˜XÜ7¸ÕAØ'0°°q±°	¸¸t¿y¹y¸kÈÐ%K˜FØ ŸH™H×@Ñ@ÀÈÐSWÕXðYô #Ø—	‘	˜4Ÿ<™<¨×)>Ñ)>ÀÇÁÐRVõñ à—	’	Ø×-Ñ-¨dÔ3Ø × 8Ñ 8Ñ8ð ×,Ñ,¨T°3¸¸dÕCØÐ<Ñ<Ø×)Ñ)¨#¨t°TÕ:Ø˜Ò&Ø×)Ñ)¨#¨tÔ4ô �c—l‘l¤KÔ0Ø�|‰|×$Ñ$¬Ò5Ø—	‘	Ô*×NÑNÐPS×P\ÑP\Ô]Ø×-Ñ-¨cÕ2Ü˜×-Ñ-¬{Ô;À×@UÑ@U×@\Ò@\ð ×-Ñ-¨lÔ;ð ×ÒØ×&Ò&Ø×:Ñ:¸3¿<¹<ÔHØ—I‘IÔ.×VÑVÐX[Õ\ð Ið ×4Ñ4°S·\±\À4×CTÑCTÔUØ—I‘IÔ.×PÑPÐRUÕVð Vð r  c                ó¤  — t        |«      }t        |t        «      sy| j                  j                  sLt        | j                  «      dk  s4| j                  d   r%|j                  «       rt        |j                  «      S | j                  j                  |«      5  | j                  j                  «       }|€
	 d d d «       y	 d d d «       |j                  r;|j                  r0|j                  d   t        j                   t        j"                  fv ry|j                  s| j%                  d|«       y| j&                  ry|j                  d   }|j(                  s|j*                  dk(  r)t,        j.                  j0                  j3                  «      }t5        |«      ryt        t7        t9        |«      «      «      }t;        ||d¬«      sût        |t<        «      r|j>                  j@                  sJt        |t0        «      r=t        |jB                  t<        «      r#|jB                  j>                  j@                  rd }nt|jD                  d   d	v rStF        jH                  jK                  |jM                  | j                  «      |jM                  | j                  «      «      }ntF        jN                  }|r| j%                  ||«       y# 1 sw Y   �ŒxY w)
NFr  éþÿÿÿr   zKMethod must have at least one argument. Did you forget the "self" argument?Tr»  )Úignore_type_params>   Úclsr+  )(rú   rÌ  rÝ   rZ  Úcheck_untyped_defsrý  rQ  r¢  r.  r  rN  rÉ  rÊ  rÌ  r   r   rM   Ú	ARG_STAR2r°  rv  Ú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ñ  ÚerasedrH  s          r   rÎ  z)TypeChecker.require_correct_self_argumentÐ  s2  € Ü˜tÓ$ˆÜ˜$¤Ô-Øð �L‰L×+Ò+Ü�4×%Ñ%Ó&¨Ò*Ø×%Ñ% bÒ)Ø—?‘?Ô$ä˜Ÿ™Ó'Ð'à�Z‰Z×%Ñ% dÓ+ñ 	ð %)§J¡J×$?Ñ$?Ó$AˆHØÐØ÷	ð 	ð  ÷		ð ×,Ò,Ø�NŠN˜tŸ~™~¨aÑ0´U·^±^ÄUÇ_Á_Ð4UÑUàà�~Š~Ø�I‰IØ]Ð_côð à×$Ò$Øà—>‘> !Ñ$ˆØ�=Š=˜DŸI™I¨Ò2Ü—z‘z×*Ñ*×:Ñ:¸8ÓDˆHÜ˜ (Ô+Øô !¤´¸xÓ0HÓ!IÓJˆÜ˜( F¸tÕDä˜6¤8Ô,Ø—K‘K×+Ò+Ü˜f¤hÔ/Ü˜vŸ{™{¬HÔ5Ø—K‘K×$Ñ$×0Ò0ð
 ‘Ø—‘ Ñ" oÑ5Ü&×EÑE×LÑLØ×+Ñ+¨D¯L©LÓ9¸8×;TÑ;TÐUY×UaÑUaÓ;bó‘ô '×CÑC�ÙØ—	‘	˜#˜tÔ$Ø÷e	ñ 	ús   ÂKËKc                ó¤   — | j                   j                  «       }|sy|D ].  }t        |t        «      sŒt	        |j
                  |«      |k\  sŒ. y y)zÞCan 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)rM  Úouter_functionsrÌ  ro   Úfind_last_var_assignment_liner  )r+  rø  Ú
after_lineÚoutersÚouters        r   rÔ  z-TypeChecker.is_var_redefined_in_outer_context  sR   € ð —‘×,Ñ,Ó.ˆÙð Øò 	 ˆEÜ˜%¤Õ)Ü0°·±¸QÓ?À:ÓMÙð	 ð r  c                óˆ  — t        |j                  t        «      �r'|j                  |j                  v �rt	        «       }|j
                  D ]  }|j                  |«       Œ |j                  |j
                  vrÈ| j                  t        j                  |j                  t        ¬«       t        |j                  j                  «      }t        |t        «      r|j                  j                  dk(  sO| j!                  dt#        |j                  j                  | j$                  «      › d�|j                  t        ¬«       yyyyy)z:Fails when the return typevar is not defined in arguments.r¾  úbuiltins.objectzConsider using the upper bound z instead©rï  r¿  N)rÌ  r"  rò   rl  ÚCollectArgTypeVarTypesr  r«  r°  r   ÚUNBOUND_TYPEVARr-   rú   rM  rá   r­  r   ré  rD   rZ  )r+  rH  Úarg_type_visitorÚargtyperM  s        r   r  z(TypeChecker.check_unbound_return_typevar#  s  € ä�c—l‘l¤KÕ0°S·\±\ÀSÇ]Á]Ò5RÜ5Ó7ÐØŸ=™=ò 1�Ø—‘Ð/Õ0ð1ð �|‰|Ð#3×#=Ñ#=Ñ=Ø—	‘	Ô*×:Ñ:¸C¿L¹LÌx�	ÔXÜ-¨c¯l©l×.FÑ.FÓG�ä˜{¬HÔ5Ø#×(Ñ(×1Ñ1Ð5FÒFà—I‘IØ9Ü& s§|¡|×'?Ñ'?ÀÇÁÓNÐOÈxðYà #§¡Ü%ð	 õ ð Gð >ð 6SÐ0r  c           
     ó   — |€t        |j                  «      }| j                  j                  |j	                  «       «       |j
                  D �]  }|j                  €Œ|rt        |j                  t        «      rŒ.|j                  j                  }d}|j                  d«      r|d|dd  › �z  }n	|d|› d�z  }| j                  j                  s8t        |j                  t        «      r|j                  j                  dk(  rdd	g}nd }| j!                  |j                  j"                  |j                  |j                  t%        |t&        j(                  ¬
«      dd|¬«       �Œ | j                  j+                  «        y )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ï  rH  Úlvalue_nameÚrvalue_nameÚnotes)r©   r  rQ  r8  r¢  rØ  ÚinitializerrÌ  ri   rÙ  rÊ  Ú
startswithrZ  Úimplicit_optionalr   r   Úcheck_simple_assignmentr­  r?   rç  Ú
ASSIGNMENTr=  )r+  rØ  rû  ÚparamrÊ  rH  r;  s          r   r.  z TypeChecker.check_default_params8  s`  € ØÐ"Ü-¨d¯i©iÓ8ˆOð 	×Ñ×!Ñ! $§/¡/Ó"3Ô4Ø—^‘^ó  	ˆEØ× Ñ Ð(ØÙ¤:¨e×.?Ñ.?ÄÔ#NØØ—>‘>×&Ñ&ˆDØ-ˆCØ�‰Ð/Ô0ØÐ)¨$¨r¨s¨)¨Ð5Ñ5‘à˜ T F¨!Ð,Ñ,�à—L‘L×2Ò2Ü˜u×0Ñ0´(Ô;Ø×%Ñ%×.Ñ.°/ÒAð]ð,ð‘ð �Ø×(Ñ(Ø—‘×#Ñ#Ø×!Ñ!Ø×)Ñ)Ü  ¬5×+;Ñ+;Ô<Ø'Ø%Øð )ö ð1 	ðB 	×Ñ×ÑÕ r  c                ó&   — |t         j                  v S r'  )r   Úreverse_op_methods©r+  Úmethod_names     r   Úis_forward_op_methodz TypeChecker.is_forward_op_methoda  s   € Øœi×:Ñ:Ð:Ð:r  c                ó&   — |t         j                  v S r'  )r   Úreverse_op_method_setrD  s     r   r  z TypeChecker.is_reverse_op_methodd  s   € Øœi×=Ñ=Ð=Ð=r  c                óê  — | j                    xs | j                  j                  }|sy t        |j                  t
        «      xr> t        d„ |j                  j                  |j                  j                  gz   D «       «      }| j                  j                  xr |}| j                  j                  s|�r>|j                  €Û| j                  j                  rÅ|j                  r<t        |j                  «      dk(  r~|j                  d   dk(  s|j                  d   dk(  rZ| j                  t        j                   |«       t#        |«      sQ|j$                  sD| j'                  d|t(        j*                  ¬«       y | j                  t        j,                  |«       y y y t        |j                  t
        «      �r;t/        |j                  j                  «      }t1        |«      r!| j                  t        j                   |«       n¨|j$                  rFt1        | j3                  ||j4                  «      «      rw| j                  t        j                   |«       nV|j4                  rJt        |t6        «      r:t1        | j9                  |«      «      r | j                  t        j                   |«       t        d„ |j                  j                  D «       «      r!| j                  t        j:                  |«       y y y y )	Nc              3  ó4   K  — | ]  }t        |«       –— Œ y ­wr'  ©r   ©rÞ  Úts     r   rß  z<TypeChecker.check_for_missing_annotations.<locals>.<genexpr>l  s    è ø€ ò N
Ø*+Ô" 1Ó%Ô%ñN
ùrà  rˆ  r   r+  r  z1Use "-> None" if function does not return a valuer¾  c              3  ó2   K  — | ]  }t        |«      –— Œ y ­wr'  rK  rL  s     r   rß  z<TypeChecker.check_for_missing_annotations.<locals>.<genexpr>Œ  s   è ø€ ÒJ°Ô)¨!×,ÑJùó   ‚)rp  rZ  Ú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+  r?  Úshow_untypedÚhas_explicit_annotationÚcheck_incomplete_defsr"  s         r   r
  z)TypeChecker.check_for_missing_annotationsg  sA  € Ø×0Ñ0Ð0ÒU°D·L±L×4UÑ4UˆÙØä",¨T¯Y©Y¼Ó"Eò #
Ì#ñ N
Ø/3¯y©y×/BÑ/BÀdÇiÁi×FXÑFXÐEYÑ/YôN
ó K
Ðð !%§¡× EÑ EÒ aÐJaÐØ�<‰<×-Ò-Ò1FØ�y‰yÐ  T§\¡\×%GÒ%GØ—~’~Ü˜Ÿ™Ó'¨1Ò,ØŸ™¨Ñ*¨fÒ4¸¿¹ÀqÑ8IÈUÒ8Rà—I‘IÔ.×CÑCÀTÔJÜ/°Ô5¸d×>OÒ>OØŸ	™	ØOØ Ü!&×!5Ñ!5ð "õ ð —I‘IÔ.×EÑEÀtÕLð ?PÐ5ô ˜DŸI™I¤|Õ4Ü*¨4¯9©9×+=Ñ+=Ó>�Ü% hÔ/Ø—I‘IÔ.×CÑCÀTÕJØ×&Ò&Ü)Ø×6Ñ6°xÀ×ARÑARÓSôð Ÿ	™	Ô"2×"GÑ"GÈÕNØ×&Ò&¬:°hÄÔ+IÜ)¨$×*HÑ*HÈÓ*RÔSØŸ	™	Ô"2×"GÑ"GÈÔNÜÑJ°d·i±i×6IÑ6IÔJÔJØ—I‘IÔ.×BÑBÀDÕIð Kð 5ð 2Gr  c                ó`  — t        |j                  «      }t        ||d¬«      }|j                  j                  «       r=| j	                  |j
                  | j                  «       |t        j                  dd«       y t        t        |j
                  «      t        t        t        t        t        f«      sN| j!                  t        j"                  j%                  t'        |j
                  | j(                  «      «      |«       y | j	                  |j
                  ||t        j                  dd«       y )NT)Úis_classmethodÚreturnszbut must return a subtype of)r  r4  rÂ   Úis_metaclassr±  r"  Ú	type_typer   ÚINVALID_NEW_TYPErÌ  rú   rÛ   rá   rç   rô   râ   r°  ÚNON_INSTANCE_NEW_TYPEr²  rD   rZ  )r+  r?  rH  Ú	self_typeÚ
bound_types        r   r	  z#TypeChecker.check___new___signature�  sò   € Ü*¨4¯9©9Ó5ˆ	Ü˜s I¸dÔCˆ
ð �9‰9×!Ñ!Ô#à×ÑØ×#Ñ#Ø—‘Ó ØÜ ×1Ñ1ØØ.õô Ü˜J×/Ñ/Ó0Ü”h¤	¬?¼KÐHô
ð �I‰IÜ ×6Ñ6×=Ñ=Ü 
× 3Ñ 3°T·\±\ÓBóð õ	ð ×ÑØ×#Ñ#ØØÜ ×1Ñ1ØØ.õr  c           	     óž  ‡— |j                   sJ ‚t        t        t        j                  «      t        t        j                  «      gt
        j                  t
        j                  gddgt        t        j                  «      | j                  d«      «      }t        ||«      s| j                  j                  ||«       y|dv ryt        |j                  «      }t        |t        «      ryt        |t        «      r|j                  j                   dk(  ry|j"                  d   t$        k(  r<|j'                  |j(                  d   gdz  t        gdz  |j*                  d   dg¬«      }t-        |j(                  «      dk\  sJ ‚t.        j0                  |   }t        |j(                  d	   «      }t        |t2        «      rt        |j4                  «      }nCt        |t6        «      rt9        |«      }n't        |t:        t<        t>        f«      r|j@                  }t        |tB        «      r6|jD                  }	t        |	t        «      r|	j                  jF                  }
|
�|
}dˆfd
„Št        |t        tH        f«      r	 ‰||«      sy|j(                  d	   }| jJ                  jM                  |||¬«      }| jO                  |||j                   ||||¬«       y)z1Check a reverse operator method such as __radd__.Nr  )Ú__eq__Ú__ne__r-  r   r  r  ©r  r   r!  rˆ  c                ó´   •‡— t        | t        «      r| j                  j                  ‰«      S t	        ˆˆfd„t        | j                  «       «      D «       «      S )Nc              3  ó²   •K  — | ]N  }t        |t        «      xr	  ‰|‰«      xs- t        |t        «      xr |j                  j	                  ‰«      –— ŒP y ­wr'  )rÌ  rõ   rá   r­  Úhas_readable_member)rÞ  Úxri  rÊ  s     €€r   rß  zSTypeChecker.check_reverse_op_method.<locals>.has_readable_member.<locals>.<genexpr>ò  sY   øè ø€ ò ð ô ˜AœyÓ)ÒJÑ.AÀ!ÀTÓ.Jò RÜ˜q¤(Ó+ÒP°·±×0JÑ0JÈ4Ó0PóRñùs   ƒAA)rÌ  rá   r­  ri  Úallrû   Úrelevant_items)rH  rÊ  ri  s    `€r   ri  z@TypeChecker.check_reverse_op_method.<locals>.has_readable_memberî  sL   ù€ ä˜#œxÔ(Ø—x‘x×3Ñ3°DÓ9Ð9Üô ô *¨#×*<Ñ*<Ó*>Ó?ôó ð r  r  )rH  zUnionType | InstancerÊ  Ústrr/  r.  )(r4  rÝ   rÛ   rì   r*  r   rL   r¯  r¸   rH  Úinvalid_signaturerú   r"  rÌ  rá   r­  r   r   rM   ro  r  r!  rý  r   Únormal_from_reverse_oprò   rM  rç   rÕ   rà   rê   râ   r#  rî   rØ  rá  rõ   rƒ  Úanalyze_external_member_accessÚcheck_overlapping_op_methods)r+  r  Úreverse_typeÚreverse_namerï  Úmethod_typer"  Úforward_nameÚforward_instrØ  Úopt_metaÚforward_baseÚforward_typeri  s                @r   r  z#TypeChecker.check_reverse_op_method³  s|  ø€ ð �yŠyÐˆyô #Ü”Y×+Ñ+Ó,¬g´i×6LÑ6LÓ.MÐNÜ�]‰]œEŸM™MÐ*Ø�4ˆLÜ”I×*Ñ*Ó+Ø�O‰OÐ/Ó0ó
ˆô ˜,¨Ô4Ø�H‰H×&Ñ& |°WÔ=ØàÐ/Ñ/àô # <×#8Ñ#8Ó9ˆÜ�h¤Ô(ØÜ�h¤Ô)Ø�}‰}×%Ñ%Ð):Ò:ØØ×!Ñ! !Ñ$¬Ò0Ø'×5Ñ5Ø'×1Ñ1°!Ñ4Ð5¸Ñ9Ü"˜) a™-Ø'×1Ñ1°!Ñ4°cÐ:ð 6ó ˆLô
 �<×)Ñ)Ó*¨aÒ/Ð/Ð/ä ×7Ñ7¸ÑEˆÜ& |×'=Ñ'=¸aÑ'@ÓAˆÜ�l¤KÔ0Ü*¨<×+CÑ+CÓD‰LÜ˜¤iÔ0Ü)¨,Ó7‰LÜ˜¤|´]ÄKÐ&PÔQØ'×0Ñ0ˆLÜ�l¤HÔ-Ø×$Ñ$ˆDÜ˜$¤Ô)ØŸ9™9×3Ñ3�ØÐ'Ø#+�Lõ	ô �|¤h´	Ð%:Ô;Ù# L°,Ô?àØ#×-Ñ-¨aÑ0ˆØ×(Ñ(×GÑGØ˜,°ð Hó 
ˆð 	×)Ñ)ØØØ�I‰IØØØØð 	*õ 	
r  c           	     óÈ  — t        |g«      D ]Ó  }t        |«      }t        |t        «      r4| j	                  |||«      sŒ2| j
                  j                  |||||«       ŒRt        |t        «      rE|j                  D ]5  }	| j	                  |	||«      sŒ| j
                  j                  |||||«       Œ7 Œ§t        |t        «      rŒ¸| j
                  j                  ||«       ŒÕ y)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_oprH  Ú"operator_method_signatures_overlaprä   rÐ  rÛ   Úforward_operator_not_callable)
r+  rr  rs  Úreverse_classry  ru  rx  rï  Úforward_itemrØ  s
             r   rq  z(TypeChecker.check_overlapping_op_methods  sÒ   € ô` 2°<°.ÓAò 	NˆLÜ*¨<Ó8ˆLÜ˜,¬Ô5Ø×0Ñ0°¸|È\ÕZØ—H‘H×?Ñ?Ø% |°\À<ÐQXõô ˜L¬*Ô5Ø(×.Ñ.ò �DØ×4Ñ4°T¸<ÈÕVØŸ™×CÑCØ)¨<¸À|ÐU\õñô
   ¬gÕ6Ø—‘×6Ñ6°|ÀWÕMñ	Nr  c                óŠ  — t        |j                  «      dk  ry|}t        |t        «      rt	        |«      }|j                  ||j                  d   gt        j                  gdz  d gdz  ¬«      }|j                  |j                  d   |j                  d   gt        j                  gdz  d gdz  ¬«      }|j                  d   }t        |t        «      rt	        |«      }t        ||«      ryt        ||«      r|}|}	n|}|}	| j                  j                  «       }
|
r|
j                  j                  ng }t        ||	|d¬«      S )Nrˆ  Fr   r  rf  )Úpartial_only)rý  r  rÌ  rò   rÇ   ro  r   rL   r·   r¸   rN  rh  r  ri  rj  )r+  r  rx  rr  Úforward_base_erasedÚforward_tweakedÚreverse_tweakedÚreverse_base_erasedÚfirstÚsecondrx  ri  s               r   r{  z$TypeChecker.is_unsafe_overlapping_opK  sZ  € ô ˆ|×%Ñ%Ó&¨Ò*àð
 +ÐÜ�l¤KÔ0Ü"0°Ó">Ðð '×4Ñ4Ø*¨L×,BÑ,BÀ1Ñ,EÐFÜ—}‘}�o¨Ñ)Ø�f˜q‘jð 5ó 
ˆð
 '×4Ñ4Ø#×-Ñ-¨aÑ0°,×2HÑ2HÈÑ2KÐLÜ—}‘}�o¨Ñ)Ø�f˜q‘jð 5ó 
ˆð +×4Ñ4°QÑ7ÐÜÐ)¬;Ô7Ü"0Ð1DÓ"EÐäÐ+Ð-@ÔAØÜÐ+Ð-@ÔAØ#ˆEØ$‰Fà#ˆEØ$ˆFàŸ
™
×/Ñ/Ó1ˆÙ4A�M×&Ñ&×0Ò0Àrˆ	Ü8Ø�6˜9°5ô
ð 	
r  c                óª  — |j                   }|t        j                  vryt        | j	                  |«      «      }|j
                  }d|dd z   }|j                  |«      rut        |«      }t        | j                  j                  |||«      «      }d}t        |t        «      rt        ||«      sd}nd}|r| j                  j                  |||«       yyy)zrCheck an inplace operator method such as __iadd__.

        They cannot arbitrarily overlap with __add__.
        NÚ__r  FT)rÊ  r   Úinplace_operator_methodsrÂ   rË   r4  ri  r  rú   rƒ  rp  rÌ  rà   Úis_more_general_arg_prefixrH  Úsignatures_incompatible)	r+  r  ÚmethodrH  r  Úother_methodÚinstanceÚtyp2r°  s	            r   r:  z)TypeChecker.check_inplace_operator_method  sÑ   € ð
 —‘ˆØœ×;Ñ;Ñ;ØÜ˜×*Ñ*¨4Ó0Ó1ˆØ�i‰iˆØ˜f Q R˜jÑ(ˆØ×"Ñ" <Ô0Ü$ SÓ)ˆHÜ"Ø×!Ñ!×@Ñ@ÀÈxÐY]Ó^óˆDð ˆDÜ˜$¤Ô-Ü1°#°tÔ<Ø‘Dð �ÙØ—‘×0Ñ0°¸ÀtÕLð ð 1r  c           	     óÆ  — t        | j                  j                  «      dk(  r||dk(  r!| j                  t        j
                  |«       y t        | j                  d«      gt        j                  gd gt        t        j                  «      | j                  d«      «      }n™| j                  j                  «       r~t        t        t        j                  «      | j                  d«      gt        j                  t        j                  gd d gt        t        j                  «      | j                  d«      «      }ny t        ||«      s| j                  j!                  |||«       y y )Nrˆ  r  r›  r  )rý  rN  rÆ  r°  r   ÚMODULE_LEVEL_GETATTRIBUTErÝ   r¯  r   rL   rÛ   rì   r*  rh  r¸   rH  Ú$invalid_signature_for_special_method)r+  rH  rï  rÊ  rt  s        r   r  z TypeChecker.check_getattr_method™  s  € Üˆt�z‰z×ÑÓ  AÒ%àÐ)Ò)Ø—	‘	Ô*×DÑDÀgÔNØô 'Ø—‘ Ó0Ð1Ü—‘�Ø�Üœ	×.Ñ.Ó/Ø—‘Ð 3Ó4ó‰Kð �Z‰Z×$Ñ$Ô&Ü&Üœ×/Ñ/Ó0°$·/±/À.Ó2QÐRÜ—‘¤§¡Ð.Ø�t�Üœ	×.Ñ.Ó/Ø—‘Ð 3Ó4ó‰Kð Ü˜#˜{Ô+Ø�H‰H×9Ñ9¸#¸wÈÕMð ,r  c           	     ó¸  — | j                   j                  «       sy t        t        t        j
                  «      | j                  d«      t        t        j
                  «      gt        j                  t        j                  t        j                  gg d¢t        «       | j                  d«      «      }t        ||«      s| j                  j                  ||d«       y y )Nr›  )NNNr  r  )rN  rh  rÝ   rÛ   rì   r*  r¯  r   rL   rã   r¸   rH  r“  )r+  rH  rï  rt  s       r   r  z TypeChecker.check_setattr_method¶  s    € Ø�z‰z×&Ñ&Ô(ØÜ"äœ	×.Ñ.Ó/Ø—‘ Ó/Üœ	×.Ñ.Ó/ðô
 �]‰]œEŸM™M¬5¯=©=Ð9ÚÜ‹JØ�O‰OÐ/Ó0ó

ˆô ˜#˜{Ô+Ø�H‰H×9Ñ9¸#¸wÈÕVð ,r  c           	     óÊ   — | j                  d«      }t        || j                  d|g«      g«      }| j                  |||t        j
                  ddt        j                  ¬«       y)zCheck the type of __slots__.r›  útyping.Iterablezactual typezexpected typer¾  N)r¯  rõ   r®  r±  r   ÚINVALID_TYPE_FOR_SLOTSrç  r@  )r+  rH  rï  Ústr_typeÚexpected_types        r   Úcheck_slots_definitionz"TypeChecker.check_slots_definitionÇ  sh   € à—?‘? >Ó2ˆÜ!Ø�t×.Ñ.Ð/@À8À*ÓMÐNó
ˆð 	×ÑØØØÜ×3Ñ3ØØÜ×!Ñ!ð 	õ 	
r  c                ó  — | j                   j                  «       syt        |«      }t        |t        «      rt        d„ |j                  D «       «      s-| j                  j                  d|t        j                  ¬«       yy)z2Check that __match_args__ contains literal stringsNc              3  ó2   K  — | ]  }t        |«      –— Œ y ­wr'  )Úis_string_literal©rÞ  rØ  s     r   rß  z/TypeChecker.check_match_args.<locals>.<genexpr>Ü  s   è ø€ ò 5
Ø(,Ô˜d×#ñ5
ùrO  zb__match_args__ must be a tuple containing string literals for checking of match statements to workr¾  )rN  rh  rú   rÌ  rç   rk  rÐ  rH  ré  rç  ÚLITERAL_REQ)r+  r&  rH  rï  s       r   Úcheck_match_argszTypeChecker.check_match_args×  sn   € à�z‰z×&Ñ&Ô(ØÜ˜cÓ"ˆÜ˜#œyÔ)´ñ 5
Ø03·	±	ô5
ô 2
ð �H‰H�M‰Mð.àÜ×&Ñ&ð	 õ ð2
r  c                ó\  — g }t        |j                  «      xs g }|j                  r'||j                  j                  j                  xs g z  }|D ]U  }t        |t        «      sŒ|j                  sŒ!|j                  |j                  D �cg c]  }|j                  |f‘Œ c}«       ŒW |ry| j                  j                  sc| j                  j                  sMg }t        j                  |Ž D ]4  }t        |«      }	|j                  t!        ||	«      t#        ||	«      f«       Œ6 |S ||fgS c c}w r'  )Úlistrl  r4  r  ri  rÌ  rò   r  r8  ÚidrZ  ÚmypycÚinspectionsÚ	itertoolsÚproductÚdictÚexpand_funcr7   )
r+  r  rH  ÚsubstÚtvarsÚtvarræ  ÚresultÚsubstitutionsÚmappings
             r   rÆ  zTypeChecker.expand_typevarsæ  s  € ð 57ˆÜ�S—]‘]Ó#Ò) rˆØ�9Š9à�T—Y‘Y—^‘^×-Ñ-Ò3°Ñ3ˆEØò 	JˆDÜ˜$¤Õ,°·³Ø—‘¸D¿K¹KÖH°5˜tŸw™w¨Ò.ÒHÕIð	Jñ ˜$Ÿ,™,×,Ò,°·±×0HÒ0HØ:<ˆFÜ!*×!2Ñ!2°EÐ!:ò W�Ü˜}Ó-�Ø—‘œ{¨4°Ó9¼;ÀsÈGÓ;TÐUÕVðWð ˆMà˜3�K�=Ð ùò Is   ÂD)
c                ój  — d}|j                   r5|j                   j                  |j                  «      x}r|j                  rd}|sn|rk|j                  s^|j                  dvrOt        |j                  «      s9| j                  j                  |j                  |d   j                  |xs |«       y y y y y y )NFT©r,  r»  r   )	r4  r¬  rÊ  rß  r6  rÐ  rH  Ú#explicit_override_decorator_missingr   )r+  r  rD  rï  rß  r  s         r   r9  z-TypeChecker.check_explicit_override_decoratorþ  s¬   € ð !ÐØ�9Š9 $§)¡)§-¡-°·	±	Ó":Ð:˜$Ð:À×@UÒ@Uð  $Ðñ !Ù)Ø×-Ò-Ø—	‘	Ð!8Ñ8Ü˜tŸy™yÔ)à�H‰H×8Ñ8Ø—	‘	Ð4°QÑ7×@Ñ@À'Â/ÈTõð *ð 9ð .ð *ð !r  c                óœ  — | j                   ry|j                  dvxrc | j                  j                  xs |j	                  «        xr8 |j                  dk7  xs' |j
                  j                  j                  d«      du }g }|j
                  j                  dd D ]-  }| j                  |||«      }|€ y|sŒ|j                  |«       Œ/ |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¡  r¼  Údataclass_tagrˆ  )rv  rÊ  rZ  r  r¢  r4  Úmetadatar¬  ÚmroÚ*check_method_or_accessor_override_for_baser8  )r+  r  Úcheck_override_compatibilityrD  Úbaser­  s         r   r5  z!TypeChecker.check_method_override	  sÜ   € ð ×$Ò$Øð �I‰IÐZÐZò Ø—‘×0Ñ0ÒI¸¿¹Ó8IÐ4Iòð —	‘	˜]Ñ*ò CØ—9‘9×%Ñ%×)Ñ)¨/Ó:¸dÐBð 	%ð 57Ð!Ø—I‘I—M‘M ! "Ð%ò 	7ˆDØ×DÑDØ�dÐ8óˆFð ˆ~áÚØ)×0Ñ0°Õ6ð	7ð )Ð(r  c                óÌ  — d}|rß|j                   }|j                  j                  |«      }|rrt        |j                  «      r2t        |«      s'| j                  j                  ||j                   |«       |j                  r| j                  ||j                  |«       d}|rB| j                  |||«      ry|t        j                  v rd|dd z   }| j                  |||«      ry|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Ê  ri  r¬  rž   r  rÐ  rH  Ú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_base7	  sÑ   € ð "ÐÙØ—9‘9ˆDØŸ
™
Ÿ™ tÓ,ˆIÙä  §¡Ô0¼ÀDÔ9IØ—H‘H×0Ñ0°°t·y±yÀ$ÔGà—=’=Ø×=Ñ=¸dÀIÇNÁNÐTXÔYØ$(Ð!Ù+ð ×@Ñ@ÀÀtÈTÔRØØœ9×=Ñ=Ñ=à! D¨¨ H™_�Fð
 ×DÑDÀTÈ6ÐSWÔXØ#Ø Ð r  c                ó  — | j                  |j                  |j                  |d¬«      \  }}| j                  |j                  ||d¬«      \  }}|�|€J ‚t        ||«      s)| j                  j                  |j                  |||«       yy)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Ê  r4  r¸   rH  Úincompatible_setter_overrider)  )r+  r  r¹  rH  r  rL  s         r   Úcheck_setter_type_overridez&TypeChecker.check_setter_type_override`	  s‰   € ð ×)Ñ)¨$¯)©)°T·Y±YÀÐRVÐ)ÓW‰ˆˆQØ×3Ñ3°D·I±I¸tÀTÐW[Ð3Ó\Ñˆ�qàˆ =Ð#<Ð<Ð<ä˜-¨Ô-Ø�H‰H×1Ñ1°$·+±+¸sÀMÐSWÕXð .r  c           
     óN  ‡— |j                   j                  |«      }|syt        |t        «      s|}n|j                  }t        |t
        t        f«      r|j                  xs |j                  }n.|j                  j                  xs |j                  j                  }| j                  |j                  |j                  |«      \  Š}‰€(|j                  › d�|j                  j                   v sJ ‚y|j                  }d}	| j                  |||«      \  }
}|
�€)d}	| j                  | j                  k  rs| j                  j!                  «       }t        |t
        «      r,| j#                  || j                  j%                  |«      «       y| j#                  ||j                  «       yt        |t
        t        f«      r| j'                  |«      }
nst        |t        «      r| j'                  |j                  «      }
nGt        |t(        «      r-|j*                  �t-        |j*                  «      }
nt/        «       }
n
t/        «       }
d}t1        |«      rGt1        |«      st        |t(        «      r,t3        |«      st3        |«      r|	rd}| j5                  ||«       t        |t
        t        f«      r|j                  xs |j                  }n9t        |t        «      r'|j                  }|j                  xs |j                  }nd}t-        ‰«      Št-        |
«      }
t7        |«      rŠt        |t(        «      rz|j8                  sn|j6                  r|j0                  rVt        |t        «      rFt        |
t:        «      s6| j<                  j?                  d|j                  t@        jB                  ¬«       t        |
t:        «      st        ‰t:        «      r	 yt        |
tD        «      �rt        ‰tD        «      �r| jG                  ‰|
|j                  ||jH                  | jJ                  jL                  k(  r|j                  n|jL                  |||«      }|r©|r§t@        jN                  | jP                  jR                  v r�| jU                  |«      rp|sntW        |
‰d¬«      s`tY        |
‰| jP                  ¬«      \  }}tZ        j\                  j_                  d|j                  › d	|› d
|› d�«      }| j?                  ||«       yt        |
t`        «      rºtc        ˆfd„|
jd                  D «       «      rœ|r™t@        jN                  | jP                  jR                  v rs| jU                  |«      rb|s`tY        |
‰| jP                  ¬«      \  }}tZ        j\                  j_                  d|j                  › d	|› d
|› d�«      }| j?                  ||«       ytg        |
‰«      r	 y|r!| jU                  |«      r|rtW        ‰|
«      r	 y| j<                  ji                  |j                  ||j                  ||
‰¬«       y)zªCheck 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.
        Fz-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 ¬«      –— Œ y­w)TrÇ  Nr[  )rÞ  Úorig_typrH  s     €r   rß  zGTypeChecker.check_method_override_for_base_with_name.<locals>.<genexpr>ü	  s%   øè ø€ ò :
àô �s˜H¸4×@Ð@ñ:
ùs   ƒ©ÚoriginalÚoverride)5ri  r¬  rÌ  rf   rÓ  ro   r„   r  Ú	is_staticrÃ  rÊ  r4  r  rl  rí  rN  rì  ré  rè  rË   r™   r­  rú   rã   r'  Úis_custom_settable_propertyrÅ  rÑ  r¼  rÛ   rH  r°  rç  ÚOVERRIDErà   Úcheck_overrideÚmodule_namerf  r   ÚMUTABLE_OVERRIDErZ  Ú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_readyrL  Ú	top_levelÚalways_allow_covariantÚoriginal_class_or_staticr?  ÚokÚbase_strÚoverride_strrH  rH  s                      @r   r¾  z4TypeChecker.check_method_override_for_base_with_nameo	  sX  ø€ ð —J‘J—N‘N 4Ó(ˆ	ÙØô
 ˜$¤	Ô*Ø‰Gà—i‘iˆGô �dœWÔ&7Ð8Ô9Ø'+§}¡}Ò'F¸¿¹Ñ$à'+§y¡y×'9Ñ'9Ò'P¸T¿Y¹Y×=PÑ=PÐ$Ø×)Ñ)¨$¯)©)°T·Y±YÀÓE‰ˆˆQØˆ;ð —i‘i�[ Ð.°$·)±)·/±/ÑAÐAÐAØà!Ÿ™ˆð ˆØ×3Ñ3°D¸$ÀÓEÑˆ�qØÑ Ø#ˆOØ�}‰}˜tŸ~™~Ò-ð !ŸJ™J×9Ñ9Ó;�	Ü˜i¬Ô1Ø—O‘O I¨t¯z©z×/IÑ/IÈ)Ó/TÔUð
 ð —O‘O D¨$¯)©)Ô4ØÜ˜M¬GÔ5FÐ+GÔHØ $× 2Ñ 2°=Ó A‘Ü˜M¬9Ô5Ø $× 2Ñ 2°=×3EÑ3EÓ F‘Ü˜M¬3Ô/ð !×%Ñ%Ð1Ü$3°M×4FÑ4FÓ$G‘Mä$,£J‘Mô !)£
�à!&ÐÜ Ô%Ü  Ô/´:¸mÌSÔ3Qä*¨4Ô0Ô5PÐQ^Ô5_ñ #Ø-1Ð*Ø×3Ñ3°D¸$Ô?ä�m¤gÔ/@Ð%AÔBØ'4×'=Ñ'=Ò'XÀ×AXÑAXÑ$Ü˜¤yÔ1Ø ×%Ñ%ˆDØ'+§}¡}Ò'F¸¿¹Ñ$à',Ð$ä˜cÓ"ˆÜ'¨Ó6ˆô ˜ÔÜ˜=¬#Ô.Ø!×*Ò*Ø"×.Ò.°-×2TÒ2TÜ˜4¤Ô+ô ˜m¬WÔ5Ø—‘—‘ØQà—I‘IÜŸ™ð	 ô ô �m¤WÔ-´¸CÄÔ1IØðD ôC ˜¤|Õ4¼ÀCÌÕ9Và×$Ñ$ØØØ—	‘	ØØ!×-Ñ-°·±×1CÑ1CÒC�—	’	ÈÏÉØ(Ø(Øó	ˆBñ Ù!Ü×*Ñ*¨d¯l©l×.NÑ.NÑNØ×.Ñ.¨}Ô=Ù.Ü" =°#ÈDÕQä)?Ø! 3°·±ô*Ñ&�˜,ô '×NÑN×bÑbØ$ T§Y¡Y KÐ/EÀhÀZð P*Ø*6¨°qð:ó�ð —	‘	˜#˜wÔ'ðJ ôI ˜¤yÔ1´có :
à)×/Ñ/ô:
ô 7
ñ Ü×*Ñ*¨d¯l©l×.NÑ.NÑNØ×.Ñ.¨}Ô=Ù.ô *@Ø! 3°·±ô*Ñ&�˜,ô '×NÑN×bÑbØ$ T§Y¡Y KÐ/EÀhÀZð P*Ø*6¨°qð:ó�ð —	‘	˜#˜wÔ'ð" ô! ˜=¨#Ô.ð ð ñ Ø×/Ñ/°Ô>ÑBXÜ˜3 Ô.ð ð
 ð �H‰H×:Ñ:Ø—	‘	˜4 §¡¨G¸mÐVYð ;ô ð r  c                óº  — t        |t        «      r^|j                  rQ|j                  d   t        k(  r;t	        |j
                  d   |j                  D �ch c]  }|j                  ’Œ c}«      S y t        |t        «      rH|j                  D �cg c]  }| j                  |«      ‘Œ }}|D �cg c]  }|sŒ|‘Œ	 }}|rt        |«      S y J d«       ‚c c}w c c}w c c}w )Nr   z,Need to check all FunctionLike subtypes here)rÌ  rÝ   r   rL   r*   r  rl  r£  rä   rÐ  Úget_op_other_domainrÏ   )r+  Útprø  ÚitÚ	raw_itemsrÐ  s         r   rä  zTypeChecker.get_op_other_domain"
  s»   € Ü�bœ,Ô'Ø�|Š| §¡¨Q¡´7Ò :ô & b§l¡l°1¡oÀbÇlÁlÖ7SÀ¸¿»Ò7SÓTÐTØÜ˜œJÔ'Ø@BÇÁÖI¸"˜×1Ñ1°"Õ5ÐIˆIÐIØ"+Ö2˜Bªr’RÐ2ˆEÐ2ÙÜ,¨UÓ3Ð3ØàHÐHÓH�5ùò 8Tùò JùÚ2s   ÁC
ÂCÂ+CÂ3Cc	                ó�
  ‡— d}	d}
t        ||d¬«      sd}	nWt        |t        «      rG| j                  |«      r6| j	                  |«      }| j	                  |«      }|r|rt        ||«      sd}	d}
t        |t
        «      r[|r|sd}	nTt        |t        «      rDt        |t        «      r4|j                  �|j                  €d}	|j                  �|j                  €d}	t        |«      rd}	|	�r\d}t        |t        «      xr |j                  }t        |t        t        f«      r|j                  «       }t        |t        t        f«      r|j                  «       }t        |t        «      �rÚt        |t        «      �rÉt        |j                  «      t        |j                  «      k(  �r�|j                  |j                  k(  �rƒ|j                  «       Šd}t!        |«      }t        |t"        «      r|j$                  j&                  }dˆfd„}t)        t+        |j,                  |j,                  «      «      D �]°  \  }\  }}|j/                  «       r/|j/                  «       r|j                  |   }|j                  |   }n{|j1                  «       rj|j1                  «       rZ|sX|j2                  |   }||j2                  v r:|j                  |   }|j2                  j5                  |«      }|j                  |   }nŒÃŒÄt        | ||«      «      rŒ×|}t        |t"        «      r |j6                  s”|j8                  rW|j$                  j;                  |j&                  «      x}r0t        |j<                  t>        «      r|j<                  j@                  s1|jB                  ||jE                  «       z      }|jF                  dk7  r|}| jH                  jK                  |dz   |||||||¬«       d}�Œ³ t         ||jL                  «      |jL                  «      sõ| jH                  jO                  ||||jL                  |jL                  |«       d}n¾t        |t        «      r®t        |t        «      ržg }|jP                  D ]>  }t)        |jP                  «      D ]$  \  }}t        ||«      sŒ|jS                  |«        Œ> Œ@ t        |«      t        |jP                  «      k(  r.|tU        |«      k7  r | jH                  jW                  ||||«       d}|s!| jH                  jY                  ||||||¬	«       |
r"| j[                  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Ç  Nc                ó   •— t        | ‰¬«      S )N)Úids_to_erase)r*   )rM  Úoverride_idss    €r   Úerase_overridez2TypeChecker.check_override.<locals>.erase_overrideŠ
  s   ø€ Ü)¨!¸,ÔGÐGr  rŒ  rˆ  )Úorigin_contextrÌ  zHOverloaded operator methods can't have wider argument types in overridesr¾  )rM  rè   r/  rè   )0r¸   rÌ  rä   rF  rä  rà   rÝ   Ú
type_guardrË  rÐ  Úunpack_kwargsrm  rý  r  Úmin_argsÚtype_var_idsr�   ro   r4  rÊ  rÏ  Úzipr   Úis_positionalÚis_namedr!  ÚindexrÑ  rž  r¬  r  rf   rä  rØ  ÚboundrŽ  rH  Ú$argument_incompatible_with_supertyper"  Ú'return_type_incompatible_with_supertyperÐ  r8  ÚsortedÚ.overload_signature_incompatible_with_supertyperÙ  ré  rç  rÑ  ) r+  rÎ  rÍ  rÊ  Úname_in_superrÄ  rß  rÚ  r  r°  Úop_method_wider_noteÚoriginal_domainÚoverride_domainÚemitted_msgÚoffset_argumentsÚ	type_namer-  rì  r×  Úsub_kindÚ
super_kindÚoverride_arg_typeÚoriginal_arg_typeÚarg_nameÚ
original_irï  ÚsymÚarg_nodeÚorderÚchild_variantÚparent_variantrë  s                                   @r   rÒ  zTypeChecker.check_override2
  sÆ  ø€ ð8 ˆØ$ÐÜ˜( HÀ4ÕHØ‰DÜ˜¤*Ô-°$×2KÑ2KÈDÔ2Qð #×6Ñ6°xÓ@ˆOØ"×6Ñ6°xÓ@ˆOáÙ#Ü" ?°OÔDà�Ø'+Ð$Ü�h¤Ô-Ù'Ñ0HØ‘Ü˜H¤lÔ3¼
À8Ì\Ô8ZØ×&Ñ&Ð2°x×7JÑ7JÐ7RØ�DØ×#Ñ#Ð/°H×4DÑ4DÐ4LØ�Dä�dÔØˆDâØˆKä)¨(´LÓAÒ\Àh×F\ÑF\Ðä˜(¤\´:Ð$>Ô?Ø#×8Ñ8Ó:�Ü˜(¤\´:Ð$>Ô?Ø#×8Ñ8Ó:�ô ˜8¤\Õ2Ü˜x¬Õ6Ü˜×*Ñ*Ó+¬s°8×3EÑ3EÓ/FÓFØ×%Ñ%¨×):Ñ):Ó:ð  (×4Ñ4Ó6�Ø �	Ü)¨(Ó3�
Ü˜j¬'Ô2Ø *§¡× 4Ñ 4�IõHô 2;Ü˜×*Ñ*¨H×,>Ñ,>Ó?ó2ó ++Ñ-�AÑ-˜ *ð  ×-Ñ-Ô/°J×4LÑ4LÔ4NØ,4×,>Ñ,>¸qÑ,AÐ)Ø,4×,>Ñ,>¸qÑ,AÑ)Ø!×*Ñ*Ô,°×1DÑ1DÔ1FÑO_Ø#+×#5Ñ#5°aÑ#8˜Ø# x×'9Ñ'9Ñ9Ø08×0BÑ0BÀ1Ñ0EÐ-Ø)1×);Ñ);×)AÑ)AÀ(Ó)K˜JØ08×0BÑ0BÀ:Ñ0NÑ-à$à Ü%Ð&7¹ÐHYÓ9ZÕ[Ø+/˜ä& t¬WÔ5Ø$(×$4Ò$4à$(×$5Ò$5à/3¯y©y¯}©}¸T¿Y¹YÓ/GÐ(G¨Ð(GÜ'1°#·(±(¼IÔ'FØ'*§x¡x×':Ò':ð (,§~¡~°a¸(¿.¹.Ó:JÑ6JÑ'K˜HØ'Ÿ}™}°Ò2Ø*2 ØŸ™×EÑEØ ™EØ Ø%Ø)Ø-Ø%Ø#Ø+/ð Fô 	ð '+šðW++ôZ "¡.°×1BÑ1BÓ"CÀX×EVÑEVÔWØ—H‘H×DÑDØ˜m¨Y¸×8IÑ8IÈ8×K\ÑK\Ð^bôð #'‘KÜ˜H¤jÔ1´jÀÌ:Ô6Vð �Ø%-§^¡^ò "�MÜ-6°x·~±~Ó-Fò "Ñ)˜˜>Ü% m°^ÕDØ!ŸL™L¨œOÙ!ñ"ð"ô �u“:¤ X§^¡^Ó!4Ò4¸Ä&ÈÃ-Ò9OØ—H‘H×KÑKØ˜m¨Y¸ôð #'�Káà—‘×>Ñ>Ø˜-¨°DÀ8ÐV^ð ?ô ñ $Ø—	‘	Ø^ØÜŸ™ð ô ð
 ˆxˆr  c                ó   — |j                   rt        |j                   t        «      syt        |j                   j                  «      }t        |«      syt        |«      }|syt        d„ |D «       «      r| j                  j                  |«       yy)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  ó†   K  — | ]9  }t        |j                  t        «      xr |j                  j                  d k(  –— Œ; y­w)úbuiltins.FalseN)rÌ  Úexprr   r   )rÞ  Úrets     r   rß  z7TypeChecker.check__exit__return_type.<locals>.<genexpr>ô
  s;   è ø€ ò 
àô �s—x‘x¤Ó*ÒT¨s¯x©x×/@Ñ/@ÐDTÑ/TÓTñ
ùs   ‚?A)
r­  rÌ  rÝ   rú   r"  Úhas_bool_itemr¼   rk  rH  Úincorrect__exit__return)r+  r  r"  r\  s       r   r¥  z$TypeChecker.check__exit__return_typeá
  sx   € ð �yŠy¤
¨4¯9©9´lÔ CØä" 4§9¡9×#5Ñ#5Ó6ˆÜ˜XÔ&Øä'¨Ó-ˆÙØäñ 
àô
ô 
ð �H‰H×,Ñ,¨TÕ2ð	
r  c           
     ór
  — |j                   }|j                  dd D ]H  }|j                  sŒ| j                  t        j
                  j                  |j                  «      |«       ŒJ t        |j                  «      s9| j                  t        j                  j                  |j                  «      |«       | j                  j                  |j                   «      5  | j                  d¬«      5  | j                  }t        | j                   «      | _        | j                  j#                  «       5  | j$                  j'                  |j                   «      5  | j)                  |j*                  «       ddd«       ddd«       || _        | j,                  s¯|j                   j.                  s=|j                   j0                  s'|j                   j2                  s| j5                  |«       |j6                  s| j9                  |«       | j;                  |«       | j=                  |«       |j.                  r| j?                  |«       |j@                  r÷tC        |j                   «      }tE        |j@                  «      D ]Ê  }tG        |tH        «      rtG        |jJ                  tL        «      rŒ.| jN                  j)                  |«      }| jQ                  ||¬«      }d}	tG        |tR        «      r|jT                  xs d}	| jV                  }
d| _+        | jN                  jY                  ||gtZ        j\                  g||	¬«      \  }}|
| _+        ŒÌ ddd«       ddd«       |j^                  j`                  rã|j^                  jb                  €Í|j                  D ]¾  }te        |jf                  |jh                  j^                  j`                  «      D ]…  \  }}tG        |tj        «      sŒ|jl                  tn        k7  sŒ+tG        |tj        «      sŒ<|jl                  |jl                  k7  sŒV| j                  d|j                  › d�|tp        jr                  ¬	«       Œ‡ ŒÀ |j^                  j`                  r%| ju                  |j^                  j`                  «       |jv                  r'|j^                  j`                  r| jy                  |«       |j6                  s'|j                   j2                  r| j{                  |«       t}        |j                   «       y# 1 sw Y   �Œ—xY w# 1 sw Y   �ŒœxY w# 1 sw Y   �ŒÜxY w# 1 sw Y   �ŒáxY w)
zType check a class definition.rˆ  NT©r  r  )Úcallable_namezVariance of TypeVar "z+" incompatible with variance in parent typer.  )?r4  r¶  r¼  r°  r   ÚCANNOT_INHERIT_FROM_FINALr²  rÊ  rÃ   ÚbasesÚINCOMPATIBLE_DISJOINT_BASESrM  rÁ  r¢  rI  r   rZ  r£  rN  rÂ  r«  r¤  rv  Útypeddict_typeÚ
tuple_typeÚis_enumÚcheck_init_subclassÚhas_incompatible_baseclassÚcheck_multiple_inheritanceÚcheck_metaclass_compatibilityÚcheck_final_deletableÚcheck_typeddict_inheritancerä  rÖ   ÚreversedrÌ  ra   Úanalyzedr‡   rƒ  Ú	temp_noder‰   r   r{  Ú
check_callr   rL   r  ri  Ú	type_argsrò  r�  r­  rò   rÏ  rS   rç  r-   rÅ  r!  Úcheck_protocol_varianceÚ
check_enumr²   )r+  r  rH  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‰iˆØ—G‘G˜A˜B�Kò 	^ˆDØ�}‹}Ø—	‘	Ô*×DÑD×KÑKÈDÏIÉIÓVÐX\Õ]ð	^ô -¨S¯Y©YÔ7Ø�I‰IÔ&×BÑB×IÑIÈ#Ï(É(ÓSÐUYÔZØ�[‰[×$Ñ$ T§Y¡YÓ/ñ *	G°×1IÑ1IÐSWÐ1IÓ1Xñ *	GØŸ™ˆJÜ/°·±Ó=ˆDŒKØ—‘×.Ñ.Ó0ñ +Ø—Z‘Z×*Ñ*¨4¯9©9Ó5ñ +Ø—K‘K §	¡	Ô*÷+÷+ð %ˆDŒKØ×,Ò,ØŸ	™	×0Ò0°D·I±I×4HÒ4HÈDÏIÉI×L]ÒL]à×,Ñ,¨TÔ2Ø×6Ò6à×3Ñ3°CÔ8Ø×2Ñ2°3Ô7Ø×*Ñ*¨3Ô/Ø×%Ò%Ø×4Ñ4°TÔ:à�ŠÜ,¨T¯Y©YÓ7�ä!)¨$¯/©/Ó!:ò G�IÜ! )¬XÔ6¼:Ø!×*Ñ*¬Kô<ð !à×+Ñ+×2Ñ2°9Ó=�CØŸ>™>¨#°y˜>ÓA�DØ#�HÜ! )¬WÔ5Ø#,×#5Ñ#5Ò#=¸˜ð /3×.FÑ.FÐ+Ø/3�DÔ,Ø!×.Ñ.×9Ñ9Ø˜d˜V¤e§m¡m _°dÈ(ð :ó ‘F�C˜ð 0G�DÕ,ð)G÷-*	G÷ *	GðZ �8‰8×Ò #§(¡(×"4Ñ"4Ð"<Ø ŸY™Yò �	Ü14Ø—N‘N I§N¡N×$7Ñ$7×$AÑ$Aó2ò Ñ-�I˜~ô # 9¬kÕ:Ø%×.Ñ.´)Ó;Ü& ~´{ÕCØ*×3Ñ3°y×7IÑ7IÓIàŸ	™	Ø3°I·N±NÐ3Cð D;ð ;à$(Ü!&§¡ð	 "õ ñðð  �8‰8×ÒØ×'Ñ'¨¯©×(:Ñ(:Ô;à�?Š?˜sŸx™x×1Ò1Ø×(Ñ(¨Ô.Ø×.Ò.°4·9±9×3DÒ3DØ�O‰O˜DÔ!Ü˜dŸi™iÕ(÷C+ñ +ú÷+ñ +ú÷*	Gñ *	Gú÷ *	Gñ *	GúsV   ÃT,Ã-ATÄ.&TÅT	Å0TÅ8GTÍT,ÔTÔ
TÔTÔTÔT)	Ô$T,Ô,T6c                ó  — |j                   D ]|  }|j                  j                  |«      }|sŒ!t        |j                  t
        «      sŒ<|j                  j                  sŒS| j                  t        j                  |j                  «       Œ~ y r'  )
Údeletable_attributesri  r¬  rÌ  r  r™   r¼  r°  r   ÚCANNOT_MAKE_DELETABLE_FINAL)r+  rH  Úattrr  s       r   r!  z!TypeChecker.check_final_deletableI  sb   € ð ×,Ñ,ò 	SˆDØ—9‘9—=‘= Ó&ˆDÚœ
 4§9¡9¬cÕ2°t·y±y×7IÓ7IØ—	‘	Ô*×FÑFÈÏ	É	ÕRñ	Sr  c                ó  — |j                   j                  r-|j                   j                  j                  j                  dvry|j                   j                  dd D �])  }d|j
                  vrŒt        |j                  «      }||_        t        |d«      }t        |j                  j                  «       «      }t        |j                  j                  «       «      }d|v r3|j                  d«      }|j                  |«       |j                  |«       t         gt#        |«      z  }t%        ||||«      }	|j&                  |	_        |j(                  |	_        |j*                  |	_        | j,                  j/                  |	dd¬«        y y)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)r4  rá  r­  r   r¶  ri  r   rÊ  r  r}   r¢  Úkeywordsr  Úkeysrõ  r=  rK   rý  ra   rŽ  r   r�  rƒ  r«  )
r+  r  r¹  rµ  Úcalleer�  r!  r  r   Ú	call_exprs
             r   r  zTypeChecker.check_init_subclassQ  sK  € ð �9‰9×#Ò#¨¯	©	×(@Ñ(@×(EÑ(E×(NÑ(Nð W
ñ )
ð ð —I‘I—M‘M ! "Ð%ó 	ˆDØ"¨$¯*©*Ñ4ØÜ  §¡Ó+ˆIØ!ˆIŒNÜ 	Ð+>Ó?ˆFÜ˜Ÿ™×,Ñ,Ó.Ó/ˆDÜ*.¨t¯}©}×/AÑ/AÓ/CÓ*DˆIð ˜iÑ'Ø—o‘o kÓ2�Ø—‘˜cÔ"Ø—‘˜”Ü"˜¤c¨$£iÑ/ˆIÜ  ¨¨y¸)ÓDˆIØ!ŸY™YˆIŒNØ#Ÿ{™{ˆIÔØ!%§¡ˆIÔØ×Ñ×$Ñ$ YÀ$ÐY]Ð$Ô^ñ ñ-	r  c                ó6  ‡— |D ]“  Št        ‰t        «      r‰j                  «       sŒ$t        ‰j                  ‰j
                  «      s| j                  d‰«       ‰j                  sŒct        ˆfd„‰j                  D «       «      rŒ‚| j                  d‰«       Œ• y )Nz3TypeVar default must be a subtype of the bound typec              3  óJ   •K  — | ]  }t        ‰j                  |«      –— Œ y ­wr'  )r·   r8  )rÞ  ræ  Útvs     €r   rß  z5TypeChecker.check_typevar_defaults.<locals>.<genexpr>‡  s   øè ø€ Ò$\È¤\°"·*±*¸e×%DÑ$\ùs   ƒ #z3TypeVar default must be one of the constraint types)	rÌ  rò   Úhas_defaultr¸   r8  rM  r°  r  rã  )r+  r«  rC  s     @r   rÅ  z"TypeChecker.check_typevar_defaults�  sw   ø€ Øò 	UˆBÜ˜r¤;Ô/°B·N±NÔ4DØÜ˜bŸj™j¨"¯.©.Ô9Ø—	‘	ÐOÐQSÔTØ�y‹y¤Ó$\ÐRT×R[ÑR[Ô$\Õ!\Ø—	‘	ÐOÐQSÕTñ	Ur  c                óR  — |j                   j                  sJ ‚|j                   j                  t        vr‹d|j                   j                  v rs|j                   j                  d   }t        |j                  t        «      r@|j                  j                  r*| j                  t        j                  |j                  «       |j                   j                  dd D ]4  }|j                  sŒ|j                  t        vsŒ#| j                  ||«       Œ6 | j                  rj| j                  j                  dvrR|j                   j                   s<| j                  d|j                   j                  › d�|«       | j#                  d|«       | j%                  |«       | j'                  |«       y )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)r4  r  r   r¬   ri  rÌ  r  r™   Úhas_explicit_valuer°  r   Ú$ENUM_MEMBERS_ATTR_WILL_BE_OVERRIDDENr¶  Úcheck_final_enumrn  rf  Úenum_membersré  Úcheck_enum_basesÚcheck_enum_new)r+  r  r  r¹  s       r   r)  zTypeChecker.check_enumŠ  sG  € Ø�y‰y× Ò Ð Ð Ø�9‰9×Ñ¤ZÑ/°MÀTÇYÁYÇ_Á_Ñ4TØ—)‘)—/‘/ -Ñ0ˆCÜ˜#Ÿ(™(¤CÔ(¨S¯X©X×-HÒ-Hð —	‘	Ô*×OÑOÐQT×QYÑQYÔZØ—I‘I—M‘M ! BÐ'ò 	2ˆDØ�|‹| §¡´ZÒ ?Ø×%Ñ% d¨DÕ1ð	2ð �<Š<˜DŸI™I×.Ñ.Ð6KÑKØ—9‘9×)Ò)Ø—	‘	Ø% d§i¡i×&8Ñ&8Ð%9ð :0ð 0ð ôð —	‘	ØbØôð
 	×Ñ˜dÔ#Ø×Ñ˜DÕ!r  c                ó^   — |j                   r!| j                  d|j                  › d�|«       y y )Nz+Cannot extend enum with existing members: "r  )rL  r°  rÊ  )r+  r  r¹  s      r   rK  zTypeChecker.check_final_enum§  s-   € Ø×ÒØ�I‰IÐCÀDÇIÁIÀ;ÈaÐPÐRVÕWð r  c                óØ  — t        |j                  t        t        f«      ryt        |j                  t        «      syt        |j                  j                  «      skt        |j                  j                  «      sLt        |j                  j                  «      s-t        t        |j                  j                  «      t        «      ry| j                  xs |j                  j                  S )NFT)rÌ  r  rn   rf   r™   rÐ  rÊ  r	  r
  rú   r­  rà   rn  rI  )r+  r  s     r   Úis_final_enum_valuezTypeChecker.is_final_enum_value«  s�   € Ü�c—h‘h¤¬9Ð 5Ô6ØÜ˜#Ÿ(™(¤CÔ(Øô �s—x‘x—}‘}Ô%Ü˜Ÿ™Ÿ™Ô'Ü˜Ÿ™Ÿ™Ô'ô œ/¨#¯(©(¯-©-Ó8¼,ÔGàà�|‰|Ò:˜sŸx™x×:Ñ:Ð:r  c                ó  — d}|j                   j                  D ]g  }|€|j                  j                  r|}Œ|€Œ!|j                  j                  rŒ8| j	                  d|j                  | j                  «      › d�|«        y y)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  )r4  r  r­  r  r°  r#  rZ  )r+  r  Ú	enum_baser¹  s       r   rM  zTypeChecker.check_enum_basesÃ  s€   € ð  &*ˆ	Ø—I‘I—O‘Oò 		ˆDØÐ  T§Y¡Y×%6Ò%6Ø �	ØØÑ&¨t¯y©y×/@Ó/@Ø—	‘	ØCÀI×D^ÑD^Ð_c×_kÑ_kÓDlÐCmÐmnÐoØôñ ñ		r  c                ó|  ‡— dd„Šd}|j                   j                  D ]œ  }d}|j                  j                  r,t	        ˆfd„|j                  j
                  dd D «       «      }n ‰|j                  «      }|r=|r;| j                  dj                  |j                  | j                  «      «      |«       Œ˜|sŒ›d}Œž y )	Nc                óŒ   — | j                  d«      }t        |xr' |j                  xr |j                  j                  dk7  «      S )Nr»  zbuiltins.object.__new__)r¬  r.  r  r   )r4  Ú
new_methods     r   Úhas_new_methodz2TypeChecker.check_enum_new.<locals>.has_new_methodà  sF   € ØŸ™ )Ó,ˆJÜØò JØ—O‘OòJà—O‘O×,Ñ,Ð0IÑIóð r  Fc              3  óL   •K  — | ]  }|j                    xr  ‰|«      –— Œ y ­wr'  )r  )rÞ  ÚbrW  s     €r   rß  z-TypeChecker.check_enum_new.<locals>.<genexpr>î  s$   øè ø€ ÒaÈ A§I¡I Ò C±.ÀÓ2CÓ CÑaùs   ƒ!$rˆ  rŒ  zLOnly a single data type mixin is allowed for Enum subtypes, found extra "{}"T)r4  r—   r/  r.  )
r4  r  r­  r  rã  r¶  r°  r²  r#  rZ  )r+  r  Úhas_newr¹  Ú	candidaterW  s        @r   rN  zTypeChecker.check_enum_newß  s£   ø€ ó	ð ˆØ—I‘I—O‘Oò 	ˆDØˆIà�y‰y× Ò äÓaÈTÏYÉYÏ]É]Ð[\Ð]_ÐM`ÔaÓa‘	á*¨4¯9©9Ó5�	á™WØ—	‘	ð'ß'-¡v¨d×.CÑ.CÀDÇLÁLÓ.QÓ'RØõò
 Ø‘ñ!	r  c                ó~  — | j                   ry|j                  �y|j                  }t        |j                  d   g «      }|j
                  j                  }| j                  €(| j                  dddg «      \  }}t        |g «      | _        | j                  }t        |«      D �]  \  }}	t        |	t        «      sŒt        |«      D �
�cg c]  \  }
}||
k(  r|n|j                  «       ‘Œ }}
}t        |«      D �
�cg c]$  \  }
}||
k(  r
t        «       n|j                  «       ‘Œ& }}
}t        ||«      t        ||«      }}t        ||d¬«      rt        }nt        ||d¬«      rt         }nt"        }||	j$                  k7  sŒÜ| j&                  j)                  |	j$                  |	j*                  ||«       �Œ yc c}}
w c c}}
w )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>ÚDummyT)Úignore_declared_variance)rv  r'  r4  rá   r¶  r  ri  rd  Úmake_fake_typeinforÏ  rÌ  rò   ro  rô   r¸   rO   rN   rS   rÏ  rH  Úbad_proto_variancerÊ  )r+  r  r4  Úobject_typer«  r  Ú
dummy_infoÚdummyr×  r¬  ru  Úup_argsÚ	down_argsÚupÚdownrÀ  s                   r   r(  z#TypeChecker.check_protocol_varianceû  sŸ  € ð ×$Ò$ØØ�>‰>Ð%àØ�y‰yˆÜ˜tŸx™x¨™|¨RÓ0ˆØ—	‘	×#Ñ#ˆØ×$Ñ$Ð,Ø ×3Ñ3°I¸wÈÐQSÓT‰MˆAˆzÜ(0°¸RÓ(@ˆDÔ%Ø×)Ñ)ˆÜ  Ó'ó 	V‰GˆAˆtÜ˜d¤KÔ0àäMVÐW\ÓM]÷#ÙEIÀQÈ˜q Ašv‘¨5×+>Ñ+>Ó+@Ñ@ð#ˆGñ #ô T]Ð]bÓSc÷%ÙKOÈ1Èa Q¨!¢V”Ô!°×1DÑ1DÓ1FÑFð%ˆIñ %ô    gÓ.´¸¸yÓ0I�ˆBä˜$ ¸TÕBÜ$‘Ü˜B ¸tÕDÜ(‘ä$�Ø˜4Ÿ=™=Ó(Ø—‘×+Ñ+¨D¯M©M¸4¿9¹9ÀhÐPTÖUñ'	Vùó#ùó%s   Ã!F3Ã9)F9c                óÒ  ‡— t        |j                  «      dk  ry|j                  dd }|D ��ch c]  }|j                  D ]  }|’Œ Œ }}}t	        ||j                  j                  «       z
  «      D ]m  Št        ‰«      rŒt        ˆfd„t        |«      D «       «      \  }}||dz   d D ]4  }‰|j                  v sŒ||j                  vsŒ!| j                  ‰|||«       Œ6 Œo yc c}}w )z.Check for multiple inheritance related errors.rˆ  Nc              3  óJ   •K  — | ]  \  }}‰|j                   v sŒ||f–— Œ y ­wr'  )ri  )rÞ  r×  r¹  rÊ  s      €r   rß  z9TypeChecker.check_multiple_inheritance.<locals>.<genexpr>5  s$   øè ø€ ÒY©¨¨DÀdÈdÏjÉjÒFX˜A˜tœ9ÑYùs   ƒ#š	#)
rý  r  r¶  ri  rù  r>  rÐ  ÚnextrÏ  Úcheck_compatibility)r+  rH  r¶  r¹  rÊ  Ú	all_namesr×  Úbase2s       `   r   r  z&TypeChecker.check_multiple_inheritance$  sá   ø€ äˆs�y‰y‹>˜QÒàà�g‰g�a�bˆkˆØ&)×A˜d°d·j±jÒA¨d’TÐA�TÐAˆ	ÑAÜ˜9 s§y¡y§~¡~Ó'7Ñ7Ó8ò 	EˆDô ˜$ÔØô ÓY´I¸c³NÔYÓY‰GˆAˆtØ˜Q ™U˜W˜ò E�Ø˜5Ÿ;™;Ò&¨5¸¿¹Ò+@Ø×,Ñ,¨T°4¸ÀÕDñEñ	Eùó Bs   ¯C#c           	     óJ  — |dv ry|j                   |   }|j                   |   }| j                  ||||¬«      \  }}| j                  ||||¬«      \  }	}t        |«      }
t        |	«      }t        |
t        «      rƒt        |t        «      rs|
j                  «       rM|j                  «       r=t        t        |
j                  «       «      t        |j                  «       «      ¬«      }�nq|r|	sJ ‚t        ||	d¬«      }�n[|�r|	�r|j                  �(| j                  |j                  «      st        ||	«      }nt        ||	«      }|�r|j                  �r|j                  rù| j                  |j                  «      rÞt        |j                  «      rÉt        |j                  t        «      r¯t        |t        «      sŸ| j                  j!                  d|› d|j"                  › d	|j"                  › d
�|t$        j&                  ¬«       nT|€'| j                  j)                  ||j"                  |«       |	€'| j                  j)                  ||j"                  |«       d}t+        |j                  «      r2t-        |«      s'| j                  j/                  ||j"                  |«       t+        |j                  «      r| j1                  ||j                  |«       t        |j                  t2        «      r|j                  j4                  rd}|s| j                  j7                  ||||«       yy)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¼  r  N)rx  ©ÚleftÚrightTrÇ  z%Cannot override writeable attribute "z" in base "z#" with read-only property in base "r  r¾  )ri  rÃ  rú   rÌ  rà   Úis_type_objr¸   r  Útype_objectr  rÖ  r´   rÑ  rf   rÛ   rH  r°  rÊ  rç  rÑ  Úcannot_determine_type_in_baserž   rÐ  r»  r½  r™   Úallow_incompatible_overrideÚ#base_class_definitions_incompatible)r+  rÊ  Úbase1rm  rR  r†  r‡  Ú
first_typer  Úsecond_typeÚp_first_typeÚp_second_typerà  s                r   rk  zTypeChecker.check_compatibility:  s•  € ð. ÐNÑNàØ—‘˜DÑ!ˆØ—‘˜TÑ"ˆà×0Ñ0°°u¸cÐQTÐ0ÓU‰ˆ
�AØ×1Ñ1°$¸¸sÐRUÐ1ÓV‰ˆ�Qô ' zÓ2ˆÜ'¨Ó4ˆÜ�l¤LÔ1´jÀÔP\Ô6]Ø×'Ñ'Ô)¨m×.GÑ.GÔ.Iô  Ü/°×0HÑ0HÓ0JÓKÜ0°×1JÑ1JÓ1LÓMô’ñ
 "¡kÐ1Ð1Ü 
¨KÈdÔS’ÚšKØ�{‰{Ð&¨t×/IÑ/IÈ&Ï+É+Ô/VÜ 
¨KÓ8‘ä" :¨{Ó;�Úà—J“JØŸšØ×2Ñ2°6·;±;Ô?Ü# E§J¡JÔ/Ü" 5§:¡:¬yÔ9Ü& }´gÔ>à—H‘H—M‘MØ?À¸vÀ[ÐQV×Q[ÑQ[ÐP\ð ]=Ø=B¿Z¹Z¸LÈðKàÜ"Ÿ^™^ð	 "õ ð Ð!Ø—‘×6Ñ6°t¸U¿Z¹ZÈÔMØÐ"Ø—‘×6Ñ6°t¸U¿Z¹ZÈÔMØˆBô ˜Ÿ™Ô%¬j¸Ô.>Ø�H‰H×(Ñ(¨¨u¯z©z¸3Ô?Ü˜Ÿ™Ô$Ø×5Ñ5°d¸F¿K¹KÈÔMô �f—k‘k¤3Ô'¨F¯K©K×,SÒ,SØˆBÙØ�H‰H×8Ñ8¸¸uÀeÈSÕQð r  c                óˆ  — |j                  «       s0|j                  s$|j                  s|j                  s|j                  �y|j
                  €ut        d„ |j                  D «       «      rX| j                  d|t        j                  ¬«       |j                  «       }|r#| j                  ||t        j                  ¬«       yyyy)z<Ensures that metaclasses of all parent types are compatible.Nc              3  óL   K  — | ]  }|j                   j                  d u–— Œ y ­wr'  )r­  rá  )rÞ  r¹  s     r   rß  z<TypeChecker.check_metaclass_compatibility.<locals>.<genexpr>�  s$   è ø€ ò .
Ø59ˆD�I‰I×$Ñ$¨DÔ0ñ.
ùs   ‚"$zxMetaclass conflict: the metaclass of a derived class must be a (non-strict) subclass of the metaclasses of all its basesr¾  )r]  r!  Úis_named_tupler  r  rá  rã  r  r°  rç  Ú	METACLASSÚexplain_metaclass_conflictré  )r+  rH  Úexplanations      r   r   z)TypeChecker.check_metaclass_compatibility’  s³   € ð ×ÑÔØ�ŠØ×!Ò!Ø�{Š{Ø×!Ñ!Ð-àà×ÑÐ%¬#ñ .
Ø=@¿Y¹Yô.
ô +
ð �I‰IðNàÜ—_‘_ð	 ô ð ×8Ñ8Ó:ˆKÙØ—	‘	˜+ s´·±�	ÕAð ð+
Ð%r  c                ó0  — |j                   j                  sJ ‚|j                   j                  }|j                   j                  }|�|j                  sy|j                  D �]3  \  }}|j                  sJ ‚|j                  «       D �]  \  }}|j
                  |   }|sJ ‚||j                  j                  v }	|	rt        ||«      }
nt        ||«      }
|
rŒP|j                  |   }|j                  €.| j                  d|› d|j                  › d�|j                  «       Œ™| j                  d|› d|j                  › d|j                  j                  › d�|j                  «       ||j                  v sŒì| j                  d|› d	�|j                  «       �Œ �Œ6 y)
zTEnsure that the final definition of a TypedDict is compatible with its base classes.NzDefinition of field "z " incompatible with base class "r  z#Incompatible definitions of field "z" in base classes "z" and "z/This can be resolved by redeclaring the field "z!" with a mutually compatible type)r4  r  Útypeddict_dataÚreadyr  rÐ  Úreadonly_keysr¸   r´   Úfield_sourcesr¹  r°  rÊ  rR  ré  )r+  r  ÚtdÚdatar¹  Ú
base_itemsÚ
field_nameÚ	base_typeÚ
field_typeÚis_readonlyÚis_compatibleÚsources               r   r"  z'TypeChecker.check_typeddict_inheritanceª  s–  € à�y‰y×'Ò'Ð'Ð'Ø�Y‰Y×%Ñ%ˆØ�y‰y×'Ñ'ˆØˆ<˜tŸzšzØØ $§
¡
ó 	ÑˆD�*Ø×&Ò&Ð&Ð&Ø)3×)9Ñ)9Ó);ó Ñ%�
˜IØŸX™X jÑ1�
Ù!Ð!�zØ(¨D×,?Ñ,?×,MÑ,MÐM�ÙÜ$.¨z¸9Ó$E‘Mä$1°*¸iÓ$H�MÚ$Ø!×/Ñ/°
Ñ;�FØ—{‘{Ð*ØŸ	™	Ø3°J°<ð @ Ø $§	¡	˜{¨!ð-à"ŸJ™Jõð Ÿ	™	ØAÀ*Àð N Ø $§	¡	˜{¨'°&·+±+×2BÑ2BÐ1CÀ1ðFà"ŸJ™Jôð
 &¨×)9Ñ)9Ò9Ø ŸI™IØ"QÐR\ÐQ]ð ^Bð !Cà &§
¡
öò/ñ	r  c                óÂ   — |j                   D ]?  \  }}| j                  j                  |«      x}€Œ$| j                  |j                  |«       ŒA | j                  |«       y r'  )ri  rV  r¬  Úwarn_deprecatedr  Úcheck_import)r+  r  rÊ  r  r  s        r   Úvisit_import_fromzTypeChecker.visit_import_fromÐ  sW   € Ø—z‘zò 	5‰GˆD�!Ø—|‘|×'Ñ'¨Ó-Ð-�Ñ:Ø×$Ñ$ S§X¡X¨tÕ4ð	5ð 	×Ñ˜$Õr  c                ó&   — | j                  |«       y r'  ©r’  ©r+  r  s     r   Úvisit_import_allzTypeChecker.visit_import_allÖ  ó   € Ø×Ñ˜$Õr  c                ó&   — | j                  |«       y r'  r•  r–  s     r   Úvisit_importzTypeChecker.visit_importÙ  r˜  r  c           	     ó„  — |j                   D ]±  }|j                  d   }| j                  |«      \  }}}|€t        t        j
                  «      }t        |j                  t        «      sJ ‚t        j                  j                  |j                  j                  «      }| j                  ||j                  ||dd¬«       Œ³ y )Nr   z
local namezimported name)rH  r9  r:  )ÚassignmentsÚlvaluesÚcheck_lvaluerÛ   rì   r*  rÌ  Úrvaluer   r   ÚINCOMPATIBLE_IMPORT_OFr²  rÊ  r?  )r+  r  Úassignrþ  Úlvalue_typer  r‰  Úmessages           r   r’  zTypeChecker.check_importÜ  s¯   € Ø×&Ñ&ò 	ˆFØ—^‘^ AÑ&ˆFØ!%×!2Ñ!2°6Ó!:ÑˆK˜˜BØÐ"ä%¤i×&<Ñ&<Ó=�Ü˜fŸm™m¬XÔ6Ð6Ð6Ü&×=Ñ=×DÑDÀVÇ]Á]×EWÑEWÓXˆGØ×(Ñ(ØØ—‘ØØØ(Ø+ð )õ ñ	r  c                óº  — |j                   r| j                  j                  «        y d}d}|j                  D �]   }| j                  j                  «       rÎd}| j                  j                  «       €!|s| j                  |j                  |¬«       d}| j                  «       sd}|sL|sJ| j                  |«      s9| j                  j                  |«       | j                  j                  «        d}d}|r| j                  j                  s y | j                  j                  sŒì| j                  |«       | j                  j                   j#                  «        �Œ# y )NFr˜  T)r¥  rI  rú  r  rN  rì  r•  r¦  r§  rH  r¨  r©  rZ  rª  r«  rƒ  Ú
expr_cacher‰  )r+  rY  r³  r´  Úsr¶  s         r   Úvisit_blockzTypeChecker.visit_blockò  s  € Ø×Òð �K‰K×#Ñ#Ô%ØØ"ÐØ$ÐØ—‘ó 	1ˆAØ�{‰{×)Ñ)Ô+Ø�Ø—:‘:×0Ñ0Ó2Ð:ÑCUØ×)Ñ)¨!¯&©&¸Ð)Ô:Ø)-Ð&Ø×<Ñ<Ô>Ø!�FáÙ0Ø ×9Ñ9¸!Ô<à—H‘H×2Ñ2°1Ô5Ø—K‘K×=Ñ=Ô?Ø!�FØ+/Ð(á $§,¡,×"@Ò"@Ùà—|‘|×5Ò5Øà�K‰K˜ŒNà×Ñ×(Ñ(×.Ñ.Ö0ñ5	1r  c                óª   — | j                  «       xrB | j                  j                  xr* | j                   xr | j                  j                  «        S r'  )Úin_checked_functionrZ  Úwarn_unreachablerm  rI  Ú!is_unreachable_warning_suppressedr‚  s    r   r¦  z,TypeChecker.should_report_unreachable_issues  sS   € à×$Ñ$Ó&ò DØ—‘×-Ñ-òDà×.Ñ.Ð.òDð —K‘K×AÑAÓCÐCð		
r  c                ó  — t        |t        «      rt        |j                  «      ryt        |t        «      rt        |j                  «      ryt        |t        «      ryt        |t        «      r‹t        |j                  t        «      rq| j                  j                  j                  d¬«      5  t        | j                  j                  |j                  dd¬«      «      }ddd«       t        t        «      ryy# 1 sw Y   ŒxY w)a   Returns 'true' if the given statement either throws an error of some kind
        or is a no-op.

        We use this function while handling the '--warn-unreachable' flag. When
        that flag is present, we normally report an error on any unreachable statement.
        But if that statement is just something like a 'pass' or a just-in-case 'assert False',
        reporting an error would be annoying.
        T)Úfilter_revealed_typer:  NF)rÌ  rZ   Úis_false_literalr  rŠ   Úis_literal_not_implementedrˆ   rk   ra   rƒ  rH  Úfilter_errorsrú   r«  rô   )r+  r¦  rH  s      r   r§  z$TypeChecker.is_noop_for_reachability  sÍ   € ô �aœÔ$Ô)9¸!¿&¹&Ô)AØÜ˜œ:Ô&Ô+EÀaÇfÁfÔ+MØÜ˜œ9Ô%ØÜ˜œ>Ô*Ü˜!Ÿ&™&¤(Ô+Ø×&Ñ&×*Ñ*×8Ñ8ÈdÐ8ÓSñ Ü)Ø×)Ñ)×0Ñ0ØŸF™F°dÈTð 1ó ó�C÷ô ˜c¤?Ô3ØØ÷ð ús   Â.2C:Ã:Dc                ó>  — |j                   r| j                  sZ| j                  |j                  «      5  | j	                  |j
                  d   |j                  |j                  du «       ddd«       |j                   r| j                  |«       |j                  �¤| j                  j                  rŽt        |j                  «      ryt        |j
                  d   t        «      r5| j                  j                  dt!        t"        j$                  «      |«       n'| j                  j                  d|j                  |«       t'        |j                  | j                  | j(                  | j                  |¬«       t+        |j
                  «      dkD  rÂ| j-                  |j                  «      s%| j.                  j1                  |j                  «       | j3                  | j5                  |j                  «      |«      }|j
                  dd D ]E  }| j                  |j                  «      5  | j	                  |||j                  du «       ddd«       ŒG | j7                  |«       |j                  r[|j                  rOt9        |j                  «      s:| j:                  j=                  «       � | j?                  t@        jB                  |«       |jD                  r.| jG                  «       s| j                  jI                  |¬«       yyy# 1 sw Y   �ŒœxY w# 1 sw Y   �ŒxY w)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_defrn  Úenter_final_contextÚis_final_defÚcheck_assignmentr�  rŸ  r­  Úcheck_type_alias_rvaluerZ  r  rÀ   rÌ  r•   rH  r  rÛ   rì   r*  r¿   rp  rý  Úhas_typerƒ  r«  r%  Úlookup_typeÚcheck_finalr  rN  rh  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;  s[  € ð —’ 4§<¢<Ø×)Ñ)¨!¯.©.Ó9ñ OØ×%Ñ% a§i¡i°¡m°Q·X±X¸q¿v¹vÈ¸~ÔN÷Oð �>Š>Ø×(Ñ(¨Ô+ð �F‰FÐØ—‘×4Ò4Ü,¨Q¯V©VÔ4ä˜!Ÿ)™) B™-¬Ô3ð —‘×4Ñ4Ø)¬7´9×3IÑ3IÓ+JÈAõð —‘×4Ñ4Ð5GÈÏÉÐQRÔSÜ˜qŸv™v t§|¡|°T×5JÑ5JÈDÏHÉHÐ^_Õ`äˆq�y‰y‹>˜AÒð —=‘= §¡Ô*Ø×!Ñ!×(Ñ(¨¯©Ô2Ø—^‘^ D×$4Ñ$4°Q·X±XÓ$>ÀÓBˆFØ—i‘i  �nò F�Ø×-Ñ-¨a¯n©nÓ=ñ FØ×)Ñ)¨"¨f°a·f±fÀ°nÔE÷Fð FðFð 	×Ñ˜Ôà�NŠNØ—’Ü# A§F¡FÔ+Ø—
‘
×'Ñ'Ó)Ð5à�I‰IÔ&×DÑDÀaÔHà×Ò T×%=Ñ%=Ô%?Ø�H‰H×5Ñ5¸aÐ5Õ@ð &@Ð÷QOñ Oú÷8Fñ Fús   ´7LÈ( LÌLÌL	c                óê   — | j                   j                  «       5  | j                  j                  |j                  «      }d d d «       | j                  |j                  d   «       y # 1 sw Y   Œ)xY w©NrŒ  )rH  r°  rƒ  r«  rŸ  Ú
store_typer�  )r+  r¦  Ú
alias_types      r   r¶  z#TypeChecker.check_type_alias_rvaluep  sW   € Ø�X‰X×#Ñ#Ó%ñ 	<Ø×*Ñ*×1Ñ1°!·(±(Ó;ˆJ÷	<à�‰˜Ÿ	™	 "™ zÕ2÷	<ð 	<ús   ›&A)Á)A2c                óN  — t        |t        t        f«      r| j                  |j                  |||«       y| j                  ||d«       | j                  ||«      \  }}}t        |t        «      �rO|j                  �rB|j                  j                  }|dv rM|r|}n| j                  j                  |«      }|r+|dk(  r| j                  ||«       n| j                  |||«       |dk(  rK| j                  j                  «       �1|xs | j                  j                  |«      }	| j!                  |	|«       |dk(  r0|�.| j                  j                  |«      }	| j#                  ||	|«       |dk(  rQ| j                  j                  «       }
|
r5t%        j&                  |
«      r | j)                  t*        j,                  |«       t        |t.        «      r/|j                  dk(  r | j)                  t*        j0                  |«       |�r(t        |t2        «      �r;|j4                  �€.| j                  j                  |«      }t        t7        |«      t8        «      ry|j:                  }t=        || j>                  |j@                  ¬«      rl| jC                  |«      }|��[| jD                  s4tG        |«      }tI        |t9        «       g«      }| jK                  |||«       nd|_        ||= |j4                  }�n| jM                  |||«      �sï| jO                  |«      }| jP                  jS                  ||«       | jK                  ||tU        |«      «       �n¤t        |t.        «      rM|jV                  €A| j                  j                  |jX                  «      }| j[                  |||||¬	«      \  }}}�nG| j>                  j\                  �st_        |«      �r	t        |t        «      rù|jV                  t`        k(  ræt        |j                  tb        «      rÌ|j                  j4                  r¶|j                  | jd                  v ržt        t7        |«      tf        «      s…| jd                  |j                     }d
}ti        | jP                  jj                  «      D ]  }|jl                  |v sŒ|jn                  } n |r(tU        |«      }| jK                  |j                  ||«       | jq                  |||||¬«      \  }}d}t7        |«      }t7        |«      }t        |tr        «      rË|ju                  «       r»|jw                  «       jx                  s|jw                  «       jz                  r‡t        |t|        «      rwt        |j~                  t€        «      r]|j~                  j4                  jx                  s |j~                  j4                  jz                  r| j‚                  j…                  ||«       y|r¿|r½t        |t2        «      s­t        |t        «      r|j†                  �s+| jP                  j‰                  |||«       t        |t        «      rþt        |j                  tb        «      rä|j                  jŠ                  rÎ|j                  jŒ                  r¸|�¶tG        |«      |j                  _        n›| j>                  j\                  r…|�ƒt        |t2        «      sst        |t        «      rct        |j                  tb        «      rI|j                  jŠ                  r3| jP                  j‰                  |||«       n|r| j�                  |||«       |r…| j‘                  ||«      }| j                  j                  ||¬«      }|j@                  s6|jŒ                  s*t        |t        «      r|j                  dk(  stG        |«      }| j“                  ||||«       | j•                  |«       t        |t–        «      r@t        |t        «      r|j                  dk(  s | j˜                  s| j›                  ||«       yyyy)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  rN  rh  rš  r   r¦  r§  r°  r   Ú&DATACLASS_POST_INIT_MUST_BE_A_FUNCTIONr}   ÚCANNOT_MODIFY_MATCH_ARGSrå   r­  rú   rã   r&  Úis_valid_inferred_typerZ  r¼  r­  rm  r+   rÏ   Úset_inferred_typeÚinfer_partial_typeÚinference_error_fallback_typerI  rì  rÁ   Úkindr  Úcheck_member_assignmentr×  Úis_literal_nonerU   r™   r_  rÛ   r#  rÒ  r£  rú  r?  rà   rr  rs  Úis_abstractr!  rî   rØ  rá   rH  Ú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‰   rv  Úcheck_compatibility_all_supers)r+  rþ  rŸ  Úinfer_lvalue_typer¢  Úindex_lvaluerÈ  rÊ  Ú	signaturerH  rh  Úrvalue_typer&  rR  Úinferred_typer#  Úinstance_typeÚdecl_frame_mapÚhas_if_ancestorró  Úp_rvalue_typeÚp_lvalue_typer†  s                          r   rµ  zTypeChecker.check_assignmentu  s­  € ô �fœy¬(Ð3Ô4Ø×5Ñ5Ø—‘˜f fÐ.?õð ×?Ñ?ÀÈÐPSÔTØ26×2CÑ2CÀFÈFÓ2SÑ/ˆK˜ xô ˜&¤(Õ+°·³Ø—{‘{×'Ñ'�ØÐMÑMá"Ø$/™	à$(×$5Ñ$5×$<Ñ$<¸VÓ$D˜	Ù Ø =Ò0Ø ×5Ñ5°iÀÕHà ×5Ñ5°iÀÈÔNà˜;Ò&¨4¯:©:×+BÑ+BÓ+DÐ+PØ%ÒI¨×):Ñ):×)AÑ)AÀ&Ó)I�CØ×/Ñ/°°VÔ<ØÐ+Ò+°Ð0DØ×+Ñ+×2Ñ2°6Ó:�CØ×)Ñ)¨(°C¸Ô@Ø˜?Ò*Ø#'§:¡:×#:Ñ#:Ó#<�LÙ#Ô(:×(QÑ(QÐR^Ô(_ØŸ	™	Ô"2×"YÑ"YÐ[aÔbä˜&¤*Ô-°&·+±+ÐAQÒ2QØ—	‘	Ô*×CÑCÀVÔLâÜ˜k¬;Õ7¸K×<LÑ<LÑ<Tà"&×"3Ñ"3×":Ñ":¸6Ó"B�KÜ!¤/°+Ó">ÄÔIð à%Ÿ/™/�CÜ-Ø# T§\¡\À3Ç<Á<õð )-×(?Ñ(?ÀÓ(D˜Ø(Ñ4Ø#'×#=Ò#=ä.OÐP[Ó.\ Ü0EÀ{ÔT\ÓT^ÐF_Ó0` Ø $× 6Ñ 6°s¸FÀMÕ Rà+/ ¤Ø -¨cÐ 2Ø*-¯(©(šKð  $×6Ñ6°s¸FÀKÕPð
 (,×'IÑ'IÈ+Ó'V˜HØ ŸK™KŸO™O¨F°HÔ=ð
 !×2Ñ2°3¸Ô@RÐS[Ó@\Ö]ä˜v¤zÔ2°v·{±{Ð7Jà$(×$5Ñ$5×$<Ñ$<¸V¿[¹[Ó$I�MØBF×B^ÑB^Ø ¨{¸FÈFð C_ó CÑ?�K Ò.?ð !ŸL™L×;Ó;Ü+¨FÕ3Ü& v¬xÔ8Ø"ŸK™K¬4Ò/Ü& v§{¡{´CÔ8Ø"ŸK™K×,Ò,Ø"ŸK™K¨4×+?Ñ+?Ñ?Ü *¬?¸;Ó+GÌÔ Qà)-×)=Ñ)=¸f¿k¹kÑ)J˜ð +0˜Ü%-¨d¯k©k×.@Ñ.@Ó%Aò &˜EØ$Ÿx™x¨>Ò9Ø27×2IÑ2I Ù %ð&ñ +Ü*<¸[Ó*I˜KØ ×2Ñ2°6·;±;ÀÈÔTà/3×/KÑ/KØ# V°VÀhÐW]ð 0Ló 0Ñ,�K ð
  $�Hô !0°Ó <�Ü /°Ó <�ä˜}¬lÔ;Ø%×1Ñ1Ô3à%×1Ñ1Ó3×?Ò?Ø(×4Ñ4Ó6×BÒBä" =´(Ô;Ü" =×#5Ñ#5´xÔ@à%×*Ñ*×/Ñ/×;Ò;¸}×?QÑ?Q×?VÑ?V×?bÒ?bð —H‘H×1Ñ1°-ÀÔHØÙÑ#4¼ZÈÔU`Ô=aä& v¬xÔ8¸V×=SÓ=SØŸ™×/Ñ/°¸À[ÔQä& v¬xÔ8Ü *¨6¯;©;¼Ô <Ø &§¡× 7Ò 7Ø &§¡× 8Ò 8Ø +Ð 7ä/PÐQ\Ó/]˜FŸK™KÕ,à—L‘L×3Ò3Ø#Ð/Ü& {´KÔ@ô # 6¬8Ô4Ü" 6§;¡;´Ô4ØŸ™×/Ò/ð —K‘K×+Ñ+¨F°KÀÕMáØ×-Ñ-¨l¸FÀFÔKáØ#×=Ñ=¸hÈÓO�Ø"×/Ñ/×6Ñ6°vÈLÐ6ÓY�à×%Ò%Ø×,Ò,Ü" 6¬8Ô4¸¿¹ÐHXÒ9Xä"CÀKÓ"P�KØ×(Ñ(¨°6¸;ÈÔOØ×*Ñ*¨6Ô2ä˜6¤7Ô+Ü# F¬HÔ5¸&¿+¹+ÐIYÒ:YØ×1Ò1ð
 ×3Ñ3°F¸FÕCð 2ð ;Zð ,r  )úbuiltins.listú+)úbuiltins.setú|r   Úpartial_type_augmented_opsc           
     ó|  — g }|j                   rç|j                   j                  dd  D ]Ë  }|j                  |j                  vrŒ|j                  |j                     j                  }| j                  |j                  ||t        |«      xs t        |t        «      xr t        |«       ¬«      \  }}|sŒ�t        |t        «      r|j                  rŒªt        |t        «      rŒ»|j                  |«       ŒÍ |s›|j                  dk(  r>| j                  j                  «       �$| j                  d«      }| j!                  d|g«      S |j                  dk(  r>| j                  j#                  «       r$| j                  d«      }| j!                  d|g«      S y |d   }	|D ]  }
t%        |
|	«      r|
}	Œt'        |	|
«      rŒ y  |	S )	Nrˆ  r  rÅ  r›  r–  r™  rš  r   )r4  r¶  rÊ  ri  r  rÃ  Ú	is_methodrÌ  r™   r&   Úinvalid_partial_typerå   r8  rN  rh  r¯  r®  Úis_top_levelr¶   r¸   )r+  rÈ  rŸ  Útype_contextsr¹  Ú	base_noder‹  r  r˜  r[  Úothers              r   rÛ  z%TypeChecker.get_variable_type_context6  s�  € ØˆØ�=Š=Ø Ÿ™×)Ñ)¨!¨"Ð-ò 4�Ø—=‘=¨¯
©
Ñ2Øð !ŸJ™J x§}¡}Ñ5×:Ñ:�	Ø#×7Ñ7Ø—M‘MØØÜ& yÓ1ò 7Ü! )¬SÓ1ò 7Ü+¨IÓ6Ð6ð  8ó  ‘�	˜1ò Ü'¨	´3Ô7¸I×<ZÓ<ZÜ& y´+Õ>à!×(Ñ(¨Õ3ð'4ñ* Ø�}‰} Ò+°·
±
×0GÑ0GÓ0IÐ0UØŸ?™?¨>Ó:�Ø×.Ñ.Ð/@À8À*ÓMÐMØ�}‰} 	Ò)¨d¯j©j×.EÑ.EÔ.GØŸ?™?¨>Ó:�Ø×.Ñ.Ð/@À8À*ÓMÐMØØ! !Ñ$ˆ	Ø"ò 	ˆEÜ  ¨	Ô2Ø!‘	Ü 	¨5Õ1áð	ð Ðr  c                ó.  — d}t        |t        «      rKt        |j                  t        «      r1t        |j                  j                  t
        «      r|j                  }n+t        |t        «      r| j                  j                  |«      }|��
|j                  }t        |t
        «      sJ ‚|j                  €y|dk7  r%|j                  j                  |f| j                  vry| j                  |«      }|€y| j                  j                  |«      }t        |«      }t        |t        «      r<|j                  |j                  k(  r"t        || j                   «      r||_        ||= yyyt        |t"        «      rt%        |j                  «      |_        ||= yyy)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Î  rZ  rÛ   r  )r+  rþ  rŸ  Úopr&  rH  rR  râ  s           r   rË  z:TypeChecker.try_infer_partial_generic_type_from_assignment_  s^  € ð ˆä�vœxÔ(Ü˜6Ÿ;™;¬Ô,Ü˜6Ÿ;™;×+Ñ+¬[Ô9à—+‘+‰CÜ˜¤
Ô+Ø×#Ñ#×8Ñ8¸Ó@ˆCØ‰?Ø—(‘(ˆCÜ˜c¤;Ô/Ð/Ð/Ø�x‰xÐØà�SŠy˜cŸh™h×/Ñ/°Ð4¸D×<[Ñ<[Ñ[Øð !×3Ñ3°CÓ8ˆMØÐ$ØØ×+Ñ+×2Ñ2°6Ó:ˆKÜ)¨+Ó6ˆKÜ˜+¤xÔ0Ø×#Ñ# s§x¡xÒ/Ô4JØ §¡ô5ð  +�C”HØ% cÑ*ð	5Ð/ô
 ˜K¬Ô1Ü1°#·(±(Ó;�”Ø! #Ñ&ð 2ð+ r  c           	     ó  — |j                   }t        |t        «      �rì|j                  |j                  k(  s|j                  �rÅ|j
                  �s·|j                  t        d fv �r¡t        |j                  j                  «      dkD  �r}|j                  j                  dd  D ]h  }|j                  j                  |j                  «      }|€Œ+| j                  |||j                   «      s n!| j!                  |||j                   «      rŒh n |j                  j#                  «       }|r|d   nd }d }|j                  rc|j
                  sWt        |j$                  t&        «      s|j$                  nd }	| j(                  j+                  ||	«      }
|j$                  }|
|_        | j-                  |j                  |j                  |«      \  }}|j                  r|j
                  s||_        |sy |j                  j                  dd  D ]ü  }|j.                  r|j                  dk(  r|j0                  dk(  sŒ.t3        |j                  «      rŒD| j-                  |j                  ||«      \  }}t5        |«      }t        |t&        «      rd }|sŒ„|€J ‚| j7                  ||||||¬«      s y |rT|rR| j-                  |j                  ||d¬«      \  }}|€J ‚t9        ||«      s | j:                  j=                  ||||«        y ||u sŒü y  y y y y y y )	Nr   rˆ  rŒ  rÅ  r-  )rÞ  TrÂ  )r  rÌ  r™   rŽ  rØ  Úexplicit_self_typerÒ  rW   rý  r4  r  r¶  ri  r¬  rÊ  Ú"check_compatibility_classvar_superÚcheck_compatibility_final_superÚdirect_base_classesr­  rå   rƒ  r«  rÃ  ru  r   rÐ  rÐ  Úcheck_compatibility_superr¸   rH  rÄ  )r+  rþ  rŸ  Úlvalue_noder¹  ÚtnodeÚdirect_basesÚlast_immediate_baseÚactual_lvalue_typerR  râ  r¢  r  r‹  ró  Úcustom_setters                   r   rÞ  z*TypeChecker.check_compatibility_all_supers�  s  € Ø—k‘kˆô �{¤CÕ(ð
 × Ñ  F§K¡KÒ/Ø×*Ó*Ø#×6Ó6à—‘¤ d˜|Ò+Ü�K×$Ñ$×*Ñ*Ó+¨aÓ/à#×(Ñ(×,Ñ,¨Q¨RÐ0ò 	�ØŸ
™
Ÿ™ {×'7Ñ'7Ó8�ØÑ$Ø×BÑBÀ;ÐPTÐV[×V`ÑV`Ôaáà×?Ñ?ÀÈTÐSX×S]ÑS]Õ^áð	ð '×+Ñ+×?Ñ?ÓAˆLÙ6B ,¨rÒ"2ÈÐð
 "&ÐØ×&Ò&¨{×/MÒ/Mä.8¸×9IÑ9IÌ;Ô.W�k×&Ò&Ð]a�Ø"×/Ñ/×6Ñ6°v¸sÓC�Ø%0×%5Ñ%5Ð"Ø#.�Ô Ø!×5Ñ5°k×6FÑ6FÈ×HXÑHXÐZ`Óa‰NˆK˜Ø×&Ò&¨{×/MÒ/MØ#5�Ô áØà#×(Ñ(×,Ñ,¨Q¨RÐ0ò .�ð ×:Ò:Ø×$Ñ$¨Ò3¸¿¹ÐIZÒ8Zàä˜k×.Ñ.Ô/Øà'+×'?Ñ'?À×@PÑ@PÐRVÐX^Ó'_Ñ$�	˜9ä ;¸IÓ F�Ü˜i¬Ô5Ø $�IâØ$Ð0Ð0Ð0Ø×9Ñ9Ø#ØØØ!Ø!Ø/<ð :ô ñ Ù"¡}Ø'+×'?Ñ'?Ø'×,Ñ,¨d°FÈð (@ó (™˜	 1ð
  )Ð4Ð4Ð4Ü)¨)°[ÔAØ ŸH™H×AÑAØ &¨°YÀôñ #ØÐ2Ò2ñ ñ].ðC 0ð ,ð 7ð +ð )r  c           
     óD  — | j                  |||t        j                  dd|j                  › d�«      }|rkt        j
                  | j                  j                  v rE| j                  |«      r4|s2| j                  |||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Ô  rZ  rÕ  rÖ  r×  )r+  Úcompare_typerŸ  r¹  r‹  ró  rÞ  rà  s           r   rý  z%TypeChecker.check_compatibility_superî  s¥   € ð ×ÑØØØÜ×=Ñ=Ø!Ø˜4Ÿ9™9˜+Ð%:Ð;ó
ˆñ Ü×&Ñ&¨$¯,©,×*JÑ*JÑJØ×*Ñ*¨9Ô5Ù*à×#Ñ#ØØØÜ ×HÑHØ˜tŸy™y˜kÐ)>Ð?Ø%óˆBð ˆ	r  )r,  r  rx  c          	     ó  — |j                   j                  |«      }|r\t        |j                  t        t
        f«      r|j                  r0t        |j                  t        «      r|j                  j                  �y|€| j                  j                  «       }nt        |«      }|€J d«       ‚t        |t        «      rt        |«      }	n|}	t        |dt        j                  j!                  |«      ||| d¬«      }
| j"                  j%                  d¬«      5  |r:|	j                  j&                  xs |
j)                  d«      }t+        |	||
||¬	«      }nt-        ||	|
|«      }ddd«       |j                  fS # 1 sw Y   ŒxY w)
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)rI  rJ  rK  rL  rï  r5  Úsuppress_errors©Úfilter_deprecatedr8  )Úmcs_fallbackÚoverride_info)ri  r¬  rÌ  r  r™   rf   r­  rå   rN  Úcurrent_self_typer  rç   rÕ   r"   r|  r}  Úis_operator_methodrH  r°  rá  r¯  r#   r$   )r+  rÊ  r¹  rï  r,  r  rx  ró  ra  r�  Úmxr#  r‹  s                r   rÃ  zTypeChecker.node_type_from_base  sY  € ð$ —J‘J—N‘N 4Ó(ˆ	ñ Ü˜)Ÿ.™.¬3´	Ð*:Ô;Ø—N’NÜ˜)Ÿ.™.¬+Ô6Ø—‘×#Ñ#Ð/ààÐ ØŸ
™
×4Ñ4Ó6‰Iä% mÓ4ˆIØÐ$ÐQÐ&QÓQÐ$Ü�i¤Ô+Ü% iÓ0‰Hà ˆHäØ!ØÜŸ™×9Ñ9¸$Ó?Ø#ØØØ ô
ˆð �X‰X×#Ñ#°dÐ#Ó;ñ 	UÙØ#Ÿ=™=×7Ñ7ÒY¸2¿=¹=ÈÓ;Y�Ü:Ø˜d B°XÈTô‘	ô ;¸4ÀÈ2ÈtÓT�	÷	Uð ˜)Ÿ.™.Ð(Ð(÷	Uð 	Uús   ÄAE6Å6E?c                ón  — t        |t        «      sy|j                  rF|j                  s:| j                  t        j
                  j                  |j                  «      |«       y|j                  sF|j                  r:| j                  t        j                  j                  |j                  «      |«       yy©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_superM  s†   € ô ˜)¤SÔ)ØØ×Ò I×$9Ò$9Ø�I‰IÔ&×CÑC×JÑJÈ4Ï9É9ÓUÐW[Ô\ØØ×!Ò! i×&;Ò&;Ø�I‰IÔ&×@Ñ@×GÑGÈÏ	É	ÓRÐTXÔYØØr  c                ó¸  — t        |t        t        t        f«      syt	        |j
                  «      ry|j                  rN|j                  st        |t        «      s2| j                  j                  |j
                  |j
                  |«       y|j                  rB|j                  t        v s|j
                  t        v ry| j                  |j
                  ||«       y)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¼  rH  r»  r   r¬   r­   r½  r  s       r   rû  z+TypeChecker.check_compatibility_final_superZ  s�   € ô ˜)¤c¬8´YÐ%?Ô@ØÜ�d—i‘iÔ ØØ×Ò 4§=¢=¼
À9ÌcÔ8Rð
 �H‰H×(Ñ(¨¯©°D·I±I¸tÔDØØ�=Š=Ø�}‰}¤
Ñ*¨d¯i©iÔ;MÑ.MØØ×5Ñ5°d·i±iÀÈDÔQØr  c                ól   — d}|r| j                  |«      }|r| j                  j                  ||«       yy)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Ö  rH  Úfinal_cant_override_writable)r+  rÊ  ró  rR  Úwritables        r   r½  z0TypeChecker.check_if_final_var_override_writablew  s8   € ð ˆÙØ×1Ñ1°)Ó<ˆHÙØ�H‰H×1Ñ1°$¸Õ<ð r  c                ó   — | j                   S )z:Check whether we a currently checking a final declaration.©rx  r‚  s    r   Úget_final_contextzTypeChecker.get_final_context‹  r„  r  c              #  ób   K  — | j                   }|| _         	 d–— || _         y# || _         w xY w­w)zDStore whether the current checked assignment is a final declaration.Nr  )r+  r´  Úold_ctxs      r   r³  zTypeChecker.enter_final_context�  s3   è ø€ ð ×$Ñ$ˆØ)ˆÔð	)Ûà!(ˆDÕø ˆDÕüs   ‚/—# ›/£	,¬/c                ó@  — t        |t        «      r| j                  |j                  «      }n+t        |t        «      r|j
                  g}n|j                  g}t        |t        «      r|j                  nd}|rÖ| j                  j                  «       x}rº|d   }t        |t        «      sJ ‚|j                  �—t        |j                  t        «      sJ ‚|j                  j                  re|j                  j                  sO| j                  sCt        |t        «      r3|j                   �'|j"                  s| j$                  j'                  |«       |D �]K  }t        |t        «      sŒt        |j                  t        «      sŒ0|j                  j(                  }| j                  j                  «       }|�›|j*                  dd D ]‰  }|j,                  j/                  |«      }	|	sŒ!t        |	j                  t        «      sŒ<|	j                  j0                  sŒS|rŒV| j$                  j3                  ||	j                  j4                  du |«        n |j                  j0                  s�Œ|r�Œ| j$                  j3                  ||j                  j4                  du |«       �ŒN y)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´  rN  rh  r‰   r  r™   Úfinal_unset_in_classÚfinal_set_in_initrn  r­  r~  rH  Úfinal_without_valuerÊ  r¶  ri  r¬  r¼  Úcant_assign_to_finalr4  )
r+  r¦  ÚlvsÚis_final_declrh  r½  rÊ  r  r¹  r  s
             r   r¹  zTypeChecker.check_final™  sñ  € ô �aœÔ(Ø×&Ñ& q§y¡yÓ1‰CÜ˜œ>Ô*Ø—8‘8�*‰Cà—8‘8�*ˆCÜ*4°Q¼Ô*G˜ŸšÈUˆÙ¨d¯j©j×.EÑ.EÓ.GÐG˜lÐGØ�Q‘ˆBÜ˜b¤'Ô*Ð*Ð*Ø�w‰wÐ"Ü! "§'¡'¬3Ô/Ð/Ð/à—G‘G×0Ò0ØŸG™G×5Ò5Ø ŸLšLô ˜q¤.Ô1ØŸ™Ð*ð )×7Ò7à—H‘H×0Ñ0°Ô3Øó 	QˆBÜ˜"œgÕ&¬:°b·g±g¼sÕ+CØ—w‘w—|‘|�Ø—j‘j×-Ñ-Ó/�Ø�?ð !$§¡¨¨ ò 	&˜Ø"Ÿj™jŸn™n¨TÓ2˜ò ¤:¨c¯h©h¼Õ#<Ø"Ÿx™x×0Ó0ºØ $§¡× =Ñ =¸dÀCÇHÁHÇMÁMÐUYÐDYÐ[\Ô ]á %ð	&ð —7‘7×#Ô#«MØ—H‘H×1Ñ1°$¸¿¹¿¹ÈÐ8LÈaÖPñ'	Qr  c                ó2  — t        |t        «      sy t        | j                  j	                  |j
                  «      «      }t        |t        «      r/|j                  j                  «       rt        |j                  «      }t        |t        «      sy |j                  j                  €y |j                  |j                  j                  v ry |j                  j                  d d D ]  }|j                  j!                  d«      €Œ y  |j                  j!                  |j                  «      }|€y | j#                  ||j                  «      ry | j%                  t&        j(                  j+                  |j                  |j                  j,                  «      |«       y )NrŒ  r  )rÌ  r}   rú   rƒ  r«  r  rò   r£  Úis_selfrM  rá   r­  ÚslotsrÊ  r¶  ri  r¬  Úis_assignable_slotr°  r   ÚNAME_NOT_IN_SLOTSr²  r   )r+  rþ  ÚinstÚ	base_infor-  s        r   rÝ  z%TypeChecker.check_assignment_to_slotsÏ  s/  € Ü˜&¤*Ô-Øä˜t×0Ñ0×7Ñ7¸¿¹ÓDÓEˆÜ�dœKÔ(¨T¯W©W¯_©_Ô->ä" 4×#3Ñ#3Ó4ˆDÜ˜$¤Ô)ØØ�9‰9�?‰?Ð"ØØ�;‰;˜$Ÿ)™)Ÿ/™/Ñ)ØØŸ™Ÿ™ s¨Ð+ò 	ˆIØ�‰×"Ñ" =Ó1Ñ=ñ ð	ð —Y‘Y—]‘] 6§;¡;Ó/ˆ
ØÐð Ø×"Ñ" 6¨:¯?©?Ô;Øà�	‰	Ü×.Ñ.×5Ñ5°f·k±kÀ4Ç9Á9×CUÑCUÓVÐX^õ	
r  c                ó:  ‡ ‡— t        ‰dd «      ryt        |«      }|�t        |t        «      ryt        |t        «      r|j
                  j                  d«      d uS t        |t        «      ryt        |t        «      rt        ˆˆ fd„|j                  D «       «      S y)Nr  FTÚ__set__c              3  óB   •K  — | ]  }‰j                  ‰|«      –— Œ y ­wr'  )r,  )rÞ  Úurþ  r+  s     €€r   rß  z1TypeChecker.is_assignable_slot.<locals>.<genexpr>  s   øè ø€ ÒM¸a�t×.Ñ.¨v°q×9ÑMùó   ƒ)Úgetattrrú   rÌ  rÛ   rá   r­  r¬  rà   rõ   rk  rÐ  )r+  rþ  rH  s   `` r   r,  zTypeChecker.is_assignable_slotñ  s€   ù€ Ü�6˜6 4Ô(Øä˜cÓ"ˆØˆ;œ* S¬'Ô2ØÜ�cœ8Ô$ð
 —8‘8—<‘< 	Ó*°$Ð6Ð6Ü�cœ<Ô(ØÜ�cœ9Ô%ÜÔMÀ3Ç9Á9ÔMÓMÐMØr  c           	     ó|  — g }|D �]3  }t        |t        «      s|j                  |«       Œ&t        | j                  j                  |j                  «      «      }t        |t        «      s|j                  |«       Œv|j                  D ]¯  }t        |t        «      s|j                  t        |«      «       Œ.t        |j                  «      }t        |t        «      r|j                  }n-t        |t        «      r|j                  j                  dk(  sJ ‚|}|j                  t        t        |«      «      «       Œ± �Œ6 |S )zÞFlatten 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ñ   rM  rá   r   )r+  ÚrvaluesÚnew_rvaluesÚrvrH  rM  Úunpackedr#  s           r   Úflatten_rvalueszTypeChecker.flatten_rvalues  s  € ð ˆØó 	EˆBÜ˜b¤(Ô+Ø×"Ñ" 2Ô&ØÜ! $×"3Ñ"3×":Ñ":¸2¿7¹7Ó"CÓDˆCÜ˜c¤9Ô-Ø×"Ñ" 2Ô&ØØ—Y‘Yò E�Ü! !¤ZÔ0Ø×&Ñ&¤x°£{Õ3ä.¨q¯v©vÓ6�HÜ! (Ô,<Ô=Ø#+×#7Ñ#7™ô ' x´Ô:Ø (§¡× 6Ñ 6Ð:JÒ JððKð $,˜Ø×&Ñ&¤x´¸Ó0BÓ'CÕDòEð	Eð, Ðr  c                ó  — t        |t        t        f«      �rYg }d }d }t        | j	                  |j
                  «      «      D �]1  \  }}	t        |	t        «      �r	t        | j                  j                  |	j                  «      «      }
| j                  |
«      r™t        |
t        «      r‰|�6|| j                  |
|«      k7  r!| j                  t        j                   |«       ŒŸ|�|dz   |k(  r&|j#                  |	«       |}| j                  |
|«      }ŒÏ| j                  t        j                   |«       Œð| j                  t        j$                  j'                  |
«      |«       �Œ!|j#                  |	«       �Œ4 d }d }t        |«      D ]m  \  }}	t        |	t        «      sŒt        | j                  j                  |	j                  «      «      }
| j                  |
«      sŒWt        |
t        «      sŒh|€|}|}Œo |�^|�\|�Z||z
  dz   }t)        |«      t)        |«      |z
  z
  }|dkD  r3|d| t+        |«      D �cg c]  }t-        |	¬«      ‘Œ c}z   ||dz   d  z   }| j/                  |t)        |«      |«      rþt1        d„ t        |«      D «       t)        |«      «      }|d | }|t)        |«      k7  rt3        t        ||   «      nd }||dz   d  }| j5                  ||t)        |«      «      \  }}}t7        t9        ||«      «      }|r9t        |«      }|j;                  |«       |j#                  |j                  |f«       |j=                  t9        ||«      «       |D ]  \  }}| j?                  |||«       Œ y y | jA                  ||||«       y c c}w )Nrˆ  r   r  c              3  óH   K  — | ]  \  }}t        |t        «      sŒ|–— Œ y ­wr'  ©rÌ  r�   ©rÞ  r×  r½  s      r   rß  zCTypeChecker.check_assignment_to_multiple_lvalues.<locals>.<genexpr>^  s   è ø€ ÒS™5˜1˜b¼*ÀRÌÕ:R”QÑSùó   ‚"›")!rÌ  r•   rz   rÏ  r<  rÐ  r�   rú   rƒ  r«  r  Útype_is_iterablerá   Úiterable_item_typer°  r   ÚCONTIGUOUS_ITERABLE_EXPECTEDr8  ÚITERABLE_TYPE_EXPECTEDr²  rý  r�  r“   Ú check_rvalue_count_in_assignmentrj  r   Úsplit_around_starr¢  rò  Úset_lineÚextendrµ  Úcheck_multi_assignment)r+  r�  rŸ  rï  rß  r8  Úiterable_typeÚlast_idxÚidx_rvalÚrvalÚtypsÚiterable_startÚiterable_endr×  Úiterable_numÚrvalue_neededr  Ú
star_indexÚleft_lvsÚstar_lvÚ	right_lvsÚleft_rvsÚstar_rvsÚ	right_rvsÚlr_pairsÚrv_listr½  r:  s                               r   rÊ  z0TypeChecker.check_assignment_to_multiple_lvalues#  st  € ô �fœy¬(Ð3Õ4ð
 )+ˆGØ)-ˆMØ#'ˆHÜ"+¨D×,@Ñ,@ÀÇÁÓ,NÓ"Oó )‘�˜$Ü˜d¤HÕ-Ü*¨4×+<Ñ+<×+CÑ+CÀDÇIÁIÓ+NÓO�DØ×,Ñ,¨TÔ2´zÀ$ÌÔ7QØ(Ð4¸È$×JaÑJaØ  &óKò :ð !ŸI™IÔ&6×&SÑ&SÐU\Õ]à'Ð/°8¸a±<À8Ò3KØ '§¡¨tÔ 4Ø+3 Ø04×0GÑ0GÈÈfÓ0U¡à $§	¡	Ô*:×*WÑ*WÐY`Õ aàŸ	™	Ô"2×"IÑ"I×"PÑ"PÐQUÓ"VÐX_Ö`à—N‘N 4Ö(ð%)ð& *.ˆNØ'+ˆLÜ$ WÓ-ò )‘��4Ü˜d¤HÕ-Ü*¨4×+<Ñ+<×+CÑ+CÀDÇIÁIÓ+NÓO�DØ×,Ñ,¨TÕ2´zÀ$ÌÕ7QØ)Ð1Ø-.˜NØ'(™ð)ð Ð*Ø Ð,Ø!Ð-à+¨nÑ<¸qÑ@�Ü # G£´°G³¸|Ñ0KÑ L�Ø  1Ò$à  .Ð1ÜJOÐP]ÓJ^Ö_ÀQœ8 M¸4Ö@Ò_ñ`à! ,°Ñ"2Ð"4Ð5ñ6ð ð ×4Ñ4°W¼cÀ'»lÈGÔTÜ!ÙS¤I¨gÓ$6ÔSÔUXÐY`ÓUaó�
ð # ; JÐ/�à;EÌÈWËÒ;U”Dœ 7¨:Ñ#6Ô7Ð[_ð ð $ J°¡NÐ$4Ð5�	à04×0FÑ0FØ˜Z¬¨W«ó1Ñ-�˜( Iô  ¤ H¨hÓ 7Ó8�ÙÜ& xÓ0�GØ×$Ñ$ VÔ,Ø—O‘O W§\¡\°7Ð$;Ô<Ø—‘¤ I¨yÓ 9Ô:à&ò E‘F�B˜Ø×)Ñ)¨"¨bÐ2CÕDñEð- Uð2 ×'Ñ'¨°¸ÐBSÕTùò; `s   È4Nc                ó|  — |�·t        d„ |D «       «      s| j                  d|«       yt        |«      |kD  r!| j                  t        j                  |«       yt        d„ t        |«      D «       «      }|}t        |«      |z
  dz
  }|}||z
  dz
  }	||	kD  s||kD  r | j                  t        j                  |«       yt        d„ |D «       «      r<t        |«      dz
  |kD  r*| j                  j                  |t        |«      dz
  |«       yy|t        |«      k7  r'| j                  j                  |t        |«      |«       yy)Nc              3  ó<   K  — | ]  }t        |t        «      –— Œ y ­wr'  r?  )rÞ  Úes     r   rß  z?TypeChecker.check_rvalue_count_in_assignment.<locals>.<genexpr>  s   è ø€ Ò@°1”z !¤X×.Ñ@ùó   ‚z/Variadic tuple unpacking requires a star targetFc              3  óH   K  — | ]  \  }}t        |t        «      sŒ|–— Œ y ­wr'  r?  r@  s      r   rß  z?TypeChecker.check_rvalue_count_in_assignment.<locals>.<genexpr>…  s   è ø€ Ò"a©¨¨BÌ
ÐSUÔW_ÕH`¤1Ñ"aùrA  rˆ  Tc              3  ó<   K  — | ]  }t        |t        «      –— Œ y ­wr'  r?  )rÞ  rþ  s     r   rß  z?TypeChecker.check_rvalue_count_in_assignment.<locals>.<genexpr>’  s   è ø€ ÒB°Œz˜&¤(×+ÑBùr`  )	rã  r°  rý  r   Ú$TOO_MANY_TARGETS_FOR_VARIADIC_UNPACKrj  rÏ  rH  Úwrong_number_values_to_unpack)
r+  r�  Úrvalue_countrï  Úrvalue_unpackÚleft_star_indexÚleft_prefixÚleft_suffixÚright_prefixÚright_suffixs
             r   rF  z,TypeChecker.check_rvalue_count_in_assignmentw  s0  € ð Ð$ÜÑ@¸Ô@Ô@Ø—	‘	ÐKÈWÔUØÜ�7‹|˜lÒ*Ø—	‘	Ô*×OÑOÐQXÔYØÜ"Ñ"a´)¸GÓ2DÔ"aÓaˆOØ)ˆKÜ˜g›,¨Ñ8¸1Ñ<ˆKØ(ˆLØ'¨-Ñ7¸!Ñ;ˆLØ˜\Ò)¨[¸<Ò-Gð —	‘	Ô*×OÑOÐQXÔYØÜÑB¸'ÔBÔBÜ�7‹|˜aÑ ,Ò.Ø—‘×6Ñ6°|ÄSÈÃ\ÐTUÑEUÐW^Ô_Øð ð œS ›\Ò)Ø�H‰H×2Ñ2°<ÄÀWÃÈwÔWØØr  c                ó¨  — t        |xs | j                  j                  |«      «      }t        |t        «      rt        |j
                  «      }t        |t        «      r,|j                  «       }t        |«      dk(  rt        |d   «      }t        |t        «      r!t        |j                  «      �t        |i «      }t        |t        «      rb|D ]\  }	t        |	t        «      r|	j                  }	| j!                  t        t"        j$                  |¬«      |«      }
| j'                  |	|
|«       Œ^ yt        |t        «      r| j)                  ||||||«       yt        |t        «      r| j+                  |||||«       y|}t        |t,        «      rM|j.                  j0                  dk(  r4|j2                  €| j4                  j7                  |«       n|j2                  }t        |t8        «      rVt        |j:                  t<        «      r<t        |«      t        |j:                  «      k7  r| j4                  j7                  |«       | j?                  ||||«       y)z:Check the assignment of one rvalue to a number of lvalues.rˆ  r   Nrˆ  r›  ) rú   rƒ  r«  rÌ  rð   rM  rõ   rl  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_valuerH  Úunpacking_strings_disallowedrâ   ræ  rm  Ú$check_multi_assignment_from_iterable)r+  r�  rŸ  rï  rß  Úrv_typeÚundefined_rvaluerâ  rl  r½  r%  Úrvalue_literals               r   rJ  z"TypeChecker.check_multi_assignment›  sù  € ô & gÒ&Q°×1BÑ1B×1IÑ1IÈ&Ó1QÓRˆä�k¤?Ô3Ü)¨+×*AÑ*AÓBˆKä�k¤9Ô-à(×7Ñ7Ó9ˆNÜ�>Ó" aÒ'Ü-¨n¸QÑ.?Ó@�ô �{¤IÔ.Ü# K×$5Ñ$5Ó6ÐBô & k°2Ó6ˆKä�k¤7Ô+Øò H�Ü˜b¤(Ô+ØŸ™�BØ ŸN™NÜœI×6Ñ6À;ÔOÐQXó�	ð ×%Ñ% b¨)Ð5FÕGñHô ˜¤YÔ/Ø×2Ñ2Ø˜ ¨gÐ7GÐIZõô ˜¤YÔ/Ø×2Ñ2Ø˜ ¨gÐ7Hõð )ˆNÜ˜+¤xÔ0°[×5EÑ5E×5NÑ5NÐR`Ò5`Ø×/Ñ/Ð7Ø—H‘H×9Ñ9¸'ÕBà%0×%AÑ%A�Nä˜>¬;Ô7Ü˜~×3Ñ3´SÔ9Ü˜“L¤C¨×(<Ñ(<Ó$=Ò=à—‘×5Ñ5°gÔ>à×5Ñ5Ø˜ gÐ/@õr  c                ó  — d| _         t        d„ | j                  |«      D «       «      }| j                  j	                  «       5 }|j
                  D ]�  }| j                  |||||d¬«       t        || j                  |«      «      D ]J  \  }	}
|	j                  | j                  d   j                  |
t        t        j                  «      «      «       ŒL Œƒ 	 ddd«       t        d„ |D «       «      }j                  «       D ]�  \  }}t        |t        «      r|j                   }g }|D ]  \  }}|€J ‚|j                  ||f«       Œ t        |Ž \  }}| j                  j#                  |t%        t'        |«      «      t%        t'        |«      «      «       Œ’ t        || j                  |«      «      D ]B  \  }}
| j)                  |
«      \  }}}|r| j+                  ||
|«       Œ1| j-                  |
|«       ŒD d| _         y# 1 sw Y   �Œ'xY w)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 –— Œ y ­wr'  r  )rÞ  r  s     r   rß  z@TypeChecker.check_multi_assignment_from_union.<locals>.<genexpr>ñ  s   è ø€ Ò2]¸!´2Ñ2]ùs   ‚)rß  rr  rs  rŒ  Nc              3  ó2   K  — | ]  }t        |«      –— Œ y ­wr'  )rÏ   )rÞ  Úcols     r   rß  z@TypeChecker.check_multi_assignment_from_union.<locals>.<genexpr>  s   è ø€ ÒM¸3Ô1°#×6ÑMùrO  F)r\  Útupler!  rI  Úaccumulate_type_assignmentsrÐ  rJ  rò  r8  r7  r=  rÛ   rì   r*  rÌ  r�   r  r°  rÏ   r¢  rž  rÏ  rÁ  )r+  r�  rŸ  râ  rï  rß  Ú
transposedrœ  rØ  rM  r½  Úunion_typesr  rÐ  Úclean_itemsr­  Údeclared_typerÓ  Údeclared_typesÚunionÚ_1Ú_2rÈ  s                          r   rn  z-TypeChecker.check_multi_assignment_from_unionÜ  s  € ð( !%ˆÔÜ-2Ñ2]¸t×?SÑ?SÐT[Ó?\Ô2]Ó-]ˆ
à�[‰[×4Ñ4Ó6ð 	[¸+Ø#×)Ñ)ò [�ð ×+Ñ+ØØØØ&7Ø Ø%)ð ,ô ô ! ¨T×-AÑ-AÀ'Ó-JÓKò [‘E�A�rð —H‘H˜TŸ_™_¨RÑ0×4Ñ4°R¼Ä×AWÑAWÓ9XÓYÕZñ[ñ[÷	[ô  ÑMÀ*ÔMÓMˆØ&×,Ñ,Ó.ò 	‰KˆD�%ä˜$¤Ô)Ø—y‘y�ð 46ˆKØ',ò :Ñ#��mØ$Ð0Ð0Ð0Ø×"Ñ" D¨-Ð#8Õ9ð:ô %(¨Ð$5Ñ!ˆE�>Ø�K‰K×#Ñ#ØÜ%¤d¨5£kÓ2Ü%¤d¨>Ó&:Ó;õð	ô$ ˜[¨$×*>Ñ*>¸wÓ*GÓHò 	+‰IˆE�2à#×0Ñ0°Ó4ÑˆB��HÙØ×&Ñ& x°°UÕ;à—‘  EÕ*ð	+ð !&ˆÕ÷U	[ñ 	[ús   ÁBG:Ç:Hc                óò   — g }|D ]o  }t        |t        t        f«      r*|j                  | j	                  |j
                  «      «       t        |t        «      r|j                  }|j                  |«       Œq |S r'  )	rÌ  r•   rz   rI  r!  rÐ  r�   r  r8  )r+  r�  Úresr½  s       r   r!  zTypeChecker.flatten_lvalues  se   € Ø "ˆØò 	ˆBÜ˜"œy¬(Ð3Ô4Ø—
‘
˜4×/Ñ/°·±Ó9Ô:Ü˜"œhÔ'à—W‘W�Ø�J‰J�r�Nð	ð ˆ
r  c                óø  — t        |«      }|€|S |\  }}t        t        |«      t        «      s|S t	        d„ t        |«      D «       d«      }|€dt        |«      t        |j                  «      z
  dz   }|dk  r|S |j                  |j                  d| |g|z  z   |j                  |dz   d z   ¬«      S t        t        |j                  «      |t        |«      |z
  dz
  «      }|j                  t        |«      ¬«      S )z Adjust type of rvalue to match the shape/structure of lvalues.

        Currently, we only allow this if the rvalue type has contains *tuple[Any, ...].
        Nc              3  óH   K  — | ]  \  }}t        |t        «      sŒ|–— Œ y ­wr'  r?  r@  s      r   rß  z=TypeChecker.adjust_rvalue_type_if_possible.<locals>.<genexpr>8  ó   è ø€ ÒK‘5�1�b´*¸RÄÕ2JŒQÑKùrA  rˆ  r   ©rÐ  )rü   rÌ  rú   rÛ   rj  rÏ  rý  rÐ  ro  r÷   ry  r¢  )	r+  râ  r�  Úright_variadicÚright_unpack_indexÚ
right_itemrg  ÚextraÚ	new_itemss	            r   Úadjust_rvalue_type_if_possiblez*TypeChecker.adjust_rvalue_type_if_possible*  s"  € ô +¨;Ó7ˆØÐ!ØÐØ)7Ñ&Ð˜JÜœ/¨*Ó5´wÔ?ØÐÜÙKœI gÓ.ÔKÈTó
ˆð Ð"Ü˜“L¤3 {×'8Ñ'8Ó#9Ñ9¸AÑ=ˆEØ�qŠyØ"Ð"Ø×,Ñ,Ø!×'Ñ'Ð(;Ð);Ð<Ø�, Ñ&ñ'à×#Ñ#Ð$6¸Ñ$:Ð$<Ð=ñ>ð -ó ð ô
 6Ü�+×#Ñ#Ó$ o´s¸7³|ÀoÑ7UÐXYÑ7Yó
ˆ	ð ×(Ñ(¬t°I«Ð(Ó?Ð?r  c                óB  — t        |j                  «      }|�'| j                  ||«      }t        |j                  «      }| j                  |t	        |j                  «      ||¬«      �rˆt        d„ t        |«      D «       t	        |«      «      }|d | }	|t	        |«      k7  rt        t        ||   «      nd }
||dz   d  }|sá| j                  ||«      }t        | j                  j                  ||«      «      }t        |t        «      rt        |j                  «      }t        |t         «      r,|j#                  «       }t	        |«      dk(  rt        |d   «      }t        |t         «      r| j%                  |||||«       y t        |t&        «      ry t        |t(        «      r|}t        |j                  «      }|�| j                  ||«      }| j+                  |j                  |t	        |«      «      \  }}}t-        |	|«      D ](  \  }}| j/                  || j1                  ||«      |«       Œ* |
rŒt3        |D �cg c]I  }t        |t4        «      s| j1                  ||«      n$t        | j1                  |j6                  |«      «      ‘ŒK c}«      }|j9                  |«       | j/                  |
j:                  ||«       t-        ||«      D ](  \  }}| j/                  || j1                  ||«      |«       Œ* y |�r(|D �]!  }t        |t<        «      rYt        |j>                  t@        «      r?|j>                  j6                  €)t'        tB        jD                  «      |j>                  _        Œmt        |t        «      sŒ~t        |j:                  t<        «      sŒ™t        |j:                  j>                  t@        «      sŒ¾|j:                  j>                  j6                  �Œß| jG                  dt'        tB        jD                  «      g«      |j:                  j>                  _        �Œ$ y y c c}w )N)rf  c              3  óH   K  — | ]  \  }}t        |t        «      sŒ|–— Œ y ­wr'  r?  r@  s      r   rß  z@TypeChecker.check_multi_assignment_from_tuple.<locals>.<genexpr>Y  s   è ø€ ÒO‘u�q˜"´jÀÄXÕ6N”ÑOùrA  rˆ  r   ré  )$rø   rÐ  rŽ  rF  rý  rj  rÏ  r   r�   Úlvalue_type_for_inferencerú   rƒ  r«  rÌ  rð   rM  rõ   rl  rn  rÛ   rç   rG  rò  rµ  r%  rz   rö   r­  rH  r  r   r  r™   rì   rŒ  r®  )r+  r�  rŸ  râ  rï  rs  rß  rf  rT  rU  rV  rW  r¢  Úreinferred_rvalue_typerl  Úleft_rv_typesÚstar_rv_typesÚright_rv_typesr½  rr  Ú	list_exprs                        r   rm  z-TypeChecker.check_multi_assignment_from_tupleH  s¬  € ô ,¨K×,=Ñ,=Ó>ˆØÐ$Ø×=Ñ=¸kÈ7ÓSˆKÜ/°×0AÑ0AÓBˆMØ×0Ñ0Ø”S˜×*Ñ*Ó+¨WÀMð 1õ 
ô ÙO¤	¨'Ó 2ÔOÔQTÐU\ÓQ]óˆJð ˜{ 
Ð+ˆHØ=GÌ3ÈwË<Ò=W”dœ8 W¨ZÑ%8Ô9Ð]aˆGØ 
¨Q¡Ð 0Ð1ˆIá#à"×<Ñ<¸WÀkÓR�Ü)8Ø×%Ñ%×,Ñ,¨V°[ÓAó*Ð&ô Ð4´oÔFÜ-<Ð=S×=_Ñ=_Ó-`Ð*ÜÐ4´iÔ@à%;×%JÑ%JÓ%L�NÜ˜>Ó*¨aÒ/Ü1@ÀÐPQÑARÓ1SÐ.ÜÐ4´iÔ@Ø×:Ñ:Ø Ð)?ÀÐJ[ôð ÜÐ4´gÔ>ð ÜÐ4´iÔ@ð #9�Kô 0°×0AÑ0AÓBˆMØÐ(Ø"×AÑAÀ+ÈwÓW�à;?×;QÑ;QØ×!Ñ! :¬s°7«|ó<Ñ8ˆM˜=¨.ô  # 8¨]Ó;ò _‘��GØ×%Ñ% b¨$¯.©.¸À'Ó*JÐL]Õ^ð_áÜ$ð (5öð $ô $.¨g´zÔ#Bð !ŸN™N¨7°GÔ<ä!)¨$¯.©.¸¿¹ÀwÓ*OÓ!PñQòó	�	ð ×"Ñ" 7Ô+Ø×%Ñ% g§l¡l°IÐ?PÔQÜ" 9¨nÓ=ò _‘��GØ×%Ñ% b¨$¯.©.¸À'Ó*JÐL]Õ^ñ_ò
 !Ø!ó �Bä" 2¤xÔ0Ü& r§w¡w´Ô4ØŸG™GŸL™LÐ0ä'.¬y×/CÑ/CÓ'D˜Ÿ™�Ü# B¬Õ1ä& r§w¡w´Õ9Ü *¨2¯7©7¯<©<¼Õ =Ø "§¡§¡× 1Ñ 1Ñ 9à04×0GÑ0GØ /´'¼)×:NÑ:NÓ2OÐ1Pó1˜BŸG™GŸL™LÖ-ñð !ùò!s   È5APc                ó6  ‡ ‡— t        d„ t        |«      D «       t        |«      «      }|d | }|t        |«      k7  rt        t        ||   «      nd }||dz   d  }‰ j                  |j                  |t        |«      «      \  }}}	g Šdˆ ˆfd„}
 |
||«       |ra‰ j                  |j                  «      \  }}}|r/t        |t        «      s‰j                  |gt        |«      z  «       n‰j                  |«        |
||	«       t        ‰‰ j                  d«      «      S )Nc              3  óH   K  — | ]  \  }}t        |t        «      sŒ|–— Œ y ­wr'  r?  r@  s      r   rß  z8TypeChecker.lvalue_type_for_inference.<locals>.<genexpr>²  r‡  rA  rˆ  c                óÂ   •— t        | |«      D ]O  \  }}‰j                  |«      \  }}}|r"t        |t        «      s‰j	                  |«       Œ?‰j	                  |«       ŒQ y r'  )rò  rž  rÌ  rå   r8  )	r'  Úrv_typesr½  rr  Úsub_lvalue_typeÚ
index_exprrÈ  r+  Útype_parameterss	          €€r   Úappend_types_for_inferencezITypeChecker.lvalue_type_for_inference.<locals>.append_types_for_inference½  s^   ø€ Ü" 3¨Ó1ò 4‘��GØ8<×8IÑ8IÈ"Ó8MÑ5� ¨XÙ"¬:°oÄ{Ô+SØ#×*Ñ*¨?Õ;ð $×*Ñ*¨7Õ3ñ4r  r7  )r'  úlist[Expression]rš  rO  r/  r0  )rj  rÏ  rý  r   r�   rG  rÐ  rž  r  rÌ  rå   rI  rç   r¯  )r+  r�  râ  rT  rU  rV  rW  r“  r”  r•  rž  r›  rœ  rÈ  r�  s   `             @r   r‘  z%TypeChecker.lvalue_type_for_inference°  s  ù€ ÜÙKœI gÓ.ÔKÌSÐQXË\ó
ˆ
ð ˜;˜JÐ'ˆØ9CÄsÈ7Ã|Ò9S”$”x ¨Ñ!4Ô5ÐY]ˆØ˜J¨™NÐ,Ð-ˆ	Ø7;×7MÑ7MØ×Ñ˜z¬3¨w«<ó8
Ñ4ˆ�} nð ')ˆö	4ñ 	# 8¨]Ô;áØ48×4EÑ4EÀgÇlÁlÓ4SÑ1ˆO˜Z¨Ù¤z°/Ä;Ô'OØ×&Ñ&¨Ð'8¼3¸}Ó;MÑ'MÕNð  ×&Ñ& }Ô5á" 9¨nÔ=ä˜¨$¯/©/Ð:JÓ*KÓLÐLr  c                ó`   — ||z
  dz
  }|dk7  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Ð  rT  ÚlengthÚnr_right_of_starÚright_indexrp  Ústarrq  s	            r   rG  zTypeChecker.split_around_starÖ  s[   € ð " JÑ.°Ñ2ÐØ+;¸qÒ+@Ð'Ñ'ÄcÈ%ÃjˆØ�[�jÐ!ˆØ�Z Ð,ˆØ�k�lÐ#ˆØ�T˜5Ð Ð r  c           	     óØ   — t        |«      }t        |t        «      r|j                  «       r|j                  }t        || j                  dt        t        j                  «      g«      «      S )Nr–  )
rú   rÌ  rà   rr  r#  r¸   r®  rÛ   rì   r*  ©r+  r­  s     r   rB  zTypeChecker.type_is_iterableæ  sX   € Ü˜tÓ$ˆÜ�dœLÔ)¨d×.>Ñ.>Ô.@Ø—=‘=ˆDÜØ�$×)Ñ)Ð*;¼gÄi×F\ÑF\Ó>]Ð=^Ó_ó
ð 	
r  c                ó�  — t        |«      }| j                  |«      rŽ| j                  ||«      }|D ]v  }t        |t        «      rA| j                  d|g«      }| j                  |j                  | j                  ||«      |«       ŒT| j                  || j                  ||«      |«       Œx y | j                  j                  ||«       y )Nré  )rú   rB  rC  rÌ  r�   r®  rµ  r  r%  rH  Útype_not_iterable)r+  r�  râ  rï  rß  rB  r½  Ú
items_types           r   rq  z0TypeChecker.check_multi_assignment_from_iterableî  s¹   € ô & kÓ2ˆØ× Ñ  Ô-Ø×/Ñ/°¸WÓEˆIØò 	�Ü˜b¤(Ô+Ø!%×!8Ñ!8¸È9È+Ó!V�JØ×)Ñ)ØŸ™ §¡°
¸GÓ!DÐFWõð ×)Ñ)Ø˜DŸN™N¨9°gÓ>Ð@Qõñ	ð �H‰H×&Ñ& {°GÕ<r  c                ól  — d }d }d }| j                   j                  xrž t        |t        «      xrŒ t        |j                  t
        «      xrp |j                  j                  xrX |j                  j                  d uxr> t        |j                  j                  t        «       xr |j                  j                   }| j                  |«      r«t        |t        «      rt        |j                  t
        «      r�|st        |t        «      r*t        |j                  t
        «      sJ ‚|j                  }�nøt        |t        «      sJ ‚| j                  j                  |j                  «       |j                  }�n³t        |t         «      r|}�nŸt        |t        «      r1| j                  j#                  |d|«      }| j%                  ||«       �n^t        |t        «      r˜| j                  j'                  |d¬«      }| j                   j                  rRt        |j                  t
        «      r8|j                  j                  s|j                  j(                  r|j                  }| j%                  ||«       n¶t        |t*        t,        f«      rU|j.                  D �cg c]$  }| j1                  |«      d   xs t3        d¬«      ‘Œ& }}t5        || j7                  d«      «      }nKt        |t8        «      r | j1                  |j                  «      \  }}	}	n| j                  j                  |«      }|||fS c c}w )NT)rþ  r   ©Ú	ambiguousr7  )rZ  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à  rÈ  Úskip_definitionÚsub_exprrÓ  r  s
             r   rž  zTypeChecker.check_lvalue  sŸ  € ð ˆØˆØˆð
 �L‰L×+Ñ+ò -Ü˜6¤8Ó,ò-ä˜6Ÿ;™;¬Ó,ò-ð —‘×'Ñ'ò-ð —‘× Ñ ¨Ð,ò	-ô
 ˜vŸ{™{×/Ñ/´Ó=Ð=ò-ð —K‘K×,Ñ,Ð,ð 	ð ×Ñ˜vÔ&Ü ¬Ô1´ZÀÇÁÌSÔ5QÙ#ä˜&¤(Ô+Ü! &§+¡+¬sÔ3Ð3Ð3Ø!Ÿ;™;’ä! &¬*Ô5Ð5Ð5Ø×!Ñ!×(Ñ(¨¯©Ô5Ø!Ÿ>™>’Ü˜¤	Ô*Ø!ŠLÜ˜¤
Ô+Ø×+Ñ+×JÑJÈ6ÐSWÐY_Ó`ˆKØ�O‰O˜F KÖ0Ü˜¤Ô)Ø×+Ñ+×<Ñ<¸VÈDÐ<ÓQˆKà—‘×/Ò/Ü˜vŸ{™{¬CÔ0ð —[‘[×,Ò,°·±×0GÒ0Gà!Ÿ;™;�Ø�O‰O˜F KÕ0Ü˜¤¬HÐ 5Ô6ð !'§¡öð
 ð	 ×!Ñ! (Ó+¨AÑ.ò 0ô  ¨$Ô/ñ0ðˆEð ô $ E¨4¯?©?Ð;KÓ+LÓM‰KÜ˜¤Ô)Ø $× 1Ñ 1°&·+±+Ó >ÑˆK˜™Aà×+Ñ+×2Ñ2°6Ó:ˆKà˜L¨(Ð2Ð2ùòs   Ê)L1c                óÌ   — t        |t        «      r8|j                  ry|j                  }t        |t        «      r|j
                  d u S yt        |t        «      r|j                  S yr  )rÌ  r   Úis_inferred_defr  r™   r­  r}   )r+  r¦  r  s      r   r®  zTypeChecker.is_definitionG  s\   € Ü�aœÔ"Ø× Ò Øð —6‘6ˆDÜ˜$¤Ô$Ø—y‘y DÐ(Ð(ð ô ˜œ:Ô&Ø×$Ñ$Ð$Ør  c           	     ó  — t        |t        «      r| j                  j                  ||«       yt	        || j
                  |j                  t        |t        «      ¬«      s³| j                  j                  «       r.t        |j                  «      rt        t        |«      t        «      sk| j                  s_|j                  dk7  rO| j                  |||«      s;| j                  j!                  ||| j
                  «       | j#                  |||«       yyyt        |t        «      r™| j$                  ��|j&                  r�|j&                  | j$                  v rit)        | j$                  |j&                     |«      sF| j                  j!                  ||| j
                  «       t+        t,        j.                  «      |_        yt3        |«      }| j5                  |||«       | j
                  j6                  r| j8                  j;                  |||«       yy)z>Infer the type of initialized variables from initializer type.)rÇ  Úis_lvalue_memberr  N)rÌ  rÞ   rH  Údeleted_as_rvaluerÎ  rZ  r¼  r}   rN  rh  r	  rÊ  rú   rã   r\  rÐ  Úneed_annotation_for_varÚ!set_inference_error_fallback_typer[  r¯  r·   rÛ   rì   rŒ  r­  r  rÏ  r×  rI  r°  )r+  rÊ  rþ  Ú	init_typerï  s        r   rÜ  zTypeChecker.infer_variable_typeW  sŽ  € ô �i¤Ô-Ø�H‰H×&Ñ& y°'Õ:ä&ØØ—‘Ø $§¡Ü!+¨F´JÓ!?õ	ð —
‘
×'Ñ'Ô)Ü˜dŸi™iÔ(Üœ¨yÓ9¼8ÔDà×)Ò)ð �y‰y˜CÒ¨×(?Ñ(?ÀÀfÈiÔ(XØ—‘×0Ñ0°°wÀÇÁÔMØ×6Ñ6°t¸VÀYÕOð )YÐô �vœzÔ*Ø×-Ñ-Ð9Ø—’Ø—‘ $×"?Ñ"?Ñ?Ü  ×!>Ñ!>¸v¿~¹~Ñ!NÐPYÔZð �H‰H×,Ñ,¨T°7¸D¿L¹LÔIÜ¤	× 4Ñ 4Ó5ˆD�Iô
 # 9Ó-ˆIà×"Ñ" 4¨°Ô;Ø�|‰|×.Ò.Ø—‘×'Ñ'¨°	¸9ÕEð /r  c                ó>  — t        |«      }t        |t        «      r4t        |t        «      s| j                  j
                  st        d |«      }�nt        |t        «      �r|j                  j                  }t        |t        «      }|rP|dk(  s|dk(  s
|dk(  s|dk(  r<t        d„ t        |j                  «      D «       «      rt        |j                  |«      }n–|r’|dk(  r�t        |j                  d   «      }t        |j                  d   «      }t        |t        t        f«      rF| j                  |«      r5t!        |«      }t        |t        «      sJ ‚t        |j                  ||«      }ny	y	y	| j#                  |||«       || j$                  d
   j&                  |<   y)Nré  rë  úbuiltins.dictúcollections.OrderedDictc              3  óH   K  — | ]  }t        |t        t        f«      –— Œ y ­wr'  )rÌ  rã   rô   rL  s     r   rß  z1TypeChecker.infer_partial_type.<locals>.<genexpr>œ  s$   è ø€ ò àô ˜q¤8¬_Ð"=×>ñùr¸  úcollections.defaultdictr   rˆ  FrŒ  T)rú   rÌ  rã   r}   rZ  r×  rå   rá   r­  r   r‰   rk  rû   r�  rô   Ú'is_valid_defaultdict_partial_value_typer)   rÏ  rR  r(  )	r+  rÊ  rþ  r¼  Úpartial_typer   Úis_refÚarg0Úarg1s	            r   rÐ  zTypeChecker.infer_partial_type‰  si  € Ü# IÓ.ˆ	Ü�i¤Ô*Ü�vœzÔ*°$·,±,×2QÒ2Qô ' t¨TÓ2ŠLÜ˜	¤8Õ,Ø —~‘~×.Ñ.ˆHÜ ¬Ó0ˆFáà Ò/Ø >Ò1Ø ?Ò2ØÐ#<Ò<äñ ä-¨i¯n©nÓ=ôô ô
  +¨9¯>©>¸4Ó@‘Ù˜HÐ(AÒAÜ& y§~¡~°aÑ'8Ó9�Ü& y§~¡~°aÑ'8Ó9�ÜØœ8¤_Ð5ôà×BÑBÀ4ÔHÜ% dÓ+�DÜ% d¬HÔ5Ð5Ð5Ü#.¨y¯~©~¸tÀTÓ#J‘Là ààØ×Ñ˜t V¨\Ô:Ø+1ˆ×Ñ˜2Ñ×"Ñ" 4Ñ(Ør  c                óN  — t        |t        «      syt        |j                  «      dk(  ryt        |j                  «      dk(  rct	        |j                  d   «      }| j
                  j                  rt        |t        t        t        f«      }nt        |t        t        f«      }|ryy)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ú   rZ  Úold_type_inferencerô   rã   rò   )r+  rM  r÷  Úalloweds       r   rÂ  z3TypeChecker.is_valid_defaultdict_partial_value_typeµ  s€   € ô ˜!œXÔ&ØÜˆq�v‰v‹;˜!ÒØÜˆq�v‰v‹;˜!ÒÜ! !§&¡&¨¡)Ó,ˆCØ�|‰|×.Ò.ä$ S¬?¼HÄkÐ*RÓS‘ä$ S¬?¼HÐ*EÓF�ÙØØr  c                óF  — |�r™| j                   �s‹||_        d|_        d|_        || j                  vr;| j
                  j                  D �ch c]  }|j                  ’Œ c}| j                  |<   t        |t        «      r1| j                  �%|j                  �|| j                  |j                  <   | j                  ||«       t        |«      }d}t        |t        «      r|j                  }n)t        |t         «      r|j"                  d   j                  }|r„t%        |«      rd|_        yt)        |«      rd|_        yt-        |«      rRd|_        t        |t         «      r:d|_        t        |t0        «      sJ |«       ‚|j2                  j4                  |_        yyyyyyc c}w )zºStore 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.
        TNr   )rm  r­  rØ  Úis_readyr_  rI  rÒ  r£  rÌ  r}   r[  r¯  rÁ  rú   rÝ   r-  rä   rÐ  Úis_node_staticÚis_staticmethodÚis_classmethod_noder[  rÑ  r'  rf   r&  r,  )r+  r&  rþ  r­  ró  Úp_typer-  s          r   rÏ  zTypeChecker.set_inferred_typeÎ  se  € ò �t×1Ó1ØˆCŒHØ"ˆCŒOØˆCŒLØ˜$×.Ñ.Ñ.àCGÇ;Á;×CUÑCUÖ,V¸%¨U¯X«XÒ,V�×$Ñ$ SÑ)Ü˜&¤*Ô-°$×2OÑ2OÐ2[à—>‘>Ð-ØDH�D×1Ñ1°&·.±.ÑAØ�O‰O˜F DÔ)Ü$ TÓ*ˆFØˆJÜ˜&¤,Ô/Ø#×.Ñ.‘
Ü˜F¤JÔ/ð $Ÿ\™\¨!™_×7Ñ7�
ÙÜ! *Ô-Ø*.�CÕ'Ü(¨Ô4Ø)-�CÕ&Ü  Ô,Ø&*�C”OÜ! &¬*Ô5à37˜Ô0Ü)¨*´iÔ@ÐLÀ*ÓLÐ@Ø*4¯.©.×*DÑ*D˜�ð	 6ð -ð ð) 2ˆ3ùò -Ws   ÁFc                óL   — | j                  |«      }| j                  |||«       y)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õ  s&   € ð ×5Ñ5°dÓ;ˆØ×Ñ˜s F¨HÕ5r  c                óJ   — |j                  t        «       «      }t        |«      S r'  )r«  ÚSetNothingToAnyr*   )r+  r­  r#  s      r   rÑ  z)TypeChecker.inference_error_fallback_type  s    € Ø—;‘;œÓ0Ó1ˆô ˜hÓ'Ð'r  c                óÀ  — t        |t        t        t        t        t
        f«      ryt        |t        «      r¨t        |j                  t
        «      rŽt        |j                  j                  t        «      rj|j                  j                  j                  }t        |t        «      r|j                   S t        |t        «      rt        d„ |j                  D «       «       S y)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  ó4   K  — | ]  }|j                   –— Œ y ­wr'  ©rl  rž  s     r   rß  z,TypeChecker.simple_rvalue.<locals>.<genexpr>  s   è ø€ Ò"H°d 4§>¥>Ñ"Hùrà  F)rÌ  rx   r�   r`   rl   r‰   ra   r?  r  rY   r­  rÝ   rl  rä   rã  rÐ  )r+  rŸ  rH  s      r   Úsimple_rvaluezTypeChecker.simple_rvalue	  sž   € ô �fœw¬´¼IÄwÐOÔPØÜ�fœhÔ'Ü˜&Ÿ-™-¬Ô1´jØ—‘×"Ñ"Ô$9ô7ð —m‘m×(Ñ(×-Ñ-�Ü˜c¤<Ô0Ø"Ÿ}™}Ð,Ð,Ü ¤ZÔ0Ü"Ñ"H¸c¿i¹iÔ"HÓHÐHÐHØr  c                ó`  — ||usJ ‚| j                   }d}| j                  j                  d¬«      5 }	| j                  5 }
| j                  j                  |||¬«      }ddd«       ddd«       |duxr& |j                   xr t        | j                  «       }|duxr |j                  xr 	j                  «       }|duxr* t        t        |«      t        «      xr || j                   k(  }|xs |xs |}|rÇt        «      s¼| j                  j                  d¬«      5 }| j                  5 }| j                  j                  |||¬«      }ddd«       ddd«       j                  «       sTt        | j                  «      r>|s'|s%t        t        |«      t        «      s!t        ||«      rd}|}| j!                  «       |s:| j                  j#                  	j%                  «       «       | j!                  
«       S # 1 sw Y   �Œ£xY w# 1 sw Y   �Œ¨xY w# 1 sw Y   ŒÍxY w# 1 sw Y   ŒÑxY w)z…Infer rvalue type in two type context and select the best one.

        See comments below for supported fallback scenarios.
        FT)Úsave_filtered_errors©r†  r<  N)r<  )r  rH  r°  rr  rƒ  r«  r²  rÎ  rZ  Úhas_new_errorsrÌ  rú   rõ   rÌ   rÛ   r¶   Ústore_typesÚ
add_errorsÚfiltered_errors)r+  r¢  rŸ  Úpreferred_contextÚfallback_contextrÈ  r<  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  sL  € ð  Ð'8Ñ8Ð8Ð8ð (,×'HÑ'HÐ$à %Ðà�H‰H×"Ñ"¸Ð"Ó=ð	ØAMØ×Ñð	à#+à×+Ñ+×2Ñ2ØÐ%6ÐIYð 3ó ˆK÷		÷ 	ð ˜DÐ ò FØ×(Ñ(Ð(òFä*¨;¸¿¹ÓEÐEð 	ð ˜DÐ Ò[ X×%9Ñ%9Ò[¸l×>YÑ>YÓ>[ð 	'ð  TÐ)ò RÜœ?¨;Ó7¼ÓCòRà,°×0QÑ0QÑQð 	ð -Ò`°Ò`ÐB`ˆÙÔ 4°[Ô Aà—‘×&Ñ&¸DÐ&ÓAðØEUØ×#Ñ#ðà'3à"&×"3Ñ"3×":Ñ":ØÐ,Ð?Oð #;ó #�÷	÷ ð %×3Ñ3Ô5Ü*¨?¸D¿L¹LÔIñ *Ù5ä%¤o°oÓ&FÌÔPÜ)¨/¸;ÔGð )-Ð%Ø-�Ø× Ñ  Ô.á$Ø�H‰H×Ñ × <Ñ <Ó >Ô?Ø×Ñ˜XÔ&ØÐ÷w	ñ 	ú÷ 	ñ 	ú÷Bð ú÷ ð úsF   ±H¾G>ÁHÄ H$Ä-HÅH$Ç>H	ÈHÈHÈH!	ÈH$È$H-rÙ  Ú
expression)r;  rþ  rÈ  c          	     óô  — | j                   r+t        |t        «      rt        t        j
                  «      |fS |d uxr t        t        |«      t        «       }
|	d uxs t        t        |«      t        «      xr | j                  |«       }|r|�t        |«      r| j                  j                  |||
¬«      }n-|	�|	j                  sd }|}n|}d }| j                  |||||	|
«      }|	�’t        || j                  «      s||	j                   r0t        |	j                   t"        «      st%        ||	j                   «      s@| j&                  j)                  |	|	| j                  «       |j                  t+        «       «      }t        |t,        «      �ro|	��l|	j                   ��_|	j.                  �sRt1        |«      }| j3                  |«      �s5t        |	j                   t"        «      �st5        ||	j                   «      �s| j7                  ||	j                   «      rçt9        |	j                   |g«      }|	j:                  s%| j<                  j?                  |	j@                  «       | jC                  |	||«       |jD                  tF        k(  r7| jH                  jK                  «       �| jL                  j?                  ||f«       | jN                  jQ                  ||«       tS        |«      }|�|| jN                  jT                  |<   t        |tV        «      r| j&                  jY                  ||«       t        |tV        «      r | j&                  j[                  ||«       ||fS |r| j]                  |||||› d�|› d�|¬«       ||fS )NrÙ  z	 has type)r;  )/rn  rÌ  ri   rÛ   rì   r*  rú   rõ   rÖ  Úis_typeddict_type_contextrƒ  r«  r²  rê  rÎ  rZ  r­  rå   r¸   rH  rº  rÒ  r   r¼  r+   Úrefers_to_different_scoper¶   Úcan_widen_in_scoperÏ   rÙ  rT  r8  rÊ  rÏ  rÒ  rQ   rN  rì  rU  rI  rì  r;   rÖ  rÞ   r¹  Údeleted_as_lvaluer±  )r+  r¢  rŸ  rï  rH  r9  r:  r;  rþ  rÈ  r<  ræ  râ  Ú	preferredr#  Únew_inferredr   s                    r   r?  z#TypeChecker.check_simple_assignmentq  s   € ð �<Š<œJ v¬|Ô<äœ9×1Ñ1Ó2°KÐ?Ð?à*°$Ð6ò  ¼zÜ Ó,¬gó@ð <Ðð  Ð$Ò[¬
´?À;Ó3OÔQZÓ([ò1à×(Ñ(¨Ó0Ð0ð ñ   ;Ð#6Ô:SÐT_Ô:`Ø"×/Ñ/×6Ñ6Ø¨ÐGWð 7ó ‘ð Ð'°×0DÒ0DØ $�IØ*‘Hà +�IØ#�Hà"×EÑEØ ¨°H¸hÐHXó�ð
 Ð$Ü.¨{¸D¿L¹LÔIà ŸšÜ! (§-¡-´Ô=ô & k°8·=±=ÔAð —‘×0Ñ0°¸8ÀTÇ\Á\ÔRØ)×0Ñ0´Ó1BÓC�ô ˜6¤8Õ,ØÑ(Ø—M‘MÑ-Ø ×)Ó)ä@ÀÓM�ð
 ×6Ñ6°vÕ>Ü& x§}¡}´kÕBÜ-¨l¸H¿M¹MÕJØ×/Ñ/°¸¿¹ÔFä"7¸¿¹ÈÐ8UÓ"V�Kà#×0Ò0à×)Ñ)×0Ñ0°·±Ô?Ø×*Ñ*¨8°V¸[ÔIØ—{‘{¤dÒ*¨t¯z©z×/LÑ/LÓ/NÐ/Zð ×5Ñ5×<Ñ<¸fÀkÐ=RÔSØ—K‘K—O‘O F¨KÔ8ô ' vÓ.�CØ�Ø8C˜Ÿ™×0Ñ0°Ñ5ä˜+¤{Ô3Ø—‘×*Ñ*¨;¸Ô@Ü˜+¤{Ô3Ø—‘×*Ñ*¨;¸Ô@ð  Ð+Ð+ñ Ø×"Ñ"àØØØØ"�m 9Ð-Ø"�m 9Ð-Øð #ô 	ð  Ð+Ð+r  c                ó  — |j                   t        k(  ry| j                  j                  «       �|j                   t        k7  ry|j                   t        k(  r6|j
                  j                  d«      d   | j                  j
                  k7  ryy)NFTú.r   )rÒ  rU   rN  rì  rQ   r   Ú
rpartitionrf  ©r+  rÊ  s     r   rî  z%TypeChecker.refers_to_different_scopeá  si   € Ø�9‰9œÒàØ�Z‰Z×*Ñ*Ó,Ð8¸T¿Y¹YÌ$Ò=NàØ�Y‰Yœ$Ò 4§=¡=×#;Ñ#;¸CÓ#@ÀÑ#CÀtÇyÁy×GYÑGYÒ#YàØr  c                ó’   — |j                   t        k(  r4| j                  j                  «       �t	        t        |«      t        «      syy)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.
        FT)rÒ  rQ   rN  rì  rÌ  rú   rã   )r+  rÊ  r³  s      r   rï  zTypeChecker.can_widen_in_scopeí  s8   € ð �I‰IœÒØ—
‘
×-Ñ-Ó/Ð;Üœ¨yÓ9¼8ÔDàØr  c                ó´  — t        |«      }t        |t        «      r|j                  «       st        |t        «      r| j                  |||«      \  }}||dfS | j                  j                  d¬«      5  | j                  j                  |d¬«      }ddd«       | j                  |||«      \  }}t        |«      r|n|}||t        ||«      fS # 1 sw Y   Œ>xY w)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)rI  N)rú   rÌ  rà   rr  rî   r?  rH  r°  rƒ  r°  r¸   )	r+  rþ  rä  Úset_lvalue_typerŸ  rï  râ  r  Úget_lvalue_types	            r   rÓ  z#TypeChecker.check_member_assignmentý  sã   € ô  (¨Ó6ˆä�}¤lÔ3¸×8QÑ8QÔ8SÔXbØœ8ôY
ð "×9Ñ9¸/È6ÐSZÓ[‰NˆK˜Ø °Ð5Ð5à�X‰X×#Ñ#°dÐ#Ó;ñ 	Ø"×/Ñ/×NÑNØ %ð Oó ˆO÷	ð ×5Ñ5°oÀvÈwÓW‰ˆ�QÜ%/°¸_Ô%M‘kÐSbˆØ˜O¬Z¸ÈÓ-YÐYÐY÷	ð 	ús   Á3CÃCc                óì  — | j                  ||«       t        | j                  j                  |j                  «      «      }| j                  j                  d||«      }||_        | j                  j                  d|||j                  |gt        j                  t        j                  g|«      \  }}t        |«      }t        |t        «      r(|j                  s| j                  j                  «        yyy)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¹  rp  rt  Úcheck_method_callrõ  r   rL   rÌ  rô   r­  rI  rú  )r+  rþ  rŸ  rï  Úbasetypert  Úres_typer  s           r   rÚ  z$TypeChecker.check_indexed_assignment"  sÓ   € ð 	×;Ñ;¸FÀFÔKÜ" 4×#4Ñ#4×#;Ñ#;¸F¿K¹KÓ#HÓIˆØ×'Ñ'×FÑFØ˜8 Vó
ˆð )ˆÔØ×'Ñ'×9Ñ9ØØØØ�\‰\˜6Ð"Ü�]‰]œEŸM™MÐ*Øó
‰ˆ�!ô # 8Ó,ˆÜ�h¤Ô0¸×9KÒ9KØ�K‰K×#Ñ#Õ%ð :LÐ0r  c                óö   — ||_         | j                  xj                  dz  c_        ||= | j                  j                  r:t        |j                  «      }||_        | j                  j                  |||«       yy)z8Replace the partial type of var with a non-partial type.rˆ  N)	r­  rI  ÚversionrZ  r×  r   rÊ  r  r°  )r+  r&  rš  rR  rù  s        r   Úreplace_partial_typez TypeChecker.replace_partial_type<  sg   € ð ˆŒà�‰×Ò˜qÑ ÕØ˜#ÐØ�<‰<×*Ò*ô ˜Ÿ™Ó"ˆAØˆAŒFØ�K‰K×#Ñ# A x°Õ:ð +r  c                óÚ  — d }t        |j                  t        «      r;t        |j                  j                  t        «      r|j                  j                  }n?t        |j                  t
        «      r%| j                  j                  |j                  «      }t        |t        «      �rDt        |j                  t        «      �r(|j                  j                  }|€y | j                  |«      }|€y |j                  }|dk(  s
|dk(  s|dk(  rß| j                  j                  |j                  «      }| j                  j                  |«      }t        || j                  «      rˆt        || j                  «      rq| j                   sd|dk(  r6|j                  j"                  � t%        ||j                  j"                  «      r(| j'                  |||g«      }	| j)                  ||	|«       y y y y y y y y )Nr¾  r¿  rÁ  )rÌ  r¹  r‰   r  r™   r}   rƒ  rö  r­  rå   r­  r   r«  rõ  rÎ  rZ  rm  Ú
value_typer´   r®  r  )
r+  rþ  rŸ  r&  r^  rR  ÚtypenameÚkey_typer  rš  s
             r   rý  z:TypeChecker.try_infer_partial_type_from_indexed_assignmentK  s£  € ð ˆÜ�f—k‘k¤7Ô+´
¸6¿;¹;×;KÑ;KÌSÔ0QØ—+‘+×"Ñ"‰CÜ˜Ÿ™¤ZÔ0Ø×#Ñ#×8Ñ8¸¿¹ÓEˆCÜ�cœ3ÕÜ˜#Ÿ(™(¤KÕ0ØŸH™HŸM™M�	ØÐ$ØØ $× 7Ñ 7¸Ó <�Ø Ð(ØØ$×-Ñ-�à Ò/ØÐ#<Ò<ØÐ#<Ò<ð  $×0Ñ0×7Ñ7¸¿¹ÓE�HØ!%×!2Ñ!2×!9Ñ!9¸&Ó!A�Jä.¨x¸¿¹ÔFÜ2°:¸t¿|¹|ÔLØ $× :Ò :à$Ð(AÒAØ #§¡× 3Ñ 3Ð ?Ü$1°*¸c¿h¹h×>QÑ>QÔ$Rð $(×#:Ñ#:¸8ÀhÐPZÐE[Ó#\˜Ø×1Ñ1°#°xÀÕOð	 %Sð	 !;ð Mð Gð =ð 1ð  r  c                ó<  — t        |«      }t        |t        «      �r |j                  j                  dk(  rdt
        fS |j                  j                  d«      �Ät        |j                  t        «      ržt        |j                  j                  t        «      rzt        | j                  j                  |j                  j                  j                  «      «      }t        |t        «      xr% |j                  j                  j                  d«      }nd}|sdt        fS y)aU  Some types require usage in basically 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. We special case somethings that return
        awaitables because in those particular cases we can guarantee
        it's safe.
        útyping.CoroutinezAre you missing an await?Ú	__await__Nz
.TaskGroupF)rú   rÌ  rá   r­  r   r/   r¬  r  ra   r?  r}   rƒ  r«  Úendswithr.   )r+  rH  r¦  Úproper_typeÚ	called_onÚis_a_taskgroups         r   Útype_requires_usagezTypeChecker.type_requires_usager  så   € ô & cÓ*ˆÜ�k¤8Õ,ð ×Ñ×(Ñ(Ð,>Ò>Ø3Ô5EÐFÐFØ×Ñ×#Ñ# KÓ0Ð<ô
 ˜aŸf™f¤hÔ/´J¸q¿v¹v¿}¹}ÌjÔ4YÜ /°×0AÑ0A×0HÑ0HÈÏÉÏÉ×I[ÑI[Ó0\Ó ]�IÜ%/Ø!¤8ó&ò &Ià#Ÿ.™.×1Ñ1×:Ñ:¸<ÓHñ #ð &+�NÙ%Ø7Ô9IÐJÐJØr  c                ó:  — | j                   j                  |j                  dd¬«      }| j                  ||«      }|r_|\  }}| j	                  t
        j                  j                  t        || j                  «      «      ||¬«       | j                  |||¬«       y y )NTr:  r¾  )rƒ  r«  r  r  r°  r   ÚTYPE_MUST_BE_USEDr²  rD   rZ  ré  )r+  r¦  Ú	expr_typeÚerror_note_and_codeÚ
error_noter¿  s         r   Úvisit_expression_stmtz!TypeChecker.visit_expression_stmt‘  s–   € Ø×%Ñ%×,Ñ,¨Q¯V©VÀtÐ^bÐ,Ócˆ	Ø"×6Ñ6°yÀ!ÓDÐÙØ2ÑˆJ˜Ø�I‰IÜ ×2Ñ2×9Ñ9¼+ÀiÐQU×Q]ÑQ]Ó:^Ó_ØØð ô ð
 �I‰I�j !¨$ˆIÕ/ð r  c                óZ   — | j                  |«       | j                  j                  «        y)zType check a return statement.N)Úcheck_return_stmtrI  rú  ©r+  r¦  s     r   Úvisit_return_stmtzTypeChecker.visit_return_stmt�  s    € à×Ñ˜qÔ!Ø�‰×ÑÕ!r  c           
     óx  — | j                   j                  dd¬«      5 }| j                  5 }| j                  j	                  dd¬«      5  t        | j                  j                  |||¬«      «      }ddd«       ddd«       ddd«       j                  «       s| j                  «       S |j                  «       }}| j                   j                  dd¬«      5 }| j                  5 }t        | j                  j                  |d|¬«      «      }	ddd«       ddd«       |j                  «       st        	|«      r| j                  |«       |	S | j                   j                  |«       | j                  |«       S # 1 sw Y   �ŒxY w# 1 sw Y   �ŒxY w# 1 sw Y   �ŒxY w# 1 sw Y   Œ•xY w# 1 sw Y   Œ™xY w)z=Infer type of expression with fallback to empty type context.T)r  rØ  F)rù  Údiscard©r;  N)rH  r°  rr  rI  r  rú   rƒ  r«  rÚ  rÛ  rÝ  r¸   rÜ  )
r+  r  Útype_ctxÚallow_none_func_callrH  râ  rH  Úoriginal_messagesÚoriginal_type_mapÚalt_typs
             r   Úinfer_context_dependentz#TypeChecker.infer_context_dependent¢  s¯  € ð �X‰X×#Ñ#°dÐQUÐ#ÓVð 
	ÐZ]à×#Ñ#ð	Ø'/à—‘×)Ñ)°5À$Ð)ÓGñ	ô
 &Ø×%Ñ%×,Ñ,Ø˜hÐ:Nð -ó ó�÷	÷ 	÷
	ð ×!Ñ!Ô#Ø×Ñ˜XÔ&ØˆJð  ×/Ñ/Ó1ÐØ$ÐØ�X‰X×#Ñ#°dÐQUÐ#ÓVð 	ÐZ]Ø×$Ñ$ð ¨Ü)Ø×%Ñ%×,Ñ,¨T°4ÐK_Ð,Ó`ó�÷÷	ð
 ×!Ñ!Ô#¬
°7¸HÔ(EØ×Ñ˜XÔ&ØˆNð 	�‰×ÑÐ-Ô.Ø×ÑÐ*Ô+Øˆ
÷;	ñ 	ú÷ 	ñ 	ú÷
	ñ 
	ú÷&ð ú÷	ð 	ús^   žF«F
Á	(E=Á1F
Á9FÃF0Ã((F$ÄF0Å=FÆF
Æ
F	ÆFÆF!Æ$F-	Æ)F0Æ0F9c           	     óà  — | j                   j                  «       }|��Ñ|j                  r*| j                  | j                  d   |j
                  «      }n:|j
                  r| j                  | j                  d   «      }n| j                  d   }t        |«      }t        |t        «      }t        |t        «      r/|s-|j                  s!| j                  t        j                  |«       y |j                  �rˆt        |t         «      }t        |t"        «      }|xs |xs |}t        |j                  t$        t&        t(        t*        t,        t.        f«      s>t        |j                  t0        «      rBt        |j                  j                  t$        «      r| j3                  |j                  ||«      }n1t        | j4                  j7                  |j                  ||¬«      «      }t        |t8        «      r5|j:                  j<                  t>        v rt#        t@        jB                  «      }|jD                  r!| j                  t        jF                  |«       y t        |t"        «      r´| jH                  jJ                  r�| jL                  s‘tO        t#        t@        jB                  «      |«      sn|jP                  tR        v rtU        |j                  «      sGt        |t8        «      r|j:                  j<                  dk(  s|s| jV                  jY                  ||«       y |r4|st        |t         «      ry | j                  t        jZ                  |«       y | j]                  d|d||j                  |t        j^                  ¬«       y |j                  r|j
                  st        |t"        «      ry t        |t         t"        f«      ry | ja                  «       r!| j                  t        jb                  |«       y y y )NrŒ  r  r-  ÚgotrÀ  )rÁ  rÂ  rÃ  rÄ  rï  Úouter_contextrH  )2rN  Úcurrent_functionrÝ  r–  rP  r~  r”  rú   rÌ  ry   rô   r­  r°  r   ÚNO_RETURN_EXPECTEDr  rã   rÛ   ra   rz   r•   rh   r‹   rƒ   r]   r"  rƒ  r«  rá   r­  r   rÙ   rì   r*  r  ÚRETURN_IN_ASYNC_GENERATORrZ  Úwarn_return_anyrm  r¶   rÊ  r¯   r¯  rH  Úincorrectly_returning_anyÚNO_RETURN_VALUE_EXPECTEDr±  rë  r©  ÚRETURN_VALUE_EXPECTED)	r+  r¦  r  rŽ  Ú	is_lambdaÚdeclared_none_returnÚdeclared_any_returnr  rH  s	            r   r  zTypeChecker.check_return_stmtÆ  s  € Ø�z‰z×*Ñ*Ó,ˆØÑØ× Ò Ø"×<Ñ<Ø×%Ñ% bÑ)¨4×+<Ñ+<ó‘ð ×"Ò"Ø"×<Ñ<¸T×=NÑ=NÈrÑ=RÓS‘à"×/Ñ/°Ñ3�Ü)¨+Ó6ˆKä" 4¬Ó4ˆIÜ˜+¤Ô7á ¨×)>Ò)>Ø—I‘IÔ.×AÑAÀ1ÔEØà�v‹vÜ'1°+¼xÓ'HÐ$Ü&0°¼gÓ&FÐ#ð (1Ò'_Ð4HÒ'_ÐL_Ð$ô ˜qŸv™v¬´(¼IÄxÔQXÔZ`Ð'aÔbÜ! !§&¡&¬)Ô4Ü" 1§6¡6§;¡;´Ô9ð ×6Ñ6°q·v±v¸{ÐL`Óa‘Cä)Ø×)Ñ)×0Ñ0ØŸF™F KÐCWð 1ó ó�Cô ˜c¤8Ô,°·±×1BÑ1BÔF`Ñ1`Ü!¤)×"8Ñ"8Ó9�Cà×*Ò*Ø—I‘IÔ.×HÑHÈ!ÔLØä˜c¤7Ô+ð Ÿ™×4Ò4Ø $× :Ò :Ü 1´'¼)×:PÑ:PÓ2QÐS^Ô _à ŸI™IÔ)=Ñ=Ü :¸1¿6¹6Ô Bô ' {´HÔ=Ø +× 0Ñ 0× 9Ñ 9Ð=NÒ Ná )àŸ™×:Ñ:¸;ÈÔJØñ (ñ !¤J¨s´HÔ$=ØØ—I‘IÔ.×GÑGÈÕKà×&Ñ&Ø&+Ø #Ø(2Ø"-Ø !§¡Ø&'Ü,×KÑKð 'õ ð ×%Ò%Ø ×-Ò-Ü" ;´Ô8àä˜k¬H´gÐ+>Ô?Øà×+Ñ+Ô-Ø—I‘IÔ.×DÑDÀaÕHð .ðU r  c                ó&  — | j                   j                  ddd¬«      5  t        |j                  |j                  «      D ]Ö  \  }}t        | j                  j                  |«      «      }t        |t        «      r| j                  j                  ||«       | j                  |«      \  }}t        |«      |_        | j                   j                  dd¬«      5  | j                  |d¬«       | j                  |«       ddd«       | j                  |d¬«       ŒØ | j                   j                  dd¬«      5  |j                   r| j                  |j                   «       ddd«       ddd«       y# 1 sw Y   ŒtxY w# 1 sw Y   ŒxY w# 1 sw Y   yxY w)	zType check an if statement.FTr   ©rù  rú  Úfall_throughr  ©rù  r2  ©Úfrom_assignmentN)rI  r  rò  r  r  rú   rƒ  r«  rÌ  rÞ   rH  r¹  r  Úis_unreachable_mapÚunreachable_elser  r  )r+  r¦  r_  rY  rM  Úif_mapr  s          r   Úvisit_if_stmtzTypeChecker.visit_if_stmt5  s]  € ð �[‰[×&Ñ&°ÈÐ\]Ð&Ó^ñ 	-Ü˜AŸF™F A§F¡FÓ+ò D‘��1Ü# D×$5Ñ$5×$<Ñ$<¸QÓ$?Ó@�ä˜a¤Ô-Ø—H‘H×.Ñ.¨q°!Ô4à#'×#=Ñ#=¸aÓ#@Ñ �˜ä%7¸Ó%A�Ô"ð —[‘[×.Ñ.¸È1Ð.ÓMñ #Ø×&Ñ& v¸uÐ&ÔEØ—K‘K ”N÷#ð
 ×"Ñ" 8¸UÐ"ÕCð!Dð$ —‘×*Ñ*°EÈÐ*ÓJñ -Ø—;’;Ø—K‘K §¡Ô,÷-÷'	-ð 	-÷#ð #ú÷-ð -ú÷'	-ð 	-ús<   ŸB8FÃ%E/Ã<:FÄ6(E;ÅFÅ/E8Å4FÅ;F	Æ FÆFc                ó¼   — t        |j                  g|j                  gd«      }|j                  |«       | j	                  ||j
                  |j                  ¬«       y)zType check a while statement.N)rö  )rr   r  r  rH  r  r  )r+  r¦  Úif_stmts      r   Úvisit_while_stmtzTypeChecker.visit_while_stmtP  sG   € ä˜!Ÿ&™&˜ A§F¡F 8¨TÓ2ˆØ×Ñ˜ÔØ×Ñ˜ !§+¡+¸a¿f¹fÐÕEr  c                óú  — | j                  |j                  |j                  |j                  «       t	        |j                  t
        «      r'| j                  j                  |j                  d«      }n%| j                  j                  |j                  «      }t        ||j                  «      \  }}|r^| j                  j                  |||j                  |«      \  }}t        ||«      s�| j                  j                  |j                  |«       nZt        |j                  |j                  |j                  «      }|j                  |«       | j!                  |j                  |d¬«       | j#                  |«       y)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¸   rH  Ú incompatible_operator_assignmentrƒ   rH  rµ  r¹  )r+  r¦  r¢  Úinplacer�  râ  r  r  s           r   Úvisit_operator_assignment_stmtz*TypeChecker.visit_operator_assignment_stmtV  s  € à×;Ñ;¸A¿H¹HÀaÇhÁhÐPQ×PTÑPTÔUÜ�a—h‘h¤
Ô+ð ×+Ñ+×=Ñ=¸a¿h¹hÈÓM‰Kà×+Ñ+×2Ñ2°1·8±8Ó<ˆKÜ:¸;ÈÏÉÓM‰ˆ�Ùà!×.Ñ.×7Ñ7¸ÀÈQÏXÉXÐWXÓY‰NˆK˜Ü˜k¨;Ô7Ø—‘×9Ñ9¸!¿$¹$ÀÕBô ˜!Ÿ$™$ §¡¨!¯(©(Ó3ˆDØ�M‰M˜!ÔØ×!Ñ!¨¯©¸$ÐRVÐ!ÔWØ×Ñ˜Õr  c                óÎ  — | j                   j                  |j                  «       t        |j                  t        «      rBt        |j                  j                  «      dkD  r | j                  t        j                  |«       | j                  |j                  «      \  }}|j                  �)| j                   j                  ||j                  d d¬«       | j                  |«       y )Nr   F)Úsuppress_unreachable_errors)rƒ  r«  r  rÌ  r•   rý  rÐ  r°  r   ÚMALFORMED_ASSERTr  rH  Úanalyze_cond_branchr  )r+  r¦  Útrue_mapr  s       r   Úvisit_assert_stmtzTypeChecker.visit_assert_stmtl  s¬   € Ø×Ñ× Ñ  §¡Ô(ä�a—f‘fœiÔ(¬S°·±·±Ó->ÀÒ-BØ�I‰IÔ&×7Ñ7¸Ô;ð "×7Ñ7¸¿¹Ó?Ñˆ�(Ø�5‰5ÐØ×Ñ×1Ñ1Ø˜!Ÿ%™% À5ð 2ô ð 	×Ñ˜8Õ$r  c                óÜ   — |j                   r| j                  |j                   |«       |j                  r| j                  |j                  |d¬«       | j                  j	                  «        y)zType check a raise statement.T)ÚoptionalN)r  Útype_check_raiseÚ	from_exprrI  rú  r  s     r   Úvisit_raise_stmtzTypeChecker.visit_raise_stmtz  sM   € à�6Š6Ø×!Ñ! !§&¡&¨!Ô,Ø�;Š;Ø×!Ñ! !§+¡+¨q¸4Ð!Ô@Ø�‰×ÑÕ!r  c                ó   — t        | j                  j                  |«      «      }t        |t        «      r| j
                  j                  ||«       y | j                  d«      }|t        |«      g}|r|j                  t        «       «       | j                  |t        j                  |«      |t        j                  «       t        |t         «      r| j                  j#                  |g g |«       t        |t$        «      r|j&                  j(                  t*        v sCt        |t,        «      ret        |j.                  t0        «      rJ|j.                  j(                  dk(  r0| j3                  t        j                  j5                  d«      |«       y y y y )Núbuiltins.BaseExceptionúbuiltins.NotImplementedz%; did you mean "NotImplementedError"?)rú   rƒ  r«  rÌ  rÞ   rH  r¹  r¯  rî   r8  rã   r±  rõ   Ú
make_unionr   ÚINVALID_EXCEPTIONrà   r&  rá   r­  r   rÙ   ra   r?  r‰   r°  rØ  )r+  r_  r¦  rK  rH  r>  Úexpected_type_itemss          r   rL  zTypeChecker.type_check_raise‚  s@  € Ü˜d×/Ñ/×6Ñ6°qÓ9Ó:ˆÜ�cœ;Ô'Ø�H‰H×&Ñ& s¨AÔ.Øà—?‘?Ð#;Ó<ˆØ'¬°(Ó);Ð<ÐÙð  ×&Ñ&¤x£zÔ2à×ÑØ”×%Ñ%Ð&9Ó:¸AÔ?O×?aÑ?aô	
ô �cœ<Ô(à×Ñ×(Ñ(¨¨b°"°aÔ8ä�sœHÔ%¨#¯(©(×*;Ñ*;Ô?YÑ*YÜ�qœ(Ô#Ü˜1Ÿ8™8¤WÔ-Ø—‘×!Ñ!Ð%>Ò>à�I‰IÜ ×2Ñ2×FÑFØ;óð õ	ð ?ð .ð $r  c                ó&  — d}| j                   j                  dd¬«      5  | j                  |t        |j                  «      ¬«       |j                  rNt        «       }t        | j                  j                  |«      5  | j                  |j                  «       ddd«       ddd«       |j                  r¹| j                   j                  «       }|€J ‚| j                   j                  «       sDt        | j                  j                  |«      5  | j                  |j                  «       ddd«       | j                  j                  |«       |sd| j                   j                  d   _        yyy# 1 sw Y   Œ×xY w# 1 sw Y   ŒÛxY w# 1 sw Y   Œ_xY w)zType check a try statement.NFr   r3  )Ú	try_framerŒ  )rI  r  Úvisit_try_without_finallyr.  Úfinally_bodyr4   r5   rH  rG  r«  r«  r¥  r
  rÒ  r©  )r+  r¦  r  Úpreviously_suppresseds       r   Úvisit_try_stmtzTypeChecker.visit_try_stmt£  sF  € ð ˆð
 �[‰[×&Ñ&°ÀAÐ&ÓFñ 	0ð ×*Ñ*¨1¼¸Q¿^¹^Ó8LÐ*ÔMØ�~Š~ä6Ó8�Ü*¨4¯8©8¯?©?¸KÓHñ 0Ø—K‘K §¡Ô/÷0÷	0ð �>Š>Ø$(§K¡K×$QÑ$QÓ$SÐ!ð Ð*Ð*Ð*Ø—;‘;×-Ñ-Ô/Ü*¨4¯8©8¯?©?¸KÓHñ 0Ø—K‘K §¡Ô/÷0à�H‰H×/Ñ/°Ô<á(ð HM�—‘×"Ñ" 2Ñ&ÕDð )ð' ÷0ð 0ú÷	0ð 	0ú÷<0ð 0ús0    AE;Á=E/ÂE;ÄFÅ/E8	Å4E;Å;FÆFc                óè  — | j                   j                  dd|¬«      5  | j                   j                  ddd¬«      5  | j                   j                  ddd¬«      5  | j                  |j                  «       ddd«       t	        t        |j                  «      «      D �]f  }| j                   j                  dd¬«      5  |j                  |   }|rV| j                  ||j                  «      }|j                  |   }|r)d|_        | j                  || j                  ||«      «       | j                  |j                  |   «       |j                  |   }|r§|j                  }t        |j                   t"        «      rPt%        |¬	«      }||j                   _        | j(                  j*                  r| j                   j-                  |||«       | j(                  j*                  s| j                   j/                  |«       ddd«       �Œi 	 ddd«       |j0                  r| j                  |j0                  «       ddd«       y# 1 sw Y   �ŒËxY w# 1 sw Y   �ŒºxY w# 1 sw Y   ŒSxY w# 1 sw Y   yxY w)
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ù  r2  rV  Tr1  Né   r3  ©r�  )rI  r  r«  r  r�  rý  ÚhandlersrÓ  Úcheck_except_handler_testÚis_starÚvarsr¶  rµ  r%  rÊ  rÌ  r  r™   rÞ   r­  rZ  r×  r°  Úcleanser  )	r+  r¦  rV  r×  rH  rM  r&  r�  rš  s	            r   rW  z%TypeChecker.visit_try_without_finallyÒ  sü  € ð �[‰[×&Ñ&°ÀAÐQZÐ&Ó[ñ !	)à—‘×*Ñ*°EÈTÐ`aÐ*Óbñ 9à—[‘[×.Ñ.¸ÈAÐY]Ð.Ó^ñ (Ø—K‘K §¡Ô'÷(äœs 1§:¡:›Ó/ó 9�AØŸ™×2Ñ2¸DÈqÐ2ÓQñ 9ØŸg™g a™j˜ÙØ $× >Ñ >¸sÀAÇIÁIÓ N˜AØ"#§&¡&¨¡)˜CÙ"ð 7; Ô 3Ø $× 5Ñ 5°c¸4¿>¹>È!ÈSÓ;QÔ RØŸ™ A§J¡J¨q¡MÔ2ØŸf™f Q™i˜Ùð &)§X¡X˜FÜ)¨#¯(©(´CÔ8Ü+6¸fÔ+E Ø08 §¡¤Ø#'§<¡<×#BÒ#Bà$(§K¡K×$;Ñ$;¸CÀÈ8Ô$TØ#'§<¡<×#BÒ#BØ $§¡× 3Ñ 3°CÔ 8÷19ñ 9ñ9÷	9ð< �{Š{Ø—‘˜AŸK™KÔ(÷C!	)ð !	)÷(ñ (ú÷9ñ 9ú÷9ð 9ú÷!	)ð !	)úsT   ŸI(¾IÁIÁ9AIÃ D>I	Ç>IÈ
/I(ÉIÉIÉIÉIÉI%	É!I(É(I1c                óx  — | j                   j                  |«      }g }| j                  ||«      }t        |«      D �]a  }t	        |t
        «      r|j                  |«       Œ&t	        |t        «      rŒ7t	        |t        «      rl|j                  d   }|j                  «       s3| j                  t        j                  |«       | j                  |«      c S t        |j!                  «       «      }nPt	        |t"        «      r|j$                  }n3| j                  t        j                  |«       | j                  |«      c S t'        || j)                  d«      «      s3| j                  t        j                  |«       | j                  |«      c S |j                  |«       �Œd |r�g }	|D ]w  }t+        || j)                  d«      «      rI| j                  t        j,                  |«       |	j                  t        t.        j0                  «      «       Œg|	j                  |«       Œy | j3                  |	«      S t5        |«      S )z,Type check an exception handler test clause.r   rP  úbuiltins.BaseExceptionGroup)rƒ  r«  Úget_types_from_except_handlerrû   rÌ  rÛ   r8  rô   rà   rÐ  rr  r°  r   ÚINVALID_EXCEPTION_TYPEÚdefault_exception_typer*   Úget_instance_typerî   rØ  r¸   r¯  r¶   ÚINVALID_EXCEPTION_GROUPrì   rŒ  Úwrap_exception_grouprÏ   )
r+  rù  r`  rH  Ú	all_typesÚ
test_typesÚttyperØ  r>  Únew_all_typess
             r   r_  z%TypeChecker.check_except_handler_test   sÏ  € à×Ñ×&Ñ& qÓ)ˆà "ˆ	Ø×7Ñ7¸¸QÓ?ˆ
ä% jÓ1ó 	'ˆEÜ˜%¤Ô)Ø× Ñ  Ô'ØÜ˜%¤Ô1Øä˜%¤Ô.Ø—{‘{ 1‘~�Ø×'Ñ'Ô)Ø—I‘IÔ.×EÑEÀqÔIØ×6Ñ6°wÓ?Ò?Ü)¨$×*@Ñ*@Ó*BÓC‘Ü˜E¤8Ô,Ø Ÿ:™:‘à—	‘	Ô*×AÑAÀ1ÔEØ×2Ñ2°7Ó;Ò;ä˜h¨¯©Ð8PÓ(QÔRØ—	‘	Ô*×AÑAÀ1ÔEØ×2Ñ2°7Ó;Ò;à×Ñ˜XÖ&ð/	'ñ2 Ø(*ˆMØ ò .�Ü$ S¨$¯/©/Ð:WÓ*XÔYØ—I‘IÔ.×FÑFÈÔJØ!×(Ñ(¬´×1EÑ1EÓ)FÕGà!×(Ñ(¨Õ-ð.ð ×,Ñ,¨]Ó;Ð;Ü$ YÓ/Ð/r  c                ób   — t        t        j                  «      }|r| j                  d|g«      S |S )z:Exception type to return in case of a previous type error.úbuiltins.ExceptionGroup)rÛ   rì   rŒ  r®  )r+  r`  r<  s      r   rg  z"TypeChecker.default_exception_type+  s0   € äœ9×/Ñ/Ó0ˆÙØ×*Ñ*Ð+DÀxÀjÓQÐQØˆr  c                ó~   — t        |«      }t        || j                  d«      «      rd}nd}| j                  ||g«      S )zDTransform except* variable type into an appropriate exception group.zbuiltins.Exceptionrp  rd  )rÏ   r¸   r¯  r®  )r+  rÓ  r÷  r¹  s       r   rj  z TypeChecker.wrap_exception_group2  s?   € ä# EÓ*ˆÜ�c˜4Ÿ?™?Ð+?Ó@ÔAØ,‰Dà0ˆDØ×&Ñ& t¨c¨UÓ3Ð3r  c                óØ  — t        |«      }t        |t        «      r8t        |j                  «      }t        |t
        «      r|j                  «       S |gS t        |d«      r<t        |j                  d   f«      }t        |t
        «      r|j                  «       S |gS t        |t
        «      r7|j                  «       D ��cg c]  }| j                  ||«      D ]  }|‘Œ Œ c}}S |gS c c}}w )z?Helper for check_except_handler_test to retrieve handler types.r7  r   )
rú   rÌ  rç   rÏ   rÐ  rõ   rl  rÿ   r�  re  )r+  rH  rù  Úmerged_typerØ  Ú	union_typs         r   re  z)TypeChecker.get_types_from_except_handler;  så   € ä˜cÓ"ˆÜ�cœ9Ô%Ü/°·	±	Ó:ˆKÜ˜+¤yÔ1Ø"×1Ñ1Ó3Ð3Ø�=Ð Ü˜sÐ$4Ô5ä/°·±¸!±°Ó?ˆKÜ˜+¤yÔ1Ø"×1Ñ1Ó3Ð3Ø�=Ð Ü˜œYÔ'ð  ×.Ñ.Ó0÷àØ!%×!CÑ!CÀDÈ!Ó!Lòð ò ðØóð ð �5ˆLùós   Â? C&c                ó  ‡ ‡‡— ‰j                   r‰ j                  ‰j                  «      \  }Šn‰ j                  ‰j                  «      \  }Š‰‰_        |‰_        ‰ j                  ‰j                  ‰j                  ˆˆˆ fd„¬«       y)zType check a for statement.c                 óX   •— ‰j                  ‰j                  ‰ ‰j                  d u ‰«      S r'  )Úanalyze_index_variablesrõ  Ú
index_type)rB  r¦  r+  s   €€€r   r_  z,TypeChecker.visit_for_stmt.<locals>.<lambda>^  s(   ø€  $×">Ñ">Ø—‘˜ A§L¡L°DÐ$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_typerB  s   `` @r   Úvisit_for_stmtzTypeChecker.visit_for_stmtR  sr   ú€ à�:Š:Ø'+×'LÑ'LÈQÏVÉVÓ'TÑ$ˆM™9à'+×'FÑ'FÀqÇvÁvÓ'NÑ$ˆM˜9Ø(ˆÔØ#0ˆÔ à×ÑØ�F‰FØ�K‰Kõð 	õ 	
r  c                óæ   — | j                   }|j                  |«      }|j                  d|g g |«      d   }|j                  d|g g |«      d   }|j                  ||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Ú	awaitablerB  s          r   rz  z,TypeChecker.analyze_async_iterable_item_typec  s„   € à× Ñ ˆØ—;‘;˜tÓ$ˆØ×1Ñ1°+¸xÈÈRÐQUÓVÐWXÑYˆØ×2Ñ2°;ÀÈ"ÈbÐRVÓWÐXYÑZˆ	Ø×-Ñ-Ø�tÔ-×MÑMó
ˆ	ð ˜Ð"Ð"r  c                ó–   — | j                  | j                  j                  |«      |¬«      \  }}| 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_typen  s^   € à!×OÑOØ×Ñ×$Ñ$ TÓ*°Dð Pó 
Ñˆ�(ð ×5Ñ5°dÓ;ˆÙØ˜XÐ%Ð%Ø˜Ð!Ð!r  c                ó2  — | j                   }t        |«      }|j                  d|g g |«      d   }t        |t        «      r=|j
                  j                  j                  dk(  r|t        |«      j                  d   fS |j                  d|g g |«      d   }||fS )zBAnalyse iterable type and return iterator and iterator item types.Ú__iter__r   r7  Ú__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_expressionx  s§   € ð × Ñ ˆä" 4Ó(ˆØ×1Ñ1°*¸hÈÈBÐPWÓXÐYZÑ[ˆô �x¤Ô+Ø×)Ñ)×.Ñ.×7Ñ7Ð;KÒKàœ^¨HÓ5×:Ñ:¸1Ñ=Ð=Ð=ð ×5Ñ5°jÀ(ÈBÐPRÐT[Ó\Ð]^Ñ_ˆHØ˜XÐ%Ð%r  c                óä  — t        |t        «      ràt        |j                  t        «      rÆ|j                  j                  dk(  r­dt        |j                  «      cxk  rdk  r�n yt        d„ |j                  D «       «      rpd}d}|j                  D ]W  }t        | j                  |«      «      }t        |t        «      sŒ.|j                  j                  t        v sŒK|€|}ŒP||k7  sŒVd}ŒY |r|r|S y)z¸Try 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(  –— Œ y ­wr'  )rL   )rÞ  rÒ  s     r   rß  z<TypeChecker.analyze_range_native_int_type.<locals>.<genexpr>—  s   è ø€ Ò?¨�DœG•OÑ?ùs   ‚NTF)rÌ  ra   r?  r‰   r   rý  r�  rk  r   rú   r¸  rá   r­  rØ   )r+  r  Ú
native_intrà  r÷  Úargts         r   rŒ  z)TypeChecker.analyze_range_native_int_type‹  sÓ   € ô �tœXÔ&Ü˜4Ÿ;™;¬Ô0Ø—‘×$Ñ$Ð(8Ò8Ø”S˜Ÿ™“^Ô( qÔ(ð ô Ñ?°·±Ô?Ô?à&*ˆJØˆBØ—y‘yò #�Ü& t×'7Ñ'7¸Ó'<Ó=�Ü˜d¤HÕ-°$·)±)×2DÑ2DÔH^Ò2^Ø!Ð)Ø%)™
Ø Ó+Ø"™ð#ñ ‘jØ!Ð!Ør  c                ó  — t        |«      }t        |t        «      rMg }|j                  D ]'  }| j	                  |«      }|sŒ|j                  |«       Œ) t        j                  |«      S t        |t        «      rk|j                  j                  d«      rP| j                  d«      j                  }t        ||«      }t        |j                  «      dk(  sJ ‚|j                  d   S t        |t        «      r| j	                  t        |«      «      S y)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  rR  rá   r­  râ  r¯  r<   rý  r�  rç   rÕ   )r+  rH  rÓ  rØ  Úc_typerÄ  Úsuper_instances          r   r—  z'TypeChecker.analyze_container_item_type¦  sì   € ô
 ˜cÓ"ˆÜ�cœ9Ô%Ø "ˆEØŸ	™	ò )�Ø×9Ñ9¸$Ó?�ÚØ—L‘L Õ(ð)ô ×'Ñ'¨Ó.Ð.Ü�cœ8Ô$¨¯©×):Ñ):Ð;MÔ)NØŸ™Ð(:Ó;×@Ñ@ˆIÜ6°s¸IÓFˆNÜ�~×*Ñ*Ó+¨qÒ0Ð0Ð0Ø!×&Ñ& qÑ)Ð)Ü�cœ9Ô%Ø×3Ñ3´NÀ3Ó4GÓHÐHØr  c                óJ   — | j                  || j                  ||«      |«       y)z>Type check or infer for loop or list comprehension index vars.N)rµ  r%  )r+  rõ  rB  rß  rï  s        r   rw  z#TypeChecker.analyze_index_variables¼  s"   € ð 	×Ñ˜e T§^¡^°I¸wÓ%GÐIZÕ[r  c                ó¦  — t        |j                  t        «      r­|j                  }t        |j                  d«      }|j
                  |_        |j                  |_        t        ||j                  gt        j                  gd g«      }|j
                  |_        |j                  |_        | j                  j                  |d¬«       y |j                  j                  | j                  «       t        |j                  «      D ]M  }t        |t        «      sŒ| j                  j!                  |t#        |j$                  ¬«      t'        |«      «       ŒO y )NÚ__delitem__Tr  r]  )rÌ  r  rw   r}   r¹  rŽ  r   ra   rõ  r   rL   rƒ  r«  Úflattenr   rI  r°  rÞ   rÊ  r   )r+  r¦  r_  ÚmÚcÚelts         r   Úvisit_del_stmtzTypeChecker.visit_del_stmtÂ  sê   € Ü�a—f‘fœiÔ(Ø—‘ˆAÜ˜1Ÿ6™6 =Ó1ˆAØ—V‘VˆAŒFØ—x‘xˆAŒHÜ˜˜QŸW™W˜I¬¯© ¸¸Ó?ˆAØ—V‘VˆAŒFØ—x‘xˆAŒHØ×Ñ×$Ñ$ Q¸$Ð$Õ?à�F‰F�M‰M˜$×+Ñ+Ô,Ü˜qŸv™v“ò �Ü˜c¤8Õ,Ø—K‘K×+Ñ+Øœ[°·±Ô9¼?È3Ó;Oõñr  c                óÒ   — t        d„ |j                  D «       «      r:t        t        j                  «      |j
                  _        d|j
                  _        y | j                  |«       y )Nc              3  ó4   K  — | ]  }t        |d «      –— Œ y­wrÛ  rÜ  rÝ  s     r   rß  z.TypeChecker.visit_decorator.<locals>.<genexpr>Õ  s   è ø€ ÒSÀÔ! !Ð%;×<ÑSùrà  T)	rã  rä  rÛ   rì   r*  r&  r­  rË  r(  ©r+  r_  s     r   r%  zTypeChecker.visit_decoratorÔ  sF   € ÜÑSÀaÇlÁlÔSÔSÜ ¤×!7Ñ!7Ó8ˆA�E‰EŒJØ!ˆA�E‰EŒNØØ×"Ñ" 1Õ%r  c           	     óð  — |j                   }|j                  rÈ| j                  |«      }t        |t        «      sJ ‚t        |j                  d«      s�|j                  }|j                  }| j                  ||«      }| j                  ||«      }	|r| j                  |«      }
n| j                  ||«      }
| j                  d||	|
|g«      }|j                  |¬«      |_        | j                  s| j!                  |«       | j"                  s|j                   j$                  ry| j&                  j)                  |j                   «      5  | j+                  «       5  | j-                  |j                   |j                   j.                  |¬«       d d d «       d d d «       | j                  |j                   «      }d}t1        |r|j2                  dd  n|j2                  «      D �]V  }t5        |d«      rŒt5        |t6        «      r#|s | j9                  t:        j<                  |«       ŒDd}| j>                  jA                  |«      }| jC                  ||¬«      }d }t        |tD        «      r|jF                  xs d }d }|€lt        |tH        «      r\| jK                  |jL                  «      rA| jO                  |jL                  «      }| j>                  jQ                  ||j.                  «      }| jS                  |j                   ||«       | j>                  jU                  ||gtV        jX                  g|||¬	«      \  }}�ŒY |r| j[                  ||j                   «       | j]                  ||j                   «       t_        ||j                   «      }t        |t        «      r||_0        ||jb                  _        d|jb                  _2        |j                   jf                  rtt        |t        «      rSti        |jj                  D �cg c]  }|jm                  «       sŒ|‘Œ c}«      dkD  r| jn                  j9                  d
|«       | jq                  |«       |s|ry |j                   jr                  r­|jt                  s¡| jw                  |«      }|j                   jx                  r^|s\|�Z|j                   jr                  jz                  s:| jn                  j}                  |j                   j.                  |j                   «       | j                  |j                   |«       |j                   jr                  rm|j                   j.                  dv rU|j                  rIt        t�        |j                  «      t‚        t„        f«      s | j9                  t:        j†                  |«       |j                   jˆ                  r.t        |t‚        «      r| j‹                  |j                   |«       y y y # 1 sw Y   �ŒRxY w# 1 sw Y   �ŒWxY wc c}w )Nr}  ©r"  rÉ  Frˆ  zabc.abstractmethodTr  )r  ra  zToo many arguments for propertyr±  )FrÓ  Úis_awaitable_coroutinerË   rÌ  rÝ   rÿ   r"  r~  r‹  r‘  r”  r–  r®  ro  r­  rv  r.  rw  r/  rM  rÒ  r0  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«   r-  r&  rË  rÑ  rý  r   Úis_requiredrH  Ú$check_incompatible_property_overrider4  r�  r5  r6  r7  r8  r9  rú   rà   rÛ   ÚBAD_CONSTRUCTOR_TYPEr˜  r™  )r+  r_  rË  r  r  rH  rM  rŸ  ÚtyÚtcÚtrr"  r*  Únon_trivial_decoratorrµ  r,  r-  r   ra  Út2ÚkrD  s                         r   r(  z!TypeChecker.visit_decorator_innerÛ  s²  € ð �v‰vˆØ×&Ò&Ø×$Ñ$ TÓ*ˆCÜ˜c¤<Ô0Ð0Ð0ô % S§\¡\Ð3NÔOØ—L‘L�Ø×%Ñ%�Ø×2Ñ2°1°aÓ8�Ø×4Ñ4°Q¸Ó:�ÙØ×7Ñ7¸Ó:‘Bà×7Ñ7¸¸1Ó=�BØ×2Ñ2Ð3NÐQSÐUWÐY[Ð]^ÐP_Ó`�Ø×-Ñ-°xÐ-Ó@�”	ð ×(Ò(Ø×%Ñ% dÔ+à×&Ò&¨!¯&©&×*BÒ*BØ—‘×+Ñ+¨A¯F©FÓ3ñ X°T×5TÑ5TÓ5Vñ XØ×$Ñ$ Q§V¡V°!·&±&·+±+È;Ð$ÔW÷X÷ Xð
 ×&Ñ& q§v¡vÓ.ˆØ %Ðä©o˜!Ÿ,™, q rÑ*À1Ç<Á<ÓPó 	ˆAÜ! !Ð%9Ô:ð Ü! !¤^Ô4Ù"Ø—I‘IÔ.×JÑJÈAÔNØØ$(Ð!Ø×#Ñ#×*Ñ*¨1Ó-ˆCØ—>‘> #¨q�>Ó1ˆDØˆHÜ˜!œWÔ%ØŸ:™:Ò-¨�ð (,ˆKØÐ¤J¨q´*Ô$=À$Ç-Á-ÐPQ×PVÑPVÔBWØ"×.Ñ.¨q¯v©vÓ6�Ø×,Ñ,×<Ñ<¸[È!Ï&É&ÓQ�Ø×,Ñ,¨Q¯V©V°S¸!Ô<Ø×'Ñ'×2Ñ2Ø�d�VœeŸm™m˜_¨a¸xÐU`ð 3ó ‰GˆC’ð-	ñ2 !Ø×.Ñ.¨s°A·F±FÔ;Ø×*Ñ*¨3°·±Ô7Ü  Q§V¡VÓ,ˆÜ�cœ<Ô(ØˆCŒNØˆ�‰Œ
Øˆ�‰ŒØ�6‰6×ÒÜ˜#œ|Ô,Ü 3§=¡=ÖD˜a°A·M±MµOšÒDÓEÈÒIØ—H‘H—M‘MÐ"CÀQÔGØ×5Ñ5°aÔ8á™/ØØ�6‰6�;Š;˜qŸ}š}Ø(,×(BÑ(BÀ1Ó(EÐ%à—‘×+Ò+Ù1Ø-Ð9ð Ÿ™Ÿ™×3Ò3à—‘×.Ñ.¨q¯v©v¯{©{¸A¿F¹FÔCØ×2Ñ2°1·6±6Ð;TÔUà�6‰6�;Š;˜1Ÿ6™6Ÿ;™;Ð*AÑAØ�vŠvœj¬¸¿¹Ó)@Ä<ÔQXÐBYÔZØ—	‘	Ô*×?Ñ?ÀÔCà�6‰6×Ò¤:¨c´<Ô#@à×(Ñ(¨¯©°Õ5ð $AÐ÷EXñ Xú÷ Xñ XüòV Es0   ÅW&Å3WÆ	W&Ï8W3ÐW3×W#	×W&×&W0c                óÜ   — | j                   j                  rVt        |j                  «      r@t	        |«      r4| j
                  s'| j                  j                  |j                  |«       y y y y y r'  )	rZ  Údisallow_untyped_decoratorsÚis_typed_callabler­  Úis_untyped_decoratorrm  rH  Ú typed_function_untyped_decoratorrÊ  )r+  rÓ  Údec_typeÚdec_exprs       r   r©  z'TypeChecker.check_for_untyped_decorator<  sZ   € ð �L‰L×4Ò4Ü! $§)¡)Ô,Ü$ XÔ.Ø×.Ò.à�H‰H×5Ñ5°d·i±iÀÕJð /ð /ð -ð 5r  c                ó6  — |j                   j                  �s|j                  j                  rë|j                  j                  }|j                  j                  j
                  dd  D ]®  }|j                  j                  |«      }|sŒ!t        |j                  t        «      sŒ<|j                  j                  sŒSt        t        |j                  j                  d   «      j                   j                  sŒ�| j                  t         j"                  |«       Œ° y y y ©Nrˆ  r   )r&  r'  rÓ  r4  rÊ  r¶  ri  r¬  rÌ  r  r„   rÑ  r   rf   rÐ  r°  r   Ú'READ_ONLY_PROPERTY_OVERRIDES_READ_WRITE)r+  r_  rÊ  r¹  rÀ  s        r   r¬  z0TypeChecker.check_incompatible_property_overrideG  sÁ   € Ø�u‰u×)Ó)¨a¯f©f¯kªkØ—6‘6—;‘;ˆDØŸ™Ÿ™Ÿ™¨¨Ð+ò 	[�Ø ŸJ™JŸN™N¨4Ó0�	Ù Øä˜yŸ~™~Ô/@ÕAØ!Ÿ™×2Ó2ÜœY¨	¯©×(<Ñ(<¸QÑ(?Ó@×DÑD×YÓYà—I‘IÔ.×VÑVÐXYÕZñ	[ð /:Ð)r  c                óŒ  — d}t        |j                  |j                  «      D ]´  \  }}|j                  r | j	                  |||j
                  d u «      }n| j                  |||j
                  d u «      }t        |«      }t        |dd«      rŒjt        |dd«      s<t        |t        «      sŒˆ|j                  j                  dk(  sŒ¢t        j                  sŒ³d}Œ¶ |rB| j                  j!                  dd¬«      5  | j#                  |j$                  «       d d d «       y | j#                  |j$                  «       y # 1 sw Y   y xY w)NFúbuiltins.boolT)rù  rV  )rò  r  r"  ry  Úcheck_async_with_itemr»  Úcheck_with_itemrú   rþ   rÌ  rá   r­  r   r°   rž  rI  r  r«  r  )r+  r¦  Úexceptions_maybe_suppressedr  r"  Úexit_ret_types         r   Úvisit_with_stmtzTypeChecker.visit_with_stmtU  s!  € Ø&+Ð#Ü §¡¨¯©Ó1ò 	3‰LˆD�&Ø�zŠzØ $× :Ñ :¸4ÀÈ×IZÑIZÐ^bÐIbÓ c‘à $× 4Ñ 4°T¸6À1×CTÑCTÐX\ÐC\Ó ]�ô ,¨MÓ:ˆMÜ˜}¨o¸uÔEØä˜}¨o¸tÔDÜ˜=¬(Õ3Ø!×&Ñ&×/Ñ/°?ÓBÜ×)Ó)ð /3Ñ+ð1	3ñ4 'ð —‘×*Ñ*°DÀDÐ*ÓIñ $Ø—‘˜AŸF™FÔ#÷$ð $ð �K‰K˜Ÿ™Õ÷$ð $ús   Ã9D:Ä:Ec                óÚ   — | j                   j                  r| j                  s| j                  ry t        j
                  j                  |«      r| j                  j                  ||«       y y r'  )	rZ  Údisallow_any_decoratedrn  rm  r|  r}  Úhas_any_typerH  Úuntyped_decorated_function)r+  rH  rÓ  s      r   rª  z)TypeChecker.check_untyped_after_decoratorz  sK   € Ø�|‰|×2Ò2°d·l²lÀd×F`ÒF`Øä�>‰>×&Ñ& sÔ+Ø�H‰H×/Ñ/°°TÕ:ð ,r  c                óè  — | j                   }|j                  |«      }|j                  d|g g |«      d   }|j                  ||t        j
                  «      }|r#| j                  || j                  ||«      |«       | j                  t        t        j                  «      |«      }|j                  d||gdz  t        j                  gdz  |«      \  }}	|j                  ||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  r"  rß  r†  rR  Úobjr÷  r„  r  s
             r   rÀ  z!TypeChecker.check_async_with_item�  sé   € ð × Ñ ˆØ�k‰k˜$ÓˆØ×,Ñ,¨\¸3ÀÀBÈÓMÈaÑPˆØ×'Ñ'Ø�Ô'×OÑOó
ˆñ Ø×!Ñ! &¨$¯.©.¸¸dÓ*CÐEVÔWØ�n‰nœW¤Y×%;Ñ%;Ó<¸dÓCˆØ×/Ñ/Ø˜˜s˜e a™i¬%¯-©-¨¸1Ñ)<¸dó
‰ˆˆQð ×(Ñ(Ø�Ô'×NÑNó
ð 	
r  c                óh  — | j                   }|j                  |«      }|j                  d|g g |«      d   }|r#| j                  || j	                  ||«      |«       | j	                  t        t        j                  «      |«      }|j                  d||gdz  t        j                  gdz  |«      \  }}	|S )Nr:  r   rA  r  )
rƒ  r«  rƒ  rµ  r%  rÛ   rì   r*  r   rL   rÎ  s
             r   rÁ  zTypeChecker.check_with_item”  s­   € ð × Ñ ˆØ�k‰k˜$ÓˆØ×,Ñ,¨[¸#¸rÀ2ÀtÓLÈQÑOˆÙØ×!Ñ! &¨$¯.©.¸¸dÓ*CÐEVÔWØ�n‰nœW¤Y×%;Ñ%;Ó<¸dÓCˆØ×/Ñ/Ø˜˜c˜U Q™Y¬¯©¨¸!Ñ(;¸Tó
‰ˆˆQð ˆ
r  c                ó8   — | j                   j                  «        y r'  )rI  Úhandle_breakr  s     r   Úvisit_break_stmtzTypeChecker.visit_break_stmt¢  s   € Ø�‰× Ñ Õ"r  c                ó8   — | j                   j                  «        y r'  )rI  Úhandle_continuer  s     r   Úvisit_continue_stmtzTypeChecker.visit_continue_stmt¥  s   € Ø�‰×#Ñ#Ô%Ør  c           
     óR	  — t        |j                  «      }| j                  ||«      }| j                  j	                  dd¬«      5  t        | j                  j                  |j                  «      «      }t        |t        «      r| j                  j                  ||«       |j                  D �cg c]  }| j                  j                  ||«      ‘Œ  }}|D �cg c]  }|j                  ‘Œ }}| j                  |«      }	|j                  t!        «       i}
t#        |j                  |j$                  |j&                  «      D �]µ  \  }}}| j                  j)                  ||«      }| j                  j                  ||«      }| j                  j	                  dd¬«      5  t+        ||j,                  |j.                  «      \  }}||v r||   ||<   ||v r||   ||<   | j1                  |«      }| j1                  |«      }| j3                  |j                  |	«       | j5                  |d¬«       |r;|j7                  «       D ](  \  }}| j5                  | j9                  ||«      d¬«       Œ* | j5                  |j                  d¬«       |��@| j                  j	                  dd¬«      5  t        | j                  j                  |«      «      }t        |t        «      r| j                  j                  ||«       | j;                  |«      \  }}t=        ||«      }t        |t>        «      ru|j@                  xs |jB                  }t        |tD        «      rK||fD ]D  }tG        |«      D ]4  }t        |tD        «      r|jH                  |jH                  k(  sŒ-||   ||<   Œ6 ŒF | j5                  |d¬«       | j                  |«       d d d «       n| j                  |«       d d d «       | j5                  d¬«       |}
�Œ¸ tK        |
«      s=| jL                  s1|
jO                  «       D ]  }| j                  jQ                  ||«       Œ  | j                  j	                  dd¬«      5  	 d d d «       d d d «       y c c}w c c}w # 1 sw Y   Œ«xY w# 1 sw Y   Œ¯xY w# 1 sw Y   Œ4xY w# 1 sw Y   y xY w)NFr   r3  Tr  r4  r  ))Úcollapse_walrusÚsubjectÚ_make_named_statement_for_matchrI  r  rú   rƒ  r«  rÌ  rÞ   rH  r¹  ÚpatternsrL  ÚcapturesÚ#infer_variable_types_from_type_mapsrô   rò  ÚguardsÚbodiesÚnarrow_type_from_binderÚconditional_types_to_typemapsr­  Ú	rest_typeÚpropagate_up_typemap_infoÚ"check_and_remove_capture_conflictsr  rÐ  Ú_get_recursive_sub_patterns_mapr  Úor_conditional_mapsr¤   ÚpatternrÊ  r   r¢  r   r6  rm  r  Ú"match_statement_inexhaustive_match)r+  r¦  Úunwrapped_subjectÚnamed_subjectÚsubject_typeÚpÚpattern_typesrM  Ú	type_mapsÚinferred_typesÚunmatched_typesÚgrY  Úcurrent_subject_typeÚpattern_typeÚpattern_mapr  r  rH  r€  Ú	guard_mapÚguard_else_mapÚcase_targetrâ  s                           r   Úvisit_match_stmtzTypeChecker.visit_match_stmt©  si  € ô ,¨A¯I©IÓ6ÐØ×<Ñ<¸QÐ@QÓRˆØ�[‰[×&Ñ&°ÀAÐ&ÓFñ P	Ü*¨4×+<Ñ+<×+CÑ+CÀAÇIÁIÓ+NÓOˆLä˜,¬Ô4Ø—‘×*Ñ*¨<¸Ô;ð TU×S]ÑS]Ö^Èa˜T×1Ñ1×8Ñ8¸¸LÕIÐ^ˆMÐ^Ø<IÖ'J°q¨¯
«
Ð'JˆIÐ'JØ!×EÑEÀiÓPˆNð )*¯	©	´?Ó3DÐ'EˆOÜ˜qŸz™z¨1¯8©8°Q·X±XÓ>ó 6+‘��1�aØ'+×'8Ñ'8×'PÑ'PØ! <ó(Ð$ð  $×3Ñ3×:Ñ:¸1Ð>RÓS�Ø—[‘[×.Ñ.¸È1Ð.ÓMñ /'Ü,IØ% |×'8Ñ'8¸,×:PÑ:Pó-Ñ)�K ð
 %¨Ñ3Ø9DÀ]Ñ9S˜Ð$5Ñ6Ø$¨Ñ0Ø6>¸}Ñ6M˜Ð!2Ñ3Ø"&×"@Ñ"@ÀÓ"M�KØ#×=Ñ=¸hÓG�HØ×;Ñ;¸L×<QÑ<QÐSaÔbØ×&Ñ& {ÀEÐ&ÔJÙ"Ø)4×):Ñ):Ó)<ò ™I˜D #Ø ×.Ñ.Ø $× DÑ DÀTÈ3Ó OØ05ð /õ ðð
 ×&Ñ& |×'<Ñ'<ÈeÐ&ÔTØ‘}Ø!Ÿ[™[×6Ñ6ÀÐTUÐ6ÓVñ +Ü!0°×1BÑ1B×1IÑ1IÈ!Ó1LÓ!M˜Bä)¨"¬kÔ:Ø $§¡× :Ñ :¸2¸qÔ Aà8<×8RÑ8RÐSTÓ8UÑ5˜I ~Ü':¸8À^Ó'T˜Hô  *¨!¬YÔ7Ø./¯i©iÒ.A¸1¿6¹6 Ü#-¨k¼8Ô#DØ5>ÀÐ4Iò %U¨Ü48¸³Nò )U¨Dä0:¸4ÄÔ0JØ48·M±MÀ[×EYÑEYÒ4Yà08ØFNÈtÁn¨H°]Ò,Cñ)Uð%Uð !×.Ñ.¨yÈ%Ð.ÔPØ ŸK™K¨œN÷/+ð +ð2 Ÿ™ Aœ÷_/'ð` ×"Ñ" 8¸UÐ"ÔCØ"*’ðm6+ôp & oÔ6¸t×?YÒ?YØ*×1Ñ1Ó3ò H�CØ—H‘H×?Ñ?ÀÀQÕGðHð
 —‘×*Ñ*°EÈÐ*ÓJñ Ø÷÷_P	ð P	ùò _ùÚ'J÷@+ð +ú÷-/'ð /'ú÷rð ú÷_P	ð P	úsw   ÁA)RÂ.#Q/ÃRÃQ4Ã*B1RÆDRÊ#DQ9	Î=RÏBRÑRÑRÑ/
RÑ9RÑ>RÒRÒ
RÒR	ÒRÒR&c                óÚ   — | j                   j                  |«      r|S |j                  �|j                  S | j                  d«      }t	        |«      }t        |«      }||_        ||_        |S )zEConstruct a fake NameExpr for inference if a match clause is complex.Úmatch)rI  Ú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   sf   € à�;‰;×'Ñ'¨Ô0àˆNØ�_‰_Ð(Ø—?‘?Ð"ð
 ×-Ñ-¨gÓ6ˆDÜ�D“	ˆAÜ$ T›NˆMØ!"ˆMÔØ+ˆAŒOØ Ð r  c                ó’  — i }t        |«      }t        |t        «      r©t        |t        «      r™t	        d„ |j
                  D «       «      r|S t        |j
                  «      t        |j
                  «      k(  sJ ‚t        |j
                  |j
                  «      D ]+  \  }}|||<   |j                  | j                  ||«      «       Œ- |S )Nc              3  ó<   K  — | ]  }t        |t        «      –— Œ y ­wr'  r?  rž  s     r   rß  z>TypeChecker._get_recursive_sub_patterns_map.<locals>.<genexpr>  s   è ø€ ÒE°$”:˜d¤H×-ÑEùr`  )
rú   rÌ  r•   rç   rã  rÐ  rý  rò  r�  rå  )r+  r  rH  Úsub_patterns_mapÚtyp_Ú	item_exprÚitem_typs          r   rå  z+TypeChecker._get_recursive_sub_patterns_map  sµ   € ð 46ÐÜ˜sÓ#ˆÜ�dœIÔ&¬:°d¼IÔ+FÜÑE¸$¿*¹*ÔEÔEð (Ð'ô �t—z‘z“?¤c¨$¯*©*£oÒ5Ð5Ð5Ü'*¨4¯:©:°t·z±zÓ'Bò cÑ#�	˜8Ø.6Ð  Ñ+Ø ×'Ñ'¨×(LÑ(LÈYÐX`Ó(aÕbðcð  Ðr  c                óÜ  — t        t        «      }|D ]]  }t        |«      rŒ|j                  «       D ]<  \  }}t	        |t
        «      sŒ|j                  }|€J ‚||   j                  ||f«       Œ> Œ_ i }|j                  «       D ]å  \  }}	d}
g }|	D ]Œ  \  }}|j                  |«       | j                  |«      \  }}}|€Œ/d}
t	        |j                  t        «      r=|j                  j                  r'| j                  j                  |j                  d|«       |||<   ŒŽ |
rŒžt        j                  |«      }|	d   \  }}t	        |t        «      sJ ‚|||<   | j!                  ||||«       Œç |S )NFTr   )r   r¢  r6  rÐ  rÌ  r   r  r8  rž  r™   r¼  rH  r&  rÊ  rõ   rR  rÜ  )r+  rî  Úall_capturesÚtmr  rH  r  rï  r&  rÜ  Úalready_existsrÓ  Úprevious_typer  rš  Úfirst_occurrences                   r   rÝ  z/TypeChecker.infer_variable_types_from_type_maps&  s�  € ô
 GRÔRVÓFWˆØò 	?ˆBÜ% bÕ)Ø!#§¡£ò ?‘I�D˜#Ü! $¬Õ1Ø#Ÿy™y˜Ø#Ð/Ð/Ð/Ø$ TÑ*×1Ñ1°4¸°+Õ>ñ	?ð	?ð 24ˆØ)×/Ñ/Ó1ò 	\‰MˆC�Ø"ˆNØ "ˆEØ%ò 	8‘	��cØ—‘˜SÔ!à&*×&7Ñ&7¸Ó&=Ñ#�˜q !Ø Ñ,Ø%)�NÜ! $§)¡)¬SÔ1°d·i±i×6HÒ6HØŸ™×5Ñ5°d·i±iÀÈÔMà*7�N 3Ò'ð	8ò "Ü$×/Ñ/°Ó6�à&.¨q¡kÑ#Ð  !ä! #¤sÔ+Ð+Ð+Ø&.�˜sÑ#Ø×(Ñ(¨Ð.>ÀÐJZÕ[ð+	\ð, Ðr  c           	     óø   — t        |«      ry t        |j                  «       «      D ]R  \  }}t        |t        «      sŒ|j
                  }||vs)| j                  |||   |t        j                  dd¬«      rŒP||= ŒT y )Nzpattern captures typezvariable has type)rH  rÁ  rÃ  )	r6  r¢  rÐ  rÌ  r   r  r±  r   ÚINCOMPATIBLE_TYPES_IN_CAPTURE)r+  râ  rï  r  rH  r  s         r   rä  z.TypeChecker.check_and_remove_capture_conflictsM  s…   € ô ˜hÔ'ØÜ˜hŸn™nÓ.Ó/ò 	#‰IˆD�#Ü˜d¤HÔ-ØØ—9‘9ˆDØ˜>Ñ)°×1CÑ1CØØ˜tÑ$ØÜ$×BÑBØ5Ø 3ð 2Dõ 2ð ˜T‘Nñ	#r  c                ó  — |j                   r%| j                  |j                   j                  «       | j                  j	                  «       5  | j
                  j                  |j                  «       d d d «       y # 1 sw Y   y xY wr'  )Ú
alias_noderÅ  Úalias_tvarsrH  r°  rƒ  r«  ræ  ©r+  Úos     r   Úvisit_type_alias_stmtz!TypeChecker.visit_type_alias_stmt`  s^   € Ø�<Š<Ø×'Ñ'¨¯©×(@Ñ(@ÔAà�X‰X×#Ñ#Ó%ñ 	.Ø×Ñ×$Ñ$ Q§W¡WÔ-÷	.÷ 	.ñ 	.ús   Á&A;Á;Bc                óÔ   — t        |t        g «      «      }|dz   |z   |_        t        t	        «       ||«      }||_        ||_        t        |«       |j                  «       |_	        ||fS )Nrô  )
rb   r^   r   r—   r‘   r4  r  rJ   Úcalculate_metaclass_typerá  )r+  Úcurr_module_fullnameÚclass_gen_nameÚclass_short_namer  Úcdefr4  s          r   r_  zTypeChecker.make_fake_typeinfog  sh   € ô Ð(¬%°«)Ó4ˆØ,¨sÑ2°^ÑCˆŒÜœ› tÐ-AÓBˆØˆŒ	ØˆŒ
Ü�dÔØ"×;Ñ;Ó=ˆÔØ�TˆzÐr  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|j                  |	d	f«       y
g }
|D ]D  }|j                  j                  sŒ|
j                  |	d|j                  j                  › d�f«       ŒF |
r|j                  |
«       y
	  |||‰ j                  «      \  }}‰ j                  j                  «       5 }‰ j!                  |«       d
d
d
«       j#                  «       rY ||d
d
d…   «      } |||‰ j                  «      \  }}‰ j                  j                  «       5 }‰ j!                  |«       d
d
d
«       d|_        |j#                  «       r|j                  |	df«       y
t)        t*        |dd¬«      |j,                  |<   t/        |g |d   j0                  xs |d   j0                  ¬«      S # 1 sw Y   ŒéxY w# 1 sw Y   ŒŒxY w# t&        $ r |j                  |	df«       Y y
w xY w)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_promotionsc                ó¨   — g }| D ]J  }|j                   j                  r|j                   j                  }n|g}|D ]  }|j                  |«       Œ ŒL |S r'  )r­  Úis_intersectionr  r8  )Ú
instances_Úbase_classes_r.  rÇ  Úexpanded_insts        r   Ú_get_base_classesz:TypeChecker.intersect_instances.<locals>._get_base_classes   s\   € ØˆMØ"ò 8�Ø—9‘9×,Ò,Ø#Ÿy™yŸ™‘Hà $˜v�Hà%-ò 8�MØ!×(Ñ(¨Õ7ñ8ð8ð !Ð r  c                ó<  •— | D �cg c]  }t        ||d¬«      ‘Œ }}dt        |d«      › d�}|j                  j                  |«      x}�*t	        |j
                  t        «      sJ ‚|j
                  |fS ‰	j                  |j                  ||| «      \  }}||fS c c}w )Nr  )rZ  Ú	verbosityz<subclass of Úandú>)	rE   rH   ri  r¬  rÌ  r  r—   r_  r   )
r  Úcurr_module_rZ  rj  ri  rÊ  Úsymbolr  Úinfo_r+  s
            €r   Ú!_make_fake_typeinfo_and_full_namezJTypeChecker.intersect_instances.<locals>._make_fake_typeinfo_and_full_name¬  sª   ø€ ð Q^Ö^È1Ô% a°ÀAÖFÐ^ˆEÐ^Ø"¤:¨e°UÓ#;Ð"<¸AÐ>ˆDØ&×,Ñ,×0Ñ0°Ó6Ð6�ÐCÜ! &§+¡+¬xÔ8Ð8Ð8Ø—{‘{ DÐ(Ð(Ø×1Ñ1°,×2GÑ2GÈÈtÐUbÓc‰KˆD�%Ø˜$�;Ðùò _s   †BT)rZ  Úbarer#  zhave distinct disjoint basesNr  z
" is finalrŒ  z/would have inconsistent method resolution orderz)would have incompatible method signatures)Úmodule_hiddenrˆ  ©Úextra_attrs)r  útuple[Instance, Instance]r/  úlist[Instance])r  r.  r%  r~   rZ  r£   r/  ztuple[TypeInfo, str])rN  rÆ  rÌ  r~   r¶   rH   rF   rZ  rÃ   r8  r­  r¼  rÊ  rI  rH  r°  r  rÚ  r  rI   r’   rQ   ri  rá   r,  )r+  Ú	instancesrG  Úcurr_modulerp  rq  r   r(  Úbase_classesÚpretty_names_listÚ
new_errorsr¹  r4  Ú	full_namerá  s   `              r   Úintersect_instanceszTypeChecker.intersect_instances}  sƒ  ø€ ð* —j‘j×&Ñ& qÑ)ˆÜ˜+¤xÔ0Ð0Ð0ð  ‰ˆˆeÜ˜T 5¸EÕBØˆKÜ˜U D¸EÕBØˆLó
	!ð		Ø)ð		Ø9Að		ØLSð		à!õ		ñ )¨Ó3ˆô 'Ü" L¸$¿,¹,ÈTÒRÐTYó
Ðô -¨\Ô:Ø�M‰MÐ,Ð.LÐMÔNØàˆ
Ø ò 	WˆDØ�y‰y×!Ó!Ø×!Ñ!Ð#4¸¸$¿)¹)¿.¹.Ð9IÈÐ6TÐ"UÕVð	Wñ Ø�M‰M˜*Ô%Øð	Ù?Ø˜k¨4¯<©<ó‰OˆD�)ð —‘×'Ñ'Ó)ð 6¨\Ø×/Ñ/°Ô5÷6à×*Ñ*Ô,á0°¹4¸R¸4±ÓA�Ù"CØ  +¨t¯|©|ó#‘��ið —X‘X×+Ñ+Ó-ð :°Ø×3Ñ3°DÔ9÷:à#'ˆDÔ ð ×&Ñ&Ô(Ø�M‰MÐ,Ð.YÐZÔ[Øä'6´t¸TÀ5ÐX\Ô']ˆ×Ñ˜)Ñ$Ü˜˜b¨i¸©l×.FÑ.FÒ.bÈ)ÐTUÉ,×JbÑJbÔcÐc÷'6ð 6ú÷:ð :ûô ò 	Ø�M‰MÐ,Ð._Ð`ÔaÙð	úsC   Ä1I Ä<H6ÅAI Æ%IÆ7I È6H?È;I ÉIÉI ÉI-É,I-c                ó>  — | j                   j                  d   }t        |t        «      sJ ‚t	        d|j
                  j                  › d�|j                  «      }t        || j                  «      }| j                  |j                  |||g«      \  }}t        dg t        g «      |«      }|j                  dz   |_        ||_        t!        t"        |«      }	d|	_        |	|j                  d<   t!        t&        |«      |j                  |<   t)        |g |j*                  ¬«      S )zïCreates a fake type that represents the intersection of an Instance and a CallableType.

        It operates by creating a bare-minimum dummy TypeInfo that
        subclasses type and adds a __call__ method matching callable_type.
        r   z<callable subtype of r$  rG  z	.__call__Tr+  )rN  rÆ  rÌ  r~   Úgen_unique_namer­  rÊ  ri  rE   rZ  r_  r   ro   r^   Ú	_fullnamer4  r’   rW   rß  rQ   rá   r,  )
r+  rH  Úcallable_typeÚ
cur_moduleÚgen_nameÚ
short_namer  r4  Úfunc_defr  s
             r   Úintersect_instance_callablez'TypeChecker.intersect_instance_callableã  sü   € ð —Z‘Z×%Ñ% aÑ(ˆ
Ü˜*¤hÔ/Ð/Ð/Ü"Ð%:¸3¿8¹8¿=¹=¸/ÈÐ#KÈZ×M]ÑM]Ó^ˆô & c¨4¯<©<Ó8ˆ
Ø×,Ñ,¨Z×-@Ñ-@À(ÈJÐY\ÐX]Ó^‰
ˆˆdô ˜: r¬5°«9°mÓDˆØ!Ÿ]™]¨[Ñ8ˆÔØˆŒÜœd HÓ-ˆØ#ˆÔØ!$ˆ�
‰
�:Ñä%4´T¸4Ó%@ˆ
×Ñ˜Ñ"ä˜˜b¨c¯o©oÔ>Ð>r  c                ó8  — | j                  d«      }t        t        t        j                  «      t        t        j                  «      gt
        j                  t
        j                  gddgt        t        j                  «      |d¬«      }| j                  ||«      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  r>  )r+  rH  r#  r9  s       r   Úmake_fake_callablezTypeChecker.make_fake_callable  s{   € ð —?‘?Ð#6Ó7ˆÜ$Ü”Y×'Ñ'Ó(¬'´)×2DÑ2DÓ*EÐFÜ�^‰^œUŸ_™_Ð-Ø�4ˆLÜœY×/Ñ/Ó0ØØ!ô
ˆð ×/Ñ/°°]ÓCÐCr  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        «      rQg }g }|j                  D ]:  }| j                  |d¬«      \  }}|j                  |«       |j                  |«       Œ< ||fS t        |t        «      r)| j                  t        |«      |«      \  }}|r|gng }||fS |}t        |t        «      rt        |«      }t        |t        «      rº|j                  j!                  d«      }	|	r5|	j                  r)| j                  |	j                  d¬«      \  }}|r|s|gg fS |sf| j#                  |«      }
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©Úunsound_partitionrG  F)rú   rÌ  rà   rî   rÛ   rã   rõ   rÐ  Úpartition_by_callablerI  rò   rÈ   rç   rÕ   rá   r­  Ú
get_methodrB  r  )r+  rH  rE  Ú	callablesÚuncallablesrÂ  ÚsubcallablesÚsubuncallablesÚitypr�  Úfakes              r   rF  z!TypeChecker.partition_by_callable  s  € ô" ˜cÓ"ˆä�cœL¬(Ð3Ô4Ø�5˜"�9Ðä�cœ7Ô#Ø�5˜3˜%�<Ðä�cœ8Ô$Ø˜�u�9Ðä�cœ9Ô%ØˆIØ&(ˆKØŸ9™9ò 3�ð 04×/IÑ/IØ¨tð 0Jó 0Ñ,�˜nð × Ñ  Ô.Ø×"Ñ" >Õ2ð3ð ˜kÐ)Ð)ä�cœ;Ô'ð &*×%?Ñ%?Ü'¨Ó,Ð.?ó&Ñ"ˆI�{ñ $/˜3™%°BˆKØ˜kÐ)Ð)ð ˆÜ�cœ9Ô%Ü! #Ó&ˆDä�dœHÔ%Ø—Y‘Y×)Ñ)¨*Ó5ˆFÙ˜&Ÿ+š+Ø)-×)CÑ)CØ—K‘K°5ð *Dó *Ñ&�	˜;ñ ¡[ð  ˜5 "˜9Ð$á$Ø×.Ñ.¨tÓ4�Ü˜c¤9Ô-Ü+4°S·Y±YÀÓ+E�D—I‘IÔ(Ø ŸI™I×0Ñ0Ð1°C°5Ð8Ð8Ø�v ˜u�}Ð$áØ˜�u�9Ðð �5˜3˜%�<Ðr  c                ó  — |si i fS t        t        |«      t        «      ri i fS | j                  |d¬«      \  }}|r4|r2|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.
        FrD  )rÌ  rú   rÛ   rF  rõ   rR  rô   )r+  r  Úcurrent_typerH  rI  Úcallable_mapÚuncallable_maps          r   Úconditional_callable_type_mapz)TypeChecker.conditional_callable_type_mapf  s¦   € ñ Ø�r�6ˆMä”o lÓ3´WÔ=Ø�r�6ˆMà!%×!;Ñ!;¸LÐ\aÐ!;Ó!bÑˆ	�;á™Ø ¤)×"6Ñ"6°yÓ"AÐBˆLØ"¤I×$8Ñ$8¸Ó$EÐFˆNØ Ð/Ð/áØ˜œoÓ/Ð0Ð0Ð0à”oÓ'Ð(¨"Ð,Ð,r  c                ó>  — g }g }t        |«      }t        |t        «      rt        |j	                  «       «      }n|g}t        |«      }|D �]'  }t        |t        «      rt        |j                  «      n|}|rÙt        |t        «      rÉ|D ]Â  }	|	|j                  v r|j                  |«       Œ#|	|j                  v r8t        t        |j                  |	   «      t        «      r|j                  |«       Œi|	|j                  vr*|j                  s|j                  r|j                  |«       Œ¡|j                  |«       |j                  |«       ŒÄ �Œ|j                  |«       |j                  |«       �Œ* 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, and TypeVars with TypedDict
        bounds, based on left operand being literal string(s).
        )rú   rÌ  rõ   rû   rl  rÔ   rò   rM  rê   Úrequired_keysr8  rÐ  rô   Ú	is_closedr¼  rR  )
r+  rB  rK  Úif_typesÚ
else_typesÚpossible_iterable_typesÚitem_str_literalsÚpossible_iterable_typerö  rô  s
             r   Úconditional_types_for_iterablez*TypeChecker.conditional_types_for_iterable‚  sv  € ð  "ˆØ!#ˆ
ä'¨Ó6ˆÜ�m¤YÔ/Ü&6°}×7SÑ7SÓ7UÓ&VÑ#à'4 oÐ#ä>¸yÓIÐà&=ó 	:Ð"ô Ð4´kÔBô  Ð 6× BÑ BÔCà+ð ñ !¤Z°´}Ô%EØ,ò B�CØ˜e×1Ñ1Ñ1Ø Ÿ™Ð(>Õ?Ø §¡Ñ+´
Ü'¨¯©°CÑ(8Ó9¼?ô1ð
 #×)Ñ)Ð*@ÕAØ E§K¡KÑ/°U·_²_ÈÏÊð
 #×)Ñ)Ð*@ÕAà Ÿ™Ð(>Ô?Ø"×)Ñ)Ð*@ÕAò#Bð& —‘Ð 6Ô7Ø×!Ñ!Ð"8Ö9ð9	:ô< ×#Ñ# HÓ-¬y×/CÑ/CÀJÓ/OÐOÐOr  c                óš  ‡ — t        |t        «      xrl t        |j                  «      xrU |j                  j	                  d«       xr7 |j                  j	                  d«       xr |j                  j
                  dk7  xsK t        |t        «      xs9 t        |t        «      xr' t        ˆ fd„t        |j                  «      D «       «      S )NÚ__bool__Ú__len__r-  c              3  ó@   •K  — | ]  }‰j                  |«      –— Œ y ­wr'  )Ú_is_truthy_type©rÞ  rM  r+  s     €r   rß  z.TypeChecker._is_truthy_type.<locals>.<genexpr>Á  s   øè ø€ ÒS°A˜×,Ñ,¨Q×/ÑSùó   ƒ)rÌ  rá   r.  r­  ri  r   rà   rõ   rk  rû   rÐ  ©r+  rM  s   ` r   r`  zTypeChecker._is_truthy_typeµ  s²   ø€ ô ˜1œhÓ'ò 9Ü˜Ÿ™“Lò9àŸ™×2Ñ2°:Ó>Ð>ò9ð Ÿ™×2Ñ2°9Ó=Ð=ò9ð —F‘F—O‘OÐ'8Ñ8òô ˜!œ\Ó*òô ˜1œiÓ(ò TÜÓSÔ9IÈ!Ï'É'Ó9RÔSÓSð	
r  c                ó>  ‡ ‡‡— t         j                  syt        ‰«      Š‰ j                  ‰«      sydˆˆ ˆfd„}dˆˆ ˆfd„}t	        ‰t
        «      r5‰ j                  t        j                  j                   |«       «      ‰«       yt	        ‰t        «      r5‰ j                  t        j                  j                   |«       «      ‰«       yt	        ‰t        «      rŽ‰j                  j                  dk(  ru‰ j                  dddg «      \  }}‰ j                  t        j                   j                   |«       t#        t        |‰j$                  «      ‰ j&                  «      «      ‰«       y‰ j                  t        j(                  j                   |«       «      ‰«       y)zŽ
        Check if a type can have a truthy value.

        Used in checks like::

            if x: # <---

            not x  # <---
        Nc                 ó  •— t        ‰‰j                  «      } t        ‰t        «      rd‰j                  › d| › �S t        ‰t
        «      r‰j                  rd‰j                  › d| › �S t        ‰t        «      r‡t        ‰j                  t        «      rd‰j                  j                  › d| › �S t        ‰j                  t
        «      r2‰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   rZ  rÌ  r}   rÊ  r‰   r   ra   r?  )rH  r  r+  rM  s    €€€r   Úformat_expr_typez;TypeChecker.check_for_truthy_type.<locals>.format_expr_typeÖ  sã   ø€ Ü˜a §¡Ó.ˆCÜ˜$¤
Ô+Ø! $§)¡) ¨K¸°uÐ=Ð=Ü˜D¤'Ô*¨t¯}ª}Ø˜4Ÿ=™=˜/¨°S°EÐ:Ð:Ü˜D¤(Ô+Ü˜dŸk™k¬:Ô6Ø˜tŸ{™{×/Ñ/Ð0°
¸3¸%Ð@Ð@Ü §¡¬WÔ5¸$¿+¹+×:NÒ:NØ˜tŸ{™{×3Ñ3Ð4°J¸s¸eÐDÐDØ& s eÐ,Ð,à-¨c¨UÐ3Ð3r  c                 ó|   •— t        ‰ t        t        f«      rd‰ j                  › d�S t	        ‰‰j
                  «      S )Nr  )rÌ  r   r}   rÊ  rD   rZ  )r  r+  rM  s   €€€r   Úget_expr_namez8TypeChecker.check_for_truthy_type.<locals>.get_expr_nameå  s8   ø€ Ü˜$¤¬:Ð 6Ô7Ø˜4Ÿ9™9˜+ QÐ'Ð'ô # 1 d§l¡lÓ3Ð3r  r–  ÚtypingÚ
Collection)r/  rm  )r°   rž  rú   r`  rÌ  rà   r°  r   ÚFUNCTION_ALWAYS_TRUEr²  rõ   ÚTYPE_ALWAYS_TRUE_UNIONTYPErá   r­  r   r_  ÚITERABLE_ALWAYS_TRUErD   r�  rZ  ÚTYPE_ALWAYS_TRUE)r+  rM  r  rf  rh  r  r4  s   ```    r   Úcheck_for_truthy_typez!TypeChecker.check_for_truthy_typeÅ  s3  ú€ ô ×$Ò$Øä˜AÓˆØ×#Ñ# AÔ&Ø÷	4÷	4ô �aœÔ&Ø�I‰IÔ&×;Ñ;×BÑBÁ=Ã?ÓSÐUYÕZÜ˜œ9Ô%Ø�I‰IÔ&×AÑA×HÑHÑIYÓI[Ó\Ð^bÕcÜ˜œ8Ô$¨¯©¯©Ð<MÒ)MØ×-Ñ-¨h¸ÀlÐTVÓW‰GˆAˆtØ�I‰IÜ ×5Ñ5×<Ñ<Ù$Ó&¬´H¸TÀ1Ç6Á6Ó4JÈDÏLÉLÓ(Yóð õ	ð �I‰IÔ&×7Ñ7×>Ñ>Ñ?OÓ?QÓRÐTXÕYr  ©Úin_boolean_contextc               óz   — | j                  ||¬«      \  }}| j                  |«      }| j                  |«      }||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.
        rp  )Úfind_isinstance_check_helperrã  )r+  r  rq  r8  r  Ú
new_if_mapÚnew_else_maps          r   r  z!TypeChecker.find_isinstance_checkû  sQ   € ð*  ×<Ñ<ØÐ%7ð =ó 
Ñˆ�ð ×3Ñ3°FÓ;ˆ
Ø×5Ñ5°hÓ?ˆØ˜<Ð'Ð'r  c          
     ó®  — t        |«      ri |t        «       ifS t        |«      r|t        «       ii fS t        |t        «      �r)t        |j                  «      dk7  �rt        |j                  d   «      }t        |j                  d«      rwt        |j                  «      dk7  ri i fS t        |«      t        k(  �rNt        |g| j                  | j                  |«      | j                  |j                  d   «      |«      ¢­Ž S t        |j                  d«      rAt        |j                  «      dk7  ri i fS t        |«      t        k(  �rÁ| j!                  ||«      S t        |j                  d«      rRt        |j                  «      dk7  ri i fS t        |«      t        k(  �rj| j                  |«      }| j#                  ||«      S t        |j                  d«      r›t        |j                  «      dk7  ri i fS t%        |j                  d   | j                  |j                  d   «      «      }t        |«      t        k(  �rÍ|�rÊt        |«      dk(  �r»| j'                  || j                  |«      |d   «      S d\  }}| j)                  |j                  «      }|�_t+        |«      }t        |t,        «      rt/        d	||d
¬«      }	|	�t+        |	«      }t        |t0        «      r|j2                  |j4                  }}t        |j                  t6        «      r,|j                  j2                  |j                  j4                  }}|€|��Ê|j8                  d   t:        j<                  k7  r­t        |t0        t>        f«      r—|j@                  d   jB                  d   }
|
|jB                  v r4|jB                  jE                  |
«      }t        |j                  |   «      }n9|�dnd}| jG                  tH        jJ                  jM                  |«      |«       i i fS t        |«      t        k(  �rê|�|tO        |«      ii fS |€J ‚t        |g| j                  | j                  |«      tQ        |d¬«      g|d¬«      ¢­Ž S t        |tR        «      r| jU                  |«      S t        |tV        «      rŠi }i }| jY                  |jZ                  «      \  }}|j]                  |«       |j]                  |«       | jY                  |j^                  d¬«      \  }}|j]                  |«       |j]                  |«       ||fS t        |t`        «      re|jb                  dk(  rV| jY                  |jd                  «      \  }}| jY                  |jf                  «      \  }}ti        ||«      tk        ||d
¬«      fS t        |t`        «      rc|jb                  dk(  rT| jY                  |jd                  «      \  }}| jY                  |jf                  «      \  }}tk        ||«      ti        ||«      fS t        |tl        «      r1|jb                  dk(  r"| jY                  |jn                  «      \  }}||fS t        |«      t        k(  r¥| jq                  |«      r”| js                  | j                  |«      «      rttu        | j                  |«      d«      sY| jv                  jx                  rC| j{                  | j                  |«      dd«      \  }}|t}        |«      i}|t        |«      i}||fS | j                  |«      }|r| j�                  ||«       tƒ        |d«      }|t}        |«      i}|t        |«      i}||fS )Nr   zbuiltins.isinstancer  rˆ  zbuiltins.issubclasszbuiltins.callablezbuiltins.hasattrr  rG  T©rK  ÚguardÚnarrowerF©Úis_upper_bound©Úconsider_runtime_isinstancerp  r#  ©Úcoalesce_anyÚorÚnotr]  r$  r¿  )BÚis_true_literalrô   r®  rÌ  ra   rý  r�  rØ  rª   r?  r:   rV   rá  Ú#conditional_types_with_intersectionr¸  Úget_isinstance_typeÚinfer_issubclass_mapsrR  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  r"  r�  ræ  rƒ   r÷  rp  rq  Úand_conditional_mapsræ  r˜   r  r·  Úcan_be_narrowed_with_lenrÅ   rZ  rž  Únarrow_with_lenrÐ   rÉ   ro  rÑ   )r+  r  rq  r  Úvartyper6  rË  rî  Úcalled_typeÚcallrÊ  r  rÒ  r8  r  Úif_assignment_mapÚelse_assignment_mapÚif_condition_mapÚelse_condition_mapÚleft_if_varsÚleft_else_varsÚright_if_varsÚright_else_varsrp  rq  Úyes_typeÚno_typeÚoriginal_vartypes                               r   rs  z(TypeChecker.find_isinstance_check_helper  s¸  € ô ˜4Ô Ø˜œoÓ/Ð0Ð0Ð0Ü˜DÔ!Øœ/Ó+Ð,¨bÐ0Ð0ä�dœHÕ%¬#¨d¯i©i«.¸AÓ*=Ü" 4§9¡9¨Q¡<Ó0ˆDÜ! $§+¡+Ð/DÔEÜ�t—y‘y“> QÒ&Ø˜r˜6�MÜ˜4“=¤LÓ0Ü8Øðà×AÑAØ ×,Ñ,¨TÓ2°D×4LÑ4LÈTÏYÉYÐWXÉ\Ó4ZÐ\`óòð ô $ D§K¡KÐ1FÔGÜ�t—y‘y“> QÒ&Ø˜r˜6�MÜ˜4“=¤LÓ0Ø×5Ñ5°d¸DÓAÐAÜ# D§K¡KÐ1DÔEÜ�t—y‘y“> QÒ&Ø˜r˜6�MÜ˜4“=¤LÓ0Ø"×.Ñ.¨tÓ4�GØ×=Ñ=¸dÀGÓLÐLÜ# D§K¡KÐ1CÔDÜ�t—y‘y“> QÒ&Ø˜r˜6�MÜ/°·	±	¸!±¸d×>NÑ>NÈtÏyÉyÐYZÉ|Ó>\Ó]�Ü˜4“=¤LÓ0²T¼cÀ$»iÈ1»nØ×1Ñ1°$¸×8HÑ8HÈÓ8NÐPTÐUVÑPWÓXÐXà&0Ñ#�˜Ø"×6Ñ6°t·{±{ÓC�ØÐ*Ü"1°+Ó">�Kô " +¬xÔ8Ü*¨:°{ÀKÐ]aÔb˜ØÐ+Ü*9¸$Ó*?˜KÜ! +¬|Ô<Ø.9×.AÑ.AÀ;×CYÑCY ˜ô ˜dŸk™k¬7Ô3Ø*.¯+©+×*=Ñ*=¸t¿{¹{×?UÑ?U˜Z�GØÐ)¨WÑ-@à—~‘~ aÑ(¬E¯M©MÒ9ô & k´LÄ*Ð3MÔNØ#.×#4Ñ#4°QÑ#7×#AÑ#AÀ!Ñ#D˜DØ# t§~¡~Ñ5Ø&*§n¡n×&:Ñ&:¸4Ó&@ ä'6°t·y±yÀ±~Ó'F¡à2<Ð2H¡wÈj Ø $§	¡	Ü$4×$PÑ$P×$WÑ$WÐX\Ó$]Ð_cô!"ð (*¨2 v Ü˜t“}¬Ó4ð &Ð1Ø$(¬/¸*Ó*EÐ#FÈÐ#JÐJà#*Ð#6Ð6Ð#6Ü#@Ø $ð$à!%×!IÑ!IØ$(×$4Ñ$4°TÓ$:Ü%.¨wÀuÔ%MÐ$NØ$(Ø@Eð	 "Jó ""ò$ð ô ˜œnÔ-Ø×8Ñ8¸Ó>Ð>Ü˜œnÔ-ð ˆFØˆHà59×5OÑ5OÐPT×P[ÑP[Ó5\Ñ2ÐÐ2Ø�M‰MÐ+Ô,Ø�O‰OÐ/Ô0à37×3MÑ3MØ—
‘
¨uð 4Nó 4Ñ0ÐÐ0ð �M‰MÐ*Ô+Ø�O‰OÐ.Ô/à˜8Ð#Ð#Ü˜œfÔ%¨$¯'©'°UÒ*:Ø+/×+EÑ+EÀdÇiÁiÓ+PÑ(ˆL˜.Ø-1×-GÑ-GÈÏ
É
Ó-SÑ*ˆM˜?ô
 % \°=ÓAô $ N°OÐRVÔWðð ô ˜œfÔ%¨$¯'©'°Tª/Ø+/×+EÑ+EÀdÇiÁiÓ+PÑ(ˆL˜.Ø-1×-GÑ-GÈÏ
É
Ó-SÑ*ˆM˜?ô
 $ L°-Ó@Ü$ ^°_ÓEðð ô ˜œiÔ(¨T¯W©W¸Ò-=Ø×4Ñ4°T·Y±YÓ?‰KˆD�%Ø˜$�;Ðä�D‹Mœ\Ò)Ø—‘˜dÔ#Ø×-Ñ-¨d×.>Ñ.>¸tÓ.DÔEä)¨$×*:Ñ*:¸4Ó*@À*ÔMØ—‘×,Ò,ð !%× 4Ñ 4°T×5EÑ5EÀdÓ5KÈSÐRSÓ TÑˆH�gØœI hÓ/Ð0ˆFØœj¨Ó1Ð2ˆHØ˜8Ð#Ð#ð  ×+Ñ+¨DÓ1ÐÙð ×&Ñ&Ð'7¸Ô>Ü1Ð2BÀOÓTˆàœ	 'Ó*Ð+ˆØœ* WÓ-Ð.ˆØ�xÐÐr  c                óŒ	  — |j                   D �cg c]  }t        |«      ‘Œ }}g }i }i }t        |«      D �]  \  }}| j                  |«      si i fc S | j	                  |«      }	|j                  |	«       t        |«      t        k(  sŒSt        |«      rŒ_t        |«      rŒkt        |«      rŒwt        |«      rŒƒ| j                  |«      rŒ•t        t        |	«      x}
t        «      r|
j!                  «       rŒÁt        |
t"        «      rt        |
j$                  t&        «      rŒìt)        |«      }|€Œú|||<   |||<   �Œ t+        |j-                  «       |ddh«      }g }|D �]  \  }}|dv r)| j/                  |||||j1                  «       ¬«      \  }}�n||dv �rst3        |«      dk(  sJ ‚|\  }}||   }||   }i }i }||v �r"t        |«      }d}t        |t4        «      r"t7        |j8                  «      €|j8                  }nÐt        ||   «      }t        |t:        t<        f«      rEt?        d„ |j8                  D «       «      r�|j8                  D �cg c]  }| j	                  |«      ‘Œ }}ngt        |t@        «      rWt?        d	„ |j8                  D «       «      r;|j8                  D ��cg c]$  \  }}| j	                  tC        tD        |«      «      ‘Œ& }}}|�Óg }g }|D ]±  }t        |«      }tG        |«      s&t        |tH        «      r,|jJ                  jL                  rtO        |«      stQ        |«      }| j/                  d||   ||   g||gd
dgd
h¬«      \  }}|j                  |«       tS        t        |«      «      sŒ¡|j                  |«       Œ³ tU        |«      }tW        |d¬«      }n>t        tY        |«      «      } | �(| j/                  d||   ||   g|| gd
dgd
h¬«      \  }}i }||v r)| j[                  ||«      \  }!}"||   }|!||<   |"||<   ni }i }|dv r||}}|j                  ||f«       t3        |«      dkD  s�ŒÛ|j9                  «       D ].  \  }}	t)        |«      }|�||vrŒ||   }#t]        ||#   |	«      ||#<   Œ0 �Œ t_        d„ |D «       «      rta        |d¬«      S ta        | jc                  |«      d¬«      S c c}w c c}w c c}}w )z2Infer type narrowing from a comparison expression.Nú==Úis>   r�  ú!=rœ  úis not)Únarrowable_indices>   Úinúnot inr  c              3  ó>   K  — | ]  }t        |t        «       –— Œ y ­wr'  r?  )rÞ  r×  s     r   rß  z?TypeChecker.comparison_type_narrowing_helper.<locals>.<genexpr>  s   è ø€ Ò"]À1¤z°!´XÓ'>Ô#>Ñ"]ùó   ‚c              3  ó*   K  — | ]  \  }}|d u–— Œ y ­wr'  r  )rÞ  r³  rø  s      r   rß  z?TypeChecker.comparison_type_narrowing_helper.<locals>.<genexpr>!  s   è ø€ Ò"R±T°Q¸ 1¨D¤=Ñ"Rùs   ‚r   rˆ  )ÚoperandsÚoperand_typesÚexpr_indicesr   T©Úuse_meet>   rž  rŸ  r¢  c              3  óX   K  — | ]"  }t        |d    «      xs t        |d   «      –— Œ$ y­w)r   rˆ  Nr¡  )rÞ  rž  s     r   rß  z?TypeChecker.comparison_type_narrowing_helper.<locals>.<genexpr>r  s(   è ø€ ÒA¨!Œs�1�Q‘4‹yÒ%œC  !¡›IÓ%ÑAùs   ‚(*)2r¦  rØ  rÏ  r·  r¸  r8  r:   rV   rÔ  r¯  r®  r‚  Úis_literal_enumrÌ  rú   rà   rr  rî   rØ  rò   r;   Úgroup_comparison_operandsÚpairwiseÚ narrow_type_by_identity_equalityr>  rý  rç   rø   rÐ  rz   r‹   rk  rh   r   rj   rÌ   rá   r­  r  Úhas_custom_eq_checksrÄ   rÍ   Úreduce_or_conditional_type_mapsÚ reduce_and_conditional_type_mapsÚbuiltin_item_typer[  r>   rã  Úreduce_conditional_mapsÚfind_tuple_len_narrowing)$r+  r  rj  r¦  r§  Ú narrowable_operand_index_to_hashÚ narrowable_operand_hash_to_indexr×  r  r  Úp_exprÚhÚsimplified_operator_listÚpartial_type_mapsÚoperatorr¨  r8  r  Ú
left_indexr¤  rB  rK  Úp_iterable_typeÚcontainer_item_typesÚcontainer_exprr_  r³  rø  Úall_if_mapsÚall_else_mapsÚ
known_itemÚp_known_itemÚcollection_item_typeÚif_typeÚ	else_typeÚoperand_indexs$                                       r   r‰  z,TypeChecker.comparison_type_narrowing_helper½  sI  € ð 15·±Ö>¨1”O AÕ&Ð>ˆÐ>ØˆØ+-Ð(Ø+-Ð(Ü  Ó*ó 	<‰GˆAˆtØ—=‘= Ô&Ø˜2�v’Ø×(Ñ(¨Ó.ˆIØ× Ñ  Ô+ô ˜“¤Ó-Ü'¨Õ-Ü2°4Õ8Ü(¨Õ.Ü'¨Õ-Ø×,Ñ,¨TÕ2ô ¬¸Ó)CÐC˜vÄ\ÔRØ×*Ñ*Õ,ô $ F¬HÔ5¼*ÀVÇ[Á[ÔR]Õ:^ä  Ó&�Ø‘=Ø:;Ð4°QÑ7Ø:;Ð4°QÓ7ð1	<ôT $=Ø�M‰M‹OÐ=ÀÀd¸|ó$
Ð ð ÐØ&>ó s	Ñ"ˆH�lð Ð7Ñ7Ø#'×#HÑ#HØØØ!Ø Ø'G×'LÑ'LÓ'Nð $Ió $Ñ �šð Ð-Ò-Ü˜<Ó(¨AÒ-Ð-Ð-Ø*6Ñ'�
˜KØ)¨*Ñ5�	Ø -¨kÑ :�à�Ø�àÐ!AÒAÜ&5°mÓ&D�OØ+/Ð(ô # ?´IÔ>Ü/°×0EÑ0EÓFÐNà/>×/DÑ/DÑ,ä)8¸À+Ñ9NÓ)O˜Ü% n´xÄÐ6IÔJÜ"Ñ"]È×H\ÑH\Ô"]Ô]àAO×AUÑAUö8"Ø<= D×$4Ñ$4°QÕ$7ð8"Ð 4ñ 8"ô (¨¼ÔAÜ"Ñ"R¸^×=QÑ=QÔ"RÔRð 1?×0DÑ0D÷8"á(,¨¨1ð %)×$4Ñ$4´T¼*ÀaÓ5HÕ$Ið8"Ð 4ñ 8"ð
 ,Ð7ð ')˜Ø(*˜Ø*>ò ?˜Jä+:¸:Ó+F˜Lä 4°\Ô Bä$.¨|¼XÔ$FØ(4×(9Ñ(9×(AÒ(Aä&:¸<Ô&HÜ->¸zÓ-J 
Ø/3×/TÑ/TØ $Ø*2°:Ñ*>ÀÈÑ@UÐ)VØ/8¸*Ð.EØ./°¨VØ45°3ð 0Uó 0Ñ,˜F Hð (×.Ñ.¨vÔ6Ü9¼/È*Ó:UÕVØ -× 4Ñ 4°XÕ >ð)?ô* "AÀÓ!M˜Ü#CÀMÐ\`Ô#a™ä/>Ô?PÐQ`Ó?aÓ/bÐ,Ø/Ð;Ø/3×/TÑ/TØ $Ø*2°:Ñ*>ÀÈÑ@UÐ)VØ/8Ð:NÐ.OØ./°¨VØ45°3ð 0Uó 0Ñ,˜F Hð (*˜HàÐ"BÑBà)-×)LÑ)LØ! =ó*Ñ&�G˜Yð $ KÑ0�DØ#*�F˜4‘LØ%.�H˜T’Nð �Ø�àÐ5Ñ5Ø#+¨V˜�à×$Ñ$ f¨hÐ%7Ô8ô Ð+Ó,¨qÔ0Ø'-§|¡|£~ò ‘O�D˜)Ü$ TÓ*�AØ�y AÐ-MÑ$MØ Ø$DÀQÑ$G�MÜ3=Ø% mÑ4°ió4�M -Ò0òðYs	ôp ÑAÐ/@ÔAÔAÜ*Ð+<ÀtÔLÐLô +¨4×+HÑ+HÈÓ+NÐY]Ô^Ð^ùòi ?ùòt8"ùó
8"s   �R6É
R;Ê )S c           
     ó˜  — |dv }|rt         }d}t        «       }	n||dv rrt        }d}|D ]F  }
t        ||
   «      }t	        |«      s(t        |t        «      sŒ-|j                  j                  sŒDd} n |D �
ch c]  }
t        ||
   «      sŒ|
’Œ }	}
nt        ‚g }g }|D �]C  }
|
|vrŒ	|
|	v rŒ||
   }|D �]+  }|
|k(  rŒ
||	v rŒ||   }|rt        |«      }t        |||¬«      \  }}|€|x}}nVt        t        |«      d«      }t        |t        |d¬«      gd¬«      \  }}|�"t!        |xs ||g«      }t!        |xs ||g«      }t#        ||
   ||«      \  }} |t        |«      «      r#|j%                  |«       |j%                  |«       ŒÖ| j&                  j(                  r"t+        | j,                  j.                  «      d	k7  st1        |«      r�Œ|j%                  |«       �Œ. �ŒF |	D �]W  }
|
|vrŒ	t        ||
   «      }t        |t2        «      ss||
   }|D ]h  }||	v rŒ||   }|rt        |«      }t        |d¬«      } |t        |«      «      sŒ9t#        ||
   gt        ||gd¬«      ¢­Ž \  }}|j%                  |«       Œj Œšg }g }|j4                  D �]v  }t        |«      r|j%                  ||
   |i«       t        t        |d«      «      }|D �]7  }||	v rV|
|k(  rŒt7        |«      r.t7        ||   «      s |j%                  ||
   t9        |«      i«       n|j%                  ||
   |i«       Œ^||   }|rt        |«      }t        |||¬«      \  }}|€|x}}nOt        t        |d«      «      }t        |t        |d¬«      g|d¬
«      \  }}|�t!        ||g«      }t!        ||g«      }t#        ||
   ||«      \  }}t        t        |«      t:        «      s|j%                  |«        |t        |«      «      s�Œ'|j%                  |«       �Œ: �Œy |j%                  t=        |«      «       |j%                  t=        |«      «       �ŒZ |D �]Ù  }
||
   }t        |t>        «      r>tA        |jB                  d«      r(t+        |jD                  «      d	k(  r|jD                  d   }n-t        |tF        «      r|jH                  dk(  r|jJ                  }nŒ„t        ||
   «      }t        |tL        «      rt        |jN                  tP        «      rŒ½|D �]  }|
|k(  rŒ
||   }| jS                  ||   «      }|€Œ&t        t        |jN                  «      t:        «      rŒJ| jU                  |«      } | jW                  | |g|«      \  }}|�,|jX                  s t[        ||jN                  «      s
t]        «       }t#        |||«      \  }}t        |t^        «      r0t        |j`                  tb        «      r|j`                  jd                  nd}!|j%                  |«       |!s�Œ|j%                  |«       �Œ �ŒÜ tg        |t+        |«      dkD  ¬«      }t=        |«      }||fS c c}
w )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œ  F)Úis_identityNrz  )Úfrom_equalityrˆ  )r8  rË  r8  r   Ú	__class__r  r©  )4rÎ   rj  rÍ   rú   rÌ   rÌ  rá   r­  r  r°  ÚAssertionErrorrÄ   Ú"partition_equality_ambiguous_typesrÑ   Úconditional_typesr    rÏ   rá  r8  rZ  rª  rý  rN  rÆ  r6  rõ   rÐ  r  r  rÛ   r±  ra   rª   r?  r�  r}   rÊ  r  rî   rØ  rò   Úget_type_range_of_typer¸  rƒ  r{  r´   rô   r‰   r  r—   r¼  r²  )"r+  r¼  r¦  r§  r¨  r   Úis_identity_comparisonÚis_target_for_value_narrowingÚshould_coerce_literalsÚcustom_eq_indicesr×  rH  rÁ  rÂ  r  ru  Útarget_typeÚnarrowable_expr_typeÚambiguous_expr_typerÆ  rÇ  r8  r  Úunion_expr_typer"  Ú
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_equalityy  s  € ð` "*Ð-=Ð!=Ðá!Ü,FÐ)Ø%)Ð"Ü #£Ñà˜Ñ%Ü,FÐ)à%*Ð"Ø!ò �Ü% m°AÑ&6Ó7�Ü'¨Ô,´¸CÄÕ1JÈsÏxÉx×O_ÓO_Ø-1Ð*Ùð	ð -9Ö c qÔ<PÐQ^Ð_`ÑQaÕ<b¢Ð cÐÑ cä Ð à%'ˆØ')ˆð ó D	3ˆAØÐ*Ñ*ØØÐ%Ñ%àà% aÑ(ˆIØ!ó <3�Ø˜’6ØØÐ)Ñ)ð Ø+¨AÑ.�Ù)Ü"3°KÓ"@�Kô =_Ø˜{Ð8Nô=Ñ9Ð$Ð&9ð (Ð/Ø*=Ð=�G™iä+JÜ)Ð*>Ó?Àó,Ð(ô *;Ø,Ü" ;¸uÔEÐFØ&*ô*Ñ&�G˜Yð
 +Ð6Ü"7Ø$Ò<Ð(<Ð>QÐRó#˜ô %:Ø&Ò>Ð*>Ð@SÐTó%˜	ô $AÀÈ!ÁÈgÐW`Ó#aÑ �˜Ù0´ÀÓ1MÔNØ×&Ñ& vÔ.Ø!×(Ñ(¨Õ2ð" Ÿ™×5Ò5¼#¸d¿j¹j×>NÑ>NÓ:OÐSTÒ:TÜ/°Ö7Ø#×*Ñ*¨6Ö2òy<3ðD	3ðP #ó W	PˆAØÐ*Ñ*ØÜ-¨m¸AÑ.>Ó?ˆOÜ˜o¬yÔ9ð *¨!Ñ,�	Ø%ò 7�AØÐ-Ñ-Ø Ø"/°Ñ"2�KÙ-Ü&7¸Ó&D˜Ü& {À5ÔI�FÙ4´_À[Ó5QÕRÜ+HØ$ Q™Kð,ä.¨y¸6¸(ÐRVÔWò,Ñ(˜ ð &×,Ñ,¨XÕ6ð7ð ð
 )+ˆJØ*,ˆLØ,×2Ñ2ó 56�	Ü'¨	Ô2ð ×%Ñ% x°¡{°IÐ&>Ô?ä-Ô.MÈiÐY]Ó.^Ó_�	Ø%ó .6�AØÐ-Ñ-Ø š6Ø$ä.¨yÔ9ÔBUØ)¨!Ñ,ôCð
 '×-Ñ-¨x¸©{¼OÈIÓ<VÐ.WÕXà&×-Ñ-¨x¸©{¸IÐ.FÔGØ Ø"/°Ñ"2�KÙ-Ü&7¸Ó&D˜ä@bØ! ;Ð<RôAÑ=Ð(Ð*=ð ,Ð3Ø.AÐA˜¡)ä/@Ü;Ð<PÐRVÓWó0Ð,ô .?Ø0Ü& {À5ÔIÐJØ$8Ø*.ô	.Ñ*˜ ð /Ð:Ü&;¸WÐFYÐ<ZÓ&[˜GÜ(=¸yÐJ]Ð>^Ó(_˜Iä'DØ  ™ W¨ió(Ñ$�F˜Hô &¤o°iÓ&@Ä'ÔJð #×)Ñ)¨&Ô1Ù4´_À[Ó5QÖRØ$×+Ñ+¨HÖ5ò].6ð56ðn ×ÑÔ>¸zÓJÔKØ× Ñ Ô!@ÀÓ!NÖOðoW	Pðv ó 9	3ˆAØ  ™ˆIä˜9¤hÔ/Ü& y×'7Ñ'7¸ÔIÜ˜	Ÿ™Ó'¨1Ò,à$-§N¡N°1Ñ$5Ñ!Ü˜I¤zÔ2°y·~±~ÈÒ7TØ$-§N¡NÑ!àä)¨-¸Ñ*:Ó;ˆKÜ˜+¤xÔ0´ZÀ×@PÑ@PÔR]Ô5^ð à!ó %3�Ø˜’6ØØ ‘{�à%)×%@Ñ%@ÀÈqÑAQÓ%RÐ"Ø%Ð-ØÜœoÐ.@×.EÑ.EÓFÌÔPð à×+Ñ+Ð,=Ó>�Ø%)×%MÑ%MØÐ1Ð2Ð4Eó&Ñ"�˜ð Ð&Ø*×9Ò9Ü)¨'Ð3E×3JÑ3JÔKô .Ó/�Gä#@Ø% w°	ó$Ñ �˜ô " $¬Ô0´ZÀÇ	Á	Ì8Ô5Tð —I‘I×&Ò&àð ð
 ×"Ñ" 6Ô*Ûà!×(Ñ(¨Ö2òK%3ð)9	3ôz 2°+ÌÈHËÐXYÑHYÔZˆÜ2°=ÓAˆØ�xÐÐùòU !ds   Á5YÂ	Yc                ó”   — |g}|j                  «       D ]&  \  }}|j                  | j                  ||«      «       Œ( 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+  Ú	new_typesÚall_mappingsr  r  s        r   rã  z%TypeChecker.propagate_up_typemap_info¦  sO   € ð* "�{ˆØ(Ÿ™Ó0ò 	K‰OˆD�)Ø×Ñ × 8Ñ 8¸¸yÓ IÕJð	Kä/°ÀtÔLÐLr  c                ó  ‡ ‡
‡‡‡— i }	 t        |t        «      rB‰ j                  |j                  |«      Š‰ j	                  ‰«      }|j
                  Šdˆˆˆ fd„}n¤t        |t        «      r’‰ j                  |j                  |«      Š‰ j	                  ‰«      }‰ j                  |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 ]7  } |t        |«      «      }	|	€|c S t        |	|«      sŒ'|j!                  |«       Œ9 |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'.
        c                ó°   •— ‰j                   j                  «       5 }t        ‰| ‰ddd| ‰d¬«	      }d d d «       j                  «       ry S # 1 sw Y   ŒxY w)NF)	rÊ  rH  rï  rI  rJ  rK  rL  r5  Úin_literal_context)rH  r°  r%   rÚ  )Únew_parent_typeÚwÚmember_typeÚmember_nameÚparent_exprr+  s      €€€r   Úreplay_lookupz6TypeChecker.refine_parent_types.<locals>.replay_lookupØ  sf   ø€ ØŸ™×/Ñ/Ó1ð °QÜ&;Ø!,Ø /Ø$/Ø&+Ø%*Ø(-Ø*9Ø $Ø/4ô
'˜÷ð ×'Ñ'Ô)Ø#à*Ð*÷ð ús   œAÁAc                ó¦   •— t        | t        «      sy 	 ‰€J ‚‰D �cg c]  }| j                  |   ‘Œ }}t	        |«      S c c}w # t        $ r Y y w xY wr'  )rÌ  rê   rÐ  r„  rÏ   )ræ  rô  Úmember_typesÚstr_literalss      €r   rë  z6TypeChecker.refine_parent_types.<locals>.replay_lookupø  sd   ø€ Ü)¨/¼=ÔIØ#'ð(Ø#/Ð#;Ð;Ð#;ØR^Ö+_È3¨O×,AÑ,AÀ#Ó,FÐ+_˜LÐ+_ô  5°\ÓBÐBùò ,`øÜ'ò (Ù#'ð(ús   ”A œ?²A ¿A Á	AÁAc                ó,  •— t        | t        «      r,	 ‰€J ‚‰D �cg c]  }| j                  |   ‘Œ }}t	        |«      S t        | t
        «      r3| j                  j                  dv r| j                  r| j                  d   S y c c}w # t        $ r Y y w xY w)N)ré  r7  r   )	rÌ  rç   rÐ  Ú
IndexErrorrÏ   rá   r­  r   r�  )ræ  rô  rí  Úint_literalss      €r   rë  z6TypeChecker.refine_parent_types.<locals>.replay_lookup  s¨   ø€ Ü)¨/¼9ÔEð!0Ø+7Ð+CÐ$CÐ+CàNZö4&ØGJ¨×(=Ñ(=¸cÓ(Bð4& Lð 4&ô
 (=¸\Ó'JÐ Jä *¨?¼HÔ EØ$3×$8Ñ$8×$AÑ$AØ#Fñ%Gà$3×$8Ò$8à'6×';Ñ';¸AÑ'>Ð >Ø#'ùò4&øô (2ò !0Ù+/ð!0ús!   “B ›B±B ÂB Â	BÂB)ræ  ræ   r/  úType | None)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ë  rx  Únew_parent_typesrØ  rè  rñ  ré  rê  rî  s   `         @@@@r   rà  zTypeChecker.refine_parent_typesÀ  s›  ü€ ð *,ˆð ô
 ˜$¤
Ô+Ø"×@Ñ@ÀÇÁÈFÓS�Ø"×6Ñ6°{ÓC�Ø"Ÿi™i�÷+ð +ô$ ˜D¤)Ô,Ø"×@Ñ@ÀÇÁÈFÓS�Ø"×6Ñ6°{ÓC�à×2Ñ2°4·:±:¸vÔFØ!×5Ñ5°d·j±jÓA�
ØÐ%Ø!�MäAÀ*ÓM�ØÐ+öCô $FÀjÓ#Q�LØ#Ð/ö(ð(  &˜à�ð Ð"Ø�ô *¨+Ó6ˆKÜ˜k¬9Ô5Ø�ð  "ÐÜ-¨k×.?Ñ.?Ó@ò 2�Ù+¬O¸DÓ,AÓB�ØÐ&ð "’Mä'¨°YÕ?Ø$×+Ñ+¨DÕ1ð2ñ $Ø�àˆDÜ.CÐDTÓ.UÐUˆI˜˜{Ñ+ñc r  c                óð   — t        |t        «      ret        |j                  t        «      r| j                  |j                  |«       | j	                  |j                  «      }t        |«      }|�|||<   |S |S )zéAdd 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_assignmentsA  si   € ô �dœNÔ+Ü˜$Ÿ*™*¤nÔ5Ø×2Ñ2°4·:±:¸xÔHØ ×4Ñ4°T·Z±ZÓ@ˆMÜ)¨$Ó/ˆKØÐ(Ø(5�˜Ñ%ØÐØˆr  c                ó,  — t        |t        «      syt        |j                  d«      syt	        |j
                  «      dk7  ry|j
                  d   }t        |«      t        k7  ry| j                  |«      sy| j                  | j                  |«      «      S )zIIs this expression a `len(x)` call where x is a tuple or union of tuples?Fzbuiltins.lenrˆ  r   )rÌ  ra   rª   r?  rý  r�  r:   rV   r·  r‹  r¸  )r+  r  s     r   Úis_len_of_tuplezTypeChecker.is_len_of_tupleS  sz   € ä˜$¤Ô)ØÜ! $§+¡+¨~Ô>ØÜˆt�y‰y‹>˜QÒØØ�y‰y˜‰|ˆÜ�4‹=œLÒ(ØØ�}‰}˜TÔ"ØØ×,Ñ,¨T×-=Ñ-=¸dÓ-CÓDÐDr  c                óˆ  ‡ — t        |d«      ryt        |«      }t        |t        «      r@t	        d„ |j
                  D «       «      r#|j                  j                  j                  dk(  S yt        |t        «      r|j                  j                  d«      S t        |t        «      rt	        ˆ fd„|j
                  D «       «      S y)zÆIs 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.
        r^  Fc              3  ó<   K  — | ]  }t        |t        «      –— Œ y ­wr'  )rÌ  rö   rL  s     r   rß  z7TypeChecker.can_be_narrowed_with_len.<locals>.<genexpr>o  s   è ø€ ÒB°”:˜a¤×,ÑBùr`  r7  Tc              3  ó@   •K  — | ]  }‰j                  |«      –— Œ y ­wr'  )r‹  ra  s     €r   rß  z7TypeChecker.can_be_narrowed_with_len.<locals>.<genexpr>u  s   øè ø€ ÒM¸A�t×4Ñ4°Q×7ÑMùrb  )rÅ   rú   rÌ  rç   rã  rÐ  r‘  r­  r   rá   râ  rõ   )r+  rH  Úp_typs   `  r   r‹  z$TypeChecker.can_be_narrowed_with_lenb  s�   ø€ ô !  iÔ0àÜ Ó$ˆô �eœYÔ'ÜÑB°e·k±kÔBÔBØ×-Ñ-×2Ñ2×;Ñ;Ð?OÑOÐOØÜ�eœXÔ&Ø—:‘:×&Ñ&Ð'7Ó8Ð8Ü�eœYÔ'ÜÓMÀÇÁÔMÓMÐMØr  c                óä   — | j                  |«      sy| j                  |«      }t        |«      }t        |«      }t	        |t
        «      syt	        |j                  t        «      sy|j                  S )zšIs 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æ  ra  )r+  r  r  r  s       r   Úliteral_int_exprzTypeChecker.literal_int_exprx  sc   € ð
 �}‰}˜TÔ"ØØ×$Ñ$ TÓ*ˆ	Ü% iÓ0ˆ	Ü% iÓ0ˆÜ˜+¤{Ô3ØÜ˜+×+Ñ+¬SÔ1ØØ× Ñ Ð r  c                óú  ‡ — g }t        «       }|j                  «       D ]§  \  }}}t        |t        «      r|j                  }t        |t        «      r|j                  }|dv r#|j                  |«       |j                  |«       Œf|r&|j                  dt        |«      f«       t        «       }|dv sŒ“|j                  |||gf«       Œ© |r|j                  dt        |«      f«       g }|D �]  \  }}t        ˆ fd„|D «       «      sŒt        ˆ fd„|D «       «      sŒ1|dv �r
t        «       }	g }
|D ]i  }‰ j                  |«      }|�|	j                  |«       Œ(‰ j                  |«      sŒ:t        |t        «      sJ ‚|
j                  |j                  d   «       Œk t        |	«      dkD  r|
D �ci c]  }|t        «       “Œ }}|i fgc S |	j                  «       }|t         kD  rŒ÷|
D ]B  }‰ j#                  ‰ j%                  |«      ||«      \  }}||i}||i}|j                  ||f«       ŒD �Œ@|\  }}‰ j                  |«      r||}}t'        j(                  ||«      }‰ j                  |«      }|€J ‚|t         kD  r�Œ�t        |t        «      sJ ‚‰ j#                  ‰ j%                  |j                  d   «      ||«      \  }}|j                  d   |i}|j                  d   |i}|j                  ||f«       �Œ |S c c}w )aø  Top-level logic to find type restrictions from a length check on tuples.

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

            z: tuple[int, ...]
            if 1 < len(z) < 4:
                x = z  # OK
        and report corresponding type restrictions to the binder.
        )r�  rœ  rœ  >   ú>=ú<r$  rž  ú<=rŸ  c              3  óD   •K  — | ]  }‰j                  |«      d u–— Œ y ­wr'  )r   ©rÞ  ræ  r+  s     €r   rß  z7TypeChecker.find_tuple_len_narrowing.<locals>.<genexpr>¶  s!   øè ø€ ÒMÀ�t×,Ñ,¨RÓ0¸Ô<ÑMùs   ƒ c              3  ó@   •K  — | ]  }‰j                  |«      –— Œ y ­wr'  )rú  r  s     €r   rß  z7TypeChecker.find_tuple_len_narrowing.<locals>.<genexpr>¸  s   øè ø€ Ò@°B�t×+Ñ+¨B×/Ñ@ùrb  r   rˆ  )rj  r®  rÌ  r[   ræ  r¿  r8  r¢  rã  r   rú  ra   r�  rý  rô   r=  r  rŒ  r¸  rŸ   r¬  )r+  r  ÚchainedÚ
last_groupr÷  rp  rq  rî  rÐ  Úliteral_valuesÚtuplesræ  r   ÚtplÚyes_mapÚsizer˜  r™  Úno_mapÚr_sizes   `                   r   rµ  z$TypeChecker.find_tuple_len_narrowingˆ  s  ø€ ð( ˆÜ“Uˆ
Ø#Ÿ}™}›ò 	8‰OˆB��eÜ˜$¤Ô/Ø—z‘z�Ü˜%¤Ô0ØŸ™�Ø�\Ñ!Ø—‘˜tÔ$Ø—‘˜uÕ%áØ—N‘N D¬$¨zÓ*:Ð#;Ô<Ü!$£�JØÐ?Ò?Ø—N‘N B¨¨u¨Ð#6Õ7ð	8ñ Ø�N‰N˜D¤$ zÓ"2Ð3Ô4ð ˆ	Ø ó 2	4‰IˆB�äÓMÀuÔMÔMØÜÓ@¸%Ô@Ô@Øð �\Ò!Ü!$£�Ø�Øò 2�BØ×/Ñ/°Ó3�CØ�Ø&×*Ñ*¨3Ô/Ø Ø×+Ñ+¨BÕ/Ü)¨"¬hÔ7Ð7Ð7ØŸ™ b§g¡g¨a¡jÕ1ð2ô �~Ó&¨Ò*ð BHÖH¸#˜s¤OÓ$5Ñ5ÐH�GÐHØ$ b˜M˜?Ò*Ø%×)Ñ)Ó+�ØÔ0Ò0àØ!ò 8�CØ(,×(<Ñ(<¸T×=MÑ=MÈcÓ=RÐTVÐX\Ó(]Ñ%�H˜gØ" H˜o�GØ! 7˜^�FØ×$Ñ$ g¨vÐ%6Õ7ò	8ð $‘��eØ×'Ñ'¨Ô.à"'¨˜%�DÜ!Ÿ™ b¨"Ó-�BØ×.Ñ.¨uÓ5�ØÐ)Ð)Ð)ØÔ2Ò2áÜ! $¬Ô1Ð1Ð1Ø$(×$8Ñ$8Ø×$Ñ$ T§Y¡Y¨q¡\Ó2°B¸ó%Ñ!�˜'ð  Ÿ9™9 Q™<¨Ð2�ØŸ)™) A™,¨Ð0�Ø× Ñ  '¨6Ð!2Ö3ðe2	4ðf Ðùò; Is   Æ,K8c                óþ  — t        |«      }t        |t        «      r| j                  |||«      S t        |t        «      r| j                  |||«      S t        |t        «      r–g }g }g }|j                  D ]]  }| j                  |«      s|j                  |«       Œ&| j                  |||«      \  }}	|j                  |«       |j                  |	«       Œ_ ||z  }||z  }t        |«      }
t        |«      }|
|fS J d«       ‚)zIDispatch tuple type narrowing logic depending on the kind of type we got.z"Unsupported type for len narrowing)rú   rÌ  rç   Úrefine_tuple_type_with_lenrá   Úrefine_instance_type_with_lenrõ   rÐ  r‹  r8  rŒ  rÏ   )r+  rH  r÷  r  Ú	yes_typesÚno_typesÚother_typesrM  ÚytÚntr˜  r™  s               r   rŒ  zTypeChecker.narrow_with_lené  s  € ä˜cÓ"ˆÜ�cœ9Ô%Ø×2Ñ2°3¸¸DÓAÐAÜ˜œXÔ&Ø×5Ñ5°c¸2¸tÓDÐDÜ˜œYÔ'ØˆIØˆHØˆKØ—Y‘Yò $�Ø×4Ñ4°QÔ7Ø×&Ñ& qÔ)ØØ×-Ñ-¨a°°TÓ:‘��BØ× Ñ  Ô$Ø—‘ Õ#ð$ð ˜Ñ$ˆIØ˜Ñ#ˆHÜ,¨YÓ7ˆHÜ+¨HÓ5ˆGØ˜WÐ$Ð$à>Ð>Ó>�5r  c                óÜ  — t        |j                  «      }|€8t        |   } ||j                  «       |«      r|t	        «       fS t	        «       |fS |j                  |   }t        |t        «      sJ ‚t        |j                  «      }t        |t        «      rä|j                  «       dz
  |j                  z   }|dv r||k  r||fS t	        «       |fS |dv r†|dk(  r|dz  }||k  rk|j                  d| }	|j                  |dz   d }
t        |j                  ||j                  «       z
  dz   ¬«      «      }||j                  |	|gz   |
z   ¬«      fS t	        «       |fS | j                  |t        |   |«      \  }}||fS t        |t        «      r|j                  j                  dk(  sJ ‚|j                  «       dz
  }|j                   d	   }|j                  d| }	|j                  |dz   d }
|dv r2||k  r!|j                  |	|g||z
  z  z   |
z   ¬«      |fS t	        «       |fS |dv r«|dk(  r|dz  }||k  r�|j                  |	|g||z
  z  z   |gz   |
z   ¬«      }g }t#        ||z
  «      D ]-  }|j%                  |j                  |	|g|z  z   |
z   ¬«      «       Œ/ t'        j(                  ||j*                  |j,                  «      |fS t	        «       |fS | j                  |t        |   |«      \  }}||fS )
z-Narrow a TupleType using length restrictions.Nrˆ  ©rœ  r�  ©r  r  r  )Úmin_lenrˆ  r7  r   )rø   rÐ  r    r¢  rô   rÌ  rö   rú   r­  rñ   r  ro  r  r¡   rá   r   r�  r�  r8  rõ   rR  rŽ  r   )r+  rH  r÷  r  Úunpack_indexr�  Úunpackr;  r  r  Úsuffixr˜  r™  r÷  Ú	yes_itemsrù  s                   r   r  z&TypeChecker.refine_tuple_type_with_len  sD  € ä*¨3¯9©9Ó5ˆØÐô & bÑ)ˆFÙ�c—j‘j“l DÔ)ØœOÓ-Ð-Ð-Ü"Ó$ cÐ)Ð)Ø—‘˜<Ñ(ˆÜ˜&¤*Ô-Ð-Ð-Ü" 6§;¡;Ó/ˆÜ�hÔ 0Ô1ð —j‘j“l QÑ&¨×)9Ñ)9Ñ9ˆGØ�\Ñ!Ø˜d’?Ø ˜8�OÜ&Ó(¨#Ð-Ð-Ø�{Ñ"Ø˜’:Ø˜A‘I�DØ˜T’>Ø ŸY™Y }¨Ð5�FØ ŸY™Y |°aÑ'7Ð'9Ð:�Fä'¨×(>Ñ(>ÀtÈcÏjÉjËlÑGZÐ]^ÑG^Ð(>Ó(_Ó`�FØ × 1Ñ 1¸À&ÀÑ8IÈFÑ8RÐ 1Ó SÐSÐSÜ&Ó(¨#Ð-Ð-à$(×$CÑ$CÀCÌÐQSÉÐVZÓ$[Ñ!�˜'Ø Ð(Ð(ô ˜(¤HÔ-°(·-±-×2HÑ2HÐL\Ò2\Ð\Ð\Ø—*‘*“, Ñ"ˆØ�m‰m˜AÑˆØ—‘˜=˜LÐ)ˆØ—‘˜<¨!Ñ+Ð-Ð.ˆØ�ÑØ˜$Šà×(Ñ(¨v¸¸ÀÈÁÑ8PÑ/PÐSYÑ/YÐ(ÓZÐ\_Ð_Ð_Ü"Ó$ cÐ)Ð)Ø�;ÑØ�TŠzØ˜‘	�Ø˜Š~ð ×+Ñ+Ø  C 5¨D°7©NÑ#;Ñ;¸v¸hÑFÈÑOð ,ó �ð �	Ü˜t g™~Ó.ò [�AØ×$Ñ$ S×%6Ñ%6¸VÀsÀeÈaÁiÑ=OÐRXÑ=XÐ%6Ó%YÕZð[ä ×+Ñ+¨I°s·x±xÀÇÁÓLÈgÐUÐUÜ"Ó$ cÐ)Ð)à $× ?Ñ ?ÀÄWÈRÁ[ÐRVÓ WÑˆH�gØ˜HÐ$Ð$r  c                óŽ  — t        || j                  d«      «      }|j                  d   }t        | j                  j
                  v xr |j                  j                  dk(  }|dv rt        |g|z  |¬«      |fS |dv r©|dk(  r|dz  }|r2t        | j                  d|g«      «      }t        |g|z  |gz   |¬«      }n|}|rag }	t        |«      D ]"  }
|	j                  t        |g|
z  |¬«      «       Œ$ t        j                  |	|j                  |j                   «      }||fS |}||fS | j#                  |t$        |   |«      \  }}||fS )	z5Narrow a homogeneous tuple using length restrictions.r7  r   r  )rÐ  r#  r  r  rˆ  ©r#  )r<   Úlookup_typeinfor�  r¢   rZ  Úenable_incomplete_featurer­  r   rç   rö   r®  r�  r8  rõ   rR  rŽ  r   r  r¡   )r+  rH  r÷  r  r¹  r÷  Úallow_preciser  r™  rÐ  rù  r˜  s               r   r  z)TypeChecker.refine_instance_type_with_lenE  sk  € ô )¨¨d×.BÑ.BÐCSÓ.TÓUˆØ�i‰i˜‰lˆô   4§<¡<×#IÑ#IÐIò4à�h‰h×ÑÐ#3Ñ3ð 	ð �Ñä C 5¨4¡<¸#Ô>ÀÐCÐCØ�;ÑØ�TŠzØ˜‘	�ÙÜ# D×$;Ñ$;Ð<LÈsÈeÓ$TÓU�Ü )°°¸±À¸xÑ0GÐRUÔ V‘à�ÙØ�Ü˜t›ò E�AØ—L‘L¤¨C¨5°1©9¸sÔ!CÕDðEä!*×!5Ñ!5°e¸S¿X¹XÀsÇzÁzÓ!R�ð ˜WÐ$Ð$ð �Ø˜WÐ$Ð$à $× BÑ BÀ3ÌÐPRÉÐUYÓ ZÑˆH�gØ˜HÐ$Ð$r  )r;  r¿  r%  c                ó   — y r'  r  )
r+  rÂ  rÄ  rï  rH  rÁ  rÃ  r;  r¿  r%  s
             r   r±  zTypeChecker.check_subtypei  s   € ð r  )r;  r%  c                ó   — y r'  r  )	r+  rÂ  rÄ  rï  rH  rÁ  rÃ  r;  r%  s	            r   r±  zTypeChecker.check_subtypex  s   € ð r  c               ó˜  — t        ||| j                  ¬«      ryt        |t        «      rt	        ||¬«      }| j
                  j                  «       s|�.| j                  j                  |«      s| j                  ||«       y|}
t        |«      }|}t        |«      }| j
                  j                  ||||||«      ryg }d}|xs g }|€|�Ät        |
|| j                  ¬«      \  }}|�|j                  |dz   |z   «       |�|j                  |dz   |z   «       t        |	xs ||||«      }t        |t        «      rt        |t        «      rt!        |||«      }t        |t"        «      r(t        |t"        «      rt%        |||| j                  «      }|r&|j'                  ddj)                  |«      z   d	z   «      }| j                  ||«      }|D ]*  }| j
                  j+                  |||j,                  ¬«       Œ, |r| j+                  |||j,                  ¬«       | j
                  j/                  ||||j,                  ¬«       t        |t        «      rZ|j0                  j2                  rDt        |t4        t        t6        t8        t:        f«      r| j
                  j=                  ||||¬
«       t        |t4        «      rJt        |t        «      r:t?        d||d¬«      }|r)| j
                  jA                  ||||j,                  ¬«       t        |t4        tB        f«      r’t        |t        «      r‚|j0                  j2                  rld|j0                  jD                  v rTt?        d||d¬«      }|€J ‚t        ||| j                  ¬«      s)| j
                  jA                  ||||j,                  ¬«       | jG                  ||||j,                  ¬«       y)zBGenerate an error if the subtype is not compatible with supertype.rœ  Tr¾  FÚ ú z (z, rÉ  )Úparent_errorrG  rw  )$r¸   rZ  rÌ  rm  r?   rH  Úprefer_simple_messagesrG  Ú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ï  rH  rÁ  rÃ  r;  r¿  r%  Úorig_subtypeÚorig_supertypeÚ
extra_infoÚnote_msgÚsubtype_strÚsupertype_strÚerrorré  r�  s                      r   r±  zTypeChecker.check_subtype†  sJ  € ô �g˜y°$·,±,Õ?Øä�cœ3ÔÜ˜s¨Ô.ˆCð �H‰H×+Ñ+Ô-ØÐØ—K‘K×5Ñ5°dÔ;à�I‰I�c˜7Ô#ØàˆÜ! 'Ó*ˆØ"ˆÜ# IÓ.ˆ	Ø�8‰8×:Ñ:Ø�Y ¨¨m¸_ô
ð Ø "ˆ
ØˆØ’˜ˆØÐ$¨Ð(CÜ)?Ø˜n°d·l±lô*Ñ&ˆK˜ð Ð(Ø×!Ñ! -°#Ñ"5¸Ñ"CÔDØÐ*Ø×!Ñ! /°CÑ"7¸-Ñ"GÔHÜ.ØÒ( ¨'°9¸móˆHô ˜'¤8Ô,´¸IÄxÔ1PÜ/°°wÀ	ÓJ�Ü˜'¤9Ô-´*¸YÌ	Ô2RÜ)¨%°¸)ÀTÇ\Á\ÓR�ÙØ×)Ñ)¨$°·±¸:Ó1FÑ*FÈÑ*LÓMˆCà—	‘	˜#˜wÓ'ˆØò 	8ˆDØ�H‰H�M‰M˜$ ¨c¯h©hˆMÕ7ð	8áØ�I‰I�h ¨c¯h©hˆIÔ7Ø�‰×0Ñ0°¸)ÀWÐSV×S[ÑS[Ð0Ô\ä�y¤(Ô+Ø—‘×*Ò*Ü˜7¤\´8¼YÌÔW_Ð$`Ôaà�H‰H×-Ñ-¨g°yÀ'ÐX]Ð-Ô^Ü�i¤Ô.´:¸gÄxÔ3PÜ˜z¨7°GÈÔNˆDÙØ—‘×"Ñ" 7¨D°'ÀÇÁÐ"ÔIÜ�g¤¬jÐ9Ô:¼zÈ)ÔU]Ô?^Ø�~‰~×)Ò)¨j¸I¿N¹N×<[Ñ<[Ñ.[Ü" :¨y¸'ÈtÔT�ØÐ'Ð'Ð'Ü! '¨4¸¿¹ÕFØ—H‘H×&Ñ& y°$¸ÀcÇhÁhÐ&ÔOØ×)Ñ)¨'°9¸gÈCÏHÉHÐ)ÔUØr  c                ó
  — t        t        |«      t        «      ry	 | j                  j	                  |t        «       dd¬«      }|j                  «       ryt        t        |«      t        t        f«      ry|S # t        $ r Y yw xY w)zªIf 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.
        Nr)  T)Úignore_binder)
rÌ  rú   rå   rƒ  r„  rd   r„  rÚ  rÛ   ró   )r+  rH  rá  Úaw_types       r   Úget_precise_awaitable_typez&TypeChecker.get_precise_awaitable_typeØ  s‚   € ô ”o cÓ*¬KÔ8àð	Ø×'Ñ'×<Ñ<Ø”W“Y °$ð =ó ˆGð ×&Ñ&Ô(ØÜ”o gÓ.´¼+Ð0FÔGØØˆøô ò 	áð	ús   œ'A6 Á6	BÂBc              #  óJ   K  — d| _         	 d –— d| _         y # d| _         w xY w­wr  )rz  r‚  s    r   Úchecking_await_setzTypeChecker.checking_await_setî  s&   è ø€ à&*ˆÔ#ð	0Ûà*/ˆDÕ'ø¨%ˆDÕ'üs   ‚#‹ �#—	  #c                ó¶  — | j                   ry| j                  «       5  | j                  j                  «       5 }| j	                  ||«      }|€	 ddd«       ddd«       y| j                  |||t        j                  ¬«      s	 ddd«       ddd«       y	 ddd«       ddd«       | j                  j                  ||«       y# 1 sw Y   Œ.xY w# 1 sw Y   Œ2xY w)z7Check if the given type becomes a subtype when awaited.N)rH  )	rz  r@  rH  r°  r>  r±  r   ÚINCOMPATIBLE_TYPESÚpossible_missing_await)r+  rÂ  rÄ  rï  r¿  rá  r=  s          r   r3  z(TypeChecker.check_possible_missing_awaitö  sÔ   € ð ×&Ò&àØ×$Ñ$Ó&ñ 	¨¯©×(>Ñ(>Ó(@ð 	ÀLØ×5Ñ5°g¸|ÓLˆGØˆØ÷	÷ 	ð 	ð ×%Ñ%Ø˜ GÔ1A×1TÑ1Tð &ô ð ÷	÷ 	ð 	ð÷		÷ 	ð 	�‰×'Ñ'¨°Õ6÷	ð 	ú÷ 	ð 	ús4   žC¹CÁCÁ $CÂCÂCÃC	ÃCÃCc                óš  — |dk(  r:t         j                  €| j                  |«      t         _        t         j                  S |dk(  r:t         j                  €| j                  |«      t         _        t         j                  S |dk(  r:t         j                  €| j                  |«      t         _        t         j                  S |dk(  r:t         j
                  €| j                  |«      t         _        t         j
                  S |dk(  r:t         j                  €| j                  |«      t         _        t         j                  S | j                  |«      S )zœReturn an instance type with given name and implicit Any type args.

        For example, named_type('builtins.object') produces the 'object' type.
        r›  r  úbuiltins.intr¿  r-  )rý   r˜  Ú_named_typerË   r�  Ú	bool_typera  rö  s     r   r¯  zTypeChecker.named_type  s  € ð
 �>Ò!Ü×&Ñ&Ð.Ø*.×*:Ñ*:¸4Ó*@”Ô'Ü!×*Ñ*Ð*ØÐ&Ò&Ü×+Ñ+Ð3Ø/3×/?Ñ/?ÀÓ/E”Ô,Ü!×/Ñ/Ð/Ø�>Ò!Ü×&Ñ&Ð.Ø*.×*:Ñ*:¸4Ó*@”Ô'Ü!×*Ñ*Ð*Ø�?Ò"Ü×'Ñ'Ð/Ø+/×+;Ñ+;¸DÓ+A”Ô(Ü!×+Ñ+Ð+ØÐ$Ò$Ü×)Ñ)Ð1Ø-1×-=Ñ-=¸dÓ-C”Ô*Ü!×-Ñ-Ð-Ø×Ñ Ó%Ð%r  c                óz  — | j                  |«      }|j                  }t        |t        «      r2t        |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   r"  rá   r­  r—   rÛ   rì   Úfrom_omitted_genericsrý  r  ri  )r+  rÊ  r  r  r<  s        r   rF  zTypeChecker._named_type"  s�   € à×#Ñ# DÓ)ˆØ�x‰xˆÜ�dœIÔ&Ü˜dŸk™k¬8Ô4Ð4Ð4Ø—;‘;×#Ñ#ˆDÜ˜$¤Ô)Ð/¨4Ó/Ð)Üœ9×:Ñ:Ó;ˆÜ˜˜x˜j¬3¨t¯y©y×/BÑ/BÓ+CÑCÓDÐDr  c                óv   — | j                  |«      }|D �cg c]  }t        |«      ‘Œ }}t        ||«      S c c}w )z¿Return 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.
        )r#  r+   rá   )r+  rÊ  r�  r4  r÷  s        r   r®  zTypeChecker.named_generic_type-  s@   € ð ×#Ñ# DÓ)ˆØBFÖG¸3Ô1°#Õ6ÐGˆÐGä˜˜dÓ#Ð#ùò Hs   –6c                ón   — | j                  |«      }|j                  }t        |t        «      sJ |«       ‚|S r'  )rI  r  rÌ  r—   )r+  r   r  r  s       r   r#  zTypeChecker.lookup_typeinfo8  s5   € à×#Ñ# HÓ-ˆØ�x‰xˆÜ˜$¤Ô)Ð/¨4Ó/Ð)Øˆr  c                ó$   — | j                  d«      S )zReturn instance type 'type'.r8  ©r¯  r‚  s    r   r^  zTypeChecker.type_type?  s   € à�‰˜Ó/Ð/r  c                ó$   — | j                  d«      S )zReturn instance type 'str'.r›  rN  r‚  s    r   r˜  zTypeChecker.str_typeC  s   € à�‰˜~Ó.Ð.r  c                ó(   — || j                   d   |<   y)z)Store the type of a node in the type map.rŒ  N)r7  )r+  r  rH  s      r   rÁ  zTypeChecker.store_typeG  s   € à$'ˆ�‰˜Ñ˜DÒ!r  c                óR   ‡— t        ˆfd„t        | j                  «      D «       «      S )Nc              3  ó&   •K  — | ]  }‰|v –— Œ
 y ­wr'  r  )rÞ  rž  r  s     €r   rß  z'TypeChecker.has_type.<locals>.<genexpr>L  s   øè ø€ Ò@ �4˜1”9Ñ@ùs   ƒ)rã  r#  r7  r–  s    `r   r·  zTypeChecker.has_typeK  s   ø€ ÜÓ@¤h¨t¯©Ó&?Ô@Ó@Ð@r  c                óN   — t        | j                  «      D ]  }||v sŒ||   c S  y r'  )r#  r7  )r+  r  rž  s      r   r‡  zTypeChecker.lookup_type_or_noneN  s/   € Ü˜$Ÿ/™/Ó*ò 	ˆAØ�qŠyØ˜‘w’ð	ð r  c                óz   — t        | j                  «      D ]  }|j                  |«      }|€Œ|c S  t        |«      ‚r'  )r#  r7  r¬  r„  )r+  r  rž  rM  s       r   r¸  zTypeChecker.lookup_typeT  s=   € Ü˜$Ÿ/™/Ó*ò 	ˆAØ—‘�d“ˆAØ‰}Ø’ð	ô �t‹nÐr  c                ó@   — | j                   d   j                  |«       y rÀ  )r7  r�  )r+  rµ  s     r   rÛ  zTypeChecker.store_types[  s   € Ø�‰˜Ñ×"Ñ" 1Õ%r  c                óp   — | j                   j                  xs | j                   xs | j                  d    S )zÁShould we type-check the current function?

        - Yes if --check-untyped-defs is set.
        - Yes outside functions.
        - Yes in annotated functions.
        - No otherwise.
        rŒ  )rZ  r  rQ  r‚  s    r   r©  zTypeChecker.in_checked_function^  s8   € ð �L‰L×+Ñ+Òc°4×3EÑ3EÐ/EÒcÈT×M_ÑM_Ð`bÑMcÐIcð	
r  c                ó
  — || j                   v r| j                   |   S | j                   j                  dd«      }|r;t        |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: )rV  r¬  rÌ  r  r~   ri  r„  )r+  rÊ  rY  Útables       r   ÚlookupzTypeChecker.lookupj  sz   € à�4—<‘<ÑØ—<‘< Ñ%Ð%à—‘× Ñ  °Ó6ˆAÙÜ! !§&¡&¬(Ô3Ð3Ð3ØŸ™Ÿ™�Ø˜5‘=Ø  ™;Ð&Ü˜_¨T¨FÐ3Ó4Ð4r  c                ó˜  — d|vr| j                  |«      S |j                  d«      }| j                  |d      }t        dt	        |«      dz
  «      D ]Q  }|j
                  j                  ||   «      }|€J d«       ‚t        |j                  t        «      sJ ‚|j                  }ŒS |d   }||j
                  v r|j
                  |   S t	        |«      dk(  rZ|d   dv rSdj                  |«      }|t        v rdj                  |d   t        |   «      }nd	}t        d
j                  ||«      «      ‚d}	t        |	j                  ||«      «      ‚)Nrô  r   rˆ  z0Internal error: attempted lookup of unknown namerŒ  r  )Úbuiltinsri  z*, e.g. add '[{} fixtures/{}]' to your testr)  zmCould not find builtin symbol '{}' (If you are running a test case, use a fixture that defines this symbol{})z0Failed qualified lookup: '{}' (fullname = '{}').)rZ  ÚsplitrX  r�  rý  ri  r¬  rÌ  r  r~   r   r@   r²  r„  )
r+  rÊ  Úpartsrù  r×  r  r“  r   Ú
suggestionrH  s
             r   rI  zTypeChecker.lookup_qualifiedw  sK  € Ø�d‰?Ø—;‘;˜tÓ$Ð$à—J‘J˜s“OˆEØ—‘˜U 1™XÑ&ˆAÜ˜1œc %›j¨1™nÓ-ò �Ø—g‘g—k‘k %¨¡(Ó+�Ø�ÐZÐ(ZÓZ�Ü! #§(¡(¬HÔ5Ð5Ð5Ø—H‘H‘ð	ð
 ˜‘9ˆDØ�q—w‘w‰Ø—w‘w˜t‘}Ð$Ü�U“˜q’ U¨1¡XÐ1GÑ%GØŸ8™8 E›?�ØÔ6Ñ6Ø!M×!TÑ!TØ˜a™Ô"9¸(Ñ"Có"‘Jð "$�JÜð-ç-3©V°D¸*Ó-Eóð ð I�Ü˜sŸz™z¨$°Ó5Ó6Ð6r  )r)  r  c             #  óŽ  K  — | j                   xr | j                   d   j                  xs |}| j                   j                  t        i ||«      «       d–— | j                  j
                  xr | xs5 | j                  j                  xr | j                  xr | j                  d   }| j                   j                  «       j                  }| j                  sê|j                  «       D ]Ö  \  }}t        |j                  t        «      r(|j                  j                  €|st        «       |_        ŒH|| j                   vrD|sB| j"                  j%                  ||| j                  «       | j                   j'                  |«       |j                  sŒ§t)        |j                  «      }||j                  k7  |_        ||_        ŒØ yy­w)z¹Enter 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)rR  r*  r8  r%  rZ  Úallow_untyped_globalsr  rQ  r=  r(  rm  rÐ  rÌ  r­  rå   rã   rS  rH  rº  r¿  rÊ   rð  )	r+  r)  r  r*  Ú
permissiverR  r&  rï  Úfixeds	            r   r¢  zTypeChecker.enter_partial_types–  sp  è ø€ ð ×&Ñ&ÒJ¨4×+=Ñ+=¸bÑ+A×+JÑ+JÒZÈ{ˆØ×Ñ×!Ñ!Ô"2°2°{ÀHÓ"MÔNÛð
 —l‘l×8Ñ8ÒIÀ¸\ò 
Ø�L‰L×+Ñ+Ò]°×0BÑ0BÒ]Àt×GYÑGYÐZ\ÑG]ð 	ð ×*Ñ*×.Ñ.Ó0×4Ñ4ˆØ×)Ò)Ø -× 3Ñ 3Ó 5ò 
)‘��WÜ˜cŸh™h¬Ô4¸¿¹¿¹Ð9NÑWaÜ'›z�C•Hà $×"7Ñ"7Ñ7Á
ØŸ™×8Ñ8¸¸gÀtÇ|Á|ÔTØ×-Ñ-×1Ñ1°#Ô6Ø—x“xÜ 2°3·8±8Ó <˜Ø38¸C¿H¹HÑ3D˜Ô0Ø#(˜�ñ
)ð *ùs   ‚FGÆ4Gc                ó¦  — | j                  |«      \  }}}|j                  €|r|s
t        «       S |S |�”| j                  sˆ|rj||   }|s| j                  j
                  si| j                  j                  ||| j                  «       | j                  j                  |«       t        |«      S | j                  |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ã   rm  rZ  ra  rH  rº  rS  r¿  rð  rÊ  rÊ   )r+  rH  rI  r  rï  Úin_scoper*  rR  s           r   Úhandle_partial_var_typez#TypeChecker.handle_partial_var_type¸  sÀ   € ð -1×,QÑ,QÐRVÓ,WÑ)ˆ�(˜MØ�8‰8Ð¡ñ Ü“zÐ!à�
àÐ(°×1KÒ1KÙØ+¨DÑ1�GÙ t§|¡|×'IÒ'IØŸ™×8Ñ8¸¸wÈÏÉÔUØ×-Ñ-×1Ñ1°$Ô7ô & cÓ*Ð*ð ×5Ñ5°d·i±iÀÔIÜ% cÓ*Ð*r  c                ó¤   ‡— ‰j                   sy‰j                   j                  xs+ t        ˆfd„‰j                   j                  dd  D «       «      S )NFc              3  óX   •K  — | ]!  }|j                  ‰j                  «      d u–— Œ# y ­wr'  )r¬  rÊ  )rÞ  r¹  r&  s     €r   rß  z7TypeChecker.is_defined_in_base_class.<locals>.<genexpr>Ö  s(   øè ø€ ò /
Ø/3ˆD�H‰H�S—X‘XÓ dÔ*ñ/
ùs   ƒ'*rˆ  )r4  r7  rã  r¶  )r+  r&  s    `r   Úis_defined_in_base_classz$TypeChecker.is_defined_in_base_classÓ  sG   ø€ Ø�xŠxØØ�x‰x×'Ñ'ò 
¬3ó /
Ø7:·x±x·|±|ÀAÀBÐ7Gô/
ó ,
ð 	
r  c                ó6   — | j                  |«      \  }}}|r|S y)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)re  )r+  r&  rf  r  rR  s        r   r­  zTypeChecker.find_partial_typesÚ  s'   € ð &*×%JÑ%JÈ3Ó%OÑ"ˆ�!�]ÙØ Ð Ør  c                óì  — t        | j                  «      D ]Ü  }||j                  v sŒ| j                  j                  }t        |j                  t        «      r$|j                  j                  �|j                  rd}t        |j                  t        «      r|j                  j                  €d}| xs& |j                  | j                  d   j                  k(  }||j                  |j                  fc S  y)z‰Look for partial type scope containing variable.

        Return tuple (is the scope active, is the scope a local scope, scope).
        TFrŒ  )FFN)
r#  rR  r(  rZ  Úlocal_partial_typesrÌ  r­  rå   r4  r*  )r+  r&  rN  Údisallow_other_scopesÚscope_actives        r   re  z,TypeChecker.find_partial_types_in_all_scopesæ  sÖ   € ô ˜d×0Ñ0Ó1ò 	?ˆEØ�e—i‘iÒð )-¯©×(HÑ(HÐ%ô ˜cŸh™h¬Ô4¸¿¹¿¹Ð9RÐWZ×W_ÒW_ð -1Ð)Ü˜cŸh™h¬Ô4¸¿¹¿¹Ð9Nð -2Ð)ð .Ð-Òb°·±À4×CUÑCUÐVXÑCY×CbÑCbÑ1bð ð $ U§^¡^°U·Y±YÐ>Ò>ð)	?ð* "r  c                ó   — t        ||¬«      S )z3Create a temporary node with the given, fixed type.r  )r“   )r+  rM  rï  s      r   r%  zTypeChecker.temp_node   s   € ä˜ 7Ô+Ð+r  r¾  c               óÂ   — t        |t        «      r2| j                  j                  |j                  ||j
                  ¬«      S | j                  j                  |||¬«      S )zProduce an error message.r¾  )rÌ  r?   rH  r°  ræ  r¿  )r+  rH  rï  r¿  s       r   r°  zTypeChecker.fail   sH   € ô �cœ<Ô(Ø—8‘8—=‘= §¡¨G¸#¿(¹(�=ÓCÐCØ�x‰x�}‰}˜S '°ˆ}Ó5Ð5r  c               óÈ   — t        |t        «      r3| j                  j                  |j                  ||j
                  ¬«       y| j                  j                  ||||¬«       y)zProduce a note.r¾  N)Úoffsetr¿  )rÌ  r?   rH  ré  ræ  r¿  )r+  rH  rï  rs  r¿  s        r   ré  zTypeChecker.note   sG   € ô �cœ<Ô(Ø�H‰H�M‰M˜#Ÿ)™) W°3·8±8ˆMÔ<ØØ�‰�‰�c˜7¨6¸ˆÕ=r  c                óÖ   — t        |t        «      rEt        || j                  d«      «      }|j                  d   }t        t        |«      t        «      s|S | j                  ||«      d   S )Nr–  r   rˆ  )rÌ  rá   r<   r#  r�  rú   rÛ   r‹  )r+  ræ  rï  r‡  rB  s        r   rC  zTypeChecker.iterable_item_type   sa   € Ü�bœ(Ô#Ü0°°T×5IÑ5IÐJ[Ó5\Ó]ˆHØ Ÿ™ aÑ(ˆIÜœo¨iÓ8¼'ÔBð !Ð à×AÑAÀ"ÀgÓNÈqÑQÐQr  c                óX  — t        || j                  d«      «      }t        |t        «      r~|j                  rr|j
                  sf|j                  €Zt        |t        «      rJt        t        j                  «      }| j                  d|||j                  g«      }|j                  |¬«      S |S )Nr  r	  r¦  )rË   r¯  rÌ  rp   r~  r  r­  rÝ   rÛ   rì   r*  r®  r"  ro  )r+  rÓ  rH  r<  r"  s        r   rË   zTypeChecker.function_type)   s“   € Ü˜D $§/¡/Ð2EÓ"FÓGˆä�tœXÔ&Ø×!Ò!Ø×+Ò+Ø—	‘	Ð!Ü˜3¤Ô-äœy×5Ñ5Ó6ˆHØ×.Ñ.Ø" X¨x¸¿¹Ð$FóˆHð ×$Ñ$¨hÐ$Ó7Ð7Øˆ
r  r4  c               ó¼   — t        |«      r| j                  j                  «        y |j                  «       D ]#  \  }}| j                  j	                  |||¬«       Œ% y )Nr4  )r6  rI  rú  rÐ  rì  )r+  râ  r5  r  r­  s        r   r  zTypeChecker.push_type_map9   sL   € Ü˜hÔ'Ø�K‰K×#Ñ#Õ%à&Ÿn™nÓ.ò M‘
��dØ—‘—‘  d¸O�ÕLñMr  c                ó¸  — | j                  |«      }| j                  |j                  d   «      }t        |t        «      r|j
                  }t        |«      }t        |t        «      rYg }t        |j                  «      D ]3  }t        |t        «      r|j                  |j                  «       Œ/i i fc S  t        |«      }n]t        |t        «      r|j                  }n@t        |t        «      r,|j                  j                  «       r| j!                  d«      }ni i fS | j#                  |||«      \  }}t%        |||«      \  }	}
t'        t(        |	|
f«      \  }	}
|	|
fS )z=Infer type restrictions for an expression in issubclass call.rˆ  r-  )r¸  r„  r�  rÌ  rò   rM  rú   rõ   rû   rÐ  rî   r8  rØ  rá   r­  r]  r¯  rƒ  rá  r(  Úconvert_to_typetype)r+  r  r  r�  r­  Ú
union_listrM  r˜  r™  r  r  s              r   r…  z!TypeChecker.infer_issubclass_maps@   s5  € à×"Ñ" 4Ó(ˆØ×'Ñ'¨¯	©	°!©Ó5ˆÜ�gœ{Ô+Ø×)Ñ)ˆGÜ! 'Ó*ˆÜ�gœyÔ)ØˆJÜ% g§m¡mÓ4ò "�Ü˜a¤Ô*Ø×%Ñ% a§f¡fÕ-ð ˜r˜6’Mð"ô   
Ó+‰GÜ˜¤Ô*Ø—l‘l‰GÜ˜¤Ô*¨w¯|©|×/HÑ/HÔ/JØ—o‘oÐ&7Ó8‰Gð �r�6ˆMØ ×DÑDÀWÈdÐTXÓYÑˆ�'Ü7¸¸hÈÓP‰ˆ�ÜÔ1°G¸VÐ3DÓE‰ˆ�Ø˜ˆÐr  r|  c                ó   — y r'  r  ©r+  r  Útype_rangesrR  r8  r}  s         r   rƒ  z/TypeChecker.conditional_types_with_intersection^   s   € ð +.r  c                ó   — y r'  r  r{  s         r   rƒ  z/TypeChecker.conditional_types_with_intersectioni   s   € ð  r  c               ó:  — t        ||||¬«      }|d   }|d   }t        t        |«      t        «      r|€||fS t        |«      }	t        |	t        «      rt        |	j                  «       «      }
n|	g}
g }|D ]?  }t        |j                  «      }t        |t        t        f«      sŒ/|j                  |«       ŒA |s||fS g }g }|
D ]ƒ  }t        |t        «      s||fc S |D ]f  }t        |t        «      r,|j                  d|j                  j                  › d�df«       Œ?| j                  ||f|«      }|€ŒV|j                  |«       Œh Œ… |sC| j                  «       r'|D ]"  \  }}| j                  j!                  |||«       Œ$ t        «       |fS t#        |«      }||fS )Nr|  r   rˆ  r  z" and "NoneType"z"NoneType" is final)rÏ  rÌ  rú   rô   rõ   rû   rl  rØ  rá   rã   r8  r­  rÊ  r5  r¦  rH  Úimpossible_intersectionrÏ   )r+  r  r|  rR  r8  r}  Úinitial_typesr˜  r™  r  Úpossible_expr_typesÚpossible_target_typesr°  rØ  ÚoutrG  rø  rM  ÚintersectionrÓ  ÚreasonÚnew_yes_types                         r   rƒ  z/TypeChecker.conditional_types_with_intersectiont   sÉ  € ô *ØØØØ(Cô	
ˆð !.¨aÑ 0ˆØ,¨QÑ/ˆäœ/¨(Ó3´_ÔEÈÐI\Ø˜WÐ$Ð$ô & iÓ0ˆÜ�k¤9Ô-Ü"2°;×3MÑ3MÓ3OÓ"PÑà#. -Ðà "ÐØò 	3ˆBÜ" 2§7¡7Ó+ˆDÜ˜$¤¬8Ð 4Õ5Ø%×,Ñ,¨TÕ2ð	3ñ %Ø˜WÐ$Ð$àˆØ(*ˆØ$ò 
	)ˆAÜ˜a¤Ô*Ø Ð(Ò(Ø*ò )�Ü˜a¤Ô*Ø—M‘M Q q§v¡v§{¡{ mÐ3CÐ#DÐF[Ð"\Ô]ØØ#×7Ñ7¸¸A¸ÀÓG�ØÐ'ØØ—
‘
˜<Õ(ñ)ð
	)ñ à×4Ñ4Ô6Ø%+ò I‘M�E˜6Ø—H‘H×4Ñ4°U¸FÀCÕHðIä"Ó$ iÐ/Ð/Ü,¨SÓ1ˆØ˜YÐ&Ð&r  c                óþ   — t        |t        «      r|j                  r|j                  syyt        |t        «      rC|j                  r7|j
                  d   }t        |t        «      sJ ‚|j                  j                  S y)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³   sf   € ä�dœCÔ Ø×Ò¨×(AÒ(AØØÜ˜Ô/Ô0°T×5EÒ5EØŸ™ A™ˆJÜ˜j¬)Ô4Ð4Ð4Ø—>‘>×6Ñ6Ð6Ør  c                óZ  — t        |t        «      r«|j                  dk(  rœt        |j                  «      rt        t        «       d¬«      g}n| j                  |j                  d¬«      }t        |j                  «      rt        t        «       d¬«      g}n| j                  |j                  d¬«      }|�|€y||z   S |rIg }t        | j                  |«      «      D ](  }| j                  |«      }|€ y|j                  |«       Œ* |S | j                  | j                  |«      «      }|€y|gS )zrGet the type(s) resulting from an isinstance check.

        Returns an empty list for isinstance(x, ()).
        rì  Frz  )Úflatten_tuplesN)rÌ  rƒ   r÷  rÔ  rp  r    rã   r„  rq  Úflatten_types_if_tupler¸  rÐ  r8  )r+  r  rŠ  rp  rq  r|  rH  Ú
type_ranges           r   r„  zTypeChecker.get_isinstance_type¿   s   € ô �dœFÔ#¨¯©°3ªô ˜tŸy™yÔ)Ü!¤(£*¸UÔCÐD‘à×/Ñ/°·	±	È%Ð/ÓP�Ü˜tŸz™zÔ*Ü"¤8£:¸eÔDÐE‘à×0Ñ0°·±ÈEÐ0ÓR�Øˆ|˜u˜}ØØ˜%‘<ÐáØˆKÜ-¨d×.>Ñ.>¸tÓ.DÓEò /�Ø!×8Ñ8¸Ó=�
ØÐ%ÙØ×"Ñ" :Õ.ð	/ð
 Ðð ×4Ñ4°T×5EÑ5EÀdÓ5KÓLˆJØÐ!ØØ�<Ðr  c                ób  — t        |«      }t        |t        «      rt        |j                  «      }t        |t        «      r[|j
                  D �cg c]  }| j                  |«      ‘Œ }}t        |D �cg c]  }|€Œ|j                  ‘Œ c}«      }t        |d¬«      S t        |t        «      rT|j                  «       rDt        |j                  «       «      }t        |t        «      rt        |«      }n|}t        |d¬«      S t        |t         «      rqd}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$        «      rI|j&                  j,                  dk(  r0t%        |j&                  j.                  d   g «      }t        |d¬«      S t        |t$        «      rE|j&                  j,                  dk(  r,|j0                  r t        t	        |j0                  «      d¬«      S t        |t$        «      r|j&                  j,                  dk(  ry t3        | j5                  d«      |«      st        t7        «       d¬«      S y c c}w c c}w )NTrz  Fr8  rŒ  ztypes.UnionTypeztyping._SpecialForm)rú   rÌ  rò   rM  rõ   rÐ  rÐ  rÏ   rØ  r    rà   rr  r  rs  rç   r*   rî   rã   rá   r­  r¼  rÛ   r   r¶  r�  r¸   r¯  rô   )	r+  rH  rØ  r|  rM  Úany_parameterizedÚerased_typer{  ra  s	            r   rÐ  z"TypeChecker.get_type_range_of_typeä   s  € Ü˜cÓ"ˆÜ�cœ;Ô'Ü! #§/¡/Ó2ˆCä�cœ9Ô%ØILÏÉÖSÀ˜4×6Ñ6°tÕ<ÐSˆKÐSÜ(¸+Ö)W°QÈÉ¨!¯&«&Ò)WÓXˆDÜ˜T°$Ô7Ð7Ü�cœ<Ô(¨S¯_©_Ô->ä 6°s·±Ó7HÓ IÐäÐ+¬YÔ7Ü,Ð->Ó?‘à/�Ü˜[¸Ô?Ð?Ü�cœ8Ô$ð "ˆNÜ˜#Ÿ(™(¤HÔ-à!&�Ü˜#Ÿ(™(¤HÔ-°#·(±(·-±-×2HÒ2HØ!&�Ü˜SŸX™X°nÔEÐEÜ�cœ7Ô#Ü˜S°Ô7Ð7Ü�cœ8Ô$¨¯©×):Ñ):¸oÒ)MÜ" 3§8¡8§<¡<°Ñ#3°RÓ8ˆKÜ˜[¸Ô>Ð>Ü�cœ8Ô$¨¯©×):Ñ):Ð>OÒ)OÐTW×T\ÒT\ÜœY s§x¡xÓ0ÀÔGÐGÜ�cœ8Ô$¨¯©×):Ñ):Ð>SÒ)Sð Ü˜$Ÿ/™/¨/Ó:¸CÔ@äœ_Ó.¸uÔEÐEð ùòM TùÚ)Ws   ÁJ'Á2J,Á:J,c                óÎ  — t        |t        «      rt        |j                  t        «      sy| j	                  |j                  «      }| j	                  |«      }|�|€yt        |«      }t        t        |«      «      }t        |t        «      rt        |t        «      sy|j                  «       sy|j                  «       xr' |j                  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â   rr  Úis_enum_literalr#  r­  rs  )r+  rù  rõ  rè  s       r   r¬  zTypeChecker.is_literal_enum!  sÆ   € ô" ˜!œZÔ(´
¸1¿6¹6Ä8Ô0LØà×.Ñ.¨q¯v©vÓ6ˆØ×.Ñ.¨qÓ1ˆØÐ +Ð"5Øä% kÓ2ˆÜ%Ô&7¸Ó&DÓEˆÜ˜+¤|Ô4¼JÀ{ÔT_Ô<`Øà×&Ñ&Ô(Øð ×'Ñ'Ó)ò GØ×$Ñ$×)Ñ)¨[×-DÑ-DÓ-FÑFð	
r  c           
     ó  — |}t        |«      }t        t        j                  «      }t	        |t
        «      r3|j                  ||«      }|j                  €J ‚d|j                  _        |S t	        |t        «      r.|j                  j                  ||«      }|j                  |¬«      S t	        |t        «      r.|j                  j                  ||«      }|j                  |¬«      S t	        |t        «      rUt	        |j                  t
        «      r;t        j                   | j#                  |j                  |«      |j$                  ¬«      S t	        |t&        «      rU|j                  | j#                  |j(                  |«      |j*                  D �cg c]  }| j#                  ||«      ‘Œ c}¬«      S t	        |t,        «      rA| j/                  ||«      \  }}	t1        ||	D �cg c]  }| j#                  ||«      ‘Œ c}z   «      S |S c c}w c c}w )z8Inject an extra attribute with Any type using fallbacks.Nr"  )Úis_type_form)rM  r  )rú   rÛ   rì   ÚunannotatedrÌ  rá   Úcopy_with_extra_attrr,  Úmod_namerç   r‘  ro  rÝ   r#  rî   rØ  r   Úadd_any_attribute_to_typer“  rò   rM  r  rõ   Úpartition_union_by_attrrÏ   )
r+  rH  rÊ  rË  r<  r­  r#  rø  Ú	with_attrÚwithout_attrs
             r   r—  z%TypeChecker.add_any_attribute_to_type8!  sÏ  € àˆÜ˜cÓ"ˆÜœ9×0Ñ0Ó1ˆÜ�cœ8Ô$Ø×-Ñ-¨d°HÓ=ˆFð ×%Ñ%Ð1Ð1Ð1Ø*.ˆF×ÑÔ'ØˆMÜ�cœ9Ô%Ø×+Ñ+×@Ñ@ÀÀxÓPˆHØ×$Ñ$¨hÐ$Ó7Ð7Ü�cœ<Ô(Ø—|‘|×8Ñ8¸¸xÓHˆHØ×$Ñ$¨hÐ$Ó7Ð7Ü�cœ8Ô$¬°C·H±H¼hÔ)GÜ×+Ñ+Ø×.Ñ.¨s¯x©x¸Ó>ÈS×M]ÑM]ôð ô �cœ;Ô'Ø×$Ñ$Ø ×:Ñ:¸3¿?¹?ÈDÓQØILÏÉÖTÀA˜×6Ñ6°q¸$Õ?ÒTð %ó ð ô �cœ9Ô%Ø&*×&BÑ&BÀ3ÈÓ&MÑ#ˆI�|Ü(ØÐR^Ö_È3˜T×;Ñ;¸CÀÕFÒ_Ñ_óð ð ˆùò Uùò
 `s   ÆH
ÇH
c                ó  — | j                  ||«      r||ii fS t        |«      }t        |t        «      r8| j	                  ||«      \  }}|| j                  ||«      i}||t        |«      ifS | j                  ||«      }||k7  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  Úsource_typerÊ  r  rš  r  Útype_with_attrs           r   r†  zTypeChecker.hasattr_type_maps[!  s®   € ð ×#Ñ# K°Ô6Ø˜+Ð&¨Ð*Ð*ä% kÓ2ˆÜ�k¤9Ô-Ø"×:Ñ:¸;ÈÓM‰OˆAˆ|Ø˜T×;Ñ;¸KÈÓNÐOˆGØ˜TÔ#8¸Ó#FÐGÐGÐGà×7Ñ7¸ÀTÓJˆØ˜[Ò(Ø˜.Ð)¨2Ð-Ð-Ø�2ˆvˆr  c                óž   — g }g }|j                   D ]7  }| j                  ||«      r|j                  |«       Œ'|j                  |«       Œ9 ||fS r'  )rÐ  rœ  r8  )r+  r�  rÊ  r™  rš  rØ  s         r   r˜  z#TypeChecker.partition_union_by_attrt!  s\   € ð ˆ	ØˆØ×%Ñ%ò 	*ˆDØ×'Ñ'¨¨dÔ3Ø× Ñ  Õ&à×#Ñ# DÕ)ð		*ð
 ˜,Ð&Ð&r  c                óº  — t        |«      }t        |t        «      ryt        |t        «      r9|j                  r-|j                  j
                  r|j                  j                  }nd }| j                  j                  «       5 }t        ||t        t        t        j                  «      «      ddd|| d|¬«
       d d d «       j                  «        S # 1 sw Y   ŒxY w)NFT)rI  rJ  rK  rL  r5  Úno_deferralÚmodule_symbol_table)rú   rÌ  rÛ   rá   r,  r–  r­  ri  rH  r°  r%   r“   rì   r*  rÚ  )r+  rH  rÊ  rþ  r¢  Úwatchers         r   rœ  zTypeChecker.has_valid_attribute€!  sÀ   € Ü Ó$ˆÜ�eœWÔ%ØÜ�eœXÔ&¨5×+<Ò+<À×ARÑAR×A[ÒA[à"'§*¡*×"2Ñ"2Ñà"&ÐØ�X‰X×#Ñ#Ó%ð 	¨Ü!ØØÜœ¤×!7Ñ!7Ó8Ó9ØØØ!Ø!Øà Ø$7õ÷	ð ×)Ñ)Ó+Ð+Ð+÷	ð 	ús   Â6CÃCc                ó<   — | j                   j                  ||¬«      S )NrÉ  )rƒ  r«  )r+  r  r†  s      r   Úget_expression_typezTypeChecker.get_expression_type™!  s   € Ø× Ñ ×'Ñ'¨¸<Ð'ÓHÐHr  c               ó\   — | j                   |j                  j                     j                  S r'  )rX  r­  rÓ  rn  )r+  rH  s     r   Úis_defined_in_stubzTypeChecker.is_defined_in_stubœ!  s!   € Ø�|‰|˜CŸH™H×0Ñ0Ñ1×9Ñ9Ð9r  c                óL  ‡— t        ‰t        «      r‰j                  Št        ‰t        t        t
        f«      rl‰j                  �_| j                  j                  D ]3  }t        |t        «      sŒt        ˆfd„|j                  D «       «      sŒ3 y | j                  ‰|«       yyy)zEWarn if deprecated and not directly imported with a `from` statement.Nc              3  óB   •K  — | ]  }‰j                   |d    k(  –— Œ y­w)r   Nrá  )rÞ  rù  r  s     €r   rß  z/TypeChecker.check_deprecated.<locals>.<genexpr>§!  s   øè ø€ Ò6\ÈQ°t·y±yÀAÀaÁDÕ7HÑ6\ùr4  )rÌ  rf   rÓ  ro   r„   r—   Ú
deprecatedrf  Úimportsrv   rã  ri  r‘  )r+  r  rï  Úimps    `  r   Úcheck_deprecatedzTypeChecker.check_deprecatedŸ!  s‰   ø€ ä�dœIÔ&Ø—9‘9ˆDÜ�dœWÔ&7¼ÐBÔCØ�O‰OÐ'à—y‘y×(Ñ(ò 4�Ü˜c¤:Õ.´3Ó6\ÐRU×R[ÑR[Ô6\Õ3\Ùð4ð ×$Ñ$ T¨7Õ3ð (ð Dr  c                ó¶  ‡— t        ‰t        «      r‰j                  Št        ‰t        t        t
        f«      r¡‰j                  x}�’| j                  s…t        ˆfd„| j                  j                  D «       «      s\| j                  j                  r| j                  j                  n| j                  j                  } |||t        j                   ¬«       yyyyy)zWarn if deprecated.Nc              3  ó|   •K  — | ]3  }‰j                   |k(  xs ‰j                   j                  |› d �«      –— Œ5 y­w)rô  N)r   r=  )rÞ  rì  r  s     €r   rß  z.TypeChecker.warn_deprecated.<locals>.<genexpr>´!  s?   øè ø€ ò àð —‘ Ñ"ÒG d§m¡m×&>Ñ&>À!ÀÀA¸wÓ&GÓGñùs   ƒ9<r¾  )rÌ  rf   rÓ  ro   r„   r—   rª  rp  rã  rZ  Údeprecated_calls_excludeÚreport_deprecated_as_noterH  ré  r°  rç  Ú
DEPRECATED)r+  r  rï  rª  Úwarns    `   r   r‘  zTypeChecker.warn_deprecated¬!  s°   ø€ ä�dœIÔ&Ø—9‘9ˆDä�tœgÔ'8¼(ÐCÔDØ#Ÿ™Ð.�Ð;Ø×)Ò)Üó àŸ™×>Ñ>ôô ð
 %)§L¡L×$JÒ$J�4—8‘8—=’=ÐPT×PXÑPX×P]ÑP]ˆDÙ�˜W¬5×+;Ñ+;Ö<ðð *ð <ð Er  c                óT   — 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ˆ  )rb  )r+  Ú	namespacerÊ  s      r   rý  z!TypeChecker.new_unique_dummy_name¼!  s,   € à˜	�{ ! D§O¡OÐ#4Ð5ˆØ�Š˜1Ñ�Øˆr  c                ó   — y r'  r  r  s     r   Úvisit_pass_stmtzTypeChecker.visit_pass_stmtÄ!  ó   € Ør  c                ó   — y r'  r  r  s     r   Úvisit_nonlocal_declzTypeChecker.visit_nonlocal_declÇ!  r¹  r  c               óÎ  — | j                   j                  rÏ|j                  D ]¿  }| j                  j	                  |«      }|sŒ!t        |j                  t        «      sŒ<|j                  j                  €ŒSt        |«      }|j                  |_        t        |_        |j                  j                  |_        t        |«      }|€Œ£| j                  j                  |||«       ŒÁ y y r'  )rZ  r×  ri  rV  r¬  rÌ  r  r™   r­  r   rQ   rÒ  r   r   rI  r°  )r+  r  rÊ  r  rù  rH  s         r   Úvisit_global_declzTypeChecker.visit_global_declÊ!  s©   € Ø�<‰<×*Ò*àŸ™ò 	=�Ø—l‘l×&Ñ& tÓ,�Úœ: c§h¡h´Õ4¸¿¹¿¹Ñ9RÜ  ›�AØ ŸX™X�A”FÜ!�A”FØ!$§¡×!2Ñ!2�A”JÜ)¨!Ó,�CØ‘ØŸ™×/Ñ/°°3¸Õ<ñ	=ð +r  )rG  r2   rX  rW  rZ  r£   rf  r~   rg  rm  r`  r¦   r€  zdict[int, int]r/  r0  )r/  rJ  )r/  zlist[Type | None]©r/  r0  )r‘  zlist[Statement]r’  rŽ   r/  r0  ©T)rw  r.  r/  r0  r'  )
rÄ  z7Sequence[DeferredNode | FineGrainedDeferredNode] | Nonerq  r.  rw  r.  r½  r.  r/  r.  )r  z.DeferredNodeType | FineGrainedDeferredNodeTyper½  r.  r/  r0  )rÕ  zFuncDef | Decoratorr/  r0  )r  r~   r/  r0  )r  r  rè  r  r/  r0  )rÊ  rm  rï  rd   r/  r0  )rô  rŽ   r/  r0  )
r  rŽ   r  zStatement | Nonerö  úExpression | Noner÷  zCallable[[], None] | Noner/  r0  )r  r„   r/  r0  )rÕ  r…   r/  úIterator[None])rQ  rò  rR  rd   r/  úCallableType | None)rH  rè   r~  r.  r/  r.  ©rH  rè   r/  r.  )rŽ  rè   r~  r.  r/  rè   )rŽ  rè   r/  rè   )r  ro   r/  r0  )NNF)
r  rp   r©  rÂ  rÊ  ú
str | NonerË  r.  r/  r0  )r  ro   rš  rà   r/  r0  )r/  rÁ  ©F)
r  rp   rH  rÝ   rÊ  rÄ  rË  r.  r/  r0  )rØ  rp   rH  rÝ   rÊ  rÄ  r  rp   rº  rÝ   r/  r0  )rÓ  rè   r  ro   r/  r.  )rø  r™   r)  ra  r/  r.  )rH  rÝ   r/  r0  )rØ  rp   rû  úbool | Noner/  r0  )rE  rm  r/  r.  )r?  rp   r/  r0  )r?  ro   rH  rÝ   r/  r0  )
r  rp   rr  rÝ   rs  rm  rï  rd   r/  r0  )rr  rÝ   rs  rm  r~  r—   ry  rè   ru  rm  rx  rè   rï  rd   r/  r0  )r  rÝ   rx  rè   rr  rÝ   r/  r.  )r  rn   r/  r0  )rH  rè   rï  rd   rÊ  rm  r/  r0  )rH  rè   rï  rd   r/  r0  )r&  r™   rH  rè   rï  rd   r/  r0  )r  rp   rH  rÝ   r/  z#list[tuple[FuncItem, CallableType]])r  zFuncDef | OverloadedFuncDefrD  úlist[TypeInfo] | Nonerï  úContext | Noner/  r0  )r  ú'FuncDef | OverloadedFuncDef | Decoratorr/  rÇ  )r  rÉ  r¹  r—   r¸  r.  r/  rÆ  )r  r„   r¹  r—   r/  r0  )r  rÉ  rÊ  rm  r¹  r—   r/  r.  )rå  rà   r/  rò  )rÎ  rà   rÍ  rà   rÊ  rm  rû  rm  rÄ  rm  rß  r.  rÚ  r.  r  rd   r/  r.  )r  rp   r/  r0  )r  rb   r/  r0  )rH  r—   r/  r0  )r«  zSequence[TypeVarLikeType]r/  r0  )r  rb   r¹  r—   r/  r0  )r  r’   r/  r.  )
rÊ  rm  rw  r—   rm  r—   rR  r—   r/  r0  )r  rv   r/  r0  )r  rt   r/  r0  )r  rs   r/  r0  )r  ru   r/  r0  )rY  r^   r/  r0  ©r/  r.  )r¦  rŽ   r/  r.  ©r¦  r\   r/  r0  )rþ  r{   rŸ  rj   rß  r.  r/  r0  )rÈ  r™   rŸ  rj   r/  rò  )rþ  r{   rŸ  rj   r÷  rm  r/  r0  )rþ  r‰   rŸ  rj   r/  r0  )r  rè   rŸ  rj   r¹  r—   r‹  rè   ró  r€   rÞ  r.  r/  r.  )rÊ  rm  r¹  r—   rï  rd   r,  r.  r  r.  rx  r  r/  z%tuple[Type | None, SymbolNode | None])r  r™   r¹  r—   ró  úNode | Noner/  r.  )rÊ  rm  ró  rÌ  rR  rd   r/  r0  )r´  r.  r/  rÁ  )r¦  z8AssignmentStmt | OperatorAssignmentStmt | AssignmentExprr/  r0  )rþ  r{   r/  r0  )rþ  r{   rH  rò  r/  r.  )r8  rŸ  r/  rŸ  )
r�  úlist[Lvalue]rŸ  rj   rï  rd   rß  r.  r/  r0  )
r�  rÍ  re  ra  rï  rd   rf  ú
int | Noner/  r.  )TNF)r�  rÍ  rŸ  rj   rï  rd   rß  r.  rr  rò  rs  r.  r/  r0  )r�  rŸ  rŸ  rj   râ  rõ   rï  rd   rß  r.  r/  r0  )r�  rŸ  r/  rŸ  )râ  rç   r�  rÍ  r/  rç   )r�  rÍ  rŸ  rj   râ  rç   rï  rd   rs  r.  rß  r.  r/  r0  )r�  rÍ  râ  rç   r/  rè   )rÐ  zlist[T]rT  ra  r¢  ra  r/  z tuple[list[T], list[T], list[T]])r­  rè   r/  r.  )
r�  rÍ  râ  rè   rï  rd   rß  r.  r/  r0  )rþ  r{   rŸ  rÀ  r/  z0tuple[Type | None, IndexExpr | None, Var | None])r¦  r{   r/  r.  )
rÊ  r™   rþ  r{   r¼  rè   rï  rd   r/  r0  )rÊ  r™   rþ  r{   r¼  rè   r/  r.  )rM  ræ   r/  r.  )r&  r™   rþ  r{   r­  rè   r/  r0  ©r­  rè   r/  rè   )rŸ  rj   r/  r.  )r¢  rò  rŸ  rj   rÞ  rò  rß  rò  rÈ  ú
Var | Noner<  r.  r/  rè   )r¢  rò  rŸ  rj   rï  rd   rH  r?   r9  rm  r:  rm  r;  úlist[str] | Nonerþ  rÀ  rÈ  rÐ  r/  ztuple[Type, Type | None])rÊ  r   r/  r.  )rÊ  r   r³  rè   r/  r.  )rþ  r}   rä  rè   rù  rè   rŸ  rj   rï  rd   r/  ztuple[Type, Type, bool])rþ  rw   rŸ  rj   rï  rd   r/  r0  )r&  r™   rš  rè   rR  r-  r/  r0  )rþ  rw   rŸ  rj   r/  r0  )rH  rè   r¦  rk   r/  ztuple[str, ErrorCode] | None)r¦  rk   r/  r0  )r¦  rŠ   r/  r0  )r  rj   r  rè   r  r.  r/  ræ   )r¦  rr   r/  r0  )r¦  rš   r/  r0  )r¦  r‚   r/  r0  )r¦  rZ   r/  r0  )r¦  rˆ   r/  r0  )r_  rj   r¦  rˆ   rK  r.  r/  r0  )r¦  r”   r/  r0  )r¦  r”   rV  r.  r/  r0  )rù  rj   r`  r.  r/  rè   )r`  r.  r/  rè   )rÓ  zSequence[Type]r/  rè   )rH  rè   rù  rj   r/  rO  ©r¦  rm   r/  r0  )r  rj   r/  útuple[Type, Type])r­  rè   rï  rd   r/  rÓ  )r  rj   r/  rò  )rH  rè   r/  rò  )
rõ  rj   rB  rè   rß  r.  rï  rd   r/  r0  )r¦  rg   r/  r0  )r_  rf   r/  r0  ©FF)r_  rf   rË  r.  r  r.  r/  r0  )rÓ  ro   r¹  rè   rº  rj   r/  r0  ©r¦  r›   r/  r0  )rH  rè   rÓ  ro   r/  r0  )r  rj   r"  rÀ  rß  r.  r/  rè   )r¦  r_   r/  r0  )r¦  re   r/  r0  )r¦  r|   r/  r0  )r¦  r|   rÙ  rj   r/  rj   )r  rj   rH  rè   r/  rC  )rî  úlist[TypeMap]r/  údict[SymbolNode, Type])râ  r#  rï  r×  r/  r0  )r  r–   r/  r0  )
r  rm  r  rm  r  rm  r  r.  r/  ztuple[ClassDef, TypeInfo])r/  r-  rG  zlist[tuple[str, str]]r/  rc  )rH  rá   r9  rÝ   r/  rá   )rH  rá   r/  rá   )rH  rè   rE  r.  r/  útuple[list[Type], list[Type]])r  rj   rO  rò  r/  útuple[TypeMap, TypeMap])rB  rè   rK  rè   r/  rÓ  )rM  rè   r  rj   r/  r0  )r  rj   rq  r.  r/  rÙ  )r  rc   r/  rÙ  )r¼  rm  r¦  rŸ  r§  rO  r¨  z	list[int]r   zAbstractSet[int]r/  rÙ  )rá  r#  r/  r#  )r  rj   r  rè   r/  r#  )r  rj   râ  rC  r/  rj   )r  rj   r/  r.  )r  rj   r/  rÎ  )r  rc   r/  úlist[tuple[TypeMap, TypeMap]])rH  rè   r÷  rm  r  ra  r/  rÓ  )rH  rç   r÷  rm  r  ra  r/  rÓ  )rH  rá   r÷  rm  r  ra  r/  rÓ  r  )rÂ  rè   rÄ  rè   rï  rd   rH  rm  rÁ  rÄ  rÃ  rÄ  r;  rÑ  r¿  úErrorCode | Noner%  rÈ  r/  r.  )rÂ  rè   rÄ  rè   rï  rd   rH  r?   rÁ  rÄ  rÃ  rÄ  r;  rÑ  r%  rÈ  r/  r.  )rÂ  rè   rÄ  rè   rï  rd   rH  ústr | ErrorMessagerÁ  rÄ  rÃ  rÄ  r;  rÑ  r¿  rÛ  r%  rÈ  r/  r.  )rH  rè   rá  r3   r/  rò  )
rÂ  rè   rÄ  rè   rï  rd   r¿  rÛ  r/  r0  )rÊ  rm  r/  rá   )rÊ  rm  r�  rO  r/  rá   )r   rm  r/  r—   )r/  rá   )r  rj   rH  rè   r/  r0  )r  rj   r/  r.  )r  rj   r/  rò  )r  rj   r/  rè   )rµ  rC  r/  r0  )rÊ  rm  r/  r’   )r)  r.  r  r.  r/  rÁ  )
rH  rå   rI  r.  r  r™   rï  rd   r/  rè   )r&  r™   r/  r.  )r&  r™   r/  zdict[Var, Context] | None)r&  r™   r/  z,tuple[bool, bool, dict[Var, Context] | None])rM  rè   rï  rÈ  r/  r“   )rH  rÜ  rï  rd   r¿  rÛ  r/  r1   )r   )
rH  rÜ  rï  rd   rs  ra  r¿  rÛ  r/  r0  )ræ  ræ   rï  rd   r/  rè   )rÓ  rn   r/  rà   )râ  r#  r5  r.  r/  r0  )r  ra   r  rj   r/  rÙ  )r  rè   r|  úlist[TypeRange] | NonerR  rd   r8  r0  r}  r.  r/  útuple[Type | None, Type | None])r  rè   r|  rÝ  rR  rd   r8  rè   r}  r.  r/  rÓ  )r  rè   r|  rÝ  rR  rd   r8  rò  r}  r.  r/  rÞ  )r  r€   r/  r.  )r  rj   rŠ  r.  r/  rÝ  )rH  rè   r/  zTypeRange | None©rù  rj   r/  r.  )rH  rè   rÊ  rm  r/  rè   )r  rj   r�  rè   rÊ  rm  r/  rÙ  )r�  rõ   rÊ  rm  r/  rØ  )rH  rè   rÊ  rm  r/  r.  )r  rj   r†  rò  r/  rè   )rH  rá   r/  r.  )r  rÌ  rï  rd   r/  r0  )r¶  rm  r/  rm  )r  r†   r/  r0  )r  r�   r/  r0  )r  rq   r/  r0  )ýr  r  r  rE  rn  r  rl  r  rí  rm  rp  r[  r\  r,  Úpropertyrƒ  r†  rŠ  r•  r¼  rÇ  rÃ  rÎ  rÍ  ré  rð  r«  r  r  r  r   rÖ  r+  r3  r�  r†  r‹  r‘  r”  r–  r›  râ  rÔ  r™  r£  r¤  rÈ  rÎ  rÔ  r  r.  rF  r  r
  r	  r  rq  r{  r:  r  r  rš  r   rÆ  r9  r5  r·  rÅ  r¾  rä  rÒ  r¥  r2  r!  r  rÅ  r)  rK  rQ  rM  rN  r(  r  rk  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Ê  rF  rJ  rn  r!  rŽ  rm  r‘  rG  rB  rq  rž  r®  rÜ  rÐ  rÂ  rÏ  r»  rÑ  rÖ  rê  r   r  r?  rî  rï  rÓ  rÚ  r  rý  r  r  r  r"  r  r9  r<  rC  rI  rN  rL  rZ  rW  r_  rg  rj  re  r  rz  r{  r‹  rŒ  r—  rw  r¡  r%  r(  r©  r¬  rÄ  rª  rÀ  rÁ  rÓ  rÖ  rø  rÚ  rå  rÝ  rä  r  r_  r5  r>  rB  rF  rR  r[  r`  ro  r  rs  r‰  r¯  rã  rà  ró  rú  r‹  r   rµ  rŒ  r  r  r   r±  r>  r@  r3  r¯  rF  r®  r#  r^  r˜  rÁ  r·  r‡  r¸  rÛ  r©  rZ  rI  r¢  rg  rj  r­  re  r%  r°  ré  rC  rË   r  r…  rƒ  rÖ  r„  rÐ  r¬  r—  r†  r˜  rœ  r¥  r§  r­  r‘  rý  r¸  r»  r½  r  r  r   rB  rB  �  s1  … ñð €GàƒNà	Óð -Ó,ð "Ó!à3Ó3à#Ó#àƒMØÓàÓàÓà)Ó)ð Óð Óð :Ó9ØÓØ Ó ð 'Ó&à€Hà!€Ið "ÐàÐØÓð 8<ÐÐ4Ó;à"Ð�dÓ"ð Óð )Ó(ð ƒNð ƒOà)Ó)ðT.àðT.ð %ðT.ð ð	T.ð
 ðT.ð ðT.ð ðT.ð $2ðT.ð 
ôT.ðl ó"ó ð"ð ó/ó ð/ô)ô&Jö
<ð@ IMñ(ð )-Ø'+Øñ(àEð(ð "&ð	(ð
 !%ð(ð ð(ð 
ô(ðT ?ØBð ?ØOSð ?à	ô ?ôDEô.ôHô:ô _ð '+ñ;'ð
 -1Ø37ñ;'àð;'ð $ð;'ð
 *ð;'ð 1ð;'ð 
ô;'ôB2ôm5ð^ ó:ó ð:ô5ônyRôL^ô&$ô 3ôD!ôF#ôô>
'ô=ð$ .2ØØ!ñ!Jàð!Jð +ð!Jð ð	!Jð
 ð!Jð 
ô!JôF*ðX ó2ó ð2ð X]ñ]%Øð]%Ø#/ð]%Ø7Að]%ØPTð]%à	ô]%ð~DWàðDWð ðDWð ð	DWð ðDWð #ðDWð 
ôDWôL@ôDô"ö*'!ôR;ô>ô&JôP"ðHV
ØðV
Ø,8ðV
ØHKðV
ØV]ðV
à	ôV
ðp>Nà"ð>Nð ð>Nð  ð	>Nð
 ð>Nð ð>Nð ð>Nð ð>Nð 
ô>Nð@2
Ø(ð2
Ø8<ð2
ØLXð2
à	ô2
ôhMô4Nô:Wô"
ô ð!Øð!Ø#/ð!à	,ô!ð8 #'ñ	à)ðð $9ðð  ð	ð
 
ôð. )Ø;ð )à	ô )ðD'!à5ð'!ð ð'!ð '+ð	'!ð
 
ô'!ôRYðqØ;ðqØCFðqØNVðqà	ôqôfIð màðmð ðmð ð	mð
 ðmð ðmð #'ðmð #'ðmð ðmð 
ômô^3ô2M)ô^Sô.ô`Uô"ô:Xô;ô0ô8ô8'VôREð,VRØðVRØ (ðVRØ19ðVRØ@HðVRà	ôVRôpBô0$ôL ô ô ôô,#1ôJ
ôô83Aôj3ð MQñ|DØð|DØ&0ð|DØEIð|Dà	ô|Dð~ *@ÐAVÐ(WÐ ÓWô'ðR.'Øð.'Ø&0ð.'Ø69ð.'à	ô.'ô`]ð~!àð!ð ð!ð ð	!ð
 ð!ð ð!ð !%ð!ð 
ô!ðR "ØØ)-ñ:)àð:)ð ð:)ð ð	:)ð ð:)ð ð:)ð 'ð:)ð 
/ô:)ðxØðØ'ðØ4?ðà	ôðØðØ'ðØ4?ðà	ôð:=Øð=Ø$/ð=Ø6=ð=à	ô=ô("ð ó)ó ð)ô4Qôl 
ôDô&ðH #'ñRUàðRUð ðRUð ð	RUð
  ðRUð 
ôRUðr %)ñ"àð"ð ð"ð ð	"ð
 "ð"ð 
ô"ðR #'Ø#Ø!&ñ?àð?ð ð?ð ð	?ð
  ð?ð ð?ð ð?ð 
ô?ðBA&à!ðA&ð ðA&ð ð	A&ð
 ðA&ð  ðA&ð 
ôA&ôF	ð@Ø$ð@Ø/;ð@à	ô@ðJ #'ñfàðfð ðfð ð	fð
 ðfð ðfð  ðfð 
ôfôP$MðL!Øð!Ø*-ð!Ø7:ð!à	)ô!ô 
ð #'ñ=àð=ð ð=ð ð	=ð
  ð=ð 
ô=ð0 ;?ñ@3Øð@3Ø&7ð@3à	9ô@3ôDð 0FØð0FØ!'ð0FØ48ð0FØCJð0Fà	ô0Fôd*ôXô2%EôN6ô(ôð&Sà ðSð ðSð 'ð	Sð
 &ðSð ðSð ðSð 
ôSðt -×MÒMØ%Ø'ðn,ð #'Ø$(Ø#ñn,à ðn,ð ðn,ð ð	n,ð
 ðn,ð ðn,ð ðn,ð  ðn,ð "ðn,ð ðn,ð 
"ôn,ô`
ôð #Zàð#Zð ð#Zð ð	#Zð
 ð#Zð ð#Zð 
!ô#ZðJ&Øð&Ø)3ð&Ø>Eð&à	ô&ð4;Øð;Ø"&ð;Ø7Ið;à	ô;ð%PØð%PØ)3ð%Pà	ô%PôNô>
0ô"ð
"Øð"Ø*.ð"ØFJð"à	ô"ôHmIô^-ô6Fôô,%ô"öôB-Mô^,)ô\)0ôVô4ôô.
ô"	#ô"ð&Øð&Ø#*ð&à	ô&ô&ô6ð,\Øð\Ø,0ð\ØEIð\ØT[ð\à	ô\ôô$&ð PUñ_6Øð_6Ø)-ð_6ØHLð_6à	ô_6ðB	KØð	KØ'+ð	KØ7Að	Kà	ô	Kô[ô# ôJ;ð
Øð
Ø(9ð
ØNRð
à	ô
ð&ØðØ(9ðØNRðà	ôô#ôôUôn!ð$ Øð Ø%)ð à	ô ð(%Ø&ð%à	ô%ðN#Øð#Ø1Gð#à	ô#ô&.ðà!ðð ðð ð	ð
 ðð 
#ôð,ddØ2ðddØ<Qðddà	ôddôL?ô<DðT ØðT Ø,0ðT à	&ôT ðl-Øð-Ø.9ð-à	 ô-ð81PØð1PØ.2ð1Pà	ô1Pôf
ô 4Zðn ?Cñ(Øð(Ø7;ð(à	 ô(ð: ?Cñd Øðd Ø7;ðd à	 ôd ôLz_ðxk àðk ð #ðk ð "ð	k ð
  ðk ð -ðk ð 
!ôk ôZ	Mô4VðBØðØ*@ðà	ôô$Eôô,!ô _ôB?ô4@%ðD%Øð%Ø!$ð%Ø,/ð%à	ô%ðH ð %)Ø&*ñð #'Ø!%Ø(,ñàðð ðð ð	ð
 ðð "ðð $ðð  ðð ðð &ðð 
óó ðð ð %)Ø&*ñð #'Ø(,òàðð ðð ð	ð
 ðð "ðð $ðð  ðð &ðð 
ôó ðð& %)Ø&*ñPð #'Ø!%Ø(,ñPàðPð ðPð ð	Pð
  ðPð "ðPð $ðPð  ðPð ðPð &ðPð 
õPõdð, ô0ó ð0ð7Øð7Ø(,ð7Ø7>ð7ØFVð7à	õ7õ"&õ6	Eõ	$õõ0õ/õ(õAõõõ&õ

õ5õ7ð> à%*¸Uò)Ø"ð)Ø6:ð)à	ô)ó ð)ðB+Øð+Ø+/ð+Ø7:ð+ØELð+à	õ+õ6
õ
ð"Øð"à	5õ"÷<,ð
 VZò6Ø%ð6Ø07ð6ØBRð6à	õ6ð ñ	>ð "&ò>àð>ð ð>ð ð	>ð ð>ð 
õ>õ	Rõð  KO÷ Mð Mõð< ð ñ.ð -1ò.àð.ð ,ð.ð ð	.ð
 ð.ð &*ð.ð 
)ô.ó ð.ð ð -1ò àð ð ,ð ð ð	 ð
 ð ð &*ð ð 
ô ó ð ð  $ñ='ð -1ò='àð='ð ,ð='ð ð	='ð
 ð='ð &*ð='ð 
)õ='õ~
ð 8<ñ# Øð# Ø04ð# à	õ# õJ,õ\$
õL!ðFØðØ-1ðØ9<ðà	 õð2
'Ø$ð
'Ø,/ð
'à	&õ
'õ,÷2Iõ:õ4õ=õ õõö=r  rB  c                  ó  — e Zd ZU dZded<   ded<   ded<   dd„Z	 d	 	 	 	 	 	 	 dd
„Zd d„Zd!d„Zd"d„Z		 dd	ddœ	 	 	 	 	 	 	 	 	 	 	 d#d„Z
ddœd$d„Zd%d„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d*d„Zed,d„«       Zy)-Ú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.
    rB  Ú_chkúdict[str, SymbolTableNode]Ú_namesr.  Údid_failc                ó.   — || _         || _        d| _        y r<  )rã  rå  ræ  )r+  r5  ri  s      r   r,  z&TypeCheckerAsSemanticAnalyzer.__init__æ!  s   € ØˆŒ	ØˆŒØˆ�r  Fc                óN   — | j                   j                  |«      }|€J |«       ‚|S r'  )rå  r¬  )r+  rÊ  rR  r	  r  s        r   rI  z.TypeCheckerAsSemanticAnalyzer.lookup_qualifiedë!  s,   € ð �k‰k�o‰o˜dÓ#ˆð ˆÐ$ Ó$ˆØˆ
r  c               ó:   — | j                  |«      }|€J |«       ‚|S r'  )Úlookup_fully_qualified_or_none)r+  r   r  s      r   Úlookup_fully_qualifiedz4TypeCheckerAsSemanticAnalyzer.lookup_fully_qualifiedô!  s&   € Ø×1Ñ1°(Ó;ˆØˆÐ( Ó(ˆØˆ
r  c               óX   — 	 | j                   j                  |«      S # t        $ r Y y w xY wr'  )rã  rI  r„  ©r+  r   s     r   rê  z<TypeCheckerAsSemanticAnalyzer.lookup_fully_qualified_or_noneù!  s.   € ð	Ø—9‘9×-Ñ-¨hÓ7Ð7øÜò 	Ùð	ús   ‚ �	)¨)c                 ó   — y r'  r  )r+  rc  s     r   Úrecord_fixed_typez/TypeCheckerAsSemanticAnalyzer.record_fixed_typeÿ!  ó   € Ør  N)Úblockerr¿  c               ó   — d| _         y rë  )ræ  )r+  rH  rR  Úseriousrñ  r¿  s         r   r°  z"TypeCheckerAsSemanticAnalyzer.fail"  s   € ð ˆ�r  r¾  c                ó   — y r'  r  )r+  rH  rR  r¿  s       r   ré  z"TypeCheckerAsSemanticAnalyzer.note"  rð  r  c                ón   — || j                   j                  j                  vr| j                  d|«       yy)NÚ__ignored__FT)rã  rZ  r$  r°  )r+  ÚfeaturerR  s      r   Úincomplete_feature_enabledz8TypeCheckerAsSemanticAnalyzer.incomplete_feature_enabled"  s.   € Ø˜$Ÿ)™)×+Ñ+×EÑEÑEØ�I‰I�m SÔ)ØØr  c                 ó   — y r'  r  r‚  s    r   Úrecord_incomplete_refz3TypeCheckerAsSemanticAnalyzer.record_incomplete_ref"  rð  r  c                 ó   — y r'  r  )r+  Údebug_contextÚforce_progresss      r   Údeferz#TypeCheckerAsSemanticAnalyzer.defer"  rð  r  c                 ó   — yr<  r  rí  s     r   Úis_incomplete_namespacez5TypeCheckerAsSemanticAnalyzer.is_incomplete_namespace"  s   € Ør  c                 ó   — yrë  r  r‚  s    r   Úfinal_iterationz-TypeCheckerAsSemanticAnalyzer.final_iteration"  ó   € àr  c                óL   — | j                   j                  j                  |«      S r'  )rã  rf  Úis_future_flag_set)r+  Úflags     r   r	  z0TypeCheckerAsSemanticAnalyzer.is_future_flag_set#"  s   € Ø�y‰y�~‰~×0Ñ0°Ó6Ð6r  c                óB   — | j                   j                  j                  S r'  )rã  rf  rn  r‚  s    r   Úis_stub_filez*TypeCheckerAsSemanticAnalyzer.is_stub_file&"  s   € à�y‰y�~‰~×%Ñ%Ð%r  c                 ó   — yr<  r  r‚  s    r   Úis_func_scopez+TypeCheckerAsSemanticAnalyzer.is_func_scope*"  s   € ð r  c                óN   — | j                   j                  j                  «       d uS r'  )rã  rN  rì  r‚  s    r   Úis_nested_within_func_scopez9TypeCheckerAsSemanticAnalyzer.is_nested_within_func_scope2"  s   € Ø�y‰y�‰×1Ñ1Ó3¸4Ð?Ð?r  c                óJ   — | j                   j                  j                  «       S r'  )rã  rN  rx  r‚  s    r   r­  z"TypeCheckerAsSemanticAnalyzer.type5"  s   € à�y‰y�‰×,Ñ,Ó.Ð.r  )r5  rB  ri  rä  r/  r0  rÅ  )rÊ  rm  rR  rd   r	  r.  r/  úSymbolTableNode | None)r   rm  r/  r’   )r   rm  r/  r	  )rc  zTypeInfo | TypeAliasr/  r0  )rH  rm  rR  rd   ró  r.  rñ  r.  r¿  rÛ  r/  r0  )rH  rm  rR  rd   r¿  rÛ  r/  r0  )r÷  rm  rR  rd   r/  r.  r¾  r<  )rü  rÈ  rý  r.  r/  r0  )r   rm  r/  r.  rÊ  )r	  rm  r/  r.  )r/  r  )r  r  r  rE  r  r,  rI  rë  rê  rï  r°  ré  rø  rú  rþ  r 	  rà  r	  r	  r	  r
	  r	  r­  r  r  r   râ  râ  Ù!  s  … ñð ÓØ&Ó&ØƒNóð @EðØðØ%ðØ8<ðà	óóó
óð ð		ð Ø!%ñ	àð	ð ð	ð ð		ð ð	ð ð	ð 
ó	ð HLõ óóôóð òó ðó7ð ò&ó ð&óó@ð ò/ó ñ/r  râ  c                  ó    — e Zd ZdZdd„Zdd„Zy)r/  z0Collects the non-nested argument types in a set.c                ó"   — t        «       | _        y r'  )rj  r  r‚  s    r   r,  zCollectArgTypeVarTypes.__init__="  s   € Ü+.«5ˆ�r  c                ó:   — | j                   j                  |«       y r'  )r  r¿  rc  s     r   Úvisit_type_varz%CollectArgTypeVarTypes.visit_type_var@"  s   € Ø�‰×Ñ˜1Õr  Nr¾  )rM  rò   r/  r0  )r  r  r  rE  r,  r	  r  r  r   r/  r/  :"  s   „ Ù:ó1ôr  r/  TF)r}  rË  c                ó   — y r'  r  ©rO  Úproposed_type_rangesr8  r}  rË  s        r   rÏ  rÏ  D"  s   € ð '*r  c                ó   — y r'  r  r	  s        r   rÏ  rÏ  O"  s   € ð r  c               ó¦  — |€| |fS |st        «       |fS t        |«      dk(  r€|d   j                  }t        |«      }t	        |t
        «      rV|j                  «       st	        |j                  t        «      r,|j                  j                  j                  }t        | |«      } t        | «      }t	        |t        «      rdg }g }	|j                  D ]7  }
t        |
||
||¬«      \  }}|j!                  |«       |	j!                  |«       Œ9 t#        |«      }t#        |	«      }||fS t#        |D �cg c]  }|j                  ‘Œ c}«      }t	        |t        «      r|j                  n|g}t%        t        |«      «      D ]{  }t        ||   «      }t	        |t&        «      rV|j                  j(                  r@|j                  j*                  d   }t	        |t&        «      r|j                  j(                  rŒ@|||<   Œ} t        t        j,                  |«      «      }t	        |t.        «      r|| fS t	        |t.        «      r||fS t1        d„ |D «       «      stt3        | |d¬«      r|t        «       fS t	        |t4        «      s&t	        |t&        «      r:|j                  j6                  r$t9        | |d¬«      rt;        | |�|n||¬«      }||fS |rt=        |«      }t?        | |d¬«      st        «       |fS t        j,                  |D �cg c]  }|j@                  rŒ|j                  ‘Œ c}«      }t;        | ||¬«      }t3        ||d¬«      r|�|n| }||fS c c}w c c}w )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.
    rˆ  r   )r8  r}  rË  c              3  ó4   K  — | ]  }|j                   –— Œ y ­wr'  rz  )rÞ  rŒ  s     r   rß  z$conditional_types.<locals>.<genexpr>¨"  s   è ø€ ÒP¨Zˆz×(Õ(ÑPùrà  Tr  r|  )!rô   rý  rØ  rú   rÌ  râ   r‘  ræ  r.  r#  r­  r   rÑ   rõ   rÐ  rÏ  r8  rÏ   r�  rá   Ú
is_newtyper  rR  rÛ   rã  r¶   rÝ   r!  r¸   r¹   r,   r=   r{  )rO  r	  r8  r}  rË  r"  Ú	enum_nameÚp_current_typer   Úno_itemsÚ
union_itemr˜  r™  Úproposed_typeÚremaining_typerŒ  rÐ  r×  rØ  Ú	remainderÚproposed_precise_types                        r   rÏ  rÏ  Z"  s(  € ð& Ð#à˜WÐ$Ð$áäÓ  'Ð)Ð)ä
ÐÓ  AÒ%à% aÑ(×-Ñ-ˆÜ  Ó(ˆÜ�fœkÔ*Ø×"Ñ"Ô$¬
°6·<±<ÄÔ(FàŸ™×,Ñ,×5Ñ5ˆIÜ:¸<ÈÓSˆLô
 % \Ó2€Nä�.¤)Ô,Ø "ˆ	Ø!ˆØ(×.Ñ.ò 		%ˆJÜ 1ØØ$Ø"Ø,GØ+ô!ÑˆH�gð ×Ñ˜XÔ&Ø�O‰O˜GÕ$ð		%ô .¨iÓ8ˆÜ.¨xÓ8ˆØ˜nÐ,Ð,ä)ÐMaÖ*b¸z¨:¯?«?Ò*bÓc€MÜ#-¨m¼YÔ#GˆM×ÒÈmÈ_€EÜ”3�u“:Óò ˆÜ˜u Q™xÓ(ˆô ˜œxÔ(¨T¯Y©Y×-AÒ-AØ—9‘9—?‘? 1Ñ%ˆDô ˜œxÔ(¨T¯Y©Y×-AÓ-AàˆˆaŠðô $¤I×$8Ñ$8¸Ó$?Ó@€Mä�.¤'Ô*Ø˜lÐ*Ð*Ü�-¤Ô)ð ˜gÐ%Ð%ÜÑPÐ;OÔPÔPä˜\¨=ÈDÕQØœOÓ-Ð-Ð-ô �}¤lÔ3Ü˜=¬(Ô3¸×8JÑ8J×8VÒ8VÜ˜ }ÈÕMô .ØØ"Ð.‘°MØ,GôˆIð
 ˜IÐ%Ð%áô 8¸ÓFˆä ¨mÈtÕTäÓ  'Ð)Ð)ô &×0Ñ0Ø+?Öa˜ZÀz×G`ÓG`ˆ�‹ÒaóÐô +ØØØ$?ô€Nô ˜¨È$ÕOØ#*Ð#6™¸Lˆà˜.Ð(Ð(ùòy +cùò` 	bs   Ä+M	Ë<MÌMc                ó@   — t        | «      } |€i n| |i}|€i n| |i}||fS r'  )rØ  )r  r˜  r™  r  r  s        r   rá  rá  Õ"  s8   € ô ˜4Ó €DàÐ$‰b¨4°Ð*:€GØ�?‰R¨¨w¨€FØ�Fˆ?Ðr  c                óz   — | |vr| S d}| t        |«      z   |v r|dz  }| t        |«      z   |v rŒ| t        |«      z   S )zKGenerate a name that does not appear in table by appending numbers to base.rˆ  )rm  )r¹  rY  r×  s      r   r7  r7  ß"  sM   € à�5ÑØˆØ	€AØ
”�Q“‰-˜5Ñ
 Ø	ˆQ‰ˆð ”�Q“‰-˜5Ò
 à”#�a“&‰=Ðr  c                ó`   — t        | d«      xs! t        | t        «      xr | j                  dk7  S )z>Returns true if this expression is the 'True' literal/keyword.zbuiltins.Truer   ©rª   rÌ  rx   ræ  ©rù  s    r   r‚  r‚  é"  s-   € ä˜a Ó1Ò\´ZÀÄ7Ó5KÒ5\ÐPQ×PWÑPWÐ[\ÑP\Ð\r  c                ó`   — t        | d«      xs! t        | t        «      xr | j                  dk(  S )z?Returns true if this expression is the 'False' literal/keyword.r  r   r%	  r&	  s    r   r®  r®  î"  s.   € ä˜aÐ!1Ó2Ò]´jÀÄGÓ6LÒ6]ÐQR×QXÑQXÐ\]ÑQ]Ð]r  c                óD   — t        | t        «      xr | j                  dk(  S )z>Returns true if this expression is the 'None' literal/keyword.r6  ©rÌ  r   r   r&	  s    r   rÔ  rÔ  ó"  s   € ä�aœÓ"ÒD q§z¡z°_Ñ'DÐDr  c                óD   — t        | t        «      xr | j                  dk(  S )NrQ  r)	  r&	  s    r   r¯  r¯  ø"  s   € Ü�aœÓ"ÒN q§z¡zÐ5NÑ'NÐNr  c                ó~  — | j                   j                   }t        |«      dk(  xr˜ t        |d   x}t        «      xr� |j                  du xs t        |j                  «      xrZ t        |d   x}t        «      xrC t        |j                  x}t        «      xr% |j                  du xs 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‰9�>‰>€DäˆD‹	�Q‰ò 	JÜ 4¨¡7Ð*�x¬JÓ7ò	Jà�]‰]˜dÐ"ÒD¤o°h·m±mÓ&Dò	Jô  D¨¡GÐ+�y¬^Ó<ò	Jô  Y§^¡^Ð3�z´YÓ?ò		Jð
 �_‰_ Ð$ÒH¬¸
¿¹Ó(Hðr  c                ó®  — t        | «      } t        | t        «      r[| j                  j                  dv rB| j
                  syt        t        | j
                  d   «      t        «      s| j
                  d   S yt        | t        «      rßg }| j                  D ]§  }t        |t        «      r„t        |j                  «      }t        |t        «      rt        |j                  «      }t        |t        «      r|j                  j                  dk(  sJ ‚|j                  |j
                  d   «       Œ—|j                  |«       Œ© t        d„ t        |«      D «       «      rt        |«      S yt        | t         «      r`| j"                  j                  j$                  D ]6  }|j                  dk(  sŒt'        | j"                  |«      j
                  d   c S  J d«       ‚y)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é  r7  r¾  zbuiltins.frozendictrë  zbuiltins.frozensetz_collections_abc.dict_keysztyping.KeysViewNr   r7  c              3  ó>   K  — | ]  }t        |t        «       –— Œ y ­wr'  )rÌ  rÛ   )rÞ  ræ  s     r   rß  z$builtin_item_type.<locals>.<genexpr>:#  s   è ø€ ÒX¨r”:˜b¤'Ó*Ô*ÑXùr¤  útyping.Mappingz2No Mapping base class found for TypedDict fallback)rú   rÌ  rá   r­  r   r�  rÛ   rç   rÐ  rö   rñ   rM  r8  rk  rû   rÏ   rê   r#  r¶  r<   )rå  Únormalized_itemsræ  r;  r¹  s        r   r³  r³  #  s—  € ô 
˜Ó	€Bä�"”hÔØ�7‰7×Ñð 	 
ñ 	
ð —7’7àÜœo¨b¯g©g°a©jÓ9¼7ÔCØ—w‘w˜q‘zÐ!ð0 ô/ 
�Bœ	Ô	"ØÐØ—(‘(ò 	,ˆBä˜"œjÔ)Ü*¨2¯7©7Ó3�Ü˜hÔ(8Ô9Ü.¨x×/CÑ/CÓD�Hä˜x¬Ô2°x·}±}×7MÑ7MÐQaÒ7aðØaà ×'Ñ'¨¯©°aÑ(8Õ9à ×'Ñ'¨Õ+ð	,ô ÑXÔ5EÐFVÓ5WÔXÔXÜ(Ð)9Ó:Ð:ð ô 
�BœÔ	&ð —K‘K×$Ñ$×(Ñ(ò 	LˆDØ�}‰}Ð 0Ó0Ü0°·±¸dÓC×HÑHÈÑKÒKð	Lð 	KÐJÓJˆuØr  c                óB   — t        d„ | j                  «       D «       «      S )Nc              3  óN   K  — | ]  }t        t        |«      t        «      –— Œ y ­wr'  )rÌ  rú   rô   )rÞ  rø  s     r   rß  z%is_unreachable_map.<locals>.<genexpr>G#  s   è ø€ ÒUÀ1Œzœ/¨!Ó,¬o×>ÑUùó   ‚#%)rã  r  )r(  s    r   r6  r6  F#  s   € ÜÑUÈÏ
É
ËÔUÓUÐUr  r©  c               ó  — |j                  «       }|D �ci c]  }t        |«      |“Œ }}| D ]™  }t        |«      }||vr	| |   ||<   Œ|rŒ| |   }t        |«      }	t        |	t        «      r|||<   ŒD||   }t        ||   «      }
t        |
t
        «      sŒht        |	t        «      rt        d„ |	j                  D «       «      rŒ•|||<   Œ› |r;| D ]6  }|D ]/  }t        |«      t        |«      k(  sŒt        | |   ||   «      ||<   Œ1 Œ8 |S c c}w )zªCalculate 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              3  óN   K  — | ]  }t        t        |«      t        «      –— Œ y ­wr'  )rÌ  rú   rÛ   rž  s     r   rß  z'and_conditional_maps.<locals>.<genexpr>f#  s   è ø€ Ò]È4œJ¤°tÓ'<¼g×FÑ]ùr5	  )
Úcopyr;   rú   rÌ  rô   rÛ   rõ   rã  rÐ  r>   )Úm1Úm2rª  r­  Úe2Úm2_exprsÚe1Úe1_hashÚt1Úpt1Úpt2s              r   rŠ  rŠ  J#  s.  € ð �W‰W‹Y€FØ/1Ö2¨”˜RÓ  "Ñ$Ð2€HÐ2Øò $ˆÜ˜rÓ"ˆØ˜(Ñ"Ø˜B™ˆF�2‰JØâð �B‘ˆBÜ! "Ó%ˆCÜ˜#œÔ/Ø��r’
à˜gÑ&�Ü% b¨¡fÓ-�Ü˜c¤7Õ+Ü˜s¤IÔ.ÜÑ]ÐSV×S\ÑS\Ô]Õ]à!#�F˜2’Jð+$ñ. ð ò 	<ˆBØò <�Ü Ó#¤|°BÓ'7Ó7Ü!+¨B¨r©F°B°r±FÓ!;�F˜2’Jñ<ð	<ð €MùòA 3s   •Dr~  c               ó  — t        | «      r|S t        |«      r| S i }| D ]^  }|D ]W  }t        |«      t        |«      k(  sŒ|r%t        t        | |   «      t        «      r	| |   ||<   ŒBt        | |   ||   g«      ||<   ŒY Œ` |S )zúCalculate 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.
    )r6  r;   rÌ  rú   rÛ   rÏ   )r9	  r:	  r  r­  Ún1Ún2s         r   ræ  ræ  u#  s�   € ô ˜"ÔØˆ	Ü˜"ÔØˆ	ð
 &(€FØò IˆØò 	IˆBÜ˜BÓ¤<°Ó#3Ó3Ù¤J¬¸rÀ"¹vÓ/FÌÔ$PØ!# B¡�F˜2’Jä!6¸¸2¹ÀÀ2ÁÐ7GÓ!H�F˜2’Jñ	IðIð €Mr  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_mapr8  r  s         r   r´  r´  �#  s€   € ô4 ˆ9ƒ~˜ÒØ�2ˆvˆÜ	ˆY‹˜1Ò	Ø˜‰|Ðà'0°¡|Ñ$ˆ�nØ )¨!¨" ò 	KÑˆF�HÜ/°¸fÈxÔXˆLÜ0°ÀÓJ‰Nð	Kð ˜^Ð+Ð+r  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æ  )Úmsr­  rž  s      r   r±  r±  ¶#  sU   € ä
ˆ2ƒw�!‚|Øˆ	Ü
ˆ2ƒw�!‚|Ø�!‰uˆØ�‰U€FØ��ˆVò 0ˆÜ$ V¨QÓ/‰ð0à€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Š  )rI	  rª  r­  rž  s       r   r²  r²  Â#  sa   € ä
ˆ2ƒw�!‚|Øˆ	Ü
ˆ2ƒw�!‚|Ø�!‰uˆØ�‰U€FØ��ˆVò DˆÙØÜ% f¨a¸(ÔC‰ðDð €Mr  c                ó>   — t        | dd¬«      xs t        | dd¬«      S )Nrd  F)Ú	check_allre  )rÅ   ©rM  s    r   r°  r°  Ð#  s(   € Ü   H¸Ô>ò ÔBWØ	ˆ8˜uôCð r  c                ó&  — i }| j                  «       D ]{  \  }}|}t        |t        «      r|j                  }t	        |«      }t        |t
        «      r|||<   ŒEt        |t        t        t        f«      rt        j                  |«      ||<   Œyi c S  |S r'  )rÐ  rÌ  rò   rM  rú   rô   rõ   rá   rã   rî   r   )râ  Úconverted_type_mapr  rH  rM  s        r   rx  rx  Ö#  s‘   € Ø13ÐØ—^‘^Ó%ò ‰	ˆˆcØˆÜ�aœÔ%Ø—‘ˆAÜ˜AÓˆô �aœÔ)Ø'*Ð˜tÒ$Ü˜œI¤x´Ð:Ô;Ü'/×'?Ñ'?ÀÓ'DÐ˜tÒ$ð ŠIðð Ðr  c                óâ   — t        | t        t        f«      r,| j                  D ��cg c]  }t	        |«      D ]  }|‘Œ Œ c}}S t        | t
        «      rt	        | j                  «      S | gS c c}}w )zAFlatten a nested sequence of tuples/lists into one list of nodes.)rÌ  r•   rz   rÐ  r�  r�   r  ©rM  ÚarY  s      r   r�  r�  é#  sZ   € ä�!”i¤Ð*Ô+ØŸ7™7×7�a¬G°A«JÒ7 q’Ð7�Ó7Ð7Ü	�A”xÔ	 Ü�q—v‘v‹Ðàˆsˆ
ùó	 8s   ¦A+c           	     ó†  — t        | «      } t        | t        «      r@t        j                  | j                  D ��cg c]  }t        |«      D ]  }|‘Œ Œ c}}«      gS t        | t        «      r,| j                  D ��cg c]  }t        |«      D ]  }|‘Œ Œ c}}S t        | d«      r| j                  d   gS | gS c c}}w c c}}w )z;Flatten a nested sequence of tuples into one list of nodes.r7  r   )	rú   rÌ  rõ   rR  rÐ  r‹  rç   rÿ   r�  rQ	  s      r   r‹  r‹  ó#  s¨   € ä˜Ó€AÜ�!”YÔÜ×$Ñ$°·±×%\¨AÔBXÐYZÓB[Ò%\¸Q¢aÐ%\ aÓ%\Ó]Ð^Ð^Ü�!”YÔØŸ7™7×F�aÔ,BÀ1Ó,EÒF q’ÐF�ÓFÐFÜ	˜1Ð.Ô	/Ø—‘�q‘	ˆ{ÐØˆ3€Jùó &]ùãFs   ºB7
Á;B=c                ób   — t        |«      }|j                  | «      }t        |t        «      sJ ‚|S r'  )ÚTypeTransformVisitorr  rÌ  rp   )r  r(  Úvisitorr  s       r   r©  r©  ÿ#  s/   € Ü" 3Ó'€GØ
�,‰,�tÓ
€CÜ�cœ8Ô$Ð$Ð$Ø€Jr  c                  ó(   ‡ — e Zd Zdˆ fd„Zdd„Zˆ xZS )rU	  c                ó0   •— t         ‰| �  «        || _        y r'  )Úsuperr,  r(  )r+  r(  rÌ  s     €r   r,  zTypeTransformVisitor.__init__$  s   ø€ Ü‰ÑÔØˆ�r  c                ó.   — t        || j                  «      S r'  )r7   r(  r§  s     r   r­  zTypeTransformVisitor.type$  s   € Ü˜4 §¡Ó*Ð*r  )r(  údict[TypeVarId, Type]r/  r0  rÏ  )r  r  r  r,  r­  Ú__classcell__©rÌ  s   @r   rU	  rU	  $  s   ø„ õ÷+r  rU	  c                óœ   — t        | j                  |j                  «      }t        | j                  «       |j                  «       «      }||k  S )zOCan a single call match both t and s, based just on positional argument counts?)Úmaxrð  ÚminÚmax_possible_positional_args)rM  r¦  rð  Úmax_argss       r   re  re  $  s?   € ä�1—:‘:˜qŸz™zÓ*€HÜ�1×1Ñ1Ó3°Q×5SÑ5SÓ5UÓV€HØ�xÑÐr  c                ó"  — | j                   D ]ƒ  }|j                  j                  «       sŒt        | |j                  |j                  i«      j                  | j                   D �cg c]  }|j                  j                  «       rŒ|‘Œ! c}¬«      }  n | j                  «       s| gS g }| j                   D ]V  }t        |t        «      r(|j                  r|j                  |j                  «       Œ;|j                  |j                  g«       ŒX g }t        j                  |Ž D ]`  }t        | j                   |«      D ��ci c]  \  }}|j                  |“Œ }}}|j                  t        | |«      j                  g ¬«      «       Œb |S c c}w c c}}w )zRExpand a generic callable using all combinations of type variables' values/bounds.rÕ  )rl  r£  r*  r7   rM  ro  Ú
is_genericrÌ  rò   r  r8  r¦  r§  rò  )	rŸ  rC  rø  Útvar_valuesr¬  ÚvariantsÚcombinationrª  Útvar_maps	            r   Úexpand_callable_variantsri	  $  sU  € à�k‰kò ˆð �5‰5�=‰=�?Ü˜A §¡ r§~¡~Ð6Ó7×EÑEØ&'§k¡kÖH ¸¿¹¿¹½š1ÒHð Fó ˆAñ ðð �<‰<Œ>àˆsˆ
à€KØ—‘ò 3ˆÜ�dœKÔ(¨T¯[ª[Ø×Ñ˜tŸ{™{Õ+à×Ñ × 0Ñ 0Ð1Õ2ð	3ð €HÜ ×(Ñ(¨+Ð6ò NˆÜ47¸¿¹À[Ó4Q×R¡[ b¨%�B—E‘E˜5‘LÐRˆÑRØ�‰œ A xÓ0×>Ñ>ÈÐ>ÓLÕMðNð €Oùò' Iùó" Ss   Á$F
ÂF
Ä=Fc                óN  — t        | |«      } t        ||«      }t        |«      }t        | «      D ]t  }|D ]m  }t        |j                  |j                  «      rŒ$t	        ||t
        ddd„ d¬«      st	        ||t
        ddd„ d¬«      sŒS|rt	        ||t        dddd¬«      rŒl  y Œv y)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_promoter\  s     r   r_  z;is_unsafe_overlapping_overload_signatures.<locals>.<lambda>e$  ó   € Ô6JÈ1ÈaÓ6PÐ2P€ r  T)r`  Úcheck_args_covariantlyr¶   ra  Úallow_partial_overlapc                ó   — t        || «       S r'  rl	  r\  s     r   r_  z;is_unsafe_overlapping_overload_signatures.<locals>.<lambda>n$  rn	  r  )r`  ro	  r¶   rb  rp	  )Údetach_callableri	  rm	  r"  r³   Ú!is_overlapping_types_for_overload)rá  rô  Úclass_type_varsr�  Úother_expandedÚsig_variantÚother_variants          r   rj  rj  3$  sÕ   € ô<   	¨?Ó;€IÜ˜E ?Ó3€Eô
 .¨eÓ4€NÜ/°	Ó:ò 'ˆØ+ò &	ˆMô $ K×$8Ñ$8¸-×:PÑ:PÔQØä&ØØ!Ü?Ø+0Ø&+Ù%PØ*.õô *Ø!ØÜ?Ø+/Ø&+Ù%PØ*.õð ñ  Ô'=ØØÜ.Ø'+Ø"'Ø"Ø&*ö(ò ñM&	ð'ðP r  c                óZ   — |s| S | j                  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Õ  )ro  r¢  rl  )rH  rt	  s     r   rr	  rr	  ƒ$  s.   € ñ àˆ
Ø×Ñ¤t¨C¯M©MÓ':¸_Ñ'LÐÓMÐMr  c           
     ó¤   — t        | | j                  D �ci c]  }|j                  t        |«      “Œ c}«      }t	        ||t
        dd¬«      S c c}w )zòCheck 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.
    Trd  )r7   rl  r£  rÆ   r³   rµ   )rá  rô  r¬  Úexp_signatures       r   rf  rf  �$  sT   € ô  ØÈ9×K^ÑK^Ö_À4�D—G‘GÔ8¸Ó>Ñ>Ò_ó€Mô "Ø�u¬È4Ð_côð ùò `s   •A
c                ód  — t        | t        «      r%t        |t        «      rt        | |t        dd¬«      S yt        | t        «      rkt        |t        «      r[t        | j                  «      t        |j                  «      k(  r0t        d„ t        | j                  |j                  «      D «       «      S y)z#Does t have wider arguments than s?Trd  c              3  ó:   K  — | ]  \  }}t        ||«      –— Œ y ­wr'  )Úis_same_arg_prefix)rÞ  rÐ  Úitemts      r   rß  z-is_more_general_arg_prefix.<locals>.<genexpr>³$  s!   è ø€ ò Ù9E¸ÀÔ& u¨e×4ñùs   ‚F)	rÌ  rÝ   r³   r¶   rà   rý  rÐ  rk  rò  ©rM  r¦  s     r   r‹  r‹  §$  s–   € ô �!”\Ô"Ü�aœÔ&Ü)Ø�1Ô 1ÀTÐY]ôð ð ô 
�A”|Ô	$Ü�aœÔ&Ü�1—7‘7‹|œs 1§7¡7›|Ò+Üñ ÜILÈQÏWÉWÐVW×V]ÑV]ÓI^ôó ð ð r  c           	     ó.   — t        | |t        dddd¬«      S )NT)r`  r¶   rb  ro	  rÈ  )r³   r·   r	  s     r   r}	  r}	  ¹$  s$   € Ü!Ø	Ø	ÜØØØ#Ø!ôð r  c                óà   — t        | «      } t        j                  |   }d}t        | t        «      rt        | ||«      }n't        | t        «      rt        | j                  ||«      }|�d|fS d|fS )zéDetermine 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#  )rH  r¼  r�  Úexisting_methods       r   r?  r?  Å$  sr   € ô ˜#Ó
€CÜ×!Ñ! (Ñ+€FØ€OÜ�#”xÔ Ü.¨s°F¸HÓE‰Ü	�CœÔ	'Ü.¨s¯|©|¸VÀXÓNˆàÐ"Ø�_Ð$Ð$Ø�&ˆ=Ðr  c                ór   — |t         j                  v r%d|dd  z   }| j                  j                  |«      r|S y )NÚ__ir  )r   Úops_with_inplace_methodr­  ri  )r.  r�  r¼  Úinplace_methods       r   rƒ	  rƒ	  Ø$  s;   € Ø”9×4Ñ4Ñ4Ø ¨¨ Ñ+ˆØ�9‰9×(Ñ(¨Ô8Ø!Ð!Ør  c                ó¸   — t        | «      }t        |t        «      r|xs | xr |j                  S t        |t        «      ry| j                  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)rH  rZ  rÇ  r¸  r  s        r   rÎ  rÎ  à$  sW   € ô " #Ó&€KÜ�+œxÔ(ð ÒWÐ'7Ð#7Ò#V¸G×<VÑ<VÐWÜ	�K¤Ô	1ØØ�z‰zÔ.Ó0Ó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Š	  z´Find type components that are not valid for an inferred type.

    These include <Erased> type, and any uninhabited types resulting from failed
    (ambiguous) type inference.
    c                ó,   •— t         ‰| �  t        «       y r'  )rY	  r,  r×   )r+  rÌ  s    €r   r,  zInvalidInferredTypes.__init__%  s   ø€ Ü‰ÑœÕ&r  c                ó   — |j                   S r'  r¬  rc  s     r   Úvisit_uninhabited_typez+InvalidInferredTypes.visit_uninhabited_type%  s   € Ø�{‰{Ðr  c                 ó   — yrë  r  rc  s     r   Úvisit_erased_typez&InvalidInferredTypes.visit_erased_type%  r	  r  c                ó6   — |j                   j                  «       S r'  )r£  Úis_meta_varrc  s     r   r	  z#InvalidInferredTypes.visit_type_var%  s   € ð �t‰t×ÑÓ!Ð!r  c               ó8   — | j                  |j                  «      S r'  )Úquery_typesrÐ  rc  s     r   Úvisit_tuple_typez%InvalidInferredTypes.visit_tuple_type%  s   € à×Ñ §¡Ó(Ð(r  r¾  )rM  rô   r/  r.  )rM  rß   r/  r.  )rM  rò   r/  r.  )rM  rç   r/  r.  )
r  r  r  rE  r,  rŽ	  r�	  r	  r•	  r\	  r]	  s   @r   rŠ	  rŠ	  û$  s!   ø„ ñõ'óóó"÷
)r  rŠ	  c                  ó    — e Zd ZdZdd„Zdd„Zy)rÒ  zRReplace all ambiguous Uninhabited types with Any (to avoid spurious extra errors).c                óP   — |j                   rt        t        j                  «      S |S r'  )r­  rÛ   rì   rŒ  rc  s     r   rŽ	  z&SetNothingToAny.visit_uninhabited_type%  s   € Ø�;Š;Üœ9×/Ñ/Ó0Ð0Øˆr  c                ó~   — |j                  |j                  D �cg c]  }|j                  | «      ‘Œ c}¬«      S c c}w )N)r�  )ro  r�  r«  )r+  rM  rR	  s      r   Úvisit_type_alias_typez%SetNothingToAny.visit_type_alias_type%  s/   € ð �‰¸Q¿V¹VÖ$D¸ Q§X¡X¨d¥^Ò$DˆÓEÐEùÒ$Ds   š:N)rM  rô   r/  rè   )rM  ré   r/  rè   )r  r  r  rE  rŽ	  r™	  r  r  r   rÒ  rÒ  %  s   „ Ù\óô
Fr  rÒ  c                ó¬   — t        | t        «      r| j                  } t        | t        «      r| j                  S t        | t
        «      r| j                  S y)z+Find out if a node describes a classmethod.N)rÌ  rf   rÓ  ro   r  r™   r[  ©r  s    r   rÎ  rÎ  $%  sB   € ä�$œ	Ô"Ø�y‰yˆÜ�$œÔ Ø�}‰}ÐÜ�$œÔØ×"Ñ"Ð"Ør  c                ó¬   — t        | t        «      r| j                  } t        | t        «      r| j                  S t        | t
        «      r| j                  S y)z6Find out if a node describes a static function method.N)rÌ  rf   rÓ  ro   rÏ  r™   rÍ  r›	  s    r   rÌ  rÌ  /%  sB   € ä�$œ	Ô"Ø�y‰yˆÜ�$œÔ Ø�~‰~ÐÜ�$œÔØ×#Ñ#Ð#Ør  ÚTKeyÚTValuec                  ó8   — e Zd ZdZdd„Zd	d„Zd
d„Zdd„Zdd„Zy)Ú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()'.
    c                ó.   — i | _         i | _        i | _        y r'  )Ú
_key_to_idÚ_id_to_parent_idÚ_root_id_to_valuesr‚  s    r   r,  zDisjointDict.__init__Y%  s   € à+-ˆŒð
 13ˆÔð ;=ˆÕr  c                óH  — |sy|D �cg c]  }| j                  |«      ‘Œ }}|d   }| j                  |   }|j                  |«       |dd D ]O  }||k(  s|| j                  vrŒ|| j                  |<   |j                  | j                  j	                  |«      «       ŒQ yc c}w )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.
        Nr   rˆ  )Ú_lookup_or_make_root_idr¤	  r�  r£	  r=  )r+  r>  r  rô  Úsubtree_rootsÚnew_rootÚroot_valuesÚsubtree_roots           r   Úadd_mappingzDisjointDict.add_mappinge%  sµ   € ñ ØàFJÖK¸s˜×5Ñ5°cÕ:ÐKˆÐKØ  Ñ#ˆà×-Ñ-¨hÑ7ˆØ×Ñ˜6Ô"Ø)¨!¨"Ð-ò 	JˆLØ˜xÒ'¨<¸t×?VÑ?VÑ+VØØ2:ˆD×!Ñ! ,Ñ/Ø×Ñ˜t×6Ñ6×:Ñ:¸<ÓHÕIñ		Jùò Ls   ˆBc                ó  — i }| j                   D ]8  }| j                  |«      }||vrt        «       ||<   ||   j                  |«       Œ: g }|j	                  «       D ]%  \  }}|j                  || j                  |   f«       Œ' |S )z1Returns all disjoint mappings in key-value pairs.)r¢	  Ú_lookup_root_idrj  r¿  rÐ  r8  r¤	  )r+  Úroot_id_to_keysrô  Úroot_idrô  r>  s         r   rÐ  zDisjointDict.itemsy%  s™   € à02ˆØ—?‘?ò 	.ˆCØ×*Ñ*¨3Ó/ˆGØ˜oÑ-Ü+.«5� Ñ(Ø˜GÑ$×(Ñ(¨Õ-ð		.ð ˆØ,×2Ñ2Ó4ò 	D‰MˆG�TØ�M‰M˜4 ×!8Ñ!8¸Ñ!AÐBÕCð	Dð ˆr  c                óØ   — || j                   v r| j                  |«      S t        | j                   «      }|| j                   |<   || j                  |<   t	        «       | j
                  |<   |S r'  )r¢	  r­	  rý  r£	  rj  r¤	  )r+  rô  Únew_ids      r   r¦	  z$DisjointDict._lookup_or_make_root_idˆ%  sb   € Ø�$—/‘/Ñ!Ø×'Ñ'¨Ó,Ð,ä˜Ÿ™Ó)ˆFØ#)ˆD�O‰O˜CÑ Ø,2ˆD×!Ñ! &Ñ)Ü.1«eˆD×#Ñ# FÑ+ØˆMr  c                óÈ   — | j                   |   }|| j                  |   k7  r@| j                  | j                  |      }|| j                  |<   |}|| j                  |   k7  rŒ@|S r'  )r¢	  r£	  )r+  rô  r×  Ú
new_parents       r   r­	  zDisjointDict._lookup_root_id’%  sq   € Ø�O‰O˜CÑ ˆØ�4×(Ñ(¨Ñ+Ò+ð ×.Ñ.¨t×/DÑ/DÀQÑ/GÑHˆJØ'1ˆD×!Ñ! !Ñ$ØˆAð �4×(Ñ(¨Ñ+Ó+ð ˆr  Nr¾  )r>  z	set[TKey]r  zset[TValue]r/  r0  )r/  z#list[tuple[set[TKey], set[TValue]]])rô  r�	  r/  ra  )	r  r  r  rE  r,  r«	  rÐ  r¦	  r­	  r  r  r   r 	  r 	  >%  s!   „ ñó4
=óJó(óôr  r 	  c                óf  — |D �ci c]  }|t        «       “Œ }}g }d}t        «       }t        «       }t        | «      D ]Ø  \  }	\  }
}}|€|
}|rS|
|k7  s|
|vrJ|s|j                  |t	        |«      f«       n||   j                  ||«       |
}t        «       }t        «       }|j                  |	«       |j                  |	dz   «       |
|v sŒ�|j                  |	«      }|�|j                  |«       |j                  |	dz   «      }|€ŒÈ|j                  |«       ŒÚ |�4|s|j                  |t	        |«      f«       n||   j                  ||«       |j                  «       D ]9  \  }
}|j                  «       D ]!  \  }}|j                  |
t	        |«      f«       Œ# Œ; |j                  d„ ¬«       |S c c}w )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.
    Nrˆ  c                ó   — | d   d   S r¼  r  )rØ  s    r   r_  z+group_comparison_operands.<locals>.<lambda>ý%  s   € °4¸±7¸1±:€ r  )rô  )
r 	  rj  rÏ  r8  rù  r«	  r¿  r¬  rÐ  Úsort)Úpairwise_comparisonsÚoperand_to_literal_hashÚoperators_to_groupr÷  Úgroupsrº  Úlast_operatorÚcurrent_indicesÚcurrent_hashesr×  r¼  Ú	left_exprÚ
right_exprÚ	left_hashÚ
right_hashÚdisjoint_dictr>  Úindicess                     r   r­  r­  �%  sâ  € ð` OaÖ0aÈ°´\³^Ñ1CÐ0a€FÐ0aà<>ÐØ $€MÜ #£€OÜ"›u€NÜ09Ð:NÓ0Oò /Ñ,ˆÑ,ˆH�i ØÐ Ø$ˆMá ¨MÒ 9¸XÐM_Ñ=_ñ "Ø(×/Ñ/°ÄÀÓ@WÐ0XÕYà�}Ñ%×1Ñ1°.À/ÔRØ$ˆMÜ!›eˆOÜ ›UˆNð 	×Ñ˜AÔØ×Ñ˜A ™EÔ"ð Ð)Ò)Ø/×3Ñ3°AÓ6ˆIØÐ$Ø×"Ñ" 9Ô-Ø0×4Ñ4°Q¸±UÓ;ˆJØÑ%Ø×"Ñ" :Õ.ð7/ð: Ð ÙØ$×+Ñ+¨]¼FÀ?Ó<SÐ,TÕUà�=Ñ!×-Ñ-¨n¸oÔNð $*§<¡<£>ò IÑˆ�-Ø*×0Ñ0Ó2ò 	I‰MˆD�'Ø$×+Ñ+¨X´v¸g³Ð,GÕHñ	IðIð
 ×!Ñ!Ñ&=Ð!Ô>Ø#Ð#ùòc 1bs   …F.c                ó¦   — t        | «      } | rt        | t        «      syt        d„ t	        | j
                  | j                  gz   «      D «       «       S )NFc              3  óz   K  — | ]3  }t        |t        «      xr |j                  t        j                  k(  –— Œ5 y ­wr'  )rÌ  rÛ   Útype_of_anyrì   r”  rL  s     r   rß  z$is_typed_callable.<locals>.<genexpr>&  s6   è ø€ ò àô 	�1”gÓÒI 1§=¡=´I×4IÑ4IÑ#IÓIñùs   ‚9;)rú   rÌ  rÝ   rk  rû   r  r"  )rŸ  s    r   r¶  r¶  &  sN   € Ü˜Ó€AÙ”J˜q¤,Ô/ØÜñ ä! !§+¡+°·±°Ñ"<Ó=ôó ð ð r  c                óX  — t        | «      } | syt        | t        «      rt        | «       S t        | t        «      rÄ| j
                  j                  d«      }|r¦t        |t        «      r@t        |j                  j
                  «      xs t        |j                  j
                  «      S t        |j
                  t        «      r&t        d„ |j
                  j                  D «       «      S t        |j
                  «       S yt        | t        «      rt        d„ | j                  D «       «      S y)NTrG  c              3  ó2   K  — | ]  }t        |«      –— Œ y ­wr'  ©r·  rž  s     r   rß  z'is_untyped_decorator.<locals>.<genexpr>&  s   è ø€ ÒT¸$Ô/°×5ÑTùrO  Fc              3  ó2   K  — | ]  }t        |«      –— Œ y ­wr'  rÉ	  rž  s     r   rß  z'is_untyped_decorator.<locals>.<genexpr> &  s   è ø€ ÒD°$Ô'¨×-ÑDùrO  )rú   rÌ  rÝ   r¶  rá   r­  rG  rf   r·  rÓ  r&  rä   rã  rÐ  )rH  r�  s     r   r·  r·  &  sç   € Ü
˜#Ó
€CÙØÜ	�CœÔ	&Ü$ SÓ)Ð)Ð)Ü	�CœÔ	"Ø—‘×$Ñ$ ZÓ0ˆÙÜ˜&¤)Ô,Ü+¨F¯K©K×,<Ñ,<Ó=ò ÔAUØ—J‘J—O‘OóBð ô ˜&Ÿ+™+¤zÔ2ÜÑTÀ&Ç+Á+×BSÑBSÔTÓTÐTä,¨V¯[©[Ó9Ð9Ð9àÜ	�CœÔ	$ÜÑD¸#¿)¹)ÔDÓDÐDØr  c                óª   — t        | t        «      rt        | j                  «      S t        | t        «      r| j                  S J dt        | «      › �«       ‚)NzUnexpected func type: )rÌ  rf   rÏ  rÓ  rn   r­  )rÓ  s    r   rÏ  rÏ  $&  sE   € Ü�$œ	Ô"Ü˜Ÿ™Ó#Ð#Ü	�Dœ(Ô	#Ø�~‰~ÐØ7Ð*¬4°«:¨,Ð7Ó7ˆ5r  c                ó@  — t        | t        «      r| j                  S t        | t        «      r| j                  j                  S t        | t
        «      rL| j                  r@t        | j                  d   t        «      r#| j                  d   j                  j                  S y©Nr   F)rÌ  ro   rÑ  rf   rÓ  r„   rÐ  ©r  s    r   rÑ  rÑ  ,&  sr   € Ü�$œÔ Ø×ÑÐÜ�$œ	Ô"Ø�y‰y×$Ñ$Ð$Ü�$Ô)Ô*Ø�:Š:œ* T§Z¡Z°¡]´IÔ>Ø—:‘:˜a‘=×%Ñ%×1Ñ1Ð1Ør  c                ó¼   — t        | t        «      rL| j                  r@t        | j                  d   t        «      r#| j                  d   j                  j
                  S yrÍ	  )rÌ  r„   rÐ  rf   rÓ  rÑ  rÎ	  s    r   r'  r'  7&  sB   € Ü�$Ô)Ô*Ø�:Š:œ* T§Z¡Z°¡]´IÔ>Ø—:‘:˜a‘=×%Ñ%×1Ñ1Ð1Ør  c                óÆ  — | €yt        | «      sy| j                  d   }t        |t        «      sJ ‚|j                  j                   sy|j                  }|j
                  �&|j                  �t        |j
                  t        «      ry|j                  j                  d   }t        t        |«      t        «      ryt        t        t        |j
                  «      «      |«       S )zïCheck 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.
    Fr   rˆ  )r'  rÐ  rÌ  rf   r&  r­  r,  rå   r  rú   rÛ   r·   Úget_property_type)r  rˆ  r&  r,  s       r   rÐ  rÐ  >&  sµ   € ð €|ØÜ Ô%ØØ—‘˜A‘€JÜ�j¤)Ô,Ð,Ð,Ø�>‰>×.Ò.ØØ
�.‰.€CØ
‡x�xÐ˜3Ÿ?™?Ð2´jÀÇÁÌ;Ô6WàØ—/‘/×+Ñ+¨AÑ.€KÜ”/ +Ó.´Ô8ØÜÔ-¬o¸c¿h¹hÓ.GÓHÈ+ÓVÐVÐVr  c                ó´   — t        | t        «      rt        | j                  «      S t        | t        «      r"t        | j
                  d   j                  «      S | S )Nr   )rÌ  rÝ   rú   r"  rä   rÐ  rM	  s    r   rÑ	  rÑ	  V&  sC   € Ü�!”\Ô"Ü˜qŸz™zÓ*Ð*Ü�!”ZÔ Ü˜qŸw™w q™z×2Ñ2Ó3Ð3Ø€Hr  c                ó    — t        | |dd¬«      S )NT)r  Úalways_covariantr[  ro  s     r   rm	  rm	  ^&  s   € Ü�d˜E°TÈDÔQÐQr  c                ó    — t        | |dd¬«      S )NT)r  Úoverlap_for_overloads)r=   ro  s     r   rs	  rs	  b&  s   € ô    e¸tÐ[_Ô`Ð`r  c                óL   — | j                  d«      xr | j                  d«       S )z-Check if node is private to class definition.r‰  )r=  r  )Ú	node_names    r   rÐ  rÐ  m&  s&   € à×Ñ Ó%ÒF¨i×.@Ñ.@ÀÓ.FÐ*FÐFr  c                ó@   — t        | «      }|d uxr t        |«      dk(  S )Nrˆ  )rÔ   rý  )rH  Ústrss     r   r�  r�  r&  s$   € Ü-¨cÓ2€DØ�tÐÒ.¤ D£	¨Q¡Ð.r  c                óv   — t        | d«      ryt        | t        «      rt        d„ | j                  D «       «      S y)z<Return True if type is 'bool' or a union with a 'bool' item.r¿  Tc              3  ó4   K  — | ]  }t        |d «      –— Œ y­w)r¿  N)rÿ   rž  s     r   rß  z has_bool_item.<locals>.<genexpr>|&  s   è ø€ ÒRÀÔ$ T¨?×;ÑRùrà  F)rÿ   rÌ  rõ   rã  rÐ  )rH  s    r   r  r  w&  s1   € ä˜˜oÔ.ØÜ�#”yÔ!ÜÑRÈÏ	É	ÔRÓRÐRØr  c                ó>   — t        | t        «      r| j                  S | S )zöIf an expression is an AssignmentExpr, pull out the assignment target.

    We don't make any attempt to pull out all the targets in code like `x := (y := z)`.
    We could support narrowing those if that sort of code turns out to be common.
    )rÌ  r[   r"  )r_  s    r   rØ  rØ  €&  s   € ô �!”^Ô$Ø�x‰xˆØ€Hr  c                óR   — t        |«      }| j                  |«       |j                  S )z®Find 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ø  rV	  s      r   r(  r(  ‹&  s&   € ô ˜qÓ!€GØ‡H�HˆWÔØ×ÑÐ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ß	  c                ó.   — d| _         d| _        || _        y )NrŒ  F)r”  rþ  Úvar_node)r+  rø  s     r   r,  zVarAssignVisitor.__init__˜&  s   € ØˆŒØˆŒØˆ�r  c                ód   — d| _         |j                  D ]  }|j                  | «       Œ d| _         y r  )rþ  r�  r«  ©r+  r¦  r½  s      r   r¾  z&VarAssignVisitor.visit_assignment_stmt�&  s.   € ØˆŒØ—)‘)ò 	ˆBØ�I‰I�d�Oð	àˆ�r  c                óš   — | j                   r?|j                  | j                  u r&t        | j                  |j
                  «      | _        y y y r'  )rþ  r  râ	  r_	  r”  rŽ  r¤  s     r   Úvisit_name_exprz VarAssignVisitor.visit_name_expr£&  s5   € Ø�;Š;˜1Ÿ6™6 T§]¡]Ñ2Ü  §¡°·±Ó8ˆD�Nð 3ˆ;r  c                óX   •— | j                   }d| _         t        ‰| �	  |«       || _         y r<  )rþ  rY	  r>  ©r+  r_  Ú
old_lvaluerÌ  s      €r   r>  z"VarAssignVisitor.visit_member_expr§&  s'   ø€ Ø—[‘[ˆ
ØˆŒÜ‰Ñ! !Ô$Ø ˆ�r  c                óX   •— | j                   }d| _         t        ‰| �	  |«       || _         y r<  )rþ  rY	  Úvisit_index_exprrè	  s      €r   rë	  z!VarAssignVisitor.visit_index_expr­&  s'   ø€ Ø—[‘[ˆ
ØˆŒÜ‰Ñ  Ô#Ø ˆ�r  c                ó    — d| _         |j                  D ]  }|€Œ|j                  | «       Œ d| _         |j                  j                  | «       y r  )rþ  r"  r«  r  rä	  s      r   rÄ  z VarAssignVisitor.visit_with_stmt³&  sE   € ØˆŒØ—(‘(ò 	 ˆBØ‰~Ø—	‘	˜$•ð	 ð ˆŒØ	�‰�‰�dÕr  c                óÜ   — d| _         |j                  j                  | «       d| _         |j                  j                  | «       |j                  r|j                  j                  | «       y y r  )rþ  rõ  r«  r  r  r  s     r   r  zVarAssignVisitor.visit_for_stmt»&  sN   € ØˆŒØ	�‰�‰�tÔØˆŒØ	�‰�‰�dÔØ�;Š;Ø�K‰K×Ñ˜tÕ$ð r  c                óŒ   — d| _         |j                  j                  | «       d| _         |j                  j                  | «       y r  )rþ  r"  r«  ræ  r¤  s     r   Úvisit_assignment_exprz&VarAssignVisitor.visit_assignment_exprÃ&  s0   € ØˆŒØ	�‰�‰˜ÔØˆŒØ	�‰�‰�tÕr  c                ó¾   — |j                   �|j                   j                  | «       |j                  �*d| _        |j                  j                  | «       d| _        y y r  )rç  r«  rÊ  rþ  ©r+  rì  s     r   Úvisit_as_patternz!VarAssignVisitor.visit_as_patternÉ&  sK   € Ø�9‰9Ð Ø�I‰I×Ñ˜TÔ"Ø�6‰6ÐØˆDŒKØ�F‰F�M‰M˜$ÔØˆD�Kð r  c                óp   — |j                   �*d| _        |j                   j                  | «       d| _        y y r  )Úcapturerþ  r«  rñ	  s     r   Úvisit_starred_patternz&VarAssignVisitor.visit_starred_patternÑ&  s1   € Ø�9‰9Ð ØˆDŒKØ�I‰I×Ñ˜TÔ"ØˆD�Kð !r  )rø  r™   r/  r0  rË  )r_  r   r/  r0  )r_  r}   r/  r0  )r_  rw   r/  r0  rÕ  rÒ  )r_  r[   r/  r0  )rì  r¤   r/  r0  )rì  r¥   r/  r0  )r  r  r  r,  r¾  ræ	  r>  rë	  rÄ  r  rï	  rò	  rõ	  r\	  r]	  s   @r   rß	  rß	  —&  s5   ø„ óó
ó9õ!õ!óó%óó ÷ r  rß	  r›  zbuiltins.numeric)r›  r¿  rE  zbuiltins.floatzbuiltins.complexÚOPEN_VALUE_EQUALITY_DOMAINSÚ OPEN_VALUE_EQUALITY_DOMAIN_NAMESúbuiltins.bytesr1	  útyping.AbstractSet)rø	  zbuiltins.bytearrayzbuiltins.memoryviewr1	  rù	  ÚCLOSED_VALUE_EQUALITY_DOMAINSÚVALUE_EQUALITY_DOMAINSc                  ó   — e Zd Zdd„Zy)ÚEqualityDomainInfoc                ó    — || _         || _        y r'  )Ú
type_namesÚenum_type_names)r+  rÿ	  r 
  s      r   r,  zEqualityDomainInfo.__init__ð&  s   € Ø$ˆŒØ.ˆÕr  N)rÿ	  r]  r 
  r]  r/  r0  r1  r  r  r   rý	  rý	  ï&  s   „ ô/r  rý	  c                  ó   — e Zd Zdd„Zy)ÚEqualityValueInfoc                ó    — || _         || _        y r'  )ÚdomainsÚis_top)r+  r
  r
  s      r   r,  zEqualityValueInfo.__init__ö&  s   € ØˆŒØˆ�r  N)r
  zdict[str, EqualityDomainInfo]r
  r.  r/  r0  r1  r  r  r   r
  r
  õ&  s   „ ôr  r
  c               óD  — |r| dfS t        | «      }t        |t        «      r|j                  «       n| g}g }g }|D ]1  }t	        ||«      r|j                  |«       Œ!|j                  |«       Œ3 |rt        j                  |«      nd|rt        j                  |«      fS 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õ   rl  Ú#is_equality_ambiguous_for_narrowingr8  rR  )rO  rÕ  rÊ  rH  rÐ  Únarrowable_itemsÚambiguous_itemsrØ  s           r   rÎ  rÎ  û&  s´   € ñ Ø˜TÐ!Ð!ä
˜,Ó
'€CÜ$.¨s´IÔ$>ˆC×ÑÔ À\ÀN€EØÐØ€OØò *ˆÜ.¨t°[ÔAØ×"Ñ" 4Õ(à×#Ñ# DÕ)ð	*ñ 3CŒ	×ÑÐ-Ô.ÈÙ1@Œ	×Ñ˜_Ó-ðð àFJðð r  c                ó¨  — t        | «      }t        |«      }|j                  s|j                  r:|j                  r|n|}t        d„ |j                  j	                  «       D «       «      S |j                  j                  «       |j                  j                  «       z  }|sy|D ]­  }|j                  |   }|j                  |   }|j                  rL|j                  |j                  k(  r3|j                  |j                  k(  r|j                  |j                  k(  rŒy|j                  |j                  k7  r y|j                  s|j                  sŒ­ y y)zOCan left compare equal to right through a value domain outside nominal overlap?c              3  óN   K  — | ]  \  }}|t         v xr |j                  –— Œ y ­wr'  )r÷	  r 
  )rÞ  ÚdomainÚdomain_infos      r   rß  z6is_equality_ambiguous_for_narrowing.<locals>.<genexpr>!'  s0   è ø€ ò 
á#�˜ð Ô6Ð6ÒV¸;×;VÑ;VÓVñ
ùr5	  FT)Úequality_value_infor
  rã  r
  rÐ  r>  r 
  rÿ	  )	rp  rq  Ú	left_infoÚ
right_infoÚ
other_infoÚshared_domainsr
  Úleft_domainÚright_domains	            r   r
  r
  '  s>  € ä# DÓ)€IÜ$ UÓ+€Jà×Ò˜:×,Ò,ð $-×#3Ò#3‘Z¸ˆ
Üñ 
à'1×'9Ñ'9×'?Ñ'?Ó'Aô
ó 
ð 	
ð
 ×&Ñ&×+Ñ+Ó-°
×0BÑ0B×0GÑ0GÓ0IÑI€NÙØà ò ˆØ×'Ñ'¨Ñ/ˆØ!×)Ñ)¨&Ñ1ˆð ×'Ò'Ø×+Ñ+¨|×/KÑ/KÒKØ×&Ñ&¨+×*EÑ*EÒEØ×'Ñ'¨<×+GÑ+GÒGàð ×!Ñ! \×%<Ñ%<Ò<Ùð ×&Ò&¨,×*FÓ*FÙð%ð( r  c                óÄ  — t        | «      } t        | t        «      rt        d„ | j                  D «       «      S t        | t
        «      r=| 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 ]H  }t&        j)                  |j                  «      x}sŒ%t+        | j                  j                  h|«      ||<   ŒJ t        |d¬«      S t        | t,        «      rt        i d¬«      S t        i d¬«      S )Nc              3  ó2   K  — | ]  }t        |«      –— Œ y ­wr'  ©r
  rž  s     r   rß  z&equality_value_info.<locals>.<genexpr>D'  s   è ø€ Ò*YÈÔ+>¸t×+DÑ*YùrO  c              3  ó2   K  — | ]  }t        |«      –— Œ y ­wr'  r
  rž  s     r   rß  z&equality_value_info.<locals>.<genexpr>G'  s   è ø€ Ò.^ÈTÔ/BÀ4×/HÑ.^ùrO  r-  T)r
  F)rú   rÌ  rõ   Úcombine_equality_value_inforÐ  rò   r  r
  rM  rá   ro  râ   r#  r­  r   r
  r  rj  r¶  rû	  r¬  rý	  rÛ   )rM  r 
  r
  r¹  r
  s        r   r
  r
  A'  sq  € Ü˜Ó€AÜ�!”YÔÜ*Ñ*YÐQR×QXÑQXÔ*YÓYÐYÜ�!”[Ô!Ø�8Š8Ü.Ñ.^ÐUV×U]ÑU]Ô.^Ó^Ð^Ü" 1§=¡=Ó1Ð1Ü�!”XÔ 1×#5Ñ#5Ð#AÜ" 1×#5Ñ#5Ó6Ð6Ü�!”[Ô!Ü" 1§:¡:Ó.Ð.Ü�!”XÔØ�6‰6�?‰?Ð/Ò/Ü$ R°Ô5Ð5à/0¯v©v¯~ª~˜1Ÿ6™6Ÿ?™?Ñ+Ä3Ã5ˆØˆØ—F‘F—J‘Jò 	YˆDÜ/×3Ñ3°D·M±MÓBÐBˆvÑBÜ"4°a·f±f·o±oÐ5FÈÓ"X�˜’ð	Yô ! °Ô7Ð7Ü�!”WÔÜ  ¨DÔ1Ð1Ü˜R¨Ô.Ð.r  c                óº  — i }d}| D ]Ç  }|j                   j                  «       D ]˜  \  }}|j                  |«      }|€6t        t	        |j
                  «      t	        |j                  «      «      ||<   ŒO|j
                  j                  |j
                  «       |j                  j                  |j                  «       Œš |xs |j                  }ŒÉ t        ||«      S r<  )
r
  rÐ  r¬  rý	  rj  rÿ	  r 
  r�  r
  r
  )Úinfosr
  r
  r4  r
  r
  Úexisting_domain_infos          r   r
  r
  ]'  sÑ   € Ø-/€GØ€FØò 
'ˆØ#'§<¡<×#5Ñ#5Ó#7ò 	YÑˆF�KØ#*§;¡;¨vÓ#6Ð Ø#Ð+Ü"4Ü˜×.Ñ.Ó/´°[×5PÑ5PÓ1Qó#�˜’ð %×/Ñ/×6Ñ6°{×7MÑ7MÔNØ$×4Ñ4×;Ñ;¸K×<WÑ<WÕXð	Yð Ò&˜4Ÿ;™;‰ð
'ô ˜W fÓ-Ð-r  c                ó˜   — t        | «      } t        | t        «      ryt        | t        «      r| j                  D ]  }t        |«      sŒ y yr  )rú   rÌ  rê   rõ   rÐ  rí  )r¢  rØ  s     r   rí  rí  n'  sH   € Ü! +Ó.€KÜ�+œ}Ô-ØÜ�+œyÔ)Ø×%Ñ%ò 	ˆDÜ(¨Õ.Ùð	ð r  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ï  y'  sF   € Ü�$Ô)Ô*Ø×#Ñ#Ð#Ð#Ü�$œ	Ô"Ø—8‘8×'Ñ'Ð'Ð'Ü�dœGÓ$Ð$r  r'  )rO  rè   r	  rÝ  r8  r0  r}  r.  rË  r.  r/  rÞ  )rO  rè   r	  rÝ  r8  rè   r}  r.  rË  r.  r/  rÓ  )rO  rè   r	  rÝ  r8  rò  r}  r.  rË  r.  r/  rÞ  )r  rj   r˜  rò  r™  rò  r/  rÙ  )r¹  rm  rY  r‘   r/  rm  rß  )rù  rÀ  r/  r.  )rÓ  rp   r/  r.  )rå  rè   r/  rò  )r(  r#  r/  r.  )r9	  r#  r:	  r#  rª  r.  r/  r#  )r9	  r#  r:	  r#  r  r.  r/  r#  rÅ  )rî  rÚ  rª  r.  r/  rÙ  )rI	  rÖ  r/  r#  )rI	  rÖ  rª  r.  r/  r#  )rM  rè   r/  r.  )râ  r#  r/  r#  )rM  rj   r/  rŸ  )rM  rè   r/  rO  )r  rp   r(  r[	  r/  rp   )rM  rÝ   r¦  rÝ   r/  r.  )rŸ  rÝ   r/  zlist[CallableType]r¿  )
rá  rÝ   rô  rÝ   rt	  úlist[TypeVarLikeType]r�  r.  r/  r.  )rH  rÝ   rt	  r
  r/  rÝ   )rá  rÝ   rô  rÝ   r/  r.  )rM  rà   r¦  rà   r/  r.  )rH  rè   r¼  rm  r/  ztuple[bool, str])r.  rá   r�  rm  r¼  rm  r/  rÄ  rÔ  )
rH  rè   rZ  r£   rÇ  r.  r¸  r.  r/  r.  )r  úSymbolNode | Noner/  rÆ  )r·	  z,Iterable[tuple[str, Expression, Expression]]r¸	  zMapping[int, Key]r¹	  r]  r/  zlist[tuple[str, list[int]]])rŸ  rò  r/  r.  )rH  rò  r/  r.  )rÓ  zFuncBase | Decoratorr/  r.  )r  r�   r/  r.  )r  r 
  r/  zTypeGuard[OverloadedFuncDef])r  r 
  r/  r.  )rM  ræ   r/  ræ   )rp  rè   rq  rè   r/  r.  )rØ	  rm  r/  r.  rÃ  )rH  ræ   r/  r.  )r_  rj   r/  rj   )rù  r€   rø  r™   r/  ra  )rO  rè   rÕ  rè   rÊ  r.  r/  rÞ  )rM  rè   r/  r
  )r
  zIterable[EqualityValueInfo]r/  r
  )r¢  rè   r/  r.  )r  r 
  r/  r.  (�  rE  Ú
__future__r   r¦  Úcollectionsr   Úcollections.abcr   r   r   r   r	   r
   ÚAbstractSetÚ
contextlibr   r   ri  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þ   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%  r3  rB  râ  r/  rÏ  rá  r7  r‚  r®  rÔ  r¯  rÚ  r³  r6  rŠ  ræ  r´  r±  r²  r°  rx  r�  r‹  r©  rU	  re  ri	  rj  rr	  rf  r‹  r}	  r?  rƒ	  rÎ  rŠ	  rÒ  rÎ  rÌ  r�	  rž	  r 	  r­  r¶  r·  rÏ  rÑ  r'  rÐ  rÑ	  rm	  rs	  rÐ  r�  r  rØ  r(  rß	  rö	  Ú	frozensetr  r÷	  rú	  rû	  rý	  r
  rÎ  r
  r
  r
  rí  rï  r  r  r   ú<module>rO
     sù  ðò:õx #ã Ý #ß _× _ß 0÷
÷ 
õ 
ó ß NÕ Nß EÑ Eß MÑ MÝ ,÷õ õ -Ý )÷ó ÷ TÓ S÷÷ õ (ß SÓ SÝ 2ß 6Ý .÷
÷ 
õ 
÷ -÷V÷ V÷ V÷ V÷ V÷ V÷ V÷ V÷ V÷ V÷ V÷ V÷ V÷ V÷ V÷ V÷ V÷ V÷ V÷ V÷ Võ V÷n ?Ñ >ß 5ß 3Ý Ý :Ý ß OÑ Oß <Ý =Ý 1Ý ÷÷ ÷ ÷ YÑ XÝ /ß bÑ b÷÷ ÷ ÷ ÷ ÷ ñ ÷.+÷ +÷ +÷ +÷ +÷ +÷ +÷ +÷ +÷ +÷ +÷ +÷ +÷ +÷ +÷ +÷ +÷ +÷ +÷ +÷ +ô +÷X c× bÔ bß 3Ð 3ß P× PÐ Pß *Ô *ß $Ð $áˆCƒL�àÑ �5Ô ð !"Ñ ˜Ô !à&Ð):Ñ:¸YÑFÑ �*Ô FØ*1°HÑ*<Ð?PÑ*PÑ ˜ZÔ Pô%�:õ %ô%˜jõ %ñ$ ˜:¡tÐ+Ñ,�ˆÔ ,÷(ò (÷ò ô(UA=‘+˜dÑ#Ð%9Ð;Kõ UA=ôpB^/Ð$Aõ ^/ôBÑ1õ ð 
ð ð*ð
 )-Øñ*Øð*à0ð*ð ð*ð
 "&ð*ð ð*ð %ò*ó 
ñ*ð 
ð )-ØñØðà0ðð ðð
 "&ðð ðð òó 
ñð  ðx)ð
 )-Øñx)Øðx)à0ðx)ð ðx)ð
 "&ðx)ð ðx)ð %ôx)ðvØ
ðØ +ðØ6Aðàôôô]ô
^ô
Eô
Oôô 7ôtVð HMö (ðV KPö ð6 @Eð$,Ø,ð$,Ø8<ð$,àô$,ôN	ôôôô&ô	ôô+Ð+õ +ô ôðB ð	MØðMàðMð +ðMð ð	Mð
 
ôMô`
Nôô.ô$	ôô&ð Z_ð2Ø	ð2Øð2Ø26ð2ØRVð2à	ô2ô6)™=õ )ô6F‘nõ Fôôñ ˆvƒ�Ù	�Ó	�ô\�7™4¡˜<Ñ(õ \ð~a$ØFða$à.ða$ð !ða$ð !ô	a$ôHôô28ôôôWô0ôRôaôGô
/ô
ôô	ô> Ð'õ > ðH #Ø'Ø&Ø(Ø*ñ&Ñ ˜Uô ò +4Ñ4O×4VÒ4VÓ4XÓ*YÑ   %Ô Yð 'Ø*Ø+Ø&Ø.ñ(Ñ ˜uô ð !aÑ#>Ð `ÑB_Ð `Ñ ˜Ô `÷/ò /÷ò ðØðØ%)ðØ;?ðà$ôô:&ôR/ô8.ô"õ%r  