Ë
    pPêj¶ ã                  óR  — U d Z ddlmZ ddlZddlZddlZddlmZ ddl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 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#m$Z$ dd
l%m&Z&m'Z'm(Z( ddl)m*Z* ddl+m,Z,m-Z- ddl.m/Z/ ddl0m1Z1 ddl2m3Z3m4Z4m5Z5 ddl6m7Z7m8Z8m9Z9 ddl:m;Z;m<Z<m=Z=m>Z> ddl?m@Z@mAZA ddlBmCZCmDZDmEZE ddlFmGZG ddlHmIZI ddlJmKZK ddlLmMZMmNZN ddlOmPZP ddlQmRZRmSZSmTZT ddlUmVZVmWZWmXZXmYZYmZZZm[Z[m\Z\m]Z]m^Z^m_Z_m`Z`maZambZbmcZcmdZdmeZemfZfmgZgmhZhmiZimjZjmkZkmlZlmmZmmnZnmoZompZpmqZqmrZrmsZsmtZtmuZumvZvmwZwmxZxmyZymzZzm{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  ddl¡m¢Z¢m£Z£m¤Z¤m¥Z¥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² dd l³m´Z´mµZµm¶Z¶ dd!l·m¸Z¸ dd"l¹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Ð 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þmÿZÿ�m �Z  dd&�l�m�Z dd'�l�m�Z dd(�l�m�Z e	eåeåe`eå�e�eeÕeådz  ejejg
df   �Zd)�e	d*<   d+�Z
d,�e	d-<   g d.¢�Zd,�e	d/<   h d0£�Zd,�e	d1<    G d2„ d3�e«      �Zd[d4„�Z G d5„ d6�e«      �Ze�j"                   G d7„ d8e�j$                  «      «       �Z�e�j(                  �Zd,�e	d9<   �e�j,                  �Zd,�e	d:<   �e�j0                  �Zd,�e	d;<    G d<„ d=�eeå   e*«      �Zd\d]d>„�Z G d?„ d@e$�j8                  «      �Zd[dA„�Zd[dB„�Zd[dC„�Z 	 	 	 	 	 	 	 	 d^dD„�Z!d_dE„�Z" G dF„ dGe$�j8                  «      �Z#d`dH„�Z$ G dI„ dJe$�j8                  «      �Z%d`dK„�Z& G dL„ dMe$�j8                  «      �Z'd`dN„�Z( G dO„ dPe$�j8                  «      �Z)dadQ„�Z*	 	 	 	 	 	 	 	 	 	 	 	 dbdR„�Z+dcdS„�Z,dddT„�Z-dedU„�Z.dfdV„�Z/dgdW„�Z0dhdX„�Z1didY„�Z2djdZ„�Z3y)kzGExpression type checker. This file is conceptually part of TypeChecker.é    )ÚannotationsN)Údefaultdict)ÚCallableÚIterableÚIteratorÚSequence)ÚcontextmanagerÚnullcontext)ÚClassVarÚFinalÚ	TypeAliasÚcastÚoverload)Úassert_never)Ú	applytypeÚ	erasetypeÚjoinÚmessage_registryÚnodesÚ	operatorsÚtypes)ÚArgTypeExpanderÚmap_actuals_to_formalsÚmap_formals_to_actuals)ÚExpressionCheckerSharedApi)Úanalyze_member_accessÚhas_operator)ÚStringFormatterChecker)Úconstant_fold_expr)Ú
erase_typeÚ!remove_instance_last_known_valuesÚreplace_meta_vars)Ú	ErrorInfoÚErrorWatcherÚreport_internal_error)Úexpand_typeÚexpand_type_by_instanceÚfreshen_all_functions_type_varsÚfreshen_function_type_vars)ÚTypeTranslationErrorÚexpr_to_unanalyzed_type)ÚArgumentInferContextÚinfer_function_type_argumentsÚinfer_type_arguments)Úliteral)Úlookup_fully_qualified)Úmap_instance_to_supertype)Úis_overlapping_typesÚnarrow_declared_type)ÚErrorMessage)ÚMessageBuilderÚcallable_nameÚformat_type)JÚ	ARG_NAMEDÚARG_POSÚARG_STARÚ	ARG_STAR2ÚIMPLICITLY_ABSTRACTÚLAMBDA_NAMEÚLITERAL_TYPEÚREVEAL_LOCALSÚREVEAL_TYPEÚUNBOUND_IMPORTEDÚArgKindÚAssertTypeExprÚAssignmentExprÚ	AwaitExprÚ	BytesExprÚCallExprÚCastExprÚComparisonExprÚComplexExprÚConditionalExprÚContextÚ	DecoratorÚDictExprÚDictionaryComprehensionÚEllipsisExprÚEnumCallExprÚ
ExpressionÚ	FloatExprÚFuncDefÚGeneratorExprÚ	IndexExprÚIntExprÚ
LambdaExprÚListComprehensionÚListExprÚMaybeTypeExpressionÚ
MemberExprÚMypyFileÚNamedTupleExprÚNameExprÚNewTypeExprÚ	NotParsedÚOpExprÚOverloadedFuncDefÚParamSpecExprÚPlaceholderNodeÚPromoteExprÚRefExprÚ
RevealExprÚSetComprehensionÚSetExprÚ	SliceExprÚStarExprÚStrExprÚ	SuperExprÚ
SymbolNodeÚSymbolTableNodeÚTemplateStrExprÚTempNodeÚ	TupleExprr   ÚTypeAliasExprÚTypeApplicationÚTypedDictExprÚTypeFormExprÚTypeInfoÚTypeVarExprÚTypeVarLikeExprÚTypeVarTupleExprÚ	UnaryExprÚVarÚ	YieldExprÚYieldFromExprÚget_member_expr_fullname)ÚPRECISE_TUPLE_TYPES)ÚFunctionContextÚFunctionSigContextÚMethodContextÚMethodSigContextÚPlugin)Ú
ENUM_BASES)Ústate)Úcovers_at_runtimeÚfind_memberÚis_same_typeÚ
is_subtypeÚ#merge_typevars_in_callables_by_nameÚnon_method_protocol_membersÚunion_function_signatures)Úall_name_and_member_expressionsÚhas_await_expressionÚhas_str_expression)ÚTypeVarLikeScope)ÚTypeAnalyserÚcheck_for_explicit_anyÚfix_instanceÚhas_any_from_unimported_typeÚinstantiate_type_aliasÚset_any_tvarsÚvalidate_instance)Úcallable_typeÚcustom_special_methodÚerase_to_union_or_boundÚ
false_onlyÚfixup_partial_typeÚfreeze_all_type_varsÚget_all_type_varsÚget_type_varsÚis_literal_type_likeÚmake_simplified_unionÚ	true_onlyÚtry_expanding_sum_type_to_unionÚtry_getting_str_literalsÚtuple_fallbackÚtype_object_type)*ÚLITERAL_TYPE_NAMESÚTUPLE_LIKE_INSTANCE_NAMESÚAnyTypeÚCallableTypeÚDeletedTypeÚ
ErasedTypeÚ
ExtraAttrsÚFunctionLikeÚInstanceÚLiteralTypeÚLiteralValueÚNoneTypeÚ
OverloadedÚ
ParametersÚParamSpecFlavorÚParamSpecTypeÚPartialTypeÚ
ProperTypeÚ	TupleTypeÚTypeÚTypeAliasTypeÚTypedDictTypeÚ	TypeOfAnyÚTypeTypeÚ	TypeVarIdÚTypeVarLikeTypeÚTypeVarTupleTypeÚTypeVarTypeÚUnboundTypeÚUninhabitedTypeÚ	UnionTypeÚ
UnpackTypeÚfind_unpack_in_listÚflatten_nested_tuplesÚflatten_nested_unionsÚget_proper_typeÚget_proper_typesÚget_variadic_itemÚhas_recursive_typesÚhas_type_varsÚis_named_instanceÚsplit_with_prefix_and_suffix)Úis_generic_instanceÚis_overlapping_noneÚis_self_type_likeÚremove_optional)Ú
type_state)Úfill_typevars)ÚExpressionVisitorÚ
_TypeAliasÚ
ArgCheckeré   r   Ú
MAX_UNIONS)úbuiltins.setzbuiltins.frozensetztyping.KeysViewztyping.ItemsViewz_collections_abc.dict_keysz_collections_abc.dict_itemsÚOVERLAPPING_TYPES_ALLOWLIST>   úbuiltins.memoryviewúbuiltins.bytesúbuiltins.bytearrayÚOVERLAPPING_BYTES_ALLOWLISTc                  ó   — e Zd ZdZy)ÚTooManyUnionszyIndicates that we need to stop splitting unions in an attempt
    to match an overload in order to save performance.
    N©Ú__name__Ú
__module__Ú__qualname__Ú__doc__© ó    úS/home/oem/CyberBrain26-unified/.venv/lib/python3.12/site-packages/mypy/checkexpr.pyræ   ræ   ù   s   „ òrí   ræ   c                óÒ   — t        | t        «      r| j                  ryt        | «      } t        | t        «      xs. t        | t
        «      xr t        d„ | j                  D «       «      S )NFc              3  ó2   K  — | ]  }t        |«      –— Œ y ­w©N)Úallow_fast_container_literal©Ú.0Úits     rî   ú	<genexpr>z/allow_fast_container_literal.<locals>.<genexpr>  s   è ø€ Ò(\ÈbÔ)EÀb×)IÑ(\ùó   ‚)Ú
isinstancer¾   Úis_recursiverÍ   r²   r¼   ÚallÚitems©Úts    rî   rò   rò   ÿ   sT   € Ü�!”]Ô#¨¯ªØÜ˜Ó€AÜ�aœÓ"ò Ü�1”iÓ Ò\¤SÑ(\ÐTU×T[ÑT[Ô(\Ó%\ðrí   c                  ó   — e Zd ZdZy)ÚFinishedzDRaised if we can terminate overload argument check early (no match).Nrç   rì   rí   rî   rÿ   rÿ     s   „ ÚNrí   rÿ   c                  ó   — e Zd ZdZdZdZdZy)Ú
UseReversezCUsed in `visit_op_expr` to enable or disable reverse method checks.r   é   é   N)rè   ré   rê   rë   ÚDEFAULTÚALWAYSÚNEVERrì   rí   rî   r  r    s   „ áMà€GØ€FØ�Erí   r  ÚUSE_REVERSE_DEFAULTÚUSE_REVERSE_ALWAYSÚUSE_REVERSE_NEVERc                  ó®  — e Zd ZU dZded<   ded<   ded<   ded	<   d
ed<   ded<   	 	 	 	 	 	 	 	 	 	 dÑd„ZdÒd„ZdÓd„ZdÔdÕd„Zdddœ	 	 	 	 	 	 	 	 	 	 	 dÖd„Z	d×d„Z
dØd„Z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!„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,gd-d.gd/œZd0ed1<   d2d3gid4d5gid4d5gid4d6d3gid7œZ d8ed9<   dÛd:„Z!dêd;„Z"	 	 	 	 	 	 	 	 dëd<„Z#	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 dìd=„Z$	 	 	 	 	 	 	 	 	 	 	 	 díd>„Z%	 	 	 	 	 	 	 	 	 	 	 	 	 	 dîd?„Z&	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 dïd@„Z'	 	 dð	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 dñdA„Z(	 	 	 	 	 	 dòdB„Z)	 	 	 	 	 	 	 	 dódC„Z*	 dæ	 	 	 	 	 	 	 	 	 	 	 dôdD„Z+dõdE„Z,	 	 	 	 	 dö	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 d÷dF„Z-	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 dødG„Z.dùdH„Z/dúdI„Z0dûdJ„Z1düdK„Z2dýdL„Z3	 	 	 	 	 	 	 	 	 	 dþdM„Z4	 	 	 	 	 	 dÿdN„Z5	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 �d dO„Z6	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 �ddP„Z7�ddQ„Z8	 	 	 	 	 	 	 	 	 	 	 	 �ddR„Z9	 	 	 	 	 	 	 	 �ddS„Z:	 	 	 	 	 	 	 	 	 	 	 	 �ddT„Z;	 	 dð	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 �ddU„Z<	 	 	 	 	 	 	 	 	 	 	 	 	 	 �ddV„Z=	 	 	 	 	 	 	 	 �ddW„Z>	 	 	 	 	 	 	 	 �d	dX„Z?	 	 dð	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 �d
dY„Z@	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 �ddZ„ZA	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 �dd[„ZB	 	 	 	 	 	 	 	 	 	 �dd\„ZC	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 �dd]„ZD	 	 	 	 	 	 	 	 	 	 	 	 	 	 �dd^„ZE	 	 	 	 	 	 �dd_„ZF	 �d	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 �dd`„ZG�dda„ZHeI	 	 	 	 	 	 �ddb„«       ZJ�ddc„ZK	 	 	 	 	 	 	 	 	 	 	 	 	 	 �ddd„ZL	 dÔ	 	 	 	 	 	 	 	 	 �dde„ZM	 	 	 	 	 	 	 	 	 	 �ddf„ZN	 	 	 	 	 	 	 	 	 	 	 	 �ddg„ZOdÔ�ddh„ZP	 dæ	 	 	 	 	 	 	 �ddi„ZQ	 	 	 	 	 	 	 	 �ddj„ZR�ddk„ZS�ddl„ZT�ddm„ZU�d dn„ZV�d!do„ZW�d"dp„ZX�d#dq„ZY�d$dr„ZZ�d%ds„Z[�d&dt„Z\�d'du„Z]�d(dv„Z^d(d(dddwœ	 	 	 	 	 	 	 	 	 	 	 	 	 �d)dx„Z_	 	 dð	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 �d*dy„Z`	 dæ	 	 	 	 	 	 	 	 	 	 	 	 	 �d+dz„Za	 	 	 	 	 	 	 	 	 	 	 	 	 	 �d,d{„Zb�d-d|„Zc�d.d}„Zd	 	 	 	 	 	 	 	 	 	 	 	 	 	 �d/d~„Ze	 dÔ	 	 	 	 	 	 	 	 	 	 	 �d0d„Zf�d&d€„Zg�d&d�„Zh�d1d‚„Zi�d2dƒ„Zj�d3d„„Zk�d3d…„Zl	 	 dð	 	 	 	 	 	 	 	 	 �d4d†„Zm�d5d‡„Zn�d6dˆ„Zo�d7d‰„Zp�d8dŠ„Zq�d9d‹„Zr�d:dŒ„Zs	 dÔ	 	 	 	 	 	 	 �d;d�„Zt	 	 	 	 	 	 	 	 �d<dŽ„Zu�d=d�„Zv�d>d�„Zw�d?d‘„Zx�d@d’„Zy�dAd“„Zz�dBd”„Z{�dCd•„Z|dd–œ	 	 	 	 	 	 	 �dDd—„Z}	 	 	 	 	 	 	 	 �dEd˜„Z~	 	 	 	 	 	 	 	 �dFd™„Z�dGdš„Z€�dHd›„Z�	 	 	 	 	 	 �dIdœ„Z‚�dJd�„Zƒ�dKdž„Z„�dLdŸ„Z…�dMd „Z†�dNd¡„Z‡	 	 	 	 	 	 �dOd¢„Zˆ�dPd£„Z‰	 	 	 	 	 	 �dQd¤„ZŠ�dRd¥„Z‹�dSd¦„ZŒ	 	 	 	 �dTd§„Z��dUd¨„ZŽ�dVd©„Z��dWdª„Z��dXd«„Z‘�dYd¬„Z’�dZd­„Z“	 dæ	 	 	 	 	 	 	 	 	 �d[d®„Z”�d\d¯„Z•�d]d°„Z–dÔ�d^d±„Z—	 	 �d_	 	 	 	 	 	 	 	 	 	 	 �d`d²„Z˜�dad³„Z™	 	 	 	 �db	 	 	 	 	 	 	 	 	 	 	 �dcd´„Zšdæ�dddµ„Z›�ded¶„Zœ�dfd·„Z��dd¸„Zž�dd¹„ZŸ�dgdº„Z �dhd»„Z¡dÔ�did¼„Z¢	 dÔ	 	 	 	 	 	 	 	 	 �djd½„Z£dÔ�dkd¾„Z¤�dld¿„Z¥�dmdÀ„Z¦�dndÁ„Z§�dodÂ„Z¨�dpdÃ„Z©�dqdÄ„Zª�drdÅ„Z«�dsdÆ„Z¬�dtdÇ„Z­�dudÈ„Z®�dfdÉ„Z¯�dfdÊ„Z°e±�dvdË„«       Z²e±	 	 	 	 	 	 	 	 �dwdÌ„«       Z²	 dÔ	 	 	 	 	 	 	 �dwdÍ„Z²�dxdÎ„Z³�dxdÏ„Z´�dydÐ„Zµy((z  ÚExpressionCheckerz^Expression type checker.

    This class works closely together with checker.TypeChecker.
    úmypy.checker.TypeCheckerÚchkr5   Úmsgzlist[Type | None]Útype_contextr   Ústrfrm_checkerr†   ÚpluginzArgumentInferContext | NoneÚ_arg_infer_context_cachec                ó”  — || _         || _        || _        || _        |j                  j
                  du| _        d| _        dg| _        i | _	        t        | j                   | j                  «      | _        d| _        | j                   j                  j                   t        _        d| _        i | _        d| _        d| _        d| _        y)z%Construct an expression type checker.NF)r  r  r  Úper_line_checking_time_nsÚoptionsÚline_checking_statsÚcollect_line_checking_statsÚin_expressionr  Útype_overridesr   r  Ú	is_calleeÚold_type_inferencerØ   Úinfer_polymorphicr  Ú
expr_cacheÚin_lambda_exprÚ_literal_trueÚ_literal_false)Úselfr  r  r  r  s        rî   Ú__init__zExpressionChecker.__init__,  sÀ   € ð ˆŒØˆŒØˆŒØ)BˆÔ&Ø+.¯;©;×+JÑ+JÐRVÐ+VˆÔ(ð #ˆÔØ!˜FˆÔð 79ˆÔÜ4°T·X±X¸t¿x¹xÓHˆÔð ˆŒØ+/¯8©8×+;Ñ+;×+NÑ+NÐ'NŒ
Ô$à(,ˆÔ%ð ð 	Œð $ˆÔà.2ˆÔØ/3ˆÕrí   c                ó8   — | j                   j                  «        y rñ   )r  Úclear©r!  s    rî   ÚresetzExpressionChecker.resetV  s   € Ø�‰×ÑÕrí   c                ó˜   — | j                  |«      }| j                  ||«      }| j                  j                  |j                  |«       |S )z_Type check a name expression.

        It can be of any kind: local, member or global.
        )Úanalyze_ref_exprÚnarrow_type_from_binderr  Úcheck_deprecatedÚnode)r!  ÚeÚresultÚnarroweds       rî   Úvisit_name_exprz!ExpressionChecker.visit_name_exprY  sC   € ð
 ×&Ñ& qÓ)ˆØ×/Ñ/°°6Ó:ˆØ�‰×!Ñ! !§&¡&¨!Ô,Øˆrí   Fc                óø  — d }|j                   }t        |t        «      r%|j                  rt	        t
        j                  «      S t        |t        «      rC| j                  ||«      }t        |t        «      �rb| j                  j                  ||||«      }�nBt        |t        «      r| j                  |j                  |«      }�nt        |t        «      r|j                  €f| j                  j!                  «       r2|j"                  r&| j                  j%                  |j&                  |«       t	        t
        j(                  «      }n’|j                  }n…t        |t*        t,        t.        t0        t2        f«      r"| j5                  |||j6                  xs |«      }n>t        |t8        «      rJ d|j:                  ›d�«       ‚t	        t
        j(                  «      }t        |t,        «      r�t        |t<        «      rPt        |j>                  t@        «      r6|jB                  |j>                  _!        |jD                  |j>                  _"        tG        | jH                  d   «      rtK        jL                  |«      }|€J ‚|S )NzPlaceholderNode z leaked to checkeréÿÿÿÿ)'r+  rø   r_   Úis_special_formr¬   rÀ   Úspecial_formr}   Úanalyze_var_refrº   r  Úhandle_partial_var_typerM   Úvarrc   ÚtypeÚin_checked_functionrû   Úhandle_cannot_determine_typeÚnameÚ
from_errorrT   rx   r   r]   rz   Úanalyze_static_referenceÚis_alias_rvaluere   Úfullnamer­   Úret_typer²   ÚlineÚcolumnÚis_type_type_contextr  r   Úerase_typevars)r!  r,  Úlvaluer-  r+  s        rî   r(  z"ExpressionChecker.analyze_ref_exprc  s×  € Ø"ˆØ�v‰vˆä�aœÔ" q×'8Ò'8äœ9×1Ñ1Ó2Ð2ä�dœCÔ à×)Ñ)¨$°Ó2ˆFÜ˜&¤+Õ.ØŸ™×9Ñ9¸&À&È$ÐPQÓR’Ü˜œiÔ(Ø×)Ñ)¨$¯(©(°AÓ6ŠFÜ˜Ô/Ô0Ø�y‰yÐ Ø—8‘8×/Ñ/Ô1°d·j²jØ—H‘H×9Ñ9¸$¿)¹)ÀQÔGÜ ¤×!5Ñ!5Ó6‘àŸ™‘Ü˜œw¬´)¼XÄÐWÔXØ×2Ñ2°4¸¸A×<MÑ<MÒ<WÐQWÓX‰Fä˜$¤Ô0ØTÐ 0°·±Ð0AÐASÐTÓT�uô œY×1Ñ1Ó2ˆFÜ�dœHÔ%Ü˜&¤,Ô/´JØ—‘¤ô5ð
 ()§v¡v�—‘Ô$Ø)*¯©�—‘Ô&Ü# D×$5Ñ$5°bÑ$9Ô:ô #×1Ñ1°&Ó9�ØÐ!Ð!Ð!Øˆrí   T©Úinclude_modulesÚsuppress_errorsc               óˆ  — t        |t        t        t        f«      r'|j                  xs t        t        j                  «      S t        |t        «      r| j                  j                  |«      S t        |t        «      rJ|j                  r| j                  |«      S |j                  dk(  rt        t!        «       «      S t#        |«      S t        |t$        «      rD|r| j&                  j)                  «       n	t+        «       5  | j-                  |||¬«      cddd«       S t        |t.        «      r| j1                  d«      S t        |t2        t4        f«      r| j7                  «       S t        |t8        «      r,|r| j;                  |«      S t        t        j                  «      S t        t        j<                  «      S # 1 sw Y   Œ"xY w)a¹  
        This is the version of analyze_ref_expr() that doesn't do any deferrals.

        This function can be used by member access to "static" attributes. For example,
        when accessing module attributes in protocol checks, or accessing attributes of
        special kinds (like TypeAlias, TypeInfo, etc.) on an instance or class object.
        # TODO: merge with analyze_ref_expr() when we are confident about performance.
        ztypes.NoneType©ÚctxÚalias_definitionNztyping.TypeVar)rø   r}   rM   rc   r7  r¬   rÀ   r3  rT   r  Úfunction_typerx   Útypeddict_typeÚtypeddict_callabler>  rÁ   rµ   r©   r   r  Úfilter_errorsr
   Úalias_type_in_runtime_contextry   Ú
named_typerd   r{   Úobject_typer]   Úmodule_typer;  )r!  r+  rJ  Ú	is_lvaluerF  rG  s         rî   r<  z*ExpressionChecker.analyze_static_reference�  sg  € ô" �dœS¤)Ô->Ð?Ô@Ø—9‘9Ò?¤¬	×(>Ñ(>Ó ?Ð?Ü˜œgÔ&Ø—8‘8×)Ñ)¨$Ó/Ð/Ü˜œhÔ'à×"Ò"à×.Ñ.¨tÓ4Ð4Ø—‘Ð"2Ò2ä¤£
Ó+Ð+ä'¨Ó-Ð-Ü˜œiÔ(ñ .=�—‘×'Ñ'Ô)Ä+Ã-ñ Ø×9Ñ9Ø˜c°Ið :ó ÷ñ ô ˜œkÔ*Ø—?‘?Ð#3Ó4Ð4Ü˜œ}Ô.>Ð?Ô@Ø×#Ñ#Ó%Ð%Ü˜œhÔ'á-<�4×#Ñ# DÓ)ÐaÄ'Ì)×J`ÑJ`ÓBaÐaÜ”y×+Ñ+Ó,Ð,÷ð ús   Ã>F8Æ8Gc                ó0  — |j                   r¦t        |j                   «      }t        |t        «      ru|j                  dk(  r| j                  d«      S | j                  «       r|j                  �|j                  S |j                  dv r| j                  |j                  dk(  d«      S |j                   S |j                  s@| j                  j                  «       r&| j                  j                  |j                  |«       t        t        j                   «      S )Nz
typing.Anyútyping._SpecialForm>   ÚTrueÚFalserW  úbuiltins.bool)r7  rÍ   rø   r²   r>  rQ  Úis_literal_contextÚlast_known_valuer:  Úinfer_literal_expr_typeÚis_readyr  r8  r9  r¬   rÀ   r3  )r!  r6  ÚcontextÚvar_types       rî   r4  z!ExpressionChecker.analyze_var_refÀ  sÑ   € Ø�8Š8Ü& s§x¡xÓ0ˆHÜ˜(¤HÔ-Ø—<‘< <Ò/àŸ?™?Ð+@ÓAÐAØ×*Ñ*Ô,°×1JÑ1JÐ1VØ#×4Ñ4Ð4Ø—8‘8Ð0Ñ0Ø×7Ñ7¸¿¹ÀFÑ8JÈOÓ\Ð\Ø—8‘8ˆOà—<’< D§H¡H×$@Ñ$@Ô$BØ—‘×5Ñ5°c·h±hÀÔHäœ9×1Ñ1Ó2Ð2rí   c                ód  — 	 | j                  d«      }i }t        «       }|j                  j                  «       D ]©  \  }}|j                  sŒt        |j                  t        «      r'|j                  j                  r|j                  |«       |j                  €t        t        j                  «      ||<   Œ}| j                  |j                  |j                  ddd¬«      ||<   Œ« t!        |||j"                  «      |_        |S # t        $ r# | j                  d«      j                  «       }Y �Œw xY w)Nztypes.ModuleTypeúbuiltins.objectFTrE  )rQ  ÚKeyErrorÚcopy_modifiedÚsetÚnamesrû   Úmodule_publicrø   r+  r}   Úis_finalÚaddr¬   rÀ   r;  r<  r°   r>  Úextra_attrs)r!  r+  r-  Úmodule_attrsÚ	immutabler:  Úns          rî   rS  zExpressionChecker.module_typeÒ  s  € ð	HØ—_‘_Ð%7Ó8ˆFð )+ˆÜ“Eˆ	Ø—z‘z×'Ñ'Ó)ò 	‰GˆD�!Ø—?’?ØÜ˜!Ÿ&™&¤#Ô&¨1¯6©6¯?ª?Ø—‘˜dÔ#Ø�v‰vˆ~Ü%,¬Y×-AÑ-AÓ%B�˜TÒ"ð &*×%BÑ%BØ—F‘F˜AŸF™F E¸5ÐRVð &Có &�˜TÒ"ð	ô (¨°iÀÇÁÓOˆÔØˆøô- ò 	Hð
 —_‘_Ð%6Ó7×EÑEÓG‹Fð	Hús   ‚D Ä(D/Ä.D/c                ó  — |j                   rjt        |j                   t        «      r'|j                   j                  s| j	                  |«       | j                  |j                   | j                  d   «      S | j	                  ||¬«      S )zType check a call expression.r1  ©Úallow_none_return)Úanalyzedrø   r^   Úis_typedÚvisit_call_expr_innerÚacceptr  )r!  r,  ro  s      rî   Úvisit_call_exprz!ExpressionChecker.visit_call_exprí  sj   € à�:Š:Ü˜!Ÿ*™*¤nÔ5¸a¿j¹j×>QÒ>Qð ×*Ñ*¨1Ô-à—;‘;˜qŸz™z¨4×+<Ñ+<¸RÑ+@ÓAÐAØ×)Ñ)¨!Ð?PÐ)ÓQÐQrí   c                ó  — t        |t        «      syt        |j                  t        «      r|j                  j                  �yt        |j                  t
        «      xr- t        t        |j                  j                  «      t        «      S )NFT)	rø   rg   r+  rx   rM  r   rÍ   Útargetr¿   )r!  Úbases     rî   Úrefers_to_typeddictz%ExpressionChecker.refers_to_typeddictø  sb   € Ü˜$¤Ô(ØÜ�d—i‘i¤Ô*¨t¯y©y×/GÑ/GÐ/SàÜ˜$Ÿ)™)¤YÓ/ò 
´JÜ˜DŸI™I×,Ñ,Ó-¬}ó5
ð 	
rí   c                óZ  ‡ ‡‡— ‰ j                  ‰j                  «      s?t        ‰j                  t        «      r¶‰ j                  ‰j                  j                  «      r‘t        ‰ j                  ‰j                  d¬«      «      }t        |t        «      r[t        |j                  «      }t        |t        «      sJ ‚‰ j                  |‰j                  ‰j                  ‰j                  ‰|«      S t        ‰j                  t        «      �rã‰j                  j                  dv �rÊt!        ‰j                  «      dk(  �r±t"        j$                  j'                  ‰j                  d   «      D �]�  }d }t        |t        «      r&	 ‰ j(                  j+                  |j                  «      }t/        |«      r2‰ j0                  j3                  ‰j                  j                  d‰«       Œy|r�t        |j4                  t6        «      rst        |j4                  j8                  «      }t        |t:        «      r2‰ j0                  j3                  ‰j                  j                  d‰«       Œöt        |t<        «      r�Œt        |t        «      r t        |j>                  t@        tB        f«      sot        |t        «      rz|rxt        |j4                  t6        «      r^|j4                  jD                  sHt        t        |j4                  j8                  «      tF        «      s‰ j0                  jI                  ‰«       t        |tJ        «      s�ŒÔt        |j4                  tL        «      s�Œð|j4                  jN                  r3‰ j0                  j3                  ‰j                  j                  d‰«       �Œ9|j4                  jP                  s�ŒQ‰ j0                  j3                  ‰j                  j                  d	‰«       �Œ„ ‰ jS                  ‰«       d }t        ‰j                  tT        «      �rtW        ‰j                  ‰j                  ‰j                  j                  ‰j                  j                  ˆˆ fd
„«      }	tY        t!        ‰j                  j                  «      «      D �
�cg c]D  }
t[        j\                  |	|
   D �cg c]   }‰ j                  ‰j                  |   «      ‘Œ" c}«      ‘ŒF }}
}t        |‰j                  j                  ‰j                  j                  ‰ j_                  «       ‰ ja                  d«      ¬«      }t        ‰ j                  ‰j                  |dd¬«      «      }d }d }d Št        ‰j                  tJ        «      �r‰j                  jb                  xs d Št        ‰j                  j4                  t6        «      rOt        ‰j                  j4                  j8                  «      }t        |td        «      r|jf                  jb                  Š‰sŽt        ‰j                  th        «      rt‰ j(                  jk                  ‰j                  jl                  «      rE‰j                  j                  }‰ j(                  jo                  ‰j                  jl                  «      }‰ j(                  jp                  jr                  r³‰ j(                  ju                  «       r™t        |t        «      r‰|jv                  r}|j                  tx        k7  rj‰€|�|€J ‚‰ j{                  ||«      Š‰r2t}        ˆfd„‰ j(                  jp                  j~                  D «       «      s‰ j0                  j�                  |‰«       ‰ jƒ                  |‰‰||«      }t        ‰j                  tJ        «      rkt!        ‰j                  «      dk(  rS‰j                  jb                  dv r‰ j…                  ‰«       ‰j                  jb                  dk(  r‰ j‡                  ‰«       t        ‰j                  th        «      r*‰j                  j                  dk(  r‰ j‰                  ‰«       t        |«      }t        |tF        «      rt‹        |jŒ                  «      }t        |tŽ        «      r0|j�                  s$‰ j(                  j’                  j•                  «        |sQt        |t<        «      rA‰ j—                  ‰j                  «      r&‰ j(                  j0                  j™                  |‰«       |S # t,        $ r Y �Œzw xY wc c}w c c}}
w )NT©r  )rø   Ú
issubclassr  r  ÚLiteralÚAnyÚ	TypedDictÚNewTypec                ó@   •— ‰j                  ‰j                  |    «      S rñ   )rs  Úargs)Úir,  r!  s    €€rî   ú<lambda>z9ExpressionChecker.visit_call_expr_inner.<locals>.<lambda>>  s   ø€ ˜$Ÿ+™+ a§f¡f¨Q¡iÓ0€ rí   úbuiltins.function)r?  Úfallback)Úalways_allow_anyr  c              3  óT   •K  — | ]  }‰|k(  xs ‰j                  |› d �«      –— Œ! y­w)ú.N)Ú
startswith)rô   Úpr>  s     €rî   rö   z:ExpressionChecker.visit_call_expr_inner.<locals>.<genexpr>s  s6   øè ø€ ò 'àð ˜A‘Ò= ×!4Ñ!4¸°s¸!°WÓ!=Ó=ñ'ùs   ƒ%()zbuiltins.isinstanceúbuiltins.issubclassr‹  Úformat)Mrx  Úcalleerø   rV   rw  rÍ   rs  r­   r?  r¿   Úcheck_typeddict_callÚ	arg_kindsÚ	arg_namesr�  r_   r:  ÚlenÚmypyÚcheckerÚflattenr  Úlookup_qualifiedrb  Úis_expr_literal_typer  Úcannot_use_function_with_typer+  r   rv  r¬   rµ   rp  ru   rt   Úno_argsrÈ   Útype_arguments_not_allowedrg   rx   rM  Ú
is_newtypeÚtry_infer_partial_typerX   r   Úranger   Újoin_type_listrR  rQ  r>  r²   r7  r\   Úhas_typeÚexprÚlookup_typer  Údisallow_untyped_callsr8  Úimplicitr=   Úmethod_fullnameÚanyÚuntyped_calls_excludeÚuntyped_function_callÚ check_call_expr_with_callee_typeÚcheck_runtime_protocol_testÚcheck_protocol_issubclassÚcheck_str_format_callr¤   rû   rÇ   Ú	ambiguousÚbinderÚunreachableÚalways_returns_noneÚdoes_not_return_value)r!  r,  ro  rN  rM  Útypr+  rv  r  Úformal_to_actualr‚  ÚjÚ	arg_typesÚcallee_typerR  Úmemberr?  r>  s   ``               @rî   rr  z'ExpressionChecker.visit_call_expr_inner  s†  ú€ à×$Ñ$ Q§X¡XÔ.Ü˜!Ÿ(™(¤IÔ.Ø×(Ñ(¨¯©¯©Ô7ä!0°·±¸Q¿X¹XÐQU°Ó1VÓ!WÐÜÐ,¬lÔ;Ü!0Ð1C×1LÑ1LÓ!M�Ü! .´-Ô@Ð@Ð@Ø×0Ñ0Ø" A§K¡K°·±¸a¿f¹fÀaÐI[óð ô �q—x‘x¤Õ*Ø—‘—‘Ð!=Ò=Ü�A—F‘F“˜qÓ ä—|‘|×+Ñ+¨A¯F©F°1©IÓ6ó !\�Ø�Ü˜c¤8Ô,ðØ#Ÿx™x×8Ñ8¸¿¹ÓB˜ô (¨Ô,Ø—H‘H×:Ñ:¸1¿8¹8¿=¹=È)ÐUVÔWØÙœJ t§y¡y´)Ô<Ü,¨T¯Y©Y×-=Ñ-=Ó>�FÜ! &¬'Ô2ØŸ™×>Ñ>¸q¿x¹x¿}¹}ÈeÐUVÔWØ Ü! &¬(Ô3Ù ä˜s¤IÔ.Ü" 3§<¡<´/Ä=Ð1QÔRä˜s¤HÔ-ÙÜ" 4§9¡9¬iÔ8Ø ŸI™I×-Ò-Ü&¤°t·y±y×7GÑ7GÓ'HÌ)ÔTà—H‘H×7Ñ7¸Ô:Ü˜c¤7Ö+´
¸3¿8¹8ÄXÖ0NØ—x‘x×.Ò.ØŸ™×>Ñ>¸q¿x¹x¿}¹}ÈkÐ[\Ö]ØŸ™×,Ô,ØŸ™×>Ñ>¸q¿x¹x¿}¹}ÈiÐYZÖ[ðC!\ðD 	×#Ñ# AÔ&ØˆÜ�a—h‘h¤
Õ+Ü5Ø—‘Ø—‘Ø—‘×"Ñ"Ø—‘×"Ñ"Ü0ó Ðô œs 1§8¡8×#5Ñ#5Ó6Ó7÷àô ×#Ñ#ÐEUÐVWÑEXÖ$YÀ T§[¡[°·±¸±Õ%;Ò$YÕZðˆIñ ô (ØØ—‘×"Ñ"Ø—‘×"Ñ"Ø×)Ñ)Ó+ØŸ™Ð)<Ó=ôˆLô &Ø�K‰K˜Ÿ™ ,ÀÐQUˆKÓVó
ˆð
 ˆØˆØˆÜ�a—h‘h¤Õ(ð —x‘x×(Ñ(Ò0¨DˆHÜ˜!Ÿ(™(Ÿ-™-¬Ô3Ü(¨¯©¯©×)=Ñ)=Ó>�Ü˜f¤hÔ/Ø%Ÿ{™{×3Ñ3�Hñ Ü˜qŸx™x¬Ô4Ø—H‘H×%Ñ% a§h¡h§m¡mÔ4àŸ™Ÿ™�Ø"Ÿh™h×2Ñ2°1·8±8·=±=ÓA�ð �H‰H×Ñ×3Ò3Ø—‘×,Ñ,Ô.Ü˜;¬Ô5Ø×$Ò$Ø× Ñ ¤KÒ/àÐ FÐ$6Ø"Ð.Ð.Ð.Ø×/Ñ/°¸VÓD�Ù¤3ó 'àŸ™×)Ñ)×?Ñ?ô'ô $ð —‘×.Ñ.¨{¸AÔ>à×8Ñ8Ø˜˜H k°6ó
ˆô �a—h‘h¤Ô(¬S°·±«[¸AÒ-=Ø�x‰x× Ñ Ð$RÑRØ×0Ñ0°Ô3Ø�x‰x× Ñ Ð$9Ò9Ø×.Ñ.¨qÔ1Ü�a—h‘h¤
Ô+°·±·±ÀÒ0IØ×&Ñ& qÔ)Ü" 8Ó,ˆÜ�h¤	Ô*Ü,¨X¯^©^Ó<ˆHÜ�h¤Ô0¸×9KÒ9KØ�H‰H�O‰O×'Ñ'Ô)ñ
 "Ü˜8¤XÔ.Ø×(Ñ(¨¯©Ô2à�H‰H�L‰L×.Ñ.¨{¸AÔ>Øˆøôq $ò âðüòR %Zùós*   Å?%dÒd'Ò0%d"Ó	d'ä	dädä"d'c                ó¤  — t        |j                  t        «      sJ ‚d}t        |j                  j                  d«      }t        |t
        «      r|}�n_| j                  j                  |j                  j                  «      �r/t        | j                  j                  |j                  j                  «      «      }t        |t        «      r¦|j                  j                  r�t        |j                  t        «      rvt        |j                  j                  t
        «      rR|j                  j                   |j                  j                     j                  }t        |t"        «      rt        |«      }t%        |«      }t        |t        «      r&t        |j                  t
        «      r|j                  }|�| j&                  j)                  ||«       yy)zSMore precise type checking for str.format() calls on literals and folded constants.Nz<unused>)rø   r�  r\   r   rŸ  Ústrr  rž  rÍ   r   r²   r7  Úis_enumr[  r³   Úvaluere  r½   Útry_getting_literalr  rª  )r!  r,  Úformat_valueÚfolded_callee_exprr°  Ú
value_typeÚbase_typs          rî   rª  z'ExpressionChecker.check_str_format_call“  s<  € ä˜!Ÿ(™(¤JÔ/Ð/Ð/ØˆÜ/°·±·±¸zÓJÐÜÐ(¬#Ô.Ø-ŠLØ�X‰X×Ñ˜qŸx™xŸ}™}Õ-Ü! $§(¡(×"6Ñ"6°q·x±x·}±}Ó"EÓFˆCä˜3¤Ô)Ø—H‘H×$Ò$Ü˜s×3Ñ3´[ÔAÜ˜s×3Ñ3×9Ñ9¼3Ô?à ŸX™XŸ^™^¨C×,@Ñ,@×,FÑ,FÑG×LÑL�
Ü˜j¬$Ô/Ü)¨*Ó5�CÜ*¨3Ó/ˆHÜ˜(¤KÔ0´ZÀÇÁÔPSÔ5TØ'Ÿ~™~�ØÐ#Ø×Ñ×5Ñ5°a¸ÕFð $rí   c                ó  — t        |«      }t        |t        «      r!|j                  «       r|j	                  «       }nt        |t
        «      r|j                  }d}t        |t        «      r|j                  j                  }n{t        |t        t        f«      r6|j                  j                  j                  |«      }|�|j                  nd}n/t        |t        «      rt        |«      j                  j                  }|r|› d|› �S y)z¹Convert a method name to a fully qualified name, based on the type of the object that
        it is invoked on. Return `None` if the name of `object_type` cannot be determined.
        Nrˆ  )rÍ   rø   r­   Úis_type_objÚget_instance_typerÁ   Úitemr²   r7  r>  r¿   r³   r…  Úget_containing_type_infor¼   r¨   )r!  rR  Úmethod_nameÚ	type_nameÚinfos        rî   r£  z!ExpressionChecker.method_fullname«  sÚ   € ô & kÓ2ˆä�k¤<Ô0°[×5LÑ5LÔ5Nð &×7Ñ7Ó9‰KÜ˜¤XÔ.Ø%×*Ñ*ˆKàˆ	Ü�k¤8Ô,Ø#×(Ñ(×1Ñ1‰IÜ˜¤m´[Ð%AÔBØ×'Ñ'×,Ñ,×EÑEÀkÓRˆDØ)-Ð)9˜Ÿš¸t‰IÜ˜¤YÔ/Ü& {Ó3×8Ñ8×AÑAˆIáØ�[  + Ð/Ð/àrí   c                ó>  — t        |t        «      r| j                  |j                  «      ryt        |t        «      rá|j                  €Õt        | j                  j                  |j                  «      «      }t        |t        «      r|j                  }nQt        |t        «      r@|j                  «       r0|j                  d¬«      }t        |t        «      r|j                  }nyy|j                  |j                  «      }|r| j                  |j                  «      ryy)zPCheck if `node` refers to something explicitly annotated as only returning None.T©Úforce_fallbackF)rø   rg   Údefn_returns_noner+  r\   rÍ   r  r   rŸ  r²   r7  r­   rÀ  rÁ  Úgetr:  )r!  r+  r°  rÆ  Úinstance_typeÚsyms         rî   r®  z%ExpressionChecker.always_returns_noneÇ  sÑ   € ä�dœGÔ$Ø×%Ñ% d§i¡iÔ0ØÜ�dœJÔ'¨D¯I©IÐ,=Ü! $§(¡(×"6Ñ"6°t·y±yÓ"AÓBˆCÜ˜#œxÔ(Ø—x‘x‘Ü˜C¤Ô.°3·?±?Ô3DØ #× 5Ñ 5ÀTÐ 5Ó J�Ü˜m¬XÔ6Ø(×-Ñ-‘Dà àØ—(‘(˜4Ÿ9™9Ó%ˆCÙ�t×-Ñ-¨c¯h©hÔ7ØØrí   c                óp  ‡ — t        |t        «      rIt        |j                  t        «      xr- t        t	        |j                  j
                  «      t        «      S t        |t        «      rt        ˆ fd„|j                  D «       «      S t        |t        «      ržt	        |j                  «      }|j                  s4t        |t        «      r$t        t	        |j
                  «      t        «      ryt        |t        «      r9|j                  j                  d«      }|r‰ j                  |j                  «      ryy)z'Check if `defn` can _only_ return None.c              3  ó@   •K  — | ]  }‰j                  |«      –— Œ y ­wrñ   )rÊ  )rô   rÂ  r!  s     €rî   rö   z6ExpressionChecker.defn_returns_none.<locals>.<genexpr>ä  s   øè ø€ ÒK¸�t×-Ñ-¨d×3ÑKùó   ƒTÚ__call__F)rø   rT   r7  r­   rÍ   r?  rµ   rc   rú   rû   r}   Úis_inferredr²   rË  rÊ  r+  )r!  Údefnr°  rÍ  s   `   rî   rÊ  z#ExpressionChecker.defn_returns_noneÝ  sÙ   ø€ ä�dœGÔ$Ü˜dŸi™i¬Ó6ò ¼:Ü §	¡	× 2Ñ 2Ó3´Xó<ð ô �dÔ-Ô.ÜÓKÀÇ
Á
ÔKÓKÐKÜ�dœCÔ Ü! $§)¡)Ó,ˆCà×$Ò$Ü˜s¤LÔ1Üœ¨s¯|©|Ó<¼hÔGàÜ˜#œxÔ(Ø—h‘h—l‘l :Ó.�Ù˜4×1Ñ1°#·(±(Ô;ØØrí   c                ó²  — t         j                  j                  |j                  d   «      D ]¨  }t	        | j
                  j                  |«      «      }t        |t        «      sŒ8|j                  «       sŒI|j                  «       j                  sŒd|j                  «       j                  rŒ| j
                  j                  t        j                  |«       Œª y ©Nr  )r’  r“  r”  r�  rÍ   r  r   rø   r±   rÀ  Útype_objectÚis_protocolÚruntime_protocolÚfailr   ÚRUNTIME_PROTOCOL_EXPECTED)r!  r,  rŸ  Útps       rî   r¨  z-ExpressionChecker.check_runtime_protocol_testó  s�   € Ü—L‘L×(Ñ(¨¯©°©Ó3ò 	MˆDÜ  §¡×!5Ñ!5°dÓ!;Ó<ˆBä˜2œ|Õ,Ø—N‘NÕ$Ø—N‘NÓ$×0Ó0ØŸ™Ó(×9Ó9à—‘—‘Ô.×HÑHÈ!ÕLñ	Mrí   c                óÊ  — t         j                  j                  |j                  d   «      D ]´  }t	        | j
                  j                  |«      «      }t        |t        «      sŒ8|j                  «       sŒI|j                  «       j                  sŒdt        |j                  «       «      }|sŒ€| j
                  j                  j                  |j                  «       ||«       Œ¶ y rÕ  )r’  r“  r”  r�  rÍ   r  r   rø   r±   rÀ  rÖ  r×  rŽ   r  Úreport_non_method_protocol)r!  r,  rŸ  rÛ  Úattr_memberss        rî   r©  z+ExpressionChecker.check_protocol_issubclassþ  s›   € Ü—L‘L×(Ñ(¨¯©°©Ó3ò 	_ˆDÜ  §¡×!5Ñ!5°dÓ!;Ó<ˆBÜ˜"œlÕ+°·±Õ0@ÀRÇ^Á^ÓEU×EaÓEaÜ:¸2¿>¹>Ó;KÓL�ÚØ—H‘H—L‘L×;Ñ;¸B¿N¹NÓ<LÈlÐ\]Õ^ñ	_rí   c                ó  — |r�t        d„ |D «       «      rot        |D �cg c]  }|�t        |«      nd ‘Œ c}|«      }| j                  ||¬«      }	|	�|	\  }
}| j	                  ||
|||«      S t        t        j                  «      S t        |«      dk(  r‘|d   t        k(  r…|d   }t        |t        «      r| j                  ||j                  ||«      S t        |t        «      rBt        |j                  t        «      r(| j                  ||j                  j                  ||«      S |s| j	                  |i ||t!        «       «      S | j"                  j%                  t&        j(                  |«       t        t        j                  «      S c c}w )Nc              3  ó8   K  — | ]  }|t         t        fv –— Œ y ­wrñ   )r8   r;   )rô   Úaks     rî   rö   z9ExpressionChecker.check_typeddict_call.<locals>.<genexpr>  s   è ø€ ÒI¸˜œy¬)Ð4Ô4ÑIùs   ‚©Úkwargsr�  r  r   )rú   Úziprm   Úvalidate_typeddict_kwargsÚ check_typeddict_call_with_kwargsr¬   rÀ   r;  r‘  r9   rø   rN   Úcheck_typeddict_call_with_dictrû   rG   rp  rd  r  rÙ  r   ÚINVALID_TYPEDDICT_ARGS)r!  r�  r�  r�  r�  r^  Úorig_calleerl  rã  r-  Úvalidated_kwargsÚalways_present_keysÚ
unique_args                rî   rŽ  z&ExpressionChecker.check_typeddict_call  sv  € ñ ”CÑI¸yÔIÔIô ÈÖSÀA¨¨œ' !œ*¸4Ñ?ÒSÐUYÓZˆFØ×3Ñ3¸6È&Ð3ÓQˆFØÐ!Ø8>Ñ5Ð Ð"5Ø×<Ñ<ØÐ,¨g°{ÐDWóð ô œ9×/Ñ/Ó0Ð0äˆt‹9˜Š>˜i¨™l¬gÒ5Ø˜a™ˆJÜ˜*¤hÔ/à×:Ñ:Ø˜J×,Ñ,¨g°{óð ô ˜*¤hÔ/´J¸z×?RÑ?RÔT\Ô4]à×:Ñ:Ø˜J×/Ñ/×5Ñ5°wÀóð ñ à×8Ñ8¸ÀÀWÈkÔ[^Ó[`ÓaÐaà�‰�‰Ô&×=Ñ=¸wÔGÜ”y×+Ñ+Ó,Ð,ùò7 Ts   žFc                ó  — t        t        «      }t        «       }d }|D ]·  \  }}|r�| j                  |«      }t	        ||«      }	d }
|	rt        |	«      dk(  r|	d   }
|
€B|xs |}| j                  j                  t        j                  |t        j                  ¬«        y |g||
<   |j                  |
«       Œ˜| j                  ||||«      \  }}|s y |sŒ¶|}Œ¹ | j                  j                  j                  r�|�Ž|j                   r,| j                  j                  d|t        j"                  ¬«       g }|j$                  D ]'  }||j&                  vsŒ||vsŒ|j)                  |«       Œ) |r| j*                  j-                  ||«       ||fS )Nr  r   ©ÚcodezFCannot unpack item that may contain extra keys into a closed TypedDict)r   Úlistrd  rs  r§   r‘  r  rÙ  r   Ú$TYPEDDICT_KEY_MUST_BE_STRING_LITERALÚcodesÚLITERAL_REQrh  Úvalidate_star_typeddict_itemr  Úextra_checksÚ	is_closedÚTYPEDDICT_ITEMrû   Úrequired_keysÚappendr  Ú"non_required_keys_absent_with_star)r!  rã  r�  r-  rë  Úlast_open_star_foundÚitem_name_exprÚitem_argÚkey_typeÚvaluesÚliteral_valueÚkey_contextÚis_validÚis_openÚabsent_keysÚkeys                   rî   rå  z+ExpressionChecker.validate_typeddict_kwargs0  s¡  € ô œTÓ"ˆä!›eÐà#Ðà(.ò 	4Ñ$ˆN˜HÙØŸ;™; ~Ó6�Ü1°.À(ÓK�Ø $�Ùœc &›k¨QÒ.Ø$*¨1¡I�MØ Ð(Ø"0Ò"<°H�KØ—H‘H—M‘MÜ(×MÑMØ#Ü"×.Ñ.ð "ô ñ
  ð
 .6¨J�F˜=Ñ)Ø'×+Ñ+¨MÕ:à$(×$EÑ$EØ˜f fÐ.Aó%Ñ!�˜'ñ  ÙÚØ+3Ñ(ð9	4ð: �8‰8×Ñ×(Ò(Ð-AÐ-MØ×ÒØ—‘—‘Ø\Ø(Ü×-Ñ-ð ô ð
 ˆKØ—|‘|ò ,�Ø˜f×2Ñ2Ò2°sÀ&Ò7HØ×&Ñ& sÕ+ð,ñ ð
 —‘×;Ñ;¸KÐI]Ô^ØÐ*Ð*Ð*rí   c           
     ó  ‡— t        | j                  ||¬«      «      }d}g }t        |t        «      r|g}n²t        |t        «      rrt        |j                  «       «      D ]U  }t        |t        «      r|j                  |«       Œ%| j                  |«      s| j                  j                  ||«        yd}ŒW n0| j                  |«      s| j                  j                  ||«       yd}t        «       }	|D ]  }
|	|
j                  j                  «       z  }	Œ! |	D ]Ç  Št        t	        j                  |D �
cg c]   }
‰|
j                  v sŒ|
j                  ‰   ‘Œ" c}
«      «      }|j!                  |«       t#        ˆfd„|D «       «      rD|j%                  ‰«       |‰   r'|‰   d   }t        |t        «      s||g|‰<   Œ¦|g|‰<   Œ­|g|‰<   Œ´|‰   j                  |«       ŒÉ t#        d„ |D «       «      }d|xs | fS c c}
w )a|  Update keys/expressions from a ** expression in TypedDict constructor.

        Note `result` and `always_present_keys` are updated in place.

        First tuple item returned is true if the expression `item_arg` may valid
        in `callee` TypedDict context. Second tuple item returned is true if the
        expression may contain other keys not explicitly declared.
        ©r  F©FTTc              3  ó:   •K  — | ]  }‰|j                   v –— Œ y ­wrñ   )rø  )rô   Útdr  s     €rî   rö   zAExpressionChecker.validate_star_typeddict_item.<locals>.<genexpr>”  s   øè ø€ ÒB¨r�3˜"×*Ñ*Ô*ÑBùs   ƒr   c              3  ó4   K  — | ]  }|j                   –— Œ y ­wrñ   )rö  ©rô   rý   s     rî   rö   zAExpressionChecker.validate_star_typeddict_item.<locals>.<genexpr>¨  s   è ø€ Ò;¨˜Ÿ�Ñ;ùs   ‚)rÍ   rs  rø   r¿   rÈ   rÎ   Úrelevant_itemsrù  Úvalid_unpack_fallback_itemr  Ú%unsupported_target_for_star_typeddictrd  rû   Úkeysrr   Ú
make_unionÚset_linerú   rh  )r!  rý  r�  r-  rë  ÚinferredÚany_fallbackÚpossible_tdsrÂ  Úall_keysr
  ÚargÚfirstÚ
all_closedr  s                 @rî   rô  z.ExpressionChecker.validate_star_typeddict_itemj  sê  ø€ ô # 4§;¡;¨xÀf ;Ó#MÓNˆØˆØ,.ˆÜ�h¤Ô.Ø$˜:‰LÜ˜¤)Ô,Ü(¨×)@Ñ)@Ó)BÓCò (�Ü˜d¤MÔ2Ø ×'Ñ'¨Õ-Ø×8Ñ8¸Ô>Ø—H‘H×BÑBÀ4ÈÔRÙ&à#'‘Lñ(ð ×0Ñ0°Ô:Ø�H‰H×:Ñ:¸8ÀXÔNØàˆLÜ ›UˆØò 	(ˆBØ˜Ÿ™Ÿ™›Ñ'‰Hð	(àò 	(ˆCÜÜ×$Ñ$¸lÖ%^¸ÈcÐUW×U]ÑU]Êo b§h¡h¨s£mÒ%^Ó_óˆCð �L‰L˜Ô"ÜÓB°\ÔBÔBØ#×'Ñ'¨Ô,ð
 ˜#’;Ø" 3™K¨™N�EÜ% e¬XÔ6ð (-¨c l˜˜sšà'* e˜˜sšà#& %�F˜3’Kð �s‘×"Ñ" 3Õ'ð1	(ô2 Ñ;¨lÔ;Ó;ˆ
Ø�\Ò3¨ ^Ð3Ð3ùò1 &_s   Ä3G=ÅG=c                ó  — t        |t        «      ryt        |t        «      r|j                  j	                  d«      syt        || j                  j                  d«      «      }t        d„ t        |j                  «      D «       «      S )NTútyping.MappingFc              3  ó<   K  — | ]  }t        |t        «      –— Œ y ­wrñ   )rø   r¬   ©rô   Úas     rî   rö   z?ExpressionChecker.valid_unpack_fallback_item.<locals>.<genexpr>±  s   è ø€ ÒQ¨a”:˜a¤×)ÑQùó   ‚)rø   r¬   r²   r7  Úhas_baser1   r  Úlookup_typeinforú   rÎ   r�  )r!  r°  Úmappeds      rî   r  z,ExpressionChecker.valid_unpack_fallback_item«  se   € Ü�cœ7Ô#ØÜ˜#œxÔ(°·±×0AÑ0AÐBRÔ0SØÜ*¨3°·±×0HÑ0HÐIYÓ0ZÓ[ˆÜÑQÔ3CÀFÇKÁKÓ3PÔQÓQÐQrí   c                ó:  — | j                   j                  «       5  | j                  ||¬«      }d d d «       �W|\  }}|j                  t	        |j                  «       «      cxk  xr& t	        |j                  j                  «       «      k  S c S y# 1 sw Y   ŒcxY w)Nrâ  F)r  rO  rå  rø  rd  r  rû   )r!  r�  rã  r^  r-  rê  Ú_s          rî   Úmatch_typeddict_call_with_dictz0ExpressionChecker.match_typeddict_call_with_dict³  s“   € ð �X‰X×#Ñ#Ó%ñ 	RØ×3Ñ3¸6È&Ð3ÓQˆF÷	RàÐØ"(ÑÐ˜aØ×'Ñ'¬3Ð/?×/DÑ/DÓ/FÓ+GÖcÌ3ÈvÏ|É|×O`ÑO`ÓObÓKcÑcÐcÑcÐcà÷	Rð 	Rús   ›BÂBc                ó”   — | j                  ||¬«      }|�|\  }}| j                  |||||¬«      S t        t        j                  «      S )Nrâ  )rã  r^  ré  rë  )rå  ræ  r¬   rÀ   r;  )r!  r�  rã  r^  ré  r-  rê  rë  s           rî   rç  z0ExpressionChecker.check_typeddict_call_with_dictÁ  se   € ð ×/Ñ/°vÀfÐ/ÓMˆØÐØ4:Ñ1ÐÐ1Ø×8Ñ8ØØ'ØØ'Ø$7ð 9ó ð ô œ9×/Ñ/Ó0Ð0rí   c                óÚ   — |j                   €J ‚|j                   j                  }t        |t        «      rt        |t        «      sJ ‚| j                  ||j                  j                  «      S )a“  Construct a reasonable type for a TypedDict type in runtime context.

        If it appears as a callee, it will be special-cased anyway, e.g. it is
        also allowed to accept a single positional argument if it is a dict literal.

        Note it is not safe to move this to type_object_type() since it will crash
        on plugin-generated TypedDicts, that may not have the special_alias.
        )Úspecial_aliasrv  rø   r»   r¿   Útypeddict_callable_from_contextrÓ  Ú	type_vars)r!  rÆ  rv  s      rî   rN  z$ExpressionChecker.typeddict_callableÕ  s]   € ð ×!Ñ!Ð-Ð-Ð-Ø×#Ñ#×*Ñ*ˆÜ˜&¤*Ô-´*¸VÄ]Ô2SÐSÐSØ×3Ñ3°F¸D¿I¹I×<OÑ<OÓPÐPrí   Nc           	     óZ  — t        t        |j                  j                  «       «      |j                  D �cg c]0  }||j                  v rt
        j                  nt
        j                  ‘Œ2 c}t        |j                  j                  «       «      || j                  d«      |d¬«      S c c}w )Núbuiltins.typeT)Ú	variablesÚis_bound)
r­   rð  rû   rÿ  rø  rB   r8   ÚARG_NAMED_OPTr  rQ  )r!  r�  r-  r:  s       rî   r)  z1ExpressionChecker.typeddict_callable_from_contextã  s‘   € ô Ü�—‘×$Ñ$Ó&Ó'ð #ŸL™Löàð &*¨V×-AÑ-AÑ%A”×!Ò!Äw×G\ÑG\Ñ\òô �—‘×"Ñ"Ó$Ó%ØØ�O‰O˜OÓ,ØØô
ð 	
ùòs   ¶5B(
c                ó(  — |j                  «       }|j                  r.||j                  z  }|r| j                  j	                  ||¬«       |j
                  |k  r||j                  j                  «       k  �s%||j                  j                  «       k  s`| j                  j                  ||j                  j                  «       D �cg c]  }||j
                  v s||v r|‘Œ c}t        |«      |¬«       |j
                  |k  sq| j                  j                  ||j                  j                  «       D �cg c]  }||j
                  v sŒ|‘Œ c}|D �cg c]  }||j
                  v sŒ|‘Œ c}|¬«       |j
                  |kD  rt        t        j                  «      S t        |«      }t        |t        «      r|}	nW|j                  j                   j"                  �&| j%                  |j                  j                   «      }	n| j'                  |«      }	| j                  j)                  «       5  | j*                  j,                  5  | j/                  |	|j1                  «       D �
cg c]  }
|
d   ‘Œ	 c}
t2        j4                  gt7        |«      z  |t        |j                  «       «      d d d «      \  }}d d d «       d d d «       t        «      }t        |t8        «      s|}|j                  j                  «       D ]l  \  }}||v sŒ||   }|D ]X  }| j*                  j;                  |||t=        t>        j@                  jB                  tD        jF                  ¬«      d|› d�d¬«       ŒZ Œn |S c c}w c c}w c c}w c c}
w # 1 sw Y   ŒÍxY w# 1 sw Y   ŒÑxY w)	N©r^  )Úexpected_keysÚactual_keysr^  r   rî  zTypedDict item "ú"Ú
expression)Úlvalue_typeÚrvaluer^  r  Úlvalue_nameÚrvalue_name)$r  Úto_be_mutatedÚreadonly_keysr  Úreadonly_keys_mutatedrø  rû   Úunexpected_typeddict_keysrð  r¬   rÀ   r;  rÍ   rø   r­   r…  r7  r(  rN  r)  rO  r  Úlocal_type_mapÚcheck_callable_callrÿ  rB   r8   r‘  r¿   Úcheck_simple_assignmentr4   r   ÚINCOMPATIBLE_TYPESr¹  rò  r÷  )r!  r�  rã  r^  ré  rë  r3  Úassigned_readonly_keysr  Úinfer_calleer�  Úorig_ret_typer$  r?  Ú	item_nameÚitem_expected_typeÚitem_valuesÚ
item_values                     rî   ræ  z2ExpressionChecker.check_typeddict_call_with_kwargsó  sR  € ð —k‘k“mˆØ×ÒØ%0°6×3GÑ3GÑ%GÐ"Ù%Ø—‘×.Ñ.Ð/EÈwÐ.ÔWà× Ñ Ð$7Ò7¸KÈ6Ï<É<×K\ÑK\ÓK^Ó<^à 6§<¡<×#4Ñ#4Ó#6Ò6Ø—‘×2Ñ2Øð $*§<¡<×#4Ñ#4Ó#6ö#àØ &×"6Ñ"6Ñ6¸#ÀÑ:Lò ò#ô
 !% [Ó 1Ø#ð 3ô 	ð ×(Ñ(Ð,?Ò?Ø—‘×2Ñ2Øà'-§|¡|×'8Ñ'8Ó':ö#Ø #¸cÀV×EYÑEYÒ>Yšò#ð (;ö!Ø #¸cÀV×EYÑEYÒ>Yšò!ð $ð 3ô 	ð ×#Ñ# kÒ1ô œy×3Ñ3Ó4Ð4ä% kÓ2ˆÜ�k¤<Ô0Ø&‰Lð �‰×#Ñ#×1Ñ1Ð=Ø#×6Ñ6°v·±×7KÑ7KÓL‘ð  $×CÑCÀFÓK�ð �X‰X×#Ñ#Ó%ñ 	 t§x¡x×'>Ñ'>ñ 	Ø#×7Ñ7Øð &,§]¡]£_Ö5˜T��a“Ò5Ü×"Ñ"Ð#¤c¨&£kÑ1ØÜ�V—[‘[“]Ó#ØØØó ÑˆM˜1÷	÷ 	ô # =Ó1ˆÜ˜(¤MÔ2ð ˆHà-5¯^©^×-AÑ-AÓ-Cò 	Ñ)ˆIÐ)Ø˜FÒ"Ø$ YÑ/�Ø"-ò 
�JØ—H‘H×4Ñ4Ø$6Ø)Ø *Ü(Ü,×?Ñ?×EÑEÌE×L`ÑL`ôð '7°y°kÀÐ$CØ$0ð 5õ 	ñ
ð	ð ÐùòU#ùò#ùò!ùò< 6÷	ð 	ú÷ 	ð 	úsU   ÃM(
Ä6M-
Å
M-
ÅM2Å(M2È,NÉM<É"M7É.AM<Ê0NÍ7M<Í<N	ÎNÎNc                ó  — t        |j                  t        «      rDt        |j                  j                  t        «      r |j                  j                  j
                  sy| j                  j                  j                  «       }|r|j                  |j                  vry|j                  |j                     }t        |j                  t        «      r0t        |j                  j                  t        «      r|j                  S y)z»Get variable node for a partial self attribute.

        If the expression is not a self attribute, or attribute is not variable,
        or variable is not partial, return None.
        N)rø   rŸ  r_   r+  r}   Úis_selfr  ÚscopeÚenclosing_classr:  re  r7  rº   )r!  rŸ  rÆ  rÍ  s       rî   Úget_partial_self_varz&ExpressionChecker.get_partial_self_varR  s¢   € ô �t—y‘y¤(Ô+Ü˜4Ÿ9™9Ÿ>™>¬3Ô/Ø—	‘	—‘×&Ò&ð Ø�x‰x�~‰~×-Ñ-Ó/ˆÙ�t—y‘y¨¯
©
Ñ2àØ�j‰j˜Ÿ™Ñ#ˆÜ�c—h‘h¤Ô$¬°C·H±H·M±MÄ;Ô)OØ—8‘8ˆOØrí   rù  rh  Údiscard)úbuiltins.listrß   zClassVar[dict[str, list[str]]]Ú	item_argsÚextendrO  Úupdateúbuiltins.dictrß   )rO  rS  zcollections.OrderedDictrß   z)ClassVar[dict[str, dict[str, list[str]]]]Úcontainer_argsc                ó`  — t        |j                  t        «      sy|j                  }t        |j                  t        «      rf| j                  |j                  «      }|€y|\  }}| j                  ||j                  |«      }|�#||v r| j                  j                  |||«       yyyt        |j                  t        «      �rlt        |j                  j                  t        «      �rF|j                  j                  �y|j                  j                  }|j                  j                  }| j                  |«      }|€y|\  }}t        |j                  «      }	|	�|	j                   €y| j                  ||j                  |«      }
|
�¦| j#                  |«      }t$        j&                  j)                  || j                  j*                  «      r`|	j                  €J ‚|	j                  j,                  }| j                  j/                  |||
g«      }| j                  j                  |||«       yyyyy)z-Try to make partial type precise from a call.N)rø   r�  r\   rŸ  rg   Úget_partial_varÚ&try_infer_partial_value_type_from_callr:  r  Úreplace_partial_typerV   rw  rp  ÚindexÚget_partial_instance_typer7  r½  rs  r’  r“  Úis_valid_inferred_typer  r>  Únamed_generic_type)r!  r,  r�  Úretr6  Úpartial_typesr°  rw  rY  Úpartial_typer½  rþ  ÚtypenameÚnew_types                 rî   r›  z(ExpressionChecker.try_infer_partial_typet  sÜ  € ä˜!Ÿ(™(¤JÔ/ØØ—‘ˆÜ�f—k‘k¤7Ô+à×&Ñ& v§{¡{Ó3ˆCØˆ{ØØ!$ÑˆC�Ø×=Ñ=¸aÀÇÁÈcÓRˆCàˆ 3¨-Ñ#7Ø—‘×-Ñ-¨c°3¸ÕFð $8ˆä˜Ÿ™¤YÕ/´J¸v¿{¹{×?OÑ?OÔQXÕ4Yà�{‰{×#Ñ#Ð/ØØ—;‘;×#Ñ#ˆDØ—K‘K×%Ñ%ˆEØ×&Ñ& tÓ,ˆCØˆ{ØØ!$ÑˆC�Ü4°S·X±XÓ>ˆLØÐ# |×'>Ñ'>Ð'FØØ×DÑDÀQÈÏÉÐUXÓYˆJØÐ%àŸ;™; uÓ-�Ü—<‘<×6Ñ6°xÀÇÁ×AQÑAQÔRà'×,Ñ,Ð8Ð8Ð8Ø+×0Ñ0×9Ñ9�HØ#Ÿx™x×:Ñ:¸8ÀhÐPZÐE[Ó\�HØ—H‘H×1Ñ1°#°xÀÕOð Sð &ð 5ZÐ/rí   c                óÆ   — |j                   }|€!t        |t        «      r| j                  |«      }t        |t        «      sy | j
                  j                  |«      }|€y ||fS rñ   )r+  rø   r\   rM  r}   r  Úfind_partial_types)r!  Úrefr6  r^  s       rî   rV  z!ExpressionChecker.get_partial_var›  s^   € Ø�h‰hˆØˆ;œ: c¬:Ô6Ø×+Ñ+¨CÓ0ˆCÜ˜#œsÔ#ØØŸ™×3Ñ3°CÓ8ˆØÐ ØØ�MÐ!Ð!rí   c                óf  ‡ — ‰ j                   j                  ryt        |j                  «      }|€y|j                  r!|j                  j                  j
                  }n$|j                  €J ‚|j                  j
                  }|‰ j                  v r•|‰ j                  |   v r„|j                  t        gk(  rp‰ j                  |j                  d   «      }t        j                  j                  |‰ j                   j                  «      r‰ j                   j                  ||g«      S y|‰ j                   v rÿ|‰ j                   |   v rî|j                  t        gk(  rÚt#        ‰ j                  |j                  d   «      «      }t%        |t&        «      rx|j                  j
                  }|‰ j                   |   |   v rMt)        ˆ fd„|j                  D «       «      r/‰ j                   j                  |t+        |j                  «      «      S yt%        |t,        «      r‰ j                   j/                  |«      S y)zCTry to make partial type precise from a call such as 'x.append(y)'.Nr   c              3  ó†   •K  — | ]8  }t         j                  j                  |‰j                  j                  «      –— Œ: y ­wrñ   )r’  r“  r[  r  r  )rô   Ú	item_typer!  s     €rî   rö   zKExpressionChecker.try_infer_partial_value_type_from_call.<locals>.<genexpr>Ç  s4   øè ø€ ò à%ô Ÿ™×;Ñ;¸IÀtÇxÁx×GWÑGW×Xñùs   ƒ>A)r  Úcurrent_node_deferredrZ  r7  r½  r>  rP  r�  r9   rs  r�  r’  r“  r[  r  r\  rT  rÍ   rø   r²   rú   rð  r¬   rQ  )	r!  r,  Ú
methodnamer6  r_  r`  rg  Úarg_typeÚarg_typenames	   `        rî   rW  z8ExpressionChecker.try_infer_partial_value_type_from_call¦  sÏ  ø€ ð �8‰8×)Ò)ØÜ0°·±Ó:ˆØÐØØ×"Ò"Ø#×.Ñ.×3Ñ3×<Ñ<‰Hà×$Ñ$Ð0Ð0Ð0Ø#×(Ñ(×1Ñ1ˆHð ˜Ÿ™Ñ&Ø˜dŸn™n¨XÑ6Ñ6Ø—‘¤˜yÒ(àŸ™ A§F¡F¨1¡IÓ.ˆIÜ�|‰|×2Ñ2°9¸d¿h¹h×>NÑ>NÔOØ—x‘x×2Ñ2°8¸i¸[ÓIÐIð$ ð! ˜×+Ñ+Ñ+Ø˜d×1Ñ1°(Ñ;Ñ;Ø—‘¤˜yÒ(ä& t§{¡{°1·6±6¸!±9Ó'=Ó>ˆHÜ˜(¤HÔ-Ø'Ÿ}™}×5Ñ5�Ø 4×#6Ñ#6°xÑ#@ÀÑ#LÑLÜó à)1¯©ôô ð  $Ÿx™x×:Ñ:¸8ÄTÈ(Ï-É-ÓEXÓYÐYð ô ˜H¤gÔ.Ø—x‘x×*Ñ*¨8Ó4Ð4àrí   c
                ó¢  — t        |j                  «      }
t        |
«      D �cg c]  }g ‘Œ }}t        |
«      D �cg c]  }g ‘Œ }}t        |
«      D �cg c]  }g ‘Œ }}t        |
«      D �cg c]  }g ‘Œ }}t        |«      D ]  \  }}|D ]u  }||   j	                  ||   «       ||   j	                  ||   «       |r||   j	                  ||   «       n||   j	                  d«       ||   j	                  ||   «       Œw Œ� |€V| j
                  j                  |«      }|€J ‚ |t        |||j                  ||j                  ||	| j                  ¬«      «      S | j
                  j                  |«      }|€J ‚t        |«      } |t        ||||j                  ||j                  ||	| j                  ¬«	      «      S c c}w c c}w c c}w c c}w )aº  Use special case logic to infer the return type of a specific named function/method.

        Caller must ensure that a plugin hook exists. There are two different cases:

        - If object_type is None, the caller must ensure that a function hook exists
          for fullname.
        - If object_type is not None, the caller must ensure that a method hook exists
          for fullname.

        Return the inferred return type.
        N)r³  r�  Úcallee_arg_namesr�  Údefault_return_typer�  r^  Úapi)	r7  r³  r�  rm  r�  rn  r�  r^  ro  )r‘  r³  rœ  Ú	enumeraterù  r  Úget_function_hookr‚   r�  r?  r  Úget_method_hookrÍ   r„   )r!  r�  r�  r³  r�  r±  r�  r>  rR  r^  Únum_formalsr$  Úformal_arg_typesÚformal_arg_exprsÚformal_arg_namesÚformal_arg_kindsÚformalÚactualsÚactualÚcallbackÚmethod_callbacks                        rî   Úapply_function_pluginz'ExpressionChecker.apply_function_pluginÑ  sö  € ô. ˜&×*Ñ*Ó+ˆÜ:?ÀÓ:LÖ-M°QªbÐ-MÐÐ-MÜ@EÀkÓ@RÖ3S¸1²BÐ3SÐÐ3SÜ@EÀkÓ@RÖ3S¸1²BÐ3SÐÐ3SÜ=BÀ;Ó=OÖ0P¸²Ð0PÐÐ0PÜ(Ð)9Ó:ò 	C‰OˆF�GØ!ò C�Ø  Ñ(×/Ñ/°	¸&Ñ0AÔBØ  Ñ(×/Ñ/°°V±Ô=ÙØ$ VÑ,×3Ñ3°I¸fÑ4EÕFà$ VÑ,×3Ñ3°DÔ9Ø  Ñ(×/Ñ/°	¸&Ñ0AÕBñCð	Cð Ðà—{‘{×4Ñ4°XÓ>ˆHØÐ'Ð'Ð'ÙÜØ.Ø.Ø%+×%5Ñ%5Ø.Ø(.¯©Ø)Ø#ØŸ™ô	óð ð #Ÿk™k×9Ñ9¸(ÓCˆOØ"Ð.Ð.Ð.Ü)¨+Ó6ˆKÙ"ÜØ$Ø.Ø.Ø%+×%5Ñ%5Ø.Ø(.¯©Ø)Ø#ØŸ™ô
óð ùòG .NùÚ3SùÚ3SùÚ0Ps   £	F=»	GÁ	GÁ+	Gc                ó  ‡ ‡— t        |t        «      rŽt        |j                  «      }t	        |||j                  |j
                  ˆˆ fd„«      }t        |«      D �cg c]  }g ‘Œ }	}t        |«      D ]#  \  }
}|D ]  }|	|
   j                  ‰|   «       Œ Œ%  ||	|«      S t        |t        «      sJ ‚g }|j                  D ]:  }‰ j                  |‰|||«      }t        |t        «      sJ ‚|j                  |«       Œ< t        |«      S c c}w )z@Helper to apply a signature hook for either a function or methodc                ó,   •— ‰j                  ‰|    «      S rñ   ©rs  ©r‚  r�  r!  s    €€rî   rƒ  z8ExpressionChecker.apply_signature_hook.<locals>.<lambda>*  ó   ø€ ˜$Ÿ+™+ d¨1¡gÓ.€ rí   )rø   r­   r‘  r�  r   r�  rœ  rp  rù  r¶   rû   Úapply_signature_hook)r!  r�  r�  r�  r�  Úhookrs  r±  r$  ru  rx  ry  rz  rû   rÂ  Úadjusteds   ` `             rî   rƒ  z&ExpressionChecker.apply_signature_hook  s%  ù€ ô �fœlÔ+Ü˜f×.Ñ.Ó/ˆKÜ5ØØØ× Ñ Ø× Ñ Ü.ó Ðô EJÈ+ÓDVÖ7W¸qºÐ7WÐÐ7WÜ#,Ð-=Ó#>ò B‘�˜Ø%ò B�FØ$ VÑ,×3Ñ3°D¸±LÕAñBðBñ Ð(¨&Ó1Ð1ä˜f¤jÔ1Ð1Ð1ØˆEØŸ™ò '�Ø×4Ñ4°T¸4ÀÈIÐW[Ó\�Ü! (¬LÔ9Ð9Ð9Ø—‘˜XÕ&ð'ô ˜eÓ$Ð$ùò 8Xs   Á	D	c           	     ó<   ‡ ‡‡— ‰ j                  ||||ˆˆ ˆfd„«      S )zKApply a plugin hook that may infer a more precise signature for a function.c                ó@   •—  ‰t        | |‰‰j                  «      «      S rñ   )rƒ   r  )r�  Úsigr^  r!  Úsignature_hooks     €€€rî   rƒ  zAExpressionChecker.apply_function_signature_hook.<locals>.<lambda>I  s   ø€ ™~Ô.@ÀÀsÈGÐUY×U]ÑU]Ó.^Ó_€ rí   )rƒ  )r!  r�  r�  r�  r^  r�  r‰  s   `   ` `rî   Úapply_function_signature_hookz/ExpressionChecker.apply_function_signature_hook:  s'   ú€ ð ×(Ñ(ØØØØÝ_ó
ð 	
rí   c           
     óV   ‡ ‡‡‡— t        |«      Š‰ j                  ||||ˆˆˆ ˆfd„«      S )zIApply a plugin hook that may infer a more precise signature for a method.c           	     óB   •—  ‰t        ‰| |‰‰j                  «      «      S rñ   )r…   r  )r�  rˆ  r^  Úpobject_typer!  r‰  s     €€€€rî   rƒ  z?ExpressionChecker.apply_method_signature_hook.<locals>.<lambda>^  s    ø€ ¡.Ü$ \°4¸¸gÀtÇxÁxÓPó#€ rí   )rÍ   rƒ  )	r!  r�  r�  r�  r^  r�  rR  r‰  r�  s	   `   `  `@rî   Úapply_method_signature_hookz-ExpressionChecker.apply_method_signature_hookL  s3   û€ ô ' {Ó3ˆØ×(Ñ(ØØØØöó

ð 
	
rí   c           	     ó  — t        |«      }|�{t        |t        «      rk|�6| j                  j	                  |«      }|r| j                  |||||||«      S |S | j                  j                  |«      }	|	r| j                  ||||||	«      S |S )a6  Attempt to determine a more accurate signature for a method call.

        This is done by looking up and applying a method signature hook (if one exists for the
        given method name).

        If no matching method signature hook is found, callee is returned unmodified. The same
        happens if the arguments refer to a non-method callable (this is allowed so that the code
        calling transform_callee_type needs to perform fewer boilerplate checks).

        Note: this method is *not* called automatically as part of check_call, because in some
        cases check_call is called multiple times while checking a single call (for example when
        dealing with overloads). Instead, this method needs to be called explicitly
        (if appropriate) before the signature is passed to check_call.
        )rÍ   rø   r±   r  Úget_method_signature_hookrŽ  Úget_function_signature_hookrŠ  )
r!  r6   r�  r�  r�  r^  r�  rR  Úmethod_sig_hookÚfunction_sig_hooks
             rî   Útransform_callee_typez'ExpressionChecker.transform_callee_typed  s¦   € ô0 ! Ó(ˆØÐ$¬°F¼LÔ)IØÐ&Ø"&§+¡+×"GÑ"GÈÓ"V�Ù"Ø×;Ñ;Ø  i°¸)À[ÐRaóð ð ˆð %)§K¡K×$KÑ$KÈMÓ$ZÐ!Ù$Ø×=Ñ=Ø  i°¸)ÐEVóð ð ˆrí   c                ó  — |j                   sJ ‚t        |j                  «      dk7  st        |«      dk7  ryt        t	        |j                  d   «      t
        «      syt        t	        |j                  «      t
        «      sy| j                  j                  5  | j                  j                  «       5  t	        | j                  |d   d¬«      «      }ddd«       ddd«       t        t        «      r|S y# 1 sw Y   Œ$xY w# 1 sw Y   Œ(xY w)zSCheck if this looks like an application of a generic function to overload argument.r  Nr   r  )r-  r‘  r³  rø   rÍ   r­   r?  r  r>  r  rO  rs  r¶   )r!  r´  r�  rj  s       rî   Ú"is_generic_decorator_overload_callz4ExpressionChecker.is_generic_decorator_overload_call�  sæ   € ð ×$Ò$Ð$Ð$Üˆ{×$Ñ$Ó%¨Ò*¬c°$«i¸1ªnàÜœ/¨+×*?Ñ*?ÀÑ*BÓCÄ\ÔRØÜœ/¨+×*>Ñ*>Ó?ÄÔNØØ�X‰X×$Ñ$ñ 	TØ—‘×'Ñ'Ó)ñ TÜ*¨4¯;©;°t¸A±wÈT¨;Ó+RÓS�÷T÷	Tô �h¤
Ô+ØˆOØ÷	Tð Tú÷	Tð 	Tús$   ÂDÂ2 C5ÃDÃ5C>	Ã:DÄD
c                óè  — g }g }|j                   D ]¹  }t        |¬«      }| j                  j                  «       5 }| j	                  ||gt
        g|«      \  }	}
ddd«       j                  «       rŒ`t        	«      }t        |t        «      sŒ|t        
«      }t        |t        «      sŒ˜|j                  |«       |j                  |«       Œ» |r|syt        |«      t        |«      fS # 1 sw Y   Œ‘xY w)a  Type-check application of a generic callable to an overload.

        We check call on each individual overload item, and then combine results into a new
        overload. This function should be only used if callee_type takes and returns a Callable.
        ©r°  N)rû   rr   r  rO  Ú
check_callr9   Úhas_new_errorsrÍ   rø   r­   rù  r¶   )r!  r´  Ú
overloadedrJ  r-  Úinferred_argsrÂ  r  ÚerrÚitem_resultÚinferred_argÚp_item_resultÚp_inferred_args                rî   Úhandle_decorator_overload_callz0ExpressionChecker.handle_decorator_overload_call   sî   € ð ˆØˆØ×$Ñ$ò 	)ˆDÜ˜tÔ$ˆCØ—‘×'Ñ'Ó)ð `¨SØ,0¯O©O¸KÈ#ÈÔQXÐPYÐ[^Ó,_Ñ)�˜\÷`à×!Ñ!Ô#àÜ+¨KÓ8ˆMÜ˜m¬\Ô:ØÜ,¨\Ó:ˆNÜ˜n¬lÔ;ØØ× Ñ  Ô0Ø�M‰M˜-Õ(ð	)ñ ™]àÜ˜&Ó!¤:¨mÓ#<Ð<Ð<÷!`ð `ús   ºC(Ã(C1	c           
     ó˜  — |€|�|€J ‚| j                  ||«      }t        |«      }|r6| j                  |||j                  |j                  ||j
                  |«      }n%|�#t        |t        «      r| j                  |||«      S | j                  ||j                  |j                  ||j
                  |j                  ||¬«      \  }}t        |«      }t        |j                  t        «      r^t        |t        «      rN|j                  �|j                  |j                  _        |j                  �|j                  |j                  _        |S )a?  Type check call expression.

        The callee_type should be used as the type of callee expression. In particular,
        in case of a union type this can be a particular item of the union, so that we can
        apply plugin hooks to each item.

        The 'member', 'callable_name' and 'object_type' are only used to call plugin hooks.
        If 'callable_name' is None but 'member' is not None (member call), try constructing
        'callable_name' using 'object_type' (the base type on which the method is called),
        for example 'typing.Mapping.get'.
        )Úcallable_noder6   rR  )r£  rÍ   r”  r�  r�  r�  rø   rÈ   Úcheck_union_call_exprr™  r�  rg   r­   Ú
type_guardÚtype_is)r!  r´  r,  r6   rR  rµ  r?  Úproper_callees           rî   r§  z2ExpressionChecker.check_call_expr_with_callee_type¾  s0  € ð& Ð  VÐ%7ØÐ*Ð*Ð*Ø ×0Ñ0°¸fÓEˆMÜ% kÓ2ˆÙà×4Ñ4Ø˜{¨A¯F©F°A·K±KÀÀAÇKÁKÐQ\ó‰Kð Ð¤J¨{¼IÔ$FØ×-Ñ-¨a°¸fÓEÐEØ $§¡ØØ�F‰FØ�K‰KØØ�K‰KØŸ(™(Ø'Ø#ð !0ó 	!
Ñˆ�+ô (¨Ó4ˆÜ�a—h‘h¤Ô(¬Z¸Ä|Ô-Tà×'Ñ'Ð3Ø&3×&>Ñ&>�—‘Ô#Ø×$Ñ$Ð0Ø#0×#8Ñ#8�—‘Ô Øˆrí   c                óÈ  — g }t        |j                  «       «      D ]®  }| j                  j                  «       5  t	        |||ddd|| j
                  | j                  «       |¬«
      }ddd«       | j                  |j                  d¬«      }|€Œt| j                  ||«      }|r|nd}	|j                  | j                  ||||	«      «       Œ° t        |«      S # 1 sw Y   ŒrxY w)zFType check calling a member expression where the base type is a union.F)rT  Úis_superÚis_operatorÚoriginal_typer  Úin_literal_contextÚ	self_typeNT)Úskip_non_overlapping)rÌ   r  r  rO  r   r  rZ  r)  r�  r£  rù  r§  r¤   )
r!  r,  rR  rµ  Úresr°  rÂ  r.  r6   Úitem_object_types
             rî   r¥  z'ExpressionChecker.check_union_call_exprð  sï   € àˆÜ(¨×)CÑ)CÓ)EÓFò 	ˆCà—‘×'Ñ'Ó)ñ Ü,ØØØØ#Ø"Ø %Ø"-ØŸ™Ø'+×'>Ñ'>Ó'@Ø!ô�÷ð ×3Ñ3°A·H±H¸dÐY]Ð3Ó^ˆHØÐØØ ×0Ñ0°°fÓ=ˆMÙ&3™s¸ÐØ�J‰JØ×5Ñ5°hÀÀ=ÐRbÓcõð)	ô. % SÓ)Ð)÷+ð ús   ¹.CÃC!	c
                ó´  — t        |«      }t        |t        «      rO|j                  r+| j	                  ||«      }
|
�| j                  ||
|«      }|�|S | j                  ||||||||«      S t        |t        «      r| j                  |||||||«      S t        |t        «      s| j                  j                  «       s| j                  ||||«      S t        |t        «      r| j                  |||||«      S t        |t        «      r˜t!        d||ddd|	xs || j                  | j#                  «       ¬«	      }|j$                  j&                  dz   }| j)                  |||||||«      }| j+                  ||||||||«      }|r| j                  j-                  ||«       |S t        |t.        «      r | j+                  |j0                  |||||«      S t        |t2        «      r2| j5                  |j6                  |«      }| j+                  ||||||«      S t        |t8        «      r#| j+                  t;        |«      ||||||||¬«	      S t        |t<        «      r$| j+                  |j>                  ||||||||	¬«	      S t        |t@        «      rtA        «       }|jB                  |_!        ||fS | jD                  jG                  ||«      t        tH        jJ                  «      fS )a¸  Type check a call.

        Also infer type arguments if the callee is a generic function.

        Return (result type, inferred callee type).

        Arguments:
            callee: type of the called value
            args: actual argument expressions
            arg_kinds: contains nodes.ARG_* constant for each argument in args
                 describing whether the argument is positional, *arg, etc.
            context: current expression context, used for inference.
            arg_names: names of arguments (optional)
            callable_node: associate the inferred callable type to this node,
                if specified
            callable_name: Fully-qualified name of the function/method to call,
                or None if unavailable (examples: 'builtins.open', 'typing.Mapping.get')
            object_type: If callable_name refers to a method, the type of the object
                on which the method is being called
        rÑ  FT©rT  rª  r«  r¬  r  r­  z	.__call__)r¬  )&rÍ   rø   r­   r-  r–  r¢  r?  r¶   Úcheck_overload_callr¬   r  r8  Úcheck_any_type_callrÈ   Úcheck_union_callr²   r   rZ  r7  r>  r”  r™  Ú
store_typerÅ   Úupper_boundrÁ   Úanalyze_type_type_calleerÂ  r¼   r¨   r³   r…  rÇ   r«  r  Únot_callablerÀ   r;  )r!  r�  r�  r�  r^  r�  r¤  r6   rR  r¬  r›  Úoverloaded_resultÚcall_functionr-  rÂ  r]  s                   rî   r™  zExpressionChecker.check_call  s  € ô@ ! Ó(ˆä�fœlÔ+Ø×ÒØ!×DÑDÀVÈTÓR�
ØÐ)ð )-×(KÑ(KØ 
¨Gó)Ð%ð )Ð4Ø0Ð0à×+Ñ+ØØØØØØØØó	ð 	ô ˜¤
Ô+Ø×+Ñ+Ø˜˜i¨°MÀ;ÐPWóð ô ˜¤Ô(°·±×0LÑ0LÔ0NØ×+Ñ+¨D°)¸VÀWÓMÐMÜ˜¤	Ô*Ø×(Ñ(¨°°yÀ)ÈWÓUÐUÜ˜¤Ô)Ü1ØØØØØØ Ø+Ò5¨vØ—H‘HØ#'×#:Ñ#:Ó#<ô
ˆMð #ŸK™K×0Ñ0°;Ñ>ˆMà ×6Ñ6Ø˜}¨d°I¸wÈ	ÐSYóˆMð —_‘_ØØØØØØØØó	ˆFñ ð —‘×#Ñ# M°6Ô:ØˆMÜ˜¤Ô,Ø—?‘?Ø×"Ñ" D¨)°W¸iÈóð ô ˜¤Ô)Ø×0Ñ0°·±¸gÓFˆDØ—?‘? 4¨¨y¸'À9ÈmÓ\Ð\Ü˜¤	Ô*Ø—?‘?Ü˜vÓ&ØØØØØØØØ$ð #ó 
ð 
ô ˜¤Ô,Ø—?‘?Ø—‘ØØØØØØØØ+ð #ó 
ð 
ô ˜¤Ô0Ü!Ó#ˆCØ"×,Ñ,ˆCŒMØ˜3�;Ðà—8‘8×(Ñ(¨°Ó9¼7Ä9×CWÑCWÓ;XÐXÐXrí   c	                ó”  ‡ ‡— |j                  «       j                  «       }|€|j                  r|j                  }|j                  «       r8|j	                  d¬«      }	t        |	t        «      r|	j                  j                  }t        |t        «      r |j                  t        v r|j                  |fS |j                  «       rx|j                  «       j                  r^|j                  sR‰ j                  j!                  t"        j$                  j'                  |j                  «       j                  «      |«       nÏ|j                  «       r¿|j                  «       j(                  r¥|j                  s™|j                  «       j*                  s|j                  «       }
i }|
j,                  D ])  \  }}|t.        k(  r‰ j1                  |
|«      ||<   Œ%d||<   Œ+ ‰ j2                  j5                  |j                  «       j                  ||«       |j7                  «       }|rÎt        |j8                  t:        «      r´d}t=        ‰|«      D ]£  \  }}|t>        k7  rŒtA        ‰ jC                  |«      «      }t        |tD        «      rtG        d„ |jH                  D «       «      sŒW|rI‰ j2                  j!                  d|tJ        jL                  ¬«       tO        tP        jR                  «      |fc S d}Œ¥ tA        |j                  «      }t        |tT        «      r>|jV                  r2tY        |j                  «      }t[        |«       |j]                  |¬«      }|j_                  «       rta        |«      }‰ jc                  ||«      }te        |||jf                  |jh                  ˆˆ fd	„«      }|jj                  d
k(  �rUtm        ‰«      dk(  �rF‰ j2                  jo                  «       5  tA        ‰ jC                  ‰d   «      «      }ddd«       t        tD        «      röt        |j                  tp        «      sJ ‚t        |j                  tD        «      rdtO        tP        jr                  «      }|j                  j]                  ‰ j                  ju                  d|g«      ¬«      }|j]                  |g¬«      }n\t        |j                  t        «      rBtw        |j                  ‰ j                  jy                  d«      «      }|j]                  |g¬«      }|j_                  «       r\tG        d„ |jV                  D «       «      }‰ j{                  |‰|||||«      }|r'te        |||jf                  |jh                  ˆˆ fd„«      }|j}                  «       }|�Ù|t>        t~        gk(  rÊtm        |«      dk(  r¼‰ jC                  ‰d   «      }‰ jC                  ‰d   «      }t        |t€        «      r„t        |t€        «      rt|j‚                  t„        j†                  k(  rW|j‚                  t„        jˆ                  k(  r:|jŠ                  |jŠ                  cxk(  r|jŠ                  k(  rn n|j                  |fS ‰ j�                  |‰||«      }‰ j2                  j�                  «        xrf tm        ‰«      dk\  xrV t‘        d„ |jf                  D «       «      xr8 t‘        d„ |D «       «      xr$ tm        |«      tm        |jf                  «      dz
  k(  }|r—‰ j2                  jo                  d¬«      5 }‰ j“                  ||||||||«      }ddd«       s‰ j•                  |||‰|«      rnr‰ j2                  j—                  j™                  «       «       ‰ j›                  ||‰||||¬«       n0‰ j“                  ||||||||«       ‰ j›                  ||‰||||¬«       |j                  «       rPtm        |«      dk(  rBt�        |j	                  «       d«      r(|j]                  tŸ        j                   |d   «      ¬«      }|r‰ j                  j£                  ||«       |re|€‰ j¤                  j§                  |«      s|�F‰ j¤                  j©                  |«      r+‰ j«                  |||||‰|||«	      } |j]                  | ¬«      }|j                  |fS # 1 sw Y   �ŒºxY w# 1 sw Y   �Œ”xY w)zxType check a call that targets a callable value.

        See the docstring of check_call for more information.
        NTrÈ  Fc              3  ó<   K  — | ]  }t        |t        «      –— Œ y ­wrñ   ©rø   rÉ   r  s     rî   rö   z8ExpressionChecker.check_callable_call.<locals>.<genexpr>Ô  s   è ø€ ò >Ø23”J˜q¤*×-ñ>ùr  z<Passing multiple variadic unpacks in a call is not supportedrî  ©r?  c                ó,   •— ‰j                  ‰|    «      S rñ   r€  r�  s    €€rî   rƒ  z7ExpressionChecker.check_callable_call.<locals>.<lambda>ó  s   ø€ �d—k‘k $ q¡'Ó*€ rí   Útupler  r   úbuiltins.tuple©r…  )r³  c              3  óH   K  — | ]  }t        |t        t        f«      –— Œ y ­wrñ   )rø   r¹   rÄ   ©rô   Úvs     rî   rö   z8ExpressionChecker.check_callable_call.<locals>.<genexpr>  s"   è ø€ ò ØEF”
˜1œ}Ô.>Ð?×@ñùs   ‚ "c                ó,   •— ‰j                  ‰|    «      S rñ   r€  r�  s    €€rî   rƒ  z7ExpressionChecker.check_callable_call.<locals>.<lambda>  s   ø€ ˜dŸk™k¨$¨q©'Ó2€ rí   r  c              3  ó.   K  — | ]  }|t         k(  –— Œ y ­wrñ   ©r9   ©rô   Úks     rî   rö   z8ExpressionChecker.check_callable_call.<locals>.<genexpr>5  s   è ø€ Ò; Q�Aœ•LÑ;ùó   ‚c              3  ó.   K  — | ]  }|t         k(  –— Œ y ­wrñ   rÊ  rË  s     rî   rö   z8ExpressionChecker.check_callable_call.<locals>.<genexpr>6  s   è ø€ Ò4 Q�Aœ•LÑ4ùrÍ  ©Úsave_filtered_errors©rR  r,  )VÚwith_unpacked_kwargsÚwith_normalized_var_argsr:  rÀ  rÁ  rø   r²   r7  r>  rg   r‡   r?  rÖ  r×  Úfrom_type_typer  rÙ  r   ÚCANNOT_INSTANTIATE_PROTOCOLrŒ  Úis_abstractÚfallback_to_anyÚabstract_attributesr<   Úcan_return_noner  Ú!cannot_instantiate_abstract_classÚvar_argr°  rÉ   rä  r:   rÍ   rs  r¼   r¤  rû   rò  ÚCALL_ARGr¬   rÀ   r;  r­   r-  r(   r    rc  Ú
is_genericr)   Ú+infer_function_type_arguments_using_contextr   r�  r�  Úspecial_sigr‘  rO  r»   r3  r\  r1   r!  r-   Ú
param_specr;   r¹   Úflavorr¸   ÚARGSÚKWARGSÚidÚinfer_arg_types_in_contextÚprefer_simple_messagesrú   Úcheck_argument_countÚ_detect_missing_positional_argÚ
add_errorsÚfiltered_errorsÚcheck_argument_typesrÒ   rÁ   Úmake_normalizedr·  r  rq  rr  r}  )!r!  r�  r�  r�  r^  r�  r¤  r6   rR  rÌ  r7  rØ  Ú	attr_nameÚabstract_statusrÛ  Úseen_unpackr  Úarg_kindrj  r?  Úfresh_ret_typer±  Úany_typeÚnew_arg_typeÚneed_refreshrà  Úarg1Úarg2r³  Úmight_have_shifted_argsÚwÚokÚnew_ret_types!   ` `                              rî   r?  z%ExpressionChecker.check_callable_call’  sñ  ù€ ð  ×,Ñ,Ó.×GÑGÓIˆØÐ  V§[¢[Ø"ŸK™KˆMØ×ÑÔØ"×4Ñ4ÀDÐ4ÓIˆMÜ˜-¬Ô2Ø -× 2Ñ 2× ;Ñ ;�Ü�m¤WÔ-°-×2HÑ2HÌJÑ2Và—?‘? FÐ*Ð*ð ×ÑÔ Ø×"Ñ"Ó$×0Ò0à×)Ò)à�H‰H�M‰MÜ ×<Ñ<×CÑCÀF×DVÑDVÓDX×D]ÑD]Ó^Øõð
 ×ÑÔ Ø×"Ñ"Ó$×0Ò0à×)Ò)Ø×&Ñ&Ó(×8Ò8à×%Ñ%Ó'ˆDð 46ÐØ.2×.FÑ.Fò ;Ñ*�	˜?Ø"Ô&9Ò9Ø59×5IÑ5IÈ$ÐPYÓ5ZÐ'¨	Ò2à5:Ð'¨	Ò2ð	;ð
 �H‰H×6Ñ6Ø×"Ñ"Ó$×)Ñ)Ð+>Àôð —.‘.Ó"ˆÙ”z '§+¡+¬zÔ:ð  ˆKÜ!$ T¨9Ó!5ò '‘��XØœxÒ'ØÜ*¨4¯;©;°sÓ+;Ó<�Ü! (¬IÔ6¼#ñ >Ø7?·~±~ô>õ ;ñ #ØŸ™Ÿ™ØZØ#Ü!&§¡ð &ô ô
  '¤y×';Ñ';Ó<¸fÐDÒDØ"&‘Kð'ô( # 6§?¡?Ó3ˆÜ�h¤Ô-°(×2DÒ2DÜ<¸V¿_¹_ÓMˆNÜ  Ô0Ø×)Ñ)°>Ð)ÓBˆFà×ÑÔÜ/°Ó7ˆFØ×EÑEÀfÈgÓVˆFä1ØØØ×ÑØ×ÑÜ*ó
Ðð ×Ñ Ó(¬S°«Y¸!«^Ø—‘×'Ñ'Ó)ñ AÜ*¨4¯;©;°t¸A±wÓ+?Ó@�÷Aô ˜(¤IÔ.Ü! &§/¡/´:Ô>Ð>Ð>Ü˜fŸo™o¬yÔ9ä&¤y×'=Ñ'=Ó>�HØ#)§?¡?×#@Ñ#@Ø!%§¡×!<Ñ!<Ð=MÐPXÈzÓ!Zð $Aó $�Lð $×1Ñ1¸\¸NÐ1ÓK‘FÜ §¡´Ô:Ü#<ØŸ™¨¯©×)AÑ)AÐBRÓ)Só$�Lð $×1Ñ1¸\¸NÐ1ÓK�Fà×ÑÔÜñ ØJP×JZÑJZôó ˆLð ×7Ñ7Ø˜˜i¨Ð4DÀlÐT[óˆFñ ô $:ØØØ×$Ñ$Ø×$Ñ$Ü2ó$Ð ð ×&Ñ&Ó(ˆ
àÐ"Øœh¬	Ð2Ò2ÜÐ$Ó%¨Ò*à—;‘;˜t A™wÓ'ˆDØ—;‘;˜t A™wÓ'ˆDä˜4¤Ô/Ü˜t¤]Ô3Ø—K‘K¤?×#7Ñ#7Ò7Ø—K‘K¤?×#9Ñ#9Ò9Ø—G‘G˜tŸw™wÔ7¨*¯-©-Õ7à—‘¨Ð.Ð.à×3Ñ3°F¸DÀ)ÐM]Ó^ˆ	ð —‘×/Ñ/Ó1Ð1ò <Ü�D“	˜Q‘ò<äÑ;¨&×*:Ñ*:Ô;Ó;ò<ô Ñ4¨)Ô4Ó4ò<ô �I“¤# f×&6Ñ&6Ó"7¸!Ñ";Ñ;ð 	 ñ #Ø—‘×'Ñ'¸TÐ'ÓBð 
ÀaØ×.Ñ.ØØØØØ$ØØØ!ó	�÷
ñ ˜$×=Ñ=Ø˜	 9¨d°Gôð à—‘×#Ñ# A×$5Ñ$5Ó$7Ô8Ø×)Ñ)ØØØØØ$ØØ +ð *õ ð ×%Ñ%ØØØØØ ØØØô	ð ×%Ñ%ØØØØØ ØØ'ð &ô ð ×ÑÔ Ü�Y“ 1Ò$Ü! &×":Ñ":Ó"<¸oÔNà×)Ñ)´8×3KÑ3KÈIÐVWÉLÓ3YÐ)ÓZˆFáà�H‰H×Ñ ¨vÔ6áØÐ  T§[¡[×%BÑ%BÀ=Ô%QØÐ'¨D¯K©K×,GÑ,GÈÔ,Và×5Ñ5ØØØØØ ØØØØó
ˆLð ×)Ñ)°<Ð)Ó@ˆFØ�‰ Ð&Ð&÷]Añ Aú÷H
ñ 
ús   Ïb0Üb=â0b:â=cc                óÒ  — t         j                  sy|j                  D ]Ç  }|j                  j	                  |«      }|€Œ!|j
                  }t        |t        «      r|j                  }t        |t        «      r|j                  }t        |t        «      sŒv|j                  €Œƒt        |j                  t        «      sJ ‚t        t        «       |j                  j                   «      c S  y)z�Is the given attribute a method with a None-compatible return type?

        Overloads are only checked if there is an implementation.
        F)rˆ   Ústrict_optionalÚmrore  rË  r+  rø   rc   ÚimplrM   ÚfuncrT   r7  r­   rŒ   rµ   r?  )r!  r7  rí  rw  Úsymnoder+  s         rî   rÙ  z!ExpressionChecker.can_return_none‡  s·   € ô
 ×$Ò$ð Ø—H‘Hò 	FˆDØ—j‘j—n‘n YÓ/ˆGØˆØØ—<‘<ˆDÜ˜$Ô 1Ô2Ø—y‘y�Ü˜$¤	Ô*Ø—y‘y�Ü˜$¤Õ(Ø—9‘9Ñ(Ü% d§i¡i´Ô>Ð>Ð>Ü%¤h£j°$·)±)×2DÑ2DÓEÒEð	Fð rí   c           
     óÚ  — t        |t        «      rt        t        j                  |¬«      S t        |t        «      rgt        |j                  «      }t        |t        «      r|j                  d¬«      }t        ||«      }t        |t        «      r|j                  g ¬«      }|S t        |t        «      rKt        |j                  «       D �cg c]  }| j                  t        |«      |«      ‘Œ c}|j                  «      S t        |t        «      r7| j                  t        |j                   «      |«      }| j#                  ||«      S t        |t$        «      r=t'        |«      j                  j(                  dk7  r| j                  t'        |«      |«      S t        |t*        «      r| j-                  |«      S | j.                  j1                  ||«       t        t        j2                  «      S c c}w )zzAnalyze the callee X in X(...) where X is Type[item].

        Return a Y that we can pass to check_call(Y, ...).
        ©Ú
source_anyT)rÔ  )r-  rÃ  )rø   r¬   rÀ   Úfrom_another_anyr²   r©   r7  r­   rc  r'   rÈ   r  r¹  rÍ   r@  rÅ   r¸  Ú!replace_type_type_callee_ret_typer¼   r¨   r>  r¿   r)  r  Úunsupported_type_typer;  )r!  rÂ  r^  r°  ÚexpandedrÛ  r�  s          rî   r¹  z*ExpressionChecker.analyze_type_type_calleeŸ  s˜  € ô
 �dœGÔ$Üœ9×5Ñ5À$ÔGÐGÜ�dœHÔ%Ü" 4§9¡9Ó-ˆCÜ˜#œ|Ô,Ø×'Ñ'°tÐ'Ó<�Ü.¨s°DÓ9ˆHÜ˜(¤LÔ1ð $×1Ñ1¸BÐ1Ó?�ØˆOÜ�dœIÔ&Üð #×1Ñ1Ó3öàð ×1Ñ1´/À"Ó2EÀwÕOòð —	‘	óð ô �dœKÔ(ð
 ×2Ñ2´?À4×CSÑCSÓ3TÐV]Ó^ˆFØ×9Ñ9¸&À$ÓGÐGä�dœIÔ&¬>¸$Ó+?×+DÑ+D×+MÑ+MÐQaÒ+aØ×0Ñ0´ÀÓ1EÀwÓOÐOÜ�dœMÔ*Ø×7Ñ7¸Ó=Ð=à�‰×&Ñ& t¨WÔ5Ü”y×+Ñ+Ó,Ð,ùò)s   Ã
"G(c           	     ó¶  — t        |«      }t        |t        «      r|j                  |¬«      S t        |t        «      r3t	        |j
                  D �cg c]  }|j                  |¬«      ‘Œ c}«      S t        |t        «      rNt        |j                  «       D �cg c]  }| j                  ||«      ‘Œ c}|j                  |j                  ¬«      S |S c c}w c c}w )NrÀ  ©r@  rA  )rÍ   rø   r­   rc  r¶   rû   rÈ   r  r  r@  rA  )r!  r�  r?  ÚcrÂ  s        rî   r  z3ExpressionChecker.replace_type_type_callee_ret_typeÈ  sÀ   € Ü  Ó(ˆÜ�fœlÔ+Ø×'Ñ'°Ð'Ó:Ð:Ü�fœjÔ)ÜÈ6Ï<É<ÖXÀa˜qŸ™¸˜ÕAÒXÓYÐYÜ�fœiÔ(Üð !'× 5Ñ 5Ó 7öàð ×:Ñ:¸4ÀÕJòð —[‘[Ø—}‘}ôð ð ˆùò Yùòs   ÁCÂCc                ó¦   — g }|D ]I  }| j                  |«      }t        |«      r|j                  t        «       «       Œ9|j                  |«       ŒK |S )z»Infer argument expression types in an empty context.

        In short, we basically recurse on each argument without considering
        in what context the argument was called.
        )rs  Úhas_erased_componentrù  rµ   )r!  r�  r°  r  rj  s        rî   Ú infer_arg_types_in_empty_contextz2ExpressionChecker.infer_arg_types_in_empty_contextÙ  sO   € ð ˆàò 	%ˆCØ—{‘{ 3Ó'ˆHÜ# HÔ-Ø—
‘
œ8›:Õ&à—
‘
˜8Õ$ð	%ð ˆ
rí   c                óR   — t         j                  }t        |«      rdt         _        |S )ax  Adjust type inference of unions if type context has a recursive type.

        Return the old state. The caller must assign it to type_state.infer_unions
        afterwards.

        This is a hack to better support inference for recursive types.

        Note: This is performance-sensitive and must not be a context manager
        until mypyc supports them better.
        T)rØ   Úinfer_unionsrÐ   )r!  r  Úolds      rî   Ú$infer_more_unions_for_recursive_typez6ExpressionChecker.infer_more_unions_for_recursive_typeé  s$   € ô ×%Ñ%ˆÜ˜|Ô,Ø&*ŒJÔ#Øˆ
rí   c                ó�  — dgt        |«      z  }t        |«      D ]2  \  }}|D ](  }||   j                  «       rŒ|j                  |   ||<   Œ* Œ4 g }	t	        ||«      D ]e  \  }
}|�>| j                  |«      }|	j                  | j                  |
|«      «       |t        _	        ŒF|	j                  | j                  |
«      «       Œg |	S )a  Infer argument expression types using a callable type as context.

        For example, if callee argument 2 has type List[int], infer the
        argument expression with List[int] type context.

        Returns the inferred types of *actual arguments*.
        N)
r‘  rp  Úis_starr³  rä  r  rù  rs  rØ   r  )r!  r�  r�  r�  r±  Úarg_contextÚfiry  Úair°  r  rJ  r  s                rî   rå  z,ExpressionChecker.infer_arg_types_in_contextù  sÖ   € ð +/¨´#°d³)Ñ);ˆÜ$Ð%5Ó6ò 	7‰KˆB�Øò 7�Ø˜R‘=×(Ñ(Ô*ØØ"(×"2Ñ"2°2Ñ"6�˜B’ñ7ð	7ð ˆÜ˜D +Ó.ò 	-‰HˆC�Øˆð ×?Ñ?ÀÓD�Ø—
‘
˜4Ÿ;™; s¨CÓ0Ô1à*-”
Õ'à—
‘
˜4Ÿ;™; sÓ+Õ,ð	-ð ˆ
rí   c                óz  — | j                   d   }|s|S t        |t        «       «      }|j                  }t	        |«      r!t	        |«      rt        |«      }t        |«      }t        |«      }t        |t        «      s,t        |t        «      rBt        d„ |j                  D «       «      r&t        |«      st        |«      s|j                  «       S t        |j                   ||d¬«      }g }|D ];  }	t#        |	«      st%        |	«      r|j'                  d«       Œ+|j'                  |	«       Œ= | j)                  |||d¬«      S )a  Unify callable return type to type context to infer type vars.

        For example, if the return type is set[t] where 't' is a type variable
        of callable, and if the context is set[int], return callable modified
        by substituting 't' with 'int'.
        r1  c              3  óN   K  — | ]  }t        t        |«      t        «      –— Œ y ­wrñ   )rø   rÍ   rÅ   )rô   Úus     rî   rö   zPExpressionChecker.infer_function_type_arguments_using_context.<locals>.<genexpr>I  s   è ø€ ÒZÀA”Jœ¨qÓ1´;×?ÑZùs   ‚#%T©Úskip_unsatisfiedN)r  r"   r¯   r?  rÕ   r×   rÍ   rø   rÅ   rÈ   rú   rû   rÔ   r£   rc  r.   r-  Ú#has_ambiguous_uninhabited_componentr  rù  Úapply_generic_arguments)
r!  ÚcallableÚerror_contextrJ  Ú
erased_ctxr?  Ú
proper_retr�  Únew_argsr  s
             rî   rÞ  z=ExpressionChecker.infer_function_type_arguments_using_context  s-  € ð ×Ñ Ñ#ˆÙØˆOô ' s¬J«LÓ9ˆ
Ø×$Ñ$ˆÜ˜xÔ(Ô-@ÀÔ-Eô ' xÓ0ˆHÜ(¨Ó4ˆJô % XÓ.ˆ
ä�z¤;Ô/Ü˜*¤iÔ0ÜÑZÈ×IYÑIYÔZÔZô2 ' sÔ+Ô4HÈÔ4MØ×-Ñ-Ó/Ð/Ü#Ø×Ñ ¨*Àtô
ˆð ')ˆØò 	%ˆCÜ2°3Ô7Ô;OÐPSÔ;TØ—‘ Õ%à—‘ Õ$ð		%ð ×+Ñ+Ø�h Àð ,ó 
ð 	
rí   c                ó¶  ‡ ‡‡— ‰ j                   j                  «       �rá‰ j                  j                  «       5  ‰ j	                  ‰‰||«      }ddd«       ‰ j                  ‰‰|t        ‰«      «      }	g }
t        |«      D ]0  \  }}|	|   dkD  r|
j                  d«       Œ |
j                  |«       Œ2 t        ‰|
|||‰ j                  «       ‰ j                   j                  «       ¬«      \  }}d|	v r‰ j                  ‰‰||||||«      \  Š}‰j                  dk(  ržt        |«      dk(  r�t        |v st        |v r€t        |d   «      }t!        |t"        t$        f«      r‰ j'                  d«      |d<   nG|rt)        ‰ j'                  d«      |«      s*‰ j                   j+                  t,        j.                  |«       ‰ j                   j0                  j2                  �sTt5        ˆfd„|D «       «      �r?|r't7        ||‰j8                  ‰j:                  ˆˆ fd	„«      }t        ‰||||‰ j                  «       ‰ j                   j                  «       d
¬«      \  }}‰ j=                  ‰||«      }t?        j@                  ||«      }|�tC        d„ |D «       «      rtE        |«       |S t%        «       }d
|_#        |D ��cg c]A  }|�;tI        |tK        ‰jL                  «      |z   D �ci c]  }|jN                  |“Œ c}«      nd‘ŒC }}}n0tQ        tR        jT                  «      gt        ‰jL                  «      z  }‰ jW                  ‰||«      S # 1 sw Y   �Œ÷xY wc c}w c c}}w )z´Infer the type arguments for a generic callee type.

        Infer based on the types of arguments.

        Return a derived callable type that has the arguments applied.
        Nr  )r^  Ústrictr  Údictr   úbuiltins.strc              3  ó´   •K  — | ]O  }|d u xsE t        t        |«      t        «      xs* t        t	        |«      «      t        ‰j
                  «      z  –— ŒQ y ­wrñ   )rø   rÍ   rÇ   rd  r¢   r-  )rô   r  r´  s     €rî   rö   zBExpressionChecker.infer_function_type_arguments.<locals>.<genexpr>Á  s]   øè ø€ ò ?ð ð �T�	ò FÜœo¨aÓ0´/ÓBòFä”} QÓ'Ó(¬3¨{×/DÑ/DÓ+EÑEóFñ?ùs   ƒAAc                ó,   •— ‰j                  ‰|    «      S rñ   r€  ©r  r�  r!  s    €€rî   rƒ  zAExpressionChecker.infer_function_type_arguments.<locals>.<lambda>Ð  s   ø€  $§+¡+¨d°1©gÓ"6€ rí   T)r^  r$  Úallow_polymorphicc              3  ó\   K  — | ]$  }|d uxr t        t        |«      t        «       –— Œ& y ­wrñ   )rø   rÍ   rÇ   r  s     rî   rö   zBExpressionChecker.infer_function_type_arguments.<locals>.<genexpr>æ  s3   è ø€ ò /àð ˜T�MÒY¬*´_ÀQÓ5GÌÓ*YÐ&YÓYñ/ùs   ‚*,),r  r8  r  rO  rå  Úget_arg_infer_passesr‘  rp  rù  r-   Úargument_infer_contextÚ#infer_function_type_arguments_pass2rß  r8   r;   rÍ   rø   rµ   rÇ   rQ  rŒ   rÙ  r   Ú&KEYWORD_ARGUMENT_REQUIRES_STR_KEY_TYPEr  r  r¤  r   r�  r�  r  r   Ú
apply_polyrú   r    r«  r&   rð  r-  rä  r¬   rÀ   ÚunannotatedÚapply_inferred_arguments)r!  r´  r�  r�  r�  r±  rô  r^  r³  Úarg_pass_numsÚ
pass1_argsr‚  r  rœ  r$  Ú	first_argÚpoly_inferred_argsÚ	free_varsÚpoly_callee_typeÚappliedÚunknownr  rÇ  s   ```                    rî   r-   z/ExpressionChecker.infer_function_type_argumentst  sh  ú€ ð  �8‰8×'Ñ'Õ)ð
 —‘×'Ñ'Ó)ñ Ø ×;Ñ;Ø  yÐ2Bó�	÷ð
 !×5Ñ5Ø˜T 9Ð.>ÄÀDÃ	óˆMð -/ˆJÜ# IÓ.ò +‘��3Ø  Ñ# aÒ'Ø×%Ñ% dÕ+à×%Ñ% cÕ*ð	+ô  =ØØØØØ Ø×3Ñ3Ó5Ø—x‘x×3Ñ3Ó5ô ÑˆM˜1ð �MÑ!à-1×-UÑ-UØØØØØ$Ø!Ø Øó	.Ñ*�˜]ð ×'Ñ'¨6Ò1Ü˜Ó&¨!Ò+Ü )Ñ+¬y¸IÑ/Eô ,¨M¸!Ñ,<Ó=�	Ü˜i¬(´OÐ)DÔEØ'+§¡°~Ó'F�M !Ò$Ù"¬*°T·_±_À^Ó5TÐV_Ô*`Ø—H‘H—M‘MÔ"2×"YÑ"YÐ[bÔcà—8‘8×#Ñ#×6Ó6¼3ó ?ð 'ô	?õ <ñ  ô (>Ø!Ø!Ø#×-Ñ-Ø#×-Ñ-Ü6ó(Ð$ô 1NØØØØØ$Ø ×7Ñ7Ó9ØŸ8™8×7Ñ7Ó9Ø&*ô	1Ñ-Ð" Ið $(×#?Ñ#?ØÐ!3°Wó$Ð ô
 $×.Ñ.Ð/?ÀÓK�ØÐ&¬3ñ /à/ô/ô ,ô )¨Ô1Ø"�Nä)Ó+�Ø$(�Ô!ð 0÷	!ð ð ˜=ô $Ø´t¸K×<QÑ<QÓ7RÐU^Ñ7^Ö_°! §¡ g¡Ò_ôð "ñ	"ð	!�ò 	!ô %¤Y×%:Ñ%:Ó;Ð<¼sÀ;×CXÑCXÓ?YÑYˆMØ×,Ñ,¨[¸-ÈÓQÐQ÷iñ üòR  `ùó	!s#   ¹MÊ6'MËMË1MÍMÍMc	           	     ó  ‡ ‡— t        |«      }	t        t        |	«      «      D ],  \  }
}t        |t        t
        f«      st        |«      sŒ(d|	|
<   Œ. ‰ j                  ||	|«      }|j                  «       s|g fS |r't        |||j                  |j                  ˆˆ fd„«      }‰ j                  j                  «       5  ‰ j                  |‰||«      }ddd«       t        ||||‰ j!                  «       ¬«      \  }	}||	fS # 1 sw Y   Œ/xY w)a^  Perform second pass of generic function type argument inference.

        The second pass is needed for arguments with types such as Callable[[T], S],
        where both T and S are type variables, when the actual argument is a
        lambda with inferred types.  The idea is to infer the type variable T
        in the first pass (based on the types of other arguments).  This lets
        us infer the argument and return type of the lambda expression and
        thus also the type variable S in this second pass.

        Return (the callee with type vars applied, inferred actual arg types).
        Nc                ó,   •— ‰j                  ‰|    «      S rñ   r€  r)  s    €€rî   rƒ  zGExpressionChecker.infer_function_type_arguments_pass2.<locals>.<lambda>(	  r‚  rí   r1  )rð  rp  rÎ   rø   rµ   rÇ   r  r  rÝ  r   r�  r�  r  rO  rå  r-   r-  )r!  r´  r�  r�  r�  r±  Úold_inferred_argsrô  r^  rœ  r‚  r  r³  r$  s   ` `           rî   r.  z5ExpressionChecker.infer_function_type_arguments_pass2ÿ  s  ù€ ô2 Ð.Ó/ˆÜÔ 0°Ó ?Ó@ò 	(‰FˆAˆsÜ˜#¤¬/Ð:Ô;Ô?SÐTWÕ?XØ#'�˜aÒ ð	(ð ×2Ñ2°;ÀÈwÓWˆà×%Ñ%Ô'à �?Ð"áÜ5ØØØ×%Ñ%Ø×%Ñ%Ü.ó Ðð �X‰X×#Ñ#Ó%ñ 	Ø×7Ñ7Ø˜T 9Ð.>óˆI÷	ô
 9ØØØØØØ×/Ñ/Ó1ô
Ñˆ�qð ˜MÐ)Ð)÷	ð 	ús   Â;C>Ã>Dc                ó¸   — | j                   €Ct        | j                  j                  d«      | j                  j                  d«      «      | _         | j                   S )Nr  útyping.Iterable)r  r,   r  rQ  r%  s    rî   r-  z(ExpressionChecker.argument_infer_context<	  sN   € Ø×(Ñ(Ð0Ü,@Ø—‘×#Ñ#Ð$4Ó5°t·x±x×7JÑ7JÐK\Ó7]ó-ˆDÔ)ð ×,Ñ,Ð,rí   c                ó
  — dg|z  }t        |j                  «      D ]ä  \  }}d}	t        |j                  |   «      }
t        |
t        «      r‰|
j                  «       ry||   D ]q  }t        ||   «      }t        |t        «      rt        d||d¬«      }|�t        |«      }t        |t        «      sŒN|j                  rŒ[t        ||   t        «      rŒod}	 n |	rŒ¼|j                  t        «       «      sŒÖ||   D ]  }d||<   Œ	 Œæ |S )a  Return pass numbers for args for two-pass argument type inference.

        For each actual, the pass number is either 1 (first pass) or 2 (second
        pass).

        Two-pass argument type inference primarily lets us infer types of
        lambdas more effectively.
        r  FrÑ  T)r«  r  )rp  r³  rÍ   rø   r­   rà  r²   rŠ   r-  rX   rs  ÚArgInferSecondPassQuery)r!  r�  r�  r³  r±  Únum_actualsr°  r‚  r  Úskip_param_specÚp_formalr²  Úp_actualÚcall_methods                 rî   r,  z&ExpressionChecker.get_arg_infer_passesC	  s  € ð  ˆc�KÑˆÜ × 0Ñ 0Ó1ò 	‰FˆAˆsØ#ˆOÜ& v×'7Ñ'7¸Ñ':Ó;ˆHÜ˜(¤LÔ1°h×6IÑ6IÔ6KØ)¨!Ñ,ò �AÜ.¨y¸©|Ó<�Hô " (¬HÔ5Ü&1°*¸hÈÐ^bÔ&c˜Ø&Ð2Ü'6°{Ó'C˜Hä" 8¬\Õ:Ø (× 2Ó 2Ü *¨4°©7´JÕ ?à*.˜Ùð)ò* # s§z¡zÔ2IÓ2KÕ'LØ)¨!Ñ,ò �AØ�C˜’Fñð5	ð8 ˆ
rí   c                ó  — t        ||j                  «      D ]V  \  }}|rt        |«      sŒ| j                  j	                  |||«       t        t        j                  «      gt        |«      z  }ŒX | j                  |||«      S )zŽApply inferred values of type arguments to a generic function.

        Inferred_args contains the values of function type arguments.
        )
rä  r-  r  r  Úcould_not_infer_type_argumentsr¬   rÀ   r;  r‘  r  )r!  r´  rœ  r^  Úinferred_typeÚtvs         rî   r2  z*ExpressionChecker.apply_inferred_argumentsr	  s|   € ô "% ]°K×4IÑ4IÓ!Jò 	UÑˆM˜2Ù Ô$8¸Õ$Gà—‘×7Ñ7¸ÀRÈÔQÜ!(¬×)=Ñ)=Ó!>Ð ?Ä#ÀmÓBTÑ T‘ð		Uð ×+Ñ+¨K¸ÈÓPÐPrí   c                óÆ  — t        d„ |j                  D «       «      syt        d„ |D «       «      syt        |«      t        |j                  «      dz
  k7  ryd}d}t        t        |j                  «      «      D ]R  }|t        |«      k\  r|} n@t        ||   |j                  |   | j                  j                  ¬«      r|dz  }ŒM|€|}ŒR y |�|t        |«      k7  ry|t        |j                  «      dz
  k(  ry|j                  |   }	t        |«      }
|	�|
€yd|	› d	|
› �}|t        |«      k  r||   n|}| j                  j                  ||t        j                  ¬
«       y)aÉ  Try to identify a single missing positional argument using type alignment.

        If the caller and callee are just positional arguments and exactly one arg is missing,
        we scan left to right to find which argument skipped. If only the last argument is missing,
        we return False since it's already handled in a desired manner. If there is an error,
        report it and return True, or return False to fall back to normal checking.
        c              3  ó.   K  — | ]  }|t         k(  –— Œ y ­wrñ   rÊ  rË  s     rî   rö   zCExpressionChecker._detect_missing_positional_arg.<locals>.<genexpr>•	  s   è ø€ Ò: A�1œ•<Ñ:ùrÍ  Fc              3  ó.   K  — | ]  }|t         k(  –— Œ y ­wrñ   rÊ  rË  s     rî   rö   zCExpressionChecker._detect_missing_positional_arg.<locals>.<genexpr>—	  s   è ø€ Ò3 A�1œ•<Ñ3ùrÍ  r  Nr   ©r  zMissing positional argument "z" in call to rî  T)rú   r�  r‘  rœ  r³  rŒ   r  r  r�  r6   r  rÙ  rò  rÜ  )r!  r�  r³  r�  r�  r^  Úskip_idxr²  r‚  Ú
param_nameÚcallee_namer  rJ  s                rî   rè  z0ExpressionChecker._detect_missing_positional_arg†	  sb  € ô Ñ:¨×)9Ñ)9Ô:Ô:ØÜÑ3¨Ô3Ô3ØÜˆy‹>œS ×!1Ñ!1Ó2°QÑ6Ò6Øà#ˆØˆÜ”s˜6×+Ñ+Ó,Ó-ò 		ˆAØ”C˜	“NÒ"Ø�ÙÜ˜) A™,¨×(8Ñ(8¸Ñ(;ÀTÇXÁX×EUÑEUÕVØ�Q‘‘ØÐ!Ø‘áð		ð Ð˜q¤C¨	£NÒ2Øà”s˜6×+Ñ+Ó,¨qÑ0Ò0Øà×%Ñ% hÑ/ˆ
Ü# FÓ+ˆØÐ Ð!4Øà-¨j¨\¸À{ÀmÐTˆØ (¬3¨t«9Ò 4ˆd�8Šn¸'ˆØ�‰�‰�c˜3¤U§^¡^ˆÔ4Ørí   c	                ó¦  ‡— |€"t        t        t        j                  «      «      }i }	|D ]!  }
|
D ]  }|	j	                  |d«      dz   |	|<   Œ Œ# | j                  |‰|||	|«      \  }}t        |j                  «      D �]Q  \  }}||   }|j                  «       r€|s~|s||j                  «       r9| j                  j                  |||«       |rJ|rHd|v rD| j                  |||«       n0|j                  |   xs d}| j                  j                  |||«       d}Œœ|j                  «       sht!        |‰|«      r[| j"                  j%                  «       s t'        t)        ‰|d      «      t*        «      sŒó| j                  j-                  |||«       d}�Œ|j/                  «       rJ|rH||d      t0        j2                  t0        j4                  fvr | j                  j7                  ||«       d}�Œn|j9                  «       €�Œ€|s0|j:                  dk7  r!| j                  j                  |||«       d}�Œ²t=        |«      dkD  s�ŒÂt?        ˆfd„|D «       «      }||d      t0        j@                  k(  r#|dkD  r| j                  jC                  d|«       d}||d      t0        j4                  k(  s�Œ-|dkD  s�Œ4| j                  jC                  d	|«       d}�ŒT |S )
aO  Check that there is a value for all required arguments to a function.

        Also check that there are no duplicate values for arguments. Report found errors
        using 'messages' if it's not None. If 'messages' is given, 'context' must also be given.

        Return False if there were any errors. Otherwise return True
        r   r  rˆ  ú?FÚpartialc              3  óV   •K  — | ]   }t        t        ‰|   «      t        «      –— Œ" y ­wrñ   )rø   rÍ   r¹   )rô   rÌ  Úactual_typess     €rî   rö   z9ExpressionChecker.check_argument_count.<locals>.<genexpr>ý	  s)   øè ø€ ò ,àô #¤?°<À±?Ó#CÄ]×Sñ,ùs   ƒ&)z)ParamSpec.args should only be passed oncez+ParamSpec.kwargs should only be passed once)"rr   r¬   rÀ   r3  rË  Ú check_for_extra_actual_argumentsrp  r�  Úis_requiredÚis_positionalr  Útoo_few_argumentsÚmissing_classvar_callable_noter�  Úmissing_named_argumentr  Úis_duplicate_mappingr  r8  rø   rÍ   r¼   Úduplicate_argument_valueÚis_namedr   r8   r;   Útoo_many_positional_argumentsrà  rß  r‘  Úsumr:   rÙ  )r!  r�  rV  Úactual_kindsÚactual_namesr±  r^  rR  r6   Úall_actualsry  r  rù  Úis_unexpected_arg_errorr‚  ÚkindÚmapped_argsÚargnameÚparamspec_entriess     `                rî   rç  z&ExpressionChecker.check_argument_count¹	  s¬  ø€ ð$ ˆ?äœw¤y×'=Ñ'=Ó>Ó?ˆGð
 ')ˆØ'ò 	;ˆGØò ;�Ø!,§¡°°AÓ!6¸Ñ!:�˜A’ñ;ð	;ð '+×&KÑ&KØ�L ,°¸kÈ7ó'
Ñ#ˆÐ#ô
 ! ×!1Ñ!1Ó2ó *	#‰GˆAˆtØ*¨1Ñ-ˆKØ×ÑÔ!©+Ñ>Uà×%Ñ%Ô'Ø—H‘H×.Ñ.¨v°wÀÔMÙ"¡}¸ÀÑ9MØ×;Ñ;¸KÈÐX_Õ`à$×.Ñ.¨qÑ1Ò8°S�GØ—H‘H×3Ñ3°F¸GÀWÔMØ‘Ø—\‘\”^Ô(<Ø˜\¨<ô)ð —8‘8×/Ñ/Ô1´ZÜ# L°¸Q±Ñ$@ÓAÄ9õ6ð —H‘H×5Ñ5°f¸aÀÔIØ’Bà—‘”ÙØ  ¨Q¡Ñ0¼¿¹Ì%Ï/É/Ð8ZÑZð —‘×6Ñ6°v¸wÔGØ’Ø×"Ñ"Ó$Ò0Ù" v×'9Ñ'9¸YÒ'FØ—H‘H×.Ñ.¨v°wÀÔMØ’BÜ˜Ó%¨Ô)Ü(+ó ,à!,ô,ó )Ð%ð $ K°¡NÑ3´u·~±~ÒEÐJ[Ð^_ÒJ_ØŸ™Ÿ™Ð&QÐSZÔ[Ø"˜Ø# K°¡NÑ3´u·±ÔFÐK\Ð_`ÔK`ØŸ™Ÿ™Ð&SÐU\Ô]Ø"šðU*	#ðV ˆ	rí   c                óh  — d}d}t        |«      D �]œ  \  }	}
|	|vrž|
t        j                  k7  st        ||	   «      r}|
t        j                  k7  rjd}|
t        j
                  k7  r| j                  j                  ||«       Œq|sJ d«       ‚||	   }|€J ‚||	   }| j                  j                  ||||«       d}Œ©|
t        j                  k(  rt        j                  |j                  vs|
t        j                  k(  sŒìt        ||	   «      }t        |t        t        f«      s�Œ|j                  |	d«      t        |j                   «      k  s�Œ<|
t        j                  k7  st        |t        «      s| j                  j                  ||«       n| j                  j#                  |||«       d}d}�ŒŸ ||fS )z·Check for extra actual arguments.

        Return tuple (was everything ok,
                      was there an extra keyword argument error [used to avoid duplicate errors]).
        FTz/Internal error: named kinds without names givenr   )rp  r   r:   Úis_non_empty_tupler;   r8   r  Útoo_many_argumentsÚunexpected_keyword_argumentr�  rÍ   rø   r¼   r¿   rË  r‘  rû   Ú"too_many_arguments_from_typed_dict)r!  r�  rV  rb  rc  rd  r^  re  rù  r‚  rf  Úact_nameÚact_typeÚactual_types                 rî   rW  z2ExpressionChecker.check_for_extra_actual_arguments	
  s�  € ð #(ÐØˆä  Ó.ó %	#‰GˆAˆtà˜Ñ$ð œŸ™Ò'Ô+=¸lÈ1¹oÔ+Nð œŸ™Ò'ð �Øœ5Ÿ?™?Ò*Ø—H‘H×/Ñ/°¸Õ@á'ÐZÐ)ZÓZ˜<Ø+¨A™�HØ#Ð/Ð/Ð/Ø+¨A™�HØ—H‘H×8Ñ8¸ÀÈ8ÐU\Ô]Ø.2Ñ+àœŸ™Ò&¬5¯>©>À×AQÑAQÑ+QØœŸ™Ó(Ü-¨l¸1©oÓ>�Ü˜k¬I´}Ð+EÖFØ"—‘ q¨!Ó,¬s°;×3DÑ3DÓ/EÔEà¤5§?¡?Ò2¼*À[ÔR_Ô:`Ø ŸH™H×7Ñ7¸ÀÕHà ŸH™H×GÑGØ &¨°Wôð 7;Ð3Ø"šðK%	#ðR Ð*Ð*Ð*rí   c                ó„  — t        |t        «      r°t        |t        «      rŸ |j                  dd¬«      \  }}|j                  j                  |«      }|�jt        |j                  t        «      rO|j                  j                  s8|j                  j                  s!| j                  j                  d|› d�|«       y y y y y y y )Nrˆ  r  )Úmaxsplitr4  zN" is considered instance variable, to make it class variable use ClassVar[...])rø   r»   r²   Úrsplitr7  rË  r+  r}   rÒ  Úis_classvarr  Únote)r!  rR  r6   r^  r$  Úvar_namer+  s          rî   r[  z0ExpressionChecker.missing_classvar_callable_noteF
  s±   € ô �k¤:Ô.´:¸kÌ8Ô3TØ.˜-×.Ñ.¨s¸QÔ?‰KˆAˆxØ×#Ñ#×'Ñ'¨Ó1ˆDØÐ¤J¨t¯y©y¼#Ô$>Ø—y‘y×,Ò,°T·Y±Y×5JÒ5JØ—H‘H—M‘MØ˜H˜:ð &Gð Gàõð 6KÐ,ð %?Ðð 4UÐ.rí   c                ó’  — t        ||«      D ]¸  \  }}t        |«      }|t        j                  k(  r-| j	                  |«      s| j
                  j                  ||«       |t        j                  k(  sŒe| j                  |«      rŒwt        || j                  j                  d«      «      }| j
                  j                  |||«       Œº y )Nú _typeshed.SupportsKeysAndGetItem)rä  rÍ   r   r:   Úis_valid_var_argr  Úinvalid_var_argr;   Úis_valid_keyword_var_argrŒ   r  rQ  Úinvalid_keyword_var_arg)r!  r³  r�  r^  rj  rð  Ú
is_mappings          rî   Úcheck_var_args_kwargsz'ExpressionChecker.check_var_args_kwargsT
  s©   € ô #& i°Ó";ò 	PÑˆH�hÜ& xÓ0ˆHØœ5Ÿ>™>Ò)°$×2GÑ2GÈÔ2QØ—‘×(Ñ(¨°7Ô;Øœ5Ÿ?™?Ó*°4×3PÑ3PÐQYÕ3ZÜ'Ø˜dŸh™h×1Ñ1Ð2TÓUó�
ð —‘×0Ñ0°¸:ÀwÕOñ	Prí   c	                óâ
  — | j                  |||«       |xs | j                  }t        | j                  «       «      }	t	        |«      D �]  \  }
}t        |j                  |
   «      }d}|D �cg c]  }||   ‘Œ	 }}t        |«      dkD  �rAt        ||d      «      }t        |t        «      �rt        |j                  «      dk(  �rt        |j                  d   t        «      ré|t        j                  gt        j                  gt        |«      dz
  z  z   k(  r´|j                  d   g|dd D �cg c]  }||   ‘Œ	 c}z   }t        |t        «      r}t        |j                  «      }t        |t        «      rX|j                  sJ ‚|j                  }t        j                  gt        j                  gt        |j                  «      dz
  z  z   }d}|�sK|D �cg c]  }||   ‘Œ	 }}t        |t        «      �rýt        |j                  «      }t        |t        «      �r_t!        |j                  «      }|€!|j                  }t        gt        |«      z  }�nÊ|j                  |   }t        |t        «      sJ ‚t        |j                  «      }t        |t"        «      rH|j                  }t%        t        |j                  «      «      D �
cg c]  }
|
|k7  rt        nt        ‘Œ }}
�n<t        |t&        «      sJ ‚|j                  j(                  dk(  sJ ‚|j                  d| |j*                  d   gt        |«      t        |j                  «      z
  dz   z  z   |j                  |dz   d z   }t        gt        |«      z  }n£t        |t"        «      r|g}t        g}nˆt        |t&        «      sJ ‚|j                  j(                  dk(  sJ ‚|j*                  d   gt        |«      z  }t        gt        |«      z  }n+|gt        |«      z  }|j,                  |
   gt        |«      z  }t        «      t        |«      cxk(  rt        |«      k(  sJ ‚ J ‚t        «      t        |«      k7  rgt        |«      t        |«      kD  r'| j.                  j0                  j3                  ||«       n'| j.                  j0                  j5                  ||d«       �Œzt        |«      t        |«      k(  sJ ‚t        |«      t        «      k(  sJ ‚t7        |||||«      D ]S  \  }}}}}|	j9                  |||j:                  
   |t        |t        «      ¬«      } ||||||dz   |
dz   ||||   |«
       ŒU �Œ yc c}w c c}w c c}w c c}
w )zºCheck argument types against a callable type.

        Report errors if the argument types are not compatible.

        The check_call docstring describes some of the arguments.
        Fr  r   NTrÃ  )Úallow_unpack)r  Ú	check_argr   r-  rp  rÍ   r³  r‘  rø   r¼   rû   rÉ   r   r:   r9   r7  rÊ   rÄ   rœ  r²   r>  r�  r�  r  r  rl  rZ  rä  Úexpand_actual_typer�  )r!  r³  r�  r�  r�  r±  r^  r‚  rR  Úmapperr‚  ry  Úorig_callee_arg_typeÚexpanded_tupler  rb  Úp_actual_typerV  Úp_callee_typeÚcallee_arg_typesÚcallee_arg_kindsÚunpacked_typeÚinner_unpack_indexÚinner_unpackÚinner_unpacked_typerz  rq  Úactual_kindÚcallee_arg_typeÚcallee_arg_kindÚexpanded_actuals                                  rî   rë  z&ExpressionChecker.check_argument_typesa
  se  € ð" 	×"Ñ" 9¨i¸ÔAàÒ/ §¡ˆ	ä  ×!<Ñ!<Ó!>Ó?ˆä#Ð$4Ó5ó l	‰JˆAˆwÜ#2°6×3CÑ3CÀAÑ3FÓ#GÐ ð #ˆNØ29Ö:¨Q˜I a›LÐ:ˆLÐ:Ü�7‹|˜aÓÜ /°	¸'À!¹*Ñ0EÓ F�ä˜}¬iÕ8Ü˜M×/Ñ/Ó0°AÓ5Ü" =×#6Ñ#6°qÑ#9¼:ÔFØ$¬¯©Ð(8¼E¿M¹M¸?ÌcÐRYËlÐ]^ÑN^Ñ;_Ñ(_Ò_à$1×$7Ñ$7¸Ñ$:Ð#;ÐU\Ð]^Ð]_ÐU`Ö>aÐPQ¸yÈ»|Ò>aÑ#a�LÜ!Ð"6¼
ÔCÜ(7Ð8L×8QÑ8QÓ(R˜Ü% m´YÔ?Ø#0×#6Ò#6Ð6Ð#6Ø/<×/BÑ/BÐ,Ü05·±Ð/?Ä5Ç=Á=À/Ü # M×$7Ñ$7Ó 8¸1Ñ <ñCñ 0Ð,ð .2˜Nâ!Ø6=Ö>° 	¨!£Ð>�Ð>ÜÐ2´JÕ?Ü$3Ð4H×4MÑ4MÓ$N�MÜ! -´Õ;Ü-@À×ATÑATÓ-UÐ*Ø-Ð5Ø/<×/BÑ/BÐ,Ü07¨y¼3¸w»<Ñ/GÒ,à+8×+>Ñ+>Ð?QÑ+R˜LÜ#-¨l¼JÔ#GÐGÐ#GÜ2AÀ,×BSÑBSÓ2TÐ/Ü)Ð*=Ô?OÔPð 4A×3FÑ3FÐ 0ô .3´3°}×7JÑ7JÓ3KÓ-Lö4"à()ð 01Ð4FÒ/F¥GÌHÑ$Tð4"Ð 0ò 4"ô (2Ð2EÄxÔ'PÐ PÐ'PØ':×'?Ñ'?×'HÑ'HÐL\Ò'\Ð \Ð'\à$1×$7Ñ$7Ð8KÐ9KÐ$LØ':×'?Ñ'?ÀÑ'BÐ&CÜ'*¨7£|´c¸-×:MÑ:MÓ6NÑ'NÐQRÑ'Rñ'Tñ%Tð '4×&9Ñ&9Ð:LÈqÑ:PÐ:RÐ&Sñ%Tð !1ô 5<°9¼sÀ7»|Ñ3KÑ 0Ü# MÔ3CÔDØ,@Ð+AÐ(Ü,4¨:Ñ(ä)¨-¼ÔBÐBÐBØ,×1Ñ1×:Ñ:Ð>NÒNÐNÐNØ,9×,>Ñ,>¸qÑ,AÐ+BÄSÈÃ\Ñ+QÐ(Ü,3¨9´s¸7³|Ñ+CÑ(à(<Ð'=ÄÀGÃÑ'LÐ$Ø(.×(8Ñ(8¸Ñ(;Ð'<¼sÀ7»|Ñ'KÐ$ä�|Ó$¬¨G«ÔI¼¸LÓ8IÒIÐIÑIÐIÐIäÐ#Ó$¬¨LÓ(9Ò9Ü�|Ó$¤sÐ+;Ó'<Ò<Ø—H‘H—L‘L×3Ñ3°F¸GÕDà—H‘H—L‘L×2Ñ2°6¸7ÀDÔIÙäÐ'Ó(¬C°Ó,=Ò=Ð=Ð=ÜÐ'Ó(¬CÐ0@Ó,AÒAÐAÐAÜVYØ˜ |Ð5EÐGWóWò ÑR�˜ [°/À?ð #)×";Ñ";ØØØ×$Ñ$ QÑ'Ø#Ü!+¨O¼ZÓ!Hð #<ó #�ñ Ø#ØØØ#Ø˜Q‘JØ˜‘EØØØ˜‘LØõòñml	ùò ;ùò ?bùò  ?ùò 4"s   Á-UÄ-U"ÇU'ËU,c           
     ón  — t        |«      }t        |«      }t        |«      }t        |t        «      r| j                  j	                  ||	«       y| j                  ||«      r| j                  j                  ||	«       yt        ||| j                  j                  ¬«      s–| j                  j                  |||||||	|
¬«      }|j                  «       s| j                  j                  |||	|¬«       | j                  j                  «       s)| j                  j                  |||	|j                  «       yyy)z.Check the type of a single argument in a call.rN  )rR  r^  Úouter_context)Úparent_errorN)rÍ   rø   r®   r  Údeleted_as_rvalueÚhas_abstract_type_partÚconcrete_only_callrŒ   r  r  Úincompatible_argumentr  Úincompatible_argument_noteræ  Úcheck_possible_missing_awaitrï  )r!  Úcaller_typeÚoriginal_caller_typeÚcaller_kindr´  rl  Úmr�  rR  r^  r”  Úerrors               rî   r‚  zExpressionChecker.check_argæ
  s  € ô & kÓ2ˆÜ.Ð/CÓDÐÜ% kÓ2ˆä�k¤;Ô/Ø�H‰H×&Ñ& {°GÕ<à×(Ñ(¨°kÔBØ�H‰H×'Ñ'¨°WÕ=Ü˜K¨¸d¿h¹h×>NÑ>NÕOØ—H‘H×2Ñ2ØØØØ$ØØ'ØØ+ð 3ó 	ˆEð ×&Ñ&Ô(ð —‘×3Ñ3Ø(¨+°wÈUð 4ô ð —8‘8×2Ñ2Ô4Ø—‘×5Ñ5Ø ¨g°u·z±zõð 5ð# Prí   c                ó¾  ‡ — |j                  «       }‰ j                  |«      }‰ j                  ||||«      }	d}
d}d}‰ j                  ||	«      }d}t	        ˆ fd„|D «       «      rŸ	 ‰ j
                  j                  «       5  ‰ j                  |	||||||||«	      }ddd«       r`|D �cg c]  }|d   ‘Œ	 }}|D �cg c]  }|d   ‘Œ	 }}t        ||j                  |j                  «      ‰ j                  t        |«      «      f}	 ‰ j                  |	|||||||«      }|�7|�5t        |d   |d   «      r!t!        t#        |d   «      t$        «      s|sd}nd}|�M|�I|D ]D  }t!        t#        |«      x}t&        «      sŒ‰ j(                  j+                  |j,                  |«       ŒF |S |�Ft!        t#        |d   «      x}t&        «      r&‰ j(                  j+                  |j,                  |«       |S ‰ j/                  |	|||||«      }
t1        |
«      dkD  r|
d   }nXt%        t2        j4                  «      }t7        |«      sd}nt8        j:                  }‰ j
                  j=                  ||||||¬«       ‰ j?                  |||||||¬«      }|r,|s*‰ j(                  jA                  tB        jD                  |«       |S # 1 sw Y   �ŒxY wc c}w c c}w # t        $ r d}Y �Œ×w xY w)	z(Checks a call to an overloaded function.NFc              3  ó@   •K  — | ]  }‰j                  |«      –— Œ y ­wrñ   )Ú
real_union)rô   r  r!  s     €rî   rö   z8ExpressionChecker.check_overload_call.<locals>.<genexpr>4  s   øè ø€ Ò9¨ˆt�‰˜s×#Ñ9ùrÐ  r   r  T)r�  r�  rï  ©r6   rR  )#rÒ  r  Úplausible_overload_call_targetsÚpossible_none_type_var_overlapr¤  r  rO  Úunion_overload_resultr¤   r@  rA  Úcombine_function_signaturesrÎ   ræ   Úinfer_overload_return_typerŒ   rø   rÍ   r¬   r­   r  Úwarn_deprecatedÚ
definitionÚoverload_erased_call_targetsr‘  rÀ   r;  Úis_operator_methodrò  ÚOPERATORÚno_variant_matches_argumentsr™  rÙ  r   ÚTOO_MANY_UNION_COMBINATIONS)r!  r�  r�  r�  r�  r6   rR  r^  r³  Úplausible_targetsÚerased_targetsÚinferred_typesÚunioned_resultÚnone_type_var_overlapÚunion_interruptedÚunioned_returnr  ÚreturnsÚinferred_resultrI  r
  rv  rï  r-  s   `                       rî   r´  z%ExpressionChecker.check_overload_call  s#  ø€ ð ×,Ñ,Ó.ˆØ×9Ñ9¸$Ó?ˆ	à ×@Ñ@Ø�y )¨Vó
Ðð 59ˆØ,0ˆØ37ˆð
 !%× CÑ CÀIÐO`Ó aÐØ!ÐÜÓ9¨yÔ9Ô9ðØ—X‘X×+Ñ+Ó-ñ Ø%)×%?Ñ%?Ø)ØØ!Ø!Ø!Ø%Ø#Ø-Øó
&�N÷ñ" "Ø-;Ö<¨˜q ›tÐ<�GÐ<Ø4BÖ%C¨q a¨£dÐ%C�NÐ%Cô .¨g°w·|±|ÀWÇ^Á^ÓTØ×8Ñ8Ô9IÈ.Ó9YÓZð&‘Nð ×9Ñ9ØØØØØØØØó	
ˆð Ð&¨>Ð+Eô ˜?¨1Ñ-¨~¸aÑ/@ÔAÜ"¤?°?À1Ñ3EÓ#FÌÔPÙ-à!%‘à"&�ØÐ%ØÐ)Ø%3ò H�MÜ!¤°}Ó'EÐ"E !Ä|ÕTØŸ™×0Ñ0°·±¸wÕGðHð "Ð!ØÐ&Üœ¨¸qÑ/AÓBÐB˜!ÄLÔQØ—‘×(Ñ(¨¯©°wÔ?Ø"Ð"ð ×:Ñ:Ø˜y¨)°YÀÀgó
ˆô ˆ~Ó Ò"ð *¨!Ñ,‰Fô œY×1Ñ1Ó2ˆFÜ% mÔ4Ø‘ä—~‘~�Ø�H‰H×1Ñ1Ø˜	 7°iÈ9Ð[_ð 2ô ð —‘ØØØØØØ'Ø#ð !ó 
ˆñ Ñ%:Ø�H‰H�M‰MÔ*×FÑFÈÔPØˆ÷Yñ üò$ =ùÚ%Cøô !ò )Ø$(Ó!ð)ús6   Á&K Â J6ÂK Â(KÂ:KÊ6K Ê;K ËKËKc           
     ó|  ‡— dd„}g }g }d}d}	t        |‰«      D ]-  \  }
}|
t        k(  r
 ||«      sd}|
t        k(  sŒ# ||«      rŒ,d}	Œ/ |j                  D ]Ô  }t	        |||j
                  |j                  ˆfd„«      }| j                  j                  «       5  |j                  «       �|j                  |«       ng| j                  |‰|||d«      rQ|r|j                  r|j                  |«       n1|	r|j                  r|j                  |«       n|j                  |«       ddd«       ŒÖ ||z   S # 1 sw Y   ŒåxY w)aE  Returns all overload call targets that having matching argument counts.

        If the given args contains a star-arg (*arg or **kwarg argument, except for
        ParamSpec), this method will ensure all star-arg overloads appear at the start
        of the list, instead of their usual location.

        The only exception is if the starred argument is something like a Tuple or a
        NamedTuple, which has a definitive "shape". If so, we don't move the corresponding
        alternative to the front since we can infer a more precise match using the original
        order.c                ó˜   — t        | «      } t        | t        t        f«      xs( t        | t        «      xr | j
                  j                  S rñ   )rÍ   rø   r¼   r¿   r²   r7  Úis_named_tupler˜  s    rî   Ú	has_shapezDExpressionChecker.plausible_overload_call_targets.<locals>.has_shape¶  s>   € Ü! #Ó&ˆCÜ˜c¤I¬}Ð#=Ó>ò Ü˜3¤Ó)ÒE¨c¯h©h×.EÑ.Eðrí   FTc                ó   •— ‰|    S rñ   rì   ©r‚  r³  s    €rî   rƒ  zCExpressionChecker.plausible_overload_call_targets.<locals>.<lambda>É  s   ø€ ÈiÐXYÉl€ rí   N©r°  r½   ÚreturnÚbool)rä  r:   r;   rû   r   r�  r�  r  rO  rà  rù  rç  Ú
is_var_argÚ	is_kw_arg)r!  r³  r�  r�  r   r½  ÚmatchesÚstar_matchesÚargs_have_var_argÚargs_have_kw_argrf  r°  r±  s    `           rî   r¥  z1ExpressionChecker.plausible_overload_call_targets¤  sB  ø€ ó$	ð ')ˆØ+-ˆà!ÐØ ÐÜ˜Y¨	Ó2ò 	(‰IˆD�#Ø”xÒ©	°#¬Ø$(Ð!Ø”yÓ ©°3­Ø#'Ñ ð		(ð —>‘>ò 	,ˆCÜ5Ø˜9 c§m¡m°S·]±]ÓDZó Ðð —‘×'Ñ'Ó)ñ ,Ø—>‘>Ó#Ð/ð —N‘N 3Õ'Ø×.Ñ.Ø˜ I¨yÐ:JÈDôñ )¨S¯^ª^Ø$×+Ñ+¨CÕ0Ù)¨c¯mªmØ$×+Ñ+¨CÕ0àŸ™ sÔ+÷!,ð ,ð		,ð, ˜gÑ%Ð%÷%,ð ,ús   ÂB
D2Ä2D;	c	                óÚ  — g }	g }
g }t        t        t        |«      «      }g }|D �].  }| j                  | j                  j                  u sJ ‚| j                  j                  d¬«      5 }| j                  j                  5 }| j                  |||||||¬«      \  }}ddd«       ddd«       j                  «        }|sŒ›|s!| j                  j                  «       fc S t        «      }t        |t        «      r|	j                  |«       n|	j                  |«       |
j                  «       |j                  |«       |j                  «       �Œ1 |	syt        |	|
|||«      r¾t        |
«      r(| j                  j                  |d   «       |
d   |d   fS t        |
D �cg c]  }t!        |«      ‘Œ c}«      r:| j                  j                  |d   «       t!        |
d   «      t!        |d   «      fS | j                  t#        t$        j&                  «      ||||||¬«      S | j                  j                  |d   «       |
d   |d   fS # 1 sw Y   �ŒµxY w# 1 sw Y   �ŒºxY wc c}w )aÝ  Attempts to find the first matching callable from the given list.

        If a match is found, returns a tuple containing the result type and the inferred
        callee type. (This tuple is meant to be eventually returned by check_call.)
        If multiple targets match due to ambiguous Any parameters, returns (AnyType, AnyType).
        If no targets match, returns None.

        Assumes all of the given targets have argument counts compatible with the caller.
        T)Úfilter_revealed_type)r�  r�  r�  r�  r^  r6   rR  Nr   )r¤  ÚmapÚhas_any_typer  r  rO  r>  r™  rš  Ústore_typesrÍ   rø   r­   rù  Úany_causes_overload_ambiguityÚall_same_typesr    r¬   rÀ   r3  )r!  r±  r�  r³  r�  r�  r6   rR  r^  rÅ  Úreturn_typesr³  Úargs_contain_anyÚ	type_mapsr°  rø  rŸ  r?  Ú
infer_typeÚis_matchÚp_infer_types                        rî   r©  z,ExpressionChecker.infer_overload_return_typeß  sa  € ð* ')ˆØ#%ˆØ%'ˆÜœs¤<°Ó;Ó<ÐØ24ˆ	à$ó 	$ˆCØ—8‘8˜tŸx™xŸ|™|Ñ+Ð+Ð+Ø—‘×'Ñ'¸TÐ'ÓBð 
ÀaØ—X‘X×,Ñ,ð 	°Ø+/¯?©?Ø"Ø!Ø"+Ø"+Ø 'Ø&3Ø$/ð ,;ó ,Ñ(�H˜j÷	÷
ð ×+Ñ+Ó-Ð-ˆHÚñ (Ø—H‘H×(Ñ(¨Ô+Ø# ZÐ/Ò/Ü.¨zÓ:�Ü˜l¬LÔ9ð —N‘N <Õ0à—N‘N 3Ô'Ø×#Ñ# HÔ-Ø×%Ñ% jÔ1Ø× Ñ  Ö#ð;	$ñ> ØÜ*¨7°LÀ)ÈYÐXaÔbô ˜lÔ+Ø—‘×$Ñ$ Y¨q¡\Ô2Ø# A‘¨°qÑ(9Ð9Ð9Ü¸LÖ I°S¤¨C¥Ò IÔJØ—‘×$Ñ$ Y¨q¡\Ô2Ü! ,¨q¡/Ó2´J¸~ÈaÑ?PÓ4QÐQÐQà—‘Ü"¤9×#9Ñ#9Ó:ØØ'Ø'Ø#Ø"/Ø +ð 'ó ð ð �H‰H× Ñ  ¨1¡Ô.Ø ‘? N°1Ñ$5Ð5Ð5÷i	ñ 	ú÷
ñ 
üòJ !Js*   Á(IÁ?IÂIÆ$I(ÉIÉIÉI%	c           	     óh   — g }|D ]*  }| j                  ||||||«      sŒ|j                  |«       Œ, |S )z¬Returns a list of all targets that match the caller after erasing types.

        Assumes all of the given targets have argument counts compatible with the caller.
        )Úerased_signature_similarityrù  )	r!  r±  r³  r�  r�  r�  r^  rÅ  r°  s	            rî   r¬  z.ExpressionChecker.overload_erased_call_targets3  sH   € ð ')ˆØ$ò 	$ˆCØ×/Ñ/Ø˜9 i°°s¸Gõð —‘˜sÕ#ð		$ð
 ˆrí   c                óR  ‡— |r|syd}t        |«      D ]A  }t        |t        «      sŒt        |j                  «      D ]  }t        |t        «      sŒd} ŒA ŒC |syt        d„ |D «       «      }t        |«      D ]-  Št        ˆfd„|D «       «      sŒt        ˆfd„|D «       «      sŒ- y y)a˜  Heuristic to determine whether we need to try forcing union math.

        This is needed to avoid greedy type variable match in situations like this:
            @overload
            def foo(x: None) -> None: ...
            @overload
            def foo(x: T) -> list[T]: ...

            x: int | None
            foo(x)
        we want this call to infer list[int] | None, not list[int | None].
        FTc              3  óF   K  — | ]  }t        |j                  «      –— Œ y ­wrñ   )r‘  r³  ©rô   r
  s     rî   rö   zCExpressionChecker.possible_none_type_var_overlap.<locals>.<genexpr>d  s   è ø€ ÒE¨aœ˜QŸ[™[×)ÑEùs   ‚!c              3  ój   •K  — | ]*  }t        t        |j                  ‰   «      t        «      –— Œ, y ­wrñ   )rø   rÍ   r³  rµ   ©rô   r
  r‚  s     €rî   rö   zCExpressionChecker.possible_none_type_var_overlap.<locals>.<genexpr>f  s*   øè ø€ ò ØJK”
œ?¨1¯;©;°q©>Ó:¼H×Eñùó   ƒ03c              3  ój   •K  — | ]*  }t        t        |j                  ‰   «      t        «      –— Œ, y ­wrñ   )rø   rÍ   r³  rÅ   rÜ  s     €rî   rö   zCExpressionChecker.possible_none_type_var_overlap.<locals>.<genexpr>h  s*   øè ø€ ò ØMN”
œ?¨1¯;©;°q©>Ó:¼K×HñùrÝ  )rÎ   rø   rÈ   rû   rµ   Úminrœ  r¤  )r!  r³  r±  Úhas_optional_argrj  rÂ  Ú
min_prefixr‚  s          @rî   r¦  z0ExpressionChecker.possible_none_type_var_overlapH  sÀ   ø€ ñ !©	ØØ ÐÜ(¨Ó3ò 	ˆHÜ˜h¬	Ô2ØÜ(¨¯©Ó8ò �Ü˜d¤HÕ-Ø'+Ð$Ùñð	ñ  ØäÑEÐ3DÔEÓEˆ
Ü�zÓ"ò 	ˆAÜó ØO`ôõ äó ØRcôõ ñ ð	ð rí   c                ó<  — |
t         k\  rt        ‚t        |«      D ]  \  }}| j                  |«      sŒ n: | j	                  ||«      5  | j                  ||||||||	«      }ddd«       �|gS y|sZ| j	                  ||«      5  | j                  ||||||||	«      }ddd«       �%t        t        |d   «      t        t        f«      s|gS t        ||   «      }t        |t        «      sJ ‚g }|j                  «       D ]I  }|j                  «       }|||<   | j                  |||||||||	|
dz   «
      }|�|j                  |«       ŒI y t        «       }g }|D ])  }||vsŒ|j                  |«       |j!                  |«       Œ+ |S # 1 sw Y   �Œ&xY w# 1 sw Y   Œ÷xY w)a  Accepts a list of overload signatures and attempts to match calls by destructuring
        the first union.

        Return a list of (<return type>, <inferred variant type>) if call succeeds for every
        item of the desctructured union. Returns None if there is no match.
        Nr   r  )rÞ   ræ   rp  r£  Útype_overrides_setr©  rø   rÍ   rÈ   r¬   r  Úcopyr§  rQ  rd  rh  rù  )r!  r±  r�  r³  r�  r�  r6   rR  rµ  r^  ÚlevelÚidxr°  r°  ÚdirectÚfirst_unionÚ	res_itemsrÂ  Únew_arg_typesÚ
sub_resultÚseenr-  Úpairs                          rî   r§  z'ExpressionChecker.union_overload_resultn  sü  € ð, ”JÒÜÐô " )Ó,ò 	‰HˆC�Ø�‰˜sÕ#Ùð	ð
 ×(Ñ(¨¨yÓ9ñ 
Ø×5Ñ5Ø%ØØØØØ!ØØó	�÷
ð ˆØ�u�Øñ %Ø×(Ñ(¨¨yÓ9ñ 
Ø×8Ñ8Ø%ØØØØØ!ØØó	�÷
ð Ð!¬*Ü  q¡	Ó*¬Y¼Ð,@ô+ð �x�ô & i°¡nÓ5ˆÜ˜+¤yÔ1Ð1Ð1Øˆ	Ø×.Ñ.Ó0ò 	ˆDØ%ŸN™NÓ,ˆMØ!%ˆM˜#ÑØ×3Ñ3Ø!ØØØØØØØ%ØØ˜‘	óˆJð Ð%Ø× Ñ  Õ,ñ ð'	ô, (+£uˆØˆØò 	$ˆDØ˜4ÒØ—‘˜”Ø—‘˜dÕ#ð	$ð ˆ÷I
ñ 
ú÷$
ð 
ús   ÁFÂFÆFÆFc                ót   — t        |«      }t        |t        «      xr t        |j	                  «       «      dkD  S rÕ  )rÍ   rø   rÈ   r‘  r  ©r!  r°  s     rî   r£  zExpressionChecker.real_unionÔ  s1   € Ü˜cÓ"ˆÜ˜#œyÓ)ÒK¬c°#×2DÑ2DÓ2FÓ.GÈ!Ñ.KÐKrí   c              #  óè   K  — t        |«      t        |«      k(  sJ ‚t        ||«      D ]  \  }}|| j                  |<   Œ 	 d–— |D ]  }| j                  |= Œ y# |D ]  }| j                  |= Œ w xY w­w)z5Set _temporary_ type overrides for given expressions.N)r‘  rä  r  )r!  ÚexprsÚ	overridesrŸ  r°  s        rî   rã  z$ExpressionChecker.type_overrides_setØ  sŠ   è ø€ ô
 �5‹zœS ›^Ò+Ð+Ð+Ü˜U IÓ.ò 	,‰IˆD�#Ø(+ˆD×Ñ Ò%ð	,ð	.Ûàò .�Ø×'Ñ'¨Ñ-ñ.ø˜ò .�Ø×'Ñ'¨Ñ-ñ.üs   ‚=A2Á A ÁA2ÁA/Á/A2c                ó’  — |sJ d«       ‚t        d„ |D «       «      st        t        j                  «      S t	        d|«      }t        |d¬«      }|�|S t        |«      \  }}t        |D �cg c]  }|j                  ‘Œ c}«      }t        t        j                  «      }|d   j                  ||gt        t        gddg||d¬«      S c c}w )	aI  Accepts a list of function signatures and attempts to combine them together into a
        new CallableType consisting of the union of all the given arguments and return types.

        If there is at least one non-callable type, return Any (this can happen if there is
        an ambiguity because of Any in arguments).
        zTrying to merge no callablesc              3  ó<   K  — | ]  }t        |t        «      –— Œ y ­wrñ   )rø   r­   rÚ  s     rî   rö   z@ExpressionChecker.combine_function_signatures.<locals>.<genexpr>î  s   è ø€ Ò>°1”:˜a¤×.Ñ>ùr  úlist[CallableType]T)Úsimplify_unionsNr   )r³  r�  r�  r?  r-  r¢  )rú   r¬   rÀ   r3  r   r�   r�   r¤   r?  rc  r:   r;   )r!  r   Ú	callablesÚcombinedr-  r
  Úunion_returnr¤  s           rî   r¨  z-ExpressionChecker.combine_function_signaturesæ  sÑ   € ñ Ð4Ð4Ó4ˆuÜÑ>¸Ô>Ô>Üœ9×1Ñ1Ó2Ð2ÜÐ-¨uÓ5ˆ	ä,¨YÈÔMˆØÐØˆOô
  CÀ9ÓMÑˆ	�9Ü,À)Ö-L¸Q¨a¯j«jÒ-LÓMˆÜ”i×,Ñ,Ó-ˆØ˜‰|×)Ñ)Ø˜C�jÜ¤Ð+Ø˜T�lØ!ØØð *ó 
ð 	
ùò .Ms   Á)Cc           	     óv  ‡— t        |||j                  |j                  ˆfd„«      }| j                  j	                  «       5  | j                  |‰|||d«      s
	 ddd«       y	 ddd«       	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 dd„}	 | j                  ‰||||||¬«       y# 1 sw Y   Œ=xY w# t        $ r Y yw xY w)z^Determine whether arguments could match the signature at runtime, after
        erasing types.c                ó   •— ‰|    S rñ   rì   r¿  s    €rî   rƒ  z?ExpressionChecker.erased_signature_similarity.<locals>.<lambda>  s   ø€ ÐPYÐZ[ÑP\€ rí   NFc
                ó(   — t        | |«      st        ‚y rñ   )Úarg_approximate_similarityrÿ   )
rœ  Úoriginal_ccaller_typerž  r´  rl  rŸ  r�  rR  r^  r”  s
             rî   r‚  z@ExpressionChecker.erased_signature_similarity.<locals>.check_arg  s   € ô .¨k¸;ÔGô �ð Hrí   )r^  r‚  T)rœ  r½   rþ  r½   rž  rB   r´  r½   rl  ÚintrŸ  rÿ  r�  r­   rR  úType | Noner^  rL   r”  rL   rÁ  ÚNone)r   r�  r�  r  rO  rç  rë  rÿ   )	r!  r³  r�  r�  r�  r�  r^  r±  r‚  s	    `       rî   r×  z-ExpressionChecker.erased_signature_similarity  s5  ø€ ô 2Ø�y &×"2Ñ"2°F×4DÑ4DÓF\ó
Ðð �X‰X×#Ñ#Ó%ñ 	Ø×,Ñ,Ø˜	 9¨iÐ9IÈ4ôð ÷	ð 	ð÷	ð	Øð	à#'ð	ð !ð	ð ð		ð
 ð	ð ð	ð !ð	ð %ð	ð ð	ð #ð	ð ó	ð"	Ø×%Ñ%ØØØØØ ØØ#ð &ô ð ÷E	ð 	ûôF ò 	Ùð	ús   ÁB ÂB, Â B)Â,	B8Â7B8c                ó^   — t        j                  ||| j                  j                  ||¬«      S )z=Simple wrapper around mypy.applytype.apply_generic_arguments.r  )r   r  r  Úincompatible_typevar_value)r!  r  r   r^  r  s        rî   r  z)ExpressionChecker.apply_generic_arguments:  s0   € ô ×0Ñ0ØØØ�H‰H×/Ñ/ØØ-ô
ð 	
rí   c                óP  — | j                  |«      }| j                  |||«       t        |«      }t        |t        «      r6t	        t
        j                  |¬«      t	        t
        j                  |¬«      fS t	        t
        j                  «      t	        t
        j                  «      fS )Nr  )r  r  rÍ   rø   r¬   rÀ   r  r3  )r!  r�  r�  r�  r^  r³  s         rî   rµ  z%ExpressionChecker.check_any_type_callJ  s‡   € ð ×9Ñ9¸$Ó?ˆ	Ø×"Ñ" 9¨i¸ÔAä  Ó(ˆÜ�fœgÔ&äœ	×2Ñ2¸vÔFÜœ	×2Ñ2¸vÔFðð ô
 œ9×1Ñ1Ó2´G¼I×<RÑ<RÓ4SÐSÐSrí   c                ó  — | j                   j                  «       5  |j                  «       D �cg c]  }| j                  |||||«      ‘Œ }}d d d «       t	        D �cg c]  }|d   ‘Œ	 c}«      |fS c c}w # 1 sw Y   Œ,xY wc c}w )Nr   )r  Údisable_type_namesr  r™  r¤   )	r!  r�  r�  r�  r�  r^  ÚsubtypeÚresultsr°  s	            rî   r¶  z"ExpressionChecker.check_union_callY  s�   € ð �X‰X×(Ñ(Ó*ñ 	ð  &×4Ñ4Ó6öàð —‘ ¨¨y¸'À9ÕMðˆGð ÷	ô &¸Ö&A°# s¨1£vÒ&AÓBÀFÐKÐKùò÷	ð 	üò 'Bs"   ›A7®A2Á
A7ÁBÁ2A7Á7B c                óš   — | j                  ||«      }| j                  ||«      }| j                  j                  |j                  |«       |S )z'Visit member expression (of form e.id).)Úanalyze_ordinary_member_accessr)  r  rª  r+  )r!  r,  rT  r-  r.  s        rî   Úvisit_member_exprz#ExpressionChecker.visit_member_expri  sC   € à×4Ñ4°Q¸	ÓBˆØ×/Ñ/°°6Ó:ˆØ�‰× Ñ  §¡¨Ô+Øˆrí   c                óR  — |j                   �| j                  |«      S | j                  |j                  | j                  ¬«      }|j                  }d}t        |t        «      r0t        |j                  t        «      r|j                  j                  }t        |t        «      rIt        |j                  t        «      r/|j                  j                  xs |j                  j                  }nd}t        |j                  |||dd|| j                  | j!                  «       |||¬«      }|S )z–Analyse member expression or member lvalue.

        An rvalue can be provided optionally to infer better setter type when is_lvalue is True.
        Nrz  F)	rT  rª  r«  r¬  r  r­  Úmodule_symbol_tablerJ  r7  )rf  r(  rs  rŸ  r  rø   rg   r+  r]   re  r}   rJ  Úis_clsr   r:  r  rZ  )	r!  r,  rT  r7  r¬  rw  r  rJ  Úmember_types	            rî   r
  z0ExpressionChecker.analyze_ordinary_member_accessp  sò   € ð �6‰6Ðà×(Ñ(¨Ó+Ð+ð !ŸK™K¨¯©¸$¿.¹.˜KÓIˆMØ—6‘6ˆDØ"&Ðä˜$¤Ô(¬Z¸¿	¹	Ä8Ô-LØ&*§i¡i§o¡oÐ#Ü˜$¤Ô(¬Z¸¿	¹	Ä3Ô-Gð Ÿ)™)×+Ñ+Ò?¨t¯y©y×/?Ñ/?‘à�ä/Ø—‘ØØØ#ØØ!Ø+Ø—H‘HØ#'×#:Ñ#:Ó#<Ø$7ØØôˆKð Ðrí   c                óZ   — t        |||ddd|| j                  | j                  «       ¬«	      S )z}Analyse member access that is external, i.e. it cannot
        refer to private definitions. Return the result type.
        Fr³  )r   r  rZ  )r!  rµ  Ú	base_typer^  s       rî   Úanalyze_external_member_accessz0ExpressionChecker.analyze_external_member_accessš  s9   € ô %ØØØØØØØ#Ø—‘Ø#×6Ñ6Ó8ô

ð 
	
rí   c                ó2   — t        | j                  d   «      S ©Nr1  )r£   r  r%  s    rî   rZ  z$ExpressionChecker.is_literal_context­  s   € Ü# D×$5Ñ$5°bÑ$9Ó:Ð:rí   c                ó�  — | j                  |«      }| j                  «       rt        ||¬«      S |du r:| j                  €"|j	                  t        ||¬«      ¬«      | _        | j                  S |du r:| j
                  €"|j	                  t        ||¬«      ¬«      | _        | j
                  S |j	                  t        ||¬«      ¬«      S )az  Analyzes the given literal expression and determines if we should be
        inferring an Instance type, a Literal[...] type, or an Instance that
        remembers the original literal. We...

        1. ...Infer a normal Instance in most circumstances.

        2. ...Infer a Literal[...] if we're in a literal context. For example, if we
           were analyzing the "3" in "foo(3)" where "foo" has a signature of
           "def foo(Literal[3]) -> None", we'd want to infer that the "3" has a
           type of Literal[3] instead of Instance.

        3. ...Infer an Instance that remembers the original Literal if we're declaring
           a Final variable with an inferred type -- for example, "bar" in "bar: Final = 3"
           would be assigned an Instance that remembers it originated from a '3'. See
           the comments in Instance's constructor for more details.
        )r¹  r…  T)r[  F)rQ  rZ  r³   r  rc  r   )r!  r¹  Úfallback_namer°  s       rî   r\  z)ExpressionChecker.infer_literal_expr_type°  sÍ   € ð" �o‰o˜mÓ,ˆØ×"Ñ"Ô$Ü U°SÔ9Ð9à˜‰}Ø×%Ñ%Ð-Ø),×):Ñ):Ü)4¸5È3Ô)Oð *;ó *�DÔ&ð ×)Ñ)Ð)Ø˜‰~Ø×&Ñ&Ð.Ø*-×*;Ñ*;Ü)4¸5È3Ô)Oð +<ó +�DÔ'ð ×*Ñ*Ð*Ø×$Ñ$´kÈÐX[Ô6\Ð$Ó]Ð]rí   c                óÀ   — t        |j                  «      rt        |j                  «      rJ ‚t        |j                  |j                  z   | j                  d«      ¬«      S )z$Concatenate two fixed length tuples.rÃ  )rû   r…  )rÊ   rû   r¼   rQ  )r!  ÚleftÚrights      rî   Úconcat_tupleszExpressionChecker.concat_tuplesÓ  sI   € ä'¨¯
©
Ô3Ô8KÈEÏKÉKÔ8XÐYÐYÜØ—*‘*˜uŸ{™{Ñ*°T·_±_ÐEUÓ5Vô
ð 	
rí   c                ó:   — | j                  |j                  d«      S )z(Type check an integer literal (trivial).úbuiltins.int©r\  r¹  ©r!  r,  s     rî   Úvisit_int_exprz ExpressionChecker.visit_int_exprÚ  ó   € à×+Ñ+¨A¯G©G°^ÓDÐDrí   c                ó:   — | j                  |j                  d«      S )z&Type check a string literal (trivial).r&  r  r  s     rî   Úvisit_str_exprz ExpressionChecker.visit_str_exprÞ  r   rí   c                ó:   — | j                  |j                  d«      S )z%Type check a bytes literal (trivial).râ   r  r  s     rî   Úvisit_bytes_exprz"ExpressionChecker.visit_bytes_exprâ  s   € à×+Ñ+¨A¯G©GÐ5EÓFÐFrí   c                ó$   — | j                  d«      S )z%Type check a float literal (trivial).zbuiltins.float©rQ  r  s     rî   Úvisit_float_exprz"ExpressionChecker.visit_float_expræ  s   € à�‰Ð/Ó0Ð0rí   c                ó$   — | j                  d«      S )zType check a complex literal.zbuiltins.complexr&  r  s     rî   Úvisit_complex_exprz$ExpressionChecker.visit_complex_exprê  s   € à�‰Ð1Ó2Ð2rí   c                óv   — 	 | j                  d«      S # t        $ r t        t        j                  «      cY S w xY w)zType check '...'.ztypes.EllipsisType)rQ  rb  r¬   rÀ   r3  r  s     rî   Úvisit_ellipsisz ExpressionChecker.visit_ellipsisî  s7   € ð	3Ø—?‘?Ð#7Ó8Ð8øÜò 	3äœ9×1Ñ1Ó2Ò2ð	3ús   ‚ “"8·8c                ó
  — |j                   r| j                  |j                   «      S |j                  dk(  s|j                  dk(  r| j                  |«      S |j                  dk(  r+t	        |j
                  t        «      r| j                  |«      S |j                  dk(  r”t	        |j
                  t        «      r0| j                  j                  |j
                  |j                  «      S t	        |j
                  t        «      r0| j                  j                  |j
                  |j                  «      S | j                  |j
                  «      }t        |«      }t	        |t        «      �ré|j                  dk(  �rÙ|j                  j                   j#                  d«      }|�r±|j$                  dk(  �r¡t        | j                  |j                  «      «      }t	        |t        «      re|j                  j                   j#                  d«      }|�€Et'        |j(                  «      �t'        |j(                  «      �€| j+                  ||«      S t,        | j.                  j0                  j2                  v rât	        |t4        «      rÒ| j.                  j7                  |«      r·|j                   j#                  d«      }|€š|j                  j                   j$                  d	k(  rwt'        |j(                  «      €b| j.                  j9                  ||«      }| j.                  j;                  d	|g«      }|j=                  |j(                  t?        |«      gz   ¬
«      S t@        }	|j                  dk(  rŒtC        |d«      r:t        | j                  |j                  «      «      }t	        |tD        «      rtF        }	t	        |tD        «      r6t        | j                  |j                  «      «      }tC        |d«      rtH        }	t,        | j.                  j0                  j2                  v rÍ|j                  dk(  r¾t	        |t4        «      r®|j                   j$                  d	k(  r•t        | j                  |j                  «      «      }t	        |t        «      ra|j                  j                   j$                  d	k(  r>t'        |j(                  «      €)|j=                  t?        |«      g|j(                  z   ¬
«      S |j                  tJ        jL                  v rétJ        jL                  |j                     }
|	tN        jP                  u s|	tN        jR                  u r4| jU                  |
||j                  ||	tN        jP                  u ¬«      \  }}nk|	tN        jV                  u rN| jU                  tJ        jX                  |
   | j                  |j                  «      |j
                  |d¬«      \  }}nt[        |	«       |_.        S t_        d|j                  › �«      ‚)z(Type check a binary operator expression.ÚandÚorÚ*ú%ú+Ú__add__zbuiltins.tuple.__add__Ú__radd__rÃ  )rû   ú|rS  )r  r  r^  Úallow_reverseFzUnknown operator )0rp  rs  ÚopÚcheck_boolean_oprø   r  rZ   Úcheck_list_multiplyrF   r  Úcheck_str_interpolationr  rm   rÍ   r¼   Úpartial_fallbackr7  rË  r>  rÊ   rû   r  r�   r  r  Úenable_incomplete_featurer²   Útype_is_iterableÚiterable_item_typer\  rc  rÉ   r  rÒ   r¿   r  r	  r   Ú
op_methodsr  r  r  Úcheck_opr  Úreverse_op_methodsr   Úmethod_typeÚRuntimeError)r!  r,  Ú	left_typeÚproper_left_typeÚleft_add_methodÚproper_right_typeÚright_radd_methodrg  r"  Úuse_reverseÚmethodr-  rA  s                rî   Úvisit_op_exprzExpressionChecker.visit_op_exprö  sÑ  € à�:Š:à—;‘;˜qŸz™zÓ*Ð*Ø�4‰4�5Š=˜AŸD™D DšLØ×(Ñ(¨Ó+Ð+Ø�4‰4�3Š;œ: a§f¡f¬hÔ7à×+Ñ+¨AÓ.Ð.Ø�4‰4�3Š;Ü˜!Ÿ&™&¤)Ô,Ø×*Ñ*×BÑBÀ1Ç6Á6È1Ï7É7ÓSÐSÜ˜!Ÿ&™&¤'Ô*Ø×*Ñ*×BÑBÀ1Ç6Á6È1Ï7É7ÓSÐSØ—K‘K §¡Ó'ˆ	ä*¨9Ó5ÐÜÐ&¬	Õ2°q·t±t¸s³{Ø.×?Ñ?×DÑD×HÑHÈÓSˆOÚ ?×#;Ñ#;Ð?WÓ#WÜ$3°D·K±KÀÇÁÓ4HÓ$IÐ!ÜÐ/´Ô;Ø(9×(JÑ(J×(OÑ(O×(SÑ(SÐT^Ó(_Ð%Ø(Ñ0ô 0Ð0@×0FÑ0FÓGÐOÜ2Ð3D×3JÑ3JÓKÑSà#'×#5Ñ#5Ð6FÐHYÓ#ZÐZä'¨4¯8©8×+;Ñ+;×+UÑ+UÑUÜ"Ð#4´hÔ?ØŸ™×1Ñ1Ð2CÔDð ):×(>Ñ(>×(BÑ(BÀ:Ó(NÐ%à)Ð1Ø,×=Ñ=×BÑB×KÑKÐO_Ò_Ü/Ð0@×0FÑ0FÓGÐOà$(§H¡H×$?Ñ$?Ð@QÐSTÓ$U˜	Ø!%§¡×!<Ñ!<Ð=MÐPYÈ{Ó![˜Ø/×=Ñ=Ø"2×"8Ñ"8¼JÀvÓ<NÐ;OÑ"Oð  >ó  ð ô #6ˆØ�4‰4�3Š;Ü Ð!1°?ÔCô %4°D·K±KÀÇÁÓ4HÓ$IÐ!ÜÐ/´Ô?Ü"4�KÜÐ*¬MÔ:ô %4°D·K±KÀÇÁÓ4HÓ$IÐ!Ü$Ð%6¸ÔHÜ"3�Kä $§(¡(×"2Ñ"2×"LÑ"LÑLð —‘˜’ÜÐ/´Ô:Ø$×)Ñ)×2Ñ2Ð6FÒFä$3°D·K±KÀÇÁÓ4HÓ$IÐ!äÐ0´)Ô<Ø)×:Ñ:×?Ñ?×HÑHÐL\Ò\Ü+Ð,=×,CÑ,CÓDÐLà,×:Ñ:Ü)Ð*:Ó;Ð<Ð?P×?VÑ?VÑVð ;ó ð ð �4‰4”9×'Ñ'Ñ'Ü×)Ñ)¨!¯$©$Ñ/ˆFØœj×0Ñ0Ñ0°KÄ:×CSÑCSÑ4SØ&*§m¡mØØ'ØŸ™ØØ"-´×1CÑ1CÐ"Cð '4ó 'Ñ#�™ð ¤
× 1Ñ 1Ñ1Ø&*§m¡mä×0Ñ0°Ñ8Ø"Ÿk™k¨!¯'©'Ó2ØŸ™ØØ"'ð '4ó 'Ñ#�™ô ˜[Ô)Ø'ˆAŒMØˆMäÐ!2°1·4±4°&Ð9Ó:Ð:rí   c                ó˜  — d}t        |j                  |j                  dd |j                  «      D �]ê  \  }}}| j                  |«      }|dk(  s|dk(  �r| j	                  |«      }|€| j                  |«      }t        |«      }|g}t        |t        «      rt        |j                  «       «      }| j                  «       }	g }
g }d}d}|D �]î  }| j                  j                  d¬«      5 }| j                  d||gt        g||¬	«      \  }}| j                  j!                  |«      }ddd«       t        |t"        «      rd}Œwj%                  «       rý| j'                  |«      rì| j                  j                  d¬«      5 }| j                  j)                  ||«      \  }}ddd«       j%                  «       r-| j                  j+                  |j-                  «       «       d}�Œt/        |gt0        j                  gdg| j                  «       | j3                  d
«      «      }|j4                  j7                  |«       |j7                  «       �Œ„|j%                  «       s0r.|
j7                  |«       |j4                  j7                  «       �ŒÄ| j                  j+                  |j-                  «       «       d}�Œñ |�sA|�s>t        j8                  |«      }t;        ||«      �s|
s | j                  j=                  d|||«       �nút        j8                  |
«      }| j                  j>                  �sÎ| jA                  |||d¬«      �r¸| j                  jA                  ||d|«       �n˜|t        jB                  v röt        jB                  |   }tE        | j                  jF                  «      5 }| jI                  ||||d¬«      \  }	}|j4                  j7                  |«       ddd«       j%                  «       �s|dv �r| j                  |«      }| j                  j>                  �sÙ| jA                  ||«      �rÆtK        |«      }tK        |«      }| j                  jA                  ||d|«       �n�|dk(  s|dk(  �rw| j                  |«      }| j                  «       }	| j                  j>                  �s#| jA                  ||d¬«      �rt        |tL        «      r]t        |jN                  tP        «      rC|jN                  jR                  s-t        t        |jN                  jT                  «      tV        «      s¡t        |tL        «      r]t        |jN                  tP        «      rC|jN                  jR                  s-t        t        |jN                  jT                  «      tV        «      s4tK        |«      }tK        |«      }| j                  jA                  ||d|«       |j4                  j7                  d«       ntY        d|› �«      ‚|€	}�ŒÕt[        j\                  |	«      }�Œí |€J ‚|S # 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 comparison expression.

        Comparison expressions are type checked consecutive-pair-wise
        That is, 'a < b > c == d' is check as 'a < b and b > c and c == d'
        Nr  Úinznot inFTrÏ  Ú__contains__)rI  r  r�  r�  r^  r¬  r„  )Úoriginal_containerÚprefer_literalÚ	container)r5  )z==z!=ÚequalityÚiszis not)Úidentity_checkÚidentityzUnknown comparison operator )/rä  Úoperandsr   rs  Úfind_partial_type_ref_fast_pathrÍ   rø   rÈ   rð  r  Ú	bool_typer  rO  Úcheck_method_call_by_namer9   r  Úanalyze_container_item_typerº   rš  rz  Ú-analyze_iterable_item_type_without_expressionré  rê  r­   r   rQ  Úmethod_typesrù  r  rŒ   Úunsupported_operand_typesÚcan_skip_diagnosticsÚdangerous_comparisonr>  r$   Úerrorsr?  rº  r_   r+  r}   rÒ  r7  r¬   rB  r   Ú
join_types)r!  r,  r-  r  r  ÚoperatorrC  Ú
right_typeÚ
item_typesrë  Úcontainer_typesÚiterable_typesÚ
failed_outÚencountered_partial_typerg  Úcontainer_errorsr$  rA  Ú	cont_typeÚiterable_errorsÚitertypeÚiterable_typeÚcontainer_typerI  rø  s                            rî   Úvisit_comparison_exprz'ExpressionChecker.visit_comparison_exprc  s�  € ð #ˆô &)¨¯©°Q·Z±ZÀÀ°^ÀQÇ[Á[Ó%Qó X	=Ñ!ˆD�%˜ØŸ™ DÓ)ˆIà˜4Ò 8¨xÓ#7ð "×AÑAÀ%ÓH�
ØÐ%Ø!%§¡¨UÓ!3�Jä,¨ZÓ8�
Ø.8¨\�
Ü˜j¬)Ô4Ü!% j×&?Ñ&?Ó&AÓ!B�Jà!Ÿ^™^Ó-�
à.0�Ø-/�Ø"�
Ø+0Ð(à!+ó 3*�Ið Ÿ™×/Ñ/ÀTÐ/ÓJð TÐN^Ø)-×)GÑ)GØ#1Ø&/Ø"& Ü'. iØ$%Ø*4ð *Hó *™˜˜;ð %)§H¡H×$HÑ$HÈÓ$S˜	÷Tô " )¬[Ô9à37Ð0Øà(×7Ñ7Ô9ð ×-Ñ-¨iÔ8ð "ŸX™X×3Ñ3ÈÐ3ÓNð ÐRaØ*.¯(©(×*`Ñ*`Ø )¨1ó+™K˜A˜x÷ð +×9Ñ9Ô;Ø ŸH™H×/Ñ/°×0OÑ0OÓ0QÔRØ)-šJä*6Ø!* Ü!&§¡ Ø!% Ø $§¡Ó 0Ø $§¡Ð0CÓ Dó+˜Kð ŸN™N×1Ñ1°+Ô>Ø*×1Ñ1°(Ö;Ø-×<Ñ<Ô>Á9Ø'×.Ñ.¨yÔ9ØŸ™×-Ñ-¨kÖ:àŸ™×+Ñ+Ð,<×,LÑ,LÓ,NÔOØ%)š
ðg3*òj 0º
Ü$-×$8Ñ$8¸Ó$H�MÜ% i°Õ?Ù.Ø ŸH™H×>Ñ>¸tÀYÐPZÐ\]Ö^ä-6×-AÑ-AÀ/Ó-R˜NØ#'§8¡8×#@Ó#@ÀT×E^ÑE^Ø )Ø .Ø3=Ø/4ð	 F_õ Fð !%§¡× =Ñ =Ø$-¨~¸{ÈAö!"ð œY×1Ñ1Ñ1Ü"×-Ñ-¨hÑ7�ä! $§(¡(§/¡/Ó2ð 7°aØ.2¯m©mØ 	¨5°!À4ð /<ó /Ñ+�J ð —N‘N×)Ñ)¨+Ô6÷	7ð ×'Ñ'Õ)¨h¸,Ò.FØ!%§¡¨UÓ!3�JØŸ8™8×8Ó8¸T×=VÑ=VØ! :õ>ô %8¸	Ó$B˜	Ü%8¸Ó%D˜
ØŸ™×5Ñ5°iÀÈZÐYZÖ[à˜TÒ! X°Ó%9Ø!Ÿ[™[¨Ó/�
Ø!Ÿ^™^Ó-�
àŸ™×5Ó5Ø×1Ñ1°)¸ZÐX\Ð1Õ]ô # 4¬Ô2Ü& t§y¡y´#Ô6Ø $§	¡	× 5Ò 5Ü&¤°t·y±y·~±~Ó'FÌÔPô # 5¬(Ô3Ü& u§z¡z´3Ô7Ø %§
¡
× 6Ò 6Ü&¤°u·z±z·±Ó'GÌÔQô !4°IÓ >�IÜ!4°ZÓ!@�JØ—H‘H×1Ñ1°)¸ZÈÐUVÔWØ—‘×%Ñ% dÕ+ä"Ð%AÀ(ÀÐ#LÓMÐMð ˆ~Ø#’äŸ™¨°Ó<’ðqX	=ðt Ð!Ð!Ð!Øˆ÷wTñ Tú÷4ñ ú÷X7ñ 7ús$   Ã*<X%Å> X2Î,5X?Ø%X/Ø2X<Ø?Y		c                ó  — t        |t        «      syt        |j                  t        «      r_| j	                  |j                  |«      }t        |t
        «      r3|j                  �'| j                  j                  |t        |«      «       |S y)zÌIf expression has a partial generic type, return it without additional checks.

        In particular, this does not generate an error about a missing annotation.

        Otherwise, return None.
        N)
rø   rg   r+  r}   r4  rº   r7  r  r·  rŸ   )r!  rŸ  r-  s      rî   rV  z1ExpressionChecker.find_partial_type_ref_fast_path
  sj   € ô ˜$¤Ô(ØÜ�d—i‘i¤Ô%Ø×)Ñ)¨$¯)©)°TÓ:ˆFÜ˜&¤+Ô.°6·;±;Ð3JØ—‘×#Ñ# DÔ*<¸VÓ*DÔEØ�Ørí   )rN  Ú
seen_typesrO  rS  c               óÂ  — | j                   j                  j                  sy|€
t        «       }||f|v ry|j	                  ||f«       t        ||f«      \  }}t        |d«      st        |d«      r|sy|rt        |«      }t        |«      }| j                   j                  j                  «       ry| j                   j                  j                  r!t        |t        «      r2t        |t        «      r"yt        |t        «      st        |t        «      ryt        |t        «      r6t        |t        «      r&t        |«      }t        |«      }t        ||f«      \  }}|rt        |«      rt        |«      ryt        |t         «      �r½t        |t         «      �r¬|j"                  j$                  }|j"                  j$                  }|t&        v ri|t&        v ra| j                   j)                  d«      }	t+        ||	«      }t+        ||	«      }| j-                  |j.                  d   |j.                  d   |¬«      S |j"                  j1                  d«      r¬|j"                  j1                  d«      r‘| j                   j)                  d«      }
t+        ||
«      }t+        ||
«      }| j-                  |j.                  d   |j.                  d   |¬«      xs. | j-                  |j.                  d   |j.                  d   |¬«      S |dv r3||k(  r.| j-                  |j.                  d   |j.                  d   |¬«      S |t2        v r	|t2        v ryt        |t4        «      rEt        |t4        «      r5t        |j6                  t8        «      rt        |j6                  t8        «      ryt        |t4        «      rOt        |t         «      r?|j:                  j"                  j$                  d	k(  r|j"                  j1                  d
«      ryt        |t4        «      rOt        |t         «      r?|j:                  j"                  j$                  d	k(  r|j"                  j1                  d
«      ryt=        ||d¬«       S )a  Check for dangerous non-overlapping comparisons like 42 == 'no'.

        The original_container is the original container type for 'in' checks
        (and None for equality checks).

        Rules:
            * X and None are overlapping even in strict-optional mode. This is to allow
            'assert x is not None' for x defined as 'x = None  # type: str' in class body
            (otherwise mypy itself would have couple dozen errors because of this).
            * Optional[X] and Optional[Y] are non-overlapping if X and Y are
            non-overlapping, although technically None is overlap, it is most
            likely an error.
            * Any overlaps with everything, i.e. always safe.
            * Special case: b'abc' in b'cde' is safe.
        FÚ__eq__ztyping.AbstractSetr   )rp  r  r  )rO  rÃ  râ   rã   )Úignore_promotions)r  r  Ústrict_equalityrd  rh  rÎ   rœ   rº  r¬  Ú!is_unreachable_warning_suppressedÚstrict_equality_for_nonerø   rµ   rÈ   r×   Úhas_bytes_componentr²   r7  r>  rà   r!  r1   r^  r�  r   rä   r³   r¹  rÂ  r…  r2   )r!  r  r  rN  rp  rO  rS  Ú	left_nameÚ
right_nameÚabstract_setÚabstract_maps              rî   r^  z&ExpressionChecker.dangerous_comparison  s²  € ð2 �x‰x×Ñ×/Ò/ØàÐÜ›ˆJØ�%ˆ=˜JÑ&ØØ�‰˜˜e�}Ô%ä&¨¨e }Ó5‰ˆˆeô " $¨Ô1Ô5JÈ5ÐRZÔ5[Ù Øáô
 ' tÓ,ˆDÜ'¨Ó.ˆEà�8‰8�?‰?×<Ñ<Ô>ð Ø�8‰8×Ñ×4Ò4Ü˜$¤Ô)¬j¸ÄÔ.IØÜ˜œhÔ'¬:°e¼XÔ+FØÜ�dœIÔ&¬:°e¼YÔ+GÜ" 4Ó(ˆDÜ# EÓ*ˆEÜ*¨D°%¨=Ó9‰KˆD�%áÜ#Ð$6Ô7Ü# DÔ)ð
 Ü�dœHÕ%¬*°U¼HÕ*EàŸ	™	×*Ñ*ˆIØŸ™×,Ñ,ˆJàÔ8Ñ8ØÔ"=Ñ=à#Ÿx™x×7Ñ7Ð8LÓM�Ü0°°|ÓD�Ü1°%¸ÓF�Ø×0Ñ0Ø—I‘I˜a‘L %§*¡*¨Q¡-¸Jð 1ó ð ð —‘×#Ñ#Ð$4Ô5¸%¿*¹*×:MÑ:MÐN^Ô:_à#Ÿx™x×7Ñ7Ð8HÓI�Ü0°°|ÓD�Ü1°%¸ÓF�Ø×0Ñ0Ø—I‘I˜a‘L %§*¡*¨Q¡-¸Jð 1ó ò cà×.Ñ.¨t¯y©y¸©|¸U¿Z¹ZÈ¹]ÐWaÐ.Óbðcð ÐAÑAÀjÐT]ÒF]Ø×0Ñ0Ø—I‘I˜a‘L %§*¡*¨Q¡-¸Jð 1ó ð ð Ô9Ñ9¸jÜ+ñ?ð Ü�dœKÔ(¬Z¸¼{Ô-KÜ˜$Ÿ*™*¤dÔ+´
¸5¿;¹;ÌÔ0MàÜ�dœKÔ(¬Z¸¼xÔ-Hà�}‰}×!Ñ!×*Ñ*Ð.>Ò>À5Ç:Á:×CVÑCVØ$ôDð Ü�eœ[Ô)¬j¸¼xÔ.Hà�~‰~×"Ñ"×+Ñ+Ð/?Ò?ÀDÇIÁI×DVÑDVØ$ôEð Ü'¨¨eÀuÔMÐMÐMrí   c                ó  — |xs |}|xs |}t        |«      }t        |t        «      r| j                  ||||||«      S t	        |||ddd||| j
                  | j                  «       ¬«
      }| j                  ||||||«      S )a  Type check a call to a named method on an object.

        Return tuple (result type, inferred method type). The 'original_type'
        is used for error messages. The self_type is to bind self in methods
        (see analyze_member_access for more details).
        FT)rT  rª  r«  r¬  r®  r  r­  )rÍ   rø   rÈ   Úcheck_union_method_call_by_namer   r  rZ  Úcheck_method_call)	r!  rI  r  r�  r�  r^  r¬  r®  rA  s	            rî   rX  z+ExpressionChecker.check_method_call_by_name�  s¡   € ð  &Ò2¨ˆØÒ* ˆ	ä# IÓ.ˆ	Ü�i¤Ô+Ø×7Ñ7Ø˜	 4¨°G¸]óð ô ,ØØØØØØØ'ØØ—‘Ø#×6Ñ6Ó8ô
ˆð ×%Ñ% f¨i¸ÀdÈIÐW^Ó_Ð_rí   c           
     ó4  — g }g }|j                  «       D ]`  }	| j                  j                  «       5  | j                  ||	||||«      \  }
}ddd«       |j	                  
«       |j	                  «       Œb t        |«      t        |«      fS # 1 sw Y   ŒCxY w)a  Type check a call to a named method on an object with union type.

        This essentially checks the call using check_method_call_by_name() for each
        union item and unions the result. We do this to allow plugins to act on
        individual union items.
        N)r  r  r  rX  rù  r¤   )r!  rI  r  r�  r�  r^  r¬  r°  Úmeth_resr°  rÂ  Ú	meth_items               rî   r}  z1ExpressionChecker.check_union_method_call_by_nameÄ  s    € ð ˆØ!ˆØ×+Ñ+Ó-ò 	'ˆCð —‘×,Ñ,Ó.ñ Ø"&×"@Ñ"@Ø˜C  y°'¸=ó#‘��i÷ð �J‰J�tÔØ�O‰O˜IÕ&ð	'ô % SÓ)Ô+@ÀÓ+JÐJÐJ÷ð ús   ²BÂB	c                óŽ   — | j                  ||«      }|�|nd}| j                  ||||||¬«      }| j                  ||||||¬«      S )zŒType check a call to a method with the given name and type on an object.

        Return tuple (result type, inferred method type).
        NrÑ  r¤  )r£  r”  r™  )	r!  rÄ  r  rA  r�  r�  r^  r6   rR  s	            rî   r~  z#ExpressionChecker.check_method_callà  sp   € ð ×,Ñ,¨Y¸ÓDˆØ#0Ð#<‘iÀ$ˆð ×0Ñ0Ø˜;¨¨i¸Èkð 1ó 
ˆð �‰ØØØØØ'Ø!ð ó 
ð 	
rí   c                óü   — t        ||«      sy| j                  j                  «       5 }t        ||ddd||| j                  | j                  «       ¬«	      }|j                  «       rdn|cddd«       S # 1 sw Y   yxY w)zULooks up the given operator and returns the corresponding type,
        if it exists.NFT)	r:  r°  rT  rª  r«  r¬  r^  r  r­  )r   r  rO  r   r  rZ  rš  )r!  Úop_namer  r^  rø  rµ  s         rî   Úlookup_operatorz!ExpressionChecker.lookup_operatorþ  s|   € ô
 ˜I wÔ/Øà�X‰X×#Ñ#Ó%ð 	:¨Ü*ØØØØØ Ø'ØØ—H‘HØ#'×#:Ñ#:Ó#<ô
ˆFð ×+Ñ+Ô-‘4°6÷	:÷ 	:ò 	:ús   ¨A A2Á2A;c                óŒ   — |j                   j                  D ]+  }|j                  j                  |«      sŒ|j                  c S  y)a¹  Returns the name of the class that contains the actual definition of attr_name.

        So if class A defines foo and class B subclasses A, running
        `get_class_defined_in(B, "foo")` would return the full name of A.

        However, if B were to override and redefine foo, that method call would
        return the full name of B instead.

        If the attr name is not present in the given class or its MRO, returns None.
        N)r7  rý  re  rË  r>  )r!  r°  rí  Úclss       rî   Úlookup_definerz ExpressionChecker.lookup_definer  s:   € ð —8‘8—<‘<ò 	$ˆCØ�y‰y�}‰}˜YÕ'Ø—|‘|Ò#ð	$ð rí   c           
     ó*  — t        |«      }t        |«      }t        |t        «      rt        t        j                  |¬«      }||fS t        |t        «      rt        t        j                  |¬«      }||fS t
        j                  |   }| j                  |||«      }	| j                  |||«      }
|t
        j                  v rt        ||«      r||	||fg}n¬t        |t        «      rwt        |t        «      rg| j                  ||«      | j                  ||«      k7  r[|j                  j                  �,|j                  j                  j                  |j                  urt        ||«      r||
||f||	||fg}n||	||f||
||fg}|D ����cg c]  \  }}}}|€Œ||||f‘Œ }}}}}g }g }|D ]Œ  \  }}}}| j                  j!                  d¬«      5 }| j#                  ||||gt$        g|«      }d d d «       j'                  «       r1|j)                  |j+                  «       «       |j)                  «       ŒŠc S  t        |t        «      r|j                  j,                  s&t        |t        «      r3|j                  j,                  rt        t        j.                  «      }||fS |sƒ| j                  j!                  d¬«      5 }| j1                  |||gt$        g|«      }d d d «       j'                  «       r1|j)                  |j+                  «       «       |j)                  «       nS | j                  j3                  |d   «       t5        |«      dk(  r|d   S t        t        j6                  «      }||f}|S c c}}}}w # 1 sw Y   �Œ–xY w# 1 sw Y   Œ±xY w)Nr  TrÏ  r   r  )rÍ   rø   r¬   rÀ   r  r   r@  r…  Úop_methods_that_shortcutr‹   r²   rˆ  r7  Úalt_promoter‰   r  rO  r~  r9   rš  rù  rê  r×  r3  rX  ré  r‘  r;  )r!  r„  rC  Ú	left_exprrb  Ú
right_exprr^  rò  Úrev_op_nameÚleft_opÚright_opÚvariants_rawÚnar6  Úobjr  Úvariantsr_  r  r:  rI  Úlocal_errorsr-  Ú	error_anys                           rî   Úcheck_op_reversiblez%ExpressionChecker.check_op_reversible$  s  € ô $ IÓ.ˆ	Ü$ ZÓ0ˆ
ô �i¤Ô)Üœy×9Ñ9ÀiÔPˆHØ˜XÐ%Ð%Ü�j¤'Ô*Üœy×9Ñ9ÀjÔQˆHØ˜XÐ%Ð%ô
  ×2Ñ2°7Ñ;ˆà×&Ñ& w°	¸7ÓCˆØ×'Ñ'¨°ZÀÓIˆð ”i×8Ñ8Ñ8¼\È)ÐU_Ô=`ð % g¨y¸*ÐEÐF‰Lô   	¬8Ô4¼ÀJÔPXÔ9Yà×'Ñ'¨	°7Ó;Ø×*Ñ*¨:°{ÓCòDð "Ÿ™×2Ñ2Ð:Ø$Ÿ>™>×5Ñ5×:Ñ:À*Ç/Á/ÑQô
 " *¨iÔ8ð ˜h¨
°IÐ>Ø˜' 9¨jÐ9ð‰Lð ˜' 9¨jÐ9Ø˜h¨
°IÐ>ðˆLð BN×`Ñ`Ñ+=¨B°°C¸ÐQSÑQ_�R˜˜S #Ò&Ð`ˆÓ`ð ˆØˆØ&.ò 	Ñ"ˆD�&˜#˜sØ—‘×'Ñ'¸TÐ'ÓBð ^ÀlØ×/Ñ/°°c¸6ÀCÀ5Ì7È)ÐU\Ó]�÷^à×*Ñ*Ô,Ø—‘˜l×:Ñ:Ó<Ô=Ø—‘˜vÕ&à’ð	ô �y¤(Ô+°	·±×0NÒ0NÜ�z¤8Ô,°·±×1PÒ1Päœy×5Ñ5Ó6ˆHØ˜XÐ%Ð%ñ Ø—‘×'Ñ'¸TÐ'ÓBð ÀlØ×7Ñ7Ø˜Y¨¨´w°iÀó�÷ð
 ×*Ñ*Ô,Ø—‘˜l×:Ñ:Ó<Ô=Ø—‘˜vÕ&ð �à�‰×Ñ˜F 1™IÔ&Üˆw‹<˜1ÒØ˜1‘:Ðä¤	× 4Ñ 4Ó5ˆIØ 	Ð)ˆFØˆMùõg a÷^ñ ^ú÷,ð ús$   ÆM4
ÆM4
ÇM<Ê=N	Í<N	Î	Nc                ó‚  — |�r|g}t        |«      }t        |t        «      r"t        t	        |j                  «       «      «      }| j                  |«      }g }g }	| j                  j                  «       5 }
|D ]I  }| j                  ||t        ||¬«      |||¬«      \  }}|j                  |«       |	j                  |«       ŒK 	 ddd«       
j                  «       st        |«      }t        |	«      }||fS ||fg}t        |«      }t        |t        «      r3t	        |j                  «       «      D �cg c]  }|t        ||¬«      f‘Œ }}g }g }	| j                  j                  d¬«      5 }
|D ]S  }|D ]L  \  }}| j                  ||t        ||¬«      |||¬«      \  }}|j                  |«       |	j                  |«       ŒN ŒU 	 ddd«       |
j                  «       �r| j                  j                  |
j                  «       «       |
j                  «       d   }t        t!        «       «      }|j"                  |_        |j$                  |_        t'        |«      dk\  r*t'        |«      dk\  r| j                  j)                  |«       nYt'        |«      dk\  r| j                  j+                  d||¬«       n,t'        |«      dk\  r| j                  j+                  d	||¬«       t        |«      }| j-                  t/        |	«      «      }||fS | j1                  |||gt2        g|¬
«      S # 1 sw Y   �ŒaxY wc c}w # 1 sw Y   �ŒtxY w)z‡Type check a binary operation which maps to a method call.

        Return tuple (result type, inferred operator method type).
        r1  )r„  rC  rŒ  rb  r�  r^  NTrÏ  r1  r  ÚLeftÚRight)rI  r  r�  r�  r^  )rÍ   rø   rÈ   rð  rÌ   r  rs  r  rO  r—  rr   rù  rš  r¤   ré  rê  rµ   r@  rA  r‘  Ú"warn_both_operands_are_from_unionsÚwarn_operand_was_from_unionr¨  rÎ   rX  r9   )r!  rI  r  r  r^  r5  Úleft_variantsrb  Úall_resultsÚall_inferredr•  Úleft_possible_typer-  r  Úresults_finalÚinferred_finalÚright_variantsrÂ  Úright_possible_typer�  r�  Úrecent_contexts                         rî   r?  zExpressionChecker.check_op¶  sS  € ò Ø&˜KˆMÜ'¨	Ó2ˆIÜ˜)¤YÔ/Ü $Ô%:¸9×;SÑ;SÓ;UÓ%VÓ W�ØŸ™ SÓ)ˆJð
 ˆKØˆLà—‘×'Ñ'Ó)ð 2¨\Ø*7ò 
2Ð&Ø'+×'?Ñ'?Ø &Ø"4Ü"*Ð+=ÀwÔ"OØ#-Ø#&Ø 'ð (@ó (Ñ$�F˜Hð  ×&Ñ& vÔ.Ø ×'Ñ'¨Õ1ñ
2÷2ð  ×.Ñ.Ô0Ü 5°kÓ B�Ü!6°|Ó!D�Ø$ nÐ4Ð4ð  *¨3Ð/Ð0ˆNÜ(¨Ó4ˆJÜ˜*¤iÔ0ô !6°j×6OÑ6OÓ6QÓ Rö"àð œ8 D°'Ô:Ò;ð"�ð "ð
 ˆKØˆLà—‘×'Ñ'¸TÐ'ÓBð 6ÀlØ*7ò 6Ð&Ø;Iò 
6Ñ7Ð+¨ZØ+/×+CÑ+CØ$*Ø&8Ü&.Ð/AÈ7Ô&SØ':Ø'1Ø$+ð ,Dó ,Ñ(˜ ð $×*Ñ*¨6Ô2Ø$×+Ñ+¨HÕ5ñ
6ñ6÷6ð ×*Ñ*Õ,Ø—‘×#Ñ# L×$@Ñ$@Ó$BÔCà"×2Ñ2Ó4°RÑ8�Ü!)¬(«*Ó!5�Ø&)§h¡h�Ô#Ø(+¯
©
�Ô%Ü�}Ó%¨Ò*¬s°>Ó/BÀaÒ/GØ—H‘H×?Ñ?ÀÕOÜ˜Ó'¨1Ò,Ø—H‘H×8Ñ8¸ÀÐTbÐ8ÕcÜ˜Ó(¨AÒ-Ø—H‘H×8Ñ8Ø °^ð 9ô ô 2°+Ó>ˆMØ!×=Ñ=Ô>NÈ|Ó>\Ó]ˆNØ  .Ð0Ð0à×1Ñ1ØØ#Ø�UÜ"˜)Øð 2ó ð ÷[2ñ 2üò@"÷6ñ 6ús    Á3AL"Ä0L/Å(AL4Ì"L,Ì4L>c                ór  — | j                   d   }| j                  |j                  |«      }t        |d«      }|j                  dv sJ ‚|j
                  r|j                  t        «       ii }}n”|j                  ri |j                  t        «       i}}no|j                  dk(  r)| j                  j                  |j                  «      \  }}n7|j                  dk(  r(| j                  j                  |j                  «      \  }}t        j                  j                  «      }t        j                  | j                  j                   j"                  v r>|r<|j
                  s0| j$                  j'                  |j                  |j                  «       t        j                  j                  «      }| j                  j)                  «       r>|r<|j                  s0| j$                  j+                  |j                  |j                  «       | j-                  ||j                  | j/                  |«      «      }	|r|r
t        «       S |r|S |r|	S |j                  dk(  rt1        |«      }
|j2                   }n'|j                  dk(  rt5        |«      }
|j6                   }t9        
t        «      r|	S r|S t;        |
|	g«      S )z/Type check a boolean operation ('and' or 'or').r1  rY  )r-  r.  r-  r.  )r  rs  r  r¦   r6  Úright_alwaysrÇ   Úright_unreachabler  r  Úfind_isinstance_checkr’  r“  Úis_unreachable_maprò  ÚREDUNDANT_EXPRr  Úenabled_error_codesr  Úredundant_left_operandÚ should_report_unreachable_issuesÚunreachable_right_operandÚanalyze_cond_branchÚ_combined_contextrž   Úcan_be_truer¥   Úcan_be_falserø   r¤   )r!  r,  rJ  rC  Úexpanded_left_typeÚleft_mapÚ	right_mapÚleft_unreachabler¨  rb  Úrestricted_left_typeÚresult_is_lefts               rî   r7  z"ExpressionChecker.check_boolean_op%  s:  € ð ×Ñ Ñ#ˆØ—K‘K §¡¨Ó,ˆ	Ü<¸YÈÓXÐà�t‰t�}Ñ$Ð$Ð$ð �>Š>Ø#$§6¡6¬?Ó+<Ð"=¸r�i‰HØ× Ò Ø"$ q§w¡w´Ó0AÐ&B�i‰HØ�T‰T�UŠ]Ø"&§(¡(×"@Ñ"@ÀÇÁÓ"HÑˆI‘xØ�T‰T�TŠ\Ø"&§(¡(×"@Ñ"@ÀÇÁÓ"HÑˆH�iô  Ÿ<™<×:Ñ:¸8ÓDÐä× Ñ  D§H¡H×$4Ñ$4×$HÑ$HÑHÙ à—N’Nà�H‰H×+Ñ+¨A¯D©D°!·&±&Ô9ä ŸL™L×;Ñ;¸IÓFÐà�H‰H×5Ñ5Ô7Ù!à×'Ò'à�H‰H×.Ñ.¨q¯t©t°Q·W±WÔ=à×-Ñ-Ø�q—w‘w × 6Ñ 6Ð7IÓ Jó
ˆ
ñ Ñ 1Ü"Ó$Ð$áàÐÙàÐà�4‰4�5Š=Ü#-Ð.@Ó#AÐ Ø!3×!?Ñ!?Ð?‰NØ�T‰T�TŠ\Ü#,Ð-?Ó#@Ð Ø!3×!@Ñ!@Ð@ˆNäÐ*¬OÔ<àÐÙàÐä(Ð*>À
Ð)KÓLÐLrí   c                óN  — | j                  |j                  «      }t        || j                  d«      «      r+| j                  |j                  | j
                  d   ¬«      }n| j                  |j                  «      }| j                  d||j                  |«      \  }}||_        |S )zzType check an expression of form '[...] * e'.

        Type inference is special-cased for this common construct.
        r  r1  r  Ú__mul__)rs  r  rŒ   rQ  r  r  r?  rA  )r!  r,  rb  rC  r-  rA  s         rî   r8  z%ExpressionChecker.check_list_multiplyq  s‡   € ð
 —[‘[ §¡Ó)ˆ
Ü�j $§/¡/°.Ó"AÔBð Ÿ™ A§F¡F¸×9JÑ9JÈ2Ñ9N˜ÓO‰IàŸ™ A§F¡FÓ+ˆIØ"Ÿm™m¨I°yÀ!Ç'Á'È1ÓMÑˆ�Ø#ˆŒØˆrí   c                ó.  — | j                  |j                  «      }| j                  j                  j                  }| j                  j                  |j                  |j                  «       | j                  j                  j                  |k7  r| j                  xj                  dz  c_        | j                  j                  |«       t        |«      s&| j                  j                  |j                  |«       | j                  |j                  «       |S rÕ  )rs  r¹  r  r¬  ÚversionÚcheck_assignmentrv  Úassignment_expression_effectÚcheck_finalÚhas_uninhabited_componentr·  rV  )r!  r,  r¹  Úbinder_versions       rî   Úvisit_assignment_exprz'ExpressionChecker.visit_assignment_expr�  s¹   € Ø—‘˜AŸG™GÓ$ˆØŸ™Ÿ™×0Ñ0ˆØ�‰×!Ñ! !§(¡(¨A¯G©GÔ4Ø�8‰8�?‰?×"Ñ" nÒ4Ø�H‰H×1Ò1°QÑ6Õ1Ø�‰×Ñ˜QÔÜ(¨Ô/ð �H‰H×Ñ §¡¨%Ô0Ø×,Ñ,¨Q¯X©XÔ6Øˆrí   c                ó2  — | j                  |j                  «      }|j                  }|dk(  r8| j                  «       }| j                  j                  ||j                  «       |S t        j                  |   }| j                  ||g g |«      \  }}||_	        |S )z7Type check an unary operation ('not', '-', '+' or '~').Únot)
rs  rŸ  r6  rW  r  Úcheck_for_truthy_typer   Úunary_op_methodsrX  rA  )r!  r,  Úoperand_typer6  r-  rI  rA  s          rî   Úvisit_unary_exprz"ExpressionChecker.visit_unary_expr�  s�   € à—{‘{ 1§6¡6Ó*ˆØ�T‰TˆØ�Š;ØŸ>™>Ó+ˆFØ�H‰H×*Ñ*¨<¸¿¹Ô@ð
 ˆô ×/Ñ/°Ñ3ˆFØ"&×"@Ñ"@ÀÈÐWYÐ[]Ð_`Ó"aÑˆF�KØ'ˆAŒMØˆrí   c                óÒ   — | j                  |«      }| j                  ||«      }t        |«      }| j                  «       r(t	        |t
        «      r|j                  �|j                  }|S )zgType check an index expression (base[index]).

        It may also represent type application.
        )Úvisit_index_expr_helperr)  rÍ   rZ  rø   r²   r[  )r!  r,  r-  Úp_results       rî   Úvisit_index_exprz"ExpressionChecker.visit_index_exprœ  sb   € ð
 ×-Ñ-¨aÓ0ˆØ×-Ñ-¨a°Ó8ˆÜ" 6Ó*ˆà×#Ñ#Ô%Ü˜8¤XÔ.Ø×)Ñ)Ð5à×.Ñ.ˆFØˆrí   c                óª   — |j                   r| j                  |j                   «      S | j                  |j                  «      }| j                  ||«      S rñ   )rp  rs  rw  Úvisit_index_with_type)r!  r,  rC  s      rî   rË  z)ExpressionChecker.visit_index_expr_helper¬  sA   € Ø�:Š:à—;‘;˜qŸz™zÓ*Ð*Ø—K‘K §¡Ó'ˆ	Ø×)Ñ)¨)°QÓ7Ð7rí   c           
     óê  — |j                   }|xs |}t        |«      }| j                  |«       t        |t        «      r(t        d„ |j                  D «       «      rt        |i «      }t        |t        «      r@|xs |}t        |j                  «       D �cg c]  }| j                  |||«      ‘Œ c}d¬«      S t        |t        «      �r,| j                  j                  «       �rt        |t        «      r| j                  ||«      S | j!                  |«      }|�Êg }|D ]¸  }	| j#                  ||	«      }
|
�|j%                  |
«       Œ)| j                  j'                  t(        j*                  |«       t        d„ |j                  D «       «      r0| j-                  |«      }| j                  j/                  d|› �|«       t1        t2        j4                  «      c S  t        |«      S | j7                  ||«      S t        |t8        «      r| j;                  ||j                   «      d   S t        |t<        «      r�|j?                  «       r�|jA                  «       jB                  r+| jE                  |jA                  «       |j                   |«      S |jA                  «       jF                  s|jA                  «       jH                  dk(  r| jK                  d«      S t        |tL        «      r"| j                  |jO                  «       |||«      S t        |tP        «      r*|jR                  jH                  d	k(  r| jK                  d	«      S | jU                  d
||j                   gtV        g|||¬«      \  }}||_,        |S c c}w )a  Analyze type of an index expression for a given type of base expression.

        The 'original_type' is used for error messages (currently used for union types). The
        'self_type' is to bind self in methods (see analyze_member_access for more details).
        c              3  ó<   K  — | ]  }t        |t        «      –— Œ y ­wrñ   r¿  ró   s     rî   rö   z:ExpressionChecker.visit_index_with_type.<locals>.<genexpr>Æ  s   è ø€ ò 4
Ø+-ŒJ�rœ:×&ñ4
ùr  F)Úcontract_literalsc              3  ó<   K  — | ]  }t        |t        «      –— Œ y ­wrñ   r¿  r  s     rî   rö   z:ExpressionChecker.visit_index_with_type.<locals>.<genexpr>å  s   è ø€ ÒR¸Qœz¨!¬Z×8ÑRùr  zVariadic tuple can have length r   r,  ztypes.GenericAliasrV  Ú__getitem__)r¬  r®  )-rY  rÍ   rs  rø   r¼   r¤  rû   r&   rÈ   r¤   r  rÏ  r  r8  rk   Úvisit_tuple_slice_helperÚtry_getting_int_literalsÚvisit_tuple_index_helperrù  rÙ  r   ÚTUPLE_INDEX_OUT_OF_RANGEÚmin_tuple_lengthrv  r¬   rÀ   r;  Únonliteral_tuple_index_helperr¿   Úvisit_typeddict_index_exprr±   rÀ  rÖ  r¸  Úvisit_enum_index_exprr*  r>  rQ  rÅ   Úvalues_or_boundr²   r7  rX  r9   rA  )r!  rC  r,  r¬  r®  rY  r°  ÚnsÚoutrl  rÂ  Úmin_lenr-  rA  s                 rî   rÏ  z'ExpressionChecker.visit_index_with_type³  s  € ð —‘ˆØÒ* ˆ	Ü# IÓ.ˆ	ð 	�‰�EÔä�i¤Ô+´ñ 4
Ø1:·±ô4
ô 1
ô $ I¨rÓ2ˆIä�i¤Ô+Ø)Ò6¨YˆMä(ð  )×7Ñ7Ó9öàð ×.Ñ.¨s°A°}ÕEòð #(ôð ô ˜	¤9Õ-°$·(±(×2NÑ2NÕ2Pô ˜%¤Ô+Ø×4Ñ4°YÀÓFÐFà×.Ñ.¨uÓ5ˆBØˆ~Ø�Øò 	=�AØ×8Ñ8¸ÀAÓF�DØÐ'ØŸ
™
 4Õ(àŸ™Ÿ™Ô&6×&OÑ&OÐQRÔSÜÑRÀ)Ç/Á/ÔRÔRØ&*×&;Ñ&;¸IÓ&F˜GØ ŸH™HŸM™MÐ,KÈGÈ9Ð*UÐWXÔYÜ&¤y×';Ñ';Ó<Ò<ð	=ô -¨SÓ1Ð1à×9Ñ9¸)ÀUÓKÐKÜ˜	¤=Ô1Ø×2Ñ2°9¸a¿g¹gÓFÀqÑIÐIÜ˜	¤<Ô0°Y×5JÑ5JÔ5LØ×$Ñ$Ó&×.Ò.Ø×1Ñ1°)×2GÑ2GÓ2IÈ1Ï7É7ÐTUÓVÐVà×%Ñ%Ó'×1Ò1Ø×(Ñ(Ó*×3Ñ3°ÒFà—‘Ð';Ó<Ð<ä�i¤Ô-Ø×-Ñ-Ø×)Ñ)Ó+¨Q°¸yóð ô ˜	¤8Ô,°·±×1HÑ1HÐLaÒ1aà—?‘?Ð#8Ó9Ð9à"&×"@Ñ"@ØØØ—‘�	Ü�	ØØ+Ø#ð #Aó #ÑˆF�Kð (ˆAŒMØˆMùòss   ÂM0c                ó@  — t        |j                  «      }|€|j                  «       S |j                  |   }t        |t        «      sJ ‚t        |j
                  t        «      r*|j                  «       dz
  |j
                  j                  z   S |j                  «       dz
  S rÕ  )rÊ   rû   Úlengthrø   rÉ   r7  rÄ   rà  )r!  r  Úunpack_indexÚunpacks       rî   rÙ  z"ExpressionChecker.min_tuple_length  s€   € Ü*¨4¯:©:Ó6ˆØÐØ—;‘;“=Ð Ø—‘˜LÑ)ˆÜ˜&¤*Ô-Ð-Ð-Ü�f—k‘kÔ#3Ô4Ø—;‘;“= 1Ñ$ v§{¡{×':Ñ':Ñ:Ð:Ø�{‰{‹}˜qÑ Ð rí   c           
     óº  — t        |j                  «      }|€N|dk  r|t        |j                  «      z  }d|cxk  rt        |j                  «      k  rn y |j                  |   S y |j                  |   }t        |t        «      sJ ‚t        |j                  «      }t        |t        «      rRt        |j                  «      }t        |t        «      sJ ‚|j                  j                  dk(  sJ ‚|j                  d   }n<t        |t        «      sJ ‚|j                  j                  dk(  sJ ‚|j                  d   }| j                  |«      |j                  «       z
  dz   }|dk\  r½|| j                  |«      k\  rCt        t        |«      t        «      r)t        j                   |g|j                  |dz   d  z   «      S y ||k  r|j                  |   S t        j                   |g|j                  |dz   t#        ||z
  dz   |dz   «       z   |j$                  |j&                  «      S || j                  |«      z  }|dk  r@t        t        |«      t        «      r&t        j                   |j                  d | |gz   «      S y |||z   k\  r|j                  ||z
  dz      S t        j                   |j                  t)        ||«      | |gz   |j$                  |j&                  «      S )Nr   rÃ  r  r  )rÊ   rû   r‘  rø   rÉ   rÍ   r7  rÄ   r¸  r²   r>  r�  rÙ  râ  r¬   rÈ   r  Úmaxr@  rA  rß  )	r!  r  rl  rã  rä  ÚunpackedÚboundÚmiddleÚextra_itemss	            rî   r×  z*ExpressionChecker.visit_tuple_index_helper  s«  € Ü*¨4¯:©:Ó6ˆØÐØ�1ŠuØ”S˜Ÿ™“_Ñ$�Ø�AÔ'œ˜DŸJ™J›Ô'àð —z‘z !‘}Ð$ØØ—‘˜LÑ)ˆÜ˜&¤*Ô-Ð-Ð-Ü" 6§;¡;Ó/ˆÜ�hÔ 0Ô1ô $ H×$8Ñ$8Ó9ˆEÜ˜e¤XÔ.Ð.Ð.Ø—:‘:×&Ñ&Ð*:Ò:Ð:Ð:Ø—Z‘Z ‘]‰Fä˜h¬Ô1Ð1Ð1Ø—=‘=×)Ñ)Ð-=Ò=Ð=Ð=Ø—]‘] 1Ñ%ˆFà×+Ñ+¨DÓ1°D·K±K³MÑAÀAÑEˆØ�Š6Ø�D×)Ñ)¨$Ó/Ò/ô œo¨fÓ5´wÔ?ô %×/Ñ/°°¸4¿:¹:ÀlÐUVÑFVÐFXÐ;YÑ0YÓZÐZØØ�<ÒØ—z‘z !‘}Ð$Ü×'Ñ'Ø�Ø—*‘*˜\¨AÑ-´°A¸±OÀaÑ4GÈÐXYÑIYÓ0ZÐ[ñ\à—	‘	Ø—‘ó	ð ð 	
ˆT×"Ñ" 4Ó(Ñ(ˆØˆqŠ5äœ/¨&Ó1´7Ô;Ü ×+Ñ+¨D¯J©J°}¸Ð,EÈÈÑ,PÓQÐQØØ�˜{Ñ*Ò*Ø—:‘:˜a +™o°Ñ1Ñ2Ð2Ü×#Ñ#Ø�J‰J”s˜1˜lÓ+¨lÐ;¸v¸hÑFÈÏ	É	ÐSW×S^ÑS^ó
ð 	
rí   c           	     óÚ  — d g}d g}d g}|j                   r1| j                  |j                   «      }|€| j                  ||«      S |}|j                  r1| j                  |j                  «      }|€| j                  ||«      S |}|j                  r1| j                  |j                  «      }|€| j                  ||«      S |}g }	t        j                  |||«      D �]  \  }
}}|dk(  r=| j                  j                  d|«       |	j                  | j                  d«      «       ŒJ|j                  |
||| j                  d«      ¬«      }|€„t        |«      }|�2|\  }}t        t        |«      t        «      r| j                  ||«      c S | j                  j                  t         j"                  |«       t        t$        j&                  «      c S |	j                  |«       �Œ t)        |	«      S )Nr   zSlice step cannot be zerorÃ  rÄ  )Úbegin_indexrÖ  rÚ  Ú	end_indexÚstrideÚ	itertoolsÚproductr  rÙ  rù  rQ  ÚslicerÏ   rø   rÍ   r¬   r   Ú!AMBIGUOUS_SLICE_OF_VARIADIC_TUPLErÀ   r;  r¤   )r!  rC  ÚslicÚbeginÚendrî  Ú	begin_rawÚend_rawÚ
stride_rawrû   Úbr,  ÚsrÂ  Úleft_variadicr$  Ú	left_items                    rî   rÕ  z*ExpressionChecker.visit_tuple_slice_helperK  sÅ  € Ø'+ fˆØ%) FˆØ(, vˆà×ÒØ×5Ñ5°d×6FÑ6FÓGˆIØÐ Ø×9Ñ9¸)ÀTÓJÐJØˆEà�>Š>Ø×3Ñ3°D·N±NÓCˆGØˆØ×9Ñ9¸)ÀTÓJÐJØˆCà�;Š;Ø×6Ñ6°t·{±{ÓCˆJØÐ!Ø×9Ñ9¸)ÀTÓJÐJØˆFàˆÜ ×(Ñ(¨°°VÓ<ó 	‰GˆAˆq�!Ø�AŠvØ—‘—‘Ð9¸4Ô@Ø—‘˜TŸ_™_Ð-=Ó>Ô?ØØ—?‘? 1 a¨°T·_±_ÐEUÓ5V�?ÓWˆDØˆ|Ü 1°)Ó <�Ø Ð,Ø#0‘L�A�yÜ!¤/°)Ó"<¼gÔFà#×AÑAÀ)ÈTÓRÒRØ—‘—‘Ô.×PÑPÐRVÔWÜœy×3Ñ3Ó4Ò4Ø�L‰L˜Öð	ô  % UÓ+Ð+rí   c                ó   — t        |t        «      r|j                  gS t        |t        «      rs|j                  dk(  r,|j
                  }t        |t        «      rd|j                  z  gS |j                  dk(  r)|j
                  }t        |t        «      r|j                  gS t        | j                  |«      «      }t        |t        «      r|j                  �|j                  }t        |t        «      r't        |j                  t        «      r|j                  gS t        |t        «      reg }t        |j                  «      D ]I  }t        |t        «      r6t        |j                  t        «      r|j                  |j                  «       ŒI y |S y)aî  If the given expression or type corresponds to an int literal
        or a union of int literals, returns a list of the underlying ints.
        Otherwise, returns None.

        Specifically, this function is guaranteed to return a list with
        one or more ints if one the following is true:

        1. 'expr' is a IntExpr or a UnaryExpr backed by an IntExpr
        2. 'typ' is a LiteralType containing an int
        3. 'typ' is a UnionType containing only LiteralType of ints
        ú-r1  r1  N)rø   rW   r¹  r|   r6  rŸ  rÍ   rs  r²   r[  r³   rÿ  rÈ   rÎ   rû   rù  )r!  rY  Úoperandr°  rß  rÂ  s         rî   rÖ  z*ExpressionChecker.try_getting_int_literalsu  s/  € ô �eœWÔ%Ø—K‘K�=Ð Ü˜œyÔ)Ø�x‰x˜3ŠØŸ*™*�Ü˜g¤wÔ/Ø §¡Ñ.Ð/Ð/Ø�x‰x˜3ŠØŸ*™*�Ü˜g¤wÔ/Ø#ŸM™M˜?Ð*Ü˜dŸk™k¨%Ó0Ó1ˆÜ�cœ8Ô$¨×)=Ñ)=Ð)IØ×&Ñ&ˆCÜ�cœ;Ô'¬J°s·y±yÄ#Ô,FØ—I‘I�;ÐÜ�cœ9Ô%ØˆCÜ(¨¯©Ó3ò  �Ü˜d¤KÔ0´ZÀÇ
Á
ÌCÔ5PØ—J‘J˜tŸz™zÕ*áð	 ð
 ˆJØrí   c                óº   — | j                  d||gt        g|¬«       | j                  |«      }t        |t        «      r| j
                  j                  d|g«      S |S )NrÔ  r1  rÃ  )rX  r9   Úunion_tuple_fallback_itemrø   rk   r  r\  )r!  rC  rY  Úunions       rî   rÚ  z/ExpressionChecker.nonliteral_tuple_index_helper›  sY   € Ø×&Ñ& }°iÀ%ÀÌ7È)Ð]bÐ&Ôcà×.Ñ.¨yÓ9ˆÜ�eœYÔ'Ø—8‘8×.Ñ.Ð/?À%ÀÓIÐIØˆrí   c                ó�  — g }|j                   D ]«  }t        |t        «      rˆt        |j                  «      }t        |t
        «      rt        |j                  «      }t        |t        «      r8|j                  j                  dk(  r|j                  |j                  d   «       Œ•t        ‚|j                  |«       Œ­ t        |«      S )NrÃ  r   )rû   rø   rÉ   rÍ   r7  rÄ   r¸  r²   r>  rù  r�  ÚNotImplementedErrorr¤   )r!  rC  rû   rÂ  r‹  s        rî   r  z+ExpressionChecker.union_tuple_fallback_item£  s¢   € àˆØ—O‘Oò 	#ˆDÜ˜$¤
Ô+Ü /°·	±	Ó :�Ü˜mÔ-=Ô>Ü$3°M×4MÑ4MÓ$N�Mä˜}¬hÔ7Ø%×*Ñ*×3Ñ3Ð7GÒGà—L‘L ×!3Ñ!3°AÑ!6Õ7ä-Ð-à—‘˜TÕ"ð	#ô % UÓ+Ð+rí   c                ó¬  — t        |t        «      r|j                  g}�n&t        | j	                  |«      «      }t        |t
        «      rt        |j                  «      }n|g}g }t        |«      D ]Ó  }t        |t        «      r|j                  �|j                  }t        |t        «      rYt        |j                  t        «      r?|j                  j                  j                  dk7  r|j!                  |j                  «       Œ”| j"                  j%                  ||«       t'        t(        j*                  «      t-        «       fc S  g }|D ]s  }	|j                  j/                  |	«      }
|
€C| j"                  j1                  ||	||«       t'        t(        j*                  «      t-        «       fc S |j!                  |
«       Œu t3        |«      t-        |«      fS )Nrâ   )rø   rm   r¹  rÍ   rs  rÈ   rð  rû   rÎ   r²   r[  r³   r·  r…  r7  r>  rù  r  Ú$typeddict_key_must_be_string_literalr¬   rÀ   r;  rd  rË  Útypeddict_key_not_foundr¤   )r!  Útd_typerY  ÚsetitemÚ	key_namesr°  Ú	key_typesrþ  Úvalue_typesÚkey_namer½  s              rî   rÛ  z,ExpressionChecker.visit_typeddict_index_expr¶  s|  € ô �eœWÔ%ØŸ™˜ŠIä! $§+¡+¨eÓ"4Ó5ˆCÜ˜#œyÔ)Ü(,¨S¯Y©Y«‘	à ˜E�	àˆIÜ,¨YÓ7ò @�Ü˜h¬Ô1°h×6OÑ6OÐ6[Ø'×8Ñ8�Hô ˜x¬Ô5Ü" 8§>¡>´3Ô7Ø ×)Ñ)×.Ñ.×7Ñ7Ð;KÒKà×$Ñ$ X§^¡^Õ4à—H‘H×AÑAÀ'È5ÔQÜ"¤9×#7Ñ#7Ó8¼#»%Ð?Ò?ð@ð ˆØ!ò 	/ˆHØ Ÿ™×*Ñ*¨8Ó4ˆJØÐ!Ø—‘×0Ñ0°¸(ÀEÈ7ÔSÜœy×3Ñ3Ó4´c³eÐ;Ò;à×"Ñ" :Õ.ð	/ô % [Ó1´3°y³>ÐAÐArí   c                ó˜   — | j                  d«      }| j                  j                  | j                  |«      ||dd«       t	        |g «      S )Nr&  zEnum index should be a stringzactual index type)rQ  r  Úcheck_subtypers  r²   )r!  Ú	enum_typerY  r^  Ústring_types        rî   rÜ  z'ExpressionChecker.visit_enum_index_exprÛ  sK   € ð !ŸO™O¨NÓ;ˆØ�‰×ÑØ�K‰K˜ÓØØØ+Øô	
ô ˜	 2Ó&Ð&rí   c                óP  — | j                  |j                  t        t        j                  «      dd¬«      }|j
                  }| j                  j                  }|j                  rKt        |t        t        j                  «      «      s(t        ||«      r| j                  j                  ||«       |j                  r(t        |«      r| j                  j                  d||«       t        || j                  j                  | j                  j                   | j                  |¬«       |S )zType check a cast expression.T©r  ro  r†  zTarget type of castr1  )rs  rŸ  r¬   rÀ   r3  r7  r  r  Úwarn_redundant_castsr‹   r  Úredundant_castÚdisallow_any_unimportedr—   Úunimported_type_becomes_anyr•   Úis_typeshed_stub)r!  rŸ  Úsource_typeÚtarget_typer  s        rî   Úvisit_cast_exprz!ExpressionChecker.visit_cast_exprè  sã   € à—k‘kØ�I‰IÜ ¤×!7Ñ!7Ó8Ø"Ø!ð	 "ó 
ˆð —i‘iˆØ—(‘(×"Ñ"ˆà×(Ò(Ü  ¬g´i×6LÑ6LÓ.MÔNÜ˜[¨+Ô6à�H‰H×#Ñ# K°Ô6Ø×*Ò*Ô/KÈKÔ/XØ�H‰H×0Ñ0Ð1FÈÐUYÔZÜØ˜Ÿ™×)Ñ)¨4¯8©8×+DÑ+DÀdÇhÁhÐX\õ	
ð Ðrí   c                ót   — |j                   }t        j                  ||j                  |j                  d¬«      S )NT©r@  rA  Úis_type_form)r7  rÁ   rì  r@  rA  )r!  rŸ  r°  s      rî   Úvisit_type_form_exprz&ExpressionChecker.visit_type_form_exprÿ  s+   € Ø�i‰iˆÜ×'Ñ'¨°#·(±(À3Ç:Á:Ð\`ÔaÐarí   c                ó  — | j                  |j                  | j                  d   dd¬«      }| j                  j                  r|S |j
                  }t        |«      }t        |t        j                  j                  «      r|j                  �|j                  }t        ||«      s]| j                  j                  «       s&| j                  j                  d|j                  «       | j                  j!                  |||«       |S )Nr1  Tr  zC"assert_type" expects everything to be "Any" in unchecked functions)rs  rŸ  r  r  rh  r7  rÍ   rø   r’  r   r²   r[  r‹   r8  r  rv  Úassert_type_fail)r!  rŸ  r  r  Úproper_source_types        rî   Úvisit_assert_type_exprz(ExpressionChecker.visit_assert_type_expr  s×   € Ø—k‘kØ�I‰IØ×*Ñ*¨2Ñ.Ø"Ø!ð	 "ó 
ˆð �8‰8×)Ò)ØÐà—i‘iˆÜ,¨[Ó9ÐäÐ)¬4¯:©:×+>Ñ+>Ô?Ø"×3Ñ3Ð?à,×=Ñ=ˆKÜ˜K¨Ô5Ø—8‘8×/Ñ/Ô1Ø—‘—‘ØYØ—I‘Iôð �H‰H×%Ñ% k°;ÀÔEØÐrí   c                óÖ  — |j                   t        k(  rÈ|j                  €J ‚| j                  |j                  | j                  d   d¬«      }| j
                  j                  sw| j                  j                  ||j                  «       | j
                  j                  «       s&| j                  j                  d|j                  «       | j                  |«       |S | j
                  j                  sj|j                  �/|j                  D �ci c]  }|j                  |j                  “Œ c}ni }| j                  j                  ||«       | j                  |«       t!        «       S c c}w )z$Type check a reveal_type expression.r1  T©r  ro  z9'reveal_type' always outputs 'Any' in unchecked functions)rf  r@   rŸ  rs  r  r  rh  r  Úreveal_typer8  rv  Úcheck_reveal_importedÚlocal_nodesr:  r7  Úreveal_localsrµ   )r!  rŸ  Úrevealed_typeÚvar_nodeÚnames_to_typess        rî   Úvisit_reveal_exprz#ExpressionChecker.visit_reveal_expr  s-  € à�9‰9œÒ#Ø—9‘9Ð(Ð(Ð(Ø ŸK™KØ—	‘	¨×(9Ñ(9¸"Ñ(=ÐQUð (ó ˆMð —8‘8×1Ò1Ø—‘×$Ñ$ ]°D·I±IÔ>Ø—x‘x×3Ñ3Ô5Ø—H‘H—M‘MØSÐUY×U^ÑU^ôð ×*Ñ*¨4Ô0Ø Ð ð —8‘8×1Ò1ð ×'Ñ'Ð3ð CG×BRÑBRÖS°h�X—]‘] H§M¡MÑ1ÓSàð ð —‘×&Ñ& ~°tÔ<Ø×*Ñ*¨4Ô0Ü“:Ðùò Ts   ÄE&c                ó  — t         j                  | j                  j                  j                  vry d}|j
                  t        k(  rd}n#|j
                  t        k(  r|j                  sd}ny | j                  j                  d|› d�|t         j                  ¬«       |dk(  rg| j                  j                  j                  dk\  rdnd	}d
j                  ||¬«      }| j                  j                  ||t         j                  ¬«       y y )NÚ r)  r&  zName "z" is not definedrî  )é   é   ÚtypingÚtyping_extensionszXDid you forget to import it from "{module}"? (Suggestion: "from {module} import {name}"))Úmoduler:  )rò  ÚUNIMPORTED_REVEALr  r  r¬  rf  r?   r@   Úis_importedrÙ  Úpython_versionrŒ  rv  )r!  rŸ  r:  r4  Úhints        rî   r'  z'ExpressionChecker.check_reveal_imported<  sà   € Ü×"Ñ"¨$¯(©(×*:Ñ*:×*NÑ*NÑNØàˆØ�9‰9œÒ%Ø"‰DØ�Y‰Yœ+Ò%¨d×.>Ò.>Ø ‰Dàà�‰�‰˜˜t˜fÐ$4Ð5°tÄ%×BYÑBYˆÔZØ�=Ò à ŸH™H×,Ñ,×;Ñ;¸wÒF‘ÐL_ð ð?ç‰f˜F¨ˆfÓ.ð ð �H‰H�M‰M˜$ ¬5×+BÑ+BˆMÕCð !rí   c           	     óò  — t        |j                  t        «      �rt        |j                  j                  t        «      �rã|j                  j                  j
                  r| j                  «       S t        |j                  j                  |j                  | j                  j                  | j                  j                  |j                  j                  j                  || j                  j                  «      \  }}t        |«      }t        |t        «      r2t!        |j"                  «      }| j%                  ||j&                  |«      S t        |t(        «      rf|j*                  j"                  j,                  rFt!        |j*                  j"                  «      }| j%                  ||j*                  j&                  |«      S t        |t.        «      r| j1                  |«      S | j                  j                  t2        j4                  |«       t7        t8        j:                  «      S t        | j=                  |j                  «      «      }t        |t>        t@        f«      rW|jC                  «       s*| j                  j                  t2        j4                  |«       | j%                  ||j                  |«      S t        |t6        «      rt7        t8        jD                  |¬«      S t7        t8        jF                  «      S )a{  Type check a type application (expr[type, ...]).

        There are two different options here, depending on whether expr refers
        to a type alias or directly to a generic class. In the first case we need
        to use a dedicated function typeanal.instantiate_type_alias(). This
        is due to slight differences in how type arguments are applied and checked.
        r  )$rø   rŸ  rg   r+  r   Úpython_3_12_type_aliasÚtype_alias_type_typer˜   r   r  rÙ  rv  r˜  r  rÍ   r²   r©   r7  Ú apply_type_arguments_to_callabler�  r¼   r:  r¼  r¿   r)  r   ÚONLY_CLASS_APPLICATIONr¬   rÀ   r;  rs  r­   r¶   rÀ  r  r3  )r!  ÚtapprÂ  r$  rÛ  s        rî   Úvisit_type_applicationz(ExpressionChecker.visit_type_applicationS  s  € ô �d—i‘i¤Õ)¬j¸¿¹¿¹ÌÕ.SØ�y‰y�~‰~×4Ò4Ø×0Ñ0Ó2Ð2ä,Ø—	‘	—‘Ø—
‘
Ø—‘—‘Ø—‘—‘Ø—	‘	—‘×&Ñ&ØØ—‘× Ñ ó‰GˆD�!ô # 4Ó(ˆDÜ˜$¤Ô)Ü% d§i¡iÓ0�Ø×<Ñ<¸RÀÇÁÈDÓQÐQÜ˜D¤)Ô,°×1FÑ1F×1KÑ1K×1ZÒ1ZÜ% d×&;Ñ&;×&@Ñ&@ÓA�Ø×<Ñ<¸RÀ×AVÑAV×A[ÑA[Ð]aÓbÐbÜ˜D¤-Ô0Ø×;Ñ;¸DÓAÐAà—‘—‘Ô.×EÑEÀtÔLÜœy×3Ñ3Ó4Ð4ô ˜TŸ[™[¨¯©Ó3Ó4ˆÜ�bœ<¬Ð4Ô5Ø—>‘>Ô#Ø—‘—‘Ô.×EÑEÀtÔLØ×8Ñ8¸¸T¿Z¹ZÈÓNÐNÜ�bœ'Ô"Üœ9×5Ñ5À"ÔEÐEÜ”y×-Ñ-Ó.Ð.rí   c                ó>   — | j                  |j                  |d¬«      S )a�  Right hand side of a type alias definition.

        It has the same type as if the alias itself was used in a runtime context.
        For example, here:

            A = reveal_type(List[T])
            reveal_type(A)

        both `reveal_type` instances will reveal the same type `def (...) -> builtins.list[Any]`.
        Note that type variables are implicitly substituted with `Any`.
        TrI  )rP  r+  )r!  Úaliass     rî   Úvisit_type_alias_exprz'ExpressionChecker.visit_type_alias_expr  s!   € ð ×1Ñ1°%·*±*À%ÐZ^Ð1Ó_Ð_rí   )rK  c          	     óf  — |j                   r| j                  «       S | j                  j                  j                  xr | j
                  }t        |g |j                  |j                  | j                  j                  || j                  j                  ¬«      \  }}t        |«      }t        |t        «      r@t        |j                  «      }|j                   r|S | j#                  ||j$                  |«      S t        |t&        «      r@t)        |«      j                  j*                  dk7  rt        t)        |«      j                  «      S t        |t,        «      r| j/                  |«      S t        |t0        «      r"t3        ||j                  |j                  ¬«      S t        |t4        «      rt5        t6        j8                  |¬«      S t        |t:        «      r2|j<                  r&| j                  j?                  d|j@                  «      S |rt5        t6        jB                  «      S | jE                  d«      S )aÛ  Get type of a type alias (could be generic) in a runtime expression.

        Note that this function can be called only if the alias appears _not_
        as a target of type application, which is treated separately in the
        visit_type_application method. Some examples where this method is called are
        casts and instantiation:

            class LongName(Generic[T]): ...
            A = LongName[int]

            x = A()
            y = cast(A, ...)
        )Údisallow_anyrÙ  rÃ  r	  r  ztypes.UnionTyperV  )#r:  r;  r  r  Údisallow_any_genericsr  r™   r@  rA  r  rÙ  rÍ   rø   r²   r©   r7  r˜  r<  r�  r¼   r¨   r>  r¿   r)  rµ   rÁ   r¬   rÀ   r  rÈ   Úuses_pep604_syntaxr\  rû   r3  rQ  )r!  rA  rJ  rK  rD  rÂ  r$  rÛ  s           rî   rP  z/ExpressionChecker.alias_type_in_runtime_context�  s«  € ð  ×'Ò'Ø×,Ñ,Ó.Ð.ð
 —x‘x×'Ñ'×=Ñ=ÒPÀ$Ç.Á.ˆÜØØØ�H‰HØ�J‰JØ�H‰H×ÑØ%Ø—‘—‘ô
‰ˆˆaô ˜tÓ$ˆÜ�dœHÔ%ô " $§)¡)Ó,ˆBØ�}Š}Ø�	Ø×8Ñ8¸¸T¿Y¹YÈÓLÐLä�tœYÔ'ô ˜4Ó ×%Ñ%×.Ñ.Ð2BÒBä#¤N°4Ó$8×$=Ñ$=Ó>Ð>Ü˜œmÔ,Ø×7Ñ7¸Ó=Ð=Ü˜œhÔ'Ü˜D t§y¡y¸¿¹ÔEÐEÜ˜œgÔ&Üœ9×5Ñ5À$ÔGÐGÜ˜œiÔ(¨T×-DÒ-DØ—8‘8×.Ñ.Ð/@À$Ç*Á*ÓMÐMáÜœy×5Ñ5Ó6Ð6à—?‘?Ð#8Ó9Ð9rí   c                óX  — |j                  «       r%|j                  «       j                  j                  }nt	        |j
                  «      }t        |«      }t        |j
                  |«      D ]¤  \  }}t        |t        «      sŒt        t        |«      t        t        t        t        f«      rŒA| j                  j                  dt!        || j                  j"                  «      › �|«       t        t$        j&                  «      gt)        |«      z  c S  |r-|j                  «       r|j                  «       j*                  dk(  rt	        |«      S |j                  «       }t-        |||j.                  |j0                  ¬«      }t3        || j                  j                  d¬«      sat5        || j                  j                  | j                  j6                  d| j                  j"                  ¬«       t	        |j8                  «      }t;        d„ |D «       «      s|S t=        d	„ t?        |«      D «       «      }	t)        |«      |	z
  d
z
  }
||	   }t        |t@        «      sJ ‚tC        tE        |«      |	|
«      \  }}}t	        |«      tG        t	        |«      |jH                  «      gz   t	        |«      z   S )aÁ  Handle directly applying type arguments to a variadic Callable.

        This is needed in situations where e.g. variadic class object appears in
        runtime context. For example:
            class C(Generic[T, Unpack[Ts]]): ...
            x = C[int, str]()

        We simply group the arguments that need to go into Ts variable into a TupleType,
        similar to how it is done in other places using split_with_prefix_and_suffix().
        zQCan only replace ParamSpec with a parameter types list or another ParamSpec, got rÃ  r	  T)ÚindexedF)rD  r  c              3  ó<   K  — | ]  }t        |t        «      –— Œ y ­wrñ   ©rø   rÄ   rÆ  s     rî   rö   z7ExpressionChecker.split_for_callable.<locals>.<genexpr>ú  s   è ø€ ÒA°q”:˜aÔ!1×2ÑAùr  c              3  óH   K  — | ]  \  }}t        |t        «      sŒ|–— Œ y ­wrñ   rJ  )rô   r‚  rÇ  s      rî   rö   z7ExpressionChecker.split_for_callable.<locals>.<genexpr>ý  s   è ø€ ÒY™F˜Q ¼ÀAÔGWÕ9X”aÑYùó   ‚"›"r  )%rÀ  rÖ  rÓ  r*  rð  r-  rË   rä  rø   r¹   rÍ   r·   r¬   rÆ   r  rÙ  r7   r  rÀ   r;  r‘  r>  r²   r@  rA  rš   r–   rv  r�  r¤  Únextrp  rÄ   rÓ   rÂ  r¼   r¨   )r!  rý   r�  rJ  ÚvarsrJ  r  rÆ  ÚfakeÚprefixÚsuffixÚtvtÚstartré  rõ  s                  rî   Úsplit_for_callablez$ExpressionChecker.split_for_callableÊ  s  € ð �=‰=Œ?à—=‘=“?×'Ñ'×1Ñ1‰Dä˜Ÿ™Ó$ˆDÜ$ TÓ*ˆô ˜1Ÿ;™;¨Ó-ò 
	G‰GˆB�Ü˜"œmÕ,Ü!Ü# CÓ(¬:´}ÄgÌ{Ð*[õð —H‘H—M‘Mð3Ü3>¸sÀDÇHÁH×DTÑDTÓ3UÐ2VðXàôô
 $¤I×$8Ñ$8Ó9Ð:¼SÀ»YÑFÒFð
	Gñ ˜1Ÿ=™=œ?¨a¯m©m«o×.FÑ.FÐJZÒ.ZÜ˜“:ÐØ�}‰}‹ˆä˜˜d¨¯©¸#¿*¹*ÔEˆô !  t§x¡x§}¡}¸dÕCÜØ�d—h‘h—m‘m T§X¡X§]¡]ÀÐPT×PXÑPX×P`ÑP`õô ˜Ÿ	™	“?ˆDäÑA¸DÔAÔAØˆKäÑY¤i°£oÔYÓYˆÜ�T“˜VÑ# aÑ'ˆØ�6‰lˆÜ˜#Ô/Ô0Ð0Ð0Ü9¼%À»+ÀvÈvÓVÑˆˆv�sÜ�E‹{œi¬¨V«°c×6HÑ6HÓIÐJÑJÌTÐRUËYÑVÐVrí   c                óˆ  — t        |«      }t        |t        «      �rÁ|j                  «       r%|j	                  «       j
                  j                  }nt        |j                  «      }t        d„ |D «       «      }t        d„ |D «       «      }t        |«      |k  st        |«      t        |«      kD  �r	|�s|j                  «       r­|j	                  «       j                  dk(  r�t        t        t        |«      | j                  j                  d«      «      gt         gdgt        t        |«      | j                  j                  d«      «      |j"                  d|j$                  |j&                  ¬«      S | j(                  j+                  |t        |«      t        |«      |«       t-        t.        j0                  «      S | j3                  || j5                  |||«      |«      S t        |t6        «      �r7|j8                  D ]ã  }|j                  «       r%|j	                  «       j
                  j                  }nt        |j                  «      }t        d„ |D «       «      }t        d„ |D «       «      }t        |«      |k  st        |«      t        |«      kD  sŒ—|rŒš| j(                  j+                  |t        |«      t        |«      |«       t-        t.        j0                  «      c S  t7        |j8                  D �cg c]&  }| j3                  || j5                  |||«      |«      ‘Œ( c}«      S t-        t.        j:                  «      S c c}w )	a{  Apply type arguments to a generic callable type coming from a type object.

        This will first perform type arguments count checks, report the
        error as needed, and return the correct kind of Any. As a special
        case this returns Any for non-callable types, because if type object type
        is not callable, then an error should be already reported.
        c              3  ó>   K  — | ]  }|j                  «        –— Œ y ­wrñ   ©Úhas_defaultrÆ  s     rî   rö   zEExpressionChecker.apply_type_arguments_to_callable.<locals>.<genexpr>  s   è ø€ ÒG¸ A§M¡M£OÔ 3ÑGùó   ‚c              3  ó<   K  — | ]  }t        |t        «      –— Œ y ­wrñ   rJ  rÆ  s     rî   rö   zEExpressionChecker.apply_type_arguments_to_callable.<locals>.<genexpr>  s   è ø€ Ò$XÈ¤Z°Ô3C×%DÑ$Xùr  rÃ  rÂ  N)r:  r«  r.  c              3  ó>   K  — | ]  }|j                  «        –— Œ y ­wrñ   rW  rÆ  s     rî   rö   zEExpressionChecker.apply_type_arguments_to_callable.<locals>.<genexpr>?  s   è ø€ Ò#K¸A¨¯©«Ô$7Ñ#KùrY  c              3  ó<   K  — | ]  }t        |t        «      –— Œ y ­wrñ   rJ  rÆ  s     rî   rö   zEExpressionChecker.apply_type_arguments_to_callable.<locals>.<genexpr>@  s   è ø€ Ò(\ÈQ¬°AÔ7G×)HÑ(\ùr  )rÍ   rø   r­   rÀ  rÖ  rÓ  r*  rð  r-  ra  r¤  r‘  r>  r¼   r  rQ  r9   r…  r«  r.  r  Úincompatible_type_applicationr¬   rÀ   r;  r  rT  r¶   rû   r3  )r!  rÛ  r�  rJ  r*  Úmin_arg_countÚhas_type_var_tuplerõ   s           rî   r<  z2ExpressionChecker.apply_type_arguments_to_callable  sœ  € ô ˜RÓ ˆä�bœ,Õ'Ø�~‰~Ôð ŸN™NÓ,×1Ñ1×;Ñ;‘	ä  §¡Ó.�	ÜÑG¸YÔGÓGˆMÜ!$Ñ$XÈiÔ$XÓ!XÐä�D“	˜MÒ)¬S°«Y¼¸Y»Ó-GÚ(Ø—>‘>Ô#¨¯©Ó(8×(AÑ(AÐEUÒ(Uô (Ü"¤4¨£:¨t¯x©x×/BÑ/BÀ7Ó/KÓLÐMÜ ˜	Ø˜Ü!¤$ t£*¨d¯h©h×.AÑ.AÀ'Ó.JÓKØŸ™Ø$Ø#%§=¡=Ø!#§¡ô	ð 	ð —‘×6Ñ6Ø!¤3 y£>´3°t³9¸côô œy×3Ñ3Ó4Ð4Ø×/Ñ/°°D×4KÑ4KÈBÐPTÐVYÓ4ZÐ\_Ó`Ð`Ü�bœ*Õ%Ø—h‘hò 9�Ø—>‘>Ô#à "§¡Ó 0× 5Ñ 5× ?Ñ ?‘Iä $ R§\¡\Ó 2�IÜ #Ñ#KÀÔ#KÓ K�Ü%(Ñ(\ÐR[Ô(\Ó%\Ð"ä˜“I Ò-´°T³¼SÀ»^Ó1KÚ,Ø—H‘H×:Ñ:Ø%¤s¨9£~´s¸4³yÀ#ôô #¤9×#7Ñ#7Ó8Ò8ð9ô ð !Ÿh™höàð ×0Ñ0°°T×5LÑ5LÈRÐQUÐWZÓ5[Ð]`Õaòóð ô ”y×-Ñ-Ó.Ð.ùòs   Ë4+L?c                ó(   — | j                  |dd«      S )z#Type check a list expression [...].rO  z<list>©Úcheck_lst_exprr  s     rî   Úvisit_list_exprz!ExpressionChecker.visit_list_exprP  s   € à×"Ñ" 1 o°xÓ@Ð@rí   c                ó(   — | j                  |dd«      S )Nrß   z<set>ra  r  s     rî   Úvisit_set_exprz ExpressionChecker.visit_set_exprT  s   € Ø×"Ñ" 1 n°gÓ>Ð>rí   c                óœ  — | j                   d   }|s|j                  sy| j                  j                  ryg }t	        «       }|j                  D ]L  }t        |t        «      r y| j                  |«      }||vsŒ+|j                  |«       |j                  |«       ŒN | j                  |«      }|€y| j                  j                  ||g«      S )aÈ  
        Fast path to determine the type of a list or set literal,
        based on the list of entries. This mostly impacts large
        module-level constant definitions.

        Limitations:

         - no active type context
         - at least one item
         - no star expressions
         - not after deferral
         - either exactly one distinct type inside,
           or the joined type of all entries is an Instance or Tuple type,
        r1  N)r  rû   r  rh  rd  rø   rl   rs  rù  rh  Ú_first_or_join_fast_itemr\  )	r!  r,  Úcontainer_fullnamerJ  rÿ  Ú
values_setrÂ  r°  Úvts	            rî   Úfast_container_typez%ExpressionChecker.fast_container_typeW  s¾   € ð" ×Ñ Ñ#ˆÙ�a—g’gØØ�8‰8×)Ò)àØˆä #£ˆ
Ø—G‘Gò 	$ˆDÜ˜$¤Ô)áà—+‘+˜dÓ#ˆCØ˜*Ò$Ø—‘˜cÔ"Ø—‘˜sÕ#ð	$ð ×*Ñ*¨6Ó2ˆØˆ:ØØ�x‰x×*Ñ*Ð+=À¸tÓDÐDrí   c                óš   — t        |«      dk(  r| j                  j                  s|d   S t        j                  |«      }t        |«      sy |S )Nr  r   )r‘  r  rh  r   r�  rò   )r!  rû   r°  s      rî   rg  z*ExpressionChecker._first_or_join_fast_item€  sD   € Üˆu‹:˜Š? 4§8¡8×#AÒ#AØ˜‘8ˆOÜ×!Ñ! %Ó(ˆÜ+¨CÔ0ð Øˆ
rí   c                ó˜  — | j                  ||«      }|r|S t        ddt        dd¬«      g | j                  «       t	        t
        j                  «      ¬«      }t        |gt        j                  gd g| j                  j                  ||g«      | j                  d«      ||g¬«      }| j                  ||j                  D �cg c]   }t        |t         «      r|j"                  n|‘Œ" c}|j                  D �cg c]2  }t        |t         «      rt        j                  nt        j$                  ‘Œ4 c}|«      d   }t'        |«      S c c}w c c}w )	NÚTr1  z<lst>©Ú	namespace©rä  rÿ  r¸  Údefaultr„  ©r:  r-  r   )rk  rÅ   rÂ   rR  r¬   rÀ   Úfrom_omitted_genericsr­   r   r:   r  r\  rQ  r™  rû   rø   rl   rŸ  r9   r!   )	r!  r,  r>  Útagrý   rJ  Úconstructorr‚  rß  s	            rî   rb  z ExpressionChecker.check_lst_expr‹  s%  € à×$Ñ$ Q¨Ó1ˆÙØˆHô ØØÜ˜ wÔ/ØØ×(Ñ(Ó*ÜœI×;Ñ;Ó<ô
ˆô #ØˆDÜ�^‰^ÐØˆFØ�H‰H×'Ñ'¨°2°$Ó7Ø�O‰OÐ/Ó0ØØ�dô
ˆð �o‰oØØABÇÁÖI¸Aœ
 1¤hÔ/ˆa�fŠf°QÑ6ÒIØUV×U\ÑU\Ö]ÐPQ¤
¨1¬hÔ 7Œe�nŠn¼U¿]¹]ÑJÒ]Øó	
ð
 ñˆô 1°Ó5Ð5ùò	 JùÚ]s   Ã %E
Ã57Ec           	     óö  — t        |j                  «      }|€Jt        |j                  D �cg c]  }t        |t        «      rŒ|‘Œ c}«      t        |j                  «      k  S t        |j                  D �cg c]  }t        |t        «      sŒ|‘Œ c}«      dk7  ryt        d„ t        |j                  «      D «       «      }t        |j                  «      t        |j                  «      k(  xr ||k(  S c c}w c c}w )Nr  Fc              3  óH   K  — | ]  \  }}t        |t        «      sŒ|–— Œ y ­wrñ   )rø   rl   )rô   r‚  Úlvs      rî   rö   z:ExpressionChecker.tuple_context_matches.<locals>.<genexpr>¸  s   è ø€ Ò`¡U Q¨ÄzÐRTÔV^ÕG_œqÑ`ùrL  )rÊ   rû   r‘  rø   rl   rM  rp  )r!  rŸ  rJ  Úctx_unpack_indexr,  Úexpr_star_indexs         rî   Útuple_context_matchesz'ExpressionChecker.tuple_context_matches®  sÃ   € Ü.¨s¯y©yÓ9ÐØÐ#ô  4§:¡:ÖM˜a´ZÀÄ8Õ5LšÒMÓNÔRUÐVY×V_ÑV_ÓR`Ñ`Ð`ô ˜4Ÿ:™:ÖA�a¬°A´xÕ)@’ÒAÓBÀaÒGØÜÑ`¬i¸¿
¹
Ó.CÔ`Ó`ˆÜ�4—:‘:‹¤# c§i¡i£.Ñ0ÒXÐ5EÈÑ5XÐXùò Nùò Bs   «C1ÁC1Á5C6ÂC6c                óR  — t        | j                  d   «      }d}t        |t        «      rit	        |j
                  «      D �cg c]6  }t        |t        «      r| j                  ||«      st        |t        «      r|‘Œ8 }}t        |«      dk(  r|d   }n	 t        |t        «      r| j                  ||«      r|j
                  }nV|rTt        |t        «      rDt        |t        «      sJ ‚|j                  r&|j                  d   gt        |j
                  «      z  }d}|�t        |«      du}d}|xs& t        | j                  j                   j"                  v }g }	d}
t%        t        |j
                  «      «      D �]Ø  }|j
                  |   }t        |t&        «      �rh|r(|sJ ‚||
   }t        |t(        «      sJ ‚|j*                  }nd}| j-                  |j.                  |«      }t        |«      }t        |t        «      rjt        |j
                  «      �|r| j1                  |dd«      c S d}|	j3                  |j
                  «       |r|
dz  }
ŒØ|
t        |j
                  «      z  }
Œñ|r„|s‚t        |t        «      rr| j                  j5                  |«      rW| j                  j7                  ||«      }| j                  j9                  d|g«      }|	j;                  t)        |«      «       d}�Œw| j1                  |dd«      c S |r|
t        |«      k\  r| j-                  |«      }n| j-                  |||
   «      }|
dz  }
|	j;                  |«       �ŒÛ t=        t>        j@                  «      }t        |	| j                  j9                  d|g«      «      }|rtC        |i «      }|S c c}w )	zType check a tuple expression.r1  Nr  r   FrÃ  z<tuple>T)"rÍ   r  rø   rÈ   rÎ   rû   r¼   r|  rÒ   r«   r‘  r²   r�  rÊ   r�   r  r  r;  rœ  rl   rÉ   r7  rs  rŸ  rb  rQ  r<  r=  r\  rù  r¬   rÀ   r3  r&   )r!  r,  r  Útype_context_itemsrý   Útuples_in_contextÚunpack_in_contextÚseen_unpack_in_itemsÚallow_precise_tuplesrû   r²  r‚  rÂ  Úctx_itemrJ  Úttrg  r"  Úfallback_itemr-  s                       rî   Úvisit_tuple_exprz"ExpressionChecker.visit_tuple_expr»  sk  € ô ' t×'8Ñ'8¸Ñ'<Ó=ˆØ!ÐÜ�l¤IÔ.ô *¨,×*<Ñ*<Ó=ö!àÜ˜q¤)Ô,°×1KÑ1KÈAÈqÔ1QÜ$ QÔ(AÔBò ð!Ðð !ô Ð$Ó%¨Ò*Ø0°Ñ3‘ð ä�l¤IÔ.°4×3MÑ3MÈaÐQ]Ô3^Ø!-×!3Ñ!3ÑÙÔ/°Ô>WÔXÜ˜l¬HÔ5Ð5Ð5Ø× Ò Ø&2×&7Ñ&7¸Ñ&:Ð%;¼cÀ!Ç'Á'»lÑ%JÐ"ð "ÐØÐ)Ü 3Ð4FÓ GÈtÐ SÐØ$ÐàÒbÔ!4¸¿¹×8HÑ8H×8bÑ8bÐ!bð 	ð ˆØˆÜ”s˜1Ÿ7™7“|Ó$ó 4	!ˆAØ—7‘7˜1‘:ˆDÜ˜$¤Õ)ñ %á-Ð-Ð-Ø1°!Ñ4�HÜ% h´
Ô;Ð;Ð;Ø"Ÿ-™-‘Cà�CØ—[‘[ §¡¨CÓ0�Ü$ RÓ(�Ü˜b¤)Ô,Ü*¨2¯8©8Ó4Ð@Ù/ð $(×#6Ñ#6°qÐ:JÈIÓ#VÒVà37Ð0Ø—L‘L §¡Ô*á(Ø˜Q™™ð œS §¡›]Ñ*™á+Ñ4Hä% b¬(Ô3¸¿¹×8QÑ8QÐRTÔ8UØ(,¯©×(CÑ(CÀBÈÓ(J˜IØ%)§X¡X×%@Ñ%@ÐAQÐT]ÐS^Ó%_˜FØ!ŸL™L¬°FÓ);Ô<Ø37Ð0Ù$ð  ×.Ñ.¨qÐ2BÀIÓNÒNá)¨Q´#Ð6HÓ2IÒ-IØŸ™ TÓ*‘BàŸ™ TÐ+=¸aÑ+@ÓA�BØ˜‘F�AØ—‘˜RÖ ði4	!ôl  ¤	× 6Ñ 6Ó7ˆÜ&Ø�4—8‘8×.Ñ.Ð/?À-ÀÓQó
ˆñ  ä  ¨Ó,ˆFØˆùòC!s   Á;N$c                óT  — | j                   d   }|s|j                  sy| j                  j                  ryg }g }t	        «       }t	        «       }d}|j                  D ]ò  \  }}	|€|t        | j                  |	«      «      }
t        |
t        «      rP|
j                  j                  dk(  r7t        |
j                  «      dk(  r|
j                  d   |
j                  d   f}Œ‚ y| j                  |«      }||vr"|j                  |«       |j                  |«       | j                  |	«      }||vsŒÑ|j                  |«       |j                  |«       Œô | j                  |«      }|€y| j                  |«      }|€y|r|d   |k7  s|d   |k7  ry| j                  j!                  d||g«      S )aä  
        Fast path to determine the type of a dict literal,
        based on the list of entries. This mostly impacts large
        module-level constant definitions.

        Limitations:

         - no active type context
         - at least one item
         - only supported star expressions are other dict instances
         - either exactly one distinct type (keys and values separately) inside,
           or the joined type of all entries is an Instance or Tuple type
        r1  NrS  r  r   r  )r  rû   r  rh  rd  rÍ   rs  rø   r²   r7  r>  r‘  r�  rù  rh  rg  r\  )r!  r,  rJ  r  rÿ  Úkeys_setri  Ústargsr  r¹  ÚstÚkey_tÚvalue_tÚktrj  s                  rî   Úfast_dict_typez ExpressionChecker.fast_dict_type$  sˆ  € ð ×Ñ Ñ#ˆÙ�a—g’gØà�8‰8×)Ò)ààˆØˆä!›eˆÜ #£ˆ
Ø+/ˆØŸ'™'ò 	,‰JˆC�Øˆ{Ü$ T§[¡[°Ó%7Ó8�ä˜r¤8Ô,ØŸ™×(Ñ(¨OÒ;Ü˜BŸG™G›¨Ò)à Ÿg™g a™j¨"¯'©'°!©*Ð5‘FáàŸ™ CÓ(�Ø Ñ(Ø—K‘K Ô&Ø—L‘L Ô'ØŸ+™+ eÓ,�Ø *Ò,Ø—M‘M 'Ô*Ø—N‘N 7Õ+ð'	,ð* ×*Ñ*¨4Ó0ˆØˆ:Øà×*Ñ*¨6Ó2ˆØˆ:Øá�v˜a‘y B’¨&°©)°rª/ØØ�x‰x×*Ñ*¨?¸RÀ¸HÓEÐErí   c                ó¶   — | j                  ||j                  |d ¬«      }t        |«      }t        |t        «      r|j                  «       S |j                  «       S )N)r�  rã  r^  ré  )rç  rû   rÍ   rø   r¿   rc  )r!  r,  Útypeddict_contextrD  r?  s        rî   Ú"check_typeddict_literal_in_contextz4ExpressionChecker.check_typeddict_literal_in_contexta  sZ   € ð ×;Ñ;Ø$¨Q¯W©W¸aÈTð <ó 
ˆô # =Ó1ˆÜ�h¤Ô.Ø×)Ñ)Ó+Ð+Ø ×.Ñ.Ó0Ð0rí   c           
     ó®  — | j                  | j                  d   |«      \  }}|rÍt        |«      dk(  r|r| j                  ||d   «      S |D ]…  }| j                  j                  «       5 }| j                  j                  5 }| j                  ||«      }ddd«       ddd«       j                  «       rŒh| j                  j                  «       c S  |r| j                  j                  ||«       | j                  |«      }|r|S t        ddt        dd¬«      g | j                  «       t        t         j"                  «      ¬«      }	t        d	d	t        d
d¬«      g | j                  «       t        t         j"                  «      ¬«      }
g }g }|j$                  D �]  \  }}|€?|j'                  |«       |j'                  | j                  j)                  d|	|
g«      «       ŒHt+        ||g«      }|j,                  dk\  r#|j,                  |_        |j.                  |_        n"|j,                  |_        |j.                  |_        |j0                  |_        |j2                  |_        |j'                  |«       |j'                  t5        |	|
g| j7                  d«      «      «       �Œ
 t9        |t:        j<                  gt        |«      z  dgt        |«      z  | j                  j)                  d|	|
g«      | j7                  d«      d|	|
g¬«      }| j?                  ||t:        j<                  gt        |«      z  |«      d   S # 1 sw Y   �Œ¬xY w# 1 sw Y   �Œ±xY w)zoType check a dict expression.

        Translate it into a call to dict(), with provisions for **expr.
        r1  r  r   NÚKTú<dict>ro  rq  ÚVTéþÿÿÿry  rÃ  rS  r„  rs  ) Úfind_typeddict_contextr  r‘  r‘  r  rO  r  r>  rš  rÍ  Útypeddict_context_ambiguousrŽ  rÅ   rÂ   rR  r¬   rÀ   rt  rû   rù  r\  rs   r@  rA  Úend_lineÚ
end_columnr¼   rQ  r­   r   r9   r™  )r!  r,  Útypeddict_contextsÚ
exhaustiver�  r�  Útmapr?  Údtr�  rj  r�  Úexpected_typesr  r¹  Útuprv  s                    rî   Úvisit_dict_exprz!ExpressionChecker.visit_dict_exprl  s  € ð *.×)DÑ)DÀT×EVÑEVÐWYÑEZÐ\]Ó)^Ñ&Ð˜JÙÜÐ%Ó&¨!Ò+±
Ø×>Ñ>¸qÐBTÐUVÑBWÓXÐXà%7ò  Ð!Ø—X‘X×+Ñ+Ó-ð ]°°d·h±h×6MÑ6Mð ]ÐQUØ#×FÑFÀqÐJ[Ó\�H÷]÷ ]à×%Ñ%Ô'ØØ—‘×$Ñ$ TÔ*Ø’ð ñ Ø—‘×4Ñ4Ð5GÈÔKð × Ñ  Ó#ˆÙØˆIô ØØÜ˜ xÔ0ØØ×(Ñ(Ó*ÜœI×;Ñ;Ó<ô
ˆô ØØÜ˜ xÔ0ØØ×(Ñ(Ó*ÜœI×;Ñ;Ó<ô
ˆð "$ˆØ%'ˆØŸ'™'ó 	^‰JˆC�Øˆ{Ø—‘˜EÔ"Ø×%Ñ%Ø—H‘H×/Ñ/Ð0RÐUWÐY[ÐT\Ó]õô    e Ó-�Ø—8‘8˜q’=Ø"Ÿx™x�C”HØ!$§¡�C•Jà$Ÿz™z�C”HØ!&§¡�C”JØ$Ÿ~™~�”Ø!&×!1Ñ!1�”Ø—‘˜CÔ Ø×%Ñ%¤i°°R°¸$¿/¹/ÐJZÓ:[Ó&\Ö]ð#	^ô* #ØÜ�]‰]ˆOœc .Ó1Ñ1ØˆF”S˜Ó(Ñ(Ø�H‰H×'Ñ'¨¸"¸b¸ÓBØ�O‰OÐ/Ó0ØØ˜2�hô
ˆð �‰˜{¨D´5·=±=°/ÄCÈÃIÑ2MÈqÓQÐRSÑTÐT÷E]ñ ]ú÷ ]ñ ]ús$   Á)M
Â L=ÂM
Ì=MÍM
Í
M	c                ó>  — t        |«      }t        |t        «      r|gdfS t        |t        «      rjg }d}|j                  D ]S  }| j                  ||«      \  }}|D ]1  }| j                  ||j                  |«      sŒ!|j                  |«       Œ3 |xr |}ŒU ||fS g dfS )z‰Extract `TypedDict` members of the enclosing context.

        Returns:
            a 2-tuple, (found_candidates, is_exhaustive)
        TF)rÍ   rø   r¿   rÈ   rû   r—  r%  rù  )	r!  r^  Ú	dict_exprrû   rœ  rÂ  Úitem_contextsÚitem_exhaustiveÚitem_contexts	            rî   r—  z(ExpressionChecker.find_typeddict_context¿  s¼   € ô " 'Ó*ˆÜ�gœ}Ô-Ø�9˜d�?Ð"Ü˜¤Ô+ØˆEØˆJØŸ™ò <�Ø15×1LÑ1LÈTÐS\Ó1]Ñ.�˜Ø$1ò 3�LØ×:Ñ:Ø$ i§o¡o°yõð Ÿ™ \Õ2ð	3ð
 (Ò;¨O‘
ð<ð ˜*Ð$Ð$à�5ˆyÐrí   c                ót  — |j                   D ]?  }t        |t        «      sŒ|\  }}}}| j                  |«       |€Œ/| j                  |«       ŒA t	        d| j
                  j                  «      }|�0t        |j                  t        «      rt        |j                  g «      S t        t        j                  «      S )z¬Type check a template string expression (t-string).

        Type-checks all interpolated expressions but the result is always
        string.templatelib.Template.
        zstring.templatelib.Template)rû   rø   rÂ  rs  r0   r  Úmodulesr+  rx   r²   r¬   rÀ   r;  )r!  r,  rÂ  Ú
value_exprÚ_sourceÚ_conversionÚformat_specrÍ  s           rî   Úvisit_template_str_exprz)ExpressionChecker.visit_template_str_exprÙ  sš   € ð —G‘Gò 	-ˆDÜ˜$¤Õ&Ø@DÑ=�
˜G [°+Ø—‘˜JÔ'ØÑ*Ø—K‘K Õ,ð	-ô %Ð%BÀDÇHÁH×DTÑDTÓUˆØˆ?œz¨#¯(©(´HÔ=Ü˜CŸH™H bÓ)Ð)Ü”y×+Ñ+Ó,Ð,rí   c                óZ  — | j                   }d| _         | j                  j                  |d¬«       | j                  |«      \  }}|�s_| j                  j                  j                  t        t        j                  «      «       | j                  j                  j                  dd¬«      5  | j                  j                  j                  |«      5  |j                  D ]  }d|j                  _        Œ |j                   j                   dd D ]  }|j#                  | j                  «       Œ | j#                  |j%                  «       d¬«      }ddd«       ddd«       | j'                  d	«      }| j                  j                  j)                  «        || _         t+        ||«      S | j                  j                  j                  |j,                  «       | j                  j.                  j1                  |«      5  | j                  j3                  ||¬
«       ddd«       | j                  j5                  |j%                  «       «      sQ| j                  j                  j                  dd¬«      5  | j#                  |j%                  «       d¬«       ddd«       | j                  j7                  |j%                  «       «      }| j                  j                  j)                  «        || _         t9        ||«      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Type check lambda expression.TF)Úbody_is_trivialr   ©Úcan_skipÚfall_throughNr1  rn  r„  )Útype_override)r  r  Úcheck_default_paramsÚinfer_lambda_type_using_contextrÐ  rù  r¬   rÀ   r3  r¬  Úframe_contextrK  Úpush_functionÚ	argumentsÚvariabler7  Úbodyrs  rŸ  rQ  Úpopr›   r?  ÚtscopeÚfunction_scopeÚcheck_func_itemrž  r   Úreplace_callable_return_type)	r!  r,  Úold_in_lambdarI  r³  r  Ústmtr?  r…  s	            rî   Úvisit_lambda_exprz#ExpressionChecker.visit_lambda_exprê  sƒ  € à×+Ñ+ˆØ"ˆÔØ�‰×%Ñ% a¸Ð%Ô?Ø'+×'KÑ'KÈAÓ'NÑ$ˆ�}ÚØ�H‰H×!Ñ!×(Ñ(¬´×1GÑ1GÓ)HÔIð —‘—‘×-Ñ-°tÈ!Ð-ÓLñIà—‘—‘×,Ñ,¨QÓ/ñIð Ÿ;™;ò -�CØ(,�C—L‘LÕ%ð-ð
 ŸF™FŸK™K¨¨Ð,ò *�DØ—K‘K §¡Õ)ð*ð  Ÿ;™; q§v¡v£xÀ4˜;ÓH�÷I÷ Ið  —‘Ð':Ó;ˆHØ�H‰H×!Ñ!×%Ñ%Ô'Ø"/ˆDÔÜ   H¨hÓ7Ð7ð �H‰H×!Ñ!×(Ñ(¨×)?Ñ)?Ô@Ø—‘—‘×/Ñ/°Ó2ñ IØ—‘×(Ñ(¨¸-Ð(ÔH÷Ià—8‘8×$Ñ$ Q§V¡V£XÔ.à—X‘X—_‘_×2Ñ2¸DÈqÐ2ÓQñ BØ—K‘K §¡£¸D�KÔA÷Bà—x‘x×+Ñ+¨A¯F©F«HÓ5ˆHØ�H‰H×!Ñ!×%Ñ%Ô'Ø"/ˆDÔÜ/°¸xÓHÐH÷AIñ Iú÷ Iñ Iú÷.Ið Iú÷Bð Bús=   Â+&LÃA=K;ÅLÇ;LÉ1"L!Ë;L	Ì LÌLÌLÌ!L*c                ó°  — t        | j                  d   «      }t        |t        «      rJt	        |j                  «       «      D �cg c]  }t        |t        «      sŒ|‘Œ }}t        |«      dk(  r|d   }|rt        |t        «      sy| j                  j                  j                  s°g }|j                  D ]Y  }t        |«      D �cg c]  }|j                  j                  «       sŒ|‘Œ! }}|j                  |D �cg c]	  }||vsŒ|‘Œ c}«       Œ[ |j!                  t#        |j$                  t'        «       «      t)        |j*                  «      |z   ¬«      }	n8t#        |t'        «       «      }
t        |
t,        «      rt        |
t        «      sJ ‚|
}	|	j!                  | j/                  d«      ¬«      }	|	j0                  €|	j2                  �y|j4                  D �cg c]  }|j6                  ‘Œ }}|	j8                  s|j;                  «       �Q|	j!                  d	t=        t>        j@                  «      gt        |«      z  ||jB                  jE                  «       ¬
«      }	tF        |v stH        |v r|	dfS |	jJ                  |k7  r+| j                  jM                  tN        jP                  |«       y|	j!                  |jB                  ¬«      |	fS c c}w c c}w c c}w c c}w )zÈTry to infer lambda expression type using context.

        Return None if could not infer type.
        The second item in the return type is the type_override parameter for check_func_item.
        r1  r  r   ©NN)r?  r-  r„  rÄ  NF)Úis_ellipsis_argsr³  r�  r�  )r�  ))rÍ   r  rø   rÈ   rÎ   r  r­   r‘  r  r  r  r³  r¡   rä  Úis_meta_varrQ  rc  r"   r?  r¯   rð  r-  r»   rQ  r¦  r§  r¸  rf  rÅ  rà  r¬   rÀ   r3  r�  rä  r:   r;   r�  rÙ  r   ÚCANNOT_INFER_LAMBDA_TYPE)r!  r,  rJ  rý   r÷  Ú
extra_varsr  rJ  Ú	meta_varsÚcallable_ctxr   r�  s               rî   rµ  z1ExpressionChecker.infer_lambda_type_using_context  s„  € ô ˜d×/Ñ/°Ñ3Ó4ˆä�cœ9Ô%ä+¨C×,>Ñ,>Ó,@ÓAöØÄZÐPQÔS_ÕE`’ðˆIð ô �9‹~ Ò"Ø ‘l�áœ* S¬,Ô7Øð �x‰x×Ñ×2Ò2ð ˆJØ—}‘}ò T�Ü*;¸CÓ*@ÖX BÀBÇEÁE×DUÑDUÕDWšRÐX�	ÐXØ×!Ñ!°	Ö"R¨"¸RÀzÒ=Q¢2Ò"RÕSðTð ×,Ñ,Ü*¨3¯<©<¼»ÓFÜ˜sŸ}™}Ó-°
Ñ:ð -ó ‰Lô
 +¨3´
³Ó=ˆJÜ˜j¬*Ô5¼*ÀZÔQ]Ô:^Ð^Ð^Ø%ˆLð $×1Ñ1¸4¿?¹?ÐK^Ó;_Ð1Ó`ˆà×"Ñ"Ð.°,×2FÑ2FÐ2Rð à)*¯©Ö5 #�S—X“XÐ5ˆ	Ð5à×(Ò(¨C¯N©NÓ,<Ð,Hà'×5Ñ5Ø!&Ü"¤9×#9Ñ#9Ó:Ð;¼cÀ)»nÑLØ#ØŸ+™+×*Ñ*Ó,ð	 6ó ˆLô �yÑ ¤I°Ñ$:à Ð%Ð%à×!Ñ! YÒ.à�H‰H�M‰MÔ*×CÑCÀQÔGØð ×)Ñ)°A·K±KÐ)Ó@À,ÐNÐNùòùò( YùÚ"Rùò( 6s*   ÁKÁKÃK	Ã$K	Ã9	K
ÄK
ÇKc                óÂ  — | j                  |«      }t        |t        «      r|\  }}n|S t        |«      }|€C| j                  j                  t        j                  |«       t        t        j                  «      S t        |«      }|€C| j                  j                  t        j                  |«       t        t        j                  «      S |j                  }d}||v r|j                  |«      }nˆ| j                  j                  j                  «       }	|	�bt!        ||	j"                  ¬«      rK|j$                  r?||j$                  j                  v r'|j$                  j                  }|j                  |«      }|€c|j&                  r||k7  r|j&                  sd}nC| j                  j                  t        j(                  |«       t        t        j                  «      S t+        |«      |dz   k(  rC| j                  j                  t        j,                  |«       t        t        j                  «      S ||dz   d D ]   }
|j.                  |
j0                  v s	|
|d   k(  sŒ$|j$                  r9|j$                  j2                  r#|
|d   k(  rt        t        j4                  «      c S t7        |j.                  |ddd||
|| j                  | j9                  «       ¬«
      c S  J d«       ‚)	z+Type check a super expression (non-lvalue).N)Úis_classmethodr1  r  FT)
r:  r°  rT  rª  r«  r¬  Úoverride_infor^  r  r­  r­  )Ú_super_arg_typesrø   rÂ  Útype_info_from_typer  rÙ  r   ÚUNSUPPORTED_ARG_1_FOR_SUPERr¬   rÀ   r;  ÚUNSUPPORTED_ARG_2_FOR_SUPERrý  rY  rK  Úcurrent_functionrÖ   Úis_classrÆ  r×  Ú!SUPER_ARG_2_NOT_INSTANCE_OF_ARG_1r‘  ÚTARGET_CLASS_HAS_NO_BASE_CLASSr:  re  r×  r3  r   rZ  )r!  r,  r   Ú	type_typerÌ  Ú	type_infoÚinstance_inforý  rY  rI  rw  s              rî   Úvisit_super_exprz"ExpressionChecker.visit_super_exprc  sd  € ð ×%Ñ% aÓ(ˆÜ�eœUÔ#Ø',Ñ$ˆI‘}àˆLô (¨	Ó2ˆ	ØÐØ�H‰H�M‰MÔ*×FÑFÈÔJÜœ9×/Ñ/Ó0Ð0ä+¨MÓ:ˆØÐ Ø�H‰H�M‰MÔ*×FÑFÈÔJÜœ9×/Ñ/Ó0Ð0à×Ñˆð ˆØ˜ÑØ—I‘I˜iÓ(‰Eà—X‘X—^‘^×4Ñ4Ó6ˆFð Ð!Ô&7Ø¨f¯o©oõ'ð —6’6˜i¨1¯6©6¯:©:Ñ5ØŸ&™&Ÿ*™*�CØŸI™I iÓ0�EØˆ=à×)Ò)Ø! YÒ.Ø!×-Ò-ð
 ‘à—‘—‘Ô.×PÑPÐRSÔTÜœy×3Ñ3Ó4Ð4äˆs‹8�u˜q‘yÒ Ø�H‰H�M‰MÔ*×IÑIÈ1ÔMÜœ9×/Ñ/Ó0Ð0à˜ ™	˜Ð$ò 	ˆDØ�v‰v˜Ÿ™Ñ# t¨s°2©w£Ø—6’6˜aŸf™f×4Ò4¸ÀÀRÁºô #¤9×#9Ñ#9Ó:Ò:ä,ØŸ™Ø%Ø#Ø!Ø %Ø"/Ø"&ØØŸ™Ø'+×'>Ñ'>Ó'@ôò ð	ð( 	$�mÓ#ˆurí   c                ó"  — | j                   j                  «       st        t        j                  «      S t        |j                  j                  «      dk(  �rL|j                  st        t        j                  «      S | j                   j                  j                  «       rC| j                   j                  t        j                  |«       t        t        j                  «      S t        |j                  «      }t!        |«      }| j                   j                  j#                  «       }|€J ‚|j$                  r)|j$                  d   j&                  j(                  xs |}�n0| j                   j                  t        j*                  |«       t        t        j                  «      S t,        |j                  j.                  v rC| j                   j                  t        j0                  |«       t        t        j                  «      S t3        |j                  j.                  «      t4        hk7  rC| j                   j                  t        j6                  |«       t        t        j                  «      S t        |j                  j                  «      dk(  rC| j                   j                  t        j8                  |«       t        t        j                  «      S t        |j                  j                  «      dk(  rZt;        | j=                  |j                  j                  d   «      «      }| j=                  |j                  j                  d   «      }nC| j                   j                  t        j>                  |«       t        t        j                  «      S tA        |t        «      rF|j                  rt!        t        |j                  «      «      }n�t        t        jB                  |¬«      S tA        |t         «      rb|jD                  }tA        |t        «      rF|j                  rt!        t        |j                  «      «      }nt        t        jB                  |¬«      S tA        |t         «      sUtA        |tF        «      r|jI                  «       s5| jJ                  jM                  ||«       t        t        j                  «      S t;        |«      }tA        |t        «      r@|j                  rt        |j                  «      }||fS t        t        jB                  |¬«      S tA        |t         «      re|jD                  }tA        |t        «      rI|j                  r"t!        t        |j                  «      «      }||fS t        t        jB                  |¬«      S ||fS )a*  
        Computes the types of the type and instance expressions in super(T, instance), or the
        implicit ones for zero-argument super() expressions.  Returns a single type for the whole
        super expression when possible (for errors, anys), otherwise the pair of computed types.
        r   r  r  r  )'r  r8  r¬   rÀ   r1  r‘  Úcallr�  rÆ  r;  rK  Úactive_classrÙ  r   Ú%SUPER_OUTSIDE_OF_METHOD_NOT_SUPPORTEDrÙ   rÁ   rÒ  r¸  r¹  r7  Ú(SUPER_ENCLOSING_POSITIONAL_ARGS_REQUIREDr:   r�  ÚSUPER_VARARGS_NOT_SUPPORTEDrd  r9   ÚSUPER_POSITIONAL_ARGS_REQUIREDÚ#SUPER_WITH_SINGLE_ARG_NOT_SUPPORTEDrÍ   rs  ÚTOO_MANY_ARGS_FOR_SUPERrø   r  rÂ  r±   rÀ  r  Ú%first_argument_for_super_must_be_type)r!  r,  Úcurrent_typerÖ  rI  rÌ  Ú	type_itemÚinstance_items           rî   rÎ  z"ExpressionChecker._super_arg_types¶  sÕ  € ð �x‰x×+Ñ+Ô-Üœ9×0Ñ0Ó1Ð1Ü�—‘—‘Ó Ó"Ø—6’6äœy×3Ñ3Ó4Ð4Ø—‘—‘×,Ñ,Ô.Ø—‘—‘Ô.×TÑTÐVWÔXÜœy×3Ñ3Ó4Ð4ô )¨¯©Ó0ˆLÜ$,¨\Ó$:ˆIð —X‘X—^‘^×4Ñ4Ó6ˆFØÐ%Ð%Ð%Ø×ÒØ&,×&6Ñ&6°qÑ&9×&BÑ&B×&GÑ&GÒ&WÈ<’à—‘—‘Ô.×WÑWÐYZÔ[Üœy×3Ñ3Ó4Ð4Ü˜Ÿ™×)Ñ)Ñ)Ø�H‰H�M‰MÔ*×FÑFÈÔJÜœ9×/Ñ/Ó0Ð0Ü�—‘×!Ñ!Ó"¤w iÒ/Ø�H‰H�M‰MÔ*×IÑIÈ1ÔMÜœ9×/Ñ/Ó0Ð0Ü�—‘—‘Ó Ò"Ø�H‰H�M‰MÔ*×NÑNÐPQÔRÜœ9×/Ñ/Ó0Ð0Ü�—‘—‘Ó Ò"Ü'¨¯©°A·F±F·K±KÀ±NÓ(CÓDˆIØ ŸK™K¨¯©¯©°A©Ó7‰Mà�H‰H�M‰MÔ*×BÑBÀAÔFÜœ9×/Ñ/Ó0Ð0ô �i¤Ô)Ø�vŠvÜ$¤]°1·6±6Ó%:Ó;‘	äœy×9Ñ9ÀiÔPÐPÜ˜	¤8Ô,Ø!Ÿ™ˆIÜ˜)¤WÔ-Ø—6’6Ü (¬°q·v±vÓ)>Ó ?‘Iä"¤9×#=Ñ#=È)ÔTÐTä˜)¤XÔ.Ü�y¤,Ô/°I×4IÑ4IÔ4Kà�H‰H×:Ñ:¸9ÀaÔHÜœ9×/Ñ/Ó0Ð0ô (¨Ó6ˆÜ�m¤WÔ-Ø�vŠvÜ -¨a¯f©fÓ 5�ð ˜-Ð'Ð'ô œy×9Ñ9ÀmÔTÐTÜ˜¤xÔ0Ø)×.Ñ.ˆMÜ˜-¬Ô1Ø—6’6Ü$,¬]¸1¿6¹6Ó-BÓ$C�Mð ˜-Ð'Ð'ô #¤9×#=Ñ#=È-ÔXÐXà˜-Ð'Ð'rí   c                ó  — g }|j                   |j                  |j                  fD ]>  }|r!|j                  | j	                  |«      «       Œ&|j                  t        «       «       Œ@ | j                  j                  d|«      S )Nzbuiltins.slice)rì  rí  rî  rù  rs  rµ   r  r\  )r!  r,  Ú	type_argsrY  s       rî   Úvisit_slice_exprz"ExpressionChecker.visit_slice_expr  sm   € Øˆ	Ø—m‘m Q§[¡[°!·(±(Ð;ò 	-ˆEÙØ× Ñ  §¡¨UÓ!3Õ4à× Ñ ¤£Õ,ð		-ð
 �x‰x×*Ñ*Ð+;¸YÓGÐGrí   c                ó<   — | j                  |j                  dd«      S )NrO  z<list-comprehension>©Ú check_generator_or_comprehensionÚ	generatorr  s     rî   Úvisit_list_comprehensionz*ExpressionChecker.visit_list_comprehension  s!   € Ø×4Ñ4Ø�K‰K˜Ð*@ó
ð 	
rí   c                ó<   — | j                  |j                  dd«      S )Nrß   z<set-comprehension>rë  r  s     rî   Úvisit_set_comprehensionz)ExpressionChecker.visit_set_comprehension  s!   € Ø×4Ñ4Ø�K‰K˜Ð)>ó
ð 	
rí   c                ó>  — t        |j                  «      sPt        |j                  «      s;t        d„ |j                  dd  D «       «      st        d„ |j
                  D «       «      rd}t        «       g}nd}t        «       t        «       g}| j                  ||d|¬«      S )Nc              3  ó2   K  — | ]  }t        |«      –— Œ y ­wrñ   ©r‘   )rô   Úsequences     rî   rö   z9ExpressionChecker.visit_generator_expr.<locals>.<genexpr>!  s   è ø€ ÒR°hÔ'¨×1ÑRùr÷   r  c              3  ó@   K  — | ]  }|D ]  }t        |«      –— Œ Œ y ­wrñ   ró  )rô   ÚcondlistÚconds      rî   rö   z9ExpressionChecker.visit_generator_expr.<locals>.<genexpr>"  s$   è ø€ Ò_°(ÐV^Ò_ÈdÔ'¨×-Ð_Ð-Ñ_ùs   ‚ztyping.AsyncGeneratorútyping.Generatorz<generator>)Úadditional_args)r¤  Úis_asyncr‘   rŒ  Ú	sequencesÚ	condlistsrµ   rì  )r!  r,  r°  rù  s       rî   Úvisit_generator_exprz&ExpressionChecker.visit_generator_expr  s‡   € ô �—
‘
ŒOÜ# A§K¡KÔ0ÜÑRÀ!Ç+Á+ÈaÈbÀ/ÔRÔRÜÑ_¸a¿k¹kÔ_Ô_à)ˆCä+3«:¨,‰Oà$ˆCä'›z¬8«:Ð6ˆOØ×4Ñ4Øˆs�M°?ð 5ó 
ð 	
rí   c                óL  — |xs g }| j                   j                  j                  dd¬«      5  | j                  |«       t	        ddt        dd¬«      g | j                  «       t        t        j                  «      ¬«      }t        |j                  t        «      r6|j                  j                  }| j                   j                  d	|g«      }d}n|j                  }|}d
}|g}	t        |gt         j"                  gdg| j                   j                  ||	|z   «      | j                   j%                  d«      ||g¬«      }
|rt&        j(                  }dt&        _        | j+                  |
|gt         j"                  g|«      }|rt&        _        |d   cddd«       S # 1 sw Y   yxY w)z:Type check a generator expression or a list comprehension.Tr   r°  rn  r1  z<genexp>ro  rq  r?  FNr„  rs  )r  r¬  r¶  Úcheck_for_comprÅ   rÂ   rR  r¬   rÀ   rt  rø   rŒ  rl   rŸ  r\  r­   r   r9   rQ  rØ   r  r™  )r!  ÚgenrÅ  Úid_for_messagesrù  rJ  rŒ  r  Úforce_infer_unionsÚtv_listrv  Úold_infer_unionsr°  s                rî   rì  z2ExpressionChecker.check_generator_or_comprehension/  s{  € ð *Ò/¨RˆØ�X‰X�_‰_×*Ñ*°DÀqÐ*ÓIñ -	Ø×Ñ Ô$ô ØØÜ˜R¨:Ô6ØØ ×,Ñ,Ó.Ü¤	× ?Ñ ?Ó@ôˆBô ˜#Ÿ-™-¬Ô2ØŸM™M×.Ñ.�	ð —h‘h×1Ñ1Ð2CÀbÀTÓJ�ð &*Ñ"àŸM™M�	Ø�Ø%*Ð"Ø#% $ˆGÜ&Ø�Ü—‘�Ø�Ø—‘×+Ñ+¨I°wÀÑ7PÓQØ—‘×#Ñ#Ð$7Ó8Ø$Ø˜$ôˆKñ "Ü#-×#:Ñ#:Ð Ø*.”
Ô'Ø—/‘/ +°	¨{¼U¿]¹]¸OÈSÓQˆCÙ!Ø*:”
Ô'Ø�q‘6÷[-	÷ -	ò -	ús   ®E"FÆF#c                óÜ  — | j                   j                  j                  dd¬«      5  | j                  |«       t	        ddt        dd¬«      g | j                  «       t        t        j                  «      ¬«      }t	        d	d	t        d
d¬«      g | j                  «       t        t        j                  «      ¬«      }|j                  €C| j                   j                  d||g«      g}t        j                  g}dg}|j                  g}d}nB||g}t        j                  t        j                  g}ddg}|j                  |j                  g}d}t        |||| j                   j                  d||g«      | j                   j!                  d«      d||g¬«      }	|rt"        j$                  }
dt"        _        | j'                  |	|||«      }|r
t"        _        |d   cddd«       S # 1 sw Y   yxY w)z&Type check a dictionary comprehension.Tr   r°  r“  r1  r”  ro  rq  r•  r–  Nry  FrS  r„  z<dictionary-comprehension>rs  )r  r¬  r¶  rÿ  rÅ   rÂ   rR  r¬   rÀ   rt  r  r\  r   r9   r¹  r­   rQ  rØ   r  r™  )r!  r,  ÚktdefÚvtdefr³  r�  r�  r�  r  rv  r  r°  s               rî   Úvisit_dictionary_comprehensionz0ExpressionChecker.visit_dictionary_comprehensiong  sË  € à�X‰X�_‰_×*Ñ*°DÀqÐ*ÓIñ 3	Ø×Ñ Ô"ô  ØØÜ˜R¨8Ô4ØØ ×,Ñ,Ó.Ü¤	× ?Ñ ?Ó@ôˆEô  ØØÜ˜R¨8Ô4ØØ ×,Ñ,Ó.Ü¤	× ?Ñ ?Ó@ôˆEð �u‰uˆ}ð —H‘H×/Ñ/Ð0RÐUZÐ\aÐTbÓcð�	ô #Ÿ]™]˜O�	Ø!˜F�	ØŸ™�y�Ø%)Ñ"à" E˜N�	Ü"Ÿ]™]¬E¯M©MÐ:�	Ø! 4˜L�	ØŸ™˜qŸw™wÐ'�Ø%*Ð"Ü&ØØØØ—‘×+Ñ+¨O¸eÀU¸^ÓLØ—‘×#Ñ#Ð$7Ó8Ø1Ø  %˜.ôˆKñ "Ü#-×#:Ñ#:Ð Ø*.”
Ô'Ø—/‘/ +¨t°YÀÓBˆCÙ!Ø*:”
Ô'Ø�q‘6÷g3	÷ 3	ò 3	ús   ¨F0G"Ç"G+c                óØ  — t        |j                  |j                  |j                  |j                  «      D �]°  \  }}}}|r| j
                  j                  |«      \  }}no| j
                  j                  |«      \  }}t        t        |«      t        «      r8t        |t        «      r(|j                  dk(  rt        t        j                  «      }| j
                  j!                  ||d|«       |D ]õ  }| j#                  |«       | j
                  j%                  |«      \  }	}
| j
                  j'                  |	«       t(        j*                  | j
                  j,                  j.                  v sŒ~t0        j2                  j5                  |	«      r| j6                  j9                  d|«       Œºt0        j2                  j5                  |
«      sŒÚ| j6                  j9                  d|«       Œ÷ �Œ³ y)zÌCheck the for_comp part of comprehensions. That is the part from 'for':
        ... for x in y if z

        Note: This adds the type information derived from the condlists to the current binder.
        r$  TFN)rä  Úindicesrû  rü  rú  r  Ú analyze_async_iterable_item_typeÚanalyze_iterable_item_typerø   rÍ   rÇ   r_   r:  r¬   rÀ   r3  Úanalyze_index_variablesrs  r©  Úpush_type_maprò  r«  r  r¬  r’  r“  rª  r  Ú$redundant_condition_in_comprehension)r!  r,  rY  rô  Ú
conditionsrú  r$  Úsequence_typeÚ	conditionÚtrue_mapÚ	false_maps              rî   rÿ  z ExpressionChecker.check_for_compž  sv  € ô 69Ø�I‰I�q—{‘{ A§K¡K°·±ó6
ó 	WÑ1ˆE�8˜Z¨ñ Ø#'§8¡8×#LÑ#LÈXÓ#VÑ �‘=à#'§8¡8×#FÑ#FÀxÓ#PÑ ��=äœ¨}Ó=¼ÔOÜ" 5¬(Ô3ØŸ
™
 cÒ)ô %,¬I×,BÑ,BÓ$C�Mà�H‰H×,Ñ,¨U°MÀ4ÈÔKØ'ò W�	Ø—‘˜IÔ&ð '+§h¡h×&DÑ&DÀYÓ&OÑ#�˜)Ø—‘×&Ñ& xÔ0ä×'Ñ'¨4¯8©8×+;Ñ+;×+OÑ+OÒOÜ—|‘|×6Ñ6°xÔ@ØŸ™×EÑEÀeÈYÕWÜŸ™×8Ñ8¸ÕCØŸ™×EÑEÀdÈIÕVòWñ!	Wrí   c                ó‚  — | j                  |j                  «       | j                  d   }| j                  j	                  |j                  «      \  }}t
        j                  | j                  j                  j                  v r‹t        j                  j                  |«      r'| j                  j                  d|j                  «       nEt        j                  j                  |«      r&| j                  j                  d|j                  «       |€g| j                  ||j                  ||¬«      }| j                  ||j                   ||¬«      }t#        |«      r|}nt#        |«      r|}nt%        ||g«      }| j                  ||j                  ||¬«      }| j                  ||j                   ||¬«      }	t%        ||	g«      }
t'        |
«      rrt)        t+        | j                  d   «      t,        «      sLt/        j0                  ||	«      }t+        |«      }t)        |t2        «      r|j4                  j6                  dk7  r|}
|
S )Nr1  FT)r^  ro  ra  )rs  r÷  r  r  r©  rò  r«  r  r¬  r’  r“  rª  r  Úredundant_condition_in_ifr°  Úif_exprÚ	else_exprr  r¤   rÁ  rø   rÍ   rÈ   r   r`  r²   r7  r>  )r!  r,  ro  rJ  Úif_mapÚelse_mapÚctx_if_typeÚctx_else_typeÚif_typeÚ	else_typer°  ÚalternativeÚp_alts                rî   Úvisit_conditional_exprz(ExpressionChecker.visit_conditional_exprÁ  sì  € Ø�‰�A—F‘FÔØ×,Ñ,¨RÑ0ˆð  Ÿ8™8×9Ñ9¸!¿&¹&ÓAÑˆ�Ü×Ñ 4§8¡8×#3Ñ#3×#GÑ#GÑGÜ�|‰|×.Ñ.¨vÔ6Ø—‘×2Ñ2°5¸!¿&¹&ÕAÜ—‘×0Ñ0°Ô:Ø—‘×2Ñ2°4¸¿¹Ô@àˆ;ð
 ×2Ñ2Ø˜Ÿ	™	¨3ÐBSð 3ó ˆKð !×4Ñ4Ø˜!Ÿ+™+¨sÐFWð 5ó ˆMô 3°;Ô?Ø#‘Ü4°]ÔCØ!‘ä+¨[¸-Ð,HÓI�à×*Ñ*Ø�A—I‘I sÐ>Oð +ó 
ˆð ×,Ñ,Ø�a—k‘k¨3ÐBSð -ó 
ˆ	ô *¨7°IÐ*>Ó?ˆÜ$ SÔ)´*Ü˜D×-Ñ-¨bÑ1Ó2´Iô3
ô Ÿ/™/¨'°9Ó=ˆKÜ# KÓ0ˆEÜ˜e¤XÔ.°%·*±*×2EÑ2EÐIZÒ2ZØ!�Øˆ
rí   c                óÈ  — | j                   j                  j                  dd¬«      5  t        j                  j                  |«      rL| j                  j                  |¬«      5  | j                  |||¬«       d d d «       t        «       cd d d «       S | j                   j                  |«       | j                  |||¬«      cd d d «       S # 1 sw Y   ŒTxY w# 1 sw Y   y xY w)NTr   r°  )rO  r%  )r  r¬  r¶  r’  r“  rª  r  rO  rs  rÇ   r  )r!  rË  r+  r^  ro  Úsuppress_unreachable_errorss         rî   r°  z%ExpressionChecker.analyze_cond_branchò  sÍ   € ð �X‰X�_‰_×*Ñ*°DÀqÐ*ÓIñ 		`Ü�|‰|×.Ñ.¨sÔ3ð —X‘X×+Ñ+Ð:UÐ+ÓVñ aØ—K‘K °7ÐN_�KÔ`÷aä&Ó(÷		`ñ 		`ð �H‰H×"Ñ" 3Ô'Ø—;‘;˜t°'ÐM^�;Ó_÷		`ñ 		`÷
að aú÷		`ð 		`ús)   ¨<CÁ$CÁ9CÂ.CÃC	ÃCÃC!c                óÔ   — g }|�t        |«      r|S |j                  |«       | j                  r-| j                  d   �|j                  | j                  d   «       |rt        |«      S y r  )rÌ  rù  r  r¤   )r!  ÚtyÚ	ctx_itemss      rî   r±  z#ExpressionChecker._combined_context  sl   € Øˆ	Øˆ>Ü˜BÔð �	Ø×Ñ˜RÔ Ø×Ò ×!2Ñ!2°2Ñ!6Ð!BØ×Ñ˜T×.Ñ.¨rÑ2Ô3ÙÜ(¨Ó3Ð3Ørí   c                ó 
  ‡— || j                   v r| j                   |   S d}| j                  r)| j                  st        j                  «       }d| _        d}| j
                  j                  |«       | j                  }|| _        	 t        |«      }	|r%t        |t        «      r| j                  |d¬«      }
�n†|r%t        |t        «      r| j                  |d¬«      }
�n_|r%t        |t        «      r| j                  |d¬«      }
�n8|r%t        |t         «      r| j#                  |d¬«      }
�nt        |	t$        «      rN|	j&                  rB| j)                  |«      x}�/t%        j*                  ||j,                  |j.                  d¬«      }
�n³t        |	t0        «      rƒt3        ˆfd„|	j4                  D «       «      re| j)                  |«      x}�Rt%        j*                  ||j,                  |j.                  d¬«      }t7        ||	«      r|}
�n5|j9                  | «      }|}
�n t        |t        t:        t<        t>        t@        f«      rê| jB                  sÞ| jD                  jF                  sÈ| jD                  jH                  jJ                  s¨||f| jL                  v r„| jL                  ||f   \  }}
}}|| jD                  jN                  jP                  k(  r7| jD                  jS                  |«       | jT                  jW                  |«       n9| jY                  ||¬«      }
n%| jY                  ||¬«      }
n|j9                  | «      }
|| _        | j
                  jc                  «        
€J ‚| jD                  je                  ||
«       | jD                  jH                  jf                  ro|sm| jD                  jh                  sW| jD                  jk                  «       r=tm        |
«      r2| jD                  jF                  s| jT                  jo                  |
|«       | jD                  jk                  «       r| jD                  jF                  rtq        tr        jt                  «      }n|
}|r=| jv                  |j,                  xx   t        j                  «       z
  z  cc<   d| _        |S # tZ        $ rj}t]        || jD                  j^                  j`                  |j,                  | jD                  j^                  | jD                  jH                  «       Y d}~�ŒËd}~ww xY w)zÝType check a node in the given type context.  If allow_none_return
        is True and this expression is a call, allow it to return None.  This
        applies only to this expression and not any subexpressions.
        FTrn  Nr  c              3  óp   •K  — | ]-  }t        t        |«      xŠt        «      xr ‰j                  –— Œ/ y ­wrñ   )rø   rÍ   rÁ   r  )rô   rÂ  Úp_items     €rî   rö   z+ExpressionChecker.accept.<locals>.<genexpr>G  s8   øè ø€ ò àô ¬¸Ó)>Ð>˜vÄÓIÒaÈf×NaÑNaÓañùs   ƒ36r  )<r  r  r  ÚtimeÚperf_counter_nsr  rù  r  rÍ   rø   rG   rt  r   Úvisit_yield_from_exprrK   r!  rE   Úvisit_await_exprrÁ   r  Útry_parse_as_type_expressionrì  r@  rA  rÈ   r¤  rû   rŒ   rs  rZ   rs   rN   rb   r  r  rh  r  Údisable_expression_cacher  r¬  r½  rÍ  r  ré  Úaccept_maybe_cacheÚ	Exceptionr%   r_  Úfiler»  r·  Údisallow_any_exprÚis_stubr8  rÌ  Údisallowed_any_typer¬   rÀ   r1  r  )r!  r+  r  ro  r†  r  Úrecord_timeÚt0Úold_is_calleeÚp_type_contextr°  Únode_as_typeÚtyp1Útyp2rÂ  ÚmessagesÚtype_mapr�  r-  r)  s                      @rî   rs  zExpressionChecker.accept  s  ø€ ð �4×&Ñ&Ñ&à×&Ñ& tÑ,Ð,àˆØ×+Ò+°D×4FÒ4FÜ×%Ñ%Ó'ˆBØ!%ˆDÔØˆKØ×Ñ× Ñ  Ô.ØŸ™ˆØ"ˆŒðB	Ü,¨\Ó:ˆNÙ ¤Z°´hÔ%?Ø×*Ñ*¨4À4Ð*ÓH’Ù"¤z°$¼Ô'FØ×0Ñ0°ÈÐ0ÓN’Ù"¤z°$¼Ô'HØ×1Ñ1°$È$Ð1ÓO’Ù"¤z°$¼	Ô'BØ×+Ñ+¨DÀDÐ+ÓI’ô ˜>¬8Ô4Ø"×/Ò/Ø%)×%FÑ%FÀtÓ%LÐL�\ÐYä×.Ñ.Ø Ø%×*Ñ*Ø'×.Ñ.Ø!%ô	’ô ˜>¬9Ô5Üó à .× 4Ñ 4ôô ð &*×%FÑ%FÀtÓ%LÐL�\ÐYä×/Ñ/Ø Ø%×*Ñ*Ø'×.Ñ.Ø!%ô	�ô ˜d NÔ3Ø’CàŸ;™; tÓ,�DØ’Cô ˜4¤(¬H´iÄÌ6Ð!RÔSØ×,Ò,°·±×0NÒ0NØŸ™×(Ñ(×AÒAà˜,Ð'¨4¯?©?Ñ:Ø>B¿o¹oÈtÐUaÐNbÑ>cÑ;�N C¨°8Ø%¨¯©¯©×)@Ñ)@Ò@ØŸ™×,Ñ,¨XÔ6ØŸ™×+Ñ+¨HÕ5à"×5Ñ5°dÈÐ5ÓV™à×1Ñ1°$À\Ð1ÓR‘Cà—k‘k $Ó'�ð
 'ˆŒØ×Ñ×ÑÔØˆÐˆØ�‰×Ñ˜D #Ô&ð �H‰H×Ñ×.Ò.Ù$Ø—H‘H×$Ò$Ø—‘×,Ñ,Ô.Ü˜SÔ!Ø—H‘H×2Ò2à�H‰H×(Ñ(¨¨dÔ3à�x‰x×+Ñ+Ô-°·±×1OÒ1OÜ"¤9×#8Ñ#8Ó9‰FàˆFÙØ×*Ñ*¨4¯9©9Ó5¼×9MÑ9MÓ9OÐRTÑ9TÑTÓ5Ø!&ˆDÔØˆøô5 ò 	Ü!Ø�T—X‘X—_‘_×)Ñ)¨4¯9©9°d·h±h·o±oÀtÇxÁx×GWÑGW÷ò ûð	ús   ÂJ8R Ò	TÒ#ATÔTc                óJ  — | j                   j                  j                  }| j                  j	                  dd¬«      5 }| j                   j
                  5 }|j                  | «      }d d d «       d d d «       j                  «       }|| j                   j                  j                  k(  r+| j                   j                  s||f| j                  ||f<   | j                   j                  «       | j                  j                  |«       S # 1 sw Y   Œ§xY w# 1 sw Y   Œ«xY w)NT)rO  rÐ  )r  r¬  r½  r  rO  r>  rs  rê  rh  r  rÍ  ré  )r!  r+  r  rÂ  r  r>  r°  r=  s           rî   r0  z$ExpressionChecker.accept_maybe_cacheŠ  sî   € ØŸ™Ÿ™×0Ñ0ˆØ�X‰X×#Ñ#°$ÈTÐ#ÓRð 	(ÐVYØ—‘×(Ñ(ð (¨HØ—k‘k $Ó'�÷(÷	(ð ×&Ñ&Ó(ˆØ˜TŸX™XŸ_™_×4Ñ4Ò4¸T¿X¹X×=[Ò=[Ø5CÀSÈ(ÐT\Ð4]ˆD�O‰O˜T <Ð0Ñ1Ø�‰×Ñ˜XÔ&Ø�‰×Ñ˜HÔ%Øˆ
÷(ð (ú÷	(ð 	(ús#   ¾DÁDÁ'DÄD	ÄDÄD"c                ó8   — | j                   j                  |«      S )z}Return an instance type with type given by the name and no type
        arguments. Alias for TypeChecker.named_type.
        )r  rQ  )r!  r:  s     rî   rQ  zExpressionChecker.named_type–  s   € ð �x‰x×"Ñ" 4Ó(Ð(rí   c                óŒ   — | j                   j                  j                  dk\  r| j                  d«      S | j                  d«      S )zFReturns a `typing.TypeAliasType` or `typing_extensions.TypeAliasType`.)r0  é   ztyping.TypeAliasTypeztyping_extensions.TypeAliasType)r  r  r7  rQ  r%  s    rî   r;  z&ExpressionChecker.type_alias_type_typeœ  s:   € à�8‰8×Ñ×*Ñ*¨gÒ5Ø—?‘?Ð#9Ó:Ð:Ø�‰Ð@ÓAÐArí   c           	     óØ   — t        |«      }t        |t        t        t        t
        f«      xs> t        || j                  j                  dt        t        j                  «      g«      «      S )z$Is a type valid as a *args argument?r?  )rÍ   rø   r¼   r¬   r¹   rÉ   rŒ   r  r\  rÀ   r3  rï  s     rî   rz  z"ExpressionChecker.is_valid_var_arg¢  sW   € ä˜cÓ"ˆÜ˜#¤	¬7´MÄ:ÐNÓOò 
ÔS]Ø�—‘×,Ñ,Ð->ÄÌ×I_ÑI_ÓA`Ð@aÓbóT
ð 	
rí   c           
     óú  — t        |«      }t        |t        «      xrC |j                  j                  dk(  xr( t        |j                  d   | j                  d«      «      xsš t        |t        «      xsˆ t        || j                  j                  d| j                  d«      t        t        j                  «      g«      «      xs8 t        || j                  j                  dt        «       t        «       g«      «      S )z'Is a type valid as a **kwargs argument?rS  r   r&  ry  )rÍ   rø   r²   r7  r>  rŒ   r�  rQ  r¹   r  r\  r¬   rÀ   r3  rÇ   rï  s     rî   r|  z*ExpressionChecker.is_valid_keyword_var_arg©  sÞ   € ä˜cÓ"ˆô
 ˜3¤Ó)ò MØ—H‘H×%Ñ%¨Ñ8òMä˜sŸx™x¨™{¨D¯O©O¸NÓ,KÓLòô ˜#œ}Ó-òô ØØ—‘×+Ñ+Ø6Ø—_‘_ ^Ó4´g¼i×>TÑ>TÓ6UÐVóóòô ØØ—‘×+Ñ+Ø6¼Ó9JÌOÓL]Ð8^óóð!	
rí   c                ó<   — | j                   j                  ||«       y)zÁCalled when we can't infer the type of a variable because it's not ready yet.

        Either defer type checking of the enclosing function to the next
        pass or report an error.
        N)r  r9  )r!  r:  r^  s      rî   Únot_ready_callbackz$ExpressionChecker.not_ready_callbackÄ  s   € ð 	�‰×-Ñ-¨d°GÕ<rí   c                ó  — | j                   j                  d   }| j                   j                  |d«      }|j                  €dt	        t        |«      t        t        f«      s�| j                   j                  «       ru| j                   j                  t        j                  |«       nJ| j                  |j                  |«      }| j                   j                  |||t        j                  dd«       | j                   j                  |d«      S )Nr1  Fúactual typeúexpected type)r  rÐ  Úget_generator_yield_typerŸ  rø   rÍ   rµ   r¬   r8  rÙ  r   ÚYIELD_VALUE_EXPECTEDrs  r  ÚINCOMPATIBLE_TYPES_IN_YIELDÚget_generator_receive_type)r!  r,  Úreturn_typeÚexpected_item_typeÚactual_item_types        rî   Úvisit_yield_exprz"ExpressionChecker.visit_yield_exprÌ  sÍ   € Ø—h‘h×+Ñ+¨BÑ/ˆØ!ŸX™X×>Ñ>¸{ÈEÓRÐØ�6‰6ˆ>äœÐ/AÓBÄXÌwÐDWÔXØ—H‘H×0Ñ0Ô2à—‘—‘Ô.×CÑCÀQÕGà#Ÿ{™{¨1¯6©6Ð3EÓFÐØ�H‰H×"Ñ"Ø Ø"ØÜ ×<Ñ<ØØôð �x‰x×2Ñ2°;ÀÓFÐFrí   c                óÆ  — | j                   d   }|�| j                  j                  d|g«      }t        | j	                  |j
                  |«      «      }t        |t        «      rt        t        j                  |¬«      S | j                  ||t        j                  «      }|s?t        t        |«      t        «      r&| j                  j                  j                  d |«       |S )Nr1  útyping.Awaitabler  )r  r  r\  rÍ   rs  rŸ  rø   r¬   rÀ   r  Úcheck_awaitable_exprr   ÚINCOMPATIBLE_TYPES_IN_AWAITrµ   r  r¯  )r!  r,  ro  Úexpected_typerq  r]  s         rî   r-  z"ExpressionChecker.visit_await_exprá  sµ   € Ø×)Ñ)¨"Ñ-ˆØÐ$Ø ŸH™H×7Ñ7Ð8JÈ]ÈOÓ\ˆMÜ% d§k¡k°!·&±&¸-Ó&HÓIˆÜ�k¤7Ô+Üœ9×5Ñ5À+ÔNÐNØ×'Ñ'Ø˜Ô,×HÑHó
ˆñ !¤Z´ÀÓ0DÄhÔ%OØ�H‰H�L‰L×.Ñ.¨t°QÔ7Øˆ
rí   c                ó˜  — | j                   j                  || j                  d«      ||dd«      st        t        j
                  «      S | j                  d|g g |«      d   }| j                   j                  |d«      }t        |«      }|s@t        |t        «      r0|j                  s$| j                   j                  j                  «        |S )zyCheck the argument to `await` and extract the type of value.

        Also used by `async for` and `async with`.
        rS  rH  rI  Ú	__await__r   F)r  r  rQ  r¬   rÀ   r3  rX  Úget_generator_return_typerÍ   rø   rÇ   r«  r¬  r­  )r!  rý   rJ  r  Úignore_binderrí  r?  s          rî   rT  z&ExpressionChecker.check_awaitable_exprï  s­   € ð �x‰x×%Ñ%Øˆt�‰Ð1Ó2°C¸¸mÈ_ô
ô œ9×1Ñ1Ó2Ð2à×6Ñ6°{ÀAÀrÈ2ÈsÓSÐTUÑVˆIØ—x‘x×9Ñ9¸)ÀUÓKˆHÜ& xÓ0ˆHá!Ü˜x¬Ô9Ø ×*Ò*à—‘—‘×+Ñ+Ô-ØˆOrí   c                óÚ  — | j                   j                  d   }t        | j                  |j                  «      «      }t        |t        «      rt        t        j                  |¬«      }�n1| j                   j                  |«      rŸt        |«      r1t        |«      s&| j                   j                  j                  ||«       t        t        j                  «      }| j                   j                  d|||g«      }|j!                  |«       | j#                  d|g g |¬«      \  }}nwt        |«      rt        |«      s@| j                   j                  j                  ||«       t        t        j$                  «      }n!| j'                  ||t(        j*                  «      }| j                   j-                  |d«      }	| j                   j-                  |d«      }
| j                   j/                  |
|	|t(        j*                  dd«       t        |«      }| j                   j1                  |d¬	«      }|s?t        t        |«      t2        «      r&| j                   j                  j5                  d |«       |S )
Nr1  r  rø  Ú__iter__r1  FrH  rI  )Úis_coroutine)r  rÐ  rÍ   rs  rŸ  rø   r¬   rÀ   r  r<  Úis_async_defÚhas_coroutine_decoratorr  Úyield_from_invalid_operand_typer3  r\  r  rX  r;  rT  r   Ú INCOMPATIBLE_TYPES_IN_YIELD_FROMrJ  r  rY  rµ   r¯  )r!  r,  ro  rN  Úsubexpr_typeÚ	iter_typerò  Úgeneric_generator_typer$  rO  rP  Ú	expr_types               rî   r,  z'ExpressionChecker.visit_yield_from_expr  sõ  € ð —h‘h×+Ñ+¨BÑ/ˆô
 ' t§{¡{°1·6±6Ó':Ó;ˆô �l¤GÔ,Ü%¤i×&@Ñ&@È\ÔZŠIØ�X‰X×&Ñ& |Ô4Ü˜LÔ)Ô2IÈ+Ô2VØ—‘—‘×<Ñ<¸\È1ÔMäœy×5Ñ5Ó6ˆHØ%)§X¡X×%@Ñ%@Ø" X¨x¸Ð$Bó&Ð"ð #×+Ñ+¨AÔ.Ø×9Ñ9Ø˜L¨"¨bÐ:Pð :ó ‰LˆI‘qô ! Ô.Ô3JÈ;Ô3WØ—‘—‘×<Ñ<¸\È1ÔMÜ#¤I×$8Ñ$8Ó9‘	à ×5Ñ5Ø  !Ô%5×%VÑ%Vó�	ð "ŸX™X×>Ñ>¸{ÈEÓRÐØŸ8™8×<Ñ<¸YÈÓNÐà�‰×ÑØØØÜ×=Ñ=ØØô	
ô $ IÓ.ˆ	Ø—H‘H×6Ñ6°yÈuÐ6ÓUˆ	á ¤Z´À	Ó0JÌHÔ%UØ�H‰H�L‰L×.Ñ.¨t°QÔ7ØÐrí   c                ó   — |j                   S rñ   ©r7  r  s     rî   Úvisit_temp_nodez!ExpressionChecker.visit_temp_nodeB  ó   € Ø�v‰vˆrí   c                óª  ‡— t        |j                  «      Št        ‰t        «      r‰j                  t
        j                  k(  sxt        ‰|j                  «      s| j                  j                  d|«       |j                  r:t        ˆfd„|j                  D «       «      s| j                  j                  d|«       t        t
        j                  «      S )Nz3TypeVar default must be a subtype of the bound typec              3  ó6   •K  — | ]  }t        ‰|«      –— Œ y ­wrñ   ©r‹   )rô   r¹  Ú	p_defaults     €rî   rö   z8ExpressionChecker.visit_type_var_expr.<locals>.<genexpr>M  s   øè ø€ Ò#YÀu¤L°¸E×$BÑ#Yùó   ƒz3TypeVar default must be one of the constraint types)rÍ   rr  rø   r¬   Útype_of_anyrÀ   rt  rŒ   r¸  r  rÙ  rÿ  r¤  r3  )r!  r,  rm  s     @rî   Úvisit_type_var_exprz%ExpressionChecker.visit_type_var_exprE  s‘   ø€ Ü# A§I¡IÓ.ˆ	ä�y¤'Ô*Ø×%Ñ%¬×)HÑ)HÒHä˜i¨¯©Ô7Ø—‘—‘ÐSÐUVÔWØ�xŠx¤Ó#YÐPQ×PXÑPXÔ#YÔ YØ—‘—‘ÐSÐUVÔWÜ”y×-Ñ-Ó.Ð.rí   c                ó4   — t        t        j                  «      S rñ   ©r¬   rÀ   r3  r  s     rî   Úvisit_paramspec_exprz&ExpressionChecker.visit_paramspec_exprQ  ó   € Ü”y×-Ñ-Ó.Ð.rí   c                ó4   — t        t        j                  «      S rñ   rr  r  s     rî   Úvisit_type_var_tuple_exprz+ExpressionChecker.visit_type_var_tuple_exprT  rt  rí   c                ó4   — t        t        j                  «      S rñ   rr  r  s     rî   Úvisit_newtype_exprz$ExpressionChecker.visit_newtype_exprW  rt  rí   c                óx  — |j                   j                  }|rŠ| j                  j                  j                  r(t        |«      r| j                  j                  d||«       t        || j                  j                  | j                  j                  | j                  |¬«       t        t        j                  «      S )NzNamedTuple typer1  )rÆ  Ú
tuple_typer  r  r  r—   r  r  r•   r  r¬   rÀ   r3  )r!  r,  rz  s      rî   Úvisit_namedtuple_exprz'ExpressionChecker.visit_namedtuple_exprZ  s‹   € Ø—V‘V×&Ñ&ˆ
ÙØ�x‰x×Ñ×7Ò7Ô<XØô=ð —‘×4Ñ4Ð5FÈ
ÐTUÔVÜ"Ø˜DŸH™H×,Ñ,¨d¯h©h×.GÑ.GÈÏÉÐ[\õô ”y×-Ñ-Ó.Ð.rí   c                ód  — t        |j                  |j                  «      D ]u  \  }}|€Œ	| j                  |«      }t	        t        |«      t        «      rŒ4|j                  j                  |   j                  }t	        |t        «      sŒh||_        d|_        Œw t        t        j                  «      S ©NT)rä  rû   rÿ  rs  rø   rÍ   r¬   rÆ  re  r+  r}   r7  rÒ  rÀ   r3  )r!  r,  r:  r¹  r°  r6  s         rî   Úvisit_enum_call_exprz&ExpressionChecker.visit_enum_call_exprf  sŒ   € Ü˜qŸw™w¨¯©Ó1ò 	/‰KˆD�%ØÑ Ø—k‘k %Ó(�Ü!¤/°#Ó"6¼Õ@ØŸ&™&Ÿ,™, tÑ,×1Ñ1�CÜ! #¤sÕ+ð
 $'˜œØ*.˜�ð	/ô ”y×-Ñ-Ó.Ð.rí   c                ó4   — t        t        j                  «      S rñ   rr  r  s     rî   Úvisit_typeddict_exprz&ExpressionChecker.visit_typeddict_expru  rt  rí   c                ó   — |j                   S rñ   rg  r  s     rî   Úvisit__promote_exprz%ExpressionChecker.visit__promote_exprx  ri  rí   c                ó8   — | j                  |j                  «      S rñ   )rs  rŸ  r  s     rî   Úvisit_star_exprz!ExpressionChecker.visit_star_expr{  s   € à�{‰{˜1Ÿ6™6Ó"Ð"rí   c                ó$   — | j                  d«      S )zReturn instance type 'object'.ra  r&  r%  s    rî   rR  zExpressionChecker.object_type  s   € à�‰Ð0Ó1Ð1rí   c                ó$   — | j                  d«      S )zReturn instance type 'bool'.rY  r&  r%  s    rî   rW  zExpressionChecker.bool_typeƒ  s   € à�‰˜Ó/Ð/rí   c                 ó   — y rñ   rì   )r!  rŸ  Ú
known_types      rî   r)  z)ExpressionChecker.narrow_type_from_binder‡  s   € ØSVrí   c                 ó   — y rñ   rì   )r!  rŸ  rˆ  r¯  s       rî   r)  z)ExpressionChecker.narrow_type_from_binderŠ  s   € ð rí   c                óF  — t        |«      t        k\  rŽ| j                  j                  j	                  |«      }|rgt        t        |«      t        «      r| j                  j                  s8|rt        ||«      syt        ||«      }t        t        |«      t        «      r|S |S |S )zÎNarrow down a known type of expression using information in conditional type binder.

        If 'skip_non_overlapping' is True, return None if the type and restriction are
        non-overlapping.
        N)r/   r>   r  r¬  rË  rø   rÍ   r¬   rh  r2   r3   rÇ   )r!  rŸ  rˆ  r¯  Úrestrictionr.  s         rî   r)  z)ExpressionChecker.narrow_type_from_binder�  s‰   € ô �4‹=œLÒ(ØŸ(™(Ÿ/™/×-Ñ-¨dÓ3ˆKñ Üœ?¨:Ó6¼Ô@ÀTÇXÁX×EcÒEcñ (Ô0DÀZÐQ\Ô0]ØÜ/°
¸KÓH�Üœo¨hÓ7¼ÔIð 'Ð&Ø�ØÐrí   c                óÌ   ‡ — t        |t        «      rBt        |t        «      r2t        ˆ fd„t        |j                  |j                  «      D «       «      S ‰ j                  ||«      S )Nc              3  ól   •K  — | ]+  \  }}‰j                  t        |«      t        |«      «      –— Œ- y ­wrñ   )Úhas_abstract_typerÍ   )rô   Úcallerr�  r!  s      €rî   rö   z;ExpressionChecker.has_abstract_type_part.<locals>.<genexpr>®  s5   øè ø€ ò á"�F˜Fð ×&Ñ&¤°vÓ'>ÄÐPVÓ@W×Xñùs   ƒ14)rø   r¼   r¤  rä  rû   rŽ  ©r!  rœ  r´  s   `  rî   r—  z(ExpressionChecker.has_abstract_type_part«  sX   ø€ ä�k¤9Ô-´*¸[Ì)Ô2TÜó ä&)¨+×*;Ñ*;¸[×=NÑ=NÓ&Oôó ð ð ×%Ñ% k°;Ó?Ð?rí   c                óÌ  — t        |t        «      xrÓ t        |t        «      xrÁ |j                  «       xr¯ |j	                  «       j
                  xs |j	                  «       j                  xrw t        |j                  t        «      xr[ |j                  j                  j
                  xs  |j                  j                  j                  xr | j                  j                   S rñ   )rø   r±   rÁ   rÀ  rÖ  rÖ  r×  rÂ  r²   r7  r  Úallow_abstract_callr�  s      rî   rŽ  z#ExpressionChecker.has_abstract_type´  s¿   € ä�{¤LÓ1ò 1Ü˜;¬Ó1ò1à×'Ñ'Ó)ò1ð ×(Ñ(Ó*×6Ñ6Ò_¸+×:QÑ:QÓ:S×:_Ñ:_ò1ô ˜;×+Ñ+¬XÓ6ò	1ð
 ×!Ñ!×&Ñ&×2Ñ2ÒW°k×6FÑ6F×6KÑ6K×6WÑ6Wò1ð —H‘H×0Ñ0Ð0ð	
rí   c           	     óú  — t        |t        «      syt        |t        t        t        f«      r)|j
                  t        j                  k7  r|j
                  S t        |«      r-| j                  j                  d|t        j                  ¬«       yt        |«      \  }}|D �ci c]'  }|j                  t        t         |j"                  «      “Œ) c}|D �ci c]*  }t%        |«      x}�|t        t         |j"                  «      “Œ, c}z  }t&        j(                  j+                  | j                  |«      }t-        |t/        «       | j0                  | j                  j2                  | j                  j4                  | j                  j6                  «      }	 t9        || j                  j2                  | j                  j6                  «      }	|	j;                  |«      }
|j<                  ry|
S c c}w c c}w # t>        $ r Y yw xY w)aö  Try to parse a value Expression as a type expression.
        If success then return the type that it spells.
        If fails then return None.

        A value expression that is parsable as a type expression may be used
        where a TypeForm is expected to represent the spelled type.

        Unlike SemanticAnalyzer.try_parse_as_type_expression()
        (used in the earlier SemanticAnalyzer pass), this function can only
        recognize type expressions which contain no string annotations.NzlTypeForm containing a string annotation cannot be recognized here. Surround with TypeForm(...) to recognize.rî  ) rø   r[   rm   rV   rb   Úas_typera   ÚVALUEr’   r  rÙ  rò  ÚMAYBE_UNRECOGNIZED_STR_TYPEFORMr�   r:  rp   rA   r+  r€   r’  r“  ÚTypeCheckerAsSemanticAnalyzerr”   r“   r  r  Útreer  r+   rs  Údid_failr*   )r!  Úmaybe_type_exprÚ
name_exprsÚmember_exprsr,  Úe_nameÚsym_for_nameÚchk_semÚtpanr;  r<  s              rî   r.  z.ExpressionChecker.try_parse_as_type_expression¿  sµ  € ô ˜/Ô+>Ô?Øô �¬´)¼VÐ(DÔEØ×'Ñ'¬9¯?©?Ò:à"×*Ñ*Ð*ô
 ˜oÔ.Ø�H‰H�M‰Mð<àÜ×:Ñ:ð	 ô ð ô
 $CÀ?Ó#SÑ ˆ
�LØS]Ö^Èa˜Ÿ™¤Ô0@À!Ç&Á&Ó IÑIÒ^à!öb
àÜ2°1Ó5Ð5�ÐBð ”OÔ$4°a·f±fÓ=Ñ=òb
ñ 
ˆô —,‘,×<Ñ<¸T¿X¹XÀ|ÓTˆÜØô ÓØ�K‰KØ�H‰H×ÑØ�H‰H�M‰MØ�H‰H×%Ñ%ó
ˆð		Ü*Ø §¡×!1Ñ!1°4·8±8×3LÑ3LóˆDð —;‘;˜tÓ$ˆDØ×ÒØØˆKùò9 _ùò b
øô: $ò 	Ùð	ús%   Â ,G$Ã/G)ÆAG. Ç"G. Ç.	G:Ç9G:)
r  r  r  r5   r  r†   r  údict[int, int]rÁ  r  ©rÁ  r  )r,  r_   rÁ  r½   ©F)r,  rg   rD  rÂ  rÁ  r½   )r+  ro   rJ  rL   rT  rÂ  rF  rÂ  rG  rÂ  rÁ  r½   )r6  r}   r^  rL   rÁ  r½   )r+  r]   rÁ  r²   )r,  rG   ro  rÂ  rÁ  r½   )rw  rR   rÁ  rÂ  )r,  rG   rÁ  r  )rR  r½   rÄ  r·  rÁ  ú
str | None©r+  rR   rÁ  rÂ  )rÓ  zSymbolNode | NonerÁ  rÂ  )r�  r¿   r�  úlist[ArgKind]r�  zSequence[str | None]r�  úlist[Expression]r^  rL   ré  r   rÁ  r½   )rã  z.Iterable[tuple[Expression | None, Expression]]r�  r¿   rÁ  z3tuple[dict[str, list[Expression]], set[str]] | None)
rý  rR   r�  r¿   r-  údict[str, list[Expression]]rë  úset[str]rÁ  útuple[bool, bool]©r°  r»   rÁ  rÂ  )r�  r¿   rã  ú*list[tuple[Expression | None, Expression]]r^  rL   rÁ  rÂ  )
r�  r¿   rã  r¬  r^  rL   ré  r   rÁ  r½   )rÆ  rx   rÁ  r­   rñ   )r�  r¿   r-  z Sequence[TypeVarLikeType] | NonerÁ  r­   )r�  r¿   rã  r¨  r^  rL   ré  r   rë  r©  rÁ  r½   )rŸ  r\   rÁ  z
Var | None)rd  rg   rÁ  z%tuple[Var, dict[Var, Context]] | None)r,  rG   ri  r·  r6  r}   rÁ  zInstance | None)r�  r­   r�  r¦  r³  ú
list[Type]r�  úSequence[str | None] | Noner±  úlist[list[int]]r�  r§  r>  r·  rR  r   r^  rL   rÁ  r½   )r�  r±   r�  r§  r�  r¦  r�  r®  r„  z>Callable[[list[list[Expression]], CallableType], FunctionLike]rÁ  r±   )r�  r±   r�  r§  r�  r¦  r^  rL   r�  r®  r‰  z,Callable[[FunctionSigContext], FunctionLike]rÁ  r±   )r�  r±   r�  r§  r�  r¦  r^  rL   r�  r®  rR  r½   r‰  z*Callable[[MethodSigContext], FunctionLike]rÁ  r±   rÄ  )r6   r¤  r�  r½   r�  r§  r�  r¦  r^  rL   r�  r®  rR  r   rÁ  r½   )r´  r­   r�  r§  rÁ  zOverloaded | None)r´  r­   r›  r¶   rJ  rL   rÁ  útuple[Type, Type] | None)r´  r½   r,  rG   r6   r¤  rR  r   rµ  r¤  rÁ  r½   )r,  rG   rR  rÈ   rµ  r·  rÁ  r½   )NNNNN)r�  r½   r�  r§  r�  r¦  r^  rL   r�  r®  r¤  úExpression | Noner6   r¤  rR  r   r¬  r   rÁ  útuple[Type, Type])r�  r­   r�  r§  r�  r¦  r^  rL   r�  r®  r¤  r±  r6   r¤  rR  r   rÁ  r²  )r7  rx   rí  r·  rÁ  rÂ  )rÂ  r»   r^  rL   rÁ  r½   )r�  r½   r?  r½   rÁ  r½   )r�  r§  rÁ  r­  )r  r½   rÁ  rÂ  )
r�  r­   r�  r§  r�  r¦  r±  r¯  rÁ  r­  )r  r­   r  rL   rÁ  r­   )r´  r­   r�  r§  r�  r¦  r�  r®  r±  r¯  rô  rÂ  r^  rL   rÁ  r­   )r´  r­   r�  r§  r�  r¦  r�  r®  r±  r¯  r=  úSequence[Type | None]rô  rÂ  r^  rL   rÁ  z&tuple[CallableType, list[Type | None]])rÁ  r,   )r�  r­   r�  r§  r³  r­  r±  r¯  rB  rÿ  rÁ  ú	list[int])r´  r­   rœ  r³  r^  rL   rÁ  r­   )r�  r­   r³  r­  r�  r¦  r�  r§  r^  rL   rÁ  rÂ  )r�  r­   rV  r­  rb  r¦  rc  r®  r±  r¯  r^  zContext | NonerR  r   r6   r¤  rÁ  rÂ  )r�  r­   rV  r­  rb  r¦  rc  r®  rd  r¡  r^  rL   rÁ  rª  )rR  r½   r6   r·  r^  rL   rÁ  r  )r³  r­  r�  r¦  r^  rL   rÁ  r  )r³  r­  r�  r¦  r�  r§  r�  r­   r±  r¯  r^  rL   r‚  zArgChecker | NonerR  r   rÁ  r  )rœ  r½   r�  r½   rž  rB   r´  r½   rl  rÿ  rŸ  rÿ  r�  r­   rR  r   r^  rL   r”  rL   rÁ  r  )r�  r¶   r�  r§  r�  r¦  r�  r®  r6   r¤  rR  r   r^  rL   rÁ  r²  )
r³  r­  r�  r¦  r�  r®  r   r¶   rÁ  rõ  )r±  rõ  r�  r§  r³  r­  r�  r¦  r�  r®  r6   r¤  rR  r   r^  rL   rÁ  r°  )r±  rõ  r³  r­  r�  r¦  r�  r®  r�  r§  r^  rL   rÁ  rõ  )r³  r­  r±  rõ  rÁ  rÂ  )r   )r±  rõ  r�  r§  r³  r­  r�  r¦  r�  r®  r6   r¤  rR  r   rµ  rÂ  r^  rL   rå  rÿ  rÁ  zlist[tuple[Type, Type]] | NonerÀ  )rñ  zSequence[Expression]rò  úSequence[Type]rÁ  zIterator[None])r   zlist[ProperType]rÁ  zAnyType | CallableType)r³  r­  r�  r¦  r�  r®  r�  r§  r�  r­   r^  rL   rÁ  rÂ  )
r  r­   r   r³  r^  rL   r  rÂ  rÁ  r­   )
r�  r§  r�  r¦  r�  r½   r^  rL   rÁ  r²  )r�  rÈ   r�  r§  r�  r¦  r�  r®  r^  rL   rÁ  r²  )r,  r\   rT  rÂ  rÁ  r½   )r,  r\   rT  rÂ  r7  r±  rÁ  r½   )rµ  r·  r  r½   r^  rL   rÁ  r½   )rÁ  rÂ  )r¹  r´   r  r·  rÁ  r½   )r  r¼   r  r¼   rÁ  r¼   )r,  rW   rÁ  r½   )r,  rm   rÁ  r½   )r,  rF   rÁ  r½   )r,  rS   rÁ  r½   )r,  rJ   rÁ  r½   )r,  rP   rÁ  r½   )r,  rb   rÁ  r½   )r,  rI   rÁ  r½   )rŸ  rR   rÁ  r   )r  r½   r  r½   rN  r   rp  zset[tuple[Type, Type]] | NonerO  rÂ  rS  rÂ  rÁ  rÂ  )rI  r·  r  r½   r�  r§  r�  r¦  r^  rL   r¬  r   r®  r   rÁ  r²  )rI  r·  r  rÈ   r�  r§  r�  r¦  r^  rL   r¬  r   rÁ  r²  )rÄ  r·  r  r½   rA  r½   r�  r§  r�  r¦  r^  rL   rÁ  r²  )r„  r·  r  r½   r^  rL   rÁ  r   )r°  r²   rí  r·  rÁ  r¤  )r„  r·  rC  r½   rŒ  rR   rb  r½   r�  rR   r^  rL   rÁ  r²  )rI  r·  r  r½   r  rR   r^  rL   r5  rÂ  rÁ  r²  )r,  rD   rÁ  r½   )r,  r|   rÁ  r½   )r,  rV   rÁ  r½   )
rC  r½   r,  rV   r¬  zProperType | Noner®  r   rÁ  r½   )r  r¼   rÁ  rÿ  )r  r¼   rl  rÿ  rÁ  r   )rC  r¼   ró  rk   rÁ  r½   )rY  rR   rÁ  zlist[int] | None)rC  r¼   rY  rR   rÁ  r½   )rC  r¼   rÁ  r½   )r  r¿   rY  rR   r	  rÂ  rÁ  ztuple[Type, set[str]])r  rx   rY  rR   r^  rL   rÁ  r½   )rŸ  rH   rÁ  r½   )rŸ  rw   rÁ  r½   )rŸ  rC   rÁ  r½   )rŸ  rh   rÁ  r½   )rŸ  rh   rÁ  r  )r>  ru   rÁ  r½   )rA  rt   rÁ  r½   )rA  r   rJ  rL   rK  rÂ  rÁ  r½   )rý   r­   r�  rµ  rJ  rL   rÁ  r­  )rÛ  r½   r�  rµ  rJ  rL   rÁ  r½   )r,  rZ   rÁ  r½   )r,  rj   rÁ  r½   )r,  úListExpr | SetExpr | TupleExprrh  r·  rÁ  r   )rû   r­  rÁ  r   )r,  r¶  r>  r·  ru  r·  rÁ  r½   )rŸ  rs   rJ  r¼   rÁ  rÂ  )r,  rs   rÁ  r½   )r,  rN   rÁ  r   )r,  rN   r�  r¿   rÁ  r½   )r,  rN   rÁ  r½   )r^  r   r£  rN   rÁ  z tuple[list[TypedDictType], bool])r,  rq   rÁ  r½   )r,  rX   rÁ  r½   )r,  rX   rÁ  z/tuple[CallableType | None, CallableType | None])r,  rn   rÁ  r½   )r,  rn   rÁ  zType | tuple[Type, Type])r,  rk   rÁ  r½   )r,  rY   rÁ  r½   )r,  ri   rÁ  r½   )r,  rU   rÁ  r½   )
r   rU   rÅ  r·  r  r·  rù  zlist[Type] | NonerÁ  r½   )r,  rO   rÁ  r½   )r,  z'GeneratorExpr | DictionaryComprehensionrÁ  r  )r,  rK   ro  rÂ  rÁ  r½   r  )rË  zdict[Expression, Type]r+  rR   r^  r   ro  rÂ  r#  rÂ  rÁ  r½   )r%  r   rÁ  r   )NFFF)r+  rR   r  r   ro  rÂ  r†  rÂ  r  rÂ  rÁ  r½   )r+  rR   r  r   rÁ  r½   )r:  r·  rÁ  r²   )rÁ  r²   )r:  r·  r^  rL   rÁ  r  )r,  r~   rÁ  r½   )r,  rE   ro  rÂ  rÁ  r½   )
rý   r½   rJ  rL   r  zstr | ErrorMessagerZ  rÂ  rÁ  r½   )r,  r   ro  rÂ  rÁ  r½   )r,  rr   rÁ  r½   )r,  ry   rÁ  r½   )r,  rd   rÁ  r½   )r,  r{   rÁ  r½   )r,  r`   rÁ  r½   )r,  r^   rÁ  r½   )r,  rQ   rÁ  r½   )r,  rv   rÁ  r½   )r,  rf   rÁ  r½   )r,  rl   rÁ  r½   )rŸ  rR   rˆ  r½   rÁ  r½   )rŸ  rR   rˆ  r½   r¯  rÂ  rÁ  r   )rœ  r»   r´  r»   rÁ  rÂ  )rš  rR   rÁ  r   )¶rè   ré   rê   rë   Ú__annotations__r"  r&  r/  r(  r<  r4  rS  rt  rx  rr  rª  r£  r®  rÊ  r¨  r©  rŽ  rå  rô  r  r%  rç  rN  r)  ræ  rM  rP  rT  r›  rV  rW  r}  rƒ  rŠ  rŽ  r”  r–  r¢  r§  r¥  r™  r?  rÙ  r¹  r  r  r  rå  rÞ  r-   r.  r-  r,  r2  rè  rç  rW  r[  r  rë  r‚  r´  r¥  r©  r¬  r¦  r§  r£  r	   rã  r¨  r×  r  rµ  r¶  r  r
  r  rZ  r\  r  r  r"  r$  r'  r)  r+  rJ  rn  rV  r^  rX  r}  r~  r…  rˆ  r—  r?  r7  r8  rÃ  rÉ  rÍ  rË  rÏ  rÙ  r×  rÕ  rÖ  rÚ  r  rÛ  rÜ  r  r  r#  r-  r'  r?  rB  rP  rT  r<  rc  re  rk  rg  rb  r|  r†  rŽ  r‘  r¡  r—  r­  rÂ  rµ  rÙ  rÎ  ré  rî  rð  rý  rì  r  rÿ  r!  r°  r±  rs  r0  rQ  r;  rz  r|  rF  rQ  r-  rT  r,  rh  rp  rs  rv  rx  r{  r~  r€  r‚  r„  rR  rW  r   r)  r—  rŽ  r.  rì   rí   rî   r  r    sB  … ñð 
"Ó!à	Óà#Ó#à*Ó*ØƒNà9Ó9ð(4à%ð(4ð ð(4ð ð	(4ð
 $2ð(4ð 
ó(4óT óô+ðf !%Ø %ñ.-àð.-ð ð.-ð ð	.-ð ð.-ð ð.-ð 
ó.-ó`3ó$ô6	Ró
ôOóbGó0ó8ó,ó,	Mó_ð(-àð(-ð !ð(-ð (ð	(-ð
 ð(-ð ð(-ð !ð(-ð 
ó(-ðT8+ØDð8+ØN[ð8+à	<ó8+ðt?4àð?4ð ð?4ð ,ð	?4ð
 &ð?4ð 
ó?4óBRðàðð ;ðð ð	ð
 
óð1àð1ð ;ð1ð ð	1ð
 !ð1ð 
ó1ó(Qð TXð
Ø#ð
Ø0Pð
à	ó
ð ]àð]ð ,ð]ð ð	]ð
 !ð]ð &ð]ð 
ó]ó~ð0 #˜Ø 	Ð*ñ1€IÐ-ó ð
 # _Ð$5Ð6Ø" _Ð$5Ð6Ø$,¨Ð.?Ð#@Ø! N°OÐ#DÐEñ	A€NÐ=ó ó%PóN	"ð)Øð)Ø'*ð)Ø14ð)à	ó)ðVGàðGð !ðGð ð	Gð
 /ðGð *ðGð ðGð ðGð !ðGð ðGð 
óGðR%àð%ð ð%ð !ð	%ð
 /ð%ð Mð%ð 
ó%ð@
àð
ð ð
ð !ð	
ð
 ð
ð /ð
ð Eð
ð 
ó
ð$
àð
ð ð
ð !ð	
ð
 ð
ð /ð
ð ð
ð Cð
ð 
ó
ð> 26Ø#'ð'à!ð'ð ð'ð ð	'ð
 !ð'ð ð'ð /ð'ð !ð'ð 
ó'ðRØ'ðØ/?ðà	óð&=Ø'ð=Ø5?ð=ØFMð=à	!ó=ðH "ð0àð0ð ð0ð "ð	0ð
 !ð0ð ð0ð 
ó0ód*ðD 26Ø+/Ø$(Ø#'Ø%)ðDYàðDYð ðDYð !ð	DYð
 ðDYð /ðDYð )ðDYð "ðDYð !ðDYð #ðDYð 
óDYðLs'àðs'ð ðs'ð !ð	s'ð
 ðs'ð /ðs'ð )ðs'ð "ðs'ð !ðs'ð 
ós'ójó0'-óRó"ó ð $àð$ð ð$ð !ð	$ð
 *ð$ð 
ó$ðLS
Ø$ðS
Ø5<ðS
à	óS
ðjIRà!ðIRð ðIRð !ð	IRð
 /ðIRð *ðIRð ðIRð ðIRð 
ôIRðV;*à!ð;*ð ð;*ð !ð	;*ð
 /ð;*ð *ð;*ð 1ð;*ð ð;*ð ð;*ð 
0ô;*ôz-ð-àð-ð ð-ð ð	-ð
 *ð-ð ð-ð 
ô-ð^QØ'ðQØ8MðQØX_ðQà	ôQð(1àð1ð ð1ð !ð	1ð
 ð1ð ð1ð 
ô1ðv $(Ø$(ðNàðNð !ðNð $ð	Nð
 2ðNð *ðNð  ðNð !ðNð "ðNð 
ôNð`;+àð;+ð !ð;+ð $ð	;+ð
 2ð;+ð $ð;+ð ð;+ð 
ô;+ðzØðØ03ðØ>Eðà	ôðPØ#ðPØ0=ðPØHOðPà	ôPð* (,Ø#'ðCàðCð !ðCð ð	Cð
 ðCð *ðCð ðCð %ðCð !ðCð 
ôCðJ+àð+ð #ð+ð ð	+ð
 ð+ð ð+ð ð+ð ð+ð !ð+ð ð+ð ð+ð 
ô+ðZOàðOð ðOð !ð	Oð
 /ðOð "ðOð !ðOð ðOð 
ôOðb9&àð9&ð !ð9&ð /ð	9&ð
 ð9&ð 
ô9&ðvR6à-ðR6ð ðR6ð ð	R6ð
 !ðR6ð /ðR6ð "ðR6ð !ðR6ð ðR6ð 
"ôR6ðhà-ðð ðð !ð	ð
 /ðð ðð ðð 
ôð*$Ø#ð$Ø8Jð$à	ô$ðb ñdà-ðdð ðdð ð	dð
 !ðdð /ðdð "ðdð !ðdð  $ðdð ðdð ðdð 
(ôdôLLð ð.Ø)ð.Ø6Dð.à	ó.ó ð.ô
ð>3àð3ð !ð3ð /ð	3ð
 ð3ð ð3ð ð3ð 
ô3ðt "'ð
àð
ð %ð
ð ð	
ð
 ð
ð 
ô
ð TØ$ðTØ1>ðTØHLðTØW^ðTà	ôTðLàðLð ðLð !ð	Lð
 /ðLð ðLð 
ôLõ ð KOð(Øð(Ø(,ð(Ø6Gð(à	ô(ðT
Øð
Ø&*ð
Ø5<ð
à	ô
ô&;ô!^ôF
ôEôEôGô1ô3ô3ôk;ôZeôNð* +/Ø48Ø#Ø$ñANàðANð ðANð
 (ðANð 2ðANð ðANð ðANð 
ôANðT &*Ø!%ð%`àð%`ð ð%`ð ð	%`ð
 !ð%`ð ð%`ð #ð%`ð ð%`ð 
ô%`ð\ &*ðKàðKð ðKð ð	Kð
 !ðKð ðKð #ðKð 
ôKð8
àð
ð ð
ð ð	
ð
 ð
ð !ð
ð ð
ð 
ô
ô<:ô,ð PàðPð ðPð ð	Pð
 ðPð ðPð ðPð 
ôPðp $ðmàðmð ðmð ð	mð
 ðmð ðmð 
ômô^JMôXô ôôô 8ð ,0Ø!%ðVàðVð ðVð )ð	Vð
 ðVð 
ôVôp!ô4
ôl(,ôT$ôLô,ð( JOð#BØ$ð#BØ-7ð#BØBFð#Bà	ô#BðJ'Ø!ð'Ø*4ð'Ø?Fð'à	ô'ôô.bôô4ô>Dô.*/ôX`ð KPñ;:Øð;:Ø(/ð;:ØCGð;:à	ô;:ðz8WØð8WØ%3ð8WØ:Að8Wà	ô8WðtJ/ØðJ/Ø,ðJ/Ø3:ðJ/à	ôJ/ôXAô?ð'EØ/ð'EØEHð'Eà	ô'EôR	ô!6ôFYôgôR;Fðz	1Øð	1Ø.;ð	1à	ô	1ôQUðfØ"ðØ/7ðà	)ôô4-ô"*IðXKOØðKOà	8ôKOôZQ$ôfP(ôdHô
ô

ô

ð2 .2ð6àð6ð ð6ð ð	6ð
 +ð6ð 
ô6ôp5ôn!WõF/ðl #(Ø,0ñ`à#ð`ð ð`ð ð	`ð
  ð`ð &*ð`ð 
ô`ô&ð* %)Ø"'Ø!&Øñqàðqð "ðqð  ð	qð
 ðqð ðqð 
ôqõf
ô)ôBô
ô
ô6=ôGõ*ð UZðØðØ#ðØ*<ðØMQðà	ôõ.:ôxô
/ô/ô/ô/ô
/ô/ô/ôô#ô2ô0ð ÛVó ØVàðØðØ,0ðØHLðà	óó ðð
 PUðØðØ,0ðØHLðà	ôô8@ô	
õErí   r  c                ó6   — | j                  t        |«      «      S )zWhether t contains an Any type)rs  Ú
HasAnyType)rý   Úignore_in_type_objs     rî   rÌ  rÌ    s   € à�8‰8”JÐ1Ó2Ó3Ð3rí   c                  óL   ‡ — e Zd Zdˆ fd„Zdd„Zd	ˆ fd„Zd
d„Zdd„Zdd„Zˆ xZ	S )r¹  c                óN   •— t         ‰| �  t        j                  «       || _        y rñ   )Úsuperr"  r   ÚANY_STRATEGYrº  )r!  rº  Ú	__class__s     €rî   r"  zHasAnyType.__init__  s   ø€ Ü‰Ñœ×+Ñ+Ô,Ø"4ˆÕrí   c                ó<   — |j                   t        j                  k7  S rñ   )ro  rÀ   r3  ©r!  rý   s     rî   Ú	visit_anyzHasAnyType.visit_any  s   € Ø�}‰}¤	× 6Ñ 6Ñ6Ð6rí   c                ó\   •— | j                   r|j                  «       ryt        ‰| �  |«      S )NF)rº  rÀ  r½  Úvisit_callable_type)r!  rý   r¿  s     €rî   rÄ  zHasAnyType.visit_callable_type  s'   ø€ Ø×"Ò" q§}¡}¤ØÜ‰wÑ*¨1Ó-Ð-rí   c                ó–   — |j                  «       r|j                  gng }| j                  |j                  g|¢|j                  z   «      S rñ   )rX  rr  Úquery_typesr¸  rÿ  ©r!  rý   rr  s      rî   Úvisit_type_varzHasAnyType.visit_type_var  s=   € Ø!"§¡¤�1—9‘9‘+°bˆØ×Ñ §¡Ð 9°Ð 9¸A¿H¹HÑ DÓEÐErí   c                ó”   — |j                  «       r|j                  gng }| j                  |j                  g|¢|j                  ‘«      S rñ   )rX  rr  rÆ  r¸  rP  rÇ  s      rî   Úvisit_param_speczHasAnyType.visit_param_spec  s=   € Ø!"§¡¤�1—9‘9‘+°bˆØ×Ñ §¡Ð C°Ð C¸!¿(¹(Ð CÓDÐDrí   c                ó|   — |j                  «       r|j                  gng }| j                  |j                  g|¢«      S rñ   )rX  rr  rÆ  r¸  rÇ  s      rî   Úvisit_type_var_tuplezHasAnyType.visit_type_var_tuple!  s4   € Ø!"§¡¤�1—9‘9‘+°bˆØ×Ñ §¡Ð 9°Ð 9Ó:Ð: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Ì  Ú__classcell__©r¿  s   @rî   r¹  r¹    s#   ø„ õ5ó7õ.ó
FóE÷;rí   r¹  c                ón   — t        | «      } t        | t        «      xr | j                  j                  dk(  S )z;Whether t came from a function decorated with `@coroutine`.útyping.AwaitableGenerator)rÍ   rø   r²   r7  r>  rü   s    rî   r_  r_  &  s,   € ä˜Ó€AÜ�aœÓ"ÒU q§v¡v§¡Ð:UÑ'UÐUrí   c                ó   — t        | «      } t        | t        «      rI| j                  j                  dk(  r0t        | j                  «      dk\  rt        | j                  d   «      } t        | t        «      xr | j                  j                  dk(  S )z9Whether t came from a function defined using `async def`.rÑ  é   r0  ztyping.Coroutine)rÍ   rø   r²   r7  r>  r‘  r�  rü   s    rî   r^  r^  ,  sk   € ô 	˜Ó€Aä�1”hÔØ�F‰F�O‰OÐ:Ò:Ü�—‘‹K˜1Òä˜AŸF™F 1™IÓ&ˆÜ�aœÓ"ÒL q§v¡v§¡Ð:LÑ'LÐLrí   c                óf   — t        | «      } t        | t        «      xr t        | j                  «      S rñ   )rÍ   rø   r¼   rÂ  rû   rü   s    rî   rk  rk  D  s&   € Ü˜Ó€AÜ�aœÓ#Ò5¬¨Q¯W©W«Ð5rí   c                óà   ‡‡— t        | «      dkD  xr] t        | «      dk(  xr4 ‰| d      t        j                  k(  xr ‰| d      t        j                  k(   xr t	        ˆˆfd„| D «       «       S )Nr  r  r   c              3  óˆ   •K  — | ]9  }‰|   t         j                  k(  xr t        t        ‰|   «      t        «       –— Œ; y ­wrñ   )r   r;   rø   rÍ   r¿   )rô   rŸ  rb  rV  s     €€rî   rö   z'is_duplicate_mapping.<locals>.<genexpr>Z  sJ   øè ø€ ò 
ð ð ˜‰OœuŸ™Ñ.ò PÜœ¨|¸A©Ó?ÄÓOÐOóPñ
ùs   ƒ?A)r‘  r   r:   r;   rú   )ÚmappingrV  rb  s    ``rî   r]  r]  I  s…   ù€ ô 	ˆG‹�qÑò 	
ô �‹L˜AÑò <Ø˜W Q™ZÑ(¬E¯N©NÑ:ò<à˜W Q™ZÑ(¬E¯O©OÑ;ð
ò	
ô ô 
ð ô
ó 
ð 
ðrí   c                ó&   — | j                  |¬«      S )z>Return a copy of a callable type with a different return type.rÀ  )rc  )r
  rú  s     rî   r¿  r¿  b  s   € à�?‰? Lˆ?Ó1Ð1rí   c                  ó,   ‡ — e Zd ZdZdˆ fd„Zdd„Zˆ xZS )rA  zûQuery whether an argument type should be inferred in the second pass.

    The result is True if the type has a type variable in a callable return
    type anywhere. For example, the result for Callable[[], T] is True if t is
    a type variable.
    c                ó@   •— t         ‰| �  t        j                  «       y rñ   ©r½  r"  r   r¾  ©r!  r¿  s    €rî   r"  z ArgInferSecondPassQuery.__init__o  ó   ø€ Ü‰Ñœ×+Ñ+Õ,rí   c                óR   — | j                  |j                  «      xs t        |«      S rñ   )rÆ  r³  rÑ   rÁ  s     rî   rÄ  z+ArgInferSecondPassQuery.visit_callable_typer  s!   € à×Ñ §¡Ó,Ò@´¸aÓ0@Ð@rí   r¢  rÍ  )rè   ré   rê   rë   r"  rÄ  rÎ  rÏ  s   @rî   rA  rA  g  s   ø„ ñõ-÷Arí   rA  c                ó@   — | d uxr | j                  t        «       «      S rñ   )rs  ÚHasErasedComponentsQueryrü   s    rî   r  r  w  s   € Ø�Dˆ=ÒA˜QŸX™XÔ&>Ó&@ÓAÐArí   c                  ó,   ‡ — e Zd ZdZdˆ fd„Zdd„Zˆ xZS )rà  z<Visitor for querying whether a type has an erased component.c                ó@   •— t         ‰| �  t        j                  «       y rñ   rÛ  rÜ  s    €rî   r"  z!HasErasedComponentsQuery.__init__~  rÝ  rí   c                 ó   — yr}  rì   rÁ  s     rî   Úvisit_erased_typez*HasErasedComponentsQuery.visit_erased_type�  ó   € Ørí   r¢  )rý   r¯   rÁ  rÂ  )rè   ré   rê   rë   r"  rä  rÎ  rÏ  s   @rî   rà  rà  {  s   ø„ ÙFõ-÷rí   rà  c                ó@   — | d uxr | j                  t        «       «      S rñ   )rs  ÚHasUninhabitedComponentsQueryrü   s    rî   rÁ  rÁ  …  s   € Ø�Dˆ=ÒF˜QŸX™XÔ&CÓ&EÓFÐFrí   c                  ó,   ‡ — e Zd ZdZdˆ fd„Zdd„Zˆ xZS )rç  zEVisitor for querying whether a type has an UninhabitedType component.c                ó@   •— t         ‰| �  t        j                  «       y rñ   rÛ  rÜ  s    €rî   r"  z&HasUninhabitedComponentsQuery.__init__Œ  rÝ  rí   c                 ó   — yr}  rì   rÁ  s     rî   Úvisit_uninhabited_typez4HasUninhabitedComponentsQuery.visit_uninhabited_type�  rå  rí   r¢  ©rý   rÇ   rÁ  rÂ  ©rè   ré   rê   rë   r"  rë  rÎ  rÏ  s   @rî   rç  rç  ‰  s   ø„ ÙOõ-÷rí   rç  c                ó@   — | d uxr | j                  t        «       «      S rñ   )rs  Ú&HasAmbiguousUninhabitedComponentsQueryrü   s    rî   r  r  “  s   € Ø�Dˆ=ÒO˜QŸX™XÔ&LÓ&NÓOÐOrí   c                  ó,   ‡ — e Zd ZdZdˆ fd„Zdd„Zˆ xZS )rï  zOVisitor for querying whether a type has an ambiguous UninhabitedType component.c                ó@   •— t         ‰| �  t        j                  «       y rñ   rÛ  rÜ  s    €rî   r"  z/HasAmbiguousUninhabitedComponentsQuery.__init__š  rÝ  rí   c                ó   — |j                   S rñ   )r«  rÁ  s     rî   rë  z=HasAmbiguousUninhabitedComponentsQuery.visit_uninhabited_type�  s   € Ø�{‰{Ðrí   r¢  rì  rí  rÏ  s   @rî   rï  rï  —  s   ø„ ÙYõ-÷rí   rï  c                ó   ‡ ‡— t        ‰ «      Š t        ‰«      Št        ‰ t        «      rt        ‰ «      Š t        ‰t        «      rt        ‰«      Šdd„}t        ‰t        «      rt        ‰ t        t
        t        f«      ry |‰ «      r	 |‰«      ryt        ‰ t        «      r"t        ˆfd„‰ j                  «       D «       «      S t        ‰t        «      r"t        ˆ fd„‰j                  «       D «       «      S t        ‰ t        «      r't        ‰t        «      ryt        ‰ j                  ‰«      S t        ‰t        «      r“t        ‰ t        «      r‰ j                  Š t        ‰ t
        «      r‰ j                  d   j                  Š t        ‰ t        «      rt!        ‰ «      Š t        ‰ t        «      r#‰j"                  ‰ j"                  j$                  v ryt'        t)        j*                  ‰ «      t)        j*                  ‰«      «      S )aá  Return if caller argument (actual) is roughly compatible with signature arg (formal).

    This function is deliberately loose and will report two types are similar
    as long as their "shapes" are plausibly the same.

    This is useful when we're doing error reporting: for example, if we're trying
    to select an overload alternative and there's no exact match, we can use
    this function to help us identify which alternative the user might have
    *meant* to match.
    c                óÄ   — t        | t        «      xsO t        | t        «      xr | j                  «       xs+ t        | t        «      xr | j
                  j                  dk(  S )Nr,  )rø   rÁ   r±   rÀ  r²   r7  r>  r˜  s    rî   Úis_typetype_likez4arg_approximate_similarity.<locals>.is_typetype_like¶  sQ   € ä�sœHÓ%ò TÜ˜3¤Ó-ÒC°#·/±/Ó2CòTä˜3¤Ó)ÒR¨c¯h©h×.?Ñ.?À?Ñ.Rð	
rí   Tc              3  ó6   •K  — | ]  }t        |‰«      –— Œ y ­wrñ   ©rý  )rô   rÂ  rx  s     €rî   rö   z-arg_approximate_similarity.<locals>.<genexpr>Å  s   øè ø€ Ò`ÀÔ-¨d°F×;Ñ`ùrn  c              3  ó6   •K  — | ]  }t        ‰|«      –— Œ y ­wrñ   r÷  )rô   rÂ  rz  s     €rî   rö   z-arg_approximate_similarity.<locals>.<genexpr>Ç  s   øè ø€ Ò`ÀÔ-¨f°d×;Ñ`ùrn  r   r«  )rÍ   rø   rÅ   r�   r­   r¶   rÁ   rÈ   r¤  r  r¿   rý  r…  r²   rû   r¼   r¨   r7  rý  rŒ   r   r    )rz  rx  rõ  s   `` rî   rý  rý  ¡  s„  ù€ ô ˜VÓ$€FÜ˜VÓ$€Fô �&œ+Ô&Ü(¨Ó0ˆÜ�&œ+Ô&Ü(¨Ó0ˆó
ô �&œ,Ô'Ü�fœ|¬Z¼ÐBÔCØÙ˜ÔÑ$4°VÔ$<Øô �&œ)Ô$ÜÓ`È×H]ÑH]ÓH_Ô`Ó`Ð`Ü�&œ)Ô$ÜÓ`È×H]ÑH]ÓH_Ô`Ó`Ð`ô �&œ-Ô(Ü�fœmÔ,ØÜ)¨&¯/©/¸6ÓBÐBô �&œ(Ô#Ü�fœlÔ+Ø—_‘_ˆFÜ�fœjÔ)Ø—\‘\ !‘_×-Ñ-ˆFÜ�fœiÔ(Ü# FÓ+ˆFÜ�fœhÔ'¨F¯K©K¸6¿;¹;¿?¹?Ñ,Jàô ”i×*Ñ*¨6Ó2´I×4HÑ4HÈÓ4PÓQÐQrí   c                ó  ‡— t        |«      ry| D �cg c](  }t        |||j                  |j                  ˆfd„«      ‘Œ* }}t	        ‰«      D ]¦  \  }}t        |d¬«      sŒt	        |«      D �	�
cg c]  \  }	}
|
|   r|	|
|   f‘Œ }}	}
g }g }|D ]J  \  }	}| |	   }|j                  |j                  «       |D ]   }|j                  |j                  |   «       Œ" ŒL t        |«      rŒšt        |«      rŒ¦ y yc c}w c c}
}	w )aè  May an argument containing 'Any' cause ambiguous result type on call to overloaded function?

    Note that this sometimes returns True even if there is no ambiguity, since a correct
    implementation would be complex (and the call would be imprecisely typed due to Any
    types anyway).

    Args:
        items: Overload items matching the actual arguments
        arg_types: Actual argument types
        arg_kinds: Actual argument kinds
        arg_names: Actual argument names
    Fc                ó   •— ‰|    S rñ   rì   r¿  s    €rî   rƒ  z/any_causes_overload_ambiguity.<locals>.<lambda>ø  s   ø€ ÈIÐVWÉL€ rí   T)rº  )	rÏ  r   r�  r�  rp  rÌ  rù  r?  r³  )rû   rÐ  r³  r�  r�  rÂ  Úactual_to_formalÚarg_idxrj  Úitem_idxÚlookupÚmatching_formals_unfilteredÚmatching_returnsÚmatching_formalsÚformalsÚmatched_callablerx  s     `              rî   rÎ  rÎ  à  sB  ø€ ô& �lÔ#Øð ö	ð ô 	Ø�y $§.¡.°$·.±.ÓBXõ	
ðÐð ô ' yÓ1ò Ñˆ�ô ˜°TÖ:ô )2Ð2BÓ(C÷+á$�H˜fØ˜'’?ð ˜6 '™?Ò+ð+Ð'ñ +ð  "ÐØ!ÐØ%@ò 	PÑ!�˜'Ø#(¨¡?Ð Ø ×'Ñ'Ð(8×(AÑ(AÔBð &ò P�FØ$×+Ñ+Ð,<×,FÑ,FÀvÑ,NÕOñPð	Pô "Ð"2Õ3¼NÐK[Õ<\áð3ð4 ùòCùó+s   ’-C6Á.C;c                ó8   ‡ — ‰ syt        ˆ fd„‰ dd  D «       «      S )NTc              3  ó<   •K  — | ]  }t        |‰d    «      –— Œ y­w)r   Nrl  )rô   rý   r   s     €rî   rö   z!all_same_types.<locals>.<genexpr>  s   øè ø€ Ò<¨QŒ|˜A˜u Q™x×(Ñ<ùs   ƒr  )rú   )r   s   `rî   rÏ  rÏ    s    ø€ ÙØÜÓ<°%¸¸°)Ô<Ó<Ð<rí   c                ól   — t        | «      } t        | t        «      r| j                  �| j                  S | S )z>If possible, get a more precise literal type for a given type.)rÍ   rø   r²   r[  r˜  s    rî   rº  rº     s2   € ä
˜#Ó
€CÜ�#”xÔ  S×%9Ñ%9Ð%EØ×#Ñ#Ð#Ø€Jrí   c                ó&  — t        | t        «      r0| j                  }t        |t        «      xr |j                  t
        v S t        | t        «      rA| j                  }t        |t        «      xr# t        t        |j                  «      t        «      S y)z-Returns 'true' if the given node is a LiteralF)rø   rV   rw  rg   r>  rª   r_   r+  r   rÍ   rv  r³   )r+  rw  Ú
underlyings      rî   r–  r–  (  st   € ä�$œ	Ô"Ø�y‰yˆÜ˜$¤Ó(ÒP¨T¯]©]Ô>PÐ-PÐPÜ�$œÔ!Ø—Y‘Yˆ
Ü˜*¤iÓ0ò 
´ZÜ˜J×-Ñ-Ó.´ó6
ð 	
ð rí   c                óÌ   — t        | «      } ddh}t        | t        «      rt        d„ | j                  D «       «      S t        | t
        «      r| j                  j                  |v ryy)z?Is this one of builtin byte types, or a union that contains it?râ   rã   c              3  ó2   K  — | ]  }t        |«      –— Œ y ­wrñ   )rw  r  s     rî   rö   z&has_bytes_component.<locals>.<genexpr>:  s   è ø€ Ò=¨aÔ& q×)Ñ=ùr÷   TF)rÍ   rø   rÈ   r¤  rû   r²   r7  r>  )r°  Ú
byte_typess     rî   rw  rw  5  sW   € ä
˜#Ó
€CØ"Ð$8Ð9€JÜ�#”yÔ!ÜÑ=°3·9±9Ô=Ó=Ð=Ü�#”xÔ  S§X¡X×%6Ñ%6¸*Ñ%DØØrí   c                ój  — t        | «      } t        | t        «      r | j                  «       r| j	                  «       S t        | t
        «      r| j                  } t        | t        «      rt        | j                  «      } t        | t        «      rt        | «      } t        | t        «      r| j                  S y)zXGets the TypeInfo for a type, indirecting through things like type variables and tuples.N)rÍ   rø   r±   rÀ  rÖ  rÁ   rÂ  rÅ   r¸  r¼   r¨   r²   r7  r˜  s    rî   rÏ  rÏ  @  sƒ   € ä
˜#Ó
€CÜ�#”|Ô$¨¯©Ô):Ø�‰Ó Ð Ü�#”xÔ Ø�h‰hˆÜ�#”{Ô#Ü˜cŸo™oÓ.ˆÜ�#”yÔ!Ü˜SÓ!ˆÜ�#”xÔ Ø�x‰xˆð rí   c                óø   — | sy| j                  d«      d   }|t        j                  j                  «       v xsB |t        j                  j                  «       v xs  |t        j
                  j                  «       v S )NFrˆ  r1  )Úsplitr   r>  rÿ  r@  rÇ  )r>  Ú
short_names     rî   r­  r­  S  so   € ÙØØ—‘ Ó$ RÑ(€Jà”i×*Ñ*×1Ñ1Ó3Ð3ò 	=Øœ×5Ñ5×<Ñ<Ó>Ð>ò	=àœ×3Ñ3×:Ñ:Ó<Ð<ðrí   c                óD   — | �t        | t        «      r| j                  €y | S rñ   )rø   rº   r7  rü   s    rî   rZ  rZ  ^  s    € Ø€yœ
 1¤kÔ2°a·f±f°nØØ€Hrí   c                ó”   — t        | «      } t        | t        «      ryt        | t        «      rt	        d„ | j
                  D «       «      S y)NTc              3  ó2   K  — | ]  }t        |«      –— Œ y ­wrñ   )rB  )rô   rÂ  s     rî   rö   z'is_type_type_context.<locals>.<genexpr>i  s   è ø€ ÒH°$Ô'¨×-ÑHùr÷   F)rÍ   rø   rÁ   rÈ   r¤  rû   r1  s    rî   rB  rB  d  s;   € Ü˜gÓ&€GÜ�'œ8Ô$ØÜ�'œ9Ô%ÜÑH¸'¿-¹-ÔHÓHÐHØrí   )rý   r½   rÁ  rÂ  r£  )rý   r½   rº  rÂ  rÁ  rÂ  )r×  r´  rV  r­  rb  r¦  rÁ  rÂ  )r
  r­   rú  r½   rÁ  r­   )rý   r   rÁ  rÂ  )rz  r½   rx  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Á  zTypeInfo | None)r>  r¤  rÁ  rÂ  )rý   r   rÁ  zPartialType | None)r^  r   rÁ  rÂ  (4  rë   Ú
__future__r   Úenumrï  r*  Úcollectionsr   Úcollections.abcr   r   r   r   Ú
contextlibr	   r
   r2  r   r   r   rÛ   r   r   r3  r   Úmypy.checkerr’  Úmypy.errorcodesÚ
errorcodesrò  r   r   r   r   r   r   r   Úmypy.argmapr   r   r   Úmypy.checker_sharedr   Úmypy.checkmemberr   r   Úmypy.checkstrformatr   Úmypy.constant_foldr   Úmypy.erasetyper    r!   r"   Úmypy.errorsr#   r$   r%   Úmypy.expandtyper&   r'   r(   r)   Úmypy.exprtotyper*   r+   Ú
mypy.inferr,   r-   r.   Úmypy.literalsr/   Úmypy.lookupr0   Úmypy.maptyper1   Ú	mypy.meetr2   r3   Úmypy.message_registryr4   Úmypy.messagesr5   r6   r7   Ú
mypy.nodesr8   r9   r:   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`   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€   Úmypy.optionsr�   Úmypy.pluginr‚   rƒ   r„   r…   r†   Úmypy.semanal_enumr‡   Ú
mypy.staterˆ   Úmypy.subtypesr‰   rŠ   r‹   rŒ   r�   rŽ   r�   Úmypy.traverserr�   r‘   r’   Úmypy.tvar_scoper“   Úmypy.typeanalr”   r•   r–   r—   r˜   r™   rš   Úmypy.typeopsr›   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.typestaterØ   Úmypy.typevarsrÙ   Úmypy.visitorrÚ   rÿ  rÜ   r·  rÞ   rà   rä   r1  ræ   rò   rÿ   ÚuniqueÚEnumr  r  r  r  r  r  r	  r  rÌ  ÚBoolTypeQueryr¹  r_  r^  rk  r]  r¿  rA  r  rà  rÁ  rç  r  rï  rý  rÎ  rÏ  rº  r–  rw  rÏ  r­  rZ  rB  rì   rí   rî   ú<module>r=     s³  ðÚ Må "ã Û Û Ý #ß BÓ Bß 2ß KÕ KÝ *ã Ý ß V× VÑ Vß WÑ WÝ :ß @Ý 6Ý 1ß [Ñ [ß FÑ F÷ó ÷ Jß `Ñ `Ý !Ý .Ý 2ß @Ý .ß DÑ D÷K÷ K÷ K÷ K÷ K÷ K÷ K÷ K÷ K÷ K÷ K÷ K÷ K÷ K÷ K÷ K÷ K÷ K÷ KõX -÷õ õ )Ý ÷÷ ñ ÷ñ õ
 -÷÷ ñ ÷÷ ÷ ÷ ñ ÷"+÷ +÷ +÷ +÷ +÷ +÷ +÷ +÷ +÷ +÷ +÷Xõ ÷ &Ð %ß 'Ð 'ß *Ð *ð "Ø	ˆ4�˜$¡¡S¨,¸¸t¹ÀWÈgÐVÐX\Ð\ñ�
ˆJô ð �
ˆEÔ ò
&Ñ ˜Uô ò&Ñ ˜Uô ô‘Iõ ôôO‰yõ Oð ‡‚ô�—’ó ó ññ (×/Ò/Ñ �UÔ /Ù&×-Ò-Ñ �EÔ -Ù%×+Ò+Ñ �5Ô +ôjcÑ)¨$Ñ/Ð1Kõ jcõZG4ô
;�×$Ò$õ ;ô4VôMô06ð
ØðØ&0ðØ@Mðà	ôô22ô
A˜e×1Ò1õ Aô Bô˜u×2Ò2õ ôGô E×$7Ò$7õ ôPô¨U×-@Ò-@õ ô<Rð~7Øð7àð7ð ð7ð ð	7ð
 +ð7ð 
ô7ôt=ôô
ôôô&ôõrí   