%^gC UdZddlmZddlZddlmZddlmZddlm Z m Z ddl m Z m Z mZmZmZmZmZmZmZmZmZmZmZddlmZmZdd lmZddlZ dd l!m"Z"dd l#m$Z$m%Z%dd l&m'Z'm(Z(m)Z)e rdd l*m+Z+GddZ,e rddl-Z edZ.ee/e fZ0de1d<dZ2de1d<dZ3de1d<dZ4de1d<dZ5de1d<dZ6de1d<dZ7de1d<dZ8de1d<dZ9de1d<dZ:de1d<e2d e3d!e4d"e5d#iZ;de1d$<e;jyDcic]\}}|| c}}Z=de1d%<d&ddd&d&ddd'Z>de1d(<d)d*d+d,d-d.d/d0d1d2d3 Z?de1d4<d5d6iZ@de1d7<d1d2d8ZAde1d9<d:d;dZBde1d?<d@dAdBZCde1dC<eCjdDe?jyDeCd1=eCd2=d7dEZEdFZFde1dG<dHZGde1dI<GdJdKe,ZHeGdLdMeHZIeGdNdOeHZJGdPdQeJZKeJZLde1dR<eGdSdTeHZMee/dUedVfZNde1dW<GdXdYeMZOGdZd[eIZPGd\d]ePZQGd^d_ePZRGd`daePZSgdbZTde1dc<GdddeeHZUedfZVde1dg<GdhdieUeMeIZWGdjdkeHZXdZYde1dl<dZZde1dm<dZ[de1dn<GdodpZ\eTgdqzZ]de1dr<GdsdteUZ^e]gduzZ_de1dv<dZ`de1dw<dZade1dx<dZbde1dy<Gdzd{e^eMeIZceWecfZdGd|d}eMeIZegd~Zfde1d<GddeMZgGddeIZhGddeIZiGddeIZjGddeIZkGddeIZlGddeIZmGddeIZnGddeIZoGddeIZpGddeIZqGddeIZrGddeIZsGddeIZtGddeIZuGddeIZvGddeIZwGddeIZxGddeIZyGddeIZzGddeIZ{GddeIZ|GddeJZ}GddeJZ~d8dZGddeJZGddeJZGddeJZGddeJZGddeJZGddeJZGddeZGddeZe Gdde ZejZde1d<ejZde1d<ejZde1d<ejZde1d<ejZde1d<ejZde1d<GdɄdeJZGd˄deJZGd̈́deJZGdτdeJZGdфdeJZGdӄdeJZGdՄdeJZGdׄdeJZGdلdeJZGdۄdeJZGd݄deJZGd߄deJZGddeJZGdde^eJZGddeJZGddeJZGddeJZGddeJZGddeJZGddeJZGddeJZGddeJZGddeJZGddeJZdZde1d<dZde1d<dZde1d<dZde1d<GddeMeJZGddeZGddeZGddeZGddeJZGddeJZGd d eJZGd d eJZGd deJZGddeJZGddeJZGddeJZehdZde1d<ehdZde1d<GddVeMZGddeZedZde1d<edZde1d <ed!Zde1d"<ed#Zde1d$<Gd%d&eMZGd'd(eMZGd)dUZGd*d+ee/efZGd,d-ZÐd9d.ZĐd:d/ZŐd;d0ZeǫjyDcic]3\}}e|eur$e|eȫre|eMr|eMur||j5c}}Zde1d1< d<d2Z d= d>d3Zΐd?d4Zϐd@d5Z dA dBd6Zycc}}wcc}}w(Cz4Abstract syntax tree node classes (i.e. parse tree).) annotationsN)abstractmethod) defaultdict)Enumunique) TYPE_CHECKINGAnyCallableDictFinalIteratorListOptionalSequenceTupleTypeVarUnioncast) TypeAlias TypeGuard)trait)Options)is_typeshed_file short_type)ExpressionVisitor NodeVisitorStatementVisitor)Patternc@eZdZdZdZdddZ d d dZy) Contextz@Base type for objects that are valid as error message locations.linecolumnend_line end_columnc<||_||_d|_d|_yNr!)selfr"r#s *lib/python3.12/site-packages/mypy/nodes.py__init__zContext.__init__*s  $( &*Nct|tr||_nD|j|_|j|_|j|_|j |_|||_|||_|||_yy)zIf target is a node, pull line (and column) information into this node. If column is specified, this will override any column information coming from a node. N) isinstanceintr"r#r$r%)r(targetr#r$r%s r)set_linezContext.set_line0so fc "DI DI --DK"OODM$//DO   DK  $DM  !(DO "r+)r1)r"r.r#r.returnNoneNNN r/z Context | intr# int | Noner$r6r%r6r2r3)__name__ __module__ __qualname____doc__ __slots__r*r0r+r)r r %sOJrlsN9M+%u 9Msc|dkrtSiS)N)rE )rg)python_versions r)get_nongen_builtinsrps-6 >B>r+)ztyping.runtime_checkableztyping_extensions.runtimez#typing_extensions.runtime_checkableRUNTIME_PROTOCOL_DECOSz LAMBDA_NAMEc,eZdZdZdZddZddZd dZy) Nodez4Common base class for all non-type parse tree nodes.r<c|jtjjt }| t |S|SNoptions)acceptmypystrconvStrConvrrepr)r(anss r)__str__z Node.__str__s8kk$,,..wy.AB ;:  r+cl|jtjj|}|sJ|Srv)ryrzr{r|)r(rxr~s r)str_with_optionszNode.str_with_optionss.kk$,,..w.?@ s r+c,tdt|NzNot implemented RuntimeErrortyper(visitors r)ryz Node.accept,d4j99r+Nr2str)rxrr2rrzNodeVisitor[T]r2r=)r7r8r9r:r;rrryr<r+r)rtrts>I  :r+rtceZdZdZdZddZy) StatementzA statement node.r<c,tdt|rrrs r)ryzStatement.acceptrr+NrzStatementVisitor[T]r2r=r7r8r9r:r;ryr<r+r)rrsI:r+rceZdZdZdZddZy) ExpressionzAn expression node.r<c,tdt|rrrs r)ryzExpression.acceptrr+NrzExpressionVisitor[T]r2r=rr<r+r)rrsI:r+rceZdZdZdZy)FakeExpressionzA dummy expression. We need a dummy expression in one place, and can't instantiate Expression because it is a trait and mypyc barfs. r<N)r7r8r9r:r;r<r+r)rrs Ir+rLvaluecpeZdZdZdZeeddZeeddZed dZ e d dZ y) SymbolNodez+Nodes that can be stored in a symbol table.r<cyr'r<r(s r)rkzSymbolNode.name r+cyr'r<rs r)fullnamezSymbolNode.fullnamerr+cyr'r<rs r) serializezSymbolNode.serializes r+cf|d}tj|}|||Std|)N.classzunexpected .class )deserialize_mapgetNotImplementedError)clsdata classnamemethods r) deserializezSymbolNode.deserializes>N  $$Y/  $< !$6yk"BCCr+Nrr2r?)rr?r2r) r7r8r9r:r;propertyrrkrr classmethodrr<r+r)rrsj5I       DDr+rSymbolTableNodeTypeInfo DefinitioncBeZdZUdZdZdZded<ded<ded<d ed <d ed <d ed<ded<ded<ded<d ed<d ed<d ed<ded<ded<ded< d( d)fd Zd*dZe d+d Z e d+d!Z d,d"Z d-d#Z d.d$Zd/d%Zd0d&Zed1d'ZxZS)2MypyFilez1The abstract syntax tree of a single source file.) _fullnamepathdefs alias_depsis_bomnamesimports ignored_lines skipped_linesis_stubis_cache_skeletonis_partial_stub_package plugin_depsfuture_import_flags_is_typeshed_file)rkrrrrrlist[Statement]rzdefaultdict[str, set[str]]rboolr SymbolTablerlist[ImportBase]rzdict[int, list[str]]rzset[int]rrrrzdict[str, set[str]]rzset[str]r bool | NonercBt|||_d|_d|_||_||_tt|_ i|_ |r||_ ni|_ t|_ d|_ d|_d|_d|_t|_d|_y)NrArrfF)superr*rr"r#rrrsetrrrrrrrrrr)r(rrrr __class__s r)r*zMypyFile.__init__Hs      %c* !.D !#D  U  !&',$#&5 !%r+cBt|j|jS)zyReturn all definitions within the module (including nested). This doesn't include imported definitions. )local_definitionsrrrs r)rzMypyFile.local_definitionsds !T]];;r+cZ|jsdS|jjddS)Nrf.r1rsplitrs r)rkz MypyFile.nameks'rJT^^-A-A#-Fr-JJr+c|jSr'rrs r)rzMypyFile.fullnameo ~~r+c$|j|Sr')visit_mypy_filers r)ryzMypyFile.accepts&&t,,r+ct|jdk7xr8tjj|jj dS)Nrz __init__.)lenrosbasename startswithrs r)is_package_init_filezMypyFile.is_package_init_filevs8499~"Zrww'7'7 'B'M'Mk'ZZr+c||jvSr')r)r(flags r)is_future_flag_setzMypyFile.is_future_flag_setyst////r+c||j%t|j|j|_|jSr')rrabs_custom_typeshed_dirrr(rxs r)rzMypyFile.is_typeshed_file|s6  ! ! )%5g6U6UW[W`W`%aD "%%%r+c d|j|jj|j|j|j|j t |jdS)Nr)rrrrrrr)rrrrrrlistrrs r)rzMypyFile.serializesQ ZZ))$..9||II'+'C'C#'(@(@#A  r+c|ddk(sJ|tgg}|d|_tj|d|_|d|_|d|_|d|_d|_t|d |_ |S) NrrrrrrrTr) rrrrrrrrrrr)rrtrees r)rzMypyFile.deserializesH~+1T1+Bk* ,,T']; I L '+,E'F$!%#&t,A'B#C  r+)FN) rrrrrrrzdict[int, list[str]] | Noner2r3)r2Iterator[Definition]rrr2r)rrr2r)rxrr2rr)rr?r2r)r7r8r9r:r;__match_args__rUr*rrrkrryrrrrrr __classcell__rs@r)rrs ;I$.NN I ** L  (' M"!$$!!"" 59 &&"& & 3 &  &8<KK-[0&    r+rcReZdZUdZdZded<ded<ded<ded<d fd ZxZS) ImportBasez%Base class for all import statements.)is_unreachable is_top_level is_mypy_only assignmentsrrrrzlist[AssignmentStmt]rcZt|g|_d|_d|_d|_yNF)rr*rrrrr(rs r)r*zImportBase.__init__s. #!!r+r2r3)r7r8r9r:r;rUr*rrs@r)rrs//QI&%""r+rc@eZdZUdZdZdZded<dfd ZddZxZ S) Importzimport m [as n])idslist[tuple[str, str | None]]rc0t|||_yr')rr*r)r(rrs r)r*zImport.__init__s r+c$|j|Sr') visit_importrs r)ryz Import.accepts##D))r+)rrr2r3r r7r8r9r:r;rrUr*ryrrs@r)rrs IN %%*r+rcTeZdZUdZdZdZded<ded<ded<d fd Zd d ZxZ S) ImportFromzfrom m import x [as y], ...)idrrelativerrr.rrrcLt|||_||_||_yr')rr*rrr)r(rrrrs r)r*zImportFrom.__init__s#    r+c$|j|Sr')visit_import_fromrs r)ryzImportFrom.accept((..r+)rrrr.rrr2r3rrrs@r)rrs*%+I0N GM ''! /r+rcJeZdZUdZdZdZded<ded<d fd Zd dZxZ S) ImportAllzfrom m import *)rrrrr.rc>t|||_||_yr')rr*rr)r(rrrs r)r*zImportAll.__init__s   r+c$|j|Sr')visit_import_allrs r)ryzImportAll.accept''--r+)rrrr.r2r3rrrs@r)rrs$"I'N GM! .r+r) is_propertyis_class is_staticis_finalFUNCBASE_FLAGScVeZdZdZdZdfd ZeeddZeddZ xZ S)FuncBaseaAbstract base class for function-like nodes. N.B: Although this has SymbolNode subclasses (FuncDef, OverloadedFuncDef), avoid calling isinstance(..., FuncBase) on something that is typed as SymbolNode. This is to work around mypy bug #3603, in which mypy doesn't understand multiple inheritance very well, and will assume that a SymbolNode cannot be a FuncBase. Instead, test against SYMBOL_FUNCBASE_TYPES, which enumerates SymbolNode subclasses that are also FuncBase subclasses. ) runanalyzed_typeinfor rrris_explicit_overrideis_type_check_onlyrct|d|_d|_t|_d|_d|_d|_d|_ d|_ d|_ d|_ y)NFrf) rr*rr FUNC_NO_INFOrr rrrrrrrs r)r*zFuncBase.__init__ sZ 37 =A     $)!"'r+cyr'r<rs r)rkz FuncBase.namerr+c|jSr'rrs r)rzFuncBase.fullname"rr+rr) r7r8r9r:r;r*rrrkrrrs@r)rrsD  I$  r+r)FuncDef Decorator OverloadPartceZdZUdZdZded<ded<ded<ded <dfd Zedd Zdd Z dd Z e ddZ ddZ xZS)OverloadedFuncDefaRA logical node representing all the variants of a multi-declaration function. A multi-declaration function is often an @overload, but can also be a @property with a setter and a/or a deleter. This node has no explicit representation in the source program. Overloaded variants must be consecutive in the source file. )itemsunanalyzed_itemsimpl deprecatedlist[OverloadPart]r!r"zOverloadPart | Noner# str | Noner$ct|||_|j|_d|_d|_|r-|j|dj|djyyNr) rr*r!copyr"r#r$r0r"r#r(r!rs r)r*zOverloadedFuncDef.__init__;sW  %    MM%(--q 9 r+c|jr|jdjS|jJ|jjSr()r!rkr#rs r)rkzOverloadedFuncDef.nameEs= ::::a=%% %99( ((99>> !r+c$|j|Sr')visit_overloaded_func_defrs r)ryzOverloadedFuncDef.acceptN0066r+c Hd|jDcgc]}|jc}|jdn|jj|j|jdn|jjt |t |jdScc}w)Nr )rr!rrr#flagsr$)r!rrrr# get_flagsrr$)r(is r)rzOverloadedFuncDef.serializeQs|)-1ZZ8ZakkmZ8 II-D4993F3F3H II-D4993F3F3Ht^4//  8sBc |ddk(sJt|dDcgc]%}tttj |'c}}|j dhtttj |d|_t|jdkDr%|j|j j|j dOtjj|d}t|tjjsJ||_|d|_t%||d|d |_|Scc}w) Nrr r!r#rrrr0r$)r rrrrrr#rr!r0r"rztypesdeserialize_typer- ProperTyperr set_flagsr$)rrdrestyps r)rzOverloadedFuncDef.deserialize\sH~!4444DHM RMqT, 6 6q 9 :M R  88F  'L**@*@f*NOCH399~! SXX]]+ 88F  '**--d6l;Cc4::#8#89 99CHZ( #tG}%l+  Ss*Ec:td|jDS)Nc3<K|]}|jywr') is_dynamicriitems r)rlz/OverloadedFuncDef.is_dynamic..rs<4??$)allr!rs r)r=zOverloadedFuncDef.is_dynamicqs<<<    0 0 5 5 9    % %diidmmT__ ] tyy$++t}}dooVr+F) rDVarrEmypy.types.Type | NonerFExpression | NonerGArgKindrHrr2r3r4r5) r7r8r9r:r;rr*r0rrs@r)rCrCus*RIWN ! !0 !' !  !  !  !$"#!% W W W W  W  W Wr+rC TYPE_VAR_KINDPARAM_SPEC_KINDTYPE_VAR_TUPLE_KINDc0eZdZdZ ddZy) TypeParamrkrG upper_boundvaluesdefaultcJ||_||_||_||_||_yr'rU)r(rkrGrVrWrXs r)r*zTypeParam.__init__s(  &  r+N) rkrrGr.rVrMrWlist[mypy.types.Type]rXrMr2r3)r7r8r9r;r*r<r+r)rTrTsFDI   ,  &  (   r+rT) is_overload is_generator is_coroutineis_async_generatoris_awaitable_coroutineFUNCITEM_FLAGScXeZdZdZdZdZ d dfd Zd dZd dZxZ S) FuncItemz9Base class for nodes usable as overloaded function items.) arguments arg_names arg_kindsmin_argsmax_pos type_argsbodyr[r\r]r^r_expanded)rcrgrfct||xsg|_|jDcgc]&}|jrdn|jj (c}|_|jDcgc]}|jc}|_|jjt|jjtz|_ ||_ |xs tg|_||_||_d|_d|_d|_d|_d|_g|_d|_t3t5|jD]0}|j|||j7ks'|dz|_2ycc}wcc}w)NFrrA)rr*rcrHrDrkrdrGrecountARG_POSARG_OPTrgrhBlockrirrr[r\r]r^r_rjrfrangermax_fixed_argc)r(rcrir:rhargr2rs r)r*zFuncItem.__init__s> "bQUQ_Q_`Q_##,,$CLL4E4EEQ_`=A^^(L^c^(L NN009DNN>*+A~~a (Q1D1D1F-F !A ,a(Ls +E5*E:c|jSr')rgrs r)rqzFuncItem.max_fixed_argcs ||r+c|jduSr'rrs r)r=zFuncItem.is_dynamicsyyD  r+)NNNN) rclist[Argument] | Noneri Block | Noner:mypy.types.FunctionLike | Nonerhlist[TypeParam] | Noner2r3)r2r.r) r7r8r9r:r; __deletable__r*rqr=rrs@r)rbrbsaCI$9M,0!.2,0 &(&&, & * &  &8!r+rb) is_decoratedis_conditionalis_trivial_bodyr FUNCDEF_FLAGS NOT_ABSTRACT IS_ABSTRACTIMPLICITLY_ABSTRACTceZdZdZdZdZ d d fd Zed dZd dZ d dZ e ddZ xZ S)rzQFunction definition. This is a non-lambda function defined using 'def'. ) _namer{r|abstract_status original_def deco_liner}rdataclass_transform_spec docstringr$)rkrcrrict|||||||_d|_d|_t |_d|_d|_d|_ d|_ d|_ d|_ d|_ yr)rr*rr{r|rrr}rrrrrr$)r(rkrcrir:rhrs r)r*zFuncDef.__init__sn D#y9 !#+ %>B%)!GK%%)&*r+c|jSr'rrs r)rkz FuncDef.name6 zzr+c$|j|Sr')visit_func_defrs r)ryzFuncDef.accept:%%d++r+c d|j|j|j|jDcgc]}t |j c}|j dn|j jt|t|j|jdn|jj|jd Scc}w)Nr) rrkrrdrerr0rrr$) rrrdrer.valuerrr1r~rrr$)r(xs r)rzFuncDef.serialize=s JJ04?1#agg,? II-D4993F3F3Ht]3#3300822<<>//  @sC c |ddk(sJtg}t|dg||ddnCttjj tjj |d}|d|_t||d|d|_ |dDcgc] }t|c}|_ |d |_ |d tj|d nd|_|d |_|`|`|`|Scc}w) Nrrrkrrr0rdrerrr$)rorrrzr4 FunctionLiker5rr7rdrOrerDataclassTransformSpecrrr$rcrgrf)rrriretrs r)rzFuncDef.deserializeVsH~***Ry L  <'$**114::3N3NtTZ|3\]  Z( #tG}%[) -1+->?->->? "#45./; # . .t4N/O P $ l+ M K L @sC4)rfNNNN) rkrrcrvrirwr:rxrhryr2r3rrr)rr?r2r)r7r8r9r:r;rr*rrkryrrrrrs@r)rrs I;N +/!.2,0 ++)+ + , + * + +4, 2r+rceZdZUdZdZdZded<ded<ded<d ed <d ed <dfd ZeddZ eddZ eddZ eddZ eddZ ddZddZeddZddZxZS)rzhA decorated function. A single Decorator object can include any number of function decorators. )func decoratorsoriginal_decoratorsvarr[)rrrrrlist[Expression]rrrLrrr[ct|||_||_|j |_||_d|_yr)rr*rrr)rrr[)r(rrrrs r)r*zDecorator.__init__s:  $#-??#4  r+c.|jjSr')rrkrs r)rkzDecorator.nameyy~~r+c.|jjSr')rrrs r)rzDecorator.fullnameyy!!!r+c.|jjSr')rrrs r)rzDecorator.is_finalrr+c.|jjSr')rrrs r)rzDecorator.inforr+c.|jjSr')rrrs r)rzDecorator.typesxx}}r+c$|j|Sr')visit_decoratorrs r)ryzDecorator.acceptrr+cd|jj|jj|jdS)Nr)rrrr[)rrrr[rs r)rzDecorator.serializes8!II'')88%%'++   r+c|ddk(sJttj|dgtj|d}|d|_|S)Nrrrrr[)rrrrLr[)rrdecs r)rzDecorator.deserializesPH~,,,++DL92stTY{?[\}- r+c6|jjSr')rr=rs r)r=zDecorator.is_dynamicyy##%%r+)rrrrrrLr2r3rr)r2rr2rMrr)rr?r2r)r7r8r9r:r;rrUr*rrkrrrrryrrrr=rrs@r)rr|s TI2N M  )) H!""""-  &r+r)is_selfis_clsis_initialized_in_classis_staticmethodis_classmethodr is_settable_propertyis_suppressed_import is_classvaris_abstract_varr is_index_varfinal_unset_in_classfinal_set_in_initexplicit_self_typeis_ready is_inferredinvalid_partial_typefrom_module_getattrhas_explicit_valueallow_incompatible_override VAR_FLAGScteZdZdZdZdZd d fd Zed dZed dZ d dZ ddZ e dd Z xZS)rLzPA variable. It can refer to global/local variable or a data attribute. )rrrr final_valuerrrrrrrr rrrrrrrrrrrrr)rkrrct|||_d|_t|_||_d|_d|_d|_ |j du|_ d|_ d|_ d|_ d|_d|_d|_d|_d|_d|_d|_d|_d|_d|_d|_d|_d|_d|_d|_y)NrfFT)rr*rr VAR_NO_INFOrrrrrrrrrr rrrrrrrrrrrrrr)r(rkrrs r)r*z Var.__init__s   ,0    99,',$$# $)! $!%*! GK$)!!&#(#( #(+0(%*!r+c|jSr'rrs r)rkzVar.name4rr+c|jSr'rrs r)rz Var.fullname8rr+c$|j|Sr') visit_varrs r)ryz Var.accept<s  &&r+cd|j|j|jdn|jjt |t d}|j |j |d<|S)NrL)rrkrrr0r)rrrrr1rr)r(rs r)rz Var.serialize?sdJJ II-D4993F3F3HtY/      '"&"2"2D  r+c|ddk(sJ|d}|ddn!tjj|d}t||}d|_|d|_t ||d|jd|_|S) NrrLrkrFrr0r) rzr4r5rLrrr7rr)rrrkrvs r)rzVar.deserializeMsH~&&&F|F|+t1L1LTRX\1Z dO :& !T']#/ r+r')rkrrrMr2r3rrr)rr?r2rL)r7r8r9r:r;rr*rrkrryrrrrrs@r)rLrLsb I:5N4*l'   r+rLcFeZdZUdZdZdZded<ded<ded<d ed <d ed <d ed<d ed<ded<ded<d ed<ded<ded<ded<ded< d# d$fd Zed%dZ e jd&dZ d'dZ d(d Z d)d!Z ed*d"ZxZS)+ClassDefzClass definition)rkrrrh type_varsbase_type_exprsremoved_base_type_exprsr metaclassrkeywordsanalyzedhas_incompatible_baseclassrrremoved_statements)rkrrrkrrorryrhz list[mypy.types.TypeVarLikeType]rrrrrrrNrrzdict[str, Expression]rrrrrrc4t|||_d|_||_|xsg|_||_|xsg|_g|_t|_ ||_ g|_ |r t|ni|_d|_d|_d|_d|_g|_yNrfF)rr*rkrrrrhrrCLASSDEF_NO_INFOrrrdictrrrrrr) r(rkrrrrrrhrs r)r*zClassDef.__init__s   "b".4"')$$ "*2X  */'%)%)"$r+c|jSr'rrs r)rzClassDef.fullnamerr+c||_yr'rr(rs r)rzClassDef.fullname r+c$|j|Sr')visit_class_defrs r)ryzClassDef.acceptrr+c6|jjSr')r is_genericrs r)rzClassDef.is_genericrr+cd|j|j|jDcgc]}|jc}dScc}w)Nr)rrkrr)rkrrrrs r)rzClassDef.serializesA!II 15@A!++-@   AsA c  |ddk(sJt|dtg|dDcgc]C}ttjj tjj |Ec}}|d|_|Scc}w)Nrrrkrr)rrorrzr4TypeVarLikeTyper5r)rrrr9s r)rzClassDef.deserializesH~+++ L "Ik* *ATZZ//1L1LQ1OP*   J'   sAB )NNNNN)rkrrror'list[mypy.types.TypeVarLikeType] | Nonerzlist[Expression] | NonerrNrz#list[tuple[str, Expression]] | Nonerhryr2r3rrrr2r3rrr)rr?r2r)r7r8r9r:r;rrUr*rrsetterryrrrrrrs@r)rrZsI&&N IN K%%//%%-- N    ## $$'' >B37'+8<,0%%%; % 1 % % %6%*% %:__-&   r+rc@eZdZUdZdZdZded<dfd ZddZxZ S) GlobalDeclzDeclaration global x, y, ...r list[str]rc0t|||_yr'rr*rr(rrs r)r*zGlobalDecl.__init__  r+c$|j|Sr')visit_global_declrs r)ryzGlobalDecl.acceptrr+rrr2r3rrrs@r)rrs &IN /r+rc@eZdZUdZdZdZded<dfd ZddZxZ S) NonlocalDeclzDeclaration nonlocal x, y, ...rrrc0t|||_yr'rrs r)r*zNonlocalDecl.__init__rr+c$|j|Sr')visit_nonlocal_declrs r)ryzNonlocalDecl.accept**400r+rrrrs@r)rrs (IN 1r+rc6eZdZdZdZdddfdZddZxZS)ro)rirF)rc>t|||_||_yr')rr*rir)r(rirrs r)r*zBlock.__init__s  -r+c$|j|Sr') visit_blockrs r)ryz Block.accepts""4((r+)rirrrr2r3r)r7r8r9r;rr*ryrrs@r)roros*I/NHM-)r+roc@eZdZUdZdZdZded<dfd ZddZxZ S) ExpressionStmtz/An expression as a statement, such as print(s).exprrrc0t|||_yr'rr*rr(rrs r)r*zExpressionStmt.__init__   r+c$|j|Sr')visit_expression_stmtrs r)ryzExpressionStmt.accept,,T22r+rrr2r3rrrs@r)rrs 9IN 3r+rceZdZUdZdZdZded<ded<ded <ded <d ed <d ed <d ed<d ed< d dfd ZddZxZ S)AssignmentStmtabAssignment statement. The same node class is used for single assignment, multiple assignment (e.g. x, y = z) and chained assignment (e.g. x = y = z), assignments that define new names, and assignments with explicit types ("# type: t" or "x: t [= ...]"). An lvalue can be NameExpr, TupleExpr, ListExpr, MemberExpr, or IndexExpr. )lvaluesrvaluerr new_syntax is_alias_def is_final_definvalid_recursive_alias)r rvaluesr list[Lvalue]r rr rMrrrr rrrct|||_||_||_||_||_d|_d|_d|_ yr) rr*r r rrr rrr)r(r r rr rs r)r*zAssignmentStmt.__init__BsL    #$!!',$r+c$|j|Sr')visit_assignment_stmtrs r)ryzAssignmentStmt.acceptSrr+r) r rr rrrMr rr2r3rrrs@r)r r s I4N    ++"! (, ---% -  -  -"3r+r cTeZdZUdZdZdZded<ded<ded <d fd Zd d ZxZ S)OperatorAssignmentStmtz,Operator assignment statement such as x += 1)oplvaluer )rrr rrrrrr cLt|||_||_||_yr')rr*rrr )r(rrr rs r)r*zOperatorAssignmentStmt.__init__bs#   r+c$|j|Sr')visit_operator_assignment_stmtrs r)ryzOperatorAssignmentStmt.accepth55d;;r+)rrrrr rr2r3rrrs@r)rrWs*6*I/N G N  t|||_||_yr')rr*rr<)r(rr<rs r)r*zAssertStmt.__init__s  r+c$|j|Sr')visit_assert_stmtrs r)ryzAssertStmt.acceptrr+r')rrr<rNr2r3rr(rs@r)r;r;s#I$N   /r+r;c<eZdZUdZdZded<dfd ZddZxZS)DelStmtrrrc0t|||_yr'rrs r)r*zDelStmt.__init__rr+c$|j|Sr')visit_del_stmtrs r)ryzDelStmt.acceptrr+)rrr2r3rr(rs@r)rArAsIN L,r+rAceZdZdZddZy) BreakStmtr<c$|j|Sr')visit_break_stmtrs r)ryzBreakStmt.acceptr r+Nrr7r8r9r;ryr<r+r)rFrFs I.r+rFceZdZdZddZy) ContinueStmtr<c$|j|Sr')visit_continue_stmtrs r)ryzContinueStmt.acceptrr+NrrIr<r+r)rKrKs I1r+rKceZdZdZddZy)PassStmtr<c$|j|Sr')visit_pass_stmtrs r)ryzPassStmt.acceptrr+NrrIr<r+r)rOrOs I-r+rOcPeZdZUdZdZded<ded<ded<d fd Zd d ZxZS) IfStmtr rr list[Block]rirwr!cLt|||_||_||_yr'r#r$s r)r*zIfStmt.__init__r%r+c$|j|Sr') visit_if_stmtrs r)ryz IfStmt.accept$$T**r+)rrrirTr!rwr2r3rr(rs@r)rSrSs)-I2N  # +r+rScFeZdZUdZdZded<ded<dfd ZddZxZS) RaiseStmt)r from_exprrNrr[c>t|||_||_yr')rr*rr[)r(rr[rs r)r*zRaiseStmt.__init__s  "r+c$|j|Sr')visit_raise_stmtrs r)ryzRaiseStmt.acceptr r+)rrNr[rNr2r3rr(rs@r)rZrZ s%%I*N   # .r+rZceZdZUdZdZded<ded<ded<ded <d ed <d ed <d ed< dfd ZddZxZS)TryStmt)rir4varshandlersr! finally_bodyis_starrorilist[Expression | None]r4list[NameExpr | None]rarTrbrwr!rcrrdct|||_||_||_||_||_||_d|_yr) rr*rirar4rbr!rcrd)r(rirar4rbr!rcrs r)r*zTryStmt.__init__-sB      "( r+c$|j|Sr')visit_try_stmtrs r)ryzTryStmt.accept?rr+)rirorarfr4rerbrTr!rwrcrwr2r3rr(rs@r)r`r`s]IbN K ""  M$'     # $,r+r`ceZdZUdZdZded<ded<ded<d ed <d ed <d ed< d dfd ZddZxZS)WithStmt)rr/ranalyzed_typesrir0)rr/rirrlist[Lvalue | None]r/rMrrZrlrorirr0cvt|||_||_||_g|_||_d|_yr)rr*rr/rrlrir0)r(rr/ri target_typers r)r*zWithStmt.__init__Qs<   *   r+c$|j|Sr')visit_with_stmtrs r)ryzWithStmt.accept`rr+r') rrr/rmrirororMr2r3rr(rs@r)rkrkCsn[I/N  ++)) KN/3  $   ,   -r+rkcneZdZUdZdZded<ded<ded<ded < d fd Zd d ZxZS) MatchStmt)subjectpatternsguardsbodiesrrt list[Pattern]rurervrTrwct|t|t|cxk(rt|k(sJJ||_||_||_||_yr')rr*rrtrurvrw)r(rtrurvrwrs r)r*zMatchStmt.__init__nsQ 8}F :s6{:::::     r+c$|j|Sr')visit_match_stmtrs r)ryzMatchStmt.accept|r r+) rtrrurxrvrerwrTr2r3rr(rs@r)rsrsds_;I@N  ##     (     .r+rscdeZdZUdZdZded<ded<ded<d ed <d ed <dfd ZddZxZS) TypeAliasStmt)rkrhrr alias_node)rkrhrNameExprrklist[TypeParam]rh LambdaExprrrrTypeAlias | Noner~cht|||_||_||_d|_d|_yr)rr*rkrhrrr~)r(rkrhrrs r)r*zTypeAliasStmt.__init__s2  " ',$r+c$|j|Sr')visit_type_alias_stmtrs r)ryzTypeAliasStmt.acceptrr+)rkrrhrrrr2r3rr(rs@r)r}r}s4WI3N N !!  3r+r}c@eZdZUdZdZdZded<dfd ZddZxZ S) IntExprzInteger literalrr.rc0t|||_yr'rr*rr(rrs r)r*zIntExpr.__init__rr+c$|j|Sr')visit_int_exprrs r)ryzIntExpr.acceptrr+)rr.r2r3rrrs@r)rrsIN J,r+rc@eZdZUdZdZdZded<dfd ZddZxZ S) StrExprzString literalrrrc0t|||_yr'rrs r)r*zStrExpr.__init__rr+c$|j|Sr')visit_str_exprrs r)ryzStrExpr.acceptrr+rrr2r3rrrs@r)rrsIN J,r+rc&td|DS)Nc3<K|]}t|tywr')r-rr>s r)rlz"is_StrExpr_list..s9STz$(Sr@)rA)seqs r)is_StrExpr_listrs 9S9 99r+c@eZdZUdZdZdZded<dfd ZddZxZ S) BytesExprz Bytes literalrrrc0t|||_yr'rrs r)r*zBytesExpr.__init__rr+c$|j|Sr')visit_bytes_exprrs r)ryzBytesExpr.acceptr r+rrrrs@r)rrs!IN J.r+rc@eZdZUdZdZdZded<dfd ZddZxZ S) FloatExprz Float literalrfloatrc0t|||_yr'rrs r)r*zFloatExpr.__init__rr+c$|j|Sr')visit_float_exprrs r)ryzFloatExpr.acceptr r+)rrr2r3rrrs@r)rrsIN L.r+rc@eZdZUdZdZdZded<dfd ZddZxZ S) ComplexExprzComplex literalrcomplexrc0t|||_yr'rrs r)r*zComplexExpr.__init__rr+c$|j|Sr')visit_complex_exprrs r)ryzComplexExpr.accept))$//r+)rrr2r3rrrs@r)rrsIN N0r+rceZdZdZdZddZy) EllipsisExprzEllipsis (...)r<c$|j|Sr')visit_ellipsisrs r)ryzEllipsisExpr.acceptrr+Nrrr<r+r)rrsI,r+rcJeZdZUdZdZdZded<ded<d fd Zd dZxZ S) StarExprzStar expression)rvalidrrrrc>t|||_d|_yr)rr*rrrs r)r*zStarExpr.__init__s   r+c$|j|Sr')visit_star_exprrs r)ryzStarExpr.acceptrr+rrrrs@r)rr s%!I&N  K-r+rc`eZdZdZdZdfd ZeddZejddZxZ S) RefExprz,Abstract base class for name-like constructs)rGnoder is_new_defis_inferred_defis_alias_rvalue type_guardtype_isct|d|_d|_d|_d|_d|_d|_d|_d|_ yr) rr*rGrrrrrrrrs r)r*zRefExpr.__init__.sJ  $ '+  %$26/3 r+c|jSr'rrs r)rzRefExpr.fullnameDrr+c||_yr'rrs r)rzRefExpr.fullnameHrr+rrr) r7r8r9r:r;r*rrrrrs@r)rr s>6 I4,__r+rc<eZdZdZdZdZdfd ZddZd dZxZ S) rzOName expression This refers to a local name, global name or a module. )rkis_special_form)rkrc>t|||_d|_yr)rr*rkr)r(rkrs r)r*zNameExpr.__init__Ws  $r+c$|j|Sr')visit_name_exprrs r)ryzNameExpr.accept]rr+cJd|)NzSerializing NameExpr: r<rs r)rzNameExpr.serialize`s5.tf55ur+)rkrr2r3rr) r7r8r9r:r;rr*ryrrrs@r)rrMs# ,I%N% -6r+rc4eZdZdZdZdZdfd ZddZxZS) MemberExprzMember access expression x.y)rrkdef_var)rrkrcLt|||_||_d|_yr')rr*rrkr)r(rrkrs r)r*zMemberExpr.__init__ks%   $( r+c$|j|Sr')visit_member_exprrs r)ryzMemberExpr.acceptsrr+)rrrkrr2r3r r7r8r9r:r;rr*ryrrs@r)rrds&+I-N(/r+rcPeZdZdZdZdZdZdZdZd ddZ d ddZ dd Z dd Z dd Z y )rOrrArCrEcH|tk(xs|tk(xs |xr |tk(Sr')rmrnARG_STARr(stars r) is_positionalzArgKind.is_positionals$wP$'/Pd6Otx?OPr+cH|tk(xs|tk(xs |xr |tk(Sr') ARG_NAMED ARG_NAMED_OPT ARG_STAR2rs r)is_namedzArgKind.is_nameds&y YDM$9Yd>XtyGXYr+c*|tk(xs |tk(Sr')rmrrs r) is_requiredzArgKind.is_requiredsw3$)"33r+c*|tk(xs |tk(Sr')rnrrs r) is_optionalzArgKind.is_optionalsw7$-"77r+c*|tk(xs |tk(Sr')rrrs r)rdzArgKind.is_starsx449#44r+NrK)rrr2rr)r7r8r9rmrnrrrrrrrrrdr<r+r)rOrOxs=GGHIIMQZ485r+rOrmrnrrrrcNeZdZdZdZdZ d dfd ZddZxZS) CallExprzCall expression. This can also represent several special forms that are syntactically calls such as cast(...) and None # type: .... )calleeargsrerdr)rrrerdct||sdgt|z}||_||_||_||_||_yr')rr*rrrrerdr)r(rrrerdrrs r)r*zCallExpr.__init__sH T*I  "+4! r+c$|j|Sr')visit_call_exprrs r)ryzCallExpr.acceptrr+r') rrrrre list[ArgKind]rdzlist[str | None]rrNr2r3rrrs@r)rrs^ IIAN'+ !!!! ! $ ! $ ! !*-r+rc<eZdZUdZdZded<dfd ZddZxZS) YieldFromExprrrrc0t|||_yr'rrs r)r*zYieldFromExpr.__init__rr+c$|j|Sr')visit_yield_from_exprrs r)ryzYieldFromExpr.acceptrr+rrr(rs@r)rrsIN 3r+rc<eZdZUdZdZded<dfd ZddZxZS) YieldExprrrNrc0t|||_yr'rrs r)r*zYieldExpr.__init__rr+c$|j|Sr')visit_yield_exprrs r)ryzYieldExpr.acceptr r+r9rr(rs@r)rrsIN .r+rc^eZdZUdZdZdZded<ded<ded<d ed <d fd Zdd ZxZ S) IndexExprzaIndex expression x[y]. Also wraps type application such as List[int] as a special form. )baser+ method_typer)rr+rrr+rMrz&TypeApplication | TypeAliasExpr | NonercZt|||_||_d|_d|_yr')rr*rr+rr)r(rr+rs r)r*zIndexExpr.__init__s+    r+c$|j|Sr')visit_index_exprrs r)ryzIndexExpr.acceptr r+)rrr+rr2r3rrrs@r)rrs8 =I&N  ''54.r+rcTeZdZUdZdZdZded<ded<ded <d fd Zd d ZxZ S) UnaryExprzUnary operation)rrr)rrrrrrrMrcLt|||_||_d|_yr')rr*rrr)r(rrrs r)r*zUnaryExpr.__init__ s$  r+c$|j|Sr')visit_unary_exprrs r)ryzUnaryExpr.acceptr r+)rrrrr2r3rrrs@r)rrs+-I#N G '' .r+rc4eZdZdZdZdZdfd ZddZxZS)AssignmentExprz5Assignment expressions in Python 3.8+, like "a := 2".)r/rc>t|||_||_yr')rr*r/r)r(r/rrs r)r*zAssignmentExpr.__init__s   r+c$|j|Sr')visit_assignment_exprrs r)ryzAssignmentExpr.accept rr+)r/rrrr2r3rrrs@r)rrs?#I(N 3r+rceZdZUdZdZdZded<ded<ded<d ed <d ed <d ed <ded< d dfd ZddZxZ S)OpExprz^Binary operation. The dot (.), [] and comparison operators have more specific nodes. )rleftrightr right_alwaysright_unreachabler)rrrrrrrrrMrrrrTypeAliasExpr | Nonerct|||_||_||_d|_d|_d|_||_yr) rr*rrrrrrr)r(rrrrrs r)r*zOpExpr.__init__BsD   !!&  r+c$|j|Sr') visit_op_exprrs r)ryz OpExpr.acceptNrXr+r') rrrrrrrrr2r3rrrs@r)rr$sx I-N G  ''""^b ! !' !0: !FZ !  !+r+rc\eZdZUdZdZdZded<ded<ded <d fd Zdd Zdd Z xZ S)ComparisonExprz+Comparison expression (e.g. a < b > c < d).) operatorsoperands method_types)rr rr rrzlist[mypy.types.Type | None]rcLt|||_||_g|_yr')rr*r rr)r(r rrs r)r*zComparisonExpr.__init__^s$ "  r+c#Kt|jD])\}}||j||j|dzf+yw)zzIf this comparison expr is "a < b is c == d", yields the sequence ("<", a, b), ("is", b, c), ("==", c, d) rAN) enumerater r)r(r2operators r)pairwisezComparisonExpr.pairwisedsB%T^^4KAxDMM!,dmmAE.BB B5sAAc$|j|Sr')visit_comparison_exprrs r)ryzComparisonExpr.acceptkrr+)r rrrr2r3)r2z,Iterator[tuple[str, Expression, Expression]]r) r7r8r9r:r;rrUr*rryrrs@r)r r Rs259I.N.. C3r+r cdeZdZUdZdZdZded<ded<ded< d fd Zd dZxZ S) SliceExprznSlice expression (e.g. 'x:y', 'x:', '::2' or ':'). This is only valid as index in index expressions. ) begin_index end_indexstriderNrrrcLt|||_||_||_yr')rr*rrr)r(rrrrs r)r*zSliceExpr.__init__}s& &" r+c$|j|Sr')visit_slice_exprrs r)ryzSliceExpr.acceptr r+)rrNrrNrrNr2r3rrrs@r)rrosV 7I;N""   & % "   .r+rcJeZdZUdZdZdZded<ded<d fd Zd dZxZ S) CastExprz!Cast expression cast(type, expr).rrrrmypy.types.Typerc>t|||_||_yr'rr*rrr(rr:rs r)r*zCastExpr.__init__   r+c$|j|Sr')visit_cast_exprrs r)ryzCastExpr.acceptrr+rrr:r"r2r3rrrs@r)r r s&+ I%N   -r+r cJeZdZUdZdZdZded<ded<d fd Zd dZxZ S) AssertTypeExprz1Represents a typing.assert_type(expr, type) call.r!rrr"rc>t|||_||_yr'r$r%s r)r*zAssertTypeExpr.__init__r&r+c$|j|Sr')visit_assert_type_exprrs r)ryzAssertTypeExpr.accept--d33r+r)rrrs@r)r+r+s&; I%N   4r+r+cneZdZUdZdZdZded<ded<ded< d d fd Zd d ZxZ S) RevealExprzGReveal type expression reveal_type(expr) or reveal_locals() expression.)rrG local_nodes is_importedrNrr.rGlist[Var] | Noner2cZt|||_||_||_||_yr')rr*rrGr2r3)r(rGrr2r3rs r)r*zRevealExpr.__init__s.   &&r+c$|j|Sr')visit_reveal_exprrs r)ryzRevealExpr.acceptrr+)NNF) rGr.rrNr2r4r3rr2r3rrrs@r)r1r1sfQ>ICN  I!! #'(,! ' '  '& '  '  '/r+r1cTeZdZUdZdZdZded<ded<ded <d fd Zd d ZxZ S) SuperExprzExpression super().name)rkrcall)rkr:rrrkTypeInfo | Nonerrr:cLt|||_||_d|_yr')rr*rkr:r)r(rkr:rs r)r*zSuperExpr.__init__s#    r+c$|j|Sr')visit_super_exprrs r)ryzSuperExpr.acceptr r+)rkrr:rr2r3rrrs@r)r9r9s*!(I-N I  N .r+r9c>eZdZdZdZeddZd dZd dZd dZ y) rzLambda expression)rcrdrerictSr')rrrs r)rkzLambdaExpr.namesr+c||jjd}t|tsJ|j}|J|S)z/Return the expression (the body) of the lambda.r1)rir-r5r)r(rrs r)rzLambdaExpr.exprs>iinnR #z***xx r+c$|j|Sr')visit_lambda_exprrs r)ryzLambdaExpr.acceptrr+cyrr<rs r)r=zLambdaExpr.is_dynamicsr+Nr)r2rrr) r7r8r9r:rrrkrryr=r<r+r)rrs+DN /r+rc@eZdZUdZdZdZded<dfd ZddZxZ S) ListExprzList literal expression [...].r!rr!c0t|||_yr'rr*r!r*s r)r*zListExpr.__init__ rr+c$|j|Sr')visit_list_exprrs r)ryzListExpr.accept rr+r!rr2r3rrrs@r)rFrFs (IN -r+rFc@eZdZUdZdZdZded<dfd ZddZxZ S) DictExprz0Dictionary literal expression {key: value, ...}.rG*list[tuple[Expression | None, Expression]]r!c0t|||_yr'rIr*s r)r*zDictExpr.__init__ rr+c$|j|Sr')visit_dict_exprrs r)ryzDictExpr.accept rr+)r!rOr2r3rrrs@r)rNrN s :IN 55-r+rNc@eZdZUdZdZdZded<dfd ZddZxZ S) TupleExprzXTuple literal expression (..., ...) Also lvalue sequences (..., ...) and [..., ...]rGrr!c0t|||_yr'rIr*s r)r*zTupleExpr.__init__( rr+c$|j|Sr')visit_tuple_exprrs r)ryzTupleExpr.accept, r r+rLrrrs@r)rTrT s$7IN .r+rTc@eZdZUdZdZdZded<dfd ZddZxZ S) SetExprz$Set literal expression {value, ...}.rGrr!c0t|||_yr'rIr*s r)r*zSetExpr.__init__9 rr+c$|j|Sr')visit_set_exprrs r)ryzSetExpr.accept= rr+rLrrrs@r)rYrY0 s .IN ,r+rYceZdZUdZdZdZded<ded<ded <d ed <d ed < dfd ZddZxZ S) GeneratorExprzGGenerator expression ... for ... in ... [ for ... in ... ] [ if ... ].) left_expr sequences condlistsr0indices)r_rbr`rarr_rr`list[list[Expression]]ra list[bool]r0rrbcht|||_||_||_||_||_yr')rr*r_r`rarbr0)r(r_rbr`rar0rs r)r*zGeneratorExpr.__init__N s3 """   r+c$|j|Sr')visit_generator_exprrs r)ryzGeneratorExpr.accept] ++D11r+) r_rrbrr`rrarcr0rdr2r3rrrs@r)r^r^A srQNIGN%%  ! ! !$ ! * !  !  !2r+r^c@eZdZUdZdZdZded<dfd ZddZxZ S) ListComprehensionz,List comprehension (e.g. [x + 1 for x in a]) generatorr^rlc0t|||_yr'rr*rlr(rlrs r)r*zListComprehension.__init__j  "r+c$|j|Sr')visit_list_comprehensionrs r)ryzListComprehension.acceptn s//55r+rlr^r2r3rrrs@r)rjrja s 6I#N#6r+rjc@eZdZUdZdZdZded<dfd ZddZxZ S) SetComprehensionz+Set comprehension (e.g. {x + 1 for x in a})rkr^rlc0t|||_yr'rnros r)r*zSetComprehension.__init__{ rpr+c$|j|Sr')visit_set_comprehensionrs r)ryzSetComprehension.accept s..t44r+rsrrrs@r)rurur s 5I#N#5r+ruceZdZUdZdZdZded<ded<ded<d ed <d ed <d ed< dfd ZddZxZ S)DictionaryComprehensionz3Dictionary comprehension (e.g. {k: v for k, v in a})keyrr`rar0rb)r{rrbr`rarr{rrr`rcrardr0rrbcvt|||_||_||_||_||_||_yr')rr*r{rr`rarbr0)r(r{rrbr`rar0rs r)r*z DictionaryComprehension.__init__ s:  ""   r+c$|j|Sr')visit_dictionary_comprehensionrs r)ryzDictionaryComprehension.accept rr+)r{rrrrbrr`rrarcr0rdr2r3rrrs@r)rzrz s=QIJN O %% ! !! ! $ ! * !! !"t|||_||_yr')rr*rr4)r(rr4rs r)r*zTypeApplication.__init__ s   r+c$|j|Sr')visit_type_applicationrs r)ryzTypeApplication.accept r/r+)rrr4rZr2r3rrrs@r)rr s&*!I&N    4r+r INVARIANT COVARIANT CONTRAVARIANTVARIANCE_NOT_READYceZdZUdZdZded<ded<ded<ded<d ed <ed d f dfd ZeddZ eddZ xZ S)TypeVarLikeExprzBase class for TypeVarExpr, ParamSpecExpr and TypeVarTupleExpr. Note that they are constructed by the semantic analyzer. )rrrVrXvariance is_new_stylerrrr"rVrXr.rFr1czt||||_||_||_||_||_||_yN)r")rr*rrrVrXrr) r(rkrrVrXrrr"rs r)r*zTypeVarLikeExpr.__init__ sA d# !&   (r+c|jSr'rrs r)rkzTypeVarLikeExpr.name rr+c|jSr'rrs r)rzTypeVarLikeExpr.fullname rr+)rkrrrrVr"rXr"rr.rrr"r.r2r3r) r7r8r9r:r;rUrr*rrkrrrs@r)rr s ]I JN!  M"")))% ) ! )  ))) )$r+rceZdZUdZdZdZded<eddf d fd Zd d Z dd Z e dd Z xZ S) TypeVarExprarType variable expression TypeVar(...). This is also used to represent type variables in symbol tables. A type variable is not valid as a type unless bound in a TypeVarLikeScope. That happens within: 1. a generic class that uses the type variable as a type argument or 2. a generic function that refers to the type variable in its signature. )rW)rkrWrVrXrZrWFr1c @t ||||||||||_yr)rr*rW) r(rkrrWrVrXrrr"rs r)r*zTypeVarExpr.__init__" s) xgx\`a r+c$|j|Sr')visit_type_var_exprrs r)ryzTypeVarExpr.accept0 rr+cd|j|j|jDcgc]}|jc}|jj|j j|j dScc}w)Nr)rrkrrWrVrXr)rrrWrrVrXr)r(ts r)rzTypeVarExpr.serialize3 sg#JJ.2kk:kq{{}k:++557||--/   ;sA? c .|ddk(sJt|d|d|dDcgc]!}tjj|#c}tjj|dtjj|d|dScc}w) NrrrkrrWrVrXr)rrzr4r5)rrrs r)rzTypeVarExpr.deserialize> sH~... L  59(^ D^TZZ ( ( +^ D JJ ' '](; < JJ ' 'Y 8      Es&B )rkrrrrWrZrVr"rXr"rr.rrr"r.r2r3rr)rr?r2r)r7r8r9r:r;rrUrr*ryrrrrrs@r)rr s IAN "!""   &  %  !      1      r+rc6eZdZdZdZddZddZed dZy) ParamSpecExprr<rkrVrXc$|j|Sr')visit_paramspec_exprrs r)ryzParamSpecExpr.acceptP rhr+cd|j|j|jj|jj|j dS)Nr)rrkrrVrXr)rrrVrrXrrs r)rzParamSpecExpr.serializeS sF%JJ++557||--/   r+c |ddk(sJt|d|dtjj|dtjj|d|dS)NrrrkrrVrXr)rrzr4r5rrs r)rzParamSpecExpr.deserialize] seH~000 L   JJ ' '](; < JJ ' 'Y 8     r+Nrr)rr?r2r) r7r8r9r;rryrrrr<r+r)rrK s*I7N2   r+rceZdZUdZdZded<dZeddf d fd Zd dZ d d Z e dd Z xZ S)TypeVarTupleExprz1Type variable tuple expression TypeVarTuple(...).tuple_fallbackmypy.types.InstancerFr1c @t ||||||||||_yr)rr*r) r(rkrrVrrXrrr"rs r)r*zTypeVarTupleExpr.__init__r s* xgx\`a,r+c$|j|Sr')visit_type_var_tuple_exprrs r)ryzTypeVarTupleExpr.accept r.r+cd|j|j|jj|jj|j j|j dS)Nr)rrkrrVrrXr)rrrVrrrXrrs r)rzTypeVarTupleExpr.serialize sX(JJ++557"11;;=||--/   r+c |ddk(sJt|d|dtjj|dtjjj |dtjj|d|dS) NrrrkrrVrrXr)rrzr4r5Instancerrs r)rzTypeVarTupleExpr.deserialize sH~!3333 L   JJ ' '](; < JJ   + +D1A,B C JJ ' 'Y 8     r+)rkrrrrVr"rrrXr"rr.rrr"r.r2r3rr)rr?r2r)r7r8r9r:r;rUrrr*ryrrrrrs@r)rri s; I''7N"" - - -% - , - ! - - - -  -7      r+rc@eZdZUdZdZdZded<dfd ZddZxZ S) TypeAliasExprzType alias expression (rvalue).rrrc0t|||_yr')rr*r)r(rrs r)r*zTypeAliasExpr.__init__ rr+c$|j|Sr')visit_type_alias_exprrs r)ryzTypeAliasExpr.accept rr+)rrr2r3rrrs@r)rr s)IN O3r+rcLeZdZUdZdZdZded<ded<d d fd Zd d ZxZ S) NamedTupleExprz:Named tuple expression namedtuple(...) or NamedTuple(...).)ris_typedrrrrrc>t|||_||_yr')rr*rr)r(rrrs r)r*zNamedTupleExpr.__init__ s    r+c$|j|Sr')visit_namedtuple_exprrs r)ryzNamedTupleExpr.accept rr+rK)rrrrr2r3rrrs@r)rr s&D$IN NN! 3r+rc@eZdZUdZdZdZded<dfd ZddZxZ S) TypedDictExprz%Typed dict expression TypedDict(...).rrrc0t|||_yr')rr*r)r(rrs r)r*zTypedDictExpr.__init__ rr+c$|j|Sr')visit_typeddict_exprrs r)ryzTypedDictExpr.accept rhr+)rrr2r3rrrs@r)rr s!/IN N2r+rcTeZdZUdZdZdZded<ded<ded<d fd Zd d ZxZ S) EnumCallExprz5Named tuple expression Enum('name', 'val1 val2 ...').)rr!rWrrrr!rerWcLt|||_||_||_yr')rr*rr!rW)r(rr!rWrs r)r*zEnumCallExpr.__init__ s#    r+c$|j|Sr')visit_enum_call_exprrs r)ryzEnumCallExpr.accept rhr+)rrr!rrWrer2r3rrrs@r)rr s-?+I0N N  ## 2r+rc<eZdZUdZdZded<dfd ZddZxZS) PromoteExprz2Ducktype class decorator expression _promote(...).rumypy.types.ProperTyperc0t|||_yr')rr*r)r(rrs r)r*zPromoteExpr.__init__ rr+c$|j|Sr')visit__promote_exprrs r)ryzPromoteExpr.accept rr+)rrr2r3r) r7r8r9r:r;rUr*ryrrs@r)rr s<I 1r+rcheZdZUdZdZdZded<ded<ded< d fd Zd d ZxZ S) NewTypeExprz NewType expression NewType(...).)rkold_typerrrkrMrr;rcRt|||||_||_d|_y)N)r"r#)rr*rkrr)r(rkrr"r#rs r)r*zNewTypeExpr.__init__ s, d62    r+c$|j|Sr')visit_newtype_exprrs r)ryzNewTypeExpr.accept rr+) rkrrrMr"r.r#r.r2r3rrrs@r)rr sS*,I1N I$$ #9ADNQ 0r+rc@eZdZUdZdZdZded<dfd ZddZxZ S) AwaitExprzAwait expression (await ...).rrrc0t|||_yr'rrs r)r*zAwaitExpr.__init__ rr+c$|j|Sr')visit_await_exprrs r)ryzAwaitExpr.accept r r+rrrrs@r)rr s 'IN .r+rcfeZdZUdZdZded<ded< d dd d fd Zdd Zdd ZxZ S)TempNodezTemporary dummy node used during type checking. This node is not present in the original program; it is just an artifact of the type checker implementation. It only represents an opaque node with some fixed type. )rno_rhsr"rrrN)contextct|||_||_|#|j|_|j |_yy)zJConstruct a dummy node; optionally borrow line/column from context object.N)rr*rrr"r#)r(r:rrrs r)r*zTempNode.__init__5 s?     DI!..DK r+cJd|jt|jfzS)NzTempNode:%d(%s))r"rrrs r)__repr__zTempNode.__repr__@ s DIIs499~#>>>r+c$|j|Sr')visit_temp_noders r)ryzTempNode.acceptC rr+rK)r:r"rrrzContext | Noner2r3rr) r7r8r9r:r;rUr*rryrrs@r)rr& sX#I  L49 )W[ )" ),0 )FT )  )?-r+r> r:__new____dict__r*r;r8 __weakref__rU__subclasshook____class_getitem____abstractmethods__EXCLUDED_PROTOCOL_ATTRIBUTES>_order__ignore_ __order__EXCLUDED_ENUM_ATTRIBUTESceZdZUdZdZded<ded<ded<ded <d ed <d ed <d ed<ded<ded<ded<d ed<d ed<d ed<ded<ded<ded<ded<ded<d ed!<d ed"<d ed#<d ed$<ded%<d ed&<d ed'<d(ed)<ded*<d+ed,<d ed-<d.ed/<d ed0<d ed1<d2ed3<d4ed5<d6ed7<d8ed9<d ed:<d;ed<<gd=Zd>ed?<dXfd@ ZdYdAZe dZdBZ e dZdCZ d[dDZ d\dEZ d]dFZe d^dGZe d^dHZd_dIZdZdJZd[dKZd`dLZdadMZdbdNZd[dOZdcdPZdddQZdedRZdfdSZdZdTZ dgdUZdhdVZedidWZ xZ!S)jraThe type structure of a single class. Each TypeInfo corresponds one-to-one to a ClassDef, which represents the AST of the class. In type-theory terms, this is a "type constructor", and if the class is generic then it will be a type constructor of higher kind. Where the class is used in an actual type, it's in the form of an Instance, which amounts to a type application of the tycon to the appropriate number of arguments. ))r module_namedefnmro _mro_refsbad_mrordeclared_metaclassmetaclass_typer is_abstract is_protocolruntime_protocolabstract_attributesdeletable_attributesslotsassumingassuming_proper inferringis_enumfallback_to_anymeta_fallback_to_anyrhas_param_spec_typebases_promote tuple_type special_aliasis_named_tupletypeddict_type is_newtypeis_intersectionmetadata alt_promotehas_type_var_tuple_typetype_var_tuple_prefixtype_var_tuple_suffix self_typerrr$rrrrrlist[TypeInfo]rzlist[str] | Nonerrrrmypy.types.Instance | Nonerrrrrrrzlist[tuple[str, int]]rrrzset[str] | Nonerz5list[tuple[mypy.types.Instance, mypy.types.Instance]]rrzlist[mypy.types.Instance]rrrrrrrzlist[mypy.types.ProperType]rr zmypy.types.TupleType | Nonerrzmypy.types.TypedDictType | Nonerr r zdict[str, JsonDict]r rrzmypy.types.TypeVarType | NonerzDataclassTransformSpec | Nonerrr&r$) rrrrrr rrrr r FLAGSct||j|_||_||_||_g|_d|_d|_ g|_ g|_ d|_ d|_ d|_d|_d|_g|_g|_d|_g|_g|_g|_d|_d|_d|_d|_|j7d|_d|_d|_d|_g|_ d|_!d|_"d|_#d|_$d|_%d|_&d|_'i|_(d|_)d|_*d|_+d|_,y)zInitialize a TypeInfo.FN)-rr*rrrrrrrr rrrrrrrrrrrrrrrrr add_type_varsrrrrrr rrrrr r r rrrr$)r(rrrrs r)r*zTypeInfo.__init__> sS   &#( ',$  "&" #% $&!  !  %15"15"   $$)! !#"$ (,%"'r+cd|_|jjrt|jjD]\}}t |t j jrd|_t |t j jrF|jrJd|_||_ t|jj|z dz |_ |jj|jyy)NFTrA)r rrrr-rzr4 ParamSpecTyperTypeVarTupleTyperrrappendrk)r(r2vds r)rzTypeInfo.add_type_varsl s',$ 99  "499#6#672b$**":":;/3D,b$**"="=>#;;;;37D012D.14TYY5H5H1IA1MPQ1QD.%%bgg.8 r+c.|jjS)z Short name.)rrkrs r)rkz TypeInfo.namey syy~~r+c|jSr'rrs r)rzTypeInfo.fullname~ rr+c2t|jdkDS)z7Is the type generic (i.e. does it have type variables)?r)rrrs r)rzTypeInfo.is_generic s4>>"Q&&r+ch|jD]#}|jj|}|s!|cSyr')rrr)r(rkrns r)rz TypeInfo.get s/88C d#Ar+cJ|jD]}||jvs|cSyr')rr)r(rkrs r)get_containing_type_infoz!TypeInfo.get_containing_type_info s&88Csyy  r+cXt}|jsJd|jddD]q}|js|jj D]E\}}t |j tttfr,|tvr5|j|Gst|S)Nz?This property can be only accessed after MRO is (re-)calculatedr1) rrrrr!r-rrrrraddsorted)r(membersrrkrs r)protocol_memberszTypeInfo.protocol_members s ExxZZZxHHSbMD"&**"2"2"4JD$!$))ih-OP ;; KK% #5"gr+c|jjDcgc]P\}}t|jtr1|t vr)|j ds|jjr|Rc}}Scc}}w)N__)rr!r-rrLrrr)r(rksyms r) enum_memberszTypeInfo.enum_members sj"ZZ--/  / c388S) 88-HH// /   sAA7cB|j|}|r|St|r')rKeyError)r(rkrs r) __getitem__zTypeInfo.__getitem__ s! HHTN H4. r+c"d|jdS)Nz )rrs r)rzTypeInfo.__repr__ sDMM?!,,r+c$t|t Sr')r-FakeInfors r)__bool__zTypeInfo.__bool__ sdH---r+c(|j|duSr')r)r(rks r)has_readable_memberzTypeInfo.has_readable_member sxx~T))r+c|jD]S}||jvs|j|j}t|tr|cSt|t r|cSyyr')rrrr-rr)r(rkrrs r) get_methodzTypeInfo.get_method sU88Csyy yy++dH-Ki0Kr+c|j}||jjds|S|jdk(r tj j |gS|jDcgc]0}|j"|jj |j2}}|D]tfd|DscSycc}w)N builtins.typec3bK|]&}|jjjv(ywr')rr)riothercs r)rlz4TypeInfo.calculate_metaclass_type.. s#D5::+s,/) rrhas_baserrzr4rrrA)r(declareds candidatesr;s @r)calculate_metaclass_typez!TypeInfo.calculate_metaclass_type s**   (>(>(OO >>_ ,::&&tR0 0XX ##/A4H4H4M4M4Y    ADDD s*5Ccb|jdxs|jdk(xs |jS)Nr8z abc.ABCMeta)r<rrrs r) is_metaclasszTypeInfo.is_metaclass s2 MM/ * $}} - $## r+cH|jD]}|j|k(syy)zReturn True if type has a base type with the specified name. This can be either via extension or via implementation. TF)rr)r(rrs r)r<zTypeInfo.has_base s& 88C||x'r+cT|jDcgc]}|jc}Scc}w)zXReturn a direct base classes. Omit base classes of other base classes. )rr)r(rs r)direct_base_classeszTypeInfo.direct_base_classes s$ '+jj1jd j111s%c||_tj|}|js||_y|j|j_y)z.Update tuple_type and special_alias as needed.N)rrfrom_tuple_typerr/r(r:rjs r)update_tuple_typezTypeInfo.update_tuple_type s<))$/!!!&D (- D   %r+c||_tj|}|js||_y|j|j_y)z2Update typeddict_type and special_alias as needed.N)rrfrom_typeddict_typerr/rHs r)update_typeddict_typezTypeInfo.update_typeddict_type s=!--d3!!!&D (- D   %r+ct}|jtjj |tj j |S)zzReturn a string representation of the type. This includes the most important information about the type. rw)str_conv type_str_conv)rdumprzr{r|r4TypeStrVisitorrs r)rzTypeInfo.__str__ sK )yy\\))'):**33G3D  r+c d}dfd dj|z}|jr(ddj fd|jDd}djdjfd |jD}g}t |j D]}|j|j |jz}|j |j} t| tr%| jr|d  | jdz }|j|d |jd||d |fg} |jr%| jd  |jd|jr%| jd |jdtj j#| |S)z5Return a string dump of the contents of the TypeInfo.rfc&|jSr')ry)r:rOs r)type_strzTypeInfo.dump..type_str s::m, ,r+rzBases(z, c3.K|] }|ywr'r<)rirrTs r)rlz TypeInfo.dump..! s%Lhtns)zMro({})c3ZK|]"}|jj|z$ywr')r format_id)rir?rNs r)rlz TypeInfo.dump..# s&T84dmmh&8&8&>>8s(+ (zName(NameszDeclaredMetaclass(zMetaclassType()rN)r:r"r2r)rXrjoinformatrr$rrr-rLrrrrrrzr{ dump_tagged) r(rNrOrheadrrrk descriptionrr!rTs `` @r)rPz TypeInfo.dump s  -H..t44 ::DII%L%LLMQOD IIT488T T 4::&D!3!3DJJt4D4I4I!JJK::d#((D$$HTYY$7#8:: LL % ' q)4w6FG  " " LL-ht7N7N.O-PPQR S    LL>(43F3F*G)HJ K||''th'GGr+ciddd|jd|jd|jj|jd|jjd|j d|j d |jd |jDcgc]}|jc}d |jDcgc]}|jc}d |jDcgc]}|jc}d |jdn|jjd|jdn|jjd|jdn|jjd|jdn|jjd|jdn|jjdt!|t"j$|j&|j(t+|j(nd|j,|j.|j.jnd|j0|j0jnd|j2d}|Scc}wcc}wcc}w)Nrrrrrrrrrrrrr rrrrr0)r rrrrr$)rrrrrrrrrrrr rrrrr1rrr rr$rrrr$)r(br;prs r)rzTypeInfo.serialize3 st" j" 4++"   "  TZZ))$--8 " DII'') " "4#;#; "  "  "4#;#;"  TZZ8ZakkmZ8"  11AJJ1"   > 1 >"  4#3#3#;4AQAQA[A[A]"  !//7T=T=T=^=^=`" ++39L9L9V9V9X#" & $//"9$t?X?X?Z'" ( ++39L9L9V9V9X+" . YtX^^4/" 0 +/::+AVDJJ't$($=$=7;~~7Q113W[00<--779//C" F 591>sI=?J$Jctj|d}tj|d}|d}t|||}|d|_|dDcgc] }|d|dfc}|_|d|_|d |_|d Dcgc]+}tjjj|-c}|_ g}|d D]X} tjj| } t| tjjsJ|j| Z||_|d dn+tjjj|d |_|d dn+tjjj|d |_|ddn+tjjj|d|_|d|_|ddn+tjj*j|d|_|ddn+tjj.j|d|_|d|_|dt5|dnd|_|d|_t;||d|d} | )tjj<j| nd|_|jAdtBj|d|_"|jAd|_#|Scc}wcc}w)NrrrrrrrArrrrr rrrrrr rrr0rrr$)$rrrrrrrrrzr4rrr5r-r6rrr rrr TupleTyper TypedDictTyperr rrrr7 TypeVarTyperrrrr$) rrrrrtiattrrarrbrsts r)rzTypeInfo.deserializeZ s''W 6##DL1=) eT; /J' AEF[A\!]A\47DG"4A\!]K( !%&;!<@DW N 1DJJ''33A6 Nj!A ++A.Aa!6!67 77 OOA " M"* $$00m1DE ()1 $$006J1KL $%- $$006F1GH E{ L!) %%11$|2DE $%- ))55d;K6LM  :& )-g)B3tG}%"&'=">"d7m$ + ACtzz--99"=UY 88. / ;*@*L*L/0+B '.  s"^Os L0L )rrrrrrr2r3rrr)rkrr2zSymbolTableNode | None)rkrr2r;)r2r)rkrr2r)rkrr2r)rkrr2zFuncBase | Decorator | None)r2r)rrr2r)r2r)r:zmypy.types.TupleTyper2r3)r:zmypy.types.TypedDictTyper2r3)rNzmypy.strconv.StrConvrOzmypy.types.TypeStrVisitorr2rr)rr?r2r)"r7r8r9r:r;rUrr*rrrkrrrr!r&r*r-rr2r4r6r@rBr<rErIrLrrPrrrrrs@r)rr^ s *IXN N   MN22.. /.## ,DCJJ)( M   %$ *),+,+43"!$#-,<; E5 ,\ /'      !-. *   255  H,H=VH H<%N@@r+c eZdZdZddZddZy)r1r<c||_yr'rk)r(r<s r)r*zFakeInfo.__init__ s r+cv|dk(rtj||Sttj|d)Nrr<)object__getattribute__AssertionError)r(rhs r)rozFakeInfo.__getattribute__ s5 ; **46 6V44T5ABBr+N)r<rr2r3)rhrr2r)r7r8r9r;r*ror<r+r)r1r1 sI,Cr+r1zVar is lacking infozFinal[TypeInfo]rzClassDef is lacking inforz"FuncBase for non-methods lack inforz*fallback can't be filled out until semanalMISSING_FALLBACKceZdZdZdZdZdddddd dfdZeddZedd Z e dd Z e dd Z e dd Z dd ZddZeddZxZS)ra  A symbol node representing a type alias. Type alias is a static concept, in contrast to variables with types like Type[...]. Namely: * type aliases - can be used in type context (annotations) - cannot be re-assigned * variables with type Type[...] - cannot be used in type context - but can be re-assigned An alias can be defined only by an assignment to a name (not any other lvalues). Such assignment defines an alias by default. To define a variable, an explicit Type[...] annotation is required. As an exception, at non-global scope non-subscripted rvalue creates a variable even without an annotation. This exception exists to accommodate the common use case of class-valued attributes. See SemanticAnalyzerPass2.check_and_set_up_type_alias for details. Aliases can be generic. We use bound type variables for generic aliases, similar to classes. Essentially, type aliases work as macros that expand textually. The definition and expansion rules are following: 1. An alias targeting a generic class without explicit variables act as the given class (this doesn't apply to TypedDict, Tuple and Callable, which are not proper classes but special type constructors): A = List AA = List[Any] x: A # same as List[Any] x: A[int] # same as List[int] x: AA # same as List[Any] x: AA[int] # Error! C = Callable # Same as Callable[..., Any] T = Tuple # Same as Tuple[Any, ...] 2. An alias using explicit type variables in its rvalue expects replacements (type arguments) for these variables. If missing, they are treated as Any, like for other generics: B = List[Tuple[T, T]] x: B # same as List[Tuple[Any, Any]] x: B[int] # same as List[Tuple[int, int]] def f(x: B[T]) -> T: ... # without T, Any would be used here 3. An alias can be defined using another aliases. In the definition rvalue the Any substitution doesn't happen for top level unsubscripted generic classes: A = List B = A # here A is expanded to List, _not_ List[Any], # to match the Python runtime behaviour x: B[int] # same as List[int] C = List[A] # this expands to List[List[Any]] AA = List[T] D = AA # here AA expands to List[Any] x: D[int] # Error! Note: the fact that we support aliases like `A = List` means that the target type will be initially an instance type with wrong number of type arguments. Such instances are all fixed either during or after main semantic analysis passes. We therefore store the difference between `List` and `List[Any]` rvalues (targets) using the `no_args` flag. See also TypeAliasExpr.no_args. Meaning of other fields: target: The target type. For generic aliases contains bound type variables as nested types (currently TypeVar and ParamSpec are supported). _fullname: Qualified name of this type alias. This is used in particular to track fine grained dependencies from aliases. alias_tvars: Type variables used to define this alias. normalized: Used to distinguish between `A = List`, and `A = list`. Both are internally stored using `builtins.list` (because `typing.List` is itself an alias), while the second cannot be subscripted because of Python runtime limitation. line and column: Line and column on the original alias definition. eager: If True, immediately expand alias when referred to (useful for aliases within functions that can't be looked up from the symbol table) ) r/r alias_tvarsno_args normalized _is_recursiveeagertvar_tuple_indexpython_3_12_type_alias)rkr/rsrtNF)rsrtrurwryc*||_||_|g}||_||_||_d|_||_| |_d|_t|D]1\} } t| tjjs+| |_3t |=||yr')rr/rsrtrurvrwryrxrr-rzr4rrr*) r(r/rr"r#rsrtrurwryr2rrs r)r*zTypeAlias.__init__,s"  K& $+/ &<# $k*DAq!TZZ889()%+ v&r+c H|jsJt|jjtjj |tjj |jj|j|j|jS)zGenerate an alias to the tuple type described by a given TypeInfo. NOTE: this doesn't set type alias type variables (for generic tuple types), they must be set by the caller (when fully analyzed). fallback) rr copy_modifiedrzr4rtype_vars_as_argsrrrr"r#rrs r)rGzTypeAlias.from_tuple_typeKs{ OO ) ),,$**66tyy7J7JK *  MM II KK  r+c H|jsJt|jjtjj |tjj |jj|j|j|jS)zGenerate an alias to the TypedDict type described by a given TypeInfo. NOTE: this doesn't set type alias type variables (for generic TypedDicts), they must be set by the caller (when fully analyzed). r|) rrr~rzr4rrrrrr"r#rs r)rKzTypeAlias.from_typeddict_type`s""""    - -,,$**66tyy7J7JK .  MM II KK  r+c>|jjddSNrr1rrs r)rkzTypeAlias.nameu~~##C(,,r+c|jSr'rrs r)rzTypeAlias.fullnameyrr+c:td|jDS)Nc3dK|](}t|tjj*ywr')r-rzr4r)rirs r)rlz0TypeAlias.has_param_spec_type..s$UDTq:a!9!9:DT.0)anyrsrs r)rzTypeAlias.has_param_spec_type}sUDDTDTUUUr+c d|j|jj|jDcgc]}|jc}|j|j |j |j|jd }|Scc}w)Nr) rrr/rsrtrur"r#ry) rr/rrsrtrur"r#ry)r(rrs r)rzTypeAlias.serializesu!kk++-373C3CD3CaAKKM3CD||//IIkk&*&A&A   EsB c$|j|Sr')visit_type_aliasrs r)ryzTypeAlias.acceptr r+c |ddk(sJ|d}|dDcgc]!}tjj|#}}td|DsJtjj|d}|d}|d}|d }|d } |d } ||||| t t tjj |||| Scc}w) Nrrrrsc3dK|](}t|tjj*ywr')r-rzr4r)rirs r)rlz(TypeAlias.deserialize..s"Rk:a!;!;!?    T$**"<"<={K!#9  Ts&C)r/r"rrr"r.r#r.rsrrtrrurrwrryrr2r3)rrr2rrrrr)rr?r2r)r7r8r9r:r;rr*rrGrKrrkrrrryrrrs@r)rr sVp IBN@D ',''' '  '=''''!%' '>  (  (--VV .  r+rcheZdZdZdZdd d dZed dZed dZd dZ dd Z y )PlaceholderNodeaTemporary symbol node that will later become a real SymbolNode. These are only present during semantic analysis when using the new semantic analyzer. These are created if some essential dependencies of a definition are not yet complete. A typical use is for names imported from a module which is still incomplete (within an import cycle): from m import f # Initially may create PlaceholderNode This is particularly important if the imported shadows a name from an enclosing scope or builtins: from m import int # Placeholder avoids mixups with builtins.int Another case where this is useful is when there is another definition or assignment: from m import f def f() -> None: ... In the above example, the presence of PlaceholderNode allows us to handle the second definition as a redefinition. They are also used to create PlaceholderType instances for types that refer to incomplete types. Example: class C(Sequence[C]): ... We create a PlaceholderNode (with becomes_typeinfo=True) for C so that the type C in Sequence[C] can be bound. Attributes: fullname: Full name of the PlaceholderNode. node: AST node that contains the definition that caused this to be created. This is useful for tracking order of incomplete definitions and for debugging. becomes_typeinfo: If True, this refers something that could later become a TypeInfo. It can't be used with type variables, in particular, as this would cause issues with class type variable detection. The long-term purpose of placeholder nodes/types is to evolve into something that can support general recursive types. )rrbecomes_typeinfoF)rc<||_||_||_||_yr')rrrr")r(rrr"rs r)r*zPlaceholderNode.__init__s!" 0 r+c>|jjddSrrrs r)rkzPlaceholderNode.namerr+c|jSr'rrs r)rzPlaceholderNode.fullnamerr+cJd)Nz#PlaceholderNode can't be serializedr<rs r)rzPlaceholderNode.serializes ;;;ur+c$|j|Sr')visit_placeholder_noders r)ryzPlaceholderNode.acceptr/r+N) rrrrtr"r.rrr2r3rrr) r7r8r9r:r;r*rrkrrryr<r+r)rrsu.`:IQV#'/2IM --<4r+rceZdZdZdZ d ddd ddZeddZeddZddZ dd Z dd Z e dd Z y )ra Description of a name binding in a symbol table. These are only used as values in module (global), function (local) and class symbol tables (see SymbolTable). The name that is bound is the key in SymbolTable. Symbol tables don't contain direct references to AST nodes primarily because there can be multiple symbol table references to a single AST node (due to imports and aliases), and different references can behave differently. This class describes the unique properties of each reference. The most fundamental attribute is 'node', which is the AST node that the name refers to. The kind is usually one of LDEF, GDEF or MDEF, depending on the scope of the definition. These three kinds can usually be used interchangeably and the difference between local, global and class scopes is mostly descriptive, with no semantic significance. However, some tools that consume mypy ASTs may care about these so they should be correct. Attributes: node: AST node of definition. Among others, this can be one of FuncDef, Var, TypeInfo, TypeVarExpr or MypyFile -- or None for cross_ref that hasn't been fixed up yet. kind: Kind of node. Possible values: - LDEF: local definition - GDEF: global (module-level) definition - MDEF: class member definition - UNBOUND_IMPORTED: temporary kind for imported names (we don't know the final kind yet) module_public: If False, this name won't be imported via 'from import *'. This has no effect on names within classes. module_hidden: If True, the name will be never exported (needed for stub files) cross_ref: For deserialized MypyFile nodes, the referenced module name; for other nodes, optionally the name of the referenced object. implicit: Was this defined by assignment to self attribute? plugin_generated: Was this symbol generated by a plugin? (And therefore needs to be removed in aststrip.) no_serialize: Do not serialize this node if True. This is used to prevent keys in the cache that refer to modules on which this file does not depend. Currently this can happen if there is a module not in build used e.g. like this: import a.b.c # type: ignore This will add a submodule symbol to parent module `a` symbol table, but `a.b` is _not_ added as its dependency. Therefore, we should not serialize these symbols as they may not be found during fixup phase, instead they will be re-added during subsequent patch parents phase. TODO: Refactor build.py to make dependency tracking more transparent and/or refactor look-up functions to not require parent patching. NOTE: No other attributes should be added to this class unless they are shared by all node kinds. )rGr module_public module_hidden cross_refimplicitplugin_generated no_serializeF)rrct||_||_||_||_||_d|_||_||_yr')rGrrrrrrr)r(rGrrrrrrs r)r*zSymbolTableNode.__init__;s@  *  *%) 0(r+cH|j|jjSyr')rrrs r)rzSymbolTableNode.fullnameOs 99 99%% %r+c|j}t|ttfr|j |jSt|t r|j jSyr')rr-rLSYMBOL_FUNCBASE_TYPESrrr)r(rs r)rzSymbolTableNode.typeVsIyy dS"78 9dii>S99  i (88== r+ct|j|j|j|j|j }|j |_|Sr')rrGrrrrr)r(news r)r)zSymbolTableNode.copy`sA IItyy$"4"4dmmTEWEW   r+cBt|jdt|j}t |jt r|d|jj dz }|j|d|jz }|jr|d|jz }|S)N/rYrV : z cross_ref:) rPrGrrr-rrrr)r(r>s r)rzSymbolTableNode.__str__gs$))$%Qz$))'<&= > dii , 2dii(()+ +A 99 3tyyk" "A >> ;t~~./ /Ar+cdt|jd}|jrd|d<|jsd|d<|jrd|d<|j rd|d<t |jtr|jj|d <|S|j J|d |||jj}d |vrg||d z|zk7r\t |jtr|jjs,t |jtr Jd |d ||d <|S|jj|d<|S)zSerialize a SymbolTableNode. Args: prefix: full name of the containing module or class; or None name: name of this object relative to the containing object r)rrGTrFrrrr:rzDefinition of z is unexpectedly incompleter)rPrGrrrrr-rrrrLrrr)r(prefixrkrrs r)rzSymbolTableNode.serializersO%6z$))?TU   $(D !!!$)D ! ==#D   '+D# $ dii * $ 2 2D   99( '4 '>))$v,7D$T40F d "#'#8F d "#'#8F  ":.FO  %&*+=&>F # r+N)TFF)rGr.rSymbolNode | Nonerrrrrrrrrrr2r3)r2r&r)r2rr)rrrkrr2r?)rr?r2r)r7r8r9r:r;r*rrrr)rrrrr<r+r)rrs9v I## )"'")) ) )  )  ))) )(  !Fr+c>eZdZdZdZddZd dZd dZed dZ y) rzrStatic representation of a namespace dictionary. This is used for module, class and function namespaces. r<cg}|jD]\}}t|trf|jdk7s&|jxsdj ddt vsO|j dt|zdzt|z||j dt|}|jdd |dxxd z cc<d j|S) Nbuiltinsrfrr1z rz rz SymbolTable(rV ) r!r-rrrrWrrr$insertr[)r(ar{rs r)rzSymbolTable.__str__s**,JC%1NNj0-244S9"=EZZHHTCH_u4s5zAB+,' 1I N# " yy|r+c t|jDcgc]\}}||jfc}}Scc}}wr')rr!r))r(r{rs r)r)zSymbolTable.copys4 M 93S$))+. MNNMs= cddi}|jD],\}}|dk(s |jr|j||||<.|S)Nrr __builtins__)r!rr)r(rrr{rs r)rzSymbolTable.serializesP"M2**,JC n$(:(:#6DI' r+c|ddk(sJt}|jD]#\}}|dk7s tj|||<%|S)Nrr)rr!rr)rrrir{rs r)rzSymbolTable.deserializesQH~... ]**,JCh)55e<3' r+Nr)r2r)rrr2r?)rr?r2r) r7r8r9r:r;rr)rrrr<r+r)rrs2 I"O r+rcZeZdZdZdZdddddd ddZd dZed dZy) rzSpecifies how a dataclass-like transform should be applied. The fields here are based on the parameters accepted by `typing.dataclass_transform`. eq_default order_defaultkw_only_defaultfrozen_defaultfield_specifiersN)rrrrrc~||nd|_||nd|_||nd|_||nd|_|||_yd|_y)NTFr<r)r(rrrrrs r)r*zDataclassTransformSpec.__init__sW)3(>*D.;.G]U2A2MSX0>0JnPU4D4P 0VXr+c|j|j|j|jt |j dS)Nr)rrrrrrrs r)rz DataclassTransformSpec.serializes<//!//#33"11 $T%:%: ;   r+c t|jd|jd|jd|jdt|jdgS)Nrrrrrr)rrtuplers r)rz"DataclassTransformSpec.deserializesU%xx -((?3 HH%6788$45"488,>#CD   r+) rrrrrrrztuple[str, ...] | Nonerrr2r3r)rr?r2r) r7r8r9r:r;r*rrrr<r+r)rrs<I#'%)'+37'+Y Y# Y % Y 1 Y$Y Y$   r+rcF|Dcgc]}t||s|c}Scc}wr')getattr)rrrks r)r1r1s#" :UTgdD&9DU :: :sc,|D]}t||dy)NT)setattr)rr0rks r)r7r7sdD!r+cd}t|jtr|jj}n/t|jtrt |j}|y|d|jS)zReturn the qualified name representation of a member expression. Return a string of form foo.bar, foo.bar.baz, or similar, or None if the argument cannot be represented in this form. Nr)r-rrrkrget_member_expr_fullname)rinitials r)rrs] G$))X&)).. DIIz **4995Ya { ##r+rc`d}d}d}d}t||D]\}}|tk(r|s|s|s|s|d|y|tk(r|s|s|r |d|yd}@|tk(r|s|s|r |d|yd}]|tk(s |t k(rd}|st|d|y|t k(s|r |d|yd}y)NFzHRequired positional args may not appear after default, named or var argsz>Positional default args may not appear after named or var argsTz/Var args may not appear after named or var argsz-A **kwargs argument must be the last argumentz'You may only have one **kwargs argument)ziprmrnrrrr) renodesfail is_var_arg is_kw_arg seen_namedseen_optrGrs r)check_arg_kindsr3sJIJH)U+ d 7?Y*^ W_Y*UW[\H X Y*FMJ Y $-"7JDdK Y >EI7,r+ct}t||D]-\}}|||vr|d|d||y|j|/y)NzDuplicate argument "z" in )rrr#)rrrr_ seen_namesrkrs r)check_arg_namesrXsT #&%J%' d   2 'vU;-@$ G t (r+cdt|jtr|jjSy)z.Return whether the expression is ClassVar[...]F)r-rrLrrs r) is_class_varrfs#$))S!yy$$$ r+c^t|ttttfxr |j S)z6Check whether `node` corresponds to a final attribute.)r-rLrr rrrs r) is_final_noderms" dS'+rmypy_extensionsr mypy.strconvrz mypy.optionsr mypy.utilrr mypy.visitorrrr mypy.patternsrr mypy.typesr=rr?rUr@rBrDrFrGrHrIrJrKrPr!rQrWrarcrdrergupdaterprqrrrtrrrrrrrrrrrrrrr rCrPrQrRrTr`rbr~rrrrrrrrLrrrrorr rrr*r5r;rArFrKrOrSrZr`rkrsr}rrrrrrrrrrrrOrmrnrrrrrrrrrrrr rr r+r1r9rrFrNrTrYr^rjrurzrrrrrrrrrrrrrrrrrr frozensetrrrr1rrrrqrrrrr1r7rglobalsrr- issubclassrrrrrrr)r_kindr{objs0000r)rs :" #A! 2II%%)%)P CLCH~*%eee % U u U e E64v?OQbc Ec>H>N>N>PQ>PleUUE\>PQEQ#"% u#" ,-+3'3*  e  (>w&GeG &?'5 $5#" , ". _>$,-G$H/H ()M N oN"#OP%Pb b JG4jG4Tuup/$sO+,/d/ / d;" $$IOO%%S Cy 33 # : %""%,"4L" "R-      #    \ CGI I%(I0?III@Rv}s 7 _#$8_)