
    i                      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 dd
lmZmZ m!Z"m#Z$m%Z& ddl'm(Z( ddl)Z*ddl+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8mZm9Z9m:Z:m;Z;m<Z<m!Z!m=Z=m>Z>m?Z?m@Z@mAZAmBZBm#Z#mCZCmDZDmEZEmFZFm%Z%mGZGmHZHmIZImJZJ ddlKmLZL ddlMmNZNmOZOmPZP ddlQmRZRmSZSmTZT erddlUmVZV e G d de                      ZW G d d          ZXerddlYZ* ed          ZZe[e\ef         Z]de^d<   dZ_de^d<   dZ`de^d<   dZade^d<   dZbde^d<   dZcde^d <   dZdde^d!<   dZede^d"<   dZfde^d#<   dZgde^d$<   e_d%e`d&ead'ebd(iZhde^d)<   d* ehi                                D             Zjde^d+<   d,ddd,d,ddd-Zkde^d.<   d/d0d1d2d3d4d5d6d7d8d9
Zlde^d:<   d;d<iZmde^d=<   d7d8d>Znde^d?<   d@dAdBdCdDZode^dE<   dFZpde^dG<   dHZqde^dI<    G dJ dKeX          Zre( G dL dMer                      Zse( G dN dOer                      Zt G dP dQet          ZuetZvde^dR<   e( G dS dTer                      Zwexe\dUedV         f         Zyde^dW<    G dX dY          Zz G dZ d[ew          Z{ G d\ d]es          Z| G d^ d_e|          Z} G d` dae|          Z~ G db dce|          Zg ddZde^de<    G df dger          Zedh         Zde^di<    G dj dkeewes          Z G dl dmer          ZdZde^dn<   dZde^do<   dZde^dp<    G dq dr          Zeg dsz   Zde^dt<    G du dve          Zeg dwz   Zde^dx<   dZde^dy<   dZde^dz<   dZde^d{<    G d| d}eewes          ZeefZde^d~<    G d dewes          Zg dZde^d<    G d dew          Z G d des          Z G d des          Z G d des          Z G d des          Z G d des          Z G d des          Z G d des          Z G d des          Z G d des          Z G d des          Z G d des          Z G d des          Z G d des          Z G d des          Z G d des          Z G d des          Z G d des          Z G d des          Z G d des          Z G d des          Z G d des          Z G d det          Z G d det          ZddZ G d det          Z G d det          Z G d det          Z G d det          Z G d det          Z G d det          Z G dĄ de          Z G dƄ de          Ze G dȄ de                      Zej        Zde^d<   ej        Zde^d<   ej        Zde^d<   ej        Zde^d<   ej        Zde^d<   ej        Zde^d<   eeeeeefZde^d<    G dф det          Z G dӄ det          Z G dՄ det          Z G dׄ det          Z G dل det          Z G dۄ det          Z G d݄ det          ZeeeeefZ G d߄ det          Z G d det          Z G d det          Z G d det          Z G d det          Z G d det          Z G d det          Z G d deet          Z G d det          Z G d det          Z G d det          Z G d det          Z G d det          Z G d det          Z G d det          Z G d det          Z G d d et          Z G d det          Z G d det          ZdZde^d<   dZde^d<   dZde^d<   dZde^d<    G d	 d
ewet          ZefZde^d<    G d deۦ          Z G d deۦ          Z G d deۦ          Z G d det          Z G d det          Z G d det          Z G d det          Z G d det          Z G d det          Z G d det          Z G d  d!et          Z eh d"          Zde^d#<    eh d$          Zde^d%<    G d& dVew          Z G d' d(e          Z ed)          Zd*e^d+<    ed,          Zd*e^d-<    ed.          Zd*e^d/<    ed0          Zde^d1<    G d2 d3ew          Z G d4 d5ew          Z G d6 dU          Z G d7 d8e[e\ef                   Z G d9 d:          Ze( G d; d<                      Zdd@ZddCZddGZddKZddNZdO  e            i                                D             Zde^dP<   ddWZ	 ddd\Zdd^Zdd`Z ddcZ	 dddhZdiZdje^dk<   dlZdje^dm<   dnZdje^do<   dpZdje^dq<   drZdje^ds<   dtZdje^du<   dvZ	dje^dw<   dxZ
dje^dy<   dzZdje^d{<   d|Zdje^d}<   d~Zdje^d<   dZdje^d<   dZdje^d<   dZdje^d<   dZdje^d<   dZdje^d<   dZdje^d<   dZdje^d<   dZdje^d<   dZdje^d<   dZdje^d<   dZdje^d<   dZdje^d<   dZdje^d<   dZdje^d<   dZdje^d<   dZdje^d<   dZdje^d<   dZdje^d<   dZ dje^d<   dZ!dje^d<   dZ"dje^d<   dZ#dje^d<   dZ$dje^d<   dZ%dje^d<   dZ&dje^d<   dZ'dje^d<   dZ(dje^d<   dZ)dje^d<   dZ*dje^d<   dZ+dje^d<   dZ,dje^d<   dZ-dje^d<   dZ.dje^d<   dZ/dje^d<   dĐZ0dje^d<   dƐZ1dje^d<   dȐZ2dje^d<   dʐZ3dje^d<   d̐Z4dje^d<   dΐZ5dje^d<   dАZ6dje^d<   dҐZ7dje^d<   dԐZ8dje^d<   d֐Z9dje^d<   dؐZ:dje^d<   dڐZ;dje^d<   dܐZ<dje^d<   dސZ=dje^d<   dZ>dje^d<   dZ?dje^d<   dZ@dje^d<   dZAdje^d<   dZBdje^d<   dZCdje^d<   dZDdje^d<   dZEdje^d<   dZFdje^d<   dZGdje^d<   dZHdje^d<   dZIdje^d<   dZJdje^d<   dZKdje^d<   dZLdje^d<   dZMdje^d<   d ZNdje^d<   dZOdje^d<   dZPdje^d<   dZQdje^d<   dZRdje^d	<   d
ZSdje^d<   dZTdje^d<   d dZUdd!dZVdS ("  z4Abstract syntax tree node classes (i.e. parse tree).    )annotationsN)abstractmethod)defaultdict)CallableIteratorSequence)contextmanager)Enumunique)	TYPE_CHECKINGAnyFinalOptional	TypeAlias	TypeGuardTypeVarUnioncast)
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_NONE
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)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     I/root/projects/qq-shell/venv/lib64/python3.11/site-packages/mypy/nodes.pyrC   rC   N   s        EEErI   rC   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_columnrN   intrO   returnNonec                >    || _         || _        d | _        d | _        d S NrM   )selfrN   rO   s      rJ   __init__zContext.__init__X   s"    	$(&*rI   NtargetContext | int
int | NonerP   rQ   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)
isinstancerS   rN   rO   rP   rQ   )rX   rZ   rO   rP   rQ   s        rJ   set_linezContext.set_line^   sw     fc"" 	0DIIDI -DK"ODM$/DO DK$DM!(DOOO "!rI   )rR   rR   )rN   rS   rO   rS   rT   rU   NNN
rZ   r[   rO   r\   rP   r\   rQ   r\   rT   rU   )rD   rE   rF   __doc__	__slots__rY   r_   rH   rI   rJ   rL   rL   S   s\        JJ<I+ + + + + "#!%) ) ) ) ) ) )rI   rL   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 rH   rH   ).0_name_kinds      rJ   
<dictcomp>r|      s    QQQleUUEQQQrI   inverse_node_kindsz__builtins__.str)rD   rb   __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   )rl      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.rH   rT   strc                    |                      t          j                            t	                                          S Noptions)acceptmypystrconvStrConvr:   rX   s    rJ   __str__zNode.__str__   s+    {{4<//		/BBCCCrI   r   r:   c                t    |                      t          j                            |                    }|sJ |S r   )r   r   r   r   )rX   r   as      rJ   str_with_optionszNode.str_with_options   s4    KK,,W,==>>rI   visitorNodeVisitor[T]rd   c                <    t          dt          |                     NzNot implementedRuntimeErrortyperX   r   s     rJ   r   zNode.accept       ,d4jj999rI   NrT   r   )r   r:   rT   r   r   r   rT   rd   )rD   rE   rF   rb   rc   r   r   r   rH   rI   rJ   r   r      s_        >>ID D D D   
: : : : : :rI   r   c                      e Zd ZdZdZd	dZdS )
	StatementzA statement node.rH   r   StatementVisitor[T]rT   rd   c                <    t          dt          |                     r   r   r   s     rJ   r   zStatement.accept   r   rI   Nr   r   rT   rd   rD   rE   rF   rb   rc   r   rH   rI   rJ   r   r      s3        I: : : : : :rI   r   c                      e Zd ZdZdZd	dZdS )

ExpressionzAn expression node.rH   r   ExpressionVisitor[T]rT   rd   c                <    t          dt          |                     r   r   r   s     rJ   r   zExpression.accept   r   rI   Nr   r   rT   rd   r   rH   rI   rJ   r   r      s3        I: : : : : :rI   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.
    rH   N)rD   rE   rF   rb   rc   rH   rI   rJ   r   r     s          IIIrI   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.rH   rT   r   c                    d S rW   rH   r   s    rJ   namezSymbolNode.name  	     	rI   c                    d S rW   rH   r   s    rJ   fullnamezSymbolNode.fullname  r   rI   rf   c                    d S rW   rH   r   s    rJ   	serializezSymbolNode.serialize"  s    rI   datac                    |d         }t                               |          }| ||          S t          d|           )N.classzunexpected .class )deserialize_mapgetNotImplementedError)clsr   	classnamemethods       rJ   deserializezSymbolNode.deserialize&  sI    N	 $$Y//6$<<!"By"B"BCCCrI   r%   rU   c                <    t          d| j        j         d          )NzCannot serialize 	 instance)r   	__class__rD   rX   r   s     rJ   writezSymbolNode.write.  s!    !"Xdn6M"X"X"XYYYrI   r#   c                2    t          d| j         d          )NzCannot deserialize r   )r   rD   r   r   s     rJ   readzSymbolNode.read1  s    !"O"O"O"OPPPrI   Nr   rT   rf   )r   rf   rT   r   r   r%   rT   rU   r   r#   rT   r   )rD   rE   rF   rb   rc   propertyr   r   r   r   classmethodr   r   r   rH   rI   rJ   r   r     s        55I   ^ X    ^ X    ^ D D D [DZ Z Z Z Q Q Q [Q Q QrI   r   SymbolTableNodeTypeInfo
Definitionc                  |    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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bytesr   r   list[dict[str, Any]]r   dict[int, list[str]]r   boolr   r   rT   rU   c                Z    || _         || _        || _        || _        || _        || _        d S rW   r   )rX   r   r   r   r   r   r   s          rJ   rY   zFileRawData.__init__M  s7     	$*'>$%:"""rI   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                   d S rW   )r1   r   r   r9   r   write_int_barelenr   r4   r   r   itemsr   r6   r0   r   r   )rX   r   errrN   codess        rJ   r   zFileRawData.write]  s   D$)$$$D$,'''$!!!tS11222? 	" 	"CtS!!!!$%%%tS!344555-3355 	( 	(KD%dD!!!4''''456664344444rI   r#   c           
        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                              S )Nc                .    g | ]}t                    S rH   )r*   ry   _r   s     rJ   
<listcomp>z$FileRawData.read.<locals>.<listcomp>q  s    JJJ!iooJJJrI   c                J    i | ]}t                    t                     S rH   )r   r,   r   s     rJ   r|   z$FileRawData.read.<locals>.<dictcomp>s  s)    aaa$t)<)<aaarI   )r'   r/   r   rangeread_int_barer   r   r&   )r   r   r   r   r   r   s    `    rJ   r   zFileRawData.readl  s    $T""~~))))JJJJu]45H5H/I/IJJJ
~~----aaaaeMZ^L_L_F`F`aaa':}iooyQU
 
 	
rI   N)r   r   r   r   r   r   r   r   r   r   r   r   rT   rU   r   )r   r#   rT   r   )
rD   rE   rF   rb   rc   r   rY   r   r   r   rH   rI   rJ   r   r   :  s         KKI KKKNNN$$$$''''!!!!; ; ; ; 5 5 5 5 	
 	
 	
 [	
 	
 	
rI   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>d? fd'Zd@d)Ze	dAd*            Z
e	dAd+            ZdBd/ZdCd0ZdDd2ZdEd5ZdFd7ZedGd9            ZdHd;ZedId=            Z xZS )J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]] | NonerT   rU   c                   t                                                       || _        d| _        d| _        || _        || _        t          t                    | _	        t                      | _
        i | _        |r|| _        ni | _        t                      | _        d| _        d| _        d| _        d| _        d| _        t                      | _        d | _        d | _        d S )Nrh   r    F)superrY   r   rN   rO   r   r  r   setr   r  r  r   r  r   r  r  r   r   r  r	  r
  )rX   r   r   r  r   r   s        rJ   rY   zMypyFile.__init__  s     			%c**55 	$!.D!#D UU	!&',$%*"#&55 !%rI   Iterator[Definition]c                6    t          | j        | j                  S )zyReturn all definitions within the module (including nested).

        This doesn't include imported definitions.
        )local_definitionsr  r   r   s    rJ   r  zMypyFile.local_definitions  s    
 !T];;;rI   c                T    | j         sdn| j                             d          d         S )Nr  .rR   r   splitr   s    rJ   r   zMypyFile.name  s(    JrrT^-A-A#-F-Fr-JJrI   c                    | j         S rW   r   r   s    rJ   r   zMypyFile.fullname  
    ~rI   r   r   rd   c                ,    |                     |           S rW   )visit_mypy_filer   s     rJ   r   zMypyFile.accept      &&t,,,rI   c                    t          | j                  dk    o6t          j                            | j                                      d          S )Nr   z	__init__.)r   r   osbasename
startswithr   s    rJ   is_package_init_filezMypyFile.is_package_init_file  s:    49~~"Zrw'7'7	'B'B'M'Mk'Z'ZZrI   flagc                    || j         v S rW   )r  )rX   r&  s     rJ   is_future_flag_setzMypyFile.is_future_flag_set  s    t///rI   r   r:   c                \    | j         t          |j        | j                  | _         | j         S rW   )r	  r<   abs_custom_typeshed_dirr   rX   r   s     rJ   r<   zMypyFile.is_typeshed_file  s-    !)%5g6UW[W`%a%aD"%%rI   rf   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    rJ   r   zMypyFile.serialize  sL     Z))$.99|I'+'C#)$*B#C#C
 
 	
rI   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      rJ   r   zMypyFile.deserialize  s    H~+++T+++Bk* ,,T'];;
IL	'+,E'F$!%#&t,A'B#C#C rI   r%   c                   t          |t                     t          || j                   | j                            || j                   t          || j                   t          || j                   t          || j	                   t          |t          | j                             t          |t                     d S rW   )r9   	MYPY_FILEr   r   r  r   r0   r  r   r   r6   r-  r  r   r   s     rJ   r   zMypyFile.write  s    $	"""$'''
t~...4&&&$	"""45666tVD$<==>>>$     rI   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)r/   r2  r   r   r   r  r   r  r&   r  r   r   r  r,   r  r  r   r/  s      rJ   r   zMypyFile.read  s    ~~****B!$ %%d++
 TNN	'0$#&}T':':#;#; !%~~((((rI   )FN)
r   r  r   r  r  r   r   r  rT   rU   )rT   r  r   r   rT   r   )r&  r   rT   r   )r   r:   rT   r   r   )r   rf   rT   r   r   )r   r#   rT   r   )rD   rE   rF   rb   rc   __match_args__r   rY   r  r   r   r   r   r%  r(  r<   r   r   r   r   r   __classcell__r   s   @rJ   r   r   y  sJ        ;;I* .N NNNIII**** LLL (''' MMM "!!!$$$$!!!!""""     59      >< < < < K K K XK    X- - - -[ [ [ [0 0 0 0& & & &	
 	
 	
 	
 
 
 
 [
! ! ! !    [    rI   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   r;  r<  r=  zlist[AssignmentStmt]r>  rT   rU   c                    t                                                       g | _        d| _        d| _        d| _        d S NF)r  rY   r>  r;  r<  r=  rX   r   s    rJ   rY   zImportBase.__init__;  s?    #!!rI   rT   rU   )rD   rE   rF   rb   rc   r   rY   r7  r8  s   @rJ   r:  r:  *  s|         //QI &%%%" " " " " " " " " "rI   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 )Importzimport m [as n])idslist[tuple[str, str | None]]rE  rT   rU   c                V    t                                                       || _        d S rW   )r  rY   rE  )rX   rE  r   s     rJ   rY   zImport.__init__L  s$    rI   r   r   rd   c                ,    |                     |           S rW   )visit_importr   s     rJ   r   zImport.acceptP  s    ##D)))rI   )rE  rF  rT   rU   r   
rD   rE   rF   rb   rc   r6  r   rY   r   r7  r8  s   @rJ   rD  rD  C  so         IN%%%%     * * * * * * * *rI   rD  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   rM  rS   rN  rF  r  rT   rU   c                r    t                                                       || _        || _        || _        d S rW   )r  rY   rM  r  rN  )rX   rM  rN  r  r   s       rJ   rY   zImportFrom.__init___  s2    
 rI   r   r   rd   c                ,    |                     |           S rW   )visit_import_fromr   s     rJ   r   zImportFrom.accepte      ((...rI   )rM  r   rN  rS   r  rF  rT   rU   r   rJ  r8  s   @rJ   rL  rL  T  s         %%+I0NGGGMMM''''! ! ! ! ! !/ / / / / / / /rI   rL  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 *)rM  rN  r   rM  rS   rN  rT   rU   c                d    t                                                       || _        || _        d S rW   )r  rY   rM  rN  )rX   rM  rN  r   s      rJ   rY   zImportAll.__init__s  s+     rI   r   r   rd   c                ,    |                     |           S rW   )visit_import_allr   s     rJ   r   zImportAll.acceptx      ''---rI   )rM  r   rN  rS   rT   rU   r   rJ  r8  s   @rJ   rT  rT  i  su         "I'NGGGMMM! ! ! ! ! !
. . . . . . . .rI   rT  )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inforY  rZ  r[  r\  is_explicit_overrideis_type_check_onlydef_or_infer_varsr   rT   rU   c                    t                                                       d | _        d | _        t          | _        d| _        d| _        d| _        d| _	        d| _
        d| _        d| _        d| _        d S )NFr  )r  rY   r   r`  FUNC_NO_INFOra  rY  rZ  r[  r\  rb  rc  rd  r   rA  s    rJ   rY   zFuncBase.__init__  su     37	=A 	  $)!"' "'rI   r   c                    d S rW   rH   r   s    rJ   r   zFuncBase.name  r   rI   c                    | j         S rW   r  r   s    rJ   r   zFuncBase.fullname  r  rI   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__)r[  r   r   s    rJ   has_self_or_cls_argumentz!FuncBase.has_self_or_cls_argument  s     >!;TY)%;;rI   rB  r   r5  )rD   rE   rF   rb   rc   rY   r   r   r   r   rk  r7  r8  s   @rJ   r_  r_    s         I     @    ^ X    X < < < X< < < < <rI   r_  )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   rq  zOverloadPart | Nonerr  
str | Noners  r\   rt  rT   rU   c                    t                                                       || _        |                                | _        d | _        d | _        d | _        d | _        |r.| 	                    |d         j
        |d         j                   d S d S Nr   )r  rY   r   copyrq  rr  rs  rt  ru  r_   rN   rO   rX   r   r   s     rJ   rY   zOverloadedFuncDef.__init__  s    
 %

	 -1 	:MM%(-q99999	: 	:rI   r   c                ^    | j         r| j         d         j        S | j        J | j        j        S ry  )r   r   rr  r   s    rJ   r   zOverloadedFuncDef.name  s5    : 	":a=%% 9(((9>!rI   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   rh   FT)
ru  	enumerater   rY  r^   rl  is_trivial_selfr   
decoratorsfunc)rX   iitemtrivials       rJ   r  z!OverloadedFuncDef.is_trivial_self  s      ,(( ,, 		 		GAtq55(85aaaG$(( + !,1D) 55! T_%%//ty7P/(-%uu 0 !%trI   rm  c                    | j         d         }t          |t                    sJ |j        j        sJ | j        J | j         | j                 }t          |t                    sJ |S ry  )r   r^   rm  varis_settable_propertyrt  )rX   
first_itemr  s      rJ   setterzOverloadedFuncDef.setter  so     Z]
*i00000~2222 ,,,z$+,$	*****rI   r   r   rd   c                ,    |                     |           S rW   )visit_overloaded_func_defr   s     rJ   r   zOverloadedFuncDef.accept!      00666rI   rf   c           	         dd | j         D             | j        d n| j                                        | j        | j        d n| j                                        t          | t                    | j        | j        dS )Nrp  c                6    g | ]}|                                 S rH   r   )ry   r  s     rJ   r   z/OverloadedFuncDef.serialize.<locals>.<listcomp>'       888akkmm888rI   )r   r   r   r   rr  flagsrs  rt  )	r   r   r   r   rr  	get_flagsr]  rs  rt  r   s    rJ   r   zOverloadedFuncDef.serialize$  s|    )88TZ888 I-DD493F3F3H3H I-DD493F3F3H3Ht^44/ -	
 	
 		
rI   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   rp  c                h    g | ]/}t          t          t                              |                    0S rH   )r   rn  r   r   )ry   ds     rJ   r   z1OverloadedFuncDef.deserialize.<locals>.<listcomp>4  s0    RRRqT,
 6 6q 9 9::RRRrI   r   rr  r   r   r   r  rs  rt  )rp  r   r   rn  r   r   rr  r   r   r_   rN   r   typesdeserialize_typer^   
ProperTyper   r   	set_flagsrs  rt  )r   r   restyps       rJ   r   zOverloadedFuncDef.deserialize0  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+/
rI   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 rW   )r9   OVERLOADED_FUNC_DEFr   r   r   r   r   r   r  write_type_optr   r   r   rr  r"   write_flagsrY  rZ  r[  r\  r7   rs  r3   rt  r   )rX   r   r  s      rJ   r   zOverloadedFuncDef.writeF  s   $+,,,$!!!tS__---J 	 	DJJt
!!$	222$'''9dL))))IOOD!!!D4+T]DNDMZ[[[dDO,,,dD-...$     rI   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 rH   )read_overload_partr   s     rJ   r   z*OverloadedFuncDef.read.<locals>.<listcomp>Z  s"     ^ ^ ^a!3D!9!9 ^ ^ ^rI   r      	num_flags)r/   r   rp  r   r   r   r  read_type_optr^   r  r   r   r   r"   r  rr  r   r   r_   rN   
read_flagsrY  rZ  r[  r\  r-   rs  r)   rt  r   )r   r   r  r  tags    `   rJ   r   zOverloadedFuncDef.readW  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++'--~~((((
rI   c                >    t          d | j        D                       S )Nc              3  >   K   | ]}|                                 V  d S rW   )
is_dynamicry   r  s     rJ   	<genexpr>z/OverloadedFuncDef.is_dynamic.<locals>.<genexpr>n  s,      <<4??$$<<<<<<rI   )allr   r   s    rJ   r  zOverloadedFuncDef.is_dynamicm  s!    <<<<<<<<rI   )r   rv  rT   rU   r   r5  )rT   rm  r   r   )r   rf   rT   rp  r   )r   r#   rT   rp  )rD   rE   rF   rb   rc   r   rY   r   r   r  r  r   r   r   r   r   r   r  r7  r8  s   @rJ   rp  rp    s~         I ((((
: 
: 
: 
: 
: 
: " " " X"    X,    X7 7 7 7

 

 

 

    [*! ! ! !"    [*= = = = = = = =rI   rp  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   rT   rU   c                    t                                                       || _        || _        || _        || _        || _        d S rW   )r  rY   r  r  r  r  r  )rX   r  r  r  r  r  r   s         rJ   rY   zArgument.__init__x  sD     	 .&	 rI   NrZ   r[   rO   r\   rP   rQ   c                B   t                                          ||||           | j        rA| j        j        dk     r1| j                            | j        | j        | j        | j                   | j                            | j        | j        | j        | j                   d S ry  )r  r_   r  rN   rO   rP   rQ   r  )rX   rZ   rO   rP   rQ   r   s        rJ   r_   zArgument.set_line  s     	:>>> 	^ 0 5 9 9%%didmT_]]]ty$+t}doVVVVVrI   F)r  r  r  r  r  r  r  r  r  r   rT   rU   r`   ra   )	rD   rE   rF   rb   rc   r6  rY   r_   r7  r8  s   @rJ   r  r  q  s        **RIWN ! ! ! ! ! ! !$ "#!%W W W W W W W W W W WrI   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  rS   r  r  r  list[mypy.types.Type]r  rT   rU   c                L    || _         || _        || _        || _        || _        d S rW   r  )rX   r   r  r  r  r  s         rJ   rY   zTypeParam.__init__  s,     		&rI   N)r   r   r  rS   r  r  r  r  r  r  rT   rU   )rD   rE   rF   rc   rY   rH   rI   rJ   r  r    s-        DI     rI   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] | NonerT   rU   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 rW   )r  r  r   ry   args     rJ   r   z%FuncItem.__init__.<locals>.<listcomp>  s(    ```##,E$$CL4E```rI   c                    g | ]	}|j         
S rH   )r  r  s     rJ   r   z%FuncItem.__init__.<locals>.<listcomp>  s    (L(L(Lc(L(L(LrI   Fr   rh   )r  rY   r  r  r  countARG_POSARG_OPTr  r  Blockr  r   r`  r  r  r  r  r  r  r  r   r   max_fixed_argc)rX   r  r  r  r  r  r   s         rJ   rY   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	& 	&rI   rS   c                    | j         S rW   )r  r   s    rJ   r  zFuncItem.max_fixed_argc  s
    |rI   r   c                    | j         d u S rW   r   r   s    rJ   r  zFuncItem.is_dynamic  s    yD  rI   )NNNN)
r  r  r  r  r  r  r  r  rT   rU   )rT   rS   r5  )
rD   rE   rF   rb   rc   __deletable__rY   r  r  r7  r8  s   @rJ   r  r    s        CCI$ 9M ,0!.2,0& & & & & & &8   ! ! ! ! ! ! ! !rI   r  )is_decoratedis_conditionalis_trivial_bodyr  r=  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 )(rl  zQFunction definition.

    This is a non-lambda function defined using 'def'.
    )rz   r  r  abstract_statusoriginal_defr  r  r=  dataclass_transform_spec	docstringrs  original_first_arg)r   r  r   r  r  Nr   r   r  r  r  r  r  r  r  r  rT   rU   c                8   t                                          ||||           || _        d| _        d| _        t
          | _        d| _        d | _        d| _	        d | _
        d | _        d | _        d| _        |r|d         j        j        | _        d S d | _        d S )NFr   )r  rY   rz   r  r  r  r  r  r  r=  r  r  rs  r  r  r   r  )rX   r   r  r  r  r  r   s         rJ   rY   zFuncDef.__init__  s     	D#y999
!#+  %>B!GK%%)&*  %  	+2;A,2G2LD###&*D###rI   c                    | j         S rW   rz   r   s    rJ   r   zFuncDef.name<  
    zrI   r   r   rd   c                ,    |                     |           S rW   )visit_func_defr   s     rJ   r   zFuncDef.accept@      %%d+++rI   rf   c                   d| j         | j        | j        d | j        D             | j        d n| j                                        t          | t                    | j        | j	        d n| j	                                        | j
        | j        dS )Nrl  c                6    g | ]}t          |j                  S rH   rS   valuery   xs     rJ   r   z%FuncDef.serialize.<locals>.<listcomp>O  s     ???1#ag,,???rI   )r   r   r   r  r  r   r  r  r  rs  r  )rz   r   r  r  r   r   r  r  r  r  rs  r  r   s    rJ   r   zFuncDef.serializeC  s      J????? I-DD493F3F3H3Ht]33#3 08 2<<>>/"&"9!
 
 	
rI   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   rl  r   r   r   r  r  r  c                (    g | ]}t           |         S rH   	ARG_KINDSr  s     rJ   r   z'FuncDef.deserialize.<locals>.<listcomp>p  s    AAA!1AAArI   r  r  r  rs  )r  rl  r   r   r  FunctionLiker  r   r  r  r   r  r  r  DataclassTransformSpecr   r  rs  r  r  r  )r   r   r  rets       rJ   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
rI   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 rH   r   ry   aks     rJ   r   z!FuncDef.write.<locals>.<listcomp>  s     EEEc"(mmEEErI   )%r9   FUNC_DEFr   rz   r   r  r  r   r   r  rY  rZ  r[  r\  r  r  r  r  r  r  r  r  r  r=  r8   r  r2   r  r   r  r  r"   r   r7   rs  r  r   r   s     rJ   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$     rI   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 rH   r  r  s     rJ   r   z FuncDef.read.<locals>.<listcomp>  s    EEE22EEErI   ))r   r/   r"   r   r  read_function_likerl  r  r   r  rY  rZ  r[  r\  r  r  r  r  r  r  r  r  r  r=  r.   r  r(   r  r   r  r   r	  r   r  r-   rs  r  r  r  r  r   )r   r   r   r  r  r
  s         rJ   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~~((((
rI   )r  NNNN)r   r   r  r  r  r  r  r  r  r  rT   rU   r   r   r   )r   rf   rT   rl  r   )r   r#   rT   rl  )rD   rE   rF   rb   rc   r6  rY   r   r   r   r   r   r   r   r   r7  r8  s   @rJ   rl  rl    s
        
I  ;N
 +/!.2,0 +  +  +  +  +  +  +D    X, , , ,
 
 
 
4    [@!! !! !! !!F ' ' ' [' ' ' ' 'rI   rl  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 )/rm  zhA decorated function.

    A single Decorator object can include any number of function decorators.
    )r  r  original_decoratorsr  r  )r  r  r  rl  r  list[Expression]r  r  r  r  r   r  rT   rU   c                    t                                                       || _        || _        |                                | _        || _        d| _        d S r@  )r  rY   r  r  rz  r  r  r  )rX   r  r  r  r   s       rJ   rY   zDecorator.__init__  sN    	$#-??#4#4  rI   r   c                    | j         j        S rW   )r  r   r   s    rJ   r   zDecorator.name      y~rI   c                    | j         j        S rW   )r  r   r   s    rJ   r   zDecorator.fullname      y!!rI   c                    | j         j        S rW   )r  r\  r   s    rJ   r\  zDecorator.is_final  r  rI   r   c                    | j         j        S rW   )r  ra  r   s    rJ   ra  zDecorator.info  r  rI   r  c                    | j         j        S rW   )r  r   r   s    rJ   r   zDecorator.type  s    x}rI   r   r   rd   c                ,    |                     |           S rW   )visit_decoratorr   s     rJ   r   zDecorator.accept  r   rI   rf   c                v    d| j                                         | j                                        | j        dS )Nrm  )r   r  r  r  )r  r   r  r  r   s    rJ   r   zDecorator.serialize  s<    !I''))8%%''+	
 
 	
rI   r   c                    |d         dk    sJ t          t                              |d                   g t                              |d                             }|d         |_        |S )Nr   rm  r  r  r  )rm  rl  r   r  r  )r   r   decs      rJ   r   zDecorator.deserialize  s\    H~,,,,++DL992stTY{?[?[\\}-
rI   r%   c                    t          |t                     | j                            |           | j                            |           t          || j                   t          |t                     d S rW   )r9   	DECORATORr  r   r  r0   r  r   r   s     rJ   r   zDecorator.write  sc    $	"""	t4)***$     rI   r#   c                T   t          |          t          k    sJ t                              |          }t          |          t          k    sJ t
                              |          }t          |g |          }t          |          |_        t          |          t          k    sJ |S rW   )
r/   r  rl  r   VARr  rm  r&   r  r   )r   r   r  r  r$  s        rJ   r   zDecorator.read  s    ~~))))||D!!~~$$$$hhtnnb#&&#D//~~((((
rI   c                4    | j                                         S rW   )r  r  r   s    rJ   r  zDecorator.is_dynamic%      y##%%%rI   )r  rl  r  r  r  r  rT   rU   r   r5  )rT   r   rT   r  r   r   )r   rf   rT   rm  r   )r   r#   rT   rm  )rD   rE   rF   rb   rc   r6  r   rY   r   r   r   r\  ra  r   r   r   r   r   r   r   r  r7  r8  s   @rJ   rm  rm    s         
 TI2NMMM    ))))HHH! ! ! ! ! !    X " " " X" " " " X"    X    X- - - -
 
 
 
    [! ! ! !    [& & & & & & & &rI   rm  )is_selfis_clsis_initialized_in_classis_staticmethodis_classmethodrY  r  is_suppressed_importis_classvaris_abstract_varr\  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.
    )rz   r   ra  r   setter_typefinal_valuer,  r-  r8  r9  r.  r/  r0  rY  r  r2  r3  r\  r4  r5  r6  r1  r7  r;  r<  r=  r:  is_argument)r   r   rA  Nr   r   r   r  rT   rU   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  rY   rz   r   VAR_NO_INFOra  r   r@  r,  r-  r8  r9  r.  r/  r0  rY  r  r2  r3  r4  r1  r\  rA  r5  r6  r7  r;  r<  r=  r:  rB  )rX   r   r   r   s      rJ   rY   zVar.__init__i  s   
	,0	;?9, (-$$# $)! $! %*! GK$)!!& #(#(  #(+0( %*! rI   c                    | j         S rW   r  r   s    rJ   r   zVar.name  r  rI   c                    | j         S rW   r  r   s    rJ   r   zVar.fullname  r  rI   c                d    | j         p| j        }d|dt          t          |                      dS )Nz<Var z at >)r   r   hexrM  rX   r   s     rJ   __repr__zVar.__repr__  s5    })	3t333r$xx==3333rI   r   r   rd   c                ,    |                     |           S rW   )	visit_varr   s     rJ   r   z
Var.accept  s      &&&rI   rf   c           	         d| j         | j        | j        d n| j                                        | j        d n| j                                        t          | t                    d}| j        
| j        |d<   |S )Nr  )r   r   r   r   r@  r  rA  )rz   r   r   r   r@  r  r>  rA  r   s     rJ   r   zVar.serialize  s     J I-DD493F3F3H3H#'#3#;44AQA[A[A]A]tY//
 
 '"&"2DrI   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   r@  Fr   r  rA  )r   r  r  r  r^   r  CallableTyper@  r8  r   r  r   rA  )r   r   r   r   r@  vs         rJ   r   zVar.deserialize  s	   H~&&&&F|F|+tt1L1LTRX\1Z1Z M"* D,,T--@AA 	
 dOO+tz'<==  ;
(?@@   $
:&!T']###//rI   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 rW   )!r9   r(  r   rz   r   r  r  r   r@  r   r  r.  r/  r0  rY  r  r1  r2  r3  r\  r4  r5  r6  r7  r8  r9  r:  r;  r<  r=  r5   rA  r   r   s     rJ   r   z	Var.write  s    $$
###
!!$	222
!!$(8999$''',$# )) $!)&' )('0'	
 	
 	
0 	dD,---$     rI   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  r/   r"   CALLABLE_TYPErP  r   r@  r   r  r.  r/  r0  rY  r  r1  r2  r3  r\  r4  r5  r6  r7  r8  r9  r:  r;  r<  r=  r!   complexread_float_barerA  r+   r   )r   r   r   r  rQ  r@  r  s          rJ   r   zVar.read  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~~((((rI   rW   )r   r   r   r  rT   rU   r   r   r   )r   rf   rT   r  r   )r   r#   rT   r  )rD   rE   rF   rb   rc   r6  rY   r   r   r   rK  r   r   r   r   r   r   r7  r8  s   @rJ   r  r  B  s,        
I> 5N9! 9! 9! 9! 9! 9! 9!v    X    X4 4 4 4' ' ' '       [,! ! ! !B & & & [& & & & &rI   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_exprsra  	metaclassr  keywordsanalyzedhas_incompatible_baseclassr  removed_statements)r   r   r   r   r   r  r   r  r  z list[mypy.types.TypeVarLikeType]rZ  r  r[  r\  r   ra  r  r]  r  zdict[str, Expression]r^  r_  r   r`  r  ra  N'list[mypy.types.TypeVarLikeType] | Nonelist[Expression] | None#list[tuple[str, Expression]] | NonerT   rU   c                N   t                                                       || _        d| _        || _        |pg | _        || _        |pg | _        g | _        t          | _
        || _        g | _        |rt          |          ni | _        d | _        d| _        d | _        g | _        d S Nr  F)r  rY   r   r   r   rZ  r  r[  r\  CLASSDEF_NO_INFOra  r]  r  dictr^  r_  r`  r  ra  )	rX   r   r   rZ  r[  r]  r^  r  r   s	           rJ   rY   zClassDef.__init__O  s     			"b".4"')$$	"*2:X*/'%)"$rI   c                    | j         S rW   r  r   s    rJ   r   zClassDef.fullnamej  r  rI   rQ  c                    || _         d S rW   r  rX   rQ  s     rJ   r   zClassDef.fullnamen      rI   r   r   rd   c                ,    |                     |           S rW   )visit_class_defr   s     rJ   r   zClassDef.acceptr  r   rI   c                4    | j                                         S rW   )ra  
is_genericr   s    rJ   rp  zClassDef.is_genericu  r*  rI   rf   c                B    d| j         | j        d | j        D             dS )NrY  c                6    g | ]}|                                 S rH   r  ry   rQ  s     rJ   r   z&ClassDef.serialize.<locals>.<listcomp>  s     @@@A!++--@@@rI   )r   r   r   rZ  )r   r   rZ  r   s    rJ   r   zClassDef.serializex  s3     !I@@@@@	
 
 	
rI   r   c                    |d         dk    sJ t          |d         t          g           d |d         D                       }|d         |_        |S )Nr   rY  r   c                    g | ]>}t          t          j        j        t          j                            |                    ?S rH   )r   r   r  TypeVarLikeTyper  rs  s     rJ   r   z(ClassDef.deserialize.<locals>.<listcomp>  sG        TZ/1L1LQ1O1OPP  rI   rZ  r   )rY  r  r   r   r   r  s      rJ   r   zClassDef.deserialize  sj    H~++++L"II k*  	
 
 J'
rI   r%   c                    t          |t                     t          || j                   t          j                            || j                   t          || j                   t          |t                     d S rW   )
r9   	CLASS_DEFr   r   r   r  write_type_listrZ  r   r   r   s     rJ   r   zClassDef.write  sf    $	"""$	"""
""4888$&&&$     rI   r#   c                    t          t          |          t          g           t          j                            |                    }t          |          |_        t          |          t          k    sJ |S rW   )	rY  r   r  r   r  read_type_var_likesr   r/   r   rw  s      rJ   r   zClassDef.read  sY    x~~uRyy$*2P2PQU2V2VWW~~~~((((
rI   )NNNNN)r   r   r   r  rZ  rb  r[  rc  r]  r  r^  rd  r  r  rT   rU   r   rQ  r   rT   rU   r   r5  r   )r   rf   rT   rY  r   )r   r#   rT   rY  )rD   rE   rF   rb   rc   r6  r   rY   r   r   r  r   rp  r   r   r   r   r   r7  r8  s   @rJ   rY  rY  $  s        I$ &NIIINNNKKK%%%%////%%%%----NNN        ####$$$$'''' >B37'+8<,0% % % % % % %6    X _   _- - - -& & & &
 
 
 
    [! ! ! !    [    rI   rY  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  rT   rU   c                V    t                                                       || _        d S rW   r  rY   r  rX   r  r   s     rJ   rY   zGlobalDecl.__init__  $    


rI   r   r   rd   c                ,    |                     |           S rW   )visit_global_declr   s     rJ   r   zGlobalDecl.accept  rR  rI   r  r  rT   rU   r   rJ  r8  s   @rJ   r  r    so         &&IN     / / / / / / / /rI   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  rT   rU   c                V    t                                                       || _        d S rW   r  r  s     rJ   rY   zNonlocalDecl.__init__  r  rI   r   r   rd   c                ,    |                     |           S rW   )visit_nonlocal_declr   s     rJ   r   zNonlocalDecl.accept      **4000rI   r  r   rJ  r8  s   @rJ   r  r    so         ((IN     1 1 1 1 1 1 1 1rI   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  r;  F)r;  r  r  r;  r   rT   rU   c               d    t                                                       || _        || _        d S rW   )r  rY   r  r;  )rX   r  r;  r   s      rJ   rY   zBlock.__init__  s0    	 -rI   r   r   rd   c                ,    |                     |           S rW   )visit_blockr   s     rJ   r   zBlock.accept  s    ""4(((rI   )r  r  r;  r   rT   rU   r   )rD   rE   rF   rc   r6  rY   r   r7  r8  s   @rJ   r  r    sh        *I/NHM - - - - - - - -) ) ) ) ) ) ) )rI   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  rT   rU   c                V    t                                                       || _        d S rW   r  rY   r  rX   r  r   s     rJ   rY   zExpressionStmt.__init__  $    			rI   r   r   rd   c                ,    |                     |           S rW   )visit_expression_stmtr   s     rJ   r   zExpressionStmt.accept      ,,T222rI   r  r   rT   rU   r   rJ  r8  s   @rJ   r  r    so         99IN     3 3 3 3 3 3 3 3rI   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   r`  
new_syntaxis_alias_defis_final_definvalid_recursive_alias)r  rvaluesr   list[Lvalue]r  r   r  r  r   r`  r   r  r  r  r  NFrT   rU   c                    t                                                       || _        || _        || _        || _        || _        d| _        d| _        d| _	        d S r@  )
r  rY   r  r  r   r`  r  r  r  r  )rX   r  r  r   r  r   s        rJ   rY   zAssignmentStmt.__init__  s]     		#$!!',$$$rI   r   r   rd   c                ,    |                     |           S rW   )visit_assignment_stmtr   s     rJ   r   zAssignmentStmt.accept(  r  rI   r@  )
r  r  r  r   r   r  r  r   rT   rU   r   rJ  r8  s   @rJ   r  r    s          	I 4N    ++++  "!!! (, - - - - - - -"3 3 3 3 3 3 3 3rI   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  rT   rU   c                r    t                                                       || _        || _        || _        d S rW   )r  rY   r  r  r  )rX   r  r  r  r   s       rJ   rY   zOperatorAssignmentStmt.__init__7  s2    rI   r   r   rd   c                ,    |                     |           S rW   )visit_operator_assignment_stmtr   s     rJ   r   zOperatorAssignmentStmt.accept=      55d;;;rI   )r  r   r  r   r  r   rT   rU   r   rJ  r8  s   @rJ   r  r  ,  s         66*I/NGGGNNN     < < < < < < < <rI   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  rT   rU   c                r    t                                                       || _        || _        || _        d S rW   )r  rY   r  r  r  rX   r  r  r  r   s       rJ   rY   zWhileStmt.__init__J  s2    		"rI   r   r   rd   c                ,    |                     |           S rW   )visit_while_stmtr   s     rJ   r   zWhileStmt.acceptP  rX  rI   )r  r   r  r  r  r  rT   rU   r   	rD   rE   rF   rc   r6  r   rY   r   r7  r8  s   @rJ   r  r  A  s~         -I2NKKK# # # # # #. . . . . . . .rI   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  NrT   rU   c                    t                                                       || _        || _        || _        d | _        d | _        || _        || _        || _	        d| _
        d S r@  )r  rY   r  r  r  r  r  r  r  r  r  )rX   r  r  r  r  r  r   s         rJ   rY   zForStmt.__init__s  sa     	
$%/""&&*#		"rI   r   r   rd   c                ,    |                     |           S rW   )visit_for_stmtr   s     rJ   r   zForStmt.accept  r  rI   rW   )r  r   r  r   r  r  r  r  r  r  rT   rU   r   r  r8  s   @rJ   r  r  T  s         
I JN MMM&&&&1111....2222KKKNNN .2      &, , , , , , , ,rI   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  rT   rU   c                V    t                                                       || _        d S rW   r  r  s     rJ   rY   zReturnStmt.__init__  r  rI   r   r   rd   c                ,    |                     |           S rW   )visit_return_stmtr   s     rJ   r   zReturnStmt.accept  rR  rI   r  r  rT   rU   r   r  r8  s   @rJ   r  r    si         IN     / / / / / / / /rI   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  NrT   rU   c                d    t                                                       || _        || _        d S rW   )r  rY   r  r  )rX   r  r  r   s      rJ   rY   zAssertStmt.__init__  s+    	rI   r   r   rd   c                ,    |                     |           S rW   )visit_assert_stmtr   s     rJ   r   zAssertStmt.accept  rR  rI   rW   )r  r   r  r  rT   rU   r   r  r8  s   @rJ   r  r    sz         I$N      
/ / / / / / / /rI   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  rT   rU   c                V    t                                                       || _        d S rW   r  r  s     rJ   rY   zDelStmt.__init__  r  rI   r   r   rd   c                ,    |                     |           S rW   )visit_del_stmtr   s     rJ   r   zDelStmt.accept  r  rI   )r  r   rT   rU   r   r  r8  s   @rJ   r  r    sf         INLLL     , , , , , , , ,rI   r  c                      e Zd ZdZddZdS )		BreakStmtrH   r   r   rT   rd   c                ,    |                     |           S rW   )visit_break_stmtr   s     rJ   r   zBreakStmt.accept  rX  rI   Nr   rD   rE   rF   rc   r   rH   rI   rJ   r  r    s-        I. . . . . .rI   r  c                      e Zd ZdZddZdS )	ContinueStmtrH   r   r   rT   rd   c                ,    |                     |           S rW   )visit_continue_stmtr   s     rJ   r   zContinueStmt.accept  r  rI   Nr   r  rH   rI   rJ   r  r    s-        I1 1 1 1 1 1rI   r  c                      e Zd ZdZddZdS )	PassStmtrH   r   r   rT   rd   c                ,    |                     |           S rW   )visit_pass_stmtr   s     rJ   r   zPassStmt.accept  r   rI   Nr   r  rH   rI   rJ   r  r    s-        I- - - - - -rI   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  rT   rU   c                    t                                                       || _        || _        || _        d| _        d S r@  )r  rY   r  r  r  r  r  s       rJ   rY   zIfStmt.__init__  s<    		" %rI   r   r   rd   c                ,    |                     |           S rW   )visit_if_stmtr   s     rJ   r   zIfStmt.accept      $$T***rI   )r  r  r  r  r  r  rT   rU   r   r  r8  s   @rJ   r  r    s         AIFN & & & & & &+ + + + + + + +rI   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  rT   rU   c                d    t                                                       || _        || _        d S rW   )r  rY   r  r  )rX   r  r  r   s      rJ   rY   zRaiseStmt.__init__  s+    	"rI   r   r   rd   c                ,    |                     |           S rW   )visit_raise_stmtr   s     rJ   r   zRaiseStmt.accept  rX  rI   )r  r  r  r  rT   rU   r   r  r8  s   @rJ   r  r    sw         %I*N     # # # # # #
. . . . . . . .rI   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  rT   rU   c                    t                                                       || _        || _        || _        || _        || _        || _        d| _        d S r@  )	r  rY   r  r  r  r  r  r  r  )rX   r  r  r  r  r  r  r   s          rJ   rY   zTryStmt.__init__	  sQ     			
 "(rI   r   r   rd   c                ,    |                     |           S rW   )visit_try_stmtr   s     rJ   r   zTryStmt.accept  r  rI   )r  r  r  r  r  r  r  r  r  r  r  r  rT   rU   r   r  r8  s   @rJ   r  r    s         ]IbNKKK""""MMM     $, , , , , , , ,rI   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  rZ   r`  analyzed_typesr  r  )r  rZ   r  r  r  list[Lvalue | None]rZ   r  r`  r  r   r  r  r   r  Ntarget_typerT   rU   c                    t                                                       || _        || _        || _        g | _        || _        d| _        d S r@  )r  rY   r  rZ   r`  r   r  r  )rX   r  rZ   r  r  r   s        rJ   rY   zWithStmt.__init__-  sK     		* 	rI   r   r   rd   c                ,    |                     |           S rW   )visit_with_stmtr   s     rJ   r   zWithStmt.accept<  r   rI   rW   )
r  r  rZ   r  r  r  r  r  rT   rU   r   r  r8  s   @rJ   r  r    s         [I/N++++))))KKKNNN /3      - - - - - - - -rI   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  rT   rU   c                    t                                                       t          |          t          |          cxk    rt          |          k    sn J || _        d | _        || _        || _        || _        d S rW   )r  rY   r   r  r	  r
  r  r  )rX   r  r
  r  r  r   s        rJ   rY   zMatchStmt.__init__K  sz     	8}}F::::s6{{::::::! rI   r   r   rd   c                ,    |                     |           S rW   )visit_match_stmtr   s     rJ   r   zMatchStmt.acceptZ  rX  rI   )
r  r   r
  r  r  r  r  r  rT   rU   r   r  r8  s   @rJ   r  r  @  s         LI@N""""####     . . . . . . . .rI   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  rT   rU   c                    t                                                       || _        || _        || _        d| _        d | _        d S r@  )r  rY   r   r  r  r  r  )rX   r   r  r  r   s       rJ   rY   zTypeAliasStmt.__init__i  sA    	"
',$rI   r   r   rd   c                ,    |                     |           S rW   )visit_type_alias_stmtr   s     rJ   r   zTypeAliasStmt.acceptq  r  rI   )r   r  r  r  r  r  rT   rU   r   r  r8  s   @rJ   r  r  ^  s         WI3NNNN!!!!         3 3 3 3 3 3 3 3rI   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  rS   r  rT   rU   c                V    t                                                       || _        d S rW   r  rY   r  rX   r  r   s     rJ   rY   zIntExpr.__init__  r  rI   r   r   rd   c                ,    |                     |           S rW   )visit_int_exprr   s     rJ   r   zIntExpr.accept  r  rI   )r  rS   rT   rU   r   rJ  r8  s   @rJ   r  r  x  sl         INJJJ     , , , , , , , ,rI   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 )StrExprzString literal)r  as_typer  r   r  "NotParsed | mypy.types.Type | Noner%  rT   rU   c                x    t                                                       || _        t          j        | _        d S rW   )r  rY   r  rC   rG   r%  r   s     rJ   rY   zStrExpr.__init__  s-    
 rI   r   r   rd   c                ,    |                     |           S rW   )visit_str_exprr   s     rJ   r   zStrExpr.accept  r  rI   r  r   rT   rU   r   rJ  r8  s   @rJ   r$  r$    sz         $INJJJ 0///' ' ' ' ' '
, , , , , , , ,rI   r$  seqr  rT   TypeGuard[list[StrExpr]]c                4    t          d | D                       S )Nc              3  @   K   | ]}t          |t                    V  d S rW   )r^   r$  r  s     rJ   r  z"is_StrExpr_list.<locals>.<genexpr>  s,      99Tz$((999999rI   )r  )r+  s    rJ   is_StrExpr_listr/    s    99S999999rI   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 literalr  r   r  rT   rU   c                V    t                                                       || _        d S rW   r  r   s     rJ   rY   zBytesExpr.__init__  r  rI   r   r   rd   c                ,    |                     |           S rW   )visit_bytes_exprr   s     rJ   r   zBytesExpr.accept  rX  rI   r*  r   rJ  r8  s   @rJ   r1  r1    sn         IN JJJ     . . . . . . . .rI   r1  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 literalr  floatr  rT   rU   c                V    t                                                       || _        d S rW   r  r   s     rJ   rY   zFloatExpr.__init__  r  rI   r   r   rd   c                ,    |                     |           S rW   )visit_float_exprr   s     rJ   r   zFloatExpr.accept  rX  rI   )r  r7  rT   rU   r   rJ  r8  s   @rJ   r6  r6    sl         INLLL     . . . . . . . .rI   r6  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 literalr  rV  r  rT   rU   c                V    t                                                       || _        d S rW   r  r   s     rJ   rY   zComplexExpr.__init__  r  rI   r   r   rd   c                ,    |                     |           S rW   )visit_complex_exprr   s     rJ   r   zComplexExpr.accept      ))$///rI   )r  rV  rT   rU   r   rJ  r8  s   @rJ   r<  r<    sl         INNNN     0 0 0 0 0 0 0 0rI   r<  c                      e Zd ZdZdZd	dZdS )
EllipsisExprzEllipsis (...)rH   r   r   rT   rd   c                ,    |                     |           S rW   )visit_ellipsisr   s     rJ   r   zEllipsisExpr.accept  r  rI   Nr   r   rH   rI   rJ   rB  rB    s3        I, , , , , ,rI   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 )StarExprzStar expression)r  validr   r  r   rG  rT   rU   c                d    t                                                       || _        d| _        d S r@  )r  rY   r  rG  r  s     rJ   rY   zStarExpr.__init__  s-    	 


rI   r   r   rd   c                ,    |                     |           S rW   )visit_star_exprr   s     rJ   r   zStarExpr.accept  r   rI   r  r   rJ  r8  s   @rJ   rF  rF    sx         !I&NKKK     - - - - - - - -rI   rF  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_isrT   rU   c                    t                                                       d | _        d | _        d| _        d| _        d| _        d| _        d | _        d | _	        d S rf  )
r  rY   r  rM  r   rN  rO  rP  rQ  rR  rA  s    rJ   rY   zRefExpr.__init__	  sY     $	'+	
  %$26/3rI   r   c                    | j         S rW   r  r   s    rJ   r   zRefExpr.fullname'	  r  rI   rQ  c                    || _         d S rW   r  rk  s     rJ   r   zRefExpr.fullname+	  rl  rI   rB  r   r}  )
rD   rE   rF   rb   rc   rY   r   r   r  r7  r8  s   @rJ   rL  rL  	  s        66	I4 4 4 4 4 4,    X _   _    rI   rL  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   rM  r   r   rT   rU   c                d    t                                                       || _        d| _        d S r@  )r  rY   r   rW  )rX   r   r   s     rJ   rY   zNameExpr.__init__:	  s.    	$rI   r   r   rd   c                ,    |                     |           S rW   )visit_name_exprr   s     rJ   r   zNameExpr.accept@	  r   rI   rf   c                    J d|              )NFzSerializing NameExpr: rH   r   s    rJ   r   zNameExpr.serializeC	  s    55t55555rI   )r   r   rT   rU   r   r   )
rD   rE   rF   rb   rc   r6  rY   r   r   r7  r8  s   @rJ   r  r  0	  s{         
 ,I%N% % % % % %- - - -6 6 6 6 6 6 6 6rI   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   rM  r  r   r   r   rT   rU   c                r    t                                                       || _        || _        d | _        d S rW   )r  rY   r  r   r^  )rX   r  r   r   s      rJ   rY   zMemberExpr.__init__N	  s4    		 $(rI   r   r   rd   c                ,    |                     |           S rW   )visit_member_exprr   s     rJ   r   zMemberExpr.acceptV	  rR  rI   )r  r   r   r   rT   rU   r   	rD   rE   rF   rb   rc   r6  rY   r   r7  r8  s   @rJ   r]  r]  G	  sa        &&+I-N( ( ( ( ( (/ / / / / / / /rI   r]  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   rh   rj   rl   r     Fstarr   rT   c                H    | t           k    p| t          k    p|o
| t          k    S rW   )r  r  ARG_STARrX   re  s     rJ   is_positionalzArgKind.is_positionalj	  s$    wP$'/Pd6Otx?OPrI   c                H    | t           k    p| t          k    p|o
| t          k    S rW   )	ARG_NAMEDARG_NAMED_OPT	ARG_STAR2rh  s     rJ   is_namedzArgKind.is_namedm	  s&    y YDM$9Yd>XtyGXYrI   c                .    | t           k    p
| t          k    S rW   )r  rk  r   s    rJ   is_requiredzArgKind.is_requiredp	  s    w3$)"33rI   c                .    | t           k    p
| t          k    S rW   )r  rl  r   s    rJ   is_optionalzArgKind.is_optionals	  s    w7$-"77rI   c                .    | t           k    p
| t          k    S rW   )rg  rm  r   s    rJ   r  zArgKind.is_starv	  s    x449#44rI   Nr  )re  r   rT   r   r5  )rD   rE   rF   r  r  rg  rk  rm  rl  ri  rn  rp  rr  r  rH   rI   rJ   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 5rI   r  r  r  rg  rk  rm  rl  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  r_  )rv  rw  r  r  Nrv  r   rw  r  r  list[ArgKind]r  list[str | None]r_  r  rT   rU   c                    t                                                       |sd gt          |          z  }|| _        || _        || _        || _        || _        d S rW   )r  rY   r   rv  rw  r  r  r_  )rX   rv  rw  r  r  r_  r   s         rJ   rY   zCallExpr.__init__	  s^     	 	+T*I	"+4 !rI   r   r   rd   c                ,    |                     |           S rW   )visit_call_exprr   s     rJ   r   zCallExpr.accept	  r   rI   rW   )rv  r   rw  r  r  rx  r  ry  r_  r  rT   rU   r   rb  r8  s   @rJ   ru  ru  	  sr          IIAN '+! ! ! ! ! ! !*- - - - - - - -rI   ru  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  rT   rU   c                V    t                                                       || _        d S rW   r  r  s     rJ   rY   zYieldFromExpr.__init__	  r  rI   r   r   rd   c                ,    |                     |           S rW   )visit_yield_from_exprr   s     rJ   r   zYieldFromExpr.accept	  r  rI   r  r   r  r8  s   @rJ   r~  r~  	  si         IN     3 3 3 3 3 3 3 3rI   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  rT   rU   c                V    t                                                       || _        d S rW   r  r  s     rJ   rY   zYieldExpr.__init__	  r  rI   r   r   rd   c                ,    |                     |           S rW   )visit_yield_exprr   s     rJ   r   zYieldExpr.accept	  rX  rI   r  r   r  r8  s   @rJ   r  r  	  si         IN     . . . . . . . .rI   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_typer_  r%  )r  r  r   r  r  r  r  z&TypeApplication | TypeAliasExpr | Noner_  r&  r%  rT   rU   c                    t                                                       || _        || _        d | _        d | _        t          j        | _        d S rW   )	r  rY   r  r  r  r_  rC   rG   r%  )rX   r  r  r   s      rJ   rY   zIndexExpr.__init__	  sC    	
 rI   r   r   rd   c                ,    |                     |           S rW   )visit_index_exprr   s     rJ   r   zIndexExpr.accept	  rX  rI   )r  r   r  r   rT   rU   r   rJ  r8  s   @rJ   r  r  	  s          
 HI&N'''' 5444 0///' ' ' ' ' '. . . . . . . .rI   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  rT   rU   c                r    t                                                       || _        || _        d | _        d S rW   )r  rY   r  r  r  )rX   r  r  r   s      rJ   rY   zUnaryExpr.__init__	  s5    	rI   r   r   rd   c                ,    |                     |           S rW   )visit_unary_exprr   s     rJ   r   zUnaryExpr.accept	  rX  rI   )r  r   r  r   rT   rU   r   rJ  r8  s   @rJ   r  r  	  s         -I#NGGG''''           . . . . . . . .rI   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".)rZ   r  rZ   r  r  r   rT   rU   c                d    t                                                       || _        || _        d S rW   )r  rY   rZ   r  )rX   rZ   r  r   s      rJ   rY   zAssignmentExpr.__init__
  s+    


rI   r   r   rd   c                ,    |                     |           S rW   )visit_assignment_exprr   s     rJ   r   zAssignmentExpr.accept

  r  rI   )rZ   r  r  r   rT   rU   r   rb  r8  s   @rJ   r  r  	  sa        ??#I(N     
3 3 3 3 3 3 3 3rI   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_unreachabler_  r%  )r  r  r  r   r  r   r  r  r  r  r   r  r  TypeAliasExpr | Noner_  r&  r%  NrT   rU   c                    t                                                       || _        || _        || _        d | _        d| _        d| _        || _        t          j
        | _        d S r@  )r  rY   r  r  r  r  r  r  r_  rC   rG   r%  )rX   r  r  r  r_  r   s        rJ   rY   zOpExpr.__init__1
  s\     		
!!&  rI   r   r   rd   c                ,    |                     |           S rW   )visit_op_exprr   s     rJ   r   zOpExpr.accept>
  r  rI   rW   )
r  r   r  r   r  r   r_  r  rT   rU   r   rJ  r8  s   @rJ   r  r  
  s          
	I -NGGG''''"""" 0/// ^b' ' ' ' ' ' '+ + + + + + + +rI   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  rT   rU   c                r    t                                                       || _        || _        g | _        d S rW   )r  rY   r  r  r  )rX   r  r  r   s      rJ   rY   zComparisonExpr.__init__U
  s5    " rI   ,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)
        rh   N)r~  r  r  )rX   r  operators      rJ   pairwisezComparisonExpr.pairwise[
  s[       %T^44 	C 	CKAxDM!,dmAE.BBBBBB	C 	CrI   r   r   rd   c                ,    |                     |           S rW   )visit_comparison_exprr   s     rJ   r   zComparisonExpr.acceptb
  r  rI   )r  r  r  r  rT   rU   )rT   r  r   )rD   rE   rF   rb   rc   r6  r   rY   r  r   r7  r8  s   @rJ   r  r  I
  s         559I.N....     C C C C3 3 3 3 3 3 3 3rI   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  rT   rU   c                r    t                                                       || _        || _        || _        d S rW   )r  rY   r  r  r  )rX   r  r  r  r   s       rJ   rY   zSliceExpr.__init__t
  s5     	&"rI   r   r   rd   c                ,    |                     |           S rW   )visit_slice_exprr   s     rJ   r   zSliceExpr.accept
  rX  rI   )r  r  r  r  r  r  rT   rU   r   rJ  r8  s   @rJ   r  r  f
  s          
 7I;N""""    	 	 	 	 	 	. . . . . . . .rI   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  rT   rU   c                d    t                                                       || _        || _        d S rW   r  rY   r  r   rX   r  r  r   s      rJ   rY   zCastExpr.__init__
  +    				rI   r   r   rd   c                ,    |                     |           S rW   )visit_cast_exprr   s     rJ   r   zCastExpr.accept
  r   rI   r  r   r  r  rT   rU   r   rJ  r8  s   @rJ   r  r  
  s{         ++ I%N     
- - - - - - - -rI   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  rT   rU   c                V    t                                                       || _        d S rW   r  rY   r   )rX   r  r   s     rJ   rY   zTypeFormExpr.__init__
  s$    			rI   r   r   rd   c                ,    |                     |           S rW   )visit_type_form_exprr   s     rJ   r   zTypeFormExpr.accept
      ++D111rI   )r  r  rT   rU   r   rJ  r8  s   @rJ   r  r  
  so         $$IN     2 2 2 2 2 2 2 2rI   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  rT   rU   c                d    t                                                       || _        || _        d S rW   r  r  s      rJ   rY   zAssertTypeExpr.__init__
  r  rI   r   r   rd   c                ,    |                     |           S rW   )visit_assert_type_exprr   s     rJ   r   zAssertTypeExpr.accept
      --d333rI   r  r   rJ  r8  s   @rJ   r  r  
  s{         ;; I%N     
4 4 4 4 4 4 4 4rI   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  rS   r  list[Var] | Noner  NFr  r   rT   rU   c                    t                                                       || _        || _        || _        || _        d S rW   )r  rY   r  r  r  r  )rX   r  r  r  r  r   s        rJ   rY   zRevealExpr.__init__
  s?     			&&rI   r   r   rd   c                ,    |                     |           S rW   )visit_reveal_exprr   s     rJ   r   zRevealExpr.accept
  rR  rI   )NNF)
r  rS   r  r  r  r  r  r   rT   rU   r   rJ  r8  s   @rJ   r  r  
  s         QQ>ICNIII!!!!
 #'(,!' ' ' ' ' ' '/ / / / / / / /rI   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   ra  call)r   r  ra  r   r   TypeInfo | Nonera  ru  r  rT   rU   c                r    t                                                       || _        || _        d | _        d S rW   )r  rY   r   r  ra  )rX   r   r  r   s      rJ   rY   zSuperExpr.__init__
  s2    					rI   r   r   rd   c                ,    |                     |           S rW   )visit_super_exprr   s     rJ   r   zSuperExpr.accept
  rX  rI   )r   r   r  ru  rT   rU   r   rJ  r8  s   @rJ   r  r  
  s         !!(I-NIIINNN     . . . . . . . .rI   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  rT   r   c                    t           S rW   )r   r   s    rJ   r   zLambdaExpr.name
  s    rI   r   c                n    | j         j         d         }t          |t                    sJ |j        }|J |S )z/Return the expression (the body) of the lambda.rR   )r  r^   r  r  )rX   r
  r  s      rJ   r  zLambdaExpr.expr
  s>    inR #z*****xrI   r   r   rd   c                ,    |                     |           S rW   )visit_lambda_exprr   s     rJ   r   zLambdaExpr.accept
  rR  rI   r   c                    dS r@  rH   r   s    rJ   r  zLambdaExpr.is_dynamic
  s    urI   Nr   )rT   r   r   r5  )
rD   rE   rF   rb   r6  r   r   r  r   r  rH   rI   rJ   r  r  
  sy        DN   X   / / / /     rI   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   rT   rU   c                V    t                                                       || _        d S rW   r  rY   r   r{  s     rJ   rY   zListExpr.__init__  r  rI   r   r   rd   c                ,    |                     |           S rW   )visit_list_exprr   s     rJ   r   zListExpr.accept  r   rI   r   r  rT   rU   r   rJ  r8  s   @rJ   r  r    so         ((IN     - - - - - - - -rI   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   rT   rU   c                V    t                                                       || _        d S rW   r  r{  s     rJ   rY   zDictExpr.__init__  r  rI   r   r   rd   c                ,    |                     |           S rW   )visit_dict_exprr   s     rJ   r   zDictExpr.accept!  r   rI   )r   r  rT   rU   r   rJ  r8  s   @rJ   r  r    so         ::IN5555     - - - - - - - -rI   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   rT   rU   c                V    t                                                       || _        d S rW   r  r{  s     rJ   rY   zTemplateStrExpr.__init__2  s&     	


rI   r   r   rd   c                ,    |                     |           S rW   )visit_template_str_exprr   s     rJ   r   zTemplateStrExpr.accept8      ..t444rI   )r   r  rT   rU   r   rJ  r8  s   @rJ   r  r  %  sr         ,,IN TSSS     5 5 5 5 5 5 5 5rI   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   rT   rU   c                V    t                                                       || _        d S rW   r  r{  s     rJ   rY   zTupleExpr.__init__G  r  rI   r   r   rd   c                ,    |                     |           S rW   )visit_tuple_exprr   s     rJ   r   zTupleExpr.acceptK  rX  rI   r  r   rJ  r8  s   @rJ   r  r  <  su         7 7 IN     . . . . . . . .rI   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   rT   rU   c                V    t                                                       || _        d S rW   r  r{  s     rJ   rY   zSetExpr.__init__X  r  rI   r   r   rd   c                ,    |                     |           S rW   )visit_set_exprr   s     rJ   r   zSetExpr.accept\  r  rI   r  r   rJ  r8  s   @rJ   r  r  O  so         ..IN     , , , , , , , ,rI   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  rT   rU   c                    t                                                       || _        || _        || _        || _        || _        d S rW   )r  rY   r  r  r  r  r  )rX   r  r  r  r  r  r   s         rJ   rY   zGeneratorExpr.__init__m  sB     	""" rI   r   r   rd   c                ,    |                     |           S rW   )visit_generator_exprr   s     rJ   r   zGeneratorExpr.accept|  r  rI   )r  r   r  r  r  r  r  r  r  r	  rT   rU   r   rJ  r8  s   @rJ   r  r  `  s         QQNIGN%%%%! ! ! ! ! !2 2 2 2 2 2 2 2rI   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  rT   rU   c                V    t                                                       || _        d S rW   r  rY   r  rX   r  r   s     rJ   rY   zListComprehension.__init__  $    "rI   r   r   rd   c                ,    |                     |           S rW   )visit_list_comprehensionr   s     rJ   r   zListComprehension.accept  s    //555rI   r  r  rT   rU   r   rJ  r8  s   @rJ   r  r    so         66I#N# # # # # #6 6 6 6 6 6 6 6rI   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  rT   rU   c                V    t                                                       || _        d S rW   r  r  s     rJ   rY   zSetComprehension.__init__  r  rI   r   r   rd   c                ,    |                     |           S rW   )visit_set_comprehensionr   s     rJ   r   zSetComprehension.accept  r  rI   r  r   rJ  r8  s   @rJ   r  r    so         55I#N# # # # # #5 5 5 5 5 5 5 5rI   r  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  )r  r  r  r  r  r   r  r  r  r  r  r  r	  r  r  r  rT   rU   c                    t                                                       || _        || _        || _        || _        || _        || _        d S rW   )r  rY   r  r  r  r  r  r  )rX   r  r  r  r  r  r  r   s          rJ   rY   z DictionaryComprehension.__init__  sI     	
"" rI   r   r   rd   c                ,    |                     |           S rW   )visit_dictionary_comprehensionr   s     rJ   r   zDictionaryComprehension.accept  r  rI   )r  r   r  r   r  r  r  r  r  r  r  r	  rT   rU   r   rJ  r8  s   @rJ   r  r    s         ==QIJNOOO%%%%! ! ! ! ! !"< < < < < < < <rI   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 )ConditionalExprz+Conditional expression (e.g. x if y else z))condif_expr	else_expr)r&  r%  r'  r   r%  r&  r'  rT   rU   c                r    t                                                       || _        || _        || _        d S rW   )r  rY   r%  r&  r'  )rX   r%  r&  r'  r   s       rJ   rY   zConditionalExpr.__init__  s2    	"rI   r   r   rd   c                ,    |                     |           S rW   )visit_conditional_exprr   s     rJ   r   zConditionalExpr.accept  r  rI   )r%  r   r&  r   r'  r   rT   rU   r   rJ  r8  s   @rJ   r$  r$    s         550I5N# # # # # #4 4 4 4 4 4 4 4rI   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  rT   rU   c                d    t                                                       || _        || _        d S rW   )r  rY   r  r  )rX   r  r  r   s      rJ   rY   zTypeApplication.__init__  s+    	


rI   r   r   rd   c                ,    |                     |           S rW   )visit_type_applicationr   s     rJ   r   zTypeApplication.accept  r  rI   )r  r   r  r  rT   rU   r   rJ  r8  s   @rJ   r,  r,    s{         **!I&N         
4 4 4 4 4 4 4 4rI   r,  	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.
    )rz   r   r  r  varianceis_new_styler   rz   r   r  r  r  rS   r6  FrR   r   r   r7  r   rN   rT   rU   c                    t                                          |           || _        || _        || _        || _        || _        || _        d S N)rN   )r  rY   rz   r   r  r  r6  r7  )	rX   r   r   r  r  r6  r7  rN   r   s	           rJ   rY   zTypeVarLikeExpr.__init__  sR     	d###
!& (rI   c                    | j         S rW   r  r   s    rJ   r   zTypeVarLikeExpr.name$  r  rI   c                    | j         S rW   r  r   s    rJ   r   zTypeVarLikeExpr.fullname(  r  rI   )r   r   r   r   r  r  r  r  r6  rS   r7  r   rN   rS   rT   rU   r   )rD   rE   rF   rb   rc   r   r0  rY   r   r   r   r7  r8  s   @rJ   r5  r5    s          
 ]IJJJNNN !    
 MMM "") ) ) ) ) ) )$    X    X    rI   r5  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  FrR   r   r   r   r  r  r  r6  rS   r7  r   rN   rT   rU   c	           	     f    t                                          |||||||           || _        d S r9  )r  rY   r  )
rX   r   r   r  r  r  r6  r7  rN   r   s
            rJ   rY   zTypeVarExpr.__init__F  s8     	xgx\`aaarI   r   r   rd   c                ,    |                     |           S rW   )visit_type_var_exprr   s     rJ   r   zTypeVarExpr.acceptT  r  rI   rf   c                    d| j         | j        d | j        D             | j                                        | j                                        | j        dS )Nr>  c                6    g | ]}|                                 S rH   r  ry   ts     rJ   r   z)TypeVarExpr.serialize.<locals>.<listcomp>\  s     :::q{{}}:::rI   )r   r   r   r  r  r  r6  )rz   r   r  r  r   r  r6  r   s    rJ   r   zTypeVarExpr.serializeW  sY    #J::dk:::+5577|--//
 
 	
rI   r   c           
        |d         dk    sJ t          |d         |d         d |d         D             t          j                            |d                   t          j                            |d                   |d	                   S )
Nr   r>  r   r   c                L    g | ]!}t           j                            |          "S rH   r   r  r  rs  s     rJ   r   z+TypeVarExpr.deserialize.<locals>.<listcomp>h  s(    DDDTZ((++DDDrI   r  r  r  r6  )r>  r   r  r  r   s     rJ   r   zTypeVarExpr.deserializeb  s    H~....LDDT(^DDDJ''](;<<J''Y88
 
 	
rI   r%   c                   t          |t                     t          || j                   t          || j                   t
          j                            || j                   | j	        
                    |           | j        
                    |           t          || j                   t          |t                     d S rW   )r9   TYPE_VAR_EXPRr   rz   r   r   r  rz  r  r  r   r  r   r6  r   r   s     rJ   r   zTypeVarExpr.writen  s    $&&&$
###$'''
""4555t$$$4   $&&&$     rI   r#   c           
     ^   t          t          |          t          |          t          j                            |          t          j                            |          t          j                            |          t          |                    }t          |          t          k    sJ |S rW   )	r>  r   r   r  read_type_list	read_typer   r/   r   r   r   r
  s      rJ   r   zTypeVarExpr.readx  s    TNNTNNJ%%d++J  &&J  &&TNN
 
 ~~((((
rI   )r   r   r   r   r  r  r  r  r  r  r6  rS   r7  r   rN   rS   rT   rU   r   r   )r   rf   rT   r>  r   )r   r#   rT   r>  )rD   rE   rF   rb   rc   r6  r   r0  rY   r   r   r   r   r   r   r7  r8  s   @rJ   r>  r>  2  s         	 	 IAN "!!! ""      1 1 1 1	
 	
 	
 	
 	
 	
 	
 [	
! ! ! ! 
 
 
 [
 
 
 
 
rI   r>  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 )ParamSpecExprrH   r   r  r  r   r   rT   rd   c                ,    |                     |           S rW   )visit_paramspec_exprr   s     rJ   r   zParamSpecExpr.accept  r  rI   rf   c                    d| j         | j        | j                                        | j                                        | j        dS )NrP  )r   r   r   r  r  r6  )rz   r   r  r   r  r6  r   s    rJ   r   zParamSpecExpr.serialize  sF    %J+5577|--//
 
 	
rI   r   c           	         |d         dk    sJ t          |d         |d         t          j                            |d                   t          j                            |d                   |d                   S )Nr   rP  r   r   r  r  r6  )rP  r   r  r  r   s     rJ   r   zParamSpecExpr.deserialize  so    H~0000LJ''](;<<J''Y88
 
 	
rI   r%   rU   c                @   t          |t                     t          || j                   t          || j                   | j                            |           | j                            |           t          || j	                   t          |t                     d S rW   )r9   PARAM_SPEC_EXPRr   rz   r   r  r   r  r   r6  r   r   s     rJ   r   zParamSpecExpr.write  s    $((($
###$'''t$$$4   $&&&$     rI   r#   c           	     "   t          t          |          t          |          t          j                            |          t          j                            |          t          |                    }t          |          t          k    sJ |S rW   )rP  r   r   r  rM  r   r/   r   rN  s      rJ   r   zParamSpecExpr.read  sp    TNNTNNJ  &&J  &&TNN
 
 ~~((((
rI   Nr   r   )r   rf   rT   rP  r   )r   r#   rT   rP  )rD   rE   rF   rc   r6  r   r   r   r   r   r   rH   rI   rJ   rP  rP    s        I7N2 2 2 2
 
 
 
 
 
 
 [
! ! ! ! 	 	 	 [	 	 	rI   rP  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.InstancerQ  FrR   r   r   r   r  r  r  r6  rS   r7  r   rN   rT   rU   c	           	     f    t                                          |||||||           || _        d S r9  )r  rY   r[  )
rX   r   r   r  r[  r  r6  r7  rN   r   s
            rJ   rY   zTypeVarTupleExpr.__init__  s;     	xgx\`aaa,rI   r   r   rd   c                ,    |                     |           S rW   )visit_type_var_tuple_exprr   s     rJ   r   zTypeVarTupleExpr.accept  r  rI   rf   c                    d| j         | j        | j                                        | j                                        | j                                        | j        dS )NrZ  )r   r   r   r  r[  r  r6  )rz   r   r  r   r[  r  r6  r   s    rJ   r   zTypeVarTupleExpr.serialize  sX    (J+5577"1;;==|--//
 
 	
rI   r   c           
     F   |d         dk    sJ t          |d         |d         t          j                            |d                   t          j        j                            |d                   t          j                            |d                   |d                   S )	Nr   rZ  r   r   r  r[  r  r6  )rZ  r   r  r  Instancer   r   s     rJ   r   zTypeVarTupleExpr.deserialize  s    H~!33333LJ''](;<<J++D1A,BCCJ''Y88
 
 	
rI   r%   c                t   t          |t                     | j                            |           t	          || j                   t	          || j                   | j                            |           | j                            |           t          || j
                   t          |t                     d S rW   )r9   TYPE_VAR_TUPLE_EXPRr[  r   r   rz   r   r  r  r   r6  r   r   s     rJ   r   zTypeVarTupleExpr.write  s    $+,,,!!$'''$
###$'''t$$$4   $&&&$     rI   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 rW   )r/   r   r  INSTANCErb  r   rZ  r   rM  r   r   )r   r   fallbackr
  s       rJ   r   zTypeVarTupleExpr.read  s    ~~!44444:&++D11TNNTNNJ  &&J  &&TNN
 
 ~~((((
rI   )r   r   r   r   r  r  r[  r\  r  r  r6  rS   r7  r   rN   rS   rT   rU   r   r   )r   rf   rT   rZ  r   )r   r#   rT   rZ  )rD   rE   rF   rb   rc   r   r6  r0  rY   r   r   r   r   r   r   r7  r8  s   @rJ   rZ  rZ    s         ;; I''''7N ""- - - - - - -7 7 7 7	
 	
 	
 	
 	
 	
 	
 [	
! ! ! !    [    rI   rZ  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).rM  r   rM  rT   rU   c                V    t                                                       || _        d S rW   )r  rY   rM  )rX   rM  r   s     rJ   rY   zTypeAliasExpr.__init__  r  rI   r   r   rd   c                ,    |                     |           S rW   )visit_type_alias_exprr   s     rJ   r   zTypeAliasExpr.accept  r  rI   )rM  r   rT   rU   r   rJ  r8  s   @rJ   ri  ri    sl         ))INOOO     3 3 3 3 3 3 3 3rI   ri  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(...).)ra  is_typedra  r   ra  r   rp  FrT   rU   c                d    t                                                       || _        || _        d S rW   )r  rY   ra  rp  )rX   ra  rp  r   s      rJ   rY   zNamedTupleExpr.__init__!  s+    	 rI   r   r   rd   c                ,    |                     |           S rW   )visit_namedtuple_exprr   s     rJ   r   zNamedTupleExpr.accept&  r  rI   r  )ra  r   rp  r   rT   rU   r   rJ  r8  s   @rJ   ro  ro    s|         DD$IN NNNNNN! ! ! ! ! ! !
3 3 3 3 3 3 3 3rI   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 )TypedDictExprz%Typed dict expression TypedDict(...).rq  r   ra  rT   rU   c                V    t                                                       || _        d S rW   )r  rY   ra  )rX   ra  r   s     rJ   rY   zTypedDictExpr.__init__4  r  rI   r   r   rd   c                ,    |                     |           S rW   )visit_typeddict_exprr   s     rJ   r   zTypedDictExpr.accept8  r  rI   )ra  r   rT   rU   r   rJ  r8  s   @rJ   rv  rv  *  sn         //IN NNN     2 2 2 2 2 2 2 2rI   rv  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 ...').)ra  r   r  r   ra  r  r   r  r  rT   rU   c                r    t                                                       || _        || _        || _        d S rW   )r  rY   ra  r   r  )rX   ra  r   r  r   s       rJ   rY   zEnumCallExpr.__init__I  s2    	
rI   r   r   rd   c                ,    |                     |           S rW   )visit_enum_call_exprr   s     rJ   r   zEnumCallExpr.acceptO  r  rI   )ra  r   r   r  r  r  rT   rU   r   rJ  r8  s   @rJ   r{  r{  <  s         ??+I0N NNN####     2 2 2 2 2 2 2 2rI   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   rT   rU   c                V    t                                                       || _        d S rW   r  )rX   r   r   s     rJ   rY   zPromoteExpr.__init__Z  r  rI   r   r   rd   c                ,    |                     |           S rW   )visit__promote_exprr   s     rJ   r   zPromoteExpr.accept^  r  rI   )r   r  rT   rU   r   )	rD   rE   rF   rb   rc   r   rY   r   r7  r8  s   @rJ   r  r  S  sj         <<I     1 1 1 1 1 1 1 1rI   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_typera  r   r   r  r  r  ra  rN   rS   rO   rT   rU   c                x    t                                          ||           || _        || _        d | _        d S )N)rN   rO   )r  rY   r   r  ra  )rX   r   r  rN   rO   r   s        rJ   rY   zNewTypeExpr.__init__o  s;     	d6222	 			rI   r   r   rd   c                ,    |                     |           S rW   )visit_newtype_exprr   s     rJ   r   zNewTypeExpr.acceptw  r@  rI   )
r   r   r  r  rN   rS   rO   rS   rT   rU   r   rJ  r8  s   @rJ   r  r  b  s         **,I1NIII$$$$     0 0 0 0 0 0 0 0rI   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  rT   rU   c                V    t                                                       || _        d S rW   r  r  s     rJ   rY   zAwaitExpr.__init__  r  rI   r   r   rd   c                ,    |                     |           S rW   )visit_await_exprr   s     rJ   r   zAwaitExpr.accept  rX  rI   r  r   rJ  r8  s   @rJ   r  r  {  so         ''IN     . . . . . . . .rI   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 | NonerT   rU   c                   t                                                       || _        || _        ||j        | _        |j        | _        dS dS )zJConstruct a dummy node; optionally borrow line/column from context object.N)r  rY   r   r  rN   rO   )rX   r  r  r  r   s       rJ   rY   zTempNode.__init__  sM     		DI!.DKKK rI   r   c                >    d| j         t          | j                  fz  S )NzTempNode:%d(%s))rN   r   r   r   s    rJ   rK  zTempNode.__repr__  s     DIs49~~#>>>rI   r   r   rd   c                ,    |                     |           S rW   )visit_temp_noder   s     rJ   r   zTempNode.accept  r   rI   r  )r  r  r  r   r  r  rT   rU   r   r   )
rD   rE   rF   rb   rc   r   rY   rK  r   r7  r8  s   @rJ   r  r    s           #I LLL 49	)W[	) 	) 	) 	) 	) 	) 	) 	)? ? ? ?- - - - - - - -rI   r  >   rb   rj  __dict__rY   rc   rE   __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_mror\  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_anyrZ  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  rc  rs  type_object_typer   r   r  rY  r  list[TypeInfo]r  zlist[str] | Noner  r   r  r\  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  rZ  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  rc  rw  rs  r  r  )r  r  r  r  r  r  r  r  r\  r  r  r   FLAGSrT   rU   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  rY   r   r   r  r  r  rZ  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  add_type_varsr\  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  rc  rs  r  )rX   r  r  r  r   s       rJ   rY   zTypeInfo.__init__  sx   
	&#( ',$
"&" #% $&!
!  %15"15" %$$)!!#"$(,%"' $rI   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 )NFTrh   )r  r  rZ  r~  r^   r   r  ParamSpecTyper  TypeVarTupleTyper  r   r  appendr   )rX   r  vds      rJ   r  zTypeInfo.add_type_vars  s    ',$9 		/"49#677 / /2b$*":;; 4/3D,b$*"=>> R#;;;;37D012D.14TY5H1I1IA1MPQ1QD.%%bg....		/ 		// /rI   c                    | j         j        S )zShort name.)r  r   r   s    rJ   r   zTypeInfo.name  s     y~rI   c                    | j         S rW   r  r   s    rJ   r   zTypeInfo.fullname  r  rI   c                2    t          | j                  dk    S )z7Is the type generic (i.e. does it have type variables)?r   )r   rZ  r   s    rJ   rp  zTypeInfo.is_generic  s    4>""Q&&rI   r   SymbolTableNode | Nonec                Z    | j         D ]"}|j                            |          }|r|c S #d S rW   )r  r  r   )rX   r   r   ns       rJ   r   zTypeInfo.get  sA    8 	 	C	d##A trI   r  c                4    | j         D ]}||j        v r|c S d S rW   )r  r  )rX   r   r   s      rJ   get_containing_type_infoz!TypeInfo.get_containing_type_info   s3    8 	 	Csy  


 !trI   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-)calculatedrR   )r  r  r  r  r   r^   rM  r   r>  r   r  addr-  )rX   membersr  r   rM  s        rJ   protocol_memberszTypeInfo.protocol_members  s      EExZZZZZZHSbSM 	& 	&D &"&*"2"2"4"4 & &JD$!$)ih-OPP ! ;;; KK%%%%grI   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)r^   rL  r   )ry   r$  s     rJ   r  z(TypeInfo.enum_members.<locals>.<genexpr>"  sM        !#w//LM1     rI   __zenum.nonmember)r  r   r^   rM  rm  anyr  r  r  r   r  r;   r$  r<  r   r  get_proper_typer   r  is_type_objrb  r   )rX   r  r   symr  s        rJ   enum_memberszTypeInfo.enum_members  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$$$rI   r   c                R    |                      |          }|r|S t          |          rW   )r   KeyError)rX   r   r  s      rJ   __getitem__zTypeInfo.__getitem__K  s*    HHTNN 	!H4.. rI   c                    d| j          dS )Nz
<TypeInfo rH  r   r   s    rJ   rK  zTypeInfo.__repr__R  s    ,DM,,,,rI   c                .    t          | t                     S rW   )r^   FakeInfor   s    rJ   __bool__zTypeInfo.__bool__U  s     dH----rI   c                0    |                      |          d uS rW   )r   rJ  s     rJ   has_readable_memberzTypeInfo.has_readable_member[  s    xx~~T))rI   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$  )ry   r  r   s     rJ   r   z'TypeInfo.get_method.<locals>.<listcomp>c  s3    UUUq=S=S=S0T0TUUUUrI   rR   )r  r  rM  r-  keysr^   r  rm  )rX   r   r   rM  possible_redefinitionss    `   rJ   
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trI   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.typerh   )	r  r   has_baser   r   r  rb  r  r   )rX   declaredwinnersuper_class
super_metas        rJ   calculate_metaclass_typez!TypeInfo.calculate_metaclass_typep  s    *(>(>(O(OO>_,,:&&tR0008ABB< 	 	K$7J!Z_%<~#{##JO$<== ''(<== #FrI   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")rh   z > z conflicts with )r  r   r  r   r   r  r  join)rX   r  r  resolution_stepsr  r  conflicts          rJ   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trI   F)preciser  c               V    |                      d          p| j        dk    p	| j        o| S )Nr  zabc.ABCMeta)r  r   r  )rX   r  s     rJ   is_metaclasszTypeInfo.is_metaclass  s7    MM/** 6}-6$4W	
rI   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   )rX   r   r   s      rJ   r  zTypeInfo.has_base  s3    
 8 	 	C|x''tt (urI   c                $    d | j         D             S )zXReturn a direct base classes.

        Omit base classes of other base classes.
        c                    g | ]	}|j         
S rH   r  )ry   r  s     rJ   r   z0TypeInfo.direct_base_classes.<locals>.<listcomp>  s    111d	111rI   )r  r   s    rJ   direct_base_classeszTypeInfo.direct_base_classes  s    
 21dj1111rI   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  rZ   _is_recursiverX   r  aliass      rJ   update_tuple_typezTypeInfo.update_tuple_type  sS    ))$//! 	4!&D(-D%/3D,,,rI   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  rZ   r  r  s      rJ   update_typeddict_typezTypeInfo.update_typeddict_type  sT    !--d33! 	4!&D(-D%/3D,,,rI   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  TypeStrVisitorr+  s     rJ   r   zTypeInfo.__str__  sT    
 ))yy\))')::*33G3DD  
 
 	
rI   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  rT   r   c                .    |                                S rW   )r   )r  r  s    rJ   type_strzTypeInfo.dump.<locals>.type_str  s    ::m,,,rI   r   zBases(z, c              3  .   K   | ]} |          V  d S rW   rH   )ry   r  r  s     rJ   r  z TypeInfo.dump.<locals>.<genexpr>  s+      %L%Lhhtnn%L%L%L%L%L%LrI   )zMro({})c              3  R   K   | ]!}|j                             |          z   V  "d S rW   )r   	format_id)ry   r  r  s     rJ   r  z TypeInfo.dump.<locals>.<genexpr>  s8      TT4dmh&8&8&>&>>TTTTTTrI    (zName(NameszDeclaredMetaclass(zMetaclassType()r  )r  r  rT   r   )r#  r  r   formatr  r-  r  rM  r^   r  r   r  r   r  r  r   r   dump_tagged)rX   r  r  r  headr  r  r   descriptionrM  r   r  s    ``        @rJ   r  zTypeInfo.dump  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GrI   rf   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  rZ  r  r  c                6    g | ]}|                                 S rH   r  ry   bs     rJ   r   z&TypeInfo.serialize.<locals>.<listcomp>  r  rI   r  c                    g | ]	}|j         
S rH   r  ry   cs     rJ   r   z&TypeInfo.serialize.<locals>.<listcomp>  s    1111AJ111rI   r  c                6    g | ]}|                                 S rH   r  )ry   ps     rJ   r   z&TypeInfo.serialize.<locals>.<listcomp>  s     >>>1>>>rI   r  r  r  r  r  r  )r  r  r  r  r  rs  )r  r   r  r   r  r  rZ  r  r  r  r  r  r  r  r  r  r  r   r  r  r  r-  r  r  r  rs  r   s     rJ   r   zTypeInfo.serialize  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 rI   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   rh   rH   )ry   attrs     rJ   r   z(TypeInfo.deserialize.<locals>.<listcomp>4  s%    !]!]!]47DG"4!]!]!]rI   r  rZ  r  c                V    g | ]&}t           j        j                            |          'S rH   )r   r  rb  r   r,  s     rJ   r   z(TypeInfo.deserialize.<locals>.<listcomp>7  s+    NNN1DJ'33A66NNNrI   r  r  r  r  r  r  r  r  r  r  r  r  r  r  rs  )$r  r   rY  r   r   r  rZ  r  r  r   r  r  r^   r  r  r  rb  r  r  r  r  	TupleTyper  TypedDictTyper  r  r  r  r  r  TypeVarTyper  r   r	  r  rs  )
r   r   r  r  r  tir  r2  rE  sts
             rJ   r   zTypeInfo.deserialize-  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' ..	rI   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 rH   rH   )ry   r   r   s      rJ   r   z"TypeInfo.write.<locals>.<listcomp>u      EEEDAqaEEErI   c                    g | ]\  }}|S rH   rH   )ry   r   ss      rJ   r   z"TypeInfo.write.<locals>.<listcomp>v  r>  rI   c                    g | ]	}|j         
S rH   r  r/  s     rJ   r   z"TypeInfo.write.<locals>.<listcomp>z  s    ;;;Qaj;;;rI   )1r9   	TYPE_INFOr  r   r   r  r   r  r6   r  r2   rZ  r0   r  r   r  rz  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r\  r  r  r4   r  r  r"   r-  r  r  r  r7   rs  r   r   s     rJ   r   zTypeInfo.writeo  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,,,$     rI   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 rH   )read_str_barer   s     rJ   	<setcomp>z TypeInfo.read.<locals>.<setcomp>  s!    PPPd++PPPrI   )Br  r   r/   ry  rY  r   r   r   r,   r(   listzipr  rZ  r&   r  r  r   r   r   r   r  rf  r  rb  r  r   r  rL  r  r"   r  r  r  
TUPLE_TYPEr7  r  TYPED_DICT_TYPEr8  r  r  r  r  r  r  r  r  r  r  r\  r  r  r*   r  r    r  r  TYPE_VAR_TYPEr9  r  r   r	  r  r-   rs  r   )
r   r   r  r  r  r:  attrsstatusesr   r  s
    `        rJ   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**~~((((	rI   )r  r  r  rY  r  r   rT   rU   rB  r   r5  )r   r   rT   r  )r   r   rT   r  )rT   r  )r   r   rT   r   )r   r   rT   r   )r   r   rT   r  )rT   r  rT   rw  )r  r   rT   r   )r   r   rT   r   )rT   r  )r  r  rT   rU   )r  r  rT   rU   )r  r  r  r  rT   r   r   )r   rf   rT   r   r   )r   r#   rT   r   )%rD   rE   rF   rb   rc   r   r  rY   r  r   r   r   rp  r   r  r  r  r  rK  r  r  r  r  r  r  r  r
  r  r  r   r  r   r   r   r   r   r7  r8  s   @rJ   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rI   c                  "    e Zd ZdZddZdd	Zd
S )r  r  r  r   rT   rU   c                    || _         d S rW   rP  )rX   r  s     rJ   rY   zFakeInfo.__init__  s    rI   r5  r   c                    |dk    rt                               | |          S t          t                               | d                    )Nr   r  )object__getattribute__AssertionError)rX   r5  s     rJ   rT  zFakeInfo.__getattribute__  sA    ;**4666V44T5AABBBrI   N)r  r   rT   rU   )r5  r   rT   r   )rD   rE   rF   rc   rY   rT  rH   rI   rJ   r  r    sG        I,   C C C C C CrI   r  zVar is lacking infozFinal[TypeInfo]rD  zClassDef is lacking inforg  z"FuncBase for non-methods lack inforf  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)
    )
rZ   r   modulealias_tvarsno_args
normalizedr  eagertvar_tuple_indexpython_3_12_type_alias)r   rZ   rY  rZ  NF)rY  rZ  r[  r\  r^  rZ   r  r   r   rX  rN   rS   rO   rY  rb  rZ  r   r[  r\  r^  rT   rU   c               V   || _         || _        || _        |g }|| _        || _        || _        d | _        |	| _        |
| _        d | _	        t          |          D ]+\  }}t          |t          j        j                  r|| _	        ,t                                          ||           d S rW   )r   rX  rZ   rY  rZ  r[  r  r\  r^  r]  r~  r^   r   r  r  r  rY   )rX   rZ   r   rX  rN   rO   rY  rZ  r[  r\  r^  r  rE  r   s                rJ   rY   zTypeAlias.__init__{  s     "K&$ +/
&<# $k** 	* 	*DAq!TZ899 *()%v&&&&&rI   ra  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).
        rg  )r  r   copy_modifiedr   r  rb  type_vars_as_argsr  rZ  r   r  rN   rO   r   ra  s     rJ   r  zTypeAlias.from_tuple_type  s     O)),,$*66ty7JKK  *   MIK
 
 	
rI   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).
        ra  )r  r   rb  r   r  rb  rc  r  rZ  r   r  rN   rO   rd  s     rJ   r  zTypeAlias.from_typeddict_type  s     """"--,,$*66ty7JKK  .   MIK
 
 	
rI   c                B    | j                             d          d         S Nr  rR   r  r   s    rJ   r   zTypeAlias.name      ~##C((,,rI   c                    | j         S rW   r  r   s    rJ   r   zTypeAlias.fullname  r  rI   c                >    t          d | j        D                       S )Nc              3  T   K   | ]#}t          |t          j        j                  V  $d S rW   )r^   r   r  r  rs  s     rJ   r  z0TypeAlias.has_param_spec_type.<locals>.<genexpr>  s1      UUq:a!9::UUUUUUrI   )r  rY  r   s    rJ   r  zTypeAlias.has_param_spec_type  s"    UUDDTUUUUUUrI   r   r   rd   c                ,    |                     |           S rW   )visit_type_aliasr   s     rJ   r   zTypeAlias.accept  rX  rI   rf   c           	         d| j         | j        | j                                        d | j        D             | j        | j        | j        d}|S )Nr   c                6    g | ]}|                                 S rH   r  rs  s     rJ   r   z'TypeAlias.serialize.<locals>.<listcomp>  s     DDDaAKKMMDDDrI   )r   r   rX  rZ   rY  rZ  r[  r^  )r   rX  rZ   r   rY  rZ  r[  r^  r   s     rJ   r   zTypeAlias.serialize  sW    !kk++--DD43CDDD|/&*&A	
 	
 rI   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   rX  c                L    g | ]!}t           j                            |          "S rH   rH  rs  s     rJ   r   z)TypeAlias.deserialize.<locals>.<listcomp>  s(    SSS!tz22155SSSrI   rY  c              3  T   K   | ]#}t          |t          j        j                  V  $d S rW   )r^   r   r  rv  rD  s     rJ   r  z(TypeAlias.deserialize.<locals>.<genexpr>  s1      RR:a!;<<RRRRRRrI   rZ   rZ  r[  r^  rR   rY  rZ  r[  r^  )r  r   r  r  r   rG  rv  )	r   r   r   rX  rY  rZ   rZ  r[  r^  s	            rJ   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

 

 

 
	
rI   r%   c                   t          |t                     t          || j                   t          || j                   | j                            |           t          j        	                    || j
                   t          || j                   t          || j                   t          || j                   t          |t                     d S rW   )r9   
TYPE_ALIASr   r   rX  rZ   r   r   r  rz  rY  r0   rZ  r[  r^  r   r   s     rJ   r   zTypeAlias.write  s    $
###$'''$$$$$
""4)9:::4&&&4)))44555$     rI   r#   c                p   t          |          }t          |          }t          j                            |          }t          j                            |          }t          |||dd|t          |          t          |          t          |          	  	        }t          |          t          k    sJ |S )NrR   rs  )	r   r   r  rM  r|  r   r&   r/   r   )r   r   r   rX  rZ   rY  r
  s          rJ   r   zTypeAlias.read  s    D>>$%%d++j44T::#dOO #,T??

 

 

 ~~((((
rI   )rZ   r  r   r   rX  r   rN   rS   rO   rS   rY  rb  rZ  r   r[  r   r\  r   r^  r   rT   rU   )ra  r   rT   r   r   r5  r   r   )r   rf   rT   r   r   )r   r#   rT   r   )rD   rE   rF   rb   rc   r6  rY   r   r  r  r   r   r   r  r   r   r   r   r   r7  r8  s   @rJ   r   r     s       W WrI BN @D ',' ' ' ' ' ' ' 'B 
 
 
 [
* 
 
 
 [
* - - - X-    X V V V XV. . . .    
 
 
 [
,	! 	! 	! 	!    [    rI   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   rM  becomes_typeinfoF)ry  r   r   rM  r   rN   rS   ry  r   rT   rU   c               >    || _         || _        || _        || _        d S rW   )r   rM  ry  rN   )rX   r   rM  rN   ry  s        rJ   rY   zPlaceholderNode.__init__N  s%     "	 0			rI   c                B    | j                             d          d         S rg  r  r   s    rJ   r   zPlaceholderNode.nameV  rh  rI   c                    | j         S rW   r  r   s    rJ   r   zPlaceholderNode.fullnameZ  r  rI   rf   c                    J d            )NFz#PlaceholderNode can't be serializedrH   r   s    rJ   r   zPlaceholderNode.serialize^  s    ;;;;;rI   r   r   rd   c                ,    |                     |           S rW   )visit_placeholder_noder   s     rJ   r   zPlaceholderNode.accepta  r  rI   N)
r   r   rM  r   rN   rS   ry  r   rT   rU   r   r   r   )rD   rE   rF   rb   rc   rY   r   r   r   r   r   rH   rI   rJ   rx  rx    s        . .` :I QV      - - - X-    X< < < <4 4 4 4 4 4rI   rx  c                      e Zd ZdZdZ	 	 	 d%ddd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d.d#            Zd$S )/r   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.
        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 be never exported (needed for
            stub files)
        cross_ref: For deserialized MypyFile nodes, the referenced module
            name; for other nodes, optionally the name of the referenced object.
        implicit: Was this defined by assignment to self attribute?
        plugin_generated: Was this symbol generated by a plugin?
            (And therefore needs to be removed in aststrip.)
        no_serialize: Do not serialize this node if True. This is used to prevent
            keys in the cache that refer to modules on which this file does not
            depend. Currently this can happen if there is a module not in build
            used e.g. like this:
                import a.b.c # type: ignore
            This will add a submodule symbol to parent module `a` symbol table,
            but `a.b` is _not_ added as its dependency. Therefore, we should
            not serialize these symbols as they may not be found during fixup
            phase, instead they will be re-added during subsequent patch parents
            phase.
            TODO: Refactor build.py to make dependency tracking more transparent
            and/or refactor look-up functions to not require parent patching.

    NOTE: No other attributes should be added to this class unless they
    are shared by all node kinds.
    )r  rM  module_publicmodule_hidden	cross_refimplicitplugin_generatedno_serializeTF)r  r  r  rS   rM  SymbolNode | Noner  r   r  r  r  r  rT   rU   c               v    || _         || _        || _        || _        || _        d | _        || _        || _        d S rW   )r  rM  r  r  r  r  r  r  )rX   r  rM  r  r  r  r  r  s           rJ   rY   zSymbolTableNode.__init__  sF     		* *%) 0(rI   rw  c                ,    | j         | j         j        S d S rW   )rM  r   r   s    rJ   r   zSymbolTableNode.fullname  s    9 9%%4rI   r  c                    | j         }t          |t          t          f          r|j        |j        S t          |t
                    r|j        j        S d S rW   )rM  r^   r  r  r   rm  r  )rX   rM  s     rJ   r   zSymbolTableNode.type  sQ    ydS"7899 	di>S9i(( 	8= 4rI   c                v    t          | j        | j        | j        | j        | j                  }| j        |_        |S rW   )r   r  rM  r  r  r  r  )rX   news     rJ   rz  zSymbolTableNode.copy  s8    Ity$"4dmTEW
 
 
rI   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$  r!   : z cross_ref:)	rw   r  r=   rM  r^   r   r   r   r  )rX   r@  s     rJ   r   zSymbolTableNode.__str__  s    $)$>>z$)'<'<>>di,, 	,+di(++++A9 "ty"""A> 	0/t~///ArI   prefixr   rf   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 incompleterM  )rw   r  r  r  r  r  r^   rM  r   r   r  r;  rx  r   )rX   r  r   r   r   s        rJ   r   zSymbolTableNode.serialize  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rI   r   c                   |d         dk    sJ t           |d                  }d|v rt          |d           }|d         |_        n>d|v s
J |            t                              |d                   }t          ||          }d|v r|d         |_        d|v r|d         |_        d|v r|d         |_        d	|v r|d	         |_        |S )
Nr   r   r  r  rM  r  r  r  r  )	r}   r   r  r   r   r  r  r  r  )r   r   r  stnoderM  s        rJ   r   zSymbolTableNode.deserialize  s    H~!22222!$v,/$$T400F#K0FT>>>4>>>))$v,77D$T400Fd""#'#8F d""#'#8F ":.FO%%&*+=&>F#rI   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  )r9   SYMBOL_TABLE_NODEr   r  r0   r  r  r  r  r^   rM  r   r   r  r;  rx  r7   r   r   )rX   r   r  r   r  r   s         rJ   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!!!$     rI   r#   c                   t          |          t          k    sJ t          t          |          d           }t	          |          |_        t	          |          |_        t	          |          |_        t	          |          |_        t          |          }|t          |          |_        n||_        t          |          t          k    sJ |S rW   )r/   r  r   r   r&   r  r  r  r  r-   read_symbolrM  r  r   )r   r   r  r  s       rJ   r   zSymbolTableNode.read;  s    ~~!22222htnnd33%dOO%dOO ( &&	"4((CHH%CM~~((((
rI   N)TFF)r  rS   rM  r  r  r   r  r   r  r   r  r   r  r   rT   rU   rN  r+  )rT   r   r   )r  r   r   r   rT   rf   )r   rf   rT   r   )r   r%   r  r   r   r   rT   rU   )r   r#   rT   r   )rD   rE   rF   rb   rc   rY   r   r   r   rz  r   r   r   r   r   r   rH   rI   rJ   r   r   e  s-       9 9v	I ##) "'") ) ) ) ) )(    X    X   	 	 	 	! ! ! !F    [*! ! ! !>    [  rI   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.
    rH   rT   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  rR   z  r  z  <invalid item>r   zSymbolTable(r!  
)r   r^   r   r   r  r   r  r   r-  insertr   )rX   r   r  r  s       rJ   r   zSymbolTable.__str__T  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||rI   c                X    t          d |                                 D                       S )Nc                @    g | ]\  }}||                                 fS rH   )rz  )ry   r  rM  s      rJ   r   z$SymbolTable.copy.<locals>.<listcomp>g  s)    MMM93S$))++.MMMrI   )r  r   r   s    rJ   rz  zSymbolTable.copyf  s'    MM

MMMNNNrI   r   rf   c                    ddi}|                                  D ],\  }}|dk    s|j        r|                    ||          ||<   -|S )Nr   r  __builtins__)r   r  r   )rX   r   r   r  r  s        rJ   r   zSymbolTable.serializei  s]    "M2**,, 	7 	7JC
 n$$(:$#66DIIrI   r   c                    |d         dk    sJ t                      }|                                D ](\  }}|dk    rt                              |          ||<   )|S )Nr   r  )r  r   r   r   )r   r   r;  r  r  s        rJ   r   zSymbolTable.deserializeu  sa    H~....]]**,, 	= 	=JCh)55e<<3	rI   r%   rU   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  rh   )r   r  r9   r   r   r-  write_str_barer   )rX   r   r   sizer  r  s         rJ   r   zSymbolTable.write~  s    **,, 	 	JC
 n$$(:$AIDD$%%%tT"""$<< 	- 	-CIEn$$(:$4%%%KKh,,,,	- 	-rI   r#   c                    t                    t          k    sJ t                    }t          fdt	          |          D                       S )Nc                b    g | ]+}t                    t                                        f,S rH   )rE  r   r   r   s     rJ   r   z$SymbolTable.read.<locals>.<listcomp>  s4    TTT1mD!!?#7#7#=#=>TTTrI   )r/   r   r   r  r   )r   r   r  s    ` rJ   r   zSymbolTable.read  sV    ~~----T""TTTTdTTT
 
 	
rI   Nr   )rT   r  )r   r   rT   rf   )r   rf   rT   r  )r   r%   r   r   rT   rU   )r   r#   rT   r  )rD   rE   rF   rb   rc   r   rz  r   r   r   r   r   rH   rI   rJ   r  r  L  s         
 I   $O O O O
 
 
 
    [- - - -( 
 
 
 [
 
 
rI   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  rT   rU   c               t    ||nd| _         ||nd| _        ||nd| _        ||nd| _        ||nd| _        d S )NTFrH   r  )rX   r  r  r  r  r  s         rJ   rY   zDataclassTransformSpec.__init__  sc     )3(>**D.;.G]]U2A2MSX0>0JnnPU4D4P 0 0VXrI   rf   c                ^    | j         | j        | j        | j        t	          | j                  dS Nr  )r  r  r  r  rG  r  r   s    rJ   r   z DataclassTransformSpec.serialize  s6    /!/#3"1 $T%: ; ;
 
 	
rI   r   c                   t          |                    d          |                    d          |                    d          |                    d          t          |                    dg                               S )Nr  r  r  r  r  r  )r	  r   tupler   s     rJ   r   z"DataclassTransformSpec.deserialize  sq    %xx--((?33 HH%67788$455"488,>#C#CDD
 
 
 	
rI   r%   c                ,   t          |t                     t          || j                   t          || j                   t          || j                   t          || j                   t          || j                   t          |t                     d S rW   )
r9   r   r0   r  r  r  r  r6   r  r   r   s     rJ   r   zDataclassTransformSpec.write  s    $   4)))4+,,,4-...4,---tT2333$     rI   r#   c                    t          t          |          t          |          t          |          t          |          t          t          |                              }t	          |          t
          k    sJ |S r  )r	  r&   r  r,   r/   r   rN  s      rJ   r   zDataclassTransformSpec.read  sk    $ #D//%dOO$T??"=#6#677
 
 
 ~~((((
rI   )r  r  r  r  r  r  r  r  r  r  rT   rU   r   )r   rf   rT   r	  r   )r   r#   rT   r	  )rD   rE   rF   rb   rc   rY   r   r   r   r   r   rH   rI   rJ   r	  r	    s        < <I #'%)'+37 '+Y Y Y Y Y Y$
 
 
 
 
 
 
 [
! ! ! ! 	 	 	 [	 	 	rI   r	  c                  2    e Zd ZU ded<   edd            ZdS )SplittingVisitorr   recurse_into_functionsrT   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  )rX   old_recurse_into_functionss     rJ   set_recurse_into_functionsz+SplittingVisitor.set_recurse_into_functions  sK       &*%@"&*#	EEEE*DD'''*DD'DDDDs    	(N)rT   r  )rD   rE   rF   r   r	   r  rH   rI   rJ   r  r    sH          !   
E 
E 
E ^
E 
E 
ErI   r  rM  r  r  c                       fd|D             S )Nc                4    g | ]}t          |          |S rH   )getattr)ry   r   rM  s     rJ   r   zget_flags.<locals>.<listcomp>  s(    :::TgdD&9&9:D:::rI   rH   )rM  r  s   ` rJ   r  r    s    ::::U::::rI   r  rU   c                2    |D ]}t          | |d           d S r4  )setattr)rM  r  r   s      rJ   r  r    s0     " "dD!!!!" "rI   r   r%   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   rh   )r   r~  r   )r   r  packedr  r&  s        rJ   r  r    so    u::@FU##  4 	a1fFdFrI   r#   r  rS   c                X    t          |           fdt          |          D             S )Nc                (    g | ]}d |z  z  dk    S )rh   r   rH   )ry   r  r  s     rJ   r   zread_flags.<locals>.<listcomp>
  s'    ???VqAv1$???rI   )r   r   )r   r  r  s     @rJ   r  r    s0    d^^F????eI.>.>????rI   r  rw  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  )r^   r  r  r   r]  get_member_expr_fullname)r  initials     rJ   r  r    sk     G$)X&& 6).	DIz	*	* 6*4955t##	###rI   c                    i | ]V\  }}t          |          t          ur;t          |t                     r&t          |t                    r|t          uN||j        WS rH   )r   r  r^   
issubclassr   r   )ry   r  objs      rJ   r|   r|     sn       SCyy  3 !3
## ! 	: 
 	rI   r   r  rx  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)rH  r  r  rg  rk  rl  rm  )	r  r  r  
is_var_arg	is_kw_arg
seen_namedseen_optr  rM  s	            rJ   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 rI   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  rH  r  )r  r  r  r)  
seen_namesr   rM  s          rJ   check_param_namesr  L  s     #&%%J%''  
d
 2 2DAAAKAA4HHHEEt	 rI   r   c                R    t          | j        t                    r| j        j        S dS )z.Return whether the expression is ClassVar[...]F)r^   rM  r  r2  r  s    rJ   is_class_varr  Z  s&    $)S!! %y$$5rI   r  c                `    t          | t          t          t          t          f          o| j        S )z6Check whether `node` corresponds to a final attribute.)r^   r  rl  rp  rm  r\  rj  s    rJ   is_final_noder  a  s#    dS'+<iHII[dm[rI   r  mypy.types.CallableTypec                L    | j         }t          |t                    r|j        }|S rW   )
definitionr^   rm  r  )r  r  s     rJ   get_func_defr  f  s(    J*i(( %_
rI   name_prefixra  r  r  c              #  (  K   |                                  D ]z\  }}|}d|v r|                    d          d         }|dz   |z   }|j        }|rC|j        |k    r8|||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.
    z-redefr   r  N)r   r  rM  r   r^   r   r  r  )r  r  ra  r   symnode	shortnamer   rM  s           rJ   r  r  m  s        
I 
Ig	t

8,,Q/I$y0| 	IDMX--GT))))$)) I,TZ4HHHHHHHHH
I 
IrI   2   z
Final[Tag]r2  3   r  4   r  5   r&  6   r(  7   rJ  8   rW  9   rd  :   rB  ;   ru  <   ry  =   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   
NAMED_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_EXPRc                   t          |           }|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 |t$          k    rt&                              |           S J d|             )NFzUnknown symbol tag )r/   r(  r  r   r  rl  r&  rm  rB  r   r  rp  rJ  r>  ru  r   rW  rP  rd  rZ  r   r  s     rJ   r  r    s-   
4..C
czzxx~~
h||D!!!
i~~d###
i}}T"""
!!! %%d+++
m%%%
j~~d###
o!!$'''
!!!$$T***-------rI   r  
Tag | Nonec                    |t          |           }|t          k    rt                              |           S |t          k    rt
                              |           S J d|             )NFz Invalid tag for an OverloadPart )r/   r&  rm  r   r  rl  r  s     rJ   r  r    sa    
{tnn
i~~d###
h||D!!!::S:::::rI   )r+  r  rT   r,  )rM  r   r  r  rT   r  )rM  r   r  r  rT   rU   )r   r%   r  r	  rT   rU   )r   r#   r  rS   rT   r	  )r  r]  rT   rw  )r  rx  r  r  r  r  rT   rU   )r  )
r  r  r  r  r  r  r)  r   rT   rU   )r  r  rT   r   )rM  r  rT   r   )r  r  rT   r  rW   )r  r  r  r   ra  r  rT   r  r   )r   r#   r  r  rT   rn  (W  rb   
__future__r   r"  abcr   collectionsr   collections.abcr   r   r   
contextlibr	   enumr
   r   typingr   r   r   r   r   re   r   r   r   r   librt.internalr   rW  r   r   r   rE  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,   r-   r.   r/   r0   r1   r2   r3   r4   r5   r6   r7   r8   r9   mypy.optionsr:   	mypy.utilr;   r<   r=   mypy.visitorr>   r?   r@   mypy.patternsrA   rC   rL   
mypy.typesrd   rh  r   rf   r   rg   ri   rk   rm   rn   ro   rp   rq   rr   rw   r   r}   r   r   r   r   r   r   r   r   r   r   r   r   r   r  r   r   r   r:  rD  rL  rT  r]  r_  rn  rp  r  r  r  r  r  r  r  r  r  r  r  rl  r  rm  r>  r  rY  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r$  r/  r1  r6  r<  rB  rF  rL  r  r]  r  r  r  rg  rk  rm  rl  r  ru  r~  r  r  r  r  r  MaybeTypeExpressionr  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r$  r,  r0  r1  r2  r3  r5  r<  r>  rP  rZ  ri  ro  rv  r{  r  r  r  r  	frozensetr  r  r   r  rD  rg  rf  rV  rx  r   r  r	  r  r  r  r  r  r  globalsr   r  r  r  r  r  r  r2  r  r  r&  r(  rJ  rW  rd  rB  ru  ry  r  r  r  r  r  r   r  r  r  r  r
  r  r  r  r  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  rH   rI   rJ   <module>r     s.!   : : : " " " " " " 				       # # # # # # 8 8 8 8 8 8 8 8 8 8 % % % % % %        
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
              " ! ! ! ! !    $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $J !           = = = = = = = = = = 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<
 <
 <
 <
 <
 <
 <
 <
~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                     $ ' * * *     7! 7! 7! 7! 7!x 7! 7! 7!t & ) ) )                   H H H H Hh
I H H 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d d d d d d d dN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 -	       \ \ \ \
    CGI I I I I, 	    "$  $ $ $ $    	                     "$  $ $ $ $	    
    	     "  " " " "	    	    	                            ! ! ! ! !
        
    	            
    ! ! ! ! !        	    
    
    	        
    	    
    
                 
    ! ! ! ! !!$  $ $ $ $ #  # # # #!$  $ $ $ $            	    '*  * * * *        "  " " " "        $'  ' ' ' '    
    	    
            
        
    
    
    
         #  # # # #"  " " " "! ! ! ! !! ! ! ! !    ! ! ! ! !! ! ! ! !"%  % % % %!$  $ $ $ $    . . . .0; ; ; ; ; ; ;rI   