
    *eA                      U d dl mZ d dlZd dlZd dlZd dl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 d dlmZmZmZ d dlmZ d dlmZ d dlmZmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;m<Z<m=Z=m>Z>m?Z?m@Z@mAZAmBZBmCZCmDZDmEZEmFZFmGZGmHZHmIZImJZJmKZKmLZLmMZMmNZNmOZOmPZPmQZQmRZRmSZSmTZTmUZUmVZVmWZWmXZXmYZYmZZZm[Z[m\Z\m]Z]m^Z^m_Z_m`Z`maZambZbmcZcmdZdmeZemfZfmgZg d d	lhmiZi d d
ljmkZkmlZlmmZmmnZnmoZompZpmqZqmrZr d dlsmtZtmuZu d dlvmwZwmxZx d dlymzZz d dl{m|Z|m}Z}m~Z~mZmZmZmZmZmZmZmZmZmZmZ d dlmZmZ ej        d         Zded<   d dlZd dlmZmZmZmZmZmZmZmZmZ efdPdZej        Zej        Zej        dk    rej        ZneZej        dk    r`ej        Zej        Zej        Zej        Zej        Zej        Zej        Zej        Zej        Zeej        ej        ej        ej        f         Zn,eZeZeZeZeZeZeZeZeZeej        ej        ej        f         Zej        d k    rej        ZneZ ed!eM"          Z e9d#          Zded$<    eeg d%          Zded&<    ej        d'          Zded(<   	 dQdRd1ZdSd4ZdTd:ZdUd>ZdVdBZ G dC dD          Z G dE dF          ZdWdHZ G dI dJez          Z G dK dLez          ZdXdOZdS )Y    )annotationsN)	AnyCallableFinalListOptionalSequenceTypeVarUnioncast)Literaloverload)defaults
errorcodesmessage_registry)Errors)ErrorMessage)K	ARG_NAMEDARG_NAMED_OPTARG_OPTARG_POSARG_STAR	ARG_STAR2ArgKindArgument
AssertStmtAssignmentExprAssignmentStmt	AwaitExprBlock	BreakStmt	BytesExprCallExprClassDefComparisonExprComplexExprConditionalExprContinueStmt	DecoratorDelStmtDictExprDictionaryComprehensionEllipsisExpr
ExpressionExpressionStmtFakeInfo	FloatExprForStmtFuncDefGeneratorExpr
GlobalDeclIfStmtImport	ImportAll
ImportBase
ImportFrom	IndexExprIntExpr
LambdaExprListComprehensionListExpr	MatchStmt
MemberExprMypyFileNameExprNodeNonlocalDeclOperatorAssignmentStmtOpExprOverloadedFuncDefOverloadPartPassStmt	RaiseStmtRefExpr
ReturnStmtSetComprehensionSetExpr	SliceExprStarExpr	StatementStrExpr	SuperExprTempNodeTryStmt	TupleExpr	UnaryExprVar	WhileStmtWithStmt	YieldExprYieldFromExprcheck_arg_names)Options)	AsPatternClassPatternMappingPattern	OrPatternSequencePatternSingletonPatternStarredPatternValuePattern)"infer_reachability_of_if_statementmark_block_unreachable)argument_elide_namespecial_function_elide_names)TraverserVisitor)AnyTypeCallableArgumentCallableTypeEllipsisTypeInstance
ProperTypeRawExpressionType	TupleTypeTypeTypeList	TypeOfAnyUnboundType	UnionType
UnpackType)bytes_to_human_readable_reprunnamed_function   r   PY_MINOR_VERSION)	AST	AttributeCallFunctionTypeIndexNameStarredUnaryOpUSubsourcestr | bytesfilenamestrmodefeature_versionintreturnr   c                4    t          j        | ||d|          S )NT)type_commentsr   )ast3parse)r   r   r   r   s       .lib/python3.11/site-packages/mypy/fastparse.py
ast3_parser      s,     :'             )r   
   )r      N)boundz*fallback can't be filled out until semanalMISSING_FALLBACK_dummy_fallbackz[^#]*#\s*type:\s*ignore\s*(.*)TYPE_IGNORE_PATTERNfnammodule
str | Noneerrorsr   optionsOptions | NonerB   c                t   |dur|j         p||j        v }|o|du p|j         }|t                      }|                    |||           |                    d          }|rBt          j        d         }|j        d         dk    r|j        d         |k    r|j        d         }n |j        d         dk    sJ |j        d         }	 t          j
                    5  t          j        dt                     t          | |d	|
          }	ddd           n# 1 swxY w Y   t          |||||                              |	          }
n# t           $ r}t"          j        dk     }|r|j        dk    rd|_        |j        }|t"          j        j        k    r;|                    d          r&|j        d          d|j        d          }|d| dz  }|                    |j        |j        nd|j        |dt4          j                   t9          g g di           }
Y d}~nd}~ww xY wt;          |
t8                    sJ |
S )zParse a source file, without doing any semantic analysis.

    Return the parse tree. If errors is not provided, raise ParseError
    on failure. Otherwise, use the errors object to report parse errors.
    N)r   z.pyir}   r   r   ignore)categoryexec)r   )r   is_stubr   strip_function_bodiespathr   	   z	<fstring>zinvalid syntax.z+; you likely need to run mypy using Python z	 or newerr   TblockercodeF)ignore_errorsignored_filespreserve_astsr_   set_fileendswithr   PYTHON3_VERSIONpython_versionwarningscatch_warningsfilterwarningsDeprecationWarningr   ASTConvertervisitSyntaxErrorsysversion_infor   linenomsgminor
startswithreportoffsetcodesSYNTAXrB   
isinstance)r   r   r   r   r   r   r   is_stub_filer   asttreeeis_py38_or_earliermessagepython_version_strs                  r   r   r      s    D(BW-B $$  *\w$/[gF[B[))
OOD&'O222==((L 4"215!!$))g.DQ.G/.Y.Y%4Q7O%a(A----!03 +$&& 	T 	T#H7IJJJJVT6?SSSC	T 	T 	T 	T 	T 	T 	T 	T 	T 	T 	T 	T 	T 	T 	T  "7
 
 
 %** 	  + + + -6 	!*";"; AH%S-3338J8JK[8\8\3$+$:1$=![![@VWX@Y![![bEWbbbbG,AHH"H 	 	
 	
 	
 Br**'+* dH%%%%%Ks=   E /DE DE D*E 
HCHHtaglist[str] | Nonec                   | r?|                                  dk    s'|                                                      d          rg S t          j        d|           }|dS d |                    d                              d          D             S )zParse optional "[code, ...]" tag after "# type: ignore".

    Return:
     * [] if no tag was found (ignore all errors)
     * list of ignored error codes if a tag was found
     * None if the tag was invalid.
     #z\s*\[([^]#]*)\]\s*(#.*)?$Nc                6    g | ]}|                                 S  )strip).0r   s     r   
<listcomp>z)parse_type_ignore_tag.<locals>.<listcomp>  s     ;;;TDJJLL;;;r   r}   ,)r   r   rematchgroupsplit)r   ms     r   parse_type_ignore_tagr      s      #))++##syy{{'='=c'B'B#	
-s33Ayt;;QWWQZZ%5%5c%:%:;;;;r   type_commentlinecolumnErrors | None*tuple[list[str] | None, ProperType | None]c                   	 t          | dd          }t                              |           }|rc|                    d          }t	          |          }|<|3|                    ||t          j        j        t          j
                   n
t          nd}t          |t          j                  sJ t          |||d                              |j                  }||fS # t          $ rx |t|                     dd	          d
                                         }	t          j                            |	          }
|                    |||
j        d|
j                   Y dS  w xY w)zkParse type portion of a type comment (+ optional type ignore).

    Return (ignore info, parsed type).
    z<type_comment>evalr}   Nr   F)r   override_columnis_evaluatedr      r   Tr   NN)r   r   r   r   r   r   r   INVALID_TYPE_IGNOREvaluer   r   r   r   r   r.   TypeConverterr   bodyr   r   TYPE_COMMENT_SYNTAX_ERROR_VALUEformatr   )r   r   r   r   typextra_ignorer   ignored	convertedstripped_typeerr_msgs              r   parse_type_commentr     s   "'7@@ +00>> 	*0033C(=c(B(BG%MMf&6&J&PW\Wc "     &%  G#t/////!vE
 
 

%// 	 	!!5    (..sA66q9??AAM&FMMm\\GMM$t',MWWW::s   C A=E!E!expr_stringexpr_fallback_namerr   c                P   	 t          |                                 ||d          \  }}t          |t                    r|j        | |_        ||_        |S t          |t                    r|S t          | |||          S # t          t          f$ r t          | |||          cY S w xY w)zParses a type that was originally present inside of an explicit string.

    For example, suppose we have the type `Foo["blah"]`. We should parse the
    string expression "blah" using this function.
    N)r   r   r   )
r   r   r   rx   original_str_exproriginal_str_fallbackry   rs   r   
ValueError)r   r   r   r   _nodes         r   parse_type_stringr  8  s    P$[%6%6%8%8tF[_```4dK(( 	TT-C-K%0D");D&Ki(( 	TK$[2DdFSSS$ P P P !.@$OOOOOPs   AA? A? -A? ?#B%$B%expr	ast3.exprboolc                    t          | t                    r| j        dk    S t          | t                    r5t          | j        t                    r| j        j        dk    o
| j        dk    S dS )Nno_type_checktypingF)r   r   idr   r   attr)r  s    r   is_no_type_check_decoratorr  P  sj    $ Nw/))	D)	$	$ Ndj$'' 	N:=H,Mo1MM5r   c                  v   e Zd ZU d?dZd@dZdAdBdZdCdZdDdZdEdZdFd#Z	dGd&Z
dHd(Zd)d)d)d*dId1ZdJd6Zej        d7ej        d8ej        d9ej        d:ej        d;ej        d<ej        d=ej        d>ej        d?ej        d@ej        dAej        dBej        dCiZdDedE<   dKdHZej        dIej         dJej!        dKej"        dLej#        dMej$        dNej%        dOej&        dPej'        dQej(        dRi
Z)dDedS<   dLdUZ*dMdXZ+dNd[Z,d)d)d\dOd]Z-dPd^Z.	 dQdRdbZ/dSddZ0dTdeZ1dUdgZ2dVdiZ3dWdmZ4dXdpZ5dYdrZ6	 dZd[dtZ7d\dyZ8	 dZd]d~Z9	 dZd^dZ:d_dZ;d`dZ<dadZ=dbdZ>dcdZ?dddZ@dedZAdfdZBdgdZCdhdZDdidZEdjdZFdkdZGdldZHdmdZIdndZJdodZKdpdZLdqdZMdrdZNdsdZOdtdZPdudńZQdvdȄZRdwd˄ZSdxd΄ZTdydфZUdzdԄZVd{dքZWd|dلZXd}d܄ZYd~d߄ZZddZ[ddZ\ddZ]ddZ^ddZ_ddZ`ddZaddZbddZcddZddd ZeddZfddZgddZhdd
ZiddZjddZkddZlddZmddZnddZoddZpdd!Zqdd$Zrdd'Zsdd*Ztdd-Zudd0Zvdd3Zwdd6Zxdd9Zydd<Zzdd>Z{d_S (  r   r   r_   r   r
  r   r   r   r   r   r   Nonec                   g | _         g | _        || _        || _        || _        || _        || _        i | _        i | _        d S N)	class_and_function_stackimportsr   r   r   r   r   type_ignoresvisitor_cache)selfr   r   r   r   r   s         r   __init__zASTConverter.__init__Z  sS     LN%)+%:"	24 GIr   r   r   r   r   c                X    | j                             |||dt          j                   d S Nnote)severityr   r   r   r   r   r  r   r   r   s       r   r  zASTConverter.noter  s+    4vELQQQQQr   Tr   r   c                    |s| j         j        s[| j                            | j        | j        | j         j                   | j                            |||j        ||j                   d S d S )Nr   )	r   r   r   set_file_ignored_linesr   r  r   r   r   )r  r   r   r   r   s        r   failzASTConverter.failu  s|     	X$,4 	XK..	4,dl.H   KtVSYchWWWWW	X 	Xr   r  r6   c                `    |                      t          j        |j        |j        d           d S )NFr   r   r   )r#  r   FAILED_TO_MERGE_OVERLOADSr   r   r  r  s     r   fail_merge_overloadz ASTConverter.fail_merge_overload}  s:    		6;	 	 	
 	
 	
 	
 	
r   
AST | Noner   c                    |d S t          |          }| j                            |          }|)d|j        j        z   }t          | |          }|| j        |<    ||          S )Nvisit_)typer  get	__class____name__getattr)r  r  typeobjvisitormethods        r   r   zASTConverter.visit  sk    <4t**$((11? 77FdF++G*1Dw'wt}}r   r   nAstNodec                    |j         |_        |j        |_        t	          |dd           |_        t	          |dd           |_        |S )N
end_linenoend_col_offset)r   r   
col_offsetr   r0  end_line
end_column)r  r  r4  s      r   set_linezASTConverter.set_line  s@    H	l<66!!%5t<<r   lSequence[AST | None]list[Expression | None]c                h    g }|D ],}|                      |          }|                    |           -|S r  )r   append)r  r=  resr   exps        r   translate_opt_expr_listz$ASTConverter.translate_opt_expr_list  s;    ') 	 	A**Q--CJJsOOOO
r   Sequence[AST]list[Expression]c                h    t          t          t                   |                     |                    S r  )r   r   r.   rD  r  r=  s     r   translate_expr_listz ASTConverter.translate_expr_list  s%    D$d&B&B1&E&EFFFr   ast3.expr | ast3.stmtc                    t          |t          j        t          j        t          j        f          r|j        r|j        d         j        S |j        S Nr   )r   r   AsyncFunctionDefr$   FunctionDefdecorator_listr   r'  s     r   
get_linenozASTConverter.get_lineno  sI    td3T]DDTUVV	1#	1 &q)00{r   F)ismodule	can_stripis_coroutinestmtsSequence[ast3.stmt]rQ  rR  rS  list[Statement]c                  |rn|rk| j         rct          | j                   |                     |d                   k     r1| j         t          | j                            }|r]d                    |          }|                     t
          j                            |          t          | j                   dd           | j        j	        | j        j
                 t          | j                                                t          j        j                   t          |                     |                     |                              }|                     ||           t'          |           |gS | j        }|r*| j        r#t-          |          dk    r|d         dk    r|sg S g }	|D ],}
|                     |
          }|	                    |           -|r| j        r|dd          ddgk    rEt1          |	          rd}n3t3                      }|	D ]"}|                    |           |j        rd} n#|rA|d	         dk    r5|r3t9                      }|	D ]"}|                    |           |j        rd} n#|rg S |	S )
Nr   z, Fr%  r}   FCr   )r  minrP  joinr#  r   "TYPE_IGNORE_WITH_ERRCODE_ON_MODULEr   r   used_ignored_linesfilerA  r   FILEr   r    fix_function_overloadstranslate_stmt_listset_block_linesri   r  r   lenr   is_possible_trivial_bodyFindAttributeAssignacceptfound	FindYield)r  rT  rQ  rR  rS  ignoresjoined_ignoresblockstackrB  stmtr  r2  syield_visitors                  r   rb  z ASTConverter.translate_stmt_list  s    		 !	 D%&&q)B)BBB'D,=(>(>?G !%7!3!3		$GNN~^^T.//!	     K*4;+;<SAR=S=ST[[
   $55d6N6Nu6U6UVVWWE  ..."5)))7N- 	*	 E

aaC    I! 	 	D::d##DJJt  	3 	RSSzc3Z''+C00 
" %II 233G  " ")))"= "(-I!E"  U2Y#--,- !*  AHH]+++$* $)	  	
r   ast3.stmt | ast3.argr   r   ProperType | Nonec                r    |d S |j         }t          |||j        | j                  \  }}|
|| j        |<   |S r  )r   r   r9  r   r  )r  r4  r   r   r   r   s         r   translate_type_commentz#ASTConverter.translate_type_comment  sL     4XF 2<W[Wb c cL#',8!&)Jr   +-*@/%z**z<<z>>|^&z//zFinal[dict[type[AST], str]]op_mapopast3.operatorc                    t           j                            t          |                    }|,t	          dt          t          |                    z             |S )NzUnknown operator )r   r~  r-  r,  RuntimeErrorr   r  r  op_names      r   from_operatorzASTConverter.from_operator  sH    %))$r((33?2Sb]]BCCCNr   ><z==z>=z<=z!=iszis notinznot incomp_op_map
ast3.cmpopc                    t           j                            t          |                    }|,t	          dt          t          |                    z             |S )NzUnknown comparison operator )r   r  r-  r,  r  r   r  s      r   from_comp_operatorzASTConverter.from_comp_operator(  sH    *..tBxx88?=DHHMNNNNr   br    c                F   |d         |d         }}|j         |_        |j        |_        t	          |dd           |_        t	          |dd           |_        |j        sd S |j        d         }t          |t          t          f          r|j        |_        |j        |_        d S d S )Nr   r   r7  r8  )r   r   r9  r   r0  r:  r;  r   r   r)   rH   )r  r  rT  firstlast	new_firsts         r   rc  zASTConverter.set_block_lines/  s    Ahb	t#T<66
t%5t<<v 	FF1I	i)->!?@@ 	( ^AF 'AHHH		( 	(r   list[ast3.stmt]Block | Nonec                    d }|rKt          |                     |                     |                              }|                     ||           |S r  r    ra  rb  rc  )r  rT  r  s      r   as_blockzASTConverter.as_block>  sS     	+d11$2J2J52Q2QRRSSA  E***r   rR  rS  c          	         |sJ t          |                     |                     |||                              }|                     ||           |S )Nr  r  )r  rT  rR  rS  r  s        r   as_required_blockzASTConverter.as_required_blockE  se     ''(()R^(__ 
 

 	Q&&&r   c           	     
   g }g }d }d}d }d }d }d }	g }
|D ]}}d }d }d }t          |t                    r4|du r0|                     ||          }||                     |          \  }}|t          |t          t
          f          r|j        |k    r||
                    |           |Jt          |t                    r|	                    |j
                   n|                    |           d\  }}|	r|                     |	           d }	|                    |           t          |t
                    rd}%|gt          |t                    rQ||k    rJ|
                    |           |||                     |           u|Jt          |t                    r|	                    |j
                   n|                    |           d\  }}t          |j        d         t                    rg|
	                    t          t          t                   |j        d d                              |	                    |j        d         j
                   H|                    t          t          t          t
          f         |j        d                              ||                    |           |}d\  }}d }	|rF||k    r@|                                }t          |t                    sJ |
                    |           |r3|
r1|
D ],}|                     |           |                    |           -g }
t%          |          dk    r|                    |d                    n5t%          |          dk    r"|                    t          |                     d}t          |t                    r t'          |j                  s|g}|j        }t          |t                    r|g }|}|}d }|x|
	                    t          t          t                   |j        d d                              t          t          t          t
          t          f         |j        d                   }|}	dg }d }|                    |           |r1|
r/|
D ],}|                     |           |                    |           -t%          |          dk    r|                    |d                    net%          |          dk    r#|                    t          |                     n/||                    |           n||                    |           |S )NFr   Tr   r   r}   )r   r6   _check_ifstmt_for_overloads'_get_executable_if_block_with_overloadsr)   r3   namerA  rH   extenditemsr(  r   r   r   r   pop_strip_contents_from_if_stmtrd  r|   )r  rT  retcurrent_overloadcurrent_overload_nameseen_unconditional_func_deflast_if_stmtlast_if_overloadlast_if_stmt_overload_namelast_if_unknown_truth_valueskipped_if_stmtsrn  if_overload_nameif_block_with_overloadif_unknown_truth_valuepoppedif_stmts                    r   ra  z#ASTConverter.fix_function_overloadsQ  s   !/1,0&+#&*KO15"59#)+ r	% r	%D+/37"48"$'' K,G5,P,P#'#C#CDJ_#`#` #/ DDTJJ.. &1ti%9:: 2I!666+$++L999#/ ""24EFF B(//0@0FGGGG(//0@AAA5?2L"2. 7,,-HIII26/ ''---dG,, 726/%1tV,, 2$(=== !''---)1-9001GHHH#/ ""24EFF B(//0@0FGGGG(//0@AAA5?2L"249"=?PQQ $++Df?U?Z[^\^[^?_,`,`aaa$++,B,G,K,QRRRR$++U9g#568N8STU8VWW     +JJ|,,,1F.5?2L"226/# 4(=A[([([ !WWYYF%ff55555$++F333# *(8 * $4 , ,99'BBB

7++++')$'((A--JJ/23333)**Q..JJ01ABBCCC /4+dI.. %7G	7R7R %(,v$,0I))f-- %2B2N')$,<)#'L15.-9(// f/E/J3B3/OPP   ,0!)W6G"GH27;, ,( 3I//')$,0)JJt$$$$ 	$ 0 	$ , $ $11':::

7####  A%%JJ'*++++!""Q&&JJ()9::;;;;)JJ'((((%JJ|$$$
r   Nrn  r  c                .    t          |j        d         j                  dk    r_t          |j        d         j        d         t          t          f          s|+t          |j        d         j        d         t
                    st          |j        d         j                  dk    r^t          |j        d         j        d         t                    r3t           fd|j        d         j        dd         D                       sdS t          t          t          t
          t          f         |j        d         j        d                   j	        }|j
        |S t          |j
        j                  dk    rt          |j
        j        d         t          t
          t          f          r|j
        j        d         j	        |k    r|S t          |j
        j        d         t                    r,                     |j
        j        d         |          |k    r|S dS )z{Check if IfStmt contains only overloads with the same name.
        Return overload_name if found, None otherwise.
        r   r}   Nr   c              3  B   K   | ]}                     |          V  d S r  )_is_stripped_if_stmt)r   r  r  s     r   	<genexpr>z;ASTConverter._check_ifstmt_for_overloads.<locals>.<genexpr>  s1      ]]7D--g66]]]]]]r   )rd  r   r   r)   rH   r3   allr   r   r  	else_bodyr6   r  )r  rn  r  overload_names   `   r   r  z(ASTConverter._check_ifstmt_for_overloads  s    	!!""a''49Q<,Q/)=N1OPP ( )4ty|03W== 5 49Q<$%%))49Q<,R02CDD *]]]]diPQlFWX[Y[X[F\]]]]] * 4)W&778$)A,:KB:O
 

 	 >!  t~"##q(( 4>.q1IwHY3Z[[%N'*/=@@$$4>.q16::%44T^5H5KMbcc ! ! %$tr   "tuple[Block | None, IfStmt | None]c                   t          || j                   |j        |j        d         j        du rdS |j        "|j        d         j        du r|j        j        du rd|fS |j        j        du r|j        d         dfS |j        d         j        du rSt          |j        j        d         t                    r%|                     |j        j        d                   S |j        dfS d|fS )a  Return block from IfStmt that will get executed.

        Return
            0 -> A block if sure that alternative blocks are unreachable.
            1 -> An IfStmt if the reachability of it can't be inferred,
                 i.e. the truth value is unknown.
        Nr   Tr   F)rh   r   r  r   is_unreachabler   r6   r  r  rn  s     r   r  z4ASTConverter._get_executable_if_block_with_overloads
  s     	+4>>>>!dil&AT&I&I:N"y|*e33-66 :>(D009Q<%%9Q<&$.. $.-a0&99 \CCDNDWXYDZ[[[>4''Tzr   c                Z   t          |j                  dk    rg |j        d         _        |j        rwt          |j        j                  dk    r\t          |j        j        d         t                    r'|                     |j        j        d                    dS g |j        _        dS dS dS )zRemove contents from IfStmt.

        Needed to still be able to check the conditions after the contents
        have been merged with the surrounding function overloads.
        r}   r   N)rd  r   r  r   r6   r  r  s     r   r  z)ASTConverter._strip_contents_from_if_stmt*  s     ty>>Q "DIaL> 	)c$."566!;;$.-a0&99 )11$.2Ea2HIIIII&(###		) 	);;r   rR   c                @   t          |t                    sdS t          |j                  dk    r#t          |j        d         j                  dk    sdS |j        rt          |j        j                  dk    rdS |                     |j        j        d                   S )ziCheck stmt to make sure it is a stripped IfStmt.

        See also: _strip_contents_from_if_stmt
        Fr}   r   T)r   r6   rd  r   r  r  r  s     r   r  z!ASTConverter._is_stripped_if_stmt8  s    
 $'' 	5DI!##DIaL,=(>(>!(C(C5~ 	T^%8!9!9Q!>!>4 (()<Q)?@@@r   r  c                *    || j         j        k    rdS |S )z;Return the actual, internal module id for a source text id.r  )r   custom_typing_module)r  r  s     r   translate_module_idz ASTConverter.translate_module_idK  s    2228	r   modast3.ModulerB   c                   i | _         |j         D ]P}t          |j                  }||| j         |j        <   (|                     t
          j        |j        dd           Q|                     |                     |j	        d                    }t          || j        d| j                   }| j        |_        | j        |_        |S )Nr   Fr   T)rQ  )ignored_lines)r  r   r   r   r#  r   r   ra  rb  r   rB   r  r   r   )r  r  tiparsedr   r  s         r   visit_ModulezASTConverter.visit_ModuleQ  s    " 	^ 	^B*2622F!/5!"),,		*>	2W\	]]]]**4+C+CCHW[+C+\+\]]tT\5@QRRRl9
r   ast3.FunctionDefFuncDef | Decoratorc                ,    |                      |          S r  do_func_defr  r4  s     r   visit_FunctionDefzASTConverter.visit_FunctionDeff  s    """r   ast3.AsyncFunctionDefc                0    |                      |d          S )NT)rS  r  r  s     r   visit_AsyncFunctionDefz#ASTConverter.visit_AsyncFunctionDefk  s    555r   (ast3.FunctionDef | ast3.AsyncFunctionDefc                   | j                             d           t          |j        ot	          d |j        D                                 }|j        }|                     |j        ||          }t          |j	                  r|D ]	}d|_
        
d |D             }d |D             }g }	|rdgt          |          z  }	d}
n|j        	 t          |j        dd	          }t          |t                    sJ t          |j                  d
k    rst          |j        d         t"                    rS|j        d         j        t&          u r:|j        r&|                     t,          j        ||j                   d |D             }	n|j        st	          d |D                       r&|                     t,          j        ||j                   t3          | j        ||j                                      |j                  }t9          t:          t<          t>                            |          }	t3          | j        |                               |j                  }
| j         dd         ddgk    }|rMt          |	          t          |          k     r-|	!                    dtE          tF          j$                             n# tJ          $ r |j        &                    dd          d         '                                }t,          j(        )                    |          }|                     |||j                   |j        r+|j        d         dvr| *                    d||j                   tE          tF          j+                  gt          |          z  }	tE          tF          j+                  }
Y nw xY wtX          j-        dk    rY|j.        rR|                     t_          dt`          j1                  |j.        d         j        |j.        d         j        d           d |D             }	t3          | j        |j        r|j        j        n|                               |j                  }
te          ||	          D ] \  }}| 3                    ||j4                   !d}t	          |	          s|
r"t          |	          d
k    r@t	          d |	D                       r'|                     t,          j5        ||j                   nt          |	          t          |          k    r)|                     t,          j6        ||j        d           nt          |	          t          |          k     r)|                     t,          j7        ||j        d           n=tq          d |	D             |||
|
ntE          tF          j9                  tt                    }tw          |dd          }tw          |dd          }| j         <                                 | j                             d            | =                    |j>        d|!          }t          |j	        |||          }t          |j@        tp                    r|j@        A                                |_B        |rd|_C        |||_D        ||_E        |j        r|j        d         j        }t          |j	                  }d|_G        |H                    |           d|_I        ||_J        |H                    ||j        ||           t          ||                     |j                  |          }|j        d         }|H                    |j        |j        ||           |}n|H                    ||j        ||           |}| jL        jM        rt          jO        |d"          |_P        | j         <                                 |S )#zCHelper shared between visit_FunctionDef and visit_AsyncFunctionDef.Dc              3  4   K   | ]}t          |          V  d S r  )r  )r   ds     r   r  z+ASTConverter.do_func_def.<locals>.<genexpr>t  s+      $]$]q%?%B%B$]$]$]$]$]$]r   )r  Tc                    g | ]	}|j         
S r   )kindr   args     r   r   z,ASTConverter.do_func_def.<locals>.<listcomp>}  s    ...#SX...r   c                8    g | ]}|j         rd n|j        j        S r  )pos_onlyvariabler  r  s     r   r   z,ASTConverter.do_func_def.<locals>.<listcomp>~  s(    QQQSS\@TTs|/@QQQr   Nz<func_type>	func_typer}   r   c                \    g | ])}|j         |j         nt          t          j                  *S r  )type_annotationrm   rw   unannotatedr   as     r   r   z,ASTConverter.do_func_def.<locals>.<listcomp>  sI     ! ! !  ,8 ))$Y%:;;! ! !r   c              3  (   K   | ]}|j         d uV  d S r  r  r  s     r   r  z+ASTConverter.do_func_def.<locals>.<genexpr>  s*      'T'T!(9(E'T'T'T'T'T'Tr   )r   r   r   rY  rZ  r   r   )(r   z.Suggestion: wrap argument types in parenthesesr   &PEP 695 generics are not yet supportedr   Fr  c                    g | ]	}|j         
S r   r  r  s     r   r   z,ASTConverter.do_func_def.<locals>.<listcomp>  s    999q*999r   c              3  @   K   | ]}t          |t                    V  d S r  )r   rp   )r   ts     r   r  z+ASTConverter.do_func_def.<locals>.<genexpr>  s,      *Z*Z1:a+F+F*Z*Z*Z*Z*Z*Zr   c                H    g | ]}||nt          t          j                   S r  )rm   rw   r  r  s     r   r   z,ASTConverter.do_func_def.<locals>.<listcomp>  s,    ___PQ!-QQWY5J-K-K___r   r7  r8  rX  r  clean)Qr  rA  r
  rO  anyr   transform_argsargsrk   r  r  rd  r   r   r   r   argtypesConstantr   Ellipsisreturnsr#  r   DUPLICATE_TYPE_SIGNATURESr9  r   r   rI  r   r   r   ru   r   insertrm   rw   special_formr   r   r   r   r   r  
from_errorr   r   type_paramsr   r   
VALID_TYPEzipset_type_optionalinitializerELLIPSIS_WITH_OTHER_TYPEARGSTYPE_SIGNATURE_TOO_MANY_ARGSTYPE_SIGNATURE_TOO_FEW_ARGSro   r  r   r0  r  r  r   r3   r,  copy_modifiedunanalyzed_typerS  
definitionr   rY   is_readyr<  is_decorated	deco_liner)   r   include_docstringsr   get_docstring	docstring)r  r4  rS  r  r   r  r  	arg_kinds	arg_names	arg_typesreturn_typefunc_type_asttranslated_argsin_method_scoper   r   arg_typer  r:  r;  r   func_defr  vardecor  retvals                              r   r  zASTConverter.do_func_defn  s    	%,,S111]$]$]AL\$]$]$]!]!]
 
 ""166"OO'// 	$ $ $#.....	QQDQQQ	')	 ;	T*IKK^'*< *1>=+ V V!->>>>> .//144"=#9!#<hGG 5%.q178CCy d		"2"LfVWVbccc! ! "&	! ! !II y dC'T'Tt'T'T'T$T$T d		"2"LfVWVbccc2?&!,3 3 3))-*@AA $ !%T(4.%9? K KI+DKfEEEKKMLabb #'"?"Dc
"R" Is9~~D		'A'A$$Q	0F(G(GHHH 	< 	< 	< ! 4 4S! < <Q ? E E G G*JQQR_``		'61<888> anQ&7z&I&IIIH&RSR^   %Y%9::;c$iiG	%i&:;;	< 7**q}*		 !IPUP`aaaM!$+M!$/!	     :9D999I'ai"K!)"2"2V  eAI  !y11 	> 	>MC""8S_====	y>> 	[ 	9~~""s*Z*ZPY*Z*Z*Z'Z'Z"		*GQRQ]^^^^Y#i..00		$AL!	      Y#i..00		$@L!	      )__U^___#.#:KK	H]@^@^# 	 1lD11Q 0$77
%))+++%,,S111%%af<%XX164y99hm\22 	E'/}'B'B'D'DH$ 	)$(H! #+I #IN 	 (+2Ihm$$C CLLL   $(H!!*HfalHjIIIXt'?'?@P'Q'QSVWWD$Q'EMM%,(8(JOOO*.FF falHjIIIF<* 	D!%!3AU!C!C!CH%))+++s   G/J> >C-N.-N.r,  Type | Noner  Expression | Nonec                    | j         j        sd S t          |t                    o
|j        dk    }t          |t
                    r	||_        d S d S )Nr  )r   implicit_optionalr   rC   r  rx   optional)r  r,  r  r  s       r   r  zASTConverter.set_type_optional  sW    |- 	Fk844S9IV9SdK(( 	%$DMMM	% 	%r   r  ast3.argumentsr  list[Argument]c           
     J   g }g }t          |dt          t          t          j                 g                     }||j        z   }|j        }t          |          t          |          z
  }	t          |d |	                   D ]^\  }
}|
t          |          k     }|	                    | 
                    |d t          ||                     |	                    |           _t          t          ||	d          |                    D ]d\  }
\  }}|	|
z   t          |          k     }|	                    | 
                    ||t          ||                     |	                    |           e|j        O|	                    | 
                    |j        d t          |                     |	                    |j                   t          |j        |j                  D ]S\  }}|	                    | 
                    |||t$          nt&          |                     |	                    |           T|j        O|	                    | 
                    |j        d t*          |                     |	                    |j                   t-          d |D             || j                   |S )Nposonlyargsc                &    g | ]}|j         j        S r   )r  r  r  s     r   r   z/ASTConverter.transform_args.<locals>.<listcomp>7  s    ???s*???r   )r0  r   r   r   r  r  r   rd  	enumeraterA  make_argumentr   r  r   varargr   
kwonlyargskw_defaultsr   r   kwargr   r^   fail_arg)r  r  r   r  new_argsnamesr   	args_argsargs_defaultsnum_no_defaultsir  r  r  kds                  r   r  zASTConverter.transform_args  sw     "dM4TX3K3KLL$)+	i..3}+=+==i(8(89:: 	 	DAq3{+++HOOD..q$PXYYZZZLLOOOO #3y1A1A'BM#R#RSS 	 	IAv1&*S-=-==HOOD..q!WmXVVWWWLLOOOO ;"OOD..t{D(MZZ[[[LL%%% $*:;; 	 	EArOO""r
99}   
 LLOOOO :!OOD..tz4MZZ[[[LL$$$??h???VVVr   r  ast3.argdefaultast3.expr | Noner  r   r  r   c           
     8   |rd }n|j         }|j        }|-|+|                     t          j        |j        |j                   d }|/t          | j        |j                  	                    |          }n| 
                    ||          }t          |j                  rd}t          t          |j                  || 	                    |          ||          }	|	                    |j        |j        t!          |dd           t!          |dd                      |	S )Nr  Tr7  r8  )
annotationr   r#  r   r  r   r9  r   r   r   rt  rj   r  r   rY   r<  r0  )
r  r  r1  r  r  r  r  r4  r   arguments
             r   r#  zASTConverter.make_argument;  s     	JHHJ+L%,*B		*DcjRUR`aaaH%(3:FFFLLZXX66sLIIsw'' 	HCLL(DJJw4G4GxXXJNCt,,C)400		
 	
 	
 r   c                b    |                      t          |          |j        |j                   d S r  )r#  r   r   r9  )r  r   r  s      r   r(  zASTConverter.fail_arg[  s*    		,s##SZ@@@@@r   ast3.ClassDefr$   c           	          j                             d            fd|j        D             }t          j        dk    rY|j        rR                     t          dt          j	                  |j        d         j
        |j        d         j        d           t          |j                             |j                  d                      |j                  t%          |                              d	          |
          }                     |j                  |_        |j
        |_        |j        r|j        d         j
        nd |_         j        j        rt5          j        |d          |_        |j        |_        t=          |dd           |_        t=          |dd           |_          j         !                                 |S )NrZ  c                `    g | ]*}|j         	|j                             |j                  f+S r   )r  r   r   )r   kwr  s     r   r   z/ASTConverter.visit_ClassDef.<locals>.<listcomp>e  s5    RRRr26RRVTZZ112RRRr   r   r  r   r   Fr  	metaclass)r;  keywordsr  r7  r8  )"r  rA  r<  r   r   r  r#  r   r   r  r   r9  r$   r  r  r   rI  basesdictr-  rO  
decoratorsr   r  r   r	  r   r
  r  r   r0  r:  r;  r  )r  r4  r<  cdefs   `   r   visit_ClassDefzASTConverter.visit_ClassDefc  s   %,,S111RRRRQZRRRw&&1=&IIEEL\]]]a 'a +	     F""16**$$QW--8nn((55
 
 
 2213CDD H	787GQ)!,33T<* 	@!/???DNl<66!!%5t<<%))+++r   ast3.ReturnrM   c                |    t          |                     |j                            }|                     ||          S r  )rM   r   r   r<  r  r4  r  s      r   visit_ReturnzASTConverter.visit_Return  s1    $**QW--..}}T1%%%r   ast3.Deleter*   c                Z   t          |j                  dk    rQt          |                     |j                            }|                    |j                   t          |          }n-t          |                     |j        d                             }|                     ||          S )Nr}   r   )rd  targetsrW   rI  r<  r   r*   r   )r  r4  tupr  s       r   visit_DeletezASTConverter.visit_Delete  s    qy>>AD44QY??@@CLL"""3<<DD4::ail3344D}}T1%%%r   ast3.Assignr   c                    |                      |j                  }|                     |j                  }|                     ||j                  }t          |||d          }|                     ||          S )NFr,  
new_syntax)rI  rH  r   r   rt  r   r   r<  )r  r4  lvaluesrvaluer   ro  s         r   visit_AssignzASTConverter.visit_Assign  sk    **1955AG$$))!Q^<<7FGGG}}Q"""r   ast3.AnnAssignc                   |j         }|j        <t          t          t          j                  d          }||_        |j        |_        n| 	                    |j                  }t          | j        |          	                    |j                  }|J |j        j        |_        t          | 	                    |j                  g||d          }|                     ||          S )NT)no_rhsr  rM  )r   r   rU   rm   rw   r  r   r9  r   r   r   r   r4  r   targetr<  )r  r4  r   rP  r   ro  s         r   visit_AnnAssignzASTConverter.visit_AnnAssign  s    x7?!)')2H*I*IRV!W!W!WFFKLFMMZZ((FDKd33399!,GG\,
DJJqx0016PTUUU}}Q"""r   ast3.AugAssignrF   c                    t          |                     |j                  |                     |j                  |                     |j                            }|                     ||          S r  )rF   r  r  r   rU  r   r<  r  r4  ro  s      r   visit_AugAssignzASTConverter.visit_AugAssign  sZ    "qt$$djj&:&:DJJqw<O<O
 
 }}Q"""r   ast3.Forr2   c                J   |                      ||j                  }t          |                     |j                  |                     |j                  |                     |j                  |                     |j	                  |          }| 
                    ||          S r  )rt  r   r2   r   rU  iterr  r   r  orelser<  r  r4  target_typer  s       r   	visit_ForzASTConverter.visit_For  s    11!Q^DDJJqx  JJqv""16**MM!(##
 
 }}T1%%%r   ast3.AsyncForc                X   |                      ||j                  }t          |                     |j                  |                     |j                  |                     |j                  |                     |j	                  |          }d|_
        |                     ||          S NT)rt  r   r2   r   rU  r]  r  r   r  r^  is_asyncr<  r_  s       r   visit_AsyncForzASTConverter.visit_AsyncFor  s    11!Q^DDJJqx  JJqv""16**MM!(##
 
 }}T1%%%r   
ast3.WhilerZ   c                    t          |                     |j                  |                     |j                  |                     |j                            }|                     ||          S r  )rZ   r   testr  r   r  r^  r<  rD  s      r   visit_WhilezASTConverter.visit_While  sZ    JJqv 6 6qv > >ah@W@W
 
 }}T1%%%r   ast3.Ifc                    t          |                     |j                  g|                     |j                  g|                     |j                            }|                     ||          S r  )r6   r   ri  r  r   r  r^  r<  rD  s      r   visit_IfzASTConverter.visit_If  sb    ZZ 4#9#9!&#A#A"BDMMRSRZD[D[
 
 }}T1%%%r   	ast3.Withr[   c                                           ||j                  }t           fd|j        D              fd|j        D                                  |j                  |          }                     ||          S )Nc                D    g | ]}                     |j                  S r   r   context_exprr   r.  r  s     r   r   z+ASTConverter.visit_With.<locals>.<listcomp>  '    999ATZZ''999r   c                D    g | ]}                     |j                  S r   r   optional_varsrs  s     r   r   z+ASTConverter.visit_With.<locals>.<listcomp>  '    :::QTZZ((:::r   )rt  r   r[   r  r  r   r<  r_  s   `   r   
visit_WithzASTConverter.visit_With  s    11!Q^DD9999999::::!':::""16**	
 
 }}T1%%%r   ast3.AsyncWithc                                          ||j                  }t           fd|j        D              fd|j        D                                  |j                  |          }d|_                             ||          S )Nc                D    g | ]}                     |j                  S r   rq  rs  s     r   r   z0ASTConverter.visit_AsyncWith.<locals>.<listcomp>  rt  r   c                D    g | ]}                     |j                  S r   rv  rs  s     r   r   z0ASTConverter.visit_AsyncWith.<locals>.<listcomp>  rx  r   T)rt  r   r[   r  r  r   re  r<  )r  r4  r`  ro  s   `   r   visit_AsyncWithzASTConverter.visit_AsyncWith  s    11!Q^DD9999999::::!':::""16**	
 
 
}}Q"""r   
ast3.RaiserK   c                    t          |                     |j                  |                     |j                            }|                     ||          S r  )rK   r   exccauser<  rD  s      r   visit_RaisezASTConverter.visit_Raise  sA    AE**DJJqw,?,?@@}}T1%%%r   ast3.TryrV   c           
     Z     fd|j         D             } fd|j         D             } fd|j         D             }t                               |j                  |||                     |j                                       |j                            }                     ||          S )Nc                r    g | ]3}|j         (                    t          |j                   |          nd 4S r  r  r<  rC   r   hr  s     r   r   z*ASTConverter.visit_Try.<locals>.<listcomp>  J     
 
 
ST!&2DDMM(16**A...$
 
 
r   c                D    g | ]}                     |j                  S r   r   r,  r  s     r   r   z*ASTConverter.visit_Try.<locals>.<listcomp>  '    888AF##888r   c                D    g | ]}                     |j                  S r   r  r   r  s     r   r   z*ASTConverter.visit_Try.<locals>.<listcomp>  )    GGGqD**1622GGGr   )handlersrV   r  r   r  r^  	finalbodyr<  r  r4  vstypesr  r  s   `     r   	visit_TryzASTConverter.visit_Try  s    
 
 
 
XYXb
 
 
 9888QZ888GGGGAJGGG""16**MM!(##MM!+&&
 
 }}T1%%%r   TryStarc           
     h     fd|j         D             } fd|j         D             } fd|j         D             }t                               |j                  |||                     |j                                       |j                            }d|_                             ||          S )Nc                r    g | ]3}|j         (                    t          |j                   |          nd 4S r  r  r  s     r   r   z.ASTConverter.visit_TryStar.<locals>.<listcomp>  r  r   c                D    g | ]}                     |j                  S r   r  r  s     r   r   z.ASTConverter.visit_TryStar.<locals>.<listcomp>  r  r   c                D    g | ]}                     |j                  S r   r  r  s     r   r   z.ASTConverter.visit_TryStar.<locals>.<listcomp>  r  r   T)	r  rV   r  r   r  r^  r  is_starr<  r  s   `     r   visit_TryStarzASTConverter.visit_TryStar  s    
 
 
 
XYXb
 
 
 9888QZ888GGGGAJGGG""16**MM!(##MM!+&&
 
 }}T1%%%r   ast3.Assertr   c                    t          |                     |j                  |                     |j                            }|                     ||          S r  )r   r   ri  r   r<  rD  s      r   visit_AssertzASTConverter.visit_Assert  sA    $**QV,,djj.?.?@@}}T1%%%r   ast3.Importr7   c                0   g }|j         D ]N}|                     |j                  }|j        }|||j        k    r|j        }|                    ||f           Ot          |          }| j                            |           |                     ||          S r  )r*  r  r  asnamerA  r7   r  r<  )r  r4  r*  aliasr  r  r.  s          r   visit_ImportzASTConverter.visit_Import  s    .0W 	) 	)E++EJ77D\F~$%*"4"4 LL$((((5MMA}}Q"""r   ast3.ImportFromr9   c                   |j         J t          |j                  dk    r<|j        d         j        dk    r&|j        |j        nd}t          ||j                   }nFt          |j        |                     |j                  nd|j         d |j        D                       }| j        	                    |           | 
                    ||          S )Nr}   r   rw  r   c                *    g | ]}|j         |j        fS r   )r  r  r  s     r   r   z1ASTConverter.visit_ImportFrom.<locals>.<listcomp>8  s!    555!&!(#555r   )levelrd  r*  r  r   r8   r:   r  r  rA  r<  )r  r4  r  r.  s       r   visit_ImportFromzASTConverter.visit_ImportFrom/  s    w"""qw<<1C!7!7h2!((C%c1733AA67h6J((222PR55QW555 A
 	A}}Q"""r   ast3.Globalr5   c                V    t          |j                  }|                     ||          S r  )r5   r*  r<  )r  r4  gs      r   visit_GlobalzASTConverter.visit_Global>  s%    qw}}Q"""r   ast3.NonlocalrE   c                V    t          |j                  }|                     ||          S r  )rE   r*  r<  )r  r4  r  s      r   visit_NonlocalzASTConverter.visit_NonlocalC  s%    !!}}Q"""r   	ast3.Exprr/   c                    |                      |j                  }t          |          }|                     ||          S r  )r   r   r/   r<  )r  r4  r   r  s       r   
visit_ExprzASTConverter.visit_ExprH  s6    

17##e$$}}T1%%%r   	ast3.PassrJ   c                J    t                      }|                     ||          S r  )rJ   r<  rY  s      r   
visit_PasszASTConverter.visit_PassN  s    JJ}}Q"""r   
ast3.Breakr!   c                J    t                      }|                     ||          S r  )r!   r<  rY  s      r   visit_BreakzASTConverter.visit_BreakS  s    KK}}Q"""r   ast3.Continuer(   c                J    t                      }|                     ||          S r  )r(   r<  rY  s      r   visit_ContinuezASTConverter.visit_ContinueX  s    NN}}Q"""r   	NamedExprr   c                    t          |                     |j                  |                     |j                            }|                     ||          S r  )r   r   rU  r   r<  rY  s      r   visit_NamedExprzASTConverter.visit_NamedExpr^  sA    4::ah//AG1D1DEE}}Q"""r   ast3.BoolOprG   c                n   t          |j                  dk    sJ |j        }t          |t          j                  rd}nIt          |t          j                  rd}n,t          dt          t          |                    z             | 
                    ||                     |j                  |          S )Nr   andorzunknown BoolOp )rd  valuesr  r   r   AndOrr  r   r,  r   rI  )r  r4  op_noder  s       r   visit_BoolOpzASTConverter.visit_BoolOpc  s    18}}!!!!$gtx(( 	ABB)) 	ABB03tAww<<?@@@ zz"d66qx@@!DDDr   valsr	  c           
         t          |          dk    rt          ||d         |d                   }n4t          ||d         |                     ||dd          |                    }|                     ||          S )Nr   r   r}   )rd  rG   r   r<  )r  r  r  r4  r   s        r   r   zASTConverter.groupq  sm    t99>>r47DG,,AAr47DJJr48Q$?$?@@A}}Q"""r   
ast3.BinOpc                J   |                      |j                  }|1t          dt          t	          |j                            z             t          ||                     |j                  |                     |j                            }| 	                    ||          S )Nzcannot translate BinOp )
r  r  r  r   r,  rG   r   leftrightr<  r  r4  r  r   s       r   visit_BinOpzASTConverter.visit_BinOpy  s    %%:83tADzz??JKKK2tzz!&))4::ag+>+>??}}Q"""r   ast3.UnaryOprX   c                   d }t          |j        t          j                  rd}net          |j        t          j                  rd}nCt          |j        t          j                  rd}n!t          |j        t          j                  rd}|1t          dt          t          |j                            z             t          ||                     |j                            }|                     ||          S )N~notru  rv  zcannot translate UnaryOp )r   r  r   InvertNotUAddr   r  r   r,  rX   r   operandr<  r  s       r   visit_UnaryOpzASTConverter.visit_UnaryOp  s    adDK(( 	BBdh'' 	BBdi(( 	BBdi(( 	B::Sad__LMMMb$**QY//00}}Q"""r   ast3.Lambdar=   c                   t          j        |j                  }|j        j        |_        |j        j        |_        | j                            d           t          |                     |j	        |j                  | 
                    |g                    }| j                                         |                    |j        |j                   |S )NL)r   Returnr   r   r9  r  rA  r=   r  r  r  r  r<  )r  r4  r   r   s       r   visit_LambdazASTConverter.visit_Lambda  s    {16""fm&+%,,S111t**1618<<d>T>TVZU[>\>\]]%))+++	

18Q\***r   
ast3.IfExpr'   c                    t          |                     |j                  |                     |j                  |                     |j                            }|                     ||          S r  )r'   r   ri  r   r^  r<  r  r4  r   s      r   visit_IfExpzASTConverter.visit_IfExp  sQ    DJJqv..

160B0BDJJqxDXDXYY}}Q"""r   	ast3.Dictr+   c           
         t          t          t          |                     |j                  |                     |j                                                }|                     ||          S r  )r+   listr  rD  keysrI  r  r<  r  s      r   
visit_DictzASTConverter.visit_Dict  s^    T11!&994;S;STUT\;];]^^__
 
 }}Q"""r   ast3.SetrO   c                |    t          |                     |j                            }|                     ||          S r  )rO   rI  eltsr<  r  s      r   	visit_SetzASTConverter.visit_Set  s3    D,,QV4455}}Q"""r   ast3.ListCompr>   c                    t          |                     t          t          j        |                              }|                     ||          S r  )r>   visit_GeneratorExpr   r   GeneratorExpr<  r  s      r   visit_ListCompzASTConverter.visit_ListComp  s>    d55d4;La6P6PQQRR}}Q"""r   ast3.SetComprN   c                    t          |                     t          t          j        |                              }|                     ||          S r  )rN   r  r   r   r  r<  r  s      r   visit_SetCompzASTConverter.visit_SetComp  s>    T44T$:KQ5O5OPPQQ}}Q"""r   ast3.DictCompr,   c                L     fd|j         D             } fd|j         D             } fd|j         D             }d |j         D             }t                               |j                                       |j                  ||||          }                     ||          S )Nc                D    g | ]}                     |j                  S r   r   rU  r   cr  s     r   r   z/ASTConverter.visit_DictComp.<locals>.<listcomp>  '    >>>A4::ah''>>>r   c                D    g | ]}                     |j                  S r   r   r]  r  s     r   r   z/ASTConverter.visit_DictComp.<locals>.<listcomp>  '    :::AF##:::r   c                D    g | ]}                     |j                  S r   rI  ifsr  s     r   r   z/ASTConverter.visit_DictComp.<locals>.<listcomp>  )    JJJD,,QU33JJJr   c                6    g | ]}t          |j                  S r   r
  re  r   r  s     r   r   z/ASTConverter.visit_DictComp.<locals>.<listcomp>  "    ;;;D$$;;;r   )
generatorsr,   r   keyr   r<  r  r4  rH  itersifs_listre  r   s   `      r   visit_DictCompzASTConverter.visit_DictComp  s    >>>>>>>::::Q\:::JJJJQ\JJJ;;al;;;#JJqutzz!'22GUHh
 
 }}Q"""r   ast3.GeneratorExpr4   c                     fd|j         D             } fd|j         D             } fd|j         D             }d |j         D             }t                               |j                  ||||          }                     ||          S )Nc                D    g | ]}                     |j                  S r   r  r  s     r   r   z3ASTConverter.visit_GeneratorExp.<locals>.<listcomp>  r  r   c                D    g | ]}                     |j                  S r   r  r  s     r   r   z3ASTConverter.visit_GeneratorExp.<locals>.<listcomp>  r  r   c                D    g | ]}                     |j                  S r   r   r  s     r   r   z3ASTConverter.visit_GeneratorExp.<locals>.<listcomp>  r  r   c                6    g | ]}t          |j                  S r   r  r  s     r   r   z3ASTConverter.visit_GeneratorExp.<locals>.<listcomp>  r  r   )r  r4   r   eltr<  r	  s   `      r   r  zASTConverter.visit_GeneratorExp  s    >>>>>>>::::Q\:::JJJJQ\JJJ;;al;;;$**QU++WeXxPP}}Q"""r   
ast3.Awaitr   c                    |                      |j                  }t          |          }|                     ||          S r  )r   r   r   r<  )r  r4  vr   s       r   visit_AwaitzASTConverter.visit_Await  s4    JJqwaLL}}Q"""r   
ast3.Yieldr\   c                |    t          |                     |j                            }|                     ||          S r  )r\   r   r   r<  r  s      r   visit_YieldzASTConverter.visit_Yield  s1    djj))**}}Q"""r   ast3.YieldFromr]   c                |    t          |                     |j                            }|                     ||          S r  )r]   r   r   r<  r  s      r   visit_YieldFromzASTConverter.visit_YieldFrom  s1    $**QW--..}}Q"""r   ast3.Comparer%   c                      fd|j         D             }                     |j        g|j        z             }t	          ||          }                     ||          S )Nc                :    g | ]}                     |          S r   )r  )r   or  s     r   r   z.ASTConverter.visit_Compare.<locals>.<listcomp>  s'    ???AT,,Q//???r   )opsrI  r  comparatorsr%   r<  )r  r4  	operatorsoperandsr   s   `    r   visit_ComparezASTConverter.visit_Compare  s_    ???????	++QVHq},DEE9h//}}Q"""r   r   r#   c                   |j         }|j        }d |D             }|                     d |D             d |D             z             }d |D             d |D             z   }t          |                     |j                  ||t          dd gt          |          z            |z             }|                     ||          S )Nc                    g | ]	}|j         
S r   )r  r   ks     r   r   z+ASTConverter.visit_Call.<locals>.<listcomp>  s    1111111r   c                J    g | ] }t          |t                    r|j        n|!S r   )r   r   r   r  s     r   r   z+ASTConverter.visit_Call.<locals>.<listcomp>  s-    DDD!
1g..5QWWADDDr   c                    g | ]	}|j         
S r   )r   r)  s     r   r   z+ASTConverter.visit_Call.<locals>.<listcomp>  s    GbGbGbTUGbGbGbr   c                V    g | ]&}t          |          t          u rt          nt          'S r   )r,  r   r   r   r  s     r   r   z+ASTConverter.visit_Call.<locals>.<listcomp>  s,    OOOQaG!3!3XXOOOr   c                .    g | ]}|t           nt          S r  )r   r   r  s     r   r   z+ASTConverter.visit_Call.<locals>.<listcomp>  s3     S
 S
 S
8;II)S
 S
 S
r   zList[Optional[str]])	r  r<  rI  r#   r   funcr   rd  r<  )r  r4  r  r<  keyword_namesr  r  r   s           r   
visit_CallzASTConverter.visit_Call  s    v:11111,,DDtDDDGbGbYaGbGbGbb
 
	 PO$OOO S
 S
?LS
 S
 S
 
	 JJqv&T(:;;mK	
 
 }}Q"""r   r  c                   |j         }d }|t          d          }n=t          |t                    rt	          |          }nt          |t
                    rt          t          |                    }nt          |t                    rt          t          |                    }nt          |t                    rt          |          }nt          |t                    rt          |          }nit          |t                    rt          |          }nD|t          u rt!                      }n,t#          dt          t%          |                    z             |                     ||          S )Nr  zConstant not implemented for )r   rC   r   r   rS   bytesr"   r{   r
  r   r<   floatr1   complexr&   r  r-   r  r,  r<  )r  r4  valr   s       r   visit_ConstantzASTConverter.visit_Constant  s?   g;  AAS!! 	QAAU## 	Q6s;;<<AAT"" 	QS""AAS!! 		QAAU## 	Q#AAW%% 	QC  AAH__AA>T#YYOPPP}}Q"""r   ast3.JoinedStrr.   c                   t          d          }|                    |j        |j                   t	          |                     |j                            }|                    |           t          |j                  dk    r!|                     |j        d         |          S t          |j                  dk    r7|j        d         }t          |t                     r|j
        dk    r
|j        dd = t          |d          }|                    |           t          ||gt          gd g          }|                     ||          S )Nr   r}   r   r   r\  )rS   r<  r   r9  r?   rI  r  rd  r  r   r   rA   r#   r   )r  r4  empty_stringstrs_to_joinr  join_methodresult_expressions          r   visit_JoinedStrzASTConverter.visit_JoinedStr  s0    r{{ah555 8 8 B BCCl+++|!""a''==!3A!6:::#$$q((%b)D$(( ,TZ2-=-= !&rss+ v66\***$[<.7)dVTT}}.222r   ast3.FormattedValuec                B   |                      |j                  }|                    |j        |j                   |j        dk     rdndt          |j                  z   }t          d|z   dz             }|j        |                      |j                  nt          d          }|                    |j        |j                   t          |d          }|                    |           t          |||gt          t          gd d g          }|                     ||          S )Nr   r   !{z:{}}r   )r   r   r<  r   r9  
conversionchrrS   format_specrA   r#   r   )r  r4  val_expconv_strformat_stringformat_spec_expformat_methodr=  s           r   visit_FormattedValuez!ASTConverter.visit_FormattedValue)  s   
 **QW%%1<000))22sS5F5F/Fh 78878}7P$**Q]333V]^`VaVaqx666"=(;;}---$G_57IDRV<
 
 }}.222r   r   MemberExpr | SuperExprc                H   |j         }t          |                     |          |j                  }|j        }t          |t                    r@t          |j        t                    r&|j        j	        dk    rt          |j	        |          }n|}|                     ||          S )Nsuper)r   rA   r   r  r  r   r#   calleerC   r  rT   r<  )r  r4  r   member_exprobjr   s         r   visit_AttributezASTConverter.visit_Attribute<  s     E!2!2AF;;sH%%	3:x00	 
7**(1+2BC(H(HAAA}}Q"""r   ast3.Subscriptr;   c                   t          |                     |j                  |                     |j                            }|                     ||           t
          j        dk     }t          |j        t          j	                  s!|rAt          |j        t          j
                  r"|j        |j        _        |j        |j        _        |S )Nr   )r;   r   r   slicer<  r   r   r   r   SliceExtSlicer   indexr   )r  r4  r   r   s       r   visit_SubscriptzASTConverter.visit_SubscriptK  s    djj))4::ag+>+>??a -6agtz** 	&	&#-agt}#E#E	& 6AGLXAGNr   r   rQ   c                |    t          |                     |j                            }|                     ||          S r  )rQ   r   r   r<  r  s      r   visit_StarredzASTConverter.visit_Starred\  s1    TZZ(())}}Q"""r   r   rC   c                V    t          |j                  }|                     ||          S r  )rC   r  r<  r  s      r   
visit_NamezASTConverter.visit_Namea  s#    QTNN}}Q"""r   	ast3.ListListExpr | TupleExprc                      fd|j         D             }t          |j        t          j                  rt          |          }nt          |          }                     ||          S )Nc                :    g | ]}                     |          S r   r   r   r   r  s     r   r   z+ASTConverter.visit_List.<locals>.<listcomp>g  s#    &E&E&Etzz!}}&E&E&Er   )r  r   ctxr   StorerW   r?   r<  )r  r4  	expr_listr   s   `   r   
visit_ListzASTConverter.visit_Listf  sd    &E&E&E&Eaf&E&E&E	aeTZ(( 	$&/	&:&:AA##A}}Q"""r   
ast3.TuplerW   c                |    t          |                     |j                            }|                     ||          S r  )rW   rI  r  r<  r  s      r   visit_TuplezASTConverter.visit_Tuplep  s3    d..qv6677}}Q"""r   
ast3.SlicerP   c                    t          |                     |j                  |                     |j                  |                     |j                            S r  )rP   r   lowerupperstepr  s     r   visit_SlicezASTConverter.visit_Slicew  s>    AG,,djj.A.A4::afCUCUVVVr   ast3.ExtSlicec                v    t          |                     t          t          |          j                            S r  )rW   rI  r   r   dimsr  s     r   visit_ExtSlicezASTConverter.visit_ExtSlice{  s)    11$sA,,2CDDEEEr   r   rD   c                    |                      t          t          |          j                  }t	          |t
                    sJ |S r  )r   r   r   r   r   rD   r  r4  r   s      r   visit_IndexzASTConverter.visit_Index  9    

4Q<<-..%&&&&&r   Matchr@   c                     t                               |j                   fd|j        D              fd|j        D              fd|j        D                       }                     ||          S )Nc                D    g | ]}                     |j                  S r   )r   patternr  s     r   r   z,ASTConverter.visit_Match.<locals>.<listcomp>  s'    444qTZZ	""444r   c                D    g | ]}                     |j                  S r   )r   guardr  s     r   r   z,ASTConverter.visit_Match.<locals>.<listcomp>  s'    222QTZZ  222r   c                D    g | ]}                     |j                  S r   r  r  s     r   r   z,ASTConverter.visit_Match.<locals>.<listcomp>  s)    ===T##AF++===r   )r@   r   subjectcasesr<  rD  s   `  r   visit_MatchzASTConverter.visit_Match  s    JJqy!!4444AG4442222!'222====QW===	
 
 }}T1%%%r   
MatchValuerg   c                |    t          |                     |j                            }|                     ||          S r  )rg   r   r   r<  rD  s      r   visit_MatchValuezASTConverter.visit_MatchValue  s1    DJJqw//00}}T1%%%r   MatchSingletonre   c                V    t          |j                  }|                     ||          S r  )re   r   r<  rD  s      r   visit_MatchSingletonz!ASTConverter.visit_MatchSingleton  s%    ((}}T1%%%r   MatchSequencerd   c                      fd|j         D             }d |D             }t          |          dk     sJ t          |          }                     ||          S )Nc                :    g | ]}                     |          S r   rb  r   pr  s     r   r   z4ASTConverter.visit_MatchSequence.<locals>.<listcomp>  s#    666aDJJqMM666r   c                <    g | ]}t          |t                    |S r   )r   rf   )r   r  s     r   r   z4ASTConverter.visit_MatchSequence.<locals>.<listcomp>  s'    FFFq
1n(E(EFFFFr   r   )patternsrd  rd   r<  )r  r4  r  starsr  s   `    r   visit_MatchSequencez ASTConverter.visit_MatchSequence  se    66661:666FFHFFF5zzA~~~~x((}}T1%%%r   	MatchStarrf   c                    |j         t          d           }n7|                     t          |j                   |          }t          |          }|                     ||          S r  )r  rf   r<  rC   )r  r4  r  r  s       r   visit_MatchStarzASTConverter.visit_MatchStar  sV    6>!$''DD==!&!1!1155D!$''D}}T1%%%r   MatchMappingrb   c                      fd|j         D             } fd|j        D             }|j        d }nt          |j                  }t	          |||          }                     ||          S )Nc                :    g | ]}                     |          S r   rb  )r   r*  r  s     r   r   z3ASTConverter.visit_MatchMapping.<locals>.<listcomp>  s#    ...!

1...r   c                :    g | ]}                     |          S r   rb  )r   r  r  s     r   r   z3ASTConverter.visit_MatchMapping.<locals>.<listcomp>  s#    444A$**Q--444r   )r  r  restrC   rb   r<  )r  r4  r  r  r  r  s   `     r   visit_MatchMappingzASTConverter.visit_MatchMapping  s{    ....qv...44444446>DDAF##DdFD11}}T1%%%r   
MatchClassra   c                                          |j                  }t          |t                    sJ  fd|j        D             }|j        } fd|j        D             }t          ||||          }                     ||          S )Nc                :    g | ]}                     |          S r   rb  r  s     r   r   z1ASTConverter.visit_MatchClass.<locals>.<listcomp>  s#    999tzz!}}999r   c                :    g | ]}                     |          S r   rb  r  s     r   r   z1ASTConverter.visit_MatchClass.<locals>.<listcomp>  s#    @@@A$**Q--@@@r   )	r   clsr   rL   r  	kwd_attrskwd_patternsra   r<  )r  r4  	class_refpositionalskeyword_keyskeyword_valuesr  s   `      r   visit_MatchClasszASTConverter.visit_MatchClass  s    JJqu%%	)W-----9999aj999{@@@@@@@I{L.QQ}}T1%%%r   MatchAsr`   c                    |j         d }n*t          |j                   }|                     ||          }t          |                     |j                  |          }|                     ||          S r  )r  rC   r<  r`   r   r|  )r  r4  r  r  s       r   visit_MatchAszASTConverter.visit_MatchAs  sc    6>DDAF##D==q))DAI..55}}T1%%%r   MatchOrrc   c                p     t           fd|j        D                       }                     ||          S )Nc                :    g | ]}                     |          S r   rb  )r   r|  r  s     r   r   z.ASTConverter.visit_MatchOr.<locals>.<listcomp>  s%    HHH'$**W--HHHr   )rc   r  r<  rD  s   `  r   visit_MatchOrzASTConverter.visit_MatchOr  s;    HHHHQZHHHII}}T1%%%r   ast_TypeAliasc                &   |                      t          dt          j                  |j        |j        d           t          t          |j        j	                  g| 
                    |j                            }|                     ||          S )Nz*PEP 695 type aliases are not yet supportedr   Fr  )r#  r   r   r  r   r9  r   rC   r  r  r   r   r<  rD  s      r   visit_TypeAliaszASTConverter.visit_TypeAlias  s    		EEL\]]]HL	 	 	
 	
 	
 x	223TZZ5H5HII}}T1%%%r   )r   r_   r   r
  r   r   r   r
  r   r   r   r  r   r   r   r   r   r   r   r  )T)
r   r   r   r   r   r   r   r
  r   r  )r  r6   r   r  )r  r)  r   r   )r  r   r4  r5  r   r   )r=  r>  r   r?  )r=  rE  r   rF  )r  rJ  r   r   )
rT  rU  rQ  r
  rR  r
  rS  r
  r   rV  )r4  rq  r   r   r   rr  )r  r  r   r   )r  r  r   r   )r  r    rT  rU  r   r  )rT  r  r   r  )rT  r  rR  r
  rS  r
  r   r    )rT  rV  r   rV  r  )rn  r6   r  r   r   r   )rn  r6   r   r  )rn  r6   r   r  )rn  rR   r   r
  )r  r   r   r   )r  r  r   rB   )r4  r  r   r  )r4  r  r   r  )F)r4  r  rS  r
  r   r  )r,  r  r  r  r   r  )r  r  r   r   r  r
  r   r  )r  r0  r1  r2  r  r   r  r
  r  r
  r   r   )r   r   r  r0  r   r  )r4  r7  r   r$   )r4  rB  r   rM   )r4  rF  r   r*   )r4  rK  r   r   )r4  rR  r   r   )r4  rW  r   rF   )r4  r[  r   r2   )r4  rb  r   r2   )r4  rg  r   rZ   )r4  rk  r   r6   )r4  rn  r   r[   )r4  rz  r   r[   )r4  r  r   rK   )r4  r  r   rV   )r4  r  r   rV   )r4  r  r   r   )r4  r  r   r7   )r4  r  r   r9   )r4  r  r   r5   )r4  r  r   rE   )r4  r  r   r/   )r4  r  r   rJ   )r4  r  r   r!   )r4  r  r   r(   )r4  r  r   r   )r4  r  r   rG   )r  r   r  rF  r4  r	  r   rG   )r4  r  r   rG   )r4  r  r   rX   )r4  r  r   r=   )r4  r  r   r'   )r4  r  r   r+   )r4  r  r   rO   )r4  r  r   r>   )r4  r  r   rN   )r4  r  r   r,   )r4  r  r   r4   )r4  r  r   r   )r4  r  r   r\   )r4  r  r   r]   )r4  r  r   r%   )r4  r   r   r#   )r4  r  r   r   )r4  r8  r   r.   )r4  r?  r   r.   )r4  r   r   rL  )r4  rS  r   r;   )r4  r   r   rQ   )r4  r   r   rC   )r4  r^  r   r_  )r4  rh  r   rW   )r4  rk  r   rP   )r4  rq  r   rW   )r4  r   r   rD   )r4  ry  r   r@   )r4  r  r   rg   )r4  r  r   re   )r4  r  r   rd   )r4  r  r   rf   )r4  r  r   rb   )r4  r  r   ra   )r4  r  r   r`   )r4  r  r   rc   )r4  r  r   r   )|r/  
__module____qualname__r  r  r#  r(  r   r<  rD  rI  rP  rb  rt  r   AddSubMultMatMultDivModPowLShiftRShiftBitOrBitXorBitAndFloorDivr~  __annotations__r  GtLtEqGtELtENotEqIsIsNotInNotInr  r  rc  r  r  ra  r  r  r  r  r  r  r  r  r  r  r  r#  r(  rA  rE  rJ  rQ  rV  rZ  ra  rf  rj  rm  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  r&  r1  r7  r>  rK  rR  rY  r[  r]  rg  rj  rp  rt  rw  r  r  r  r  r  r  r  r  r  r  r   r   r   r   r   Y  s        I I I I0R R R RX X X X X
 
 
 
	 	 	 	      G G G G    "L L L L L L\
 
 
 
 	##	3c##$TT
CSSt+F         	$$
D
H
H0K       ( ( ( (    <AW\
 
 
 
 
 
L L L L^ AE) ) ) ) )V   @) ) ) )A A A A&      *# # # #
6 6 6 6 QVW W W W Wr% % % % FK* * * * *d     @A A A A       F& & & &
& & & &# # # ## # # ## # # #	& 	& 	& 	&
& 
& 
& 
&& & & && & & && & & &	# 	# 	# 	#& & & &
& & & &"& & & &&& & & &
# # # # # # # ## # # #
# # # #
& & & &# # # #
# # # #
# # # ## # # #
E E E E# # # ## # # ## # # #$	 	 	 	# # # #
# # # ## # # #
# # # #
# # # #
# # # ## # # ## # # ## # # #
# # # #
# # # ## # # #&# # # #03 3 3 3,3 3 3 3&# # # #   "# # # #
# # # #
# # # ## # # #W W W WF F F F
   & & & && & & && & & && & & && & & &
& 
& 
& 
&& & & && & & && & & && & & & & &r   r   c                      e Zd Z	 	 	 dHdIdZdJdZdKdLdZedMd            ZedNd            ZdNdZdOdZdPd Z	dQd"Z
dRd&ZdSd*ZdTd,ZdUd.ZdVd0ZdWd2ZdXd4ZdYd6ZdZd9Zd[d;Zd\d=Zd]d?Zd^dAZd_dCZd`dEZdadGZdS )br   r   Tr   r   r   r   r   r   r
  r   r  c                L    || _         || _        || _        g | _        || _        d S r  )r   r   r   
node_stackr   )r  r   r   r   r   s        r   r  zTypeConverter.__init__  s/     	.%'(r   r   c                *    | j         dk     r|S | j         S )zApply column override if defined; otherwise return column.

        Column numbers are sometimes incorrect in the AST and the column
        override can be used to work around that.
        r   )r   )r  r   s     r   convert_columnzTypeConverter.convert_column  s      !##M''r   Nr  r   r  r   rs   c           
     R    t          dd| j        t          |dd          |          S )a  Constructs a type representing some expression that normally forms an invalid type.
        For example, if we see a type hint that says "3 + 4", we would transform that
        expression into a RawExpressionType.

        The semantic analysis layer will report an "Invalid type" error when it
        encounters this type, along with the given note if one is provided.

        See RawExpressionType's docstring for more details on how it's used.
        Nz
typing.Anyr9  r   )r   r   r  )rs   r   r0  )r  r  r  s      r   invalid_typezTypeConverter.invalid_type  s6     !,TYwt\SU7V7V]a
 
 
 	
r   r	  rr   c                    d S r  r   r'  s     r   r   zTypeConverter.visit       r   r)  rr  c                    d S r  r   r'  s     r   r   zTypeConverter.visit  r  r   c                   |dS | j                             |           	 d|j        j        z   }t	          | |d          }|= ||          }t          |t                    sJ || j                                          S |                     |          | j                                          S # | j                                          w xY w)z2Modified visit -- keep track of the stack of nodesNr+  )	r  rA  r.  r/  r0  r   rr   r  r  )r  r  r3  r2  r   s        r   r   zTypeConverter.visit  s    <4t$$$
	" 77FdFD11G"gdmm!#z22222 O!!!! ((..O!!!!DO!!!!s   AB- ?B- -Cc                P    t          | j                  dk     rdS | j        d         S )z3Return the AST node above the one we are processingr   NrY  )rd  r  r  s    r   parentzTypeConverter.parent  s)    t!##4r""r   r   r   c                j    | j         r+| j                             |||j        d|j                   d S d S )NTr   )r   r   r   r   r   s       r   r#  zTypeConverter.fail  sD    ; 	UKtVSY38TTTTT	U 	Ur   r   c                j    | j         r+| j                             |||dt          j                   d S d S r  r  r   s       r   r  zTypeConverter.note#  sB    ; 	VKtVS6UUUUU	V 	Vr   r=  Sequence[ast3.expr]
list[Type]c                       fd|D             S )Nc                :    g | ]}                     |          S r   rb  rc  s     r   r   z5TypeConverter.translate_expr_list.<locals>.<listcomp>(  s#    )))!

1)))r   r   rH  s   ` r   rI  z!TypeConverter.translate_expr_list'  s    ))))q))))r   r   r   ru   c                   |j         }t          |          }t          |                                 t          j                  s0d }|rd                    |          }|                     ||          S |s+|                     t          j
        |j        |j                   d }t          t          j                  }|}t!          |j                  D ]n\  }}	|dk    r|                     |	          }
|
J |
}'|dk    r|                     |	          }C|                     t          j        |j        |j                   o|j        D ]}|j        }|j        dk    rV|>|                     t          j                            |          |j        |j                   |                     |          }k|j        dk    r^||ur>|                     t          j                            |          |j        |j                   |                     |          }
|
J |
}|                     t          j                            |j                  |j        |j                   t7          ||||j        |j                  S )Nz,Suggestion: use {0}[...] instead of {0}(...)r  r   r}   r  r,  )r/  stringify_namer   r  r   r   r   r  r#  r   ARG_CONSTRUCTOR_NAME_EXPECTEDr   r9  rm   rw   r  r"  r  r   _extract_argument_nameARG_CONSTRUCTOR_TOO_MANY_ARGSr<  r   r  MULTIPLE_VALUES_FOR_NAME_KWARGMULTIPLE_VALUES_FOR_TYPE_KWARGARG_CONSTRUCTOR_UNEXPECTED_ARGrn   )r  r   fconstructorr  r  default_typer   r.  r  r   r*  r   s                r   r1  zTypeConverter.visit_Call*  sv   F$Q''$++--33 	3D ZELL[YY$$QT$222 	^II&DahPQP\]]]y566 '' 	b 	bFAsAvv JJsOO	 ,,,a22377		*H!(TUT`aaaa 	 	AGEu#II(GNN{[[  
 22599&l**II(GNN{[[  
 !JJu--	 ,,,		$CJJ15QQL$   
  T;!,OOOr   rv   c                H     t           fd|D              j                  S )Nc                :    g | ]}                     |          S r   rb  rc  s     r   r   z9TypeConverter.translate_argument_list.<locals>.<listcomp>`  s#    2221A222r   r  )rv   r   rH  s   ` r   translate_argument_listz%TypeConverter.translate_argument_list_  s-    2222222CCCCr   r4  c                h   t          |t                    r3t          |j        t                    r|j                                        S t          |t                    r	|j        d S |                     t          j                            t          |          j
                  | j        d           d S rL  )r   r  r   r   r   r#  r    ARG_NAME_EXPECTED_STRING_LITERALr   r,  r/  r   r  s     r   r  z$TypeConverter._extract_argument_nameb  s    a"" 	z!'3'?'? 	7==??"8$$ 	4		=DDT!WWEUVVI	
 	
 	

 tr   r   c                j    t          |j        | j        |                     |j                            S )Nr   r   )rx   r  r   r  r9  r  s     r   r]  zTypeConverter.visit_Namen  s+    14di8K8KAL8Y8YZZZZr   r  c                B   t          |j        t          j                  s|                     |          S |                     |j                  }|                     |j                  }t          ||g| j	        | 
                    |j                  | j        d          S )NT)r   r   r   uses_pep604_syntax)r   r  r   r  r  r   r  r  ry   r   r  r9  r   )r  r4  r  r  s       r   r  zTypeConverter.visit_BinOpq  s    !$
++ 	($$Q'''zz!&!!

17##5M&&q|44*#
 
 
 	
r   r  c                R   |j         }|t          d| j                  S t          |t                    rt          |d| j        |j                  S |t          u rt          | j                  S t          |t                    rt          |d| j                  S t          |t          t          t          f          r|                     ||          S t          |t                    r,t!          |          }t          |d| j        |j                  S |                     |          S )Nr  r  zbuiltins.strzbuiltins.boolzbuiltins.bytes)r   )r   rx   r   r   r   r  r9  r  rp   r
  rs   r   r4  r5  numeric_typer3  r{   r  )r  r4  r6  contentss       r   r7  zTypeConverter.visit_Constant  s   g;vDI6666c3 	S$S.$)Q\RRR(??TY////c4   	K$S/	JJJJcC011 	-$$S!,,,c5!! 	a3C88H$X/?STS_````  ###r   r   c                   |                      |j                  }t          |t                    rFt          |j        t
                    r,t          |j        t                    r|xj        dz  c_        |S |                     |          S )Nr   )	r   r  r   rs   r  r   literal_valuer   r  )r  r4  r   s      r   r  zTypeConverter.visit_UnaryOp  s     jj##c,-- 	*QT42H2H 	#+S11 !!R'!!
  ###r   r   objectc           
         t          |t                    r|}d}nd }dt          |          j         }t	          ||| j        t          |dd                    S )Nzbuiltins.intz	builtins.r9  r   r  )r   r   r,  r/  rs   r   r0  )r  r   r4  numeric_value	type_names        r   r  zTypeConverter.numeric_type  sn    
 eS!! 	;(-M&II
 !M:DKK$8::I 949WQVX=Y=Y
 
 
 	
r   
ast3.Indexc                    |                      t          t          |          j                  }t	          |t
                    sJ |S r  )r   r   r   r   r   ru   rv  s      r   rw  zTypeConverter.visit_Index  rx  r   rk  c                0    |                      |d          S )Nz(did you mean to use ',' instead of ':' ?r  )r  r  s     r   rp  zTypeConverter.visit_Slice  s      )S TTTr   rS  c                   t           j        dk    r	|j        }nWt          |j        t          j                  r|j        j        }n*t          |j        t          j                  r<t          j	        |j                  }t          |dd           |j        j        |_        nt          |j        t          j                  sJ t          j	        |j        j                  }|D ]s}t          |dd           `t          |t          j                  r|j        j        |_        ?t          |t          j                  r|j        J |j        j        |_        tt	          j        ||j                  }d}t          |t          j                  r5|                     |j                  }t'          |j                  dk    rd}n|                     |          g}|                     |j                  }t          |t*                    r*|j        s#t+          |j        || j        |j        |          S |                     |          S )Nr   r9  Fr   T)r   r   empty_tuple_index)r   r   rU  r   r   r   r   rV  copydeepcopyr0  rm  r9  rW  rs  Tuplerd  rI  r  rd  r   rx   r  r  r   r   r  )r  r4  slicevalrs  ro  r  paramsr   s           r   rY  zTypeConverter.visit_Subscript  s   v%%GHH,, 	/GMHH,, 	/}QW--Hxt44<&.n&?#agt}55555=..D : :1lD119!!TZ00 :'(w'9#Atz22 : w222'(w'9z$..H!h
++ 	,--hm<<F8=!!Q&&$(!jj**+F

17##e[)) 		(%* 		(
Y|"3    $$Q'''r   rh  c           	         t          |                     |j                  t          d| j        |                     |j                            S )NT)implicitr   r   )rt   rI  r  r   r   r  r9  r  s     r   rj  zTypeConverter.visit_Tuple  sJ    $$QV,,&&q|44
 
 
 	
r   r   c                    |                      |j                  }t          |t                    r,|j        s%t          |j         d|j         | j                  S |                     |          S )Nr   r  )	r   r   r   rx   r  r  r  r   r  )r  r4  
before_dots      r   rR  zTypeConverter.visit_Attribute  sk    ZZ((
j+.. 	(z 	(*/<<AF<<49MMMM$$Q'''r   ast3.Starredc                T    t          |                     |j                  d          S )NT)from_star_syntax)rz   r   r   r  s     r   r[  zTypeConverter.visit_Starred  s#    $**QW--EEEEr   r^  c                |    t          |j        t          j                  sJ |                     |j                  }|S r  )r   rd  r   Loadr  r  )r  r4  results      r   rg  zTypeConverter.visit_List  s6    !%+++++--af55r   )r   r   T)
r   r   r   r   r   r   r   r
  r   r  )r   r   r   r   r  )r  r   r  r   r   rs   )r  r	  r   rr   )r  r)  r   rr  )r   r)  )r   r   r   r   r   r   r   r  r  )r=  r  r   r  )r   r   r   ru   )r=  r  r   rv   )r4  r	  r   r   )r4  r   r   ru   )r4  r  r   ru   )r4  r  r   ru   )r4  r   r   ru   )r   r  r4  r   r   ru   )r4  r  r   ru   )r4  rk  r   ru   )r4  rS  r   ru   )r4  rh  r   ru   )r4  r   r   ru   )r4  r  r   ru   )r4  r^  r   ru   )r/  r  r  r  r  r  r   r   r  r#  r  rI  r1  r  r  r]  r  r7  r  r  rw  rp  rY  rj  rR  r[  rg  r   r   r   r   r     sS        !!) ) ) ) )	( 	( 	( 	(
 
 
 
 
    X    X" " " ""# # # #U U U UV V V V* * * *3P 3P 3P 3PjD D D D
 
 
 
[ [ [ [
 
 
 
$ $ $ $.$ $ $ $
 
 
 
$   U U U U
)( )( )( )(V
 
 
 
( ( ( (F F F F     r   r   r4  c                    t          | t                    r| j        S t          | t                    r"t	          | j                  }|| d| j         S d S )Nr   )r   r   r  r   r  r   r  )r4  svs     r   r  r    s\    !T $t	Ay	!	! $AG$$>##16###4r   c                  R    e Zd ZdZddZddZdd	ZddZddZddZ	ddZ
ddZdS )rf  zACheck if an AST contains attribute assignments (e.g. self.x = 0).r   r  c                "    d| _         d| _        d S NFlvaluerh  r  s    r   r  zFindAttributeAssign.__init__  s    


r   ro  r   c                `    d| _         |j        D ]}|                    |            d| _         d S NTF)r  rO  rg  r  ro  lvs      r   visit_assignment_stmtz)FindAttributeAssign.visit_assignment_stmt  s6    ) 	 	BIIdOOOOr   r[   c                    d| _         |j        D ]}||                    |            d| _         |j                            |            d S r  )r  rU  rg  r   r  s      r   visit_with_stmtz#FindAttributeAssign.visit_with_stmt  sP    ( 	  	 B~		$	dr   r2   c                    d| _         |j                            |            d| _         |j                            |            |j        r|j                            |            d S d S r  )r  rX  rg  r   r  r  ro  s     r   visit_for_stmtz"FindAttributeAssign.visit_for_stmt$  sh    	t	d; 	%Kt$$$$$	% 	%r   r/   c                    d S r  r   r!  s     r   visit_expression_stmtz)FindAttributeAssign.visit_expression_stmt,      r   r   r#   c                    d S r  r   r  r   s     r   visit_call_exprz#FindAttributeAssign.visit_call_expr0  r%  r   r;   c                    d S r  r   r'  s     r   visit_index_exprz$FindAttributeAssign.visit_index_expr4  r%  r   rA   c                &    | j         r	d| _        d S d S rd  r  r'  s     r   visit_member_exprz%FindAttributeAssign.visit_member_expr8  s!    ; 	DJJJ	 	r   Nr   r  )ro  r   r   r  )ro  r[   r   r  )ro  r2   r   r  )ro  r/   r   r  )r   r#   r   r  )r   r;   r   r  )r   rA   r   r  )r/  r  r  __doc__r  r  r  r"  r$  r(  r*  r,  r   r   r   rf  rf    s        KK         % % % %              r   rf  c                  *    e Zd ZdZddZddZdd	Zd
S )ri  z/Check if an AST contains yields or yield froms.r   r  c                    d| _         d S r  rh  r  s    r   r  zFindYield.__init__@  s    


r   r   r\   c                    d| _         d S rd  r1  r'  s     r   visit_yield_exprzFindYield.visit_yield_exprC      


r   r]   c                    d| _         d S rd  r1  r'  s     r   visit_yield_from_exprzFindYield.visit_yield_from_exprF  r4  r   Nr-  )r   r\   r   r  )r   r]   r   r  )r/  r  r  r.  r  r3  r6  r   r   r   ri  ri  =  sV        99           r   ri  ro  rV  c                   t          |           }|dk    rdS d}t          | d         t                    r%t          | d         j        t                    r|dz  }||k    rdS ||dz   k    rdS | |         }t          |t
          t          f          p.t          |t                    ot          |j        t                    S )zCould the statements form a "trivial" function body, such as 'pass'?

    This mimics mypy.semanal.is_trivial_body, but this runs before
    semantic analysis so some checks must be conservative.
    r   Fr}   T)rd  r   r/   r  rS   rJ   rK   r-   )ro  r=  r.  rn  s       r   re  re  J  s     	AAAvvu	A!A$'' Jqty',J,J 	QAvvt1q5yyuQ4DdXy122 4((PZ	<-P-Pr   )
r   r   r   r   r   r   r   r   r   r   r  )r   r   r   r   r   r   r   r   r   r   r   rB   )r   r   r   r   )
r   r   r   r   r   r   r   r   r   r   )
r   r   r   r   r   r   r   r   r   rr   )r  r	  r   r
  )r4  r   r   r   )ro  rV  r   r
  )
__future__r   r  r   r   r   r  r   r   r   r   r   r	   r
   r   r   typing_extensionsr   r   mypyr   r   r   r   mypy.errorsr   mypy.message_registryr   
mypy.nodesr   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   r1   r2   r3   r4   r5   r6   r7   r8   r9   r:   r;   r<   r=   r>   r?   r@   rA   rB   rC   rD   rE   rF   rG   rH   rI   rJ   rK   rL   rM   rN   rO   rP   rQ   rR   rS   rT   rU   rV   rW   rX   rY   rZ   r[   r\   r]   r^   mypy.optionsr_   mypy.patternsr`   ra   rb   rc   rd   re   rf   rg   mypy.reachabilityrh   ri   mypy.sharedparserj   rk   mypy.traverserrl   
mypy.typesrm   rn   ro   rp   rq   rr   rs   rt   ru   rv   rw   rx   ry   rz   	mypy.utilr{   r|   r   r~   r  r   r   r   r   r   r   r   r   r   r   r   r   r  r  	TypeAliasr  ry  r  r  r  r  r  r  r  r  r  rn  r|  ExceptHandlerr5  r  r   r   r   compiler   r   r   r   r  r  r   r   r  rf  ri  re  r   r   r   <module>rH     sM	   " " " " " " "  				 



  W W W W W W W W W W W W W W W W W W W W W W / / / / / / / / @ @ @ @ @ @ @ @ @ @       . . . . . .L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L LZ !          	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 Y X X X X X X X N N N N N N N N + + + + + +                                 E D D D D D D D *1-  - - - -     X W W W W W W W W W W W W W W W W W W W W W K[	 	 	 	 	 N	=wNMMMwJEJ(N&MI$LJlGlGDIty$,8JJKGGEJNMILJGGDIty$*<<=GwlGGGGCt #(#OPP  P P P P!"2B;; ; ; ; ;'RZ(IJJ  J J J J #@ @ @ @ @F< < < <$#" #" #" #"LP P P P0   }& }& }& }& }& }& }& }&@,i i i i i i i iX	   + + + + +* + + +\
 
 
 
 
  
 
 
     r   