ML i) fUdZddlmZddlmZmZmZddlmZddl m Z m Z m Z m Z mZddlmZmZddlmZmZddlmZdd lmZmZdd lmZmZdd lm Z m!Z!dd l"m#Z#dd l$m%Z%m&Z&m'Z'm(Z(m)Z)ddl*m+Z+m,Z,ddl-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;mZ>m?Z?m@Z@mAZAmBZBmCZCmDZDmEZEmFZFmGZGmHZHmIZImJZJmKZKmLZLmMZMmNZNmOZOmPZPmQZQmRZRmSZSmTZTmUZUmVZVmWZWmXZXmYZYmZZZm[Z[m\Z\m]Z]m^Z^m_Z_m`Z`maZambZbmcZcmdZdmeZemfZfmgZgmhZhmiZimjZjmkZkmlZlmmZmmnZnmoZompZpmqZqmrZrmsZsmtZtmuZumvZvmwZwmxZxmyZymzZzm{Z{m|Z|m}Z}m~Z~mZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZddlmZddlmZmZmZmZmZmZmZmZddlmZmZmZmZddlmZddlmZmZmZmZmZmZmZddlmZddlmZddlmZddlmZddlmZmZmZmZmZmZmZmZmZddlmZddlmZddlmZmZmZmZmZmZmZmZmZmZmZmZmZddlmZmZmZddlmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZm Z m Z m Z m Z m Z mZmZmZmZmZmZmZmZmZmZmZmZmZddlmZmZdd lmZdd!l m!Z!m"Z"m#Z#m$Z$m%Z%dd"l&m'Z'e d#Z(d$d%d&d'd(d)d*d+d,d-d. Z)d/e*d0<gd1Z+d/e*d2<dZ,d/e*d3<d4Z-d/e*d5<d6Z.d/e*d7<d8Z/d/e*d9<d:Z0d/e*d;<e1Z2d<e*d=<Gd>d?e'd@eeZ3dTdAZ4dUdBZ5dVdCZ6dWdDZ7dXdEZ8dYdFZ9GdGdHeZ:dYdIZ;GdJdKeZd\dNZ?d]dOZ@d^dPZAd_dQZBd`dRZCdadSZDy@)baThe semantic analyzer. Bind names to definitions and do various other simple consistency checks. Populate symbol tables. The semantic analyzer also detects special forms which reuse generic syntax such as NamedTuple and cast(). Multiple analysis iterations may be needed to analyze forward references and import cycles. Each iteration "fills in" additional bindings and references until everything has been bound. For example, consider this program: x = 1 y = x Here semantic analysis would detect that the assignment 'x = 1' defines a new variable, the type of which is to be inferred (in a later pass; type inference or type checking is not part of semantic analysis). Also, it would bind both references to 'x' to the same module-level variable (Var) node. The second assignment would also be analyzed, and the type of 'y' marked as being inferred. Semantic analysis of types is implemented in typeanal.py. See semanal_main.py for the top-level logic. Some important properties: * After semantic analysis is complete, no PlaceholderNode and PlaceholderType instances should remain. During semantic analysis, if we encounter one of these, the current target should be deferred. * A TypeInfo is only created once we know certain basic information about a type, such as the MRO, existence of a Tuple base class (e.g., for named tuples), and whether we have a TypedDict. We use a temporary PlaceholderNode node in the symbol table if some such information is missing. * For assignments, we only add a non-placeholder symbol table entry once we know the sort of thing being defined (variable, NamedTuple, type alias, etc.). * Every part of the analysis step must support multiple iterations over the same AST nodes, and each iteration must be able to fill in arbitrary things that were missing or incomplete in previous iterations. * Changes performed by the analysis need to be reversible, since mypy daemon strips and reuses existing ASTs (to improve performance and/or reduce memory use). ) annotations) CollectionIterableIterator)contextmanager)AnyCallableFinalTypeVarcast) TypeAlias TypeGuard) errorcodesmessage_registry)constant_fold_expr)PROPERTY_DECORATOR ErrorCode)Errorsreport_internal_error)TypeTranslationErrorexpr_to_unanalyzed_type) ErrorMessage)SUGGESTED_TEST_FIXTURESTYPES_FOR_UNIMPORTED_HINTSMessageBuilder best_matches pretty_seq)MroError calculate_mro)w ARG_NAMEDARG_POS ARG_STAR2 CONTRAVARIANT COVARIANTGDEFIMPLICITLY_ABSTRACT INVARIANT IS_ABSTRACTLDEFMDEF NOT_ABSTRACTPARAM_SPEC_KIND REVEAL_LOCALS REVEAL_TYPERUNTIME_PROTOCOL_DECOSSYMBOL_FUNCBASE_TYPES TYPE_VAR_KINDTYPE_VAR_TUPLE_KINDVARIANCE_NOT_READYArgKind AssertStmtAssertTypeExprAssignmentExprAssignmentStmt AwaitExprBlock BreakStmt BytesExprCallExprCastExprClassDefComparisonExpr ComplexExprConditionalExprContext ContinueStmtDataclassTransformSpec DecoratorDelStmtDictExprDictionaryComprehension EllipsisExpr EnumCallExpr ExpressionExpressionStmtFakeExpression FloatExprForStmtFuncBaseFuncDefFuncItem GeneratorExpr GlobalDeclIfStmtImport ImportAll ImportBase ImportFrom IndexExprIntExpr LambdaExprListComprehensionListExprLvalue MatchStmt MemberExprMypyFileNamedTupleExprNameExprNode NonlocalDeclOperatorAssignmentStmtOpExprOverloadedFuncDef OverloadPart ParamSpecExprPassStmtPlaceholderNode PromoteExpr RaiseStmtRefExpr ReturnStmt RevealExprSetComprehensionSetExpr SliceExprStarExpr StatementStrExpr SuperExpr SymbolNode SymbolTableSymbolTableNodeTempNodeTryStmt TupleExprr TypeAliasExpr TypeAliasStmtTypeApplication TypedDictExprTypeInfo TypeParam TypeVarExprTypeVarLikeExprTypeVarTupleExpr UnaryExprVar WhileStmtWithStmt YieldExpr YieldFromExprget_member_expr_fullnameimplicit_module_attrs is_final_node type_aliasestype_aliases_source_versionstyping_extensions_aliases)Options) AsPattern ClassPatternMappingPattern OrPatternSequencePatternSingletonPatternStarredPattern ValuePattern)ClassDefContextDynamicClassDefContextPluginSemanticAnalyzerPluginInterface) dataclasses) ALWAYS_FALSE ALWAYS_TRUE MYPY_FALSE MYPY_TRUEinfer_condition_value"infer_reachability_of_if_statement%infer_reachability_of_match_statement)Scope)EnumCallAnalyzer)NamedTupleAnalyzer)NewTypeAnalyzer) ALLOW_INCOMPATIBLE_OVERRIDEPRIORITY_FALLBACKSSemanticAnalyzerInterfacecalculate_tuple_fallbackfind_dataclass_transform_spechas_placeholder parse_boolrequire_bool_literal_argumentset_callable_name)TypedDictAnalyzer)TypeVarLikeScope) SELF_TYPE_NAMESFindTypeVarVisitor TypeAnalyserTypeVarDefaultTranslatorTypeVarLikeListanalyze_type_aliascheck_for_explicit_anydetect_diverging_aliasfind_self_type fix_instancehas_any_from_unimported_typetype_constructorsvalidate_instance) function_type get_type_vars"try_getting_str_literals_from_type)3ASSERT_TYPE_NAMESDATACLASS_TRANSFORM_NAMESDEPRECATED_TYPE_NAMESDISJOINT_BASE_DECORATOR_NAMESFINAL_DECORATOR_NAMESFINAL_TYPE_NAMESIMPORTED_REVEAL_TYPE_NAMES NEVER_NAMESOVERLOAD_NAMESOVERRIDE_DECORATOR_NAMESPROTOCOL_NAMESREVEAL_TYPE_NAMES TPDICT_NAMESTYPE_ALIAS_NAMESTYPE_CHECK_ONLY_NAMES TYPE_NAMESTYPE_VAR_LIKE_NAMESTYPED_NAMEDTUPLE_NAMESUNPACK_TYPE_NAMESAnyType CallableType FunctionLikeInstance LiteralTypeNoneType Overloaded Parameters ParamSpecTypePlaceholderType ProperTypeTrivialSyntheticTypeTranslator TupleTypeType TypeAliasType TypedDictType TypeOfAnyTypeType TypeVarIdTypeVarLikeTypeTypeVarTupleType TypeVarType UnboundType UnionType UnpackTypeflatten_nested_tuplesget_proper_typeget_proper_types has_type_varsis_named_instance remove_dupstype_vars_as_args)is_invalid_recursive_aliasstore_argument_type) fill_typevars)correct_relative_import is_dunder module_prefixunmangleunnamed_function) NodeVisitorT nested_scopes generatorsdivisionabsolute_importwith_statementprint_functionunicode_literalsbarry_as_FLUFLgenerator_stopr) z__future__.nested_scopesz__future__.generatorsz__future__.divisionz__future__.absolute_importz__future__.with_statementz__future__.print_functionz__future__.unicode_literalsz__future__.barry_as_FLUFLz__future__.generator_stopz__future__.annotationsr FUTURE_IMPORTS)objectboolfunctionCORE_BUILTIN_CLASSES SCOPE_GLOBAL SCOPE_CLASS SCOPE_FUNCSCOPE_COMPREHENSIONSCOPE_ANNOTATION _TypeAliasTagc 2eZdZUdZgdZded<ded<ded<ded <d ed <d ed <d ed<dZded<ded<ded<ded<ded<dZdZdZ dZ ded<ded<d ed<dZ dZ dZ d ed!<d"ed#<d$ed%<dZd&ed'<iZd(ed)< dbd*Zedcd+Zeddd,Zeddd-Zeddd.Zeded/Ze df dgd0Zdhd1Zdid2Zdhd3Z dj dkd4Zdhd5Zdhd6Zdld7Zdld8Z dmd9Z!dnd:Z"e dj dod;Z#dpd<Z$dqd=Z%dpd>Z&drd?Z'dsd@Z(dtdAZ)dudBZ*dvdCZ+dndDZ,dwdEZ-edxdFZ.dwdGZ/dwdHZ0e1dydIZ2dwdJZ3 dzdKZ4 d{dLZ5dwdMZ6dwdNZ7dwdOZ8 d|dPZ9 d}dQZ:d~dRZ;ddSZ<ddTZ=ddUZ>ddVZ?ddWZ@ddXZAddYZB ddZZCdd[ZD dd\ZEdd]ZFdd^ZGdd_ZHdd`ZIddaZJddbZKddcZLdddZM ddeZNddfZOddgZPddhZQddiZRdndjZSddkZT ddlZU ddmZVddnZWddoZX d ddpZYddqZZ ddrZ[ ddsZ\ddtZ] d dduZ^ddvZ_ddwZ` ddxZa ddyZbddzZcdd{Zddd|Ze dj dd}Zfdd~ZgddZhddZiddZj ddZkddZlddZmddZn ddZo d ddZp ddZqddZrddZsddZtddZuddZvddZwddZxdfddZyddZzddZ{dfddZ|ddZ}ddZ~ddZddZddZddZddZddZddZddZddZddZddZddZddZ d ddZddZddZddZ ddZ ddZ d ddZ ddZddZddZ ddZ ddZdfddZ ddZddZddZddZddZddZddZddZddZ ddZ ddZddddd ddZddZddZddZddZdd„ZddÄZddĄZddńZddƄZ ddDŽZddȄZddɄZddʄZdd˄Zdd̄Zdd̈́Zdd΄ZddτZddЄZddфZdd҄ZddӄZddԄZddՄZddքZddׄZdd؄ZddلZddڄZddۄZdd܄ZÐdd݄ZĐddބZŐdd߄ZƐddZǐddZȐddZɐddZʐddZːddZ̐ddZ͐ddZΐddZϐddZАddZѐddZҐddZӐddZԐddZՐddZ֐ddZאddZؐddZِddZڐddZېddZܐddZݐddZސddZߐddZddZddZddZddZddZddZddZddZddZddZd dZd dZd dZd dZd dZdd Z df dd Zdd Zdd Zdd ZddZddZddZ df ddZddZddZddZ ddZ ddZddZddZddZddZddZdjddZdjddZddZddZ d d!d Zd"d!Z d# d$d"Z d%d#Z d&d$Z d'd%Z d(d&Z d)d'Zed*d(Zdd+d)Zd,d*Zd-d+Zdnd,Z d. d/d-Zd0d.Z df d1d/Zd2d0Zd3d1Ze d4d2Zddd3Zddd4Zddd5Zddd6Zd5d7Z d d6d8Zdd9Z d7d:Z!djd8d;Z" d9d<Z# dj d:d=Z$ dj d:d>Z%dd?Z&ddd@Z' dfdddA d;dBZ(djd<dCZ)d=dDZ*d>dEZ+ d? d@dFZ,dAdGZ-dddddddddddddH dBdIZ.dfdCdJZ/dddddddddddddH dDdKZ0dEdLZ1dFdMZ2dndNZ3djdGdOZ4 dj dHdPZ5ddQZ6ddRZ7dIdSZ8ddTZ9dJdUZ:dKdVZ;dLdWZ<dMdXZ=dNdYZ>dOdZZ?dPd[Z@dQd\ZAdRd]ZBdSd^ZCdTd_ZDdUd`ZEdVdaZFy(WSemanticAnalyzerzSemantically analyze parsed mypy files. The analyzer binds names and does various consistency checks for an AST. Note that type checking is performed as a separate pass. )patchesoptions cur_mod_nodedict[str, MypyFile]modulesr|globalszlist[set[str]] global_declsnonlocal_declszlist[SymbolTable | None]locals list[int] scope_stack block_depthNTypeInfo | None_typezlist[TypeInfo | None] type_stackr tvar_scoperr#zlist[FuncItem]function_stackF missing_names$list[tuple[int, Callable[[], None]]]r" loop_depthset[str]importsrerrorsrpluginzStatement | None statementzdict[FuncDef, Type]wrapped_coro_return_typescdg|_tg|_i|_t |_d|_g|_g|_t|_ g|_ dg|_ dg|_ ||_||_t!|||_||_t g|_||_g|_i|_||_d|_t3|_g|_d|_d|_d|_d|_d|_ d|_!d|_"d|_#y)aConstruct semantic analyzer. We reuse the same semantic analyzer instance across multiple modules. Args: modules: Global modules dictionary missing_modules: Modules that could not be imported encountered so far incomplete_namespaces: Namespaces that are being populated during semantic analysis (can contain modules and classes within the current SCC; mutated by the caller) errors: Report analysis errors using this instance NrTF)$r*rr, saved_localssetr8r/r0incomplete_type_stackrr1r2r-r5r9r&rmsgmissing_modulesr3incomplete_namespaces all_exports export_mapr:recurse_into_functionsrscopedeferral_debug_contextbasic_type_applicationsallow_unbound_tvarscurrent_overload_iteminside_except_star_block$return_stmt_inside_except_star_block _str_type_function_type _object_type)selfr&rBrCr9r:s R/mnt/ssd/data/python-lab/Trading/venv/lib/python3.12/site-packages/mypy/semanal.py__init__zSemanticAnalyzer.__init__s&f (>  u  13"*, 3#  !&'2.!eW&;"&(02 '+#W >@#(-$ $) 26"/4%:?1*./3-1c|jSN)r/rQs rRtypezSemanticAnalyzer.types zzrTc|jSrV) _is_stub_filerWs rR is_stub_filezSemanticAnalyzer.is_stub_files!!!rTc|jSrV)_is_typeshed_stub_filerWs rRis_typeshed_stub_filez&SemanticAnalyzer.is_typeshed_stub_files***rTc|jSrV)_final_iterationrWs rRfinal_iterationz SemanticAnalyzer.final_iterations$$$rTc#bK|j}d|_ d||_y#||_wxYwwNTrJ)rQolds rRallow_unbound_tvars_setz(SemanticAnalyzer.allow_unbound_tvars_set s1&&#'  + '*D $sD $s/#/ ,/c#K|j}||_|s|j}||_ d||_|s|_yy#||_|s|_wwxYwwrV)rLrM)rQvalue entering_loopreold_return_stmt_flags rRinside_except_star_block_setz-SemanticAnalyzer.inside_except_star_block_setsp++(-%#'#L#L 8=D 5 Q ,/D ) dfd jy)zRemove dummy alias definitions such as List = TypeAlias(object) from typing. They will be replaced with real aliases when corresponding targets are ready. c|jD]}t|trK|jD]}|j|jr|jjt|t sot |jdk(st|jdtsjd|jdjvs|j|y)Nrr.) copy isinstancerVbody else_bodyr8lenlvaluesrerrnameremove)defsstmtr|aliasesruhelpers rRrz9SemanticAnalyzer.prepare_typing_namespace..helperDs *dF+ $ *tyy)*~~t~~223t^4DLL)Q."4<<?H=$,,-Qt||A/C/C.DEP D) *rTN)rzlist[Statement]returnNone)r)rQrurrs ``@rRrtz)SemanticAnalyzer.prepare_typing_namespace7s * y~~rTc(|j}tD]I}t|tg}t t |d}d||_tt|||<K|dj}t|tsJt|g}dtfdttjfdttjfd|fd|fd |fg}|D]8\}} t!|| } d|| _tt| |j|<:y ) zAdd certain special-cased definitions to the builtins module. Some definitions are too special or fundamental to be processed normally from the AST. rm builtins.rr reveal_type reveal_localsTrueFalse __debug__N)rqrr?r:rr| _fullnamer}r%noder{rrrr special_formr) rQrurqrcdefinfo bool_info bool_typespecial_var_typestypvs rRrsz+SemanticAnalyzer.prepare_builtins_namespaceVs" ) 6DD%),DKM4 Y  i ) $ 5 + =ID#D#A%dV,AK$3D!$2H,224= GD!y $# 557.. K<#33`5``3JJL**..#h 8N8N0O%P< 00JIJ0JJL#<<55223DED223STD<++#667HI#/N1NN/ >>Z/$//xz0BCD}L(EdV&LL}!!n **40H#Jx}}o,VnnS)G$( $ 3 3D 9 # c=?;#D$7$7$=y"M!Os= rTcl|jdk(sJtjD]\}}|tvr!t||jj kDr/|j dd}||jvr(t|j|jtsy|j||||y)aaAdd builtin type aliases to typing module. For historical reasons, the aliases like `List = list` are not defined in typeshed stubs for typing module. Instead we need to manually add the corresponding nodes on the fly. We explicitly mark these aliases as normalized, so that a user can write `typing.List[int]`. roryrN) rrrrrr#python_versionsplitrqr{rrn create_aliasrQtreealias target_namers rRrz$SemanticAnalyzer.add_builtin_aliasess}}((("."4"4"6 > E;5507$,,:U:UU;;s#B'Dtzz!*TZZ5E5J5JO*\   dK = >rTcR|jdk(sJtjD]\}}|jdd}||jvr(t |j|j trP|jj|d|j||||y)zTyping extensions module does contain some type aliases. We need to analyze them as such, because in typeshed they are just defined as `_Alias()` call. Which is not supported natively. rpryrN) rrrrrrqr{rr poprrs rRrz-SemanticAnalyzer.add_typing_extension_aliasess}} 3333";"A"A"C > E;;;s#B'Dtzz!jD1A1F1F &R JJNN4 &   dK = >rTcH|j}|j|}|rt|jtr|j ||y|j |g}|Jt||j|jd|jt||dddd}|j|||y|j|r|j ||y||jvr7t|j|jtsJ|j|=yy)NF disallow_anyr#rT)rrno_args normalized)track_incomplete_refslookup_fully_qualified_or_noner{rrnmark_incompleterrrnoter#r rfound_incomplete_refrq) rQrrrrtagrtarget alias_nodes rRrzSemanticAnalyzer.create_aliass ((*  / / < !&&/2$$T4000bA)))DIItyyudll' #  j$7  & &s +  t ,tzz!!$**T"2"7"7IIIJJt$"rTcd|jvrG|jjD])\}}||jvrd|_d|_#d|_+yy)z7Adjust the module visibility of globals due to __all__.__all__TFN)r'rrD module_public module_hidden)rQrgs rRrz&SemanticAnalyzer.adjust_public_exports<sX  $<<--/ ,a4+++&*AO&+AO',AO , %rTc#K|j}||_|jj|j|j ||||_|j |_|j|j5|jjjd|_ |j||_ |j|_t!|_t%|||j&|_t+|||j&|_t/|||_t3|||j&|_d|_|r|j j9ddd}d|vr>|j;|}|r+t=|j>t@r|j>|_!|jE|jFjH|jF|jJjMd|jO||jO|jFjP|jFjRD]}|j"jU|d|rf|jW|jWd|_!|jJjY|j[|jFjHddd|`y#1swY|`yxYww)zConfigure analyzer for analyzing targets within a file/class. Args: file_node: target file options: options specific to the file active_type: must be the surrounding class to analyze method targets )rGr#z.pyirryrFN).rGr#r9set_filepathrrr$r module_scopelowerendswithrZis_typeshed_filer]rqr'rr1rrAnamed_tuple_analyzerrtyped_dict_analyzerrenum_call_analyzerrnewtype_analyzernum_incomplete_refsrsplitrr{rrr/push_type_argsdefn type_argsr@append enter_classr type_vars bind_existing leave_classr pop_type_args)rQrur#rrGenclosing_fullnameenclosing_nodetvars rRrzSemanticAnalyzer.file_contextIs^   Y^^Y-?-?uV]^%#,,    0# ?!*!5!5!7!@!@!HD *3*D*DW*MD '$??DL.0DO(:7D$(((SD %'8$'QD $&6w&ED #$3GT488$LD !()D $%0%9%9%@%@a%H%K",,%)%H%HI[%\N%*^5H5H(*S%3%8%8 ##K$4$4$>$> @P@PQ**11%8!!+.  !1!1!6!67',,668DOO11$78 !!#  "! **..0"";#3#3#=#=>G# ?H LI# ?H LsA:K-> -C&&t, -#..r2Q6,,TYY7 **c$2E2E.F.J$$T-=-=11$7**  ZZ & &t , ,222? ,%%d+ , , , , , , ,s$-D/D#D/#D, (D//D8c@|j|S|d|jS)N#rKrQrrs rRfunction_fullnamez"SemanticAnalyzer.function_fullnames+  % % -O1T77899rTc |j|j||j|y|jj ||j r9t |j tsJ|j|j |}nd}|jj|jr|j J|j |_ |j |jdvrrt |j tsJt t|j jtr)|j j!t#|_|j%||j ||j'|j(}|j+|j,j/|5|j r|j1|j t |j tsJ|j3}|j5}|j7|j d|}|j9|s t;|r6|j||j=|j dddyt |t>sJt |tr |jxr |j@ }|jBrItD|jF|dvr4|jId|tJjL|j!d}|jNrItD|jF|dvr4|jId|tJjL|j!d }|jQ||}|rC|j 7|j }|jR|jRf|jTz|_*||_|jW|jX|j[|t |t\r7t |j tsJt_|j ||_ddd|ja||jc||jr|j J|j jdro|jfsct |jhjjtlr |jnr3|jptrk7r tu|jvr tx|_8tu|jvr&|jfs|jptzk7rd |_:|j|rt |j tr|j~j||j k7r|jrnttj} |jd | | |j jg} | Jd |j j!| |_|j |j~|<|j=|jy#1swYxYw) NF)rS__init_subclass__)ret_type)nested namespacez3TypeGuard functions must have a positional argumentcode) type_guardz2"TypeIs" functions must have a positional argument)type_isTztyping.Coroutinez*Internal error: typing.Coroutine not found)Errrr2rrXr{rupdate_function_type_variablesris_class_scoperrrrr copy_modifiedrprepare_method_signaturerrrtvar_scope_framer1 method_framecheck_classvar_in_signature type_analyzerrvisit_callable_typerrrr is_staticrr! arg_kindsrcodes VALID_TYPErremove_unpack_kwargs self_type variablesadd_type_alias_deps aliases_usedcheck_function_signaturerRranalyze_arg_initializersanalyze_function_body is_protocolr[rGrrj is_propertyabstract_statusr(is_trivial_bodyr|r&r+ is_coroutiner<ris_async_generatorrrr) rQr has_self_typerranalyzerrresult skip_selfrany_typers rRr z!SemanticAnalyzer.analyze_func_defs   t~~t 4 < JJt   ""4( 99dii6 66 ?? 4PM!M !    99( (( DIyy$6W)W!$))\:::odii.@.@A7K $ 7 7 7 LDI  ) )$ = I))$--8  " "4??#?#?#I J, Cyy00;!$))\::: --/002!55diiYa5b,,S1_V5LJJt$&&t~~6, C, C"&*555fl3 $ 3 3 5 Ldnn:LI((WF#yy>>504/@6CSCS/SF," (()>)>?--d3dG,%dii>>> 1$))T BDIY, C\ %%d+ ""4(    99( (( %%))#DJJ$7$79JKtO_O_((K7#DII.':$ *))((L8'+$   499l3..2248DIIE&&#9#9#9:22&8TYY=O=O(P +Y-YY+ II33X3F 7;yy..t4 4>>*o, C, CsC YF=YY(c~|jr|jdtjur|S|jd}t |t s|St |j}t |tsN|jd||jddttjgz}|j|St|jt|j z}|j#|jd|rdj%t't)d|Dcgc]}d|d c}}|jd|||jddttjgz}|j|S|jdd|gz}|j|dScc}w) Nrz.Unpack item in ** argument must be a TypedDict arg_typesz, "z7Overlap between argument names and ** TypedDict items: T)r< unpack_kwargs)r$r4r"r<r{rrrXrrrr from_errorrr? arg_namesrdiscardjoinsortedfilter) rQrr last_type p_last_type new_arg_typesoverlapr overlappeds rRr'z%SemanticAnalyzer.remove_unpack_kwargss}} b 19J9J JJMM"% )Z0J%inn5 +}5 IIF RMM#2.'):N:N2O1PPM$$}$= =cmm$s;+<+<'== b)* F6$PWCX,>q,AB i1$#yy49L9L9XXX-1YY-@-@ /3,'4T': }} Y(>'+|'D ;Hl SDI"z$2F2F 'U%od6J6J6T6TUV6W&XZab55%t}}'N Y8N !II [ $%*%>%>& !II []ac(V]#E~8 II;T BrTcP|jJt|}|rt|tr|j |j dSt|t r^|j|j|d}|>|jtvr,|jr |j |jddSyt|tr||jjk(St|t r6|j|j|d}|duxr|jtvSy)zODoes this (analyzed or not) type represent the expected Self type for a method?NF)is_classmethodTsuppress_errorsr)rXrr{rrSitemrlookup_qualifiedrrrrargsrr(r)rQrrYsyms rRrSz&SemanticAnalyzer.is_expected_self_typeXsyy$$$c" #x(11#((51QQ#{+++CHHc4+P?s||z'Achh55chhqkRW5XX c; '$))--- - c; '''#t'LCd?Fs||'F FrTct|tr |j}t|ttfr+t |j rt |j ryt|tt tfr|jr||_yy)a If 'new' conditionally redefine 'previous', set 'previous' as original We reject straight redefinitions of functions, as they are usually a programming error. For example: def f(): ... def f(): ... # Error: 'f' redefined TF) r{rFrUrRrrrr original_def)rQpreviousnews rRset_original_defz!SemanticAnalyzer.set_original_defksh c9 %((C x'9!5 6 * / h#y 9 :s?Q?Q'C rTc |j|j}|j|jj |5|j }|j ||\|_}|r|j|j|jr|jDchc]}|j}}|jDchc]}|j|j} }t|| z } | r<|jj| D cgc]} | j!ddc} ||cdddScc}wcc}wcc} w#1swYyxYw)zMake any type variables in the signature of defn explicit. Update the signature of defn to contain type variable definitions if defn is generic. Return True, if the signature contains typing.Self type, or False otherwise. Nryr)rrrrr1rr!bind_function_type_variablesr)rXsetup_self_typerrrrCrA"type_parameters_should_be_declaredr) rQfun_typerrrar5rbound_fullnamespdeclared_fullnamesextrars rRrz/SemanticAnalyzer.update_function_type_variabless0))$--8  " "4??#?#?#I J !""$A010N0NxY]0^ -H  !6$$&~~7?7I7I"J!1::"J"JKO>>%Zad&9&9!&&&A%Z"%Z1CCDHH??389ab)94! ! ! #K%Z: ! !s7A#E)E<E "E .+EE 4 EEEc |jJ|j}|jVt|jjr6|j dd||jjt |k7nyt d|jdtdgt |ttj|_y)zSetup a (shared) Self type variable for current class. We intentionally don't add it to the class symbol table, so it can be accessed only by mypy and will not cause clashes with user defined names. NzSelf upper boundforce_progressSelfz.Selfr)idvalues upper_bounddefault) rXr(rruprocess_placeholderrrrrrrrfrom_omitted_genericsrQrs rRrgz SemanticAnalyzer.setup_self_typesyy$$$yy >> %t~~99:((&#'>>#=#=tAT#T )$ }}oU #|%d+I;;<  rTc||_|j||jsy|jj |5|j |dddy#1swYyxYwrV)r;rrFrGranalyze_overloaded_func_defrQrs rRvisit_overloaded_func_defz*SemanticAnalyzer.visit_overloaded_func_defsZ ))$/**  ZZ & &t , 3  , ,T 2 3 3 3s AA%c#JK||_ dd|_y#d|_wxYwwrVr)rQr\s rRoverload_item_setz"SemanticAnalyzer.overload_item_sets&%)" . )-D &D &s## #c,|j|j|_|jj |_|j d}d|_|jd5|j|dddd}dt|tr{|jjredd|j_|j|}t|j|j}t|tsJ||_|g}n{|j#|\}}}||_|r |j'||t)|dkD|(||j dusJ|j dd|_n|s|j+||rt-fdt/|j Dsbt1||_|j4|j2_t|tr'|r%|d|j6_||j6_|j s!|j$s|jd|_y|j;||j=||j?||jA|y#1swYxYw)NrTF)some_overload_decoratorsrc3K|]:\}}t|txr!t|j|dkDssdndkD<yw)rrN)r{rFr~ decorators).0iitr0s rR z?SemanticAnalyzer.analyze_overloaded_func_def..sM 2 r9 % LBMM"1q5 aK L  sAA)!rrrunanalyzed_itemsrzrrrrr{rFrUr0+analyze_property_with_multi_part_definitionrr definitionanalyze_overload_sigs_and_implimpl"handle_missing_overload_decoratorsr~&handle_missing_overload_implementationany enumeraterrXrr setter_typeprocess_deprecated_overloadprocess_final_in_overload*process_static_or_class_method_in_overloadprocess_overload_impl) rQr first_itembare_setter_typertypesrnon_overload_indexesr0s @rRr{z,SemanticAnalyzer.analyze_overloaded_func_defsI ,,TYY7**//1 ZZ] !%   # #A & $   d # $  j) ,1L1LK*.JOO '#OOPTU  1C1C1EFCc<0 00'CNEE 150S0STX0Y -E4-DI#77.UVW8 tzz"~---!ZZ_ );;DA  #4::.   #5)DI!YYDIIN*i05E&+Ah #-= *zz99!11"5  ((. &&t, 77= ""4(C $ $s (J  Jc|jryt|jx}trR|jj x}:||_|j D]$}t|ts||j_&|j D]}d}t|ts|jD]}|r-t|tr|jjd|2|j|x}Fd}t|jjx}trd|d}nd}d|d|jd||j_y)NFz-@overload should be placed before @deprecatedT overloadz of function  is deprecated: )r0r{rrFrU deprecatedrrrefers_to_fullnamerrArget_deprecatedrXrrr) rQrrrr\ deprecationrrtypestrs rRrz,SemanticAnalyzer.process_deprecated_overloads,     dii'd 399// /Z <(DO  6dI.+5DII( 6JJ DK$ * A"'9!^'L &UWXY(,(;(;A(>>*K&* %TYY^^&;c\J()#ajG&)G&wi|DMM?JZ)l, ,  rTct|trUt|jtr;t |j x}dk\r!t|dx}tr |jSyNrr) r{r=rcalleerr~r^ryrh) expressionr^rs rRrzSemanticAnalyzer.get_deprecated8sW z8 ,":#4#46KLZ__,T-2a0:':## #rTc|jyt|jtr |jn|jj}t |j ri|j rX|jsK|jJ|jjr t|_ |jtk7rd|_yyyyy)zSet flags for an overload implementation. Currently, this checks for a trivial body in protocols classes, where it makes the method implicitly abstract. NT) rr{rRrUr2r|rr[rXr/r&r1r+)rQrrs rRrz&SemanticAnalyzer.process_overload_implCs 99  &tyy':tyy  499 %$*=*=*?HYHY99( ((yy$$':$##|3'+$4 IZ*? %rTcg}g}d}t|jD]\}}|dk7rOd|_|j|t |jdz kr|nd5|j |dddt |tr t|j|j}t |tsJ||_ td|jDs<|t |jdz k(r|js|}n\|j|nJd|j_|j||j j"r|j%d||xj&|jj&zc_vt |t(s|t |jdz k(r|js|}|j||||fS#1swY{xYw)zFind overload signatures, the implementation, and items with missing @overload. Assume that the first was already analyzed. As a side effect: analyzes remaining items and updates 'is_overload' flags. NrTrc3<K|]}t|tywrV)rr)rdecs rRrzBSemanticAnalyzer.analyze_overload_sigs_and_impl..is^s-c>B^z!An overload can not be a property)rrrrr~rr{rFrrUrrrrr[rrr0ris_explicit_overriderR)rQrrrrrr\callables rRrz/SemanticAnalyzer.analyze_overload_sigs_and_implSs!$( , 3GAtAv#' ++S_q5H1HAdS&KK%&$ *(D4F4F4HI!(L999&*#^doo^^C Oa//8I8I# -33A6,0DII)LL*xx++ "EtL))TYY-K-KK)D'*DJJ!++D4E4ED(//2A 3Bd000;&&s G((G2 c|rS|D]M}|jr |jd|j|/|jd|j|On|ddD]9}|j|j|j||jd;|j r4|j|j|j |jdt |D]}|j|=y)zoGenerate errors for overload items without @overload. Side effect: remote non-overload items. zJAn implementation for an overloaded function is not allowed in a stub filezt |jdt sJd|jdj_ yy|jd|tjyy)zFGenerate error about missing overload implementation (only if needed).c3zK|]3}t|txr|jjtk(5ywrV)r{rFrUr1r(rr\s rRrzJSemanticAnalyzer.handle_missing_overload_implementation..s64+X 0I0I[0XX9;rTzFAn overloaded function outside a stub file must have an implementationrN)r[rXr/ is_func_scoperr{rFr(rUr1allr2rr%NO_OVERLOAD_IMPL)rQrr\s rRrz7SemanticAnalyzer.handle_missing_overload_implementations  yyTYY224;M;M;O!JJ;D!$ 24? 1/:, ;  JJ ::%djjmY???9=DJJqM&&6 \//%!rTctd|jDrd|_td|jD}|js|j d|nPtd|jddDr1td|jddD}|j d ||j |j jrd|_yyy) zHDetect the @final status of an overloaded function (and perform checks).c34K|]}|jywrVis_finalrs rRrz=SemanticAnalyzer.process_final_in_overload..s4t}}4Tc3:K|]}|js|ywrVrrovs rRrz=SemanticAnalyzer.process_final_in_overload..sDB RDz8@final should be applied only to overload implementationc34K|]}|jywrVrrs rRrz=SemanticAnalyzer.process_final_in_overload..s>tT]]>rrNc3:K|]}|js|ywrVrrs rRrz=SemanticAnalyzer.process_final_in_overload..s L  Lrz@In a stub file @final must be applied only to the first overload)rrrnextr[rr)rQr bad_finals rRrz*SemanticAnalyzer.process_final_in_overloads 44 4 DMD$**DDI$$ TV_`>tzz!"~>> Ldjjn LL  VXa 99 TYY%7%7 DM&8 rTcg}g}|jD]{}t|tr |j}n&t|tr|}nJdt ||j |j|j |j}|jt|jtr|jj}nDt|jtr |j}nJdt |j|j |j|j |jtt|dk7r|jjd|ytt|dk7r|jjd|y|d|_|d|_y)Nz+The 'item' variable is an unexpected type: zUnexpected impl type: r classmethod staticmethodr)rr{rFrUrRrXrrNr#rr~r?rA)overload_inconsistently_applies_decorator)rQr class_status static_statusr\inners rRrz;SemanticAnalyzer.process_static_or_class_method_in_overloads\  JJ 2D$ * D'*X KDQUJ<XXu    /   1 2 99 $))Y/ DIIw/ H 6tDII6GHHu    /   1 s< !Q & HH > >}d S ]# $ ) HH > >~t T(ODM*1-DNrTcTd|_|j}|jd}t|tsJg}d}|jj }t |ddD]S\}}t|tr|jj||js@|jd} |j| |r|jj|j_ | j dk(rSd|j_ t|j|j} t| tsJ| }|dz|_|jddD]} | j||j!d|d|d| *|j!d |d ||j#|dzVt%|D]}||=|ddD]Y}t|ts|jD]7} |j'| x} d |j(d | |j_9[|S) a.Analyze a property defined using multiple methods (e.g., using @x.setter). Assume that the first method (@property) has already been analyzed. Return bare setter type (without any other decorators applied), this may be used by the caller for performance optimizations. TrNrsetterz$Only supported top decorators are "@z.setter" and "@z .deleter"z$Unexpected definition for property "r= function r)r0rr{rFrUrrrr_is_valid_property_decoratorr1ris_settable_propertyrr setter_indexrrrrrrr)rQrrr deleted_itemsr func_namerr\ first_nodesetter_func_type other_noderrs rRrzOO4S4S 1%??h6BFJNN?/ #MM#M/?,01AD-*.//!"*=4J&--d34 B9+_]f\ggpq&  @ 1MtT$$QU+1 ,2-( Aa !"I D$ *A&*&9&9!&<< I' 6FzlS ,  rTct|tsyt|jtr|jj|k7ry|jdvryy)NF>rdeleterT)r{rbexprrer)rQdeco property_names rRrz-SemanticAnalyzer._is_valid_property_decorator#sF$ +$))X.$))..M2Q 991 1rTc|jr|jJ|j|_|j|j|_|j |j||yrV)rrXrrrrr)rQrUs rRrz-SemanticAnalyzer.add_function_to_symbol_table4sS    99( (( DI,,TYY7  4.rTc,|j|j}|j|jj |5|j D]*}|j s|j j|, dddy#1swYyxYwrV)rrrrr1rrrr)rQrrrr s rRr-z)SemanticAnalyzer.analyze_arg_initializers;st))$--8  " "4??#?#?#I J 1~~ 1??OO**40 1 1 1 1sB #B  Bc|j}|j|j}|j|jj |5|j r{|j}|j }t|tsJ|j||tt|jD]}t||||j|j j#||j%|5|j&D]}|j)|j*| |ra|j,rU|j&rI|j.sd|j&dj*_nd|j&dj*_|j4j7|ddd|j j9dddy#1swY,xYw#1swYyxYw)NTr)rrrrrr1rrXr!r{rrfranger~r<r named_typer2renterr add_localvariablerMrNis_selfis_clsr|rr)rQr is_methodrrrjrrr s rRr.z&SemanticAnalyzer.analyze_function_bodyCs'') ))$--8  " "4??#?#?#I J &yy&&(ii!#|444..sD9s3==12GA'adooFG    & &t ,D! '>>7CNN3<<67 !>!>4>>===Aq)22:<@q)229   & '    # # %1 & & ' ' & &s&B4G- B,G!6"G-!G* &G--G6c6t|tr#|jD]}|j|yt|tsyt |j t|jgzD]&}|j|s|j|yyrV) r{rrr rrr<rr is_classvarfail_invalid_classvar)rQrrs rRr z,SemanticAnalyzer.check_classvar_in_signature`s c: &YY 4003 4 #|, !#--0OCLL4Q3RR A"**1-  rTc|j}t|tsJt|jt|j krv|j d|t|j t|jz }ttjg|z}|jj|yt|jt|j kDr|j d|dyy)Nz$Type signature has too few argumentsz%Type signature has too many argumentsTblocker) rXr{rr~r<rrrrr?extend)rQfdefsignum_extra_anys extra_anyss rRr,z)SemanticAnalyzer.check_function_signaturensii#|,,, s}} DNN 3 3 IIIJ MM  ,  #dnn"5 5 II=tTI R6rTc ||_|jj|_|jddkD|j _|js|j|j|||j|j|j _ |j|j|j_ |jD]}|j|g}d}d}t|jD]\}}t|dr9|j!|t"|j _|j'd|Lt|dr#|j!|d|j _{t|drF|j!|d|j _d|j_|j'd |t|d rG|j!|d|j _d|j_|j'd | t|t2r6|j!|d|j _|j'd |ft|d r|j!|d|j _d|j_t|drt"|j _nt|drd|j_|j'd|t|dr,t;t<j>|j_ d}0t|tBr|jErz|j@Jd|j@jFr|jHjK|n"d|j _&d|j_&|j!||jOd|t|tPrd|j _)tU|tVr?q!%)"*.'77L#A'=>q!$(!)-&77 sK#A'?@q!04-77 CH# q!'+$&*#%a)?@/:CHH,'+FG37CGG077 CH#A'=>&y'='=> $ #A'<=&&(990N2NN0yy,,??B,0)+/(NN1%IIOQRS#A'<=.2+Ax(-?3.594W4WXY4Z1 $ 3 3A 66*C(1#,,?OPZ|&\#WW((/3+GC 3H'" "Aq! "377#6#6DII99CGGL.2CGG +!>cgg>Q>Q IIBCN`   HH  #(("3"39L9L IIMs S 88 # #{ 2sxx7H7H II .IJC P 88  #(("3"3 II&KKS Q#4 rTcj|jr|jr|jd|d|yy)Nr=z" used with a non-method)rXrr)rQ decoratorcontexts rRrz3SemanticAnalyzer.check_decorated_function_is_methods1yyD..0 II)$<=w G1rTc"||_|jj|j |j |j }|j |jj|5|j|j|&|j|j | dddy|j||j|jddd|jjy#1swY$xYwrV)r;r@rrrrrr1 class_framerrr analyze_classrr)rQrrs rRvisit_class_defz SemanticAnalyzer.visit_class_defs ""))dii-8'' 2  " "4??#>#>y#I J /""4>>48@$$TYY5 / /   t $   t~~ .  / ""&&( / /s3:D6,DDc|sgS|jjt|jjtg}|D]5}|j ||}|y|j|j |f7|D]C\}}|j|r|jd|d|.|j|||ddE|S)Nr=z%" already defined as a type parameterT) no_progress type_param) r*rr|r,ranalyze_type_paramris_defined_type_paramrr)rQrr tvsrltvrs rRrzSemanticAnalyzer.push_type_argssI ;=)  0113 %A((G4Bz JJ| $  %  VHD"))$/ AdV#HI7Sb'tPTU  V  rTcx|jD]+}|||vs ||j}t|ts+yyNTF)r*rr{r)rQrrqrs rRrz&SemanticAnalyzer.is_defined_type_param sE[[ E}u}T{''dO4  rTc |j|j}|jr7|j|jd}|]t dg|j }nE|j tk(r"|jd|jg}n|j}|jr|j|jddd|j tk(|j tk(|j tk(}|t dg|j }n|j tk(r|j||j}ny|j tk(r|j||j}nI|j tk(r6|j||j}nt!t"j$}|j tk(rg}|j&r|j&D]}|j|d}|t dg|j }t)|rI|j+t,j.||j1t!t"j2|j1|t5|j||||t6d|j S|j tk(r%t9|j|||d|j S|j tk(sJ|jd|jg} t;|j||| |d|j S) NTallow_placeholderbuiltins.tupleF)rrJreport_invalid_typesallow_param_spec_literalsallow_tuple_literal allow_unpack)rrrrtrurvvariance is_new_styler)rrrrurvr r)rrrrutuple_fallbackrvr r)rrrurrrkindr2r object_typervr,r1check_typevar_defaultcheck_paramspec_defaultcheck_typevartuple_defaultrrrxrtrrr TYPE_VAR_GENERIC_CONSTRAINT_TYPErr?rr3rlr) rQrr rrrurvrtrhanalyzedr!s rRrz#SemanticAnalyzer.analyze_type_params&&z7  ! !..)?)?SW.XK".dB E "55"oo.>AQAQAS@TU "..0   nn"""&$(%**4//_*L$.OO$F'__0CC%G)$GLLAM144Wj>P>PQO366w @R@RS$7799':CUCUVi==>G ??m +!#F  '..0E#~~et~LH'#24W\\#J$X. "2"S"SU\] gi.B.B&CD h/0__!'+!\\  __ / __!'!\\  ??&99 99!__-=@P@P@R?STN#__!'-!\\ rTcr|sy|jj|jjyrV)r*rr,)rQrs rRrzSemanticAnalyzer.pop_type_argscs(   rTc|j|j}|jsI|j|s8t |||j d}|j |j||d|j}|jj|j|jj|j||j}|j|||\}}}|j||D]}t|t r:t#d|j$g|j&zDr|j)t+|j,sc|j/|j|y|j1||j3|} | |j5|r|j/|j|y| \} } t#d| Dr|j/|j|y|j7|j|j8\} } }| s|j5|r|j/|j|y|j;|r0|jr#|j=|||j?|y|jA||ry|jC||j=||| rd|j_"|rd|j_#|jHjK|j5|jM|| ||j_'|jQ|| d|j_)|jTr4|jVjY}|jZjY|j\D]}|j_|||jTr:|jVja|jZjatb|je|dddy#1swYyxYw)NTbecomes_typeinfoF) can_deferr c32K|]}t|ywrVrrrs rRrz1SemanticAnalyzer.analyze_class..s4'("4c3BK|]\}}t|tywrV)r{r)rbase_s rRrz1SemanticAnalyzer.analyze_class..sKWT1z$0Ks)3rrris_core_builtin_classrnrrrbase_type_exprsrremoved_base_type_exprsclear-infer_metaclass_and_bases_from_compat_helpers'clean_up_bases_and_infer_type_variablescheck_type_alias_basesr{rrrurtrrrvranalyze_class_keywordsanalyze_base_classesrget_declared_metaclass metaclassanalyze_typeddict_classdefsetup_type_varssetup_alias_type_varsanalyze_namedtuple_classdefprepare_class_deffallback_to_anymeta_fallback_to_anyrG class_scopeconfigure_base_classesr/recalculate_metaclassruntime_protocolrr*rr,ranalyze_class_decoratorrranalyze_class_body_common)rQrrr placeholderrbases tvar_defsr/tvd bases_result base_types base_errordeclared_metaclass should_deferany_metatype_params_namesrs rRr zSemanticAnalyzer.analyze_classis&&tyy1yy!;!;D!A *(D$))VZ[K OODII{DEO J((* ##D$@$@A $$**, ::4@$$(,(T(T %)U) %y+ ##E* C#{+4-0__,= ,J41  s{{+$$TYY5  ##D)007  4#<# ,,T9= >~~ ""#45  ''(89  * *4 0# 1 1 1s ,DP66P?c|D]s}t|tr |j}t|ts0t|jt sK|jj sb|jd|uy)NzAType alias defined using "type" statement not valid as base class)r{r[r4rqrr python_3_12_type_aliasr)rQrOr4s rRr<z'SemanticAnalyzer.check_type_alias_basess[ D$ *yy4)tyy)4II44 WY] rTch||_g|j_|jjyrV)rr add_type_vars)rQrrPs rRrBz SemanticAnalyzer.setup_type_varss%"   !rTc~|jjJt|j|jj_t |jD]1\}}t |ts||jj_3|jjj}t |tsJt |tr%t|j|j_yt |tr%t|j|j _yJdt#|)NzUnexpected special alias type: )r special_aliaslistr alias_tvarsrr{rtvar_tuple_indexrrrrfallbackr^rpartial_fallbackrX)rQrrrrs rRrCz&SemanticAnalyzer.setup_alias_type_varssyy&&222.24>>.B +dnn- =DAq!-.;< ''8 =((//&*--- fm ,#4T^^#DFOO  *+J J5rTcH|jdk(xr|jtvSNrm)rrrr|s rRr6z&SemanticAnalyzer.is_core_builtin_classs *,R>R1RRrTc|j|jtd|jjDr|j |j j ||j||jy)zHParts of class body analysis that are common to all kinds of class defs.c38K|]}|jduywrV)r()rbs rRrz=SemanticAnalyzer.analyze_class_body_common..s>1q{{$&>N) rrrmrorgrrapply_class_plugin_hooksrr|s rRrMz*SemanticAnalyzer.analyze_class_body_commonsb # > > >  "  %%d+ rTc|jr6|jjr t|jjsy|jj |\}}|rl|j D])}|j |||j|||+||j|j|y|j||dyy)NT custom_namesF) rtypeddict_typerrrArranalyze_class_decorator_commonrrrE)rQr is_typeddictrrs rRrAz+SemanticAnalyzer.analyze_typeddict_classdefs II ((#DII$<$<=!55PPQUV d !__ O   &#77dIN O|$$TYY5&&tT&ErTcf|jrZ|jjrD|jjr.t|jjsd}|j}n8|jj ||j |j\}}|r||j|j|y|j||d|j|||j||jj|j5|jD]0}|j!||j#||j|2|jj%|5|j'|ddddddyy#1swYxYw#1swYyxYw)z-Check if this class can define a named tuple.TNrmF)ris_named_tuple tuple_typerrrDr[rrrrErBrCrGrHrrrpsave_namedtuple_bodyrM)rQrrPrsrrs rRrDz,SemanticAnalyzer.analyze_namedtuple_classdefss II (( $$#DII$8$89"N$(IID#'#<#<#X#Xd''););)=$ ND |$$TYY5&&tT&E$$T95**40ZZ++DII6= $S D);;D$))TRS22GGM=66t<= = == = s%AF'7F F'F$ F''F0c|jD]d}|j|}|s|jj|}|t |rt j }|sR|t|||f|jrW|j|j}|r:|jj|}|r|t||j||jD]G}|j|}|s|jj|}|s5|t|||It |}| t j|jyy)zIApply a plugin hook that may infer a more precise definition for a class.N)rget_fullname_for_hookr:get_class_decorator_hookrdataclasses_plugindataclass_tag_callbackrr@get_metaclass_hookr7get_base_class_hookadd_dataclass_tagr) rQrrdecorator_namehookmetaclass_name base_expr base_namespecs rRrkz)SemanticAnalyzer.apply_class_plugin_hooks0s5 AI!77 BN{{;;NK<$A)$L-DDDy$?@ A >>!77GN{{55nEt~~tDE-- AI229=I{{66yAy$?@  A-T2    0 0 ; rTc>t|tr|j|jSt|tr|j|j St|t r7|jr |jS|j|}|r |jSyrV) r{r=rwrr[r4rqrrlookup_type_noderQrr_s rRrwz&SemanticAnalyzer.get_fullname_for_hookSs} dH %--dkk: : i (--dii8 8 g &}}}}$''-C||#rTcd|jjD]}|j|yrV)keywordsrtr)rQrrhs rRr=z'SemanticAnalyzer.analyze_class_keywordscs*]]))+ E LL  rTc|jj|j|jjd|jjt |j jd|jjd||_|jjty)Nrr) r0rrXr*r,rr-r5r/r3r?rys rRrzSemanticAnalyzer.enter_classgs tyy) 4   , # q!  !!#%(rTcF|jj|jj|jj|jj|j j|_|jjy)zRestore analyzer state.N)r-rr5r*r,r0r/r3rWs rRrzSemanticAnalyzer.leave_classqsj    __((*   rTc|j||j||j|t|trN|j t vr;|jjrd|j_y|jd|yyt|tr ? DM  +H I$(D !  +@ A&*D # // ::j G &t}}o5Ej\RDOHrTcrg}g}d}|jt|jD]e}|j|j|}|Jt|jt sJ|j |j|jfgt|D]?\} } t| trd| _ |j|  |j| } |j| } | w| d} || dz}|rF|jr(|r|jd|n%|jd|n|jd||j | |j| t| t s|j#| j| }||j |jj$t&vs'| |vs-|j | d}B|j)||}|rt+t-|t+|kr|js|jd|t-|}t/|j1t/|s}|jrNt3t/|t/|z }|j4j7|Dcgc]}|d c}|n|jd |t-||z}n|}t9|D]-} |j:j |j<| || =/|j?||}|||fS#t$rYwxYwcc}w) aRemove extra base classes such as Generic and infer type vars. For example, consider this class: class Foo(Bar, Generic[T]): ... Now we will remove Generic[T] from bases of Foo and infer that the type variable 'T' is a type argument of Foo. Note that this is performed *before* semantic analysis. Returns (remaining base expressions, inferred type variables, is protocol). FTrrz/No arguments expected for "Protocol" base classz$Generic[...] base class is redundantz9Only single Generic[...] or Protocol[...] can be in basesz9Duplicate type variables in Generic[...] or Protocol[...]zMIf Generic[...] or Protocol[...] is present it should list all type variables) rlookuprr{rrrrrwvalidanalyze_type_exprrr!analyze_class_typevar_declarationrrrr]rrrget_all_bases_tvarsr~rr?issubsetrCrArhrr8r7tvar_defs_from_tvars)rQrr7r rdeclared_tvarsr/rlrrrr4r7tvarsr_ all_tvars undeclaredrrPs rRr;z8SemanticAnalyzer.clean_up_bases_and_infer_type_variabless  *, >> %^^ ;{{16673'''!$))_===%%qvvtyy&9:  ; &o6 +LAy)X."&   " "9 - 33I>;;DAF!q vay( !~~& II&WY`a II&LgV WY`q!%%e,$ ,++DIIt<?sxx';xx((N:q?Oq)&* A +D,,_gF ;~./#n2EEdnn UW^_(8Ny>**3~+>?>>!'I^9L(L!MJHH??)342A4gII= "-^i-G!H&N'" #A  ( ( / /0D0DQ0G H"  # --ngF  ;66o(  H5sL$ L4$ L10L1ct|tsy|}|j|j|}| |jy|jj dk(s(|jj t vr|jr|jj dk7}g}d}|jD]}|j}|j|} | r\}}||vs |j|}|j|}|j |@t |S#t$rYWwxYw)z-Return all type variable references in bases.)rrrrrr)rQr7rrrrr4 base_tvarss rRrz$SemanticAnalyzer.get_all_bases_tvarsD s}"$%o6 )LAy77 BD"55d;  Z( )5!! ,sA A&%A&cg}d}|D]<\}}|jjt||j||_|jsT|j j |js/|jtjj|||j j||}|V|jsF|jj|j||t!t"j$|_n|jr |j}|j'|?|SrV)rvrrrr r1rrrrr#TYPE_VAR_REDECLARED_IN_NESTED_CLASSformatbind_new has_defaultrAtvar_without_default_typerrr?r)rQrr rPlast_tvar_name_with_defaultr tvar_exprtvar_defs rRrz%SemanticAnalyzer.tvar_defs_from_tvarsT s,. 26#$ 'OD) ) 1 1 8 8(y~~wG!I  ))$//2O2O""3 $HHOOPTUW^//i@H*6x?S?S?U22MM#>$+9+?+?#@ %%'.6mm+   X &) '*rTc&g}|D]6} |j|}|j|}|j|8t |}g}|D]2\}}|j j ||} |j| 4|S#t$rYwxYw)a7Return all type variable references in item type expressions. This is a helper for generic TypedDicts and NamedTuples. Essentially it is a simplified version of the logic we use for ClassDef bases. We duplicate some amount of code, because it is hard to refactor common pieces. )rrrrrr1rr) rQ type_exprsrrr4rrPrrrs rRget_and_bind_all_tvarsz'SemanticAnalyzer.get_and_bind_all_tvarsp s# %I 33I>11$7J LL $ %E" $ 'OD)//i@H   X & '(  sB BBc|js|j|j|_|xs|j |}||_||_|sB|j s!|j|j|_n|j|_|j}d|vr|jdd}|j||j||jr d|jjvrQ|jjdzt|jz}|jdz|z|j_n|jj}|jj|_|jjs|jjr|j!||jyt#t$|j|j&|<yy)zPrepare for the analysis of a class definition. Create an empty TypeInfo and store it in a symbol table, or if the 'info' argument is provided, store it instead (used for magic type definitions). @rryN)rrrrrmake_empty_type_inforrrrris_nested_within_func_scopestrrrrsroadd_symbol_skip_localr}r%r')rQrrrn local_name global_names rRrEz"SemanticAnalyzer.prepare_class_def svyy // :DM:444T:DDIDI))+%)%8%8%CDN%)YYDNYY * #))#.q1J  DIIt4  + + -$))---"iinns2S^C &*oo&;k&I ##iinn  II//DMyy''499+C+C**; B,;D$)),L [)' .rTc6|jrX|jdk(rI|jtvr7|j|jj }t |tsJ|Stt||j}|j||Sre) is_module_scoperrrr'rr{rr|set_line)rQrrs rRrz%SemanticAnalyzer.make_empty_type_info s  ":- 11 << *//DdH- -- KM4AD MM$  rTct|tr |jSt|tr t |St|t r|j |jSt|tr|j |jSy)zQTry finding a short simplified textual representation of a base class expression.N) r{rerrbrr[get_name_repr_of_exprr4r=rrQrs rRrz&SemanticAnalyzer.get_name_repr_of_expr sl dH %99  dJ '+D1 1 dI &--dii8 8 dH %--dkk: :rTcd}g}|D]}t|tr|jttzvsFt|t r7t|j tr|j jtvrs |j|dd}|yt|}|j||f||fS#t$rI|j|}t|t rd}nd}|r |d|dz }|j||d}YwxYw) a#Analyze base class types. Return None if some definition was incomplete. Otherwise, return a tuple with these items: * List of (analyzed type, original expression) tuples * Boolean indicating whether one of the bases had a semantic analysis error FT)rallow_type_anyzUnsupported dynamic base classInvalid base class "r=N) r{rqrrrrr=rexpr_to_analyzed_typerrrrr)rQr7is_errorrOrr4rrAs rRr>z%SemanticAnalyzer.analyze_base_classes s"(" ,I9g.&&*@<*OO9h/y//9$$--= 11d2|"4(D LL$ * +E" ,Fh( 11)<i2:C.CRvQ<'C #y) s;B77AD D cNg}|j}|D]\}}t|tr%|j||}|j |nt|t r:|j jr|jd||j |nt|trY|jjr;t|ttfrd|jd}nd}|j||d|_nct|t r|j |j"n7d}|j%|} | r |d| dz }|j||d|_|jj&rPt)|rEt|ttfrd |j} nd } |j*j-| ||t/||j|j0|j*| |s.|j2d k7r|j |j5||_|j9|s|j;|jy |j=|s|j?|j|jA||j4y )a Set up base classes. This computes several attributes on the corresponding TypeInfo defn.info related to the base classes: defn.info.bases, defn.info.mro, and miscellaneous others (at least tuple_type, fallback_to_any, and is_enum.) zCannot subclass "NewType"zClass cannot subclass "z" (has type "Any")z)Class cannot subclass value of type "Any"Trrr=z Base type z Base typer.rN)!rr{rconfigure_tuple_base_classrrrX is_newtyperrr#disallow_subclassing_anyrerbrrFrrbrdisallow_any_unimportedrrAunimported_type_becomes_anyrr^rrr#rOverify_base_classes set_dummy_mroverify_duplicate_base_classes set_any_mrocalculate_class_mro) rQrrOrSrr4r actual_baserArprefixs rRrIz'SemanticAnalyzer.configure_base_classes s4&( yy$! OD)$ *"==dDI !!+.D(+99''II94@!!$'D'*<<88!)h -CD 7 7GGYZIIIc9-'+$D-0!!$--0*11)<RvQ<'C #y)'+$||338TUY8Zi(J)?@))..)9:F(F44VT9M "dllD$>$>R[ ?! Hdmm/@@   d..0 1 ''-   tyy ) 11$7   TYY '   t'7'78rTc2|j}|jr=|jk7r.t|js|jd|d|_|j rAt|j j r"|jdd||jk7|j|j|jjjdk(r$ts|jtfdjS)Nz3Class has two incompatible bases derived from tupleTz tuple baserprctSrV)r)r4srRz=SemanticAnalyzer.configure_tuple_base_class..T s|jd|jd||j |jYwxYw)zCalculate method resolution order for a class. `obj_type` exists just to fill in empty base class list in case of an error. z?Cannot determine consistent method resolution order (MRO) for "r=N) rrrrrrrrr:get_customize_class_mro_hookrrN)rQrobj_typers rRrz$SemanticAnalyzer.calculate_class_mrob s * $))X . ==;;;;DMMJD_T>+;TBC  * IIQRVR[R[Q\\]^    tyy )  *sA))AB0/B0cd}t|jdk(r|jd}t|trt|jt r|j ||jjdvrWt|jdk\r?td|jDr#|jd}|jdd|_d}|jD]}t|tst|jt s/|jj||jjdk(sdt|jdk(s}|jdtk(s|jd}n|j||hdhz }t|dk(ryt|dkDr#|jd|t j"y|j%|_y) aLookup for special metaclass declarations, and update defn fields accordingly. * six.with_metaclass(M, B1, B2, ...) * @six.add_metaclass(M) * future.utils.with_metaclass(M, B1, B2, ...) * past.utils.with_metaclass(M, B1, B2, ...) Nrr>six.with_metaclasspast.utils.with_metaclassfuture.utils.with_metaclassc3.K|] }|tk(ywrV)r!rr"s rRrzQSemanticAnalyzer.infer_metaclass_and_bases_from_compat_helpers.. sLDGOLszsix.add_metaclasszMultiple metaclass definitionsr)r~r7r{r=rrqrrrr^rr$rrr!r@rr% METACLASSr)rQrwith_meta_exprr add_meta_exprdec_exprmetass rRr:z>SemanticAnalyzer.infer_metaclass_and_bases_from_compat_helpersx s-1 t## $ ),,Q/I)X.:i>N>NPW3X&&y1$$-- INN+q0L 8K8KLL%.^^A%6N+4>>!"+=D(,0  H(H-*X__g2V&&t,OO,,0CCHMM*a/ **1-8$,MM!$4M ?4&H u:?  u:> II65??I S rTc|j}d}|jD]5}|j}|j||s"|j d|d}7| S)NFzCycle in inheritance hierarchyT)rrOrX is_base_classr)rQrrcycler4baseinfos rRrz$SemanticAnalyzer.verify_base_classes sZyyJJ DyyH!!$1 :DA   yrTct|jj}|r |jd|jd|| S)NzDuplicate base class "r=)find_duplicaterdirect_base_classesrr)rQrdups rRrz.SemanticAnalyzer.verify_duplicate_base_classes s?TYY::<=  II.sxxj:D AwrTc|g}|h}|ro|j}||k(ry|jD]G}|j|vs|j|j|j |jI|roy)z9Determine if t is a base class of s (but do not use mro).TF)rrOrXradd)rQrsworklistvisitednxtr4s rRrzSemanticAnalyzer.is_base_class ss3#,,.Cax  +99G+OODII.KK * + rTcd}|rMd}t|tr |j}nt|tr t |}|'|j d|d|t jy|j||}|yt|jtr~tt|jjtrQ|jjr:|j d|jjd|t jyt|jt ry|j}t|jt"rg|jj$sQ|jj&s;t|jj(}t|t*r |j}t|t,r |j.'|j d |d|t jy |j1s#|j d |t jy t3|}t|t*sJ|}|d d fS) aGet declared metaclass from metaclass expression. Returns a tuple of three values: * A metaclass instance or None * A boolean indicating whether we should defer * A boolean indicating whether we should set metaclass Any fallback (either for Any metaclass or invalid/dynamic metaclass). The two boolean flags can only be True if instance is None. Nz%Dynamic metaclass not supported for "r=rNFTzClass cannot use "z!" as a metaclass (has type "Any")rzInvalid metaclass ")NFFz8Metaclasses not inheriting from "type" are not supportedF)r{rerrbrrr%rr]rrrrXrr#rrnr rZr`rrrrt is_metaclassr) rQrmetaclass_exprrUrr_metaclass_inforrs rRr?z'SemanticAnalyzer.get_declared_metaclass s" !N.(3!/!4!4NJ7!9.!I% ;D6C" )''GC{(#((C(Z 8VX_-`<<88II,SXX]]O;\]&"__ )#((O4(+.((N388Y/77,,(9fh/%+[[Nnh7>;T;T;` ).)9;^RWRaRa*!..0 N" * 0DdH- --!% !5%//rTc||j_|jj|j_t d|jj Drh|jjr-|jjj jdk(r%|jdg}|||j_|jjra|jjj jdr1d|j_ |jr|jd|yyyy)Nc34K|]}|jywrV)r/)rrs rRrz9SemanticAnalyzer.recalculate_metaclass.. s:Dt:r builtins.typez abc.ABCMetaz enum.EnumMetaTzEnum class cannot be generic) rrUcalculate_metaclass_typemetaclass_typerrjrXrrrhas_baseis_enumrr)rQrrUabc_metas rRrJz&SemanticAnalyzer.recalculate_metaclass s'9 $#'99#E#E#G  :DIIMM: :II,,99++0099_L 22="E'/7DII, 99 # # (@(@(E(E(N(N(_ $DII ~~ 8$?)` #rTc||_|jD]\}}|j xr|jj}||}|}|xs||k(}n|j dd}|}|}||j vrg|j |}|jrt} n|jt} nt} t| ||| } |j|| ||| |j||||| y)Nryrrrr rr)r rrr)r;idsr[r#implicit_reexportrr&rr)rXr*r%r}add_imported_symboladd_unknown_imported_symbol) rQrrsas_iduse_implicit_reexportbase_id imported_idrrr"symbols rR visit_importzSemanticAnalyzer.visit_import$ s& IB)-(9(9$9$\dll>\>\ ! # 5 Du ((3-*% 5 $,,&||G,%%'DYY*DD($m}K\(("/&3"3 )00 '"/&3"3 1A& rTc ||_|j|}|jj|}|jD]\}}|dz|z}|j ||d}n||j k(r,||jvrtt|j|}nS||cxk(rdk(r-nn*||jvr|j||jdd|jj|}d}|xs|} |j xr|jj} | xs |duxr||k(} |sJ|jj|} | |j} t| | }n||jvrd}|rS|sQd|jvrC|dz|z}|j!|jd| |}|r|j#| ||| | |rA|j%|||| || ||j&s|j)||| | | |d|r|s|j)||| | | | |j+| ||| |  y) NryrFT __getattr__r r.)rrr rrrr rrr)r;rr&rrqset_future_import_flagsrr}r%rErDr[r#rcurrent_symbol_kindrBcreate_getattr_varrprocess_imported_symbolrreport_missing_module_attributer)rQimp module_idmodulersrrrrmissing_submodulerrrmodr"gvars rRvisit_import_fromz"SemanticAnalyzer.visit_import_fromN s005 !!),S IB 3+H  ( ( 2~doo-(dll2J 'tT\\(-CD+)+ T__0L*.//)*DD$$Q'||''+ % +2K )-(9(9$9$\dll>\>\ !1Xe46G6WBRWKMll&&x0?335D*45D!5!55(,%d} 'D%s?R/..v||M/JKYabOO#&3*7&7 $,,)Rh WZ-%%88!#&3*7&7 #499 144"/&3"3 500 ("/&3"3 1[S rTc| xrLt|jt xs/||jvxs|j |j dz }t|jt rD|jr|j||||||y|j||j||d|j|||||y)NryrT)rrr,r ) r{rrcr& startswithrrnrar!rr) rQrr#rsrrrrr rs rRr z(SemanticAnalyzer.process_imported_symbol s*) 499h/ / >t||+ >&&t'<==  dii 1##44"/"/# 5$$II"/"/%) %   wmS` ! rTTcx|j|r|j||||yd|d|d}|jj|} | r|| jj vr#| j|j s d|d|d}n|jjs|jj|jjvsYt| jj j|h} t|| d} | rdt!| d d } || z }|j#||t$j& |r|j)||d|| |d k(rd|j+} |j-| %| t.vr|j0j3| |y|jjd}|rl||jvr]|j0j5d|d|t$j& |j0j5d|t$j& yyyy)Nr zModule "z" has no attribute "r=z(" does not explicitly export attribute "r)rz; maybe or?rrrorrpz#Use `from typing_extensions import z ` insteadzhSee https://mypy.readthedocs.io/en/stable/runtime_troubles.html#using-new-additions-to-the-typing-module)is_incomplete_namespacerr&rrqkeysrr# ignore_errorsr$rr9 ignored_filesr? differencerrrr% ATTR_DEFINEDrrrrrAadd_fixture_noter)rQ import_id source_idrrrr rmessager$ alternativesmatches suggestionrrrps rRr!z0SemanticAnalyzer.report_missing_module_attribute s?  ' ' 2  WMQ^ !  YK';I;aH!!), FLL--// Y8O8]8]yk)QR[Q\\]^ **d.?.?.D.D HaHa.a"6<<#4#4#67BBI;O &y,!D#+Jw,E+Fa!HJ*.G '7);); < &  , , +"// -   "9??#4"56H33H=E 77))(G<$(LL$4$45H$I!$6G6M6M)MHHMM=i[ R"//" HHMMC"//" *N$ !rTcL|j|jury|jtttfvrt |jt ttttfrt|}|j|_|j|_t|}|j|_|j|_t |jtrd|_ t|g|}|||fD]}|j||jj!|yyr)rr"r)r%r*r{rrRrrFr reis_alias_rvaluer8r assignmentsr) rQrexisting_symbol module_symbol import_nodelvaluervalue assignmentrs rR!process_import_over_existing_namez2SemanticAnalyzer.process_import_over_existing_name s   =#5#5 5   D$#5 5*  39i"P; k*F)..FK)..FKk*F',,FK',,FK&++y1*.&'&9J"FF2 + k* +  # # * *: 6rTct|j|j|j|jj \}}|s|j d||S)Nz*Relative import climbs too many namespaces)rrrelativersr$rr)rQrr5oks rRrz(SemanticAnalyzer.correct_relative_import8 sN/ OOT]]DGGT5F5F5[5[5] 2 IIBD IrTc6|j|}||jvr|j|}|j|r|jd||jj D]\}}|dz|z}|j ||js,|jdrd|jvsLt|jtr/|jj|jj|j|||ddyy)N*ryr5rTFr)rr&r.rrqrrrr*r{rrcr8rrrr)rQri_idmrrrrs rRvisit_import_allz!SemanticAnalyzer.visit_import_all@ s++A. 4<<  T"A++D1$$S!,ggmmo  d#:,,,X6%%ts/CyTUT[T[G[!$))X6 ((););<,,dATQV-  rTc|jj||jr|j|sy|j |j ddy)NT)escape_comprehensionshas_explicit_value)rhrrcheck_valid_comprehensionanalyze_lvaluerrQrs rRvisit_assignment_exprz&SemanticAnalyzer.visit_assignment_expr^ sI t    11!4 AHHDUYZrTctt|jD]d\}}|tk7s|t |j dz ks,|j d|z &|j d|tjddyyy)zCheck that assignment expression is not nested within comprehension at class scope. class C: [(j := i) for i in [1, 2, 3]] is a syntax error that is not enforced by Python parser, but at later steps. rrzKAssignment expression within a comprehension cannot be used in a class bodyT)rseriousrF) rrr,rr~r*rr%SYNTAX)rQrr scope_types rRrPz*SemanticAnalyzer.check_valid_comprehensione s'x0@0@'AB MAz00QT[[9IA9M5M;;rAv&.II:"\\ $ $ ! rTc||_|j|ry|j}|j|rO|j}d|_|j 5|j j|ddd||_na|j|r5|j 5|j j|dddn|j j||j|s|j|j r-t|D]}|j|j| y|j|r4|j 5|j j|dddd}|j|r d|_d}nt!|j t"r|j%|rd}n|j'|rd}nm|j)|rd}nY|j+|rd}nE|j-|rd}n1|j.j1|rd}n|j3|rd}|r|j5|yd|_|j7||_|j;||j=||j?||jA||jC||jE||jFs'|jI|jJ|j ||jM||jO||jQ|y#1swYxYw#1swYxYw#1swYxYwr))r;"analyze_identity_global_assignmentrcan_possibly_be_type_formrIrfrBr'can_possibly_be_typevarlike_declarationrshould_wait_rhsnames_modified_by_assignmentrrcheck_and_set_up_type_alias is_alias_defr{r=process_typevar_declarationprocess_paramspec_declaration process_typevartuple_declarationanalyze_namedtuple_assignanalyze_typeddict_assignrprocess_newtype_declarationanalyze_enum_assignrecord_special_form_lvalue unwrap_final is_final_defanalyze_lvaluescheck_final_implicit_defstore_final_statuscheck_classvarprocess_type_annotationapply_dynamic_class_hookrXprocess_module_assignmentrprocess__all__process__deletable__process__slots__)rQrrold_basic_type_applicationsrrs rRvisit_assignment_stmtz&SemanticAnalyzer.visit_assignment_stmt{ s  2 21 5 ((*  ) )! ,*.*F*F '+/D (--/ &% &+FD (  9 9! <--/ &% & & HHOOD !  $ $S )T-A-A!((-K5Q7 6$$TYY5 6   ) )! ,--/ &% &  + +A .!ANL ( +//2# 33A6# 66q9# //2# ..q1# &&BB1E# ))!,#   + +A . **1- Q %%a( " A $$Q' %%a(vv  * *199ahh B A !!!$ a E & &  & & & &s$M+M %M-M M*-M7ct|jtrt|jdk7ry|jd}t|tr#|jj |j k7ry|j |jry|j }|j||}||jry|jy|jy||jvr|j||j|t|jtsJ|j|fD]9}|j|_ t|_|jj"|_;y)zSpecial case 'X = X' in global scope. This allows supporting some important use cases. Return true if special casing was applied. rFrT)r{rBrer~rrrXrrrarrr'rrnr%r"rr)rQrrArr_rs rRrYz3SemanticAnalyzer.analyze_identity_global_assignment s!((H-QYY11D1&(+qxx}} /K 99 D$6$6$8{{kk$" ;## xx4<<'chh2chh8HHf,6D #DI $DI$'HH$5$5DM6rTc|jryt|trP|j|j|}|r1t|j t r|j jsyyt|trUt|}|rG|j||d}|r1t|j t r|j jsyyt|tr5t|jtr|j|jSt|tr5t|j tr|j|j Sy)aCan we already classify this r.h.s. of an assignment or should we wait? This returns True if we don't have enough information to decide whether an assignment is just a normal variable definition or a special form. Always return False if this is a final iteration. This will typically cause the lvalue to be classified as a variable plus emit an error. FTrZ)rar{rerrrrnr,rbrr]r[r4rqr\r=r)rQrvrfnames rRr\z SemanticAnalyzer.should_wait_rhs s    b( # BGGR(AZ8AXAXJ ',R0E))%T)JAFFOA  ahh )j'.R((//**C,&G#1G*G G!))A,1   (1C!((Y$78rTc^t|jdk7st|jdtsyt|jt r$t|jj tsy|jj }|j||jtvS)z1Check if r.h.s. can be a TypeVarLike declaration.rrF) r~rr{rerBr=rrrrrrs rRr[z8SemanticAnalyzer.can_possibly_be_typevarlike_declarationC sr qyy>Q j1x&H!((H-ZQY5Zhhoo 4||222rTcdt|tsyt|jtr!|j d|j d|y|rhd}nt }t|jts|j |vryt|jtr|ry|jj St|jtr|jj tvSt|trP|j|j|}|r1t|jtr|jj ryyt|t"rTt%|}|rG|j'||d}|r1t|jtr|jj ryy)aDoes this expression refer to a type? This includes: * Special forms, like Any or Union * Classes (except subscripted enums) * Other type aliases * PlaceholderNodes with becomes_typeinfo=True (these can be not ready class definitions, and not ready aliases). If bare is True, this is not a base of an index expression, so some special forms are not valid (like a bare Union). Note: This method should be only used in context of a type alias definition. This method can only return True for RefExprs, to check if C[int] is a valid target for type alias call this method on expr.base (i.e. on C in C[int]). See also can_be_type_alias(). FzType variable "z%" is invalid as target for type alias> typing.Tupletyping.Callable typing.AnyTrZ)r{rqrrrrrrr rr rrrerrrnr,rbrr])rQrxr{ valid_refsrrys rRrzSemanticAnalyzer.is_type_refM sI$"g& bgg / II }4YZ\^ _ KJ*J bggy )R[[J-F bggx (ww& & bggs #77##{2 2 b( # BGGR(AZ8QVV=T=TJ ',R0E))%T)JAFFO<AXAXrTc.t|trt|jtrt |j dk(rt|j dtr|j |jj|j}|j |j dj|j d}|M|jrA|jjdk(r(|&|jr|jjdk(ryy)zIs this a r.h.s. for a None alias? We special case the assignments like Void = type(None), to allow using Void in type annotations. rrrr|TF) r{r=rrer~r^r]rrrr)rQrcallr s rRrzSemanticAnalyzer.is_none_alias s dH %4;;1 Na'tyy|X6,,T[[-=-=t{{K++DIIaL,=,=tyy|L$  **o=))_<rTc|jd}t|tsJd|_|j t k(r |j |j|_|j |_ y)zRecord minimal necessary information about l.h.s. of a special form. This exists mostly for compatibility with the old semantic analyzer. rTN) rr{reis_special_formrr%rrrrr")rQrrAs rRrgz+SemanticAnalyzer.record_special_form_lvalue s` 1&(+++!%  # # % -"11&++>FO..0 rTct|jtr5t|jjtr|j |S|j j||jS)zCheck if s defines an Enum.) r{rBr=r(rK_is_single_name_assignmentrprocess_enum_callrrRs rRrfz$SemanticAnalyzer.analyze_enum_assign sX ahh )j9J9JL.Y2215 5&&88D||jA|j> dddy #1swYyxYw) z Check if s defines a namedtuple.rrFzcollections.namedtuplez0NamedTuple type as an attribute is not supportedNz7First argument to namedtuple() should be "{}", not "{}"rTr+)!r{rBr=r(rdrrtrrr~rrerbrrqrrrrrrrr1r rcheck_namedtuplerrr% NAME_MATCHrrBrrC) rQrrArrrr internal_namerrPs rRrcz*SemanticAnalyzer.analyze_namedtuple_assign s( ahh )j9J9JN.[xx  %%00!!&&11: 66q99 qyy>Q j1*?U&V1 fj )!((H-*QXX__g2V88??33778G];]IIPRXY{{''-  " "4??#>#>y#I J -1-F-F-W-W$ 2 2 4. *M4$    $ MTTmHH))    $$T6D$I$$TYY :**4995+   s =J6AJ6AJ66J?ct|jtrt|jjtrn|jjj j rDt|jjj j s|j|St|jdk7s#t|jdttfsy|jd}|j}|j|}|j|j j#|5|j$j'|j||j)\}}}|s dddyt|tr|j+d| dddy|s|j-||dn/|j.}|j1|||j3| dddy#1swYyxYw)z Check if s defines a typed dict.rrFNz,TypedDict type as attribute is not supportedTr+)r{rBr=r(rrrorrr~rrerbrrrr1r rcheck_typeddictrrrrrBrC) rQrrArr is_typed_dictrrPrs rRrdz)SemanticAnalyzer.analyze_typeddict_assign s ahh )j9J9JM.Zxx  %%44_!!&&55> 66q99 qyy>Q j1*?U&V1{{''-  " "4??#>#>y#I J -1-E-E-U-U$ 2 2 4. *M4!    &*- H&Q  $$T6D$Iyy$$T95**40!   s?=H#H1AHH cpt|jdk(xrt|jdtSr)r~rr{rerRs rRrz+SemanticAnalyzer._is_single_name_assignment s)199~"Iz!))A,'IIrTc|jdu}|j|jr4t|jtsJ|jjsd}|j r5t|j t r|j j }nd}nd}|jD]!}|j|||j|#y)NFT) explicit_typerrO) rR is_final_typer{rr^rBr~no_rhsrrQri)rQrexplicitrOlvals rRrjz SemanticAnalyzer.analyze_lvalues s$$D0   a// 0a//= ==$$))  88!((H-)*%8"%)"!& II D   &#5   rTct|jtsyd}|j} t|jtr|jj }|st|jt r|jj}t|tr5|j r)|jj}|j dz|z}nt|trgt|jtrMt|jtr3|jj}|jj dz|z}nt|tr|}4 |sy|jj|}|sy|jD]0}t|t s|t#||j|2y)Nr6ry)r{rBr=rrqrrrbrrr[r4r(rr:get_dynamic_class_hookrrer)rQrryr callee_expr method_namerrs rRroz)SemanticAnalyzer.apply_dynamic_class_hooksW!((H- xx$++w/ ,,Z Z@"kk.. k73 8L8L"&++"2"2K'0036DE{I6";#3#3W=";#7#7I"&++"2"2K',,55;kIE X6&D  {{11%8 II @DdH- 'dii> ? @rTc|jr|j|jsyt|jtsJt |jj dkDr|j d|jd}|jj snd|_t|jtrk|jjrU|jr|jjs3d}|j d|n|jj d|_|jG|jjdkr.|j|jr|j d |yt |jdk7st|jdt s|j d |y|jd}t|t sJ|j"r|jdu|_|j&d dkDr|j d ||jrA|jj(r+|j+r|j,j/|t|jtrO|jjr9|j0s-|j+s|s|j,j3|y) amStrip Final[...] if present in an assignment. This is done to invoke type inference during type checking phase for this assignment. Also, Final[...] doesn't affect type in any way -- it is rather an access qualifier for given `Var`. Also perform various consistency checks. Returns True if Final[...] was present. Frz*Final[...] takes at most one type argumentNTzAType in Final[...] can only be omitted if there is an initializerr)r z=Variable should not be annotated with both ClassVar and FinalzInvalid final declarationrzCannot use Final inside a loop)rRrr{rr~r^rrXrBr~rrsr#rrrrq is_new_defis_inferred_defr5r/rrArr[final_without_value)rQrinvalid_bare_finalrs rRrhzSemanticAnalyzer.unwrap_final<s   (:(:1;L;L(M!++[999 q  %% & * IIBADUDU V"  %%AF188X.HHOOtyy'?'?%)" ]_`a&&++A.AF FF  ++g5  ( IIUWX Y qyy>Q j1w&G II11 5yy|$((( ??#$66T>D ??2  " II6 : 99..""$77: qxx *%%'')%,,Q/rTc`|jsy|jd}t|tsJt|trp|j |s|j d|d|_y|jsJ|jdjdk7r|j d|d|_yyy)zDo basic checks for final declaration on self in __init__. Additional re-definition checks are performed by `analyze_lvalue`. Nrz;Final can be only applied to a name or an attribute on selfFrrSz (rTc|jrt|jdk(rt|jdtr|jdj }t|t rd|_|jr%t|j|j|_ |jr:t|jtr|jjrd|_yyyyyyy|j#|jD]=}t|t$rt|jt&r|jj(r|jj*j-|j.d}|rt|j t rft|jtr|jjs6t1|j j. x|j _|_t|t2s|j5|s|jsJd|jj*j-|j.d}|sbt|j t s~|j js|j6sJ|j6d}|j.dk(s|j j s|j j8rt|jtr|jjr&d|j _d|_@y)zRIf this is a locally valid final declaration, set the corresponding flag on `Var`.rrTNSelf member outside a classrrS)rir~rr{rqrrrrXrrBr final_valuerr~rfinal_unset_in_classflatten_lvaluesrerr rqrrrrbrr2final_set_in_init)rQrrrcur_nodecurrent_functions rRrlz#SemanticAnalyzer.store_final_statussG >>199~"z!))A,'Hyy|((dC($(DMvv+=ahh+X(**,"188X6188??481+>r+B(,11Z? ( B B$,MM$C$C%/(%C>BHMM;-1ANW+ 2rTcg}|D]T}t|ttfr+|j|j |j D|j |V|SrV)r{rr_rrrr)rQrreslvs rRrz SemanticAnalyzer.flatten_lvaluessR " B"y(34 4//9: 2    rTc |jr|jd}t|t}|j |j|}| t |r|j |y||_|jr|jjrt|trt|jtr|jjrtt|jtrYd|j_nF|jrI|jjr3|j|r"|j!s|j#d|t%|jdk(rt|jdt&r|jd}d}|jrft|trVt%|jj(dkDr4|jj(dj+|j,du}|r7|j.r+|j1|j|j2|_|jr.|jD]}|j5||j yy)z5Analyze type annotation or infer simple literal type.rrNTz8All protocol members must have explicitly declared typesrr)rXrr{rrrrr/rerBr~rrris_abstract_varis_annotated_protocol_memberrrr~rqrjrrranalyze_simple_literal_typeristore_declared_types)rQrrArr(ref_exprsafe_literal_inferences rRrnz(SemanticAnalyzer.process_type_annotations 66YYr]F",VY"? ~~affBU~VH?8#< 1 AF II))vx0qxx2HHOOfkk3/26FKK/ II))55a8**, TVWX199~"z!))A,'H99Q<)-&99Hh!?C DVYZDZ.2YY]]1-=-A-A(---PTX-X*)h.F.F!==ahhWAF 66)) :))&!&&9 : rTc:td|jDS)zCheck whether a protocol member is annotated. There are some exceptions that can be left unannotated, like ``__slots__``.c3zK|]3}t|txr|jdk7xr |j5yw) __slots__N)r{rerr)rrs rRrz@SemanticAnalyzer.is_annotated_protocol_member..s; H % W"''[*@ WREWEW W r)rrrRs rRrz-SemanticAnalyzer.is_annotated_protocol_members" ii   rTcl|jryt||j}|t|tryt|t rd}n8t|t rd}n%t|trd}nt|trd}|j}|r|r|jt||S|S)zReturn builtins.int if rvalue is an int literal, etc. If this is a 'Final' context, we return "Literal[...]" instead. Nz builtins.boolz builtins.intrzbuiltins.float)rhrb)last_known_value) r2rrr{complexrintrfloatrrr)rQrBrrh type_namers rRrz,SemanticAnalyzer.analyze_simple_literal_type s    "64??; =Jug6 eT "'I s #&I s #&I u %(I%%i0 8$$kX[6\$] ] rTctt|jxr|jdj}|j xr |j } t ||j |j |j} |j| } g} |j|} || n|} |j|j j#| 5|j%| | } |r*|j'5|j)|dddt+| ||j |j,|j |j.|j0|||| || \}}dddg}d}| D](}t3|t4r|rd}|j7|*| Dcgc]\}}|j8}}}t3| t:r | j<nd}|||fS#t$r4|jd|tjdgtgdfcYSwxYw#1swYxYw#1swYxYwcc}}w) aCheck if 'rvalue' is a valid type allowed for aliasing (e.g. not a type variable). If yes, return the corresponding type, a list of qualified type variable names for generic aliases, a set of names the alias depends on, and a list of type variables if the alias is generic. A schematic example for the dependencies: A = int B = str analyze_alias(Dict[A, B])[2] == {'__main__.A', '__main__.B'} rr]z2Invalid type alias: expression is not a valid typerNF)rin_dynamic_func global_scopeallowed_alias_tvarsalias_type_params_namesrZT)rr2 is_dynamicrXrr#r[r]rrr%r&r?rrrr1r rrfrrr:r$r^r{rrrrrempty_tuple_index)rQrrBrdeclared_type_varsall_declared_type_params_namesrZdynamicrrfound_type_varsrPralias_type_varsr( depends_on new_tvar_defsvariadictd_namerqualified_tvarsrs rR analyze_aliaszSemanticAnalyzer.analyze_alias(s9&t**St/B/B2/F/Q/Q/ST99}@T-@-@)@  .) d&7&7$J_J_C2237+- ''- -?-G/M_  " "4??#>#>y#I J 11/3GI%113(MM$'($6  !!**"3 ')$-(F'=$ Hj 0  %B"./   $  %=LL[UD4==LL5?[5QC11W\ OEVVV[$ . IIDfSXScSc  SUB- -  .((   BMs=-G%H(8H AH(H4:HHH% H((H1c|jWt|jtr=|j|jj|d}|r|j t vryy)NTrZF)rRr{rr]rrrr)rQrrs rRrzSemanticAnalyzer.is_pep_613psV   (Z8I8I;-W**1+<+<+A+A1VZ*[F&//-==rTc |jry|jd}t|jdkDst|tsy|j |}|s |j y|j|j|jr:|jjd}d}|j|j\}}n|j}d}d}d}t|tr |jry|jj|j}|rt|j t"smt|j t$r |j&rGt|j t(r|j j j*|j*krRt|j t$r7|j&s+|j-dj/|j|y|j0xs|j3} |s|st|t4r| ry|s|s|j7|sy|r!t|j t(t$fsyd} |j9|rt;} g} t=} g} d}n|j?}|jA|j|d||\} } } } }| sy|j3s#t| tBxrt| tD}n tG| }|jI|s|r|jK|j|d y|jM| |jM| tO| |jP|jR|jT| tW| } |jPjXr>t[| r3tG| s(|jTj]d | |t_| } t| tBxr)t| t`xr| j xr| xr| }t| tBrUt| t`rEtc| |j,|s.te| |j,|jfd|jP |j3}t%| |ji|j|j*|jj| ||| }t|jtlttnfrt|tnr%|jPjpdk\s |jrrt|jjttstu||j_ |j*|jj_| jj|jj_5n+t|jt4rd|j_;|rd}t|j t$r`|j jx| k7rP| |j _<| |j _=||j _>d}d|j _?n ||_d}|r[|jr|j|jd|y|j|dn|j|j||t|t4r5t|j t$r|j j|_D|r |j n|}t|t$sJ|j|||j|jre|j0J|j0jrA|j-d||jdjs|jgd|y)a/Check if assignment creates a type alias and set it up as needed. Return True if it is a type alias (even if the target is not ready), or False otherwise. Note: the resulting types for subscripted (including generic) aliases are also stored in rvalue.analyzed. TrrFN)rzTCannot assign multiple types to name "{}" without an explicit "type[...]" annotation)rrrr+r.Type alias targetrr`reagerrZ)r rrpz.Type aliases are prohibited in protocol bodiesz9Use variable annotation syntax to define protocol members)Iinvalid_recursive_aliasrr~r{rerrRcheck_type_alias_type_callrBrr^analyze_type_alias_type_paramsr=r(current_symbol_tablerrrr r_rnrrrrXrrqrrrr?rrrrrrrr*rr#r^rAmake_any_non_explicitrrrmake_any_non_unimportedrrrrrrr[rirr[rr<rr`r _is_recursiveracannot_resolve_namerrr!disable_invalid_recursive_aliasesrr/isupper)rQrrApep_613rBpep_695 type_paramsall_type_params_namesrnon_global_scoperr`rrrrincomplete_targetrrrupdated current_nodes rRr^z,SemanticAnalyzer.check_and_set_up_type_aliaswsA $ $1 qyy>A Z%A//!$1,,8  * *188&++ * FXX]]1%FG151T1TUVU]U]1^ .K.XXFGK$( ! fh 'FOO,,.226;;?  x}}c *8==)4Q^^8==/:x}}?Q?Q?V?VYZY_Y_?_(--3ANN BBH&BU 99<(:(:(<w:fg+FK[wt/E/Ef/M Jx}} 6RS   f %*C13K#&5J)+O % ,,.COSOaOa "&#./D PbP LCj/;L%%'%/sJ$?%JE!%4C$8!((-1B$$V[[&4$P   ,   1 sDLL$2L2Ldhh`ab$C( << / /4PQT4U"3'445H#qQ-c2 sJ ' 3) HH  &%   c: &:c8+D$S$))5FGS$))TYYUTXT`T`a""$     , FF HH##*   ahhHf = >66* ++w6$:K:Kahh//?$1*$=!%&VVAHH   "'*zzAHH   $ ' *'+AHH $ G(--3==''3.,/HMM(0;HMM-,3HMM)"G26HMM/!+ '',,V[[&!DJJqJ6 OOFKKQ 7 fg &:fkk9+M$*KK$:$:J !(0x}}j , 222 ..q,I    99( ((yy$$ JAN{{1~--/IIY[\]rTc.t|tsydg}|jjdk\r|j dt |j t|sy|j|||sy|jjtdk7ryy)NFtyping_extensions.TypeAliasType)r typing.TypeAliasTyperT) r{r=r#rrrrtuplecheck_typevarlike_namer$countr!)rQrBrrqs rRrz+SemanticAnalyzer.check_type_alias_type_callIs&(+23 << & &' 1 LL/ 0!&--u>**64@    ! !' *a /rTcd|jvr[|j|jjd}t|ts|j d|ggfS|j }nggfSg}g}d}|D]}t|trd|_|j| |j|}t|tsO|j} |j|d} | r=t| dtr|r%|j d|t j"d}d}n|j%| s|j'|j(|} | r@t| j*t,r&|j/| j*j(nX|j d |t j"| r4| j0t2vr"|j5d |t j"z| |vr+|j d | d d |t j"| s|j/| d |j/| ||fS#t$rYwxYw)zAnalyze type_params of TypeAliasType. Returns declared unbound type variable expressions and a list of all declared type variable names for error reporting. rzCTuple literal expected as the type_params argument to TypeAliasTypeFT)rrzFCan only use one TypeVarTuple in type_params argument to TypeAliasTyperzDFree type variable expected in type_params argument to TypeAliasTypez*Don't Unpack type variables in type_paramszDuplicate type variable "rz*" in type_params argument to TypeAliasType)r@r^indexr{rrrrwrrrrrrrrr%TYPE_VARrr]rrrrrrrr) rQrBtype_params_argrrall_declared_tvar_namesrtp_exprr4rrr_s rRrz/SemanticAnalyzer.analyze_type_alias_type_paramsYsT F,, ,$kk&*:*:*@*@*OPOoy9 Y#2v )//Kr6M*,-/#"0 ,G'8, %  " "7 + 33G<dK0,,.C11$41PDd1g'78* d !&" /3+ *.'..s3++DIIt<:chh@+22388==AII^"^^ s||/@@ H$UZUcUc"~% /Qy8bc '..tAw7%%d+a0 ,b666W(  s#I IIcLg}t|jtr8|jj|ur |j d|j dnSt |h|jr*>"?L (,A % C IIc3  rTcz|rt|tsJdt|tr|j||||||yt|tr<|j |||||r%|j |s|j d|yyyt|tr&|r|j d||j|yt|tr|j||yt|tr3|r|j|j||y|j d|y|j d|y)aAnalyze an lvalue or assignment target. Args: lval: The target lvalue nested: If true, the lvalue is within a tuple or list lvalue expression explicit_type: Assignment has type annotation escape_comprehensions: If we are inside a comprehension, set the variable in the enclosing scope instead. This implements https://www.python.org/dev/peps/pep-0572/#scope-of-the-target is_index_var: If lval is the index variable in a for loop z-assignment expression target must be NameExpr)rO is_index_varz;Type cannot be declared in assignment to non-self attributezUnexpected type declarationz4Starred assignment target must be in a list or tupleInvalid assignment targetN)r{reanalyze_name_lvaluerbanalyze_member_lvaluerrr[rranalyze_tuple_or_list_lvaluerwrQr)rQrrrrrNrOr s rRrQzSemanticAnalyzer.analyze_lvalues* !dH- ^/^ ^- dH %  $ $%#5) % j )  & &t]HFX YT%<% KK  i (  - -dM B h '##DIIv}E PRVW II14 8rTc@|jry|j}|j|r>|r|jd|n)|jj ||j du||j}|j|} | j|} |j|} |tk(rt|j tr|j jr|jdsz| Pt| jt s6|jdj#||j j||r&|r$|jd||j%d|| rt| jt r| s|j'||| ||} |j)|| ||} | rd|_d|_||_| |_|t0k(r| j2|_n|j|_|j7rOt9|d k(rA|j:j<s+t?t@jB}|jE|||r&|jG||r|jd|yyy|jI|||y) znAnalyze an lvalue that targets a name expression. Arguments are similar to "analyze_lvalue". N)Cannot redefine an existing name as final)rN__z;Attempted to reuse member name "{}" in Enum definition "{}"z%Enum members must be left unannotatedzLSee https://typing.readthedocs.io/en/latest/spec/enums.html#defining-membersTr5)%rris_alias_for_final_namerrAcant_assign_to_finalrXrrris_global_or_nonlocalr*r{rr r*rnrrmake_name_lvalue_varrrrr"r%rrrrrr#rrrrris_final_redefinition&make_name_lvalue_point_to_existing_def)rQrArrrNrOr rr"rqrouterraddedrs rRr z$SemanticAnalyzer.analyze_name_lvalues; ;; {{  ' ' - EvN--dDIIT4I6R'')))@U)V99T?**40 DL499h/ !!OOD)#Jx}}o,V QXXdiinn !3 A6J b Jx}}oFPU++-/1C\COOD#vMbOcE$(!)-&" ! 4<&)mmFO&,kkFO%%'~,T\\5X5X&i&<&<=11&#>D66tTB EvNCx  7 7 x XrTc|tk(r%|j|xr|j| S|tk(r0|jr$t |dz|jj vSy)N'F)r%is_mangled_globalis_initial_mangled_globalr*rXrrq)rQr"rs rRrz&SemanticAnalyzer.is_final_redefinitionAsZ 4<))$/\8V8VW[8\4\ \ T\diiD>C'499??: :rTcN|jrl|jdsyt|}|jdJd|jdj |}|duxrt |j S|jTt|dz}||k(ry|jjj |}|duxrt |j St|dz}||k(ry|jj |}|duxrt |j S)NrFrzNo locals at function scope) rrrr*rrrrXrqr')rQrr orig_names rRrz(SemanticAnalyzer.is_alias_for_final_nameHs     ==%D>D;;r?. M0M M.{{2**40H4'HM(--,H H YY " ,Iy yy**95H4'HM(--,H H ,Iy ||'' 2H4'HM(--,H HrTcT|j}t|}|j|||_|tk(r3|j J|j |_d|_|tv|_ |tk7r|j||_ n||_ d|_ ||_||_|S)z:Return a Var node for an lvalue that is a name expression.TF)rrr is_inferredr*rXrrrallow_incompatible_overrider)rrrrOr )rQrAr"inferredrOr rrs rRrz%SemanticAnalyzer.make_name_lvalue_var^s{{ I 6  4<99( ((YYAF(,A %,04O,OA ) 4<--d3AKAK 1%rTc|r|jd||j|j|d}|A|jr5|j s%|jj |j}|r|j |j||y|r|j||n|j|j||j|j|y)zUpdate an lvalue to point to existing definition in the same scope. Arguments are similar to "analyze_lvalue". Assume that an existing name exists. rTrZN) rrrrXrrrbind_name_exprname_not_definedcheck_lvalue_validityr)rQrrrras rRrz7SemanticAnalyzer.make_name_lvalue_point_to_existing_defzs  IIA4 H{{499dD{I  DIId6H6H6J99==3L   % %dii| D##D,7%%dii6  & &tyy$ 7rTc|j}|Dcgc]}t|ts|}}t|dkDr|j d|yt|dk(r d|d_|D]}|j |d|dycc}w)z?Analyze an lvalue or assignment target that is a list or tuple.rz%Two starred expressions in assignmentTr)rrrrON)rr{rwr~rrrQ)rQrrrr\ star_exprsrs rRrz-SemanticAnalyzer.analyze_tuple_or_list_lvalues ',Kt 40JdK K z?Q  II=t D:!#&* 1 # ##"/(, $ Ls BBc~|jry|j||j|rq|jsJd|jjj |j }|jj |j }|r|r|jd||jsQ|rOt|jtr5|jjr|r|j|j |||jjr/|r-|+t|jtrd|j_ |:|0t|jtr|jjs||s|r|jjr||jd|nd|_d|_t|j }|j!||j#|j |_|j|_d|_|xs||_||_||_t/t0|d|jj|j <|j2j4D]}t|t6sd|_|j;|j|y)zAnalyze lvalue that is a member expression. Arguments: lval: The target lvalue explicit_type: Assignment has type annotation is_final: Is the target final NrrFz9Protocol members cannot be defined via assignment to selfT)implicit)rrrrXrqrrrr{rr!attribute_already_definedr/rrrrrrrrexplicit_self_typedef_varr}r*rG functionsrRhas_self_attr_defr') rQrrrrOrrrrUs rRr z&SemanticAnalyzer.analyze_member_lvalues 99  D  " "4 (99 ;; ;9yy**4995H99==+DH EtLIIx}}c2MM--!..tyy$Iyy$$);@ThmmS149HMM1 $DIIs)C HaHa$-899((T\IIY[_`'+DO+/D(DIIAJJt$"&"5"5dii"@AK!YYAF!&AJ+8+DHA(#$DL !DI1@qSW1XDIIOODII. $ 4 4:%dG459D2: ""499d3rTct|jtsy|jj}t|txr |j S)z1Does memberexpr to refer to an attribute of self?F)r{rrerrr)rQ memberexprrs rRrz#SemanticAnalyzer.is_self_member_refs8*//84##$$55rTct|tr|jd|yt|tr!|jtj |yy)Nr )r{rrrrCANNOT_ASSIGN_TO_TYPE)rQrrs rRr'z&SemanticAnalyzer.check_lvalue_validitys? dK ( II13 7 h ' II&<ND(--dH=> FO  )  % %fkk3 7 rTc2|j|d}|sy|j||}|y|jddjt}|j |j dd|z}|j|j d|zd|jd|zd|jd|zd||}|y|\}}} |jj|} | rct| jtsIt| jtr| j|jus|j!d|d|y|j"j$rmt'|dD]3\} } t)| sd| } |j*j-| | |5t)|rd } |j*j-| ||||| gzD]0}t/||j"|j0|j*| 2|r/|j"j2rt5t6j8}|js:t||j;|||| |}|j<|_||_d }nt|jtsJ||jj>k7xs4||jj@k7xs| |jjBk7}||j_ ||j_| |j_!tEd |Dr|jGdd ||nAtI|r|jGdd||n tI| r|jGdd|||jK||j|y )zCheck if s declares a TypeVar; it yes, store it in symbol table. Return True if this looks like a type variable declaration (but maybe with errors), otherwise return False. )ztyping.TypeVarztyping_extensions.TypeVarFNrzCannot redefine "z" as a type variable)startz Constraint zUpper bound of type variabler.Tc32K|]}t|ywrVr0rrs rRrz?SemanticAnalyzer.process_typevar_declaration..hs2aq!2r2zTypeVar valuesrpzTypeVar upper boundzTypeVar default)&get_typevarlike_declarationextract_typevarlike_namer$rr!analyze_value_typesr^process_typevar_parametersr@rrr{rrnrr(rr#rrrrArrr^mypycrrimplementation_artifactrrrtrurvrrwrr)rQrrrn_valuesrtrrrurvrr constraintrrtype_varrs rRr`z,SemanticAnalyzer.process_typevar_declarationsO //3bc,,Q5 <>>!"%++G4))$))AH *EF-- IIa(ln % NN1x<> * NN1x<> *    ;),&+w,,.2248  x}}o 6 { 3 8V II)$/CDa H << / /#,V1#= PZ/ ;*3%0FHH88QO P ,K8744V[!L;00 A "4<<!;!;TXXq   dll((!)"C"CDK}}"d))$/gxH!IIHM$DMGdmm[9 99$--...4$--";";;4dmm333  )4DMM %#)DMM $+DMM ! 262 2  $ $T+;Qw $ W [ )  $ $T+@!T[ $ \ W %  $ $T+The default argument to TypeVarTuple must be an Unpacked tuple)rr{rrrrr?rHs rRr&z+SemanticAnalyzer.check_typevartuple_defaults;g&#z* IIVX_ `i223GrTct|}t|jtsJt|jtr|jj n|jj }t|jdkr|jd|d|yt|jdtr|jdtk7r|j|d|y|jdj|k7r=d}|j|j|jdj|||yy) zDChecks that the name of a TypeVar or ParamSpec matches its variable.rzToo few arguments for z()Frz-() expects a string literal as first argumentzCString argument 1 "{}" to {}(...) does not match variable name "{}"T)rr{rrqrerrrr~r^rryr$r!rhr)rQrrr typevarlike_typerAs rRrz'SemanticAnalyzer.check_typevarlike_names~$++w/// *4;; ADKK  t{{G[G[  tyy>A  II./?.@CW M$))A,0DNN14E4P II)**WXZa b YYq\  4 'WC IIcjj1!3!35EtLg VrTct|jdk7st|jdtsyt|jt sy|j}|j }t|tsy|j|vry|S)zReturns the call expression if `s` is a declaration of `typevarlike_type` (TypeVar or ParamSpec), or None otherwise. rrN) r~rr{rerBr=rrqrr)rQrtypevarlike_typesrrs rRr<z,SemanticAnalyzer.get_typevarlike_declarationsm qyy>Q j1x&H!((H-xx&'* ??"3 3 rTc|dkD}d}d}|j} ttj} t |||D]\} } } | j s"|j tj|y| dk(r_t| tr| jdvr| jdk(}m|j tjjd|y| dk(r_t| tr| jdvr| jdk(}|j tjjd|y| dk(r2|r|j d|y|jd | | |}|y|} 9| d k(r5|jd | | |d }|xsttj} s| d k(r&|j d||j d|y|j tjd| d|y|r|r|j d|y|dk(r!|j tj |y|rt"}n|rt$}nt&}|| | fS)NrF covariant)rrr contravariantboundz2TypeVar cannot have both values and an upper boundr rvTrdrtz'TypeVar "values" argument not supportedzAUse TypeVar('T', t, ...) instead of TypeVar('T', values=(t, ...))z: "r=z2TypeVar cannot be both covariant and contravariantr)r#rrrxr6is_namedrrTYPEVAR_UNEXPECTED_ARGUMENTr{rerTYPEVAR_VARIANCE_DEFrget_typevarlike_argumentr?"TYPE_VAR_TOO_FEW_CONSTRAINED_TYPESr$r#r')rQr^rqkinds num_valuesr  has_valuesrRrSrurv param_value param_name param_kindtv_argrs rRr?z+SemanticAnalyzer.process_typevar_parameterss\ !^    ,,.  ? ?@36tUE3J*  /KZ&&( *FFP[(k849I9IM^9^ + 0 0F :III.CCJJ;WY`a.k849I9IM^9^$/$4$4$>MII(==DD_UW^ w&IIRT[\66y*k[bc>$ y(66z;UY7!AGI,@,@$Ax' CWM WY` 'CCDC |STUW^U* X  IIJG T 1_ II&II7 S  H $H Hg--rT)rJrrreport_invalid_typevar_argc |j|dd|||} | tdg|j} t| } |rLt | t r<| j r0|jtjj|||| S#t$r5|r0|jtjj|||YywxYw)NTF)rrrJrr) rrrrr{rrFrrrGrr) rQtypevarlike_namer^r]r rJrrrar(rs rRrXz)SemanticAnalyzer.get_typevarlike_arguments" 11"&%*$7*C) 2H+4W\\B!(+C)jg.F3K\K\ $==DDEUWab J# ) $==DDEUWab  sB B ;C  C c|sy|jd}t|tsJ|jr|j d|y|j ||j |sy|j S)Nrz9Cannot declare the type of a TypeVar or similar construct)rr{rerXrrr)rQrrrAs rRr=z)SemanticAnalyzer.extract_typevarlike_name0sb1&(+++ 66 IIQST U**4a@{{rTc |j|d}|sy|j||}|y|jddjt}|dk7r|j d|t tj}t|jd|zd|jd|zdD]d\}}|dk(rH|jd|||d d d }|xst tj}|j||}S|j d |f|jsKt!||j#||j%|t&} |j(| _| |_d } nFt+|jt sJ||jj,k7} ||j_t/|r|j1dd || |j3||j|y )acChecks if s declares a ParamSpec; if yes, store it in symbol table. Return True if this looks like a ParamSpec (maybe with errors), otherwise return False. In the future, ParamSpec may accept bounds and variance arguments, in which case more aggressive sharing of code with process_typevar_declaration should be pursued. )ztyping_extensions.ParamSpecztyping.ParamSpecFNrrz-Too many positional arguments for "ParamSpec"rv ParamSpecT)rJrrazOThe variance and bound arguments to ParamSpec do not have defined semantics yetzParamSpec defaultrp)r<r=r$rr!rrrrxr6r^r@rXr?r%r(rlrr#r'rr{rvrrwr) rQrrrrBrvr]r^r` paramspec_varrs rRraz.SemanticAnalyzer.process_paramspec_declaration>s// B ,,Q5 <>>!"%++G4 q= IIEq I ? ?@'* IIa(ln %t~~a(ln'E(   #KY&66(,.2/47!AGI,@,@$A66w L  e' 8}})d))$/1A1A1CWiM"&M )DMGdmm]; ;;!6!66G$+DMM ! 7 #  $ $T+>RY $ Z dmmQ/rTc "|j|d}|sy|jddjt}|dk7r|j d|t t j}t|jd|zd|jd|zdD]h\}}|dk(rH|jd|||d dd }|xst t j}|j||}S|j d |d |j|j||}|y|jsm|j!d |j#g} t%||j'|| j)| |t*} |j,| _| |_d } nFt/|jt$sJ||jj0k7} ||j_t3|r|j5dd|| |j7||j|y )zChecks if s declares a TypeVarTuple; if yes, store it in symbol table. Return True if this looks like a TypeVarTuple (maybe with errors), otherwise return False. )ztyping_extensions.TypeVarTupleztyping.TypeVarTupleFrNrz0Too many positional arguments for "TypeVarTuple"rv TypeVarTupleT)rJrarzUnexpected keyword argument "z" for "TypeVarTuple"rzTypeVarTuple defaultrp)r<r$rr!rrrrxr6r^r@rXr?r&r=r(rr#rrrr'rr{rvrrwr) rQrrrBrvr]r^r`rr!typevartuple_varrs rRrbz1SemanticAnalyzer.process_typevartuple_declarations // H >>!"%++G4 q= IIH! L ? ?@'* IIa(ln %t~~a(ln'E(  _ #KY&66"(,/4!%7!AGI,@,@$A99';O 9*EYZ\]^! _$,,Q5 <}}!__-=@P@P@R?STN/##D),,.  %)II  !,DMGdmm-=> >>!6!66G$+DMM ! 7 #  $ $T+A1U\ $ ] dmmQ/rTc2|jr!|jsd|vr|dt|zz }t|t g}|jr3|js'|j dz|j |z|_n|j ||_tt||j }||_ |jj}|s&|j|jjg}|g|z|_ |g|_ |S)Nrry)rrXrr?r:rrrrrr|rrjr#rO)rQrbasetype_or_fallbackr class_defrrjs rRbasic_new_typeinfoz#SemanticAnalyzer.basic_new_typeinfos     co C#d)O #DT59-     "&3!69L9LT9R!RI !%!4!4T!:I  y$//B "''++',,d.>.>.@.E.EFC6C<*+  rTcg}|D]} |j|j|d}|tdg|j}t |rI|j t j||jttjn|j||S#t$r=|j d||jttjYwxYw)zBAnalyze types from values expressions in type variable definition.TrNz Type expected) rrrrrrrr'rrrr?r)rQrr7rr(s rRr>z$SemanticAnalyzer.analyze_value_typess =D =>>006$*# /tRCH *II.OOQUVMM')*>*>"?@MM(+ =$ ( = /40 gi&:&:;< =sB B--AC32C3c|jd}t|jdk7st|tsy|jr|j |jsyt|jt sJ|jrt|tr|j}t|trd|_|j|j}|jJ||jjt|vrs|jjjrS|j!t"j$|n2t|t&r|j)|r|j+||jj,sqt|j.t0rO|j.j2r9|j4j6r"|j!d|t8j:yd|_yy)z-Check if assignment defines a class variable.rrNTz*ClassVar without type argument becomes Anyr)rr~r{rqrXrrrrerrrr(rrrrrCLASS_VAR_WITH_GENERIC_SELFrbrrr^rBr~rr#disallow_any_genericsr%TYPE_ARG)rQrrArr(s rRrmzSemanticAnalyzer.check_classvarso1 qyy>Q j&A vvT--aff5 !&&+...    Z%A;;D$$#' ~~aff-H99( (($II''=+BBIINN,, *FFJFJ/43J3J63R  & &v .vv{{!((H-!((//<<55IIJATYTbTbIcAF rTct|tsy|j|j|}|r |jsy|jj dk(S)NFztyping.ClassVar)r{rr]rrrrrQrr_s rRrzSemanticAnalyzer.is_classvarsG#{+##CHHc2#((xx  $555rTct|tsy|j|j|}|r |jsy|jj t vSNF)r{rr]rrrrrrus rRrzSemanticAnalyzer.is_final_typesG#{+##CHHc2#((xx  $444rTcD|jtj|yrV)rrCLASS_VAR_OUTSIDE_OF_CLASS)rQr s rRrz&SemanticAnalyzer.fail_invalid_classvars "==wGrTct|ttfrttd|Drbt t t|}t |jg|Dcgc]}|jc}}|D]^}}|j|||yt|tr|j|} | rt| jtr|D]} t| tst| jtr| jjFt| tr*|j!j#| j$} n`t| t&rO|j)| r>|jJ|jj*j#| j$} n| st| jtr]| j| jurEt| tt&fsJ|j-dj/| j$|Z| j0sh| jJ| j| _ yyyycc}w)a(Propagate module references across assignments. Recursively handles the simple form of iterable unpacking; doesn't handle advanced unpacking with *rest, dictionary unpacking, etc. In an expression like x = y = z, z is the rval and lvals will be [x, y]. c3<K|]}t|tywrV)r{rr;s rRrz=SemanticAnalyzer.process_module_assignment..-s; )*Jq) $; rNzZCannot assign multiple modules to name "{}" without explicit "types.ModuleType" annotation)r{rr_rr r_r6rrprqrrrcrrXrerrrrbrrqrrr) rQlvalsrvalr seq_lvalsrelementwise_assignmentsrxlvsrnoderlnodes rRrpz*SemanticAnalyzer.process_module_assignment!s dY1 2s; .3; 8 T)_e4I$'*$**&T7SA7S&T #3 =S..sB< = g &))$/EEJJ9!4D%dG4 !$))S1diinn6P "$1 $ 9 9 ; ? ? J#D*5$:Q:QRV:W#yy444 $  3 3DII > %ejj(; RWR\R\@\#-dXz4J#KK#K II!QQWQWX\XaXaQb # "11#(::#99#9).EJ74:u'8TsI czt|jdk(rt|jdtr|jdjdk(rh|jdj t k(rGt|jttfr&|j|jjyyyyyy)z1Export names if argument is a __all__ assignment.rrrN) r~rr{rerr"r%rBr_r add_exportsrrRs rRrqzSemanticAnalyzer.process__all__is  Na 199Q<2 ! !!Y. ! !!T)188h %:;   QXX^^ ,<*/3 rTcl|jjsyt|jdk(rt |jdt r|jdj dk(r|jdjtk(r|j}t |ttfs|jd|y|j}g}|D]@}t |ts|jd|&|j|j B|j"sJ||j"_yyyyy)Nrr __deletable__zC"__deletable__" must be initialized with a list or tuple expressionz5Invalid "__deletable__" item; string literal expected)r#r@r~rr{rerr"r*rBr_rrrryrrhrXdeletable_attributes)rQrrBrattrsr\s rRrrz%SemanticAnalyzer.process__deletable__ts||!!   Na 199Q<2 ! !!_4 ! !!T)XXFfx&;< _abcLLEE -!$0IIUW[\LL,  - 99 9-2DII **53 rTct|jtr9t|jdk(rt|jdt r|jdj dk(r|jdjtk(rt|jtttttfsytd|jj ddDryd}g}t|jtr|j#|jnt|jtttfr&|j%|jj&n6|jj&D]\}}|r||j#|d}g}|D]?}t|tr+|j(d k7r|j#|j(>d}A|sy|jj ddD]+}|j*J|j%|j*-t-||j_yyyyyy) z Processing ``__slots__`` if defined in type. See: https://docs.python.org/3/reference/datamodel.html#slots rrrNc38K|]}|jduywrV)slots)rrls rRrz4SemanticAnalyzer.process__slots__..s@q177d?@rirTF__dict__)r{rXrr~rrerr"r*rBryr_rrurHrrjrrrrhrr?) rQrconcrete_slotsrBkeyr5rr\ super_types rRrsz!SemanticAnalyzer.process__slots__s tyy( +AII!#199Q<2 ! !![0 ! !!T)ahh(IwPX(YZ@DIIMM!B,?@@!N')F!((G, ahh'AHHxG&DE ahhnn- hhnn/FC%#/ c*). / E +dG,z1ILL,%*N  +"#iimmAb1 / !''333 Z--. /"%jDIIO[*13$ ,rTc|jry|jdxxdz cc<|jD]}|j||jdxxdzcc<y)Nrr)is_unreachabler-r|r)rQrhrs rR visit_blockzSemanticAnalyzer.visit_blocksX    ! A KKN  !rTc,|r|j|yyrV)r)rQrhs rRvisit_block_maybez"SemanticAnalyzer.visit_block_maybes   Q  rTcH||_|jj|yrV)r;rrrRs rRvisit_expression_stmtz&SemanticAnalyzer.visit_expression_stmts  drTc |j}||_|js|jd||jr|jd|d|jr|jj |||_y)Nz"return" outside functionz%"return" not allowed in except* blockTrU)r;rrrMrr)rQrres rRvisit_return_stmtz"SemanticAnalyzer.visit_return_stmtsgnn!!# II11 5  4 4 II=q$I O 66 FFMM$ rTc||_|jr|jj||jr|jj|yyrV)r;rr from_exprrRs rRvisit_raise_stmtz!SemanticAnalyzer.visit_raise_stmts> 66 FFMM$  ;; KK  t $ rTc||_|jr|jj||jr|jj|yyrV)r;rrrArRs rRvisit_assert_stmtz"SemanticAnalyzer.visit_assert_stmts< 66 FFMM$  55 EELL  rTc||_|jj||jj|t |jt r|jj dk(re|jjtk(rGt |jttfr&|j|jjyyyyy)Nr) r;rArrBr{rerr"r%r_rrrrRs rRvisit_operator_assignment_stmtz/SemanticAnalyzer.visit_operator_assignment_stmts   qxx * * %188h %:;   QXX^^ ,<&+ +rTc`||_|jj||jdxxdz cc<|j dd5|j j|ddd|jdxxdzcc<|j |jy#1swY}|j |j ||j|j|@|j|jyrV) r;rr#rr~rrrr|rr})rQrrs rR visit_if_stmtzSemanticAnalyzer.visit_if_stmt/ss*1dll;s166{# (A FF1I  T "   QVVAY ' ( q{{+rTc6||_|j||yrV)r;analyze_try_stmtrRs rRvisit_try_stmtzSemanticAnalyzer.visit_try_stmt7s a&rTc*|jj|t|j|j|j D]o\}}}|r|j||r|j ||j|jxs |j5|j|dddq|jr|jj||jr|jj|yy#1swYxYwrV) r|rr6rvarshandlersrQrkrLis_starr} finally_body)rQrrrXrhandlers rRrz!SemanticAnalyzer.analyze_try_stmt;s  g"%aggqvvqzz"B ( D#w G$##C(2243P3P3]TUT]T]^ (w' ( (  ( ;; KK  w ' >> NN ! !' *   ( (s D  D c||_g}|jrY|jr|jdjs0|j t j|tj|jrt|jtsJ|jDcgc]}|| }}t|dk(r|j d|nt|dk(r|jg}nt|jtrct|t|jj k(r%|jj j#}n%|j d|n|j d|g}t%|j&|jD]\}}|j)||s|j+||jdu|s<|j-d}|j/|r|j1|t|t2}|j5|| } | |j7| |j9|| ||_|j=|j>ycc}w) Nrrrz5Invalid type comment: "with" statement has no targetsrz/Incompatible number of types for "with" targetsz3Multiple types expected for multiple "with" targets)rr) r;rrr2r3rrASYNC_WITH_OUTSIDE_COROUTINEr%rVrRr{rrr~rrrzr6rrrQrrrrrrranalyzed_typesrr|) rQrrractual_targets new_typeserrr(s rRvisit_with_stmtz SemanticAnalyzer.visit_with_stmtIs ::%%'t/B/B2/F/S/S *GGQVQ]Q] ^  a//< <<)*CAQ]aCNC>"a' QSTU^$)**+A--y9~&#a.?.?.E.E*FF--3388:EIIOQRS OQRS " ) ?DAq HHTN##AQ5F5Fd5R#S ! A''*2215*4Q *B'#~~aEX~YH+!((211!X> ?"%  MDs &I?.I?c||_|jj||j|js|j d|yy)NzInvalid delete target)r;rris_valid_del_targetrrRs rRvisit_del_stmtzSemanticAnalyzer.visit_del_stmt{s?  d''/ II-q 10rTct|tttfryt|tt frt fd|jDSy)NTc3@K|]}j|ywrV)r)rr\rQs rRrz7SemanticAnalyzer.is_valid_del_target..sJ$t//5JsF)r{r[rerbrr_rrrRs` rRrz$SemanticAnalyzer.is_valid_del_targets> a)Xz: ; Ix0 1J!''JJ JrTc||_|jD]G}||jdvr|jd|d||jdj |Iy)NrName "" is nonlocal and global)r;rqr)rr(r)rQrrs rRvisit_global_declz"SemanticAnalyzer.visit_global_decls`GG ,Dt**2.. F4&(@A1E   b ! % %d + ,rTc ||_|jr|jd|y|jD]}t t |j ddt |jddD]-\}}| ||vs|tk(r|jd|d|n|jd|d||j d2||j dvr!|jdj||||jdvr|jd|d ||jdj| y) Nz0nonlocal declaration not allowed at module levelrz1nonlocal binding not allowed for type parameter "r=zNo binding for nonlocal "z" foundzGName "{}" is already defined in local scope before nonlocal declarationrr) r;rrrqr6rr*r,rrr(r)r)rQrrtablerWs rRvisit_nonlocal_declz$SemanticAnalyzer.visit_nonlocal_declsM    ! IIH! L 2),T[["-.9I9I#29N0O* L%E:(TU]%)99 II"STXSYYZ []^ LII 9$wGK;;r?.44;;r?3JII< s1::' *A JJqM  &HHQKE  T"   QXXa[ )  *rTc . |jry||_|j|j|}||j |y|jDcgc]}|j }} |j j|j j }|rt|jtst|jtr#|jj|jk(sE|j|j j ||d |j|jy|j}|j!|j j |j"j%d||d\}}} } } |st't(j*}|j-s#t|t.xrt|t0} n t3|} t5d|D} |j7|s| s| rO|j9|j j |j"d |j|jy|j;| |j;| t=||j>|j@|jB|tE|}|j>jFr3tI|r(|jBjKd||tM|}|j-}t|t.r>t|tNr.tQ||jR|jTd|j> t||jW|j j |j|jX|d|d }||_-|rt|jttfr|jj|jk(rd}t|jtrO|jj\|k7r?||j_.||j_/d}d|j_0n ||_ d}|r|jbrD|je|j j d | |j|jy|j |d n'|jg|j j |||r |jn|}t|tsJ|ji|||j"|j jk||j|jycc}w#|j|jwxYw) NNameT)rrrrZc32K|]}t|ywrVr0)rrs rRrz9SemanticAnalyzer.visit_type_alias_stmt..sJ 3Jr2r+r.rFrrrrp)6rr;rrrrrrr{rr rnralready_definedrrrrhrrrr?rrrrrrrr*rr#r^rArrrrrrrrrrrrrr`rrarrrr)rQrrrlrrrrr`rrrr incomplete_tvrrrrs rRvisit_type_alias_stmtz&SemanticAnalyzer.visit_type_alias_stmtsf $ $ ))!++q9   JJqM 12 =A = =h ,00266qvv{{CH8==)4x}}o>8==CUCUYZY_Y_C_$$QVV[[!XvFB   q{{ +,,.COSOaOa  "&#./D'+ PbP LCj/;Li223%%'%/sJ$?%JE!%4C$8!JkJJM((-1Bm$$QVV[[!''D$QH   q{{ +E  $ $Z 0  $ $_ 5 #T\\4#=#=txxQR  (,C||338TUX8Y445H#qQ-c2&&(E#z*z#x/HS$))TYYUTXT`T`a"##AFFKK0''+ J&ALx}} .JKMM&&!&&0hmmY7}}++s203 ,4? 1"&6: 3%/HM"G++00faH   q{{ + 1T : Z;,48==*LlI6 66  2 21lAGG L FFMM$    q{{ +U!>T   q{{ +s(U2)B4U7:D U7"IU7BU77Vcf|j|j|}|r|j||yyrV)rrr%)rQrrs rRvisit_name_exprz SemanticAnalyzer.visit_name_expr0s. KK 4 (   a ( rTct|jtrH|jj |r-|j s!|j d|jd|yt|jtr|j|jd|y|j|_ |j|_|jxsd|_ y)z,Bind name expression to a symbol table node.r=z3" is a type variable and only valid in type contextrr6N) r{rrr1 get_bindingrJrrrnrwr"rrrs rRr%zSemanticAnalyzer.bind_name_expr5s sxx -++C0,, II$))$WXZ^ _ / 2  $ $TYY =DIDILL.BDMrTc|js)|jjs|jd|y|j|_|jjD]}|j |y)Nz"super" used outside class)rXrr^rrr)rQrr s rRvisit_super_exprz!SemanticAnalyzer.visit_super_exprDsSyy II2D 9 II 99>> C JJt  rTcv|jD]*}t|trd|_|j |,yrcrr{rwrrrQrr\s rRvisit_tuple_exprz!SemanticAnalyzer.visit_tuple_exprL2JJ D$)! KK  rTcv|jD]*}t|trd|_|j |,yrcrrs rRvisit_list_exprz SemanticAnalyzer.visit_list_exprRrrTcv|jD]*}t|trd|_|j |,yrcrrs rRvisit_set_exprzSemanticAnalyzer.visit_set_exprXrrTct|jD])\}}||j||j|+yrV)rr)rQrrrhs rRvisit_dict_exprz SemanticAnalyzer.visit_dict_expr^s6** JC 4 LL  rTc||js|jd|dy|jj|y)Nz!can't use starred expression hereTr)rrrrrs rRvisit_star_exprz SemanticAnalyzer.visit_star_exprds.zz II94I N II  T "rTc~|js|jd|ddno|jdtk(r|jd|ddnC|jdj r|jd|ddnd|jd_|jr|jj|yy)Nz"yield from" outside functionTrrz9"yield from" inside comprehension or generator expressionz"yield from" in async function) rrr,rr2r3 is_generatorrrrQrs rRvisit_yield_from_exprz&SemanticAnalyzer.visit_yield_from_exprjs!!# II5q$PTI U   b !%8 8 IIK     $ 1 1 II64QUI V37D   # 0 66 FFMM$  rTc H|jj|t|jdr|j|ddsy |j |j d}t|j d||_ |j|j_ |j|j_ |jj|yt|jtr|j|ddsy |j |j d}t|j d||_ |j|j_ |j|j_ |jj|yt|jtr|j|dd syd }|jd |d }|r.t!|j"t$r|j&t(vrd }t+t,|j d||_ |j|j_ |j|j_ |jj|yt|jdrg}|j/rh|j0j3Dcgc]B\}}t5|j"dd r&t!|j"t6r |j"D}}}n|j9rc|j:|j:j<j?Dcgc])}t!|j"t6s|j"+}}no|jAr_|jBS|jBd} | B| j?Dcgc])}t!|j"t6s|j"+}}t+tD||_ |j|j_ |j|j_ |jj|yt|jdr|jd|yt|jdrz|j|ddsy |j |j d}tG||_ |j|j_ |jj|yt|jdr|jI||_ yt|jdrw|j|ddsytKd|j d|j d|_ |j|j_ |jj|yt|jdr=|jM5|j D]} | j| dddy|j D]} | j|t!|jtNrt!|jjPtRr|jjPjTdk(rz|jjPjVtXk(rQ|jjTdvr7|jjTdk(r+|j r|j[|j dy|jjTdk(rX|j rLt!|j dt\t^fr)|j[|j dj2y|jjTd k(rh|j r[t!|j dt`r=|jbDcgc]!}||j djdk7s |#c}|_1yyyyyyyyy#t $r|jd|YywxYw#t $r|jd |YywxYwcc}}wcc}wcc}w#t $r|jd|YywxYw#1swYyxYwcc}w)!zAnalyze a call expression. Some call expressions are recognized as special forms, including cast(...). z typing.castrr NrzCast target is not a typer assert_typez assert_type() type is not a typerFTrZ)r"r is_importedzbuiltins.reveal_localsr!r)r" local_nodesrz;Any(...) is no longer supported. Use cast(Any, ...) insteadztyping._promote_promotez$Argument 1 to _promote is not a typerzbuiltins.divmoddivmod)rrr)rrrrrr)3rrrcheck_fixed_argsrr^rrr>r(rrrr6rrr{rr0rrrrsr.rr'rgetattrrrrXrqrtrr*r-rotranslate_dict_callrirfrbrrerr"r%rr_rryrDrh) rQrrreveal_importedreveal_type_noderrrst symbol_tablerjs rRvisit_call_exprz SemanticAnalyzer.visit_call_expr{s 4 dkk= 9((q&9 55diilC %TYYq\6:DM!%DMM #';;DMM MM  &  -> ?((q-@ 55diilC+499Q<@DM!%DMM #';;DMM MM  &  -> ?((q-@#O#{{=$PT{U  /446KL$--1KK"&& tyy|DM"&DMM #';;DMM MM  &  -E F&(K##%$(<<#5#5#7aqvv}e<AFFTWAXFF  $$&99(*.))//*@*@*B#$&jQSQXQXZ]F^#K###%;;*#';;r?L#/.:.A.A.C'(*zRTRYRY[^G_BGG' ''M{SDM!%DMM #';;DMM MM  &  \ : IISUY Z  -> ?((q*= 55diilC(/DM!%DMM  MM  &  _ = 44T:DM  -> ?((q(;"8TYYq\499Q<HDM!%DMM  MM  &  KKT --/ ##AHHTN# # # YY  4;; 3t{{//:KK$$))Y6KK$$))T1KK$$(FF;;##x/DII$$TYYq\2KK$$0 "499Q<(I1FG$$TYYq\%7%78KK$$0 "499Q<9373C3C'_aqDIIVWLL^L^G^'_D$:"1G27;4Y(  5t< (  =`>aa2bbbc jtd|jDs#|jD]}|j|yt t |j |jDcgc]\}}| t|nd|fc}}}|j||j||Scc}}w)zTranslate 'dict(x=y, ...)' to {'x': y, ...} and 'dict()' to {}. For other variants of dict(...), return None. c38K|]}|ttfvywrV)r r"rs rRrz7SemanticAnalyzer.translate_dict_call..sMd4Iy11MriN) rr$r^rrHr6r@ryr)rQrrjrrhrs rRrz$SemanticAnalyzer.translate_dict_call s MdnnMMYY  #&dnndii"@ C"%dEB   d D  s(B/ cd}|dk(rd}t|j|k7r|jd|||fz|y|jtg|zk7r|jd|d|d||yy ) zsVerify that expr has specified number of positional args. Return True if the arguments are valid. rrr6z"%s" expects %d argument%sFr=z" must be called with z positional argumentT)r~r^rr$r!)rQrnumargsrrs rRrz!SemanticAnalyzer.check_fixed_argss  a<A tyy>W $ II2dGQ5GG N >>gY0 0 II$5gY>RSTRUVX\ ]rTc|j}|j|t|trt|jt r|j |j|j}|rpt|jtr|j|jd|y|j|_ |jxsd|_ |j|_yyt|trd}t|jtr|j}nOt|jtr|jr|jr|jd}|j st|jt"r|jj%|jj}|r|j&dk(r|j}nt|jt(r|jj*rjt|jj,t.sJt|jj,t0r |jj,j}|r|j2j5|j}|at|jt tt(fr;|sy|j|_ |jxsd|_ |j|_yyyyy)N attributer6rr)rrr{rqrrcget_module_symbolrrnrwr"rrrrrXr2r#rargument_by_nameposr rrrrrqr)rQrr4r_ type_infofunc_def formal_argrs rRvisit_member_exprz"SemanticAnalyzer.visit_member_expr.s yy D dG $DIIx)H((DII>Cchh8,,TYY TJHH # 2 HH g &I$))X. II DIIs+ d>Q>Q..r2))j .U!)!?!? !OJ!jnn&9$(II DIIy1dii6G6G!$))"2"2J???dii..9 $ 0 0 5 5IOO'' 2=Z8Y8W%X !DI$%JJ$4"DM !DI &Y=1'rTc|jj||jdvrt|j|j}|t t fvr|jdk(s|ttfvr|jdk(rd|_ y|ttfvr|jdk(s|t t fvr|jdk(rd|_ |jj|y)N)andr,r r,T) rrrrr#rrrrright_unreachable right_alwaysr)rQrr#s rR visit_op_exprzSemanticAnalyzer.visit_op_expr\s  77m #,TYY EH\:66477e;K[)44D)-&{I66477e;K\:66477d?$(! $rTcH|jD]}|j|yrV)operandsr)rQroperands rRvisit_comparison_exprz&SemanticAnalyzer.visit_comparison_exprms!}} !G NN4  !rTc:|jj|yrVrrrs rRvisit_unary_exprz!SemanticAnalyzer.visit_unary_exprqs rTc|j}|j|t|trPt|jt r6|jj s|jj|yt|trt|jts t|r|j|y|jj|yrV) r4rr{rqrr is_genericrr refers_to_class_or_functionanalyze_type_application)rQrr4s rRvisit_index_exprz!SemanticAnalyzer.visit_index_exprtsyy D tW %499h/II((* JJ  d # tW %*TYY *J ( .  ) )$ / JJ  d #rTc|j|}|y|j}t|||_|j|j_|j |j_y)zNAnalyze special form -- type application (either direct or via type aliasing).N)analyze_type_application_argsr4rr(rr)rQrrr4s rRrz)SemanticAnalyzer.analyze_type_applicationsQ2248 = yy'e4 !YY #{{ rTc|j}|j}|j||j|ry|jryg}t |t rj|j}t |jtxr|jjdk(}|r*t|dk(rt |dtr |dd}n|g}|j}t |trwt |jtr]|jjdu}|j} t!d| j"Drd} t| j"} nd} d} nt |trt |jt$rg|jj&xs|jjdk(}|jj(} t|jj*} nd}d} d} |D]K} |j-| d} |j3| |j4d| | }|y|j7|M|r*t9|}|j;j=|}| ru| d k(rp|rnt?|d }t|d k(xrt |t@}|s>t!d |Ds,tC|tDgt|zdgt|zg}|S#t.$r|j1d |YywxYw)zoAnalyze type arguments (index) in a type application. Return None if anything was incomplete. Nrrrc3<K|]}t|tywrV)r{rr1s rRrzASemanticAnalyzer.analyze_type_application_args..sKA:a/KrTFrzType expected within [...])rJrrrrrc3HK|]}t|ttfywrV)r{rrr1s rRrzASemanticAnalyzer.analyze_type_application_args..s%`UVjZ4O&P%` ")#rrrrrIr{rrr4rqrrr~rJrr rarr`rhas_type_var_tuple_typehas_param_spec_typerrrrrrJrrr!check_unpacks_in_listrrrr!)rQrrrrris_tupler4rrhas_param_specnum_argsr\typeargr(flattened_items first_arg single_anys rRrz.SemanticAnalyzer.analyze_type_application_argss  ((* u%  $ $S )  ' ' eY 'KKE!$))W5`$)):L:LP`:`HCJ!O 59l0Scr GEyy dG $DIIy)I9955TALIIEK9J9JKK!%u001!& g &:dii+J 11[TYY5G5GK[5[ "YY::N499../H L"NH #D 66t$6O~~%)$<$<"&*8)& H LL "% #( 3E:O&&(>>OE h!m'a1IUqKZ 7-KJ#%`Z_%`"`#EG9s5z+AD6CPUJCVWX 7(  6= s<K++L  L c|jr|jj||jr|jj||jr|jj|yyrV) begin_indexr end_indexstriders rRvisit_slice_exprz!SemanticAnalyzer.visit_slice_exprsV       # #D ) >> NN ! !$ ' ;; KK  t $ rTc|jj||j|j}|||_yyrVrrrrXrQrr(s rRvisit_cast_exprz SemanticAnalyzer.visit_cast_expr8 >>$)),   DI rTc|jj||j|j}|||_yyrVr4r5s rRvisit_assert_type_exprz'SemanticAnalyzer.visit_assert_type_exprr7rTc||jtk(r)|j|jj|yyyrV)r"r.rrrs rRvisit_reveal_exprz"SemanticAnalyzer.visit_reveal_exprs4 99 #yy$   &% rTc|jj|tt|jD]2}|j |j|}|$||j|<4yrV)rrrr~rr)rQrrr(s rRvisit_type_applicationz'SemanticAnalyzer.visit_type_applicationsY s4::' )A~~djjm4H# ( 1  )rTc*t|jjrY|jr|jdj s0|j tj|tj|jj|yNrr r generatorrrr2r3rrrr%rVrrs rRvisit_list_comprehensionz)SemanticAnalyzer.visit_list_comprehensione t~~&& '%%'t/B/B2/F/S/S *FFSXS_S_ ` d#rTc*t|jjrY|jr|jdj s0|j tj|tj|jj|yr?r@rs rRvisit_set_comprehensionz(SemanticAnalyzer.visit_set_comprehensionrCrTct|jrY|jr|jdjs0|j t j|tj|j|5|j||jj||jj|ddd|j|y#1swYxYwr?)rrrr2r3rrrr%rVranalyze_comp_forrrrhanalyze_comp_for_2rs rRvisit_dictionary_comprehensionz/SemanticAnalyzer.visit_dictionary_comprehensions t}} %%'t/B/B2/F/S/S *FFSXS_S_ ` ZZ  $  ! !$ ' HHOOD ! JJ  d # $ %  $ $s AC""C+c|j|5|j||jj|ddd|j |y#1swYxYwrV)rrG left_exprrrHrs rRvisit_generator_exprz%SemanticAnalyzer.visit_generator_exprsS ZZ  (  ! !$ ' NN ! !$ ' ( % ( (s -AA"ctt|j|j|jD]H\}\}}}|dkDr|j ||j ||D]}|j |Jy)zAnalyses the 'comp_for' part of comprehensions (part 1). That is the part after 'for' in (x for x in l if p). This analyzes variables and conditions which are analyzed in a local scope. rN)rr6indices sequences condlistsrrQ)rQrrrsequence conditionsconds rRrGz!SemanticAnalyzer.analyze_comp_for sz 1:  dnndnn =1  " ,A,x1u%    &" " D! " "rTc@|jdj|y)zAnalyses the 'comp_for' part of comprehensions (part 2). That is the part after 'for' in (x for x in l if p). This analyzes the 'l' part which is analyzed in the surrounding scope. rN)rOrrs rRrHz#SemanticAnalyzer.analyze_comp_for_20s q  &rTc|j||jdd5|j|dddy#1swYyxYw)NF)ri)r-rkr.rs rRvisit_lambda_exprz"SemanticAnalyzer.visit_lambda_expr8sF %%d+  . .uE . J -  & &t , - - -s AA c|jj||jj||jj|yrV)if_exprrrS else_exprrs rRvisit_conditional_exprz'SemanticAnalyzer.visit_conditional_expr=s8 D!  d#rTc||j|j}|t|tsJd||_yy)Nz&Cannot use type aliases for promotions)rrXr{rr5s rRvisit__promote_exprz$SemanticAnalyzer.visit__promote_exprBs<>>$)),  h 3 ]5] ]3 DI rTc|js|jd|ddn|jdtk(r|jd|ddnV|jdj r)d|jd_d|jd_nd|jd_|jr|jj|yy)Nz"yield" outside functionTrrz4"yield" inside comprehension or generator expression) rrr,rr2r3rr4rrrs rRvisit_yield_exprz!SemanticAnalyzer.visit_yield_exprHs!!# II0!T4I P   b !%8 8 IIF     $ 1 137D   # 09=D   # 637D   # 0 66 FFMM$  rTc2|jr |js$|jd|dtjn<|jdj s#|jd|dtj |jj|y)Nz"await" outside functionT)rUrrz'"await" outside coroutine ("async def")) rr2rr%TOP_LEVEL_AWAITr3AWAIT_NOT_ASYNCrrrs rRvisit_await_exprz!SemanticAnalyzer.visit_await_exprZs~!!#4+>+> II0$5K`K`I a$$R(55 II9**   rTc|j|jj||j|j|jyyrV)patternrrrQrQrls rRvisit_as_patternz!SemanticAnalyzer.visit_as_patternms? 99 II  T " 66     ' rTcH|jD]}|j|yrVrrrQrlrds rRvisit_or_patternz!SemanticAnalyzer.visit_or_patterns!zz !G NN4  !rTc:|jj|yrVrres rRvisit_value_patternz$SemanticAnalyzer.visit_value_patternws  drTcH|jD]}|j|yrVrhris rRvisit_sequence_patternz'SemanticAnalyzer.visit_sequence_patternzrkrTcT|j|j|jyyrV)capturerQres rRvisit_starred_patternz&SemanticAnalyzer.visit_starred_pattern~s# 99    * !rTc|jD]}|j||jD]}|j||j|j |jyyrV)r/rrtrestrQ)rQrlrrhs rRvisit_mapping_patternz&SemanticAnalyzer.visit_mapping_patternsa66 C JJt  XX E LL   66     ' rTc|jj||jD]}|j||jD]}|j|yrV) class_refr positionalskeyword_values)rQrlrrs rRvisit_class_patternz$SemanticAnalyzer.visit_class_patternsS 4 == C JJt  !! A HHTN rTcd}||jdvr2||jvr|j|S|s|j||y||jdvr@t |j ddD]}|||vs ||cS|s|j||y|j rn|js^||j jvrF|j j|}|js|j|jr|Sd}|}|j r<|js,|dvr(ttt||jSt |j D]}|||vs ||cS||jvr|j|S|jj!dd}|rpt#|jt$sJ|jj}||vr:t'|dkDr%|dd k(r|dd k7r|s|j||y||}|S|s|s|j||y|rSy) a_Look up an unqualified (no dots) name in all active namespaces. Note that the result may contain a PlaceholderNode. The caller may want to defer in that case. Generate an error if the name is not defined unless suppress_errors is true or the current namespace is incomplete. In the latter case defer. FrNT> __module__ __qualname__rnrrr5)r(r'r&r)rr*rXrrqr+is_active_symbol_in_class_bodyrr}r*rrrr{rcr~) rQrrr[ implicit_namerr implicit_noderhs rRrzSemanticAnalyzer.lookups5 4$$R( (t||#||D))"%%dC0 4&&r* *!$++cr"23 '$ ;& '#%%dC0 99T//1ddiioo6M99??4(D==66tyyAK!% $ 99T//1d>\6\"4T4==?)CD Ddkk* #E TU]T{" # 4<< <<% % LL  ^T 2 affh/ //FFLLEu}t9q=T!W^Q3*--dC8T{ _  ! !$ ,$$rTcr|jy|,|j|s|j|jsy|j |rj|j |j vry|j |j }|j|jsy|j |j Sy)a/Can a symbol defined in class body accessed at current statement? Only allow access to class attributes textually after the definition, so that it's possible to fall back to the outer scope. Example: class X: ... class C: X = X # Initializer refers to outer scope Nested classes are an exception, since we want to support arbitrary forward references in type annotations. Also, we allow forward references to type aliases to support recursive types. TF) r;is_textually_before_statementis_defined_in_current_modulerr is_type_likerr'is_textually_before_classr)rQr global_nodes rRr~z/SemanticAnalyzer.is_active_symbol_in_class_bodys& >> ! L11$744T]]C   T "yy ,,,tyy1K11+2B2BC(()9)9:: :rTcnt|ttfxst|txr |jSrV)r{rr rnr,rQrs rRrzSemanticAnalyzer.is_type_likes0$9 56 t_ - G$2G2G rTc|jsJ|jj|jz }|j||jryt|tr$|j s|t |jkDS|dkDS)zCheck if a node is defined textually before the current statement Note that decorated functions' line number are the same as the top decorator. Fr)r;ris_overloaded_itemr{rFrr~r)rQr line_diffs rRrz.SemanticAnalyzer.is_textually_before_statementss ~~~NN''$))3  " "4 8 i (1A1As4#;#;<< <q= rTc~|jJ|y|j|jjjkS)zFSimilar to above, but check if a node is defined before current class.F)rXrrrs rRrz*SemanticAnalyzer.is_textually_before_classs7yy$$$ <yy499>>....rTcrt|trt|tr||jDchc] }t|tr |j n|"c}v}|j duxrDt|j txr||j j uxs||j u}|xs|Sycc}w)z=Check whether the function belongs to the overloaded variantsNF)r{rjrRrrFrUr)rQrr;r\in_itemsin_impls rRrz#SemanticAnalyzer.is_overloaded_item s d- .:i3Q OSzz%GKZi8 dB%Hiit+DIIy1Qi499>>6Q* ) &w &%s%B4cN|syt|j||jk(Srw)rr&rrs rRrz-SemanticAnalyzer.is_defined_in_current_module-s"T\\84GGrTcd|vr|j|||S|jd}|j}|j|d||}|rtdt |D]}|j }||} t |tr|j| } n$t |tr|j|| } |j}nt |tr|cSt |trk|jr_t |jt sJt |jt"r&|jj$j| } nid} nft |t&r>t)|j$} t | t*r|j-||||d| cSt |t.r| dvryd} | r | j0r|s|j3|||y| }|S)aSLookup a qualified name in all activate namespaces. Note that the result may contain a PlaceholderNode. The caller may want to defer in that case. Generate an error if the name is not defined unless suppress_errors is true or the current namespace is incomplete. In the latter case defer. ryrZrrN)r^kwargs)r)rrrrr~rr{rrrcrrrrnr rrrrrXrrrimplicit_symbolrlrr&) rQrrr[partsrr_rrpartnextsymrs rRr]z!SemanticAnalyzer.lookup_qualified2s d?;;tS/;J J 3OO kk%(CkI 1c%j)! xxQxdH-"hhtnGh/"44T4@G $ Io6Ji0T\\%dkk:>>>!$++x8"&++"2"2"6"6t"<"&!$,-dii8%c73#'#7#7T59c#RR"$ 64CU;U#"G'"7"7*--dC9-MC! D rTc |j|}t|tr |j |j |d}|Sy#t$rYywxYwNTrZ)rrr{rr]r)rQrrrs rRrz!SemanticAnalyzer.lookup_type_nodeisZ ,,T2A a %%%affdD%IAH $  sA AAc$|j}|j}|j|}|s|dz|z}||jvrt t |j|}|S|j |r|j|Sd|vr*|j|d||}|r`t t |}|S|j|r=ttj}t||} || _t t | }|S|jrd}|S)zcLook up a symbol from a module. Return None if no matching symbol could be bound. ryrrXN)rrrqrr&r}r%r.rris_missing_modulerrfrom_unimported_typerrr) rQrrr$rqr_rrr'var_typers rRrz"SemanticAnalyzer.get_module_symbolss  iio|d*H4<<'%dDLL,BC  --f5**, %'..u]/CT8T)$5C ''1#9#A#AB8,& %dA.   C rTc||jvSrV)rB)rQr$s rRrz"SemanticAnalyzer.is_missing_modules----rTc|jd}n|jj}||}n|dzdj|z}ttj |}t |d|}||_tt|S)z>Create symbol for a qualified name reference through Any type.Nryr) rrrrBrrfrom_another_anyrrr}r%) rQr_rr source_typebasenamerrrrs rRrz SemanticAnalyzer.implicit_symbolsy 88 Hxx((H  H#~7H955{C%)X&  tS))rTc(t|jttfrrt |jj }t|t r |j}nttj}t||}||_ d|_ |Sy)aCreate a dummy variable using module-level __getattr__ return type. If not possible, return None. Note that multiple Var nodes can be created for a single name. We can use the from_module_getattr and the fullname attributes to check if two dummy Var nodes refer to the same thing. Reusing Var nodes would require non-local mutable state, which we prefer to avoid. rTN) r{rrRrrrXrrrrr?rfrom_module_getattr)rQ getattr_defnrrr node_typerrs rRrz#SemanticAnalyzer.create_getattr_varsv l'''3 8' (9(9(>(>?I)\2((i223Ds#A"AK$(A !HrTc:|j|}|J||SrV)r)rQrrrets rRlookup_fully_qualifiedz'SemanticAnalyzer.lookup_fully_qualifieds&11(;(( rTcT|jdd\}}||jvrO|j|}|jj|}|!|j |r|j |S|j d}g}|r\dj||jvr?|j|j|rdj||jvr?|r|sy|jdj|}|j|}|jj|d}|!|j |r|j |ddD]E}|@t|jtr&|jjj|}Ey|S)aTLookup a fully qualified name that refers to a module-level definition. Don't assume that the name is defined. This happens in the global namespace -- the local module namespace is ignored. This does not dereference indirect refs. Note that this can't be used for names nested in class namespaces. ryr)maxsplitNr)rr&rqrr.rrrBrrreverser{rr) rQrrr$rfilenoder7splitted_modulesrqrs rRrz/SemanticAnalyzer.lookup_fully_qualified_or_nones sQ7  T\\ !||F+H^^''-F~$">">v"F**,M (~~c2 E"sxx0@'A'U -1134#sxx0@'A'U$5 MMOXX./F||F+H^^''a1F~$">">v"F**,ab  %*V[[(*K#[[..2248F  MrTc^|j|jd|_|jS)Nr)rPrrWs rRr#zSemanticAnalyzer.object_types,    $ $0A BD    rTc^|j|jd|_|jS)Nr)rNrrWs rRrzSemanticAnalyzer.str_types& >> !!__^TYYEXEXAYYZZrTc$|j|S)z,Legacy function -- use named_type() instead.)r)rQfully_qualified_names rR builtin_typezSemanticAnalyzer.builtin_types344rTc|jd|jdj|S|j%|jjj|S|jj|SNr)r*rrXrqr'rQrs rRlookup_current_scopez%SemanticAnalyzer.lookup_current_scope sa ;;r? &;;r?&&t, , YY "99??&&t, ,<<##D) )rTc |jrt} n|jt} nt} t | |||} |j || ||||| S)aAdd symbol to the currently active symbol table. Generally additions to symbol table should go through this method or one of the methods below so that kinds, redefinitions, conditional definitions, and skipped names are handled consistently. Return True if we actually added the symbol, or False if we refused to do so (because something is not ready). If can_defer is True, defer current target if adding a placeholder. r )rr)rXr*r%r}add_symbol_table_node) rQrrr rrr-rNrrr"rs rRrzSemanticAnalyzer.add_symbol,sb.    D YY "DD $m= )) &'9.C[R\  rTc|j|jj}t}n|j}t}t ||}|||<y)aSame as above, but skipping the local namespace. This doesn't check for previous definition and is only used for serialization of method-level classes. Classes defined within methods can be exposed through an attribute type, but method-level symbol tables aren't serialized. This method can be used to add such classes to an enclosing, serialized symbol table. N)rXrqr*r'r%r})rQrrrqr"rs rRrz&SemanticAnalyzer.add_symbol_skip_localPsC 99 IIOOEDLLED t,d rTc|j||}|j|} t|jtr(|r&||j |d|n|j | |t| |s| j} |j} t| tryt| | snt| ttttfr|j|||t| ttfr|j| | s|j||| y||j dvr d|j dvr|||<|sd|_yy)aAdd symbol table node to the currently active symbol table. Return True if we actually added the symbol, or False if we refused to do so (because something is not ready or it was a no-op). Generate an error if there is an invalid redefinition. If context is None, unconditionally add node, since we can't report an error. Note that this is used by plugins to forcibly replace nodes! TODO: Prevent plugins from replacing nodes, as it could cause problems? Args: name: short name of symbol symbol: Node to add can_defer: if True, defer current target if adding a placeholder context: error context (see above about None value) )rNrrFrrIT)rrr{rrnrwris_valid_replacementis_same_symbolrRrFrjradd_redefinitionrdrr3progress) rQrrr r-rNrrrqrrercs rRrz&SemanticAnalyzer.add_symbol_table_nodefs?8))"7J* 99T? fkk? 3 "((vw?  #(6: --C++C#/!#s+cGY8I8#TU))%v>"3)(<=$BWBWX[]`Ba--dGXF  ++B/ /Ct?Q?QRT?U4U E$K $ rTcd}d|_ |dk(r|d}n|d|}|j|}||||<y|j|jury|dz }J)aOAdd a symbol table node that reflects a redefinition as a function or a class. Redefinitions need to be added to the symbol table so that they can be found through AST traversal, but they have dummy names of form 'name-redefinition[N]', where N ranges over 2, 3, ... (omitted for the first redefinition). Note: we always store redefinitions independently of whether they are valid or not (so they will be semantically analyzed), the caller should give an error for invalid redefinitions (such as e.g. variable redefined as a class). rTz -redefinitionN) no_serializerr)rQrqrrrnew_namers rRrz!SemanticAnalyzer.add_redefinitionsz  #Av"V=1"V=4yy*H"(h&++- FArTct|jsJ|j}||_|j|||y)zAdd local variable or function.N)rrrr)rQrr rs rRrzSemanticAnalyzer.add_locals4!!###yy dG,rTc|yd}t||tttfr`|j j |}|t||j tttfrWt||j|ts%||j||jk(r |j St||ttfr,ttj}|jd|n||j}t||}|j||_ |jJ|j|_|j|_|j |_|S)Nc|SrVxs rRrzDSemanticAnalyzer._get_node_for_class_scoped_import..sqrTzUnsupported class scoped import)r{rFrQrrrrrXrrr?rrrrrr)rQr symbol_noder frrs rR!_get_node_for_class_scoped_importz2SemanticAnalyzer._get_node_for_class_scoped_importsA   &1 a ny(C&@ A00266t+>+>> }}$!K.8Y*?@$+9+?+?#@ ;WE n))dC.K$($7$7$=K !99( ((#yyK &||K !(K rTc~|r|rJ|j|}|rIt|jts/t|jts|j ||||ry|j}|j r|j |||}t|j|||}|j|||y)z2Add an alias to an existing symbol through import.Nr ) rr{rrnrDrrr}r"r) rQrrr rrr>rrs rRrz$SemanticAnalyzer.add_imported_symbols! 5533D9 33_Etyy/:55dOTSZ[)-    @@{T[\K II{-}  ""49rTcH|jj|}|r1t|jtr|jj ryt |}|j jr |||_nU|jr3|jjdz|z|_|j|_ n|j||_d|_ ttj |j}||_ d|_|j#|||||y)aAdd symbol that we don't know what it points to because resolving an import failed. This can happen if a module is missing, or it is present, but doesn't have the imported attribute. The `target_name` is the name of symbol in the namespace it is imported from. For example, for 'from mod import x as y' the target_name is 'mod.x'. This is currently used only to track logical dependencies. NryTmissing_import_namer )rrr{rris_suppressed_importr# logical_depsrrXrrrrrrrrr) rQrr rrrrrr9s rRrz,SemanticAnalyzer.add_unknown_imported_symbols,,.2248  8==#68==;];] $i << $ $)@ (CM YY II..4t;CMyyCH //5CM 999s}}]#'   #wm=  rTc#HK|j}||_d||_ywrV)r1)rQframe old_scopes rRrz!SemanticAnalyzer.tvar_scope_frame@s OO  #r#c|jrJd|rd|_d|_|r |jn#|jr|jjnd}|j j |j|fy)a]Defer current analysis target to be analyzed again. This must be called if something in the current target is incomplete or has a placeholder node. However, this must *not* be called during the final analysis iteration! Instead, an error should be generated. Often 'process_placeholder' is a good way to either defer or generate an error. NOTE: Some methods, such as 'anal_type', 'mark_incomplete' and 'record_incomplete_ref', call this implicitly, or when needed. They are usually preferable to a direct defer() call. z%Must not defer during final iterationTrN)rarrrr;rHrr)rQ debug_contextrqrs rRrzSemanticAnalyzer.deferGsr''P)PP'  !DM #0M  DNNT^^5H5H`b  ##**DOOT+BCrTc|jS)zHReturn tag that can be used for tracking references to incomplete names.rrWs rRrz&SemanticAnalyzer.track_incomplete_refscs'''rTc |j|k7S)zDHave we encountered an incomplete reference since starting tracking?r)rQrs rRrz%SemanticAnalyzer.found_incomplete_refgs''3..rTcN|j|xjdz c_y)zRRecord the encounter of an incomplete reference and defer current analysis target.rN)rrrWs rRrz&SemanticAnalyzer.record_incomplete_refks    A% rTc^|j||dk(rd|_nq|j|s`|j|}|jsJt |||jj |}|j||||t|jdj|y)aMark a definition as incomplete (and defer current analysis target). Also potentially mark the current namespace as incomplete. Args: name: The name that we weren't able to define (or '*' if the name is unknown) node: The node that refers to the name (definition or lvalue) becomes_typeinfo: Pass this to PlaceholderNode (used by special forms like named tuples that will create TypeInfos). rITr+rrN) rrrrr;rnrrrr3r)rQrrr,rrrrrNs rRrz SemanticAnalyzer.mark_incompleteps$ 4 3;"DO++D1**40H>> !>)$ 3 3FVK OO++%   2""4(rTc||jvS)zIs a module or class namespace potentially missing some definitions? If a name is missing from an incomplete namespace, we'll need to defer the current analysis target. )rCrs rRr.z(SemanticAnalyzer.is_incomplete_namespaces 45555rTcj|jr|j|||y|j||y)aProcess a reference targeting placeholder node. If this is not a final iteration, defer current node, otherwise report an error. The 'kind' argument indicates if this a name or attribute expression (used for better error message). rpN)rarr)rQrr"rrqs rRrwz$SemanticAnalyzer.process_placeholders/     $ $T4 5 JJs>J :rTc|rd|dnd}|jd||d||jr|jd|yy)Nrr=r6zCannot resolve z (possible cyclic definition)z1Recursive types are not allowed at function scope)rrr)rQrr"r name_formats rRrz$SemanticAnalyzer.cannot_resolve_namesP&*4&l  OD6+6STVYZ     III3 O rTc|j|jjdz|zS|jr|S|jdz|zS)Nry)rXrrrrs rRrzSemanticAnalyzer.qualified_namesK 99 99&&,t3 3    !K??S(4/ /rTc#.K|jj|t}|jj |t |t tf}|jj |stnt|jj t|jj t|jj d|jj d|j j t d|jj#|jj#|jj#|jj#|jj#|jj#|j j#y#|jj#|jj#|jj#|jj#|jj#|jj#|j j#wxYww)z3Enter a function, generator or comprehension scope.rrN)r> setdefaultr|r*rr{rTrIr,rrr(r?r)r-r5r3r)rQrrqis_comprehensions rRrzSemanticAnalyzer.enters !!,,X{}E 5!%h@W0XY 2B H[\   ' ""35) # q! !!#%( %  KKOO     "    ! ! #    # # %    " OO   !    " " $ KKOO     "    ! ! #    # # %    " OO   !    " " $s DJG#B7JB8JJcl|jd}|tk(r|jd}|ttfvS)Nr)r,rrr)rQrWs rRrzSemanticAnalyzer.is_func_scopes<%%b) ) )))"-Jj*=>>>rTc:td|jDS)zJAre we underneath a function scope, even if we are in a nested class also?c38K|]}|ttfvywrV)rr)rrs rRrz?SemanticAnalyzer.is_nested_within_func_scope..sTa1%899Tri)rr,rWs rRrz,SemanticAnalyzer.is_nested_within_func_scopesT4CSCSTTTrTcD|jduxr|j SrV)rXrrWs rRrzSemanticAnalyzer.is_class_scopes"yy$AT-?-?-A)AArTcH|jxs|j SrV)rrrWs rRrz SemanticAnalyzer.is_module_scopes"'')AT-?-?-ABBrTcr|jrt}|S|jrt}|St}|SrV)rr*rr)r%)rQr"s rRrz$SemanticAnalyzer.current_symbol_kinds@    D     !D D rTc|r+|jdtk(r|jd}|J|S|jr|jdtk(r|jd}n|jd}|J|rt |jt |jk(sJt t |jD]U\}}|tk7s|t |jdz k(r |j}n|jd|z }|Jd|}n Jd|}|J|S|j|jj}|S|j}|S)Nrrrz)Escaping comprehension from invalid scopez0Should have at least one non-comprehension scope) r,rr*rr~rrrr'rXrq)rQrNrrrrWrqnames_candidates rRrz%SemanticAnalyzer.current_symbol_tablest $**2.2BB BA= =H    !#'77KKOKKO= =$4;;'3t/?/?+@@@@%.x8H8H/I%J UMAz!%88DKK 01 44$(LLE.2kk"q&.AO / ;KJK ;$3E UU"TT5$ $$  YY "IIOOE LLE rTcn|jxr$||jdvxs||jdvSr)rr(r)rs rRrz&SemanticAnalyzer.is_global_or_nonlocals@!!# D%%b) ) LTT5H5H5L-L rTct|tr|gn|}|D]8}t|ts|jj |j :yrV)r{rLryrDrrh)rQ exp_or_expsexpsexps rRrzSemanticAnalyzer.add_exportssE *; C } 3C#w'  '' 2 3rTc<|j|xs |j}|E|jr9|js)|jr|jdr|j sd}|r|j yd|d}|j||tjd|tvr2d|}|j||jj||tDchc]}|jddd }}tDcic]}|j!|}}|D]g} | dj!}||vrd j#| ||j%ddd } |j'| |tjiycc}wcc}w) NrTrz" is not definedrrryrrzXDid you forget to import it from "{module}"? (Suggestion: "from {module} import {name}"))r$r)r.rrXrr@rarrr% NAME_DEFINEDrrrAr4rrrrrr) rQrrrrr7rrmodules_with_unimported_hints lowercasedr$hints rRr&z!SemanticAnalyzer.name_not_defineds11)2NtO   &&(****2.((J   & & ( 4& 01 '3U%7%7 8 tf !8 8"4&)H228<D))(C8/I) &*DJJsA q !) %) 6PPTdjjlD(P P3 :F 4&)//1Hz)?fFH)=)D)DS!)LR)PfQ  IIdCe&8&8I 9 : ) Qs 'F Fct|tr |j}nt|tr|}nd}t|trt|jtrd}n>|r:|j dk7r+|j |jrd|j }nd}|j|dt|d||tjy)Nz (by an import)rz on line z (possibly by an import)rz" already definedr) r{r}rr{rcr is_local_namerrrrr%NO_REDEF)rQrr original_ctxnounr extra_msgs rRrz SemanticAnalyzer.already_definedIs lO 4&2&7&7D  j 1DD lO 4LDUDUW_9`*I dii2o$*<*Generic named tuples are not supported for legacy class syntaxz:Use either Python 3 class syntax, or the assignment syntaxzNamedTuple without tuple type)rb)rrrrJrr)r{r=rrrrrrrrrtrrrrr) rQrrrrrJrrrrrPrbrs rRrz&SemanticAnalyzer.expr_to_analyzed_types dH % KK -1-F-F-W-WdD..0. *M4 Z\`a VX\]$+,, 4 ?? C$C C?b)HT__22XF F**40~~ !5/) 3&?%  rTc|jt5|j5|j|ddddddy#1swYxYw#1swYyxYwrV)rrrfrrs rRrz"SemanticAnalyzer.analyze_type_exprsW " "#3#5 6 8T8T8V  KK       s!AAAA AA#) r1rrJrallow_typed_dict_special_forms allow_finalrrrprohibit_self_type"prohibit_special_class_field_typesrc ^| |j}t|||j|j|j|j ||| |||||| | | } t |jxr|jdj| _ |j xr |j | _ | S)N) rJrrrrrrrrrrr) r1rr:r#r$r^rr2rrrXr)rQr1rrJrrrrrrrrrtpans rRr!zSemanticAnalyzer.type_analyzers  J   KK LL     & & 3 3!5/+I#&?%1/Q)# & $D$7$7$`D.@sd33D#t3TrTN) r1rJrrrrrrrrrr) rrXrgr!rrrr*r+)rQrr1rrJrrrrrrrrrr5rjrs`` rRrzSemanticAnalyzer.anal_typesF' T  TYY+=+E  "   ! 3 3/+I#&?%!51/Q)  ((*jjm  $ $S )   0 rTc,tj|SrV)rmake_normalized)rQr(s rRrPzSemanticAnalyzer.class_typeZs'' 22rTc>|jj||fyrV)r"r)rQprioritypatchs rRrzSemanticAnalyzer.schedule_patch]s Xu-.rTctd|jD]\}}td|d||jjddddy)NzDeferral trace:z :rzAINTERNAL ERROR: maximum semantic analysis iteration count reachedTr)printrHr9r)rQr&rs rR report_hangzSemanticAnalyzer.report_hang`s\  44 'IC DQtf% & '    O  rTc||jj}|jjj |t j |y)zyAdd dependency from trigger to a target. If the target is not given explicitly, use the current target. N)rGcurrent_targetr$ plugin_depsrr?r)rQtriggerrs rRadd_plugin_dependencyz&SemanticAnalyzer.add_plugin_dependencyksD >ZZ..0F %%00#%@DDVLrTc|sy||jj}|jj|j |y)zAdd full names of type aliases on which the current node depends. This is used by fine-grained incremental mode to re-check the corresponding nodes. If `target` is None, then the target node used will be the current scope. N)rGr/r$ alias_depsupdate)rQr+rs rRr*z$SemanticAnalyzer.add_type_alias_depstsB  >ZZ..0F $$V,33LArTc6t|dz|jvSNr)rr'rs rRrz"SemanticAnalyzer.is_mangled_globals~#t||33rTc$|t|dzk(Sr7)rrs rRrz*SemanticAnalyzer.is_initial_mangled_globalsx~+++rTct|SrV)rrs rRrzSemanticAnalyzer.parse_bools $rTc$t|tr |jSt|trdt|jt rJ|jj 4t|jj }|t|dk(r|dSy)zzAttempt to find the string literal value of the given expression. Returns `None` if no literal value can be found.Nrr) r{ryrhrqrrrXrr~)rQrrts rRparse_str_literalz"SemanticAnalyzer.parse_str_literalsl dG $::  dG $DIIs)C Hb7 GF!c&kQ&6ay rTc|tvr:|j|jjj t|yyrV)rr&rfuture_import_flagsr)rQ module_names rRrz(SemanticAnalyzer.set_future_import_flagss6 . ( LL ) = = A A.Q\B] ^ )rTcR|j|jj|SrV)r&ris_future_flag_set)rQflags rRr@z#SemanticAnalyzer.is_future_flag_sets ||DOO,??EErTc\t}t|j|jD]~\}}| |dk(r|j ||_%t |||}|5|dk(r||_B|dk(r||_O|dk(r||_ \|dk(r||_ i|jd|d||S)zqBuild a DataclassTransformSpec from the arguments passed to the given call to typing.dataclass_transform.field_specifiers eq_default order_defaultkw_only_defaultfrozen_defaultz,Unrecognized dataclass_transform parameter "r=) rEr6r@r^*parse_dataclass_transform_field_specifiersrCrrDrErFrGr)rQr parametersrrhbooleans rRrz/SemanticAnalyzer.parse_dataclass_transform_specs,- t~~tyy9 XKD%|)).2.].]/ +3D%FG|#(/ %(+2 (**-4 *)),3 ) HaPRVW7 X:rTct|ts|jd|yg}|jD]A}t|ts|jd|y|j |j Ct|S)Nz3"field_specifiers" argument must be a tuple literalrz0"field_specifiers" must only contain identifiers)r{rrrrqrrrr)rQr rq specifiers rRrHz;SemanticAnalyzer.parse_dataclass_transform_field_specifierssp#y) IIKS Q -Ii1 LiX LL++ ,  - U|rTcyrVrrQos rRvisit_int_exprzSemanticAnalyzer.visit_int_exprrTcyrVrrNs rRvisit_str_exprzSemanticAnalyzer.visit_str_exprrQrTcyrVrrNs rRvisit_bytes_exprz!SemanticAnalyzer.visit_bytes_exprrQrTcyrVrrNs rRvisit_float_exprz!SemanticAnalyzer.visit_float_exprrQrTcyrVrrNs rRvisit_complex_exprz#SemanticAnalyzer.visit_complex_exprrQrTcyrVrrNs rRvisit_ellipsiszSemanticAnalyzer.visit_ellipsisrQrTcyrVrrNs rRvisit_temp_nodez SemanticAnalyzer.visit_temp_noderQrTcyrVrrNs rRvisit_pass_stmtz SemanticAnalyzer.visit_pass_stmtrQrTcyrVrrNs rRvisit_singleton_patternz(SemanticAnalyzer.visit_singleton_patternrQrT) r&r%rBr7rCr7r9rr:rrr)rr.)rr)rIterator[None])F)rhrrirrrb)rurcrr)rurcrzdict[str, str]rrrV)rz&MypyFile | FuncDef | OverloadedFuncDefr"r4rarrurcr#rrr.rr)rrcrr) rrcrrrrrrrr)rr)rurcr#rrr.rrb)rrRrr)rrrrr)rrRrrrr)rUrRrrr5rrr)rrrYrrr)rbz Node | NonerczFuncDef | Decoratorrr)rirrrSrr)rrjrr)r\z int | Nonerrb)rrLr str | None)rrjrz9tuple[list[CallableType], OverloadPart | None, list[int]])rrjrr+rrrr)rrjrzCallableType | None)rrLrrrzTypeGuard[MemberExpr])rUzFuncDef | OverloadedFuncDefrr)rrSrr)rrrr)rrSrr)rrFrr)rrr rCrr)rr?rr)rlist[TypeParam] | Noner rCrz(list[tuple[str, TypeVarLikeExpr]] | None)rrrr)rrr rCrzTypeVarLikeExpr | None)rrdrr)rOlist[Expression]rr)rr?rPlist[TypeVarLikeType]rr)rr?rr)rr?rPrfrr)rrLrrc)rrrr)rr?rrLrr)rr?rrrrLrr)rr?r7rer rCrz4tuple[list[Expression], list[TypeVarLikeType], bool])r4rrz#tuple[TypeVarLikeList, bool] | None)rrr"tuple[str, TypeVarLikeExpr] | None)FF)rrrrrrrrg)rrrr)r7rerr+rr)rrr rCrrf)rrerrfrw)rr?rr.rnrrr)rr?rr)r7rerz7tuple[list[tuple[ProperType, Expression]], bool] | None)rr?rOz#list[tuple[ProperType, Expression]]rr)rr?r4rrr)rr?rzCallable[[], Instance] | Nonerr)rrrrrr)rrrzExpression | Nonerz"tuple[Instance | None, bool, bool])rr?rUInstance | Nonerr)rrWrr)r"rZrr)rr}r#rrsrrrrrrrrr rYrr)T)r5rr6rrrrrrrr rfrrrr) rrr>r}r?r}r@rYrr)rzImportFrom | ImportAllrr)rrXrr)rr7rr)rr7rr)rr8rr)rr8rr)rxrLrr)rxrLr~rrr)rxrLr{rrrrrLrr)rrerre)rBrLrrr Type | None)FNNF)rrrBrLrrrzTypeVarLikeList | Nonerzlist[str] | NonerZrrzDtuple[Type | None, list[TypeVarLikeType], set[str], list[str], bool])rBrLrrrzTypeGuard[CallExpr])rBr=rz!tuple[TypeVarLikeList, list[str]])rzAssignmentStmt | TypeAliasStmtrr rrCrr)FFFFFF)rr`rrrrrrrNrrOrr rrr)rArerrrrrNrrOrr rrr)r"rrrrr) rArer"rr#rrOrr rrr)rrerrrrrr)rrrrrr) rrbrrrrrOrrr)r2rbrr)rzExpression | SymbolNode | NonerrCrr)rAr`rrrr)rvrr rCrr)rr=rrr rCrr)rr8rPtuple[str, ...]rzCallExpr | None) r^rerqzlist[str | None]rZz list[ArgKind]r[rr rCrztuple[int, Type, Type] | None)rcrr^rr]rLr rCrJrrrrrrarrzProperType | None)rr8rr=rrc)rrrlrrrrr)rrerz list[Type])rrrr)rrjrr)r rCrr)r|z list[Lvalue]r}rLrr8rr)rhr:rr)rhz Block | Nonerr)rrMrr)rrrrr)rrprr)rr5rr)rrhrr)rrrr)rrPrr)rr;rr)rrDrr)rrVrr)rrrr)rrrzNodeVisitor[None]rr)rrrr)rrGrr)rrLrr)rrUrr)rrgrr)rrarr)rrrr)rrerr)rrer_r}rr)rrzrr)rrrr)rr_rr)rrurr)rrHrr)rrwrr)rrrr)rr=rr)rr=rzDictExpr | None)rr=rrrrrr)rrbrr)rrirr)rr@rr)rrrr)rr[rr)rr[rlist[Type] | None)rrvrr)rr>rr)rr6rr)rrsrr)rrrr)rr^rr)rrtrr)rrIrr)rrTrr)rz'GeneratorExpr | DictionaryComprehensionrr)rr]rr)rrBrr)rrorr)rrrr)rr9rr)rlrrr)rlrrr)rlrrr)rlrrr)rlrrr)rlrrr)rlrrr)rrrrCr[rrSymbolTableNode | None)rSymbolNode | Nonerr)rr{rr)rr{r;rxrr)rrrcrr)rrLrrm)rrcrrrrm)r$rrr) r_r}rrrz list[str]rrrr})rr}rrrrrrz Var | None)rrrrr})rrrrrm)rr)rrrr^rlrr)rrrr^rlrrh)rrrr)rrrrm)TFTFFF)rrrr{r rCrrrrr-rrNrrrrrrr)rrrr{rr)NTFFF)rrrr}r Context | Noner-rrNrrrrrrr)rqr|rrrr}rr)rz!Var | FuncDef | OverloadedFuncDefr rCrr)rrrrnr rCrrn) rrrr}r rYrrrrrr) rrr rCrrcrrrrrr)rrrrb)rrorqrrr)rr)rrrr)FTF) rrrrfr,rrrrrrr)rrrrr) rrcr"rrrCrqrrr)rrcr"rrrCrr)rrrr)rz2FuncItem | GeneratorExpr | DictionaryComprehensionrrb)rr)rNrrrrr|)rz!Iterable[Expression] | Expressionrr)rrrrCrrcrr) rrrrCr#SymbolTableNode | SymbolNode | Nonerrrr)rrrrCrrprr) rAzstr | ErrorMessagerrCrUrrErrorCode | Nonerrrr)rArrrCrrqrr)rrrrCrr)rrfrr)TFFFFF)rrLrrrrrrrJrrrrrrrj)rrLrr)r1TypeVarLikeScope | NonerrrJrrrrrrrrrrrrrrrcrrcrrrr)rrLrrrr)rrr1rrrrrJrrrrrrrrrrrrrrrcrrcrrrrj)r(rrr)r(rr)zCallable[[], None]rr)r1rrrcrr)r+zCollection[str]rrcrr)rrLrz bool | None)r>rrr)rArrr)rr=rrE)r rLrrk)rOr\rr)rOryrr)rOr<rr)rOrOrr)rOrArr)rOrJrr)rOr~rr)rOrmrr)rOrrr(G__name__r|r}rrrr/rrrr`rrZr]r;r<rSrrXr[r^rarrfrkrvrtrsrrrrrrrrr rr r'rrSrdrrgr}rr{rrrrrrrrrrrrr-r.r r,rrr rrrrr r<rBrCr6rMrArDrkrwr=rrrLrpr;rrrrrrrrErrr>rIrrrrr:rrrr?rJrr(r r!rDrrLrSrPrurYr\rrZr[rrrgrfrcrdrrjrorhrkrlrrnrrrrr^rrrrQr rrrrrr rr'rr`r$r%r&rr<r?rXr=rarbrnr>rmrrrrprqrrrsrrrrrrrrrrrrrrrrrrrrrrr%rrrrrrrrrrr rrrrrrr2r6r9r;r=rBrErIrLrGrHrVrZr\r^rbrfrjrmrorrrurzrr~rrrrrr]rrrrrrrr#rrrrrrrrrrrrrrrrrrrrr.rwrrrrrrrrrrrr&rrr,rr rrrrrrr!rrrPrr-r2r*rrrr;rr@rrHrPrSrUrWrYr[r]r_rarrTrRr!r!Ys ;M!   "" $$!E?!%%  #" HHJ"! 11JM"  N N"&I& 6827S2$S2"S2 ( S2  S2  S2 S2n""++%%++16QQ*.Q QQ, P>$=b(,46     % 0*CJ>*>(%B ,TX3!3,33BQ3 33r,:: r+hN.&CP&.!. : 3..M)^:, ,1%,1 B,1\  ( #'    B4!&.>3 %3 3 j/2 "/1&:  SbRHH )/:A 1,N#N.5N N` ^1@ " K"S*  )>   D!65HF4!F4)3F4:HF4 F4P -3.9)~"  % -,,2OR,' +0!d2 ,2: *r,p) /    #  "M`^( ,'\ "!$$+KZ%! ! )$$ && " '- $ !  $ &( !!+(@ECC%C8<C CJ%N !&/ H @E55%58<5 5n:.*"**-*6?*NU* *"+36BE 2 1f!  # \\ [ [5*"##&+! " " "  "  "  " "  $" " "  " H4#'&+! >> > >  > $ >>> >@>-((&7(BI( (T::: :  :  : :>% % %  %  %  %  % V$$ DD8(/&"'"# ")")") ")  ")  ") ")H6QV;;&);07;IM; ; P 0%J% %%2? UBCGL%%)%?C% %N 3 (:(:T  % 5X `c  4\`CC%C5XC C \`HH%H5XH H J<  "&          6RR _&*"'$$)*/"( ( #(  (  ( " ( $(( (  ( T/3$)$)"'/4!*/"%))-9=$','" ' " '  ')-''$(''#'''-7'' 'R  /3$)$)"'/4!*/"%))-9=$< <, < " < " < <)-<<$(<<#<'<-7<< !<|3/  MMCGB+B5?B B 4,  _F!F rTr!Nc @t|tr=t|jdk(r|S|j |g|jddzSt|t r;t |j Dcgc]}ttt||c}SJcc}w)Nrrr;) r{rr~r<rrrr rQ)rrcrs rRrQrQs#|$ s}}  "J  C53==3D+D EE C $NQii XT, ;As C D X   u Ys1!Bc t|ts|f}t|tsy|j|vryt|jt r6|jj s t|jj|Sy)z=Is node a name or member expression with the given full name?FT) r{rrqrrrr rZrr)r fullnamess rRrrsc i 'L dG $ }} !$))Y' 0P0P !1!19== rTcpt|txr%t|jttt fS)z1Does semantically analyzed node refer to a class?)r{rqrrrRrj)rs rRrr s. dG $  Hg'89*rTcZtdt|D]}|||d|vs||cSy)z[If the list has duplicates, return one of the duplicates. Otherwise, return None. rN)rr~)r_rs rRrrs> 1c$i  7d2Ah 7N rTcg}|jD]S\}}|j|jj}|d|jd}||k7sC|j |U|D]}||=y)zrrTrcBt|d}|D] \}}|y)zeCall patch callbacks in the right order. This should happen after semantic analyzer pass 3. c |dS)Nrrrs rRrz1apply_semantic_analyzer_patches..Ms !rT)rN)rC)r"patches_by_priorityr( patch_funcs rRapply_semantic_analyzer_patchesrHs* !n= 3* rTcHg}|jD]}|t|z }|S)zLReturn all unqualified (short) names assigned to in an assignment statement.)rnames_modified_in_lvalue)rr7rAs rRr]r]Rs/F))3*6223 MrTct|tr|gSt|trt|jSt|t t fr#g}|jD]}|t|z }|SgS)z4Return all NameExpr assignment targets in an Lvalue.)r{rerwrrr_rr)rAr7r\s rRrrZsm&(#x FH %' 44 FXy1 2!#LL 5D .t4 4F 5 IrTct|txrG|jxr9t|txr'|jxr|j|jk(S)zIDo n1 and n2 refer to the same Var derived from module-level __getattr__?)r{rrrr)n1n2s rRis_same_var_from_getattrrhsW 2s '  " " ' r3  '  " " ' KK2;; & rTcFtttjSrV)r~rrrrrTrRrrss GI223 44rTct|jtrJt|jtr/|jj xr|jjSyy)zCan symbol table node replace an existing one? These are the only valid cases: 1. Placeholder gets replaced with a non-placeholder 2. Placeholder that isn't known to become type replaced with a placeholder that can become a type TF)r{rrnr,)rercs rRrrwsH#((O, chh 0xx000NSXX5N5N N rTcp||k(xs0t|txrt|txs t||SrV)r{rnr)rjrhs rRrrs8 Q * q/ * Mz!_/M * #Aq )rTc|j}|syt|dtr,t|djtr|jdd}t |dk(ryt |dkDry|d}t|t rL|j}|yt|tr |j}t|txr|jdk(St|txs,t|txrt|jtS)aYReturns 'true' if the given body is "trivial" -- if it contains just a "pass", "..." (ellipsis), or "raise NotImplementedError()". A trivial body may also start with a statement containing just a string (e.g. a docstring). Note: Functions that raise other kinds of exceptions do not count as "trivial". We use this function to help us determine when it's ok to relax certain checks on body, but functions that raise arbitrary exceptions are more likely to do non-trivial work. For example: def halt(self, reason: str = ...) -> NoReturn: raise MyCustomError("Fatal error: " + reason, self.line, self.context) A function that raises just NotImplementedError is much less likely to be this complex. Note: If you update this, you may also need to update mypy.fastparse.is_possible_trivial_body! FrrNTzbuiltins.NotImplementedError) r|r{rMrryr~rpr=rrerrrmrJ)blockr|rrs rRr2r2s& ::D $q'>*z$q',,/Pzz!"~ 4yA~ TQ 7D$ "yy < dH %;;D$)]dmm?].]] dH % 4(PZ <-PrT)rrrcrrr)rrLrvzstr | tuple[str, ...]rrri)r_zlist[T]rzT | None)rqr|r$rrr)rrrr)r"r4rr)rr8rlist[NameExpr])rAr`rr)rrnrrnrr)rrC)rer}rcr}rr)rjrnrhrnrr)rr:rr(Er __future__rcollections.abcrrr contextlibrrorr r r r rpr rrmypyrr%rmypy.constant_foldrmypy.errorcodesrr mypy.errorsrrmypy.exprtotyperrmypy.message_registryr mypy.messagesrrrrrmypy.mrorr mypy.nodesr r!r"r#r$r%r&r'r(r)r*r+r,r-r.r/r0r1r2r3r4r5r6r7r8r9r:r;r<r=r>r?r@rArBrCrDrErFrGrHrIrJrKrLrMrNrOrPrQrRrSrTrUrVrWrXrYrZr[r\r]r^r_r`rarbrcrdrerfrgrhrirjrkrlrmrnrorprqrrrsrtrurvrwrxryrzr{r|r}r~rrrrrrrrrrrrrrrrrrrrrrr mypy.optionsr mypy.patternsrrrrrrrr mypy.pluginrrrr mypy.pluginsrrymypy.reachabilityrrrrrrr mypy.scopermypy.semanal_enumrmypy.semanal_namedtuplermypy.semanal_newtypermypy.semanal_sharedrrrrrrrrrmypy.semanal_typeddictrmypy.tvar_scoper mypy.typeanalrrrrrrrrrrrrr mypy.typeopsrrr mypy.typesrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrmypy.types_utilsrr mypy.typevarsr mypy.utilrrrrr mypy.visitorrrrrrrrrrrrrr!rQrrrr{rr}rrrr]rrrrrr2rrTrRrs0d#::%66@6195I.-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxr!    ;.60   5,ZY44444444444444444444jML''cccc$$ CL!0)%"3!1!1#5!1!1+   =e< e U EU%ZSr02QSrld   * F7F, F9F 5"0rT