
    %^gU                   F   U d dl mZ d dlZd dlZd dlZd dlZd dlmZmZm	Z	m
Z
mZmZmZmZmZ d dlmZmZ d dlmZmZmZ d dlmZ d dlmZ d dlmZmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;m<Z<m=Z=m>Z>m?Z?m@Z@mAZAmBZBmCZCmDZDmEZEmFZFmGZGmHZHmIZImJZJmKZKmLZLmMZMmNZNmOZOmPZPmQZQmRZRmSZSmTZTmUZUmVZVmWZWmXZXmYZYmZZZm[Z[m\Z\m]Z]m^Z^m_Z_m`Z`maZambZbmcZcmdZdmeZemfZfmgZgmhZhmiZimjZjmkZkmlZl d d	lmmnZn d d
lompZpmqZqmrZrmsZsmtZtmuZumvZvmwZw d dlxmyZymzZz d dl{m|Z|m}Z} d dl~mZ d dlmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZ d dlmZmZ ej&                  d   Zded<   d dlZd dlmZmZmZmZmZmZmZmZmZmZ ef	 	 	 	 	 	 	 	 	 d.dZejF                  ZejH                  Zej&                  dk\  rejJ                  ZejL                  ZejN                  ZejP                  ZejR                  ZejT                  ZejV                  ZejX                  ZejZ                  Zeej\                  ej^                  ej`                  ejb                  f   Zn;eZeZeZeZeZeZeZeZeZeej\                  ej^                  ejb                  f   Zej&                  dk\  rejf                  ZneZej&                  dk\  r4ejh                  Zejl                  Zej                  Zejr                  ZneZeZeZeZ edeP      Z ee#g d      Zded<    ejz                  d      Zded<   	 d/	 	 	 	 	 	 	 	 	 	 	 d0dZd1dZ	 	 	 	 	 	 	 	 	 	 d2d Z	 	 	 	 	 	 	 	 	 	 d3d!Zd4d"Zd5d#Z G d$ d%      Z G d& d'      Zd6d(Z G d) d*e      Z G d+ d,e      Zd7d-Zy)8    )annotationsN)	AnyCallableFinalListOptionalSequenceTypeVarUnioncast)Literal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USubc                6    t        j                  | ||d|      S )NT)type_commentsfeature_version)ast3parse)sourcefilenamemoder   s       .lib/python3.12/site-packages/mypy/fastparse.py
ast3_parser      s$     ::'     )   
   )r      r      N)bound_dummy_fallbackz[^#]*#\s*type:\s*ignore\s*(.*)TYPE_IGNORE_PATTERNc                   |duxr |j                   xs ||j                  v }|xr |du xs |j                   }|
t               }|j	                  |||       |j                  d      }|rGt        j                  d   }|j                  d   dk(  rE|j                  d   |kD  r3|j                  d   }n#|j                  d   dk\  sJ |j                  d   }	 t        j                         5  t        j                  dt               t        | |d	|
      }	ddd       t        |||||      j                  	      }
t;        |
t8              sJ |
S # 1 sw Y   <xY w# t         $ r}t"        j$                  dk  }|r|j&                  dk(  rd|_        |j*                  }|t"        j$                  j,                  kD  r;|j/                  d      r*|j                  d    d|j                  d    }|d| dz  }|j1                  |j(                  |j(                  nd|j2                  |dt4        j6                         t9        g g di       }
Y d}~d}~ww xY w)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)optionsz.pyir   r   r   ignore)categoryexec)r   )r   is_stuberrorsstrip_function_bodiespathr   	   z	<fstring>zinvalid syntax.z+; you likely need to run mypy using Python z	 or newerr   TblockercodeF)ignore_errorsignored_filespreserve_astsrd   set_fileendswithr   PYTHON3_VERSIONpython_versionwarningscatch_warningsfilterwarningsDeprecationWarningr   ASTConvertervisitSyntaxErrorsysversion_infor   linenomsgminor
startswithreportoffsetcodesSYNTAXrE   
isinstance)r   fnammoduler   r   r   r   is_stub_filer   asttreeeis_py38_or_earliermessagepython_version_strs                  r   r   r      sZ    D(BW-B-B $$$  *\w$/[gF[F[B[)
OOD&'O2==(L"2215!!!$)g.D.DQ.G/.Y%44Q7O%%a(A---!003 +$$&##H7IJVT6?SC '  "7
 %* 	8 dH%%%KC '&  + --6!**"; AH%%S--3338J8JK[8\$+$:$:1$=#>a@V@VWX@Y?Z![DEWDXXabbG,AHH"HH 	 	
 Br*'+s1   E ,+E'E EE 	I'C#IIc                "   | r2| j                         dk(  s| j                         j                  d      rg S t        j                  d|       }|y|j	                  d      j                  d      D cg c]  }|j                          c}S c c}w )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*(#.*)?$Nr   ,)stripr   rematchgroupsplit)tagmr   s      r   parse_type_ignore_tagr     sx     #))+#syy{'='=c'B	
-s3Ay%&WWQZ%5%5c%:;%:TDJJL%:;;;s   2Bc                   	 t        | dd      }t        j                  |       }|rb|j                  d      }t	        |      }|F|<|j                  ||t        j                  j                  t        j                         nt        d}t        |t        j                        sJ t        |||d      j!                  |j"                        }||fS # t        $ rr |n| j%                  dd	      d
   j'                         }	t        j(                  j+                  |	      }
|j                  |||
j                  d|
j,                         Y y 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)lineoverride_columnis_evaluatedr      r   Tr   NN)r   r   r   r   r   r   r   INVALID_TYPE_IGNOREvaluer   r   r   r   r   r2   TypeConverterr   bodyr   r   TYPE_COMMENT_SYNTAX_ERROR_VALUEformatr   )type_commentr   columnr   typextra_ignorer   ignored	convertedstripped_typeerr_msgs              r   parse_type_commentr     s@   "'7@ +00>*003C(=c(BG%MMf&6&J&J&P&PW\WcWc "  &%G#t///!vE

%/ 	 	!!5  (..sA6q9??AM&FFMMm\GMM$t',,MWs   C A7EE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_fallbackrx   r   
ValueError)expr_stringexpr_fallback_namer   r   _nodes         r   parse_type_stringr  D  s    P$qQ%7d6Z^_4d[)45$:P:P:X%0D");D&K$[2DdFSS$ P !.@$OOPs   AA 
A A87A8c                    t        | t              r| j                  dk(  S t        | t              rDt        | j                  t              r*| j                  j                  dk(  xr | j
                  dk(  S y)Nno_type_checktypingF)r   r   idr   r   attr)exprs    r   is_no_type_check_decoratorr  Z  sW    $ww/))	D)	$djj$'::==H,Mo1MMr   c                    | y t        j                  |       D ]N  }t        |t         j                  t         j                  t         j
                  t         j                  f      sL|c S  y N)r   walkr   Yield	YieldFrom	NamedExprAwait)r  r   s     r   .find_disallowed_expression_in_annotation_scoper  c  sI    |		$dTZZTUK   r   c                     e Zd ZU 	 	 	 	 	 	 	 	 	 	 	 	 ddZddZdddZddZddZddZddZ	ddZ
dd	Zd
d
d
d	 	 	 	 	 	 	 	 	 ddZ	 	 	 	 	 	 ddZej                  dej                   dej"                  dej$                  dej&                  dej(                  dej*                  dej,                  dej.                  dej0                  dej2                  dej4                  dej6                  diZded<   ddZej>                  dej@                  dejB                  d ejD                  d!ejF                  d"ejH                  d#ejJ                  d$ejL                  d%ejN                  d&ejP                  d'i
Z)ded(<   dd)Z*dd*Z+dd+Z,d
d
d,	 	 	 	 	 	 	 dd-Z-dd.Z.	 d	 	 	 	 	 dd0Z/	 	 	 	 dd1Z0dd2Z1dd3Z2dd4Z3dd5Z4dd6Z5dd7Z6	 d	 	 	 	 	 dd8Z7dd9Z8	 d	 	 	 	 	 	 	 dd:Z9	 d	 	 	 	 	 	 	 	 	 	 	 dd;Z:dd<Z;dd=Z<dd>Z=dd?Z>dd@Z?ddAZ@ddBZAddCZBddDZCddEZDddFZEddGZFddHZGddIZHddJZIddKZJddLZKddMZLddNZMddOZNddPZOddQZPddRZQddSZRddTZSddUZTddVZUddWZVddXZWddYZXddZZYdd[ZZdd\Z[dd]Z\dd^Z]dd_Z^dd`Z_ddaZ`ddbZaddcZbdddZcddeZdddfZeddgZfddhZgddiZhddjZiddkZjddlZkddmZlddnZmddoZnddpZoddqZpddrZqddsZrddtZsdduZtddvZuddwZvddxZwddyZxddzZydd{Zzdd|Z{dd}Z|dd~Z}ddZ~y/)r   c                   g | _         g | _        || _        || _        || _        || _        || _        i | _        i | _        y 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__m  sM     LN%)+%:"	24 GIr   c                `    | j                   j                  |||dt        j                         y Nnote)severityr   r   r   r   r   r  r   r   r   s       r   r  zASTConverter.note  s#    4vELLQr   c                (   |s| j                   j                  sz| j                  j                  | j                  | j
                  | j                   j                         | j                  j                  |||j                  ||j                         y y )Nr   )	r   r   r   set_file_ignored_linesr   r  r   r   r   )r  r   r   r   r   s        r   failzASTConverter.fail  sj    $,,44KK..		4,,dll.H.H KKtVSYYchhW 5r   c                r    | j                  t        j                  |j                  |j                  d       y )NFr   r   r   )r!  r   FAILED_TO_MERGE_OVERLOADSr   r   r  r   s     r   fail_merge_overloadz ASTConverter.fail_merge_overload  s-    		66;;	 	 	
r   c                    |y t        |      }| j                  j                  |      }|4d|j                  j                  z   }t        | |      }|| j                  |<    ||      S )Nvisit_)typer  get	__class____name__getattr)r  r   typeobjvisitormethods        r   r   zASTConverter.visit  sh    <t*$$((1? 7 77FdF+G*1Dw't}r   c                    |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   ns      r   set_linezASTConverter.set_line  s>    HH	ll<6!!%5t<r   c                \    g }|D ]$  }| j                  |      }|j                  |       & |S r
  )r   append)r  lresr   exps        r   translate_opt_expr_listz$ASTConverter.translate_opt_expr_list  s0    ')A**Q-CJJsO  
r   c                N    t        t        t           | j                  |            S r
  )r   r   r2   r>  )r  r;  s     r   translate_expr_listz ASTConverter.translate_expr_list  s    D$d&B&B1&EFFr   c                    t        |t        j                  t        j                  t        j                  f      r%|j
                  r|j
                  d   j                  S |j                  S Nr   )r   r   AsyncFunctionDefr(   FunctionDefdecorator_listr   r%  s     r   
get_linenozASTConverter.get_lineno  sM    td33T]]DDTDTUV##&&q)000{{r   F)ismodule	can_stripis_coroutinec                  |rh|re| j                   rXt        | j                         | j                  |d         k  r-| j                   t        | j                            }|rVdj                  |      }| j	                  t
        j                  j                  |      t        | j                         dd       | j                  j                  | j                  j                     t        | j                            j                  t        j                  j                         t        | j!                  | j#                  |                  }| j%                  ||       t'        |       |gS | j(                  }|r&| j*                  rt-        |      dk(  r|d   dk(  r|sg S g }	|D ]$  }
| j/                  |
      }|	j                  |       & |r| j*                  r|dd  ddgk(  r@t1        |	      rd}n2t3               }|	D ]#  }|j5                  |       |j6                  s!d} n |r<|d	   dk(  r4|r2t9               }|	D ]#  }|j5                  |       |j6                  s!d} n |rg S |	S )
Nr   z, Fr#  r   FCr   )r  minrF  joinr!  r   "TYPE_IGNORE_WITH_ERRCODE_ON_MODULEr   r   used_ignored_linesfiler:  r   FILEr   r$   fix_function_overloadstranslate_stmt_listset_block_linesrn   r  r   lenr   is_possible_trivial_bodyFindAttributeAssignacceptfound	FindYield)r  stmtsrG  rH  rI  ignoresjoined_ignoresblockstackr<  stmtr   r/  syield_visitors                  r   rU  z ASTConverter.translate_stmt_list  s)    !!D%%&q)BB''D,=,=(>?G!%7!3		$GGNN~^T../!	   KK**4;;+;+;<SARAR=ST[[

 $55d6N6Nu6UVWE  ."5)7N-- **E
aaC I!D::d#DJJt 
 33RSzc3Z'+C0 %I 23G )"==(-I!	 ! U2Y#-, !*AHH]+$**$)		  	
r   c                    |y |j                   }t        |||j                  | j                        \  }}||| j                  |<   |S r
  )r   r   r4  r   r  )r  r7  r   r   r   r   s         r   translate_type_commentz#ASTConverter.translate_type_comment  sQ     XXF 2<W[WbWb cL#',8!!&)Jr   +-*@/%z**z<<z>>|^&z//zFinal[dict[type[AST], str]]op_mapc                    t         j                  j                  t        |            }| t	        dt        t        |            z         |S )NzUnknown operator )r   rp  r*  r)  RuntimeErrorstrr  opop_names      r   from_operatorzASTConverter.from_operator'  s?    %%))$r(3?2Sb]BCCNr   ><z==z>=z<=z!=iszis notinznot incomp_op_mapc                    t         j                  j                  t        |            }| t	        dt        t        |            z         |S )NzUnknown comparison operator )r   r|  r*  r)  rr  rs  rt  s      r   from_comp_operatorzASTConverter.from_comp_operator;  s?    **..tBx8?=DHMNNNr   c                N   |d   |d   }}|j                   |_        |j                  |_        t	        |dd       |_        t	        |dd       |_        |j                  sy |j                  d   }t        |t        t        f      r#|j                  |_        |j                  |_        y y )Nr   r   r2  r3  )r   r   r4  r   r-  r5  r6  r   r   r-   rK   )r  br]  firstlast	new_firsts         r   rV  zASTConverter.set_block_linesB  s    Ahb	t##T<6
t%5t<vvFF1I	i)->!?@ ^^AF ''AH	 Ar   c                    d }|r;t        | j                  | j                  |                  }| j                  ||       |S r
  r$   rT  rU  rV  )r  r]  r  s      r   as_blockzASTConverter.as_blockQ  s?    d11$2J2J52QRSA  E*r   rH  rI  c          	         |sJ t        | j                  | j                  |||                  }| j                  ||       |S )Nr  r  )r  r]  rH  rI  r  s        r   as_required_blockzASTConverter.as_required_blockX  sP     u''(()R^(_

 	Q&r   c           	     *	   g }g }d }d}d }d }d }d }	g }
|D ]  }d }d }d }t        |t              r,|du r(| j                  ||      }|| j                  |      \  }}|t        |t        t
        f      r|j                  |k(  r||
j                  |       |Bt        |t              r|j                  |j                         n|j                  |       d\  }}|	r| j                  |	       d }	|j                  |       t        |t
              sd}|8t        |t              r'||k(  r!|
j                  |       ||| j                  |       @|Bt        |t              r|j                  |j                         n|j                  |       d\  }}t        |j                  d   t              r]|
j                  t        t        t           |j                  d d              |j                  |j                  d   j                         |j                  t        t        t        t
        f   |j                  d                9||j                  |       |}d\  }}d }	|r8||k(  r3|j!                         }t        |t              sJ |
j                  |       |r-|
r+|
D ]$  }| j#                  |       |j                  |       & g }
t%        |      dk(  r|j                  |d          n(t%        |      dkD  r|j                  t        |             d}t        |t              r&t'        |j                        s|g}|j                  }At        |t              rr|pg }|}|}d }|b|
j                  t        t        t           |j                  d d              t        t        t        t
        t        f   |j                  d         }|}	g }d }|j                  |        |r+|
r)|
D ]$  }| j#                  |       |j                  |       & t%        |      dk(  r|j                  |d          |S t%        |      dkD  r|j                  t        |             |S ||j                  |       |S ||j                  |       |S )NFr   Tr   r   r   )r   r9   _check_ifstmt_for_overloads'_get_executable_if_block_with_overloadsr-   r6   namer:  rK   extenditemsr&  r   r   r   r   pop_strip_contents_from_if_stmtrW  r   )r  r]  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_stmtsrb  if_overload_nameif_block_with_overloadif_unknown_truth_valuepoppedif_stmts                    r   rT  z#ASTConverter.fix_function_overloadsd  s   !/1,0&+#&*KO15"59#)+D+/37"48"$',G5,P#'#C#CDJ_#` #/DDTJ E+-C
 &1ti%9:II!66+$++L9#/ ""24EF(//0@0F0FG(//0@A5?2L"2.,,-HI26/ ''-dG,26/%1tV,$(== !''-)1-9001GH#/ ""24EF(//0@0F0FG(//0@A5?2L"2499"=?PQ$++Df?U?Z?Z[^\^?_,`a$++,B,G,G,K,Q,QR$++U9g#568N8S8STU8VW  +JJ|,1F.5?2L"226/#(=A[([ !WWYF%ff555$++F3#(8 $499'B

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

7# ,  A%JJ'*+ 
 !"Q&JJ()9:;
 
	 )JJ'( 
 %JJ|$
r   Nc                N    t        |j                  d   j                        dk(  r\t        |j                  d   j                  d   t        t        f      s|*t        |j                  d   j                  d   t
              s~t        |j                  d   j                        dkD  rXt        |j                  d   j                  d   t              r.t         fd|j                  d   j                  dd D              sy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                  j                  d   |      |k(  r|S y)z{Check if IfStmt contains only overloads with the same name.
        Return overload_name if found, None otherwise.
        r   r   Nr   c              3  @   K   | ]  }j                  |        y wr
  )_is_stripped_if_stmt).0r  r  s     r   	<genexpr>z;ASTConverter._check_ifstmt_for_overloads.<locals>.<genexpr>  s     ]F\7D--g6F\s   )rW  r   r   r-   rK   r6   allr   r   r  	else_bodyr9   r  )r  rb  r  overload_names   `   r   r  z(ASTConverter._check_ifstmt_for_overloads  s    		!!!"a'499Q<,,Q/)=N1OP(4tyy|003W=499Q<$$%)499Q<,,R02CD]diiPQlFWFWX[Y[F\]])W&778$))A,:K:KB:O

$ 	 >>!  t~~""#q( 4>>..q1IwHY3Z[NN''*//=@$$4>>..q16:44T^^5H5H5KMbc ! %$r   c                N   t        || j                         |j                  |j                  d   j                  du ry|j                  3|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 r]t        |j                  j                  d   t              r(| j                  |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)rm   r   r  r   is_unreachabler   r9   r  r  rb  s     r   r  z4ASTConverter._get_executable_if_block_with_overloads  s    	+4>>>!diil&A&AT&INN"yy|**e3--6 :>>((D099Q<%%99Q<&&$. $..--a0&9CCDNNDWDWXYDZ[[>>4''Tzr   c                ~   t        |j                        dk(  rg |j                  d   _        |j                  rt        |j                  j                        dk(  rbt        |j                  j                  d   t              r)| j                  |j                  j                  d          yg |j                  _        yyy)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)rW  r   r  r   r9   r  r  s     r   r  z)ASTConverter._strip_contents_from_if_stmt<  s     tyy>Q "DIIaL>>c$.."5"56!;$..--a0&911$..2E2Ea2HI&(#	 <>r   c                N   t        |t              syt        |j                        dk(  r%t        |j                  d   j                        dk(  sy|j                  r"t        |j                  j                        dk(  ry| j                  |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   r9   rW  r   r  r  r  s     r   r  z!ASTConverter._is_stripped_if_stmtJ  s    
 $'DII!#DIIaL,=,=(>!(C~~T^^%8%8!9Q!> (()<)<Q)?@@r   c                :    || j                   j                  k(  ry|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_id]  s    222	r   c                   i | _         |j                   D ]`  }t        |j                        }||| j                   |j                  <   4| j	                  t
        j                  |j                  dd       b | j                  | j                  |j                  d            }t        || j                  d| j                         }| j                  |_        | j                  |_        |S )Nr   Fr   T)rG  )ignored_lines)r  r   r   r   r!  r   r   rT  rU  r   rE   r  r   r   )r  modtiparsedr   r  s         r   visit_ModulezASTConverter.visit_Modulec  s    ""B*2662F!/5!!")),		*>>		2W\	] # **4+C+CCHHW[+C+\]tT\\5@Q@QRll99
r   c                $    | j                  |      S r
  do_func_defr  r7  s     r   visit_FunctionDefzASTConverter.visit_FunctionDefx  s    ""r   c                (    | j                  |d      S )NT)rI  r  r  s     r   visit_AsyncFunctionDefz#ASTConverter.visit_AsyncFunctionDef}  s    55r   c                   | j                   j                  d       t        |j                  xr t	        d |j                  D                    }|j
                  }| j                  |j                  ||      }t        |j                        r|D ]	  }d|_
         |D cg c]  }|j                   }}|D cg c]&  }|j                  rdn|j                  j                  ( }}d}	g }
|rdgt        |      z  }
d}n|j                  	 t        |j                  dd      }t!        |t"              sJ t        |j$                        dk(  rt!        |j$                  d	   t&              r|j$                  d	   j(                  t*        u rv|j,                  r+| j/                  t0        j2                  ||j4                         |D cg c]3  }|j6                  |j6                  nt9        t:        j<                        5 }
}n|j,                  st	        d
 |D              r+| j/                  t0        j2                  ||j4                         t?        | j@                  ||j4                        jC                  |j$                        }tE        tF        tH        tJ              |      }
t?        | j@                  |      jM                  |j,                        }| j                   dd ddgk(  }|r@t        |
      t        |      k  r)|
jO                  d	t9        t:        jP                               nt`        jb                  dk\  r'|jd                  r| jg                  |jd                        }	|D cg c]  }|j6                   }
}t?        | j@                  |j,                  r|j,                  j
                  n|      jM                  |j,                        }ti        ||
      D ]!  \  }}| jk                  ||jl                         # d}t	        |
      s|r-t        |
      dk7  r>t	        d |
D              r,| j/                  t0        jn                  ||j4                         nt        |
      t        |      kD  r.| j/                  t0        jp                  ||j4                  d       nt        |
      t        |      k  r.| j/                  t0        jr                  ||j4                  d       nWtu        |
D cg c]  }||nt9        t:        j<                        ! c}||||nt9        t:        j<                        tv              }ty        |dd      }ty        |dd      }| j                   j{                          | j                   j                  d       | j}                  |j~                  d|      }t        |j                  ||||	      }t!        |j                  tt              r|j                  j                         |_C        |rd|_D        |||_E        ||_F        |j                  r|j                  d	   j
                  }t        |j                        }d|_H        |j                  |       d|_J        ||_K        |j                  ||j4                  ||       t        || jC                  |j                        |      }|j                  d	   }|j                  |j
                  |j4                  ||       |}n |j                  ||j4                  ||       |}| j                  j                  rt        j                  |d      |_Q        | j                   j{                          |S c c}w c c}w c c}w # tR        $ r |j                  jU                  dd      d	   jW                         }t0        jX                  j[                  |      }| j/                  |||j4                         |j                  r.|j                  d	   dvr| j]                  d||j4                         t9        t:        j^                        gt        |      z  }
t9        t:        j^                        }Y w xY wc c}w c c}w )zCHelper shared between visit_FunctionDef and visit_AsyncFunctionDef.Dc              3  2   K   | ]  }t        |        y wr
  )r  )r  ds     r   r  z+ASTConverter.do_func_def.<locals>.<genexpr>  s     $]L\q%?%BL\s   )r  TNz<func_type>	func_typer   r   c              3  8   K   | ]  }|j                   d u  y wr
  )type_annotation)r  as     r   r  z+ASTConverter.do_func_def.<locals>.<genexpr>  s     'Tt!(9(9(Ets   )r   r   r   rL  rM  r   r   )r   r   z.Suggestion: wrap argument types in parenthesesr   c              3  <   K   | ]  }t        |t                y wr
  )r   ru   )r  ts     r   r  z+ASTConverter.do_func_def.<locals>.<genexpr>  s     *ZPY1:a+FPYs   Fr  r2  r3  rK  r  clean)Rr  r:  boolrE  anyr   transform_argsargsrp   r  pos_onlykindvariablerW  r   r   r   r   argtypesConstantr   Ellipsisreturnsr!  r   DUPLICATE_TYPE_SIGNATURESr4  r  rr   r}   unannotatedr   r   r@  r   r   r   rz   r   insert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_ARGSrt   r   r-  r  r  r   r6   r)  copy_modifiedunanalyzed_typerI  
definitionr   r^   is_readyr8  is_decorated	deco_liner-   r   include_docstringsr   get_docstring	docstring)r  r7  rI  r  r   r  arg	arg_kinds	arg_namesexplicit_type_params	arg_typesreturn_typefunc_type_astr  translated_argsin_method_scoper   r   arg_typer  r5  r6  r   func_defr  vardecor  retvals                                r   r  zASTConverter.do_func_def  s
    	%%,,S1]$]AL\L\$]!]
 ""1666"O'/#  *..#SXX	.LPQDSS\\Ts||/@/@@D	Q7;')	T*IK^^',< *1>>=+ V!->>> ../14"=#9#9!#<hG%..q1778Cyy		"2"L"LfVWVbVbc "&! "&A  !00< --!()>)>!?@ "&  ! yyC'Tt'T$T		"2"L"LfVWVbVbc2?&!,,3))-*@*@A $ !%T(4.%9? KI+DKKfEKKMLaLab #'"?"?"Dc
"R"s9~D	'A$$Q	0F0F(GH 7*q}}'+'A'A!--'P$489Dq**DI9'aii!))"2"2VeAII  !y1MC""8S__= 2 	y>[9~"s*ZPY*Z'Z		*GGQRQ]Q]^Y#i.0		$AALL!	   Y#i.0		$@@LL!	   )U^_U^PQ!-QWY5J5J-KKU^_#.#:K	H]H]@^#	 1lD1Q 0$7
%%))+%%,,S1%%aff<%X1664y:NOhmm\2'/}}'B'B'DH$$(H! #+I #IN ((+22Ihmm$C CLLL $(H!!*HfallHjIXt'?'?@P@P'QSVWD$$Q'EMM%,,(8(8(JO*.F fallHjIF<<**!%!3!3AU!CH%%))+O /Q*!.  	< ! 4 4S! <Q ? E E G*JJQQR_`		'61<<8>>annQ&7z&IIIH&RSR^R^ %Y%9%9:;c$iG	%i&:&:;	< :8 `s?    ]9+]$B8]. 8])=D+]. 'a -$a%)]. .C+aac                    | j                   j                  sy t        |t              xr |j                  dk(  }t        |t
              r||_        y y )NNone)r   implicit_optionalr   rF   r  r~   optional)r  r)  r  r  s       r   r  zASTConverter.set_type_optional  sD    ||--k84S9I9IV9SdK($DM )r   c           
     
   g }g }t        |dt        t        t        j                     g             }||j
                  z   }|j                  }t        |      t        |      z
  }	t        |d |	       D ]L  \  }
}|
t        |      k  }|j                  | j                  |d t        ||             |j                  |       N t        t        ||	d  |            D ]R  \  }
\  }}|	|
z   t        |      k  }|j                  | j                  ||t        ||             |j                  |       T |j                  L|j                  | j                  |j                  d t        |             |j                  |j                         t        |j                   |j"                        D ]E  \  }}|j                  | j                  |||t$        nt&        |             |j                  |       G |j(                  L|j                  | j                  |j(                  d t*        |             |j                  |j(                         t-        |D cg c]  }|j.                  j0                   c}|| j2                         |S c c}w )Nposonlyargs)r-  r   r   r   r  r  r   rW  	enumerater:  make_argumentr   r  r   varargr   
kwonlyargskw_defaultsr   r   kwargr   rc   r  r  fail_arg)r  r  r   r  new_argsnamesr  	args_argsargs_defaultsnum_no_defaultsir  r  r  kdr  s                   r   r  zASTConverter.transform_args   s     "dM4TXX3KL$))+	i.3}+==i(89:DAq3{++HOOD..q$PXYZLLO ; #3y1A'BM#RSIAv1&*S-==HOOD..q!WmXVWLLO T ;;"OOD..t{{D(MZ[LL% $*:*:;EArOO""r
9}
 LLO < ::!OOD..tzz4MZ[LL$h?hs**h?V @s   J c           
     N   |rd }n|j                   }|j                  }|7|5| j                  t        j                  |j
                  |j                         d }|1t        | j                  |j
                        j                  |      }n| j                  ||      }t        |j                        rd}t        t        |j                  |      || j                  |      ||      }	|	j                  |j
                  |j                  t!        |dd       t!        |dd              |	S )Nr  Tr2  r3  )
annotationr   r!  r   r  r   r4  r   r   r   rf  ro   r  r   r^   r8  r-  )
r  r  defaultr  r  r  r  r  r   arguments
             r   r  zASTConverter.make_argumentL  s     HJ++L%,*B		*DDcjjRUR`R`aH%(3::FLLZX66sLIsww'HC2Hdjj>QSWYabJJNNCt,C)40		
 r   c                d    | j                  t        |      |j                  |j                         y r
  )r!  r   r   r4  )r  r   r  s      r   r  zASTConverter.fail_argl  s    		,s#SZZ@r   c           	        | j                   j                  d       |j                  D cg c]6  }|j                  s|j                  | j	                  |j
                        f8 }}d }t        j                  dk\  r'|j                  r| j                  |j                        }t        |j                  | j                  |j                        d | j                  |j                        t!        |      j#                  d      ||      }| j                  |j$                        |_        |j(                  |_        |j$                  r|j$                  d   j(                  nd |_        | j.                  j0                  rt3        j4                  |d      |_        |j8                  |_        t=        |dd       |_        t=        |d	d       |_         | j                   jC                          |S c c}w )
NrM  r   	metaclass)r  keywords	type_argsr   Fr  r2  r3  )"r  r:  r  r  r   r   r   r   r  r  r(   r  r  r   r@  basesdictr*  rE  
decoratorsr   r   r  r   r  r   r  r  r4  r   r-  r5  r6  r  )r  r7  kwr  r  cdefs         r   visit_ClassDefzASTConverter.visit_ClassDeft  s~   %%,,S1=>ZZRZr266RVVTZZ12ZR 8<w&1==#'#=#=amm#L FF""166*$$QWW-8n((5*
 2213C3CD HH	787G7G))!,33T<<**!//?DNll<6!!%5t<%%))+; Ss
   G))G)c                0   t        |j                        }|y t        |t        j                  t        j
                  f      r5| j                  t        j                  |j                  |j                         t        |t        j                        r5| j                  t        j                  |j                  |j                         t        |t        j                        r6| j                  t        j                  |j                  |j                         y y r
  )r  r   r   r   r  r  r!  r   "TYPE_VAR_YIELD_EXPRESSION_IN_BOUNDr   r4  r  "TYPE_VAR_NAMED_EXPRESSION_IN_BOUNDr  "TYPE_VAR_AWAIT_EXPRESSION_IN_BOUND)r  
type_paramincorrect_exprs      r   validate_type_paramz ASTConverter.validate_type_param  s    G
HXHXY!ntzz4>>&BCII CC!!%%
 ndnn5II CC!!%%
 ndjj1II CC!!%% 2r   c           
     j   g }|D ]%  }d }g }d }t         j                  dk\  r:t        | j                  |j                        j                  |j                        }t        |t              r-|j                  t        |j                  t        d g |             t        |t              r-|j                  t        |j                  t        d g |             t        |j                  t         j"                        rt%        |j                  j&                        dk  r8| j)                  t*        j,                  |j                  |j.                  d       nt        | j                  |j                        }|j                  j&                  D cg c]  }|j                  |       }}nW|j                  K| j1                  |       t        | j                  |j                        j                  |j                        }|j                  t        |j                  t2        |||             ( |S c c}w )N)r      r  r   Fr  )r   r   r   r   r   r   default_valuer   ast_ParamSpecr:  r\   r  r   ast_TypeVarTupler   r   r   TuplerW  eltsr!  r   "TYPE_VAR_TOO_FEW_CONSTRAINED_TYPESr4  r#  r   )	r  r  r  pr   valuesr  convr  s	            r   r  z"ASTConverter.translate_type_params  s   !A!%E!#F#'G7*'!((CII!//Z!]+$++IaffotUWY`,abA/0$++aff&94WM aggtzz2177<<(1,		,OOHHLL$)	 "   -T[[qxxH9:!FA$**Q-!FWW(,,Q/)$++AHHEKKAGGTE$++affmUFGL7 < $# "Gs   H0c                n    t        | j                  |j                              }| j                  ||      S r
  )rP   r   r   r8  r  r7  r   s      r   visit_ReturnzASTConverter.visit_Return  s*    $**QWW-.}}T1%%r   c                :   t        |j                        dkD  rKt        | j                  |j                              }|j	                  |j
                         t        |      }n't        | j                  |j                  d               }| j	                  ||      S )Nr   r   )rW  targetsrZ   r@  r8  r   r.   r   )r  r7  tupr   s       r   visit_DeletezASTConverter.visit_Delete  sp    qyy>AD44QYY?@CLL"3<D4::aiil34D}}T1%%r   c                    | j                  |j                        }| j                  |j                        }| j	                  ||j
                        }t        |||d      }| j                  ||      S )NFr)  
new_syntax)r@  r3  r   r   rf  r   r"   r8  )r  r7  lvaluesrvaluer   rc  s         r   visit_AssignzASTConverter.visit_Assign  s_    **1995AGG$))!Q^^<7FG}}Q""r   c                   |j                   }|j                  =t        t        t        j
                        d      }||_        |j                  |_        n| j                  |j                        }t        | j                  |      j                  |j                        }|J |j                  j                  |_        t        | j                  |j                        g||d      }| j                  ||      S )NT)no_rhsr  r7  )r   r   rX   rr   r}   r  r   r4  r   r   r   r   r  r"   targetr8  )r  r7  r   r:  r   rc  s         r   visit_AnnAssignzASTConverter.visit_AnnAssign  s    xx77?!)')2H2H*IRV!WFFKLLFMZZ(FDKKd399!,,G\\,,
DJJqxx016PTU}}Q""r   c                    t        | j                  |j                        | j                  |j                        | j                  |j
                              }| j                  ||      S r
  )rI   rw  ru  r   r>  r   r8  r  r7  rc  s      r   visit_AugAssignzASTConverter.visit_AugAssign  sO    "qtt$djj&:DJJqww<O
 }}Q""r   c                D   | j                  ||j                        }t        | j                  |j                        | j                  |j
                        | j                  |j                        | j                  |j                        |      }| j                  ||      S r
  )rf  r   r5   r   r>  iterr  r   r  orelser8  r  r7  target_typer   s       r   	visit_ForzASTConverter.visit_For  sz    11!Q^^DJJqxx JJqvv""166*MM!((#
 }}T1%%r   c                R   | j                  ||j                        }t        | j                  |j                        | j                  |j
                        | j                  |j                        | j                  |j                        |      }d|_
        | j                  ||      S NT)rf  r   r5   r   r>  rD  r  r   r  rE  is_asyncr8  rF  s       r   visit_AsyncForzASTConverter.visit_AsyncFor  s    11!Q^^DJJqxx JJqvv""166*MM!((#
 }}T1%%r   c                    t        | j                  |j                        | j                  |j                        | j                  |j                              }| j                  ||      S r
  )r_   r   testr  r   r  rE  r8  r0  s      r   visit_WhilezASTConverter.visit_While  sO    JJqvv 6 6qvv >ahh@W
 }}T1%%r   c                    t        | j                  |j                        g| j                  |j                        g| j                  |j                              }| j                  ||      S r
  )r9   r   rN  r  r   r  rE  r8  r0  s      r   visit_IfzASTConverter.visit_If  sX    ZZ 4#9#9!&&#A"BDMMRSRZRZD[
 }}T1%%r   c           	        | j                  ||j                        }t        |j                  D cg c]  }| j	                  |j
                         c}|j                  D cg c]  }| j	                  |j                         c}| j                  |j                        |      }| j                  ||      S c c}w c c}w r
  )
rf  r   r`   r  r   context_exproptional_varsr  r   r8  )r  r7  rG  r  r   s        r   
visit_WithzASTConverter.visit_With#  s    11!Q^^D129ATZZ'923'':'QTZZ(':""166*	
 }}T1%% ::s   "B8""B=
c           	        | j                  ||j                        }t        |j                  D cg c]  }| j	                  |j
                         c}|j                  D cg c]  }| j	                  |j                         c}| j                  |j                        |      }d|_	        | j                  ||      S c c}w c c}w rJ  )rf  r   r`   r  r   rS  rT  r  r   rK  r8  )r  r7  rG  r  rc  s        r   visit_AsyncWithzASTConverter.visit_AsyncWith.  s    11!Q^^D129ATZZ'923'':'QTZZ(':""166*	
 
}}Q"" ::s   "B?""C
c                    t        | j                  |j                        | j                  |j                              }| j	                  ||      S r
  )rN   r   exccauser8  r0  s      r   visit_RaisezASTConverter.visit_Raise:  s9    AEE*DJJqww,?@}}T1%%r   c           
     V   |j                   D cg c]5  }|j                  %| j                  t        |j                        |      nd 7 }}|j                   D cg c]  }| j	                  |j
                         }}|j                   D cg c]  }| j                  |j                         }}t        | j                  |j                        |||| j                  |j                        | j                  |j                              }| j                  ||      S c c}w c c}w c c}w r
  )handlersr  r8  rF   r   r)  r  r   rY   r  rE  	finalbodyr  r7  hvstypesr]  r   s          r   	visit_TryzASTConverter.visit_Try?  s    XYXbXb
XbST!&&2DDMM(166*A.$NXb 	 
 ./ZZ8ZAFF#Z8<=JJGJqD**1662JG""166*MM!((#MM!++&
 }}T1%%
 9Gs   :D"D!"D&c           
     d   |j                   D cg c]5  }|j                  %| j                  t        |j                        |      nd 7 }}|j                   D cg c]  }| j	                  |j
                         }}|j                   D cg c]  }| j                  |j                         }}t        | j                  |j                        |||| j                  |j                        | j                  |j                              }d|_        | j                  ||      S c c}w c c}w c c}w rJ  )r]  r  r8  rF   r   r)  r  r   rY   r  rE  r^  is_starr_  s          r   visit_TryStarzASTConverter.visit_TryStarP  s   XYXbXb
XbST!&&2DDMM(166*A.$NXb 	 
 ./ZZ8ZAFF#Z8<=JJGJqD**1662JG""166*MM!((#MM!++&
 }}T1%%
 9Gs   :D#"D("D-c                    t        | j                  |j                        | j                  |j                              }| j	                  ||      S r
  )r    r   rN  r   r8  r0  s      r   visit_AssertzASTConverter.visit_Assertc  s9    $**QVV,djj.?@}}T1%%r   c                F   g }|j                   D ]Y  }| j                  |j                        }|j                  }|||j                  k7  r|j                  }|j	                  ||f       [ t        |      }| j                  j	                  |       | j                  ||      S r
  )r  r  r  asnamer:  r:   r  r8  )r  r7  r  aliasr  rj  r  s          r   visit_ImportzASTConverter.visit_Importh  s    .0WWE++EJJ7D\\F~$%**"4 LL$(  5MA}}Q""r   c           	     $   |j                   J t        |j                        dk(  rM|j                  d   j                  dk(  r1|j                  |j                  nd}t        ||j                         }nlt        |j                  | j                  |j                        nd|j                   |j                  D cg c]  }|j                  |j                  f c}      }| j                  j                  |       | j                  ||      S c c}w )Nr   r   ri  r   )levelrW  r  r  r   r;   r=   r  rj  r  r:  r8  )r  r7  r  r  r  s        r   visit_ImportFromzASTConverter.visit_ImportFromx  s    ww"""qww<1C!7hh2!((C%c1773A67hh6J((2PR-.WW5W!&&!((#W5A
 	A}}Q"" 6s   :Dc                P    t        |j                        }| j                  ||      S r
  )r8   r  r8  )r  r7  gs      r   visit_GlobalzASTConverter.visit_Global  s!    qww}}Q""r   c                P    t        |j                        }| j                  ||      S r
  )rH   r  r8  )r  r7  r  s      r   visit_NonlocalzASTConverter.visit_Nonlocal  s!    !}}Q""r   c                r    | j                  |j                        }t        |      }| j                  ||      S r
  )r   r   r3   r8  )r  r7  r   r   s       r   
visit_ExprzASTConverter.visit_Expr  s/    

177#e$}}T1%%r   c                :    t               }| j                  ||      S r
  )rM   r8  rA  s      r   
visit_PasszASTConverter.visit_Pass  s    J}}Q""r   c                :    t               }| j                  ||      S r
  )r%   r8  rA  s      r   visit_BreakzASTConverter.visit_Break  s    K}}Q""r   c                :    t               }| j                  ||      S r
  )r,   r8  rA  s      r   visit_ContinuezASTConverter.visit_Continue  s    N}}Q""r   c                    t        | j                  |j                        | j                  |j                              }| j	                  ||      S r
  )r!   r   r>  r   r8  rA  s      r   visit_NamedExprzASTConverter.visit_NamedExpr  s9    4::ahh/AGG1DE}}Q""r   c                Z   t        |j                        dk\  sJ |j                  }t        |t        j
                        rd}n=t        |t        j                        rd}n t        dt        t        |            z         | j                  || j                  |j                        |      S )Nr   andorzunknown BoolOp )rW  r-  ru  r   r   AndOrrr  rs  r)  r   r@  )r  r7  op_noderu  s       r   visit_BoolOpzASTConverter.visit_BoolOp  s    188}!!!$$gtxx(B)B03tAw<?@@ zz"d66qxx@!DDr   c           
         t        |      dk(  rt        ||d   |d         }n$t        ||d   | j                  ||dd  |            }| j                  ||      S )Nr   r   r   )rW  rJ   r   r8  )r  ru  valsr7  r   s        r   r   zASTConverter.group  sY    t9>r47DG,Ar47DJJr48Q$?@A}}Q""r   c                2   | j                  |j                        }|*t        dt        t	        |j                              z         t        || j                  |j                        | j                  |j                              }| j                  ||      S )Nzcannot translate BinOp )
rw  ru  rr  rs  r)  rJ   r   leftrightr8  r  r7  ru  r   s       r   visit_BinOpzASTConverter.visit_BinOp  sq    %:83tADDz?JKK2tzz!&&)4::agg+>?}}Q""r   c                   d }t        |j                  t        j                        rd}ntt        |j                  t        j                        rd}nMt        |j                  t        j
                        rd}n&t        |j                  t        j                        rd}|*t        dt        t        |j                              z         t        || j                  |j                              }| j                  ||      S )N~notrg  rh  zcannot translate UnaryOp )r   ru  r   InvertNotr   r   rr  rs  r)  r]   r   operandr8  r  s       r   visit_UnaryOpzASTConverter.visit_UnaryOp  s    addDKK(Bdhh'Bdii(Bdii(B::Sadd_LMMb$**QYY/0}}Q""r   c                   t        j                  |j                        }|j                  j                  |_        |j                  j                  |_        | j
                  j                  d       t        | j                  |j                  |j                        | j                  |g            }| j
                  j                          |j                  |j                  |j                         |S )NL)r   Returnr   r   r4  r  r:  r@   r  r  r  r  r8  )r  r7  r   r   s       r   visit_LambdazASTConverter.visit_Lambda  s    {{166"ffmm&&++%%,,S1t**166188<d>T>TVZU[>\]%%))+	

188Q\\*r   c                    t        | j                  |j                        | j                  |j                        | j                  |j                              }| j                  ||      S r
  )r+   r   rN  r   rE  r8  r  r7  r   s      r   visit_IfExpzASTConverter.visit_IfExp  sH    DJJqvv.

1660BDJJqxxDXY}}Q""r   c           
         t        t        t        | j                  |j                        | j                  |j                                          }| j                  ||      S r
  )r/   listr  r>  keysr@  r-  r8  r  s      r   
visit_DictzASTConverter.visit_Dict  sO    T11!&&94;S;STUT\T\;]^_
 }}Q""r   c                n    t        | j                  |j                              }| j                  ||      S r
  )rR   r@  r*  r8  r  s      r   	visit_SetzASTConverter.visit_Set  s,    D,,QVV45}}Q""r   c                    t        | j                  t        t        j                  |                  }| j                  ||      S r
  )rA   visit_GeneratorExpr   r   GeneratorExpr8  r  s      r   visit_ListCompzASTConverter.visit_ListComp  s5    d55d4;L;La6PQR}}Q""r   c                    t        | j                  t        t        j                  |                  }| j                  ||      S r
  )rQ   r  r   r   r  r8  r  s      r   visit_SetCompzASTConverter.visit_SetComp   s5    T44T$:K:KQ5OPQ}}Q""r   c                V   |j                   D cg c]  }| j                  |j                         }}|j                   D cg c]  }| j                  |j                         }}|j                   D cg c]  }| j	                  |j
                         }}|j                   D cg c]  }t        |j                         }}t        | j                  |j                        | j                  |j                        ||||      }| j                  ||      S c c}w c c}w c c}w c c}w r
  )
generatorsr   r>  rD  r@  ifsr  rK  r0   keyr   r8  r  r7  cr3  itersifs_listrK  r   s           r   visit_DictCompzASTConverter.visit_DictComp  s    12>A4::ahh'>-.\\:\AFF#\:=>\\J\D,,QUU3\J./ll;lD$l;#JJquutzz!''2GUHh
 }}Q"" ?:J;s   "D"D3"D!%D&c                "   |j                   D cg c]  }| j                  |j                         }}|j                   D cg c]  }| j                  |j                         }}|j                   D cg c]  }| j	                  |j
                         }}|j                   D cg c]  }t        |j                         }}t        | j                  |j                        ||||      }| j                  ||      S c c}w c c}w c c}w c c}w r
  )r  r   r>  rD  r@  r  r  rK  r7   eltr8  r  s           r   r  zASTConverter.visit_GeneratorExp  s    12>A4::ahh'>-.\\:\AFF#\:=>\\J\D,,QUU3\J./ll;lD$l;$**QUU+WeXxP}}Q"" ?:J;s   "C="D3"D%Dc                r    | j                  |j                        }t        |      }| j                  ||      S r
  )r   r   r#   r8  )r  r7  vr   s       r   visit_AwaitzASTConverter.visit_Await  s.    JJqwwaL}}Q""r   c                n    t        | j                  |j                              }| j                  ||      S r
  )ra   r   r   r8  r  s      r   visit_YieldzASTConverter.visit_Yield  s*    djj)*}}Q""r   c                n    t        | j                  |j                              }| j                  ||      S r
  )rb   r   r   r8  r  s      r   visit_YieldFromzASTConverter.visit_YieldFrom$  s*    $**QWW-.}}Q""r   c                    |j                   D cg c]  }| j                  |       }}| j                  |j                  g|j                  z         }t        ||      }| j                  ||      S c c}w r
  )opsr~  r@  r  comparatorsr)   r8  )r  r7  o	operatorsoperandsr   s         r   visit_ComparezASTConverter.visit_Compare)  sg    9:?AT,,Q/	?++QVVHq}},DE9h/}}Q"" @s   A0c                x   |j                   }|j                  }|D cg c]  }|j                   }}| j                  |D cg c]   }t	        |t
              r|j                  n|" c}|D cg c]  }|j                   c}z         }|D cg c]  }t        |      t
        u rt        nt        ! c}|D cg c]  }|t        nt         c}z   }	t        | j                  |j                        ||	t        dd gt!        |      z        |z         }
| j#                  |
|      S c c}w c c}w c c}w c c}w c c}w )NzList[Optional[str]])r  r  r  r@  r   r   r   r)  r   r   r   r   r'   r   funcr   rW  r8  )r  r7  r  r  kkeyword_namesr  r  r  r  r   s              r   
visit_CallzASTConverter.visit_Call1  s/   vv::(0111,,?CDt!
1g.QWWA5tDYaGbYaTUYaGbb
	 KOO$QaG!3X@$O?LS
?LI)3}S
 
	 JJqvv&T(:;mK	
 }}Q"" 2DGbO S
s   D#%D(,D-
$D26D7c                8   |j                   }d }|t        d      }nt        |t              rt	        |      }nt        |t
              rt        t        |            }nt        |t              rt        t        |            }nt        |t              rt        |      }nkt        |t              rt        |      }nOt        |t              rt        |      }n3|t        u rt!               }n t#        dt        t%        |            z         | j'                  ||      S )Nr  zConstant not implemented for )r   rF   r   rs  rV   bytesr&   r   r  intr?   floatr4   complexr*   r  r1   rr  r)  r8  )r  r7  valr   s       r   visit_ConstantzASTConverter.visit_ConstantD  s    gg; AS!AU#6s;<AT"S"AS!AU##AW%C AH_A>T#YOPP}}Q""r   c                n   t        d      }|j                  |j                  |j                         t	        | j                  |j                              }|j                  |       t        |j                        dk(  r| j                  |j                  d   |      S t        |j                        dkD  r=|j                  d   }t        |t               r|j                  dk(  r|j                  dd = t        |d      }|j                  |       t        ||gt        gd g      }| j                  ||      S )Nr   r   r   r   rO  )rV   r8  r   r4  rB   r@  r-  rW  r  r   r   rD   r'   r   )r  r7  empty_stringstrs_to_joinr  join_methodresult_expressions          r   visit_JoinedStrzASTConverter.visit_JoinedStr\  s    r{ahh5 8 8 BCl+|!!"a'==!3!3A!6::##$q(%%b)D$(TZZ2-= !&&rs+ v6\*$[<.7)dVT}}.22r   c                >   | j                  |j                        }|j                  |j                  |j                         |j
                  dk  rdndt        |j
                        z   }t        d|z   dz         }|j                  | j                  |j                        n
t        d      }|j                  |j                  |j                         t        |d      }|j                  |       t        |||gt        t        gd d g      }| j                  ||      S )Nr   r   !{z:{}}r   )r   r   r8  r   r4  
conversionchrrV   format_specrD   r'   r   )r  r7  val_expconv_strformat_stringformat_spec_expformat_methodr  s           r   visit_FormattedValuez!ASTConverter.visit_FormattedValuer  s    
 **QWW%1<<0)2sS5F/Fh 7878}}7P$**Q]]3V]^`Vaqxx6"=(;}-$G_57IDRV<
 }}.22r   c                X   |j                   }t        | j                  |      |j                        }|j                  }t        |t              rJt        |j                  t              r0|j                  j                  dk(  rt        |j                  |      }n|}| j                  ||      S )Nsuper)r   rD   r   r  r  r   r'   calleerF   r  rW   r8  )r  r7  r   member_exprobjr   s         r   visit_AttributezASTConverter.visit_Attribute  s     E!2AFF;sH%3::x0

7*(1+2B2BC(HAA}}Q""r   c                   t        | j                  |j                        | j                  |j                              }| j	                  ||       t
        j                  dk  }t        |j                  t        j                        s&|rZt        |j                  t        j                        r6|j                  |j                  _        |j                  |j                  _        |S )Nr   )r>   r   r   slicer8  r   r   r   r   SliceExtSlicer   indexr   )r  r7  r   r   s       r   visit_SubscriptzASTConverter.visit_Subscript  s    djj)4::agg+>?a --6aggtzz*:aggt}}#E 66AGGLXXAGGNr   c                n    t        | j                  |j                              }| j                  ||      S r
  )rT   r   r   r8  r  s      r   visit_StarredzASTConverter.visit_Starred  s*    TZZ()}}Q""r   c                P    t        |j                        }| j                  ||      S r
  )rF   r  r8  r  s      r   
visit_NamezASTConverter.visit_Name  s     QTTN}}Q""r   c                    |j                   D cg c]  }| j                  |       }}t        |j                  t        j
                        rt        |      }nt        |      }| j                  ||      S c c}w r
  )	r*  r   r   ctxr   StorerZ   rB   r8  )r  r7  r   	expr_lists       r   
visit_ListzASTConverter.visit_List  s_    >?ff&Eftzz!}f	&EaeeTZZ(&/	&:A#A}}Q"" 'Fs   A6c                n    t        | j                  |j                              }| j                  ||      S r
  )rZ   r@  r*  r8  r  s      r   visit_TuplezASTConverter.visit_Tuple  s,    d..qvv67}}Q""r   c                    t        | j                  |j                        | j                  |j                        | j                  |j                              S r
  )rS   r   lowerupperstepr  s     r   visit_SlicezASTConverter.visit_Slice  s8    AGG,djj.A4::affCUVVr   c                f    t        | j                  t        t        |      j                              S r
  )rZ   r@  r   r   dimsr  s     r   visit_ExtSlicezASTConverter.visit_ExtSlice  s$    11$sA,2C2CDEEr   c                |    | j                  t        t        |      j                        }t	        |t
              sJ |S r
  )r   r   r   r   r   rG   r  r7  r   s      r   visit_IndexzASTConverter.visit_Index  1    

4Q<--.%&&&r   c                   t        | j                  |j                        |j                  D cg c]  }| j                  |j                         c}|j                  D cg c]  }| j                  |j
                         c}|j                  D cg c]  }| j                  |j                         c}      }| j                  ||      S c c}w c c}w c c}w r
  )	rC   r   subjectcasespatternguardr  r   r8  )r  r7  r  r   s       r   visit_MatchzASTConverter.visit_Match  s    JJqyy!,-GG4GqTZZ		"G4*+''2'QTZZ '256WW=WT##AFF+W=	
 }}T1%%	 52=s   "C
 "C"Cc                n    t        | j                  |j                              }| j                  ||      S r
  )rl   r   r   r8  r0  s      r   visit_MatchValuezASTConverter.visit_MatchValue  s*    DJJqww/0}}T1%%r   c                P    t        |j                        }| j                  ||      S r
  )rj   r   r8  r0  s      r   visit_MatchSingletonz!ASTConverter.visit_MatchSingleton  s!    (}}T1%%r   c                    |j                   D cg c]  }| j                  |       }}|D cg c]  }t        |t              s| }}t	        |      dk  sJ t        |      }| j                  ||      S c c}w c c}w )Nr   )patternsr   r   rk   rW  ri   r8  )r  r7  r,  r  starsr   s         r   visit_MatchSequencez ASTConverter.visit_MatchSequence  sr    +,::6:aDJJqM:6$FHq
1n(EHF5zA~~x(}}T1%% 7Fs   A6A;A;c                    |j                   t        d       }n0| j                  t        |j                         |      }t        |      }| j                  ||      S r
  )r  rk   r8  rF   )r  r7  r   r  s       r   visit_MatchStarzASTConverter.visit_MatchStar  sI    66>!$'D==!&&!115D!$'D}}T1%%r   c                <   |j                   D cg c]  }| j                  |       }}|j                  D cg c]  }| j                  |       }}|j                  d }nt	        |j                        }t        |||      }| j                  ||      S c c}w c c}w r
  )r  r   r  restrF   rg   r8  )r  r7  r  r  r  r-  r  r   s           r   visit_MatchMappingzASTConverter.visit_MatchMapping  s    '(vv.v!

1v.)*4A$**Q-466>DAFF#DdFD1}}T1%% /4s
   BBc                h   | j                  |j                        }t        |t              sJ |j                  D cg c]  }| j                  |       }}|j
                  }|j                  D cg c]  }| j                  |       }}t        ||||      }| j                  ||      S c c}w c c}w r
  )	r   clsr   rO   r  	kwd_attrskwd_patternsrf   r8  )r  r7  	class_refr,  positionalskeyword_keyskeyword_valuesr   s           r   visit_MatchClasszASTConverter.visit_MatchClass  s    JJquu%	)W---./jj9jtzz!}j9{{12@A$**Q-@I{L.Q}}T1%% :@s   B*0B/c                    |j                   d }n't        |j                         }| j                  ||      }t        | j	                  |j
                        |      }| j                  ||      S r
  )r  rF   r8  re   r   r  )r  r7  r  r   s       r   visit_MatchAszASTConverter.visit_MatchAs	  sX    66>DAFF#D==q)DAII.5}}T1%%r   c                    t        |j                  D cg c]  }| j                  |       c}      }| j                  ||      S c c}w r
  )rh   r  r   r8  )r  r7  r  r   s       r   visit_MatchOrzASTConverter.visit_MatchOr  s?    QZZHZ'$**W-ZHI}}T1%% Is   Ac                0   t        |j                        }|y t        |t        j                  t        j
                  f      r5| j                  t        j                  |j                  |j                         t        |t        j                        r5| j                  t        j                  |j                  |j                         t        |t        j                        r6| j                  t        j                  |j                  |j                         y y r
  )r  r   r   r   r  r  r!  r    TYPE_ALIAS_WITH_YIELD_EXPRESSIONr   r4  r   TYPE_ALIAS_WITH_NAMED_EXPRESSIONr   TYPE_ALIAS_WITH_AWAIT_EXPRESSION)r  r7  r"  s      r   validate_type_aliasz ASTConverter.validate_type_alias  s    GP!ntzz4>>&BCII&GGSTS_S_`ndnn5II&GGSTS_S_`ndjj1II&GGSTS_S_` 2r   c                   | j                  |j                        }| j                  |       | j                  |j                        }t        |      }| j                  ||j                         t        t        |g            }| j                  ||j                         t        | j                  |j                        ||      }| j                  ||      S )N)r   )r  r  r%  r   r   rP   r8  r@   r$   r[   r  r  )r  r7  r  r   r  
value_funcr   s          r   visit_TypeAliaszASTConverter.visit_TypeAlias#  s    00?  #

177# c177#UC5\2
j!''*T__QVV4k:N}}T1%%r   )r   rd   r   r  r   r   r   r  r   rs  returnr  r   rs  r   r  r   r  r)  r  )T)
r   r   r   r  r   r  r   r  r)  r  )r   r9   r)  r  )r   
AST | Noner)  r   )r   r   r7  AstNoder)  r   )r;  zSequence[AST | None]r)  zlist[Expression | None])r;  zSequence[AST]r)  list[Expression])r   zast3.expr | ast3.stmtr)  r  )
r]  Sequence[ast3.stmt]rG  r  rH  r  rI  r  r)  list[Statement])r7  zast3.stmt | ast3.argr   
str | Noner)  ProperType | None)ru  zast3.operatorr)  rs  )ru  z
ast3.cmpopr)  rs  )r  r$   r]  r.  r)  r  )r]  list[ast3.stmt]r)  zBlock | None)r]  r2  rH  r  rI  r  r)  r$   )r]  r/  r)  r/  r
  )rb  r9   r  r0  r)  r0  )rb  r9   r)  z"tuple[Block | None, IfStmt | None])rb  r9   r)  r  )rb  rU   r)  r  )r  rs  r)  rs  )r  zast3.Moduler)  rE   )r7  zast3.FunctionDefr)  FuncDef | Decorator)r7  zast3.AsyncFunctionDefr)  r3  )F)r7  z(ast3.FunctionDef | ast3.AsyncFunctionDefrI  r  r)  r3  )r)  zType | Noner  zExpression | Noner)  r  )r  zast3.argumentsr   r  r  r  r)  zlist[Argument])r  ast3.argr  ast3.expr | Noner  r   r  r  r  r  r)  r   )r   rs  r  r4  r)  r  )r7  zast3.ClassDefr)  r(   )r!  ast_TypeVarr)  r  )r  z	list[Any]r)  zlist[TypeParam])r7  zast3.Returnr)  rP   )r7  zast3.Deleter)  r.   )r7  zast3.Assignr)  r"   )r7  zast3.AnnAssignr)  r"   )r7  zast3.AugAssignr)  rI   )r7  zast3.Forr)  r5   )r7  zast3.AsyncForr)  r5   )r7  z
ast3.Whiler)  r_   )r7  zast3.Ifr)  r9   )r7  z	ast3.Withr)  r`   )r7  zast3.AsyncWithr)  r`   )r7  z
ast3.Raiser)  rN   )r7  zast3.Tryr)  rY   )r7  TryStarr)  rY   )r7  zast3.Assertr)  r    )r7  zast3.Importr)  r:   )r7  zast3.ImportFromr)  r<   )r7  zast3.Globalr)  r8   )r7  zast3.Nonlocalr)  rH   )r7  z	ast3.Exprr)  r3   )r7  z	ast3.Passr)  rM   )r7  z
ast3.Breakr)  r%   )r7  zast3.Continuer)  r,   )r7  r  r)  r!   )r7  zast3.BoolOpr)  rJ   )ru  rs  r  r-  r7  	ast3.exprr)  rJ   )r7  
ast3.BinOpr)  rJ   )r7  zast3.UnaryOpr)  r]   )r7  zast3.Lambdar)  r@   )r7  z
ast3.IfExpr)  r+   )r7  	ast3.Dictr)  r/   )r7  zast3.Setr)  rR   )r7  zast3.ListCompr)  rA   )r7  zast3.SetCompr)  rQ   )r7  zast3.DictCompr)  r0   )r7  zast3.GeneratorExpr)  r7   )r7  z
ast3.Awaitr)  r#   )r7  z
ast3.Yieldr)  ra   )r7  zast3.YieldFromr)  rb   )r7  zast3.Comparer)  r)   )r7  r   r)  r'   )r7  r  r)  r   )r7  zast3.JoinedStrr)  r2   )r7  zast3.FormattedValuer)  r2   )r7  r   r)  zMemberExpr | SuperExpr)r7  ast3.Subscriptr)  r>   )r7  r   r)  rT   )r7  r   r)  rF   )r7  	ast3.Listr)  zListExpr | TupleExpr)r7  
ast3.Tupler)  rZ   )r7  
ast3.Slicer)  rS   )r7  zast3.ExtSlicer)  rZ   )r7  r   r)  rG   )r7  Matchr)  rC   )r7  
MatchValuer)  rl   )r7  MatchSingletonr)  rj   )r7  MatchSequencer)  ri   )r7  	MatchStarr)  rk   )r7  MatchMappingr)  rg   )r7  
MatchClassr)  rf   )r7  MatchAsr)  re   )r7  MatchOrr)  rh   )r7  ast_TypeAliasr)  r  )r7  rH  r)  zTypeAliasStmt | AssignmentStmt)r,  
__module____qualname__r  r  r!  r&  r   r8  r>  r@  rF  rU  rf  r   AddSubMultMatMultDivModPowLShiftRShiftBitOrBitXorBitAndFloorDivrp  __annotations__rw  GtLtEqGtELtENotEqIsIsNotInNotInr|  r~  rV  r  r  rT  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r#  r  r1  r5  r;  r?  rB  rH  rL  rO  rQ  rU  rW  r[  rc  rf  rh  rl  ro  rr  rt  rv  rx  rz  r|  r~  r  r   r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r
  r  r  r  r  r  r   r%  r(   r   r   r   r   l  sf   II I 	I  $I I 
I0RX
	G "L"L 	L
 L L 
L\
%
5?
	
 	##		3c##$TT

CSSt+F'   	$$

D

H

H0K, ( <AW\
$
48
PT
	
K\ AE))3=)	)V	+@)A&*#
6 QVV9VIMV	Vp% FK*"**-*>B*	*d  " 	
   
@AB. $F&
&###	&
&&&&	#&
&"&&&
# ##
#
&#
#
##
E###$	#
##
#
#
####
#
##&#03,3&#"#
#
##WF
&&&&&
&&&&	a&r   r   c                     e Zd Z	 	 	 d	 	 	 	 	 	 	 	 	 ddZddZdd dZed!d       Ze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)dZd*dZd+dZd,dZd-dZd.dZd/dZd0dZd1dZd2dZd3dZd4dZd5dZd6dZy)7r   c                J    || _         || _        || _        g | _        || _        y r
  )r   r   r   
node_stackr   )r  r   r   r   r   s        r   r  zTypeConverter.__init__3  s)     	.%'(r   c                <    | j                   dk  r|S | j                   S )zApply column override if defined; otherwise return column.

        Column numbers are sometimes incorrect in the AST and the column
        override can be used to work around that.
        r   )r   )r  r   s     r   convert_columnzTypeConverter.convert_column@  s#     !#M'''r   Nc           
     L    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.Anyr4  r   )r   r   r  )rx   r   r-  )r  r   r  s      r   invalid_typezTypeConverter.invalid_typeK  s+     !,TYYwt\SU7V]a
 	
r   c                     y r
  rc  r%  s     r   r   zTypeConverter.visitY  s    47r   c                     y r
  rc  r%  s     r   r   zTypeConverter.visit\  s    <?r   c                   |y| j                   j                  |       	 d|j                  j                  z   }t	        | |d      }|6 ||      }t        |t              sJ || j                   j                          S | j                  |      | j                   j                          S # | j                   j                          w xY w)z2Modified visit -- keep track of the stack of nodesNr(  )	rf  r:  r+  r,  r-  r   rw   r  rj  )r  r   r0  r/  r   s        r   r   zTypeConverter.visit_  s    <t$
	" 7 77FdFD1G"dm!#z222 OO! ((.OO!DOO!s   AB) >B) )Cc                R    t        | j                        dk  ry| j                  d   S )z3Return the AST node above the one we are processingr   NrL  )rW  rf  r  s    r   parentzTypeConverter.parentp  s%    t!#r""r   c                    | j                   r5| j                   j                  |||j                  d|j                         y y )NTr   )r   r   r   r   r  s       r   r!  zTypeConverter.failv  s3    ;;KKtVSYY388T r   c                z    | j                   r/| j                   j                  |||dt        j                         y y r  r  r  s       r   r  zTypeConverter.notez  s/    ;;KKtVS6U r   c                J    |D cg c]  }| j                  |       c}S c c}w r
  )r   r  r;  r   s      r   r@  z!TypeConverter.translate_expr_list~  s"    '()q!

1q)))s    c                P   |j                   }t        |      }t        | j                         t        j
                        s(d }|rdj                  |      }| j                  ||      S |s5| j                  t        j                  |j                  |j                         d }t        t        j                        }|}t!        |j"                        D ]n  \  }}	|dk(  r| j%                  |	      }
|
J |
}#|dk(  r| j'                  |	      }:| j                  t        j(                  |j                  |j                         p |j*                  D ]3  }|j,                  }|j.                  dk(  rX|D| j                  t        j0                  j                  |      |j                  |j                         | j'                  |      }w|j.                  dk(  r`||urD| j                  t        j2                  j                  |      |j                  |j                         | j%                  |      }
|
J |
}| j                  t        j4                  j                  |j.                        |j                  |j                         6 t7        ||||j                  |j                        S )Nz,Suggestion: use {0}[...] instead of {0}(...)r  r   r   r  r)  )r  stringify_namer   rp  r   r   r   rj  r!  r   ARG_CONSTRUCTOR_NAME_EXPECTEDr   r4  rr   r}   r  r   r  r   _extract_argument_nameARG_CONSTRUCTOR_TOO_MANY_ARGSr  r   r  MULTIPLE_VALUES_FOR_NAME_KWARGMULTIPLE_VALUES_FOR_TYPE_KWARGARG_CONSTRUCTOR_UNEXPECTED_ARGrs   )r  r   fconstructorr  r  default_typer   r  r  r   r  r   s                r   r  zTypeConverter.visit_Call  s(   FF$Q'$++-3DELL[Y$$QT$22II&DDahhPQP\P\]y556 'FAsAv JJsO	 ,,,a2237		*HH!((TUT`T`a ( AGGEuu#II(GGNN{[
 2259&l*II(GGNN{[
 !JJu-	 ,,,		$CCJJ155QLL$$+ 4  T;!,,OOr   c                t    t        |D cg c]  }| j                  |       c}| j                        S c c}w )Nr  )r|   r   r   rt  s      r   translate_argument_listz%TypeConverter.translate_argument_list  s-    21A2CC2s   5c                `   t        |t              r4t        |j                  t              r|j                  j	                         S t        |t              r|j                  y | j                  t        j                  j                  t        |      j                        | j                  d       y rB  )r   r  r   rs  r   r!  r    ARG_NAME_EXPECTED_STRING_LITERALr   r)  r,  r   r  s     r   ry  z$TypeConverter._extract_argument_name  sw    a"z!''3'?77==?"8$		==DDT!WEUEUVII	

 r   c                x    t        |j                  | j                  | j                  |j                              S )Nr   r   )r~   r  r   rh  r4  r  s     r   r  zTypeConverter.visit_Name  s(    144dii8K8KALL8YZZr   c                V   t        |j                  t        j                        s| j	                  |      S | j                  |j                        }| j                  |j                        }t        ||g| j                  | j                  |j                        | j                  d      S )NT)r   r   r   uses_pep604_syntax)r   ru  r   rT  rj  r   r  r  r   r   rh  r4  r   )r  r7  r  r  s       r   r  zTypeConverter.visit_BinOp  s    !$$

+$$Q''zz!&&!

177#5M&&q||4**#
 	
r   c                4   |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| j                  ||      S t        |t              r.t!        |      }t        |d| j                  |j                        S | j#                  |      S )Nr  r  zbuiltins.strzbuiltins.boolzbuiltins.bytes)r   )r   r~   r   r   rs  r  r4  r  ru   r  rx   r  r  r  numeric_typer  r   rj  )r  r7  r  contentss       r   r  zTypeConverter.visit_Constant  s    gg;vDII66c3$S.$))Q\\RR(?TYY//c4 $S/		JJcC01$$S!,,c5!3C8H$X/?STS_S_``  ##r   c                J   | j                  |j                        }t        |t              rht	        |j
                        t        u rMt        |j                  t              r|xj
                  dz  c_        |S t        |j                  t              r|S | j                  |      S )Nr   )r   r  r   rx   r)  literal_valuer  ru  r   r   rj  )r  r7  r   s      r   r  zTypeConverter.visit_UnaryOp  s|     jj#s-.S&&'3.!$$%!!R'!
!$$%
  ##r   c           
         t        |t              r|}d}nd }dt        |      j                   }t	        ||| j
                  t        |dd            S )Nzbuiltins.intz	builtins.r4  r   r  )r   r  r)  r,  rx   r   r-  )r  r   r7  numeric_value	type_names        r   r  zTypeConverter.numeric_type  sZ    
 eS!(-M&I
 !M#DK$8$8#9:I 9499WQVX=Y
 	
r   c                |    | j                  t        t        |      j                        }t	        |t
              sJ |S r
  )r   r   r   r   r   rz   r  s      r   r  zTypeConverter.visit_Index  r   r   c                (    | j                  |d      S )Nz(did you mean to use ',' instead of ':' ?rv  )rj  r  s     r   r  zTypeConverter.visit_Slice  s      )S TTr   c                   t         j                  dk\  r|j                  }nt        |j                  t        j
                        r|j                  j                  }nt        |j                  t        j                        rJt        j                  |j                        }t        |dd       :|j                  j                  |_        nt        |j                  t        j                        sJ t        t        t        j                      t        j                  |j                  j"                              }|D ]  }t        |dd       t        |t        j
                        r|j                  j                  |_        Gt        |t        j                        sb|j                  J |j                  j                  |_         t	        j$                  ||j&                        }d}t        |t        j$                        r6| j)                  |j*                        }t-        |j*                        dk(  rd}n| j/                  |      g}| j/                  |j                        }t        |t0              r:|j2                  s.t1        |j4                  || j6                  |j8                  |      S | j;                  |      S )Nr   r4  Fr   T)r   r   empty_tuple_index)r   r   r  r   r   r   r   r  copydeepcopyr-  r  r4  r  r   r   r  r  r)  r  r@  r*  rW  r   r~   r  r  r   r   rj  )r  r7  slicevalr  rc  r  paramsr   s           r   r  zTypeConverter.visit_Subscript  s   v%GGH,GGMMH,}}QWW-Hxt4<&.nn&?&?#aggt}}555TYYqww||)DED 1lD19!!TZZ0'(ww'9'9#Atzz2 ww222'(ww'9'9  zz$.H!h

+--hmm<F8==!Q&$(!jj*+F

177#e[)%**

YY||"3  $$Q''r   c           	         t        | j                  |j                        t        d| j                  | j                  |j                              S )NT)implicitr   r   )ry   r@  r*  r   r   rh  r4  r  s     r   r  zTypeConverter.visit_TupleG  s@    $$QVV,&&q||4
 	
r   c                &   |j                   s| j                  |      S i }g }t        |j                   |j                        D ]  \  }}t	        |t
        j                        rt	        |j                  t              s6|!|j                  | j                  |             ]| j                  |      c S | j                  |      ||j                  <    t        |t               t               t        |j                  |j                        }||_        |S r
  )r  rj  r  r-  r   r   r  r   rs  r:  r   r{   setr   r   r4  extra_items_from)r  r7  r  r  	item_namer   results          r   r  zTypeConverter.visit_DictP  s    vv$$Q''!# #AFFAHH 5Iui7z)//[^?_$$++DJJu,=>((++%)ZZ%6E)//" !6 uceSUOQXXq||\"2r   c                    | j                  |j                        }t        |t              r<|j                  s0t        |j
                   d|j                   | j                        S | j                  |      S )Nr   r  )	r   r   r   r~   r  r  r  r   rj  )r  r7  
before_dots      r   r  zTypeConverter.visit_Attributea  sZ    ZZ(
j+.z*//!2!AFF8<499MM$$Q''r   c                N    t        | j                  |j                        d      S )NT)from_star_syntax)r   r   r   r  s     r   r  zTypeConverter.visit_Starredj  s    $**QWW-EEr   c                    t        |j                  t        j                        sJ | j	                  |j
                        }|S r
  )r   r  r   Loadr  r*  )r  r7  r  s      r   r  zTypeConverter.visit_Listn  s3    !%%+++--aff5r   )r   r   T)
r   Errors | Noner   r  r   r  r   r  r)  r  )r   r  r)  r  r
  )r   r   r  r0  r)  rx   )r   r8  r)  rw   )r   r+  r)  r1  )r)  r+  )r   r   r   r  r   r  r)  r  r*  )r;  Sequence[ast3.expr]r)  z
list[Type])r   r   r)  rz   )r;  r  r)  r|   )r7  r8  r)  r0  )r7  r   r)  rz   )r7  r9  r)  rz   )r7  r  r)  rz   )r7  r   r)  rz   )r   objectr7  r   r)  rz   )r7  z
ast3.Indexr)  rz   )r7  r>  r)  rz   )r7  r;  r)  rz   )r7  r=  r)  rz   )r7  r:  r)  rz   )r7  r   r)  rz   )r7  zast3.Starredr)  rz   )r7  r<  r)  rz   )r,  rI  rJ  r  rh  rj  r   r   rp  r!  r  r@  r  r  ry  r  r  r  r  r  r  r  r  r  r  r  r  r  rc  r   r   r   r   2  s     !!)) ) 	)
 ) 
)	(
 7 7? ?""#UV*3PjD
[
$.$ 
$U
+(Z
"(Fr   r   c                    t        | t              r| j                  S t        | t              r(t	        | j
                        }|| d| j                   S y )Nr   )r   r   r  r   rw  r   r  )r7  svs     r   rw  rw  t  sJ    !Ttt	Ay	!AGG$>T166(##r   c                  P    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y
)rY  zACheck if an AST contains attribute assignments (e.g. self.x = 0).c                     d| _         d| _        y NFlvaluer[  ro  s    r   r  zFindAttributeAssign.__init__  s    
r   c                d    d| _         |j                  D ]  }|j                  |         d| _         y NTF)r  r9  rZ  r  rc  lvs      r   visit_assignment_stmtz)FindAttributeAssign.visit_assignment_stmt  s)    ))BIIdO r   c                    d| _         |j                  D ]  }||j                  |         d| _         |j                  j                  |        y r  )r  r>  rZ  r   r  s      r   visit_with_stmtz#FindAttributeAssign.visit_with_stmt  s@    ((B~		$  	dr   c                    d| _         |j                  j                  |        d| _         |j                  j                  |        |j                  r|j                  j                  |        y y r  )r  r  rZ  r   r  r  rc  s     r   visit_for_stmtz"FindAttributeAssign.visit_for_stmt  sN    	t	d;;KKt$ r   c                     y r
  rc  r  s     r   visit_expression_stmtz)FindAttributeAssign.visit_expression_stmt      r   c                     y r
  rc  r  r   s     r   visit_call_exprz#FindAttributeAssign.visit_call_expr  r  r   c                     y r
  rc  r  s     r   visit_index_exprz$FindAttributeAssign.visit_index_expr  r  r   c                ,    | j                   rd| _        y y rJ  r  r  s     r   visit_member_exprz%FindAttributeAssign.visit_member_expr  s    ;;DJ r   Nr)  r  )rc  r"   r)  r  )rc  r`   r)  r  )rc  r5   r)  r  )rc  r3   r)  r  )r   r'   r)  r  )r   r>   r)  r  )r   rD   r)  r  )r,  rI  rJ  __doc__r  r  r  r  r  r  r  r  rc  r   r   rY  rY  ~  s-    K%r   rY  c                  (    e Zd ZdZddZddZddZy)	r\  z/Check if an AST contains yields or yield froms.c                    d| _         y r  r[  ro  s    r   r  zFindYield.__init__  s	    
r   c                    d| _         y rJ  r  r  s     r   visit_yield_exprzFindYield.visit_yield_expr  	    
r   c                    d| _         y rJ  r  r  s     r   visit_yield_from_exprzFindYield.visit_yield_from_expr  r  r   Nr  )r   ra   r)  r  )r   rb   r)  r  )r,  rI  rJ  r  r  r  r  rc  r   r   r\  r\    s    9r   r\  c                B   t        |       }|dk(  ryd}t        | d   t              r"t        | d   j                  t              r|dz  }||k(  ry||dz   kD  ry| |   }t        |t
        t        f      xs, t        |t              xr 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)rW  r   r3   r  rV   rM   rN   r1   )rc  r;  r  rb  s       r   rX  rX    s     	AAAv	A!A$'Jqtyy',J	QAv1q5yQ4DdXy12 4(PZ		<-Pr   )
r   str | bytesr   rs  r   rs  r   r  r)  r   r
  )r   r  r   rs  r   r0  r   r   r   zOptions | Noner)  rE   )r   r0  r)  zlist[str] | None)
r   rs  r   r  r   r  r   r  r)  z*tuple[list[str] | None, ProperType | None])
r   rs  r   rs  r   r  r   r  r)  rw   )r  r8  r)  r  )r  r5  r)  r5  )r7  r   r)  r0  )rc  r/  r)  r  )
__future__r   r  r   r   r   r  r   r   r   r   r   r	   r
   r   r   typing_extensionsr   r   mypyr   r   r   r   mypy.errorsr   mypy.message_registryr   
mypy.nodesr   r   r   r   r   r   r   r   r   r   r   r   r    r!   r"   r#   r$   r%   r&   r'   r(   r)   r*   r+   r,   r-   r.   r/   r0   r1   r2   r3   r4   r5   r6   r7   r8   r9   r:   r;   r<   r=   r>   r?   r@   rA   rB   rC   rD   rE   rF   rG   rH   rI   rJ   rK   rL   rM   rN   rO   rP   rQ   rR   rS   rT   rU   rV   rW   rX   rY   rZ   r[   r\   r]   r^   r_   r`   ra   rb   rc   mypy.optionsrd   mypy.patternsre   rf   rg   rh   ri   rj   rk   rl   mypy.reachabilityrm   rn   mypy.sharedparsero   rp   mypy.traverserrq   
mypy.typesrr   rs   rt   ru   rv   rw   rx   ry   rz   r{   r|   r}   r~   r   r   	mypy.utilr   r   r   r   rX  r   r   r   r   r   r   r   r   r   r   r   r   r   r  r  r?  r@  rA  rB  rC  rD  rE  rF  rG  r  rb  r  ExceptHandlerr,  r7  	TypeAliasrH  	ParamSpecr'  r6  TypeVarTupler(  r   r   compiler   r   r   r   r  r  r  r   r   rw  rY  r\  rX  rc  r   r   <module>r     s   "  	 
  W W W / @ @  .Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Qd !	 	 	 Y N +    " E **1- % -  ^ ] ] K[		#&	.1	DG		 NN	==wJJEJ((N&&MI$$LJllGllGDIItyy$,,8J8JJKGEJNMILJGGDIItyy$*<*<<=GwllGGwNNMNNM,,K((MMKCt ""2B; ;'RZZ(IJ U J #@@
@ @ 	@
 @ @F<$#"#" #"*-#"7D#"/#"LPP*-P58PBEPP,C& C&L. D
+* +\
  
r   