X-Ph% ~UdZddlmZddlmZmZmZddlmZddl 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~mZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZddlmZddlmZmZmZmZmZmZmZmZddlmZmZmZmZddlmZddlmZmZmZmZmZmZmZddlmZddlmZddlmZddlmZddlmZmZmZmZmZmZmZmZmZddlmZddlmZddlmZmZmZmZmZmZmZmZmZmZmZmZmZmZddlmZmZmZddlmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZm Z m Z m Z m Z m Z mZmZmZmZmZmZmZmZmZmZmZmZddlmZmZdd lmZdd!lm 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:Z/d/e)d;<e0Z1d<e)d=<Gd>d?e&d@eeZ2dxdFZ3dydLZ4dzdMZ5d{dQZ6d|dWZ7d}dYZ8GdZd[eZ9d}d\Z:Gd]d^eZ;d~daZddlZ?ddnZ@ddqZAddtZBddwZCd@S)aThe 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)x 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_fullnameget_nongen_builtinsimplicit_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_typeno_subscript_builtin_aliastype_constructorsvalidate_instance) function_type get_type_vars"try_getting_str_literals_from_type)0ASSERT_TYPE_NAMESDATACLASS_TRANSFORM_NAMESDEPRECATED_TYPE_NAMESFINAL_DECORATOR_NAMESFINAL_TYPE_NAMESIMPORTED_REVEAL_TYPE_NAMES NEVER_NAMESOVERLOAD_NAMESOVERRIDE_DECORATOR_NAMESPROTOCOL_NAMESREVEAL_TYPE_NAMES TPDICT_NAMESTYPE_ALIAS_NAMESTYPE_CHECK_ONLY_NAMESTYPE_VAR_LIKE_NAMESTYPED_NAMEDTUPLE_NAMESUNPACK_TYPE_NAMESAnyType CallableType FunctionLikeInstance LiteralTypeNoneType Overloaded Parameters ParamSpecTypePlaceholderType ProperTypeTrivialSyntheticTypeTranslator TupleTypeType TypeAliasType TypedDictType TypeOfAnyTypeType TypeVarIdTypeVarLikeTypeTypeVarTupleType TypeVarType UnboundType UnionType UnpackTypeget_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 eZdZUdZgdZded<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)<dd.Zedd/Zedd1Zedd2Zedd3Zedd5Ze ddd8Zdd;Zdd>Zdd?Z dddDZddEZddFZddHZddIZ ddNZ!ddOZ"e dddPZ#ddSZ$ddUZ%ddVZ&ddYZ'dd^Z(ddaZ)ddfZ*ddiZ+ddjZ,ddlZ-eddoZ.ddpZ/ddqZ0e1dduZ2ddvZ3ddxZ4dd{Z5dd|Z6dd}Z7dd~Z8ddZ9ddZ:ddZ;ddZ<ddZ=ddZ>ddZ?ddZ@ddZAddZBddZCddZDddZEddZFddZGddZHddZIddZJddZKddZLddZMddZNddZOddZPddZQddZRddZSddZTddZUddZVddZW d̐ddZXddZYddZZdd„Z[ddĄZ\ dҐddƄZ]ddDŽZ^ddȄZ_ddʄZ`dd̄ZaddτZbddЄZcddфZd dddԄZeddՄZfddքZgddׄZhddلZidd݄ZjddZkddZlddZmddZn dߐddZoddZpddZqddZrddZsddZtddZuddZvddZwdddZxddZyddZzddd Z{dd Z|dd Z}dd Z~ddZddZddZddZddZddZddZddZddZddZddZddZ ddd%Zdd&Zdd'Zdd)Zdd,Zdd1Z ddd9Zdd<Zdd?Zdd@ZddCZddDZdddFZddHZddJZddLZddMZddNZddPZddQZddRZddTZddXZdd`ZdddddaddjZddkZddlZddmZddpZddsZddtZdduZddvZddwZd d{Zdd|Zdd}Zdd~Zd dZd dZd dZd dZddZddZddZddZddZddZddZddZddZddZddZddZddZddZddZÐddZĐddZŐddZƐd dZǐd!dZȐd"dZɐd#dZʐd$dZːd%dZ̐d&dZ͐d'dZΐd(dZϐd)dZАd*dZѐd+d„ZҐd,dĄZӐd-dƄZԐd.dȄZՐd/dʄZ֐d/d˄Zאd0d̈́Zؐd1dτZِd2dфZڐd3dӄZېd4dՄZܐd5dׄZݐd6dلZސd7dۄZߐd8d݄Zd9d߄Zd:dZd:dZd;dZd<dZd=dZd>dZd?dZd@dZdAdZdBdZdCdZdDdZdEdZdFdZ ddGdZdHdZdHdZdIdZdHdZdJdZdKdZ ddGdZdLd ZdMd ZdNd ZdOdZdPdZdQdZdRdZdSdZdSdZddTdZddUdZdVdZdWdZ dXdYd ZdZd!Z d[d\d$Zd]d%Zd^d'Z d_d)Z d`d*Z dad+Z edbd-Z dҐdcd0Zddd2Zded4Zdd5Z dfdgd7Zdhd8Z ddid9Zdjd:Zdkd;Zedld>Zdd?Zdd@ZddAZddBZdmdCZ d̐dndDZddEZdodHZddpdJZ dqdNZ! ddrdOZ" ddrdPZ#ddQZ$ddRZ% ddddSdsdZZ&ddtd[Z'dud]Z(dvd^Z) dwdxdaZ*dydbZ+dddddddddddddc dzdkZ,dd{dlZ-dddddddddddddc d|dmZ.d}doZ/d~dsZ0ddtZ1dddwZ2 dddzZ3dd{Z4dd|Z5dd~Z6dŐdZ7ddZ8ddZ9ddZ:ddZ;ddZ<ddZ=ddZ>ddZ?ddZ@ddZAddZBddZCddZDdS(SemanticAnalyzerzSemantically 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_typesmissing_modulesincomplete_namespacesreturnNonecdg|_tg|_i|_t |_d|_g|_g|_t|_ g|_ dg|_ dg|_ ||_||_t!|||_||_t g|_||_g|_i|_||_d|_t3|_g|_d|_d|_d|_d|_d|_ dS)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_localssetr7r.r/incomplete_type_stackrr0r1r,r4r8r%rmsgr<r2r= all_exports export_mapr9recurse_into_functionsrscopedeferral_debug_contextbasic_type_applicationsallow_unbound_tvarscurrent_overload_iteminside_except_star_block$return_stmt_inside_except_star_block)selfr%r<r=r8r9s L/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/mypy/semanal.py__init__zSemanticAnalyzer.__init__s&f (>  uu  13"*,, 3#  !&'22.!eeW&;"&(02 '+#WW >@#(-$ $) 26"/4%:?111c|jSN)r.rOs rPtypezSemanticAnalyzer.types zrRrc|jSrT) _is_stub_filerUs rP is_stub_filezSemanticAnalyzer.is_stub_files !!rRc|jSrT)_is_typeshed_stub_filerUs rPis_typeshed_stub_filez&SemanticAnalyzer.is_typeshed_stub_files **rRc|jSrT)_final_iterationrUs rPfinal_iterationz SemanticAnalyzer.final_iterations $$rRIterator[None]c#VK|j}d|_ dV||_dS#||_wxYwNTrK)rOolds rPallow_unbound_tvars_setz(SemanticAnalyzer.allow_unbound_tvars_setsF&#'  + EEE'*D $ $ $sD $ * * * *s (value entering_loopc#K|j}||_|s|j}||_ dV||_|s ||_dSdS#||_|s||_wxYwrT)rMrN)rOrfrgrdold_return_stmt_flags rPinside_except_star_block_setz-SemanticAnalyzer.inside_except_star_block_sets+(-% >#'#L 8=D 5 Q EEE,/D )  Qr?c|D]}t|tr6|jD]}|j|jr|jjt|t rkt |jdkrSt|jdtr3j d|jdj vr| |dS)Nrr.) copy isinstancerVbody else_bodyr8lenlvaluesrerrnameremove)rystmtrrvrkhelpers rPrz9SemanticAnalyzer.prepare_typing_namespace..helper?s * *dF++4 $ **ty))))~4t~2333t^44*DL))Q.."4<?H==/$,EEt|A/CEEPP D))) * *rRN)ryrzr>r?)ry)rOrkrvrs ``@rPrtz)SemanticAnalyzer.prepare_typing_namespace2sG * * * * * * * * y~rRcb|j}tD]^}t|tg}t t |d}d||_tt|||<_|dj }t|tsJt|g}dtfdttjfdttjfd|fd|fd |fg}|D]<\}} t!|| } d|| _tt| |j|<=d S) 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) rOrkrqrcdefinfo bool_info bool_typespecial_var_typestypvs rPrsz+SemanticAnalyzer.prepare_builtins_namespaceQsG ) 6 6DD%)),,DKMM4< Y  i ) $ 5 + = =ID#D#A,d,,AK$3D!$<$22H,244= = GD!y  $## 5577.. KK<#3``5````JJLLLFF***..#h 8N0O0O%P< 0JJIJJJJJLLLFF##<5U223DEEDD223STTD<+#667HII#//1N//// >Z//$/xzz0BCCD}}&Ld&L&L}}}!!nn **400H#Jx}o,V,V#nnS))G $(( $ 3 3D 9 9 # c=??;;;;#D$7$7$=$=y"MM!OOs= = rRtreec`|jdksJtjD]\}}|tvrt||jjkr*|dd}||jvr&t|j|j tst| ||||dS)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]`. ror|rN) rrrrrr"python_versionsplitrqr~rrn create_aliasrOralias target_namers rPrz$SemanticAnalyzer.add_builtin_aliasess}(((("."4"6"6 > > E;55507$,:UUU;;s##B'Dtz!!*TZ5E5JO*\*\!   dK = = = = > >rRcL|jdksJtjD]\}}|dd}||jvr&t |j|jtrO|j|d| ||||dS)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. rpr|rN) rrrrrrqr~rr poprrs rPrz-SemanticAnalyzer.add_typing_extension_aliasess} 33333";"A"C"C > > E;;;s##B'Dtz!!jD1A1F &R&R! JNN4 & & &   dK = = = = > >rRrstrrrcd|}||}|rt|jtr|||dS||g}|Jt||j|j d|j t||dddd}| |||dS| |r|||dS||jvr1t|j|jtsJ|j|=dSdS)NF disallow_anyr"rT)rrno_args normalized)track_incomplete_refslookup_fully_qualified_or_noner~rrnmark_incompleterrrnoter"r rfound_incomplete_refrq) rOrrrrtagrtarget alias_nodes rPrzSemanticAnalyzer.create_aliassh((**  / / < <  %!&/22 8$$T40000000bAA)))DItyudl' #  j$77777  & &s + + %  t , , , , ,tz!!!$*T"2"7IIIIIJt$$$"!rRcd|jvr>|jD]&\}}||jvrd|_d|_d|_%dSdS)z7Adjust the module visibility of globals due to __all__.__all__TFN)r&rrE module_public module_hidden)rOrgs rPrz&SemanticAnalyzer.adjust_public_exports7sk  $ $<--// , ,a4+++&*AO&+AOO',AOO % $ , ,rRc#K|j}||_|j|j|j||||_|j|_||j5|j d|_ | ||_ |j|_t!|_t%|||j|_t+|||j|_t/|||_t3|||j|_d|_|r|jddd}d|vr=||}|r&t=|jt@r |j|_!|"|j#j$|j#|j%&d|'||'|j#j(|j#j)D]}|j*|dV|rg|+|+d|_!|j%,|-|j#j$dddn #1swxYwY|`dS)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 )rHr"z.pyirr|rFN).rHr"r8set_filepathrrr#r module_scopelowerendswithrXis_typeshed_filer[rqr&rr0rrDnamed_tuple_analyzerrtyped_dict_analyzerrenum_call_analyzerrnewtype_analyzernum_incomplete_refsrsplitrr~rrr.push_type_argsdefn type_argsrCappend enter_classr type_vars bind_existing leave_classr pop_type_args)rOrkr"rrHenclosing_fullnameenclosing_nodetvars rPrzSemanticAnalyzer.file_contextDs   Y^Y-?uV]^^^%#,    0 0# ?# ?!*!5!5!7!7!@!@!H!HD *3*D*DW*M*MD '$?DL.00DO(:7D$((S(SD %'8$'Q'QD $&6w&E&ED #$3GT48$L$LD !()D $ 8%0%9%@%@a%H%H%K",,,%)%H%HI[%\%\N%9*^5H(*S*S9%3%8 ##K$4$> @PQQQ*11%888!!+...  !1!6777',688DO11$7777 EEE ?!!###  """! *..000"";#3#=>>>G# ?# ?# ?# ?# ?# ?# ?# ?# ?# ?# ?# ?# ?# ?# ?H LLLs&IJ77J;>J;rrRcV||_|jD]#}|jr|j|$|jddk|_||j|_|j rt|j dkr#|j s|j s|||j sdS|j|5|d5||dddn #1swxYwYddddS#1swxYwYdS)NrrF)rf)r: arguments initializerrr,is_conditionalrrrrGrr1 is_decorated is_overloadadd_function_to_symbol_tablerHfunction_scoperjanalyze_func_def)rOrargs rPvisit_func_defzSemanticAnalyzer.visit_func_def~s> - -C -&&t,,,".r2Q6,,TY77 * 8c$2E.F.F.J.J$ 8T-= 811$777*  F Z & &t , , , ,222?? , ,%%d+++ , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ,s6 D$D: DD D D DD"%D"rrc,|j|S|d|jS)N#rLrOrrs rPfunction_fullnamez"SemanticAnalyzer.function_fullnames'  % -O99T7999rRcn ||j|||dS|j||jr8t |jtsJ||j|}nd}|j | r|jJ|j|_ |j}|j dvrtt |jtsJt t|jjtr,|jt#|_|||j|||j}||j|5|jr||jt |jtsJ|}|}||jd|}||st;|r=||||j ddddSt |t>sJt |tr| o|j }|j!rNtD|j#|dvr8|$d|tJj&|d}|j'rNtD|j#|dvr8|$d|tJj&|d }|(||}|r7|j0|j}|j)"|j)gtU|j+z|_+||_|,|j-|.|t |t^r6t |jtsJta|j||_dddn #1swxYwY|1||2|| r|jJ|jj3r]|j4sVt |j5j6tnr|j8r0|j9ttkr tw|j<r tz|_9tw|j<r|j4s|j9t|krd |_;|j?rt |jtr|j@A||jkr|jBrnwttjD} |Ed | | |jjg} | Jd |j| |_|j|j@|<||jdS) NF)rQ__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)Frrrr1rrVr~rupdate_function_type_variablesris_class_scoperrrrr copy_modifiedrprepare_method_signaturerrrtvar_scope_framer0 method_framecheck_classvar_in_signature type_analyzerrvisit_callable_typerrrr is_staticrr! arg_kindsrcodes VALID_TYPErremove_unpack_kwargs self_typelist variablesadd_type_alias_deps aliases_usedcheck_function_signaturerRranalyze_arg_initializersanalyze_function_body is_protocolrYrHrrj is_propertyabstract_statusr(is_trivial_bodyrr&r+ is_coroutiner;ris_async_generatorrrr) rOr has_self_typerranalyzerrresult skip_selfrany_typers rPr z!SemanticAnalyzer.analyze_func_defs   t~t 4 4 < JJt    F ""4((( 9 "di66 6 6 6 ?? 4PPMM!M !!!     J9((( DIy$6W)W)W!$)\:::::odi.@AA7KKM $ 7 7 7 L LDI  ) )$ = I I I))$-88  " "4?#?#?#I#I J J, C, Cy+ C00;;;!$)\::::: --//0022!55diYa5bb,,S11_V5L5LJJt$$$&&t~666, C, C, C, C, C, C, C, C"&*55555fl33Y $ 3 3 5 5 Ldn:LI(GWF#y>504/?$vGWBXBX/XF," (()>???--d333dG,,C%di>>>>> 1$)T B BDIY, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C\ %%d+++ ""4(((     ,9((( % ;) ;$DJ$79JKK ;PTO_ ;(K77#DI..8(;$ ** ,) ,(L88'+$   A49l33 A.22488DIEE& A#9#9::22&8TY=O(P ++-Y+++ I33X3FF 7;y.t4 4>*****s7CQ+GQ++Q/2Q/rrcf|jr|jdtjur|S|jd}t |t s|St |j}t |tsV| d||jddttj gz}| |St|jt|jz}||jd|rxdd|D}| d|||jddttj gz}| |S|jdd|gz}| |dS) Nrz.Unpack item in ** argument must be a TypedDict arg_typesz, cg|]}d|d S)".0rs rP z9SemanticAnalyzer.remove_unpack_kwargs..#s #D#D#DDKKKK#D#D#DrRz7Overlap between argument names and ** TypedDict items: T)r> unpack_kwargs)r%r4r"r>r~rrrVrrrr from_errorrrB arg_namesrdiscardjoin)rOrr last_type new_arg_typesoverlap overlappeds rPr(z%SemanticAnalyzer.remove_unpack_kwargss}  b 19J J JJM"% )Z00 J#IN33 )]33 > IIF R R RM#2#.'):N2O2O1PPM$$}$== =cm$$s9?';';; b)***  >#D#DG#D#D#DEEJ II\PZ\\^b c c cM#2#.'):N2O2O1PPM$$}$== = crc*i[8   = MMMrRfuncrrr7c|j}|jdkrd|_|jr |jdkr|jdvrd|_|js|d|dSt |trWt|j d}t |trx|r"|j |jj J|jj }nd|_ t|}|js |jdkr||}t|||_dS|rt |jtrt t|jj dtsh|||jp |jdkr$|d|t$jdS|d |dSdSdSdSdS|r|d |dSdS) zICheck basic signature validity and tweak annotation of self/cls argument.__new__T)r__class_getitem__zKMethod must have at least one argument. Did you forget the "self" argument?rNz9Redundant "Self" annotation for the first method argumentrz9Method cannot have explicit self annotation and Self typez#Static methods cannot use Self type)rVrr$is_classrrr~rrr>rr)is_trivial_selfr class_typereplace_implicit_first_typeunanalyzed_typeis_expected_self_typer&REDUNDANT_SELF_TYPE)rOrNrr7functyper) leading_types rPrz)SemanticAnalyzer.prepare_method_signature+sW9 9 ! !!DN~% Ci!7!7yFFF $ >  aHl33 +H,>q,ABB i11$;#y49L9X9X9X-1Y-@ /3,'4T':': }E Y(>(>'+|'D'D ;Hl S SDIII"z$2F 'U'U%od6J6TUV6W&X&XZabb55%t}'N Y8N  !II [ $%*%>& !II []a3   C II;T B B B B B C CrRris_classmethodc|jJt|}|rt|tr||jdSt|t r||j|d}|k|j dks7|j dkrU|j s%| ds|j j d kr)|jr"||jd dSdSt|tr||jjkSt|t r/||j|d}|duo |j t"vSdS) zODoes this (analyzed or not) type represent the expected Self type for a method?NF)r[Tsuppress_errorsz typing.Type builtins.typer)r r)rVrr~rrWitemrlookup_qualifiedrrrrYis_future_flag_setr"rargsrr)r)rOrr[syms rPrWz&SemanticAnalyzer.is_expected_self_typeXsvy$$$c""  #x(( R11#(51QQQ#{++ Y++CHc4+PPO 55LO;; $ 1<$(#:#:=#I#I<$(<#>&#H#H $I  55chqkRW5XXX5 c; ' ' .$)-- - c; ' ' G''#t'LLCd?Fs|'F FurRprevious Node | NonenewFuncDef | Decoratorc.t|tr|j}t|ttfr*t |jrt |jrdSt|tt tfr|jr ||_dSdS)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~rFrNrRrrrr original_def)rOrfrhs rPset_original_defz!SemanticAnalyzer.set_original_defys c9 % % (C x'9!5 6 6  ** !//  4 h#y 9 : : s?Q 'C 45rRfun_typerSc0|j}j|5}|||\|_}|rj |j r]d|jD}fd|j D}t||z }|r%j d|D||cdddS#1swxYwYdS)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. Nch|] }|j SrArrrCrs rP zBSemanticAnalyzer.update_function_type_variables..s"J"J"J!1:"J"J"JrRcDh|]}|jSrA)rr)rCprOs rPrrzBSemanticAnalyzer.update_function_type_variables..s)%Z%Z%Zad&9&9!&&A&A%Z%Z%ZrRcDg|]}|ddS)r|rr)rCrs rPrDzCSemanticAnalyzer.update_function_type_variables..s'999ab)999rR)rrrrr0r r"bind_function_type_variablesr+rVsetup_self_typersortedrD"type_parameters_should_be_declared) rOrmrrrar7bound_fullnamesdeclared_fullnamesextras ` rPrz/SemanticAnalyzer.update_function_type_variabless{))$-88  " "4?#?#?#I#I J J ! !""$$A010N0NxY]0^0^ -H   '!6$$&&&~ "J"Jx7I"J"J"J%Z%Z%Z%Z4>%Z%Z%Z"1CCDDH??9959994! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! !s B5D  DDc z|jJ|j}|jPt|jjr5|dd||jjt |kndSt d|jdtdgt |ttj |_dS)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) rVr)rrprocess_placeholderrrrrrrrfrom_omitted_genericsrOrs rPrxz SemanticAnalyzer.setup_self_typesy$$$y > %t~9:: ((&#'>#=tATAT#T )$ } # # #||%d++I;<<    rRrjc||_|||jsdS|j|5||ddddS#1swxYwYdSrT)r:rrGrHr analyze_overloaded_func_defrOrs rPvisit_overloaded_func_defz*SemanticAnalyzer.visit_overloaded_func_defs ))$///*  F Z & &t , , 3 3  , ,T 2 2 2 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3sA##A'*A'ra int | Nonec#HK||_ dVd|_dS#d|_wxYwrTr)rOras rPoverload_item_setz"SemanticAnalyzer.overload_item_sets>%)" . EEE)-D & & &D & - - - -s !cV||j|_|j|_|jd}d|_|d5||dddn #1swxYwYd}dt|trr|j j rfdd|j _| |}t|j |d}t|t sJ|g}n||\}}}||_|r)|||t)|dk|&||jdusJ|jdd|_n|s|||rt-fdt/|jDsZt1||_|j|j_t|tr |r|d|j_||j_|js|js|jd|_dS||||||| |dS)NrTFbuiltins.function)some_overload_decoratorsrc3K|]>\}}t|to!t|j|dkssdndkV?dS)rrN)r~rFr decorators)rCiitr2s rP z?SemanticAnalyzer.analyze_overloaded_func_def..so  2 r9 % % LBM""1q55 5aaK       rR)!rrrunanalyzed_itemsr}rrrrr~rFrNr2+analyze_property_with_multi_part_definitionr named_typeranalyze_overload_sigs_and_implimpl"handle_missing_overload_decoratorsr&handle_missing_overload_implementationany enumeraterrVrr setter_typeprocess_deprecated_overloadprocess_final_in_overload*process_static_or_class_method_in_overloadprocess_overload_impl) rOr first_itembare_setter_typertypesrnon_overload_indexesr2s @rPrz,SemanticAnalyzer.analyze_overloaded_func_defs ,,TY77*//11 Z] !%   # #A & & $ $   d # # # $ $ $ $ $ $ $ $ $ $ $ $ $ $ $  j) , , B1L BK*.JO '#OOPTUU  AT1U1UVVCc<00 0 0 0EEE 150S0STX0Y0Y -E4-DI# 77.UVW8 tz"~----!Z_ ) B;;DAAA  >    #4:..       >#5))DI!YDIN*i00 >5E >&+Ah #-= *z 9 6!1"5 F ((... &&t,,, 77=== ""4(((((s(B  BBcF|jrdSt|jx}tr@|jjx}2||_|jD]#}t|tr ||j_$|jD]}d}t|tr|jD]}|r1t|tr|j d|5| |x}Fd}t|jj x}trd|d}nd}d|d|jd||j_dS)NFz-@overload should be placed before @deprecatedT overloadz of function  is deprecated: )r2r~rrFrN deprecatedrrrefers_to_fullnamerrDrget_deprecatedrVrrr) rOrrrra deprecationrrtypestrs rPrz,SemanticAnalyzer.process_deprecated_overload(sm    F di'd 3 3 69/ /Z <(DO  6 6dI..6+5DI(J  DK$ **   A" '9!^'L'L  &UWXYYYY(,(;(;A(>(>>*K&* %TY^&;c\JJ*&0#jjjGG&)G,w,,DM,,),, ,  rR expressionrL str | Nonect|trXt|jtr>t |jx}dkr$t|dx}tr|jSdSNrr) r~r=rcalleerrrdryrf)rrdrs rPrzSemanticAnalyzer.get_deprecatedEss z8 , , $":#46KLL $Z_,T--22a0:'::3# #trRcP|jdSt|jtr|jn |jj}t |jrU|rC|js>|jJ|jj r t|_ |j tkrd|_dSdSdSdSdS)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~rRrNr4rrrYrVr1r&r3r+)rOrrs rPrz&SemanticAnalyzer.process_overload_implPs 9  F&ty'::Ntyy  49 % % ,$*=*=*?*? ,HY ,9(((y$ ;':$#|33'+$$$  , , , , , ,43rR9tuple[list[CallableType], OverloadPart | None, list[int]]cg}g}d}t|jD]\}}|dkrfd|_||t |jdz kr|nd5||dddn #1swxYwYt |trt|j | d}t |tsJtd|j Ds;|t |jdz kr |js|}nY||nCd|j _|||jjr|d||xj|j jzc_~t |t(r;|t |jdz kr |js|}|||||fS)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. NrTrrc3@K|]}t|tVdSrT)rr)rCdecs rPrzBSemanticAnalyzer.analyze_overload_sigs_and_impl..us-^^s-c>BB^^^^^^rRz!An overload can not be a property)rrrrrrr~rFrrNrrrrrYrrr2ris_explicit_overriderR)rOrrrrrracallables rPrz/SemanticAnalyzer.analyze_overload_sigs_and_impl`s;!$( ,, 3 3GAtAvv#' ++S__q5H1H1HAAdSS&&KK%%%&&&&&&&&&&&&&&&$ ** 3(DOODW4X4XYY!(L99999^^do^^^^^ MC OOa///8I/# -33A6666,0DI)LL***x+M "EtLLL))TY-KK)))D'** 3DJ!+++D4E+DD(//222d000s BB B rrc|rP|D]L}|jr"|d|j|+|d|j|Mnr|ddD]4}||j|j||jd5|jr,||j|j|jdt |D] }|j|= dS)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 filez.sO4++X 0I[0XrRrTzFAn overloaded function outside a stub file must have an implementationrN)rYrVr1 is_func_scoperr~rFr(rNr3allr4rr&NO_OVERLOAD_IMPL)rOrras rPrz7SemanticAnalyzer.handle_missing_overload_implementations5  y TY2 4;M;M;O;O !J;;D!$ 22;4? 11/:,, ;;  J  :>%djmY?????9=DJqM&666>> \/%  rRctd|jDrd|_td|jD}|js|d|nbtd|jddDr.s$44t}444444rRTc3(K|] }|j |VdSrTrrCovs rPrz=SemanticAnalyzer.process_final_in_overload..s)DDB DRDDDDDDrRz8@final should be applied only to overload implementationc3$K|] }|jV dSrTrrs rPrz=SemanticAnalyzer.process_final_in_overload..s$>>tT]>>>>>>rRrNc3(K|] }|j |VdSrTrrs rPrz=SemanticAnalyzer.process_final_in_overload..s) L L L L L L L L LrRz@In a stub file @final must be applied only to the first overload)rrrnextrYrr)rOr bad_finals rPrz*SemanticAnalyzer.process_final_in_overloads 44444 4 4  DMDD$*DDDDDI$  TV_````>>tz!""~>>>>>  L Ldjn L L LLL  VXa 9 TY%7  DMMM ! rRcg}g}|jD]}t|tr|j}n2t|tr|}nJdt |||j||j|j t|j tr |j j}nAt|j tr|j }nJdt |j ||j||jtt|dkr|j d|dStt|dkr|j d|dS|d|_|d|_dS)NFz+The 'item' variable is an unexpected type: zUnexpected impl type: r classmethod staticmethodr)rr~rFrNrRrVrrRr$rrrBrD)overload_inconsistently_applies_decorator)rOr class_status static_statusrainners rPrz;SemanticAnalyzer.process_static_or_class_method_in_overloads  J 2 2D$ ** Y D'** YXXDQUJJXXXXX    / / /   1 1 1 1 9 $)Y// I DIw// I HHtDIHHHHH    / / /   1 1 1 s<  ! !Q & & H > >}d S S S S S ]## $ $ ) ) H > >~t T T T T T(ODM*1-DNNNrRCallableType | Nonectd|_|j}|jd}t|tsJg}d}t |ddD]y\}}t|tr!|j||jr|jd}t|tr|j dkrcd|j _ |jj |j_ t|j|d} t| tsJ| }|j dkr|jj |j_ |jddD]} | ||d|jj d |=|d |jj d |||dz{t%|D]}||=|ddD]O}t|tr8|jD]0} || x} d |jd | |j_1P|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. TrNrsetterrdeleterz!Only supported top decorator is @z.setterz$Unexpected definition for property "r@ function r)r2rr~rFrrNrrrbrris_settable_propertyr3rrrrrrrrrr) rOrrr deleted_itemsrrra first_nodesetter_func_type other_noderrs rPrz #M#MMMM/?,%?i778B8WDI5*./!""*=44J&--d33334 ] @T]]]_c XAUXXXZ^___$$QU++++-((  Aa!""I  D$ ** A&*&9&9!&<&<< IS SSzSS , rRFuncDef | OverloadedFuncDefc|r|jJ|j|_||j|_||j||dSrT)rrVrrrrr)rOrNs rPrz-SemanticAnalyzer.add_function_to_symbol_table0sb     "9((( DI,,TY77  4.....rRc||j}||j|5|jD]#}|jr|j|$ ddddS#1swxYwYdSrT)rrrrr0r rrr)rOrrrr s rPr/z)SemanticAnalyzer.analyze_arg_initializers7s))$-88  " "4?#?#?#I#I J J 1 1~ 1 1?1O**4000 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1s,BB Bc|}||j}||j|5|jr|}|j}t|tsJ| ||tt|j D]}t||||j|j|||5|jD]}||j||rO|jr |jdkr=|jr6|jsd|jdj_nd|jdj_|j|dddn #1swxYwY|jddddS#1swxYwYdS)NrPTr)rrrrrr0r rVr"r~rrwrangerr>rrr1renterr add_localvariabler$rrRis_selfis_clsrrr)rOr is_methodrrr{rrr s rPr0z&SemanticAnalyzer.analyze_function_body?sl'')) ))$-88  " "4?#?#?#I#I J J & &y G&&((i!#|44444..sD999s3=1122GGA'adoFFFF   & &t , , ,D!! ' '>77CNN3<6666 AdnA Y8N8NTXTb8N=A=Aq)2::<@q)29   &&& ' ' ' ' ' ' ' ' ' ' ' ' ' ' '   # # % % %1 & & & & & & & & & & & & & & & & & &s8B:G$BF3' G$3F7 7G$:F7 ;G$$G(+G(rcTt|tr!|jD]}||dSt|tsdSt |jt|jgzD]/}| |r| |dS0dSrT) r~rrr!rrr>rr is_classvarfail_invalid_classvar)rOrrs rPr!z,SemanticAnalyzer.check_classvar_in_signature\s c: & & Y 4 4003333 F#|,,  F!#-00OCL4Q4Q3RR  A"" **1---   rRfdefc|j}t|tsJt|jt|jkrx|d|t|jt|jz }ttj g|z}|j |dSt|jt|jkr|d|ddSdS)Nz$Type signature has too few argumentsz%Type signature has too many argumentsTblocker) rVr~rrr>rrrrrFextend)rOrsignum_extra_anys extra_anyss rPr.z)SemanticAnalyzer.check_function_signaturejsi#|,,,,, s}  DN 3 3 3 3 IIIJ M  , , , , ,   #dn"5"5 5 5 II=tTI R R R R R6 5rRrrFc ||_|j|_|jddk|j_|js||j ||| |j |j_ | |j |j _ |jD]}| |g}d}d}t|jD]\}}t|dr=||t"|j_|d|St|dr"||d|j_t|drD||d|j_d|j _|d |t|d rE||d|j_d|j _|d |.t|t2r9||d|j_|d ||t|d r||d|j_d|j _t|drt"|j_nt|dr d|j _|d|t|dr't;t<j|j _ d}Ft|tBr|"rg|j Jd|j j#r|j$%|nd|j_&d|j _&|||'d|t|tPrd|j_)tU|tVr;t|j,tZr!|.||j_/a|0|x}d|j1d||j_2|j jsd}tg|D] }|j|= |jr |j jr$|j r|j |j _4d|j _5|s!|j6r|j ||r0|jr)|j jr|'d|tn|jjs |jjr"|j jr|'d||jjt"kr0|jj&r$|'d|jj d||jjr.|jjr$|'tpj9|dSdSdS)NrrFzabc.abstractmethodabstractmethod)zasyncio.coroutines.coroutineztypes.coroutineTzbuiltins.staticmethodrzbuiltins.classmethodroverride)zbuiltins.propertyabc.abstractpropertyfunctools.cached_propertyz enum.propertyztypes.DynamicClassAttributerrpropertyztyping.no_type_checkzNo type set at class scopez/@final cannot be used with non-method functionsrrz0Decorators on top of @property are not supportedrz5Only instance methods can be decorated with @propertyzMethod z is both abstract and final):r:original_decoratorsr}rr,rNrrrrrrrrrrrr(r3"check_decorated_function_is_methodis_awaitable_coroutiner$is_staticmethodrRr[rrr2rrrrrVrrr1rDprotocol_members_cant_be_finalrrris_type_check_onlyr~r=rrparse_dataclass_transform_specdataclass_transform_specrrrrrris_initialized_in_classrGrr$CLASS_PATTERN_CLASS_OR_STATIC_METHOD)rOrrremoved no_type_checkcould_be_decorated_propertyrrs rPvisit_decoratorz SemanticAnalyzer.visit_decoratorvs05577"&"22"6": 0 OOCHc3 / / /!00:: //99  A HHTNNNN &+#cn--C 3C 3DAq!!%9::A 3q!!!+6(778H#NNNN#A'Z[[= 3q!!!26//#A'>??: 3q!!!%)"*.'77LLLL#A'=>>5 3q!!!$(!)-&77 sKKKK#A'?@@0 3q!!!04-77 CHHHH#  , 3q!!!'+$&*#%a)?@@8/:CH,,'+FGG837CG077 CHHHH#A'=>> 3&y'=>> $ #A'<== 3&&(( T9002N000y,0??BBBB,0)+/(NN1%%%%IIOQRSSSS#A'<== 3.2++Ax(( 3-?3.. 3594W4WXY4Z4Z11 $ 3 3A 6 66*C&\#,&\&\PZ&\&\##W( 3/3+'"" " "Aq!! 337#6 3DI 39CGL.2CG + "!< " HOOD ! ! ! & 3> cg>Q  IIBCN`     H  T#("3 T9L T IIMs S S S 8 #{ 2 2sx7H 2 IIJ JJJC P P P 8  R#("3 R II&KS Q Q Q Q Q R R R RrR decoratorcontextrCct|jr|r|d|d|dSdS)Nr@z" used with a non-method)rVrr)rOrrs rPrz3SemanticAnalyzer.check_decorated_function_is_methodsSy HD..00 H II=)===w G G G G G H HrRr?c*||_|j|j ||j}||j|5| |j |)| |j| ddddS| || |j dddn #1swxYwY|jdSrT)r:rCrrrrrr0 class_framerrr analyze_classrr)rOrrs rPvisit_class_defz SemanticAnalyzer.visit_class_defsV "))di-888'' 22  " "4?#>#>y#I#I J J / /""4>488@$$TY555 / / / / / / / /   t $ $ $   t~ . . .  / / / / / / / / / / / / / / / "&&(((((s/8C/4/C//C36C3rlist[TypeParam] | None(list[tuple[str, TypeVarLikeExpr]] | Nonec|sgS|jt|jtg}|D]9}|||}|dS||j|f:|D]O\}}||r|d|d|5| |||ddP|S)Nr@z%" already defined as a type parameterT) no_progress type_param) r)rr|r+ranalyze_type_paramris_defined_type_paramrr)rOrrtvsrttvrs rPrzSemanticAnalyzer.push_type_argss I ;==)))  011113 % %A((G44Bztt JJ| $ $ $ $ V VHD"))$// V IdIII7SSSSb'tPTUUUU rRcr|jD].}|||vr%||j}t|trdS/dSNTF)r)rr~r)rOrrqrs rPrz&SemanticAnalyzer.is_defined_type_paramsO[  E}u}}T{'dO44 44urRrrTypeVarLikeExpr | Nonec @||j}|jr5||jd}|t dg|j}nN|jtkr*|d| g}n| }|j r||j ddd|jtk|jtk|jtk}|t dg|j}n|jtkr| ||j }nq|jtkr|||j }nE|jtkr|||j }nt!t"j}|jtkrg}|jr|jD]}||d}|t dg|j}t)|rM|t,j||t!t"j||t5|j||||t6d|jS|jtkrt9|j|||d|jS|jtksJ|d| g} t;|j||| |d|jS) NTallow_placeholderbuiltins.tupleF)r%rKreport_invalid_typesallow_param_spec_literalsallow_tuple_literal allow_unpack)rrrrrrvariance is_new_styler)rrrrrr,r)rrrrtuple_fallbackrr,r)rrrrrrkindr2r object_typerr,r1check_typevar_defaultcheck_paramspec_defaultcheck_typevartuple_defaultrrrrrrr TYPE_VAR_GENERIC_CONSTRAINT_TYPErrFrr3rlr) rOrrrrrrrrfanalyzedr-s rPrz#SemanticAnalyzer.analyze_type_params"&&z77  ! 1..)?SW.XXK".dB EE "555"oo.>AQAQASAS@TUU "..00   ?nn""&$(%**4/_*L$.O$F'_0CC%G)$GLAAM1144Wj>PQQO3366w @RSS$77799':CUVVi=>>G ?m + +!#F 0'.00E#~~et~LLH'#24W\#J#J$X..0 "2"SU\]]] gi.B&C&CDDDD h////_!'+!\    _ / / _!'!\  ?&99999!__-=@P@P@R@R?STTN#_!'-!\ rRcr|sdS|j|jdSrT)r)rr+)rOrs rPrzSemanticAnalyzer.pop_type_args_s<  F  rRc||j}|jsK||s6t |||jd}||j||d|}|j |j |j | ||j}| |||\}}}|||D]}t|t r;t#d|jg|jzDr|t+|jr||j|dS||||} | ||r||j|dS| \} } t#d| Dr||j|dS||j|j\} } }| s||r||j|dS||r4|jr+|||||dS| ||rdS|!||||| r d|j_"|r d|j_#|j$%|j5|&|| ||j_'|(|| d|j_)|j*r2|j+,}|j-,|j.D]}|/|||j*r9|j+0||j-0tb|2|ddddS#1swxYwYdS)NTbecomes_typeinfoF) can_deferrc34K|]}t|VdSrTrrCrs rPrz1SemanticAnalyzer.analyze_class..s;44'(""444444rRc3FK|]\}}t|tVdSrT)r~r)rCbase_s rPrz1SemanticAnalyzer.analyze_class..s0KKWT1z$00KKKKKKrR)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~rrrrrrrranalyze_class_keywordsanalyze_base_classesrget_declared_metaclass metaclassanalyze_typeddict_classdefsetup_type_varssetup_alias_type_varsanalyze_namedtuple_classdefprepare_class_deffallback_to_anymeta_fallback_to_anyrH class_scopeconfigure_base_classesr1recalculate_metaclassruntime_protocolrr)rr+ranalyze_class_decoratorrranalyze_class_body_common)rOrrr placeholderrbases tvar_defsr1tvd bases_result base_types base_errordeclared_metaclass should_deferany_metatype_params_namesrs rPrzSemanticAnalyzer.analyze_classes&&ty11y K!;!;D!A!A K *(D$)VZ[[[K OODI{DEO J J J((** ##D$@AAA $**,,, ::4@@@$(,(T(T %)U) ) %y+ ##E***  C#{++ 44-0_,= ,J44411   s{++ $$TY555   ##D)))0077  4#<# > ,,T9====~ : ""#4555 ''(8999  * *4 0 0 0# 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1sC3QQ  Q rZlist[Expression]c|D]o}t|tr|j}t|tr.B.B +dn-- = =DAq!-.. =;< '8(/&*----- fm , , K#4T^#D#DFO  * * K+R1RRrRc.||jtd|jjDr||j||||dS)zHParts of class body analysis that are common to all kinds of class defs.c3(K|] }|jduVdSrT)r))rCbs rPrz=SemanticAnalyzer.analyze_class_body_common..s)>>1q{$&>>>>>>rRN) rrrmrorxryrapply_class_plugin_hooksrrs rPrXz*SemanticAnalyzer.analyze_class_body_commons ### >> >>> > > #  " " "  %%d+++ rRc|jr'|jjrt|jjsdS|j|\}}|rp|jD]0}|||||||1|||j |n| ||ddSdS)NT custom_namesF) rtypeddict_typerrrLrranalyze_class_decorator_commonrrrP)rOr is_typeddictrrs rPrLz+SemanticAnalyzer.analyze_typeddict_classdefs I  ( $DI$<==  4!5PPQUVV d  !_ O O   &&&#77dINNN|$$TY5555&&tT&EEE4urRc4|jr;|jjr/|jjr#t|jjs d}|j}n6|j||j|\}}|r|||j |n| ||d| ||| ||j |j5|jD]3}|||||j|4|j|5||dddn #1swxYwYdddn #1swxYwYdSdS)z-Check if this class can define a named tuple.TNrxF)ris_named_tuple tuple_typerrrOrYrrrrPrMrNrHrSrrr{save_namedtuple_bodyrX)rOrr[r~rdecos rPrOz,SemanticAnalyzer.analyze_namedtuple_classdef s. I  (  $ $DI$899 "N$(IDD#'#<#X#Xd'););)=)=$$ ND  |$$TY5555&&tT&EEE$$T9555**4000Z++DI66== $SS D)));;D$)TRRRR2GGMM==66t<<<=============== =============== 4us7 F!77GGN F{55nEEFDt~tDDEEE- A AI229==I A{66yAAADy$??@@@-T22    0 ; ; ; ; ;  rRexprcDt|tr||jSt|tr||jSt|t r,|jr|jS||}|r|jSdSrT) r~r=rrr[r?rqrrlookup_type_noderOrres rPrz&SemanticAnalyzer.get_fullname_for_hookOs dH % % $--dk:: : i ( ( $--di88 8 g & & $} %}$''--C $|#trRch|jD]}||dSrT)keywordsrr)rOrrfs rPrHz'SemanticAnalyzer.analyze_class_keywords_s>]))++  E LL      rRcx|j|j|jd|jt |jd|jd||_|j tdS)Nrr) r/rrVr)r+rr,r4r.r2rBrs rPrzSemanticAnalyzer.enter_classcs ty))) 4     ,,, ### q!!!  !!#%%(((((rRc<|j|j|j|j|j|_|jdS)zRestore analyzer state.N)r,rr4r)r+r/r.r2rUs rPrzSemanticAnalyzer.leave_classms    _((**       rRc|||||j|t|trB|jt vr2|jjrd|j_dS| d|dSdSt|tr;t|j tr#|||j_dSdSdS)NTz9@runtime_checkable can only be used with protocol classes)rr{rr~rqrrr/r1rVrr=rrrrr )rOrrs rPrWz(SemanticAnalyzer.analyze_class_decoratorvs ++D$)YGGG i ) ) `!%;;;9(a15DI...IIY[_````` <;  8 , , `1C  72 2  `261T1TU^1_1_DI . . . ` ` ` `rRct|tr d|_dSt|tr d|_dS||x}d|jd||_dSdS)zvCommon method for applying class decorators. Called on regular classes, typeddicts, and namedtuples. TNzclass r)rrrrrrrrr)rOrrrrs rPr{z/SemanticAnalyzer.analyze_class_decorator_commons i)> ? ? S DMMM  +@ A A S&*D # # # // :::j GRt}RRjRRDOOOH GrRrB4tuple[list[Expression], list[TypeVarLikeType], bool]cg}g}d}|jf|jD]^}||j|}|Jt|jt sJ||j|jf_t|D]h\} } t| trd| _ | |  | | } n#t$rYZwxYw| | } | | d} || dz}|rM|jr0|r|d|n-|d|n|d||| || t| t rR|| j| }|5|j.|jjt&vr| |vr|| d}j|||}|r t+t-|t+|kr|js|d |t-|}t/|t/|s|jrRt3t/|t/|z }|jd |D|n|d |t-||z}n|}t9|D]*} |j|j| || =+|||}|||fS) 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). FNTrrz/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[...]cg|] }|d SrrA)rCrs rPrDzLSemanticAnalyzer.clean_up_bases_and_infer_type_variables..s4442A444rRzMIf Generic[...] or Protocol[...] is present it should list all type variables) rlookuprr~rrrrrwvalidanalyze_type_exprrr!analyze_class_typevar_declarationrrrrbrrrget_all_bases_tvarsrrrBissubsetryrDrzrrCrBtvar_defs_from_tvars)rOrrBrr declared_tvarsr1rtrrrr?r9tvarsre all_tvars undeclaredr[s rPrFz8SemanticAnalyzer.clean_up_bases_and_infer_type_variabless  *, > %^ ; ;{{16733'''!$)_=====%%qvty&9::::%o66 + +LAy)X.. '"&   " "9 - - - 33I>>'    ;;DAAF!q vay( ! ~&W II&WY`aaaa II&LgVVVV WY`q!!!%%e,,,$ ,, +++DIt<<?sx';x(N::q?O?Oq)))&* ,,_gFF  ';~..//#n2E2EEEdnE UW^___(88Ny>>**3~+>+>?? I> !'I^9L9L(L!M!MJH??44444gII= "-^i-G!H!H&N'"" # #A  ( / /0DQ0G H H H""--ngFF  ;66s;C CCr?#tuple[TypeVarLikeList, bool] | Noneczt|tsdS|}||j|}||jdS|jjdks|jjt vr|jr|jjdk}g}d}|jD]}|}| |} | rLt| dtr|r| d|ad}| | y| |s#| d|jjz|||fSdS)zAnalyze type variables declared using Generic[...] or Protocol[...]. Args: base: Non-analyzed base class Return None if the base class does not declare type variables. Otherwise, return the type variables. Nztyping.GenericFrz.Can only use one type var tuple in a class defTz&Free type variable expected in %s[...])r~rrbrrrrrrdranalyze_unbound_tvarrrrr) rOr?unboundreis_protorhave_type_var_tupler rrs rPrz2SemanticAnalyzer.analyze_class_typevar_declarationsi$ ,, 4##GL':: ;#(*4 H !1 1 1x N22 3x(,< s"$%o66 ) )LAy77 BBDD+H"55d;;  Z(((5!!!s 2 ??rcg}d}|D]\}}|jt||j||_|j||}|T|s@|j|j||ttj |_n|r|j}| ||SrT) rrrrr0bind_new has_defaultrDtvar_without_default_typerrrFr)rOrrr[last_tvar_name_with_defaultr tvar_exprtvar_defs rPrz%SemanticAnalyzer.tvar_defs_from_tvarsN s,. 26#$ ' 'OD) ) 1 8 8(y~wGG!!I //i@@H*6x?S?S?U?U622M#>$+9+?#@#@  %%'' <.6m+   X & & & &rR type_exprscHg}|D]S} ||}n#t$rY%wxYw||}||Tt |}g}|D]5\}}|j||} || 6|S)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. )rrrrrr0rr) rOrrrr?rr[rrrs rPget_and_bind_all_tvarsz'SemanticAnalyzer.get_and_bind_all_tvarsb s# % %I 33I>>'    11$77J LL $ $ $ $E"" $ ' 'OD)//i@@H   X & & & &s  ++rycL|js||j|_|p||}||_||_|s@|s ||j|_n |j|_|j}d|vr|dd}| ||j|| rd|jjvr<|jjdzt|j z}|j dz|z|j_n |jj}|jj|_|jjs |jjr|||jdSt#t$|j|j|<dSdS)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). @rr|N)rrrrrmake_empty_type_inforrrrris_nested_within_func_scoperrrr~rzadd_symbol_skip_localr}r%r&)rOrrry local_name global_names rPrPz"SemanticAnalyzer.prepare_class_defy sy / // ::DM:444T::DDIDI /))++/%)%8%8%C%CDNN%)YDNY *  #))#..q1J  DIt444  + + - - M$)---"ins2S^^C &*o&;k&I ###in  I/DMy' M49+C M**; BBBBB,;D$),L,L [)))' M MrRc,|rH|jdkr=|jtvr/|j|jj}t |tsJn7tt||j}| ||Srq) is_module_scoperrrr&rr~rr|set_line)rOrrs rPrz%SemanticAnalyzer.make_empty_type_info s  " " :-- 111 < */DdH-- - - - -KMM4AAD MM$    rRcBt|tr|jSt|trt |St|t r||jSt|tr||j SdS)zQTry finding a short simplified textual representation of a base class expression.N) r~rerrbrr[get_name_repr_of_exprr?r=rrOrs rPrz&SemanticAnalyzer.get_name_repr_of_expr s dH % % 9  dJ ' ' 2+D11 1 dI & & 9--di88 8 dH % % ;--dk:: :trR7tuple[list[tuple[ProperType, Expression]], bool] | NonecJd}g}|D]}t|tr|jttzvsBt|t r.t|jtr|jjtvrq ||dd}nb#t$rU| |}t|t rd}nd}|r |d|dz }| ||d}YwxYw|dSt|}| ||f||fS) 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)r%allow_type_anyzUnsupported dynamic base classInvalid base class "r@N) r~rqrrrrr=rexpr_to_analyzed_typerrrrr)rOrBis_errorrZrr?rrDs rPrIz%SemanticAnalyzer.analyze_base_classes ss(" ," ,I9g.. &*@<*OOO9h//Py/99P$-== 11d2(   11)<<i22/:CC.C(<<<<'C #y))) |tt"4((D LL$ * + + + +hs9BAC10C1#list[tuple[ProperType, Expression]]clg}|j}|D]\}}t|tr-|||}||n%t|t r8|jjr|d|||nt|trT|j j r@t|ttfr d|jd}nd}|||d|_not|t r||jn?d}||} | r |d| dz }|||d|_|j jrTt)|rEt|ttfr d |j} nd } |j| ||t/||j |j|j| |s2|jd kr'||||_||s||jd S||s||j| ||jd S)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_classrrrV is_newtyperrr"disallow_subclassing_anyrerbrrQrrnrdisallow_any_unimportedrrDunimported_type_becomes_anyrr\rrr/rZverify_base_classes set_dummy_mroverify_duplicate_base_classes set_any_mrocalculate_class_mro) rOrrZr^rr?r actual_baserDrprefixs rPrTz'SemanticAnalyzer.configure_base_classes s&( y$! ! OD)$ ** ,"==dDII !!+....D(++ ,9'AII94@@@!!$''''D'** ,<8.!)h -CDDJZ ZZZIIIc9---'+$$D-00 ,!!$-0000*11)<<(<<<<'C #y)))'+$|3 N8TUY8Z8Z Ni(J)?@@):).::FF(F44VT9MMM "dlD$>R[       2dm/@@@   d..00 1 1 1 ''--    ty ) ) ) F11$77 (   TY ' ' '   t'788888rRrrc|j}|jr<|jkr1t|js|d|d|_|jr;t|jjr"|dd||jk|| |j j j dkr-ts| tfdj S)Nz3Class has two incompatible bases derived from tupleTz tuple baserr&c"tSrT)r)r?srPz=SemanticAnalyzer.configure_tuple_base_class..F s+;+;TBBCCCCC D D D DsAAAcd}t|jdkr|jd}t|trt|jt rz|||jjdvrWt|jdkr?td|j Dr!|jd}|jdd|_d}|j D]}t|trt|jt rg|j ||jjdkr=t|jdkr%|j dtkr|jd}n|j||hdhz }t|dkrdSt|dkr|d|dS||_dS)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|]}|tkVdSrT)r!rCr.s rPrzQSemanticAnalyzer.infer_metaclass_and_bases_from_compat_helpers.. s&LLDGOLLLLLLrRzsix.add_metaclasszMultiple metaclass definitions)rrBr~r=rrqrrrrdrr%rrr!rKrr)rOrwith_meta_exprr add_meta_exprdec_exprmetass rPrEz>SemanticAnalyzer.infer_metaclass_and_bases_from_compat_helpersj s-1 t# $ $ ) ),Q/I)X.. >:i>NPW3X3X >&&y111$- IN++q00LL 8KLLLLL1&/^A%6N+4>!""+=D(,0   H(H-- *X_g2V2V &&t,,,O,0CCCHM**a// *1-88$,M!$4ME?4&H u::?? F u::>> II6 = = = FrRc|j}d}|jD]7}|j}|||r|d|d}8| S)NFzCycle in inheritance hierarchyT)rrZrV is_base_classr)rOrrcycler?baseinfos rPrz$SemanticAnalyzer.verify_base_classes sayJ  DyH!!$11  :DAAAyrRct|j}|r|d|jd|| S)NzDuplicate base class "r@)find_duplicaterdirect_base_classesrr)rOrdups rPrz.SemanticAnalyzer.verify_duplicate_base_classes sOTY::<<==  B II:sx:::D A A AwrRsc|g}|h}|re|}||krdS|jD]?}|j|vr4||j||j@|edS)z9Determine if t is a base class of s (but do not use mro).TF)rrZrVradd)rOrr worklistvisitednxtr?s rPrzSemanticAnalyzer.is_base_class s3# +,,..Caxxt  + +9G++OODI...KK *** +urRmetaclass_exprExpression | None"tuple[Instance | None, bool, bool]c(d}|r d}t|tr|j}n$t|trt |}||d|d|dS|||}|dSt|jtr^tt|jj tr2|j j r$|d|jjd|dSt|jtrdS|j}t|jtrM|jjsA|jjs5t|jj}t|t&r|j }t|t(r|j|d|d|d S|s|d |d St/|}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@NFTzClass cannot use "z!" as a metaclass (has type "Any")r!zInvalid metaclass ")NFFz8Metaclasses not inheriting from "type" are not supportedF)r~rerrbrrrbrrrrVrr"rrnr rfrlrrrr is_metaclassr) rOrrr`rremetaclass_inforrs rPrJz'SemanticAnalyzer.get_declared_metaclass s?" , &!N.(33 J!/!4NJ77 J!9.!I!I% I$III>ZZZ((''GGC{((#(C(( )Z 8V8VX_-`-` )<8II]SX]]]]&)(#(O44 )((+.(N38Y// 17 1, 1 )99fh//1%+[Nnh77 *>;T;` AAAA>RRR))!..00 * NP^*) 00DdH-- - - -!% !5%//rRr`Instance | Nonec||j_|j|j_t d|jjDrJ|jjr|jjjjdkr$|dg}| ||j_|jjrO|jjj dr-d|j_ |j r| d|dSdSdSdS)Nc3$K|] }|jV dSrT)r1)rCrs rPrz9SemanticAnalyzer.recalculate_metaclass.. s%::Dt::::::rRr_z abc.ABCMetaz enum.EnumMetaTzEnum class cannot be generic) rr`calculate_metaclass_typemetaclass_typerrurVrrrhas_baseis_enumrr)rOrr`abc_metas rPrUz&SemanticAnalyzer.recalculate_metaclass s'9 $#'9#E#E#G#G  ::DIM::: : : 8I, 89+09_LL 22="EE'/7DI, 9 # @ (@(E(N(N(_(_ @ $DI ~ @ 8$????? @ @ @ @ @ @rRrrWc||_|jD]\}}|j o |jj}| |}|}|p||k}n|dd}|}|}||jvro|j|}|rt} n|j t} nt} t| ||| } | || ||| |||||| dS)Nr|rrrrrr)rrrr)r:idsrYr"implicit_reexportrr%rr)rVr*r%r}add_imported_symboladd_unknown_imported_symbol) rOrras_iduse_implicit_reexportbase_id imported_idrrr.symbols rP visit_importzSemanticAnalyzer.visit_import sS& & IB)-(9$9$\dl>\ ! # 5 Du ((3--*% 5 $,&&|G,%%'' DDY*DDD($m}K\(("/&3"3 )00 '"/&3"3 1A& & rRimprZc h||_||}|j|}|jD]\}}|dz|z}|||d}n||jkr*||jvr!tt|j|}nJ||cxkrdkr#nn ||j vr|j ||j dd<|j|}d}|p|} |j o |j j } | p |duo||k} |sL|j|} | %|} t| | }n ||jvrd}|rT|sRd|jvrI|dz|z}||jd| |}|r|| ||| | q|rB||||| || ||jr|||| | | |d|r |s|||| | | | || ||| | dS) Nr|rFT __getattr__rr:)rrrr$rrrrrr)r:rr%rrqset_future_import_flagsrr}r%rFrErYr"r"current_symbol_kindr<create_getattr_varrprocess_imported_symbolrreport_missing_module_attributer$)rOr+ module_idmodulerr%rrrmissing_submoduler(r&rmodr.gvars rPvisit_import_fromz"SemanticAnalyzer.visit_import_from7 s&0055 !!),,S S IB 3+H  ( ( 2 2 2~do--(dl2J2J 'tT\(-CDD++++)+++++ T_0L0L*./)*DD$QQQ'|''++ % +2K )-(9$9$\dl>\ !1Xe46G6WBRWKM -l&&x00?3355D*455DD!555(,% d } 'D'D%s?R/..v|M/JKYabbOO#&3*7&7 $ ,,)Rh WZ-% 88!#&3*7&7 #499  1 44"/&3"3 500 ("/&3"3 1[S S rRr}r5rr(rrYc~| oAt|jt p&||jvp||jdz }t|jt rC|jr|||||||dS| ||j||d| |||||dS)Nr|r.T)rrr8r) r~rrcr% startswithrrnr_r4rr#) rOrr5rr(rrrrrs rPr3z(SemanticAnalyzer.process_imported_symbol s*) 49h// / >t|+ >&&t'<===  di 1 1 # 44"/"/# 5$$I"/"/%) %   wmS` !     rRT import_id source_idrrfr$c||r|||||dSd|d|d}|j|} | r|| jvr| j|js d|d|d}nht| j|h} t|| d} | rdt| d d } || z }| ||tj |r|||d|| |d krd|} || &| t"vr|j| |dS|jd}|r_||jvrX|jd|d|tj |jd|tj dSdSdSdS)NrzModule "z" has no attribute "r@z(" does not explicitly export attribute "r)rz; maybe or?rr/rorrpz#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%rrqkeysrrB differencerrrr& ATTR_DEFINEDr$rrrrDadd_fixture_noter)rOr=r>r(rrrr$messager6 alternativesmatches suggestionrrrps rPr4z0SemanticAnalyzer.report_missing_module_attribute s  ' ' 2 2   WMQ^ !    FHYHHIHHH!!),,  /FL--//// Y8O8]/^y^^R[^^^ #6<#4#4#6#677BBI;OO &y,!DDD/!HJw,E,E!H!H!HJ*.G '7); <<< &   , , +"// -     69??#4#466H33H==E 777))(G<<<<<$(L$4$45H$I$I!$ 6G6M)M)MHMMRiRRR"/" HMMC"/"# !   )M)MrRexisting_symbol module_symbol import_nodec4|j|jurdS|jtttfvrt |jt ttttfrt|}|j|_|j|_t|}|j|_|j|_t |jtrd|_ t|g|}|||fD]}|||j|dSdSr)rr.r)r%r*r~rrRrrFr reis_alias_rvaluer8r assignmentsr) rOr(rKrLrMlvaluervalue assignmentrs rP!process_import_over_existing_namez2SemanticAnalyzer.process_import_over_existing_name s  =#5 5 55  D$#5 5 5*  39i"P; ; 5 k**F).FK).FKk**F',FK',FK&+y11 .*.&'&99J"FF2 + + k****  # * *: 6 6 64urRImportFrom | ImportAllct|j|j|j|j\}}|s|d||S)Nz*Relative import climbs too many namespaces)rrrelativerr#rr)rOrr=oks rPrz(SemanticAnalyzer.correct_relative_import sY/ OT]DGT5F5[5[5]5]  2 J IIBD I I IrRrXc(||}||jvr|j|}||r|d||jD]\}}|dz|z}|||jrv|dr d|jvrXt|j tr$|j |j j||||dddSdS)N*r|r@rTFr )rr%rBrrqrr0rr<r~rrcr7r rrr#)rOri_idmrrrrs rPvisit_import_allz!SemanticAnalyzer.visit_import_all' s3++A.. 4<   T"A++D11 -$$S!,,,gmmoo   d#:,,,X666%ts/C/CyTUT[G[G[!$)X66= (();<<<,,dATQV-   DrRr7c|j||r||sdS||jdddS)NT)escape_comprehensionshas_explicit_value)rfrrcheck_valid_comprehensionanalyze_lvaluerrOr s rPvisit_assignment_exprz&SemanticAnalyzer.visit_assignment_exprE si t      11!44  AHDUYZZZZZrRctt|jD]d\}}|tkrT|t |jdz kr9|jd|z '|d|tjdddSnedS)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. rrNzKAssignment expression within a comprehension cannot be used in a class bodyT)rseriousrF) rrr+rrr)rr&SYNTAX)rOr r scope_types rPraz*SemanticAnalyzer.check_valid_comprehensionL s'x0@'A'ABB  MAz000QT[9I9IA9M5M5M;rAv&.II:"\ $ $ !55trRr8c||_||rdS|}||r\|j}d|_|5|j|dddn #1swxYwY||_nv||rG|5|j|dddn #1swxYwYn|j|| |s| |jr/t|D]}| |j |dS||rF|5|j|dddn #1swxYwYd}||r d|_d}nt!|jt"r||rd}n||rd}n|||rd}nd||rd}nL||rd}n4|j|rd}n||rd}|r||dSd|_|||_||||||| ||!||"||j#s!|$|j%|j||&||'||(|dSr!))r:"analyze_identity_global_assignmentrcan_possibly_be_type_formrJrerRr'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_hookrVprocess_module_assignmentrprocess__all__process__deletable__process__slots__)rOr rold_basic_type_applicationsrrs rPvisit_assignment_stmtz&SemanticAnalyzer.visit_assignment_stmtb s  2 21 5 5  F((**  ) )! , , "*.*F '+/D (--// & &%%% & & & & & & & & & & & & & & &+FD ( (  9 9! < < "--// & &%%% & & & & & & & & & & & & & & & HOOD ! ! !  $ $S ) ) T-A-A!(-K-K 5Q77 6 6$$TY5555 F  ) )! , , &--// & &%%% & & & & & & & & & & & & & & &  + +A . . $!ANLL ( + + $//22 $# 33A66 $# 66q99 $# //22 $# ..q11 $# &BB1EE $# ))!,, $#    + +A . . . F**1-- Q %%a((( """ A $$Q''' %%a(((v C  * *19ah B B B A !!!$$$ a     s6*BBB C44C8;C8!GG G ct|jtrt|jdkrdS|jd}t|tr|jj|jkrdS|j|rdS|j}|||}||j rdS| dS|j dS||j vr| ||j |t|j ts5|j|fD]+}|j |_ t|_|j j|_,dS)zSpecial case 'X = X' in global scope. This allows supporting some important use cases. Return true if special casing was applied. rFrNT)r~rRrerrrrVrrr_rrr&rrnr%r.rr)rOr rQrrers rPrjz3SemanticAnalyzer.analyze_identity_global_assignment s?!(H-- QY11D1D51&(++ qx} /K/K5 9 D$6$6$8$8 5{kk$"" ;# u txu4<''ch222ch88 6Hf,66D #DI $DI$'H$5DMM4rRrvc|jrdSt|trF||j|}|r(t|jt r|jjsdSnt|trTt|}|rB| ||d}|r(t|jt r|jjsdSnt|tr4t|j tr||j St|tr4t|jtr||jSdS)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. FTr])r_r~rerrrrnr8rbrrbr[r?rqrmr=r)rOrrfnames rPrmz SemanticAnalyzer.should_wait_rhs sS   5 b( # # 3 BGR((A Z88 AX t J ' ' 3,R00E ))%T)JJ AFO<< QVE\ 4 I & & 3:bgw+G+G 3''00 0 H % % 3*RY*H*H 3'' 22 2urR allow_nonect|tr||drdSt|tr||jdrdS||rdS|r"t|t r |jdkrdSt|trN|j dkrC|j rdS| |j dr| |j drdSdS)zIs this a valid r.h.s. for an alias definition? Note: this function should be only called for expressions where self.should_wait_rhs() returns False. T)bareF builtins.None|)r)r~rq is_type_refr[r? is_none_aliasrerrrioprYcan_be_type_aliasleftright)rOrrs rPrz"SemanticAnalyzer.can_be_type_alias s) b' " " t'7'7'7'F'F 4 b) $ $ )9)9"')9)N)N 4   b ! ! 4  *R22 r{o7U7U4 b& ! ! besll  t%%bg$%?? DDZDZTE[EE turRct|jdkrdSt|jtrBt|jjt r#|jjj}|tvp|tvSt|jdtsdS|j | |sdSt|jttfsdSdS)aLike can_be_type_alias(), but simpler and doesn't require fully analyzed rvalue. Instead, use lvalues/annotations structure to figure out whether this can potentially be a type alias definition, NamedTuple, or TypedDict. Another difference from above function is that we are only interested IndexExpr, CallExpr and OpExpr rvalues, since only those can be potentially recursive (things like `A = A` are never valid). rFrNT)rrr~rRr=rrqrrrrrerV is_pep_613r[rirOr refs rPrkz*SemanticAnalyzer.can_possibly_be_type_form s qy>>A  5 ah ) ) Hj'.R.R H(/*C,&G#1G*G G!)A,11 5  (1C1C (5!(Y$788 5trRcJt|jdks t|jdtsdSt|jt rt|jjtsdS|jj}|||jtvS)z1Check if r.h.s. can be a TypeVarLike declaration.rrF) rrr~rerRr=rrrrrrs rPrlz8SemanticAnalyzer.can_possibly_be_typevarlike_declaration* s qy>>Q  j1x&H&H 5!(H-- ZQY5Z5Z 5ho 4|222rRrcFt|tsdSt|jtr!|d|jd|dS|rhd}nt }t|jts |j|vrdSt|jtr|rdS|jj St|jtr|jjtvSt|trF| |j|}|r(t|jtr|jjrdSnht|t"rSt%|}|rB|||d}|r(t|jtr|jjrdSdS)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.AnyTr])r~rqrrrrrrr rrrrrerrrnr8rbrrb)rOrr valid_refsrrs rPrzSemanticAnalyzer.is_type_ref4 s$"g&& 5 bg / /  IIZ ZZZ\^ _ _ _5  +KJJJJ*J bgy ) ) R[J-F-F4 bgx ( ( ' tw& & bgs # # 37#{2 2 b( # #  BGR((A Z88 QV=T t J ' ' ,R00E ))%T)JJ AFO<< AX 4urRct|trt|jtrt |jdkrt|jdtr||jj|j}||jdj|jd}|2|jr+|jj dkr||jr|jj dkrdSdS)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. rrNr_rTF) r~r=rrerrdrbrrrr)rOrcallr s rPrzSemanticAnalyzer.is_none_aliask s dH % % 4;11  NNa''ty|X66(,,T[-=t{KK++DIaL,=ty|LL$ % *o==()_<<4urRc|jd}t|tsJd|_|t kr||j|_||_ dS)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_formr1r%rrrrr.)rOr rQs rPrxz+SemanticAnalyzer.record_special_form_lvalue sr 1&(+++++!%  # # % % - -"11&+>>FO..00 rRct|jtr4t|jjtr||S|j||S)zCheck if s defines an Enum.) r~rRr=r4rK_is_single_name_assignmentrprocess_enum_callrrcs rPrwz$SemanticAnalyzer.analyze_enum_assign sg ah ) ) 6j9JL.Y.Y 622155 5&88D>Q  j1*?U&V&V 51 fj ) ) !(H-- Z*QX_g2V2V Z8?37778G];];]IIPRXYYY5{''--  " "4?#>#>y#I#I J J  -1-F-W-W$ 2 2 4 4.. *M4$          $$ MTTmH)           6$$T6D$IIII$$TY :::**49555+                  s %;J-AJ> : 66q999 qy>>Q  j1*?U&V&V 51{''--  " "4?#>#>y#I#I J J  -1-E-U-U$ 2 2 4 4.. *M4!           &*--  H&QQQ         1$$T6D$IIIIy$$T9555**4000!                  s;G;',G; AG;;G?G?crt|jdkot|jdtSr)rrr~rercs rPrz+SemanticAnalyzer._is_single_name_assignment s*19~~"Iz!)A,'I'IIrRcX|jdu}||jr*t|jtsJ|jjsd}|jr+t|jt r|jj }nd}nd}|jD] }| |||j |!dS)NFT) explicit_typerr`) rV is_final_typer~rrdrRr~no_rhsrrbrz)rOr explicitr`lvals rPr{z SemanticAnalyzer.analyze_lvalues s$D0   a/ 0 0 !a/== = = =$) !  8 '!(H-- *)*%8""%)""!& I  D   &#5       rRc t|jtsdSd}|j} t|jtr |jj}|st|jt r|jj}t|tr!|jr|jj}|jdz|z}nt|trSt|j tr9t|j tr|jj}|j jdz|z}nt|tr|} |sdS|j |}|sdS|jD]7}t|t s|t#||j|8dS)Nr5Tr|)r~rRr=rrqrrrbrrr[r?r4rr9get_dynamic_class_hookrrer)rOr rr callee_expr method_namerrs rPrz)SemanticAnalyzer.apply_dynamic_class_hook s!(H--  Fx $+w// - , Z Z@@ "k. k733  8L "&+"2K'036DEE{I66 ";#3W== #;#7II  #'+"2K',5;kIEE X66&D   F{11%88  FI @ @DdH--  D'di>> ? ? ? ? @ @rRc|jr||jsdSt|jtsJt |jjdkr|d|jd}|jjsYd|_t|jtr7|jj r+|jr |jj sd}|d|n|jjd|_|jB|j j dkr2||jr|d |dSt |jdks t|jdt s|d |dS|jd}t|t sJ|jr|jdu|_|jd dkr|d ||jr:|jjr.|r|j|t|jtrC|jj r7|js0|s|s|j|dS) 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)rVrr~rrrdrrVrRr~rr~r"rrrrq is_new_defis_inferred_defr4r1rrDrrYfinal_without_value)rOr invalid_bare_finalrs rPryzSemanticAnalyzer.unwrap_final#s  (:(:1;L(M(M 5!+[99999 q % & & * * IIBADU V V V" % /AF18X.. bHO b  b(,y'?  b &*" ]_`aaa&+A.AF F  +g55  ((6 IIUWX Y Y Y5 qy>>Q  j1w&G&G  II11 5 5 55y|$((((( ? 2#$6T>D ?2  " " II6 : : : 9 ;. ;""$$ ;77::: qx * * 0 0% 0''))  0 & 0,,Q///trRcr|jsdS|jd}t|tsJt|trr||s|d|d|_dS|jsJ|jdjdkr!|d|d|_dSdSdS)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 selfFrrQz=rRc|jrt|jdkrt|jdtr|jdj}t|t rtd|_|jrt|j |j |_ | r5t|j tr|j jrd|_dSdSdSdSdSdSdS||jD]}t|t$rt|jt&r|jjr|jj|jd}|rkt|jt rQt|j tr |j js+t1|jj x|j_|_t|t2r||r|js Jd|jj|jd}|rt|jt r~|jjrr|jsJ|jd}|jdkrQ|jjrE|jjs9t|j tr |j jsd|j_d|_dS)zRIf this is a locally valid final declaration, set the corresponding flag on `Var`.rrTNSelf member outside a classrrQ)rzrrr~rqrrrrVrrRr final_valuerr~rfinal_unset_in_classflatten_lvaluesrerrrqrrrrbrr1final_set_in_init)rOr rrcur_nodecurrent_functions rPr}z#SemanticAnalyzer.store_final_statusys >7 219~~""z!)A,'H'H"y|(dC((9$(DMvY+=ah+X+X(**,,9"18X669;<8?959111#"""99999999 ,,QY77+ 2+ 2tX.. d"49h77 d ) d $y2249dCCH d&x}c::d",AHh!?!?dEFHOdGPPXP]PbFcFcBcc . dJ// 2D4K4KD4Q4Q 29CC&CCCC#y2249dCCH 2Jx}c$B$B 2x}G] 2#2222+/+>r+B(,1Z?? ( B@$,M$C@&0(%C%C@IJ@ ?CHM;-1ANW+ 2+ 2rRrcg}|D]a}t|ttfr.|||jL||b|SrT)r~rr_rrrr)rOrreslvs rPrz SemanticAnalyzer.flatten_lvaluessh "  B"y(344  4//99:::: 2 rRc|jr|jd}t|t}||j|}|t |r||dS||_|jrm|jjrat|trLt|j tr2|j j r&t|j tr d|j _n,|jrK|jjr?||r*|s|d|t%|jdkrt|jdt&r|jd}d}|jr^t|trIt%|jjdkr,|jjd|jdu}|r,|jr%||j |j|_|jr%|jD]}|||jdSdS)z5Analyze type annotation or infer simple literal type.rr)NTz8All protocol members must have explicitly declared typesrr)rVrr~rrrrr1rerRr~rrris_abstract_varis_annotated_protocol_memberrrrrqrurrranalyze_simple_literal_typerzstore_declared_types)rOr rQr)r4ref_exprsafe_literal_inferences rPrz(SemanticAnalyzer.process_type_annotationsN 6# XYr]F",VY"?"? ~~afBU~VVH?8#<#< 1 AF  7I) 7vx00 7qx22  7 HO  7fk3//726FK/  YI) Y55a88 Y**,,  Y  TVWXXX19~~""z!)A,'H'H"9Q<)-&9YHh!?!?YC DVDVYZDZDZ.2Y]1-=-A-A(--P-PTX-X*)Xh.FX!==ahWWAF 6 :) : :))&!&9999 : : : :rRc>td|jDS)zCheck whether a protocol member is annotated. There are some exceptions that can be left unannotated, like ``__slots__``.c3dK|]+}t|to|jdko|jV,dS) __slots__N)r~rerr)rCrs rPrz@SemanticAnalyzer.is_annotated_protocol_member..sT  H % % W"'[*@ WREW      rR)rrrcs rPrz-SemanticAnalyzer.is_annotated_protocol_members4  i      rRrRr Type | Nonec|jrdSt||j}|t|trdSt|t rd}nGt|t rd}n/t|trd}nt|trd}| |}|r'|r%| t||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)rfrn)last_known_value) r1rrr~complexrintrfloatrrr)rOrRrrf type_namers rPrz,SemanticAnalyzer.analyze_simple_literal_types    4"64?;; =Jug66=4 eT " " )'II s # # )&II s # # )&II u % % )(I%%i00  ^8 ^$$kX[6\6\6\$]] ] rRr%declared_type_varsTypeVarLikeList | Noneall_declared_type_params_nameslist[str] | NonerfDtuple[Type | None, list[TypeVarLikeType], set[str], list[str], bool]c<t|jo|jd}|j o|j } t ||j|j|j} nE#t$r8| d|tj dgtgdfcYSwxYw| | } g} ||} || n|} ||j| 5|| | } |rA|5||dddn #1swxYwYt+| ||j|j|j|j|j|||| || \}}dddn #1swxYwYg}d}| D]1}t3|t4r|rd}||2d | D}t3| t8r| jnd}|||||fS) 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'} rrbz2Invalid type alias: expression is not a valid typerNF)r%in_dynamic_func global_scopeallowed_alias_tvarsalias_type_params_namesrfTc"g|] \}}|j SrArp)rC_namers rPrDz2SemanticAnalyzer.analyze_alias..SsLLL[UD4=LLLrR)rr1 is_dynamicrVrr"rYrbrrr&r'rBrrrr0rrrerrr9r#r\r~rrrempty_tuple_index)rOrrRr%rrrfdynamicrrfound_type_varsr[ralias_type_varsr4 depends_on new_tvar_defsvariadictdqualified_tvarsrs rP analyze_aliaszSemanticAnalyzer.analyze_aliass&t*St/B2/F/Q/Q/S/STT9}@T-@)@  .) d&7$J_CC$ . . . IIDfSXSc    SUUB- - - -  . 22377+- ''-- -?-G//M_  " "4?#>#>y#I#I J J  11/3GGI% (1133((MM$'''((((((((((((((($6  !*"3 ')$-(F'=$$$ Hj               0  % %B".//    $ $ $ $LLOLLL5?[5Q5Q\C11W\ OEVVVsH"A((?B*)B* -F*9E F*E F*"E #;F**F.1F.c|jNt|jtr4||jj|d}|r|jt vrdSdS)NTr]F)rVr~rrbrrrr)rOr rs rPrzSemanticAnalyzer.is_pep_613Ws]  (Z8I;-W-W (**1+<+A1VZ*[[F &/-===turRc |jrdS|jd}t|jdkst|tsdS||}|s |jdS||j|j r2|jj d}d}| |j\}}n |j}d}d}d}t|tr |j rdS||j }|rt|jt"sUt|jt$r|jr4t|jt(rk|jjj|jkrQt|jt$r5|js.|d|j |dS|jp|} |s|st|t4r| rdS|s|s||sdS|r#t|jt(t$fsdSd} ||r#t;} g} t=} g} d}n|}| |j |d||\} } } } }| sdS|s+t| tBot| tD}ntG| }|$|s|r|%|j |d dS|&| |&| tO| |j(|j)|j*| tW| } |j(j,rIt[| r:tG| s+|j*.d | |t_| } t| tBo"t| t`o | j o| o| }t| tBrNt| t`r9tc| |j|s#te| |j|j3d|j( |}t%| |4|j |j|j5| ||| }t|jtlttnfrt|tnr|j(j8dks|j9ret|jj ttstu||j_ |j|jj _| j5|jj _5n&t|jt4r d|j_;|rd}t|jt$rC|jj<| kr2| |j_<| |j_=||j_>d}d|j_?n ||_d}|r<|j@r|A|j d|dS|B|dn|C|j ||t|t4r+t|jt$r|jjD|_D|r|jn|}t|t$sJ|E|||j|Fr`|jJ|jjGrK|d||j dHs|3d|dS)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. TrrFNrzTCannot assign multiple types to name "{}" without an explicit "Type[...]" annotation)r%rrr7r:Type alias targetrrlreagerrf)r rrz.Type aliases are prohibited in protocol bodiesz9Use variable annotation syntax to define protocol members)Iinvalid_recursive_aliasrrr~rerrVcheck_type_alias_type_callrRrrdanalyze_type_alias_type_paramsr=r4current_symbol_tablerrrr rprnrrrrVrrqrrrrBrrrrrrrr,rr"r\rDmake_any_non_explicitrrrmake_any_non_unimportedrrrrrrr[rirrYrrOrrlr _is_recursiver_cannot_resolve_namerrr!disable_invalid_recursive_aliasesrr1isupper)rOr rQpep_613rRpep_695 type_paramsall_type_params_namesrnon_global_scoperrlrrrrincomplete_targetrrrupdated current_nodes rProz,SemanticAnalyzer.check_and_set_up_type_alias^s $ 41 qy>>A  Z%A%A 5//!$$ 1,85  * *18&+ * F F )X]1%FG151T1TUVU]1^1^ .K..XFGK$( ! fh ' ' FO 5,,..226;??   x}c * * 8=)44 =>^ 8=/:: @H}?Q?VYZY_?_?_(-33 AN  BBH&BUBU 59<(:(:(<(< w :fg+F+F K[ 5 w t/E/Ef/M/M 5  Jx} 6RSS 5   f % % **C13K#&55J)+O %  ,,..COSOaOa "&#./D PbPP LCj/;L u%%'' 9%/sJ$?$?%JEE!!%4C$8$8!((-- 1B $$V[&4$PPPt   ,,,   111 sDL$2Ldh`abbbb$C(( < / 34PQT4U4U 3"3'' 3445H#qQQQ-c22 sJ ' ' 3)) H  &%   c: & & b:c8+D+D b$S$)5FGG bS$)TYUTXT`aaaa""$$     , , F H##*     ahHf = > > ,66** , +w66$:K6ah/?? >$1*$=$=!%&VAH  "'*zAH  $ $ ' * * ,'+AH $  8G(-33 ='3..,/HM(0;HM-,3HM)"G26HM/!+  7'7,,V[&!DDD4JJqJ666 OOFKQ 7 7 7 fg & & ;:fk9+M+M ;$*K$:J !(0@x}}j , 22222 ..q,III     ^9(((y$ ^ JANNN{1~--//^IIY[\]]]trRTypeGuard[CallExpr]cHt|tsdSdg}|jjdkr|dt |jt|sdS||||sdS|j tdkrdSdS)NFtyping_extensions.TypeAliasType)r typing.TypeAliasTyperT) r~r=r"rrrrtuplecheck_typevarlike_namer%countr!)rOrRrrqs rPrz+SemanticAnalyzer.check_type_alias_type_call0s&(++ 523 < &' 1 1 LL/ 0 0 0!&-u>> 5**64@@ 5   ! !' * *a / /5trRr=!tuple[TypeVarLikeList, list[str]]cd|jvr\|j|jd}t|ts|d|ggfS|j}nggfSg}g}d}|D] }t|trd|_| | | |}n#t$rYWwxYwt|tsq| } ||d} | rEt| dtr)|r%|d|t jd}d}n|| s||j|} | r:t| jt,r || jjnT|d |t j| r0| jt2vr"|d |t j| |vr.|d | d d |t j| r0|| d ||  ||fS)zAnalyze type_params of TypeAliasType. Returns declared unbound type variable expressions and a list of all declared type variable names for error reporting. r zCTuple 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)rGrdindexr~rrrrwrrrrrrrrr&TYPE_VARrrbrrrrrrrr) rOrRtype_params_argr rall_declared_tvar_namesrtp_exprr?rrres rPrz/SemanticAnalyzer.analyze_type_alias_type_params@s F, , ,$k&*:*@*@*O*OPOoy99  Y#2v )/KKr6M*,-/#"0 ,0 ,G'8,, & %  " "7 + + + 33G<<'    dK00 ,,..C11$41PPD d1g'788 /*! d !&" /3+ *.'..s33 ++DIt<< :ch@@ +2238=AAAAII^"^ s|/@@@ H$UZUc"~%% cQccc  ,'..tAw777%%d+++666s'B== C  C AssignmentStmt | TypeAliasStmtrr ctxc<g}t|jtr-|jj|ur|d|jdnZt |h|jrDtt|jtrdnd}|d|dt||j|j |j r|d|r%ttj|_d|_|D]}|||d S) zEProhibit and fix recursive type aliases that are invalid/unsupported.zCannot resolve name "z" (possible cyclic definition)runionzInvalid recursive alias: a z item of itselfzAInvalid recursive alias: type variable nesting on right hand sideTN)r~rrrrrrrrrrbr0rrrFrr)rOr rr messagesrrDs rPrz2SemanticAnalyzer.disable_invalid_recursive_aliasessK |*M : : S#)\99 OOY (9YYY    ( 8K L L S%ol6I&J&JIVVc\c  OOQ&QQQ R R R ! ,-t/Ddo   a OO_ ` ` `  -"))*>"?"?L (,A %  C IIc3      rRrr`rrr_r` is_index_varc|rt|ts Jdt|tr|||||||dSt|trK||||||r-||s|d|dSdSdSt|tr/|r|d|||dSt|tr| ||dSt|tr8|r| |j ||dS|d|dS|d|dS)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)r`r$z;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_lvaluerwrbr)rOrrrrr_r`r$s rPrbzSemanticAnalyzer.analyze_lvalues* ! _dH-- ^ ^/^ ^ ^ ^ dH % % 9  $ $%#5) %     j ) ) 9  & &t]HFX Y Y Y _T%<%>> KK      i ( ( 9  - -dM B B B B B h ' ' 9 X##DIv}EEEEE PRVWWWWW II14 8 8 8 8 8rRrQrec|jrdS|j}||r<|r|d|n#|j||jdu||}||} | |} | |} |tkrt|jtr|jjr|ds| Nt| jt s4|d||jj||r.|r,|d||d|| rt| jt r| s |||| ||} ||| ||} | rd|_d|_||_| |_|t0kr | j|_n |j|_|rNt9|d kr;|jjs/t?t@j!}|"|||r.|#||r|d|dSdSdS|$|||dS) znAnalyze an lvalue that targets a name expression. Arguments are similar to "analyze_lvalue". N)Cannot redefine an existing name as final)r___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-membersTr@)%rris_alias_for_final_namerrDcant_assign_to_finalrVr1rris_global_or_nonlocalr*r~rrr<rnrrmake_name_lvalue_varrrrr.r%rrrrrr"rrrrris_final_redefinition&make_name_lvalue_point_to_existing_def)rOrQrrr_r`r$rr.rqrouterraddedrs rPr'z$SemanticAnalyzer.analyze_name_lvalues ;  F{  ' ' - - S S EvNNNN--dDIT4I6RRR''))))@U)VV99T??**400 DLL49h//  ! OOD))  #Jx}o,V,V# QXXdin  !3  A6JJJ b  YJx}oFF YPU Y++-/1C\COOD#vMbOccE ?$(!)-&" ! 4<<&)mFOO&,kFO%%''?~~,,T\5X,&i&<==11&#>>> OD66tTBB O EvNNNNN O O O O  7 7 x X X X X XrRr.rc|tkr+||o|| S|tkr%|jrt |dz|jjvSdS)N'F)r%is_mangled_globalis_initial_mangled_globalr*rVrrq)rOr.rs rPr1z&SemanticAnalyzer.is_final_redefinition(sd 4<<))$//\8V8VW[8\8\4\ \ T\\di\D>>C'49?: :urRc\|ru|dsdSt|}|jd Jd|jd|}|duot |jS|jQt|dz}||krdS|jj|}|duot |jSt|dz}||krdS|j |}|duot |jS)Nr6FrzNo locals at function scope) rrrr)rrrrVrqr&)rOrr orig_names rPr-z(SemanticAnalyzer.is_alias_for_final_name/s1      I==%% uD>>D;r?..0M...{2**400H4'HM(-,H,H H Y " ,Iy  uy**955H4'HM(-,H,H H ,Iy  u|'' 22H4'HM(-,H,H HrRinferredrcX|j}t|}||||_|tkr*|jJ|j|_d|_|tv|_ |tkr| ||_ n||_ d|_ ||_||_|S)z:Return a Var node for an lvalue that is a name expression.NTF)rrr is_inferredr*rVrr rallow_incompatible_overrider)rrrr`r$)rOrQr.r;r`r$rrs rPr0z%SemanticAnalyzer.make_name_lvalue_varEs{ II 6  4<<9(((YAF(,A %,04O,OA ) 4<<--d33AKKAK 1%rRc|r|d|||j|d}|:|jr3|s|j|j}|r||j||dS|r|||n||j|| |j |dS)zUpdate an lvalue to point to existing definition in the same scope. Arguments are similar to "analyze_lvalue". Assume that an existing name exists. r+Tr]N) rrrrVrrrbind_name_exprname_not_definedcheck_lvalue_validityr)rOrrrrks rPr2z7SemanticAnalyzer.make_name_lvalue_point_to_existing_defas  I IIA4 H H H{{49dD{II  DI d6H6H6J6J 9==33L  8  % %di| D D D D D 7##D,7777%%di666  & &ty$ 7 7 7 7 7rRrc|j}d|D}t|dkr|d|dSt|dkr d|d_|D]}||d|ddS)z?Analyze an lvalue or assignment target that is a list or tuple.c<g|]}t|t|SrA)r~rwrs rPrDzASemanticAnalyzer.analyze_tuple_or_list_lvalue..s'KKKt 40J0JKdKKKrRrz%Two starred expressions in assignmentTr)rrrr`N)rrrrrb)rOrrr star_exprsrs rPr)z-SemanticAnalyzer.analyze_tuple_or_list_lvalue|s KKuKKK z??Q   II=t D D D D D:!##&* 1 #  ##"/(, $  rRrbc|jrdS||||r|js Jd|jj|j}|j|j}|r|r|d||jsF|rDt|jtr*|jj r|r| |j|||jj r*|r(|&t|jtr d|j_ |.|&t|jtr |jj s||s|r|jj r||d|nd|_d|_t|j}||||j|_|j|_d|_|p||_||_||_t/t0|d|jj|j<||j|dS)zAnalyze lvalue that is a member expression. Arguments: lval: The target lvalue explicit_type: Assignment has type annotation is_final: Is the target final Nrr+Fz9Protocol members cannot be defined via assignment to selfT)implicit)rrrrVrqrrrr~rr=attribute_already_definedr1rrrrrrrrexplicit_self_typedef_varr}r*rB)rOrrrr`rrrs rPr(z&SemanticAnalyzer.analyze_member_lvaluesZ 9  F D  " "4 ( (/ Y9 ; ;; ; ; ;y**4955H9==++D MH M EtLLLI J Jx}c22 JM-  J "  J..ty$IIIy$ :); :@ThmS11:49HM1 $DIs)C)C$ Ha$$-$8$9(YT\IIY[_````'+DO+/D(DIAJJt$$$"&"5"5di"@"@AK!YAF!&AJ+8+DHA(#$DL !DI1@qSW1X1X1XDIODI. ""49d33333rR memberexprct|jtsdS|jj}t|to|jS)z1Does memberexpr to refer to an attribute of self?F)r~rrerrr)rOrKrs rPrz#SemanticAnalyzer.is_self_member_refs<*/844 5#$$$55rRExpression | SymbolNode | Nonect|tr|d|dSt|tr"|tj|dSdS)Nr&)r~rrrrCANNOT_ASSIGN_TO_TYPE)rOrr s rPrBz&SemanticAnalyzer.check_lvalue_validitysm dK ( ( C II13 7 7 7 7 7 h ' ' C II&>ND(--dH====>> FOOOOO  ) )   % %fk3 7 7 7 7 7 DrRc ||d}|sdS|||}|dS|jddt}||jdd|z}||jd|zd|jd|zd|jd|zd||}|dS|\}}} | |} | r^t| j tsDt| j tr| j |jus|d|d|dS|jjrtt'|dD]5\} } t)| r!d| } |j| | |6t)|rd } |j| ||||| gzD]%}t/||j|j|j| &|r%|jjrt5t6j}|js=t|||||| |}|j|_||_d }npt|jtsJ||jjkp||jj kp| |jj!k}||j_ ||j_| |j_!tEd |Dr|#dd ||nQtI|r|#dd||n(tI| r|#dd|||%||j|d S)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:Tc34K|]}t|VdSrTr<rqs rPrz?SemanticAnalyzer.process_typevar_declaration..Ls*22aq!!222222rRzTypeVar valuesrzTypeVar upper boundzTypeVar default)&get_typevarlike_declarationextract_typevarlike_namer%rr!analyze_value_typesrdprocess_typevar_parametersrGrrr~rrnrr4rr"rrrrDrrr\mypycrrimplementation_artifactrrrrrrrrr)rOr rrn_valuesrrr+rrrr constraintrrtype_varrs rPrqz,SemanticAnalyzer.process_typevar_declarations //3bcc 5,,Q55 <5>!""%++G44))$)AH 4D*EFF-- Ia(lnn % N1x<>> * N1x<>> *     ;5),&+w,,..22488   x}o 6 6  { 3 3  9A 8V8V IID$DDDa H H H5 < / M#,V1#=#=#= P PZ/ ;;P0300FH88QOOO+K88 M744V[!LLL;00  A "4<!;TXq       Edl( E!)"CDDK} ,"d))$//gxH!IHM$DMGGdm[99 9 9 9$-..4$-";;4dm33  )4DM %#)DM $+DM ! 226222 2 2 Y  $ $T+;Qw $ W W W W [ ) ) Y  $ $T+@!T[ $ \ \ \ \ W % % Y  $ $T+rr`rrrrF)rOrrrrarg_type arg_ptypes rPr1z(SemanticAnalyzer.check_paramspec_default^sg&& c: & & 4(77 \ \ 8+H55 i11\i6M\IIQ!QQQSZ[[[ \ sG $ $ 4! 4cG[#9:: 4 IIg   i233GrRct|}t|ts/|d|t t j}|S)Nz>The default argument to TypeVarTuple must be an Unpacked tuple)rr~rrrrrFrbs rPr2z+SemanticAnalyzer.check_typevartuple_defaultqsLg&&#z** 4 IIVX_ ` ` `i233GrRrctt|}t|jtsJt|jtr |jjn |jj}t|jdkr| d|d|dSt|jdtr|j dtkr| |d|dS|jdj |kr?d}| ||jdj |||dSdS) 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~rrqrerrrrrdrryr%r!rfr)rOrrrtypevarlike_typerDs rPrz'SemanticAnalyzer.check_typevarlike_namexs&~~$+w///// *4; A A [DK  t{G[  ty>>A   IIC/?CCCW M M M5$)A,00 DN14E4P4P II)XXXZa b b b5 Yq\ 4 ' 'WC IIcjj1!35EtLLg V V V5trRtypevarlike_typestuple[str, ...]CallExpr | Nonect|jdks t|jdtsdSt|jt sdS|j}|j}t|tsdS|j|vrdS|S)zReturns the call expression if `s` is a declaration of `typevarlike_type` (TypeVar or ParamSpec), or None otherwise. rrN) rrr~rerRr=rrqrr)rOr rirrs rPrVz,SemanticAnalyzer.get_typevarlike_declarations qy>>Q  j1x&H&H 4!(H-- 4x&'** 4 ?"3 3 34 rRrdrqlist[str | None]kinds list[ArgKind] num_valuestuple[int, Type, Type] | Nonec(|dk}d}d}|} ttj} t |||D]\} } } | s#|tj|dS| dkr`t| tr| j dvr | j dk}n|tj d|dS| dkr`t| tr| j dvr | j dk}|tj d|dS| dkr<|r|d|dS|d | | |}|dS|} L| d kr7|d | | |d }|pttj} | d kr/|d||d|dS|tjd| d|dS|r|r|d|dS|dkr"|tj|dS|rt"}n|rt$}nt&}|| | fS)NrF covariant)rrr contravariantboundz2TypeVar cannot have both values and an upper boundr rTrcrz'TypeVar "values" argument not supportedzAUse TypeVar('T', t, ...) instead of TypeVar('T', values=(t, ...))z: "r@z2TypeVar cannot be both covariant and contravariantr)r/rrrrQis_namedrrTYPEVAR_UNEXPECTED_ARGUMENTr~rerTYPEVAR_VARIANCE_DEFrget_typevarlike_argumentrF"TYPE_VAR_TOO_FEW_CONSTRAINED_TYPESr$r#r')rOrdrqrnrpr has_valuesrsrtrr param_value param_name param_kindtv_argr+s rPrYz+SemanticAnalyzer.process_typevar_parameterss  !^    ,,..  ?@@36tUE3J3J* *  /KZ&&((  *FPPPtt[((k844 9IM^9^9^ + 0F :IIII.CJJ;WWY`aaa44..k844 9IM^9^9^$/$4$>MMII(=DD_UUW^ 44w&& IIRT[\\\4466y*k[bcc>44$ y((66z;UY7!AGI,@$A$Ax'' CWMMM WY`tt 'CUU UUUW^tt  ! ! IIJG T T T4 1__ II&I7 S S S4  ! HH  !$HH Hg--rR)rKr(r*report_invalid_typevar_argtypevarlike_namer}r|rKr(r*rProperType | Nonec ||dd|||} | tdg|j} t| } |rPt | t r;| jr4|tj |||| S#t$r:|r4|tj |||YdSwxYw)NTF)r%r'rKr(r*) rrrrr~rr`rrrarr) rOrr}r|rrKr(r*rr4rs rPryz)SemanticAnalyzer.get_typevarlike_arguments" 11"&%*$7*C) 2H+4W\BB!(++C) jg.F.F 3K\  $=DDEUWabb J#   )  $=DDEUWabb44  sBBACCc|sdS|jd}t|tsJ|jr|d|dS|||j|sdS|jS)Nrz9Cannot declare the type of a TypeVar or similar construct)rr~rerVrrr)rOr rrQs rPrWz)SemanticAnalyzer.extract_typevarlike_names~ 41&(+++++ 6  IIQST U U U4**4a@@ 4{rRc ||d}|sdS|||}|dS|jddt}|dkr|d|t tj}t|j d|zd|j d|zdD]o\}}|dkrN| d|||d d d }|pt tj }|||}Y|d |p|jsSt!|||||t&} |j| _| |_d } n8t+|jt sJ||jjk} ||j_t/|r|dd || |||j|d S)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"r ParamSpecT)rKr(rzOThe variance and bound arguments to ParamSpec do not have defined semantics yetzParamSpec defaultr)rVrWr%rr!rrrrrQrdrGryrFr1r4rlrr/r'rr~rrrr) rOr rrr\rr|r}r paramspec_varrs rPrrz.SemanticAnalyzer.process_paramspec_declaration"s?// B   5,,Q55 <5>!""%++G44 q== IIEq I I I ?@@'* Ia(lnn %t~a(lnn'E( (    #KY&&66(,.2/47!AGI,@$A$A66w LL  e} ,)d))$//1A1A1C1CWiM"&M )DMGGdm];; ; ; ;!66G$+DM ! 7 # # [  $ $T+>RY $ Z Z Z dmQ///trRc n||d}|sdS|jddt}|dkr|d|t t j}t|j d|zd|j d|zdD]s\}}|dkrN| d|||d dd }|pt t j }| ||}Y|d |d |t|||}|dS|js}|d |g} t%|||| | |t*} |j| _| |_d } n8t/|jt$sJ||jjk} ||j_t3|r|dd|| |||j|d S)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"r TypeVarTupleT)rKrr*zUnexpected keyword argument "z" for "TypeVarTuple"r&zTypeVarTuple defaultr)rVr%rr!rrrrrQrdrGryrFr2rWr4rr/rrrr'rr~rrrr) rOr rr\rr|r}rrr-typevartuple_varrs rPrsz1SemanticAnalyzer.process_typevartuple_declarationfso // H   5>!""%++G44 q== IIH! L L L ?@@'* Ia(lnn %t~a(lnn'E( (  _ _ #KY&&66"(,/4!%7!AGI,@$A$A99';OO Z*ZZZ\]^^^^,,Q55 <5} ,!__-=@P@P@R@R?STTN/##D)),,..   %)I  !,DMGGdm-=>> > > >!66G$+DM ! 7 # # ^  $ $T+A1U\ $ ] ] ] dmQ///trRbasetype_or_fallbackrc2|r |jsd|vr|dt|zz }t|t g}|r-|js&|jdz||z|_n|||_tt||j}||_ |jj }|s |j| jg}|g|z|_ |g|_ |S)Nrr|)rrVrr?r:rrrrrr|rrur/rZ)rOrrr class_defrrus rPbasic_new_typeinfoz#SemanticAnalyzer.basic_new_typeinfos      $  $coo C#d))O #DT599--      ;  ; "&3!69L9LT9R9R!RI  !%!4!4T!:!:I  y$/BB "'+ G',d.>.>.@.@.EFC6C<*+  rRr list[Type]c$g}|D] } |||d}|tdg|j}t |rM|t j||ttj n||#t$rF|d||ttj YwxYw|S)zBAnalyze types from values expressions in type variable definition.Tr$Nz Type expected) rrrrrrrr3rrrrFr)rOrr9rr4s rPrXz$SemanticAnalyzer.analyze_value_typess = =D =>>0066$*# /tRCCH **,II.OQUVVVMM')*>"?"?@@@@MM(+++' = = = /4000 gi&:;;<<<<< = sB3B==A D  D c|jd}t|jdkst|tsdS|jr||jsdS|rt|tr|j}t|trd|_| |j}|jJ|[tt|t|jj jzr |t j||N|jjt|vr5|jj jr&|t j|dSdSdSdSt|t(r||r||dSdS)z-Check if assignment defines a class variable.rrNT)rrr~rqrVrrrerrrrBrrrrrCLASS_VAR_WITH_TYPEVARSr)CLASS_VAR_WITH_GENERIC_SELFrbrr)rOr rQrr4s rPr~zSemanticAnalyzer.check_classvars1 qy>>Q  j&A&A  Fv T--af55  F     /Z%A%A /;D$$$ (#' ~~af--H9(((#M(,C,C(D(Ds (HH)# *BAFFF$I'=+B+BBBIN,C *FJJJJJ %$BBBBFJ// /43J3J63R3R /  & &v . . . . . / /rRct|tsdS||j|}|r|jsdS|jjdkS)NFztyping.ClassVar)r~rrbrrrrrOrres rPrzSemanticAnalyzer.is_classvarsW#{++ 5##CHc22 #( 5x $555rRct|tsdS||j|}|r|jsdS|jjt vSNF)r~rrbrrrrrrs rPrzSemanticAnalyzer.is_final_typesW#{++ 5##CHc22 #( 5x $444rRcF|tj|dSrT)rrCLASS_VAR_OUTSIDE_OF_CLASS)rOrs rPrz&SemanticAnalyzer.fail_invalid_classvars  "=wGGGGGrRlvals list[Lvalue]rvalct|ttfrutd|Dr\t t t|}t |jgd|DR}|D]^}}||||dSt|tr| |}|rt|j trw|D]u} t| tst| j tr | j j@t| tr-|| j} nYt| t&rC|| r.|jJ|jj| j} n| rt| j tr\| j |j urNt| tt&fsJ|d| j|S| jr|j J|j | _ qdSdSdSdS)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|tVdSrT)r~rrqs rPrz=SemanticAnalyzer.process_module_assignment..s=; ; )*Jq) $ $; ; ; ; ; ; rRcg|] }|j SrA)rrqs rPrDz>SemanticAnalyzer.process_module_assignment..+s7S7S7SA7S7S7SrRNzZCannot assign multiple modules to name "{}" without explicit "types.ModuleType" annotation)r~rr_rr r*rQrrrqrrrcrrVrerrrrbrrqrrr) rOrrr  seq_lvalselementwise_assignmentsrlvsrnoderlnodes rPrz*SemanticAnalyzer.process_module_assignments dY1 2 2: 4s; ; .3; ; ; 8 8 : 4T)_e44I$'*$*&T7S7S7S7S7S&T&T&T #3 = =S..sB<<<< = = g & & 4))$//E 4EJ99 4!44D%dG44! !$)S11!din6P "$11! $ 9 9 ; ; ? ? J J#D*55!$:Q:QRV:W:W!#y444 $  3 3DI > >  4%ej(;; 4 RWR\@\@\#-dXz4J#K#KKKK II!QQWQWX\XaQbQb # "14#(:#9#9#9).EJ= 4 4 4 4 4 444rRclt|jdkrt|jdtru|jdjdkra|jdjt krHt|jttfr)| |jj dSdSdSdSdSdS)z1Export names if argument is a __all__ assignment.rrrN) rrr~rerr.r%rRr_r add_exportsrrcs rPrzSemanticAnalyzer.process__all__Ns  NNa  19Q<22  ! !Y.. ! !T))18h %:;;*   QX^ , , , , ,   ..))))rRcL|jjsdSt|jdkrt |jdt r|jdjdkr|jdjtkr|j }t |ttfs| d|dS|j }g}|D]H}t |ts| d|.||jI|jsJ||j_dSdSdSdSdS)Nrr __deletable__zC"__deletable__" must be initialized with a list or tuple expressionz5Invalid "__deletable__" item; string literal expected)r"rZrrr~rerr.r*rRr_rrrryrrfrVdeletable_attributes)rOr rRrattrsras rPrz%SemanticAnalyzer.process__deletable__Ys5|!  F  NNa  19Q<22  ! !_44 ! !T))XFfx&;<<  _abcccLEE - -!$00-IIUW[\\\\LL,,,,9   -2DI * * *#   44))rRct|jtrt|jdkrt|jdt r|jdjdkr|jdjtkrt|j tttttfsdStd|jjddDrdSd}g}t|j tr||j nut|j tttfr ||j jn.|j jD]!\}}|r|||d}"g}|D]?}t|tr&|jd kr||j=d}@|sdS|jjddD]%}|jJ||j&t-||j_dSdSdSdSdSdS) z Processing ``__slots__`` if defined in type. See: https://docs.python.org/3/reference/datamodel.html#slots rrrNc3(K|] }|jduVdSrT)slotsrCrts rPrz4SemanticAnalyzer.process__slots__..s(@@q17d?@@@@@@rRrTF__dict__)r~rVrrrrerr.r*rRryr_rrurHrrurrrrfrrB) rOr concrete_slotsrRkeyr@rra super_types rPrz!SemanticAnalyzer.process__slots__psM ty( + +2 )AI!##19Q<22$ ! ![00 ! !T))ah(IwPX(YZZ @@DIM!B$,?@@@@@ !N')F!(G,, / ah''''AHxG&DEE / ahn---- hn//FC%/#/ c****).E + +dG,,+z1I1ILL,,,,%*NN! #imAbD1 / / !'333 Z-....!%jjDIOOOe2 )2 )####00))rRrtr:c|jrdS|jdxxdz cc<|jD]}|||jdxxdzcc<dS)Nrr)is_unreachabler,rr)rOrtr s rP visit_blockzSemanticAnalyzer.visit_blocksx   F !  A KKNNNN !rR Block | Nonec8|r||dSdSrT)r)rOrts rPvisit_block_maybez"SemanticAnalyzer.visit_block_maybes.    Q       rRrMcH||_|j|dSrT)r:rrrcs rPvisit_expression_stmtz&SemanticAnalyzer.visit_expression_stmts#  drRrrc||_|s|d||jr|d|d|jr|j|dSdS)Nz"return" outside functionz%"return" not allowed in except* blockTrf)r:rrrNrrrcs rPvisit_return_stmtz"SemanticAnalyzer.visit_return_stmts!!## 6 II11 5 5 5  4 P II=q$I O O O 6 FMM$       rRrpc||_|jr|j||jr|j|dSdSrT)r:rr from_exprrcs rPvisit_raise_stmtz!SemanticAnalyzer.visit_raise_stmtsW 6 FMM$    ; % K  t $ $ $ $ $ % %rRr5c||_|jr|j||jr|j|dSdSrT)r:rrrDrcs rPvisit_assert_stmtz"SemanticAnalyzer.visit_assert_stmtsU 6 FMM$    5  ELL       rRrhc||_|j||j|t |jt rg|jjdkrY|jjtkrFt |jttfr'| |jj dSdSdSdSdS)Nr) r:rQrrRr~rerr.r%r_rrrrcs rPvisit_operator_assignment_stmtz/SemanticAnalyzer.visit_operator_assignment_stmts   qx * * - ** %%18h %:;;&   QX^ , , , , ,  - -**%%%%rRrcb||_|j||jdxxdz cc<|dd5|j|dddn #1swxYwY|jdxxdzcc<||jdS)NrrFTrfrg)r:rrr4rjrrrrcs rPvisit_while_stmtz!SemanticAnalyzer.visit_while_stmts  d q   . .U$ . O O  FMM$                   q  q{+++++sA55A9<A9rPc|jrR|r|jdjs,|t j|tj||_ |j || |j |jdud|jr||jr||j t#|j t$}||j|}|"||j |||_|jdxxdz cc<|dd5||jdddn #1swxYwY|jdxxdzcc<||jdS) NrrT)rr$rrFr)is_asyncrr1r5rrASYNC_FOR_OUTSIDE_COROUTINEr&rgr:rrrbr index_typerrr~rrrr4rjrrrr)rOr r)r4s rPvisit_for_stmtzSemanticAnalyzer.visit_for_stmts : ^%%'' ^t/B2/F/S ^ *FPUP\ ]]]  d AG1 + N ! !' * * * * * + +sB22B6 9B6 rc||_g}|jrR|r|jdjs,|t j|tj |j rt|j tsJd|j D}t|dkr|d|nt|dkr |j g}nt|j tr`t|t|j jkr|j j}n-|d|n|d|g}t%|j|j D]\}}|||r|||j du |r|d}||r||t|t2}||| } | +|| ||| ||_||jdS) Nrrcg|]}||SrTrAr=s rPrDz4SemanticAnalyzer.visit_with_stmt..6sCCCAQ]a]]]rRrz5Invalid type comment: "with" statement has no targetsrz/Incompatible number of types for "with" targetsz3Multiple types expected for multiple "with" targets)rr) r:rrr1r5rrASYNC_WITH_OUTSIDE_COROUTINEr&rgrVr~rrrrrr}rQrrrbrrrrrrranalyzed_typesrr) rOr ractual_targets new_typeserrr)r4s rPvisit_with_stmtz SemanticAnalyzer.visit_with_stmt,s : _%%'' _t/B2/F/S _ *GQVQ] ^^^  Ta/<< < < <CCCCCN>""a'' QSTUUUU^$$))*+A-y99 T~&&#a.?.E*F*FFF-388::EEIIOQRSSSS OQRSSS " )) ? ?DAq HHTNNN ?##AQ5Fd5R#SSS ? ! A''**6221555*4Q *B*B'#~~aEX~YYH+!((22211!X>>>$      rRrGc||_|j|||js|d|dSdS)NzInvalid delete target)r:rris_valid_del_targetrrcs rPvisit_del_stmtzSemanticAnalyzer.visit_del_stmt^sZ  d''// 2 II-q 1 1 1 1 1 2 2rRct|tttfrdSt|tt fr t fd|jDSdS)NTc3BK|]}|VdSrT)r)rCrarOs rPrz7SemanticAnalyzer.is_valid_del_target..hs1JJ$t//55JJJJJJrRF)r~r[rerbrr_rrrcs` rPrz$SemanticAnalyzer.is_valid_del_targetdsb a)Xz: ; ; 4 Ix0 1 1 JJJJ!'JJJJJ J5rRrrUc||_|jD]K}||jdvr|d|d||jd|LdS)NrName "" is nonlocal and global)r:rqr(rr'r )rOrrs rPvisit_global_declz"SemanticAnalyzer.visit_global_decllsvG , ,Dt*2... A4AAA1EEE  b ! % %d + + + + , ,rRrrgc ||_|r|d|dS|jD]"}t t |jddt |jddD]2\}}|+||vr'|tkr|d|d|n3|d|d||jd8||jdvr)|d ||||j dvr|d|d ||j d |$dS) 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:rrrqrQrr)r+rrr'r(r )rOrrtablerhs rPvisit_nonlocal_declz$SemanticAnalyzer.visit_nonlocal_declss    ! ! 2 IIH! L L L L L 2 2),T["-..9I#2#9N0O0O** L L%E:(TU]]%)999 II [TX [ [ []^IIG$GGGKKK;r?.44;r?3J3JII<>> s1:'' * *A JqM  & & &HQKE  T"""   QXa[ ) ) ) )  * *rRrc  |jrdS||_||j|}|||dSd|jD} ||jj}|rt|j tsnt|j tr|j j |j ks?| |jj||d ||jdS|}||jj|jd||d\}}}} } |st't(j}|s+t|t.ot|t0} nt3|} ||s| rD||jj|jd ||jdS|||| t;||j|j|j |tC|}|jj"r:tG|r+|j $d||tK|}|} t|t.r8t|tLr#tO||j(|j)d|j t||*|jj|j |j+|d| d } | |_,|rt|j ttfr|j j |j krd}t|j tr+|j j-|kr||j _-||j _.d}n | |_ d}|r\|j/r>|0|jjd | ||jdS||d n!|1|jj| ||r|j n| }t|tsJ|2|||j|j3|||jdS#||jwxYw) Ncg|] }|j SrArrs rPrDz:SemanticAnalyzer.visit_type_alias_stmt..s = = =A = = =rRNameT)r%rrrfr7r:rFrrrr)4rr:rrrrrrr~rr rnralready_definedrrrrfrrrrFrrrrrrr,rr"r\rDrrrrrrrrrrrrrrlr_rrrr)rOr r r rrrrlrrrr rrrrs rPvisit_type_alias_stmtz&SemanticAnalyzer.visit_type_alias_stmts" $  F))!+q99   JJqMMM F = = = = =e ,002266qv{CCH 8=)44 x}o>> CK=CUYZY_C_C_$$QV[!XvFFF|   q{ + + + + +y,,..COSOaOa  "&#./D'+ PbPP LCj/;L 4i233%%'' 9%/sJ$?$?%JEE!!%4C$8$8!((-- 1B $$QV[!'D$QQQD   q{ + + + + +A  $ $Z 0 0 0  $ $_ 5 5 5 #T\4#=txQR     (,,C|3 38TUX8Y8Y 3445H#qQQQ-c22&&((E#z** bz#x/H/H bS$)TYUTXT`aaaa"##AFK00''+   J&AL <x} .JKK <M&!&00hmY77 #}+s2203 ,4? 1"&%/HM"G;+;00faHHH   q{ + + + + + 1T ::: Z;;;,4D8==*LlI66 6 6 6  2 21lAG L L L FMM$      q{ + + + + +D  q{ + + + +s"BS0C=S0,G:S0BS00T cp||j|}|r|||dSdSrT)rrr@)rOrrs rPvisit_name_exprz SemanticAnalyzer.visit_name_exprsE KK 4 ( (  )   a ( ( ( ( ( ) )rRreczt|jtrB|j|r(|js!|d|jd|dSt|jtr| |jd|dS|j |_ |j|_|j pd|_ dS)z,Bind name expression to a symbol table node.r@z3" is a type variable and only valid in type contextrr5N) r~rrr0 get_bindingrKrrrnrr.rrrs rPr@zSemanticAnalyzer.bind_name_exprs sx - - /++C00 /, / IIX$)XXXZ^ _ _ _ _ _ / 2 2 /  $ $TY = = = = =DIDIL.BDMMMrRrzc|js$|jjs|d|dS|j|_|jjD]}||dS)Nz"super" used outside class)rVrrdrrr)rOrr s rPvisit_super_exprz!SemanticAnalyzer.visit_super_expr$sly   II2D 9 9 9 FI 9>  C JJt      rRc||jD]3}t|trd|_||4dSrbrr~rwrrrOrras rPvisit_tuple_exprz!SemanticAnalyzer.visit_tuple_expr,KJ  D$)) "! KK      rRr_c||jD]3}t|trd|_||4dSrbrrs rPvisit_list_exprz SemanticAnalyzer.visit_list_expr2r rRruc||jD]3}t|trd|_||4dSrbrrs rPvisit_set_exprzSemanticAnalyzer.visit_set_expr8r rRrHcx|jD]1\}}|||||2dSrT)rr)rOrrrfs rPvisit_dict_exprz SemanticAnalyzer.visit_dict_expr>sM*  JC 4   LL      rRrwc||js|d|ddS|j|dS)Nz!can't use starred expression hereTr)rrrrrs rPvisit_star_exprz SemanticAnalyzer.visit_star_exprDsGz # II94I N N N N N I  T " " " " "rRrrc|s|d|ddnn|jdtkr|d|ddn>|jdjr|d|ddnd|jd_|jr|j|dSdS)Nz"yield from" outside functionTrrz9"yield from" inside comprehension or generator expressionz"yield from" in async function) rrr+rr1r5 is_generatorrrrOrs rPvisit_yield_from_exprz&SemanticAnalyzer.visit_yield_from_exprJs!!## 8 II5q$PTI U U U U  b !%8 8 8 IIK        $ 1 8 II64QUI V V V V37D  # 0 6 FMM$       rRcj|tjdr|ddsdS |jd}n'#t $r|dYdSwxYwtjd|_ j j _ j j _ j |dStjtr|ddsdS |jd}n'#t $r|d YdSwxYwtjd|_ j j _ j j _ j |dStjtr|dd sdSd }|d d }|r*t!|jt$r|jt(vrd }t+t,jd|_ j j _ j j _ j |dStjdrg}|r$d|jD}n|r0|j(d|jjD}nH|r4|j-|jd}|d|D}t+t@|_ j j _ j j _ j |dStjdr|ddStjdr|ddsdS |jd}n'#t $r|dYdSwxYwtC|_ j j _ j |dStjdr|"_ dStjdrr|ddsdStGdjdjd_ j j _ j |dStjdrO|$5jD]}|| ddddS#1swxYwYdSjD]}||t!jtJrNt!jj&tNr0jj&j(dkrjj&j)tTkrjj(dvrjj(d kr)jr"|+jddSjj(d!krUjrNt!jdtXtZfr'|+jdjdSjj(d"krKjrFt!jdt\r(fd#|j/D|_/dSdSdSdSdSdSdSdSdS)$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 typerFTr])r.r is_importedzbuiltins.reveal_localscg|]<\}}t|jddt|jt5|j=S)r=F)getattrrr~r)rCrrs rPrDz4SemanticAnalyzer.visit_call_expr..s[aqv}e<<BLAFTWAXAXFrRcPg|]#}t|jt|j$SrAr~rrrCsts rPrDz4SemanticAnalyzer.visit_call_expr..s>###$&jQSQXZ]F^F^####rRrcPg|]#}t|jt|j$SrArrs rPrDz4SemanticAnalyzer.visit_call_expr..s>'''(*zRTRY[^G_G_'G'''rR)r. local_nodesrz;Any(...) is no longer supported. Use cast(Any, ...) insteadztyping._promote_promotez$Argument 1 to _promote is not a typerzbuiltins.divmoddivmod)rrr)rrrrrrc@g|]}|jdjk|Sr)rdrf)rCrrs rPrDz4SemanticAnalyzer.visit_call_expr..s-'_'_'_aqDIVWLL^G^G^G^G^G^rR)0rrrcheck_fixed_argsrrdrrr>r4rrrr6rrr~rr0rrrrsr.rr&rrrVrqrrr)r-rotranslate_dict_callrirerbrrerr.r%rr_rryrE)rOrrreveal_importedreveal_type_noder  symbol_tabler{s ` rPvisit_call_exprz SemanticAnalyzer.visit_call_expr[s 4   dk= 9 9F `((q&99  55dilCC'    5t<<<  %TYq\6::DM!%DM #';DM M  & & & & &  -> ? ?v `((q-@@  55dilCC'     ? ?i `((q-@@ #O#{{=$PT{UU   '/46KLL '%-1KKK"&& ty|DM"&DM #';DM M  & & & & &  -E F FX `&(K##%%  #'<#5#5#7#7 $$&& 9(##*.)/*@*@*B*B###K##%% ;*#';r?L#/''.:.A.A.C.C''' 'M{SSSDM!%DM #';DM M  & & & & &  \ : :7 ` IISUY Z Z Z Z Z  -> ? ?4 `((q*==  55dilCC'    @$GGG (//DM!%DM  M  & & & & &  _ = =' ` 44T::DMMM  -> ? ?% `((q(;; "8TYq\49Q<HHDM!%DM  M  & & & & &  KT   `--// # ###AHHTNNNN# # # # # # # # # # # # # # # # # # # Y  4; 33 `t{/:: `K$)Y66K$)T11K$(FFF;#x//DI/$$TYq\22222K$00 1"49Q<(I1FGG1$$TYq\%788888K$00 1"49Q<991(`'_'_'_43C'_'_'_D$$$) ` ` ` `7611FF100000sH A,, BB% E E*)E*: Q Q?>Q?$ WWWDictExpr | Nonec:td|jDs!|jD]}||dSt dt |j|jD}|||||S)zTranslate 'dict(x=y, ...)' to {'x': y, ...} and 'dict()' to {}. For other variants of dict(...), return None. c36K|]}|ttfvVdSrT)r r"rs rPrz7SemanticAnalyzer.translate_dict_call..s,MMd4Iy11MMMMMMrRNc>g|]\}}|t|nd|fSrT)ry)rCrrfs rPrDz8SemanticAnalyzer.translate_dict_call..s?   C"%dEB   rR)rr%rdrrHrQrGr)rOrr{rs rPr%z$SemanticAnalyzer.translate_dict_calls MMdnMMMMM Y  4  "%dndi"@"@      d D rRnumargscd}|dkrd}t|j|kr|d|||fz|dS|jtg|zkr!|d|d|d||dSd S) zsVerify that expr has specified number of positional args. Return True if the arguments are valid. r rr5z"%s" expects %d argument%sFr@z" must be called with z positional argumentT)rrdrr%r!)rOrr.rr s rPr$z!SemanticAnalyzer.check_fixed_argss  a<<A ty>>W $ $ II2dGQ5GG N N N5 >gY0 0 0 IIV$VVgVVSTVVX\ ] ] ]5trRc|j}||t|trt|jt r||j|j}|r`t|jtr| |jd|dS|j |_ |j pd|_ |j|_dSdSt|trd}t|jtr |j}nt|jtru|jrn|jrg|jd}|jsRt|jt"r8|j|jj}|r|jdkr|j}nwt|jt(r]|jjrQt|jjt.sJt|jjt0r|jjj}|rv|j|j}|Wt|jt tt(fr2|sdS|j |_ |j pd|_ |j|_dSdSdSdSdS)N attributer5rr)rrr~rqrrcget_module_symbolrrnrr.rrrrrVr1r$rargument_by_nameposr rrrrrqr)rOrr?re type_infofunc_def formal_argrs rPvisit_member_exprz"SemanticAnalyzer.visit_member_exprsiy D dG $ $) 'DIx)H)H) '((DI>>C %ch88,,TY TJJJFH # 2 H  % %g & & 'I$)X.. 6 I DIs++ 6 6d>Q 6.r2).j .U.U.!)!?!? !O!OJ!.jn&9&9$(I DIy11 6di6G 6!$)"2J?????di.996 $ 0 5I 'O'' 22=Z8Y8W%X%X= !DI$%J$4"DM !DIII? ' '0 ' ' ===rRric|j||jdvrt|j|j}|t t fvr |jdks|ttfvr|jdkr d|_ dS|ttfvr |jdks|t t fvr|jdkrd|_ |j |dS)N)andr@r:r@T) rrrrr"rrrrright_unreachable right_alwaysr)rOrr;s rP visit_op_exprzSemanticAnalyzer.visit_op_expr<s  7m # #,TY EEH\:66647e;K;K[)444D)-&{I66647e;K;K\:66647d??$(! $rRr@cD|jD]}||dSrT)operandsr)rOroperands rPvisit_comparison_exprz&SemanticAnalyzer.visit_comparison_exprMs2} ! !G NN4  ! !rRrc:|j|dSrTrrrs rPvisit_unary_exprz!SemanticAnalyzer.visit_unary_exprQs rRr[c|j}||t|trOt|jt r5|js|j|dSt|trt|jtst|r| |dS|j|dSrT) r?rr~rqrr is_genericrr refers_to_class_or_functionanalyze_type_application)rOrr?s rPvisit_index_exprz!SemanticAnalyzer.visit_index_exprTsy D tW % % $49h// $I((** $ J  d # # # # # tW % % $*4TY *J*J $ ( . . $  ) )$ / / / / / J  d # # # # #rRc(||}|dS|j}t|||_|j|j_|j|j_t |trt |jtr|j}t|j }t |trc|j j}|jrR|t!|jjvr9|js4|js/|t-|d|dSdSdSdSdSdS||}|rS|jt!|jjvr5|js0|t-|jd|dSdSdSdS)zNAnalyze special form -- type application (either direct or via type aliasing).NF) propose_alt)analyze_type_application_argsr?rr4rrr~rqrr rrrrVrrrrr"rrYrrrr)rOrrr?rrrrs rPrHz)SemanticAnalyzer.analyze_type_applicationfs22488 = Fy'e44 !Y #{  dG $ $ [DIy)I)I [IE$U\22F&(++ Y{+MY*4<+FGGHH -H",H II85QQQSWXXXXX Y YYYHHHHHH%%d++A [J"5dl6Q"R"RRR)S 4QZUSSSUYZZZZZ  [ [RRRRrRlist[Type] | Nonec0|j}|}||||rdS|jrdSg}t |t rl|j}t |jto|jj dk}|r8t|dkr%t |dtr |dd}n|g}|j}t |trit |j trO|j jdu}|j } t!d| jDrd} t| j} n|d} d} nwt |tr\t |j t$rB|j jp|j j dk}|j j} t|j j} nd}d} d} |D]|} || d} n(#t.$r|d |YdSwxYw|| |jd| | }|dS||}|r'||}| r| d kr|rt=|d }t|d kot |t>}|sRt!d |Ds9tA|tBgt|zdgt|zg}|S)zoAnalyze type arguments (index) in a type application. Return None if anything was incomplete. Nr&rrc3@K|]}t|tVdSrT)r~rr=s rPrzASemanticAnalyzer.analyze_type_application_args..s,KKA:a//KKKKKKrRTFr*zType expected within [...])rKr%r(r*rrc3NK|] }t|ttfV!dSrT)r~rrr=s rPrzASemanticAnalyzer.analyze_type_application_args..s2%`%`UVjZ4O&P&P%`%`%`%`%`%`rR)"rrrrrJr~rrr?rqrrrrJrr rmrrlrhas_type_var_tuple_typehas_param_spec_typerrrrrrKrr"check_unpacks_in_listrrrr!)rOrrrrris_tupler?r*rhas_param_specnum_argsratypeargr4 first_arg single_anys rPrLz.SemanticAnalyzer.analyze_type_application_argssS  ((** u%%%  $ $S ) ) 4  ' 4 eY ' ' KE!$)W55`$):LP`:`H #CJJ!OO 59l0S0SOcrc GEy dG $ $ DIy)I)I 95TALIEKK9JKKKKK !%u011!& g & & :di+J+J  1[TY5GK[5[ "Y:N49.//HH L"NH # #D 66t$6OO'    6===ttt ~~%)$<"&*8)&  Htt LL " " " "  F&&((>>uEEE  Yh!mmm'a11IUqKZ 7-K-KJ Y#%`%`Z_%`%`%`"`"` Y#EG9s5zz+AD6CPUJJCVWWX sG00 HHrvc|jr|j||jr|j||jr|j|dSdSrT) begin_indexr end_indexstriders rPvisit_slice_exprz!SemanticAnalyzer.visit_slice_exprst   *   # #D ) ) ) > ( N ! !$ ' ' ' ; % K  t $ $ $ $ $ % %rRr>c|j|||j}| ||_dSdSrTrrrrVrOrr4s rPvisit_cast_exprz SemanticAnalyzer.visit_cast_exprD >>$),,   DIII rRr6c|j|||j}| ||_dSdSrTrarbs rPvisit_assert_type_exprz'SemanticAnalyzer.visit_assert_type_exprrdrRrscp|jtkr%|j|j|dSdSdSrT)r.r.rrrs rPvisit_reveal_exprz"SemanticAnalyzer.visit_reveal_exprsB 9 # #y$   &&&&&%$ DrRrc|j|tt|jD].}||j|}| ||j|</dSrT)rrrrrr)rOrrr4s rPvisit_type_applicationz'SemanticAnalyzer.visit_type_applicationsj s4:'' ) )A~~djm44H# ( 1  ) )rRr^ct|jjrR|r|jdjs,|tj|tj |j |dSNrr r generatorrrr1r5rrrr&rgrrs rPvisit_list_comprehensionz)SemanticAnalyzer.visit_list_comprehension| t~& ' ' a%%'' at/B2/F/S a *FSXS_ ``` d#####rRrtct|jjrR|r|jdjs,|tj|tj |j |dSrlrmrs rPvisit_set_comprehensionz(SemanticAnalyzer.visit_set_comprehensionrprRrIct|jrR|r|jdjs,|t j|tj | |5| ||j ||j |dddn #1swxYwY||dSrl)rrrr1r5rrrr&rgranalyze_comp_forrrrfanalyze_comp_for_2rs rPvisit_dictionary_comprehensionz/SemanticAnalyzer.visit_dictionary_comprehensions t}   a%%'' at/B2/F/S a *FSXS_ ``` ZZ   $ $  ! !$ ' ' ' HOOD ! ! ! J  d # # # $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ %%%%%s>$),,  h 33 ] ]5] ] ] ] DIII rRrc|s|d|ddny|jdtkr|d|ddnI|jdjr%d|jd_d|jd_nd|jd_|jr|j |dSdS)Nz"yield" outside functionTrrz4"yield" inside comprehension or generator expression) rrr+rr1r5rr6rrrs rPvisit_yield_exprz!SemanticAnalyzer.visit_yield_expr>s!!## 8 II0!T4I P P P P  b !%8 8 8 IIF        $ 1 837D  # 09=D  # 6 637D  # 0 6 FMM$       rRr9c"|r|js$|d|dtjn5|jdjs#|d|dtj|j|dS)Nz"await" outside functionT)rfrrz'"await" outside coroutine ("async def")) rr1rr&TOP_LEVEL_AWAITr5AWAIT_NOT_ASYNCrrrs rPvisit_await_exprz!SemanticAnalyzer.visit_await_exprPs!!## 4+>  II0$5K`I a a a a$R(5  II9*     rRrtrc|j|j||j||jdSdSrT)patternrrrbrOrts rPvisit_as_patternz!SemanticAnalyzer.visit_as_patterncsL 9 I  T " " " 6     ' ' ' ' '  rRrcD|jD]}||dSrTrrrOrtrs rPvisit_or_patternz!SemanticAnalyzer.visit_or_patterni2z ! !G NN4  ! !rRrc:|j|dSrTrCrs rPvisit_value_patternz$SemanticAnalyzer.visit_value_patternms  drRrcD|jD]}||dSrTrrs rPvisit_sequence_patternz'SemanticAnalyzer.visit_sequence_patternprrRrcL|j||jdSdSrT)capturerbrs rPvisit_starred_patternz&SemanticAnalyzer.visit_starred_patternts. 9    * * * * * ! rRrc|jD]}|||jD]}|||j||jdSdSrT)rCrrrestrb)rOrtrrfs rPvisit_mapping_patternz&SemanticAnalyzer.visit_mapping_patternxsz6  C JJt    X  E LL     6     ' ' ' ' '  rRrc|j||jD]}|||jD]}||dSrT) class_refr positionalskeyword_values)rOrtr4rs rPvisit_class_patternz$SemanticAnalyzer.visit_class_patternsk 4   =  C JJt    !  A HHTNNNN  rRr^SymbolTableNode | Nonecd}||jdvr0||jvr |j|S|s|||dS||jdvrIt |jddD]}|||vr ||cS|s|||dS|jr\|sH||jjvr:|jj|}|j s| |j r|Snd}|}|jrM|s9|dvr5ttt||St |jD]}|||vr ||cS||jvr |j|S|jdd}|r{t#|j t$sJ|j j}||vrOt'|dkr2|dd kr&|dd kr|s|||dS||}|S|s|s|||n|r|SdS) 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__rnrrr@)r'r&rAr(rr)rVrrqrGis_active_symbol_in_class_bodyrr}r*rrrr~rcr) rOrr r^ implicit_namerr implicit_noderts rPrzSemanticAnalyzer.lookups 4$R( ( (t|##|D))" 1%%dC0004 4&r* * *!$+crc"233 ' '$ ;&&&" 1%%dC0004 9 %T//11 %ddio6M6M9?4(D= %66tyAA K !% $ 9 ET//11 Ed>\6\6\"4T4==??)C)CDD Ddk** # #E TU]]T{""" 4<  <% % L  ^T 2 2 afh// / / /FLEu}}t99q==T!W^^Q3*9--dC8884T{  %_ %  ! !$ , , , , %$$trRSymbolNode | NonecZ|jdS|/||s||jsdS||rY|j|jvrdS|j|j}||jsdS||j SdS)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. NTF) r:is_textually_before_statementis_defined_in_current_modulerr is_type_likerr&is_textually_before_classr)rOr global_nodes rPrz/SemanticAnalyzer.is_active_symbol_in_class_bodys& > !4 L11$77 44T]CC 4   T " " ;y ,,t,ty1K11+2BCC t(()9::: :urRcrt|ttfpt|to|jSrT)r~rr rnr8rOrs rPrzSemanticAnalyzer.is_type_likes3$9 566 t_ - - G$2G rRr{c|jsJ|jj|jz }|||jrdSt|tr|js|t |jkS|dkS)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~rFrrr)rOr line_diffs rPrz.SemanticAnalyzer.is_textually_before_statements ~N'$)3  " "4 8 8 !5 i ( ( !1A !s4#;<<< <q= rRcP|jJ|dS|j|jjjkS)zFSimilar to above, but check if a node is defined before current class.NF)rVrrrs rPrz*SemanticAnalyzer.is_textually_before_classs.y$$$ <5y49>...rRrxct|trft|trQ|d|jDv}|jduo0t|jt r||jjup||ju}|p|SdS)z=Check whether the function belongs to the overloaded variantscJh|] }t|tr|jn|!SrA)r~rFrNrs rPrrz6SemanticAnalyzer.is_overloaded_item..s:%%%GKZi88B d%%%rRNF)r~rjrRrrrFrN)rOrr:in_itemsin_impls rPrz#SemanticAnalyzer.is_overloaded_items d- . . ':i3Q3Q ' %%OSz%%%Hit+DIy11Qi49>6Q* ) &w &urRcF|sdSt|j||jkSr)rr%rrs rPrz-SemanticAnalyzer.is_defined_in_current_module#s( 5T\844GGrRcBd|vr||||S|d}|j}||d||}|rtdt |D]}|j}||} t |tr|| } n@t |tr| || } |j }n t |tr|cSt |tr`|jrYt |jt sJt |jt"r |jj| } nd} n~t |t&rKt)|j} t | t*r"|||||d| cSt |t.r| dvrdSd} | r| jr|s||||dS| }|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. r|r]rrN)rdkwargs)r)rrrrrrr~rrrcr2rrrnr rrrrrVrrrimplicit_symbolrlrrA) rOrr r^partsrrerrpartnextsymrs rPrbz!SemanticAnalyzer.lookup_qualified(s4 d??;;tS/;JJ J 3O kk%(CkII " 1c%jj))! ! xQxdH--#"hhtnnGGh//#"44T4@@G $ IIo66#JJJi00#T\#%dk:>>>>>!$+x88'"&+"2"6"6t"<"<"&!$,,S-di88%c733S#'#7#7T59c#R#RRRR"$ 66$4CU;U;U#tt"G '"7 *N--dC9-MMM44 rRc ||}n#t$rYdSwxYwt|tr||j|d}|SdSNTr])rrr~rrbr)rOrrrs rPrz!SemanticAnalyzer.lookup_type_node_sv ,,T22AA#   44  a % % %%afdD%IIAHts  &&cD|j}|j}||}|s|dz|z}||jvr!t t |j|}n||r|nd|vr5||d||}|rt t |}ne| |rFttj }t||} || _t t | }n |jrd}|S)zcLook up a symbol from a module. Return None if no matching symbol could be bound. r|r-rVN)rrrqrr%r}r%rBrr2is_missing_modulerrfrom_unimported_typerrr) rOrrr6rqrerrr9var_typers rPr2z"SemanticAnalyzer.get_module_symbolis,  iioo |d*H4<''%dDL,BCC--f55 /**,,,,%''..u]/CT8TT6)$55C''11 /#9#ABB8,,,& %dA..   C rRr6c||jvSrT)r<)rOr6s rPrz"SemanticAnalyzer.is_missing_modules---rRr list[str] source_typerc|jd}n |jj}||}n|dzd|z}ttj|}t |d|}||_tt|S)z>Create symbol for a qualified name reference through Any type.Nr|r) rrrrIrrfrom_another_anyrrr}r%) rOrerrrbasenamerrrrs rPrz SemanticAnalyzer.implicit_symbols~ 8 HHx(H  HH#~7H95{CC%)X&&  tS)))rR getattr_defn Var | Nonec(t|jttfrpt |jj}t|t r|j}nttj }t||}||_ d|_ |SdS)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~rrRrrrVrrrrrFrfrom_module_getattr)rOrrrr node_typerrs rPr2z#SemanticAnalyzer.create_getattr_vars l''3 8 8 ' (9(>??I)\22 4(i233Ds###A"AK$(A !HtrRcH||}| J||SrT)r)rOrrrets rPlookup_fully_qualifiedz'SemanticAnalyzer.lookup_fully_qualifieds)11(;; rRc|dd\}}||jvrT|j|}|j|}|)||r||S|d}g}|rad||jvrE|| |rd||jvE|r|sdS| d|}|j|}|j|d}|)||r||ddD]@}|:t|j tr |j j|}>dS|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. r|r)maxsplitNr)rr%rqrrBrrrIrrreverser~rr) rOrrr6rfilenoder9splitted_modulesrqrs rPrz/SemanticAnalyzer.lookup_fully_qualified_or_nones sQ77  T\ ! !|F+H^''--F~$">">v"F"F~**,,,M (~~c22 E" 5sxx0@'A'A'U'U -1133444# 5sxx0@'A'A'U'U$ 5 t MMOOOXX.//F|F+H^''a11F~$">">v"F"F~**,,,abb   %*V[(*K*K%#[.22488FF44MrRc,|dS)NrrrUs rPr/zSemanticAnalyzer.object_types0111rRc,|dS)NrrrUs rPrzSemanticAnalyzer.str_types~...rRc(||}|s Jd|j}t|tsJ|rt ||St |t t jgt|j j zS)Nz3Internal error: attempted to construct unknown type) rrr~rrrrrrrrrOrrrdrers rPrzSemanticAnalyzer.named_types))(33IIIIIIx$)))))  (D$'' 'wy'=>>?#diFYBZBZZ[[[rRc||}|rt|jtrdS|j}t|tr(t|jt sJ|jj}t|ts J||t ||St |ttj gt|j jzSrT)rr~rrnr rrrVrrr unannotatedrrrrs rPrz#SemanticAnalyzer.named_type_or_nones11(;; j?;; 4x dI & & $dk844 4 4 4;#D$))//4///  D$'' 'wy'<==>TYEXAYAYYZZZrRfully_qualified_namec,||S)z,Legacy function -- use named_type() instead.r)rOrs rP builtin_typezSemanticAnalyzer.builtin_type s3444rRc|jd |jd|S|j|jj|S|j|SNr)r)rrVrqr&rOrs rPlookup_current_scopez%SemanticAnalyzer.lookup_current_scope s^ ;r? &;r?&&t,, , Y "9?&&t,, ,<##D)) )rRr9rc |rt} n|jt} nt} t | |||} ||| ||||| 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. Nr)rr)rVr*r%r}add_symbol_table_node) rOrrrrrr9r_rrr.r)s rPrzSemanticAnalyzer.add_symbols{.      DD Y "DDD $m=   )) &'9.C[R\   rRc|j|jj}t}n|j}t}t ||}|||<dS)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)rVrqr*r&r%r})rOrrrqr.r)s rPrz&SemanticAnalyzer.add_symbol_skip_local=sD 9 IOEDDLED t,,d rRr)Context | Nonec|||}||} t|jtr0|r.|||d|n|| |t| |s| j} |j} t| trdSt| | st| ttttfr| |||t| ttfr|| | s|||| n.||jdvrd|jdvr|||<|sd|_dSdS)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) )r_rNrFrrZT)rrr~rrnrris_valid_replacementis_same_symbolrRrFrjradd_redefinitionrlrr2progress) rOrr)rr9r_rrrqrrdrhs rPrz&SemanticAnalyzer.add_symbol_table_nodeSs8))"7J*  99T?? fk? 3 3   "((vw????  #(6::$-C+C#// u!#s++ GcGY8I8#TUU?))%v>>>"3)(<==G$BWBWX[]`BaBaG--dGXFFF +B/ / /Ct?QRT?U4U4U E$K % $ 4urRcd}d|_ |dkr|d}n|d|}||}||||<dS|j|jurdS|dz }G)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)rOrqrr)rnew_namers rPrz!SemanticAnalyzer.add_redefinitions  # Avv"111"4444yy**H"(h&+-- FA rR!Var | FuncDef | OverloadedFuncDefc||sJ|j}||_||||dS)zAdd local variable or function.N)rrrr)rOrrrs rPrzSemanticAnalyzer.add_localsD!!#####y dG,,,,,rR symbol_nodec@|dSd}t||tttfrj||}|t||jtttfrUt||j|ts"||j||jkr|jSt||ttfr0ttj }| d|n||j}t||}| ||_ |jJ|j|_|j|_|j|_|S)Nc|SrTrAxs rPrzDSemanticAnalyzer._get_node_for_class_scoped_import..sqrRzUnsupported class scoped import)r~rFrQrrrrrVrrrFrrrrrr)rOrrrfrrs rP!_get_node_for_class_scoped_importz2SemanticAnalyzer._get_node_for_class_scoped_imports  4 &1[ aa nny(C&@ A A 0002266t<>+>>> }$!!K..8Y*?@@ *$+9+?#@#@ ;WEEEEa nn)dC..K$($7$7$=$=K !9(((#yK &|K !(K rRc|r|rJ||}|rNt|jts4t|jts|||||rdS|j}|r||||}t|j|||}| |||dS)z2Add an alias to an existing symbol through import.Nr) rr~rrnrTrrr}r.r) rOrrrrrrKrr)s rPr#z$SemanticAnalyzer.add_imported_symbols!5 55533D99  3_EE ty/::  55dOTSZ[[ )-     ]@@{T[\\K I{-}    ""499999rRc||}|r(t|jtr|jjrdSt |}|jjr |||_nE|j r$|j j dz|z|_|j |_ n| ||_d|_ ttj|j}||_ d|_||||||dS)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. Nr|Tmissing_import_namer)rrr~rris_suppressed_importr" logical_depsrrVrrrrrrrrr) rOrrrrrrrr;s rPr$z,SemanticAnalyzer.add_unknown_imported_symbols,,..22488   8=#66 8=;]  F$ii < $ 6)@ (CMM Y 6 I.4t;CMyCHH //55CM 99s}]]]#'   #wm=      rRframec#<K|j}||_dV||_dSrT)r0)rOr  old_scopes rPrz!SemanticAnalyzer.tvar_scope_frame-s(O  #rR debug_contextrc|jr Jd|rd|_d|_|r|jn|jr |jjnd}|j|j|fdS)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)r_rrrr:rIrr)rOrrrs rPrzSemanticAnalyzer.defer4s'PP)PPPP  ! !DM #0 bM  DN5bT^5H5H`b  #**DOT+BCCCCCrRrc|jS)zHReturn tag that can be used for tracking references to incomplete names.rrUs rPrz&SemanticAnalyzer.track_incomplete_refsPs ''rRrc|j|kS)zDHave we encountered an incomplete reference since starting tracking?r)rOrs rPrz%SemanticAnalyzer.found_incomplete_refTs'3..rRcN||xjdz c_dS)zRRecord the encounter of an incomplete reference and defer current analysis target.rN)rrrUs rPrz&SemanticAnalyzer.record_incomplete_refXs)    A%    rRr8cx|||dkrd|_nv||sa||}|jsJt |||jj|}|||||t|j d |dS)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). rZTr7r.rN) rrr/rr:rnrrrr2r )rOrrr8rrrrrYs rPrz SemanticAnalyzer.mark_incomplete]s$ 4 3;;"DOO++D11 **400H> ! ! !)$ 3FVK OO++%     2""4(((((rRc||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. )r=rs rPrBz(SemanticAnalyzer.is_incomplete_namespaces 4555rRct|jr||||dS|||dS)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). rN)r_rr)rOrr.r rs rPrz$SemanticAnalyzer.process_placeholdersI   ;  $ $T4 5 5 5 5 5 JJs>J : : : : :rRc|rd|dnd}|d||d||r|d|dSdS)Nrr@r5zCannot resolve z (possible cyclic definition)z1Recursive types are not allowed at function scope)rrr)rOrr.r  name_formats rPrz$SemanticAnalyzer.cannot_resolve_namesz&*2l4llll  TDT+TTTVYZZZ      P III3 O O O O O P PrRcz|j|jjdz|zS|r|S|jdz|zS)Nr|)rVrrrrs rPrzSemanticAnalyzer.qualified_namesJ 9 9&,t3 3    ! ! 0K?S(4/ /rRr2FuncItem | GeneratorExpr | DictionaryComprehensionc#0K|j|t}|j|t |t tf}|j|stnt|j t|j t|jd|jd|jt dV|j|j|j |j |j|j|jdS#|j|j|j |j |j|j|jwxYw)z3Enter a function, generator or comprehension scope.rrN)rA setdefaultr|r)rr~rTrIr+rrr'rBr(r,r4r2r)rOrrqis_comprehensions rPrzSemanticAnalyzer.enters+ !,,X{}}EE 5!!!%h@W0XYY 2B [ H[\\\   ''' ""355))) ### q!!! !!#%%((( % EEE KOO      " " "   ! ! # # #   # # % % %   " " " O   ! ! !   " " $ $ $ $ $ KOO      " " "   ! ! # # #   # # % % %   " " " O   ! ! !   " " $ $ $ $s /G$$B1Jcl|jd}|tkr |jd}|ttfvS)Nr)r+rrr)rOrhs rPrzSemanticAnalyzer.is_func_scopes9%b) ) ) ))"-Jj*=>>>rRc>td|jDS)zJAre we underneath a function scope, even if we are in a nested class also?c36K|]}|ttfvVdSrT)rr)rCr s rPrz?SemanticAnalyzer.is_nested_within_func_scope..s-TTa1%899TTTTTTrR)rr+rUs rPrz,SemanticAnalyzer.is_nested_within_func_scopes"TT4CSTTTTTTrRc>|jduo| SrT)rVrrUs rPrzSemanticAnalyzer.is_class_scopes#y$AT-?-?-A-A)AArRcT|p| SrT)rrrUs rPrz SemanticAnalyzer.is_module_scopes(''))AT-?-?-A-ABBrRc|rt}n#|rt}nt}|SrT)rr*rr)r%)rOr.s rPr1z$SemanticAnalyzer.current_symbol_kindsB     DD    ! ! DDD rRc|r)|jdtkr|jd}|J|S|r|jdtkr|jd}n |jd}|J|rt |jt |jksJt t |jD]S\}}|tkrC|t |jdz kr|j}n|jd|z }| Jd|}n TJdn|}|Jn|j |j j }n|j}|S)Nrrrz)Escaping comprehension from invalid scopeFz0Should have at least one non-comprehension scope) r+rr)rrrrrr&rVrq)rOr_rrrrhrqnames_candidates rPrz%SemanticAnalyzer.current_symbol_tables ! !$*2.2BBB BA===H    ! ! !#'777KOKO===$ 4;''3t/?+@+@@@@@%.x8H/I/I%J%J U UMAz!%888DK 0 01 444$(LEE.2k"q&.AO / ; ;J!< ; ;$3E9U"TTTT$$$$ Y "IOEELE rRcf|o||jdvp||jdvSr)rr'r(rs rPr/z&SemanticAnalyzer.is_global_or_nonlocals=!!## D%b) ) LTT5H5L-L rR exp_or_exps!Iterable[Expression] | Expressionct|tr|gn|}|D]6}t|tr|j|j7dSrT)r~rLryrErrf)rOr(expsexps rPrzSemanticAnalyzer.add_exportssa *; C CT }} 3 3C#w'' 3 '' 222 3 3rRrc||p|j}|8|jr1|s|jr|jdr |jsd}|r|dSd|d}|||tj d|tvr5d|}| ||j ||dtD}dtD}|D]y} | d |}||vr d | ||d d d } || |tj zdS) NrTrz" is not definedrrcFh|]}|dddS)r|rrrvrBs rPrrz4SemanticAnalyzer.name_not_defined..'s8) ) ) &*DJJsA  q !) ) ) rRc8i|]}||SrA)rrBs rP z5SemanticAnalyzer.name_not_defined..*s"PPPTdjjllDPPPrRr|zXDid you forget to import it from "{module}"? (Suggestion: "from {module} import {name}")r)r6r)rBrrVrrCr_rrr& NAME_DEFINEDrrrDrFrrrrr) rOrr rrrGrrmodules_with_unimported_hints lowercasedr6hints rPrAz!SemanticAnalyzer.name_not_defined s11)2NtOO    &&(( * *2.  ( J    & & ( ( ( F14111 '3U%7 888 t  !8 8 8)4))H228<<D))(C888) ) .H) ) ) %QP5OPPP 3 : :F ))4))//11Hz))?fFH)=)D)DS!)L)LR)PfQQ  IIdCe&8I 9 9 9 9 : :rR original_ctx#SymbolTableNode | SymbolNode | Nonenounct|tr|j}nt|tr|}nd}t|trt|jtrd}n4|r0|jdkr%||jr d|j}nd}||dt|d||tj dS)Nz (by an import)rz on line z (possibly by an import)rz" already definedr) r~r}rr{rcr is_local_namerrrrr&NO_REDEF)rOrr r5r7r extra_msgs rPrz SemanticAnalyzer.already_defined6s lO 4 4 &2&7DD  j 1 1 DDD lO 4 4 3LDUW_9`9` 3*II  3di2oo$*<*r?s rPrHz*SemanticAnalyzer.attribute_already_definedTs' T3 ;GGGGGrRc4||pd|vS)zDDoes name look like reference to a definition in the current module?r|)rrs rPr9zSemanticAnalyzer.is_local_nameYs0066I#T/IrRc|jjs|jsdSt|jdz }|dkrB|j|}t |t s| S|dz}|dkBdS)zShould we type-check the current function? - Yes if --check-untyped-defs is set. - Yes outside functions. - Yes in annotated functions. - No otherwise. Trr)r"check_untyped_defsr1rr~r]r)rO current_index current_funcs rPin_checked_functionz$SemanticAnalyzer.in_checked_function]s < * $2E 4D/0014 q  .}=LlJ77 5'224444 Q Mq  trR)rrrDstr | ErrorMessagerfrErrorCode | Nonerc |s|sdS| J|t|tr||j}|j}|j|j|j||||j |j dS)N)rrrr) rGr~rrrfr8reportrrrr)rOrDr rfrrs rPrzSemanticAnalyzer.failws t7799  F c< ( ( |x)C  H J \~      rRc|sdS|j|j|j|d|dS)Nr)severityr)rGr8rKrr)rOrDr rs rPrzSemanticAnalyzer.notesF''))  F 38SZvDQQQQQrRfeaturec`||jjvr|d|d|d|dSdS)Nr@z;" support is experimental, use --enable-incomplete-feature=z to enableFT)r"enable_incomplete_featurer)rOrNr s rPincomplete_feature_enabledz+SemanticAnalyzer.incomplete_feature_enableds` $,@ @ @ IIHGHH4;HHH    5trRc ||dS#t$r7}t||jj|j|j|jYd}~dSd}~wwxYwrT)r Exceptionrr8filerr")rOrerrs rPrzSemanticAnalyzer.acceptsx _ KK      _ _ _ !#t{'7DKQUQ] ^ ^ ^ ^ ^ ^ ^ ^ ^ _s A,AAr'rc Bt|tr|||j|d|\}} } | r,|d||d||t| s| |dS| j s Jdt| g} t| j j | S||} || ||||||S)Nz>Generic named tuples are not supported for legacy class syntaxz:Use either Python 3 class syntax, or the assignment syntaxzNamedTuple without tuple type)rn)r'r%rrKr(r*)r~r=rrrrrrrrrrrrrr) rOrr'r%rrKr(r*rrr[rnrs rPrz&SemanticAnalyzer.expr_to_analyzed_typesH dH % % G KK   -1-F-W-WdD..00.. *M4 ^ Z\`aaa VX\]]]$+,,,  4   t? C C$C C C Cb))HT_2XFFF F**400~~ !5/) 3&?%   rRc|t5|5||dddn #1swxYwYddddS#1swxYwYdSrT)rrrerrs rPrz"SemanticAnalyzer.analyze_type_exprs " "#3#5#5 6 6  8T8T8V8V   KK                                    s4A1A A1A A1 A !A11A58A5) r0r)rKr%allow_typed_dict_special_forms allow_finalr(r*r'prohibit_self_type"prohibit_special_class_field_typesrTypeVarLikeScope | Noner)rXrYrZr[rc ||j}t|||j|j|j|j||| |||||| | | } t |jo|jd| _ |j o|j | _ | S)N) rKr)r'r%rXrYr(r*rZr[rr) r0rr9r"r#r\rr1rrrVr)rOr0r)rKr%rXrYr(r*r'rZr[rtpans rPr"zSemanticAnalyzer.type_analyzers  J   K L    & 3 3!5/+I#&?%1/Q)#   & $D$7$`D.-sd33D#t3TTrRN) r0rKr)r%rXrYr(r*r'rZr[r) rrVrxr"rrrr,r-)rOrr0r)rKr%rXrYr(r*r'rZr[rr7r{rs`` rPrzSemanticAnalyzer.anal_type sF' TTTTT    #TY #+=+E  " " "   ! 3 3/+I#&?%!51/Q)  ((**jjmm  $ $S ) ) 4   000 rRr)c*tj|SrT)rmake_normalized)rOr)s rPrTzSemanticAnalyzer.class_typeGs' 222rRprioritypatchCallable[[], None]c>|j||fdSrT)r!r)rOrdres rPrzSemanticAnalyzer.schedule_patchJs# Xu-.....rRctd|jD]\}}td|d||jdddddS)NzDeferral trace:z :rzAINTERNAL ERROR: maximum semantic analysis iteration count reachedTr)printrIr8rK)rOr8rs rP report_hangzSemanticAnalyzer.report_hangMs~    4 ' 'IC %%%t%% & & & &    O      rRtriggerrc||j}|jj|t |dS)zyAdd dependency from trigger to a target. If the target is not given explicitly, use the current target. N)rHcurrent_targetr# plugin_depsrrBr )rOrlrs rPadd_plugin_dependencyz&SemanticAnalyzer.add_plugin_dependencyXsP >Z..00F %00#%%@@DDVLLLLLrRr-Collection[str]c|sdS||j}|jj||dS)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)rHrnr# alias_depsupdate)rOr-rs rPr,z$SemanticAnalyzer.add_type_alias_depsasP  F >Z..00F $V,33LAAAAArRc4t|dz|jvSNr6)rr&rs rPr7z"SemanticAnalyzer.is_mangled_globalqs~~#t|33rRc.|t|dzkSrv)rrs rPr8z*SemanticAnalyzer.is_initial_mangled_globalusx~~+++rR bool | Nonec t|SrT)rrs rPrzSemanticAnalyzer.parse_boolys$rRc t|tr|jSt|tr\t|jt rB|jj6t|jj}|t|dkr|dSdS)zzAttempt to find the string literal value of the given expression. Returns `None` if no literal value can be found.Nrr) r~ryrfrqrrrVrr)rOrrs rPparse_str_literalz"SemanticAnalyzer.parse_str_literal}s dG $ $ :  dG $ $ !DIs)C)C ! Hb7 GGF!c&kkQ&6&6ay trR module_namec|tvr7|j|jjt|dSdSrT)rr%rfuture_import_flagsr )rOr|s rPr0z(SemanticAnalyzer.set_future_import_flagssA . ( ( L ) = A A.Q\B] ^ ^ ^ ^ ^ ) (rRflagcL|j|j|SrT)r%rrc)rOrs rPrcz#SemanticAnalyzer.is_future_flag_sets|DO,??EEErRrEcvt}t|j|jD]\}}||dkr|||_)t |||}|=|dkr||_K|dkr||_Y|dkr||_ g|dkr||_ u| d|d||S) zqBuild a DataclassTransformSpec from the arguments passed to the given call to typing.dataclass_transform.Nfield_specifiers eq_default order_defaultkw_only_defaultfrozen_defaultz,Unrecognized dataclass_transform parameter "r@) rErQrGrd*parse_dataclass_transform_field_specifiersrrrrrrr)rOr parametersrrfbooleans rPrz/SemanticAnalyzer.parse_dataclass_transform_specs,-- t~ty99 X XKD%|))).2.].]// +3D%FFG|##(/ %%((+2 ((***-4 **))),3 )) PPPPRVWWWWrRr c"t|ts|d|dSg}|jD]J}t|ts|d|dS||jKt|S)Nz3"field_specifiers" argument must be a tuple literalrAz0"field_specifiers" must only contain identifiers)r~rrrrqrrrr)rOr rq specifiers rPrz;SemanticAnalyzer.parse_dataclass_transform_field_specifierss#y))  IIKS Q Q Q2 - -Ii11  LiXXXrr LL+ , , , ,U||rRor\cdSrTrArOrs rPvisit_int_exprzSemanticAnalyzer.visit_int_exprtrRrycdSrTrArs rPvisit_str_exprzSemanticAnalyzer.visit_str_exprrrRr<cdSrTrArs rPvisit_bytes_exprz!SemanticAnalyzer.visit_bytes_exprrrRrOcdSrTrArs rPvisit_float_exprz!SemanticAnalyzer.visit_float_exprrrRrAcdSrTrArs rPvisit_complex_exprz#SemanticAnalyzer.visit_complex_exprrrRrJcdSrTrArs rPvisit_ellipsiszSemanticAnalyzer.visit_ellipsisrrRr~cdSrTrArs rPvisit_temp_nodez SemanticAnalyzer.visit_temp_noderrRrmcdSrTrArs rPvisit_pass_stmtz SemanticAnalyzer.visit_pass_stmtrrRrcdSrTrArs rPvisit_singleton_patternz(SemanticAnalyzer.visit_singleton_patternrrR) r%r$r<r6r=r6r8rr9rr>r?)r>r-)r>r)r>r`)F)rfrrgrr>r`)rkrcr>r?)rkrcrvrwr>r?rT)rrr!r3r_rrkrcr"rrr-r>r?)rrcr>r?) rrcrrrrrrr>r?)r>r?)rkrcr"rrr-r>r`)rrRr>r?)rrrr>r)rrRrrr>r)rNrRrrr7rr>r?)rrr[rr>r)rfrgrhrir>r)rmrrrSr>r)rrjr>r?)rarr>r`)rrLr>r)rrjr>r)rrjrr*rrr>r?)rrjr>r)rNrr>r?)rrSr>r?)rrr>r?)rrSr>r?)rrFr>r?)rrrrCr>r?)rr?r>r?)rrrrCr>r)rrr>r)rrrrCr>r")rrr>r?)rZrdr>r?)rr?r[rgr>r?)rr?r>r)rr?r[rgr>r)rrLr>r)rrr>r?)rr?rrLr>r?)rr?rrrrLr>r?)rr?rBrdrrCr>r)r?rr>r)rrr>r)FF)rrrrrrr>r)rrr>r)rBrdr r*r>r)rrrrCr>rg)rrdr>rgr)rr?rr-ryrr>r?)rr?r>r)rBrdr>r)rr?rZrr>r?)rr?r?rr>r)rr?rrr>r?)rrr rr>r)rrrrr>r)rr?r`rr>r?)rrWr>r?)r+rZr>r?)rr}r5rrrr(rrrrrrrrYr>r?)T)r=rr>rr(rrrrrrrfr$rr>r?) r(rrKr}rLr}rMrYr>r)rrUr>r)rrXr>r?)r r7r>r?)r r7r>r)r r8r>r?)r r8r>r)rrLr>r)rrLrrr>r)rrLrrr>rrrLr>r)rrdr>rd)rRrLrrr>r)FNNF)rrrRrLr%rrrrrrfrr>r)rRrLrrr>r)rRr=r>r)r rrr r rCr>r?)FFFFFF)rr`rrrrrrr_rr`rr$rr>r?)rQrerrrrr_rr`rr$rr>r?)r.rrrr>r) rQrer.rr;rr`rr$rr>r)rrerrrrr>r?)rrrrr>r?) rrbrrrrr`rr>r?)rKrbr>r)rrMr rCr>r?)rQr`rrr>r?)rrrrCr>r)rr=rrrrCr>r)r r8rirjr>rk) rdrdrqrmrnrorprrrCr>rq)rrr}rr|rLrrCrKrr(rr*rrrr>r)r r8rr=r>r)rrrrrrr>r)rrdr>r)rrr>r)rrr>r)rrCr>r?)rrrrLr r8r>r?)rtr:r>r?)rtrr>r?)r rMr>r?)r rrr>r?)r rpr>r?)r r5r>r?)r rhr>r?)r rr>r?)r rPr>r?)r r;r>r?)r rDr>r?)r rVr>r?)r rr>r?)r rrrr>r?)r rr>r?)r rGr>r?)r rLr>r)rrUr>r?)rrgr>r?)r rar>r?)r rr>r?)rrer>r?)rrerer}r>r?)rrzr>r?)rrr>r?)rr_r>r?)rrur>r?)rrHr>r?)rrwr>r?)rrr>r?)rr=r>r?)rr=r>r*)rr=r.rrrr>r)rrbr>r?)rrir>r?)rr@r>r?)rrr>r?)rr[r>r?)rr[r>rM)rrvr>r?)rr>r>r?)rr6r>r?)rrsr>r?)rrr>r?)rr^r>r?)rrtr>r?)rrIr>r?)rrTr>r?)rrzr>r?)rr]r>r?)rrBr>r?)rror>r?)rrr>r?)rr9r>r?)rtrr>r?)rtrr>r?)rtrr>r?)rtrr>r?)rtrr>r?)rtrr>r?)rtrr>r?)rrr rCr^rr>r)rrr>r)rr{r>r)rr{r:rxr>r)rrrr>r)rrLr>r)rrcrrr>r)r6rr>r) rer}rrrrrrr>r})rr}rrrrrr>r)rrrr>r})rrrr>r)r>r)rrrrdrMr>r)rrrrdrMr>r)rrr>r)rrr>r)TFTFFF)rrrr{rrCrrrrr9rr_rrrrrr>r)rrrr{r>r?)NTFFF)rrr)r}rrr9rr_rrrrrr>r)rqr|rrr)r}r>r?)rrrrCr>r?)rrrrrrCr>r) rrrr}rrYrrrrr>r?) rrrrCrrrrrrr>r?)r rr>r`)rrrrr>r?)r>r)rrr>r)FTF) rrrrfr8rrrrrr>r?)rrrr>r) rrr.rr rCrrr>r?)rrr.rr rCr>r?)rrr>r)rrr>r`)r>r)r_rrrr>r|)r(r)r>r?)rrr rCrrr>r?) rrr rCr5r6r7rr>r?)rrr rCr5r6r>r?) rDrHr rCrfrrrIrrr>r?)rDrr rCrrIr>r?)rNrr rCr>r)rrfr>r?)TFFFFF)rrLr'rr%rrrrKrr(rr*rr>r)rrLr>r?)r0r\r)rrKrr%rrXrrYrr(rr*rr'rrZrr[rrrr>r)rrLr*rr>r)rrr0r\r)rrKrr%rrXrrYrr(rr*rr'rrZrr[rrrr>r)r)rr>r)rdrrerfr>r?)rlrrrr>r?)r-rqrrr>r?)rrLr>rx)r|rr>r?)rrr>r)rr=r>rE)r rLr>rj)rr\r>r?)rryr>r?)rr<r>r?)rrOr>r?)rrAr>r?)rrJr>r?)rr~r>r?)rrmr>r?)rrr>r?(E__name__rrrrrr.rrrr^rrXr[r:r;rQrrVrYr\r_rrerjrurtrsrrrrrrrrr rr r(rrWrlrrxrrrrrrrrrrrrrrr/r0r!r.rrrrrrrrrGrMrNrArXrLrOrvrrHrrrWr{rFrrrrrrrrPrrrIrTrrrrrErrrrJrUr*r:r3r4rTrr]rdrarrjrmrrkrlrrrxrwrtrurr{rryr|r}rrrrrrrorrrrbr'r1r-r0r2r)r(rrBrrqr0r1r2rrVrYryrWrrrsrrXr~rrrrrrrrrrrrrrrrrrrrrrrrrrrrrr@rrr r rrrr)r%r$r8r=rArDrIrHrLr_rcrfrhrjrorrrvryrtrurrrrrrrrrrrrrrrrrrrrbrr2rrr2rrr/rrrrrrrrrrrr#r$rrrrrrrBrrrrrrrrr1rr/rrArrrHr9rGrrrQrrrr"rrrTrrkrpr,r7r8rr{r0rcrrrrrrrrrrrrArRrPr r Xs ;::M!       """"$$$$!E!!!!%%%%    #""" HHJ"!!!1111JM"NNNNNN"&I&&&& 687777O@O@O@O@fX"""X"+++X+%%%X%+++^+16QQQQ^Q, P P P P>$=$=$=$=b(,0*CCCCJ>>>>*>>>>(%%%%B , , , ,TX3333^3r,,,,::::: r+r+r+r+hNNNN.+C+C+C+CZB.!!!!.    : 3 3 3 3...^.L)L)L)L)\:\,,,, +1+1+1+1Z    B4!!!!&....>4 4 4 4 l////1111&&&&:     S S S SbRbRbRbRHHHHH ) ) ) ),NNNN` ^1^1^1^1@    """" KKKK"SSSS*    D!<!<!<!4>4>4>4@6666CCCC BVVVVp&&$E.E.E.E.\%**/"+/......`    BBBBH====~..////@66665555HHHHF4F4F4F4P - - - -3333.9)9)9)9)~""""        %%%% - - - -,,,,,,,,2OOOORRRR,,,,'''' + + + +0!0!0!0!d2222 ,,,,2222: * * * *o,o,o,o,j)))) / / / /    ####     "M`M`M`M`^( ,',',','\    "!!!!$$$$$ [ [ [ [DIIIIV%%%%!!!! !!!! ))))$$$$$$$$ & & & &&&&& """" ''''---- $$$$ !!!!     $    &(((( !!!!!!!!++++((((@ECCCCCJ%%%%N    !!!!&////    HHHH @E55555n:....****"2 1111f2222////\\\\\ [ [ [ [ [5555****"##&+! " " " " " H4#'&+! >>>>>@>----((((T::::>% % % % V$$$^$ DDDDD8((((////&&&&"'"# ")")")")")H6666QV;;;;; PPPP 0000%%%^%2???? UUUUBBBBCCCCGL%%%%%N    3333 (:(:(:(:(:T    4\`CCCCC \`HHHHH JJJJ<  "&      6RRRRR ____&*"'$$)*/"( ( ( ( ( T/3$)$)"'/4!*/"%))-9=$''''''R     /3$)$)"'/4!*/"%))-9=$<<<<<<|3333////     MMMMMCGBBBBB 4444,,,,        ____FFFF!!!!F    rRr Nrrrhrr>ct|trAt|jdkr|S|g|jddzSt|t r t fd|jDSJ)Nrrr=c Vg|]%}ttt|&SrA)r rrU)rCrrhs rPrDz/replace_implicit_first_type..s. X X XT, ;As C C D D X X XrR)r~rrr>rrr)rrhs `rPrUrUs#|$$  s}   " "J  C53=3D+D EEE C $ $ X X X Xci X X X     rRrrL fullnamesstr | tuple[str, ...]rct|ts|f}t|tsdS|j|vrdSt|jt rt |jj|SdS)z=Is node a name or member expression with the given full name?FT)r~rrqrrrr rr)rrs rPrrsr i ' '!L dG $ $u } !!t$)Y''> !19=== 5rRczt|to&t|jttt fS)z1Does semantically analyzed node refer to a class?)r~rqrrrRrj)rs rPrGrGs4 dG $ $  Hg'89**rRr*list[T]T | Nonec~tdt|D]}|||d|vr ||cSdS)z[If the list has duplicates, return one of the duplicates. Otherwise, return None. rN)rr)r*rs rPrrsQ 1c$ii  7d2A2h  7NNN  4rRrqr|r6rr?cg}|D]Q\}}|j |jj}|d|d}||kr||R|D]}||=dS)zrcn|jtjkr|tjS|SrT) type_of_anyrrrrrOrs rP visit_anyzMakeAnyNonExplicit.visit_anys, =I. . .??9#9:: :rRrcR|fd|jDS)Nc:g|]}|SrArrCr{rOs rPrDz.##$D$D$DQXXd^^$D$D$DrRrdrrdrs` rPvisit_type_alias_typez(MakeAnyNonExplicit.visit_type_alias_type".$D$D$D$DQV$D$D$DEEErRNrrr>rrrr>rrrrrrrArRrPrrB FFFFFFrRrcD|tS)zLReplace all Any types that come from unimported types with special form Any.)rMakeAnyNonUnimportedrs rPrr&s 88(** + ++rRceZdZd dZd dZdS) rrrr>rcr|jtjkr!|tjdS|S)Nr)rrrrrrs rPrzMakeAnyNonUnimported.visit_any,s0 =I: : :??9#9t?TT TrRrcR|fd|jDS)Nc:g|]}|SrArrs rPrDz>MakeAnyNonUnimported.visit_type_alias_type..2rrRrrrs` rPrz*MakeAnyNonUnimported.visit_type_alias_type1rrRNrrrrArRrPrr+rrRrr!r3cNt|d}|D]\}}|dS)zeCall patch callbacks in the right order. This should happen after semantic analyzer pass 3. c|dS)NrrArs rPrz1apply_semantic_analyzer_patches..:s !rR)rN)ry)r!patches_by_priorityrd patch_funcs rPapply_semantic_analyzer_patchesr5sD !nn=== 3* rRr r8list[NameExpr]cBg}|jD]}|t|z }|S)zLReturn all unqualified (short) names assigned to in an assignment statement.)rnames_modified_in_lvalue)r r9rQs rPrnrn?s2F)33*6222 MrRrQr`ct|tr|gSt|trt|jSt|t t fr g}|jD]}|t|z }|SgS)z4Return all NameExpr assignment targets in an Lvalue.)r~rerwrrr_rr)rQr9ras rPrrGs&(##x FH % %' 444 FXy1 2 2!#L 5 5D .t44 4FF IrRn1rn2ct|to2|jo+t|to|jo|j|jkS)zIDo n1 and n2 refer to the same Var derived from module-level __getattr__?)r~rrrr)rrs rPis_same_var_from_getattrrUsS 2s '  " ' r3   '  " ' K2; & rRrCcNtttjSrT)r~rrrrArRrPrr`s GI233 4 44rRrdr}ct|jtr5t|jtr|jj o |jjSdSdS)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~rrnr8)rdrhs rPrrdsN#(O,, ch 0 0 x00NSX5N N4 5rRr{rtc||kp9t|tot|tpt||SrT)r~rnr)r{rts rPrrusA Q * q/ * * Mz!_/M/M * #Aq ) )rRblockr:cP|j}|sdSt|dtr/t|djtr|jdd}t |dkrdSt |dkrdS|d}t|t rG|j}|dSt|tr|j}t|to |j dkSt|tp.t|tot|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) rr~rMrryrrpr=rrerrrmrJ)rrrrs rPr4r4}s& :D u$q'>**z$q',/P/Pz!""~ 4yyA~~t TQu 7D$ ""^y <5 dH % % ;D$))]dm?].]] dH % % 4((PZ <-P-PrR)rrrhrr>r)rrLrrr>rr)r*rr>r)rqr|r6rr>r?)rrr>r)r!r3r>r?)r r8r>r)rQr`r>r)rrrrr>r)r>rC)rdr}rhr}r>r)r{rrtrr>r)rr:r>r(Dr __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~rrrrrrrrrrrrrrrrrrrrrrrr mypy.optionsr mypy.patternsrrrrrrrr mypy.pluginrrrr mypy.pluginsrrmypy.reachabilityrrrrrrr mypy.scopermypy.semanal_enumrmypy.semanal_namedtuplermypy.semanal_newtypermypy.semanal_sharedrrrrrrrrrmypy.semanal_typeddictrmypy.tvar_scoper mypy.typeanalrrrrrrrrrrrrrr mypy.typeopsrrr mypy.typesrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrmypy.types_utilsrr mypy.typevarsr mypy.utilrrrrr mypy.visitorrrrrrrrrrrrrr rUrrGrrrrrrrrnrrrrrr4rArRrPrs000d#"""""::::::::::%%%%%%66666666666666@@@@@@@@666666661111119999999955555555IIIIIIII......-,,,,,,,yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyt!                      ;:::::......666666000000                      544444,,,,,, ZYYYYYYYYY1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111dMLLLLLLL''''''cccccccccccccc$$$$$$ GCLL!0)%"3!1!1#5!1!1+       =<<<<<<   ArArArArAr02QArArArHd            **** FFFFF7FFF,,,, FFFFF9FFF    5555"000000rR