
    X-PhR                      U d dl mZ d dlZd dlZd dl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 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-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`maZambZbmcZcmdZdmeZemfZfmgZgmhZhmiZimjZj d d	lkmlZl d d
lmmnZnmoZompZpmqZqmrZrmsZsmtZtmuZu d dlvmwZwmxZx d dlymzZzm{Z{ d dl|m}Z} d dl~mZmZmZmZmZmZmZmZmZmZmZmZmZmZmZ d dlmZmZ ej        d         Zded<   d dlZd dlmZmZmZmZmZmZmZmZmZmZ efdPdZej        Zej        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Zej        d k    rej        Zej        Zej        Zej        ZneZeZeZeZ ed!eN"          Z ee!g d#          Zded$<    ej        d%          Zded&<   	 dQdRd/ZdSd2ZdTd8ZdUd<ZdVd@ZdWdBZ G dC dD          Z G dE dF          ZdXdHZ G dI dJe}          Z G dK dLe}          ZdYdOZdS )Z    )annotationsN)Sequence)	AnyCallableFinalLiteralOptionalTypeVarUnioncastoverload)defaults
errorcodesmessage_registry)Errors)ErrorMessage)P	ARG_NAMEDARG_NAMED_OPTARG_OPTARG_POSARG_STAR	ARG_STAR2MISSING_FALLBACKPARAM_SPEC_KINDTYPE_VAR_KINDTYPE_VAR_TUPLE_KINDArgKindArgument
AssertStmtAssignmentExprAssignmentStmt	AwaitExprBlock	BreakStmt	BytesExprCallExprClassDefComparisonExprComplexExprConditionalExprContinueStmt	DecoratorDelStmtDictExprDictionaryComprehensionEllipsisExpr
ExpressionExpressionStmt	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TypeAliasStmt	TypeParam	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TypedDictTypeTypeList	TypeOfAnyUnboundType	UnionType
UnpackType)bytes_to_human_readable_reprunnamed_function   r   PY_MINOR_VERSION)
AST	AttributeCallFunctionTypeIndexNameStarredUAdd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       N/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/mypy/fastparse.py
ast3_parser      s,     :'       )   
   )r      r      N)bound_dummy_fallbackz[^#]*#\s*type:\s*ignore\s*(.*)TYPE_IGNORE_PATTERNfnammodule
str | Noneerrorsr   optionsOptions | NonerD   c           	     0   |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          |||||                              |	          }
n8# t           $ ry}	 t#          j                                        |	           |# t           $ r9 |                    ddddt(          j                   t-          g g di           }
Y nw xY wY d}~nd}~wt.          $ r}|j        }|t2          j        j        k    r;|                    d          r&|j        d          d|j        d          }|d| dz  }|                    |j        |j        nd|j        |dt(          j                   t-          g g di           }
Y d}~nd}~ww xY wtA          |
t,                    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pathr   z&Source expression too complex to parseFblockercodezinvalid syntax.z+; you likely need to run mypy using Python z	 or newerT)!ignore_errorsignored_filespreserve_astsrc   set_fileendswithr   PYTHON3_VERSIONpython_versionwarningscatch_warningsfilterwarningsDeprecationWarningr   ASTConvertervisitRecursionErrorr   NodeVisitorreportcodesMISCrD   SyntaxErrormsgsysversion_infominor
startswithlinenooffsetSYNTAX
isinstance)r   r   r   r   r   r   r   is_stub_filer   asttreeemessagepython_version_strs                 r   r   r      sy    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0+$&& 	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
 
 
 %** 	    	 $$S))) G  	/ 	/ 	/MMB@%V[V`     BE2..DDD	/
 DDDD  + + +%S-3338J8JK[8\8\3$+$:1$=![![@VWX@Y![![bEWbbbbG,AHH"H 	 	
 	
 	
 Br**+ dH%%%%%Ksh   E /DE DE D*E 
I<&E:8G:A F=:G<F==GI<B I77I<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   r1   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_namerv   c                   	 t          d|  d||d          \  }}t          |t          t          f          r|j        | |_        ||_        |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}   r~   original_str_exproriginal_str_fallbackrw   r   
ValueError)r  r  r   r   _nodes         r   parse_type_stringr  S  s    P$%7%7%7%7d6Z^___4d[)455 	T$:P:X%0D");D&K$[2DdFSSS$ P P P !.@$OOOOOPs   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  i  sj    $ Nw/))	D)	$	$ Ndj$'' 	N:=H,Mo1MM5r   ast3.expr | Nonec                    | d S t          j        |           D ]B}t          |t           j        t           j        t           j        t           j        f          r|c S Cd S N)r   walkr   Yield	YieldFrom	NamedExprAwait)r  r  s     r   .find_disallowed_expression_in_annotation_scoper  r  sY    |t	$  dTZTUU 	KKK	4r   c                     e Zd ZU dGdZdHdZdIdZdJdZdKdZdLdZdMd"Z	dNd%Z
dOd'Zd(d(d(d)dPd0ZdQd5Zej        d6e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        dBiZdCedD<   dRdGZej        dHej         dIej!        dJej"        dKej#        dLej$        dMej%        dNej&        dOej'        dPej(        dQi
Z)dCedR<   dSdTZ*dTdWZ+dUdZZ,d(d(d[dVd\Z-dWd]Z.	 dXdYdaZ/dZdcZ0d[ddZ1d\dfZ2d]dhZ3d^dlZ4d_doZ5d`dqZ6	 dadbdsZ7dcdxZ8	 daddd}Z9	 dadedZ:dfdZ;dgdZ<dhdZ=didZ>djdZ?dkdZ@dldZAdmdZBdndZCdodZDdpdZEdqdZFdrdZGdsdZHdtdZIdudZJdvdZKdwdZLdxdZMdydZNdzdZOd{dZPd|dńZQd}dȄZRd~d˄ZSdd΄ZTddфZUddԄZVddׄZWddڄZXdd܄ZYdd߄ZZdd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dBZ|ddDZ}ddFZ~d^S (  r   r   rc   r   r  r   r   r   r   r   r   Nonec                   g | _         g | _        || _        || _        || _        || _        || _        i | _        i | _        d S r  )	class_and_function_stackimportsr   r   r   r   r   type_ignoresvisitor_cache)selfr   r   r   r   r   s         r   __init__zASTConverter.__init__|  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.note  s+    4vELQQQQQr   r   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.fail  s|     	X$,4 	XK..	4,dl.H   KtVSYchWWWWW	X 	Xr   r  r8   c                `    |                      t          j        |j        |j        d           d S )NFr   r   r   )r1  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   r>  end_line
end_column)r'  r  rB  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'  rK  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   listr1   rR  r'  rK  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   r5  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]r`  ra  rb  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, Fr3  r   FCr   )r%  minr_  joinr1  r   "TYPE_IGNORE_WITH_ERRCODE_ON_MODULEr   r   used_ignored_linesfilerO  r   FILEr   r#   fix_function_overloadstranslate_stmt_listset_block_linesrm   r#  r   lenr   is_possible_trivial_bodyFindAttributeAssignacceptfound	FindYield)r'  rc  r`  ra  rb  ignoresjoined_ignoresblockstackrP  stmtr  r@  syield_visitors                  r   rq  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  rG  r   r%  )r'  rB  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_operator7  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_operatorK  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   rE  rF  )r   r   rG  r   r>  rH  rI  r   r   r,   rJ   )r'  r  rc  firstlast	new_firsts         r   rr  zASTConverter.set_block_linesR  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#   rp  rq  rr  )r'  rc  r  s      r   as_blockzASTConverter.as_blocka  sS     	+d11$2J2J52Q2QRRSSA  E***r   ra  rb  c          	         |sJ t          |                     |                     |||                              }|                     ||           |S )Nr  r  )r'  rc  ra  rb  r  s        r   as_required_blockzASTConverter.as_required_blockh  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   r8   _check_ifstmt_for_overloads'_get_executable_if_block_with_overloadsr,   r5   namerO  rJ   extenditemsr6  r   r   rV  r   pop_strip_contents_from_if_stmtrs  r   )r'  rc  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_stmtsr}  if_overload_nameif_block_with_overloadif_unknown_truth_valuepoppedif_stmts                    r   rp  z#ASTConverter.fix_function_overloadst  s   !/1,0&+#&*KO15"59#)+ q	% q	%D+/37"48"$'' ,G5,P,P#'#C#CDJ_#`#` #/DDTJJ E+-C
 &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   Nr}  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   )rs  r   r   r,   rJ   r5   allr   r   r  	else_bodyr8   r  )r'  r}  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)rl   r   r  r   is_unreachabler   r8   r  r'  r}  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)rs  r   r  r   r8   r  r  s     r   r  z)ASTConverter._strip_contents_from_if_stmtL  s     ty>>Q "DIaL> 	)c$."566!;;$.-a0&99 )11$.2Ea2HIIIII&(###		) 	);;r   rT   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   r8   rs  r   r  r  r  s     r   r  z!ASTConverter._is_stripped_if_stmtZ  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_idm  s    2228	r   modast3.ModulerD   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)r`  )ignored_lines)r%  r   r   r   r1  r   r   rp  rq  r   rD   r$  r   r   )r'  r  tiparsedr   r  s         r   visit_ModulezASTConverter.visit_Modules  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'  rB  s     r   visit_FunctionDefzASTConverter.visit_FunctionDef  s    """r   ast3.AsyncFunctionDefc                0    |                      |d          S )NT)rb  r  r  s     r   visit_AsyncFunctionDefz#ASTConverter.visit_AsyncFunctionDef  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             }d}	g }
|rdgt          |          z  }
d}nq|j        	 t          |j        dd	          }t          |t                    sJ t          |j                  d
k    rut          |j        d         t"                    rU|j        d         j        t&          u r<|j        r(|                     t,          j        ||j        d           d |D             }
n|j        st	          d |D                       r(|                     t,          j        ||j        d           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$                             ns# tJ          $ r |j        &                    dd          d         '                                }t,          j(        )                    |          }|                     |||j        d           |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    r!|j.        r| /                    |j.                  }	d |D             }
t3          | j        |j        r|j        j        n|                               |j                  }ta          ||
          D ] \  }}| 1                    ||j2                   !d}t	          |
          s|r$t          |
          d
k    rBt	          d |
D                       r)|                     t,          j3        ||j        d           nt          |
          t          |          k    r)|                     t,          j4        ||j        d           nt          |
          t          |          k     r)|                     t,          j5        ||j        d           n=tm          d |
D             ||||ntE          tF          j7                  tp                    }ts          |dd          }ts          |dd          }| j         :                                 | j                             d           | ;                    |j<        d|          }t{          |j	        ||||	          }t          |j>        tl                    r|j>        ?                                |_@        |rd|_A        |||_B        |C                    |           |j        rt          |j	                  }d|_E        |C                    |           d|_F        | C                    ||           t          ||                     |j                  |          }|j        d         }|C                    |j        |j        ||           |}n| C                    ||           |}| jH        jI        rt          jK        |d           |_L        | 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>  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   Fr  c                \    g | ])}|j         |j         nt          t          j                  *S r  )type_annotationrq   r|   unannotatedr   as     r   r   z,ASTConverter.do_func_def.<locals>.<listcomp>  sI     ! ! !   !0< --!()>!?!?	! ! !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   rh  ri  r   r   )r  r   z.Suggestion: wrap argument types in parenthesesr   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   rt   )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  )rq   r|   r  r  s     r   r   z,ASTConverter.do_func_def.<locals>.<listcomp>  s,    ___PQ!-QQWY5J-K-K___r   rE  rF  rg  r  clean)Mr#  rO  r  r^  anyr   transform_argsargsro   r  r  rs  r   r   r   r   argtypesConstantr   Ellipsisreturnsr1  r   DUPLICATE_TYPE_SIGNATURESrG  r   r   rX  r   rV  r	   ry   r   insertrq   r|   special_formr   r   r   r   r   r+  
from_errorr   r   type_paramstranslate_type_paramszipset_type_optionalinitializerELLIPSIS_WITH_OTHER_TYPEARGSTYPE_SIGNATURE_TOO_MANY_ARGSTYPE_SIGNATURE_TOO_FEW_ARGSrs   r  r   r>  r  r  r   r5   r:  copy_modifiedunanalyzed_typerb  
definitionrJ  r]   is_readyis_decoratedr,   r   include_docstringsr   get_docstring	docstring)r'  rB  rb  r  r   r  r  	arg_kinds	arg_namesexplicit_type_params	arg_typesreturn_typefunc_type_asttranslated_argsin_method_scoper   r  arg_typer  rH  rI  r   func_defvardecor  retvals                              r   r  zASTConverter.do_func_def  s    	%,,S111]$]$]AL\$]$]$]!]!]
 
 ""166"OO'// 	$ $ $#.....	QQDQQQ	7;')	 B	T*IKK^'6< *1>=+ V V!->>>>> .//144"=#9!#<hGG 5%.q178CCy 		,F"L$)	 "   ! ! "&! ! !II y C'T'Tt'T'T'T$T$T 		,F"L$)	 "    3@&!,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<	GGG> anQ&7z&I&IIIH&RSR^   %Y%9::;c$iiG	%i&:;;	< 7**q}*'+'A'A!-'P'P$99D999I'ai"K!)"2"2V  eAI  !y11 	> 	>MC""8S_====	y>> 	[ 	9~~""s*Z*ZPY*Z*Z*Z'Z'Z"		$AL!	      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:NOOhm\22 	E'/}'B'B'D'DH$ 	)$(H! #+I v&&& 	hm$$C CLLL   $(H!MM(A&&&Xt'?'?@P'Q'QSVWWD$Q'EMM%,(8(JOOO*.FFMM(A&&&F<* 	D!%!3AU!C!C!CH%))+++s   G3K C/N65N6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   rE   r  r}   optional)r'  r:  r  r)  s       r   r  zASTConverter.set_type_optional1  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>a  s    ???s*???r   )r>  r   rV  r   r  r  r   rs  	enumeraterO  make_argumentr   r
  r   varargr   
kwonlyargskw_defaultsr   r   kwargr   rb   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_args9  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defaultr  r  r   r  r   c           
     P   |rd }n|j         }|j        }|/|-|                     t          j        |j        |j        d           d }|/t          | j        |j                  	                    |          }n| 
                    ||          }t          |j                  rd}t          |j        |          }	d|	_        t          |	|| 	                    |          ||          }
|
                    |j        |j        t#          |dd           t#          |dd                      |
S )NFr  r  TrE  rF  )
annotationr   r1  r   r  r   rG  r   r   r   r  rn   r  r]   is_inferredr   rJ  r>  )r'  r  r>  r  r  r  r   r@  r   r"  arguments              r   r0  zASTConverter.make_argumente  s<     	JHHJ+L%,*B		$>JN!	     H%(3:FFFLLZXX66sLIIsw'' 	H#'8$$C4::g+>+>hOOJNCt,,C)400		
 	
 	
 r   c                f    |                      t          |          |j        |j        d           d S NTr  )r1  r   r   rG  )r'  r   r  s      r   r5  zASTConverter.fail_arg  s.    		,s##SZ	NNNNNr   ast3.ClassDefr'   c           	          j                             d            fd|j        D             }d }t          j        dk    r!|j        r                     |j                  }t          |j         	                    |j
                  d                      |j                  t          |                              d          ||          }                     |j                  |_                             ||            j        j        rt)          j        |d          |_        |j        |_        t3          |dd           |_        t3          |d	d           |_         j                                          |S )
Nri  c                `    g | ]*}|j         	|j                             |j                  f+S r   )r  r   r   )r   kwr'  s     r   r   z/ASTConverter.visit_ClassDef.<locals>.<listcomp>  s5    RRRr26RRVTZZ112RRRr   r   	metaclass)rI  keywords	type_argsFr  rE  rF  )r#  rO  rJ  r   r   r  r	  r'   r  r  r   rX  basesdictr;  r^  
decoratorsrJ  r   r  r   r  r  rG  r   r>  rH  rI  r  )r'  rB  rJ  r  cdefs   `    r   visit_ClassDefzASTConverter.visit_ClassDef  sd   %,,S111RRRRQZRRR 8<w&&1=&#'#=#=am#L#L F""16**$$QW--8nn((55*
 
 
 2213CDDdA<* 	@!/???DNl<66!!%5t<<%))+++r   
type_paramast_TypeVarc                   t          |j                  }|d S t          |t          j        t          j        f          r-|                     t          j        |j	        |j
        d           t          |t          j                  r-|                     t          j        |j	        |j
        d           t          |t          j                  r/|                     t          j        |j	        |j
        d           d S d S rD  )r  r   r   r   r  r  r1  r   "TYPE_VAR_YIELD_EXPRESSION_IN_BOUNDr   rG  r  "TYPE_VAR_NAMED_EXPRESSION_IN_BOUNDr  "TYPE_VAR_AWAIT_EXPRESSION_IN_BOUND)r'  rQ  incorrect_exprs      r   validate_type_paramz ASTConverter.validate_type_param  s   G
HXYY!Fntz4>&BCC 	II C!%	     ndn55 	II C!%	     ndj11 	II C!%	      	 	r   r  	list[Any]list[TypeParam]c           
        g }|D ]}d }g }d }t           j        dk    r3t          | j        |j                                      |j                  }t          |t                    r1|	                    t          |j        t          d g |                     t          |t                    r1|	                    t          |j        t          d g |                     t          |j        t           j                  rt%          |j        j                  dk     r.|                     t*          j        |j        |j        d           nt          | j        |j                  fd|j        j        D             }nO|j        H|                     |           t          | j        |j                                      |j                  }|	                    t          |j        t2          |||                     |S )N)r      r  r   Fr  c                :    g | ]}                     |          S r   r   )r   r  convs     r   r   z6ASTConverter.translate_type_params.<locals>.<listcomp>  s#    !F!F!FA$**Q--!F!F!Fr   )r   r   r   r   r   r   default_valuer   ast_ParamSpecrO  r[   r  r   ast_TypeVarTupler   r   r   Tuplers  eltsr1  r   "TYPE_VAR_TOO_FEW_CONSTRAINED_TYPESrG  rX  r   )r'  r  r  pr   valuesr>  r_  s          @r   r	  z"ASTConverter.translate_type_params  s   ! 	 	A!%E!#F#'G7**'!(CCCII!/ZZ!]++ $++IafotUWY`,a,abbbbA/00 $++af&94WMM    agtz22 U17<((1,,		,OHL$)	 "      -T[qxHHH!F!F!F!F!F!F!FW(,,Q///)$+AHEEEKKAGTTE$++afmUFGLL    $#r   ast3.ReturnrO   c                |    t          |                     |j                            }|                     ||          S r  )rO   r   r   rJ  r'  rB  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   )rs  targetsrY   rX  rJ  r   r-   r   )r'  rB  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)rX  rn  r   r   r  r   r!   rJ  )r'  rB  lvaluesrvaluer   r~  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          }|                     ||           n|                     |j                  }t          | j	        |                              |j
                  }|J |j
        j        |_        t          |                     |j                  g||d          }|                     ||          S )NT)no_rhsr  rs  )r   r   rW   rq   r|   r  rJ  r   r   r   r@  rG  r   r!   target)r'  rB  r   rv  r   r~  s         r   visit_AnnAssignzASTConverter.visit_AnnAssign  s    x7?!)')2H*I*IRV!W!W!WFMM&!$$$$ZZ((FDKd33399!,GG\,
DJJqx0016PTUUU}}Q"""r   ast3.AugAssignrH   c                    t          |                     |j                  |                     |j                  |                     |j                            }|                     ||          S r  )rH   r  r  r   r{  r   rJ  r'  rB  r~  s      r   visit_AugAssignzASTConverter.visit_AugAssign  sZ    "qt$$djj&:&:DJJqw<O<O
 
 }}Q"""r   ast3.Forr4   c                J   |                      ||j                  }t          |                     |j                  |                     |j                  |                     |j                  |                     |j	                  |          }| 
                    ||          S r  )r  r   r4   r   r{  iterr  r   r  orelserJ  r'  rB  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)r  r   r4   r   r{  r  r  r   r  r  is_asyncrJ  r  s       r   visit_AsyncForzASTConverter.visit_AsyncFor'  s    11!Q^DDJJqx  JJqv""16**MM!(##
 
 }}T1%%%r   
ast3.Whiler^   c                    t          |                     |j                  |                     |j                  |                     |j                            }|                     ||          S r  )r^   r   testr  r   r  r  rJ  rj  s      r   visit_WhilezASTConverter.visit_While4  sZ    JJqv 6 6qv > >ah@W@W
 
 }}T1%%%r   ast3.Ifc                    t          |                     |j                  g|                     |j                  g|                     |j                            }|                     ||          S r  )r8   r   r  r  r   r  r  rJ  rj  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>E  '    999ATZZ''999r   c                D    g | ]}                     |j                  S r   r   optional_varsr  s     r   r   z+ASTConverter.visit_With.<locals>.<listcomp>F  '    :::QTZZ((:::r   )r  r   r_   r  r  r   rJ  r  s   `   r   
visit_WithzASTConverter.visit_WithB  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   r  r  s     r   r   z0ASTConverter.visit_AsyncWith.<locals>.<listcomp>P  r  r   c                D    g | ]}                     |j                  S r   r  r  s     r   r   z0ASTConverter.visit_AsyncWith.<locals>.<listcomp>Q  r  r   T)r  r   r_   r  r  r   r  rJ  )r'  rB  r  r~  s   `   r   visit_AsyncWithzASTConverter.visit_AsyncWithM  s    11!Q^DD9999999::::!':::""16**	
 
 
}}Q"""r   
ast3.RaiserM   c                    t          |                     |j                  |                     |j                            }|                     ||          S r  )rM   r   exccauserJ  rj  s      r   visit_RaisezASTConverter.visit_RaiseY  sA    AE**DJJqw,?,?@@}}T1%%%r   ast3.TryrX   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  rJ  rE   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>b  '    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>c  )    GGGqD**1622GGGr   )handlersrX   r  r   r  r  	finalbodyrJ  r'  rB  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>p  r  r   c                D    g | ]}                     |j                  S r   r  r  s     r   r   z.ASTConverter.visit_TryStar.<locals>.<listcomp>s  r  r   c                D    g | ]}                     |j                  S r   r  r  s     r   r   z.ASTConverter.visit_TryStar.<locals>.<listcomp>t  r  r   T)	r  rX   r  r   r  r  r  is_starrJ  r  s   `     r   visit_TryStarzASTConverter.visit_TryStaro  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   r  r   rJ  rj  s      r   visit_AssertzASTConverter.visit_Assert  sA    $**QV,,djj.?.?@@}}T1%%%r   ast3.Importr9   c                0   g }|j         D ]N}|                     |j                  }|j        }|||j        k    r|j        }|                    ||f           Ot          |          }| j                            |           |                     ||          S r  )r7  r  r  asnamerO  r9   r$  rJ  )r'  rB  r7  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.ImportFromr;   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   r  r   c                *    g | ]}|j         |j        fS r   )r  r  r  s     r   r   z1ASTConverter.visit_ImportFrom.<locals>.<listcomp>  s!    555!&!(#555r   )levelrs  r7  r  r   r:   r<   r  r$  rO  rJ  )r'  rB  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.Globalr7   c                V    t          |j                  }|                     ||          S r  )r7   r7  rJ  )r'  rB  gs      r   visit_GlobalzASTConverter.visit_Global  s%    qw}}Q"""r   ast3.NonlocalrG   c                V    t          |j                  }|                     ||          S r  )rG   r7  rJ  )r'  rB  r  s      r   visit_NonlocalzASTConverter.visit_Nonlocal  s%    !!}}Q"""r   	ast3.Exprr2   c                    |                      |j                  }t          |          }|                     ||          S r  )r   r   r2   rJ  )r'  rB  r   r  s       r   
visit_ExprzASTConverter.visit_Expr  s6    

17##e$$}}T1%%%r   	ast3.PassrL   c                J    t                      }|                     ||          S r  )rL   rJ  r  s      r   
visit_PasszASTConverter.visit_Pass  s    JJ}}Q"""r   
ast3.Breakr$   c                J    t                      }|                     ||          S r  )r$   rJ  r  s      r   visit_BreakzASTConverter.visit_Break  s    KK}}Q"""r   ast3.Continuer+   c                J    t                      }|                     ||          S r  )r+   rJ  r  s      r   visit_ContinuezASTConverter.visit_Continue  s    NN}}Q"""r   r  r    c                    t          |                     |j                  |                     |j                            }|                     ||          S r  )r    r   r{  r   rJ  r  s      r   visit_NamedExprzASTConverter.visit_NamedExpr  sA    4::ah//AG1D1DEE}}Q"""r   ast3.BoolOprI   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 )rs  rg  r  r   r   AndOrr  r   r:  r   rX  )r'  rB  op_noder  s       r   visit_BoolOpzASTConverter.visit_BoolOp  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   )rs  rI   r   rJ  )r'  r  r  rB  r   s        r   r   zASTConverter.group  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:  rI   r   leftrightrJ  r'  rB  r  r   s       r   visit_BinOpzASTConverter.visit_BinOp  s    %%:83tADzz??JKKK2tzz!&))4::ag+>+>??}}Q"""r   ast3.UnaryOpr\   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~notr  r  zcannot translate UnaryOp )r   r  r   InvertNotr   r   r  r   r:  r\   r   operandrJ  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   rG  r#  rO  r?   r  r  r  r  rJ  )r'  rB  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   r  r   r  rJ  r'  rB  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.   rV  r
  rR  keysrX  rg  rJ  r  s      r   
visit_DictzASTConverter.visit_Dict  s^    T11!&994;S;STUT\;];]^^__
 
 }}Q"""r   ast3.SetrQ   c                |    t          |                     |j                            }|                     ||          S r  )rQ   rX  rd  rJ  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   GeneratorExprJ  r  s      r   visit_ListCompzASTConverter.visit_ListComp  s>    d55d4;La6P6PQQRR}}Q"""r   ast3.SetComprP   c                    t          |                     t          t          j        |                              }|                     ||          S r  )rP   r  r   r   r  rJ  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   r{  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   rX  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  r  r   r  s     r   r   z/ASTConverter.visit_DictComp.<locals>.<listcomp>(  "    ;;;D$$;;;r   )
generatorsr/   r   keyr   rJ  r'  rB  rn  itersifs_listr  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.GeneratorExpr6   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>0  r  r   c                D    g | ]}                     |j                  S r   r  r  s     r   r   z3ASTConverter.visit_GeneratorExp.<locals>.<listcomp>1  r  r   c                D    g | ]}                     |j                  S r   r!  r  s     r   r   z3ASTConverter.visit_GeneratorExp.<locals>.<listcomp>2  r#  r   c                6    g | ]}t          |j                  S r   r%  r&  s     r   r   z3ASTConverter.visit_GeneratorExp.<locals>.<listcomp>3  r'  r   )r(  r6   r   eltrJ  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"   rJ  )r'  rB  vr   s       r   visit_AwaitzASTConverter.visit_Await8  s4    JJqwaLL}}Q"""r   
ast3.Yieldr`   c                |    t          |                     |j                            }|                     ||          S r  )r`   r   r   rJ  r  s      r   visit_YieldzASTConverter.visit_Yield>  s1    djj))**}}Q"""r   ast3.YieldFromra   c                |    t          |                     |j                            }|                     ||          S r  )ra   r   r   rJ  r  s      r   visit_YieldFromzASTConverter.visit_YieldFromC  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>I  s'    ???AT,,Q//???r   )opsrX  r  comparatorsr(   rJ  )r'  rB  	operatorsoperandsr   s   `    r   visit_ComparezASTConverter.visit_CompareH  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  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>U  s-    DDD!
1g..5QWWADDDr   c                    g | ]	}|j         
S r   )r   rJ  s     r   r   z+ASTConverter.visit_Call.<locals>.<listcomp>U  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>W  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>W  s3     S
 S
 S
8;II)S
 S
 S
r   zlist[Optional[str]])	r  rJ  rX  r&   r   funcr   rs  rJ  )r'  rB  r  rJ  keyword_namesr  r  r   s           r   
visit_CallzASTConverter.visit_CallP  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   rE   r   r   rU   bytesr%   r   r  r   r>   floatr3   complexr)   r  r0   r  r:  rJ  )r'  rB  valr   s       r   visit_ConstantzASTConverter.visit_Constantc  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.JoinedStrr1   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   rk  )rU   rJ  r   rG  rA   rX  rg  rs  r  r   r   rC   r&   r   )r'  rB  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   rJ  r   rG  
conversionchrrU   format_specrC   r&   r   )r'  rB  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   rC   r   r  r  r   r&   calleerE   r  rV   rJ  )r'  rB  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                            }|                     ||          S r  )r=   r   r   slicerJ  r  s      r   visit_SubscriptzASTConverter.visit_Subscript  sA    djj))4::ag+>+>??}}Q"""r   r   rS   c                |    t          |                     |j                            }|                     ||          S r  )rS   r   r   rJ  r  s      r   visit_StarredzASTConverter.visit_Starred  s1    TZZ(())}}Q"""r   r   rE   c                V    t          |j                  }|                     ||          S r  )rE   r  rJ  r  s      r   
visit_NamezASTConverter.visit_Name  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>  s#    &E&E&Etzz!}}&E&E&Er   )rd  r   ctxr   StorerY   rA   rJ  )r'  rB  	expr_listr   s   `   r   
visit_ListzASTConverter.visit_List  sd    &E&E&E&Eaf&E&E&E	aeTZ(( 	$&/	&:&:AA##A}}Q"""r   
ast3.TuplerY   c                |    t          |                     |j                            }|                     ||          S r  )rY   rX  rd  rJ  r  s      r   visit_TuplezASTConverter.visit_Tuple  s3    d..qv6677}}Q"""r   
ast3.SlicerR   c                    t          |                     |j                  |                     |j                  |                     |j                            }|                     ||          S r  )rR   r   loweruppersteprJ  r  s      r   visit_SlicezASTConverter.visit_Slice  sQ    djj))4::ag+>+>

16@R@RSS}}Q"""r   ast3.ExtSlicec                v    t          |                     t          t          |          j                            S r  )rY   rX  r   r   dimsr  s     r   visit_ExtSlicezASTConverter.visit_ExtSlice  s)    11$sA,,2CDDEEEr   r   rF   c                    |                      t          t          |          j                  }t	          |t
                    sJ |S r  )r   r   r   r   r   rF   r'  rB  r   s      r   visit_IndexzASTConverter.visit_Index  9    

4Q<<-..%&&&&&r   MatchrB   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   )rB   r   subjectcasesrJ  rj  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   
MatchValuerk   c                |    t          |                     |j                            }|                     ||          S r  )rk   r   r   rJ  rj  s      r   visit_MatchValuezASTConverter.visit_MatchValue  s1    DJJqw//00}}T1%%%r   MatchSingletonri   c                V    t          |j                  }|                     ||          S r  )ri   r   rJ  rj  s      r   visit_MatchSingletonz!ASTConverter.visit_MatchSingleton  s%    ((}}T1%%%r   MatchSequencerh   c                      fd|j         D             }d |D             }t          |          dk     sJ t          |          }                     ||          S )Nc                :    g | ]}                     |          S r   r^  r   rf  r'  s     r   r   z4ASTConverter.visit_MatchSequence.<locals>.<listcomp>  s#    666aDJJqMM666r   c                <    g | ]}t          |t                    |S r   )r   rj   )r   rf  s     r   r   z4ASTConverter.visit_MatchSequence.<locals>.<listcomp>  s'    FFFq
1n(E(EFFFFr   r   )patternsrs  rh   rJ  )r'  rB  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   	MatchStarrj   c                    |j         t          d           }n7|                     t          |j                   |          }t          |          }|                     ||          S r  )r  rj   rJ  rE   )r'  rB  r  r  s       r   visit_MatchStarzASTConverter.visit_MatchStar  sV    6>!$''DD==!&!1!1155D!$''D}}T1%%%r   MatchMappingrf   c                      fd|j         D             } fd|j        D             }|j        d }nt          |j                  }t	          |||          }                     ||          S )Nc                :    g | ]}                     |          S r   r^  )r   rK  r'  s     r   r   z3ASTConverter.visit_MatchMapping.<locals>.<listcomp>  s#    ...!

1...r   c                :    g | ]}                     |          S r   r^  )r   r7  r'  s     r   r   z3ASTConverter.visit_MatchMapping.<locals>.<listcomp>  s#    444A$**Q--444r   )r	  r  restrE   rf   rJ  )r'  rB  r	  rg  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   
MatchClassre   c                                          |j                  }t          |t                    sJ  fd|j        D             }|j        } fd|j        D             }t          ||||          }                     ||          S )Nc                :    g | ]}                     |          S r   r^  r  s     r   r   z1ASTConverter.visit_MatchClass.<locals>.<listcomp>  s#    999tzz!}}999r   c                :    g | ]}                     |          S r   r^  r  s     r   r   z1ASTConverter.visit_MatchClass.<locals>.<listcomp>  s#    @@@A$**Q--@@@r   )	r   clsr   rN   r  	kwd_attrskwd_patternsre   rJ  )r'  rB  	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   MatchAsrd   c                    |j         d }n*t          |j                   }|                     ||          }t          |                     |j                  |          }|                     ||          S r  )r  rE   rJ  rd   r   r  )r'  rB  r  r  s       r   visit_MatchAszASTConverter.visit_MatchAs  sc    6>DDAF##D==q))DAI..55}}T1%%%r   MatchOrrg   c                p     t           fd|j        D                       }                     ||          S )Nc                :    g | ]}                     |          S r   r^  )r   r  r'  s     r   r   z.ASTConverter.visit_MatchOr.<locals>.<listcomp>(  s%    HHH'$**W--HHHr   )rg   r  rJ  rj  s   `  r   visit_MatchOrzASTConverter.visit_MatchOr'  s;    HHHHQZHHHII}}T1%%%r   ast_TypeAliasc                   t          |j                  }|d S t          |t          j        t          j        f          r-|                     t          j        |j	        |j
        d           t          |t          j                  r-|                     t          j        |j	        |j
        d           t          |t          j                  r/|                     t          j        |j	        |j
        d           d S d S rD  )r  r   r   r   r  r  r1  r    TYPE_ALIAS_WITH_YIELD_EXPRESSIONr   rG  r   TYPE_ALIAS_WITH_NAMED_EXPRESSIONr   TYPE_ALIAS_WITH_AWAIT_EXPRESSION)r'  rB  rW  s      r   validate_type_aliasz ASTConverter.validate_type_alias+  s   GPP!Fntz4>&BCC 	II A	     ndn55 	II A	     ndj11 	II A	      	 	r   TypeAliasStmt | AssignmentStmtc                   |                      |j                  }|                     |           |                     |j                  }t          |          }|                     ||j                   t          t          |g                    }|                     ||j                   t          | 
                    |j                  ||          }|                     ||          S )N)r   )r	  r  r  r   r   rO   rJ  r?   r#   rZ   r{  r  )r'  rB  r  r   r  
value_funcr  s          r   visit_TypeAliaszASTConverter.visit_TypeAliasF  s    00??  ###

17## c17###UC5\\222
j!'***T__QV44k:NN}}T1%%%r   )r   rc   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  r8   r   r!  )r  r7  r   r   )r  r   rB  rC  r   r   )rK  rL  r   rM  )rK  rS  r   rT  )r  rY  r   r   )
rc  rd  r`  r  ra  r  rb  r  r   re  )rB  r  r   r   r   r  )r  r  r   r   )r  r  r   r   )r  r#   rc  rd  r   r!  )rc  r  r   r  )rc  r  ra  r  rb  r  r   r#   )rc  re  r   re  r  )r}  r8   r  r   r   r   )r}  r8   r   r  )r}  r8   r   r!  )r}  rT   r   r  )r  r   r   r   )r  r  r   rD   )rB  r  r   r  )rB  r  r   r  )F)rB  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   r  r  r  r  r   r   )r   r   r  r=  r   r!  )rB  rE  r   r'   )rQ  rR  r   r!  )r  rY  r   rZ  )rB  rh  r   rO   )rB  rl  r   r-   )rB  rq  r   r!   )rB  rx  r   r!   )rB  r}  r   rH   )rB  r  r   r4   )rB  r  r   r4   )rB  r  r   r^   )rB  r  r   r8   )rB  r  r   r_   )rB  r  r   r_   )rB  r  r   rM   )rB  r  r   rX   )rB  r  r   rX   )rB  r  r   r   )rB  r  r   r9   )rB  r  r   r;   )rB  r  r   r7   )rB  r  r   rG   )rB  r  r   r2   )rB  r  r   rL   )rB  r  r   r$   )rB  r  r   r+   )rB  r  r   r    )rB  r  r   rI   )r  r   r  rT  rB  r  r   rI   )rB  r  r   rI   )rB  r  r   r\   )rB  r  r   r?   )rB  r  r   r*   )rB  r  r   r.   )rB  r  r   rQ   )rB  r  r   r@   )rB  r  r   rP   )rB  r  r   r/   )rB  r.  r   r6   )rB  r5  r   r"   )rB  r9  r   r`   )rB  r<  r   ra   )rB  r?  r   r(   )rB  r   r   r&   )rB  r  r   r   )rB  rY  r   r1   )rB  r`  r   r1   )rB  r   r   rm  )rB  rt  r   r=   )rB  r   r   rS   )rB  r   r   rE   )rB  r|  r   r}  )rB  r  r   rY   )rB  r  r   rR   )rB  r  r   rY   )rB  r   r   rF   )rB  r  r   rB   )rB  r  r   rk   )rB  r  r   ri   )rB  r  r   rh   )rB  r  r   rj   )rB  r  r   rf   )rB  r  r   re   )rB  r  r   rd   )rB  r  r   rg   )rB  r  r   r!  )rB  r  r   r  )r=  
__module____qualname__r(  r+  r1  r6  r   rJ  rR  rX  r_  rq  r  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  rr  r  r  rp  r  r  r  r  r  r  r  r  r  r  r  r0  r5  rP  rX  r	  rk  rp  rw  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  r  r-  r  r8  r;  r>  rG  rR  rX  r_  rl  rs  rw  ry  r{  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r   r   r   r   r   {  s	        I I I I0R R R R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\
 
 
 
 
 
K K K K\ AE) ) ) ) )V   @) ) ) )A A A A&      *# # # #
6 6 6 6 QV_ _ _ _ _B% % % % FK* * * * *d % % % % %NO O O O   <   4 $  $  $  $F& & & &
& & & &# # # ## # # ## # # #	& 	& 	& 	&
& 
& 
& 
&& & & && & & && & & &	# 	# 	# 	#& & & &
& & & &"& & & &&& & & &
# # # # # # # ## # # #
# # # #
& & & &# # # #
# # # #
# # # ## # # #
E E E E# # # ## # # ## # # #$	 	 	 	# # # #
# # # ## # # #
# # # #
# # # #
# # # ## # # ## # # ## # # #
# # # #
# # # ## # # #&# # # #03 3 3 3,3 3 3 3&# # # ## # # #
# # # #
# # # #
# # # ## # # ## # # #
F F F F
   & & & && & & && & & && & & && & & &
& 
& 
& 
&& & & && & & && & & &   6& & & & & &r   r   c                     e Zd Z	 	 	 dJdKdZdLdZdMdNdZedOd            ZedPd            ZdPdZdQdZdRd Z	dSd"Z
dTd&ZdUd*ZdVd,ZdWd.ZdXd0ZdYd2ZdZd4Zd[d6Zd\d9Zd]d;Zd^d=Zd_d?Zd`dAZdadCZdbdEZdcdGZdddIZdS )er   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__V  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_columnc  s      !##M''r   Nr  r   r+  r   rw   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.AnyrG  r   )r   r   r+  )rw   r   r>  )r'  r  r+  s      r   invalid_typezTypeConverter.invalid_typen  s6     !,TYwt\SU7V7V]a
 
 
 	
r   r  rv   c                    d S r  r   r5  s     r   r   zTypeConverter.visit|  s    47Cr   r7  r  c                    d S r  r   r5  s     r   r   zTypeConverter.visit  s    <?Cr   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 nodesNr9  )	r  rO  r<  r=  r>  r   rv   r  r  )r'  r  rA  r@  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   Nrh  )rs  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   r1  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   rK  Sequence[ast3.expr]
list[Type]c                       fd|D             S )Nc                :    g | ]}                     |          S r   r^  r  s     r   r   z5TypeConverter.translate_expr_list.<locals>.<listcomp>  s#    )))!

1)))r   r   rW  s   ` r   rX  z!TypeConverter.translate_expr_list  s    ))))q))))r   r   r   ry   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:  )rP  stringify_namer   r  r   Listr   r  r1  r   ARG_CONSTRUCTOR_NAME_EXPECTEDr   rG  rq   r|   r  r/  r  r   _extract_argument_nameARG_CONSTRUCTOR_TOO_MANY_ARGSrJ  r   r  MULTIPLE_VALUES_FOR_NAME_KWARGMULTIPLE_VALUES_FOR_TYPE_KWARGARG_CONSTRUCTOR_UNEXPECTED_ARGrr   )r'  r   fconstructorr+  r  default_typer   r;  r  r   rK  r   s                r   rR  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   r{   c                H     t           fd|D              j                  S )Nc                :    g | ]}                     |          S r   r^  r  s     r   r   z9TypeConverter.translate_argument_list.<locals>.<listcomp>  s#    2221A222r   r  )r{   r   rW  s   ` r   translate_argument_listz%TypeConverter.translate_argument_list  s-    2222222CCCCr   rB  c                h   t          |t                    r3t          |j        t                    r|j                                        S t          |t                    r	|j        d S |                     t          j                            t          |          j
                  | j        d           d S r[  )r   r  r   r   r   r1  r    ARG_NAME_EXPECTED_STRING_LITERALr   r:  r=  r   r  s     r   r  z$TypeConverter._extract_argument_name  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   )r}   r  r   r  rG  r  s     r   r{  zTypeConverter.visit_Name  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  r~   r   r  rG  r   )r'  rB  r  r  s       r   r  zTypeConverter.visit_BinOp  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   r}   r   r   r   r  rG  r  rt   r  rw   r   rU  rV  numeric_typerT  r   r  )r'  rB  rW  contentss       r   rX  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                P   |                      |j                  }t          |t                    rct	          |j                  t          u rHt          |j        t                    r|xj        dz  c_        |S t          |j        t                    r|S | 
                    |          S )Nr   )r   r  r   rw   r:  literal_valuer   r  r   r   r  )r'  rB  r   s      r   r  zTypeConverter.visit_UnaryOp  s     jj##s-..		 S&''3..!$%% !!R'!!
!$%% 
  ###r   r   objectc           
         t          |t                    r|}d}nd }dt          |          j         }t	          ||| j        t          |dd                    S )Nzbuiltins.intz	builtins.rG  r   r  )r   r   r:  r=  rw   r   r>  )r'  r   rB  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   ry   r  s      r   r  zTypeConverter.visit_Index2  r  r   r  c                0    |                      |d          S )Nz(did you mean to use ',' instead of ':' ?r  )r  r  s     r   r  zTypeConverter.visit_Slice8  s      )S TTTr   rt  c                0   d}t          |j        t          j                  r?|                     |j        j                  }t          |j        j                  dk    rd}n|                     |j                  g}|                     |j                  }t          |t                    rX|j
        sQt          |j        || j        |j        |          }t          |dd           |_        t          |dd           |_        |S |                     |          S )NFr   T)r   r   empty_tuple_indexrF  rE  )r   rv  r   rc  rX  rd  rs  r   r   r}   r  r  r   r   r>  rI  rH  r  )r'  rB  r%  paramsr   results         r   rw  zTypeConverter.visit_Subscript<  s   !agtz** 	+--agl;;F17<  A%%$(!jj))*F

17##e[)) 	(%* 	( 
Y|"3  F !(+;T B BF%at<<FOM$$Q'''r   r  c           	         t          |                     |j                  t          d| j        |                     |j                            S )NT)implicitr   r   )rx   rX  rd  r   r   r  rG  r  s     r   r  zTypeConverter.visit_TupleT  sJ    $$QV,,&&q|44
 
 
 	
r   r  c                0   |j         s|                     |          S i }g }t          |j         |j                  D ]\  }}t	          |t
          j                  rt	          |j        t                    sB|)|	                    | 
                    |                     d|                     |          c S | 
                    |          ||j        <   t          |t                      t                      t          |j        |j                  }||_        |S r  )r	  r  r
  rg  r   r   r  r   r   rO  r   rz   setr   r   rG  extra_items_from)r'  rB  r  r,  	item_namer   r'  s          r   r
  zTypeConverter.visit_Dict]  s   v 	($$Q'''!# #AFAH 5 5 	7 	7Iui77 ,z)/[^?_?_ ,$$++DJJu,=,=>>>((+++++%)ZZ%6%6E)/""uceeSUUOQXq|\\"2r   r   c                    |                      |j                  }t          |t                    r2|j        s+t          |j         d|j         | j        |j                  S | 	                    |          S )Nr   r  )
r   r   r   r}   r  r  r  r   rG  r  )r'  rB  
before_dots      r   rs  zTypeConverter.visit_Attributen  sq    ZZ((
j+.. 	(z 	(*/<<AF<<49UVUabbbb$$Q'''r   ast3.Starredc                T    t          |                     |j                  d          S )NT)from_star_syntax)r   r   r   r  s     r   ry  zTypeConverter.visit_Starredw  s#    $**QW--EEEEr   r|  c                |    t          |j        t          j                  sJ |                     |j                  }|S r  )r   r  r   Loadr  rd  )r'  rB  r'  s      r   r  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   rw   )r  r  r   rv   )r  r7  r   r  )r   r7  )r   r   r   r   r   r   r   r!  r  )rK  r  r   r  )r   r   r   ry   )rK  r  r   r{   )rB  r  r   r   )rB  r   r   ry   )rB  r  r   ry   )rB  r  r   ry   )rB  r   r   ry   )r   r  rB  r   r   ry   )rB  r!  r   ry   )rB  r  r   ry   )rB  rt  r   ry   )rB  r  r   ry   )rB  r  r   ry   )rB  r   r   ry   )rB  r0  r   ry   )rB  r|  r   ry   )r=  r  r  r(  r  r  r   r   r  r1  r+  rX  rR  r  r  r{  r  rX  r  r  r  r  rw  r  r
  rs  ry  r  r   r   r   r   r   U  sT        !!) ) ) ) )	( 	( 	( 	(
 
 
 
 
 777 X7??? 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( ( ( (0
 
 
 
   "( ( ( (F F F F     r   r   rB  c                    t          | t                    r| j        S t          | t                    r"t	          | j                  }|| d| j         S d S )Nr   )r   r   r  r   r  r   r  )rB  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 )ru  zACheck if an AST contains attribute assignments (e.g. self.x = 0).r   r!  c                "    d| _         d| _        d S NFlvaluerw  r  s    r   r(  zFindAttributeAssign.__init__  s    


r   r~  r!   c                `    d| _         |j        D ]}|                    |            d| _         d S NTF)r;  ru  rv  r'  r~  lvs      r   visit_assignment_stmtz)FindAttributeAssign.visit_assignment_stmt  s6    ) 	 	BIIdOOOOr   r_   c                    d| _         |j        D ]}||                    |            d| _         |j                            |            d S r=  )r;  r{  rv  r   r>  s      r   visit_with_stmtz#FindAttributeAssign.visit_with_stmt  sP    ( 	  	 B~		$	dr   r4   c                    d| _         |j                            |            d| _         |j                            |            |j        r|j                            |            d S d S r=  )r;  indexrv  r   r  r'  r~  s     r   visit_for_stmtz"FindAttributeAssign.visit_for_stmt  sh    	t	d; 	%Kt$$$$$	% 	%r   r2   c                    d S r  r   rE  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_expr  rI  r   r=   c                    d S r  r   rK  s     r   visit_index_exprz$FindAttributeAssign.visit_index_expr  rI  r   rC   c                &    | j         r	d| _        d S d S r  r:  rK  s     r   visit_member_exprz%FindAttributeAssign.visit_member_expr  s!    ; 	DJJJ	 	r   Nr   r!  )r~  r!   r   r!  )r~  r_   r   r!  )r~  r4   r   r!  )r~  r2   r   r!  )r   r&   r   r!  )r   r=   r   r!  )r   rC   r   r!  )r=  r  r  __doc__r(  r@  rB  rF  rH  rL  rN  rP  r   r   r   ru  ru    s        KK         % % % %              r   ru  c                  *    e Zd ZdZddZddZdd	Zd
S )rx  z/Check if an AST contains yields or yield froms.r   r!  c                    d| _         d S r9  rw  r  s    r   r(  zFindYield.__init__  s    


r   r   r`   c                    d| _         d S r  rU  rK  s     r   visit_yield_exprzFindYield.visit_yield_expr      


r   ra   c                    d| _         d S r  rU  rK  s     r   visit_yield_from_exprzFindYield.visit_yield_from_expr  rX  r   NrQ  )r   r`   r   r!  )r   ra   r   r!  )r=  r  r  rR  r(  rW  rZ  r   r   r   rx  rx    sV        99           r   rx  r~  re  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)rs  r   r2   r  rU   rL   rM   r0   )r~  rK  r;  r}  s       r   rt  rt    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   rD   )r   r   r   r   )
r   r   r   r   r   r   r   r   r   r   )
r  r   r  r   r   r   r   r   r   rv   )r  r  r   r  )r  r  r   r  )rB  r   r   r   )r~  re  r   r  )
__future__r   r   r   r   collections.abcr   r  r   r   r   r   r	   r
   r   r   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.   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^   r_   r`   ra   rb   mypy.optionsrc   mypy.patternsrd   re   rf   rg   rh   ri   rj   rk   mypy.reachabilityrl   rm   mypy.sharedparsern   ro   mypy.traverserrp   
mypy.typesrq   rr   rs   rt   ru   rv   rw   rx   ry   rz   r{   r|   r}   r~   r   	mypy.utilr   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}  r  ExceptHandlerrC  r  	TypeAliasr  	ParamSpecra  rR  TypeVarTuplerb  r   r   compiler   r   r   r  r  r  r  r   r   r  ru  rx  rt  r   r   r   <module>rn     s	   " " " " " " " 				 



  $ $ $ $ $ $ Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z @ @ @ @ @ @ @ @ @ @       . . . . . .Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Qd !          	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 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-  - - - -     ^ ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] K[	 	 	 	 	 N	=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wNMNM,K(MMKGCt ""2B;; ; ; ; ;'RZ(IJJ  J J J J #P P P P Pf< < < <$#" #" #" #"LP P P P,      W& W& W& W& W& W& W& W&t.i i i i i i i iX	   + + + + +* + + +\
 
 
 
 
  
 
 
     r   