
    \j,                      U d Z ddlmZ ddlZddlmZ ddlmZ ddlm	Z	m
Z
mZ ddlmZ ddlmZmZ dd	lmZmZmZmZmZmZmZmZmZmZ dd
lmZ ddlm Z m!Z"m#Z$m%Z&m'Z(m)Z* ddl+m,Z, ddl-Z.ddl/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;m<Z<m=Z=m>Z>m#Z#m?Z?m@Z@mAZAmBZBm%Z%mCZCmDZDmEZEmFZFmGZGmHZHm'Z'mIZImJZJmKZKmLZLm)Z)mMZMmNZNmOZOmPZP ddlQmRZR ddlSmTZT ddlUmVZVmWZWmXZX ddlYmZZZm[Z[m\Z\ erddl]m^Z^ e G d de                      Z_ G d d          Z`erddlaZ. ed          Zbecedef         Zedefd<   dZgdefd<   dZhdefd<   dZidefd<   d Zjdefd!<   dZkdefd"<   dZldefd#<   dZmdefd$<   dZndefd%<   dZodefd&<   egd'ehd(eid)ejd*iZpdefd+<   d, epq                                D             Zrdefd-<   d.ddd.d.ddd/Zsdefd0<   d1d2d3d4d5d6d7d8d9d:d;
Ztdefd<<   d=d>iZudefd?<   d9d:d@ZvdefdA<   dBdCdDdEdFZwdefdG<   dHZxdefdI<   dJZydefdK<    G dL dMe`          Zze, G dN dOez                      Z{e, G dP dQez                      Z| G dR dSe|          Z}e|Z~defdT<   e, G dU dVez                      ZeeddWedX         f         ZdefdY<    G dZ d[e          ZddaZddcZ G dd de          Z G df dge          Z G dh die{          Z G dj dke          Z G dl dme          Z G dn doe          Zg dpZdefdq<    G dr dsez          Zedt         Zdefdu<    G dv dweee{          Z G dx dyez          ZdZdefdz<   dZdefd{<   dZdefd|<    G d} d~          Zeg dz   Zdefd<    G d de          Zeg dz   Zdefd<   dZdefd<   dZdefd<   dZdefd<    G d deee{          ZeefZdefd<    G d dee{          Zg dZdefd<    G d de          Z G d de{          Z G d de{          Z G d de{          Z G d de{          Z G d de{          Z G d de{          Z G d de{          Z G d de{          Z G d de{          Z G d de{          Z G d de{          Z G d de{          Z G d de{          Z G d de{          Z G d de{          Z G d de{          Z G d de{          Z G d de{          Z G d de{          Z G d de{          Z G d de{          Z G d de|          Z G d de|          ZddZ G dÄ de|          Z G dń de|          Z G dǄ de|          Z G dɄ de|          Z G d˄ de|          Z G d̈́ de|          Z G dτ de          Z G dф de          Ze G dӄ de                      Zej        Zdefd<   ej        Zdefd<   ej        Zdefd<   ej        Zdefd<   ej        Zdefd<   ej        Zdefd<   eeeeeefZdefd<    G d܄ de|          Z G dބ de|          Z G d de|          Z G d de|          Z G d de|          Z G d de|          Z G d de|          ZeeeeefZ G d de|          Z G d de|          Z G d de|          Z G d de|          Z G d de|          Z G d de|          Z G d de|          Z G d dee|          Z G d de|          Z G d de|          Z G d de|          Z G d  de|          Z G d de|          Z G d de|          Z G d de|          Z G d d	e|          Z G d
 de|          Z G d de|          Z G d de|          ZdZdefd<   dZdefd<   dZdefd<   d Zdefd<    G d dee|          ZefZdefd<    G d de          Z G d de          Z G d de          Z G d de|          Z G d d e|          Z G d! d"e|          Z G d# d$e|          Z G d% d&e|          Z G d' d(e|          Z G d) d*e|          Z G d+ d,e|          Z eh d-          Zdefd.<    eh d/          Zdefd0<    G d1 dXe          Z G d2 d3e          Z ed4          Zd5efd6<    ed7          Zd5efd8<    ed9          Zd5efd:<    ed;          Zdefd<<    G d= d>e          Z G d? d@e          Z G dA dW          Z G dB dCecedef                   Z G dD dE          Ze, G dF dG                      Z d dKZd!dMZd"dOZd#dRZd$dUZdV  e            q                                D             ZdefdW<   d%d^Z	 d&d'dcZ	d(deZ
d)dgZd*djZ	 d+d,dqZd-drZdsZdtefdu<   dvZdtefdw<   dxZdtefdy<   dzZdtefd{<   d|Zdtefd}<   d~Zdtefd<   dZdtefd<   dZdtefd<   dZdtefd<   dZdtefd<   dZdtefd<   dZdtefd<   dZdtefd<   dZdtefd<   dZdtefd<   dZdtefd<   dZdtefd<   dZ dtefd<   dZ!dtefd<   dZ"dtefd<   dZ#dtefd<   dZ$dtefd<   dZ%dtefd<   dZ&dtefd<   dZ'dtefd<   dZ(dtefd<   dZ)dtefd<   dZ*dtefd<   dZ+dtefd<   dZ,dtefd<   dZ-dtefd<   dZ.dtefd<   dZ/dtefd<   dZ0dtefd<   dZ1dtefd<   dZ2dtefd<   dZ3dtefd<   dZ4dtefd<   dZ5dtefd<   dZ6dtefd<   dĐZ7dtefd<   dƐZ8dtefd<   dȐZ9dtefd<   dʐZ:dtefd<   d̐Z;dtefd<   dΐZ<dtefd<   dАZ=dtefd<   dҐZ>dtefd<   dԐZ?dtefd<   d֐Z@dtefd<   dؐZAdtefd<   dڐZBdtefd<   dܐZCdtefd<   dސZDdtefd<   dZEdtefd<   dZFdtefd<   dZGdtefd<   dZHdtefd<   dZIdtefd<   dZJdtefd<   dZKdtefd<   dZLdtefd<   dZMdtefd<   dZNdtefd<   dZOdtefd<   dZPdtefd<   dZQdtefd<   dZRdtefd<   dZSdtefd<   dZTdtefd<   d ZUdtefd<   dZVdtefd<   dZWdtefd<   dZXdtefd<   dZYdtefd	<   d
ZZdtefd<   dZ[dtefd<   dZ\dtefd<   dZ]dtefd<   dZ^dtefd<   dZ_dtefd<   dZ`dtefd<   d.dZad/d0dZbdS (1  z4Abstract syntax tree node classes (i.e. parse tree).    )annotationsN)abstractmethod)defaultdict)CallableIteratorSequence)contextmanager)Enumunique)
TYPE_CHECKINGAnyFinalOptional	TypeAlias	TypedDict	TypeGuardTypeVarUnioncast)NotRequired)extract_symbol
read_floatread_intread_str	write_int	write_str)trait)%DICT_INT_GENDICT_STR_GENDT_SPECEND_TAGLIST_GENLIST_STRLITERAL_COMPLEXLITERAL_FALSELITERAL_NONELITERAL_TRUE
ReadBufferTagWriteBuffer	read_bool
read_bytesr   read_int_listread_int_opt	read_jsonread_literalr   read_str_listread_str_optread_str_opt_listread_tag
write_boolwrite_bytesr   write_int_listwrite_int_opt
write_jsonwrite_literalr   write_str_listwrite_str_optwrite_str_opt_list	write_tag)modules_state)Options)	is_sunderis_typeshed_file
short_type)ExpressionVisitorNodeVisitorStatementVisitor)Patternc                      e Zd Zd ZdS )	NotParsedN)__name__
__module____qualname__VALUE     N/var/www/app.qaans.com/backend/venv/lib/python3.11/site-packages/mypy/nodes.pyrI   rI   T   s        EEErO   rI   c                  0    e Zd ZdZdZddd	Z	 	 	 dddZd
S )Contextz@Base type for objects that are valid as error message locations.linecolumnend_line
end_columnrT   intrU   returnNonec                >    || _         || _        d | _        d | _        d S NrS   )selfrT   rU   s      rP   __init__zContext.__init__^   s"    	$(&*rO   NtargetContext | int
int | NonerV   rW   c                    t          |t                    r|| _        n0|j        | _        |j        | _        |j        | _        |j        | _        ||| _        ||| _        |	|| _        dS dS )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)
isinstancerY   rT   rU   rV   rW   )r^   r`   rU   rV   rW   s        rP   set_linezContext.set_lined   sw     fc"" 	0DIIDI -DK"ODM$/DO DK$DM!(DOOO "!rO   )rX   rX   )rT   rY   rU   rY   rZ   r[   NNN
r`   ra   rU   rb   rV   rb   rW   rb   rZ   r[   )rJ   rK   rL   __doc__	__slots__r_   re   rN   rO   rP   rR   rR   Y   s\        JJ<I+ + + + + "#!%) ) ) ) ) ) )rO   rR   T
_TypeAliasJsonDictr   LDEF   GDEF   MDEF   UNBOUND_IMPORTEDREVEAL_TYPEREVEAL_LOCALSLITERAL_YESLITERAL_TYPE
LITERAL_NOLdefGdefMdefUnboundImported
node_kindsc                    i | ]\  }}||	S rN   rN   ).0_name_kinds      rP   
<dictcomp>r      s    QQQleUUEQQQrO   inverse_node_kindsz__builtins__.str)rJ   rh   __path____file____package____annotations____spec__implicit_module_attrsbuiltins.listbuiltins.dictbuiltins.setbuiltins.frozensetzcollections.ChainMapzcollections.Counterzcollections.defaultdictzcollections.dequezcollections.OrderedDictzbuiltins.str)
typing.Listtyping.Dict
typing.Settyping.FrozenSetztyping.ChainMapztyping.Counterztyping.DefaultDictztyping.Dequeztyping.OrderedDicttyping.LiteralStringtype_aliasesr   )rr      type_aliases_source_versions)ztyping_extensions.OrderedDictztyping_extensions.LiteralStringtyping_extensions_aliasesr   r   r   r   )r   r   r   r   reverse_builtin_aliases)ztyping.runtime_checkableztyping_extensions.runtimez#typing_extensions.runtime_checkableRUNTIME_PROTOCOL_DECOSz<lambda>LAMBDA_NAMEc                  .    e Zd ZdZdZddZddZddZdS )Nodez4Common base class for all non-type parse tree nodes.rN   rZ   strc                    |                      t          j                            t	                                          S Noptions)acceptmypystrconvStrConvr@   r^   s    rP   __str__zNode.__str__   s+    {{4<//		/BBCCCrO   r   r@   c                t    |                      t          j                            |                    }|sJ |S r   )r   r   r   r   )r^   r   as      rP   str_with_optionszNode.str_with_options   s4    KK,,W,==>>rO   visitorNodeVisitor[T]rj   c                <    t          dt          |                     NzNot implementedRuntimeErrortyper^   r   s     rP   r   zNode.accept       ,d4jj999rO   NrZ   r   )r   r@   rZ   r   r   r   rZ   rj   )rJ   rK   rL   rh   ri   r   r   r   rN   rO   rP   r   r      s_        >>ID D D D   
: : : : : :rO   r   c                      e Zd ZdZdZd	dZdS )
	StatementzA statement node.rN   r   StatementVisitor[T]rZ   rj   c                <    t          dt          |                     r   r   r   s     rP   r   zStatement.accept   r   rO   Nr   r   rZ   rj   rJ   rK   rL   rh   ri   r   rN   rO   rP   r   r      s3        I: : : : : :rO   r   c                      e Zd ZdZdZd	dZdS )

ExpressionzAn expression node.rN   r   ExpressionVisitor[T]rZ   rj   c                <    t          dt          |                     r   r   r   s     rP   r   zExpression.accept  r   rO   Nr   r   rZ   rj   r   rN   rO   rP   r   r      s3        I: : : : : :rO   r   c                      e Zd ZdZdZdS )FakeExpressionzA dummy expression.

    We need a dummy expression in one place, and can't instantiate Expression
    because it is a trait and mypyc barfs.
    rN   N)rJ   rK   rL   rh   ri   rN   rO   rP   r   r     s          IIIrO   r   Lvaluec                      e Zd ZdZdZeedd                        Zeedd                        Zedd            Z	e
dd
            ZddZe
dd            ZdS )
SymbolNodez+Nodes that can be stored in a symbol table.rN   rZ   r   c                    d S r]   rN   r   s    rP   namezSymbolNode.name  	     	rO   c                    d S r]   rN   r   s    rP   fullnamezSymbolNode.fullname#  r   rO   rl   c                    d S r]   rN   r   s    rP   	serializezSymbolNode.serialize(  s    rO   datac                    |d         }t                               |          }| ||          S t          d|           )N.classzunexpected .class )deserialize_mapgetNotImplementedError)clsr   	classnamemethods       rP   deserializezSymbolNode.deserialize,  sI    N	 $$Y//6$<<!"By"B"BCCCrO   r*   r[   c                <    t          d| j        j         d          )NzCannot serialize 	 instance)r   	__class__rJ   r^   r   s     rP   writezSymbolNode.write4  s!    !"Xdn6M"X"X"XYYYrO   r(   c                2    t          d| j         d          )NzCannot deserialize r   )r   rJ   r   r   s     rP   readzSymbolNode.read7  s    !"O"O"O"OPPPrO   Nr   rZ   rl   )r   rl   rZ   r   r   r*   rZ   r[   )r   r(   rZ   r   )rJ   rK   rL   rh   ri   propertyr   r   r   r   classmethodr   r   r   rN   rO   rP   r   r     s        55I   ^ X    ^ X    ^ D D D [DZ Z Z Z Q Q Q [Q Q QrO   r   SymbolTableNodeTypeInfo
Definitionc                  B    e Zd ZU ded<   ded<   ded<   ded<   ded	<   d
S )
ParseErrorrY   rT   rU   r   messagezNotRequired[bool]blockerzNotRequired[str]codeN)rJ   rK   rL   r   rN   rO   rP   r   r   @  sE         IIIKKKLLLrO   r   r   r*   errrZ   r[   c                J   t          | |d                    t          | |d                    t          | |d                    |                    d          x}t          | |           nt	          | t
                     t          | |                    d                     d S )NrT   rU   r   r   r   )r   r   r   r5   r>   r&   r<   )r   r   r   s      rP   write_parse_errorr   H  s    dCK   dCM"""dC	N###779%%%24!!!!$%%%$(((((rO   r(   c                   t          |           t          |           t          |           d}t          |           }|t          k    rd|d<   n|t          k    rd|d<   n|t
          k    sJ t          |           x}||d<   |S )N)rT   rU   r   Tr   Fr   )r   r   r4   r'   r%   r&   r2   )r   r   tagr   s       rP   read_parse_errorr   S  s    '~~$T\]aTbTbccC
4..C
lI			Il""""T"""/FJrO   c                      e Zd ZU dZdZded<   ded<   ded<   ded	<   d
ed<   d
ed<   ded<   ded<   	 	 dddZddZedd            Z	dS ) FileRawDatazARaw (binary) data representing parsed, but not deserialized file.defsimports
raw_errorsignored_linesis_partial_stub_packageuses_template_stringssource_hashmypy_commentsbytesr   r   list[ParseError]r   dict[int, list[str]]r   boolr   r   r   r   zlist[tuple[int, str]]r    Nlist[tuple[int, str]] | NonerZ   r[   c	                ~    || _         || _        || _        || _        || _        || _        || _        ||ng | _        d S r]   r   )	r^   r   r   r   r   r   r   r   r   s	            rP   r_   zFileRawData.__init__x  sP     	$*'>$%:"&.;.G]]RrO   r   r*   c                .   t          || j                   t          || j                   t          |t                     t          |t          | j                             | j        D ]}t          ||           t          |t                     t          |t          | j
                             | j
                                        D ]%\  }}t          ||           t          ||           &t          || j                   t          || j                   t#          || j                   t          |t                     t          |t          | j                             | j        D ]%\  }}t          ||           t#          ||           &d S r]   )r6   r   r   r>   r"   write_int_barelenr   r   r   r   itemsr   r;   r5   r   r   r   r   r   )r^   r   r   rT   codestexts         rP   r   zFileRawData.write  s   D$)$$$D$,'''$!!!tS11222? 	) 	)CdC(((($%%%tS!344555-3355 	( 	(KD%dD!!!4''''4566643444$()))$!!!tS!344555, 	" 	"JD$dD!!!dD!!!!	" 	"rO   r(   c           
     R   t                    }t                    }t                    t          k    sJ fdt          t	                              D             }t                    t
          k    sJ fdt          t	                              D             }t                    }t                    }t                    }t                    t          k    sJ fdt          t	                              D             }	t          ||||||||	          S )Nc                .    g | ]}t                    S rN   )r   r   _r   s     rP   
<listcomp>z$FileRawData.read.<locals>.<listcomp>  s"    QQQ&t,,QQQrO   c                J    i | ]}t                    t                     S rN   )r   r1   r
  s     rP   r   z$FileRawData.read.<locals>.<dictcomp>  s)    aaa$t)<)<aaarO   c                L    g | ] }t                    t                    f!S rN   )r   r   r
  s     rP   r  z$FileRawData.read.<locals>.<listcomp>  s*    ^^^a(4..(4..9^^^rO   )	r,   r4   r"   rangeread_int_barer   r+   r   r   )
r   r   r   r   r   r   r   r   r   r   s
    `        rP   r   zFileRawData.read  s,   $T""~~))))QQQQeM$<O<O6P6PQQQ
~~----aaaaeMZ^L_L_F`F`aaa"+D// )$tnn~~))))^^^^5W[I\I\C]C]^^^#!	
 	
 		
rO   )r   N)r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   rZ   r[   r   )r   r(   rZ   r   )
rJ   rK   rL   rh   ri   r   r_   r   r   r   rN   rO   rP   r   r   a  s         KK	I KKKNNN    ''''!!!!(((( 6:P P P P P(" " " "* 
 
 
 [
 
 
rO   r   c                      e Zd ZU dZdZdZded<   ded<   ded<   d	ed
<   ded<   ded<   ded<   ded<   ded<   ded<   ded<   ded<   ded<   ded<   ded<   ded<   ded<   d ed!<   	 	 d@dA fd'Zd"d(dBd+Ze	dCd,            Z
e	dCd-            ZdDd1ZdEd2ZdFd4ZdGd7ZdHd9ZedId;            ZdJd=ZedKd?            Z xZS )LMypyFilez1The abstract syntax tree of a single source file.)	_fullnamepathr   
alias_depsmodule_refsis_bomnamesr   r   skipped_linesis_stubis_cache_skeletonr   r   plugin_depsfuture_import_flags_is_typeshed_fileraw_data)r   r  r   r   r  r  list[Statement]r   zdefaultdict[str, set[str]]r  zset[str]r  r   r  SymbolTabler  list[ImportBase]r   r   r   zset[int]r  r  r  r   r   zdict[str, set[str]]r  r  bool | Noner  zFileRawData | Noner  FNdict[int, list[str]] | NonerZ   r[   c                   t                                                       || _        d| _        d| _        || _        || _        t          t                    | _	        t                      | _
        i | _        |r|| _        ni | _        t                      | _        d| _        d| _        d| _        d| _        d| _        t                      | _        d | _        d | _        d S )Nrn   r   r   F)superr_   r   rT   rU   r   r  r   setr  r  r  r   r  r  r  r  r   r   r  r  r  )r^   r   r   r  r   r   s        rP   r_   zMypyFile.__init__  s     			%c**55 	$!.D!#D UU	!&',$%*"#&55 !%rO   	impl_onlyr)  Iterator[Definition]c               :    t          | j        | j        |          S )zyReturn all definitions within the module (including nested).

        This doesn't include imported definitions.
        r(  )local_definitionsr  r   )r^   r)  s     rP   r,  zMypyFile.local_definitions  s    
 !T]iPPPPrO   c                T    | j         sdn| j                             d          d         S )Nr   .rX   r  splitr   s    rP   r   zMypyFile.name#  s(    JrrT^-A-A#-F-Fr-JJrO   c                    | j         S r]   r  r   s    rP   r   zMypyFile.fullname'  
    ~rO   r   r   rj   c                ,    |                     |           S r]   )visit_mypy_filer   s     rP   r   zMypyFile.accept+      &&t,,,rO   c                    t          | j                  dk    o6t          j                            | j                                      d          S )Nr   z	__init__.)r  r  osbasename
startswithr   s    rP   is_package_init_filezMypyFile.is_package_init_file.  s:    49~~"Zrw'7'7	'B'B'M'Mk'Z'ZZrO   flagc                    || j         v S r]   )r  )r^   r<  s     rP   is_future_flag_setzMypyFile.is_future_flag_set1  s    t///rO   r   r@   c                \    | j         t          |j        | j                  | _         | j         S r]   )r  rB   abs_custom_typeshed_dirr  r^   r   s     rP   rB   zMypyFile.is_typeshed_file4  s-    !)%5g6UW[W`%a%aD"%%rO   rl   c           	         d| j         | j                            | j                   | j        | j        | j        t          | j                  dS )Nr  )r   r  r  r  r  r   r  )r  r  r   r  r  r   sortedr  r   s    rP   r   zMypyFile.serialize:  sL     Z))$.99|I'+'C#)$*B#C#C
 
 	
rO   r   c                F   |d         dk    s
J |            t          g g           }|d         |_        t                              |d                   |_        |d         |_        |d         |_        |d         |_        d|_        t          |d	                   |_
        |S )
Nr   r  r  r  r  r  r   Tr  )r  r  r!  r   r  r  r  r   r  r'  r  r   r   trees      rP   r   zMypyFile.deserializeE  s    H~+++T+++Bk* ,,T'];;
IL	'+,E'F$!%#&t,A'B#C#C rO   r*   c                   t          |t                     t          || j                   | j                            || j                   t          || j                   t          || j                   t          || j	                   t          |t          | j                             t          |t                     d S r]   )r>   	MYPY_FILEr   r  r  r   r5   r  r  r   r;   rC  r  r!   r   s     rP   r   zMypyFile.writeR  s    $	"""$'''
t~...4&&&$	"""45666tVD$<==>>>$     rO   r(   c                   t          |          t          k    sJ t          g g           }t          |          |_        t
                              |          |_        t          |          |_	        t          |          |_
        t          |          |_        t          t          |                    |_        d|_        t          |          t           k    sJ |S NT)r4   rH  r  r   r  r!  r   r  r+   r  r  r   r'  r1   r  r  r!   rE  s      rP   r   zMypyFile.read\  s    ~~****B!$ %%d++
 TNN	'0$#&}T':':#;#; !%~~((((rO   )FN)
r   r   r   r"  r  r   r   r$  rZ   r[   )r)  r   rZ   r*  r   r   rZ   r   )r<  r   rZ   r   )r   r@   rZ   r   r   )r   rl   rZ   r  r   )r   r(   rZ   r  )rJ   rK   rL   rh   ri   __match_args__r   r_   r,  r   r   r   r   r;  r>  rB   r   r   r   r   r   __classcell__r   s   @rP   r  r    s_        ;;I* .N NNNIII**** LLL (''' MMM "!!!$$$$!!!!""""     59      > 6; Q Q Q Q Q Q K K K XK    X- - - -[ [ [ [0 0 0 0& & & &	
 	
 	
 	
 
 
 
 [
! ! ! !    [    rO   r  c                  R     e Zd ZU dZdZded<   ded<   ded<   ded<   d fdZ xZS )
ImportBasez%Base class for all import statements.)is_unreachableis_top_levelis_mypy_onlyassignmentsr   rQ  rR  rS  zlist[AssignmentStmt]rT  rZ   r[   c                    t                                                       g | _        d| _        d| _        d| _        d S NF)r&  r_   rT  rQ  rR  rS  r^   r   s    rP   r_   zImportBase.__init__|  s?    #!!rO   rZ   r[   )rJ   rK   rL   rh   ri   r   r_   rM  rN  s   @rP   rP  rP  k  s|         //QI &%%%" " " " " " " " " "rO   rP  c                  @     e Zd ZU dZdZdZded<   d fdZddZ xZ	S )Importzimport m [as n])idslist[tuple[str, str | None]]r[  rZ   r[   c                V    t                                                       || _        d S r]   )r&  r_   r[  )r^   r[  r   s     rP   r_   zImport.__init__  s$    rO   r   r   rj   c                ,    |                     |           S r]   )visit_importr   s     rP   r   zImport.accept  s    ##D)))rO   )r[  r\  rZ   r[   r   
rJ   rK   rL   rh   ri   rL  r   r_   r   rM  rN  s   @rP   rZ  rZ    so         IN%%%%     * * * * * * * *rO   rZ  c                  T     e Zd ZU dZdZdZded<   ded<   ded<   d fdZddZ xZ	S )
ImportFromzfrom m import x [as y], ...)idr  relativer   rc  rY   rd  r\  r  rZ   r[   c                r    t                                                       || _        || _        || _        d S r]   )r&  r_   rc  r  rd  )r^   rc  rd  r  r   s       rP   r_   zImportFrom.__init__  s2    
 rO   r   r   rj   c                ,    |                     |           S r]   )visit_import_fromr   s     rP   r   zImportFrom.accept      ((...rO   )rc  r   rd  rY   r  r\  rZ   r[   r   r`  rN  s   @rP   rb  rb    s         %%+I0NGGGMMM''''! ! ! ! ! !/ / / / / / / /rO   rb  c                  J     e Zd ZU dZdZdZded<   ded<   d fd	ZddZ xZ	S )	ImportAllzfrom m import *)rc  rd  r   rc  rY   rd  rZ   r[   c                d    t                                                       || _        || _        d S r]   )r&  r_   rc  rd  )r^   rc  rd  r   s      rP   r_   zImportAll.__init__  s+     rO   r   r   rj   c                ,    |                     |           S r]   )visit_import_allr   s     rP   r   zImportAll.accept      ''---rO   )rc  r   rd  rY   rZ   r[   r   r`  rN  s   @rP   rj  rj    su         "I'NGGGMMM! ! ! ! ! !
. . . . . . . .rO   rj  )is_propertyis_class	is_staticis_finalFUNCBASE_FLAGSc                       e Zd ZdZdZd fdZeedd                        Zedd            Z	edd
            Z
 xZS )FuncBasea  Abstract 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.
    )r   unanalyzed_typeinforo  rp  rq  rr  is_explicit_overrideis_type_check_onlydef_or_infer_varsr  rZ   r[   c                    t                                                       d | _        d | _        t          | _        d| _        d| _        d| _        d| _	        d| _
        d| _        d| _        d| _        d S )NFr   )r&  r_   r   rv  FUNC_NO_INFOrw  ro  rp  rq  rr  rx  ry  rz  r  rW  s    rP   r_   zFuncBase.__init__  su     37	=A 	  $)!"' "'rO   r   c                    d S r]   rN   r   s    rP   r   zFuncBase.name  r   rO   c                    | j         S r]   r2  r   s    rP   r   zFuncBase.fullname  r3  rO   r   c                (    | j          p
| j        dk    S )a  If used as a method, does it have an argument for method binding (`self`, `cls`)?

        This is true for `__new__` even though `__new__` does not undergo method binding,
        because we still usually assume that `cls` corresponds to the enclosing class.
        __new__)rq  r   r   s    rP   has_self_or_cls_argumentz!FuncBase.has_self_or_cls_argument  s     >!;TY)%;;rO   rX  r   rK  )rJ   rK   rL   rh   ri   r_   r   r   r   r   r  rM  rN  s   @rP   ru  ru    s         I     @    ^ X    X < < < X< < < < <rO   ru  )FuncDef	DecoratorOverloadPartc                       e Zd ZU dZdZded<   ded<   ded<   ded	<   d
ed<   d" fdZed#d            Zed$d            Z	ed%d            Z
d&dZd'dZed(d            Zd)dZed*d             Zd$d!Z xZS )+OverloadedFuncDefaR  A 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.
    )r  unanalyzed_itemsimpl
deprecatedsetter_index_is_trivial_selflist[OverloadPart]r  r  zOverloadPart | Noner  
str | Noner  rb   r  rZ   r[   c                    t                                                       || _        |                                | _        d | _        d | _        d | _        d | _        |r.| 	                    |d         j
        |d         j                   d S d S Nr   )r&  r_   r  copyr  r  r  r  r  re   rT   rU   r^   r  r   s     rP   r_   zOverloadedFuncDef.__init__+  s    
 %

	 -1 	:MM%(-q99999	: 	:rO   r   c                ^    | j         r| j         d         j        S | j        J | j        j        S r  )r  r   r  r   s    rP   r   zOverloadedFuncDef.name7  s5    : 	":a=%% 9(((9>!rO   r   c                0   | j         | j         S t          | j                  D ]k\  }}|dk    s| j        sdnd}t	          |t
                    r|j        s
d| _          dS =t          |j                  |k    s|j	        j        s
d| _          dS ld| _         dS )zCheck we can use bind_self() fast path for this overload.

        This will return False if at least one overload:
          * Has an explicit self annotation, or Self in signature.
          * Has a non-trivial decorator.
        Nr   rn   FT)
r  	enumerater  ro  rd   r  is_trivial_selfr  
decoratorsfunc)r^   iitemtrivials       rP   r  z!OverloadedFuncDef.is_trivial_self@  s      ,(( ,, 		 		GAtq55(85aaaG$(( + !,1D) 55! T_%%//ty7P/(-%uu 0 !%trO   r  c                    | j         d         }t          |t                    sJ |j        j        sJ | j        J | j         | j                 }t          |t                    sJ |S r  )r  rd   r  varis_settable_propertyr  )r^   
first_itemr  s      rP   setterzOverloadedFuncDef.setterW  so     Z]
*i00000~2222 ,,,z$+,$	*****rO   r   r   rj   c                ,    |                     |           S r]   )visit_overloaded_func_defr   s     rP   r   zOverloadedFuncDef.acceptb      00666rO   rl   c           	         dd | j         D             | j        d n| j                                        | j        | j        d n| j                                        t          | t                    | j        | j        dS )Nr  c                6    g | ]}|                                 S rN   r   )r   r  s     rP   r  z/OverloadedFuncDef.serialize.<locals>.<listcomp>h       888akkmm888rO   )r   r  r   r   r  flagsr  r  )	r  r   r   r  r  	get_flagsrs  r  r  r   s    rP   r   zOverloadedFuncDef.serializee  s|    )88TZ888 I-DD493F3F3H3H I-DD493F3F3H3Ht^44/ -	
 	
 		
rO   r   c                   |d         dk    sJ t          d |d         D                       }|                    d          ot          t          t                              |d                             |_        t          |j                  dk    r|	                    |j        j
                   |                    d          Mt          j                            |d                   }t          |t          j        j                  sJ ||_        |d         |_        t%          ||d	                    |d
         |_        |d         |_        |S )Nr   r  c                h    g | ]/}t          t          t                              |                    0S rN   )r   r  r   r   )r   ds     rP   r  z1OverloadedFuncDef.deserialize.<locals>.<listcomp>u  s0    RRRqT,
 6 6q 9 9::RRRrO   r  r  r   r   r   r  r  r  )r  r   r   r  r   r   r  r  r  re   rT   r   typesdeserialize_typerd   
ProperTyper   r  	set_flagsr  r  )r   r   restyps       rP   r   zOverloadedFuncDef.deserializeq  s'   H~!44444RRDMRRR
 
 88F'L**@*@f*N*NOOCH39~~!!SX]+++88F'*--d6l;;Cc4:#899999CHZ(#tG}%%%l+/
rO   r*   c                   t          |t                     t          |t                     t          |t	          | j                             | j        D ]}|                    |           t          j        	                    || j
                   t          || j                   | j        t          |t                     n| j                            |           t          || j        | j        | j        | j        g           t)          || j                   t-          || j                   t          |t0                     d S r]   )r>   OVERLOADED_FUNC_DEFr"   r  r  r  r   r   r  write_type_optr   r   r  r  r&   write_flagsro  rp  rq  rr  r<   r  r8   r  r!   )r^   r   r  s      rP   r   zOverloadedFuncDef.write  s   $+,,,$!!!tS__---J 	 	DJJt
!!$	222$'''9dL))))IOOD!!!D4+T]DNDMZ[[[dDO,,,dD-...$     rO   r(   c                   t                    t          k    sJ t          fdt          t	                              D                       }t
          j                                      }|(t          |t
          j        j	                  sJ ||_
        t                    |_        t                    }|t          k    rLt          |          |_        t!          |j                  dk    r|                    |j        j                   t)          d          \  |_        |_        |_        |_        t3                    |_        t7                    |_        t                    t:          k    sJ |S )Nc                .    g | ]}t                    S rN   )read_overload_partr
  s     rP   r  z*OverloadedFuncDef.read.<locals>.<listcomp>  s"     ^ ^ ^a!3D!9!9 ^ ^ ^rO   r      	num_flags)r4   r"   r  r  r  r   r  read_type_optrd   r  r   r   r  r&   r  r  r  r  re   rT   
read_flagsro  rp  rq  rr  r2   r  r.   r  r!   )r   r   r  r  r   s    `   rP   r   zOverloadedFuncDef.read  sF   ~~)))) ^ ^ ^ ^5W[I\I\C]C] ^ ^ ^__j&&t,,?c4:#899999CH tnn,)$44CH39~~!!SX]+++EOPT`aEbEbEbBs}cl%d++'--~~((((
rO   c                >    t          d | j        D                       S )Nc              3  >   K   | ]}|                                 V  d S r]   )
is_dynamicr   r  s     rP   	<genexpr>z/OverloadedFuncDef.is_dynamic.<locals>.<genexpr>  s,      <<4??$$<<<<<<rO   )allr  r   s    rP   r  zOverloadedFuncDef.is_dynamic  s!    <<<<<<<<rO   )r  r  rZ   r[   r   rK  )rZ   r  r   r   )r   rl   rZ   r  r   )r   r(   rZ   r  )rJ   rK   rL   rh   ri   r   r_   r   r   r  r  r   r   r   r   r   r   r  rM  rN  s   @rP   r  r    s~         I ((((
: 
: 
: 
: 
: 
: " " " X"    X,    X7 7 7 7

 

 

 

    [*! ! ! !"    [*= = = = = = = =rO   r  c                  D     e Zd ZdZdZdZ	 dd fdZ	 	 	 dd fdZ xZS )Argumentz A single argument in a FuncItem.)variabletype_annotationinitializerkindpos_onlyFr  Varr  mypy.types.Type | Noner  Expression | Noner  ArgKindr  r   rZ   r[   c                    t                                                       || _        || _        || _        || _        || _        d S r]   )r&  r_   r  r  r  r  r  )r^   r  r  r  r  r  r   s         rP   r_   zArgument.__init__  sD     	 .&	 rO   Nr`   ra   rU   rb   rV   rW   c                B   t                                          ||||           | j        rA| j        j        dk     r1| j                            | j        | j        | j        | j                   | j                            | j        | j        | j        | j                   d S r  )r&  re   r  rT   rU   rV   rW   r  )r^   r`   rU   rV   rW   r   s        rP   re   zArgument.set_line  s     	:>>> 	^ 0 5 9 9%%didmT_]]]ty$+t}doVVVVVrO   F)r  r  r  r  r  r  r  r  r  r   rZ   r[   rf   rg   )	rJ   rK   rL   rh   ri   rL  r_   re   rM  rN  s   @rP   r  r    s        **RIWN ! ! ! ! ! ! !$ "#!%W W W W W W W W W W WrO   r  TYPE_VAR_KINDPARAM_SPEC_KINDTYPE_VAR_TUPLE_KINDc                      e Zd ZdZddZdS )	TypeParamr   r  upper_boundvaluesdefaultr   r   r  rY   r  r  r  list[mypy.types.Type]r  rZ   r[   c                L    || _         || _        || _        || _        || _        d S r]   r  )r^   r   r  r  r  r  s         rP   r_   zTypeParam.__init__  s,     		&rO   N)r   r   r  rY   r  r  r  r  r  r  rZ   r[   )rJ   rK   rL   ri   r_   rN   rO   rP   r  r    s-        DI     rO   r  )is_overloadis_generatoris_coroutineis_async_generatoris_awaitable_coroutineFUNCITEM_FLAGSc                  F     e Zd ZdZdZdZ	 	 	 	 dd fdZddZddZ xZ	S )FuncItemz9Base class for nodes usable as overloaded function items.)	arguments	arg_names	arg_kindsmin_argsmax_pos	type_argsbodyr  r  r  r  r  expanded)r  r  r  Nr  list[Argument] | Noner  Block | Noner  mypy.types.FunctionLike | Noner  list[TypeParam] | NonerZ   r[   c                   t                                                       |pg | _        d | j        D             | _        d | j        D             | _        | j                            t                    | j                            t                    z   | _        || _	        |pt          g           | _        || _        || _        d| _        d| _        d| _        d| _        d| _        g | _        d| _        t+          t-          | j                            D ]1}| j        |         "||                                 k     r
|dz   | _        2d S )Nc                8    g | ]}|j         rd n|j        j        S r]   )r  r  r   r   args     rP   r  z%FuncItem.__init__.<locals>.<listcomp>  s(    ```##,E$$CL4E```rO   c                    g | ]	}|j         
S rN   )r  r  s     rP   r  z%FuncItem.__init__.<locals>.<listcomp>  s    (L(L(Lc(L(L(LrO   Fr   rn   )r&  r_   r  r  r  countARG_POSARG_OPTr  r  Blockr  r   rv  r  r  r  r  r  r  r  r  r  max_fixed_argc)r^   r  r  r  r  r  r   s         rP   r_   zFuncItem.__init__  s;    	"b``QUQ_```(L(LT^(L(L(L N0099DN<P<PQX<Y<YY1:,599		"!&"'"'(-,1#(*s4>**++ 	& 	&A~a (Q1D1D1F1F-F-F !A	& 	&rO   rY   c                    | j         S r]   )r  r   s    rP   r  zFuncItem.max_fixed_argc+  s
    |rO   r   c                t    | j         d u p/t          | j         t          j        j                  o| j         j        S r]   )r   rd   r   r  CallableTypeimplicitr   s    rP   r  zFuncItem.is_dynamic.  s7    I #$)TZ%<== #	"	
rO   )NNNN)
r  r  r  r  r  r  r  r  rZ   r[   )rZ   rY   rK  )
rJ   rK   rL   rh   ri   __deletable__r_   r  r  rM  rN  s   @rP   r  r    s        CCI$ 9M ,0!.2,0& & & & & & &8   
 
 
 
 
 
 
 
rO   r  )is_decoratedis_conditionalis_trivial_bodyr  rS  FUNCDEF_FLAGSNOT_ABSTRACTIS_ABSTRACTIMPLICITLY_ABSTRACTc                       e Zd ZdZdZdZ	 	 	 	 	 d d! fdZed"d            Zd#dZ	d$dZ
ed%d            Zd&dZed'd            Z xZS )(r  zQFunction definition.

    This is a non-lambda function defined using 'def'.
    )r   r   r  abstract_statusoriginal_defr  r  is_invalid_redefinitionrS  dataclass_transform_spec	docstringr  original_first_arg)r   r  r   r  r   Nr   r   r  r  r  r  r  r  r  r  rZ   r[   c                D   t                                          ||||           || _        d| _        d| _        t
          | _        d| _        d | _        d| _	        d | _
        d | _        d | _        d| _        |r|d         j        j        | _        nd | _        d| _        d S )NFr   )r&  r_   r   r   r  r  r  r  r	  rS  r  r  r  r  r  r   r  r
  )r^   r   r  r  r  r  r   s         rP   r_   zFuncDef.__init__`  s     	D#y999
!#+  %>B!GK%%)&*  %  	+2;A,2G2LD##&*D# (-$$$rO   c                    | j         S r]   r   r   s    rP   r   zFuncDef.name  
    zrO   r   r   rj   c                ,    |                     |           S r]   )visit_func_defr   s     rP   r   zFuncDef.accept      %%d+++rO   rl   c                   d| j         | j        | j        d | j        D             | j        d n| j                                        t          | t                    | j        | j	        d n| j	                                        | j
        | j        dS )Nr  c                6    g | ]}t          |j                  S rN   rY   valuer   xs     rP   r  z%FuncDef.serialize.<locals>.<listcomp>  s     ???1#ag,,???rO   )r   r   r   r  r  r   r  r  r  r  r  )r   r  r  r  r   r   r  r  r  r  r  r  r   s    rP   r   zFuncDef.serialize  s      J????? I-DD493F3F3H3Ht]33#3 08 2<<>>/"&"9!
 
 	
rO   r   c                d   |d         dk    sJ t          g           }t          |d         g ||d         d nAt          t          j        j        t          j                            |d                                       }|d         |_        t          ||d                    |d         |_	        |
                    d          |_        d	 |d
         D             |_        |d         |_        |d          t                              |d                   nd |_        |d         |_        |`|`|`|S )Nr   r  r   r   r   r  r  r  c                (    g | ]}t           |         S rN   	ARG_KINDSr  s     rP   r  z'FuncDef.deserialize.<locals>.<listcomp>  s    AAA!1AAArO   r  r  r  r  )r  r  r   r   r  FunctionLiker  r  r  r  r   r  r  r  DataclassTransformSpecr   r  r  r  r  r  )r   r   r  rets       rP   r   zFuncDef.deserialize  s:   H~****RyyL <' $*14:3N3NtTZ|3\3\]]	
 	
 Z(#tG}%%%[)!%*>!?!?AAtK/@AAA"#45 ./; #..t4N/OPPP 	$
 l+MKL
rO   r*   c                   t          |t                     t          || j                   t          j                            || j                   t          || j                   t          || j
        | j        | j        | j        | j        | j        | j        | j        | j        | j        | j        | j        | j        | j        g           t1          || j                   t5          |d | j        D                        t9          || j                   | j        t          |t>                     n| j                             |           tC          || j"                   tC          || j#                   t          |tH                     d S )Nc                6    g | ]}t          |j                  S rN   r  r   aks     rP   r  z!FuncDef.write.<locals>.<listcomp>  s     EEEc"(mmEEErO   )%r>   FUNC_DEFr   r   r   r  r  r   r  r  ro  rp  rq  rr  r  r  r  r  r  r   r  r  r  rS  r=   r  r7   r  r   r  r  r&   r   r<   r  r  r!   r   s     rP   r   zFuncDef.write  sq   $!!!$
###
!!$	222$'''  !!'+!#$$!	
 	
 	
& 	4000tEEdnEEEFFF$,---(0dL)))))//555dDO,,,dD3444$     rO   r(   c                v   t          |          }d }t          |          }|t          k    r t          j                            ||          }t          |g t          g           |          }t          |          |_        t          |d          \  |_
        |_        |_        |_        |_        |_        |_        |_        |_        |_        |_        |_        |_        |_        t1          |          |_        d t5          |          D             |_        t9          |          |_        t          |          }|t          k    r,|t<          k    sJ t>                               |          |_!        tE          |          |_#        tE          |          |_$        |`%|`&|`'t          |          tP          k    sJ |S )N   r  c                (    g | ]}t           |         S rN   r  r$  s     rP   r  z FuncDef.read.<locals>.<listcomp>  s    EEE22EEErO   ))r   r4   r&   r   r  read_function_liker  r  r  r  ro  rp  rq  rr  r  r  r  r  r  r   r  r  r  rS  r3   r  r-   r  r   r  r    r   r   r  r2   r  r  r  r  r  r!   )r   r   r   r  r   r!  s         rP   r   zFuncDef.read  s   ~~.2tnn,*//c::CdBb		3//   tr***	
OLMLO"& *$//EEt1D1DEEE&tnntnn,'>>>>+A+F+Ft+L+LC(%d++!-d!3!3MKL~~((((
rO   )r   NNNN)r   r   r  r  r  r  r  r  r  r  rZ   r[   r   r   r   )r   rl   rZ   r  r   )r   r(   rZ   r  )rJ   rK   rL   rh   ri   rL  r_   r   r   r   r   r   r   r   r   rM  rN  s   @rP   r  r  F  s
        
I" ;N
 +/!.2,0$- $- $- $- $- $- $-L    X, , , ,
 
 
 
4    [@!! !! !! !!F ' ' ' [' ' ' ' 'rO   r  SYMBOL_FUNCBASE_TYPESc                  (    e Zd ZU dZdZdZded<   ded<   ded<   d	ed
<   ded<   d% fdZed&d            Z	ed&d            Z
ed'd            Zed(d            Zed)d            Zd*dZd+dZed,d            Zd-d!Zed.d#            Zd'd$Z xZS )/r  zhA decorated function.

    A single Decorator object can include any number of function decorators.
    )r  r  original_decoratorsr  r  )r  r  r  r  r  list[Expression]r  r-  r  r  r   r  rZ   r[   c                    t                                                       || _        || _        |                                | _        || _        d| _        d S rV  )r&  r_   r  r  r  r-  r  r  )r^   r  r  r  r   s       rP   r_   zDecorator.__init__/  sN    	$#-??#4#4  rO   r   c                    | j         j        S r]   )r  r   r   s    rP   r   zDecorator.name7      y~rO   c                    | j         j        S r]   )r  r   r   s    rP   r   zDecorator.fullname;      y!!rO   c                    | j         j        S r]   )r  rr  r   s    rP   rr  zDecorator.is_final?  r3  rO   r   c                    | j         j        S r]   )r  rw  r   s    rP   rw  zDecorator.infoC  r1  rO   r  c                    | j         j        S r]   )r  r   r   s    rP   r   zDecorator.typeG  s    x}rO   r   r   rj   c                ,    |                     |           S r]   )visit_decoratorr   s     rP   r   zDecorator.acceptK  r6  rO   rl   c                v    d| j                                         | j                                        | j        dS )Nr  )r   r  r  r  )r  r   r  r  r   s    rP   r   zDecorator.serializeN  s<    !I''))8%%''+	
 
 	
rO   r   c                    |d         dk    sJ t          t                              |d                   g t                              |d                             }|d         |_        |S )Nr   r  r  r  r  )r  r  r   r  r  )r   r   decs      rP   r   zDecorator.deserializeV  s\    H~,,,,++DL992stTY{?[?[\\}-
rO   r*   c                    t          |t                     | j                            |           | j                            |           t          || j                   t          |t                     d S r]   )r>   	DECORATORr  r   r  r5   r  r!   r   s     rP   r   zDecorator.write]  sc    $	"""	t4)***$     rO   r(   c                T   t          |          t          k    sJ t                              |          }t          |          t          k    sJ t
                              |          }t          |g |          }t          |          |_        t          |          t          k    sJ |S r]   )
r4   r&  r  r   VARr  r  r+   r  r!   )r   r   r  r  r;  s        rP   r   zDecorator.readd  s    ~~))))||D!!~~$$$$hhtnnb#&&#D//~~((((
rO   c                4    | j                                         S r]   )r  r  r   s    rP   r  zDecorator.is_dynamico      y##%%%rO   )r  r  r  r.  r  r  rZ   r[   r   rK  )rZ   r   rZ   r  r   r   )r   rl   rZ   r  r   )r   r(   rZ   r  )rJ   rK   rL   rh   ri   rL  r   r_   r   r   r   rr  rw  r   r   r   r   r   r   r   r  rM  rN  s   @rP   r  r    s         
 TI2NMMM    ))))HHH! ! ! ! ! !    X " " " X" " " " X"    X    X- - - -
 
 
 
    [! ! ! !    [& & & & & & & &rO   r  )is_selfis_clsis_initialized_in_classis_staticmethodis_classmethodro  r  is_suppressed_importis_classvaris_abstract_varrr  is_index_varfinal_unset_in_classfinal_set_in_initexplicit_self_typeis_readyis_inferredinvalid_partial_typefrom_module_getattrhas_explicit_valueallow_incompatible_override	VAR_FLAGSc                       e Zd ZdZdZdZdd fdZedd            Zedd            Z	ddZ
ddZddZed d            Zd!dZed"d            Z xZS )#r  zPA variable.

    It can refer to global/local variable or a data attribute.
    )r   r  rw  r   setter_typefinal_valuerC  rD  rO  rP  rE  rF  rG  ro  r  rI  rJ  rr  rK  rL  rM  rH  rN  rR  rS  rT  rQ  is_argument)r   r   rX  Nr   r   r   r  rZ   r[   c                   t                                                       || _        d| _        t          | _        || _        d | _        d| _        d| _	        d| _
        | j        d u | _        d| _        d| _        d| _        d| _        d| _        d| _        d| _        d| _        d| _        d| _        d | _        d| _        d| _        d| _        d| _        d| _        d| _        d| _        d| _        d S )Nr   FT)r&  r_   r   r  VAR_NO_INFOrw  r   rW  rC  rD  rO  rP  rE  rF  rG  ro  r  rI  rJ  rK  rH  rr  rX  rL  rM  rN  rR  rS  rT  rQ  rY  )r^   r   r   r   s      rP   r_   zVar.__init__  s   
	,0	;?9, (-$$# $)! $! %*! GK$)!!& #(#(  #(+0( %*! rO   c                    | j         S r]   r  r   s    rP   r   zVar.name  r  rO   c                    | j         S r]   r2  r   s    rP   r   zVar.fullname  r3  rO   c                d    | j         p| j        }d|dt          t          |                      dS )Nz<Var z at >)r   r   hexrc  r^   r   s     rP   __repr__zVar.__repr__  s5    })	3t333r$xx==3333rO   r   r   rj   c                ,    |                     |           S r]   )	visit_varr   s     rP   r   z
Var.accept  s      &&&rO   rl   c           	         d| j         | j        | j        d n| j                                        | j        d n| j                                        t          | t                    d}| j        
| j        |d<   |S )Nr  )r   r   r   r   rW  r  rX  )r   r  r   r   rW  r  rU  rX  r   s     rP   r   zVar.serialize  s     J I-DD493F3F3H3H#'#3#;44AQA[A[A]A]tY//
 
 '"&"2DrO   r   c                (   |d         dk    sJ |d         }|d         d n$t           j                            |d                   }|d         d n$t           j                            |d                   }t          ||          }|@t	          |t           j        j                  rt	          |t           j        j                  sJ ||_        d|_        |d         |_	        t          ||d                    |                    d	          |_        |S )
Nr   r  r   r   rW  Fr   r  rX  )r   r  r  r  rd   r  r  rW  rO  r  r  r   rX  )r   r   r   r   rW  vs         rP   r   zVar.deserialize  s	   H~&&&&F|F|+tt1L1LTRX\1Z1Z M"* D,,T--@AA 	
 dOO+tz'<==  ;
(?@@   $
:&!T']###//rO   r*   c                p   t          |t                     t          || j                   t          j                            || j                   t          j                            || j                   t          || j	                   t          || j        | j        | j        | j        | j        | j        | j        | j        | j        | j        | j        | j        | j        | j        | j        | j        | j        | j        | j        g           t=          || j                   t          |t@                     d S r]   )!r>   r?  r   r   r   r  r  r   rW  r  r  rE  rF  rG  ro  r  rH  rI  rJ  rr  rK  rL  rM  rN  rO  rP  rQ  rR  rS  rT  r:   rX  r!   r   s     rP   r   z	Var.write#  s    $$
###
!!$	222
!!$(8999$''',$# )) $!)&' )('0'	
 	
 	
0 	dD,---$     rO   r(   c                v   t          |          }t          j                            |          }t	          ||          }d }t          |          }|t          k    r;|t          j        j        k    sJ t          j        j        	                    |          }||_
        t          |          |_        t          |d          \  |_        |_        |_        |_        |_        |_        |_        |_        |_        |_        |_        |_        |_        |_        |_        |_        |_        |_        |_        t          |          }|t@          k    r0tC          tE          |          tE          |                    |_#        n |t          k    rtI          ||          |_#        t          |          tJ          k    sJ |S )N   r  )&r   r   r  r  r  r4   r&   CALLABLE_TYPEr  r   rW  r  r  rE  rF  rG  ro  r  rH  rI  rJ  rr  rK  rL  rM  rN  rO  rP  rQ  rR  rS  rT  r$   complexread_float_barerX  r0   r!   )r   r   r   r  rg  rW  r   s          rP   r   zVar.readD  s   ~~j&&t,,cNN6:tnn,$*22222*166t<<K#tnn* tr***)	
%M""MJN" JM"! )tnn/!!#OD$9$9?4;P;PQQAMML  (s33AM~~((((rO   r]   )r   r   r   r  rZ   r[   r   r   r   )r   rl   rZ   r  r   )r   r(   rZ   r  )rJ   rK   rL   rh   ri   rL  r_   r   r   r   rb  r   r   r   r   r   r   rM  rN  s   @rP   r  r    s,        
I> 5N9! 9! 9! 9! 9! 9! 9!v    X    X4 4 4 4' ' ' '       [,! ! ! !B & & & [& & & & &rO   r  c                  P    e Zd ZU dZdZdZded<   ded<   ded<   d	ed
<   ded<   ded<   ded<   ded<   ded<   ded<   ded<   ded<   ded<   ded<   	 	 	 	 	 d3d4 fd"Zed5d#            Z	e	j
        d6d%            Z	d7d)Zd8d*Zd9d,Zed:d.            Zd;d0Zed<d2            Z xZS )=ClassDefzClass definition)r   r  r   r  	type_varsbase_type_exprsremoved_base_type_exprsrw  	metaclassr  keywordsanalyzedhas_incompatible_baseclassr  removed_statements)r   r   r   r   r  r  r   r  r  z list[mypy.types.TypeVarLikeType]rp  r.  rq  rr  r   rw  r  rs  r  zdict[str, Expression]rt  ru  r   rv  r   rw  N'list[mypy.types.TypeVarLikeType] | Nonelist[Expression] | None#list[tuple[str, Expression]] | NonerZ   r[   c                N   t                                                       || _        d| _        || _        |pg | _        || _        |pg | _        g | _        t          | _
        || _        g | _        |rt          |          ni | _        d | _        d| _        d | _        g | _        d S Nr   F)r&  r_   r   r  r   rp  r  rq  rr  CLASSDEF_NO_INFOrw  rs  r  dictrt  ru  rv  r  rw  )	r^   r   r   rp  rq  rs  rt  r  r   s	           rP   r_   zClassDef.__init__  s     			"b".4"')$$	"*2:X*/'%)"$rO   c                    | j         S r]   r2  r   s    rP   r   zClassDef.fullname  r3  rO   rg  c                    || _         d S r]   r2  r^   rg  s     rP   r   zClassDef.fullname      rO   r   r   rj   c                ,    |                     |           S r]   )visit_class_defr   s     rP   r   zClassDef.accept  r6  rO   c                4    | j                                         S r]   )rw  
is_genericr   s    rP   r  zClassDef.is_generic  rA  rO   rl   c                B    d| j         | j        d | j        D             dS )Nro  c                6    g | ]}|                                 S rN   r  r   rg  s     rP   r  z&ClassDef.serialize.<locals>.<listcomp>  s     @@@A!++--@@@rO   )r   r   r   rp  )r   r   rp  r   s    rP   r   zClassDef.serialize  s3     !I@@@@@	
 
 	
rO   r   c                    |d         dk    sJ t          |d         t          g           d |d         D                       }|d         |_        |S )Nr   ro  r   c                    g | ]>}t          t          j        j        t          j                            |                    ?S rN   )r   r   r  TypeVarLikeTyper  r  s     rP   r  z(ClassDef.deserialize.<locals>.<listcomp>  sG        TZ/1L1LQ1O1OPP  rO   rp  r   )ro  r  r   r   r   r  s      rP   r   zClassDef.deserialize  sj    H~++++L"II k*  	
 
 J'
rO   r*   c                    t          |t                     t          || j                   t          j                            || j                   t          || j                   t          |t                     d S r]   )
r>   	CLASS_DEFr   r   r   r  write_type_listrp  r   r!   r   s     rP   r   zClassDef.write  sf    $	"""$	"""
""4888$&&&$     rO   r(   c                    t          t          |          t          g           t          j                            |                    }t          |          |_        t          |          t          k    sJ |S r]   )	ro  r   r  r   r  read_type_var_likesr   r4   r!   r  s      rP   r   zClassDef.read  sY    x~~uRyy$*2P2PQU2V2VWW~~~~((((
rO   )NNNNN)r   r   r   r  rp  rx  rq  ry  rs  r  rt  rz  r  r  rZ   r[   r   rg  r   rZ   r[   r   rK  r   )r   rl   rZ   ro  r   )r   r(   rZ   ro  )rJ   rK   rL   rh   ri   rL  r   r_   r   r   r  r   r  r   r   r   r   r   rM  rN  s   @rP   ro  ro  n  s        I$ &NIIINNNKKK%%%%////%%%%----NNN        ####$$$$'''' >B37'+8<,0% % % % % % %6    X _   _- - - -& & & &
 
 
 
    [! ! ! !    [    rO   ro  c                  @     e Zd ZU dZdZdZded<   d fdZddZ xZ	S )
GlobalDeclzDeclaration global x, y, ...r  	list[str]r  rZ   r[   c                V    t                                                       || _        d S r]   r&  r_   r  r^   r  r   s     rP   r_   zGlobalDecl.__init__  $    


rO   r   r   rj   c                ,    |                     |           S r]   )visit_global_declr   s     rP   r   zGlobalDecl.accept  rh  rO   r  r  rZ   r[   r   r`  rN  s   @rP   r  r    so         &&IN     / / / / / / / /rO   r  c                  @     e Zd ZU dZdZdZded<   d fdZddZ xZ	S )NonlocalDeclzDeclaration nonlocal x, y, ...r  r  r  rZ   r[   c                V    t                                                       || _        d S r]   r  r  s     rP   r_   zNonlocalDecl.__init__  r  rO   r   r   rj   c                ,    |                     |           S r]   )visit_nonlocal_declr   s     rP   r   zNonlocalDecl.accept      **4000rO   r  r   r`  rN  s   @rP   r  r    so         ((IN     1 1 1 1 1 1 1 1rO   r  c                  6     e Zd ZdZdZddd fd
ZddZ xZS )r  )r  rQ  F)rQ  r  r   rQ  r   rZ   r[   c               d    t                                                       || _        || _        d S r]   )r&  r_   r  rQ  )r^   r  rQ  r   s      rP   r_   zBlock.__init__  s0    	 -rO   r   r   rj   c                ,    |                     |           S r]   )visit_blockr   s     rP   r   zBlock.accept  s    ""4(((rO   )r  r   rQ  r   rZ   r[   r   )rJ   rK   rL   ri   rL  r_   r   rM  rN  s   @rP   r  r    sh        *I/NHM - - - - - - - -) ) ) ) ) ) ) )rO   r  c                  @     e Zd ZU dZdZdZded<   d fdZddZ xZ	S )ExpressionStmtz/An expression as a statement, such as print(s).exprr   r  rZ   r[   c                V    t                                                       || _        d S r]   r&  r_   r  r^   r  r   s     rP   r_   zExpressionStmt.__init__+  $    			rO   r   r   rj   c                ,    |                     |           S r]   )visit_expression_stmtr   s     rP   r   zExpressionStmt.accept/      ,,T222rO   r  r   rZ   r[   r   r`  rN  s   @rP   r  r  "  so         99IN     3 3 3 3 3 3 3 3rO   r  c                       e Zd ZU dZdZdZded<   ded<   ded	<   ded
<   ded<   ded<   ded<   ded<   	 	 dd fdZddZ xZ	S )AssignmentStmtab  Assignment 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.
    )lvaluesrvaluer   rv  
new_syntaxis_alias_defis_final_definvalid_recursive_alias)r  rvaluesr   list[Lvalue]r  r   r  r  r   rv  r   r  r  r  r  NFrZ   r[   c                    t                                                       || _        || _        || _        || _        || _        d| _        d| _        d| _	        d S rV  )
r&  r_   r  r  r   rv  r  r  r  r  )r^   r  r  r   r  r   s        rP   r_   zAssignmentStmt.__init__a  s]     		#$!!',$$$rO   r   r   rj   c                ,    |                     |           S r]   )visit_assignment_stmtr   s     rP   r   zAssignmentStmt.acceptr  r  rO   rV  )
r  r  r  r   r   r  r  r   rZ   r[   r   r`  rN  s   @rP   r  r  3  s          	I 4N    ++++  "!!! (, - - - - - - -"3 3 3 3 3 3 3 3rO   r  c                  T     e Zd ZU dZdZdZded<   ded<   ded	<   d fdZddZ xZ	S )OperatorAssignmentStmtz,Operator assignment statement such as x += 1)oplvaluer  )r  r  r  r   r  r   r  r   r  rZ   r[   c                r    t                                                       || _        || _        || _        d S r]   )r&  r_   r  r  r  )r^   r  r  r  r   s       rP   r_   zOperatorAssignmentStmt.__init__  s2    rO   r   r   rj   c                ,    |                     |           S r]   )visit_operator_assignment_stmtr   s     rP   r   zOperatorAssignmentStmt.accept      55d;;;rO   )r  r   r  r   r  r   rZ   r[   r   r`  rN  s   @rP   r  r  v  s         66*I/NGGGNNN     < < < < < < < <rO   r  c                  P     e Zd ZU dZdZded<   ded<   ded<   d fd
ZddZ xZS )	WhileStmt)r  r  	else_bodyr   r  r  r  r  r  rZ   r[   c                r    t                                                       || _        || _        || _        d S r]   )r&  r_   r  r  r  r^   r  r  r  r   s       rP   r_   zWhileStmt.__init__  s2    		"rO   r   r   rj   c                ,    |                     |           S r]   )visit_while_stmtr   s     rP   r   zWhileStmt.accept  rn  rO   )r  r   r  r  r  r  rZ   r[   r   	rJ   rK   rL   ri   rL  r   r_   r   rM  rN  s   @rP   r  r    s~         -I2NKKK# # # # # #. . . . . . . .rO   r  c                       e Zd ZU dZdZded<   ded<   ded<   ded<   ded	<   d
ed<   ded<   ded<   ded<   	 dd fdZddZ xZS )ForStmt)	index
index_typeunanalyzed_index_typeinferred_item_typeinferred_iterator_typer  r  r  is_async)r  r  r  r  r  r   r  r  r  r  r  r  r   r  r  r  r  r  r   r  NrZ   r[   c                    t                                                       || _        || _        || _        d | _        d | _        || _        || _        || _	        d| _
        d S rV  )r&  r_   r  r  r  r  r  r  r  r  r  )r^   r  r  r  r  r  r   s         rP   r_   zForStmt.__init__  sa     	
$%/""&&*#		"rO   r   r   rj   c                ,    |                     |           S r]   )visit_for_stmtr   s     rP   r   zForStmt.accept  r  rO   r]   )r  r   r  r   r  r  r  r  r  r  rZ   r[   r   r  rN  s   @rP   r  r    s         
I JN MMM&&&&1111....2222KKKNNN .2      &, , , , , , , ,rO   r  c                  <     e Zd ZU dZdZded<   d fdZdd
Z xZS )
ReturnStmtr  r  r  rZ   r[   c                V    t                                                       || _        d S r]   r  r  s     rP   r_   zReturnStmt.__init__  r  rO   r   r   rj   c                ,    |                     |           S r]   )visit_return_stmtr   s     rP   r   zReturnStmt.accept  rh  rO   r  r  rZ   r[   r   r  rN  s   @rP   r  r    si         IN     / / / / / / / /rO   r  c                  H     e Zd ZU dZdZded<   ded<   dd fd	ZddZ xZS )
AssertStmt)r  msgr   r  r  r  NrZ   r[   c                d    t                                                       || _        || _        d S r]   )r&  r_   r  r  )r^   r  r  r   s      rP   r_   zAssertStmt.__init__  s+    	rO   r   r   rj   c                ,    |                     |           S r]   )visit_assert_stmtr   s     rP   r   zAssertStmt.accept  rh  rO   r]   )r  r   r  r  rZ   r[   r   r  rN  s   @rP   r  r    sz         I$N      
/ / / / / / / /rO   r  c                  <     e Zd ZU dZdZded<   d fdZdd
Z xZS )DelStmtr  r   r  rZ   r[   c                V    t                                                       || _        d S r]   r  r  s     rP   r_   zDelStmt.__init__  r  rO   r   r   rj   c                ,    |                     |           S r]   )visit_del_stmtr   s     rP   r   zDelStmt.accept  r  rO   )r  r   rZ   r[   r   r  rN  s   @rP   r  r    sf         INLLL     , , , , , , , ,rO   r  c                      e Zd ZdZddZdS )		BreakStmtrN   r   r   rZ   rj   c                ,    |                     |           S r]   )visit_break_stmtr   s     rP   r   zBreakStmt.accept  rn  rO   Nr   rJ   rK   rL   ri   r   rN   rO   rP   r  r    s-        I. . . . . .rO   r  c                      e Zd ZdZddZdS )	ContinueStmtrN   r   r   rZ   rj   c                ,    |                     |           S r]   )visit_continue_stmtr   s     rP   r   zContinueStmt.accept  r  rO   Nr   r  rN   rO   rP   r  r  
  s-        I1 1 1 1 1 1rO   r  c                      e Zd ZdZddZdS )	PassStmtrN   r   r   rZ   rj   c                ,    |                     |           S r]   )visit_pass_stmtr   s     rP   r   zPassStmt.accept  r6  rO   Nr   r  rN   rO   rP   r  r    s-        I- - - - - -rO   r  c                  Z     e Zd ZU dZdZded<   ded<   ded<   ded	<   d fdZddZ xZS )IfStmt)r  r  r  unreachable_elser.  r  list[Block]r  r  r  r   r  rZ   r[   c                    t                                                       || _        || _        || _        d| _        d S rV  )r&  r_   r  r  r  r  r  s       rP   r_   zIfStmt.__init__'  s<    		" %rO   r   r   rj   c                ,    |                     |           S r]   )visit_if_stmtr   s     rP   r   zIfStmt.accept.      $$T***rO   )r  r.  r  r  r  r  rZ   r[   r   r  rN  s   @rP   r  r    s         AIFN & & & & & &+ + + + + + + +rO   r  c                  F     e Zd ZU dZdZded<   ded<   d fdZddZ xZS )	RaiseStmt)r  	from_exprr  r  r  rZ   r[   c                d    t                                                       || _        || _        d S r]   )r&  r_   r  r  )r^   r  r  r   s      rP   r_   zRaiseStmt.__init__;  s+    	"rO   r   r   rj   c                ,    |                     |           S r]   )visit_raise_stmtr   s     rP   r   zRaiseStmt.accept@  rn  rO   )r  r  r  r  rZ   r[   r   r  rN  s   @rP   r  r  2  sw         %I*N     # # # # # #
. . . . . . . .rO   r  c                  x     e Zd ZU dZdZded<   ded<   ded<   ded	<   d
ed<   d
ed<   ded<   d fdZddZ xZS )TryStmt)r  r  varshandlersr  finally_bodyis_starr  r  list[Expression | None]r  list[NameExpr | None]r  r  r  r  r  r  r   r  rZ   r[   c                    t                                                       || _        || _        || _        || _        || _        || _        d| _        d S rV  )	r&  r_   r  r  r  r  r  r  r  )r^   r  r  r  r  r  r  r   s          rP   r_   zTryStmt.__init__S  sQ     			
 "(rO   r   r   rj   c                ,    |                     |           S r]   )visit_try_stmtr   s     rP   r   zTryStmt.accepte  r  rO   )r  r  r  r  r  r  r  r  r  r  r  r  rZ   r[   r   r  rN  s   @rP   r
  r
  D  s         ]IbNKKK""""MMM     $, , , , , , , ,rO   r
  c                  r     e Zd ZU dZdZded<   ded<   ded<   d	ed
<   ded<   ded<   	 dd fdZddZ xZS )WithStmt)r  r`   rv  analyzed_typesr  r  )r  r`   r  r.  r  list[Lvalue | None]r`   r  rv  r  r  r  r  r   r  Ntarget_typerZ   r[   c                    t                                                       || _        || _        || _        g | _        || _        d| _        d S rV  )r&  r_   r  r`   rv  r  r  r  )r^   r  r`   r  r  r   s        rP   r_   zWithStmt.__init__w  sK     		* 	rO   r   r   rj   c                ,    |                     |           S r]   )visit_with_stmtr   s     rP   r   zWithStmt.accept  r6  rO   r]   )
r  r.  r`   r  r  r  r  r  rZ   r[   r   r  rN  s   @rP   r  r  i  s         [I/N++++))))KKKNNN /3      - - - - - - - -rO   r  c                  d     e Zd ZU dZdZded<   ded<   ded<   d	ed
<   ded<   d fdZddZ xZS )	MatchStmt)subjectsubject_dummypatternsguardsbodies)r  r   r!  r"  r   r  zNameExpr | Noner  list[Pattern]r   r  r!  r  r"  rZ   r[   c                    t                                                       t          |          t          |          cxk    rt          |          k    sn J || _        d | _        || _        || _        || _        d S r]   )r&  r_   r  r  r  r   r!  r"  )r^   r  r   r!  r"  r   s        rP   r_   zMatchStmt.__init__  sz     	8}}F::::s6{{::::::! rO   r   r   rj   c                ,    |                     |           S r]   )visit_match_stmtr   s     rP   r   zMatchStmt.accept  rn  rO   )
r  r   r   r#  r!  r  r"  r  rZ   r[   r   r  rN  s   @rP   r  r    s         LI@N""""####     . . . . . . . .rO   r  c                  d     e Zd ZU dZdZded<   ded<   ded<   d	ed
<   ded<   d fdZddZ xZS )TypeAliasStmt)r   r  r  r  
alias_node)r   r  r  NameExprr   list[TypeParam]r  
LambdaExprr  r   r  TypeAlias | Noner)  rZ   r[   c                    t                                                       || _        || _        || _        d| _        d | _        d S rV  )r&  r_   r   r  r  r  r)  )r^   r   r  r  r   s       rP   r_   zTypeAliasStmt.__init__  sA    	"
',$rO   r   r   rj   c                ,    |                     |           S r]   )visit_type_alias_stmtr   s     rP   r   zTypeAliasStmt.accept  r  rO   )r   r*  r  r+  r  r,  rZ   r[   r   r  rN  s   @rP   r(  r(    s         WI3NNNN!!!!         3 3 3 3 3 3 3 3rO   r(  c                  @     e Zd ZU dZdZdZded<   d fdZddZ xZ	S )IntExprzInteger literalr  rY   r  rZ   r[   c                V    t                                                       || _        d S r]   r&  r_   r  r^   r  r   s     rP   r_   zIntExpr.__init__  r  rO   r   r   rj   c                ,    |                     |           S r]   )visit_int_exprr   s     rP   r   zIntExpr.accept  r  rO   )r  rY   rZ   r[   r   r`  rN  s   @rP   r2  r2    sl         INJJJ     , , , , , , , ,rO   r2  c                  J     e Zd ZU dZdZdZded<   ded<   d fd
ZddZ xZ	S )StrExprzString literal)r  as_typer3  r   r  "NotParsed | mypy.types.Type | Noner;  rZ   r[   c                x    t                                                       || _        t          j        | _        d S r]   )r&  r_   r  rI   rM   r;  r6  s     rP   r_   zStrExpr.__init__  s-    
 rO   r   r   rj   c                ,    |                     |           S r]   )visit_str_exprr   s     rP   r   zStrExpr.accept  r  rO   r  r   rZ   r[   r   r`  rN  s   @rP   r:  r:    sz         $INJJJ 0///' ' ' ' ' '
, , , , , , , ,rO   r:  seqr.  TypeGuard[list[StrExpr]]c                4    t          d | D                       S )Nc              3  @   K   | ]}t          |t                    V  d S r]   )rd   r:  r  s     rP   r  z"is_StrExpr_list.<locals>.<genexpr>  s,      99Tz$((999999rO   )r  )rA  s    rP   is_StrExpr_listrE    s    99S999999rO   c                  @     e Zd ZU dZdZdZded<   d fdZddZ xZ	S )	BytesExprzBytes literalr3  r   r  rZ   r[   c                V    t                                                       || _        d S r]   r5  r6  s     rP   r_   zBytesExpr.__init__	  r  rO   r   r   rj   c                ,    |                     |           S r]   )visit_bytes_exprr   s     rP   r   zBytesExpr.accept		  rn  rO   r@  r   r`  rN  s   @rP   rG  rG    sn         IN JJJ     . . . . . . . .rO   rG  c                  @     e Zd ZU dZdZdZded<   d fdZddZ xZ	S )	FloatExprzFloat literalr3  floatr  rZ   r[   c                V    t                                                       || _        d S r]   r5  r6  s     rP   r_   zFloatExpr.__init__	  r  rO   r   r   rj   c                ,    |                     |           S r]   )visit_float_exprr   s     rP   r   zFloatExpr.accept	  rn  rO   )r  rM  rZ   r[   r   r`  rN  s   @rP   rL  rL  	  sl         INLLL     . . . . . . . .rO   rL  c                  @     e Zd ZU dZdZdZded<   d fdZddZ xZ	S )ComplexExprzComplex literalr3  rl  r  rZ   r[   c                V    t                                                       || _        d S r]   r5  r6  s     rP   r_   zComplexExpr.__init__'	  r  rO   r   r   rj   c                ,    |                     |           S r]   )visit_complex_exprr   s     rP   r   zComplexExpr.accept+	      ))$///rO   )r  rl  rZ   r[   r   r`  rN  s   @rP   rR  rR  	  sl         INNNN     0 0 0 0 0 0 0 0rO   rR  c                      e Zd ZdZdZd	dZdS )
EllipsisExprzEllipsis (...)rN   r   r   rZ   rj   c                ,    |                     |           S r]   )visit_ellipsisr   s     rP   r   zEllipsisExpr.accept4	  r  rO   Nr   r   rN   rO   rP   rX  rX  /	  s3        I, , , , , ,rO   rX  c                  J     e Zd ZU dZdZdZded<   ded<   d fd	ZddZ xZ	S )StarExprzStar expression)r  validr   r  r   r]  rZ   r[   c                d    t                                                       || _        d| _        d S rV  )r&  r_   r  r]  r  s     rP   r_   zStarExpr.__init__B	  s-    	 


rO   r   r   rj   c                ,    |                     |           S r]   )visit_star_exprr   s     rP   r   zStarExpr.acceptI	  r6  rO   r  r   r`  rN  s   @rP   r\  r\  8	  sx         !I&NKKK     - - - - - - - -rO   r\  c                  b     e Zd ZdZdZd
 fdZedd            Zej        dd	            Z xZ	S )RefExprz,Abstract base class for name-like constructs)r  noder  
is_new_defis_inferred_defis_alias_rvalue
type_guardtype_isrZ   r[   c                    t                                                       d | _        d | _        d| _        d| _        d| _        d| _        d | _        d | _	        d S r|  )
r&  r_   r  rc  r  rd  re  rf  rg  rh  rW  s    rP   r_   zRefExpr.__init__[	  sY     $	'+	
  %$26/3rO   r   c                    | j         S r]   r2  r   s    rP   r   zRefExpr.fullnameq	  r3  rO   rg  c                    || _         d S r]   r2  r  s     rP   r   zRefExpr.fullnameu	  r  rO   rX  r   r  )
rJ   rK   rL   rh   ri   r_   r   r   r  rM  rN  s   @rP   rb  rb  M	  s        66	I4 4 4 4 4 4,    X _   _    rO   rb  c                  <     e Zd ZdZdZdZd fdZddZddZ xZ	S )r*  zOName expression

    This refers to a local name, global name or a module.
    )r   is_special_form)r   rc  r   r   rZ   r[   c                d    t                                                       || _        d| _        d S rV  )r&  r_   r   rm  )r^   r   r   s     rP   r_   zNameExpr.__init__	  s.    	$rO   r   r   rj   c                ,    |                     |           S r]   )visit_name_exprr   s     rP   r   zNameExpr.accept	  r6  rO   rl   c                    J d|              )NFzSerializing NameExpr: rN   r   s    rP   r   zNameExpr.serialize	  s    55t55555rO   )r   r   rZ   r[   r   r   )
rJ   rK   rL   rh   ri   rL  r_   r   r   rM  rN  s   @rP   r*  r*  z	  s{         
 ,I%N% % % % % %- - - -6 6 6 6 6 6 6 6rO   r*  c                  4     e Zd ZdZdZdZd fd
ZddZ xZS )
MemberExprzMember access expression x.y)r  r   def_var)r  r   rc  r  r   r   r   rZ   r[   c                r    t                                                       || _        || _        d | _        d S r]   )r&  r_   r  r   rt  )r^   r  r   r   s      rP   r_   zMemberExpr.__init__	  s4    		 $(rO   r   r   rj   c                ,    |                     |           S r]   )visit_member_exprr   s     rP   r   zMemberExpr.accept	  rh  rO   )r  r   r   r   rZ   r[   r   	rJ   rK   rL   rh   ri   rL  r_   r   rM  rN  s   @rP   rs  rs  	  sa        &&+I-N( ( ( ( ( (/ / / / / / / /rO   rs  c                  R    e Zd ZdZdZdZdZdZdZdddZ	dddZ
ddZddZddZdS )r  r   rn   rp   rr   r     Fstarr   rZ   c                H    | t           k    p| t          k    p|o
| t          k    S r]   )r  r  ARG_STARr^   r{  s     rP   is_positionalzArgKind.is_positional	  s$    wP$'/Pd6Otx?OPrO   c                H    | t           k    p| t          k    p|o
| t          k    S r]   )	ARG_NAMEDARG_NAMED_OPT	ARG_STAR2r~  s     rP   is_namedzArgKind.is_named	  s&    y YDM$9Yd>XtyGXYrO   c                .    | t           k    p
| t          k    S r]   )r  r  r   s    rP   is_requiredzArgKind.is_required	  s    w3$)"33rO   c                .    | t           k    p
| t          k    S r]   )r  r  r   s    rP   is_optionalzArgKind.is_optional	  s    w7$-"77rO   c                .    | t           k    p
| t          k    S r]   )r}  r  r   s    rP   r  zArgKind.is_star	  s    x449#44rO   Nr  )r{  r   rZ   r   rK  )rJ   rK   rL   r  r  r}  r  r  r  r  r  r  r  r  rN   rO   rP   r  r  	  s         GGHIIMQ Q Q Q QZ Z Z Z Z4 4 4 48 8 8 85 5 5 5 5 5rO   r  r  r  r}  r  r  r  r  c                  8     e Zd ZdZdZdZ	 dd fdZddZ xZS )CallExprzCall expression.

    This can also represent several special forms that are syntactically calls
    such as cast(...) and None  # type: ....
    )calleeargsr  r  ru  )r  r  r  r  Nr  r   r  r.  r  list[ArgKind]r  list[str | None]ru  r  rZ   r[   c                    t                                                       |sd gt          |          z  }|| _        || _        || _        || _        || _        d S r]   )r&  r_   r  r  r  r  r  ru  )r^   r  r  r  r  ru  r   s         rP   r_   zCallExpr.__init__	  s^     	 	+T*I	"+4 !rO   r   r   rj   c                ,    |                     |           S r]   )visit_call_exprr   s     rP   r   zCallExpr.accept	  r6  rO   r]   )r  r   r  r.  r  r  r  r  ru  r  rZ   r[   r   rx  rN  s   @rP   r  r  	  sr          IIAN '+! ! ! ! ! ! !*- - - - - - - -rO   r  c                  <     e Zd ZU dZdZded<   d fdZdd
Z xZS )YieldFromExprr  r   r  rZ   r[   c                V    t                                                       || _        d S r]   r  r  s     rP   r_   zYieldFromExpr.__init__	  r  rO   r   r   rj   c                ,    |                     |           S r]   )visit_yield_from_exprr   s     rP   r   zYieldFromExpr.accept	  r  rO   r  r   r  rN  s   @rP   r  r  	  si         IN     3 3 3 3 3 3 3 3rO   r  c                  <     e Zd ZU dZdZded<   d fdZdd
Z xZS )	YieldExprr  r  r  rZ   r[   c                V    t                                                       || _        d S r]   r  r  s     rP   r_   zYieldExpr.__init__
  r  rO   r   r   rj   c                ,    |                     |           S r]   )visit_yield_exprr   s     rP   r   zYieldExpr.accept
  rn  rO   r  r   r  rN  s   @rP   r  r  
  si         IN     . . . . . . . .rO   r  c                  h     e Zd ZU dZdZdZded<   ded<   ded<   d	ed
<   ded<   d fdZddZ xZ	S )	IndexExprzaIndex expression x[y].

    Also wraps type application such as List[int] as a special form.
    )baser  method_typeru  r;  )r  r  r   r  r  r  r  z&TypeApplication | TypeAliasExpr | Noneru  r<  r;  rZ   r[   c                    t                                                       || _        || _        d | _        d | _        t          j        | _        d S r]   )	r&  r_   r  r  r  ru  rI   rM   r;  )r^   r  r  r   s      rP   r_   zIndexExpr.__init__&
  sC    	
 rO   r   r   rj   c                ,    |                     |           S r]   )visit_index_exprr   s     rP   r   zIndexExpr.accept.
  rn  rO   )r  r   r  r   rZ   r[   r   r`  rN  s   @rP   r  r  
  s          
 HI&N'''' 5444 0///' ' ' ' ' '. . . . . . . .rO   r  c                  T     e Zd ZU dZdZdZded<   ded<   ded	<   d fdZddZ xZ	S )	UnaryExprzUnary operation)r  r  r  )r  r  r   r  r   r  r  r  rZ   r[   c                r    t                                                       || _        || _        d | _        d S r]   )r&  r_   r  r  r  )r^   r  r  r   s      rP   r_   zUnaryExpr.__init__>
  s5    	rO   r   r   rj   c                ,    |                     |           S r]   )visit_unary_exprr   s     rP   r   zUnaryExpr.acceptD
  rn  rO   )r  r   r  r   rZ   r[   r   r`  rN  s   @rP   r  r  2
  s         -I#NGGG''''           . . . . . . . .rO   r  c                  4     e Zd ZdZdZdZd fd	ZddZ xZS )AssignmentExprz5Assignment expressions in Python 3.8+, like "a := 2".)r`   r  r`   r*  r  r   rZ   r[   c                d    t                                                       || _        || _        d S r]   )r&  r_   r`   r  )r^   r`   r  r   s      rP   r_   zAssignmentExpr.__init__O
  s+    


rO   r   r   rj   c                ,    |                     |           S r]   )visit_assignment_exprr   s     rP   r   zAssignmentExpr.acceptT
  r  rO   )r`   r*  r  r   rZ   r[   r   rx  rN  s   @rP   r  r  H
  sa        ??#I(N     
3 3 3 3 3 3 3 3rO   r  c                       e Zd ZU dZdZdZded<   ded<   ded<   d	ed
<   ded<   ded<   ded<   ded<   	 dd fdZddZ xZ	S )OpExprz^Binary operation.

    The dot (.), [] and comparison operators have more specific nodes.
    )r  leftrightr  right_alwaysright_unreachableru  r;  )r  r  r  r   r  r   r  r  r  r  r   r  r  TypeAliasExpr | Noneru  r<  r;  NrZ   r[   c                    t                                                       || _        || _        || _        d | _        d| _        d| _        || _        t          j
        | _        d S rV  )r&  r_   r  r  r  r  r  r  ru  rI   rM   r;  )r^   r  r  r  ru  r   s        rP   r_   zOpExpr.__init__{
  s\     		
!!&  rO   r   r   rj   c                ,    |                     |           S r]   )visit_op_exprr   s     rP   r   zOpExpr.accept
  r  rO   r]   )
r  r   r  r   r  r   ru  r  rZ   r[   r   r`  rN  s   @rP   r  r  X
  s          
	I -NGGG''''"""" 0/// ^b' ' ' ' ' ' '+ + + + + + + +rO   r  c                  \     e Zd ZU dZdZdZded<   ded<   ded	<   d fdZddZddZ	 xZ
S )ComparisonExprz+Comparison expression (e.g. a < b > c < d).)	operatorsoperandsmethod_types)r  r  r  r  r.  r  zlist[mypy.types.Type | None]r  rZ   r[   c                r    t                                                       || _        || _        g | _        d S r]   )r&  r_   r  r  r  )r^   r  r  r   s      rP   r_   zComparisonExpr.__init__
  s5    " rO   ,Iterator[tuple[str, Expression, Expression]]c              #  ~   K   t          | j                  D ]%\  }}|| j        |         | j        |dz            fV  &dS )zzIf this comparison expr is "a < b is c == d", yields the sequence
        ("<", a, b), ("is", b, c), ("==", c, d)
        rn   N)r  r  r  )r^   r  operators      rP   pairwisezComparisonExpr.pairwise
  s[       %T^44 	C 	CKAxDM!,dmAE.BBBBBB	C 	CrO   r   r   rj   c                ,    |                     |           S r]   )visit_comparison_exprr   s     rP   r   zComparisonExpr.accept
  r  rO   )r  r  r  r.  rZ   r[   )rZ   r  r   )rJ   rK   rL   rh   ri   rL  r   r_   r  r   rM  rN  s   @rP   r  r  
  s         559I.N....     C C C C3 3 3 3 3 3 3 3rO   r  c                  T     e Zd ZU dZdZdZded<   ded<   ded<   d fd	ZddZ xZ	S )	SliceExprznSlice expression (e.g. 'x:y', 'x:', '::2' or ':').

    This is only valid as index in index expressions.
    )begin_index	end_indexstrider  r  r  r  rZ   r[   c                r    t                                                       || _        || _        || _        d S r]   )r&  r_   r  r  r  )r^   r  r  r  r   s       rP   r_   zSliceExpr.__init__
  s5     	&"rO   r   r   rj   c                ,    |                     |           S r]   )visit_slice_exprr   s     rP   r   zSliceExpr.accept
  rn  rO   )r  r  r  r  r  r  rZ   r[   r   r`  rN  s   @rP   r  r  
  s          
 7I;N""""    	 	 	 	 	 	. . . . . . . .rO   r  c                  J     e Zd ZU dZdZdZded<   ded<   d fd
ZddZ xZ	S )CastExprz!Cast expression cast(type, expr).r  r   r   r  mypy.types.Typer   r  rZ   r[   c                d    t                                                       || _        || _        d S r]   r&  r_   r  r   r^   r  r  r   s      rP   r_   zCastExpr.__init__
  +    				rO   r   r   rj   c                ,    |                     |           S r]   )visit_cast_exprr   s     rP   r   zCastExpr.accept
  r6  rO   r  r   r  r  rZ   r[   r   r`  rN  s   @rP   r  r  
  s{         ++ I%N     
- - - - - - - -rO   r  c                  @     e Zd ZU dZdZdZded<   d fdZddZ xZ	S )TypeFormExprzTypeForm(type) expression.r   r  r   r  rZ   r[   c                V    t                                                       || _        d S r]   r&  r_   r   )r^   r  r   s     rP   r_   zTypeFormExpr.__init__
  s$    			rO   r   r   rj   c                ,    |                     |           S r]   )visit_type_form_exprr   s     rP   r   zTypeFormExpr.accept
      ++D111rO   )r  r  rZ   r[   r   r`  rN  s   @rP   r  r  
  so         $$IN     2 2 2 2 2 2 2 2rO   r  c                  J     e Zd ZU dZdZdZded<   ded<   d fd
ZddZ xZ	S )AssertTypeExprz1Represents a typing.assert_type(expr, type) call.r  r   r  r  r   r  rZ   r[   c                d    t                                                       || _        || _        d S r]   r  r  s      rP   r_   zAssertTypeExpr.__init__
  r  rO   r   r   rj   c                ,    |                     |           S r]   )visit_assert_type_exprr   s     rP   r   zAssertTypeExpr.accept       --d333rO   r  r   r`  rN  s   @rP   r  r  
  s{         ;; I%N     
4 4 4 4 4 4 4 4rO   r  c                  \     e Zd ZU dZdZdZded<   ded<   ded<   	 	 	 dd fdZddZ xZ	S )
RevealExprzGReveal type expression reveal_type(expr) or reveal_locals() expression.)r  r  local_nodesis_importedr  r  rY   r  list[Var] | Noner  NFr  r   rZ   r[   c                    t                                                       || _        || _        || _        || _        d S r]   )r&  r_   r  r  r  r  )r^   r  r  r  r  r   s        rP   r_   zRevealExpr.__init__  s?     			&&rO   r   r   rj   c                ,    |                     |           S r]   )visit_reveal_exprr   s     rP   r   zRevealExpr.accept  rh  rO   )NNF)
r  rY   r  r  r  r  r  r   rZ   r[   r   r`  rN  s   @rP   r  r    s         QQ>ICNIII!!!!
 #'(,!' ' ' ' ' ' '/ / / / / / / /rO   r  c                  T     e Zd ZU dZdZdZded<   ded<   ded	<   d fdZddZ xZ	S )	SuperExprzExpression super().name)r   rw  call)r   r  rw  r   r   TypeInfo | Nonerw  r  r  rZ   r[   c                r    t                                                       || _        || _        d | _        d S r]   )r&  r_   r   r  rw  )r^   r   r  r   s      rP   r_   zSuperExpr.__init__+  s2    					rO   r   r   rj   c                ,    |                     |           S r]   )visit_super_exprr   s     rP   r   zSuperExpr.accept1  rn  rO   )r   r   r  r  rZ   r[   r   r`  rN  s   @rP   r  r     s         !!(I-NIIINNN     . . . . . . . .rO   r  c                  F    e Zd ZdZdZedd            ZddZddZddZ	dS )r,  zLambda expression)r  r  r  r  rZ   r   c                    t           S r]   )r   r   s    rP   r   zLambdaExpr.name:  s    rO   r   c                n    | j         j         d         }t          |t                    sJ |j        }|J |S )z/Return the expression (the body) of the lambda.rX   )r  rd   r  r  )r^   r!  r  s      rP   r  zLambdaExpr.expr>  s>    inR #z*****xrO   r   r   rj   c                ,    |                     |           S r]   )visit_lambda_exprr   s     rP   r   zLambdaExpr.acceptF  rh  rO   r   c                    dS rV  rN   r   s    rP   r  zLambdaExpr.is_dynamicI  s    urO   Nr   )rZ   r   r   rK  )
rJ   rK   rL   rh   rL  r   r   r  r   r  rN   rO   rP   r,  r,  5  sy        DN   X   / / / /     rO   r,  c                  @     e Zd ZU dZdZdZded<   d fdZddZ xZ	S )ListExprzList literal expression [...].r  r.  r  rZ   r[   c                V    t                                                       || _        d S r]   r&  r_   r  r  s     rP   r_   zListExpr.__init__V  r  rO   r   r   rj   c                ,    |                     |           S r]   )visit_list_exprr   s     rP   r   zListExpr.acceptZ  r6  rO   r  r.  rZ   r[   r   r`  rN  s   @rP   r  r  M  so         ((IN     - - - - - - - -rO   r  c                  @     e Zd ZU dZdZdZded<   d fdZddZ xZ	S )DictExprz0Dictionary literal expression {key: value, ...}.r  *list[tuple[Expression | None, Expression]]r  rZ   r[   c                V    t                                                       || _        d S r]   r  r  s     rP   r_   zDictExpr.__init__g  r  rO   r   r   rj   c                ,    |                     |           S r]   )visit_dict_exprr   s     rP   r   zDictExpr.acceptk  r6  rO   )r  r  rZ   r[   r   r`  rN  s   @rP   r  r  ^  so         ::IN5555     - - - - - - - -rO   r  c                  @     e Zd ZU dZdZdZded<   d fdZddZ xZ	S )TemplateStrExprz"Template string expression t'...'.r  Hlist[Expression | tuple[Expression, str, str | None, Expression | None]]r  rZ   r[   c                V    t                                                       || _        d S r]   r  r  s     rP   r_   zTemplateStrExpr.__init__|  s&     	


rO   r   r   rj   c                ,    |                     |           S r]   )visit_template_str_exprr   s     rP   r   zTemplateStrExpr.accept      ..t444rO   )r  r
  rZ   r[   r   r`  rN  s   @rP   r	  r	  o  sr         ,,IN TSSS     5 5 5 5 5 5 5 5rO   r	  c                  @     e Zd ZU dZdZdZded<   d fdZddZ xZ	S )	TupleExprzXTuple literal expression (..., ...)

    Also lvalue sequences (..., ...) and [..., ...]r  r.  r  rZ   r[   c                V    t                                                       || _        d S r]   r  r  s     rP   r_   zTupleExpr.__init__  r  rO   r   r   rj   c                ,    |                     |           S r]   )visit_tuple_exprr   s     rP   r   zTupleExpr.accept  rn  rO   r  r   r`  rN  s   @rP   r  r    su         7 7 IN     . . . . . . . .rO   r  c                  @     e Zd ZU dZdZdZded<   d fdZddZ xZ	S )SetExprz$Set literal expression {value, ...}.r  r.  r  rZ   r[   c                V    t                                                       || _        d S r]   r  r  s     rP   r_   zSetExpr.__init__  r  rO   r   r   rj   c                ,    |                     |           S r]   )visit_set_exprr   s     rP   r   zSetExpr.accept  r  rO   r  r   r`  rN  s   @rP   r  r    so         ..IN     , , , , , , , ,rO   r  c                  h     e Zd ZU dZdZdZded<   ded<   ded	<   d
ed<   ded<   d fdZddZ xZ	S )GeneratorExprzGGenerator expression ... for ... in ... [ for ...  in ... ] [ if ... ].)	left_expr	sequences	condlistsr  indices)r  r  r  r  r   r  r.  r  list[list[Expression]]r  
list[bool]r  r  r  rZ   r[   c                    t                                                       || _        || _        || _        || _        || _        d S r]   )r&  r_   r  r  r  r  r  )r^   r  r  r  r  r  r   s         rP   r_   zGeneratorExpr.__init__  sB     	""" rO   r   r   rj   c                ,    |                     |           S r]   )visit_generator_exprr   s     rP   r   zGeneratorExpr.accept  r  rO   )r  r   r  r  r  r.  r  r  r  r   rZ   r[   r   r`  rN  s   @rP   r  r    s         QQNIGN%%%%! ! ! ! ! !2 2 2 2 2 2 2 2rO   r  c                  @     e Zd ZU dZdZdZded<   d fdZddZ xZ	S )ListComprehensionz,List comprehension (e.g. [x + 1 for x in a])	generatorr  r'  rZ   r[   c                V    t                                                       || _        d S r]   r&  r_   r'  r^   r'  r   s     rP   r_   zListComprehension.__init__  $    "rO   r   r   rj   c                ,    |                     |           S r]   )visit_list_comprehensionr   s     rP   r   zListComprehension.accept  s    //555rO   r'  r  rZ   r[   r   r`  rN  s   @rP   r%  r%    so         66I#N# # # # # #6 6 6 6 6 6 6 6rO   r%  c                  @     e Zd ZU dZdZdZded<   d fdZddZ xZ	S )SetComprehensionz+Set comprehension (e.g. {x + 1 for x in a})r&  r  r'  rZ   r[   c                V    t                                                       || _        d S r]   r)  r*  s     rP   r_   zSetComprehension.__init__  r+  rO   r   r   rj   c                ,    |                     |           S r]   )visit_set_comprehensionr   s     rP   r   zSetComprehension.accept  r  rO   r.  r   r`  rN  s   @rP   r0  r0    so         55I#N# # # # # #5 5 5 5 5 5 5 5rO   r0  c                  r     e Zd ZU dZdZdZded<   ded<   ded<   d	ed
<   ded<   ded<   d fdZddZ xZ	S )DictionaryComprehensionz3Dictionary comprehension (e.g. {k: v for k, v in a})keyr  r  r  r  r  )r6  r  r  r  r  r   r6  r  r.  r  r  r  r   r  r  r  rZ   r[   c                    t                                                       || _        || _        || _        || _        || _        || _        d S r]   )r&  r_   r6  r  r  r  r  r  )r^   r6  r  r  r  r  r  r   s          rP   r_   z DictionaryComprehension.__init__  sI     	
"" rO   r   r   rj   c                ,    |                     |           S r]   )visit_dictionary_comprehensionr   s     rP   r   zDictionaryComprehension.accept  r  rO   )r6  r   r  r   r  r  r  r.  r  r  r  r   rZ   r[   r   r`  rN  s   @rP   r5  r5    s         ==QIJNOOO%%%%! ! ! ! ! !"< < < < < < < <rO   r5  c                  T     e Zd ZU dZdZdZded<   ded<   ded<   d fd
ZddZ xZ	S )ConditionalExprz+Conditional expression (e.g. x if y else z))condif_expr	else_expr)r=  r<  r>  r   r<  r=  r>  rZ   r[   c                r    t                                                       || _        || _        || _        d S r]   )r&  r_   r<  r=  r>  )r^   r<  r=  r>  r   s       rP   r_   zConditionalExpr.__init__  s2    	"rO   r   r   rj   c                ,    |                     |           S r]   )visit_conditional_exprr   s     rP   r   zConditionalExpr.accept   r  rO   )r<  r   r=  r   r>  r   rZ   r[   r   r`  rN  s   @rP   r;  r;    s         550I5N# # # # # #4 4 4 4 4 4 4 4rO   r;  c                  J     e Zd ZU dZdZdZded<   ded<   d fd	ZddZ xZ	S )TypeApplicationz Type application expr[type, ...])r  r  r   r  r  r  rZ   r[   c                d    t                                                       || _        || _        d S r]   )r&  r_   r  r  )r^   r  r  r   s      rP   r_   zTypeApplication.__init__.  s+    	


rO   r   r   rj   c                ,    |                     |           S r]   )visit_type_applicationr   s     rP   r   zTypeApplication.accept3  r  rO   )r  r   r  r  rZ   r[   r   r`  rN  s   @rP   rC  rC  $  s{         **!I&N         
4 4 4 4 4 4 4 4rO   rC  	INVARIANT	COVARIANTCONTRAVARIANTVARIANCE_NOT_READYc                       e Zd ZU dZdZded<   ded<   ded<   ded<   d	ed
<   eddfd fdZedd            Z	edd            Z
 xZS )TypeVarLikeExprzBase class for TypeVarExpr, ParamSpecExpr and TypeVarTupleExpr.

    Note that they are constructed by the semantic analyzer.
    )r   r  r  r  varianceis_new_styler   r   r  r  r  r  rY   rM  FrX   r   r   rN  r   rT   rZ   r[   c                    t                                          |           || _        || _        || _        || _        || _        || _        d S N)rT   )r&  r_   r   r  r  r  rM  rN  )	r^   r   r   r  r  rM  rN  rT   r   s	           rP   r_   zTypeVarLikeExpr.__init__\  sR     	d###
!& (rO   c                    | j         S r]   r  r   s    rP   r   zTypeVarLikeExpr.namen  r  rO   c                    | j         S r]   r2  r   s    rP   r   zTypeVarLikeExpr.fullnamer  r3  rO   )r   r   r   r   r  r  r  r  rM  rY   rN  r   rT   rY   rZ   r[   r   )rJ   rK   rL   rh   ri   r   rG  r_   r   r   r   rM  rN  s   @rP   rL  rL  F  s          
 ]IJJJNNN !    
 MMM "") ) ) ) ) ) )$    X    X    rO   rL  SYMBOL_NODE_EXPRESSION_TYPESc                       e Zd ZU dZdZdZded<   eddfd" fdZd#dZ	d$dZ
ed%d            Zd&dZed'd!            Z xZS )(TypeVarExprar  Type 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.
    )r  )r   r  r  r  r  r  FrX   r   r   r   r  r  r  rM  rY   rN  r   rT   rZ   r[   c	           	     f    t                                          |||||||           || _        d S rP  )r&  r_   r  )
r^   r   r   r  r  r  rM  rN  rT   r   s
            rP   r_   zTypeVarExpr.__init__  s8     	xgx\`aaarO   r   r   rj   c                ,    |                     |           S r]   )visit_type_var_exprr   s     rP   r   zTypeVarExpr.accept  r  rO   rl   c                    d| j         | j        d | j        D             | j                                        | j                                        | j        dS )NrU  c                6    g | ]}|                                 S rN   r  r   ts     rP   r  z)TypeVarExpr.serialize.<locals>.<listcomp>  s     :::q{{}}:::rO   )r   r   r   r  r  r  rM  )r   r  r  r  r   r  rM  r   s    rP   r   zTypeVarExpr.serialize  sY    #J::dk:::+5577|--//
 
 	
rO   r   c           
        |d         dk    sJ t          |d         |d         d |d         D             t          j                            |d                   t          j                            |d                   |d	                   S )
Nr   rU  r   r   c                L    g | ]!}t           j                            |          "S rN   r   r  r  r  s     rP   r  z+TypeVarExpr.deserialize.<locals>.<listcomp>  s(    DDDTZ((++DDDrO   r  r  r  rM  )rU  r   r  r  r   s     rP   r   zTypeVarExpr.deserialize  s    H~....LDDT(^DDDJ''](;<<J''Y88
 
 	
rO   r*   c                   t          |t                     t          || j                   t          || j                   t
          j                            || j                   | j	        
                    |           | j        
                    |           t          || j                   t          |t                     d S r]   )r>   TYPE_VAR_EXPRr   r   r  r   r  r  r  r  r   r  r   rM  r!   r   s     rP   r   zTypeVarExpr.write  s    $&&&$
###$'''
""4555t$$$4   $&&&$     rO   r(   c           
     ^   t          t          |          t          |          t          j                            |          t          j                            |          t          j                            |          t          |                    }t          |          t          k    sJ |S r]   )	rU  r   r   r  read_type_list	read_typer   r4   r!   r   r   r!  s      rP   r   zTypeVarExpr.read  s    TNNTNNJ%%d++J  &&J  &&TNN
 
 ~~((((
rO   )r   r   r   r   r  r  r  r  r  r  rM  rY   rN  r   rT   rY   rZ   r[   r   r   )r   rl   rZ   rU  r   )r   r(   rZ   rU  )rJ   rK   rL   rh   ri   rL  r   rG  r_   r   r   r   r   r   r   rM  rN  s   @rP   rU  rU  |  s         	 	 IAN "!!! ""      1 1 1 1	
 	
 	
 	
 	
 	
 	
 [	
! ! ! ! 
 
 
 [
 
 
 
 
rO   rU  c                  ^    e Zd ZdZdZddZdd	Zedd            ZddZ	edd            Z
dS )ParamSpecExprrN   r   r  r  r   r   rZ   rj   c                ,    |                     |           S r]   )visit_paramspec_exprr   s     rP   r   zParamSpecExpr.accept  r  rO   rl   c                    d| j         | j        | j                                        | j                                        | j        dS )Nrg  )r   r   r   r  r  rM  )r   r  r  r   r  rM  r   s    rP   r   zParamSpecExpr.serialize  sF    %J+5577|--//
 
 	
rO   r   c           	         |d         dk    sJ t          |d         |d         t          j                            |d                   t          j                            |d                   |d                   S )Nr   rg  r   r   r  r  rM  )rg  r   r  r  r   s     rP   r   zParamSpecExpr.deserialize  so    H~0000LJ''](;<<J''Y88
 
 	
rO   r*   r[   c                @   t          |t                     t          || j                   t          || j                   | j                            |           | j                            |           t          || j	                   t          |t                     d S r]   )r>   PARAM_SPEC_EXPRr   r   r  r  r   r  r   rM  r!   r   s     rP   r   zParamSpecExpr.write  s    $((($
###$'''t$$$4   $&&&$     rO   r(   c           	     "   t          t          |          t          |          t          j                            |          t          j                            |          t          |                    }t          |          t          k    sJ |S r]   )rg  r   r   r  rd  r   r4   r!   re  s      rP   r   zParamSpecExpr.read  sp    TNNTNNJ  &&J  &&TNN
 
 ~~((((
rO   Nr   r   )r   rl   rZ   rg  r   )r   r(   rZ   rg  )rJ   rK   rL   ri   rL  r   r   r   r   r   r   rN   rO   rP   rg  rg    s        I7N2 2 2 2
 
 
 
 
 
 
 [
! ! ! ! 	 	 	 [	 	 	rO   rg  c                       e Zd ZU dZdZded<   dZeddfd! fdZd"dZ	d#dZ
ed$d            Zd%dZed&d             Z xZS )'TypeVarTupleExprz1Type variable tuple expression TypeVarTuple(...).tuple_fallbackmypy.types.Instancerh  FrX   r   r   r   r  r  r  rM  rY   rN  r   rT   rZ   r[   c	           	     f    t                                          |||||||           || _        d S rP  )r&  r_   rr  )
r^   r   r   r  rr  r  rM  rN  rT   r   s
            rP   r_   zTypeVarTupleExpr.__init__  s;     	xgx\`aaa,rO   r   r   rj   c                ,    |                     |           S r]   )visit_type_var_tuple_exprr   s     rP   r   zTypeVarTupleExpr.accept  r  rO   rl   c                    d| j         | j        | j                                        | j                                        | j                                        | j        dS )Nrq  )r   r   r   r  rr  r  rM  )r   r  r  r   rr  r  rM  r   s    rP   r   zTypeVarTupleExpr.serialize  sX    (J+5577"1;;==|--//
 
 	
rO   r   c           
     F   |d         dk    sJ t          |d         |d         t          j                            |d                   t          j        j                            |d                   t          j                            |d                   |d                   S )	Nr   rq  r   r   r  rr  r  rM  )rq  r   r  r  Instancer   r   s     rP   r   zTypeVarTupleExpr.deserialize(  s    H~!33333LJ''](;<<J++D1A,BCCJ''Y88
 
 	
rO   r*   c                t   t          |t                     | j                            |           t	          || j                   t	          || j                   | j                            |           | j                            |           t          || j
                   t          |t                     d S r]   )r>   TYPE_VAR_TUPLE_EXPRrr  r   r   r   r  r  r  r   rM  r!   r   s     rP   r   zTypeVarTupleExpr.write4  s    $+,,,!!$'''$
###$'''t$$$4   $&&&$     rO   r(   c           
        t          |          t          j        j        k    sJ t          j        j                            |          }t          t          |          t          |          t          j                            |          |t          j                            |          t          |                    }t          |          t          k    sJ |S r]   )r4   r   r  INSTANCEry  r   rq  r   rd  r   r!   )r   r   fallbackr!  s       rP   r   zTypeVarTupleExpr.read>  s    ~~!44444:&++D11TNNTNNJ  &&J  &&TNN
 
 ~~((((
rO   )r   r   r   r   r  r  rr  rs  r  r  rM  rY   rN  r   rT   rY   rZ   r[   r   r   )r   rl   rZ   rq  r   )r   r(   rZ   rq  )rJ   rK   rL   rh   ri   r   rL  rG  r_   r   r   r   r   r   r   rM  rN  s   @rP   rq  rq    s         ;; I''''7N ""- - - - - - -7 7 7 7	
 	
 	
 	
 	
 	
 	
 [	
! ! ! !    [    rO   rq  c                  @     e Zd ZU dZdZdZded<   d fdZddZ xZ	S )TypeAliasExprzType alias expression (rvalue).rc  r   rc  rZ   r[   c                V    t                                                       || _        d S r]   )r&  r_   rc  )r^   rc  r   s     rP   r_   zTypeAliasExpr.__init__W  r  rO   r   r   rj   c                ,    |                     |           S r]   )visit_type_alias_exprr   s     rP   r   zTypeAliasExpr.accept[  r  rO   )rc  r   rZ   r[   r   r`  rN  s   @rP   r  r  N  sl         ))INOOO     3 3 3 3 3 3 3 3rO   r  c                  L     e Zd ZU dZdZdZded<   ded<   dd fdZddZ xZ	S )NamedTupleExprz:Named tuple expression namedtuple(...) or NamedTuple(...).)rw  is_typedrw  r   rw  r   r  FrZ   r[   c                d    t                                                       || _        || _        d S r]   )r&  r_   rw  r  )r^   rw  r  r   s      rP   r_   zNamedTupleExpr.__init__k  s+    	 rO   r   r   rj   c                ,    |                     |           S r]   )visit_namedtuple_exprr   s     rP   r   zNamedTupleExpr.acceptp  r  rO   r  )rw  r   r  r   rZ   r[   r   r`  rN  s   @rP   r  r  _  s|         DD$IN NNNNNN! ! ! ! ! ! !
3 3 3 3 3 3 3 3rO   r  c                  @     e Zd ZU dZdZdZded<   d fdZddZ xZ	S )TypedDictExprz%Typed dict expression TypedDict(...).r  r   rw  rZ   r[   c                V    t                                                       || _        d S r]   )r&  r_   rw  )r^   rw  r   s     rP   r_   zTypedDictExpr.__init__~  r  rO   r   r   rj   c                ,    |                     |           S r]   )visit_typeddict_exprr   s     rP   r   zTypedDictExpr.accept  r  rO   )rw  r   rZ   r[   r   r`  rN  s   @rP   r  r  t  sn         //IN NNN     2 2 2 2 2 2 2 2rO   r  c                  T     e Zd ZU dZdZdZded<   ded<   ded<   d fdZddZ xZ	S )EnumCallExprz5Named tuple expression Enum('name', 'val1 val2 ...').)rw  r  r  r   rw  r  r  r  r  rZ   r[   c                r    t                                                       || _        || _        || _        d S r]   )r&  r_   rw  r  r  )r^   rw  r  r  r   s       rP   r_   zEnumCallExpr.__init__  s2    	
rO   r   r   rj   c                ,    |                     |           S r]   )visit_enum_call_exprr   s     rP   r   zEnumCallExpr.accept  r  rO   )rw  r   r  r  r  r  rZ   r[   r   r`  rN  s   @rP   r  r    s         ??+I0N NNN####     2 2 2 2 2 2 2 2rO   r  c                  <     e Zd ZU dZdZded<   d fdZddZ xZS )PromoteExprz2Ducktype class decorator expression _promote(...).r  mypy.types.ProperTyper   rZ   r[   c                V    t                                                       || _        d S r]   r  )r^   r   r   s     rP   r_   zPromoteExpr.__init__  r  rO   r   r   rj   c                ,    |                     |           S r]   )visit__promote_exprr   s     rP   r   zPromoteExpr.accept  r  rO   )r   r  rZ   r[   r   )	rJ   rK   rL   rh   ri   r   r_   r   rM  rN  s   @rP   r  r    sj         <<I     1 1 1 1 1 1 1 1rO   r  c                  T     e Zd ZU dZdZdZded<   ded<   ded<   d fdZddZ xZ	S )NewTypeExprz NewType expression NewType(...).)r   old_typerw  r   r   r  r  r  rw  rT   rY   rU   rZ   r[   c                x    t                                          ||           || _        || _        d | _        d S )N)rT   rU   )r&  r_   r   r  rw  )r^   r   r  rT   rU   r   s        rP   r_   zNewTypeExpr.__init__  s;     	d6222	 			rO   r   r   rj   c                ,    |                     |           S r]   )visit_newtype_exprr   s     rP   r   zNewTypeExpr.accept  rV  rO   )
r   r   r  r  rT   rY   rU   rY   rZ   r[   r   r`  rN  s   @rP   r  r    s         **,I1NIII$$$$     0 0 0 0 0 0 0 0rO   r  c                  @     e Zd ZU dZdZdZded<   d fdZddZ xZ	S )	AwaitExprzAwait expression (await ...).r  r   r  rZ   r[   c                V    t                                                       || _        d S r]   r  r  s     rP   r_   zAwaitExpr.__init__  r  rO   r   r   rj   c                ,    |                     |           S r]   )visit_await_exprr   s     rP   r   zAwaitExpr.accept  rn  rO   r  r   r`  rN  s   @rP   r  r    so         ''IN     . . . . . . . .rO   r  c                  X     e Zd ZU dZdZded<   ded<   	 ddd	d fdZddZddZ xZ	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.
    )r   no_rhsr  r   r   r  FN)contextr  r  Context | NonerZ   r[   c                   t                                                       || _        || _        ||j        | _        |j        | _        dS dS )zJConstruct a dummy node; optionally borrow line/column from context object.N)r&  r_   r   r  rT   rU   )r^   r  r  r  r   s       rP   r_   zTempNode.__init__  sM     		DI!.DKKK rO   r   c                >    d| j         t          | j                  fz  S )NzTempNode:%d(%s))rT   r   r   r   s    rP   rb  zTempNode.__repr__  s     DIs49~~#>>>rO   r   r   rj   c                ,    |                     |           S r]   )visit_temp_noder   s     rP   r   zTempNode.accept  r6  rO   r  )r  r  r  r   r  r  rZ   r[   r   r   )
rJ   rK   rL   rh   ri   r   r_   rb  r   rM  rN  s   @rP   r  r    s           #I LLL 49	)W[	) 	) 	) 	) 	) 	) 	) 	)? ? ? ?- - - - - - - -rO   r  >   rh   r  __dict__r_   ri   rK   __weakref__r   __subclasshook____class_getitem____abstractmethods__EXCLUDED_PROTOCOL_ATTRIBUTES>   _order__ignore_	__order__EXCLUDED_ENUM_ATTRIBUTESc                      e Zd ZU dZdZded<   ded<   ded<   ded	<   d
ed<   ded<   ded<   ded<   ded<   ded<   ded<   ded<   ded<   ded<   ded<   ded<   ded<   ded<   ded <   d!ed"<   ded#<   ded$<   ded%<   ded&<   ded'<   d!ed(<   d)ed*<   ded+<   d,ed-<   ded.<   d/ed0<   ded1<   ded2<   d3ed4<   d5ed6<   d7ed8<   d9ed:<   ded;<   d<ed=<   d>ed?<   g d@ZdAedB<   dt fdEZdudFZe	dvdG            Z
e	dvdH            ZdwdIZdxdLZdydNZe	dzdO            Ze	dzdP            Zd{dRZdvdSZdwdTZd|dUZd}dWZd~dXZddYZdZd[dd]Zdd_Zdd`ZddcZddeZdvdfZddkZddmZe ddo            Z!ddqZ"e dds            Z# xZ$S )r   a  The 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_namedefnmro	_mro_refsbad_mrorr  is_disjoint_basedeclared_metaclassmetaclass_typer  is_abstractis_protocolruntime_protocolabstract_attributesdeletable_attributesslotsassumingassuming_proper	inferringis_enumfallback_to_anymeta_fallback_to_anyrp  has_param_spec_typebases_promote
tuple_typespecial_aliasis_named_tupletypeddict_type
is_newtypeis_intersectionmetadataalt_promotehas_type_var_tuple_typetype_var_tuple_prefixtype_var_tuple_suffix	self_typer  ry  r  type_object_typer   r  r  ro  r  list[TypeInfo]r  zlist[str] | Noner  r   r  rr  r  mypy.types.Instance | Noner  r  r!  r  r  r  r  zlist[tuple[str, int]]r  r  r  zset[str] | Noner  z5list[tuple[mypy.types.Instance, mypy.types.Instance]]r  r  zlist[mypy.types.Instance]r  r  r  r  rp  r  r  zlist[mypy.types.ProperType]r  r  zmypy.types.TupleType | Noner  r  zmypy.types.TypedDictType | Noner  r  r  zdict[str, JsonDict]r  r-  r  zmypy.types.TypeVarType | Noner  zDataclassTransformSpec | Noner  ry  r  r  r  r  )r  r  r  r  r  r  r  r  rr  r  r  r   FLAGSrZ   r[   c                   t                                                       |j        | _        || _        || _        || _        g | _        d| _        d| _	        g | _
        g | _        d| _        d| _        d| _        d| _        d| _        g | _        g | _        d| _        g | _        g | _        g | _        d| _        d| _        d| _        d| _        |                                  d| _        d| _        d| _        d| _        d| _         g | _!        d| _"        d| _#        d| _$        d| _%        d| _&        d| _'        d| _(        i | _)        d| _*        d| _+        d| _,        d| _-        d| _.        dS )zInitialize a TypeInfo.FN)/r&  r_   r   r  r  r  r  rp  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  add_type_varsrr  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  ry  r  r  )r^   r  r  r  r   s       rP   r_   zTypeInfo.__init__  sx   
	&#( ',$
"&" #% $&!
!  %15"15" %$$)!!#"$(,%"' $rO   c                   d| _         | j        j        rt          | j        j                  D ]\  }}t	          |t
          j        j                  rd| _        t	          |t
          j        j	                  r;| j         rJ d| _         || _
        t          | j        j                  |z
  dz
  | _        | j                            |j                   d S d S )NFTrn   )r  r  rp  r  rd   r   r  ParamSpecTyper  TypeVarTupleTyper  r  r  appendr   )r^   r  vds      rP   r  zTypeInfo.add_type_vars)  s    ',$9 		/"49#677 / /2b$*":;; 4/3D,b$*"=>> R#;;;;37D012D.14TY5H1I1IA1MPQ1QD.%%bg....		/ 		// /rO   c                    | j         j        S )zShort name.)r  r   r   s    rP   r   zTypeInfo.name6  s     y~rO   c                    | j         S r]   r2  r   s    rP   r   zTypeInfo.fullname;  r3  rO   c                2    t          | j                  dk    S )z7Is the type generic (i.e. does it have type variables)?r   )r  rp  r   s    rP   r  zTypeInfo.is_generic?  s    4>""Q&&rO   r   SymbolTableNode | Nonec                Z    | j         D ]"}|j                            |          }|r|c S #d S r]   )r  r  r   )r^   r   r   ns       rP   r   zTypeInfo.getC  sA    8 	 	C	d##A trO   r  c                4    | j         D ]}||j        v r|c S d S r]   )r  r  )r^   r   r   s      rP   get_containing_type_infoz!TypeInfo.get_containing_type_infoJ  s3    8 	 	Csy  


 !trO   c                \   t                      }| j        s
J d            | j        d d         D ]o}|j        rf|j                                        D ]L\  }}t          |j        t          t          t          f          r-|t          v r7|                    |           Mpt          |          S )Nz?This property can be only accessed after MRO is (re-)calculatedrX   )r'  r  r  r  r  rd   rc  r   rU  r  r  addrC  )r^   membersr  r   rc  s        rP   protocol_memberszTypeInfo.protocol_membersP  s      EExZZZZZZHSbSM 	& 	&D &"&*"2"2"4"4 & &JD$!$)ih-OPP ! ;;; KK%%%%grO   c                $   g }| j                                         D ]r\  }}t          |j        t                    r:t          d |j        j        D                       r|                    |           YZt          |j        t          t          f          r|t          v s$t          |          s|                    d          rt          |j        t                    r|j        j        st          j                            |j        j                  }t          |t          j        j                  r|                                r/t          |t          j        j                  r|j        j        dk    r]|                    |           t|S )Nc              3  V   K   | ]$}t          |t                    |j        d k    V  %dS )zenum.memberN)rd   rb  r   )r   r;  s     rP   r  z(TypeInfo.enum_members.<locals>.<genexpr>l  sM        !#w//LM1     rO   __zenum.nonmember)r  r  rd   rc  r  anyr  r  r  r   r  rA   r:  rS  r   r  get_proper_typer   r  is_type_objry  r   )r^   r  r   symr  s        rP   enum_memberszTypeInfo.enum_membersa  s    ))++ -	% -	%ID# #(I.. '%  "x2     
 NN4(((  CHsHo66 % 444  5t,, 5 ch,, !86 ! *44SX]CCC"3
(?@@!ILIZIZ! #3
(;<<!  H-1AAA t$$$rO   r   c                R    |                      |          }|r|S t          |          r]   )r   KeyError)r^   r   r  s      rP   __getitem__zTypeInfo.__getitem__  s*    HHTNN 	!H4.. rO   c                    d| j          dS )Nz
<TypeInfo r_  r   r   s    rP   rb  zTypeInfo.__repr__  s    ,DM,,,,rO   c                .    t          | t                     S r]   )rd   FakeInfor   s    rP   __bool__zTypeInfo.__bool__  s     dH----rO   c                0    |                      |          d uS r]   )r   ra  s     rP   has_readable_memberzTypeInfo.has_readable_member  s    xx~~T))rO   FuncBase | Decorator | Nonec                X   | j         D ]}|j        v r|j                 j        }nNt          fd|j                                        D                       x}r|j        |d                  j        }nlt          |t                    r|c S t          |t                    r|c S  d S d S )Nc                D    g | ]}|                      d           |S )z-redefinition)r:  )r   r  r   s     rP   r  z'TypeInfo.get_method.<locals>.<listcomp>  s3    UUUq=S=S=S0T0TUUUUrO   rX   )r  r  rc  rC  keysrd   r+  r  )r^   r   r   rc  possible_redefinitionss    `   rP   
get_methodzTypeInfo.get_method  s    8 	 	Csy  y++1UUUUCINN,,UUU, , '  y!7!;<A$ 566 D),, tttrO   c                   | j         }||j                            d          s|S | j        dk    r t          j                            | g           S |}| j        dd          D ]f}|j         }||j        ||}|j                            |j        j                  r=|j                            |j        j                  r|}dd } |S )Nbuiltins.typern   )	r  r   has_baser  r   r  ry  r  r   )r^   declaredwinnersuper_class
super_metas        rP   calculate_metaclass_typez!TypeInfo.calculate_metaclass_type  s    *(>(>(O(OO>_,,:&&tR0008ABB< 	 	K$7J!Z_%<~#{##JO$<== ''(<== #FrO   c                   | j         }||j                            d          sd S | j        dk    rd S |}|g }nd|j        j         d| j         dg}| j        dd          D ]}|j         }||j        |.|}|                    d|j        j         d|j         d           C|j                            |j        j                  rh|j                            |j        j                  r.|}|                    d|j        j         d|j         d           d|j        j         d|j         d}d                    |           d| c S d S )Nr  "z" (metaclass of "z")rn   z > z conflicts with )r  r   r  r  r   r  r  join)r^   r  r  resolution_stepsr  r  conflicts          rP   explain_metaclass_conflictz#TypeInfo.explain_metaclass_conflict  s   *(>(>(O(O4>_,,4! ^HM$: ^ ^T] ^ ^ ^_8ABB< 	O 	OK$7J!Z_%<~# ''W,WW{?SWWW   {##JO$<== ''(<== # ''W,WW{?SWWW   ^:?3^^kFZ^^^Hjj!122NNHNNNNNtrO   F)preciser  c               V    |                      d          p| j        dk    p	| j        o| S )Nr  zabc.ABCMeta)r  r   r  )r^   r  s     rP   is_metaclasszTypeInfo.is_metaclass  s7    MM/** 6}-6$4W	
rO   r   c                6    | j         D ]}|j        |k    r dS dS )zReturn True if type has a base type with the specified name.

        This can be either via extension or via implementation.
        TF)r  r   )r^   r   r   s      rP   r  zTypeInfo.has_base   s3    
 8 	 	C|x''tt (urO   c                $    d | j         D             S )zXReturn a direct base classes.

        Omit base classes of other base classes.
        c                    g | ]	}|j         
S rN   r  )r   r  s     rP   r  z0TypeInfo.direct_base_classes.<locals>.<listcomp>  s    111d	111rO   )r  r   s    rP   direct_base_classeszTypeInfo.direct_base_classes
  s    
 21dj1111rO   r  mypy.types.TupleTypec                    || _         t                              |           }| j        s	|| _        dS |j        | j        _        d| j        _        dS )z.Update tuple_type and special_alias as needed.N)r  r   from_tuple_typer  r`   _is_recursiver^   r  aliass      rP   update_tuple_typezTypeInfo.update_tuple_type  sS    ))$//! 	4!&D(-D%/3D,,,rO   mypy.types.TypedDictTypec                    || _         t                              |           }| j        s	|| _        dS |j        | j        _        d| j        _        dS )z2Update typeddict_type and special_alias as needed.N)r  r   from_typeddict_typer  r`   r%  r&  s      rP   update_typeddict_typezTypeInfo.update_typeddict_type  sT    !--d33! 	4!&D(-D%/3D,,,rO   c                    t                      }|                     t          j                            |          t          j                            |                    S )zzReturn a string representation of the type.

        This includes the most important information about the type.
        r   )str_convtype_str_conv)r@   dumpr   r   r   r  TypeStrVisitorrA  s     rP   r   zTypeInfo.__str__'  sT    
 ))yy\))')::*33G3DD  
 
 	
rO   r.  mypy.strconv.StrConvr/  mypy.types.TypeStrVisitorc                p   d}dfdd                     |           z   }| j        r*dd	                    fd
| j        D                        d}d                    d	                    fd| j        D                                 }g }t          | j                  D ]}|                     | j        |         j                  z   }| j        |         j        }	t          |	t                    r|	j
        r|d |	j
                   dz  }|                    |           d| j         d||d|fg}
| j        r'|
                    d | j                   d           | j        r'|
                    d | j                   d           t          j                            |
|          S )z5Return a string dump of the contents of the TypeInfo.r   r  r  rZ   r   c                .    |                                S r]   )r   )r  r/  s    rP   type_strzTypeInfo.dump.<locals>.type_str9  s    ::m,,,rO   r   zBases(z, c              3  .   K   | ]} |          V  d S r]   rN   )r   r  r6  s     rP   r  z TypeInfo.dump.<locals>.<genexpr>>  s+      %L%Lhhtnn%L%L%L%L%L%LrO   )zMro({})c              3  R   K   | ]!}|j                             |          z   V  "d S r]   )r   	format_id)r   r  r.  s     rP   r  z TypeInfo.dump.<locals>.<genexpr>@  s8      TT4dmh&8&8&>&>>TTTTTTrO    (zName(NameszDeclaredMetaclass(zMetaclassType()r.  )r  r  rZ   r   )r:  r  r  formatr  rC  r  rc  rd   r  r   r  r   r  r  r   r   dump_tagged)r^   r.  r/  r  headr  r  r   descriptionrc  r  r6  s    ``        @rP   r0  zTypeInfo.dump2  s   
 	- 	- 	- 	- 	- 	- H..t444: 	PODII%L%L%L%L%L%L%LLLOOODIITTTT48TTTTT
 
 4:&& 	& 	&D!3!3DJt4D4I!J!JJK:d#(D$$$ ; ;:HHTY$7$7::::LL%%%%))))4w6FG" 	TLLRhht7N.O.ORRRSSS 	LLLJ((43F*G*GJJJKKK|''th'GGGrO   rl   c                   i ddd| j         d| j        d| j                            | j                  d| j                                        d| j        d| j        d	| j        d
d | j        D             dd | j	        D             dd | j
        D             d| j        d n| j                                        d| j        d n| j                                        d| j        d n| j                                        d| j        d n| j                                        d| j        d n| j                                        dt!          | t"          j                  | j        | j        t+          | j                  nd | j        | j        | j                                        nd | j        | j                                        nd | j        d}|S )Nr   r   r  r   r  r  r  rp  r  r  c                6    g | ]}|                                 S rN   r  r   bs     rP   r  z&TypeInfo.serialize.<locals>.<listcomp>[  r  rO   r  c                    g | ]	}|j         
S rN   r  r   cs     rP   r  z&TypeInfo.serialize.<locals>.<listcomp>\  s    1111AJ111rO   r  c                6    g | ]}|                                 S rN   r  )r   ps     rP   r  z&TypeInfo.serialize.<locals>.<listcomp>]  s     >>>1>>>rO   r  r  r  r  r  r  )r  r  r  r  r  r  )r  r   r  r   r  r  rp  r  r  r  r  r  r  r  r  r  r  r   r  r  r  rC  r  r  r  r  r   s     rP   r   zTypeInfo.serializeP  sK   "
j"
4+"
 "
 TZ))$-88	"

 DI''))"
 "4#;"
 "
 "4#;"
 88TZ888"
 11111"
 >>>>>"
 4#3#;44AQA[A[A]A]"
 !/7T=T=^=^=`=`"
  +39L9V9V9X9X#"
& $/"9$$t?X?X?Z?Z'"
( +39L9V9V9X9X+"
. YtX^44/"
0 +/:+AVDJ'''t$($=7;~7Q11333W[ 0< -77999/C"
 "
 "
F rO   r   c                B   t                               |d                   }t                              |d                   }|d         }t          |||          }|d         |_        d |d         D             |_        |d         |_        |d         |_        d	 |d
         D             |_        g }|d         D ]W}t          j
                            |          }t          |t          j
        j                  sJ |                    |           X||_        |d         d n)t          j
        j                            |d                   |_        |d         d n)t          j
        j                            |d                   |_        |d         d n)t          j
        j                            |d                   |_        |d         |_        |d         d n)t          j
        j                            |d                   |_        |d         d n)t          j
        j                            |d                   |_        |d         |_        |d         t5          |d                   nd |_        |d         |_        t;          ||d                    |d         }	|	$t          j
        j                            |	          nd |_        |                     d          %tB                              |d                   |_"        |                     d          |_#        |S )Nr  r  r  r   c                .    g | ]}|d          |d         fS )r   rn   rN   )r   attrs     rP   r  z(TypeInfo.deserialize.<locals>.<listcomp>~  s%    !]!]!]47DG"4!]!]!]rO   r  rp  r  c                V    g | ]&}t           j        j                            |          'S rN   )r   r  ry  r   rC  s     rP   r  z(TypeInfo.deserialize.<locals>.<listcomp>  s+    NNN1DJ'33A66NNNrO   r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  )$r!  r   ro  r   r  r  rp  r  r  r   r  r  rd   r  r  r  ry  r  r  r  r  	TupleTyper  TypedDictTyper  r  r'  r  r  r  TypeVarTyper  r   r   r  r  )
r   r   r  r  r  tir  rI  r\  sts
             rP   r   zTypeInfo.deserializew  s   ''W66##DL11=)eT;//J'!]!]F[A\!]!]!]K(!%&;!<NNWNNNj! 	 	A
++A..Aa!677777OOA M"* D$00m1DEE 	 ()1 D$006J1KLL 	 $%- D$006F1GHH 	 E{ L!) D%11$|2DEE 	 $%- D)55d;K6LMM 	
 :&)-g)B3tG}%%%"&'=">"d7m$$$+ACtz-99"===UY88.//;*@*L*L/0+ +B' ..	rO   r*   c                   t          |t                     | j                            || j                   | j                            |           t          || j                   t          || j                   t          |d | j	        D                        t          |d | j	        D                        t          || j                   t          || j                   t          j                            || j                   t          |d | j        D                        t          j                            || j                   t          j                            || j                   t          j                            || j                   t          j                            || j                   t          j                            || j                   t          j                            || j                   t5          || j        | j        | j        | j        | j        | j         | j!        | j"        | j#        | j$        | j%        g           tM          || j'                   | j(        t          |tR                     n"t          |tU          | j(                             t          || j+                   t          j                            || j,                   | j-        t          |tR                     n| j-                            |           t]          || j/                   t          |t`                     d S )Nc                    g | ]\  }}|S rN   rN   )r   r   r  s      rP   r  z"TypeInfo.write.<locals>.<listcomp>      EEEDAqaEEErO   c                    g | ]\  }}|S rN   rN   )r   r  ss      rP   r  z"TypeInfo.write.<locals>.<listcomp>  rU  rO   c                    g | ]	}|j         
S rN   r  rF  s     rP   r  z"TypeInfo.write.<locals>.<listcomp>  s    ;;;Qaj;;;rO   )1r>   	TYPE_INFOr  r   r   r  r   r  r;   r  r7   rp  r5   r  r   r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  rr  r  r  r9   r  r  r&   rC  r  r  r  r<   r  r!   r   s     rP   r   zTypeInfo.write  s   $	"""
t}---	$()))$&&&tEED,DEEEFFFtEED,DEEEFFFtT^,,,41222
""4444t;;$(;;;<<<
""4777
!!$(8999
!!$(?@@@
!!$(;<<<
!!$888
!!$(;<<< $)# %%$	
 	
 	
  	4''':dL))))4
!3!3444tT6777
!!$777(0dL)))))//555dDO,,,$     rO   r(   c                
   t                                         }t                    t          k    sJ t                                        }t                    }t          |||          }t                    |_        t                    }t                    }t          t          ||                    |_        t                    |_        t                    |_        g |_        t                    t"          k    sJ t%          t'                              D ]b}t                    t(          j        j        k    sJ |j                            t(          j        j                                                 ct                    |_        t5          t          t(          j        j                 t(          j                                                |_        t                    x}	t<          k    r@|	t(          j        j        k    sJ t(          j        j                                      |_        t                    x}	t<          k    r@|	t(          j        j        k    sJ t(          j        j                                      |_         t                    x}	t<          k    r@|	t(          j        j        k    sJ t(          j        j                                      |_!        t                    x}	t<          k    r@|	t(          j        j"        k    sJ t(          j        j#                                      |_$        t                    x}	t<          k    r@|	t(          j        j%        k    sJ t(          j        j&                                      |_'        tQ          d          \  |_)        |_*        |_+        |_,        |_-        |_.        |_/        |_0        |_1        |_2        |_3        ti                    |_5        t                    }	|	t<          k    r:|	tl          k    sJ fdt%          t'                              D             |_7        t                    |_8        t                    x}	t<          k    r@|	t(          j        j9        k    sJ t(          j        j:                                      |_;        t                    }	|	t<          k    r,|	tx          k    sJ tz                                        |_>        t                    |_@        t                    t          k    sJ |S )Nr   r  c                .    h | ]}t                    S rN   )read_str_barer
  s     rP   	<setcomp>z TypeInfo.read.<locals>.<setcomp>'  s!    PPPd++PPPrO   )Br!  r   r4   r  ro  r   r   r  r1   r-   listzipr  rp  r+   r  r  r"   r  r  r   r  r}  r  ry  r  r   r  rc  r  r&   r  r  r  
TUPLE_TYPErN  r  TYPED_DICT_TYPErO  r  r  r  r  r  r  r  r  r  r  rr  r  r  r/   r  r#   r  r  TYPE_VAR_TYPErP  r  r    r   r  r2   r  r!   )
r   r   r  r  r  rQ  attrsstatusesr  r   s
    `        rP   r   zTypeInfo.read  sB     &&~~****}}T""tnneT;//~~d## &&!%c%&:&:!;!;$T**!*4~~))))}T**++ 	< 	<AD>>TZ%88888HOODJ/44T::;;;; %T**4
 56
8Q8QRV8W8WXXD>>!Cl22$*-----!Z055d;;BND>>!Cl22$*-----$(J$7$<$<T$B$BB!D>>!Cl22$*----- $
 3 8 8 > >BD>>!Cl22$*///// J055d;;BMD>>!Cl22$*44444 $
 8 = =d C CB tr***	
NJ#MNKootnn,(????PPPPU=;N;N5O5OPPPBH"/"5"5D>>!Cl22$*22222:166t<<BLtnn,'>>>>*@*E*Ed*K*KB'$T**~~((((	rO   )r  r!  r  ro  r  r   rZ   r[   rX  r   rK  )r   r   rZ   r  )r   r   rZ   r  )rZ   r  )r   r   rZ   r   )r   r   rZ   r   )r   r   rZ   r  )rZ   r  rZ   r  )r  r   rZ   r   )r   r   rZ   r   )rZ   r  )r  r"  rZ   r[   )r  r)  rZ   r[   )r.  r2  r/  r3  rZ   r   r   )r   rl   rZ   r   r   )r   r(   rZ   r   )%rJ   rK   rL   rh   ri   r   r  r_   r  r   r   r   r  r   r  r  r  r  rb  r  r  r  r  r  r  r  r!  r(  r,  r   r0  r   r   r   r   r   rM  rN  s   @rP   r   r     s        
 
,I\ NNN NNN   MMMNNN2222.... /...#### , DCCCJJJJ )((( MMM  
   %$$$ *))) ,+++ ,+++  4333   "!!! $### -,,, <;;;   5444  E    .% .% .% .% .% .%`/ / / /    X    X' ' ' '          X  1 1 1 X1f! ! ! !- - - -. . . .* * * *   $   4# # # #J /4 
 
 
 
 
 
   2 2 2 2	4 	4 	4 	4	4 	4 	4 	4	
 	
 	
 	
H H H H<% % % %N ? ? ? [?B.! .! .! .!` H H H [H H H H HrO   c                  "    e Zd ZdZddZdd	Zd
S )r  r  r  r   rZ   r[   c                    || _         d S r]   rg  )r^   r  s     rP   r_   zFakeInfo.__init__L  s    rO   rL  r   c                    |dk    rt                               | |          S t          t                               | d                    )Nr   r  )object__getattribute__AssertionError)r^   rL  s     rP   rk  zFakeInfo.__getattribute__O  sA    ;**4666V44T5AABBBrO   N)r  r   rZ   r[   )rL  r   rZ   r   )rJ   rK   rL   ri   r_   rk  rN   rO   rP   r  r  5  sG        I,   C C C C C CrO   r  zVar is lacking infozFinal[TypeInfo]r[  zClassDef is lacking infor}  z"FuncBase for non-methods lack infor|  z*fallback can't be filled out until semanalMISSING_FALLBACKc                       e Zd ZdZdZdZddddddd, fdZed-d            Zed-d            Z	e
d.d            Ze
d.d            Ze
d/d            Zd0d#Zd1d%Zed2d'            Zd3d)Zed4d+            Z xZS )5r   a  
    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.

    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.
    module: Module where the alias was defined.
    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  modulealias_tvarsno_args
normalizedr%  eagertvar_tuple_indexpython_3_12_type_alias)r   r`   rp  rq  NF)rp  rq  rr  rs  ru  r`   r  r   r   ro  rT   rY   rU   rp  rx  rq  r   rr  rs  ru  rZ   r[   c               V   || _         || _        || _        |g }|| _        || _        || _        d | _        |	| _        |
| _        d | _	        t          |          D ]+\  }}t          |t          j        j                  r|| _	        ,t                                          ||           d S r]   )r  ro  r`   rp  rq  rr  r%  rs  ru  rt  r  rd   r   r  r  r&  r_   )r^   r`   r   ro  rT   rU   rp  rq  rr  rs  ru  r  r\  r   s                rP   r_   zTypeAlias.__init__  s     "K&$ +/
&<# $k** 	* 	*DAq!TZ899 *()%v&&&&&rO   rw  r   c           
        |j         sJ t          |j                             t          j                            |t          j                            |j        j                                      |j	        |j
        |j        |j                  S )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).
        r~  )r  r   copy_modifiedr   r  ry  type_vars_as_argsr  rp  r   r  rT   rU   r   rw  s     rP   r$  zTypeAlias.from_tuple_type  s     O)),,$*66ty7JKK  *   MIK
 
 	
rO   c           
        |j         sJ t          |j                             t          j                            |t          j                            |j        j                                      |j	        |j
        |j        |j                  S )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).
        rx  )r  r   ry  r   r  ry  rz  r  rp  r   r  rT   rU   r{  s     rP   r+  zTypeAlias.from_typeddict_type  s     """"--,,$*66ty7JKK  .   MIK
 
 	
rO   c                B    | j                             d          d         S Nr.  rX   r/  r   s    rP   r   zTypeAlias.name      ~##C((,,rO   c                    | j         S r]   r2  r   s    rP   r   zTypeAlias.fullname  r3  rO   c                >    t          d | j        D                       S )Nc              3  T   K   | ]#}t          |t          j        j                  V  $d S r]   )rd   r   r  r  r  s     rP   r  z0TypeAlias.has_param_spec_type.<locals>.<genexpr>  s1      UUq:a!9::UUUUUUrO   )r  rp  r   s    rP   r  zTypeAlias.has_param_spec_type  s"    UUDDTUUUUUUrO   r   r   rj   c                ,    |                     |           S r]   )visit_type_aliasr   s     rP   r   zTypeAlias.accept  rn  rO   rl   c           	         d| j         | j        | j                                        d | j        D             | j        | j        | j        d}|S )Nr   c                6    g | ]}|                                 S rN   r  r  s     rP   r  z'TypeAlias.serialize.<locals>.<listcomp>'  s     DDDaAKKMMDDDrO   )r   r   ro  r`   rp  rq  rr  ru  )r  ro  r`   r   rp  rq  rr  ru  r   s     rP   r   zTypeAlias.serialize!  sW    !kk++--DD43CDDD|/&*&A	
 	
 rO   r   c                   |d         dk    sJ |d         }|d         }d |d         D             }t          d |D                       sJ t          j                            |d                   }|d	         }|d
         }|d         } | |||ddt	          t
          t          j        j                 |          |||	  	        S )Nr   r   r   ro  c                L    g | ]!}t           j                            |          "S rN   r_  r  s     rP   r  z)TypeAlias.deserialize.<locals>.<listcomp>3  s(    SSS!tz22155SSSrO   rp  c              3  T   K   | ]#}t          |t          j        j                  V  $d S r]   )rd   r   r  r  r[  s     rP   r  z(TypeAlias.deserialize.<locals>.<genexpr>4  s1      RR:a!;<<RRRRRRrO   r`   rq  rr  ru  rX   rp  rq  rr  ru  )r  r   r  r  r   r^  r  )	r   r   r   ro  rp  r`   rq  rr  ru  s	            rP   r   zTypeAlias.deserialize.  s    H~,,,,
#hSStM?RSSSRRkRRRRRRRR,,T(^<<y/,'
!%&>!?sT$*"<={KK!#9

 

 

 
	
rO   r*   c                   t          |t                     t          || j                   t          || j                   | j                            |           t          j        	                    || j
                   t          || j                   t          || j                   t          || j                   t          |t                     d S r]   )r>   
TYPE_ALIASr   r  ro  r`   r   r   r  r  rp  r5   rq  rr  ru  r!   r   s     rP   r   zTypeAlias.writeE  s    $
###$'''$$$$$
""4)9:::4&&&4)))44555$     rO   r(   c                p   t          |          }t          |          }t          j                            |          }t          j                            |          }t          |||dd|t          |          t          |          t          |          	  	        }t          |          t          k    sJ |S )NrX   r  )	r   r   r  rd  r  r   r+   r4   r!   )r   r   r   ro  r`   rp  r!  s          rP   r   zTypeAlias.readP  s    D>>$%%d++j44T::#dOO #,T??

 

 

 ~~((((
rO   )r`   r  r   r   ro  r   rT   rY   rU   rY   rp  rx  rq  r   rr  r   rs  r   ru  r   rZ   r[   )rw  r   rZ   r   r   rK  r   r   )r   rl   rZ   r   r   )r   r(   rZ   r   )rJ   rK   rL   rh   ri   rL  r_   r   r$  r+  r   r   r   r  r   r   r   r   r   rM  rN  s   @rP   r   r   \  s       W WrI BN @D ',' ' ' ' ' ' ' 'B 
 
 
 [
* 
 
 
 [
* - - - X-    X V V V XV. . . .    
 
 
 [
,	! 	! 	! 	!    [    rO   r   c                  d    e Zd ZdZdZddddZedd            Zedd            ZddZ	ddZ
dS )PlaceholderNodea  Temporary 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.
    )r  rc  becomes_typeinfoF)r  r   r   rc  r   rT   rY   r  r   rZ   r[   c               >    || _         || _        || _        || _        d S r]   )r  rc  r  rT   )r^   r   rc  rT   r  s        rP   r_   zPlaceholderNode.__init__  s%     "	 0			rO   c                B    | j                             d          d         S r~  r/  r   s    rP   r   zPlaceholderNode.name  r  rO   c                    | j         S r]   r2  r   s    rP   r   zPlaceholderNode.fullname  r3  rO   rl   c                    J d            )NFz#PlaceholderNode can't be serializedrN   r   s    rP   r   zPlaceholderNode.serialize  s    ;;;;;rO   r   r   rj   c                ,    |                     |           S r]   )visit_placeholder_noder   s     rP   r   zPlaceholderNode.accept  r  rO   N)
r   r   rc  r   rT   rY   r  r   rZ   r[   r   r   r   )rJ   rK   rL   rh   ri   r_   r   r   r   r   r   rN   rO   rP   r  r  e  s        . .` :I QV      - - - X-    X< < < <4 4 4 4 4 4rO   r  c                      e Zd ZdZdZ	 	 	 d&dddd'dZed(d            Zed)d            Zed*d            Z	d+dZ
d,dZd-dZed.d             Zd/d"Zed0d$            Zd%S )1r   a  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. Should not be accessed
            directly, only via the `node` property.
        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 <module> import *'. This has no effect on names within
            classes.
        module_hidden: If True, the name will never be 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 for internal
            and/or temporary symbols such as function redefinitions.
        unfixed: Indicates that this symbol is fresh after deserialization and
            needs fixup, such as resolving cross-references etc.
        stored_info: TypeInfo containing this symbol. Normally code accesses this
            on the `node` attribute, but it may be not ready during deserialization,
            so we temporarily store info on the symbol itself.

    NOTE: No other attributes should be added to this class unless they
    are shared by all node kinds.
    )r  _node_node_bytes	_node_tagmodule_publicmodule_hidden	cross_refr  plugin_generatedno_serializeunfixedstored_infoTF)r  r  r  rY   rc  SymbolNode | Noner  r   r  r  r  r  rZ   r[   c                   || _         || _        d| _        d| _        || _        || _        || _        d | _        || _        || _	        d| _
        d | _        d S )NrO   r   F)r  r  r  r  r  r  r  r  r  r  r  r  )r^   r  rc  r  r  r  r  r  s           rP   r_   zSymbolTableNode.__init__  sd     	
* *%) 0(,0rO   r  c                ,    | j         | j         j        S d S r]   )rc  r   r   s    rP   r   zSymbolTableNode.fullname  s    9 9%%4rO   r  c                    | j         }t          |t          t          f          r|j        |j        S t          |t
                    r|j        j        S d S r]   )rc  rd   r  r+  r   r  r  )r^   rc  s     rP   r   zSymbolTableNode.type  sQ    ydS"7899 	di>S9i(( 	8= 4rO   c                   | j         rt          j        }|J | j        |                    |            n| j        3t          t          | j                  | j	                  | _        d| _        | j        }|J | j
        t          || j
                   d | _
        |                    |           d| _         | j        S )NrO   F)r  r?   
node_fixerr  resolve_cross_refr  read_symbolr(   r  r  r  set_infor   )r^   r  rc  s      rP   rc  zSymbolTableNode.node  s    < 	%&1J)))~),,T2222:%!,Z8H-I-I4>!Z!ZDJ'*D$z'''#/T4#3444'+D$J'''$zrO   c                    t          | j        | j        | j        | j        | j                  }| j        |_        | j        |_        | j        |_        |S r]   )	r   r  r  r  r  r  r  r  r  )r^   news     rP   r  zSymbolTableNode.copy3  sK    Itz4#5t}dFX
 
 l*
rO   r   c                   t           | j                  dt          | j                   }t	          | j        t
                    r|d| j        j         dz  }| j        |d| j         z  }| j        r|d| j         z  }|S )N/r;  r8   : z cross_ref:)	r}   r  rC   rc  rd   r   r   r   r  )r^   rW  s     rP   r   zSymbolTableNode.__str__<  s    $)$>>z$)'<'<>>di,, 	,+di(++++A9 "ty"""A> 	0/t~///ArO   prefixr   rl   c                .   dt           | j                 d}| j        rd|d<   | j        sd|d<   | j        rd|d<   | j        rd|d<   t          | j        t                    r| j        j	        |d	<   n| j        J | d|             |q| j        j	        }d|v ra||dz   |z   k    rUt          | j        t                    r| j        j        s/t          | j        t                    rJ d| d            ||d	<   |S | j                                        |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   )r   r  Tr  Fr  r  r  r  N:r.  Definition of  is unexpectedly incompleterc  )r}   r  r  r  r  r  rd   rc  r  r   r  rR  r  r   )r^   r  r   r   r   s        rP   r   zSymbolTableNode.serializeG  ss    %6z$)?TUU 	)$(D!! 	*$)D!= 	$#D  	,'+D#$di** 	1 $	 2D9((V*<*<d*<*<(((!9-8OO FSL4$777'	377 8<@I<Y 8  *	?    N NMMMMN N N )1D%K9..00DLrO   r   c                   |d         dk    sJ t           |d                  }d|v r%t          |d           }|d         |_        d|_        nZd|v s
J |            t                              |d                   }t          ||          }t          |t                    sd|_        d|v r|d         |_        d|v r|d         |_	        d	|v r|d	         |_
        d
|v r|d
         |_        |S )Nr   r   r  r  Trc  r  r  r  r  )r   r   r  r  r   r   rd   r   r  r  r  r  )r   r   r  stnoderc  s        rP   r   zSymbolTableNode.deserializej  s   H~!22222!$v,/$$T400F#K0F!FNNT>>>4>>>))$v,77D$T400FdH-- &!%d""#'#8F d""#'#8F ":.FO%%&*+=&>F#rO   r*   c                   t          |t                     t          || j                   t	          || j                   t	          || j                   t	          || j                   t	          || j                   d }t          | j
        t                    r| j
        j        }n| j
        J | d|             |l| j
        j        }d|v r\||dz   |z   k    rPt          | j
        t                    r| j
        j        s*t          | j
        t                    rJ d| d            |}t!          ||           |#| j
        J | j
                            |           t          |t$                     d S )Nr  r.  r  r  )r>   SYMBOL_TABLE_NODEr   r  r5   r  r  r  r  rd   rc  r  r   r  rR  r  r<   r   r!   )r^   r   r  r   r  r   s         rP   r   zSymbolTableNode.write  s   $)***$	"""4+,,,4+,,,4'''4.///	di** 	)	*II9((V*<*<d*<*<(((!9-8OO FSL4$777'	377 8<@I<Y 8  *	?    N NMMMMN N N !)IdI&&&9(((IOOD!!!$     rO   r(   c                @   t          |          t          k    sJ t          t          |          d           }t	          |          |_        t	          |          |_        t	          |          |_        t	          |          |_        t          |          }|]t          |          }|t          k    r t                              |          |_        n1t          |          |_        ||_        d|_        n||_        d|_        t          |          t&          k    sJ |S rJ  )r4   r  r   r   r+   r  r  r  r  r2   rY  r   r   r  r   r  r  r  r  r!   )r   r   r  r  r   s        rP   r   zSymbolTableNode.read  s    ~~!22222htnnd33%dOO%dOO ( &&	4..Ci$MM$//		"0"6"6 #"%CMCK~~((((
rO   N)TFF)r  rY   rc  r  r  r   r  r   r  r   r  r   r  r   rZ   r[   re  rB  )rZ   r  )rZ   r   r   )r  r   r   r   rZ   rl   )r   rl   rZ   r   )r   r*   r  r   r   r   rZ   r[   )r   r(   rZ   r   )rJ   rK   rL   rh   ri   r_   r   r   r   rc  r  r   r   r   r   r   r   rN   rO   rP   r   r     sM       5 5nI& ##1 "'"1 1 1 1 1 10    X    X    X&   	 	 	 	! ! ! !F    [0! ! ! !>    [  rO   c                  f    e Zd ZdZdZddZddZdd	Zedd            Z	ddZ
edd            ZdS )r!  zrStatic representation of a namespace dictionary.

    This is used for module, class and function namespaces.
    rN   rZ   r   c                   g }|                                  D ]\  }}t          |t                    rm|j        dk    ra|j        pd                    d          d         t
          vr8|                    dt          |          z   dz   t          |          z              |                    d           t          |          }|	                    dd	           |dxx         d
z  cc<   d
                    |          S )Nbuiltinsr   r.  rX   z  r  z  <invalid item>r   zSymbolTable(r8  
)r  rd   r   r   r0  r   r  r   rC  insertr  )r^   r   r6  r  s       rP   r   zSymbolTable.__str__  s    **,, 
	- 
	-JC%11 -Nj00-244S99"=EZZZHHTCHH_u4s5zzABBB +,,,,1II	N###	"yy||rO   c                X    t          d |                                 D                       S )Nc                @    g | ]\  }}||                                 fS rN   )r  )r   r6  rc  s      rP   r  z$SymbolTable.copy.<locals>.<listcomp>  s)    MMM93S$))++.MMMrO   )r!  r  r   s    rP   r  zSymbolTable.copy  s'    MM

MMMNNNrO   r   rl   c                    ddi}|                                  D ],\  }}|dk    s|j        r|                    ||          ||<   -|S )Nr   r!  __builtins__)r  r  r   )r^   r   r   r6  r  s        rP   r   zSymbolTable.serialize  s]    "M2**,, 	7 	7JC
 n$$(:$#66DIIrO   r   c                    |d         dk    sJ t                      }|                                D ](\  }}|dk    rt                              |          ||<   )|S )Nr   r!  )r!  r  r   r   )r   r   rR  r6  r  s        rP   r   zSymbolTable.deserialize  sa    H~....]]**,, 	= 	=JCh)55e<<3	rO   r*   r[   c                L   d}|                                  D ]\  }}|dk    s|j        r|dz  }t          |t                     t	          ||           t          |           D ]?}| |         }|dk    s|j        rt          ||           |                    |||           @d S )Nr   r  rn   )r  r  r>   r   r  rC  write_str_barer   )r^   r   r   sizer6  r  s         rP   r   zSymbolTable.write  s    **,, 	 	JC
 n$$(:$AIDD$%%%tT"""$<< 	- 	-CIEn$$(:$4%%%KKh,,,,	- 	-rO   r(   c                    t                    t          k    sJ t                    }t          fdt	          |          D                       S )Nc                b    g | ]+}t                    t                                        f,S rN   )r\  r   r   r
  s     rP   r  z$SymbolTable.read.<locals>.<listcomp>  s4    TTT1mD!!?#7#7#=#=>TTTrO   )r4   r   r  r!  r  )r   r   r  s    ` rP   r   zSymbolTable.read   sV    ~~----T""TTTTdTTT
 
 	
rO   Nr   )rZ   r!  )r   r   rZ   rl   )r   rl   rZ   r!  )r   r*   r   r   rZ   r[   )r   r(   rZ   r!  )rJ   rK   rL   rh   ri   r   r  r   r   r   r   r   rN   rO   rP   r!  r!    s         
 I   $O O O O
 
 
 
    [- - - -( 
 
 
 [
 
 
rO   r!  c                  l    e Zd ZdZdZddddddddZddZedd            ZddZ	edd            Z
dS )r   zSpecifies how a dataclass-like transform should be applied. The fields here are based on the
    parameters accepted by `typing.dataclass_transform`.
eq_defaultorder_defaultkw_only_defaultfrozen_defaultfield_specifiersN)r  r  r  r  r  r  r#  r  r  r  tuple[str, ...] | Noner  rZ   r[   c               t    ||nd| _         ||nd| _        ||nd| _        ||nd| _        ||nd| _        d S )NTFrN   r  )r^   r  r  r  r  r  s         rP   r_   zDataclassTransformSpec.__init__  sc     )3(>**D.;.G]]U2A2MSX0>0JnnPU4D4P 0 0VXrO   rl   c                ^    | j         | j        | j        | j        t	          | j                  dS Nr  )r  r  r  r  r^  r  r   s    rP   r   z DataclassTransformSpec.serialize'  s6    /!/#3"1 $T%: ; ;
 
 	
rO   r   c                   t          |                    d          |                    d          |                    d          |                    d          t          |                    dg                               S )Nr  r  r  r  r  r  )r   r   tupler   s     rP   r   z"DataclassTransformSpec.deserialize0  sq    %xx--((?33 HH%67788$455"488,>#C#CDD
 
 
 	
rO   r*   c                ,   t          |t                     t          || j                   t          || j                   t          || j                   t          || j                   t          || j                   t          |t                     d S r]   )
r>   r    r5   r  r  r  r  r;   r  r!   r   s     rP   r   zDataclassTransformSpec.write:  s    $   4)))4+,,,4-...4,---tT2333$     rO   r(   c                    t          t          |          t          |          t          |          t          |          t          t          |                              }t	          |          t
          k    sJ |S r  )r   r+   r  r1   r4   r!   re  s      rP   r   zDataclassTransformSpec.readC  sk    $ #D//%dOO$T??"=#6#677
 
 
 ~~((((
rO   )r  r#  r  r#  r  r#  r  r  r  r#  rZ   r[   r   )r   rl   rZ   r   r   )r   r(   rZ   r   )rJ   rK   rL   rh   ri   r_   r   r   r   r   r   rN   rO   rP   r   r   	  s        < <I #'%)'+37 '+Y Y Y Y Y Y$
 
 
 
 
 
 
 [
! ! ! ! 	 	 	 [	 	 	rO   r   c                  2    e Zd ZU ded<   edd            ZdS )SplittingVisitorr   recurse_into_functionsrZ   Iterator[None]c              #  V   K   | j         }d| _         	 dV  || _         dS # || _         w xY w)zTemporarily set recurse_into_functions to True.

        This is used to process top-level functions/methods as a whole.
        TN)r  )r^   old_recurse_into_functionss     rP   set_recurse_into_functionsz+SplittingVisitor.set_recurse_into_functionsV  sK       &*%@"&*#	EEEE*DD'''*DD'DDDDs    	(N)rZ   r  )rJ   rK   rL   r   r	   r  rN   rO   rP   r  r  P  sH          !   
E 
E 
E ^
E 
E 
ErO   r  rc  r  r  c                       fd|D             S )Nc                4    g | ]}t          |          |S rN   )getattr)r   r   rc  s     rP   r  zget_flags.<locals>.<listcomp>e  s(    :::TgdD&9&9:D:::rO   rN   )rc  r  s   ` rP   r  r  d  s    ::::U::::rO   r  c                2    |D ]}t          | |d           d S rJ  )setattr)rc  r  r   s      rP   r  r  h  s0     " "dD!!!!" "rO   r   c                    t          |          dk    s
J d            d}t          |          D ]\  }}|r|d|z  z  }t          | |           d S )N   z!This many flags not supported yetr   rn   )r  r  r   )r   r  packedr  r<  s        rP   r  r  m  so    u::@FU##  4 	a1fFdFrO   r  rY   c                X    t          |           fdt          |          D             S )Nc                (    g | ]}d |z  z  dk    S )rn   r   rN   )r   r  r  s     rP   r  zread_flags.<locals>.<listcomp>x  s'    ???VqAv1$???rO   )r   r  )r   r  r  s     @rP   r  r  v  s0    d^^F????eI.>.>????rO   r  r  c                    d}t          | j        t                    r| j        j        }n.t          | j        t                    rt          | j                  }|dS | d| j         S )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.  )rd   r  r*  r   rs  get_member_expr_fullname)r  initials     rP   r  r  {  sk     G$)X&& 6).	DIz	*	* 6*4955t##	###rO   c                    i | ]V\  }}t          |          t          ur;t          |t                     r&t          |t                    r|t          uN||j        WS rN   )r   r  rd   
issubclassr   r   )r   r6  objs      rP   r   r     sn       SCyy  3 !3
## ! 	: 
 	rO   r   r  r  nodeslist[T]failCallable[[str, T], None]c                   d}d}d}d}t          | |          D ]\  }}|t          k    r|s|s|s|r |d|            d S (|t          k    r|s|s|r |d|            d S d}K|t          k    r|s|s|r |d|            d S d}n|t          k    s|t
          k    rd}|r |d|            d S |t          k    r|r |d|            d S d}d S )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)r_  r  r  r}  r  r  r  )	r  r  r  
is_var_arg	is_kw_arg
seen_namedseen_optr  rc  s	            rP   check_arg_kindsr    s    JIJH)U++  
d7?? Y *  ^    W__ Y * UW[\\\HHX Y * FMMMJJY$-"7"7J DdKKK Y >EEEI7 rO   function definitionSequence[str | None]r@  r   c                    t                      }t          | |          D ]5\  }}|||v r |d| d| |            d S |                    |           6d S )NzDuplicate parameter "z" in )r'  r_  r  )r  r  r  r@  
seen_namesr   rc  s          rP   check_param_namesr    s     #&%%J%''  
d
 2 2DAAAKAA4HHHEEt	 rO   r   c                R    t          | j        t                    r| j        j        S dS )z.Return whether the expression is ClassVar[...]F)rd   rc  r  rI  r  s    rP   is_class_varr    s&    $)S!! %y$$5rO   r  c                `    t          | t          t          t          t          f          o| j        S )z6Check whether `node` corresponds to a final attribute.)rd   r  r  r  r  rr  r  s    rP   is_final_noder    s#    dS'+<iHII[dm[rO   r  mypy.types.CallableTypec                L    | j         }t          |t                    r|j        }|S r]   )
definitionrd   r  r  )r  r  s     rP   get_func_defr    s(    J*i(( %_
rO   Fname_prefixrw  r  r)  r*  c              #  \  K   |                                  D ]\  }}|}d|v r|                    d          d         }|dz   |z   }|j        }|r|j        |k    rd}	|rit	          |t
          t          t          f          sd}	nDt	          |t                    r|j        n|}
|
j	         }	|j
        r|r||j        j        j        vrd}	t	          |t
          t          t          f          rd|v rd}	|	r|||fV  t	          |t                    rt          |j        |||          E d{V  dS )zIterate over local definitions (not imported) in a symbol table.

    Recursively iterate over class members and nested classes. If impl_only is True, do
    not yield the classes themselves, only methods.
    z-redefr   r.  TF@N)r  r0  rc  r   rd   r  r  r  r  rz  r  r  r   r  r   r,  r  )r  r  rw  r)  r   symnode	shortnamer   rc  
yield_noder  s              rP   r,  r,    s~       T Tg	t

8,,Q/I$y0| 	TDMX--J +!$2CY(OPP +!&JJ(24(C(CM499D%)%;!;J / +D +TI\=\=\%*
$*;Y GHH #ST\__"
 .----$)) T,TZ4SSSSSSSSS7T TrO   c                Z   t          | t          t          f          r	|| _        dS t          | t                    r|| j        _        || j        _        dS t          | t                    r?|| _        | j        D ]}t          ||           | j
        rt          | j
        |           dS dS dS )z<Add `info` attribute to all relevant components of the node.N)rd   r  r  rw  r  r  r  r  r  r  r  )rc  rw  r  s      rP   r  r    s    $#'' 
&				D)	$	$ &		D+	,	, &	J 	! 	!DT4    9 	&TY%%%%%& &	& 	&rO   2   z
Final[Tag]rH  3   r  4   r&  5   r=  6   r?  7   ra  8   rn  9   r{  :   rY  ;   r  <   r  =   r     	EXPR_STMT   	CALL_EXPR   	NAME_EXPR   STR_EXPR   IMPORT   MEMBER_EXPR   OP_EXPR   INT_EXPR   IF_STMT   ASSIGNMENT_STMT   
TUPLE_EXPR   BLOCK   
INDEX_EXPR   	LIST_EXPR   SET_EXPR   RETURN_STMT   
WHILE_STMT   COMPARISON_EXPR   BOOL_OP_EXPR   FUNC_DEF_STMT   	PASS_STMT   
FLOAT_EXPR   
UNARY_EXPR   	DICT_EXPR   COMPLEX_EXPR   
SLICE_EXPR   	TEMP_NODE   
RAISE_STMT   
BREAK_STMT   CONTINUE_STMT   GENERATOR_EXPR   
YIELD_EXPR   YIELD_FROM_EXPR   LIST_COMPREHENSION   SET_COMPREHENSION   DICT_COMPREHENSION   IMPORT_FROM   ASSERT_STMT   FOR_STMT   	WITH_STMT   OPERATOR_ASSIGNMENT_STMT   TRY_STMT   ELLIPSIS_EXPR   CONDITIONAL_EXPR   DEL_STMT   FSTRING_EXPR   FSTRING_INTERPOLATION   LAMBDA_EXPR   ASSIGNMENT_EXPR   	STAR_EXPR   
BYTES_EXPR   GLOBAL_DECL   NONLOCAL_DECL   
AWAIT_EXPR   BIG_INT_EXPR   
IMPORT_ALL   
MATCH_STMT   
AS_PATTERN   
OR_PATTERN   VALUE_PATTERN   SINGLETON_PATTERN   SEQUENCE_PATTERN   STARRED_PATTERN   MAPPING_PATTERN   CLASS_PATTERN   TYPE_ALIAS_STMT   IMPORT_METADATA   IMPORTFROM_METADATA   IMPORTALL_METADATA   TSTRING_EXPRr   r)   c                l   |t           k    rt                              |           S |t          k    rt                              |           S |t
          k    rt                              |           S |t          k    rt                              |           S |t          k    rt                              |           S |t          k    rt                              |           S |t          k    rt                              |           S |t          k    rt                               |           S J d|             )NFzUnknown symbol tag )r?  r  r   r&  r  r=  r  r  r  ra  rU  r  r   rn  rg  r{  rq  r   r   s     rP   r  r  h  s   
czzxx~~
h||D!!!
i~~d###
!!! %%d+++
m%%%
j~~d###
o!!$'''
!!!$$T***-------rO   
Tag | Nonec                    |t          |           }|t          k    rt                              |           S |t          k    rt
                              |           S J d|             )NFz Invalid tag for an OverloadPart )r4   r=  r  r   r&  r  r  s     rP   r  r  }  sa    
{tnn
i~~d###
h||D!!!::S:::::rO   )r   r*   r   r   rZ   r[   )r   r(   rZ   r   )rA  r.  rZ   rB  )rc  r   r  r  rZ   r  )rc  r   r  r  rZ   r[   )r   r*   r  r   rZ   r[   )r   r(   r  rY   rZ   r   )r  rs  rZ   r  )r  r  r  r  r  r  rZ   r[   )r  )
r  r  r  r  r  r  r@  r   rZ   r[   )r  r*  rZ   r   )rc  r  rZ   r   )r  r  rZ   r  rV  )
r  r!  r  r   rw  r  r)  r   rZ   r*  )rc  r   rw  r   rZ   r[   )r   r(   r   r)   rZ   r   r]   )r   r(   r   r  rZ   r  (c  rh   
__future__r   r8  abcr   collectionsr   collections.abcr   r   r   
contextlibr	   enumr
   r   typingr   r   r   r   r   rk   r   r   r   r   r   typing_extensionsr   librt.internalr   r   rm  r   r  r   r\  r   r  r   r  mypy_extensionsr   mypy.strconvr   
mypy.cacher   r   r    r!   r"   r#   r$   r%   r&   r'   r(   r)   r*   r+   r,   r-   r.   r/   r0   r1   r2   r3   r4   r5   r6   r7   r8   r9   r:   r;   r<   r=   r>   mypy.modules_stater?   mypy.optionsr@   	mypy.utilrA   rB   rC   mypy.visitorrD   rE   rF   mypy.patternsrG   rI   rR   
mypy.typesrj   r~  r   rl   r   rm   ro   rq   rs   rt   ru   rv   rw   rx   r}   r  r   r   r   r   r   r   r   r   r   r   r   r   r   r   r  r   r   r   r   r   r  rP  rZ  rb  rj  rs  ru  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r+  r  rU  r  ro  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r
  r  r  r(  r2  r:  rE  rG  rL  rR  rX  r\  rb  r*  rs  r  r  r  r}  r  r  r  r  r  r  r  r  r  r  r  MaybeTypeExpressionr  r  r  r  r  r  r  r,  r  r  r	  r  r  r  r%  r0  r5  r;  rC  rG  rH  rI  rJ  rL  rS  rU  rg  rq  r  r  r  r  r  r  r  r  	frozensetr  r  r   r  r[  r}  r|  rm  r  r   r!  r   r  r  r  r  r  r  globalsr   r  r  r  r  r  r,  r  rH  r  r&  r=  r?  ra  rn  r{  rY  r  r  r  r  r  r  r   r"  r$  r&  r(  r*  r,  r.  r0  r2  r4  r6  r8  r:  r<  r>  r@  rB  rD  rF  rH  rJ  rL  rN  rP  rR  rT  rV  rX  rZ  r\  r^  r`  rb  rd  rf  rh  rj  rl  rn  rp  rr  rt  rv  rx  rz  r|  r~  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  rN   rO   rP   <module>r     s!   : : : " " " " " " 				       # # # # # # 8 8 8 8 8 8 8 8 8 8 % % % % % %                                * ) ) ) ) )                " ! ! ! ! !    & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & &N - , , , , ,             = = = = = = = = = = I I I I I I I I I I &%%%%%%        %) %) %) %) %) %) %) %)P   GCLLCH~ % % % %                         
    64v?OQbc
 c c c cQQj>N>N>P>PQQQ  Q Q Q Q #"%         #" ,-+3'3*       (>w&G  G G G G
 &?'5	$ $      #" ,	" "     !           : : : : :7 : : :" : : : : : : : : : : : : : : : :    Z          !Q !Q !Q !Q !Q !Q !Q !QJ s$5x
7KKL
 L L L L       ) ) ) )   V
 V
 V
 V
 V
 V
 V
 V
rn n n n nz n n nb" " " " " " " "2* * * * *Z * * *"/ / / / / / / /*. . . . .
 . . .& MLL L L L LL< L< L< L< L<t L< L< L<^ !!78 8 8 8 8]= ]= ]= ]= ]=*i ]= ]= ]=@"W "W "W "W "Wt "W "W "WL                     $ ' * * *     ;
 ;
 ;
 ;
 ;
x ;
 ;
 ;
| & ) ) )                   M M M M Mh
I M M Mh !27;  ; ; ; ;S& S& S& S& S&
I S& S& S&l  	    2_ _ _ _ _* _ _ _Dy y y y yy y y yx/ / / / / / / /"1 1 1 1 19 1 1 1") ) ) ) )I ) ) ),3 3 3 3 3Y 3 3 3"@3 @3 @3 @3 @3Y @3 @3 @3F< < < < <Y < < <*. . . . .	 . . .&3, 3, 3, 3, 3,i 3, 3, 3,l/ / / / / / / // / / / / / / /", , , , ,i , , ,. . . . .	 . . .1 1 1 1 19 1 1 1- - - - -y - - -+ + + + +Y + + +4. . . . .	 . . .$", ", ", ", ",i ", ", ",J- - - - -y - - -B. . . . .	 . . .<3 3 3 3 3I 3 3 34, , , , ,j , , ,., , , , ,j , , ,,: : : :. . . . .
 . . .4. . . . .
 . . ."0 0 0 0 0* 0 0 0", , , , ,: , , ,- - - - -z - - -** * * * *j * * *Z6 6 6 6 6w 6 6 6./ / / / / / / /( 5 5 5 5 5d 5 5 5<                 " " " " "$	 $ $ $ $$	 $ $ $ $, , , , ,Wh	9mT	 T T T T!- !- !- !- !-z !- !- !-H3 3 3 3 3J 3 3 3. . . . .
 . . .. . . . .
 . . .D. . . . .
 . . .,3 3 3 3 3Z 3 3 3 1+ 1+ 1+ 1+ 1+Z 1+ 1+ 1+p !*hH 3 3 3 3 3Z 3 3 3:. . . . .
 . . .:- - - - -z - - -&2 2 2 2 2: 2 2 2"4 4 4 4 4Z 4 4 4&/ / / / / / / /8. . . . .
 . . .*    :   0- - - - -z - - -"- - - - -z - - -"5 5 5 5 5j 5 5 5.. . . . .
 . . .&, , , , ,j , , ,"2 2 2 2 2J 2 2 2@6 6 6 6 6
 6 6 6"5 5 5 5 5z 5 5 5" <  <  <  <  <j  <  <  <F4 4 4 4 4j 4 4 4*4 4 4 4 4j 4 4 48 	    	             . . . . .j* . . .f (7&8  8 8 8 8Q Q Q Q Q/ Q Q Qh0 0 0 0 0O 0 0 0fH H H H H H H HV3 3 3 3 3J 3 3 3"3 3 3 3 3Z 3 3 3*2 2 2 2 2J 2 2 2$2 2 2 2 2: 2 2 2.1 1 1 1 1* 1 1 10 0 0 0 0* 0 0 02. . . . .
 . . .(- - - - -z - - -F '0i  ' '     $ #,),P,P,P"Q"Q  Q Q Q Qa a a a az a a aHC C C C Cx C C CB  (x(=>> > > > >$,H-G$H$H  H H H H ()M N N N N N N"(#OPP  P P P PF F F F F
 F F FRG4 G4 G4 G4 G4j G4 G4 G4TH H H H H H H HVL
 L
 L
 L
 L
$sO+, L
 L
 L
^D D D D D D D DN E E E E E E E E&; ; ; ;" " " "
   @ @ @ @
$ $ $ $  GIIOO%%      " " " "R -	       \ \ \ \
    [`$T $T $T $T $TN& & & &  	    "$  $ $ $ $    	                     "$  $ $ $ $	    
    	     "  " " " " 	    	    	                            ! ! ! ! !
        
    	            
    ! ! ! ! !        	    
    
    	        
    	    
    
                 
    ! ! ! ! !!$  $ $ $ $ #  # # # #!$  $ $ $ $            	    '*  * * * *        "  " " " "        $'  ' ' ' '    ! ! ! ! !	    
            
        
    
    
    
         #  # # # #"  " " " "! ! ! ! !! ! ! ! !    ! ! ! ! !! ! ! ! !"%  % % % %!$  $ $ $ $    . . . .*; ; ; ; ; ; ;rO   