o tBhgv @szUdZddlmZddlZddlmZddlmZmZm Z m Z m Z m Z m Z ddlmZmZmZddlZddlmZddlmZmZmZmZmZmZmZddlm Z m!Z!m"Z"dd l#m$Z$m%Z%dd l&m'Z'dd l(m)Z)m*Z*m+Z+dd l,m-Z-m.Z.dd l/m0Z0m1Z1m2Z2ddl3m4Z4m5Z5m6Z6ddl7m8Z8ddl9m:Z:ddl;mm?Z?ddl@mAZAddlBmCZCmDZDmEZEmFZFmGZGmHZHmIZImJZJmKZKmLZLmMZMmNZNmOZOmPZPmQZQmRZRmSZSmTZTmUZUmVZVmWZWmXZXmYZYmZZZm[Z[m\Z\m]Z]m^Z^m_Z_m`Z`maZambZbmcZcmdZdmeZemfZfmgZgmhZhmiZimjZjmkZkmlZlmmZmmnZnmoZompZpmqZqmrZrmsZsmtZtmuZumvZvmwZwmZmxZxmyZymzZzm{Z{m|Z|m}Z}m~Z~mZmZmZddlmZmZmZmZmZddlmZddlmZddlmZmZmZmZddlmZddlmZmZmZmZmZddlmZmZmZmZmZmZmZmZmZmZmZmZddlmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZddlmZddlmZddlmZdd lmZeeeeJeeeee eeTeTg dfZd!ed"<d#Zd$ed%<gd&Zd$ed'<Gd(d)d)eՃZdd.d/Zdd3d4ZGd5d6d6eՃZGd7d8d8eeZdddd?d?ejeZdd@dAZddBdCZddDdEZddLdMZddQdRZGdSdTdTejeZGdUdVdVejeZddXdYZGdZd[d[ejeZdd\d]ZGd^d_d_ejeZddbdcZddkdlZddndoZddsdtZddvdwZddzd{Zdd|d}ZdddZdddZdddZdS)zGExpression type checker. This file is conceptually part of TypeChecker.) annotationsN)contextmanager)CallableClassVarIteratorListOptionalSequencecast)Final TypeAliasoverload) applytype erasetypejoinmessage_registrynodes operatorstypes)ArgTypeExpandermap_actuals_to_formalsmap_formals_to_actuals)analyze_member_accesstype_object_type)StringFormatterChecker) erase_type!remove_instance_last_known_valuesreplace_meta_vars) ErrorWatcherreport_internal_error) expand_typeexpand_type_by_instancefreshen_function_type_vars)ArgumentInferContextinfer_function_type_argumentsinfer_type_arguments)literal)map_instance_to_supertype)is_overlapping_typesnarrow_declared_type) ErrorMessage)MessageBuilder)@ ARG_NAMEDARG_POSARG_STAR ARG_STAR2IMPLICITLY_ABSTRACT LITERAL_TYPE REVEAL_TYPEArgKindAssertTypeExprAssignmentExpr AwaitExpr BytesExprCallExprCastExprComparisonExpr ComplexExprConditionalExprContext DecoratorDictExprDictionaryComprehension EllipsisExpr EnumCallExpr Expression FloatExprFuncDef GeneratorExpr IndexExprIntExpr LambdaExprListComprehensionListExpr MemberExprMypyFileNamedTupleExprNameExpr NewTypeExprOpExprOverloadedFuncDef ParamSpecExprPlaceholderNode PromoteExprRefExpr RevealExprSetComprehensionSetExpr SliceExprStarExprStrExpr SuperExpr SymbolNodeTempNode TupleExprr TypeAliasExprTypeApplication TypedDictExprTypeInfo TypeVarExprTypeVarTupleExpr UnaryExprVar YieldExpr YieldFromExpr)FunctionContextFunctionSigContext MethodContextMethodSigContextPlugin) ENUM_BASES)state) is_equivalent is_same_type is_subtypenon_method_protocol_members)has_await_expression)check_for_explicit_anyexpand_type_aliashas_any_from_unimported_typemake_optional_type set_any_tvars) callable_typecustom_special_methoderase_to_union_or_bound false_only function_typeis_literal_type_likemake_simplified_unionsimple_literal_type true_onlytry_expanding_sum_type_to_uniontry_getting_str_literalstuple_fallback)!LITERAL_TYPE_NAMESTUPLE_LIKE_INSTANCE_NAMESAnyType CallableType DeletedType ErasedType FunctionLikeInstance LiteralType LiteralValueNoneType OverloadedParamSpecFlavor ParamSpecType PartialType ProperTypeStarType TupleTypeType TypedDictType TypeOfAnyTypeType TypeVarTypeUninhabitedType UnionTypeflatten_nested_unionsget_proper_typeget_proper_typeshas_recursive_typesis_generic_instanceis_named_instance is_optionalremove_optional) TypeState) fill_typevars)split_module_names)ExpressionVisitor _TypeAlias ArgCheckerr MAX_UNIONS) builtins.setzbuiltins.frozensetztyping.KeysViewztyping.ItemsViewzbuiltins._dict_keyszbuiltins._dict_itemsz_collections_abc.dict_keysz_collections_abc.dict_itemsOVERLAPPING_TYPES_ALLOWLISTc@eZdZdZdS) TooManyUnionszyIndicates that we need to stop splitting unions in an attempt to match an overload in order to save performance. N__name__ __module__ __qualname____doc__rre/var/www/html/riverr-enterprise-integrations-main/venv/lib/python3.10/site-packages/mypy/checkexpr.pyrrtrreturnboolcCs(t|tpt|totdd|jDS)Ncss|] }tt|VqdSN)allow_fast_container_literalr.0itrrr z/allow_fast_container_literal..) isinstancerrallitemsrrrrrs  rexprrVset[str]cCst}t|jts|jdurt|jtr|jdur||jt|tr[t|jto-|jj}t|jt r@| t |jj  |S|jdurXd|jvrX|sX||j ddd |St|trmt|jtrj|j}n |Stdt|t|jts|jdus|S)zRecursively extracts all module references from a reference expression. Note that currently, the only two subclasses of RefExpr are NameExpr and MemberExpr.N.rzUnknown RefExpr subclass: )setrnoderMfullnameaddrOrhis_suppressed_importrdupdater module_namersplitrLrrVAssertionErrortype)routputrrrrextract_refexpr_namess,    rc@r)FinishedzDRaised if we can terminate overload argument check early (no match).Nrrrrrrrrc@s eZdZUdZded<ded<ded<ded <d ed <d ed <dddZdddZdddZddddZdd#d$Z ddd'd(Z dd+d,Z ddd-d.Z dd/d0Z d d5d6Zd!d8d9Zd"dd?Zdd@dAZd#dLdMZd$dQdRZd%dSdTZd&dUdVZd'dZd[Zd(d\d]Zd)d_d`Zd*dddeZdfgdgdhgdiZdjedk<dldmgidndogidndogidndpdmgidqZdreds<ddtduZd+dxdyZd,d|d}Zd-ddZ d.ddZ!d/ddZ"d0ddZ# d1d2ddZ$ d3d4ddZ%d5ddZ& d6d7ddZ'd8ddZ(d9ddZ)d:ddZ*d;ddZ+e,dddZ/d?ddZ0d@ddZ1dAddZ2dBddńZ3dCddȄZ4 d1dDdd΄Z5dEddӄZ6dFddՄZ7 d1dGddلZ8dHddZ9dIddZ:dJddZ;dKddZ<dLddZ= dMdNddZ>dOddZ?e,dPddZ@dQddZAdRddZB ddSddZCdTddZDdUd d ZEddVd d ZFdVddZGdWddZHdXddZIdYddZJdZddZKd[d d!ZLd\d#d$ZMd]d&d'ZNd^d)d*ZOd_d,d-ZPd`d/d0ZQdad2d3ZRdbd5d6ZSdcd7d8ZT d3ddd:d;ZU d3ded>d?ZV d3dfd@dAZWdgdCdDZXdhdJdKZY ddidNdOZZdjdPdQZ[dadRdSZ\dkdUdVZ]dldXdYZ^dmd[d\Z_dmd]d^Z` d3dnd`daZadodddeZbdpdhdiZcdqdjdkZddrdmdnZedsdpdqZfdtdsdtZgdudvdwZhdvdydzZidwd}d~ZjdxddZkdddyddZldzddZmd{ddZnd|ddZod}ddZpd~ddZqdddZrdddZsdddZtdddZudddZvdddZwdddZxdddZydddZzdddZ{dddZ|dddZ} d3ddd„Z~ddĐdńZddǐdȄZdddʐd˄Z dddΐdτZ   dddҐdӄZdd֐dׄZdOdؐdلZdOdڐdۄZddܐd݄Zddސd߄ZdddZddddZ ddddZddddZdddZdddZdddZdddZdddZdddZdddZdddZdddZdd d Zdd dZdddZedddZedddZ ddddZdS(ExpressionCheckerz^Expression type checker. This class works closely together with checker.TypeChecker. mypy.checker.TypeCheckerchkr+msgzlist[Type | None] type_contextzdict[Expression, ProperType] resolved_typerstrfrm_checkerropluginrNonecCsB||_||_||_dg|_i|_t||j|j|_i|_d|_dS)z%Construct an expression type checker.NF) rrrrtype_overridesrrr is_callee)selfrrrrrr__init__s zExpressionChecker.__init__cCs i|_dSr)rrrrrreset zExpressionChecker.reseterOrcCs(|jjt|||}|||S)z_Type check a name expression. It can be of any kind: local, member or global. )r module_refsrranalyze_ref_exprnarrow_type_from_binder)rrresultrrrvisit_name_exprs  z!ExpressionChecker.visit_name_exprFrVlvaluercCsd}|j}t|tr|jrttjSt|tr,|||}t|t r+|j ||||}nt|t r:t ||d}nt|trH|jdurH|j}nt|tr|jrV||}nt||j}t|trqt|jtrq|j|j_|j|j_tt|jdtrt|}nZt|trz|d}WnMt y|d}Yn@wt|t!r||j"|}n2t|t#r|j$||j%||j&p|d}nt|t't(fr|)}nt|t*rJd|j+dttj,}|dusJ|S) Nbuiltins.functionztypes.ModuleTypebuiltins.objectalias_definitionFzPlaceholderNode z leaked to checker)-rrrOis_special_formrr special_formrhanalyze_var_refrrhandle_partial_var_typerEr named_typerRrrdtypeddict_typetypeddict_callablerrret_typerlinecolumnrrrrerase_typevarsrMKeyErrorr>varr alias_type_in_runtime_contextno_argsis_alias_rvaluererS object_typerTr from_error)rrrrrrrrr$sX                    z"ExpressionChecker.analyze_ref_exprrrhcontextr=cCs~|jr*t|j}t|tr'|r|jdur|jS|jdvr'||jdkdS|jS|js:|j r:|j |j|t t jS)N>TrueFalser  builtins.bool)rrrris_literal_contextlast_known_valuenameinfer_literal_expr_typeis_readyrin_checked_functionhandle_cannot_determine_typerrr)rrr var_typerrrris    z!ExpressionChecker.analyze_var_refr8allow_none_returncCsF|jrt|jtr|jjs||||j|jdS|j||dS)zType check a call expression.rr)analyzedrrNis_typedvisit_call_expr_inneracceptr)rrrrrrvisit_call_exprxs  z!ExpressionChecker.visit_call_exprbaserCcCsHt|tsdSt|jtr|jjdurdSt|jto#tt|jjtS)NFT) rrVrrdrr rtargetr)rrrrrrefers_to_typeddicts  z%ExpressionChecker.refers_to_typeddictc sHjstjtr;jjr;tjjdd}t|tr;t|j}t|t s.J |j j j |Stjtrjjdvrtj dkrtjj dD]}d}t|trsz j|j}Wn tyrYnwt|rjjjdqW|rt|jtrtt|jjtrjjjdqWt|trt|jtt fst|tr|rt|jtr|jj!sˆj"t|t#rt|jt$r|jj%r܈jjjdqW|jj&rjjjd qW'd}tjt(r/t)j j jj jj fd d fd d t*tjj D}t|jj jj +,dd}tjj|ddd} jj-j.rXj/rXt| trX| j0rXj1| d} d} d} tjt#rjj2} tjjtrtjjj} t| t3r| j4j2} | durtjt5rj6jj7rjj} j8jj7} 9| | | | }tjt#rtj dkrӈjj2dvrLj:jj2dkrӈ;tjt5rjjdkr<t|}t|t=rt>|j?}t|t@r|jAsjjBC|s"t|tDr"Ejr"jjF| ttGjHS|S)NTr)r issubclassrLiteralAny TypedDictNewTypecsj|Srrargsirrrrz9ExpressionChecker.visit_call_expr_inner..cs*g|]}tfdd|DqS)csg|] }j|qSrr')rjr+rr szFExpressionChecker.visit_call_expr_inner...)rjoin_type_listrr*rformal_to_actualrrrr/sz;ExpressionChecker.visit_call_expr_inner..r)rfallback)always_allow_anyr)zbuiltins.isinstancebuiltins.issubclassr6format)IrcalleerrGrrrrrrcheck_typeddict_call arg_kinds arg_namesr(rOrlenmypycheckerflattenrlookup_qualifiedris_expr_literal_typercannot_use_function_with_typerr rrrrbrartype_arguments_not_allowedrVrdr is_newtypetry_infer_partial_typerIrrangerroptionsdisallow_untyped_callsrimplicituntyped_function_callrrrrLhas_typer lookup_type check_call_expr_with_callee_typecheck_runtime_protocol_testcheck_protocol_issubclasscheck_str_format_callrrrr ambiguousbinder unreachableralways_returns_nonedoes_not_return_valuerr )rrrrrtyprr arg_types callee_typermemberrrrrr2rrs                          z'ExpressionChecker.visit_call_expr_innercCst|jtsJd}t|jjtr|jjj}n |j|jjr7t|j |jj}t|t r7t|jt r7|j}|durD|j ||dSdS)z>More precise type checking for str.format() calls on literals.N)rr8rLrr\valuerrKtry_getting_literalrLrstrrrP)rr format_valuebase_typrrrrPs z'ExpressionChecker.check_str_format_callr method_namer\ str | NonecCst|}t|tr|rt|j}nt|tr|j}d}t|tr'|jj }n#t|t t fr?|j j |}|dur<|j nd}n t|trJt|jj }|durU|d|SdS)zConvert a method name to a fully qualified name, based on the type of the object that it is invoked on. Return `None` if the name of `object_type` cannot be determined. Nr)rrr is_type_objrritemrrrrrr4get_containing_type_inforr)rrr_ type_nameinforrrmethod_fullname!s       z!ExpressionChecker.method_fullnamercCst|tr ||jr dSt|trT|jdurTt|j|j}t|t r)|j }nt|t rB| rBt|j }t|t r@|j }ndSdS||j}|rT||jrTdSdS)zPCheck if `node` refers to something explicitly annotated as only returning None.TNF)rrVdefn_returns_nonerrLrrrLrrrrrargetr)rrrVrersymrrrrT=s"      z%ExpressionChecker.always_returns_nonedefnSymbolNode | Nonecst|trt|jtott|jjtSt|tr%tfdd|j DSt|t rVt|j}|j sAt|trAtt|jtrAdSt|t rV|j d}|rV|jrVdSdS)z'Check if `defn` can _only_ return None.c3|]}|VqdSr)rgrrbrrrrZz6ExpressionChecker.defn_returns_none..T__call__F)rrErrrrrrRrrrh is_inferredrrhrgr)rrjrVrirrrrgSs(       z#ExpressionChecker.defn_returns_nonecCsbtj|jdD]%}t|j|}t|tr.| r.| j r.| j s.|j tj|q dSNr)r=r>r?r(rrrLrrra type_object is_protocolruntime_protocolfailrRUNTIME_PROTOCOL_EXPECTED)rrrtprrrrNisz-ExpressionChecker.check_runtime_protocol_testcCsntj|jdD]+}t|j|}t|tr4| r4| j r4t | }|r4|jj | ||q dSrq)r=r>r?r(rrrLrrrarrrsrurreport_non_method_protocol)rrrrw attr_membersrrrrOts z+ExpressionChecker.check_protocol_issubclassr8rr: list[ArgKind]r;Sequence[str | None]r(list[Expression] orig_callee Type | Nonec Cst|dkr0tdd|Dr0tdd|DsJttt|}|}||tt||||St|dkra|dtkra|d} t | t rM| || ||St | t rat | j t ra| || j ||St|dkro||i||S|jtj|ttjS)NrcSsg|]}|tkqSr)r,)rakrrrr/z:ExpressionChecker.check_typeddict_call..cs|]}|duVqdSrr)rarg_namerrrrz9ExpressionChecker.check_typeddict_call..r)r<rr rr\ check_typeddict_call_with_kwargsdictzipr-rr?check_typeddict_call_with_dictr8rrrurINVALID_TYPEDDICT_ARGSrrr ) rr8r:r;r(r r} item_names item_args unique_argrrrr9|s*     z&ExpressionChecker.check_typeddict_callkwargsr?dict[str, Expression] | Nonec Csdd|jD}g}|jD]6\}}d}|r+||}t||}|r+t|dkr+|d}|dur>|p2|} |jtj| dS||q t t ||S)NcSg|]}|dqS)rrrmrrrr/rz?ExpressionChecker.validate_typeddict_kwargs..rr) rrrr<rrur$TYPEDDICT_KEY_MUST_BE_STRING_LITERALappendrr) rrrritem_name_expritem_arg literal_valuekey_typevalues key_contextrrrvalidate_typeddict_kwargss   z+ExpressionChecker.validate_typeddict_kwargscCsD|j|d}|dur |jt|kot|jkSSdS)NrF)r required_keysrkeysr)rr8rr validated_kwargsrrrmatch_typeddict_call_with_dicts ,z0ExpressionChecker.match_typeddict_call_with_dictcCs0|j|d}|dur|j||||dSttjS)Nr)rr r})rrrrr )rr8rr r}rrrrrs  z0ExpressionChecker.check_typeddict_call_with_dictrerdrcCsx|jdusJ|jj}t|trt|tsJt|j}tj gt |}t|j }t ||||| d|jjdS)aConstruct a reasonable type for a TypedDict type in runtime context. If it appears as a callee, it will be special-cased anyway, e.g. it is also allowed to accept a single positional argument if it is a dict literal. Note it is not safe to move this to type_object_type() since it will crash on plugin-generated TypedDicts, that may not have the special_alias. N builtins.type variables) special_aliasrrrrlistrrr3r,r<rrrrj type_vars)rrerexpected_typeskindsnamesrrrrs z$ExpressionChecker.typeddict_callablecCs8tt|jtjgt|jt|j||dSNr) rrrrr3r,r<rr)rr8rrrtypeddict_callable_from_contexts  z1ExpressionChecker.typeddict_callable_from_contextdict[str, Expression]c sjtkrtjks7nfddjD}}|jj|t||dttj St |}t |t rC|}nj jjdurR|j j}n|}|j9|j$||ttjgt|tddd\}} Wdn1swYWdn1swYt |} t | ts} | jD]\} } | vr̈| } |jj| | | tjd| ddtjdq|S)Ncs&g|]}|jvs|vr|qSr)rr)rkeyr8rrrr/s zFExpressionChecker.check_typeddict_call_with_kwargs..) expected_keys actual_keysr zTypedDict item "" expression) lvalue_typervaluer r lvalue_name rvalue_namecode) rrrrrunexpected_typeddict_keysrrrr rrrr4rrrr filter_errorsrlocal_type_mapcheck_callable_callrr3r,r<rcheck_simple_assignmentrINCOMPATIBLE_TYPEScodesTYPEDDICT_ITEM)rr8rr r}rr infer_callee orig_ret_type_r item_nameitem_expected_type item_valuerrrrs\*           z2ExpressionChecker.check_typeddict_call_with_kwargsrrL Var | NonecCsxt|jtrt|jjtr|jjjsdS|jj}|r"|j |j vr$dS|j |j }t|jtr:t|jj t r:|jSdS)zGet variable node for a partial self attribute. If the expression is not a self attribute, or attribute is not variable, or variable is not partial, return None. N) rrrOrrhis_selfrscopeenclosing_classrrrr)rrrerirrrget_partial_self_var+s    z&ExpressionChecker.get_partial_self_varrrdiscard) builtins.listrzClassVar[dict[str, list[str]]]rextendrr builtins.dictr)rrzcollections.OrderedDictrz)ClassVar[dict[str, dict[str, list[str]]]]container_argsc CsXt|jtsdS|j}t|jtr7||j}|durdS|\}}|||j|}|dur5||_||=dSdSt|jt rt|jj tr|jj durLdS|jj }|jj }||}|dur_dS|\}}t |j} | dusq| jdursdS|||j|} | dur||} tj| r| jdusJ| jj} |j| | | g|_||=dSdSdSdSdS)z-Try to make partial type precise from a call.N)rr8rLrrVget_partial_var&try_infer_partial_value_type_from_callrrrGrrindexget_partial_instance_type value_typerr=r>is_valid_inferred_typerrnamed_generic_type) rrr8retr partial_typesrVrr partial_typerrtypenamerrrrEMsH          z(ExpressionChecker.try_infer_partial_typeref%tuple[Var, dict[Var, Context]] | NonecCsP|j}|durt|tr||}t|tsdS|j|}|dur$dS||fSr)rrrLrrhrfind_partial_types)rrrrrrrrts   z!ExpressionChecker.get_partial_var methodnameInstance | Nonec Cs@|jjrdSt|j}|durdS|jr|jjj}n |jdus!J|jj}||jvrO||j|vrO|jtgkrO| |j d}t j |rM|j||gSdS||jvr||j|vr|jtgkrt| |j d}t|tr|jj}||j||vrtdd|j Dr|j|t|j SdSt|tr|j|SdS)zCTry to make partial type precise from a call such as 'x.append(y)'.Nrcss|] }tj|VqdSr)r=r>r)r item_typerrrrs  zKExpressionChecker.try_infer_partial_value_type_from_call..)rcurrent_node_deferredrrrrrr:r-rr(r=r>rrrrrrrrrr) rrrrrrrarg_type arg_typenamerrrrs>         z8ExpressionChecker.try_infer_partial_value_type_from_callrW list[Type]Sequence[str | None] | Noner3list[list[int]]rc  Cs<t|j} ddt| D} ddt| D} ddt| D} ddt| D}t|D]/\}}|D](}| |||| ||||rR| |||||||q3q-|dur}|j|}|dusmJ|t| ||j| |j | | |j S|j |}|dusJt |}|t || ||j| |j | | |j S)aUse special case logic to infer the return type of a specific named function/method. Caller must ensure that a plugin hook exists. There are two different cases: - If object_type is None, the caller must ensure that a function hook exists for fullname. - If object_type is not None, the caller must ensure that a method hook exists for fullname. Return the inferred return type. cSg|]}gqSrrrrrrrr/r-z;ExpressionChecker.apply_function_plugin..cSrrrrrrrr/r-cSrrrrrrrr/r-cSrrrrrrrr/r-N)r<rWrF enumeraterrget_function_hookrkr;rrget_method_hookrrm)rr8r:rWr;r3r(rrr  num_formalsformal_arg_typesformal_arg_exprsformal_arg_namesformal_arg_kindsformalactualsactualcallbackmethod_callbackrrrapply_function_pluginsX     z'ExpressionChecker.apply_function_pluginrhook>Callable[[list[list[Expression]], CallableType], FunctionLike]cst|tr>t|j}t|||j|jfdd}ddt|D}t|D]\} } | D] } || | q,q&|||St|t sEJg} |j D]}  | |||}t|ts\J| |qJt | S)z@Helper to apply a signature hook for either a function or methodc|Srrr)r(rrrr,z8ExpressionChecker.apply_signature_hook..cSrrrrrrrr/r-z:ExpressionChecker.apply_signature_hook..) rrr<r:rr;rFrrrrapply_signature_hook)rr8r(r:r;rrr3rrrrrrbadjustedrrrrs,     z&ExpressionChecker.apply_signature_hooksignature_hook,Callable[[FunctionSigContext], FunctionLike]c s||||fddS)zKApply a plugin hook that may infer a more precise signature for a function.cst||jSr)rlrr(sigr rrrrr, rzAExpressionChecker.apply_function_signature_hook..)r)rr8r(r:r r;rrrrapply_function_signature_hooks z/ExpressionChecker.apply_function_signature_hook*Callable[[MethodSigContext], FunctionLike]c s(t|||||fddS)zIApply a plugin hook that may infer a more precise signature for a method.cst||jSr)rnrrr  pobject_typerrrrr,5sz?ExpressionChecker.apply_method_signature_hook..)rr)rr8r(r:r r;rrrrrapply_method_signature_hook#s z-ExpressionChecker.apply_method_signature_hookN callable_namec Cstt|}|dur8t|tr8|dur&|j|}|r$||||||||S|S|j|} | r8||||||| S|S)a6Attempt to determine a more accurate signature for a method call. This is done by looking up and applying a method signature hook (if one exists for the given method name). If no matching method signature hook is found, callee is returned unmodified. The same happens if the arguments refer to a non-method callable (this is allowed so that the code calling transform_callee_type needs to perform fewer boilerplate checks). Note: this method is *not* called automatically as part of check_call, because in some cases check_call is called multiple times while checking a single call (for example when dealing with overloads). Instead, this method needs to be called explicitly (if appropriate) before the signature is passed to check_call. N)rrrrget_method_signature_hookrget_function_signature_hookr) rrr8r(r:r r;rmethod_sig_hookfunction_sig_hookrrrtransform_callee_type;s   z'ExpressionChecker.transform_callee_typerXrYc Cs|dur|dur|dusJ|||}t|}|r)||||j|j||j|}n|dur9t|tr9||||S|j ||j|j||j|j ||d\}}t|}t|j t ret|t re|j dure|j |j _ |S)a?Type check call expression. The callee_type should be used as the type of callee expression. In particular, in case of a union type this can be a particular item of the union, so that we can apply plugin hooks to each item. The 'member', 'callable_name' and 'object_type' are only used to call plugin hooks. If 'callable_name' is None but 'member' is not None (member call), try constructing 'callable_name' using 'object_type' (the base type on which the method is called), for example 'typing.Mapping.get'. N) callable_noderr)rfrr r(r:r;rrcheck_union_call_expr check_callr8rVr type_guard)rrXrrrrYr proper_calleerrrrMds8      z2ExpressionChecker.check_call_expr_with_callee_typerc Csg}|D]O}|jt|||ddd|j||j||d }Wdn1s+wY|j|j|dd}|dur>q|||}|rH|nd} | | |||| qt |S)zH "Type check calling a member expression where the base type is a union.F) original_typerin_literal_context self_typeNT)skip_non_overlapping) relevant_itemsrrrrrrr8rfrrMr) rrrrYresrVrbnarrowedritem_object_typerrrr s4    z'ExpressionChecker.check_union_call_exprr Expression | Nonetuple[Type, Type]c Cst|}t|tr|||||||||St|tr%||||||||St|ts/|js5| ||St|t rC| |||||St|t rt d||ddd|j||j|d } |jjd}||| |||||} || |||||||} |r|j||| St|tr||j|||||St|tr||j|} || |||||St|tr|t||||||||S|j||ttjfS)aType check a call. Also infer type arguments if the callee is a generic function. Return (result type, inferred callee type). Arguments: callee: type of the called value args: actual argument expressions arg_kinds: contains nodes.ARG_* constant for each argument in args describing whether the argument is positional, *arg, etc. context: current expression context, used for inference. arg_names: names of arguments (optional) callable_node: associate the inferred callable type to this node, if specified callable_name: Fully-qualified name of the function/method to call, or None if unavailable (examples: 'builtins.open', 'typing.Mapping.get') object_type: If callable_name refers to a method, the type of the object on which the method is being called roFT) is_lvalueis_super is_operatorrrrrz .__call__)rrrrrcheck_overload_callrrrcheck_any_type_callrcheck_union_callrrrrrrr r  store_typer upper_boundranalyze_type_type_calleerbrr not_callablerr ) rr8r(r:r r;r rr call_functionrrbrrrr s           zExpressionChecker.check_callc  s$|}|dur|jr|j}t|j} |r t| tr | jj}t|t r/|jt vr/|j|fS|rJ| j rJ|j sJjtj| j|n;|r| jr|j s| js| } i} | jD]\} } | tkru| | | | <qdd| | <qdj| j| |t|||j|jfdd}|rtdd|jD}t |}!||}"||||}|rt|||j|jfdd}|#}|dur|t$t%gkr&d}&d }t|t'rt|t'r|j(t)j*kr|j(t)j+kr|j,|j,kr |j,krnn|j|fS-|||}.||||||||j/||||||d |rUt0|d krUt1|j2d rU|j3t45|dd }|r_j6|||r|durnj78|sz|durj79|r:|||||||| }|j3|d }|j|fS) zxType check a call that targets a callable value. See the docstring of check_call for more information. NFcrrrr)rrrr,[rz7ExpressionChecker.check_callable_call..cs|]}t|tVqdSr)rr)rvrrrr_rnz8ExpressionChecker.check_callable_call..crrrr)rrrr,nrrrrrr);with_unpacked_kwargsrrrrarrrrrVrprrrsfrom_type_typerrurCANNOT_INSTANTIATE_PROTOCOLr7 is_abstractfallback_to_anyabstract_attributesr0can_return_noner!cannot_instantiate_abstract_classrr:r; is_genericanyrr"+infer_function_type_arguments_using_contextr$ param_specr.r/rrflavorrARGSKWARGSidinfer_arg_types_in_contextcheck_argument_countcheck_argument_typesr<rrr copy_modifiedrmake_normalizedr rrrr)rr8r(r:r r;r rrrrr. attr_nameabstract_statusr3 need_refreshr4arg1arg2rW new_ret_typerrrrs        "   z%ExpressionChecker.check_callable_callrr>cCstjsdS|jD]<}|j|}|durq|j}t|tr |j}t|t r(|j }t|t rD|j durDt|j t s:Jtt|j jSqdS)zIs the given attribute a method with a None-compatible return type? Overloads are only checked if there is an implementation. FN)rqstrict_optionalmrorrhrrrRimplr>funcrErrrtrr)rrr>rsymnoderrrrr/s"      z!ExpressionChecker.can_return_nonerbrcs>ttr ttjdSttr7tjj}t|tr#|j dd}t t |}t|tr5|j gd}|Stt rLt fdd DjSttr~t j}t |}t|trk|j d}|St|tr|tfdd|jD}|Sttrtjjd krtSjttjS) zzAnalyze the callee X in X(...) where X is Type[item]. Return a Y that we can pass to check_call(Y, ...).  source_anyT)r*rcsg|] }t|qSr)r"rrrwr rrrr/z>ExpressionChecker.analyze_type_type_callee..r(csg|]}|jdqS)r(r<rc)rbrrr/sbuiltins.tuple)rrrfrom_another_anyrrrrrr<rr!rrrrr"r!rrrrrrunsupported_type_typer )rrbr rexpandedr8r)r rbrrr"s<             z*ExpressionChecker.analyze_type_type_calleecCs<g}|D]}||}t|r|tq||q|S)zInfer argument expression types in an empty context. In short, we basically recurse on each argument without considering in what context the argument was called. )rhas_erased_componentrr)rr(rargrrrr infer_arg_types_in_empty_contexts  z2ExpressionChecker.infer_arg_types_in_empty_contextIterator[None]ccs2tj}t|r dt_z dVW|t_dS|t_wNT)r infer_unionsr)rroldrrr allow_unionsszExpressionChecker.allow_unionsc Csdgt|}t|D]4\}}|D]-}||s>||j|||||j|||<Wdn1s9wYqq t|D]\}} | sS|||||<qDtdd|Ds_Jttt |S)aInfer argument expression types using a callable type as context. For example, if callee argument 2 has type List[int], infer the argument expression with List[int] type context. Returns the inferred types of *actual arguments*. NcsrrrrKrrrr*rz?ExpressionChecker.infer_arg_types_in_context..) r<ris_starr\rWrrr rr) rr8r(r:r3rr*rairrrrr9s z,ExpressionChecker.infer_arg_types_in_contextcallable error_contextc Cs|jd}|s |St|t}|j}t|r"t|r"t|}t|}t|tr3t|s3t |s3| St | ||}g}|D]}t |sIt|rO|dq?||q?|j|||ddS)a Unify callable return type to type context to infer type vars. For example, if the return type is set[t] where 't' is a type variable of callable, and if the context is set[int], return callable modified by substituting 't' with 'int'. rNTskip_unsatisfied)rrrrrrrrrrr<r% type_var_idshas_uninhabited_componentrUrapply_generic_arguments) rr_r`ctx erased_ctxrr(new_argsrVrrrr3-s(     z=ExpressionChecker.infer_function_type_arguments_using_contextc Csh|jr|j|||||}Wdn1swY||j|t|}g}t|D]\} } || dkrB| dq2| | q2t ||||| |jd} d|vrg| ||||| |\}} |j dkrt| dkrt|vszt|vrt| d} t| ttfr|d| d<n| rt|d| s|jtj|n ttjgt|j} ||| |S)zInfer the type arguments for a generic callee type. Infer based on the types of arguments. Return a derived callable type that has the arguments applied. Nr)r strictr"rr builtins.str)rrrrr9get_arg_infer_passesrWr<rrr$argument_infer_context#infer_function_type_arguments_pass2 special_sigr,r/rrrrrrtrur&KEYWORD_ARGUMENT_REQUIRES_STR_KEY_TYPErr unannotatedrapply_inferred_arguments) rrXr(r:r3r rW arg_pass_nums pass1_argsr*rV inferred_args first_argrrrr$ysJ           z/ExpressionChecker.infer_function_type_argumentsold_inferred_argsSequence[Type | None]&tuple[CallableType, list[Type | None]]c Csxt|}tt|D]\}} t| ttfst| rd||<q ||||}|||||} t || ||| d}||fS)a^Perform second pass of generic function type argument inference. The second pass is needed for arguments with types such as Callable[[T], S], where both T and S are type variables, when the actual argument is a lambda with inferred types. The idea is to infer the type variable T in the first pass (based on the types of other arguments). This lets us infer the argument and return type of the lambda expression and thus also the type variable S in this second pass. Return (the callee with type vars applied, inferred actual arg types). Nr ) rrrrrrrUrer9r$rl) rrXr(r:r3rvr rtr*rVrWrrrrmsz5ExpressionChecker.infer_function_type_arguments_pass2r#cCst|jd|jdS)Ntyping.Mappingtyping.Iterable)r#rrrrrrrlsz(ExpressionChecker.argument_infer_context num_actualsint list[int]cCsBdg|}t|D]\}}|tr||D]}d||<qq |S)aReturn pass numbers for args for two-pass argument type inference. For each actual, the pass number is either 1 (first pass) or 2 (second pass). Two-pass argument type inference primarily lets us infer types of lambdas more effectively. rr")rrArgInferSecondPassQuery)rrWr3r|rr*rVr.rrrrks    z&ExpressionChecker.get_arg_infer_passesrtcCsTt|D]\}}|rt|r"|j||d|ttjgt|}q||||S)zApply inferred values of type arguments to a generic function. Inferred_args contains the values of function type arguments. r) rrUrcould_not_infer_type_argumentsrrr r<re)rrXrtr r* inferred_typerrrrqs  z*ExpressionChecker.apply_inferred_arguments actual_types actual_kinds actual_namesContext | Nonec Csr|dur tttj}i} |D]} | D] } | | dd| | <qq|||||| |\} } t|jD]\}}|rn||sn| sn| r\|j ||||r[|r[d|vr[| |||n|j |pbd}|j |||d} q2|st||||r|jstt|||dtr|j |||d} q2|r||r|||dtjtjfvr|j ||d} q2| S)aOCheck that there is a value for all required arguments to a function. Also check that there are no duplicate values for arguments. Report found errors using 'messages' if it's not None. If 'messages' is given, 'context' must also be given. Return False if there were any errors. Otherwise return True Nrrr?F)r_rrrrh check_for_extra_actual_argumentsrr: is_required is_positionalrtoo_few_argumentsmissing_classvar_callable_noter;missing_named_argumentr]is_duplicate_mappingrrrrrduplicate_argument_valueis_namedrr,r/too_many_positional_arguments)rr8rrrr3r rr all_actualsraokis_unexpected_arg_errorr*kindargnamerrrr:sL    z&ExpressionChecker.check_argument_countrdict[int, int]tuple[bool, bool]cCs4d}d}t|D]\} } | |vrO| tjkst|| rO| tjkrOd}| tjkr/|j||q|s5Jd|| } | dus?J|| } |j|| | |d}q| tjkrZtj|j vs_| tjkrt || } t | t t fr|| dt| jkr| tjkst | t s|j||n |j|| |d}d}q||fS)zCheck for extra actual arguments. Return tuple (was everything ok, was there an extra keyword argument error [used to avoid duplicate errors]). FTz/Internal error: named kinds without names givenNr)rrr.is_non_empty_tupler/r,rtoo_many_argumentsunexpected_keyword_argumentr:rrrrrhr<r"too_many_arguments_from_typed_dict)rr8rrrrr rrr*ract_nameact_type actual_typerrrrUs:      z2ExpressionChecker.check_for_extra_actual_argumentscCst|tr8t|tr:|jddd\}}|j|}|dur|jjs@|jj sB|j d|d|dSdSdSdSdSdSdS)Nrr)maxsplitrzN" is considered instance variable, to make it class variable use ClassVar[...]) rrrrrrhrrhrp is_classvarrnote)rrrr rvar_namerrrrrs  z0ExpressionChecker.missing_classvar_callable_note check_argArgChecker | Nonec  Cs|p|j}t|} t|D]h\} } | D]a} || } | dur q|| }|tjkr5|| s5|j| ||tj krP| | sPt | |j d}|j| ||| | ||j| |j| }||| || |j| | d| d|||| | qqdS)zCheck argument types against a callable type. Report errors if the argument types are not compatible. The check_call docstring describes some of the arguments. Nrzr)rrrlrrr.is_valid_var_argrinvalid_var_argr/is_valid_keyword_var_argrtrrinvalid_keyword_var_argexpand_actual_typer;r:rW)rrWr:r(r8r3r rrmapperr*rrr actual_kind is_mappingexpanded_actualrrrr;s@  z&ExpressionChecker.check_argument_types caller_typeoriginal_caller_type caller_kindr3nm outer_contextc Cs t|}t|}t|}t|tr|j|| dSt|trOt|trO|rO|j s2|j rOt|j t rO|j j j sB|j j j rO|jjsO|j|| dSt|||jjds|j||grbdS|jj||||||| | d} |jj||| | d|j||| dSdS)z.Check the type of a single argument in a call.)rGN)rr rr)rrrrdeleted_as_rvaluerrrarrr,rsrbrrrallow_abstract_callconcrete_only_callrtrGshould_suppress_optional_errorincompatible_argumentincompatible_argument_notecheck_possible_missing_await) rrrrrXrrr8rr rrrrrrsT    zExpressionChecker.check_argrc s|}|}||||} d} d} d} tfdd|Drhz#j| |||||||} Wdn1s?wYWn tyPd} Ynw| rht| \}}t t ||j |j  |f} | |||||||}|dur| durt|d| drtt|dts|S| S| dur| S|dur|S| |||||} t| dkr| d}nttj}j|st|sd}ntj}jj||||dj|||||||d}| rjtj ||S) z(Checks a call to an overloaded function.NFc3rlr) real_unionrrVrrrrrnz8ExpressionChecker.check_overload_call..Trrrr)!r)rWplausible_overload_call_targetsr2rrunion_overload_resultrrrrrrcombine_function_signaturesinfer_overload_return_typertrrroverload_erased_call_targetsr<rr rris_operator_methodrOPERATORno_variant_matches_argumentsr rurTOO_MANY_UNION_COMBINATIONS)rr8r(r:r;rrr rWplausible_targetserased_targetsunioned_resultunion_interruptedunioned_returnreturnsinferred_typesinferred_resultrrrrrrrs             z%ExpressionChecker.check_overload_callr list[CallableType]c sd dd}g}g}d}d} t|D]\} } | tkr || s d}| tkr*|| s*d} q|jD]J} t||| j| jfd d } |j-| | ||| d ri|rY| j rY| | n| rd| j rd| | n| | Wd n1sswYq.||S) a/Returns all overload call targets that having matching argument counts. If the given args contains a star-arg (*arg or **kwarg argument), this method will ensure all star-arg overloads appear at the start of the list, instead of their usual location. The only exception is if the starred argument is something like a Tuple or a NamedTuple, which has a definitive "shape". If so, we don't move the corresponding alternative to the front since we can infer a more precise match using the original order.rVrrrcSs.t|}t|tpt|tpt|to|jjSr)rrrrrris_named_tuplerVrrr has_shapes  zDExpressionChecker.plausible_overload_call_targets..has_shapeFTc|Srrr)rWrrr,zCExpressionChecker.plausible_overload_call_targets..NrVrrr) rr.r/rrr:r;rrr: is_var_argr is_kw_arg) rrWr:r;r rmatches star_matchesargs_have_var_argargs_have_kw_argrrVr3rrrrs8          z1ExpressionChecker.plausible_overload_call_targetsrtuple[Type, Type] | Nonec  Csg} g} g} ttt|} g} |D]f}|j|jjusJ|j+}|j}|j|||||||d\}}Wdn1s@wYWdn1sOwY| }|rw| sc||fS| || || || |qt | dkrdSt | | |||rt | r|j | d| d| dfSt dd| Dr|j | dt| dt| dfS|jttj||||||dS|j | d| d| dfS)aAttempts to find the first matching callable from the given list. If a match is found, returns a tuple containing the result type and the inferred callee type. (This tuple is meant to be eventually returned by check_call.) If multiple targets match due to ambiguous Any parameters, returns (AnyType, AnyType). If no targets match, returns None. Assumes all of the given targets have argument counts compatible with the caller. )r8r(r:r;r rrNrcSsg|]}t|qSr)rrrVrrrr/rz@ExpressionChecker.infer_overload_return_type..)r2map has_any_typerrrrr has_new_errorsrr<any_causes_overload_ambiguityall_same_types store_typesrrrr)rrr(rWr:r;rrr r return_typesrargs_contain_any type_mapsrVwrr infer_typeis_matchrrrrsd           z,ExpressionChecker.infer_overload_return_typec Cs0g}|D]}|||||||r||q|S)zReturns a list of all targets that match the caller after erasing types. Assumes all of the given targets have argument counts compatible with the caller. )erased_signature_similarityr) rrrWr:r;r(r rrVrrrr s   z.ExpressionChecker.overload_erased_call_targetsrlevellist[tuple[Type, Type]] | Nonec  Cs| tkrtt|D] \} } || rn,q ||||||||||||} Wdn1s3wY| dur?| gSdS||||||||||||} Wdn1s^wY| durutt| dtt fsu| gSt|| }t|tsJg}| D]%}| }||| <| ||||||||| d }|dur| |qdSt}g}|D]}||vr||||q|S)aAccepts a list of overload signatures and attempts to match calls by destructuring the first union. Return a list of (, ) if call succeeds for every item of the desctructured union. Returns None if there is no match. Nrr)rrrrtype_overrides_setrrrrrrcopyrrrrr)rrr(rWr:r;rrr ridxrVrdirect first_union res_itemsrb new_arg_types sub_resultseenrpairrrrr s~        z'ExpressionChecker.union_overload_resultrVcCs"t|}t|tot|dkSrq)rrrr<rrrVrrrr} szExpressionChecker.real_unionexprsSequence[Expression] overridesSequence[Type]c csht|t|ks Jt||D] \}}||j|<qzdVW|D]}|j|=q!dS|D]}|j|=q,w)z5Set _temporary_ type overrides for given expressions.N)r<rr)rrrrrVrrrr s   z$ExpressionChecker.type_overrides_setrAnyType | CallableTypecCs|sJdt|}tdd|DsttjSttt|}t|dkr)|dSt |\}}ddt t|dj D}t |dj }g}d}|D]M}t|t|j krYd }n?tt||j D]\} \} } | | krlqa| ry| ryt|| <qad }|rnt|j D] \} } || | q||jqJt|} |rttj}|dj||gttgd d g| |d d Sg}|D] }t|}||q|dj||| |d d S) aLAccepts a list of function signatures and attempts to combine them together into a new CallableType consisting of the union of all of the given arguments and return types. If there is at least one non-callable type, return Any (this can happen if there is an ambiguity because of Any in arguments). zTrying to merge no callablescsr%rrrrOrrrr rnz@ExpressionChecker.combine_function_signatures..rrcSrrrrrrrr/ r-zAExpressionChecker.combine_function_signatures..FTN)rWr:r;rrrI)rWr:rrrI)rrrrrr r rr<#merge_typevars_in_callables_by_namerFrWrr:rrrr-rrrr<r.r/)rr callablesrrh new_kinds new_returns too_complexrr*new_kind target_kindrV union_returnr2 final_args args_listnew_typerrrr sd        z-ExpressionChecker.combine_function_signaturesc st|||j|jfdd}|j|||||ds' WddSWdn1s1wYddd}z|j||||||dWdStyTYdSw)z^Determine whether arguments could match the signature at runtime, after erasing types.crrrr)rrrr, rz?ExpressionChecker.erased_signature_similarity..NFrroriginal_ccaller_typerr3rXrr}rr8rrr~r r=rrrc Sst||stdSr)arg_approximate_similarityr) rr rrXrrr8rr rrrrr s z@ExpressionChecker.erased_signature_similarity..check_arg)r rT)rrr rrr3rXrrr}rr}r8rrr~r r=rr=rr)rr:r;rrr:r;r) rrWr:r;r(r8r r3rrrrr s4     z-ExpressionChecker.erased_signature_similarityrbcCstj|||jj||dS)z=Simple wrapper around mypy.applytype.apply_generic_arguments.ra)rrerincompatible_typevar_value)rr_rr rbrrrre sz)ExpressionChecker.apply_generic_argumentscCsL||t|}t|trttj|dttj|dfSttjttjfS)NrI)rWrrrrrRr)rr(r8rrrr' s    z%ExpressionChecker.check_any_type_callcs^jfdd|D}Wdn1swYtdd|D|fS)Nc sg|] }|qSr)r )rsubtyper:r;r(r rrrr/; sz6ExpressionChecker.check_union_call..cSrrr)rrrrrr/@ r)rdisable_type_namesrr)rr8r(r:r;r resultsrrrr2 s z"ExpressionChecker.check_union_callrcCs*|jjt||||}|||S)z'Visit member expression (of form e.id).)rrrranalyze_ordinary_member_accessr)rrrrrrrvisit_member_exprB s  z#ExpressionChecker.visit_member_exprc Csz|jdur ||S|j|j|jd}|j}d}t|tr't|jtr'|jj }t |j |||dd|j ||j ||d }|S)z+Analyse member expression or member lvalue.Nr F)rrrmodule_symbol_table)rrrrrrrVrrMrrrrrr)rrrrrr member_typerrrrH s*  z0ExpressionChecker.analyze_ordinary_member_access base_typec Cs$t|||ddd|j||j|d S)z}Analyse member access that is external, i.e. it cannot refer to private definitions. Return the result type. Frrr)rrrr)rrYrr rrranalyze_external_member_accessf sz0ExpressionChecker.analyze_external_member_accesscCst|jdS)Nr)rrrrrrrz z$ExpressionChecker.is_literal_contextrZr fallback_namecCs:||}|rt||dS|jt|||j|jddS)azAnalyzes the given literal expression and determines if we should be inferring an Instance type, a Literal[...] type, or an Instance that remembers the original literal. We... 1. ...Infer a normal Instance in most circumstances. 2. ...Infer a Literal[...] if we're in a literal context. For example, if we were analyzing the "3" in "foo(3)" where "foo" has a signature of "def foo(Literal[3]) -> None", we'd want to infer that the "3" has a type of Literal[3] instead of Instance. 3. ...Infer an Instance that remembers the original Literal if we're declaring a Final variable with an inferred type -- for example, "bar" in "bar: Final = 3" would be assigned an Instance that remembers it originated from a '3'. See the comments in Instance's constructor for more details. )rZr4)rZr4rr)r)rrrr<rr)rrZrrVrrrr} s   z)ExpressionChecker.infer_literal_expr_typeleftrrightcCst|j|j|ddS)z$Concatenate two fixed length tuples.rQ)rr4)rrr)rrrrrr concat_tuples szExpressionChecker.concat_tuplesrHcC||jdS)z(Type check an integer literal (trivial). builtins.intrrZrrrrrvisit_int_expr z ExpressionChecker.visit_int_exprr\cCr )z&Type check a string literal (trivial).rjr"r#rrrvisit_str_expr r%z ExpressionChecker.visit_str_exprr7cCr )z%Type check a bytes literal (trivial).builtins.bytesr"r#rrrvisit_bytes_expr r%z"ExpressionChecker.visit_bytes_exprrDcC |dS)z%Type check a float literal (trivial).zbuiltins.floatrr#rrrvisit_float_expr  z"ExpressionChecker.visit_float_exprr;cCr))zType check a complex literal.zbuiltins.complexr*r#rrrvisit_complex_expr r,z$ExpressionChecker.visit_complex_exprrAcCr))zType check '...'.zbuiltins.ellipsisr*r#rrrvisit_ellipsis r,z ExpressionChecker.visit_ellipsisrQc Cs`|jdks |jdkr|||S|jdkr t|jtr ||S|jdkrJt|jtr;|jjj dkr;|j |j|j St|jt rJ|j |j|j S||j}t|}t|tr|jdkr|jjd}|r|jdkrt||j }t|tr|jjd }|d ur|||S|jtjvrtj|j}|j|||j |d d \}} | |_|Std |j)z(Type check a binary operator expression.andor*%)r+__add__zbuiltins.tuple.__add____radd__NT allow_reversezUnknown operator )opcheck_boolean_oprrrKcheck_list_multiplyr7rrGpython_versionrcheck_str_interpolationrr\rrrpartial_fallbackrrhrrr op_methodscheck_op method_type RuntimeError) rr left_typeproper_left_typeleft_add_methodproper_right_typeright_radd_methodmethodrrArrr visit_op_expr s2         zExpressionChecker.visit_op_exprr:c Csd}d}t|j|jdd|jD]S\}}}||}d}|dks&|dkr||} | dur4||} |jjdd} |jd| |gtg|d\} }Wdn1sTwY| }|j | } t | t rin| r|| r|j |\} } t|gtjgdg| |d }t|| s|jd|| |n| s| r|j|| | d r|j|| d |n|j| n|tjvrtj|}t|jj}|j||||dd \}}Wdn1swY|s|d vr||} t|dst| dst|}t| } ||| r|j|| d|n5|dks&|dkrJ||} | }t|}t| } ||| rG|j|| d|d}ntd||j !||dur_|}qt"#||}q|dusmJ|S)zType check a comparison expression. Comparison expressions are type checked consecutive-pair-wise That is, 'a < b > c == d' is check as 'a < b and b > c and c == d' Nrinznot inTsave_filtered_errors __contains__rHrr(r:r r)original_container containerr7)z==z!=__eq__equalityiszis notidentityzUnknown comparison operator )$roperandsrrfind_partial_type_ref_fast_pathrrcheck_method_call_by_namer- bool_typeranalyze_container_item_typerrrranalyze_iterable_item_typerrrrtunsupported_operand_typesdangerous_comparison add_errorsfiltered_errorsr?rerrorsr@r}r[rB method_typesrr join_types)rrrrrroperatorrCrA right_type local_errorsr cont_typeitertyperHrrrrvisit_comparison_expr s&               z'ExpressionChecker.visit_comparison_exprcCsZt|tsdSt|jtr+||j|}t|tr+|jdur+|j||j ||SdS)zIf expression has a partial generic type, return it without additional checks. In particular, this does not generate an error about a missing annotation. Otherwise, return None. N) rrVrrhrrrrr fixup_partial_type)rrrrrrrVL s  z1ExpressionChecker.find_partial_type_ref_fast_pathrOcCs6|jjjsdSt||f\}}|jjrdSt|ts!t|tr#dSt|tr=t|tr=t |}t |}t||f\}}|rIt |rIt |rIdSt|t r{t|t r{|j j tvr{|j j tvr{|jd}t||}t||}t|jd|jd St|trt|trt|jtrt|jtrdSt||dd S)aCheck for dangerous non-overlapping comparisons like 42 == 'no'. The original_container is the original container type for 'in' checks (and None for equality checks). Rules: * X and None are overlapping even in strict-optional mode. This is to allow 'assert x is not None' for x defined as 'x = None # type: str' in class body (otherwise mypy itself would have couple dozen errors because of this). * Optional[X] and Optional[Y] are non-overlapping if X and Y are non-overlapping, although technically None is overlap, it is most likely an error. * Any overlaps with everything, i.e. always safe. * Special case: b'abc' in b'cde' is safe. Fztyping.AbstractSetr)ignore_promotions)rrGstrict_equalityrrR!is_unreachable_warning_suppressedrrrrhas_bytes_componentrrrrlookup_typeinfor'r(r(rrZr)rrrrO abstract_setrrrr\\ s:        z&ExpressionChecker.dangerous_comparisonrHrc Csf|p|}t|}t|tr|||||||St|||ddd|j||j|d }|||||||S)zType check a call to a named method on an object. Return tuple (result type, inferred method type). The 'original_type' is used for error messages. FTr) rrrcheck_union_method_call_by_namerrrrcheck_method_call)rrHrr(r:r rrArrrrW s&   z+ExpressionChecker.check_method_call_by_namec Cs|g}g}|D]-} |j||| ||||\} } Wdn1s&wY|| || qt|t|fS)aType check a call to a named method on an object with union type. This essentially checks the call using check_method_call_by_name() for each union item and unions the result. We do this to allow plugins to act on individual union items. N)rrrrWrr) rrHrr(r:r rrmeth_resrVrb meth_itemrrrro s      z1ExpressionChecker.check_union_method_call_by_namerAc CsH|||}|dur |nd}|j||||||d}|j||||||dS)zType check a call to a method with the given name and type on an object. Return tuple (result type, inferred method type). Nr'r)rfr r ) rr_rrAr(r:r rrrrrrp s  z#ExpressionChecker.check_method_callop_namerC left_exprrc right_exprc sdfdd }dd d}t|}t|}t|tr%ttj|d} | | fSt|tr5ttj|d} | | fStj|} |||} || |} |tjvrUt||rU| ||fg} n5t ||rt|t rt|t r|j j |j ur|||||| kr| ||f| ||fg} n | ||f| ||fg} dd| D}g}g}|D]<\}}}j jdd}||||gtg}Wdn1swY|r||||q|St|t r|j jst|t r|j jrttj} | | fS|s)j jdd}|||gtg}Wdn 1swY|r'||||n|Sj |dt|dkr<|dSttj}||f}|S)Nrsr\rrrr~c sr||sdSj"}t||ddd|jjd }|r&dn|WdS1s2wYdS)zYLooks up the given operator and returns the corresponding type, if it exists.NFT) rrVrrrrr rrr) has_memberrrrrrr)rsrrrYrLrrlookup_operator s"   $z>ExpressionChecker.check_op_reversible..lookup_operatorrVrr>r`cSs(|jjD] }|j|r|jSqdS)aReturns the name of the class that contains the actual definition of attr_name. So if class A defines foo and class B subclasses A, running 'get_class_defined_in(B, "foo")` would return the full name of A. However, if B were to override and redefine foo, that method call would return the full name of B instead. If the attr name is not present in the given class or its MRO, returns None. N)rrErrhr)rVr>clsrrrlookup_definer s  z=ExpressionChecker.check_op_reversible..lookup_definerrIcSs$g|]\}}}|dur|||fqSrr)rr9objrVrrrr/s s$z9ExpressionChecker.check_op_reversible..TrKrr)rsr\rrrr~)rVrr>r\rr`)rrrrrRrreverse_op_methodsop_methods_that_shortcutrsrtrr alt_promoterrrpr-rrr^r-rrWr]r<r )rrsrCrtrcrur rwryany_type rev_op_nameleft_opright_op variants_rawvariantsr_rrHrzrVrdr error_anyrrLrcheck_op_reversible sv              z%ExpressionChecker.check_op_reversiblerVr8c sd|r&|g}t|}t|trddt|D}||}g}g} |j(} |D]} |j|| t | d||d\} } | | | | q+Wdn1sSwY| sht |}t | }||fS||fg}t|}t|trfddt|D}g}g} |jjdd/} |D]$} |D]\}}|j|| t | d||d\} } | | | | qqWdn1swY| r|j | | d }t t}|j|_|j|_t|d krt|d kr|j|n!t|d kr |jjd ||dnt|d kr|jjd ||dt |}|| }||fS|j|||gtgd S)zType check a binary operation which maps to a method call. Return tuple (result type, inferred operator method type). cSsg|]}|qSrrrmrrrr/ sz.ExpressionChecker.check_op..ry)rsrCrtrcrur Ncsg|] }|t|dfqS)ry)r_rmryrrr/ rMTrKrr"LeftRightrN)rrrrrrrrrr_rrrr]r^rrrr<"warn_both_operands_are_from_unionswarn_operand_was_from_unionrrWr-)rrHrrVr r8 left_variantsrc all_results all_inferredrdleft_possible_typerinferred results_finalinferred_finalright_variantsright_possible_typeruerrrecent_contextrryrr@ s                     zExpressionChecker.check_opc Cs|jd}||j|}t||j|d}|jdvsJ|jr&di}}n&|jr/id}}n|jdkr>|j|j\}}n|jdkrL|j|j\}}t j |jj j vrd|durd|jsd|j |j|j|jry|dury|jsy|j |j|j|j j|dud|||j|}Wdn1swY|dur|durtS|dur|dusJ|S|dur|dusJ|S|jdkrt|} |j } n |jdkrt|} |j } t| tr|S| r|St| |gS)z/Type check a boolean operation ('and' or 'or').rr )r/r0Nr/r0)r)rrrrr9 right_alwaysright_unreachablerfind_isinstance_checkrREDUNDANT_EXPRrGenabled_error_codesrredundant_left_operand should_report_unreachable_issuesunreachable_right_operandrranalyze_cond_branchrr can_be_truer can_be_falserr) rrr rfrCexpanded_left_typeleft_map right_maprcrestricted_left_typeresult_is_leftrrrr: s^            z"ExpressionChecker.check_boolean_opcCs`||j}t||dr|j|j|jdd}n||j}|d||j|\}}||_|S)zzType check an expression of form '[...] * e'. Type inference is special-cased for this common construct. r!r)r__mul__)rrrtrrrr@rA)rrrcrCrrArrrr;m s  z%ExpressionChecker.check_list_multiplyr5cCsJ||j}|j|j|j|j||j|j|||j|Sr)rrZrcheck_assignmentr check_finalr rV)rrrZrrrvisit_assignment_expr} s   z'ExpressionChecker.visit_assignment_exprrgcCsP||j}|j}|dkr|}|Stj|}|||gg|\}}||_|S)z7Type check an unary operation ('not', '-', '+' or '~').not)rrr9rXrunary_op_methodsrWrA)rr operand_typer9rrHrArrrvisit_unary_expr s  z"ExpressionChecker.visit_unary_exprrGcCsD||}|||}t|}|r t|tr |jdur |j}|S)zgType check an index expression (base[index]). It may also represent type application. N)visit_index_expr_helperrrrrrr)rrrp_resultrrrvisit_index_expr s   z"ExpressionChecker.visit_index_exprcCs*|jr ||jS||j}|||Sr)rrrvisit_index_with_type)rrrCrrrr s   z)ExpressionChecker.visit_index_expr_helperProperType | Nonec sj}t|}|t|tr&p|tfdd|DddSt|trj rt|t r; ||S |}|durg}|D]3}|dkrU|t |j7}d|krbt |jkrmnn ||j|qHjtjttjSt|S||St|tr|jSt|tr|r|jr|jSt|tr|j ds!|j Sj"d|jgt#gd\}} | _$|S) zAnalyze type of an index expression for a given type of base expression. The 'original_type' is used for error messages (currently used for union types). cg|] }|qSr)rrrrrrrr/ s z;ExpressionChecker.visit_index_with_type..F)contract_literalsNr __getitem__)r)%rrrrrrrrrrrZvisit_tuple_slice_helpertry_getting_int_literalsr<rrrurTUPLE_INDEX_OUT_OF_RANGErrr nonliteral_tuple_index_helperrvisit_typeddict_index_exprrrarris_enumvisit_enum_index_exprrrvr!rrWr-rA) rrCrrrnsoutrrrArrrr sX        z'ExpressionChecker.visit_index_with_typeslicrZc Csdg}dg}dg}|jr||j}|dur|||S|}|jr3||j}|dur1|||S|}|jrH||j}|durF|||S|}g} t|||D]\} } } | || | | qQt | Sr) begin_indexrr end_indexstride itertoolsproductrslicer) rrCrbeginendr begin_rawend_raw stride_rawrbrsrrrr s,      z*ExpressionChecker.visit_tuple_slice_helperrlist[int] | NonecCst|tr |jgSt|tr!|jdkr!|j}t|tr!d|jgSt||}t|tr5|j dur5|j }t|t rDt|jt rD|jgSt|t rig}t |jD]}t|t rdt|jt rd||jqPdS|SdS)aIf the given expression or type corresponds to an int literal or a union of int literals, returns a list of the underlying ints. Otherwise, returns None. Specifically, this function is guaranteed to return a list with one or more ints if one one the following is true: 1. 'expr' is a IntExpr or a UnaryExpr backed by an IntExpr 2. 'typ' is a LiteralType containing an int 3. 'typ' is a UnionType containing only LiteralType of ints -rN)rrHrZrgr9rrrrrrr}rrrr)rroperandrVrrbrrrrs(      z*ExpressionChecker.try_getting_int_literalscCs@|jd||gtg|dt|j}t|tr|jd|gS|S)NrryrQ)rWr-rrrrZrr)rrCrunionrrrr$s   z/ExpressionChecker.nonliteral_tuple_index_helpertd_typec Cst|tr |jg}nQt||}t|trt|j}n|g}g}t|D]5}t|t r4|j dur4|j }t|t rMt|jt rM|j jjdkrM||jq%|j||ttjSg}|D] }|j|} | durz|j|||ttjS|| q_t|S)Nr')rr\rZrrrrrrrrrr\r4rrrr$typeddict_key_must_be_string_literalrrr rhtypeddict_key_not_foundr) rrr key_namesrV key_typesr value_typeskey_namerrrrr,s4        z,ExpressionChecker.visit_typeddict_index_expr enum_typecCs.|d}|j||||ddt|gS)NrjzEnum index should be a stringzactual index type)rr check_subtyperr)rrrr  string_typerrrrOs  z'ExpressionChecker.visit_enum_index_exprr9cCs|j|jttjddd}|j}|jj}|jr)t t |ts)||kr)|j |||j r8t|r8|j d||t||jj|jj|j |d|S)zType check a cast expression.Trrr5zTarget type of castry)rrrrrrrrGwarn_redundant_castsrrrredundant_castdisallow_any_unimportedryunimported_type_becomes_anyrwis_typeshed_stub)rr source_type target_typerGrrrvisit_cast_expr\s( z!ExpressionChecker.visit_cast_exprr4cCs>|j|j|jdddd}|j}t||s|j||||S)NrTr)rrrrrsrassert_type_fail)rrrrrrrvisit_assert_type_exprss z(ExpressionChecker.visit_assert_type_exprrWcCs|jtkr3|jdus J|j|j|jddd}|jjs1|j||j|j s1|j d|j|S|jjsM|j durDdd|j Dni}|j ||t S)z$Type check a reveal_type expression.NrTrrz9'reveal_type' always outputs 'Any' in unchecked functionscSsi|]}|j|jqSr)rr)rvar_noderrr sz7ExpressionChecker.visit_reveal_expr..)rr2rrrrrr reveal_typerr local_nodes reveal_localsr)rr revealed_typenames_to_typesrrrvisit_reveal_exprs&   z#ExpressionChecker.visit_reveal_exprtapprbcCs6t|jtrgt|jjtrgt|jj|j|jj|jjj |}t |}t|t r5t |j |j}|||j|St|trP|jj jrPt |jj |j}|||jj|St|trZ||S|jtj|ttjSt ||j}t|ttfr|s|jtj||||j|St|trttj|dSttj S)aType check a type application (expr[type, ...]). There are two different options here, depending on whether expr refers to a type alias or directly to a generic class. In the first case we need to use a dedicated function typeanal.expand_type_aliases. This is due to the fact that currently type aliases machinery uses unbound type variables, while normal generics use bound ones; see TypeAlias docstring for more details. rI)!rrrVrr rxrrrurrrrrr apply_type_arguments_to_callabler(rr>rrrrONLY_CLASS_APPLICATIONrrr rrrrarRr)rrrbrwrrrvisit_type_applications.       z(ExpressionChecker.visit_type_applicationaliasracCs|j|j|j|ddS)aRight hand side of a type alias definition. It has the same type as if the alias itself was used in a runtime context. For example, here: A = reveal_type(List[T]) reveal_type(A) both `reveal_type` instances will reveal the same type `def (...) -> builtins.list[Any]`. Note that type variables are implicitly substituted with `Any`. Tr)rrr)rrrrrvisit_type_alias_exprs z'ExpressionChecker.visit_type_alias_exprrr rrfrcCst|jtr|jjrttjS|jjj o|j }t t ||j |j||jjd}t|tr>t|j|j}|r6|S|||j|St|trTt|jjdkrTtt|j|jSt|tr^||St|trjttj|dS|rqttjS|dS)aGet type of a type alias (could be generic) in a runtime expression. Note that this function can be called only if the alias appears _not_ as a target of type application, which is treated separately in the visit_type_application method. Some examples where this method is called are casts and instantiation: class LongName(Generic[T]): ... A = LongName[int] x = A() y = cast(A, ...) ) disallow_anyrurQrIr)rrrinvalidrrr rrGdisallow_any_genericsrrr{rrrrurrrrr(rrrrrrRr)rrrrfrrrbrwrrrrs0       z/ExpressionChecker.alias_type_in_runtime_contextrwcst|}t|tr+t|jtkr$jt|jtttj S |St|t ra|j D]}t|jtkrRjt|jtttj Sq3t fdd|j DSttj S)a{Apply type arguments to a generic callable type coming from a type object. This will first perform type arguments count checks, report the error as needed, and return the correct kind of Any. As a special case this returns Any for non-callable types, because if type object type is not callable, then an error should be already reported. crr)rerr(rfrrrr/szFExpressionChecker.apply_type_arguments_to_callable..)rrrr<rrincompatible_type_applicationrrr rerrr)rrwr(rfrrrrrs     z2ExpressionChecker.apply_type_arguments_to_callablerKcC||ddS)z#Type check a list expression [...].rcheck_lst_exprr#rrrvisit_list_expr r%z!ExpressionChecker.visit_list_exprrYcCr)Nrzrr#rrrvisit_set_expr$rz ExpressionChecker.visit_set_exprListExpr | SetExpr | TupleExprcontainer_fullnamec Cs|jd}|r dS|j|d}|durt|tr|SdSg}|jD]}t|tr2t|j|<dS|| |q"t |}t |sLt|j|<dS|j ||g}||j|<|S)aY Fast path to determine the type of a list or set literal, based on the list of entries. This mostly impacts large module-level constant definitions. Limitations: - no active type context - no star expressions - the joined type of all entries must be an Instance or Tuple type rN)rrrhrrrr[rrrrr0rrr) rrrrfrtrrbvtctrrrfast_container_type's&       z%ExpressionChecker.fast_container_typetagc Cs|||}|r |Stdddg|}t|gtjgdg|j||g|d||gd}| |dd|j Ddd|j D|d}t |S) NTrrrrcSs g|] }t|tr |jn|qSr)rr[rr1rrrr/_s z4ExpressionChecker.check_lst_expr..cSs"g|] }t|tr tjntjqSr)rr[rr.r-r1rrrr/`s"r) rrrrrr.rrrr rr)rrrrrtv constructorrrrrrIs,  z ExpressionChecker.check_lst_exprr`c spt|jd}d}t|tr&fddt|jD}t|dkr%|d}n t|tr/|j}n|rKt|t rKt|t s=J|j rK|j dgtj}g}d}t tjD]Q}j|}t|t r||j} t| } t| tr|| j|t| j7}qV|ddS|r|t|kr||} n ||||} |d7}|| qVttj} t||jd| gS) zType check a tuple expression.rNcs8g|]}t|trt|jtjkst|tr|qSr)rrr<rrrrrrrrr/ksz6ExpressionChecker.visit_tuple_expr..rrrQz)rrrrrrr<rrrrr(rFr[rrrrrrrrrr) rrrtype_context_itemstuples_in_contextrr.r*rbtt fallback_itemrr rvisit_tuple_expresB             z"ExpressionChecker.visit_tuple_exprc CsX|jd}|r dS|j|d}|durt|tr|SdSg}g}d}|jD]E\}}|dur[t||} t| trR| jj dkrRt | j dkrR| j d| j df}q&t |j|<dS| ||| ||q&t|} t|} t| r~t| st |j|<dS|r|d| ks|d| krt |j|<dS|jd| | g} | |j|<| S)a~ Fast path to determine the type of a dict literal, based on the list of entries. This mostly impacts large module-level constant definitions. Limitations: - no active type context - only supported star expressions are other dict instances - the joined types of all keys and values must be Instance or Tuple types rNrr"rr)rrrhrrrrrrrr<r(rrrr0rrr) rrrfrrrstargsrrZstktrdtrrrfast_dict_types@        z ExpressionChecker.fast_dict_typec Cs||jd|}|r%|j|||dd}t|}t|tr!|S|S||}|r.|Sg}g}|jD]/\}} |durC| | q5t || g} |j dkrW|j | _ |j | _ n| j | _ | j | _ | | q5t dddg|} t dddg|} d} |s|stt| | g|dgtjgdg|jd | | g|d d | | gd }|||tjgt||d} n |r|D]B}| durt|jd | | ggtjgdg|jd | | g|d d| | gd }|||gtjg|d} q|d| |gtjg|q| dusJ| S)zoType check a dict expression. Translate it into a call to dict(), with provisions for **expr. rN)r8rr r}rKTVTrQrrzrrzrr)find_typeddict_contextrrrrrr<rrrr`rrrrrrrrr.rrr r-r<rW)rrtypeddict_contextrrrr(rrrZtuprrrvr rVrrrvisit_dict_exprsn        "  z!ExpressionChecker.visit_dict_expr dict_exprTypedDictType | NonecCst|}t|tr |St|trEg}|jD]}|||}|dur-||||r-||qt|dkr8|dSt|dkrE|j ||dS)Nrr) rrrrrrrrr<rtypeddict_context_ambiguous)rr rrrb item_contextrrrr#s"        z(ExpressionChecker.find_typeddict_contextrIcCs"|jj|dd||\}}|s]|jjttj|jj |"|j j ddD]}| |jq+|j | dd}Wdn1sGwY| d}|jjt|||S|jj|j|jj||d|j| s~|j | dd|j| }|jjt||S) zType check lambda expression.F)body_is_trivialNrTrr) type_override)rcheck_default_argsinfer_lambda_type_using_contextrrrrrr push_functionbodyrrrpopr|rcheck_func_itemrKrLreplace_callable_return_type)rrrr$stmtrr4rrrvisit_lambda_expr:s&    z#ExpressionChecker.visit_lambda_expr/tuple[CallableType | None, CallableType | None]cCs t|jd}t|tr!ddt|D}t|dkr!|d}|r(t|ts*dStt|t }t|ts9J|j dur@dSdd|j D}|j sQ| durg|jd ttjgt|||jddd }t|vsot|vrs|dfS|j|kr|jtj|dS||fS) zTry to infer lambda expression type using context. Return None if could not infer type. The second item in the return type is the type_override parameter for check_func_item. rcSsg|] }t|tr|qSrrr rrrr/fs  zEExpressionChecker.infer_lambda_type_using_context..rrNNNcSsg|]}|jqSr)rrrrrr/}sF)is_ellipsis_argsrWr:r;)rrrrrrr<rrrr argumentsr0r4r<rrrr;r.r/r:rrurCANNOT_INFER_LAMBDA_TYPE)rrrfr callable_ctxr:rrrr&Zs6      z1ExpressionChecker.infer_lambda_type_using_contextr]c Csl||}t|tr|\}}n|St|}|dur&|jtj|tt j St|}|dur;|jtj |tt j S|j }z| |}Wnty[|jtj|tt j YSwt||dkrq|jtj|tt j S||ddD]8} |j| jvs| |dkr|jr|jjr| |dkrtt jSt|j|ddd|| ||j|j|d SqyJd)z+Type check a super expression (non-lvalue).NrrFT) rrVrrrr override_infor rrrrS)_super_arg_typesrtupletype_info_from_typerrurUNSUPPORTED_ARG_1_FOR_SUPERrrr UNSUPPORTED_ARG_2_FOR_SUPERrEr ValueError!SUPER_ARG_2_NOT_INSTANCE_OF_ARG_1r<TARGET_CLASS_HAS_NO_BASE_CLASSrrrer-rrrr) rrr type_type instance_type type_info instance_inforErrrrrvisit_super_exprsR        z"ExpressionChecker.visit_super_exprType | tuple[Type, Type]cCs|js ttjSt|jjdkr\|jsttj S|jj r-|j t j|ttj St|j}t|}|jj }|dusBJ|jrO|jdjjpM|}nu|j t j|ttj St|jjvro|j t j|ttj St|jjthkr|j t j|ttj St|jjdkr|j t j|ttj St|jjdkrt||jjd}||jjd}n |j t j|ttj St |tr|jrtt|j}n&ttj!|dSt |tr|j"}t |tr|jrtt|j}nttj!|dSt |tst |t#r |$s|j%&||ttj St|}t |tr5|jr.t|j}||fSttj!|dSt |trZ|j"}t |trZ|jrStt|j}||fSttj!|dS||fS)a* Computes the types of the type and instance expressions in super(T, instance), or the implicit ones for zero-argument super() expressions. Returns a single type for the whole super expression when possible (for errors, anys), otherwise the pair of computed types. rNrr"rI)'rrrrrpr<callr(rer r active_classrur%SUPER_OUTSIDE_OF_METHOD_NOT_SUPPORTEDrr top_functionr1variabler(SUPER_ENCLOSING_POSITIONAL_ARGS_REQUIREDr.r:SUPER_VARARGS_NOT_SUPPORTEDrr-SUPER_POSITIONAL_ARGS_REQUIRED#SUPER_WITH_SINGLE_ARG_NOT_SUPPORTEDrrTOO_MANY_ARGS_FOR_SUPERrrRrbrrar%first_argument_for_super_must_be_type)rr current_typer=rHr> type_item instance_itemrrrr5sz                        z"ExpressionChecker._super_arg_typescCsPt|d}|j|j|jfD]}|r"||}|j|||tj q|dS)Nr!zbuiltins.slice) rzrrrrrrrrINVALID_SLICE_INDEX)rrexpectedrrrrrvisit_slice_expr!s  z"ExpressionChecker.visit_slice_exprrJcC||jddS)Nrz check_generator_or_comprehension generatorr#rrrvisit_list_comprehension)z*ExpressionChecker.visit_list_comprehensionrXcCrT)NrzrUr#rrrvisit_set_comprehension.rYz)ExpressionChecker.visit_set_comprehensionrFcCsDt|js t|jrd}tg}nd}ttg}|j||d|dS)Nztyping.AsyncGeneratortyping.Generatorz )additional_args)r2is_asyncrvrtrrV)rrrVr\rrrvisit_generator_expr3s  z&ExpressionChecker.visit_generator_exprgenrdid_for_messagesr\list[Type] | Nonec Cs|pg}|jjjdddB||tdddg|}|g}t|tjgdg|j ||||j d||gd}| ||j gtjg|dWdS1sRwYdS) z:Type check a generator expression or a list comprehension.Trcan_skip fall_throughrrNrr) rrR frame_contextcheck_for_comprrrrr-rrr rt)rr_rdr`r\r tv_listr rrrrVBs    $z2ExpressionChecker.check_generator_or_comprehensionr@c Cs|jjjdddS||tdddg|}tdddg|}t||gtjtjgddg|j d ||g|j d d ||gd }| ||j |j gtjtjg|dWdS1s_wYdS) z&Type check a dictionary comprehension.TrrbrrrrNrrzr)rrRrerfrrrrr-rrr rrZ)rrktdefvtdefr rrrvisit_dictionary_comprehension]s&    $z0ExpressionChecker.visit_dictionary_comprehension'GeneratorExpr | DictionaryComprehensionc Cst|j|j|j|jD][\}}}}|r|j|\}}n|j|\}}|j||d||D]6}| ||j |\} } | rF|j | t j |jjjvre| durZ|jd|q/| dure|jd|q/q dS)zCheck the for_comp part of comprehensions. That is the part from 'for': ... for x in y if z Note: This adds the type information derived from the condlists to the current binder. TNF)rindices sequences condlistsr]r analyze_async_iterable_item_typerZanalyze_index_variablesrr push_type_maprrrGrr$redundant_condition_in_comprehension) rrrsequence conditionsr]r sequence_type conditiontrue_map false_maprrrrfss(  z ExpressionChecker.check_for_compr<c Cs@||j|jd}|j|j\}}tj|jjjvr5|dur)|j d|jn |dur5|j d|j|j ||j ||d}t t|pF|}|j ||j||d}tj|su|} t t| p`| } |dusjt| |st|j ||j | |d}n||kr||} n |j ||j||d} tt|jdtrt||g} | St|| } | S)NrFT)r r)rcondrrrrrrGrrredundant_condition_in_ifrif_exprrr else_exprr=r>rrrrrrrra) rrrrfif_mapelse_mapif_typeif_type_fallbackfull_context_else_type else_typeelse_type_fallbackrrrrvisit_conditional_exprsN       z(ExpressionChecker.visit_conditional_exprrdict[Expression, Type] | NonecCs~|jjjddd,|dur |j|||dtWdS|j||j|||dWdS1s8wYdS)NTrrbr)rrRrerrrq)rrrr rrrrrs $z%ExpressionChecker.analyze_cond_branchr5rc Cs||jvr |j|S|j||j}||_zC|r&t|tr&|j|dd}n2|r5t|tr5|j|dd}n#|rDt|t rD|j |dd}n|rSt|t rS|j |dd}n| |}Wn"ty{}zt||jjj|j|jj|jjWYd}~nd}~ww||_|j|dusJ|j|||jjjr|s|jjs|jrt|r|jjs|j|||jr|jjrttj S|S)zType check a node in the given type context. If allow_none_return is True and this expression is a call, allow it to return None. This applies only to this expression and not any subexpressions. TrN)!rrrrrr8rrjvisit_yield_from_exprr<rr6visit_await_exprr Exceptionrrr_filerrGr)r disallow_any_expris_stubrrrrdisallowed_any_typerrrp) rrrrr5r old_is_calleerVrrrrrsT      zExpressionChecker.acceptrrcCs |j|S)z}Return an instance type with type given by the name and no type arguments. Alias for TypeChecker.named_type. )rr)rrrrrr$s zExpressionChecker.named_typecCsBt|}t|tp t||jdttjgp t|tp t|t S)z$Is a type valid as a *args argument?r{) rrrrtrrrrrrrrrrr*s z"ExpressionChecker.is_valid_var_argcCsJt||jd|dttjgp$t||jdttgp$t|t S)z'Is a type valid as a **kwargs argument?rzrj) rtrrrrrrrrrrrrrr7s   z*ExpressionChecker.is_valid_keyword_var_argcst|}t|trt|j}t|trt|}t|tr|j}t|tr*|j St|t r:| r:|jj St|t rAdSt|trVtfdd|D}|St|tr|j}t|trht|j}t|trqt|}t|tr|j jdur|j jSt|t rdSdSdS)z*Does type have member with the given name?Tc3s|] }|VqdSr)rv)rxrYrrrr_rz/ExpressionChecker.has_member..NF)rrrr!rrrr4rrhas_readable_memberrrarrrrrrbmetaclass_typerv)rrVrYrrbrrrrvJs8             zExpressionChecker.has_membercCs|j||dS)zCalled when we can't infer the type of a variable because it's not ready yet. Either defer type checking of the enclosing function to the next pass or report an error. N)rr)rrr rrrnot_ready_callbackqsz$ExpressionChecker.not_ready_callbackricCs|jjd}|j|d}|jdur)tt|ttfs(|jr(|j t j |n| |j|}|j |||t jdd|j|dS)NrF actual type expected type)rrget_generator_yield_typerrrrrrrurYIELD_VALUE_EXPECTEDrrINCOMPATIBLE_TYPES_IN_YIELDget_generator_receive_type)rr return_typeexpected_item_typeactual_item_typerrrvisit_yield_exprys&  z"ExpressionChecker.visit_yield_exprr6cCs|jd}|dur|jd|g}t||j|}t|tr&ttj |dS| ||t j }|s?tt|t r?|jjd||S)Nrtyping.AwaitablerI)rrrrrrrrrrRcheck_awaitable_exprrINCOMPATIBLE_TYPES_IN_AWAITrrrU)rrr expected_typerrrrrrs  z"ExpressionChecker.visit_await_exprrstr | ErrorMessage ignore_bindercCsv|j||d||ddsttjS|d|gg|d}|j|d}t|}|s9t |t r9|j s9|jj |S)zyCheck the argument to `await` and extract the type of value. Also used by `async for` and `async with`. rrr __await__rF)rrrrrrrWget_generator_return_typerrrrQrRrS)rrrfrrrWrrrrrs  z&ExpressionChecker.check_awaitable_exprrjc Cs|jjd}t||j}t|trttj|d}nP|j |rMt |r1t |s1|jj ||ttj}|jd|||g}|jd|gg|d\}}nt |rUt |sc|jj ||ttj}n|||tj}|j|d} |j|d} |j| | |tjddt|}t|tr|jjdkr|j|d} nt| } t| trttj| d} nt} |stt| tr|jj d|| S) NrrIr[__iter__ryFrr)rrrrrrrrrRtype_is_iterable is_async_defhas_coroutine_decoratorryield_from_invalid_operand_typerrrWr rr INCOMPATIBLE_TYPES_IN_YIELD_FROMrrrrrrrrU) rrrr subexpr_type iter_typer~generic_generator_typerrr expr_typerrrrsP          z'ExpressionChecker.visit_yield_from_exprr_cC|jSrrr#rrrvisit_temp_nodez!ExpressionChecker.visit_temp_noderecC ttjSrrrrr#rrrvisit_type_var_exprrz%ExpressionChecker.visit_type_var_exprrScCrrrr#rrrvisit_paramspec_exprrz&ExpressionChecker.visit_paramspec_exprrfcCrrrr#rrrvisit_type_var_tuple_exprrz+ExpressionChecker.visit_type_var_tuple_exprrPcCrrrr#rrrvisit_newtype_exprrz$ExpressionChecker.visit_newtype_exprrNcCsT|jj}|r%|jjjrt|r|jd||t||jj|jj |j|dt t j S)NzNamedTuple typery) re tuple_typerrGrryrrrwrrrr)rrrrrrvisit_namedtuple_exprs  z'ExpressionChecker.visit_namedtuple_exprrBcCsft|j|jD]&\}}|dur-||}tt|ts-|jj|j }t|t r-||_ d|_ qtt jSrY)rrrrrrrrerrrhrrprr)rrrrZrVrrrrvisit_enum_call_exprs   z&ExpressionChecker.visit_enum_call_exprrccCrrrr#rrrvisit_typeddict_expr"rz&ExpressionChecker.visit_typeddict_exprrUcCrrrr#rrrvisit__promote_expr%rz%ExpressionChecker.visit__promote_exprr[rcCst||jSr)rrrr#rrrvisit_star_expr(z!ExpressionChecker.visit_star_exprcCr))zReturn instance type 'object'.rr*rrrrr+r,zExpressionChecker.object_typecCr))zReturn instance type 'bool'.r r*rrrrrX/r,zExpressionChecker.bool_type known_typecCdSrr)rrrrrrr3sz)ExpressionChecker.narrow_type_from_binderrcCrrr)rrrrrrrr7scCsXt|tkr*|jj|}|r*tt|tr|jjs*|r%t ||dds%dSt ||S|S)zNarrow down a known type of expression using information in conditional type binder. If 'skip_non_overlapping' is True, return None if the type and restriction are non-overlapping. T)prohibit_none_typevar_overlapN) r&r1rrRrhrrrrr(r))rrrr restrictionrrrr=s   )rrrr+rrorrrr)rrOrrF)rrVrrrr)rrhr r=rr)rr8rrrr)rrCrr)rr8rr)rrr_r\rr`rrCrr)rjrkrr)r8rr:rzr;r{r(r|r r=r}r~rr)rr?rr)r8rrr?r r=rr) r8rrr?r r=r}r~rr)rerdrr)r8rrr) r8rrrr r=r}r~rr)rrLrr)rrVrr)rr8rr\rrhrr)r8rr:rzrWrr;rr3rr(r|rr\rr~r r=rr) r8rr(r|r:rzr;rrrrr)r8rr(r|r:rzr r=r;rrrrr)r8rr(r|r:rzr r=r;rrrrrrrr/)rr`r8rr(r|r:rzr r=r;rrr~rrr) rXrrr8rr`rr~rYr`rr)rr8rrrYr\rr)NNNN)r8rr(r|r:rzr r=r;rr rrr`rr~rr)r8rr(r|r:rzr r=r;rr rrr`rr~rr)rrdr>r\rr)rbrr r=rr)r(r|rr)rrrrX) r8rr(r|r:rzr3rrr)r_rr`r=rr) rXrr(r|r:rzr3rr r=rr)rXrr(r|r:rzr3rrvrwr r=rrx)rr#)rWrr3rr|r}rr~)rXrrtrwr r=rr)r8rrrrrzrrr3rr rrr~rr`rr)r8rrrrrzrrrrr r=rr)rrrr\r r=rr)rWrr:rzr(r|r8rr3rr r=rrrr~rr)rrrrrr3rXrrr}rr}r8rrr~r r=rr=rr)r8rr(r|r:rzr;rrr`rr~r r=rr) rWrr:rzr;rr rrr)rrr(r|rWrr:rzr;rrr`rr~r r=rr)rrrWrr:rzr;rr(r|r r=rrr)rrr(r|rWrr:rzr;rrr`rr~r r=rr}rrr)rrrrrrX)rrrr)rWrr:rzr;rr(r|r8rr r=rr) r_rrrwr r=rbrrr)r(r|r8rrr) r8rr(r|r:rzr;rr r=rr)rrLrrrr)rYr\rrr r=rr)rr)rZrrr\rr)rrrrrr)rrHrr)rr\rr)rr7rr)rrDrr)rr;rr)rrArr)rrQrr)rr:rr)rrCrr~)rrrrrOr~rr)rHr\rrr(r|r:rzr r=rr~rr)rHr\rrr(r|r:rzr r=rr~rr)r_r\rrrArr(r|r:rzr r=rr)rsr\rCrrtrCrcrrurCr r=rr) rHr\rrrVrCr r=r8rrr)rrQr r=rr)rr5rr)rrgrr)rrGrr)rCrrrGrrrr)rCrrrZrr)rrCrr)rCrrrCrr)rrrrCrr)rrdrrCr r=rr)rr9rr)rr4rr)rrWrr)rrbrr)rrarr) rr rrrfr=rrrr)rwrr(rrfr=rr)rrKrr)rrYrr)rrrr\rr~)rrrr\rr\rr)rr`rr)rr?rr~)rr?rr)r r~rr?rr )rrIrr)rrIrr.)rr]rr)rr]rrB)rrZrr)rrJrr)rrXrr)rrFrr) r_rFrdr\r`r\r\rarr)rr@rr)rrkrr)rr<rrrr) rrrrCr r~rrrr)NFFF) rrCrr~rrr5rrrrr)rr\rr)rVrrYr\rr)rr\r r=rr)rrirr)rr6rrrr) rrrfr=rrrrrr)rrjrrrr)rr_rr)rrerr)rrSrr)rrfrr)rrPrr)rrNrr)rrBrr)rrcrr)rrUrr)rr[rr)rr)rrCrrrr)rrCrrrrrr~)rrrr__annotations__rrrrrrrrrPrfrTrgrNrOr9rrrrrrrrrrErrrrrrr rMr r rr/r"rWrr\r9r3r$rmrlrkrqr:rrr;rrrrrrrrrrrerrrrrrrrr$r&r(r+r-r.rIrgrVr\rWrorprr@r:r;rrrrrrrrrrrrrrrrrrrrrrrrrr-r&rAr5rSrXrZr^rVrjrfrrrrrrrvrrrrrrrrrrrrrrrrrXr rrrrrrs     E        &   A   ' + G / 3# j   ,   L H )   @ = 2 1  7 N a S:  vJ+8qN >"#  &5">/Q 9<RQ4 'E rFrignore_in_type_objcCs|t|S)zWhether t contains an Any type)r HasAnyType)rrrrrrVr%rcs6eZdZdfdd Zdd d Zdfd d ZZS)rrrrrcstt||_dSr)superrr2r)rr __class__rrr\s  zHasAnyType.__init__rrcCs |jtjkSr) type_of_anyrrrrrrr visit_any`s zHasAnyType.visit_anyrcs|jr |r dSt|S)NF)rrarvisit_callable_typerrrrrcs zHasAnyType.visit_callable_type)rrrr)rrrrrrrr)rrrrrr __classcell__rrrrr[s rcCst|}t|to|jjdkS)z;Whether t came from a function decorated with `@coroutine`.typing.AwaitableGenerator)rrrrrrrrrrisrcCsPt|}t|tr|jjdkrt|jdkrt|jd}t|to'|jjdkS)z9Whether t came from a function defined using `async def`.rr3ztyping.Coroutine)rrrrrr<r(rrrrros rcCst|}t|to t|jSr)rrrrrrrrrrsrmappingr~rrrrzcsXt|dko+t|dko|dtjko|dtjk o+tfdd|D S)Nrr"rc3s2|]}|tjkott|t VqdSr)rr/rrr)rrrrrrrs  z'is_duplicate_mapping..)r<rr.r/r)rrrrrrrs   rrPrrCcCs |j|dS)z>Return a copy of a callable type with a different return type.r(rN)rPrCrrrr+s r+c,eZdZdZd fdd Zd d d ZZS) rzQuery whether an argument type should be inferred in the second pass. The result is True if the type has a type variable in a callable return type anywhere. For example, the result for Callable[[], T] is True if t is a type variable. rrcttdSrrrr2rrrrrrz ArgInferSecondPassQuery.__init__rrrcCs||jp |tSr) query_typesrWrHasTypeVarQueryrrrrrsz+ArgInferSecondPassQuery.visit_callable_typerr)rrrrrrrrrrrrsrcr) rzBVisitor for querying whether a type has a type variable component.rrcrrrrrrrrrzHasTypeVarQuery.__init__rrrcCdSrYrrrrrvisit_type_varzHasTypeVarQuery.visit_type_varr)rrrr)rrrrrrrrrrrrrr~cC|duo |tSr)rHasErasedComponentsQueryrrrrrUrUcr) rz.is_typetype_likeTc3s|]}t|VqdSrr rm)rrrrrnz-arg_approximate_similarity..c3s|]}t|VqdSrrrm)rrrrrnrN)rVrrr)rrrr~rrrrr2rrr r4rrrrrrErtrr)rrrr)rrrr s<               r rrrrWr:r;rcst|rdSfdd|D}tD]B\}t|ddrWfddt|D}g}g} |D]\} } || } || j| D] } | | j| q@q0t| sWt|sWdSqdS)aMay an argument containing 'Any' cause ambiguous result type on call to overloaded function? Note that this sometimes returns True even if there is no ambiguity, since a correct implementation would be complex (and the call would be imprecisely typed due to Any types anyway). Args: items: Overload items matching the actual arguments arg_types: Actual argument types arg_kinds: Actual argument kinds arg_names: Actual argument names Fc s(g|]}t|j|jfddqS)crrrr)rrrr,6rz:any_causes_overload_ambiguity...)rr:r;rm)r:r;rWrrr/4s z1any_causes_overload_ambiguity..T)rcs$g|]\}}|r||fqSrr)ritem_idxlookup)arg_idxrrr/@s  )rrrrrrW)rrrWr:r;actual_to_formalrmatching_formals_unfilteredmatching_returnsmatching_formalsrformalsmatched_callablerr)rr:r;rWrrs,    rrcs.tdkrdStfddddDS)NrTc3s|] }t|dVqdS)rN)rsr rrrr[sz!all_same_types..r)r<rrrrrrXs rrSequence[CallableType],tuple[list[CallableType], list[TypeVarType]]cCsg}i}g}|D]C}|rFt|}i}|jD]&}|j}||vr6t|tr&qt|ts-J|||<||||||j<qt t t ||}||q||fS)a<Takes all the typevars present in the callables and 'combines' the ones with the same name. For example, suppose we have two callables with signatures "f(x: T, y: S) -> T" and "f(x: List[Tuple[T, S]]) -> Tuple[T, S]". Both callables use typevars named "T" and "S", but we treat them as distinct, unrelated typevars. (E.g. they could both have distinct ids.) If we pass in both callables into this function, it returns a list containing two new callables that are identical in signature, but use the same underlying TypeVarType for T and S. This is useful if we want to take the output lists and "merge" them into one callable in some way -- for example, when unioning together overloads. Returns both the new list of callables and a list of all distinct TypeVarType objects used. ) r1r"rrrrrrr8r rr )rrunique_typevarsrrrenamer rrrrr^s&    rrVcCs&t|}t|tr|jdur|jS|S)z>If possible, get a more precise literal type for a given type.N)rrrrrrrrr[sr[rrCcCsRt|tr|j}t|to|jtvSt|tr'|j}t|to&tt |j t SdS)z-Returns 'true' if the given node is a LiteralF) rrGrrVrrrOrr rrr)rr underlyingrrrrAs    rAcCsLt|}ddh}t|trtdd|jDSt|tr$|jj|vr$dSdS)z?Is this one of builtin byte types, or a union that contains it?r'zbuiltins.bytearraycss|]}t|VqdSr)rlr rrrrrz&has_bytes_component..TF)rrrr2rrrr)rV byte_typesrrrrls rlTypeInfo | NonecCslt|}t|tr|r|St|tr|j}t|tr#t|j}t|t r,t |}t|t r4|j SdS)zXGets the TypeInfo for a type, indirecting through things like type variables and tuples.N) rrrrarrrrbrr!rrrrrrrrr7s     r7rr`cCsD|durdS|dd}|tjvp!|tjvp!|tjvS)NFrr)splitrr?rr{r)r short_namerrrrs  rPartialType | NonecCs$|dust|tr|jdurdS|Sr)rrrrrrrrsr)rrrr)rrVrrr)rrrrrr)rrrr)rr~rrrrzrr)rPrrCrrr)rr~rr)rrrrrr) rrrrrWrr:rzr;rrr)rrrr)rrrr)rVrrrrr)rVrrr)rr`rr)rr~rr)r __future__rr contextlibrtypingrrrrrr r typing_extensionsr r rr mypy.checkerr=mypy.errorcodes errorcodesrrrrrrrr mypy.argmaprrrmypy.checkmemberrrmypy.checkstrformatrmypy.erasetyperrr mypy.errorsrrmypy.expandtyper r!r" mypy.inferr#r$r% mypy.literalsr& mypy.maptyper' mypy.meetr(r)mypy.message_registryr* mypy.messagesr+ mypy.nodesr,r-r.r/r0r1r2r3r4r5r6r7r8r9r:r;r<r=r>r?r@rArBrCrDrErFrGrHrIrJrKrLrMrNrOrPrQrRrSrTrUrVrWrXrYrZr[r\r]r^r_r`rarbrcrdrerfrgrhrirj mypy.pluginrkrlrmrnromypy.semanal_enumrp mypy.staterq mypy.subtypesrrrsrtrumypy.traverserrv mypy.typeanalrwrxryrzr{ mypy.typeopsr|r}r~rrrrrrrrr mypy.typesrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrmypy.typestater mypy.typevarsr mypy.utilr mypy.visitorrr}rrrrrrrrrrr TypeQueryrrrrrrr+rrrUrrdrr rrrr[rArlr7rrrrrrs  $ $      B   8 #                ? :  -