ML ik\ UdZddlmZddlZddlmZddlmZmZm Z m Z m Z ddl mZmZddlmZmZmZmZmZmZmZmZmZmZddlmZmZddlZ dd l m!Z"m#Z#m$Z$m%Z%m&Z&dd l'm(Z(m)Z)m*Z*dd l+m,Z,m-Z-m.Z.dd l/m0Z0dd l1m2Z2m3Z3m4Z4m5Z5m6Z6ddl7m8Z8ddl9m:Z:ddl;mZ>ddl?m@Z@mAZAmBZBmCZCddlDmEZEmFZFmGZGmHZHmIZImJZJddlKmLZLddlMmNZNmOZOmPZPmQZQddlRmSZSddlTmUZUmVZVmWZWddlXmYZYddlZm[Z[m\Z\m]Z]m^Z^m_Z_m`Z`maZambZbmcZcddldmeZemfZfddlgmhZhmiZimjZjmkZkmlZlmmZmmnZnmoZompZpmqZqmrZrmsZsmtZtmuZumvZvmwZwmxZxmyZymzZzm{Z{m|Z|m}Z}m~Z~mZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZddlmZmZmZddlmZmZddlmZmZddlmZddlmZdd lmZdd!lmZmZmZdd"lmZmZdd#lmZdd$lmZdd%lmZmZmZmZmZmZmZmZmZmZdd&lmZmZmZdd'lmZdd(lmZmZmZdd)lmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZdd*lmZmZmZmZmZmZmZmZm Z m Z m Z m Z m Z mZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%dd+l&m'Z'm(Z(m)Z)m*Z*dd,l+m,Z,dd-l-m.Z.m/Z/m0Z0dd.l1m2Z2m3Z3dd/l4m5Z5ed0Z6d1Z7d2e8d3<d4Z9d2e8d5<eeeefZ:d6e8d7<eeeefZ;d6e8d8<Gd9d:eZ<Gd;deefZ?d6e8d=<Gd>d?eZ@Gd@dAZAGdBdCe5de-ZBGdDdEe,ZCe ddFdG ddHZDedFdG ddIZD ddFdG ddJZD ddKZEddLZFddMZGddNZHddOZIddPZJddQZKddRZLdddSZMdddTZN d ddUZOddVZPddWZQddXZRddYZSGdZd[eZTdd\ZUdd]ZV d dd^ZWdd_ZXdd`ZYddaZZddbZ[ddcZ\dddZ] d ddeZ^GdfdgeZ_GdhdieZ`ddjZaddkZbedlZcedmZdGdndoeecedfZe ddpZfddqZgddrZhddsZiddtZjdduZkddvZlddwZmddxZnddyZoddzZpdd{Zqdd|Zrdd}Zsdd~ZtGddeZuddZvddZwddZxddZyy)zMypy type checker.) annotationsN) defaultdict)IterableIteratorMappingSequenceSet) ExitStackcontextmanager) CallableFinalGenericLiteral NamedTupleOptionalTypeVarUnioncastoverload) TypeAlias TypeGuard) errorcodesjoinmessage_registrynodes operators)ConditionalTypeBinderFrameget_declaration) CheckerScopeTypeCheckerSharedApi TypeRange) checker_state) MemberContextanalyze_class_attribute_accessanalyze_instance_member_accessanalyze_member_accessis_instance_var)PatternChecker) SUPERTYPE_OF) erase_typeerase_typevars!remove_instance_last_known_values)TYPE_VARUNUSED_AWAITABLEUNUSED_COROUTINE ErrorCode) ErrorInfoErrors ErrorWatcherIterationDependentErrorsIterationErrorWatcherreport_internal_error) expand_type)Keyextract_var_from_literal_hashliteral literal_hash)map_instance_to_supertype)is_overlapping_erased_typesis_overlapping_types meet_types) ErrorMessage) SUGGESTED_TEST_FIXTURESMessageBuilderappend_invariance_notesappend_union_note format_typeformat_type_bareformat_type_distinctlymake_inferred_type_note pretty_seq)MroError calculate_mro)S ARG_NAMEDARG_POSARG_STAR CONTRAVARIANT COVARIANT FUNC_NO_INFOGDEFIMPLICITLY_ABSTRACT INVARIANT IS_ABSTRACTLDEF LITERAL_TYPEMDEF NOT_ABSTRACTSYMBOL_FUNCBASE_TYPES AssertStmtAssignmentExprAssignmentStmtBlock BreakStmt BytesExprCallExprClassDefComparisonExprContext ContinueStmt DecoratorDelStmtDictExpr EllipsisExpr ExpressionExpressionStmt FloatExprForStmtFuncBaseFuncDefFuncItem GlobalDeclIfStmtImport ImportAll ImportBase ImportFrom IndexExprIntExpr LambdaExprListExprLvalue MatchStmt MemberExprMypyFileNameExprNode NonlocalDeclOperatorAssignmentStmtOpExprOverloadedFuncDef OverloadPartPassStmt PromoteExpr RaiseStmtRefExpr ReturnStmtSetExprStarExpr StatementStrExpr SymbolNode SymbolTableSymbolTableNodeTempNodeTryStmt TupleExprr TypeAliasStmtTypeInfo UnaryExprVar WhileStmtWithStmt YieldExpr get_func_def is_final_node)flip_opsint_op_to_methodneg_ops)PRECISE_TUPLE_TYPESOptions) AsPatternStarredPattern)Plugin) dataclasses)Scope)is_trivial_bodyrefers_to_fullnameset_callable_name) ENUM_BASESENUM_SPECIAL_PROPS)BINARY_MAGIC_METHODS)state) find_memberinfer_class_variancesis_callable_compatible is_equivalentis_more_preciseis_proper_subtype is_same_type is_subtyperestrict_subtype_awayunify_generic_callable)TraverserVisitorall_return_statementshas_return_statement)TransformVisitor)check_for_explicit_anyhas_any_from_unimported_typemake_optional_type) bind_selfcan_have_shared_disjoint_basecoerce_to_literalcustom_special_methoderase_def_to_union_or_bounderase_to_bounderase_to_union_or_bound false_onlyfixup_partial_type function_typeis_literal_type_likeis_singleton_typemake_simplified_union true_onlytry_expanding_sum_type_to_union"try_getting_int_literals_from_typetry_getting_str_literals"try_getting_str_literals_from_typetuple_fallbacktype_object_type)% ANY_STRATEGYMYPYC_NATIVE_INT_NAMESOVERLOAD_NAMESAnyType BoolTypeQuery CallableType DeletedType ErasedType FunctionLikeInstance LiteralTypeNoneType Overloaded PartialType ProperType TupleTypeType TypeAliasType TypedDictTypeTypeGuardedType TypeOfAnyTypeTranslatorTypeType TypeVarIdTypeVarLikeTypeTypeVarTupleType TypeVarType UnboundTypeUninhabitedType UnionType UnpackTypefind_unpack_in_listflatten_nested_unionsget_proper_typeget_proper_typesis_literal_typeis_named_instance)is_overlapping_noneremove_optionalstore_argument_type strip_type)TypeTraverserVisitor) fill_typevarsfill_typevars_with_anyhas_no_typevars) is_dunder is_sunder) NodeVisitorTr DEFAULT_LAST_PASSMAX_PRECISE_TUPLE_SIZE _TypeAliasDeferredNodeTypeFineGrainedDeferredNodeTypec"eZdZUded<ded<y) DeferredNoder nodeTypeInfo | Noneactive_typeinfoN__name__ __module__ __qualname____annotations__R/mnt/ssd/data/python-lab/Trading/venv/lib/python3.12/site-packages/mypy/checker.pyrrs $$rrc"eZdZUded<ded<y)FineGrainedDeferredNoder rrrNrrrrrrs %%$$rrTypeMapc,eZdZUded<ded<ded<y)PartialTypeScopedict[Var, Context]mapbool is_functionis_localNrrrrrr s Nrrc(eZdZdZddZddZddZy) LocalTypeMapzStore inferred types into a temporary type map (returned). This can be used to perform type checking "experiments" without affecting exported types (which are used by mypyc). c||_yN)chk)selfr(s r__init__zLocalTypeMap.__init__-s rcTi}|jjj||Sr')r( _type_mapsappend)r) temp_type_maps r __enter__zLocalTypeMap.__enter__0s%02  ""=1rcL|jjjyNF)r(r,pop)r)exc_typeexc_valexc_tbs r__exit__zLocalTypeMap.__exit__5s !rN)r( TypeCheckerreturnNone)r8dict[Expression, Type])r3objectr4r;r5r;r8zLiteral[False])rrr__doc__r*r/r6rrrr%r%&s  rr%ceZdZUdZdZded<ded<ded<d ed <d ed <d ed<ded<ded<ded<ded<ded<ded<ded<ded<ded <d!ed"<d#ZeZdZ dZ d$ed%<d&Z d'ed(<dZ d)ed*<d+ed,<d-ed.<d/ed0<d1ed2< d.d3Z ed/d4Zed0d5Zd1d6Zd1d7Z d2d8d9 d3d:Zd4d;Zd5d<Zd6d=Zd7d>Zd8d?Z d2d&d&d@ d9dAZd:dBZd:dCZed;dDZddHZ!d?dIZ"d?dJZ#d@dKZ$d?dLZ%dAdMZ&dAdNZ' dB dCdOZ(dDdPZ)edEdQZ* dF dGdRZ+dHdSZ,dIdTZ-dJdUZ.dKdVZ/dLdWZ0dLdXZ1dMdYZ2dNdZZ3 dOd[Z4 dPd\Z5 dQd]Z6dRd^Z7dSd_Z8dTd`Z9dTdaZ:dUdbZ; dVdcZ< d2 dWddZ= dXdeZ> dYdfZ?dZdgZ@ d[dhZAd\diZB d]djZCd^dkZDd_dlZEd`dmZFd_dnZGdadoZHd_dpZIdbdqZJdcdrZKd_dsZLd_dtZMd_duZNd`dvZO dddwZPd`dxZQdedyZRdfdzZSdgd{ZTdhd|ZUdid}ZVdjd~ZWdkdZXdldZYdldZZ dm dndZ[ddhZ\ded<dodZ] dpdZ^dqdZ_ drdZ`ddd&d dsdZa dtdZb dtdZc dudZddjdZeedvdZfdwdZgdxdZhdydZidzdZj d{ d|dZk d2 d}dZl d~ ddZm ddZnddZo d{ ddZpddZq ddZrddZs d{ ddZt d2 ddZuddZv ddZwddZxddZyddZzddZ{ddZ|ddZ}e~jddfd&d&d&d ddZddZ ddZ ddZ ddZ ddZddZddZddZ ddZddZddZddZddZddZddZdFddZddZddZddZddZddZdd„ZddÄZddĄZddńZ ddƄZddDŽZddȄZ ddɄZddʄZdd˄Z d dd̄Z dd̈́Zdd΄ZddτZddЄZ ddфZ dd҄ZddӄZddԄZddՄZddքZ ddׄZ dd؄Z ddلZddڄZ ddۄZ dd܄Zdd݄ZddބZ dd߄Z ddZ ddZddZddZ ddZd8d ddZd8d ddZddZ ddZddZddZ ddZ ddZ ddZddZd>dZÐddZĐddZŐddZ ddZ ddZe dd&d&d&d ddZe dd&d&d ddZ dd&d&d&d ddZʐddZedEdZ ddZ͐ddZΐddZϐdِdZАdڐdZѐdېdZҐdېdZӐdܐdZԐdݐdZՐdސdZ֐dߐdZאddZؐdjd Zِdd Zڐdd Zeddd  dd Z ddZݐddZސddZ ddZd2ddZd&d ddZ dd&d ddZ ddZddZd8dddZddZe d2d8d ddZed8d ddZ d2d8d ddZddZdd Zdd!Zdd"Z dd#Z dd$Zdd%Zd2dd&Zdd'Zdd(Zdd)Zdd*Zdd+Zdd,Zdd-Zy&(r7zMypy type checker. Type check mypy source files that have been semantically analyzed. You must create a separate instance for each source file. Fr3errorsrCmsgzlist[dict[Expression, Type]]r,rbinder mypy.checkexpr.ExpressionChecker _expr_checkerr)pattern_checkerrtscoper scope list[Type] return_typesz list[bool] dynamic_funcszlist[PartialTypeScope] partial_typeszset[Var]partial_reportedz list[str] widened_varsrglobalsdict[str, MypyFile]moduleszlist[DeferredNode]deferred_nodesrroptionsNzdict[Var, Type] | Noneinferred_attribute_typesr!no_partial_typesset[str] module_refszdict[Var, set[int]]var_decl_framesrpluginint _unique_idc||_||_||_||_||_t |||_||_t|_ t||_ t||_ |j|_g|_g|_g|_t'|_i|_g|_g|_ig|_t'|_d|_d|_|j8|_|j;||_d|_d|_ tC||_"d|_#d|_$g|_%d|_&d|_'tPjRjU||j |j||_+d|_,d|_-d|_.d|_/d|_0tc||j |j||_2d|_3y)zSConstruct a type checker. Use errors to report type check errors. rFNT)4r>rNrPtreepathrCr?rVrrDr rErr@namesrLrGrHrIsetrJrUrOrKr,rTpass_numcurrent_node_deferredis_stubis_typeshed_fileis_typeshed_stubrQallow_constructor_cacher%local_type_maprecurse_into_functions _is_final_defoverload_impl_stackchecking_missing_awaitallow_abstract_callmypy checkexprExpressionCheckerrB _str_type_function_type _int_type _bool_type _object_typer)rCrX)r)r>rNrPrZr[rVper_line_checking_time_nss rr*zTypeChecker.__init__s     !&'2 g !$' +G4 zz  #! $5 %*"|| $ 5 5g >(,%'+$*40'+# # 8: ',# $) "^^== $((DKK)B +//3*.+/-1-dDHHdkk7Src|jSr')rBr)s r expr_checkerzTypeChecker.expr_checker!!!rc.|jjSr')rB type_contextrts rrxzTypeChecker.type_contexts!!...rc|jj|jjt|j|_g|j dd|j dj|jjg|_ g|_ d|_ t|j|_y)zCleanup stale state that might be left over from a typechecking run. This allows us to reuse TypeChecker objects in fine-grained incremental mode. Nr)rJclearrTrrPr@r,ruresetrOrIrQr rZrErts rr|zTypeChecker.resets ##%  +DLL9     " ! (,%!$)), rc ld|_tj|jj5t j |5|jj|j|jj|j|j|jj|jj5|j5|jj!5|jj"D]n}|jj%rA|j'snB|j)|rA|j*j-|n|j/|pdddddd|j0rJ|j2j5d}||j6|j8}|J|j;d|j=dg}t?|j6|sUtA||j6|j\}}|jCtDjFjI|||dddddddddy#1swYxYw#1swYxYw#1swY3xYw#1swY7xYw#1swYyxYw)aType check the entire file, but defer functions with unresolved references. Unresolved references are forward references to variables whose types haven't been inferred yet. They may occur later in the same file or in a different file that's being processed later (usually due to an import cycle). Deferred functions will be processed by check_second_pass(). TrErPN__all__typing.Sequence builtins.strrP)%rerstrict_optional_setrPstrict_optionalr#r]r>set_filer[rZfullnamerD module_scopeenter_partial_typesr@top_frame_contextdefsis_unreachable should_report_unreachable_issuesis_noop_for_reachabilityr?unreachable_statementacceptr_rLgettypernamed_generic_type named_typerrHfailrALL_MUST_BE_SEQ_STRformat)r)dall_all_nodeseq_str str_seq_sall_ss rcheck_first_passzTypeChecker.check_first_passs3'+#  & &t||'C'C D mFWFWX\F]  KK  499--T[[$,, ! ))$))*<*<= --/ +1N1N1P +!YY^^+;;557#'#H#H#J %#'#@#@#C $ > >q A % KKN+ + + 5555||'' 2# (=#yyH#///"55)DOON,K+LG&dii9+A#TYY ,( 5 ,@@GG SXY[c3      + + + +       stJ*BJJJ 4AI9 0I9 <J CJ J(J*9J>J J JJ JJ' #J**J3T)rcc B||_d|_tj|jj 5t j|5|s|js ddddddy|jj|j|jj|j|j|jj|jj5|xj dz c_|s |j}n|jrJg|_t}|D]\}}||vr |j#|t%5}|rT|j'|jj)||j'|j*j-||j/|ddd ddd ddddddy#1swYxYw#1swY'xYw#1swYnxYwdddy#1swYyxYw)zRun second or following pass of type checking. This goes through deferred nodes, returning True if there were any. TNFr~rz)rcrerrrPrr#r]rOr>rr[rZrrDrr^addr enter_context class_scoperE push_class check_partial)r)todorcdonerrstacks rcheck_second_passzTypeChecker.check_second_pass%s(?$&*#  & &t||'C'C D mFWFWX\F]  3 3    KK  499--T[[$,, ! ))$))*<*<= 1 " ..D#2222&(#LOE-1 1)D/t| HHTN"1*!// 0G0G0XY!// 0E0Eo0VW**40 11 1 1(5   *11 1 1      sbHHH/BH/A,G4A(G(  G4 HH(G1-G44G= 9HH HHcg|_t|tr|j|yd|_|j j 5|j|dddy#1swYyxYwNT)rK isinstancercheck_top_levelrer@rrr)rs rrzTypeChecker.check_partialMs[ dH %   &*.D '..0 " D! " " "s A&&A/cd|_|j5|jj5|jD]}|j | dddddd|j rJy#1swY xYw#1swY$xYw)zDCheck only the top-level of a module, skipping function definitions.FN)rerr@rrrr_)r)rrs rrzTypeChecker.check_top_levelVs&+#  % % ' #..0 ##AHHTN# # # -----  # # # #s"B#A6B6A? ;BB cN|jjt||y)aDefer a node for processing during next type-checking pass. Args: node: function/method being deferred enclosing_class: for methods, the class where the method is defined NOTE: this can't handle nested functions/methods. N)rOr-r)r)renclosing_classs r defer_nodezTypeChecker.defer_nodeas ""<o#FGrc,|jj}|j|jkrEt |t r5|jj |}|j||d|_y|jj||yr) rEtop_level_functionr^ last_passrrprrr_r?cannot_determine_type)r)namecontextrrs rhandle_cannot_determine_typez(TypeChecker.handle_cannot_determine_typensozz,,. ==4>> )jw.G #jj88>O OOD/ 2*.D & HH * *4 9rc |j|y#t$rK}t||jj|j |j|j Yd}~yd}~wwxYw)z,Type check a node in the given type context.N)r Exceptionr7r>filelinerP)r)stmterrs rrzTypeChecker.accept~sR _ KK  _ !#t{{'7'7DKKQUQ]Q] ^ ^ _s A(AA##A()exit_condition on_enter_bodyc~|jjdd5td|jD}t |j }t }d} |jjddd5||t|jj|5|j|ddddddtd |jD} t |j } | |k(r&|jjr|d kDr | |k(s|dkDrn| }| }|dz }|d k(r td |jj||r%|j|\} } |j| |r|j|dddy#1swYxYw#1swYxYw#1swYyxYw) zARepeatedly type check a loop body until the frame doesn't change.FT)can_skipconditional_framec3FK|]}t|jywr'lenr .0ptss r z*TypeChecker.accept_loop..sJs377|J!rzr)r break_framecontinue_frameNc3FK|]}t|jywr'rrs rrz*TypeChecker.accept_loop..s"NC3sww<"Nrz(Too many iterations when checking a loop)r@ frame_contextsumrIrrKr5r6r?r>rlast_pop_changed RuntimeErroriteration_dependent_errorsfind_isinstance_check push_type_map) r)body else_bodyrr partials_old widened_old iter_errorsiter partials_new widened_new_else_maps r accept_loopzTypeChecker.accept_loops[[ & & & N0 'Jt7I7IJJLd//0K24KD[[..!\].^*$0%.txx L* D)* * #"N4;M;M"NN !$"3"34 "\1![[99TAX$ 3tax+ )  2:&'QRR58 HH / / <"88H 8""8, I&a0 '0 ' ** **0 '0 's=AF3;*F'%F7F'?CF3F$ F''F0 ,F33F<c|jsy|jj|5|j|dddy#1swYyxYwr')rerDfunction_scope_visit_overloaded_func_defr)defns rvisit_overloaded_func_defz%TypeChecker.visit_overloaded_func_defsC**  [[ ' ' - 2  + +D 1 2 2 2 AA c  d}|jsyt|jdk(r |jtj||j rt |jdtsJ|j|jd|jdjjr|j|jd|jjj}ttj }t#||gt$t$gddg||j'd}|r2t)||s&|jd|jj*|j-||}t |t"rt|j.dk7r|}||jdj_t |jt2rb|j-|jdjj|}|-|jd|_||jjd<t7|jD]\}}t |tsJ|j rt |jdtsJ|jdjj} | r|dkDs| sK|dkDrF|j9|j*|j*j:d n|j|d |j*j<t>t@fvs|dz }|dt|jfvr |jtjB||jDr?|jG|jD5|jDjI|ddd|j s|jK||j7g} |jD]U} t | tsJ|j-| jj| } | >| | _| jM| W| rt3| |_ n|jt |jdtsJ|j-|jdjj|} t | t"s?ttj }t#|gt$gdg||j'd} t3| g|_ |jNr|jQ|}|jRr@|s>|<|jNjTs&|jVjY|j:||j[|||jD|j]|yy#1swYxYw) NrrzT)skip_first_itembuiltins.function) arg_types arg_kinds arg_namesret_typefallbackz!Invalid property setter signaturerr allow_empty)r)/itemsrrrMULTIPLE_OVERLOADS_REQUIRED is_propertyrrgvisit_decoratorvaris_settable_propertyvisit_decorator_innersetterrrr special_formrrNrrfuncextract_callable_typer setter_typer definition enumeratecheck_func_itemrabstract_statusrVrTINCONSISTENT_ABSTRACT_OVERLOADimplenter_overload_implrcheck_overlapping_overloadsr-infocheck_method_overrideis_explicit_overridefallback_to_anyr?no_overridable_method!check_explicit_override_decoratorcheck_inplace_operator_method)r)r num_abstractrany_typefallback_setter_type getter_typeifdefsettable item_typesitem item_typevar_typefound_method_base_classess rrz&TypeChecker._visit_overloaded_func_defs zz  tzz?a  II&BBD I   djjmY7 77  A /zz!}  55**4;;*M"kkoo22 "9#9#9:'3'2&0#Tl%!__-@A ($z+?S'TIIA4;;CSCST"88dK !+|<KDYDY@Z^_@_"6K0; 1 !!-dii4"&"<"$>tS$IM$,LL/ 1 #2$2E2Ee2L"MK!+|<%0 11*cBB   HH ! !*c 2 j* -*l333rc  |jjsb|jjj|jjj vs"|j r|jjryd}|jrt|jtr|jj}nBt|jtr!|jjj}nJd|j||j}|jxr|j dk(}t#|j$D]'\}}t|tsJ|j|jj|}|Bt#|j$|dzdD]B\}} t| tsJ|j| jj| } | Bt'|| sOt)|| r1|jj+|dz||zdz| j,|r|j.j1} | r| j2j4ng} t7j8d5t;|| | rU|dk(xrt;| ||  xr t)| | } |jj=|dz||zdz| |j,dddE||jJt?||t@dd r|jBr\tE|jG|jGdtH }|-|jjK|dz|j4|}|jLr<|jr0|jO|jLdg|jLddz }t?||t@dd s)|jjQ|dz|jtA|jR|jRrtA|jR|jRr|jjU|dz|j*y#1swYxYw) NFzImpl isn't the right type__get__rzrTrct||Sr'rlrs rz9TypeChecker.check_overlapping_overloads..s *Q2Br) is_compatris_compat_return) ignore_returnreturn_constraint_direction)rr5rr7)+rP ignore_errorsr?r>r ignored_filesrbtest_envrrrprrgrrrrrrare_argument_counts_overlappingoverload_can_never_match%overloaded_signature_will_never_matchrrE active_classr type_varsrr)is_unsafe_overlapping_overload_signaturesoverloaded_signatures_overlaprr variablesrwith_unpacked_kwargsr*&overloaded_signatures_typevar_specificr copy_modified"overloaded_signatures_arg_specificr"overloaded_signatures_ret_specific)r)r impl_typer&is_descriptor_getrrsig1jitem2sig2 current_classrA flip_noters rrz'TypeChecker.check_overlapping_overloadsps LL & &xx##txx'D'DD%%$,,*?*? *. 99$))W-*.)).. DIIy1!YY]]// 999u22:tyyII II@$))y*@ ,c RGAtdI. ..--dhhmmTBD|%djjQ&9:& 5!%33311%))..%H<6tTB+D$7HHBB1q5!a%RS)UZU_U_`*%)JJ$;$;$=M@M 2 2 < >dii--9J8Kdnn]^]_N`8`-aD.$*]aHH??AtyyQt}}dmm<!$--?HH??AtyyQGc RB  s >A#Q55Q? cVt|}|r7|jdttjg}t ||r]=^_B"c"y556H(();hRZ=[\B"c"#x(]SXX->->B]-]]rc ttj}|jd||g}t ||S#t$rYywxYw)zoIs `typ` a valid type for an async generator? True if `typ` is a supertype of AsyncGenerator. typing.AsyncGeneratorF)rrrrKeyErrorr)r)rragts ris_async_generator_return_typez*TypeChecker.is_async_generator_return_type1sR  y556H))*AHhCWXC#s##  s-; AAc t|}t|trttj|St|t r3t |jDcgc]}|j||c}S|j||s*|j|sttjSt|tsttjS|jjdk(rttjS|j r|j d}|SttjScc}w)zRGiven the declared return type of a generator (t), return the type it yields (ty). source_anyrSr)rrrrfrom_another_anyrrrget_generator_yield_typerYr^ from_errorrrrrargs)r) return_typerVrrs rrcz$TypeChecker.get_generator_yield_type>s%k2 k7 +955+N N  Y /(OZO`O`at..t\Ba ..  55kB9//0 0K29//0 0    & &*< <9112 2   "''*HO 9112 21bsEc >t|}t|trttj|St|t r3t |jDcgc]}|j||c}S|j||s*|j|sttjSt|tsttjS|jjdk(rttjS|jjdvr't!|j"dk\r|j"dS|jjdk(r't!|j"dk\r|j"dSt%Scc}w)zTGiven a declared generator return type (t), return the type its yield receives (tc).r`rSrTrUrrzr[r)rrrrrbrrrget_generator_receive_typerYr^rdrrrrrrerr)rfrVrs rriz&TypeChecker.get_generator_receive_type`s\%k2 k7 +955+N N  Y /(Q\QbQbc00|Dc ..  55kB9//0 0K29//0 0    & &*< <9112 2    % %)Z ZK$$%*##A& &    & &*A Ac+JZJZF[_`F`##A& &: 3dsFct|}t|trttj|St|t sJd|j dS)Nr`z-Should only be called on coroutine functions.r)rrrrrbrre)r)rfs rget_coroutine_return_typez%TypeChecker.get_coroutine_return_typesP%k2 k7 +955+N N+x0a2aa0""rc t|}t|trttj|St|t r3t |jDcgc]}|j||c}S|j||sttjSt|tsttjS|jjdk(r't|jdk(r|jdS|jjdvr't|jdk\r|jdSt!Scc}w)zSGiven the declared return type of a generator (t), return the type it returns (tr).r`rSrzrrhrr)rrrrrbrrrget_generator_return_typerYrdrrrrrerrjs rrnz%TypeChecker.get_generator_return_types%%k2 k7 +955+N N  Y /(P[PaPab//lCb ..{LI9//0 0K29//0 0    & &*< <[EUEUAVZ[A[##A& &    % %)Z ZK$$%*##A& &: +csEc|jsy|jj|5|j|dddy#1swYyxYwr')rerDr_visit_func_defrs rvisit_func_defzTypeChecker.visit_func_defsC**  [[ ' ' - '   & ' ' 'rcN|j||j|jrL|js/|js#|j |}|j |||j||jr$|j|}|j||yy)!Type check a function definition.rN) rrr is_overload is_decoratedrr r  original_defrcheck_func_def_override)r)rrnew_types rrpzTypeChecker._visit_func_defs T 2 99##D,=,= -1,F,Ft,L)66t=VW  . .t 4   ))$/H  ( (x 8 rc|jj|jxr| |j}|j d5|j |}|r'|j |j|j}t|tr.|j5|j||||dddn tdddd|jj||_|dk(r|j||dk(rBt!j"|j$r"t!j&|||j$yyy#1swYxYw#1swYxYw)zcType check a function. If type_override is provided, use it as the function type. T)r")rcolumnNz Not supportedr6 __post_init__)rHr- is_dynamicr_rrrGrr{rr!enter_attribute_inference_contextcheck_func_defrr2check__exit__return_typedataclasses_pluginis_processed_dataclassrcheck_post_init)r)r type_overriderrenclosing_node_deferredrs rrzTypeChecker.check_func_itemsN !!$//"3"IM8IJ"&"<"<  % %$ % 7 4$$T*C#11sxx 1S#|,;;=F''c4EFF#?33 4  %<" :   ) )$ / ? "!88C"224tyyID #FF  4 4s% AE$(E=E$E! E$$E-c|jJt|jtrF|j|j}t ||s|j j |||yy|jj}|yt|trw|jI|j}t|tr |j}n|}|j|}|,||_||=y|jtj|yyt|j }|j|_|j$j'||||j)|||tjddy)Nzredefinition with typez original type)rwrrprrr?%incompatible_conditional_function_defrrrgrfind_partial_typesrrINCOMPATIBLE_REDEFINITIONrrrr@ assign_type check_subtype) r)rryold_type orig_typeorig_defrrI name_exprs rrxz#TypeChecker.check_func_def_overridesN  ,,, d'' 1))$*;*;>tXxX4 ))..I )[1>>)#00H!(I6&ll&$($;$;C$@M$0#+)#.II.HH$O 1%TYY/ !%!2!2  '' 8YG""$>>,# rc#HK|j}i|_d||_ywr')rQ)r) old_typess rr~z-TypeChecker.enter_attribute_inference_contexts&11 (*% (1% "c |j|j|j||}|}|D ]\}}|j}t |j |_|jj 5|jj|t|tr|} | jr| jdvrqtt|jtt fsH|j"ds9|j%t&j(j+| j|| jr!| jdk(r|j-| ||j/| |j j0r| j2rt| j2t4r| j2j} t7| r|j8j;d| | t=| j2j>D]D\} } t7| sd| dzd| jd} |j8j;| | | FtA| j2|j |jB|j8| |ro|jr4|jE|r#||jFvr|jI||||n/|d vr|jK|||n|d k(r|jM||t|jtNrY|jjPtRk(r*|j%t&jT|j|jW|nAt|jtNr'|jjXr|jW||jZr|j\r<|j_|jsg|j%t&j`|nF|jc|j|jds |j%t&jf||jhr|j}|jd}|jk||}|jm||}|r|jo|}n|jq||}|jsd ||||g} |ju| }||_|jvj|j|jxj{|5|jxj}}ddd|j~rd}|jrd}|t|j>krt|j~|j>|so|j%t&jj+t|j~|j t|j>||j |d}t|tr|js|j||}tt|j>D]}|j>|} t| tNrp| jPtk(r]|jdvrOt|js:|dk7s|s3| }|jdkr|}|j%t&j|t||||jrt|j}|j||ddd|jj 5d}|jD]}|jjD]\}}t|}||j||jr1||jj}||j|<|j||jj|<|j jr|jsw|jD]h}|j}|j2t|j} || _\|jj| |j2|j2j|jxj{|5t|st|dk\r|jj|j js@|j8jj|j8jjvr2|j jst|tr |jr|j|jddd|jj}!||jjddddd!s|jZst|jvdd r*|jq|jvd|jd}"n:|jdr|jo|jvd}"n|jvd}"t|"}"|xs|j j} xs:| xr5t|txr|jtk7 xr |j }#|jturQ|j|jjvs-|jj|jjrd}#t|tr|jrd}#|rtt|"rd}#|xr]|jtuxrI|jjduxr/|jjj2jd}$|j jr|jst|"ttfs|#rt|"t rt&j}%nt&j}%|r |%jtj}%|j%|%||$r|jt&j|nu|#rst&j}%|r |%jtj}%|jdtd|"||%s"|$r |jt&j||jvj||_ y#1swYxYw#1swYxYw#1swYxYw#1swYxxYw)rs)r*__init_subclass____new__z Return typez Argument rzz to ""r) __getattr____getattribute__ __setattr__rU)rNrF)r*rr|rT abc.ABCMetacodezimplicitly returnsexpected) subtype_labelsubtypesupertype_label supertyperr?)check_typevar_defaultsrDexpand_typevarsr@rrPrexpandedr-rrprrrrrrrHrrMUST_HAVE_NONE_RETURN_TYPErcheck___new___signaturecheck_for_missing_annotationsdisallow_any_unimportedrrrr?unimported_type_becomes_anyrrrrbis_reverse_op_methodrgcheck_reverse_op_methodcheck_getattr_methodcheck_setattr_methodrvariancerP#RETURN_TYPE_CANNOT_BE_CONTRAVARIANTcheck_unbound_return_typevarvalues is_generatoris_async_generatorr^'INVALID_RETURN_TYPE_FOR_ASYNC_GENERATORrYrV!INVALID_RETURN_TYPE_FOR_GENERATORis_awaitable_coroutinercrirlrnrrGrGrE push_functionactive_self_typetype_ishas_self_or_cls_argumentrrNARROWED_TYPE_NOT_SUBTYPErFrvrequire_correct_self_argumentrangerQ is_privater&FUNCTION_PARAMETER_CANNOT_BE_COVARIANTrrrcheck_default_argsframestypesrr:!is_var_redefined_in_outer_context push_frame declarationsallow_redefinition_newr` argumentsvariablerrr_is_empty_generator_functionsuppress_unreachable_warningsr:r>rr; preserve_astshas_self_attr_defrr pop_framerallow_empty_bodiesrrZrRr\plugin_generated is_mypy_onlymetaclass_typehas_basewarn_no_returnr_rINVALID_IMPLICIT_RETURNMISSING_RETURN_STATEMENT_replacecodes EMPTY_BODYnoteEMPTY_BODY_ABSTRACTINCOMPATIBLE_RETURN_VALUE_TYPErr2)&r)rrrrr original_typr old_binderrridxarg_typeprefixtctytctrref_type arg_index found_selfrr'body_is_trivial new_frameframekey narrowed_typekey_varargvn unreachablerf show_errormay_be_abstractr?s& rrzTypeChecker.check_func_defs ##CMM2''c2 !f %ID#J/ =DK..0N ? $$T* dG,D  II)JJ *+CLL9Ho;V!!% 2 22 6 ,GGNNtyyY[_ yyTYY)%;44T3?66t<||;;99DII|)L'+yy'9'9H;HE $ D D]T\^b c1:499;N;N1Oa X#?#I/8q tyykQR-SF$(HH$H$HQY[_$`a+ 4<<1F1FZ^  55d; (@(@@44T3dK!DD11#tTB.11#t<cllK8||,, = ,PPRUR^R^55c:|44kB|G\G\GcGc55lC$$..#BB3<<P II 0 X XZ] $<B!;;A>!;;AqA#663b"b!_ H++X+>C #DI!!((6ZZ--d3J-1JJ,G,G,IHJ ;; !I+0M0M$%  3s}}#55j S]]9%=? ,FFMM +CKK F +CMM),Ddll S! # dG,T5F5F!%!C!CC!NJs3==12OA"}}Q/H!(K8%--: $ 1Y Y$.tyy$9!"az+3C"xx!|&) II&6&]&]_bc'ad6M6MN!O&#2$))"<''o>]N ?b..07 3+/ '.. YE.3kk.?.?.A Y*]"?"D".t7]7]#TYY8 )0,0KK,B,B,D 3@IOOC0>}M  <<.. 66 *;78K L&&k?C"2"J"JC"2"K"KC*"%,,E4D4D,"EC #t,* II&6&J&JDQ*IIC&!ll0@0@lA!..*>$,J,6&1$( # /, "2"F"FM    ! ! #$DKM f %HJJCN ?N ?X//77 37 3sg9F"t,L t,%tG1t,?uu0BuA*u9Ct9Aut) $t,,t6 9u >uu ct|}t|tsy|jjsLt |j dks4|j dr%|jrt|jS|jj|5|jj}| dddy ddd|jr;|jr0|jdtj tj"fvry|js|j%d|y|jd}|j&s|j(dk(r)t*j,j.j1}t3|rytt5t7|}t9||dst|t:r|j<j>sJt|t.r=t|j@t:r#|j@j<j>rd}nt|jBdd vrStDjFjI|jK|j|jK|j}ntDjL}|r|j%||y#1swYxYw) NFrrzKMethod must have at least one argument. Did you forget the "self" argument?rT)ignore_type_params>clsr))'rrrrPcheck_untyped_defsrrHr}r!rrErrrrrrO ARG_STAR2ris_classrrjrrmake_normalizedrr,rrrr is_protocolrrrERASED_SELF_TYPE_NOT_SUPERTYPErstr_with_optionsMISSING_OR_INVALID_SELF_TYPE)r)rrrrerasedr?s rrz)TypeChecker.require_correct_self_argumentFs&t$$ - LL + +4%%&*%%b)??$' ' ZZ % %d + %)JJ$?$?$AH     ,, NNt~~a0U^^U__4UU~~ II]_c >>!$ ==DII2zz**::8DH ( +!x0H!IJ(FtD68,KK++fh/v{{H5KK$$00 "o5&EELL++DLL98;T;TUYUaUa;b'CC #t$_  s J88Kc|jry|jj}|sy|D].}t|tst |j ||k\s.yy)zCan the variable be assigned to at module top level or outer function? Note that this doesn't do a full CFG analysis but uses a line number based heuristic that isn't correct in some (rare) cases. FT)is_finalrDouter_functionsrrpfind_last_var_assignment_liner)r)r after_lineoutersouters rrz-TypeChecker.is_var_redefined_in_outer_contexts\ ::,,. E%)0Q?:M rc~t|jtr"|j|jvrt }|j D]}|j ||j|j vr|jtj|jtt|jj}t|tr|jjdk(sJ|j!dt#|jj|j$d|jyyyyy)z:Fails when the return typevar is not defined in arguments.rbuiltins.objectzConsider using the upper bound z insteadrN)rrrrDCollectArgTypeVarTypesrrrrUNBOUND_TYPEVARr.rr"rrrrrFrP)r)rarg_type_visitorargtyper"s rrz(TypeChecker.check_unbound_return_typevars cllK 0S\\S]]5R57 == 1/0 1||#3#=#== *::CLLx X-cll.F.FG {H5#((115FFII9&s||'?'?NOxY # G > 6S 0rc L|jD]}|j|rt|jtr.|jj }d}|j dr |d|ddz }n |d|dz }|jjs8t|jtr|jjdk(rdd g}nd}|j|jj|j|jt|tj d d | y)NzIncompatible default for __tuple_arg_ztuple argument z argument "r builtins.NonezkPEP 484 prohibits implicit Optional. Accordingly, mypy has changed its default to no_implicit_optional=Truez_Use https://github.com/hauntsaninja/no_implicit_optional to automatically upgrade your codebaserargumentdefault)rr? lvalue_name rvalue_namenotes)r initializerrrjrr startswithrPimplicit_optionalrrcheck_simple_assignmentrrAr ASSIGNMENT)r)rrrrr?rs rrzTypeChecker.check_default_argss >> C&:coo|#L<<$$D-C~.bc 44D6++LL22s9OO,,?],  ( ( !! 5+;+;<&% ) 1 rc&|tjvSr')rreverse_op_methodsr) method_names ris_forward_op_methodz TypeChecker.is_forward_op_methodsi::::rc&|tjvSr')rreverse_op_method_setr!s rrz TypeChecker.is_reverse_op_methodsi====rcd dt|jtxr@tfd|jj|jj gzD}|j xs|jj}|jjxr|}|rQ|jjs|r7|j|jjr|jr.is_unannotated_anys0a,a)Tammy?T?T.T Trc30K|] }| ywr'rrrr+s rrz.s!N *+"1% %N srzrr)rz1Use "-> None" if function does not return a valuerc3.K|] }|ywr'rr-s rrz.sJ)!,Jsrrr8r!)rrranyrrrbrPwarn_incomplete_stubdisallow_incomplete_defsdisallow_untyped_defsrrrrrRETURN_TYPE_EXPECTEDrrrrNO_UNTYPED_DEFFUNCTION_TYPE_EXPECTEDrrnrVrrlARGUMENT_TYPE_EXPECTED)r)rhas_explicit_annotation show_untypedcheck_incomplete_defsrr+s @rrz)TypeChecker.check_for_missing_annotationssI U #-TYY "E# #N /3yy/B/BdiiFXFXEY/YN K  000UDLL4U4U $ E E aJa T\\??CXyy T\\%G%G~~'1,*f4q8IU8RII.CCTJ/5d>O>O O !&!5!5" II.EEtL?P5DII|4*499+=+=>%h/II.CCTJ&&)66xARARS "2"G"GN&&:h+I)$*H*H*RS "2"G"GNJdii6I6IJJII.EEtLK5DYfr |j@}t|tBr6|jD} t| tr| jjF} | | }d fd t|ttHfr  ||sy|j(d } |jJjM|| | } |jO|||j| || | y) z1Check a reverse operator method such as __radd__.Nr)__eq____ne__r rrrrrrrzct|tr|jjSt fdt |j DS)Nc3K|]N}t|txr |xs-t|txr|jj Pywr')rrrrhas_readable_member)rxrJrs rrzSTypeChecker.check_reverse_op_method..has_readable_member..dsYAy)J.A!T.JRq(+P0J0J40PRsAA)rrrrJallrrelevant_items)rrrJs `rrJz@TypeChecker.check_reverse_op_method..has_readable_member`sL#x(xx33D99*#*<*<*>? rr)rzUnionType | Instancerstrr8r!)(rrrrrrrNrrr?invalid_signaturerrrrrrrrOrGrrrrnormal_from_reverse_oprr"rrrrrrrrrrruanalyze_external_member_accesscheck_overlapping_op_methods)r)r reverse_type reverse_namer method_typer forward_name forward_instropt_meta forward_base forward_typerJs @rrz#TypeChecker.check_reverse_op_method%s|yyy# Y++ ,gi6L6L.M N ]]EMM * 4L I** + OO/ 0  , 4 HH & &|W =  / / #<#8#89 h (  h )}}%%)::  ! !! $ 0'55'11!459")a-'11!4c:6L <))*a/// 77 E &|'='=a'@A lK 0*<+C+CDL  i 0),7L  |]K&P Q'00L lH -$$D$)9933'#+L  |h %: ;#L,? #--a0 ((GG ,H  ))   II    * rc t|gD]}t|}t|tr4|j |||s2|j j |||||Rt|trE|jD]5} |j | ||s|j j |||||7t|tr|j j||y)aCheck for overlapping method and reverse method signatures. This function assumes that: - The reverse method has valid argument count and kinds. - If the reverse operator method accepts some argument of type X, the forward operator method also belong to class X. For example, if we have the reverse operator `A.__radd__(B)`, then the corresponding forward operator must have the type `B.__add__(...)`. N) rrrris_unsafe_overlapping_opr?"operator_method_signatures_overlaprrrforward_operator_not_callable) r)rSrT reverse_classrZrVrYr forward_itemrs rrRz(TypeChecker.check_overlapping_op_methods}s`2<.A NL*<8L, 500|\ZHH??%|\ '44*L,B,B1,EF}}o)fqj5  '44#--a0,2H2H2KL}}o)fqj5  +44Q7 ); 7"01D"E  +-@ A +-@ A#E$F#E$F //1 4AM&&00r 8 695  rc|j}|tjvryt|j |}|j }d|ddz}|j |rut|}t|jj|||}d}t|trt||sd}nd}|r|jj|||yyy)zrCheck an inplace operator method such as __iadd__. They cannot arbitrarily overlap with __add__. N__rFT)rrinplace_operator_methodsrrrrJrrrurQrris_more_general_arg_prefixr?signatures_incompatible) r)rmethodrr other_methodinstancetyp2rs rr z)TypeChecker.check_inplace_operator_methods  ;; ; **401iifQRj(  " "< 0$S)H"!!@@xY]^DD$ -1#t<D00tL 1rc t|jjdk(r||dk(r!|jtj |yt |jdgtjgdgttj|jd}n|jjr~t ttj|jdgtjtjgddgttj|jd}nyt||s|jj!|||yy)Nrzrrr)rrErrrMODULE_LEVEL_GETATTRIBUTErrrrNrrrr@rr?$invalid_signature_for_special_method)r)rrrrUs rrz TypeChecker.check_getattr_method s tzz A %)) *DDgN'01 ../ 34 KZZ $ $ &&//0$//.2QR .t  ../ 34 K #{+ HH 9 9#w M,rc |jjsytttj |j dttj gtjtjtjggdt|j d}t||s|jj||dyy)Nr)NNNrr) rEr@rrrrrrrNrrr?rt)r)rrrUs rrz TypeChecker.check_setattr_method(szz&&( " ..// ../  ]]EMM5== 9  J OO/ 0  #{+ HH 9 9#w V,rc |jd}t||jd|gg}|j|||tj ddt jy)zCheck the type of __slots__.rtyping.Iterablez actual typez expected typerN)rrrrrINVALID_TYPE_FOR_SLOTSrr)r)rrstr_type expected_types rcheck_slots_definitionz"TypeChecker.check_slots_definition9sh??>2! t../@8*M N       3 3  !!  rc|jjsyt|}t|trt d|j Ds-|jjd|tjyy)z2Check that __match_args__ contains literal stringsNc32K|]}t|ywr')is_string_literalrrs rrz/TypeChecker.check_match_args..Ns5 (, d #5 zb__match_args__ must be a tuple containing string literals for checking of match statements to workr) rEr@rrrrLrr?rr LITERAL_REQ)r)rrrs rcheck_match_argszTypeChecker.check_match_argsIsnzz&&( c"#y)5 03 5 2  HHMM.&&  2 rc\g}t|jxsg}|jr'||jjjxsgz }|D]U}t |t s|js!|j|jDcgc]}|j|fc}W|ry|jjsc|jjsMg}tj|D]4}t|} |jt!|| t#|| f6|S||fgScc}wr')listrDrrrArrrr-idrPmypyc inspections itertoolsproductdict expand_funcr8) r)rrsubsttvarstvarvalueresult substitutionsmappings rrzTypeChecker.expand_typevarsXs57S]]#)r 99 TYY^^--3 3E JD$ , DKKH5tww.HI J $,,,, 0H0H:rr;rrr}rmetadatarmro*check_method_or_accessor_override_for_baser-)r)rcheck_override_compatibilityrbasers rrz!TypeChecker.check_method_overrides << % %)=)=A^A^)^ IIZ Z 00I8I4I  ]*C99%%))/:dB %57!IIMM!"% 7DDDd8F~)006 7)(rcd}|r|j}|jj|}|rrt|jr2t |s'|j j||j||jr|j||j|d}|rB|j|||ry|tjvrd|ddz}|j|||ry|S)aCheck if method definition is compatible with a base class. Return ``None`` if the node was deferred because one of the corresponding superclass nodes is not ready. Return ``True`` if an attribute with the method name was found in the base class. FTNrjr) rr\rrrrr?cant_override_finalr$check_if_final_var_override_writable(check_method_override_for_base_with_namerrk)r)rrrfound_base_methodr base_attrrns rrz6TypeChecker.check_method_or_accessor_override_for_bases" 99D t,I 0D9IHH00tyy$G====dINNTXY$(!+@@tTR9===!DH_F DDT6SWX#  rc|j|j|j|d\}}|j|j||d\}}||Jt||s)|jj |j |||yy)a&Check override of a setter type of a mutable attribute. Currently, this should be only called when either base node or the current node is a custom settable property (i.e. where setter type is different from getter type). Note that this check is contravariant. TrN)node_type_from_baserrrr?incompatible_setter_overrider)r)rrrrr!s rcheck_setter_type_overridez&TypeChecker.check_setter_type_overrides))$))TYYRV)WQ33DIItTW[3\ q=#<<<-- HH 1 1$++sMSW X.rc N |jj|}|syt|ts|}n |j}t|t t fr|jxs |j}n.|jjxs|jj}|j|j|j|\}(|jd|jjvsJy|j}d} |j|||\} }| )d} |j|jkrs|jj!} t| t r,|j#| |jj%| y|j#||jyt|t t fr|j'|} nst|tr|j'|j} nGt|t(r-|j*t-|j*} nt/} n t/} d} t1|rGt1|st|t(r,t3|s t3|r| rd} |j5||t|t t fr|jxs |j} n9t|tr'|j}|jxs |j} nd} t-t-| } t7|rt|t(rz|j8sn|j6r |j0rVt|trFt| t:s6|j<j?d|jt@jBt| t:stt:r yt| tDrttDr|jG| |j||jH|jJjLk(r |jn |jL| ||}|r|rt@jN|jPjRvr|jU|rp| sntW| ds`tY| |jP\}}tZj\j_d|jd |d |d }|j?||yt| t`rtcfd | jdDr|rt@jN|jPjRvrs|jU|rb| s`tY| |jP\}}tZj\j_d|jd |d |d }|j?||ytg| r y|r!|jU|r| rtW| r y|j<ji|j||j||  y)zCheck if overriding an attribute `name` of `base` with `defn` is valid. Return True if the supertype node was not analysed yet, and `defn` was deferred. Fz -redefinitionTz;Cannot override writeable attribute with read-only propertyrignore_pos_arg_namesrz (base class "z" defined the type as z, override has type )c3:K|]}t|dyw)TrNr0)rorig_typrs rrzGTypeChecker.check_method_override_for_base_with_name..o s%:  sH4 @ @: soriginaloverride)5r\rrrgrrprr is_staticrrrrr^rrErrrrrrrrris_custom_settable_propertyrrrrr?rrOVERRIDErcheck_override module_namerZrMUTABLE_OVERRIDErPenabled_error_codesis_writable_attributerrHr'COVARIANT_OVERRIDE_OF_MUTABLE_ATTRIBUTEwith_additional_msgrr0rr%signature_incompatible_with_supertype)r)rrrrroverride_class_or_staticr original_nodesupertype_readyr! top_levelalways_allow_covariantoriginal_class_or_staticrokbase_str override_strr?rs @rrz4TypeChecker.check_method_override_for_base_with_namesXJJNN4(  $ *GiiG dW&78 9'+}}'F $'+yy'9'9'PTYY=P=P $))$))TYYEQ ; ii[ .$))//A AA! 33D$E q  #O}}t~~-!JJ99; i1OOItzz/I/I)/TU OOD$))4MG5F+GH $ 2 2= A M95 $ 2 2=3E3E F M3/ !%%1$3M4F4F$GM$,JM!) !&  %  /:mS3Q*405PQ^5_#-1*33D$? mg/@%A B'4'='='XAXAX $  y 1 %%D'+}}'F $', $c"' 6   =#.!**"..-2T2T4+mW5 QII  mW -C1I DC | 4C9V$$ !--1C1CC (( B!**dll.N.NN..}=."=#DQ)?!3 *&,'NNbb$TYYK/EhZP**6q: #w'JI y 1c: )//: 7 **dll.N.NN..}=.*@!3 *&,'NNbb$TYYK/EhZP**6q: #w'"!=# .  // >BX3 .   HH : : 4GmVY ; rct|tr^|jrQ|jdtk(r;t |j d|j Dchc]}|jc}Syt|trH|jDcgc]}|j|}}|Dcgc]}|s| }}|r t|SyJdcc}wcc}wcc}w)Nrz,Need to check all FunctionLike subtypes here) rrrrNr,rrDrrrget_op_other_domainr)r)tprit raw_itemsrs rrzTypeChecker.get_op_other_domain s b, '|| Q7 :&bll1obll7S7STT J '@BI"11"5III"+2BrR2E2,U33 HH H58TJ2sC C+C3Cc  d} d} t||dsd} nWt|trG|j|r6|j |} |j |} | r| rt| | sd} d} t|t r[|r|sd} nTt|t rDt|t r4|j|jd} |j|jd} t|rd} | rd} t|t xr |j}t|t tfr|j}t|t tfr|j}t|t rwt|t rft|jt|jk(r:|j|jk(r |jd}t!|}t|t"r|j$j&}d fd }t)t+|j,|j,D]M\}\}}|j/r/|j/r|j|}|j|}n{|j1rj|j1rZ|sX|j2|}||j2vr:|j|}|j2j5|}|j|}nÌt|||r|}t|t"r=|j6s1|j8||j;z}|j<dk7r|}|j>jA|dz|||||||d} Pt||jB|jBs|j>jE||||jB|jB|d} nt|trt|trg}|jFD]>}t)|jFD]$\}}t||s|jI|>@t|t|jFk(r.|tK|k7r |j>jM||||d} | s!|j>jO|||||| | r"|jQd |tRjT | S) aCheck a method override with given signatures. Arguments: override: The signature of the overriding method. original: The signature of the original supertype method. name: The name of the overriding method. Used primarily for generating error messages. name_in_super: The name of the overridden in the superclass. Used for generating error messages only. supertype: The name of the supertype. original_class_or_static: Indicates whether the original method (from the superclass) is either a class method or a static method. override_class_or_static: Indicates whether the overriding method (from the subclass) is either a class method or a static method. node: Context node. FTrNct|S)N) ids_to_erase)r,)r override_idss rerase_overridez2TypeChecker.check_override..erase_override s)!,GGrrrz)secondary_contextrzHOverloaded operator methods can't have wider argument types in overridesr)rrr8r)+rrrr#rrr type_guardrr unpack_kwargsrErrmin_args type_var_idsrrprrrzipr is_positionalis_namedrindexrrboundrr?$argument_incompatible_with_supertyper'return_type_incompatible_with_supertyperr-sorted.overload_signature_incompatible_with_supertyperrrr)r)rrr name_in_superrrrrrop_method_wider_noteoriginal_domainoverride_domain emitted_msgoffset_arguments type_namerrrsub_kind super_kindoverride_arg_typeoriginal_arg_typearg_name original_irarg_nodeorder child_variantparent_variantrs @rrzTypeChecker.check_override s8$(H4HD * -$2K2KD2Q#66x@O"66x@O#"?OD'+$ h -'0HHl3 8\8Z&&2x7J7J7RD##/H4D4D4LD d D K)(LA\hF\F\ (\:$>?#88:(\:$>?#88:8\2x6**+s83E3E/FF%%):):: (446  )(3 j'2 * 4 4IH2;**H,>,>?2 +-A-* --/J4L4L4N,4,>,>q,A),4,>,>q,A)!**,1D1D1FO_#+#5#5a#8#x'9'99080B0B10E-)1););)A)A()KJ080B0B:0N-$ %&7HY9Z[+/%dG4T=M=M'+~~a(..:J6J'KH'}}2*2EEE %)-%#.2F '+ A +D".1B1B"CXEVEVWHHDDmY8I8I8K\K\^b#'KHj1j:6V%-^^"M-6x~~-F")>%m^D!LLO!"" u:X^^!44&-9OHHKKmY#'K>>-D8V^?$ ^ xrc |jrt|jtsyt|jj}t |syt |}|sytd|Dr|jj|yy)a;Generate error if the return type of __exit__ is problematic. If __exit__ always returns False but the return type is declared as bool, mypy thinks that a with statement may "swallow" exceptions even though this is not the case, resulting in invalid reachability inference. Nc3K|]9}t|jtxr|jjdk(;yw)builtins.FalseN)rexprrr)rrets rrz7TypeChecker.check__exit__return_type..\ s;  sxx * Tsxx/@/@DT/T T s?A) rrrrr has_bool_itemrrLr?incorrect__exit__return)r)rrr=s rrz$TypeChecker.check__exit__return_typeI sxyy 499l C "499#5#56X& '-      HH , ,T 2  rc 8 |j}|jddD]H}|js|jtj j |j|Jt|js9|jtjj |j||jj|j5|jd5|j}t|j |_|jj#5|j$j'|j5|j)|j*dddddd||_|jj,s=|jj.s'|jj0s|j3||j4s|j7||j9||j;||j<rt?|j|j@}tC|j<D]}tE|tFrtE|jHtJr.|jLj)|}|jO||}d} tE|tPr|jRxsd} |jT} d|_*|jLjW||gtXjZg|| \}} | |_*dddddd|j\j^r|j\j`|jD]} tc| jd| jfj\j^D]\} }tE| ths| jjtlk7s+tE|ths<|jj| jjk7sV|jd| jd|tnjp |j\j^r%|js|j\j^|jtr'|j\j^r|jw||j4s'|jj0r|jy|t{|jy#1swYzxYw#1swYxYw#1swYxYw#1swYxYw) zType check a class definition.rzNTrr) callable_namezVariance of TypeVar "z+" incompatible with variance in parent type)rr)>rrrrrCANNOT_INHERIT_FROM_FINALrrrbasesINCOMPATIBLE_DISJOINT_BASESrDrrr@rrPrrErrrtypeddict_type tuple_typeis_enumcheck_init_subclasshas_incompatible_baseclasscheck_multiple_inheritancecheck_metaclass_compatibilitycheck_final_deletable decoratorsrrreversedrrbanalyzedrru temp_noderrri check_callrrNrrA type_argsrrerrrrUrr.rrcheck_protocol_variance check_enumr)r)rrrrsig decoratordectemprold_allow_abstract_callr base_inst base_tvarbase_decl_tvars rvisit_class_defzTypeChecker.visit_class_defb siiGGABK ^D}} *DDKKDIIVX\] ^-SYY7 II&BBII#((SUY Z [[ $ $TYY /' G1I1ISW1I1X' GJ/ =DK..0 +ZZ**4995+KK *+ +%DKII,, 0D0D HYHY((.22//4  . .s 3  & &s +,TYYH!)$//!:GI!)X6:!**K<!++229=C>>#y>AD#H!)W5#,#5#5#=/3.F.F+/3D,!..99dVemm_d(:FC0GD,)G'' G' GT 88  #(("4"4"< YY  14NNINN$7$7$A$A2-I~#9k:%..);&~{C*33y7I7II 3INN3CD;;$(!& "  88    ' '(:(: ; ??sxx11  ( ( ...4993D3D OOD !dii(}++ + +' G' G' G' GsVT-AT.&S5S( 0S58F0T(T(S2 -S55S? :TT TTc|jD]|}|jj|}|s!t|jt s<|jj sS|jtj|j~yr') deletable_attributesr\rrrrrrrCANNOT_MAKE_DELETABLE_FINAL)r)rattrrs rrz!TypeChecker.check_final_deletable sb,, SD99==&D 499c2tyy7I7I *FF R Src|jjr-|jjjjdvry|jjddD])}d|j vrt |j}||_t|d}t|jj}t|jj}d|vr3|jd}|j||j|t gt#|z}t%||||} |j&| _|j(| _|j*| _|j,j/| ddyy)a Check that keywords in a class definition are valid arguments for __init_subclass__(). In this example: 1 class Base: 2 def __init_subclass__(cls, thing: int): 3 pass 4 class Child(Base, thing=5): 5 def __init_subclass__(cls): 6 pass 7 Child() Base.__init_subclass__(thing=5) is called at line 4. This is what we simulate here. Child.__init_subclass__ is never called. ) builtins.typerNrzr metaclassTallow_none_returnalways_allow_any)rrrrrr\rrrr~rkeywordsrkeysrr2rMrrbrr{end_linerur) r)rrrcalleererrr call_exprs rrzTypeChecker.check_init_subclass sK 99 # # (@(@(E(E(N(NW ) IIMM!"% D"$**4 +I!IN +>?F ,,./D*.t}}/A/A/C*DIi'ook2 c" " c$i/I y)DI!YYIN#{{I !%I     $ $Y$Y] $ ^ - rc6|D]ttrjs$tjj s|j djsctfdjDr|j dy)Nz3TypeVar default must be a subtype of the bound typec3JK|]}tj|ywr')rr)rrtvs rrz5TypeChecker.check_typevar_defaults.. s$\\"**e%D$\s #z3TypeVar default must be one of the constraint types) rr has_defaultrrr"rrr0)r)rr&s @rrz"TypeChecker.check_typevar_defaults sw UBr;/BNN4Dbjj"..9 OQSTyy$\RTR[R[$\!\ OQST  UrcR|jjsJ|jjtvrd|jjvrs|jjd}t |j tr@|j jr*|jtj|j |jjddD]4}|js|jtvs#|j||6|jrj|jjdvrR|jj s<|jd|jjd||j#d||j%||j'|y)N __members__rzr>enum _typeshedzDetected enum "z" in a type stub with zero members. There is a chance this is due to a recent change in the semantics of enum membership. If so, use `member = value` to mark an enum member, instead of `member: type`zLSee https://typing.readthedocs.io/en/latest/spec/enums.html#defining-members)rrrrr\rrrhas_explicit_valuerr$ENUM_MEMBERS_ATTR_WILL_BE_OVERRIDDENrcheck_final_enumr`rZ enum_membersrcheck_enum_basescheck_enum_new)r)rsymrs rr zTypeChecker.check_enum sGyy    99  Z /MTYY__4T))//-0C#((C(SXX-H-H *OOQTQYQYZIIMM!B' 2D|| Z ?%%dD1 2 <.has_new_methodE sF),JJOOJOO,,0II rFc3LK|]}|j xr|ywr')r)rbr;s rrz-TypeChecker.check_enum_new..S s$aAII C.2C Cas!$rzrzLOnly a single data type mixin is allowed for Enum subtypes, found extra "{}"T)rrr8r!) rrrrr0rrrrrP)r)rhas_newr candidater;s @rr1zTypeChecker.check_enum_newD s IIOO DIyy  aTYY]][\]_M`aa *4995 W ''-vd.C.CDLL.Q'R ! rc|jy|j}t|jdg}|jj }t |D]\}}t|tst |Dcgc]%\}}||k(r|nttj'} }}t |Dcgc]-\}}||k(r tnttj/} }}t|| t|| } } t| | drt} nt| | drt} nt } | |j"k7s|j$j'|j"|j(| |"ycc}}wcc}}w)a/Check that protocol definition is compatible with declared variances of type variables. Note that we also prohibit declaring protocol classes as invariant if they are actually covariant/contravariant, since this may break transitivity of subtyping, see PEP 544. NrT)ignore_declared_variance)r rrrrrArrrrrrrrrQrPrUrr?bad_proto_variancer)r)rr object_typerrrrMrup_args down_argsupdownrs rr z#TypeChecker.check_protocol_variance` sZ >> % yytxx|R0  ## ' VGAtdK0&e,#Aq !Av 793I3I+JJ#G# &e,%Aq&'!V!9O9O1PP%I% g.y0IB$TB$BtD($4==(++DMM499hPTU+ V#%s :*E852E>ct|jdkry|jdd}|Dchc]}|jD]}|}}}t ||jj z D]mt rtfdt|D\}}||dzdD]4}|jvs||jvs!|j|||6oycc}}w)z.Check for multiple inheritance related errors.rzNc3JK|]\}}|jvs||fywr')r\)rrrrs rrz9TypeChecker.check_multiple_inheritance.. s$YDddjjFXAt9Ys# #) rrrr\rr rnextrcheck_compatibility)r)rrrr all_namesrbase2s ` rrz&TypeChecker.check_multiple_inheritance s syy>Q  ggabk&)AddjjAdTATA A9syy~~'778 ED$YIcNYYGAtQUW E5;;&5+@,,T4D E EBsC#c J|dvry|j|}|j|}|j||||\}}|j||||\} }t|} t| } t| trt| trs| j rM| j r=t t| jt| j} nq|r| sJt || d} n[|r| r|j(|j|js t || } n t|| } | r|jr|jr|j|jrt|jrt|jtrt| ts|jj!d|d|j"d |j"d |t$j& nT|'|jj)||j"|| '|jj)||j"|d} t+|jr2t-|s'|jj/||j"|t+|jr|j1||j|t|jt2r|jj4rd} | s|jj7||||yy) ayCheck if attribute name in base1 is compatible with base2 in multiple inheritance. Assume base1 comes before base2 in the MRO, and that base1 and base2 don't have a direct subclass relationship (i.e., the compatibility requirement only derives from multiple inheritance). This check verifies that a definition taken from base1 (and mapped to the current class ctx), is type compatible with the definition taken from base2 (also mapped), so that unsafe subclassing like this can be detected: class A(Generic[T]): def foo(self, x: T) -> None: ... class B: def foo(self, x: str) -> None: ... class C(B, A[int]): ... # this is unsafe because... x: A[int] = C() x.foo # ...runtime type is (str) -> None, while static type is (int) -> None )r*rrN)rPleftrightTrz%Cannot override writeable attribute "z " in base "z#" with read-only property in base "rr)r\rrrr is_type_objrr type_objectrrrrrgrr?rrrrcannot_determine_type_in_baserrrrrallow_incompatible_override#base_class_definitions_incompatible) r)rbase1rMr'rgrh first_typer second_type p_first_type p_second_typers rrKzTypeChecker.check_compatibility s. ? ?  D!T"00ucQT0U A11$sRU1V Q 'z2 ' 4 lL 1jP\6]'')m.G.G.I / 0H0H0JK01J1J1LM "k11 KdS K{{&t/I/I&++/V K8":{;JJ 226;;?#EJJ/"5::y9&}g>HHMM?v[QVQ[Q[P\]==BZZLK"^^ "!66tUZZM"66tUZZMB  %j.> HH ( (uzz3 ?  $  5 5dFKK M fkk3 'FKK,S,SB HH 8 8ueS Qrc|js0|js$|js|js |jy|j ut d|jDrX|jd|tj|j}|r#|j||tjyyyy)z. s$. 59DII $ $D 0. s"$zxMetaclass conflict: the metaclass of a derived class must be a (non-strict) subclass of the metaclasses of all its basesr) r>ris_named_tuplerrrr0rrr METACLASSexplain_metaclass_conflictr)r)r explanations rrz)TypeChecker.check_metaclass_compatibility s    !!{{!!-     %#. =@YY. +  IIN__   88:K +s A+ %rc|jD]?\}}|jj|x}$|j|j|A|j |yr')r\rLrwarn_deprecatedr check_import)r)rrrr2s rvisit_import_fromzTypeChecker.visit_import_from sWzz 5GD!||''--:$$SXXt4 5 $rc&|j|yr'rers rvisit_import_allzTypeChecker.visit_import_all  $rc&|j|yr'rhrs r visit_importzTypeChecker.visit_import rjrc |jD]}|jd}|j|\}}}|ttj }t |jtsJtjj|jj}|j||j||ddy)Nrz local namez imported name)r?rr) assignmentslvalues check_lvaluerrrrrvaluerrINCOMPATIBLE_IMPORT_OFrrr)r)rassignlvalue lvalue_typerrjmessages rrezTypeChecker.check_import s&& F^^A&F!%!2!26!: KB"%i&<&<= fmmX6 66&==DDV]]EWEWXG  ( ( (+ )  rc|jr|jjy|jD]}|jjrA|j sy|j |rA|j j|y|j||jjjyr') rr@rrrrr?rrru expr_cacher{)r)r=ss r visit_blockzTypeChecker.visit_block- s   KK # # %  5A{{))+<<>44Q7HH2215 A!!,,224 5rc|jxrB|jjxr*|j xr|jj Sr')in_checked_functionrPwarn_unreachabler_r@!is_unreachable_warning_suppressedrts rrz,TypeChecker.should_report_unreachable_issues@ sS  $ $ & D -- D... DKKAACC  rct|trt|jryt|tt fryt|t rt|jtryt|jtrq|jjjd5t|jj|jdd}dddttryy#1swYxYw)aReturns 'true' if the given statement either throws an error of some kind or is a no-op. We use this function while handling the '--warn-unreachable' flag. When that flag is present, we normally report an error on any unreachable statement. But if that statement is just something like a 'pass' or a just-in-case 'assert False', reporting an error would be annoying. T)filter_revealed_typerNF)rr\is_false_literalrrrrlrjrbrur? filter_errorsrrr)r)ryrs rrz$TypeChecker.is_noop_for_reachabilityH s a $)9!&&)A Ix0 1 > *!&&,/AFFH-&&**88d8S)))00FFdT1Cc?3s )2C55C>cT|jr |jse|j|j5|j |j d|j |jdu|jddd|jr|j||j|jjrt|jryt|j dtr5|jj!dt#t$j&|n'|jj!d|j|t)|j|j|j*|j|t-|j dkDr|j/|j s%|j0j3|j |j5|j7|j |}|j ddD]E}|j|j5|j |||jdudddG|j9||jr[|jrOt;|js:|j<j? |jAtBjD||jFr.|jIs|jjK|yyy#1swYxYw#1swYxYw)z|Type check an assignment statement. Handle all kinds of assignment statements (simple, indexed, multiple). rNzA type on this linezType of variablerrz)& is_alias_defr`enter_final_context is_final_defcheck_assignmentrorqr new_syntaxcheck_type_alias_rvaluerPrrrrr?rrrrrrbrhas_typerurr lookup_type check_finalrrEr@rrDEPENDENT_FINAL_IN_CLASS_BODYunanalyzed_typer| annotation_in_unchecked_function)r)ryrqlvs rvisit_assignment_stmtz!TypeChecker.visit_assignment_stmtd sa4<<))!..9 ]%%aiimQXXqvv~q||\ ] >>  ( ( + FF  44,QVV4!))B-344)793I3I+JA445GQRSqvvt||T5J5JDHH^_` qyy>A ==*!!((2^^D$4$4QXX$>BFiin F--ann=F))"faffnEFF F  NN#AFF+ '')5 II&DDa H  T%=%=%? HH 5 5a 5 @&@ Q ] ]8FFsAL3 LLL' c|jj5|jj|j}ddd|j |j dy#1swY)xYwNr)r?rrurrq store_typero)r)ry alias_types rrz#TypeChecker.check_type_alias_rvalue sW XX # # % <**11!((;J <  " z2 < | j@rl|jC| }|l|jDs4tG| } tI| t9g}|jK| ||nd| _|| =| j4}n|jM|j:|| ntO|rFt|tr6t|jtPr|jjRr|s|} nt|t.rM|jTA|jj|jV}|jY||||| \} }}nG|j>jZstO|r t|tr|jTt\k(rt|jtPr|jj4r|j|j^vrtt7|t`s|j^|j}d }tc|jdjfD]}|jh|vs|jj}n|r(tm|}|jK|j|||jo||||| \} }d}t7| }t7|}t|tpr|jsr|jujvs|jujxrt|tzrwt|j|t~r]|j|j4jvs |j|j4jxr|jj||y| r|rt|t2st|tr |js|jdj|| |t|trt|jtPr|jjr~|jjrh|ftG||j_nK|j>jZr5|3|jdj|||n|r|j||||r|j||}|jj|| } |j@s6|js*t|tr|jdk(s tG| } |j||| ||j|t|tr3t|tr|jdk(s|j||yyy) z0Type check a single assignment: lvalue = rvalue.=)rrrr __slots__N__match_args__r|)is_lvalue_finalrF)rinferredrtrx)Lrrr{$check_assignment_to_multiple_lvaluesr.try_infer_partial_generic_type_from_assignmentrprrrrurrrrEr@r{rrrrr&DATACLASS_POST_INIT_MUST_BE_A_FUNCTIONr~CANNOT_MODIFY_MATCH_ARGSrrrrris_valid_inferred_typerPrrr_r-rset_inferred_typeinfer_partial_typeis_literal_noneris_initialized_in_classkindrcheck_member_assignmentrrWrUrrr@rrrrrrrRrS is_abstractrrrrr?concrete_only_assignis_special_formr is_inferred is_index_varcheck_indexed_assignmentget_variable_type_contextinfer_variable_typecheck_assignment_to_slotsrcheck_compatibility_all_supers)r)rtrqinfer_lvalue_typerru index_lvaluerr signaturerr@ rvalue_typerrI inferred_type instance_typedecl_frame_maphas_if_ancestorr p_rvalue_type p_lvalue_typerxs rrzTypeChecker.check_assignment sg fy(3 4  5 5 ff.?   ? ?PS T262C2CFF2S /Kx&(+ {{''MM"$/ $($5$5$<$I%//C-#T\\3<<)-(?(?(D (4#'#=#=.OP[.\ 0E{T\T^F_0` $ 6 6sFM R+/ -c 2*-((K// U#F+"684"6;;4 ;;&#.Kvz2v{{7J$($5$5$<$9272I2I %&+*<[*IK 226;; T/3/K/K#VVhW]0L0,K $H!0 < / < }l;%113%113??(446BB"=(;"=#5#5x@%**//;;}?Q?Q?V?V?b?bHH11-H#4Z U`=a&vx8V=S=S // [Q&vx8 *6;; < & 7 7 & 8 8 + 7/PQ\/]FKK,\\88[=TKK++FKM--lFFK#==hO "//66vL6Y %%,,"684HX9X"CK"PK((6;O  * *6 2&'*68,@P1P 33FFC 2Q+r) builtins.list+) builtins.set|r partial_type_augmented_opsc |g}|jr|jjddD]}|j|jvr|j|jj}|j |j||t |xst|txr t| \}}|st|tr |jrt|tr|j||s|jdk(r>|jj$|jd}|j!d|gS|jdk(r>|jj#r$|jd}|j!d|gSy|d} |D]} t%| | r| } t'| | ry| S) Nrzrrrrwrrr)rrrr\rr is_methodrrr(invalid_partial_typerr-rEr@rr is_top_levelrr) r)rrq type_contextsr base_node base_typerryr?others rrz%TypeChecker.get_variable_type_contextW s == ))!"- 4== 2!JJx}}5:: #77MM&y17!)S17+I66 8  1' 37I!((3' 4*}} + 0G0G0I0U??>:../@8*MM}} )djj.E.E.G??>:../@8*MM!!$ " E  2!  51   rc.d}t|trKt|jtr1t|jjt r |j}n+t|t r|jj|}| |j}t|t sJ|jy|dk7r%|jj|f|jvry|j|}|y|jj|}t|}t|tr<|j|jk(r"t||j r ||_||=yyyt|t"rt%|j|_||=yyy)aETry to infer a precise type for partial generic type from assignment. 'op' is '=' for normal assignment and a binary operator ('+', ...) for augmented assignment. Example where this happens: x = [] if foo(): x = [1] # Infer List[int] as type of 'x' Nr)rrrrrrr~ruget_partial_self_varrrrrrrrrPrr)r)rtrqoprrrIrs rrz:TypeChecker.try_infer_partial_generic_type_from_assignment s^ vx (6;;,6;;++[9++C  +##88@C ?((Cc;/ //xxSychh//4D<[<[[!33C8M$++226:K)+6K+x0##sxx/4J5 +CH%c* 5/ K11#((;!#&2+ rc |j}t|tr|j|jk(s|jr|j s|j tdfvrt|jjdkDr}|jjddD]h}|jj|j}|+|j|||jsn!|j!|||jrhn|jj#}|r|dnd}d}|jrc|j sWt|j$t&s |j$nd} |j(j+|| } |j$}| |_|j-|j|j|\} } |jr|j s||_| sy|jjddD]}|j.r|jdk(r|j0dk(s.t3|jrD|j-|j||\} }t5|}t| t&rd} | s|J|j7| ||| ||sy| rT|rR|j-|j||d\} } | Jt9| | s |j:j=|| | |y||usyyyyyyy) Nrrzrrr )rTr)rrrrrexplicit_self_typerrYrrrrr\rr"check_compatibility_classvar_supercheck_compatibility_final_superdirect_base_classesrrrurrrUrrrcheck_compatibility_superrr?r)r)rtrq lvalue_nodertnode direct_baseslast_immediate_baseactual_lvalue_typer'rrurrr custom_setters rrz*TypeChecker.check_compatibility_all_supers skk  {C (   FKK/**#66 d|+K$$**+a/#((,,QR0  {'7'78$BB;PTV[V`V`a?? TSXS]S]^ '++??AL6B,r"2  "& &&{/M/M.89I9I;.Wk&&]a"//66vsC %0%5%5"#.  !55k6F6F HXHXZ`aNK&&{/M/M#5  #((,,QR0. ::$$ 3 IZ8Zk../'+'?'? @P@PRVX^'_$ 9 ;I F i5 $I$00099#!!/< :"}'+'?'?',,dF(@( 1 )444))[A HHAA & Y#22]. C0,7+ )rc D|j|||tjdd|jd}|rktj |j jvrE|j|r4|s2|j|||tjd|jdd}|S)Nzexpression has typez base class "z" defined the type as) rr INCOMPATIBLE_TYPES_IN_ASSIGNMENTrrrrPrrr)r) compare_typerqrrrrrs rrz%TypeChecker.check_compatibility_supers       = = !499+%: ;   &&$,,*J*JJ**95*## HHtyyk)>?% B r)rrrPc |jj|}|r\t|jtt fr |j r0t|j tr|j j y||jj}n t|}|Jdt|tr t|} n|} t|dtjj!||||d} |j"j%d5|r:| j j&xs| j)d} t+| || | | } nt-|| | |} ddd |jfS#1swYxYw) aFind a type for a name in base class. Return the type found and the corresponding node defining the name or None for both if the name is not defined in base or the node type is not known (yet). The type returned is already properly mapped/bound to the subclass. If setter_type is True, return setter types for settable properties (otherwise the getter type is returned). NNNz)Internal error: base lookup outside classFT)rrr r!rr(suppress_errorsfilter_deprecatedr) mcs_fallback override_info)r\rrrrrgrrrEcurrent_self_typerrrr$rjrkis_operator_methodr?rrrr%r&) r)rrrrrrPrrBrpmxrrs rrzTypeChecker.node_type_from_base2sY$JJNN4( )..3 *:;NN)..+6##/   446I%m4I$Q&QQ$ i +%i0H H !99$?#  XX # #d # ; U#==77Y2==;Y:dBXT ;42tT  U)..(( U Us A E66E?cnt|tsy|jrF|js:|jtj j |j|y|jsF|jr:|jtjj |j|yyNTF) rr is_classvarrrCANNOT_OVERRIDE_INSTANCE_VARrrCANNOT_OVERRIDE_CLASS_VARr)rrrs rrz.TypeChecker.check_compatibility_classvar_superns)S)   I$9$9 II&CCJJ499UW[ \!!i&;&; II&@@GG RTX Yrct|tttfsyt |j ry|j rN|j st|ts2|jj|j |j |y|j rB|jtvs|j tvry|j|j ||y)aCheck if an assignment overrides a final attribute in a base class. This only checks situations where either a node in base class is not a variable but a final method, or where override is explicitly declared as final. In these cases we give a more detailed error message. In addition, we check that a final variable doesn't override writeable attribute, which is not safe. Other situations are checked in `check_final()`. TF) rrrorgrrrr?rrrrrrs rrz+TypeChecker.check_compatibility_final_super{s)c8Y%?@ dii    4== 9c8R HH ( (DIIt D ==}} *dii;M.M  5 5diiD Qrcld}|r|j|}|r|jj||yy)aCheck that a final variable doesn't override writeable attribute. This is done to prevent situations like this: class C: attr = 1 class D(C): attr: Final = 2 x: C = D() x.attr = 3 # Oops! TN)rr?final_cant_override_writable)r)rrr'writables rrz0TypeChecker.check_if_final_var_override_writables8 11) *88*C88*C*4Q*GU djj.E.E.GGlGQBb'* **ww"!"''3///GG00GG55 LLq.1*)77HH003 QB"g&:bggs+Cww||jj--/?!$ &"jjnnT2:chh#<"xx00 $ = =dCHHMMUYDY[\ ] % &77##MHH11$ 8LaP' Qrc2t|tsyt|jj |j }t|t r/|jjrt|j}t|tsy|jjy|j|jjvry|jjddD]}|jj!dy|jj!|j}|y|j#||jry|j%t&j(j+|j|jj,|y)Nrr)rr~rrurrrris_selfr"rrslotsrrr\ris_assignable_slotrrNAME_NOT_IN_SLOTSrr)r)rtinst base_infors rrz%TypeChecker.check_assignment_to_slotss/&*- t0077 DE dK (TWW__->"4#3#34D$)  99?? "  ;;$))// ) s+ I""=1=  YY]]6;;/     " "6:?? ;   . . 5 5fkk499CUCU VX^ rc:tddryt|}|t|tryt|tr|j j dduSt|tryt|trtfd|jDSy)NrFT__set__c3BK|]}j|ywr')r)rurtr)s rrz1TypeChecker.is_assignable_slot.."sMat..vq9M) getattrrrrrrrrrrLr)r)rtrs`` rrzTypeChecker.is_assignable_slots 664 (c" ;*S'2 c8 $ 88<< *$6 6 c< ( c9 %M399MM Mrc |g}|D]3}t|ts|j|&t|jj |j }t|ts|j|v|jD]}t|ts|jt|.t|j}t|tr |j}n-t|tr|jjdk(sJ|}|jtt|6|S)zFlatten expression list by expanding those * items that have tuple type. For each regular type item in the tuple type use a TempNode(), for an Unpack item use a corresponding StarExpr(TempNode()). builtins.tuple)rrr-rrurrrrrrrrr"rr)r)rvalues new_rvaluesrvrrunpackedrs rflatten_rvalueszTypeChecker.flatten_rvalues%s   EBb(+""2&!$"3"3":":277"CDCc9-""2&YY E!!Z0&&x{3.qvv6H!(,<=#+#7#7'x: ( 6 6:J JK$,&&x0B'CD E E,rct|ttfrYg}d}d}t|j |j D]1\}} t| t r t|jj| j} |j| rt| tr|6||j| |k7r!|jtj |||dz|k(r&|j#| |}|j| |}|jtj ||jtj$j'| |!|j#| 4d} d} t|D]m\} } t| t st|jj| j} |j| sWt| tsh| | } | } o| ^| \|Z| | z dz}t)|t)||z z }|dkDr3|d| t+|Dcgc]}t-| c}z|| dzdz}|j/|t)||rt1dt|Dt)|}|d|}|t)|k7rt3t ||nd}||dzd}|j5||t)|\}}}t7t9||}|r9t|}|j;||j#|j|f|j=t9|||D]\}}|j?|||yy|jA||||ycc}w)Nrzrrc3HK|]\}}t|ts|ywr'rrrrrs rrzCTypeChecker.check_assignment_to_multiple_lvalues..sS51b*R:RQS"")!rrr{rrrrrrurrtype_is_iterableriterable_item_typerrCONTIGUOUS_ITERABLE_EXPECTEDr-ITERABLE_TYPE_EXPECTEDrrrr check_rvalue_count_in_assignmentrJrsplit_around_starrrset_lineextendrcheck_multi_assignment)r)rorqrrr  iterable_typelast_idxidx_rvalrvaltypsiterable_start iterable_endr iterable_num rvalue_neededr star_indexleft_lvsstar_lv right_lvsleft_rvsstar_rvs right_rvslr_pairsrv_listrrs rrz0TypeChecker.check_assignment_to_multiple_lvaluesDst fy(3 4 )+G)-M#'H"+D,@,@,N"O )$dH-*4+<+<+C+CDII+NOD,,T2z$7Q(4$JaJa &K:!II&6&S&SU\]'/8a<83K 't 4+3040G0Gf0U $ *:*W*WY` a "2"I"I"P"PQU"VX_`NN4(% )&*.N'+L$W- )4dH-*4+<+<+C+CDII+NOD,,T2z$7Q)1-.N'(  )* ,!-+n.s@1z!X.@z/Variadic tuple unpacking requires a star targetFc3HK|]\}}t|ts|ywr'rrs rrz?TypeChecker.check_rvalue_count_in_assignment..s"aB SUW_H`1"arrzTc3<K|]}t|tywr'r)rrts rrz?TypeChecker.check_rvalue_count_in_assignment..sBz&(+Br4) r0rrr$TOO_MANY_TARGETS_FOR_VARIADIC_UNPACKrJrr?wrong_number_values_to_unpack) r)ro rvalue_countr rvalue_unpackleft_star_index left_prefix left_suffix right_prefix right_suffixs rrz,TypeChecker.check_rvalue_count_in_assignments0  $@@@ KWU7|l* *OOQXY""a)G2D"aaO)Kg,81"a'-nQ.?@  {I .#K$5$56B&k26K k7 + Hb(+B NNI66;OQX %%b)5FG  H Y /  2 2g7GIZ  Y /  2 2g7H  X .;3C3C3L3LP^3^ HH 1 1' :  5 5g/@ rc d|_td|j|D}|jj 5}|j D]}|j |||||dt||j|D]J\} } | j|jdj| ttjL dddtd|D} j D]\} } t| tr | j } g}| D]\}}|J|j||ft|\}}|jj#| t%t'|t%t'|t| |j|D]B\}} |j)| \}}}|r|j+|| |1|j-| |Dd|_y#1swY'xYw)aCheck assignment to multiple lvalue targets when rvalue type is a Union[...]. For example: t: Union[Tuple[int, int], Tuple[str, str]] x, y = t reveal_type(x) # Union[int, str] The idea in this case is to process the assignment for every item of the union. Important note: the types are collected in two places, 'union_types' contains inferred types for first assignments, 'assignments' contains the narrowed types for binder. Tc3 K|]}gywr'r)rrs rrz@TypeChecker.check_multi_assignment_from_union..s2]!22]s )rrErFrNc32K|]}t|ywr')r)rcols rrz@TypeChecker.check_multi_assignment_from_union..sM31#6MrF)rRtuplerr@accumulate_type_assignmentsrrrr-r,r2rrrrrrrrrrprr)r)rorqrrr transposedrnrrr union_typesrr clean_itemsr declared_typerdeclared_typesunion_1_2rs rrBz-TypeChecker.check_multi_assignment_from_unions(!%-22]t?S?ST[?\2]-] [[ 4 4 6 [+#)) [++&7 %) ,!T-A-A'-JK[EArHHT__R044RAWAW9XYZ[ [ [ M*MM &,,. KD%$)yy46K', :#m$000""D-#89 :%($5 !E> KK # #%d5k2%d>&:;  $[$*>*>w*GH +IE2#004 BH&&xU;E*  +!&U [ [s BG::Hcg}|D]o}t|ttfr*|j|j |j t|t r |j}|j|q|Sr') rrr{rrrrrr-)r)roresrs rrzTypeChecker.flatten_lvalues5se " B"y(34 4//9:"h'WW JJrN   rc t|j}|j|t|j||rat dt |Dt|}|d|} |t|k7rt t||nd} ||dzd} |s|j||} t|jj|| } t| trt| j} t| tr,| j!}t|dk(rt|d} t| tr|j#||| ||yt| t$ryt| t&sJ| }|j)|j|t|\}}}t+| |D](\}}|j-||j/|||*| rt1|Dcgc]I}t|t2s|j/||n$t|j/|j4|Kc}}|j7||j-| j8||t+| |D](\}}|j-||j/|||*y|r(|D]!}t|t:rYt|j<t>r?|j<j4)t%t@jB|j<_mt|ts~t|j8t:st|j8j<t>s|j8j<j4|jEdt%t@jBg|j8j<_$yycc}w)N)r:c3HK|]\}}t|ts|ywr'rrs rrz@TypeChecker.check_multi_assignment_from_tuple..NsOuq"jX6NOrrzrr)#rrrrrJrrrlvalue_type_for_inferencerrurrrr"rrMrBrrrrrrr{rrrrrrrrrdr)r)rorqrrrFrr:r(r)r*r+rureinferred_rvalue_typerM left_rv_types star_rv_typesright_rv_typesrrE list_exprs rrAz-TypeChecker.check_multi_assignment_from_tuple@s^,K,=,=>  0 0 S**+WM 1 O ' 2OQTU\Q]J{ +H=G3w<=Wd8WZ%89]aG Q 01I#"<*a/1@PQAR1S.4i@::)?J[4g>!"8)DDD4 ;?;Q;Q!!:s7|< 8M=. #8]; _ G%%b$..'*JL]^ _$(5  $$.gz#B!NN7G.s K51b*R2JQ Krrzct||D]O\}}j|\}}}|r"t|tsj |?j |Qyr')rrprrr-) rrv_typesrrEsub_lvalue_type index_exprrr)type_parameterss rappend_types_for_inferencezITypeChecker.lvalue_type_for_inference..append_types_for_inferences^"31 4 G8<8I8I"8M5X":o{+S#**?;$**73 4rr )rlist[Expression]rbrFr8r9)rJrrrrrrrprrrrrr)r)rorr(r)r*r+r[r\r]rfrcrdrres` @rrYz%TypeChecker.lvalue_type_for_inferences KIg. KSQX\ ;J'9Cs7|9S$x!45Y]JN,- 7;7M7M   z3w<8 4 }n') 4 #8]; 484E4Egll4S 1OZz/;'O&&'83};M'MN &&}5"9n=$//:J*KLLrc`||z dz }|dk7r| n t|}|d|}|||}||d}|||fS)aSplits a list of items in three to match another list of length 'length' that contains a starred expression at 'star_index' in the following way: star_index = 2, length = 5 (i.e., [a,b,*,c,d]), items = [1,2,3,4,5,6,7] returns in: ([1,2], [3,4,5], [6,7]) rzrN)r) r)rr(lengthnr_right_of_star right_indexrPstarrQs rrzTypeChecker.split_around_stars["J.2+;q+@''c%j [j!Z ,kl#T5  rc t|}t|tr|jr |j}t ||j dttjgS)Nrw) rrrrRrrrrrrr)rs rrzTypeChecker.type_is_iterablesXt$ dL )d.>.>.@==D $))*;giF\F\>]=^_  rct|}|j|rt|ttt t fr|j||}|D]v}t|trA|jd|g}|j|j|j|||T|j||j|||xy|jj||y)Nr)rrrrrrrrrrrrrr?type_not_iterable)r)rorrrrr items_types rrDz0TypeChecker.check_multi_assignment_from_iterables&k2   -* (L(JG3 // WEI b(+!%!8!89+!VJ)) G!DFW))DNN9g>@Q  HH & &{G >  *!L  +++JJ6SWY_`K OOFK 0  )++< KA++226:KL(22s 'I!ct|tr8|jry|j}t|tr|j duSyt|t r |jSyr)rris_inferred_defrrrr~)r)ryrs rrszTypeChecker.is_definition#s\ a "   66D$$yyD((: &$$ $rc t|tr|jj||yt ||j |j t|tsu|jsi|jdk7rY|j|||sE|jj|||j j|j|||yyyt|tr|j|jr|j|jvrst!|j|j|sP|jj|||j jt#t$j&|_yt+|}|j-||||j j.r|j0j3|||yy)z>Infer the type of initialized variables from initializer type.)ris_lvalue_memberrN)rrr?deleted_as_rvaluerrPrr~rRrrneed_annotation_for_varpython_version!set_inference_error_fallback_typerQrtrrrrdrrrrr@r)r)rrt init_typers rrzTypeChecker.infer_variable_type3so i - HH & &y' :& $ !+FJ!?  )) yyC(?(?fi(X00w @[@[\66tVYO)Y vz *--9$"?"?? !>!>v~~!NPYZ HH , ,T7DLLt|}t|tr4t|ts|jj st d|}nt|tr |jj}t|t}|rP|dk(s|dk(s |dk(s|dk(r.ps$q8_"=>rcollections.defaultdictrrzFrT)rrrr~rPrrrrrrrLrrer'is_valid_defaultdict_partial_value_typer+rrIr ) r)rrtr partial_typeris_refarg0arg1s rrzTypeChecker.infer_partial_type]si#I. i * vz *$,,2U2U'tT2L  8 , ~~..H0F/>1?2#<<-inn= +9>>4@ H(AA&y~~a'89&y~~a'898_5BB4H%d+D%dH555#.y~~tT#JL  tV\:+12""4(rcNt|tsyt|jdk(ryt|jdk(rct |jd}|j j rt|tttf}nt|ttf}|ryy)aCheck if t can be used as the basis for a partial defaultdict value type. Examples: * t is 'int' --> True * t is 'list[Never]' --> True * t is 'dict[...]' --> False (only generic types with a single type argument supported) FrTrz) rrrrerrPold_type_inferencerrr)r)rralloweds rrz3TypeChecker.is_valid_defaultdict_partial_value_types!X& qvv;!  qvv;! !!&&),C||..$S?Hk*RS$S?H*EFrcF|r|js||_d|_d|_||jvr;|j j Dchc]}|jc}|j|<t|tr1|j%|j||j|j<|j||t|}d}t|tr |j}n)t|t r|j"dj}|rt%|rd|_yt)|rd|_yt-|rRd|_t|t r:d|_t|t0sJ||j2j4|_yyyyyycc}w)zStore inferred variable type. Store the type to both the variable node and the expression node that refers to the variable (lvalue). If var is None, do nothing. TNr)r_rris_readyrUr@rrrr~rQrtrrrrrris_node_staticis_staticmethodis_classmethod_noder<rrrgrr)r)rrtrrp_typers rrzTypeChecker.set_inferred_typese t11CH"COCL$...CG;;CUCU,V%UXX,V$$S)&*-$2O2O2[>>-DHD11&..A OOFD )$T*FJ&,/#.. FJ/$\\!_77 !*-*.C'(4)-C& ,&*CO!&*5370)*i@L*L@*4..*D*D 6- )23 -Ws FcL|j|}|j|||y)aStore best known type for variable if type inference failed. If a program ignores error on type inference error, the variable should get some inferred type so that it can used later on in the program. Example: x = [] # type: ignore x.append(1) # Should be ok! We implement this here by giving x a valid type (replacing inferred Never with Any). N)inference_error_fallback_typer)r)rrtrrs rrz-TypeChecker.set_inference_error_fallback_types&55d; sFH5rcJ|jt}t|Sr')rSetNothingToAnyr,)r)rrs rrz)TypeChecker.inference_error_fallback_types ;;01h''rct|ttttt fryt|t rt|jt rt|jjtrj|jjj}t|tr |j St|trtd|jD Sy)aReturns True for expressions for which inferred type should not depend on context. Note that this function can still return False for some expressions where inferred type does not depend on context. It only exists for performance optimizations. Tc34K|]}|jywr'rDrs rrz,TypeChecker.simple_rvalue..s"Hd4>>"HF)rryrrarmrrbr"rr[rrrDrr0r)r)rqrs r simple_rvaluezTypeChecker.simple_rvalues fwIwO P fh '&--1j ""$97mm((--c<0"}},,Z0""Hcii"HHHHrr expression)rrtrc |jr+t|trttj |fS|duxrtt |t } | t|r|} nd} |jj|| | } || t| |js|jj||| } t| |jsL| J|jj| ||jj| jt} t|t r|  | j"| j$st'| } t)| j"| s|j+|st-| j"| g}t)|| j"st| j"t.sz|j0j3| j4|j7| |||j8j;|| t=|}|||j8j>|<tt |t@rtC| s|jE|s|jjG5}|jH5}|jj|d| }ddddddjKsNtt ts5t||jrtM|| r|} |jOt| tPr|jjS| |t|tPr |jjU||| |fS|r|jW| ||||d|d|| |fS#1swYxYw#1swYxYw)N)rxr)rz has type)r),r`rrjrrrris_typeddict_type_contextrurrrPr?r}r~rrrrr-rrefers_to_different_scoperrrKr-rrr@putr<rrrrrrdhas_new_errorsr store_typesrr|deleted_as_lvaluer)r)rurqrr?rrrrtrrrxr new_inferredlit local_errorstype_mapalt_rvalue_types rrz#TypeChecker.check_simple_assignmentsi <&>7G'?'O %335&'GQ. M)/;G"1K$$X.+{3**;@+{3**;@ + +"""m9-"m9-#  + +9s$ N6N*<N6*N3 /N66N?c|jtk(ry|jjy|jtk(r6|j j dd|jj k7ryy)NFT.r)rrWrErrSr rpartitionrZr)rs rrz%TypeChecker.refers_to_different_scope]s^ 99  ZZ * * , 8 YY$ 4==#;#;C#@#CtyyGYGY#Yrct|}t|tr|jst|tr|j |||\}}||dfS|j jd5|jj|d}ddd|j |||\}}t|r|n|}||t||fS#1swY>xYw)a:Type member assignment. This defers to check_simple_assignment, unless the member expression is a descriptor, in which case this checks descriptor semantics as well. Return the inferred rvalue_type, inferred lvalue_type, and whether to use the binder for this assignment. TrF)rN) rrrrRrrr?rrurur) r)rtrset_lvalue_typerqrrrget_lvalue_types rrz#TypeChecker.check_member_assignmentis ( 6 }l 3 8Q8Q8SXb 8Y "99/6SZ[NK5 5 XX # #d # ; "//NN%OO 55ovwW Q%/ _%MkSb OZ-YYY  s 3CCc|j||t|jj|j}|jj d||}||_|jjd|||j|gtjtjg|\}}t|}t|tr(|js|jjyyy)zxType check indexed assignment base[index] = rvalue. The lvalue argument is the base[index] expression. __setitem__N).try_infer_partial_type_from_indexed_assignmentrrurrrQrUcheck_method_callrrrNrr ambiguousr@r)r)rtrqrbasetyperUres_typers rrz$TypeChecker.check_indexed_assignments ;;FFK"4#4#4#;#;FKK#HI''FF 8V )''99    \\6 " ]]EMM *   !#8, h 09K9K KK # # %:L 0rc||_|jxjdz c_||=|jjr:t |j }||_|jj|||yy)z8Replace the partial type of var with a non-partial type.rzN) rr@versionrPrrrrr)r)rryrIrs rreplace_partial_typez TypeChecker.replace_partial_typesg q  #  << . ."AAF KK # #Ax : /rcd}t|jtr;t|jjtr|jj}n?t|jt r%|j j|j}t|trDt|jtr(|jj}|y|j|}|y|j}|dk(s |dk(s|dk(r|j j|j}|j j|}t||jrt||jrq|j sd|dk(r6|jj" t%||jj"r(|j'|||g} |j)|| |yyyyyyyy)Nrrr)rrrrrr~rurrrrrrrrrPr_ value_typerrr) r)rtrqrr?rItypenamekey_typerrys rrz:TypeChecker.try_infer_partial_type_from_indexed_assignments fkk7 + 6;;;K;KS0Q++""C  Z 0##88EC c3 #((K0HHMM $ $ 7 7 <  ($--/#<<#<< $0077 EH!%!2!2!9!9&!AJ.xF2:t||L $ : :$(AA # 3 3 ?$1*chh>Q>Q$R$(#:#:8hPZE[#\11#xO %S !;MG =1 rct|}t|trD|jjdk(rdt fS|jj ddtfSy)zSome types require usage in all cases. The classic example is an unused coroutine. In the case that it does require usage, returns a note to attach to the error message. ztyping.CoroutinezAre you missing an await? __await__N)rrrrrr0rr/)r)r proper_types rtype_requires_usagezTypeChecker.type_requires_usagesa&c* k8 ,((,>>35EFF##K0<35EFFrc8|jj|jdd}|j|}|r_|\}}|j t j jt||j|||j|||yy)NTrr) rurrrrrTYPE_MUST_BE_USEDrrFrPr)r)ry expr_typeerror_note_and_code error_noters rvisit_expression_stmtz!TypeChecker.visit_expression_stmts%%,,QVVt^b,c "66yA 2 J II 2299+iQUQ]Q]:^_   IIj!$I / rcZ|j||jjy)zType check a return statement.N)check_return_stmtr@rr)rys rvisit_return_stmtzTypeChecker.visit_return_stmts  q! !rc |jjddd5}|j5}t|jj |||}ddddddj s|jS|j}}|jjddd5}|j5}t|jj |d|} dddddd|j st |r|j|| S|jj||j|S#1swYxYw#1swY xYw#1swYxYw#1swYxYw)z@Infer type of an expression with fallback to empty type context.T)rrsave_filtered_errorsrN) r?rrdrrurrrfiltered_errorsr add_errors) r)rtype_ctxallow_none_func_callr?rroriginal_messagesoriginal_type_mapalt_typs rinfer_context_dependentz#TypeChecker.infer_context_dependentsXX # #$T$   $$ %%%,,h:N-  !!#   X &J //1$ XX # #$T$   $$ )%%,,T4K_,`  !!# 7H(E   X &N -. *+ 7    &    sF E&(EE&7 E?(E3,E?E# E&&E03E< 8E??Fc ^|jj}||jr*|j|jd|j }n:|j r|j |jd}n|jd}t|}t|t}t|tr/|s-|js!|jtj|y|jrGt|t }t|t"}|xs|xs|}t|jt$t&t(t*t,t.fr|j1|j||}n1t|j2j5|j||}t|t6r2|j8j:dk(rt#t<j>}|j@r!|jtjB|yt|t"r|jDjFr|jHstKt#t<j>|sn|jLtNvrtQ|jsGt|t6r|j8j:dk(s|s|jRjU||y|r4|st|t ry|jtjV|y|jYd|d||j|tjZy|jr|j st|t"ryt|t t"fry|j]r!|jtj^|yyy)Nrrbuiltins._NotImplementedTyper gotr)rrrrr outer_contextr?)0rEcurrent_functionrrnrGrVrlrrrzrrrrNO_RETURN_EXPECTEDrrrrbr{rrirrrrurrrrrrrRETURN_IN_ASYNC_GENERATORrPwarn_return_anyr_rrris_literal_not_implementedr?incorrectly_returning_anyNO_RETURN_VALUE_EXPECTEDrrr|RETURN_VALUE_EXPECTED) r)ryrrf is_lambdadeclared_none_returndeclared_any_returnrrs rrzTypeChecker.check_return_stmt$szz**,    "<<%%b)4+<+< """<)>II.AA1Evv'1+x'H$&0g&F#(1'_4H'_L_$affx9hPWY_&`a 66qvv{L`aC)))00FFKCW1CsH-))-KK!)"8"89C**II.HH!Lc7+ 44 $ : : 1'):P:P2QS^ _ II)== :166 B'{H= + 0 0 9 9=N N )::;J(!JsH$=II.GGK&&&+ #(2"- !&',KK'%% --";8kHg+>?++-II.DDaH.S rc|jjddd5t|j|jD]\}}t |j j|}t|tr|jj|||j|\}}|jjdd5|j|d|j|ddd|j|d|jjdd5|jr|j|jddddddy#1swYtxYw#1swYxYw#1swYyxYw) zType check an if statement.FTrrr fall_throughrrrfrom_assignmentN)r@rrrrrrurrrr?r|rrr)r)ryr3r=rif_maprs r visit_if_stmtzTypeChecker.visit_if_stmtsP[[ & &\] & ^ -AFFAFF+ D1#D$5$5$<$-B II&77 ;"77?( 55     1 1!%%5 2  8$rc|jr|j|j||jr|j|j|d|jj y)zType check a raise statement.T)optionalN)rtype_check_raise from_exprr@rrs rvisit_raise_stmtzTypeChecker.visit_raise_stmtsM 66  ! !!&&! , ;;  ! !!++q4 ! @ !rct|jj|}t|tr|j j ||y|jd}|t|g}|r|jt|j|tj||tjt|t r|jj#|gg|t|t$rJ|j&j(dk(r0|j+tjj-d|yyy)Nbuiltins.BaseExceptionrz%; did you mean "NotImplementedError"?)rrurrrr?r|rrr-rrr make_unionrINVALID_EXCEPTIONrrrrrrr)r)r3ryrrr3expected_type_itemss rrzTypeChecker.type_check_raisesd//66q9: c; ' HH & &sA . ??#;<'();<  & &xz 2  %%&9:A?O?a?a  c< (    ( (b"a 8 c8 $):):>\)\ II 22FF;  *] $rcd}|jjdd5|j|t|j|jrNt }t |jj|5|j|jdddddd|jr~|J|jjsDt |jj|5|j|jddd|jj|yy#1swYxYw#1swYxYw#1swY>xYw)zType check a try statement.NFrr) try_frame) r@rvisit_try_without_finallyr! finally_bodyr5r6r?r>rrr)r)ryrs rvisit_try_stmtzTypeChecker.visit_try_stmts [[ & &A & F 0  * *1Q^^8L * M~~68 *488??KH0KK/0 0 >>* **;;--/*488??KH0KK/0 HH / / >sAII NA"#&&)C"7; 3 $ 5 5c4>>!S;Q R AJJqM2ffQi&)XXF)#((C8+6f+E08 #'<<#F#F$(KK$;$;C8$T#'<<#F#F $ 3 3C 81999  9<{{ AKK(C! )! )((99  9 9! )! )sTI(II9AID>I > I /I(I II II% !I((I1cN|jj|}g}|j||}t|D]L}t |t r|j |&t |trh|jd}|js3|jtj||j|cSt|j}nPt |t r |j"}n3|jtj||j|cSt%||j'ds3|jtj||j|cS|j |O|rg} |D]w}t)||j'drI|jtj*|| j t t,j.g| j |y|j1| St3|S)z,Type check an exception handler test clause.rrbuiltins.BaseExceptionGroup)rurget_types_from_except_handlerrrrr-rrrRrrINVALID_EXCEPTION_TYPEdefault_exception_typer,rrrrrrINVALID_EXCEPTION_GROUPrrdwrap_exception_groupr) r)rrr all_types test_typesttyperr3 new_all_typess rrz%TypeChecker.check_except_handler_testSs&&q) " 77Q? %j1 'E%)  '%.{{1~'')II.EEqI66w??)$--8E8, :: *AA1E227;;h8P(QR *AA1E227;;   X &+ '. (*M  .$S$//:W*XYII.FFJ!((1E1E)FG!((-  . ,,]; ;$Y//rcbttj}|r|jd|gS|S)z:Exception type to return in case of a previous type error.builtins.ExceptionGroup)rrrdr)r)rrs rrz"TypeChecker.default_exception_type|s09//0 **+DxjQ Qrc~t|}t||jdrd}nd}|j||gS)zDTransform except* variable type into an appropriate exception group.zbuiltins.Exceptionr$r)rrrr)r)rrrs rrz TypeChecker.wrap_exception_groups?#E* c4??+?@ A,D0D&&tcU33rc(t|}t|tr |jSt|tr7|j Dcgc]}|j ||D]}|c}}St|dr|jdgS|gScc}}w)z?Helper for check_except_handler_test to retrieve handler types.r r) rrrrrrMrrre)r)rrr union_typs rrz)TypeChecker.get_types_from_except_handlersc" c9 %99  Y ' ..0!%!C!CD!!L  s$4 5HHQK= 5Ls Bcjrjj\}njj\}_|_j jjfdy)zType check a for statement.cXjjjduSr')analyze_index_variablesr index_type)rryr)srr4z,TypeChecker.visit_for_stmt..s($">">ALLD$8!#r)rN) is_async analyze_async_iterable_item_typeranalyze_iterable_item_typeinferred_item_typeinferred_iterator_typerrr)r)ry iterator_typers`` @rvisit_for_stmtzTypeChecker.visit_for_stmtsr ::'+'L'LQVV'T $M9'+'F'Fqvv'N $M9(#0   FF KK  rc|j}|j|}|jd|gg|d}|jd|gg|d}|j||tj }||fS)zNAnalyse async iterable expression and return iterator and iterator item types. __aiter__r __anext__)rurcheck_method_call_by_namecheck_awaitable_exprrINCOMPATIBLE_TYPES_IN_ASYNC_FOR)r)rechkiterableiterator awaitablers rr-z,TypeChecker.analyze_async_iterable_item_types  ;;t$11+xRQUVWXY22;"bRVWXYZ -- t-MM ""rc|j|jj||\}}|j|}|r||fS||fS)zHAnalyse iterable expression and return iterator and iterator item types.r)-analyze_iterable_item_type_without_expressionruranalyze_range_native_int_type)r)rr;r:int_types rr.z&TypeChecker.analyze_iterable_item_types^!OO    $ $T *DP (55d; X% %!!rc2|j}t|}|jd|gg|d}t|tr=|j j jdk(r|t|jdfS|jd|gg|d}||fS)zBAnalyse iterable type and return iterator and iterator item types.__iter__rr __next__) rurr6rrpartial_fallbackrrrre)r)rrr9r:r;s rr>z9TypeChecker.analyze_iterable_item_type_without_expressions  "4(11*hBPWXYZ[ x +))..77;KK^H5::1== =55j(BPRT[\]^_HX% %rct|trt|jtr|jjdk(rdt |j cxkrdkrnytd|jDrpd}d}|j D]W}t|j|}t|ts.|jjtvsK||}P||k7sVd}Y|r|r|Sy)zTry to infer native int item type from arguments to range(...). For example, return i64 if the expression is "range(0, i64(n))". Return None if unsuccessful. zbuiltins.rangerzrc3.K|] }|tk(ywr')rN)rrs rrz.s?DGO?sNTF)rrbr"rrrrerLrrrrrr)r)r native_intrrargts rr?z)TypeChecker.analyze_range_native_int_types tX &4;;0 $$(88S^(q(???&*JByy #&t'7'7'<=dH-$))2D2DH^2^!)%) +"  #j!!rct|}t|trMg}|jD]'}|j |}|s|j |)tj |St|trk|jjdrP|jdj}t||}t|jdk(sJ|jdSt|tr|j t|Sy)zzCheck if a type is a nominal container of a union of such. Return the corresponding container item type. ztyping.ContainerrzrN)rrrranalyze_container_item_typer-rrrrrr=rrerr)r)rrrc_typersuper_instances rrJz'TypeChecker.analyze_container_item_types c" c9 % "E  )99$?LL( )''. . c8 $):):;M)N(:;@@I6sIFN~**+q0 00!&&q) ) c9 %33N34GH HrcJ|j||j|||y)z>Type check or infer for loop or list comprehension index vars.N)rr)r)rrrrs rr*z#TypeChecker.analyze_index_variabless" eT^^Iw%GIZ[rct|jtr|j}t|jd}|j |_|j |_t||jgtjgdg}|j |_|j |_|jj|dy|jj|jt|jD]M}t|ts|jj!|t#|j$t'|Oy)N __delitem__Trr)rrrxr~rrr{rbrrrNrurflattenrr@rrrr)r)ryr3mrelts rvisit_del_stmtzTypeChecker.visit_del_stmt s affi (A166=1AVVAFxxAHQWWI ?AVVAFxxAH    $ $Q$ $ ? FFMM$++ ,qvv c8,KK++[9?3;O rc|jD]]}t|ts|jdk(s$t t j |j_d|j_ y|j|y)Nztyping.no_type_checkT) rrrrrrrrrrr)r)r3rs rrzTypeChecker.visit_decorators` A!W%::!77!()?)?!@AEEJ%)AEEN   ""1%rc ~ |jr`|jj|j5|j |j|jj |ddd|j |j}d}t|r|jddn |jD]V}t|drt|tr#|s |jtj|Dd}|jj|}|j!||}d} t#|t$r|j&xsd} d} | lt#|t(r\|j+|j,rA|j/|j,} |jj1| |j } |j3|j|||jj5||gt6j8g|| | \}} Y|r|j;||j|j=||jt?||j}t#|t@r||_!||jD_#d|jD_$|jjJrtt#|t@rStM|jND cgc]} | jQs| c} dkDr|jRjd||jU||s|ry|jjVr|jXs|j[|} |jj\r^| s\| Z|jjVj^s:|jRja|jj |j|jc|j| |jjVrm|jj d vrU|jFrIt#te|jFtfthfs |jtjj||jjlr.t#|tfr|jo|j|yyy#1swYJxYwcc} w) NrFrzzabc.abstractmethodTr)rrCzToo many arguments for propertyr)8rerDrrrrrrrrrrrrrurrrrrr~rrrmethod_fullnamecheck_for_untyped_decoratorrrrNcheck_untyped_after_decoratorrrrrrrrrrr is_requiredr?$check_incompatible_property_overriderrurr r r r rrrBAD_CONSTRUCTOR_TYPErwrx)r)r3rrr non_trivial_decoratorrrrrrCt2krs rrz!TypeChecker.visit_decorator_inner(s  & &++AFF3 X$$QVV!&&++;$W X &&qvv. %o!,,qr*1<<P A!!%9:!!^4"II.JJAN$( !##**1-C>>#q>1DH!W%::-(,KJq*$=$--PQPVPVBW"..qvv6 ,,<<[!&&Q  , ,QVVS! <''22dVemm_axU`3GC- 2 !  . .sAFF ; **37QVV, c< (CN  66  #|,3==DaAMMODEIHHMM"CQG  5 5a 8 /  66;;q}}(,(B(B1(E %++1-9 33..qvv{{AFFC  2 2166;T U 66;;166;;*AAvvj)@> & &s + HH / /T : ,rc|j}|j|}|jd|gg|d}|j||tj }|r#|j ||j||||jttj|}|jd||gdztjgdz|\}} |j||tjS)N __aenter__r __aexit__r)rurr6r7r'INCOMPATIBLE_TYPES_IN_ASYNC_WITH_AENTERrrrrrrrN&INCOMPATIBLE_TYPES_IN_ASYNC_WITH_AEXIT r)rrrr9r'objrrVrs rrkz!TypeChecker.check_async_with_items  kk$,,\3BMaP'' 'OO    ! !&$..d*CEV WnnWY%;%;> +1a'+'8'8'P'P!<($ $33::1>RS [[..1.M7''':' (9(9:O,**4*G,.0M)<+<+T>T1- X '=K+G=H=WK(9:# (A:B=:QH%67&*&D&D[&Q #'#A#A(#K55l6K6K^\**;*N&-8->->-@" c $ 2 2$($H$Hs$S49!3!"" **<+@+@RW*X}![[66TU6V+!01B1B1I1I!1L!MB)"k: $ : :2q A8<8R8RST8U5I~':8^'TH *!Y7./ii.A166 #-k8#D5>4I %U/7,448N)UD0:40J48MM[EYEY4Y08FNtnH],C )U %U!..y%.P KKN3++6 Ao7'p""8U"C"*}> +@* 6 6 89HCHH??QGH **E*J  oX X _'JL++97'7'B  oX X swA)S .#RS R *BS ER1DR% 5R1A9S R= S  S %R. *R11R: 6S =S S  Sc|jj|r|S|j |jS|jd}t |}t |}||_||_|S)zEConstruct a fake NameExpr for inference if a match clause is complex.match)r@can_put_directly subject_dummynew_unique_dummy_namerrr)r)ryrrrrs rrz+TypeChecker._make_named_statement_for_match>sf ;; ' ' 0N __ (?? " --g6DD A$TNM!"M +AO rcVi}t|}t|trt|tr{t |j t |j k(sJt |j |j D]+\}}|||<|j|j||-|Sr') rrrrrrrupdater)r)rrsub_patterns_maptyp_ item_expritem_typs rrz+TypeChecker._get_recursive_sub_patterns_mapPs46s# dI &:dI+Ftzz?c$**o5 55'*4::tzz'B c# 8.6 + ''(L(LYX`(ab c rc tt}|D]T}||jD]<\}}t|ts|j }|J||j ||f>Vi}|jD] \}} d} g} | D]\}}| j ||j|\} } } | /d} t|j tr=|j jr'|jj|jd||j|| |tjdds| ||<| rt!j"| }| d\}} t|tsJ|||<|j%|||||S)NFTzpattern captures typezvariable has type)r?rrr)rrrrrrr-rprrr?rrrrINCOMPATIBLE_TYPES_IN_CAPTURErrr)r)r all_capturestmrrrrrralready_existsr previous_typerryfirst_occurrences rrz/TypeChecker.infer_variable_types_from_type_maps^s GRRVFW  ?B~!#?ID#!$1#yy#///$T*114+> ? ?24)//1 \MC"N "E% < c S!&*&7&7&=# q! ,%)N!$))S1dii6H6H55diiM))%,JJ&=(; */<s+! <$"$//6&.qk# !!#s+++&.s#((.>JZ[9 \:rc|rVt|jD]9\}}t|ts|j}||vst |||r7||=;yyr')rrrrrr)r)rrrrrs rrz$TypeChecker.remove_capture_conflictss\ !(.."23 + cdH-99D>1CX\I]9^$TN  + rc|jr%|j|jj|jj 5|j j |jdddy#1swYyxYwr') alias_noder alias_tvarsr?rrurrr)os rvisit_type_alias_stmtz!TypeChecker.visit_type_alias_stmts^ <<  ' ' (@(@ A XX # # % .    $ $QWW - . . .s &A;;Bct|tg}|dz|z|_tt ||}||_||_t||j|_ ||fS)Nr) rcr_rrrrrrLcalculate_metaclass_typer)r)curr_module_fullnameclass_gen_nameclass_short_namercdefrs rmake_fake_typeinfozTypeChecker.make_fake_typeinfosh(%)4,s2^C  t-AB  d";;=Tzrcjjd}t|tsJ|\}}t ||dr|St ||dr|Sdd} dfd }||}t t |jddd} t|s|j| d fy g} |D]D} | jjs| j| d | jjd fF| r|j| y |||j\} } jj5}j!| d d d j#rY||d d d }|||j\} } jj5}j!| d d d d| _|j#r|j| dfy t)t*| |j,| <t/| g|dj0xs|dj0S#1swYxYw#1swYxYw#t&$r|j| dfYy wxYw)aTry creating an ad-hoc intersection of the given instances. Note that this function does *not* try and create a full-fledged intersection type. Instead, it returns an instance of a new ad-hoc subclass of the given instances. This is mainly useful when you need a way of representing some theoretical subclass of the instances the user may be trying to use the generated intersection can serve as a placeholder. This function will create a fresh subclass the first time you call it. So this means calling `self.intersect_intersection([inst_1, inst_2], ctx)` twice will return the same subclass of inst_1 and inst_2. Returns None if creating the subclass is impossible (e.g. due to MRO errors or incompatible signatures). If we do successfully create a subclass, its TypeInfo will automatically be added to the global scope. rFignore_promotionscg}|D]J}|jjr|jj}n|g}|D]}|j|L|Sr')ris_intersectionrr-) instances_ base_classes_rr expanded_insts r_get_base_classesz:TypeChecker.intersect_instances.._get_base_classess\M" 899,,#yyH $vH%-8M!((78  8! rc<|Dcgc]}t||d}}dt|dd}|jj|x}*t |j t sJ|j |fS j|j|||\}}||fScc}w)Nr)rP verbosityz ) rGrJr\rrrrrr) r curr_module_rPrKr\rsymbolrinfo_r)s r!_make_fake_typeinfo_and_full_namezJTypeChecker.intersect_instances.._make_fake_typeinfo_and_full_namesQ^^1%aAF^E^":eU#;"D&,,0066C!&++x888{{D((11,2G2GtUbcKD%$;  _sBT)rPbarerzhave distinct disjoint basesNrz " is finalrz/would have inconsistent method resolution orderz)would have incompatible method signaturesrz extra_attrs)rtuple[Instance, Instance]r8list[Instance])rrrrrPrr8ztuple[TypeInfo, str])rErrrrrJrHrPrr-rrrrr?rrrrrKrrSr\rr)r) instancesr> curr_modulerPrQrr base_classespretty_names_list new_errorsrr full_namers` rintersect_instanceszTypeChecker.intersect_instancess~*jj&&q) +x000 e T5E BK UDE BL ! ) 9A LS  ! )3 ' "L$,,T RTY -\: MM,.LM N   WDyy!!!!#4$))..9I6T"UV W  MM* % ?k4<<OD)'') 6\//5 6**,04R4A "C +t||#iXX++-:33D9:#'D   & & ( MM,.YZ ['6tT'B )$bil.F.F.b)TU,JbJbcc' 6 6::  MM,._` a sC 1I <H3AI %H?7I 3H<8I ?II I*)I*c,|jjd}t|tsJt d|j j d|j}t||j}|j|j|||g\}}tdgtg|}|jdz|_||_t!t"||jd<t!t$||j|<t'|g|j(S)zCreates a fake type that represents the intersection of an Instance and a CallableType. It operates by creating a bare-minimum dummy TypeInfo that subclasses type and adds a __call__ method matching callable_type. rz>rc8|jd}tttjttjgt j t jgddgttj|d}|j||S)zIProduce a new type that makes type Callable with a generic callable type.rNT)rris_ellipsis_args) rrrrexplicitrrOrr)r)rrrs rmake_fake_callablezTypeChecker.make_fake_callable5s{??#67$ Y'' (')2D2D*E F ^^U__ - 4LY//0!  //]CCrct|}t|ttfr|ggfSt|tr|g|gfSt|t rg|gfSt|t rQg}g}|jD]:}|j|d\}}|j||j|<||fSt|tr)|jt||\}}|r|gng}||fS|}t|tr t|}t|tr|jj!d} | r5| jr)|j| jd\}}|r|s|ggfS|sf|j#|} t|tr?t|j| | j_| jj$g|gfS| g|gfS|rg|gfS|g|gfS)a(Partitions a type into callable subtypes and uncallable subtypes. Thus, given: `callables, uncallables = partition_by_callable(type)` If we assert `callable(type)` then `type` has type Union[*callables], and If we assert `not callable(type)` then `type` has type Union[*uncallables] If unsound_partition is set, assume that anything that is not clearly callable is in fact not callable. Otherwise we generate a new subtype that *is* callable. Guaranteed to not return [], []. Tunsound_partitionrF)rrrrrrrrpartition_by_callablerrrrrrr get_methodrr) r)rr callables uncallablesr subcallablessubuncallablesityprnfakes rrz!TypeChecker.partition_by_callableDs"c" cL(3 45"9  c7 #53%<  c8 $u9  c9 %IK99 304/I/It0J0, n  ."">2 3k) ) c; '&*%?%?',.?& "I{$/3%BKk) ) c9 %!#&D dH %YY))*5F&++)-)C)CKK5*D*& ;[ 5"9$$..t4c9-+4SYY+EDII( II001C588vu}$ u9 53%< rc|siifStt|triifS|j|d\}}|r<|r:|r|t j |ind}|r|t j |ind}||fS|ridfSdifS)a8Takes in an expression and the current type of the expression. Returns a 2-tuple: The first element is a map from the expression to the restricted type if it were callable. The second element is a map from the expression to the type it would hold if it weren't callable. FrN)rrrrrr)r)r current_typerr callable_mapuncallable_maps rconditional_callable_type_mapz)TypeChecker.conditional_callable_type_mapsr6M ol3W =r6M!%!;!;L\a!;!b ; FOD)"6"6y"ABUYLJUdI$8$8$EF[_N/ / t8ORxrcXg}g}t|}t|trt|j }n|g}t |}|D]}|rt|t rv|D]p}||jvr|j|#||jvs |js#|j||j|`|j|r|j||j||rtj|nd|rtj|fSdfS)z Narrows the type of `iterable_type` based on the type of `item_type`. For now, we only support narrowing unions of TypedDicts based on left operand being literal string(s). N) rrrrrMrr required_keysr-rrr) r)rrif_types else_typespossible_iterable_typesitem_str_literalspossible_iterable_typers rconditional_types_for_iterablez*TypeChecker.conditional_types_for_iterables/ "!# ' 6 mY /&6}7S7S7U&V #'4o #>yI&= : " Z0F %V, BC4BBB (>?5;;;CYCbCb (>?"))*@A"))*@A B 67!!"89 :"/7I  *D0:I  ,  @D  rct|txrlt|jxrU|jj d xr7|jj d xr|jj dk7xsKt|t xs9t|txr'tfdt|jDS)N__bool____len__r c3@K|]}j|ywr')_is_truthy_typerrr)s rrz.TypeChecker._is_truthy_type..sSA,,Q/S) rrr!rrJrrrrLrrr)rs` rr zTypeChecker._is_truthy_types1h'9L922:>>9229==9FFOO'88 !\* 1i(TS9I!''9RSS rc >tjsytjsydfd }dfd }t t r5j tjj|yt tr5j tjj|yt trjjdk(rujdddg\}}j tj j|t#t|j$j&yj tj(j|y)z Check if a type can have a truthy value. Used in checks like:: if x: # <--- not x # <--- Nctj}ttrdjd|Stt rj rdj d|Sttrtjtrdjjd|Stjt r2jj rdjj d|Sd|Sd|S)NzMember "z " has type rz " returns z Call returns zExpression has type ) rFrPrr~rrrrbr")rrr)rs rformat_expr_typez;TypeChecker.check_for_truthy_type..format_expr_typesa.C$ +!$))Ku==D'*t}}4==/SE::D(+dkk:6t{{//0 3%@@ W5$++:N:Nt{{334JseDD&se,,-cU33rc|tttfrdjdSt j S)Nr)rrr~rrFrP)rr)rsr get_expr_namez8TypeChecker.check_for_truthy_type..get_expr_name s8$: 67499+Q''#1dll33rrwtyping Collection)r8rN)rrrr rrrrFUNCTION_ALWAYS_TRUErrTYPE_ALWAYS_TRUE_UNIONTYPErrrrITERABLE_ALWAYS_TRUErFrerPTYPE_ALWAYS_TRUE)r)rrrrrrs``` rcheck_for_truthy_typez!TypeChecker.check_for_truthy_types3$$  A ##A&  4 4 a & II&;;BB=?SUY Z 9 % II&AAHHIYI[\^b c 8 $>?O?QRTX Yrc|dd}g}d}d}|D]}|j|}t|tr'||r|j|jdI|j |} | ]|iifcSt|t r0t|jtr|jj}| }|siifSg} g} |D]Y}|j|j|||\} } t|| | \}}| j|| j|[dd}|| }|r || }||fSi}||fS)aNarrow types based on any checks of the type ``type(x) == T`` Args: node: The node that might contain the comparison expr_indices: The list of indices of expressions in ``node`` that are being compared cbt|jdxrt|jdk(S)z)Is expr a call to type with one argument?rrz)rr"rre)rs r is_type_callz8TypeChecker.find_type_equals_check..is_type_call.s&%dkk?C[DIIZ[H[ [rNFrcftd|Dryi}|D]}||j||S)z2Combine all typemaps in list_maps into one typemapc3$K|]}|du ywr'rrrQs rrzKTypeChecker.find_type_equals_check..combine_maps..`s0190sN)rLr) list_maps result_maprs r combine_mapsz8TypeChecker.find_type_equals_check..combine_maps^sB0i00J )=%%a( ) r)rrbr8r!)r  list[TypeMap]r8r) operandsrrbr-reget_isinstance_typerrrr#conditional_types_with_intersectionrr)r)r expr_indicesrexprs_in_type_callstype_being_comparedrrrrif_maps else_mapscurrent_if_typecurrent_else_typecurrent_if_mapcurrent_else_mapr"rrs rfind_type_equals_checkz"TypeChecker.find_type_equals_check#s| \ 136:! 7E=='D$)l4.@#**499Q<8#77= '&2r6M!$0Z 85T#'99#5#5*6') 7,#r6M!##% ' /D151Y1Y  &(;T2 .O.0Mo'80 ,N, NN> *   - . / g& #I.HxHxrin_boolean_contextcz|j||\}}|j|}|j|}||fS)aFind any isinstance checks (within a chain of ands). Includes implicit and explicit checks for None and calls to callable. Also includes TypeGuard and TypeIs functions. Return value is a map of variables to their types if the condition is true and a map of variables to their types if the condition is false. If either of the values in the tuple is None, then that particular branch can never occur. If `in_boolean_context=True` is passed, it means that we handle a walrus expression. We treat rhs values in expressions like `(a := A())` specially: for example, some errors are suppressed. May return {}, {}. Can return None, None in situations involving NoReturn. r1)find_isinstance_check_helperr)r)rr2rr new_if_map new_else_maps rrz!TypeChecker.find_isinstance_checkssQ* << %7= 33F; 55h? <''rc t|ridfSt|rdifSt|tr)t |j dk7rt |j d}t|jdrwt |j dk7riifSt|tk(rt|g|j|j||j|j d|St|jdrAt |j dk7riifSt|tk(r|j||St|jdrRt |j dk7riifSt|tk(r|j|}|j!||St|jdrt |j dk7riifSt#|j d|j|j d}t|tk(r$|r!t |dk(r|j%||j||dSd\}}|j'|j}|_t)|}t|t*rt-d ||d } | t)| }t|t.r|j0|j2}}t|jt4r,|jj0|jj2}}||!|j6dt8j:k7rt|t.t<fr|j>dj@d} | |j@vr4|j@jC| } t |j | }n9|d nd } |jEtFjHjK| |iifSt|tk(rA||tM|iifS|Jt|g|j|j|tO|dg|dSt|tPr|jS|St|tTri} i}|jW|jX\}}|| j[|||j[||jW|j\d\}}|| j[|||j[|||dn| ||dfS|fSt|t^re|j`dk(rV|jW|jb\}}|jW|jd\}}tg||ti||d fSt|t^rc|j`dk(rT|jW|jb\}}|jW|jd\}}ti||tg||fSt|tjr1|j`dk(r"|jW|jl\}}||fSt|tk(r|jo|r|jq|j|rts|j|ds|jtjvr|jy|j|dd\}}| t{|}n t}}| t|}n t}}t|t|s||ind} t|t|s||ind}| |fS|j|}|r|j||t|d}t{|}t|}t|t|s||ind} t|t|s||ind}| |fS)Nrzbuiltins.isinstancerrzzbuiltins.issubclasszbuiltins.callablezbuiltins.hasattrrrTr guardnarrowerFis_upper_boundconsider_runtime_isinstancer1r) coalesce_anyornotrrrj)Bis_true_literalrrrbrrerrr"r;rXrr&rr%infer_issubclass_mapsrrhasattr_type_mapslookup_type_or_nonerrrrrrrrrrNrrrrrrTYPE_GUARD_POS_ARG_REQUIREDrrr"rd comparison_type_narrowing_helperr]rrrrrrrPrQand_conditional_mapsrrrrcan_be_narrowed_with_lenrrPrnarrow_with_lenrrrrr)r)rr2rvartyperrr called_typecallrrrrrif_assignment_mapelse_assignment_mapif_condition_mapelse_condition_map left_if_varsleft_else_vars right_if_varsright_else_varsrPrQyes_typeno_typeoriginal_vartypeif_type else_types rr4z(TypeChecker.find_isinstance_check_helpersI 4 t8O D !8O dH %#dii.A*="499Q<0D!$++/DEtyy>Q&r6M4=L08AA ,,T2D4L4LTYYWX\4Z\` $DKK1FGtyy>Q&r6M4=L055dDAA#DKK1DEtyy>Q&r6M4=L0"..t4G==dGLL#DKK1CDtyy>Q&r6M/ ! d>N>NtyyYZ|>\]4=L0Tc$i1n11$8H8H8NPTUVPWXX&0#"66t{{C *"1+">K"+x8*:{K]ab+*9$*?K!+|<.9.A.A;CYCYdkk73*.++*=*=t{{?U?UZG)W-@~~a(EMM9 &kL*3MN#.#4#4Q#7#A#A!#DD#t~~5&*nn&:&:4&@'6tyy~'F2<2Hwj $ $4$P$P$W$WX\$]_c!"(*2v t} 4 &1$(/**E#F#JJ#*#66#6#@ $$!%!I!I$($4$4T$:%.wu%M$N$(@E "J""$n -88> > n -FH595O5OPTP[P[5\ 2 2 , /0". 34373M3M u4N4 0 0 + ./!- 23+26F6NTZ,48J8R X` f %$''U*:+/+E+Edii+P (L.-1-G-G -S *M? %\=A$NORVW  f %$''T/+/+E+Edii+P (L.-1-G-G -S *M? $L-@$^_E i (TWW-=44TYY?KD%$;  DM\ ) d#--d.>.>t.DE)$*:*:4*@*M ,,!% 4 4T5E5Ed5KSRS T Hg#$X.*,"$W-)+-7/-RdH%X\F.8/.RgX\H8# # ++D1   & &'7 >12BOTG$w' (27O(L$RV,6y/,RD)$X\xrc Z|jDcgc] }t|}}g}i}t|D]\}}|j|siifcS|j |}|j |t |tk(sRt|r^|j|rpt|} | ~| ||<t|j|ddh} g} | D]\} } | dvr|j|| ||| |\}}n| dvrt| dk(sJ| \}}||}||}ii}}||vrrt|rgt!t#|}|Qt|sFt%|t&r|j(j*dk(st-||rt/||||<||vr3|j1||\}}||}|d}n|||<|d}n |||<ni}i}| dvr||}}| j ||ft3d | Dr t5| St5|j7|d Scc}w) z2Infer type narrowing from a comparison expression.N==is>r]!=r\is not>innot inrr >r^r_rac3*K|] }|iifk7 ywr'rrs rrz?TypeChecker.comparison_type_narrowing_helper..s8qRH}8sTuse_meet)r$rrrrr-r;rXris_literal_enumr<group_comparison_operandspairwiseequality_type_narrowing_helperrrrbuiltin_item_typerrrrr>rrr0reduce_conditional_mapsfind_tuple_len_narrowing)r)rrKr$ operand_types narrowable_operand_index_to_hashrrrhsimplified_operator_listpartial_type_mapsoperatorr'rr left_indexrkrrcollection_item_typerYrZs rrGz,TypeChecker.comparison_type_narrowing_helperGs 15 >1OA&>> +-( * $= MMO=d|$  &>6 9 "Hl77#'#F#F! 4 $ --<(A---*6' K)*5 -k : #%r!AA*95/>?PQ^?_/`,0<$78L$M *+? J$8$=$=$F$FJ[$[ ;IG[ \;J9;UF8J#78"BB)-)L)L!=*&GY$K0D!%'.t  (#')255#+V  $ $fh%7 8m6 9v 8&78 8*+<= =+4+H+H+NY]^ ^W?sH(c|dvr t}d}d} nAdd} dd} | }d}|D cgc]} ||  } } tt| | xr t|  } i}i}| r'|j ||||j ||\}}|ik(r*|ik(r%|j ||||j \}}|ik(r|ik(r|j||\}}||fScc} w)z@Calculate type maps for '==', '!=', 'is' or 'is not' expression.>r]r_FTc4tt|tSr')rrrr*s ris_exactly_literal_typezKTypeChecker.equality_type_narrowing_helper..is_exactly_literal_types!/!"4kBBrcBt|dd xrt|dd S)NrEF) check_allrF)rr*s rhas_no_custom_eq_checkszKTypeChecker.equality_type_narrowing_helper..has_no_custom_eq_checkss10x5N/8uMMNrr/)rrLr is_ambiguous_mix_of_enums%refine_identity_comparison_expressionr refine_away_none_in_comparisonr0)r)rrqr$rlr'rmis_valid_targetcoerce_only_in_literal_contextshould_narrow_by_identityrvryr expr_typesrrs rrhz*TypeChecker.equality_type_narrowing_helpers$4 ' '6GO-2 *(, % C N 6O-1 *4@Aq-*AJA(++Z8))</ ;; & $#II0557.   FH R\}}|||<|j||}|jD]\}}||vr |||<@|S)aAttempts refining parent expressions of any MemberExpr or IndexExprs in new_types. Specifically, this function accepts two mappings of expression to original types: the original mapping (existing_types), and a new mapping (new_types) intended to update the original. This function iterates through new_types and attempts to use the information to try refining any parent types that happen to be unions. For example, suppose there are two types "A = Tuple[int, int]" and "B = Tuple[str, str]". Next, suppose that 'new_types' specifies the expression 'foo[0]' has a refined type of 'int' and that 'foo' was previously deduced to be of type Union[A, B]. Then, this function will observe that since A[0] is an int and B[0] is not, the type of 'foo' can be further refined from Union[A, B] into just B. We perform this kind of "parent narrowing" for member lookup expressions and indexing expressions into tuples, namedtuples, and typeddicts. We repeat this narrowing recursively if the parent is also a "lookup expression". So for example, if we have the expression "foo['bar'].baz[0]", we'd potentially end up refining types for the expressions "foo", "foo['bar']", and "foo['bar'].baz". We return the newly refined map. This map is guaranteed to be a superset of 'new_types'. N)rrefine_parent_types)r) new_types output_maprr new_mapping parent_exprproposed_parent_types rrz%TypeChecker.propagate_up_typemap_infos2   (0 ?OD)(Jt 224CK5@5F5F5H ?1 1)+*> ;'  ? ?rc i} t|trBj|j| j }|j d fd }nt|t rj|j| j }j|j|j |j}||St| d fd }nt| d fd }n|S|S||St|}t|ts|Sg}t|jD]7}|t|} | |cSt| |s'|j!|9|s|S }t#|x}| <)aChecks if the given expr is a 'lookup operation' into a union and iteratively refines the parent types based on the 'expr_type'. For example, if 'expr' is an expression like 'a.b.c.d', we'll potentially return refined types for expressions 'a', 'a.b', and 'a.b.c'. For more details about what a 'lookup operation' is and how we use the expr_type to refine the parent types of lookup_expr, see the docstring in 'propagate_up_typemap_info'. c jj5}t|ddd|d }dddjryS#1swYxYw)NF) rrrrrr r!r(in_literal_context)r?rr'r)new_parent_typew member_type member_namerr)s r replay_lookupz6TypeChecker.refine_parent_types..replay_lookupDsf//1 Q&;!, /$/&+%*(-*9 $/4 '  '')#**  s A  Act|tsy JDcgc]}|j|}}t |Scc}w#t$rYywxYwr')rrrr\r)rr member_types str_literalss rrz6TypeChecker.refine_parent_types..replay_lookupdsd)/=I#'(#/#;;#;R^+_3O,A,A#,F+_L+_ 5\BB,`'(#'(A?AA AAct|tsy JDcgc]}|j|}}t |Scc}w#t$rYywxYwr')rrr IndexErrorr)rrr int_literalss rrz6TypeChecker.refine_parent_types..replay_lookuprsd#-oy#I'+,'3'? ?'?Vb/cs0E0Ec0J/c /c$9#FF0d#-,'+,r)rrr8 Type | None)rr~_propagate_walrus_assignmentsrrErrxrrrrrrrrr?r-r)r)rroutput parent_typerr+new_parent_typesrrrrrrs` @@@@rrzTypeChecker.refine_parent_types,s*, $ +"@@FS "66{C "ii ++$D),"@@FS "66{C 224::vF!55djjA %!MA*M +C$Fj#QL#/G &  " *+6Kk95  " -k.?.?@ 2+OD,AB &"M' Y?$++D1 2$ D.CDT.U UI{+Qrct|tret|jtr|j|j||j |j}t |}||||<|S|S)zAdd assignments from walrus expressions to inferred types. Only considers nested assignment exprs, does not recurse into other types. This may be added later if necessary by implementing a dedicated visitor. )rr]rrrEr)r)rr assigned_typers rrz)TypeChecker._propagate_walrus_assignmentssi dN +$**n5224::xH 44TZZ@M)$/K((5%  rcd}|rddtfd|D}d}g} |D]M} | } |r t| } |t| s'|rt|| sdifcS| }| j | O|iifSd} | D] } | |vs| } | dk(r| d} d} t|}t |t rJ|jst |jtr |jjj} t|dg}g}|D]U} | | k(r | |vr|| }t| } | t| | } t| |}|j t!|g|Wt#|S) aGProduce conditional type maps refining expressions by an identity/equality comparison. The 'operands' and 'operand_types' lists should be the full list of operands used in the overall comparison expression. The 'chain_indices' list is the list of indices actually used within this identity comparison chain. So if we have the expression: a <= b is c is d <= e ...then 'operands' and 'operand_types' would be lists of length 5 and 'chain_indices' would be the list [1, 2, 3]. The 'narrowable_operand_indices' parameter is the set of all indices we are allowed to refine the types of: that is, all operands that will potentially be a part of the output TypeMaps. Although this function could theoretically try setting the types of the operands in the chains to the meet, doing that causes too many issues in real-world code. Instead, we use 'is_valid_target' to identify which of the given chain types we could plausibly use as the refined type for the expressions in the chain. Similarly, 'coerce_only_in_literal_context' controls whether we should try coercing expressions in the chain to a Literal type. Performing this coercion is sometimes too aggressive of a narrowing, depending on context. Tct|}t|xs(t|txr|jj Sr')rrrrrrrs rshould_coerce_innerzNTypeChecker.refine_identity_comparison_expression..should_coerce_inners7%c*+C0sH-B#((2B2Brc34K|]}|ywr'r)rrrlrs rrzDTypeChecker.refine_identity_comparison_expression..s]! 3M!4D E]sNrFr;rrr8r!)r0rrrr-rris_enum_literalrr!rrrr"rconditional_typesrrj)r)r$rl chain_indicesnarrowable_operand_indicesr}r~ should_coercerpossible_target_indicesrrsingleton_index sum_type_name target_typerprrrs ` @rr{z1TypeChecker.refine_identity_comparison_expressionsF )   ]}]]M""$ .A%a(I-i8 "?9#=>l69=RxF # * *1 - . >r6M ( $A22"# $8 b 5b9O  ( fk *  " " $ 6<<(F"OO0099M >?  RA O#22A;D)-*:;I(;I}U &i=E  $ $%B4%P%%P Q/ R2''899rc g}|D]$}||}t|r|j|&ii} }|rt|t|k7ry|D]9}|| t st fd|Ds)t |||<;td|Dr)|D]$}|| t st | ||<&|| fS)zProduces conditional type maps refining away None in an identity/equality chain. For more details about what the different arguments mean, see the docstring of 'refine_identity_comparison_expression' up above. c36K|]}t|ywr')r>)rrrs rrz=TypeChecker.refine_away_none_in_comparison..]s]Q29a@]sc3NK|]}tt|tywr')rrr)rots rrz=TypeChecker.refine_away_none_in_comparison..csU:ob18<Us#%)rr-rr0r) r)r$rlrrnon_optional_typesrrrrrs @rr|z*TypeChecker.refine_away_none_in_comparison@s  /A"C&s+"))#. / r!c*<&=]AS&S0 E)!, *95]J\]]*9)*DF8A;'  EU}UU3KA -a 0I*950? 0J!-K xrc,t|tsyt|jdsyt |j dk7ry|j d}t |tk7ry|j|sy|j|j|S)zIIs this expression a `len(x)` call where x is a tuple or union of tuples?Fz builtins.lenrzr) rrbrr"rrer;rXrrIr)r)rs ris_len_of_tuplezTypeChecker.is_len_of_tupleksz$)!$++~> tyy>Q yy| 4=L (}}T",,T-=-=d-CDDrct|dryt|}t|tr@t d|j Dr#|j jjdk(Syt|tr|jjdSt|trt fd|j DSy)zIs this a type that can benefit from length check type restrictions? Currently supported types are TupleTypes, Instances of builtins.tuple, and unions involving such types. rFc3<K|]}t|tywr')rrrs rrz7TypeChecker.can_be_narrowed_with_len..sB:a,Br4r Tc3@K|]}j|ywr')rIr s rrz7TypeChecker.can_be_narrowed_with_len..sMAt44Q7Mr ) rrrrr0rrDrrrrr)r)rp_typs` rrIz$TypeChecker.can_be_narrowed_with_lenzs !i 0$ eY 'BekkBB--22;;?OOO eX &::&&'78 8 eY 'MMM Mrc|j|sy|j|}t|}t|}t |t syt |j tsy|j S)zIs this expression an int literal, or a reference to an int constant? If yes, return the corresponding int value, otherwise return None. N)rrrrrrrrW)r)rrrs rliteral_int_exprzTypeChecker.literal_int_exprsc }}T"$$T* %i0 %i0 +{3+++S1   rcg}t}|jD]\}}}t|tr |j}t|tr |j}|dvr#|j ||j |f|r&|j dt|ft}|dvs|j |||gf|r|j dt|fg}|D]\}}tfd|Dstfd|Ds1|dvrt} g} |D]i} j| } | | j | (j| s:t| tsJ| j | jdkt| dkDrdifgcS| j} | tkDr| D]J}j!j#||| \}}|dn||i}|dn||i}|j ||fL/|\}}j|r||}}t%j&||}j|}|J|tkDrt|tsJj!j#|jd||\}}|dn|jd|i}|dn|jd|i}|j ||f|S) aTop-level logic to find type restrictions from a length check on tuples. We try to detect `if` checks like the following: x: tuple[int, int] | tuple[int, int, int] y: tuple[int, int] | tuple[int, int, int] if len(x) == len(y) == 2: a, b = x # OK c, d = y # OK z: tuple[int, ...] if 1 < len(z) < 4: x = z # OK and report corresponding type restrictions to the binder. )r]r\r\>>=.s!Mt,,R0<Ms c3@K|]}j|ywr')rrs rrz7TypeChecker.find_tuple_len_narrowing..s@Bt++B/@r Nrrz)r]rgrr]rrr-rr0rrrbrerr2r rJrrr)r)rchained last_grouprrPrQrrliteral_valuestuplesrrsizetplrVrWyes_mapno_mapr_sizes` rrkz$TypeChecker.find_tuple_len_narrowings (U #}} 8OBe$/zz%0 \!t$u%NND$z*:#;$$R(>OOB' (  $I  #H0;/9W$ $W$ $ >> >5rc|t|j}|(t|}||j|r|dfSd|fS|j|}t |t sJt |j}t |tr|jdz |jz}|dvr ||kr||fSd|fS|dvr~|dk(r|dz }||krk|jd|} |j|dzd} t |j||jz dz}||j| |gz| zfSd|fS|j|t||\} } | | fSt |tr|jjdk(sJ|jdz }|jd } |jd|} |j|dzd} |dvr*||kr!|j| | g||z zz| z|fSd|fS|dvr|dk(r|dz }||kr|j| | g||z zz|gz| z} g}t!||z D]-}|j#|j| | g|zz| z/t%j&||j(|j*| fSd|fS|j|t||\} } | | fS) z-Narrow a TupleType using length restrictions.Nrzr\r]rrr)min_len)rr r)rrrrirrrrrrrGrrrrrerr-rrrr{)r)rrr unpack_indexrnunpackrrrsuffixrVrWr yes_itemsrs rrz&TypeChecker.refine_tuple_type_with_lens.+3995  &b)FcjjlD)Dy 9 <(&*---"6;;/ h 0 1jjlQ&)9)99G\!d?8OSy {":AIDT> YY} 5F YY|a'7'9:F'(>(>tcjjlGZ]^G^(>(_`F 1 1&8IF8R 1 SSSSy $($C$CCQSVZ$[!'(((H-(--2H2HL\2\\\**,"mmA=L)C C ; Tz #D$;$;frt|tr|j,j.rld |j,j@vrTt;d ||d }|Jt|||js)|j j=||||j(|jC||||j(y) zBGenerate an error if the subtype is not compatible with supertype.rTrF z (z, r) parent_errorrr8)"rrPrrNrAr?prefer_simple_messagesrr&try_report_long_tuple_assignment_errorrHr-rIrrDrrErrrrmaybe_note_concatenate_pos_argsrrrrrrreport_protocol_problemsr note_callrprotocol_memberscheck_possible_missing_await)r)rrrr?rrrrr orig_subtypeorig_supertype extra_infonote_msg subtype_str supertype_strerrorrrMs rrzTypeChecker.check_subtypes0 gy$,, ? c3 s.C 88 * * , IIc7 # !'*"#I. 88 : : Ym_  "    $(C)?ndll* &K(!!-#"5 "CD*!!/C"7-"GH.('9mH'8,Ix1P/w J'9-*Y 2R)%)T\\R ))$:1F*F*LMC #w' 8D HHMM$chhM 7 8  IIhchhI 7 00)WSVS[S[0\ y( +**7\8Y W_$`a HH - -gy'X] - ^ i .:gx3Pz7GND""7D'"I g j9 :z)U]?^~~))jINN<[<[.[":y'tT'''!'4FHH&&y$chh&O ))'9gCHH)Urc tt|try |jj |t dd}|jrytt|ttfry|S#t $rYywxYw)zIf type implements Awaitable[X] with non-Any X, return X. In all other cases return None. This method must be called in context of local_errors. NrT) ignore_binder) rrrrur7rer\rrr)r)rraw_types rget_precise_awaitable_typez&TypeChecker.get_precise_awaitable_types oc*K 8 ''<<WY$=G  & & ( og.+0F G  s'A66 BBc#JKd|_ dd|_y#d|_wxYwwr)rhrts rchecking_await_setzTypeChecker.checking_await_sets&&*# 0 */D '%D 's## #c|jry|j5|jj5}|j ||}| ddddddy|j |||t js ddddddy dddddd|jj||y#1swY.xYw#1swY2xYw)z7Check if the given type becomes a subtype when awaited.N)r?) rhrr?rrrrINCOMPATIBLE_TYPESpossible_missing_await)r)rrrrrrs rrz(TypeChecker.check_possible_missing_awaits  & &   $ $ & (>(>(@ L55g|LG   %%G1A1T1T&       ''6    s4CCC $CCCC CCc"|dk(r.|j|j||_|jS|dk(r.|j|j||_|jS|dk(r.|j|j||_|jS|dk(r.|j|j||_|jS|dk(r.|j |j||_|j S|j|S)zReturn an instance type with given name and implicit Any type args. For example, named_type('builtins.object') produces the 'object' type. rrz builtins.intrjr )rm _named_typernrorprqrs rrzTypeChecker.named_type!s > !~~%!%!1!1$!7>> ! & &""*&*&6&6t&<#&& & > !~~%!%!1!1$!7>> ! ? "&"&"2"24"8?? " $ $  ($($4$4T$:!$$ $%%rcz|j|}|j}t|tr2t|jt sJ|jj }t|tsJ|ttj}t ||gt|jjzSr')lookup_qualifiedrrrrrrrrrfrom_omitted_genericsrrrA)r)rr2rrs rrzTypeChecker._named_type<s##D)xx dI &dkk84 44;;##D$)/4/)9::;xj3tyy/B/B+CCDDrcv|j|}|Dcgc] }t|}}t||Scc}w)zReturn an instance with the given name and type arguments. Assume that the number of arguments is correct. Assume that the name refers to a compatible generic type. )rr-r)r)rrerrs rrzTypeChecker.named_generic_typeGs@ ##D)BFG31#6GGd##Hs6cn|j|}|j}t|tsJ||Sr')rrrr)r)rr2rs rrzTypeChecker.lookup_typeinfoRs5##H-xx$)/4/) rc$|jdS)zReturn instance type 'type'.rrrts rr?zTypeChecker.type_typeYs//rc$|jdS)zReturn instance type 'str'.rrrts rryzTypeChecker.str_type]s~..rc(||jd|<y)z)Store the type of a node in the type map.rN)r,)r)rrs rrzTypeChecker.store_typeas$'D!rcRtfdt|jDS)Nc3&K|]}|v ywr'r)rrQrs rrz'TypeChecker.has_type..fs@419@s)r0rr,rs `rrzTypeChecker.has_typees@ht&?@@@rcNt|jD] }||vs||cSyr')rr,)r)rrQs rrEzTypeChecker.lookup_type_or_nonehs/$//* Aqyw rczt|jD]}|j|}||cSt|r')rr,rr\)r)rrQrs rrzTypeChecker.lookup_typens=$//* Ad A} tnrc@|jdj|yr)r,r)r)rs rrzTypeChecker.store_typesus ""1%rcp|jjxs|j xs|jd S)zShould we type-check the current function? - Yes if --check-untyped-defs is set. - Yes outside functions. - Yes in annotated functions. - No otherwise. r)rPrrHrts rr|zTypeChecker.in_checked_functionxs8 LL + + c43E3E/E cTM_M_`bMcIc rc ||jvr|j|S|jjdd}|r;t|jtsJ|jj }||vr||St d|)z?Look up a definition from the symbol table with the given name. __builtins__NzFailed lookup: )rLrrrrr\r\)r)rr=tables rlookupzTypeChecker.lookupsz 4<< <<% %   6A!!&&(333 5= ;&_TF34 4rcd|vr|j|S|jd}|j|d}tdt |dz D]Q}|j j ||}|Jdt|jtsJ|j}S|d}||j vr|j |St |dk(rZ|ddvrSdj|}|tvrdj|dt|}nd }td j||d } t| j||) Nrrrzz0Internal error: attempted lookup of unknown namerr)builtinsrz*, e.g. add '[{} fixtures/{}]' to your testrzmCould not find builtin symbol '{}' (If you are running a test case, use a fixture that defines this symbol{})z0Failed qualified lookup: '{}' (fullname = '{}').)rsplitrNrrr\rrrrrrBrr\) r)rpartsrrr2lastr suggestionr?s rrzTypeChecker.lookup_qualifiedsK d?;;t$ $JJsOE U1X&A1c%j1n- ggkk%(+Z(ZZ!#((H555HH   9Dqwwwwt}$UqU1X1G%G88E?66!M!T!Ta"9("C"J"$J--3VD*-E Iszz$566r)r"rc#K|jxr|jdjxs|}|jjti||d|jj xr| xs5|jj xr|jxr|jd}|jj\}}}|js*|jD]\}}|jj xs|xs|xr|j|} | rBt|jtr(|jj|st!|_}||j"vrN|sL|j$j'|||jj(|j"j+||jst-|j} | |jk7|_| |_yyw)zEnter a new scope for collecting partial types. Also report errors for (some) variables which still have partial types, i.e. we couldn't infer a complete type. rN)rIr#r-rrPallow_untyped_globalsrrHr2r_rlocal_partial_typesis_defined_in_base_classrrrrrJr?r}r~rrr) r)r"rr# permissiverIrrr allow_nonefixeds rrzTypeChecker.enter_partial_typess&&J4+=+=b+A+J+JZ{ !!"22{H"MN ll88I\ LL + + ]0B0B ]tGYGYZ\G] #00446 q!)) - 3 3 5! ) W 888I"I GT%B%B3%G "388[9 -&'zCH$"7"77 88gt||GbGbc--11#6xx 2388 <38CHH3D0#(C! )*s GH 5Hc|j|\}}}|j|r|s tS|S||js|rt||}|s|jj ss|j j|||jj|jj|t|S|j|j|t|S)zjHandle a reference to a partial type through a var. (Used by checkexpr and checkmember.) ) find_partial_types_in_all_scopesrrr_rPrr?r}r~rJrrrr)r)rrrrin_scoper#rIs rhandle_partial_var_typez#TypeChecker.handle_partial_var_types-1,Q,QRV,W)(M 88 z! (1K1K+D1Gt||'I'I88 '4<<+F+F--11$7&c* *55diiI%c* *rcjsyjjxs+tfdjjddDS)NFc3XK|]!}|jjdu#ywr')rr)rrrs rrz7TypeChecker.is_defined_in_base_class.. s(/ /3DHHSXX d */ s'*rz)rr r0r)r)rs `rrz$TypeChecker.is_defined_in_base_classsGxxxx'' 3/ 7:xx||AB7G/ ,  rc6|j|\}}}|r|Sy)aLook for an active partial type scope containing variable. A scope is active if assignments in the current context can refine a partial type originally defined in the scope. This is affected by the local_partial_types configuration option. N)r)r)rr rrIs rrzTypeChecker.find_partial_types s'&*%J%J3%O"!]  rct|jD]}||jvs|jj}t |j tr$|j j |jrd}| xs&|j|jdjk(}||j|jfcSy)zLook for partial type scope containing variable. Return tuple (is the scope active, is the scope a local scope, scope). Tr)FFN) rrIr rPrrrrrr#)r)rrEdisallow_other_scopes scope_actives rrz,TypeChecker.find_partial_types_in_all_scopessd001 ?Eeii)- (H(H%chh 49RWZW_W_-1).-b4CUCUVXCYCbCb1b$U^^UYY>> ? "rct||S)z3Create a temporary node with the given, fixed type.r)r)r)rrs rrzTypeChecker.temp_node2s7++rrct|tr2|jj|j||j S|jj|||S)zProduce an error message.r)rrAr?rrr)r)r?rrs rrzTypeChecker.fail6sH c< (88==G#((=C Cxx}}S'}55rct|tr3|jj|j||j y|jj||||y)zProduce a note.rN)offsetr)rrAr?rrr)r)r?rr+rs rrzTypeChecker.note>sG c< ( HHMM#))W388M <   c76 =rct|trEt||jd}|jd}tt |t s|S|j||dS)Nrwrrz)rrr=rrerrr>)r)rrr:rs rrzTypeChecker.iterable_item_typeLsc b( #0T5I5IJ[5\]H a(Ioi8'B! AA"gNqQQrc8t||jdS)Nr)rr)r)rs rrzTypeChecker.function_typeYsT4??3F#GHHrrc||jjy|jD]#\}}|jj|||%y)Nr)r@rrr)r)rrrrs rrzTypeChecker.push_type_map\sJ   KK # # %&nn. M d dOL Mrc|j|}|j|jd}t|tr |j }t |}t|trYg}t|jD]3}t|tr|j|j/iifcSt|}n]t|tr |j}n@t|tr,|jjr|j!d}niifS|j#|||\}}t%|||\} } t't(| | f\} } | | fS)z=Infer type restrictions for an expression in issubclass call.rzr )rr%rerrr"rrrrrr-rrrr>rr&rr convert_to_typetype) r)rrrKr union_listrrVrWrrs rrCz!TypeChecker.infer_issubclass_mapscs5""4('' ! 5 g{ +))G!'* gy )J%gmm4 "a*%%aff-r6M  " +G  *llG  *w||/H/H/Joo&78Gr6M DDWdTXY'7hP1GV3DErr=cyr'rr)r type_rangesr'rr>s rr&z/TypeChecker.conditional_types_with_intersections+.rcyr'rr3s rr&z/TypeChecker.conditional_types_with_intersections rc:t||||}|d}|d}tt|tr|||fSt|} t| trt | j } n| g} g} |D]?} t| j} t| ttfs/| j| A| s||fSg}g}| D]}t|ts||fcS| D]f}t|tr,|jd|jjddf?|j||f|}|V|j|h|sC|jr'|D]"\}}|jj!|||$t|fSt#|}||fS)Nr=rrzrz" and "NoneType"z"NoneType" is final)rrrrrrrMrrrr-rrrrr?impossible_intersectionr)r)rr4r'rr> initial_typesrVrWrpossible_expr_typespossible_target_typesrroutr>rr intersectionrreason new_yes_types rr&z/TypeChecker.conditional_types_with_intersections*   (C  !.a 0,Q//(3_EI\W$ $ &i0 k9 -"2;3M3M3O"P #.-  " 3B"277+D$8 45%,,T2 3%W$ $(*$ )Aa*((* )a*MMQqvv{{m3C#DF["\]#77AG ' <( ) )446%+IME6HH44UFCHI"$i/ /,S1 Y&&rct|tr|jr |jsyyt|trC|jr7|j d}t|t sJ|jjSy)z!Check if an attribute is writableFTr)rrrrrrrgr)r)r first_items rrz!TypeChecker.is_writable_attributesf dC (A(A / 0T5E5EAJj)4 44>>66 6rcht|tr|jdk(r|j|j}|+t |jrt tdg}|j|j}|+t |jrt tdg}||y||zStt|j|}g}|D]}t|trd|jrTt|j}t|t r t#|}n|}|j%t |dxt|t&rEd} t|j(trd} |j%t |j(| t|t*rZ|j,j.dk(rAt+|j,j0dg} |j%t | d7t|t*rV|j,j.dk(r=|j2r1|j%t t5|j2dt|t6r|j%t |dy|sy|S)NrFr;Trrztypes.UnionType)rrrr%rPrr"rrQr flatten_typesrrrRrrSrr,r-rrrrrrrerr) r)rrPrQrrrany_parameterized erased_typer<rCs rr%zTypeChecker.get_isinstance_types  dF #3++DII6D| :!(*UCD,,TZZ8E}!<"8:eDE|u}%< $]43C3CD3I%JK !# C#|,1B$:3??;L$M!/;"01B"CK"3K Y{5IJC*"&chh1%*N YsxxOPC*sxx/@/@O/S&sxx||B'7<  Y{4HIC*sxx/@/@DU/UZ]ZbZb Yy':5QRC) Ys5AB5 6 rct|trt|jtsy|j |j}|j |}||yt |}t t |}t|trt|tsy|jsy|jxr'|jj|jk(S)aReturns true if this expression (with the given type context) is an Enum literal. For example, if we had an enum: class Foo(Enum): A = 1 B = 2 ...and if the expression 'Foo' referred to that enum within the current type context, then the expression 'Foo.A' would be a literal enum. However, if we did 'a = Foo.A', then the variable 'a' would *not* be a literal enum. We occasionally special-case expressions like 'Foo.A' and treat them as a single primitive unit for the same reasons we sometimes treat 'True', 'False', or 'None' as a single primitive unit. F)rr~rrrErrrrrRrrrrS)r)rrrs rrezTypeChecker.is_literal_enums"!Z( 16680L..qvv6 ..q1  +"5%k2 %&7 &DE +|4J{T_<`&&(  ' ' ) G$$))[-D-D-FF rc |}t|}ttj}t |t r3|j ||}|jJd|j_|St |tr.|jj ||}|j|St |tr.|jj ||}|j|St |trIt |jt r/tj |j#|j|St |t$rU|j|j#|j&||j(Dcgc]}|j#||c}St |t*rA|j-||\}} t/|| Dcgc]}|j#||c}zS|Scc}wcc}w)z8Inject an extra attribute with Any type using fallbacks.Nr)r"r)rrrr)rrcopy_with_extra_attrrmod_namerrDrGrrrrradd_any_attribute_to_typerr"rrpartition_union_by_attrr) r)rrrrrrr with_attr without_attrs rrIz%TypeChecker.add_any_attribute_to_type7sc"9001 c8 $--dH=F%%1 11*.F   'M c9 %++@@xPH$$h$7 7 c< (||88xHH$$h$7 7 c8 $CHHh)G++D,J,J388UY,Z[ [ c; '$$ ::3??DQILTA66q$?T%  c9 %&*&B&B3&M #I|(R^_3T;;CF__ U `s G7 G< c|j||r||iifSt|}t|tr8|j ||\}}||j ||i}||t |ifS|j ||}||k7r||iifSiifS)afSimple support for hasattr() checks. Essentially the logic is following: * In the if branch, keep types that already has a valid attribute as is, for other inject an attribute with `Any` type. * In the else branch, remove types that already have a valid attribute, while keeping the rest. )has_valid_attributerrrrJrIr)r)r source_typerrrLrtype_with_attrs rrDzTypeChecker.hasattr_type_mapsXs  # #K 6+&* *%k2 k9 -"::;MOA|T;;KNOGT#8#FGG G77 TJ [ (.)2- -2v rcg}g}|jD]7}|j||r|j|'|j|9||fSr')rrNr-)r)rOrrKrLrs rrJz#TypeChecker.partition_union_by_attrqs\  %% *D''d3  &##D)  * ,&&rc t|}t|tryt|tr9|jr-|jj r|j j}nd}|jj5}t||tttjddd||d| dddj S#1swYxYw)NFT)rrr r!r( no_deferralmodule_symbol_table)rrrrrrHrr\r?rr'rrrr)r)rrrrTwatchers rrNzTypeChecker.has_valid_attribute}s$ eW % eX &5+<+<ARARA[A["'**"2"2 "&  XX # # %  !!7!789!! $7  ))+++  s 6CCc<|jj||S)Nr)rur)r)rrxs rget_expression_typezTypeChecker.get_expression_types  ''<'HHrc\|j|jjjSr')rNrrr`)r)rs ris_defined_in_stubzTypeChecker.is_defined_in_stubs!||CHH001999rcLttr jtttt frlj _|jjD]3}t|tstfd|jDs3y|j|yyy)zEWarn if deprecated and not directly imported with a `from` statement.Nc3BK|]}j|dk(yw)rNrt)rrrs rrz/TypeChecker.check_deprecated..s6\QtyyAaD7H6\r) rrgrrprr deprecatedrZimportsrwr0r\rd)r)rrimps ` rcheck_deprecatedzTypeChecker.check_deprecateds dI &99D dW&7B C OO 'yy(( 4c:.36\RUR[R[6\3\ 4$$T73 ( Drcttr jtttt frj x}|jstfd|jjDs\|jjr|jjn|jj}|||tj yyyyy)zWarn if deprecated.Nc3|K|]3}j|k(xsjj|d5yw)rN)rr)rrrs rrz.TypeChecker.warn_deprecated..s? "Gdmm&>&>!Aw&GGs9<r)rrgrrprrr\rbr0rPdeprecated_calls_excludereport_deprecated_as_noter?rrr DEPRECATED)r)rrr\warns ` rrdzTypeChecker.warn_deprecateds dI &99D tg'8(C D#.;))>> %)LL$J$J488==PTPXPXP]P]D W5+;+; < *< ErcTd|d|j}|xjdz c_|S)zNGenerate a name that is guaranteed to be unique for this TypeChecker instance.zdummy--rz)rX)r) namespacers rrz!TypeChecker.new_unique_dummy_names, {!DOO#45 1 rcyr'rrs rvisit_pass_stmtzTypeChecker.visit_pass_stmtrcyr'rrs rvisit_nonlocal_declzTypeChecker.visit_nonlocal_declrkrcyr'rrs rvisit_global_declzTypeChecker.visit_global_declrkr)r>r3rNrMrPrrZrr[rNrVrrrzdict[int, int]r8r9)r8rA)r8zlist[Type | None]r8r9r')rz7Sequence[DeferredNode | FineGrainedDeferredNode] | Nonercr!r8r!)rz.DeferredNodeType | FineGrainedDeferredNodeTyper8r9)rrr8r9)rr rrr8r9)rrNrrer8r9)rrr8r9) rrrzStatement | NonerExpression | NonerzCallable[[], None] | Noner8r9)rrr8r9)rrr8Iterator[None])r&rr'rer8CallableType | None)rrrVr!r8r!r)rfrrVr!r8r)rfrr8r)rrpr8r9)NNF) rrqrrsr str | Nonerr!r8r9)rrpryrr8r9)r8rrF) rrqrrrrtrr!r8r9)rrrrpr8r!)rrrrWr8r!)rrr8r9)rrqrr!r8r9)r"rNr8r!)rrqr8r9)rrprrr8r9) rrqrSrrTrNrrer8r9)rSrrTrNr_rrZrrVrNrYrrrer8r9)r`rrYrrSrr8r!)rror8r9)rrrrerrNr8r9)rrrrer8r9)rrrrrrer8r9)rrqrrr8z#list[tuple[FuncItem, CallableType]])rzFuncDef | OverloadedFuncDefrlist[TypeInfo] | NonerContext | Noner8r9)r'FuncDef | OverloadedFuncDef | Decoratorr8rv)rrxrrrr!r8 bool | None)rrrrr8r9)rrxrrNrrr8r!)rrr8r)rrrrrrNrrNrrNrr!rr!rrer8r!)rrqr8r9)rrcr8r9)rrr8r9)rzSequence[TypeVarLikeType]r8r9)rrcrrr8r9)r2rr8r!) rrNrWrrMrr'rr8r9)rrwr8r9)rrur8r9)rrtr8r9)rrvr8r9)r=r_r8r9)r8r!)ryrr8r!ryr^r8r9)TF) rtr|rqrkrr!rr!r8r9)rrrqrkr8r)rtr|rqrkrrNr8r9)rtrrqrkr8r9)rrrqrkrrrrrrrr!r8r!)rrNrrrrerr!rr!rPrr8z%tuple[Type | None, SymbolNode | None])rrrrr Node | Noner8r!)rrNrr{r'rer8r9)rr!r8rr)ryz8AssignmentStmt | OperatorAssignmentStmt | AssignmentExprr8r9)rtr|r8r9)rtr|rrr8r!)r rgr8rgT) ro list[Lvalue]rqrkrrerr!r8r9) ror}r9rWrrer: int | Noner8r!)TNF)ror}rqrkrrerr!rErrFr!r8r9) rorgrqrkrrrrerr!r8r9)rorgr8rg)ror}rqrkrrrrerFr!rr!r8r9)ror}rrr8r)rzlist[T]r(rWrirWr8z tuple[list[T], list[T], list[T]])rrr8r!) ror}rrrrerr!r8r9)rtr|rqrqr8z0tuple[Type | None, IndexExpr | None, Var | None])ryr|r8r!) rrrtr|rrrrer8r9)rrrtr|rrr8r!)rrr8r!)rrrtr|rrr8r9rrr8r)rqrkr8r!)rurrqrkrrer?rArrNrrNrlist[str] | Nonertrqrz Var | Noner8ztuple[Type, Type | None])rrr8r!) rtr~rrrrrqrkrrer8ztuple[Type, Type, bool])rtrxrqrkrrer8r9)rrryrrIrr8r9)rtrxrqrkr8r9)rrr8ztuple[str, ErrorCode] | None)ryrlr8r9)ryrr8r9)rrkrrrr!r8r)ryrsr8r9)ryrr8r9)ryrr8r9)ryr\r8r9)ryrr8r9)r3rkryrrr!r8r9)ryrr8r9)ryrr r!r8r9)rrkrr!r8r)rr!r8r)rzSequence[Type]r8r)rrrrkr8rFryrnr8r9)rrkr8tuple[Type, Type])rrrrer8r)rrkr8r)rrr8r) rrkrrrr!rrer8r9)ryrhr8r9)r3rgr8r9FF)r3rgrr!rr!r8r9)rrprdrrerkr8r9ryrr8r9)rrrrpr8r9)rrkrrqrr!r8r)ryr`r8r9)ryrfr8r9)ryr}r8r9)ryr}rrkr8rk)rrkrrr8r:)rr#r8dict[SymbolNode, Type])rrrrr8r9)rrr8r9) rrNrrNrrNrrr8ztuple[ClassDef, TypeInfo])rrr>zlist[tuple[str, str]]r8zInstance | None)rrrrr8r)rrr8r)rrrr!r8tuple[list[Type], list[Type]])rrkrrr8tuple[TypeMap, TypeMap])rrrrr8tuple[Type | None, Type | None])rrrrkr8r9)rrdr' list[int]r8r)rrkr2r!r8r)rrdr8r)rrdrqrNr$rgrlrFr'rrmzdict[int, tuple[Key, ...]]r8r)rrr8r)rrkrrr8zMapping[Expression, Type])rrkrr:r8rk)r$rgrlrFrrrAbstractSet[int]r}zCallable[[ProperType], bool]r~r!r8r) r$rgrlrFrrrrr8r)rrkr8r!)rrkr8r~)rrdr8list[tuple[TypeMap, TypeMap]])rrrrNrrWr8r)rrrrNrrWr8r)rrrrNrrWr8rr)rrrrrrer?rNrrtrrtrrrErrorCode | Nonerrwr8r!)rrrrrrer?rArrtrrtrrrrwr8r!)rrrrrrer?str | ErrorMessagerrtrrtrrrrrrwr8r!)rrrr4r8r) rrrrrrerrr8r9)rrNr8r)rrNrerFr8r)rrNr8r)r8r)rrkrrr8r9)rrkr8r!)rrkr8r)rrkr8r)rr:r8r9)rrNr8r)r"r!rr!r8rr) rrrr!rrrrer8r)rrr8r!)rrr8zdict[Var, Context] | None)rrr8z,tuple[bool, bool, dict[Var, Context] | None])rrrrwr8r)r?rrrerrr8r2)r) r?rrrer+rWrrr8r9)rz/Instance | CallableType | TypeType | Overloadedrrer8r)rror8r)rrrr!r8r9)rrbrrkr8r) rrr4list[TypeRange] | Noner'rerr9r>r!r8r) rrr4rr'rerrr>r!r8r) rrr4rr'rerrr>r!r8r)rrr8r!)rrkr8rrrkr8r!)rrrrNr8r)rrkrOrrrNr8r)rOrrrNr8r)rrrrNr8r!)rrkrxrr8r)rrr8r!)rr{rrer8r9)rhrNr8rN)rrr8r9)rrr8r9)rrrr8r9)rrrr<r`rr^rrr_rbrQrRr*propertyrurxr|rrrrrrrrrrr rrrrYr^rcrirlrnrqrprrxr~rrrrrr#rrrrrRr\r rrr{rrr rrrrrrrrrrrr r.r5r0r1r rrKrrfrirlrerzrrrrrrrrrrrrrrrrrrrrrrrrBrrArYrrrDrprsrrrrrrrrrrrrrrrrrrrrrrrrrrrr rrrrr2r-r.r>r?rJr*rSrrrWrZrorXrkrlr~rrrrrrrrrrrrrrr rr0rr4rGrhrrrr{r|rrIrrkrJrrrrrrrrrrrr?ryrrrErrr|rrrr!rrrrrrrrrrCr&rr%rerIrDrJrNrWrYr_rdrrjrmrorrrr7r7:sG N -, "!33## M ))   '&H!I" 8<4;"d")( NONN%N N  N  NN$2N N`""//-$*\IM&)- &E&"& &  &P". H: _'+;' -137 ;';'$;' * ;' 1 ;' ;'B2 c5J::5nAR\^& $ 3D!F#>' 9(.2! !J!J+!J !J  !J  !JF)V22X]n%n%#/n%7An%PTn% n%` =~*(!F;>)MV!FV V ,8V HKV V]V V p>N">N>N >N  >N  >N>N>N >N@2 (2 8<2 LX2 2 hM4N:W" !!#/! ,!8#' )$9   .!);!) !)F'!5'!'!'+ '!  '!R Yq;qCFqNVq qfI bbb b  b  b#'b#'bb bH32J)XS.`U":X;088#VJE,VRVR (VR19VR@HVR VRpB0   ,5& 83Aj3#' tDtDtD tD  tD  tDn*@AV(WW'R.'.'&0.'69.' .'`]~!!! !  !  !!%! !R")-:):):) :)  :):)':) /:)x  ' 4?   '4? :==$/=6== =("))4Ql  D&H#' RURURU RU  RU  RUr%) """ " " "  "R#'#!&444 4  4  44 4lA&!A&A& A&  A&  A& A&F $#'[[[ [  [  [ [ [z$ML!!*-!7:! )!  #' === =  =  =4;?-3-3&7-3 9-3^ (F(F!'(F48(FCJ(F (FT*X2%EN 6( 0-MM%'k,#'$(#k, k,k, k,  k,  k,k, k,"k,k, "k,Z #Z#Z#Z #Z  #Z  #Z !#ZJ&&)3&>E& &4 ; ;"& ;7I ;  ;%P%P)3%P %PN" 0" ""*."FJ" "HlI\-2F 0 %":'=R,)\'0R4" " #"&&#*& &&6,\\,0\EI\T[\ \ $&PUH6H6)-H6HLH6 H6T K K'+ K7A K  K [# J;  (9 NR  &  (9 NR   #]~!$    %)    ,&, ,\++1G+ +.!    # ,dd2dd7FV7 7"&6 E $0/(A &   57>%*U6)"6)6:6) 6)6)p+++/+7:+EL+ +:  "" 5"2, VZ6%6076BR6 6 > "& >  > > >  >  > RA RLS R  RIKOMM<  .-1..,. .  .&*. )..-1  ,     &*     $ ='-1='=',=' ='  ='&*=' )='~ -^$ LB-19< 2 '$ ',/ ' & ',2I: 4= rr7c eZdZdZddZddZy)r z0Collects the non-nested argument types in a set.c"t|_yr')r]rrts rr*zCollectArgTypeVarTypes.__init__s +.5rc:|jj|yr')rrr s rvisit_type_varz%CollectArgTypeVarTypes.visit_type_vars 1rNrp)rrr8r9)rrrr<r*rrrrr r s:1rr Tr=cyr'rrproposed_type_rangesrr>s rrrs'*rcyr'rrs rrrsrc|rWt|dk(r|dj}t|}t|trV|j st|j tr,|jjj}t||}|Dcgc]}|j}}t|}t|tr||fStd|Dst||dr |t!fSt#||ds t!|fSt%j&|Dcgc]}|j(s |jc}} t+|| |} || fS||fScc}wcc}w)aTakes in the current type and a proposed type of an expression. Returns a 2-tuple: The first element is the proposed type, if the expression can be the proposed type. The second element is the type it would hold if it was not the proposed type, if any. UninhabitedType means unreachable. None means no new information can be inferred. If default is set it is returned instead.rzrc34K|]}|jywr'r;)r type_ranges rrz$conditional_types.. s *4J % % rTrr=)rrrrrrrr!rrrrrrr0rrr?rrr<r) rrrr>r enum_namerproposed_items proposed_typeproposed_precise_typeremaining_types rrrsh # $ ))!,11F$V,F&+.&&(Jv||T,J"OO0099 >|YW Returns true if this expression is the 'True' literal/keyword.z builtins.Truerrrryrrs rrBrB? s- a 1 \Z75K5\PQPWPW[\P\\rc`t|dxs!t|txr|jdk(S)z?Returns true if this expression is the 'False' literal/keyword.rrrrs rrrD s. a!1 2 ]jG6L6]QRQXQX\]Q]]rcDt|txr|jdk(S)z>Returns true if this expression is the 'None' literal/keyword.rrrrrs rrrI s a " Dqzz_'DDrcDt|txr|jdk(S)Nzbuiltins.NotImplementedrrs rrrN s a " Nqzz5N'NNrc~|jj}t|dk(xrt|dx}txr|jduxst |jxrZt|dx}t xrCt|jx}txr%|jduxst |jS)z Checks whether a function's body is 'return; yield' (the yield being added only to promote the function into a generator function). rrNrz)rrrrrrrlr)rrret_stmt expr_stmt yield_exprs rrrR s 99>>D D Q J 47*xJ 7 J ]]d " Dohmm&D J DG+y^ < J Y^^3zY ?  J __ $ H (H rct|}t|tr[|jjdvrB|j sytt|j dt s|j dSyt|trg}|jD]}t|trt|j}t|trt|j}t|tr|jjdk(sJ|j|j d|j|tdt|Dr t|Syt|t r`|j"jj$D]6}|jdk(st'|j"|j dcSJdy)aGet the item type of a builtin container. If 'tp' is not one of the built containers (these includes NamedTuple and TypedDict) or if the container is not parameterized (like List or List[Any]) return None. This function is used to narrow optional types in situations like this: x: Optional[int] if x in (1, 2, 3): x + 42 # OK Note: this is only OK for built-in containers, where we know the behavior of __contains__. )rr rrzbuiltins.frozensetz_collections_abc.dict_keysztyping.KeysViewNrr c3>K|]}t|t ywr')rr)rrs rrz$builtin_item_type.. sXr:b'**Xsztyping.Mappingz2No Mapping base class found for TypedDict fallback)rrrrrrerrrrrr"r-rLrrrrrr=)rnormalized_itemsrrrs rririb s  B"h 77    77obggaj97Cwwqz!0 / B "(( ,B"j)*2773h(89.x/C/CDHx2x}}7M7MQa7aa '' a(89 ''+ , X5EFV5WX X()9: :  B &KK$$(( LD}} 000dCHHKK L KJJu rcV||y|j}|Dchc] }t|}}|D]4}t||vstt||ts-||||<6|r;|D]6}|D]/}t|t|k(st ||||||<18|Scc}w)zCalculate what information we can learn from the truth of (e1 and e2) in terms of the information that we can learn from the truth of e1 and the truth of e2. N)copyr<rrrr@)m1m2rdrn2m2_keysn1s rrHrH s  zRZ WWYF*,-B|B-G-   7 *jB9PRY.ZBF2J  sA'cbt|}|j|}t|tsJ|Sr')TypeTransformVisitorrrrq)rr visitorrs rrr!s/"3'G ,,t C c8 $$ $ Jrc(eZdZdfd ZddZxZS)rc0t|||_yr')superr*r )r)r  __class__s rr*zTypeTransformVisitor.__init__'!s rc.t||jSr')r8r rns rrzTypeTransformVisitor.type+!s4**r)r dict[TypeVarId, Type]r8r9r)rrrr*r __classcell__rs@rrr&!s +rrct|j|j}t|j|j}||kS)zOCan a single call match both t and s, based just on positional argument counts?)maxrminmax_possible_positional_args)rryrmax_argss rr=r=/!s?1::qzz*H1113Q5S5S5UVH x rc"|jD]}|jjst||j|jij |jDcgc]}|jjr|!c}}n|j s|gSg}|jD]V}t|tr(|jr|j|j;|j|jgXg}tj|D]`}t|j|Dcic]\}}|j|}}}|jt||j gb|Scc}wcc}}w)zRExpand a generic callable using all combinations of type variables' values/bounds.r)rDrrr8r"rG is_genericrrrr-rrr) rr&r tvar_valuesrvariants combinationrtvar_maps rexpand_callable_variantsr6!sUkk 55==?Ar~~67EE&'kkH1HFA  <<>s K 3 dK (T[[   t{{ +    0 01 2 3 H ((+6N 47 [4QR[b%BEE5LRR Ax0>>>LMN O'I"Ss$F F =F c Jt||}t||}t|D]}}t|D]m}t|j|jr$t ||t ddddst ||t ddddsS|rt ||tddddrlyy)aSCheck if two overloaded signatures are unsafely overlapping or partially overlapping. We consider two functions 's' and 't' to be unsafely overlapping if three conditions hold: 1. s's parameters are partially overlapping with t's. i.e. there are calls that are valid for both signatures. 2. for these common calls, some of t's parameters types are wider that s's. 3. s's return type is NOT a subset of t's. Note that we use subset rather than subtype relationship in these checks because: * Overload selection happens at runtime, not statically. * This results in more lenient behavior. This can cause false negatives (e.g. if overloaded function returns an externally visible attribute with invariant type), but such situations are rare. In general, overloads in Python are generally unsafe, so we intentionally try to avoid giving non-actionable errors (see more details in comments below). Assumes that 'signature' appears earlier in the list of overload alternatives then 'other' and that their argument counts are overlapping. Fct|| Sr'is_subset_no_promoter1s rr4z;is_unsafe_overlapping_overload_signatures..!6J1a6P2PrT)r5check_args_covariantlyrr6allow_partial_overlapct|| Sr'rr1s rr4z;is_unsafe_overlapping_overload_signatures..!rr)r5rrr7r)detach_callablerrrr!is_overlapping_types_for_overload)rrclass_type_varsrb sig_variant other_variants rrBrBS!s< ?;I E? 3E 0 :' 5e<& M$K$8$8-:P:PQ&!?+0&+%P*.*!?+/&+%P*. '=.'+"'"&*(M& 'P rcZ|s|S|jt|j|zS)awEnsures that the callable's type variables are 'detached' and independent of the context. A callable normally keeps track of the type variables it uses within its 'variables' field. However, if the callable is from a method and that method is using a class type variable, the callable will not keep track of that type variable since it belongs to the class. r)rGrrD)rrs rrr!s.    tCMM':_'L  MMrc t||jDcic]}|jt|c}}t ||t ddScc}w)zCheck if the 'other' method can never be matched due to 'signature'. This can happen if signature's parameters are all strictly broader then other's parameters. Assumes that both signatures have overlapping argument counts. Tr9)r8rDrrrr)rrr exp_signatures rr>r>!sT 9K^K^_4DGG8>>_M "u4_c `sA cdt|tr%t|trt||tddSyt|trkt|tr[t |j t |j k(r0tdt|j |j DSy)z#Does t have wider arguments than s?Tr9c3:K|]\}}t||ywr')is_same_arg_prefix)rritemts rrz-is_more_general_arg_prefix..!s!9E&ue4sF) rrrrrrrrLrrrys rrlrl!s!\" a &)1 1TY]   A| $ a &177|s177|+ILQWWVWV]V]I^ rc .t||tddddS)NT)r5rr7rr)rrrs rrr!s$ !  #! rct|}tj|}d}t|trt |||}n't|t rt |j||}|d|fSd|fS)zDetermine if operator assignment on given value type is in-place, and the method name. For example, if operator is '+', return (True, '__iadd__') or (False, '__add__') depending on which method is supported by the type. NTF)rr op_methodsrr_find_inplace_methodrr)rrqrnexisting_methods rrr!sr # C  ! !( +FO#x .sFHE C '.s||VXN"_$$ &=rcr|tjvr%d|ddz}|jj|r|Sy)N__ir)rops_with_inplace_methodrrJ)rrnrqinplace_methods rrr!s;9444+ 99 ( ( 8! ! rct|}t|tr|xs| xr |jSt|try|j t  S)aIs an inferred type valid and needs no further refinement? Examples of invalid types include the None type (when we are not assigning None to a final lvalue) or List[]. When not doing strict Optional checking, all types containing None are invalid. When doing strict Optional checking, only None and types that are incompletely defined (i.e. contain UninhabitedType) are invalid. F)rrrrrrInvalidInferredTypes)rrPrr{rs rrr!sW"#&K+x(['7#7#ZG type, and any uninhabited types resulting from failed (ambiguous) type inference. c,t|tyr')rr*r)r)rs rr*zInvalidInferredTypes.__init__!"s &rc|jSr')rr s rvisit_uninhabited_typez+InvalidInferredTypes.visit_uninhabited_type$"s {{rcyrrr s rvisit_erased_typez&InvalidInferredTypes.visit_erased_type'"src6|jjSr')r is_meta_varr s rrz#InvalidInferredTypes.visit_type_var+"stt!!rc8|j|jSr') query_typesrr s rvisit_tuple_typez%InvalidInferredTypes.visit_tuple_type0"s((rrp)rrr8r!)rrr8r!)rrr8r!)rrr8r!) rrrr<r*rrrr rrs@rrr"s! '" )rrc eZdZdZddZddZy)rzRReplace all ambiguous Uninhabited types with Any (to avoid spurious extra errors).cP|jrttjS|Sr')rrrrdr s rrz&SetNothingToAny.visit_uninhabited_type8"s ;;9//0 0rc~|j|jDcgc]}|j|c}Scc}w)N)re)rGrer)r)rrs rvisit_type_alias_typez%SetNothingToAny.visit_type_alias_type="s/QVV$DQXXd^$DEE$Ds:N)rrr8r)rrr8r)rrrr<rr rrrrr5"s\ Frrct|tr |j}t|tr |jSt|t r |j Sy)z+Find out if a node describes a classmethod.N)rrgrrprrr<rs rrrC"sB$ "yy$ }}$""" rct|tr |j}t|tr |jSt|t r |j Sy)z6Find out if a node describes a static function method.N)rrgrrprrrr s rrrN"sB$ "yy$ ~~$### rTKeyTValuec8eZdZdZddZd dZd dZd dZd dZy) DisjointDictaiAn variation of the union-find algorithm/data structure where instead of keeping track of just disjoint sets, we keep track of disjoint dicts -- keep track of multiple Set[Key] -> Set[Value] mappings, where each mapping's keys are guaranteed to be disjoint. This data structure is currently used exclusively by 'group_comparison_operands' below to merge chains of '==' and 'is' comparisons when two or more chains use the same expression in best-case O(n), where n is the number of operands. Specifically, the `add_mapping()` function and `items()` functions will take on average O(k + v) and O(n) respectively, where k and v are the number of keys and values we're adding for a given chain. Note that k <= n and v <= n. We hit these average/best-case scenarios for most user code: e.g. when the user has just a single chain like 'a == b == c == d == ...' or multiple disjoint chains like 'a==b < c==d < e==f < ...'. (Note that a naive iterative merging would be O(n^2) for the latter case). In comparison, this data structure will make 'group_comparison_operands' have a worst-case runtime of O(n*log(n)): 'add_mapping()' and 'items()' are worst-case O(k*log(n) + v) and O(k*log(n)) respectively. This happens only in the rare case where the user keeps repeatedly making disjoint mappings before merging them in a way that persistently dodges the path compression optimization in '_lookup_root_id', which would end up constructing a single tree of height log_2(n). This makes root lookups no longer amoritized constant time when we finally call 'items()'. c.i|_i|_i|_yr') _key_to_id_id_to_parent_id_root_id_to_valuesrts rr*zDisjointDict.__init__x"s+- 13;=rcH|sy|Dcgc]}|j|}}|d}|j|}|j||ddD]O}||k(s||jvr||j|<|j|jj |Qycc}w)aAdds a 'Set[TKey] -> Set[TValue]' mapping. If there already exists a mapping containing one or more of the given keys, we merge the input mapping with the old one. Note that the given set of keys must be non-empty -- otherwise, nothing happens. Nrrz)_lookup_or_make_root_idr rr r2)r)r rr subtree_rootsnew_root root_values subtree_roots r add_mappingzDisjointDict.add_mapping"s  FJKs55c:K K #--h7 6")!"- JLx'.#s471:r)r) r r]rr-rr rrrsort)pairwise_comparisonsoperand_to_literal_hashoperators_to_grouprgroupsro last_operatorcurrent_indicescurrent_hashesrrq left_expr right_expr left_hash right_hash disjoint_dictr indicess rrfrf"s`Oa0a\^1C0aF0a<> $M #O"uN09:N0O/, ,Hi  $M M 9XM_=_"(//@W0XY}%11./R$M!eO UN AAE" ) )/33A6I$""9-044QU;J%"":.7/:  $ + +]F?I-*002 IMD' $ + +Xvg,G H II !!&=!> ##c1bsF.ct|}|rt|tsytdt |j |j gzD S)NFc3zK|]3}t|txr|jtjk(5ywr')rrr(rr)rs rrz$is_typed_callable..$#s6  1gI1==I4I4I#IIs9;)rrrrLrrr)rs rrara #sNA Jq,/!!++ "<= rcXt|}|syt|tr t| St|tr|j j d}|rt|tr@t|jj xst|jj St|j tr&td|j jDSt|j  Syt|trtd|jDSy)NTrc32K|]}t|ywr'rbrs rrz'is_untyped_decorator..9#sT$/5TrFc32K|]}t|ywr'r7 rs rrz'is_untyped_decorator..?#sD$'-Dr)rrrrarrrrgrbrrrr0r)rrns rrbrb*#s # C  C &$S))) C "$$Z0 &),+FKK,<,<=AUJJOOB&++z2T&++BSBSTTT,V[[999 C $D#))DDD rct|trt|jSt|tr |jSJdt |)NzUnexpected func type: )rrgrrror)rs rrrC#sE$ "## D( #~~7*4:,775rc@t|tr |jSt|tr|jjSt|t rL|j r@t|j dtr#|j djjSyNrF)rrprrgrrrrs rrrK#sr$ $ "yy$$$$)* ::*TZZ]I>::a=%%11 1 rct|trL|jr@t|jdtr#|jdjj Syr; )rrrrgrrr< s rrrV#sB$)* ::*TZZ]I>::a=%%11 1 rc|yt|sy|jd}t|tsJ|jjsy|j}|j &|j t|j try|j jd}tt|tryttt|j | S)zCheck if a node is a settable property with a non-trivial setter type. By non-trivial here we mean that it is known (i.e. definition was already type checked), it is not Any, and it is different from the property getter type. Frrz) rrrrgrrrrrrrrget_property_type)rr@rrs rrr]#s  |  %AJ j) ,, , >> . . ..C xx3??2j;6W//++A.K/+.8-ochh.GH+V VVrct|trt|jSt|tr"t|j djS|S)Nr)rrrrrrr*s rr? r? u#sC!\"qzz**!Z qwwqz2233 Hrc t||ddS)NT)ralways_covariantr0rOs rrr}#s dETD QQrc"t||dddS)NT)rprohibit_none_typevar_overlapoverlap_for_overloads)r?rOs rrr#s    &*"  rcL|jdxr|jd S)z-Check if node is private to class definition.rj)rendswith) node_names rrr#s&    % Fi.@.@.F*FFrc@t|}|duxrt|dk(S)Nrz)rr)rstrss rr~r~#s$ -c 2D t  .D Q.rcvt|dryt|trtd|jDSy)z.#sR$T?;RrF)rrrr0rrs rrr#s1o.#y!R RRR rc>t|tr |jS|S)zIf an expression is an AssignmentExpr, pull out the assignment target. We don't make any attempt to pull out all the targets in code like `x := (y := z)`. We could support narrowing those if that sort of code turns out to be common. )rr]r)r3s rrr#s !^$xx HrcRt|}|j||jS)zFind the highest line number of a potential assignment to variable within node. This supports local and global variables. Return -1 if no assignment was found. )VarAssignVisitorr last_line)rrrs rrr#s&q!GHHW   rcleZdZd dZd dZd dZdfd Zdfd ZddZddZ ddZ dd Z dd Z xZ S)rO c.d|_d|_||_y)NrF)rP rtvar_node)r)rs rr*zVarAssignVisitor.__init__#s  rcdd|_|jD]}|j|d|_yr)rtrorr)ryrs rrz&VarAssignVisitor.visit_assignment_stmt#s. )) B IIdO  rc|jr?|j|jur&t|j|j |_yyyr')rtrrS rrP rr)r3s rvisit_name_exprz VarAssignVisitor.visit_name_expr#s5 ;;166T]]2 8DN3;rcX|j}d|_t| |||_yr1)rtrrr)r3 old_lvaluers rrz"VarAssignVisitor.visit_member_expr#s'[[   !!$  rcX|j}d|_t| |||_yr1)rtrvisit_index_exprrZ s rr] z!VarAssignVisitor.visit_index_expr#s'[[    #  rcd|_|jD]}||j|d|_|jj|yr)rtrrrrU s rroz VarAssignVisitor.visit_with_stmt#sE (( B~ $    drcd|_|jj|d|_|jj||jr|jj|yyr)rtrrrrrs rr2zVarAssignVisitor.visit_for_stmt#sN  t   d ;; KK  t $ rcd|_|jj|d|_|jj|yr)rtrrrrW s rvisit_assignment_exprz&VarAssignVisitor.visit_assignment_expr#s0    trc|j|jj||j*d|_|jj|d|_yyr)rrrrtr)rs rvisit_as_patternz!VarAssignVisitor.visit_as_pattern#sK 99 II  T " 66 DK FFMM$ DK rcp|j*d|_|jj|d|_yyr)capturertrrc s rvisit_starred_patternz&VarAssignVisitor.visit_starred_pattern#s1 99 DK II  T "DK !r)rrr8r9rz)r3rr8r9)r3r~r8r9)r3rxr8r9rr)r3r]r8r9)rrr8r9)rrr8r9)rrrr*rrX rr] ror2ra rd rg rrs@rrO rO #s5  9! ! %   rrO c0tt|dkDS)arDo types have IntEnum/StrEnum types that are potentially overlapping with other types? If True, we shouldn't attempt type narrowing based on enum values, as it gets too ambiguous. For example, return True if there's an 'int' type together with an IntEnum literal. However, IntEnum together with a literal of the same IntEnum type is not ambiguous. rz)r_ambiguous_enum_variants)rs rrzrz#s '. /! 33rct}|D]k}t|}t|tr%|j t |j Dt|tr|jr&|j t |jg|jjrLtd|jjDr&|j|jj|jjr|jdt|tr'|j t |j gIt|t"r[|jdn|S)Nc38K|]}|jdvyw))z enum.IntEnumz enum.StrEnumN)rr^s rrz+_ambiguous_enum_variants..$s(FJ !AA(sz)r]rrrrri rrlast_known_valuerrr0rrrrrr)rrrs rri ri $s UF " A  a # MM2177; < 8 $!! 68J8J7KLMC(NOffjj(% 166??+VV^^ 9% ; ' MM2AJJ<@ A 8 $  JJy !)"* Mrc>|yt|}t|tSr1)rrr)ru lvalue_propers rrr)$s"#K0M m] 33rct|tr |j St|tr|jj St|t Sr')rrrrgrrpr s rrr0$sF$)*####$ "88'''' dG $$rr') rrrrrr9r>r!r8r) rrrrrrr>r!r8r) rrrrrrr>r!r8r)rrkrVrrWrr8r)rrNrrr8rNr)rrqr8r!)rrr8rru)rrrrrdr!r8r)rrrrr?r!r8r)rrrdr!r8r)rrr8r)rrkr8rg)rrr8rF)rrqr rr8rq)rrryrr8r!)rrr8zlist[CallableType]r|) rrrrrlist[TypeVarLikeType]rbr!r8r!)rrrrp r8r)rrrrr8r!)rrryrr8r!)rrrqrNr8ztuple[bool, str])rrrnrNrqrNr8rtr) rrrPrrr!r{r!r8r!)rSymbolNode | Noner8ry)r& z,Iterable[tuple[str, Expression, Expression]]r' zMapping[int, Key]r( rSr8zlist[tuple[str, list[int]]])rrr8r!)rrr8r!)rzFuncBase | Decoratorr8r!)rrr8r!)rrq r8zTypeGuard[OverloadedFuncDef])rrq r8r!)rrr8r)rPrrQrr8r!)rH rNr8r!r)rrr8r!)r3rkr8rk)rrrrr8rW)rrFr8r!)rrFr8rS)rurr8r!)rrq r8r!(zr< __future__rr collectionsrcollections.abcrrrrr AbstractSet contextlibr r rr r rrrrrrrrtyping_extensionsrr rmypy.checkexprrjrrrrrr mypy.binderrrrmypy.checker_sharedr r!r"mypy.checker_stater#mypy.checkmemberr$r%r&r'r(mypy.checkpatternr)mypy.constraintsr*mypy.erasetyper+r,r-mypy.errorcodesr.r/r0r1 mypy.errorsr2r3r4r5r6r7mypy.expandtyper8 mypy.literalsr9r:r;r< mypy.maptyper= mypy.meetr>r?r@mypy.message_registryrA mypy.messagesrBrCrDrErFrGrHrIrJmypy.mrorKrL mypy.nodesrMrNrOrPrQrRrSrTrUrVrWrXrYrZr[r\r]r^r_r`rarbrcrdrerfrgrhrirjrkrlrmrnrorprqrrrsrtrurvrwrxryrzr{r|r}r~rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrmypy.operatorsrrr mypy.optionsrr mypy.patternsrr mypy.pluginr mypy.pluginsrr mypy.scoper mypy.semanalrrrmypy.semanal_enumrrmypy.sharedparser mypy.stater mypy.subtypesrrrrrrrrrrmypy.traverserrrrmypy.treetransformr mypy.typeanalrrr mypy.typeopsrrrrrrrrrrrrrrrrrrrr mypy.typesrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrmypy.types_utilsrrrrmypy.typetraverserr mypy.typevarsrrr mypy.utilrr mypy.visitorrrrrr r r rrrrrr%r7r rrrrBrrrrrirHrrjr0rPrBrrr=rrBrr>rlrrrrrrrrr r r rfrarbrrrrr? rrrr~rrrrO rzri rrrrrr s"#UU0   ANNEEMM,-)XXSS(SS2SS.   -TTTTTTTTTTTTTTTTTTTTTTj?>53:OO<1   YX/bb,&&&&&&&&&&&&&&&&&&&&Ncbb33PPP**$$ CL5!"!$W.?%JK*K*/CT0T*UZU%:%%j%$tJ$4566 z (Nz+d#%9Nzbt1 * )- **0** "& * % * * )- 0 "&     7% )- 7%7%07%7% "& 7% % 7%t6 6 +66A66$] ^ E O  6r<6@E$,,$,8<$,$,N  +++ B LL L+L L  L^ N.$ &Z_2 22262RV2 26)=)6 Fn Fv  \74<(\~a$Fa$.a$!a$! a$H28W0 R"G /   > '> B4$44%r