o
    ØÝ2gÜU ã                   @  sž  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l€mZm‚Z‚mƒZƒm„Z„m…Z…m†Z†m‡Z‡mˆZˆm‰Z‰mŠZŠm‹Z‹mŒZŒmZmŽZŽmZ d dlm‘Z‘m’Z’ ej“d Z”de•d< d dl–Z—d dl–m˜Z˜m™Z™mšZšm›Z›mœZœmZmžZžmŸZŸm Z m¡Z¡ e”fdYdd„Z¢e—j£Z£e—j¤Z¤ej“dkr©e—j¥Z¥e—j¦Z¦e—j§Z§e—j¨Z¨e—j©Z©e—jªZªe—j«Z«e—j¬Z¬e—j­Z­ee—j®e—j¯e—j°e—j±f Z²neZ¥eZ¦eZ§eZ¨eZ©eZªeZ«eZ¬eZ­ee—j®e—j¯e—j±f Z²ej“d krÏe—j³Z³neZ³ej“d!kräe—j´Zµe—j¶Z·e—jZ¸e—j¹ZºneZµeZ·eZ¸eZºed"ePd#Z»e…e#g d$ƒZ¼de•d%< e ½d&¡Z¾de•d'< 	dZd[d0d1„Z¿d\d4d5„ZÀd]d;d<„ZÁd^d@dA„ZÂd_dEdF„ZÃd`dHdI„ZÄG dJdK„ dKƒZÅG dLdM„ dMƒZÆdadOdP„ZÇG dQdR„ dReƒZÈG dSdT„ dTeƒZÉdbdWdX„ZÊdS )cé    )Ú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ÚUSubÚsourceústr | bytesÚfilenameÚstrÚmodeÚfeature_versionÚintÚreturnr„   c                 C  s   t j| ||d|dS )NT)Útype_commentsr“   )Úast3Úparse)rŽ   r   r’   r“   © r™   úF/home/garg/my-data/venv/lib/python3.10/site-packages/mypy/fastparse.pyÚ
ast3_parseŠ   s   ûr›   )é   é
   )rœ   é   ©rœ   é   ÚN)ÚboundéÿÿÿÿÚ_dummy_fallbackz[^#]*#\s*type:\s*ignore\s*(.*)ÚTYPE_IGNORE_PATTERNÚfnamÚmoduleú
str | NoneÚerrorsr   ÚoptionsúOptions | NonerD   c              
   C  sÚ  |dur|j p||jv }|o|du p|j }|du rtƒ }|j|||d | d¡}|rEtjd }|jd dkrD|jd |krD|jd }n|jd dksNJ ‚|jd }z1t	 
¡  t	jdtd t| |d	|d
}	W d  ƒ n1 srw   Y  t|||||d |	¡}
W n_ tyã } zStjdk }|r›|jdkr›d|_|j}|tjjkr¾| d¡r¾|jd › d|jd › }|d|› d7 }|j|jdurÈ|jnd|j|dtjd tg g di ƒ}
W Y d}~nd}~ww t|
tƒsëJ ‚|
S )zÏParse a source file, without doing any semantic analysis.

    Return the parse tree. If errors is not provided, raise ParseError
    on failure. Otherwise, use the errors object to report parse errors.
    N)rª   z.pyir‚   r   rœ   Úignore)ÚcategoryÚexec)r“   )rª   Úis_stubr©   Ústrip_function_bodiesÚpath©rœ   é	   z	<fstring>zinvalid syntaxÚ.z+; you likely need to run mypy using Python z	 or newerr£   T©ÚblockerÚcodeF)Úignore_errorsÚignored_filesÚpreserve_astsrc   Ú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ÚSYNTAXrD   Ú
isinstance)rŽ   r¦   r§   r©   rª   r¸   r°   Úis_stub_filer“   ÚastÚtreeÚeÚis_py38_or_earlierÚmessageÚpython_version_strr™   r™   rš   r˜   É   sb   ÿ


€

þûú
û€ír˜   Útagúlist[str] | Nonec                 C  sT   | r|   ¡ dks|   ¡  d¡rg S t d| ¡}|du rdS dd„ | d¡ d¡D ƒS )	zÖParse optional "[code, ...]" tag after "# type: ignore".

    Return:
     * [] if no tag was found (ignore all errors)
     * list of ignored error codes if a tag was found
     * None if the tag was invalid.
    Ú ú#z\s*\[([^]#]*)\]\s*(#.*)?$Nc                 S  s   g | ]}|  ¡ ‘qS r™   )Ústrip)Ú.0r·   r™   r™   rš   Ú
<listcomp>  ó    z)parse_type_ignore_tag.<locals>.<listcomp>r‚   ú,)rÜ   rË   ÚreÚmatchÚgroupÚsplit)rØ   Úmr™   r™   rš   Úparse_type_ignore_tag  s   ræ   Útype_commentÚlineÚcolumnúErrors | Noneú*tuple[list[str] | None, ProperType | None]c              
   C  sì   zt | ddƒ}W n+ ty3   |dur2|  dd¡d  ¡ }tj |¡}|j|||jd|j	d Y d	S ‚ w t
 | ¡}|r\| d
¡}t|ƒ}	|	du r[|durY|j||tjjtjd nt‚nd}	t|tjƒsfJ ‚t|||dd |j¡}
|	|
fS )zkParse type portion of a type comment (+ optional type ignore).

    Return (ignore info, parsed type).
    z<type_comment>ÚevalNrÛ   é   r   Trµ   ©NNr‚   )r·   F)rè   Úoverride_columnÚis_evaluated)r›   rÅ   rä   rÜ   r   ÚTYPE_COMMENT_SYNTAX_ERROR_VALUEÚformatrÌ   Úvaluer·   r¥   râ   rã   ræ   ÚINVALID_TYPE_IGNORErÎ   rÏ   rÐ   r—   r1   ÚTypeConverterrÄ   Úbody)rç   rè   ré   r©   ÚtypÚstripped_typeÚerr_msgÚextra_ignorerØ   ÚignoredÚ	convertedr™   r™   rš   Úparse_type_comment  s:   ù
	
ÿúÿþrý   Úexpr_stringÚexpr_fallback_namerv   c              	   C  s|   z+t d| › d||dd\}}t|ttfƒr$|jdu r$| |_||_|W S t| |||ƒW S  ttfy=   t| |||ƒ Y S w )zÌParses a type that was originally present inside of an explicit string.

    For example, suppose we have the type `Foo["blah"]`. We should parse the
    string expression "blah" using this function.
    ú(ú)N)rè   ré   r©   )	rý   rÐ   r}   r~   Úoriginal_str_exprÚoriginal_str_fallbackrw   rÅ   Ú
ValueError)rþ   rÿ   rè   ré   Ú_Únoder™   r™   rš   Úparse_type_stringD  s   ýr  Úexprú	ast3.exprÚboolc                 C  sD   t | tƒr
| jdkS t | tƒr t | jtƒr | jjdko| jdkS dS )NÚno_type_checkÚtypingF)rÐ   r‰   Úidr…   ró   Úattr)r  r™   r™   rš   Úis_no_type_check_decoratorZ  s   


r  úast3.expr | Nonec                 C  sB   | d u rd S t  | ¡D ]}t|t jt jt jt jfƒr|  S qd S ©N)r—   ÚwalkrÐ   ÚYieldÚ	YieldFromÚ	NamedExprÚAwait)r  r  r™   r™   rš   Ú.find_disallowed_expression_in_annotation_scopec  s   ÿr  c                   @  s  e Zd ZU d©dd„Zdªdd„Zd«d¬dd„Zd­dd„Zd®dd „Zd¯d$d%„Zd°d)d*„Z	d±d-d.„Z
d²d0d1„Zd2d2d2d3œd³d:d;„Zd´d@dA„ZejdBejdCejdDejdEejdFejdGejdHejdIejdJejdKejdLejdMejdNiZdOedP< dµdSdT„ZejdUej dVej!dWej"dXej#dYej$dZej%d[ej&d\ej'd]ej(d^i
Z)dOed_< d¶dadb„Z*d·dedf„Z+d¸didj„Z,d2d2dkœd¹dldm„Z-dºdndo„Z.	pd»d¼dsdt„Z/d½dvdw„Z0d¾dxdy„Z1d¿d{d|„Z2dÀd~d„Z3dÁdƒd„„Z4dÂd‡dˆ„Z5dÃdŠd‹„Z6	2dÄdÅddŽ„Z7dÆd“d”„Z8	2dÄdÇd™dš„Z9	2dÄdÈd£d¤„Z:dÉd¥d¦„Z;dÊd©dª„Z<dËd­d®„Z=dÌd²d³„Z>dÍd¶d·„Z?dÎdºd»„Z@dÏd¾d¿„ZAdÐdÁdÂ„ZBdÑdÅdÆ„ZCdÒdÉdÊ„ZDdÓdÌdÍ„ZEdÔdÐdÑ„ZFdÕdÓdÔ„ZGdÖd×dØ„ZHd×dÚdÛ„ZIdØdÞdß„ZJdÙdâdã„ZKdÚdådæ„ZLdÛdédê„ZMdÜdídî„ZNdÝdñdò„ZOdÞdõdö„ZPdßdùdú„ZQdàdýdþ„ZRdádd„ZSdâdd„ZTdãd	d
„ZUdädd„ZVdådd„ZWdædd„ZXdçdd„ZYdèdd„ZZdéd d!„Z[dêd$d%„Z\dëd(d)„Z]dìd,d-„Z^díd0d1„Z_dîd4d5„Z`dïd8d9„Zadðd<d=„Zbdñd@dA„ZcdòdDdE„ZddódHdI„ZedôdLdM„ZfdõdPdQ„ZgdödSdT„Zhd÷dWdX„ZidødZd[„Zjdùd^d_„Zkdúdbdc„Zldûdfdg„Zmdüdjdk„Zndýdndo„Zodþdrds„Zpdÿdvdw„Zqd dydz„Zrdd}d~„Zsddd‚„Ztdd…d†„Zudd‰dŠ„ZvdddŽ„Zwdd‘d’„Zxdd•d–„Zydd™dš„Zzd	ddž„Z{d
d¡d¢„Z|dd¤d¥„Z}dd§d¨„Z~dpS (  rÃ   rª   rc   r¯   r
  r©   r   r°   r±   r‘   r•   ÚNonec                C  s:   g | _ g | _|| _|| _|| _|| _|| _i | _i | _d S r  )	Úclass_and_function_stackÚimportsrª   r¯   r©   r°   r±   Útype_ignoresÚvisitor_cache)Úselfrª   r¯   r©   r°   r±   r™   r™   rš   Ú__init__m  s   

zASTConverter.__init__rÉ   rè   r”   ré   c                 C  s   | j j|||dtjd d S ©NÚnote)Úseverityr·   ©r©   rÌ   rÎ   rÏ   ©r  rÉ   rè   ré   r™   r™   rš   r   …  ó   zASTConverter.noteTr   r¶   c                 C  sF   |s| j js!| j | j| j| j j¡ | jj|||j||jd d S d S )Nrµ   )	rª   r¸   r©   Úset_file_ignored_linesr±   r  rÌ   ró   r·   )r  rÉ   rè   ré   r¶   r™   r™   rš   Úfailˆ  s   ÿûzASTConverter.failr  r8   c                 C  s   | j tj|j|jdd d S )NF©rè   ré   r¶   )r&  r   ÚFAILED_TO_MERGE_OVERLOADSrè   ré   ©r  r  r™   r™   rš   Úfail_merge_overload  s   
üz ASTConverter.fail_merge_overloadú
AST | Noner   c                 C  sP   |d u rd S t |ƒ}| j |¡}|d u r$d|jj }t| |ƒ}|| j|< ||ƒS )NÚvisit_)Útyper  ÚgetÚ	__class__Ú__name__Úgetattr)r  r  ÚtypeobjÚvisitorÚmethodr™   r™   rš   rÄ   ˜  s   

zASTConverter.visitr¡   ÚnÚAstNodec                 C  s0   |j |_|j|_t|dd ƒ|_t|dd ƒ|_|S )NÚ
end_linenoÚend_col_offset)rÈ   rè   Ú
col_offsetré   r1  Úend_lineÚ
end_column)r  r  r5  r™   r™   rš   Úset_line£  s
   zASTConverter.set_lineÚlúSequence[AST | None]úlist[Expression | None]c                 C  s&   g }|D ]}|   |¡}| |¡ q|S r  )rÄ   Úappend)r  r=  ÚresrÔ   Úexpr™   r™   rš   Útranslate_opt_expr_list«  s
   
z$ASTConverter.translate_opt_expr_listúSequence[AST]úlist[Expression]c                 C  s   t tt |  |¡ƒS r  )r   r   r1   rC  ©r  r=  r™   r™   rš   Útranslate_expr_list²  ó   z ASTConverter.translate_expr_listúast3.expr | ast3.stmtc                 C  s.   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)  r™   r™   rš   Ú
get_linenoµ  s   ÿþzASTConverter.get_linenoF)ÚismoduleÚ	can_stripÚis_coroutineÚstmtsúSequence[ast3.stmt]rO  rP  rQ  úlist[Statement]c                C  s¤  |r[|r[| j r[t| j ƒ|  |d ¡k r[| j t| j ƒ }|r2d |¡}| jtj |¡t| j ƒddd | jj	| jj
 t| j ƒ  tjj¡ t|  |  |¡¡ƒ}|  ||¡ t|ƒ |gS | j}|rs| jrst|ƒdkrs|d dkrs|ssg S g }	|D ]}
|  |
¡}|	 |¡ qw|rÐ| jrÐ|dd … ddgkr®t|	ƒršd}ntƒ }|	D ]}| |¡ |jr­d} nqŸ|rÌ|d	 dkrÌ|rÌtƒ }|	D ]}| |¡ |jrËd} nq½|rÐg S |	S )
Nr   z, Fr'  r‚   ÚFéþÿÿÿÚCr£   )r  ÚminrN  Újoinr&  r   Ú"TYPE_IGNORE_WITH_ERRCODE_ON_MODULErò   r©   Úused_ignored_linesÚfiler@  rÎ   ÚFILEr·   r#   Úfix_function_overloadsÚtranslate_stmt_listÚset_block_linesrm   r  r°   ÚlenrÄ   Úis_possible_trivial_bodyÚFindAttributeAssignÚacceptÚfoundÚ	FindYield)r  rR  rO  rP  rQ  ÚignoresÚjoined_ignoresÚblockÚstackrA  Ústmtr  r3  ÚsÚyield_visitorr™   r™   rš   r_  ½  sv   ÿþý

üÿÿþÿ


þ
þz ASTConverter.translate_stmt_listúast3.stmt | ast3.argrç   r¨   úProperType | Nonec                 C  s>   |d u rd S |j }t|||j| jƒ\}}|d ur|| j|< |S r  )rÈ   rý   r9  r©   r  )r  r5  rç   rÈ   rú   r÷   r™   r™   rš   Útranslate_type_comment  s   
z#ASTConverter.translate_type_commentú+ú-Ú*ú@ú/ú%z**z<<z>>ú|ú^ú&z//zFinal[dict[type[AST], str]]Úop_mapÚopúast3.operatorc                 C  ó0   t j t|ƒ¡}|d u rtdtt|ƒƒ ƒ‚|S )NzUnknown operator )rÃ   rz  r.  r-  ÚRuntimeErrorr‘   ©r  r{  Úop_namer™   r™   rš   Úfrom_operator'  ó   zASTConverter.from_operatorú>ú<z==z>=z<=z!=Úiszis notÚinznot inÚcomp_op_mapú
ast3.cmpopc                 C  r}  )NzUnknown comparison operator )rÃ   r‡  r.  r-  r~  r‘   r  r™   r™   rš   Úfrom_comp_operator;  r‚  zASTConverter.from_comp_operatorÚbr#   c                 C  sx   |d |d }}|j |_|j|_t|dd ƒ|_t|dd ƒ|_|js$d S |jd }t|t	t
fƒr:|j|_|j|_d S d S )Nr   r£   r7  r8  )rÈ   rè   r9  ré   r1  r:  r;  rö   rÐ   r,   rJ   )r  rŠ  rR  ÚfirstÚlastÚ	new_firstr™   r™   rš   r`  B  s   
üzASTConverter.set_block_linesúlist[ast3.stmt]úBlock | Nonec                 C  s,   d }|rt |  |  |¡¡ƒ}|  ||¡ |S r  ©r#   r^  r_  r`  )r  rR  rŠ  r™   r™   rš   Úas_blockQ  s
   zASTConverter.as_block©rP  rQ  c                C  s2   |sJ ‚t |  | j|||d¡ƒ}|  ||¡ |S )Nr’  r  )r  rR  rP  rQ  rŠ  r™   r™   rš   Úas_required_blockX  s   ÿÿzASTConverter.as_required_blockc                 C  sØ  g }g }d }d}d }d }d }d }	g }
|D ]ˆ}d }d }d }t |tƒr7|du r7|  ||¡}|d ur7|  |¡\}}|d urt |ttfƒr|j|kr|d urP|
 |¡ |d urit |tƒr`| 	|j
¡ n| |¡ d\}}|	rr|  |	¡ d }	| |¡ t |tƒr~d}q|d urét |tƒré||kré|
 |¡ |d u rŸ|d urž|  |¡ q|d ur¸t |tƒr¯| 	|j
¡ n| |¡ d\}}t |jd tƒrÙ|
 	ttt |jd d… ƒ¡ | 	|jd j
¡ q| ttttf |jd ƒ¡ q|d urú| |¡ |}d\}}d }	|r||kr| ¡ }t |tƒsJ ‚|
 |¡ |r+|
r+|
D ]}|  |¡ | |¡ qg }
t|ƒdkr:| |d ¡ nt|ƒdkrH| t|ƒ¡ d}t |tƒr]t|jƒs]|g}|j}qt |tƒr”|d ur”g }|}|}d }|d ur‘|
 	ttt |jd d… ƒ¡ tttttf |jd ƒ}|}	qg }d }| |¡ q|r´|
r´|
D ]}|  |¡ | |¡ q¦t|ƒdkrÄ| |d ¡ |S t|ƒdkrÔ| t|ƒ¡ |S |d urà| |¡ |S |d urê| |¡ |S )NFrî   Tr£   r   r‚   )rÐ   r8   Ú_check_ifstmt_for_overloadsÚ'_get_executable_if_block_with_overloadsr,   r5   Únamer@  rJ   ÚextendÚitemsr*  rö   r   r   r
   ÚpopÚ_strip_contents_from_if_stmtra  r   )r  rR  Ú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_stmtsrk  Úif_overload_nameÚif_block_with_overloadÚif_unknown_truth_valueÚpoppedÚif_stmtr™   r™   rš   r^  d  sÞ   
ÿÿ






€ÿ



ÿ



ÿþ
ú
ü

þ
z#ASTConverter.fix_function_overloadsNrk  r  c                   s@  t |jd jƒdkr&t|jd jd ttfƒsP|dur&t|jd jd tƒsPt |jd jƒdkrNt|jd jd tƒrNt‡ fdd„|jd jdd… D ƒƒsPdS tttttf |jd jd ƒj	}|j
du rh|S t |j
jƒdkržt|j
jd tttfƒr‡|j
jd j	|kr‡|S t|j
jd tƒržˆ  |j
jd |¡|krž|S dS )z{Check if IfStmt contains only overloads with the same name.
        Return overload_name if found, None otherwise.
        r   r‚   Nr£   c                 3  s    | ]}ˆ   |¡V  qd S r  )Ú_is_stripped_if_stmt)rÝ   r¨  ©r  r™   rš   Ú	<genexpr>  ó   € z;ASTConverter._check_ifstmt_for_overloads.<locals>.<genexpr>)ra  rö   rÐ   r,   rJ   r5   Úallr   r
   r–  Ú	else_bodyr8   r”  )r  rk  r  Úoverload_namer™   rª  rš   r”  ñ  s>   	þÿÿ$þÿþ
ÿÿÿz(ASTConverter._check_ifstmt_for_overloadsú"tuple[Block | None, IfStmt | None]c                 C  s¸   t || jƒ |jdu r|jd jdu rdS |jdu s(|jd jdu r,|jjdu r,d|fS |jjdu r9|jd dfS |jd jdu rXt|jjd tƒrS|  |jjd ¡S |jdfS d|fS )a  Return block from IfStmt that will get executed.

        Return
            0 -> A block if sure that alternative blocks are unreachable.
            1 -> An IfStmt if the reachability of it can't be inferred,
                 i.e. the truth value is unknown.
        Nr   Trî   F)rl   rª   r®  rö   Úis_unreachablerÐ   r8   r•  ©r  rk  r™   r™   rš   r•    s   


z4ASTConverter._get_executable_if_block_with_overloadsc                 C  sl   t |jƒdkrg |jd _|jr2t |jjƒdkr4t|jjd tƒr,|  |jjd ¡ dS g |j_dS dS dS )z³Remove 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)ra  rö   r®  rÐ   r8   rš  r²  r™   r™   rš   rš  <  s   üz)ASTConverter._strip_contents_from_if_stmtrT   c                 C  s`   t |tƒsdS t|jƒdkrt|jd jƒdksdS |jr%t|jjƒdkr'dS |  |jjd ¡S )ziCheck stmt to make sure it is a stripped IfStmt.

        See also: _strip_contents_from_if_stmt
        Fr‚   r   T)rÐ   r8   ra  rö   r®  r©  r²  r™   r™   rš   r©  J  s   
"z!ASTConverter._is_stripped_if_stmtr  c                 C  s   || j jkrdS |S )z;Return the actual, internal module id for a source text id.r  )rª   Úcustom_typing_module)r  r  r™   r™   rš   Útranslate_module_id]  s   z ASTConverter.translate_module_idÚmodúast3.ModulerD   c                 C  s†   i | _ |j D ]}t|jƒ}|d ur|| j |j< q| jtj|jddd q|  | j|j	dd¡}t
|| jd| j d}| j|_| j|_|S )Nr£   F©r¶   T)rO  )Úignored_lines)r  ræ   rØ   rÈ   r&  r   rô   r^  r_  rö   rD   r  r¯   r±   )r  rµ  ÚtiÚparsedrö   r›  r™   r™   rš   Úvisit_Modulec  s   

zASTConverter.visit_Moduleúast3.FunctionDefúFuncDef | Decoratorc                 C  s
   |   |¡S r  ©Údo_func_def©r  r5  r™   r™   rš   Úvisit_FunctionDefx  ó   
zASTConverter.visit_FunctionDefúast3.AsyncFunctionDefc                 C  ó   | j |ddS )NT)rQ  r¾  rÀ  r™   r™   rš   Úvisit_AsyncFunctionDef}  ó   z#ASTConverter.visit_AsyncFunctionDefú(ast3.FunctionDef | ast3.AsyncFunctionDefc                 C  sæ  | j  d¡ t|jotdd„ |jD ƒƒƒ}|j}| j|j||d}t|j	ƒr.|D ]}d|_
q(dd„ |D ƒ}dd„ |D ƒ}d	}	g }
|rMd	gt|ƒ }
d	}n|jd	ur)zt|jd
dƒ}t|tƒsbJ ‚t|jƒdkrt|jd tƒr|jd jtu r|jr…|  tj||j¡ dd„ |D ƒ}
n+|js™tdd„ |D ƒƒr¢|  tj||j¡ t| j||jd |j¡}tttt  |ƒ}
t| j|d  |j¡}| j dd	… ddgk}|rát|
ƒt|ƒk rá|
 !dt"t#j$ƒ¡ W np t%y(   |j &dd¡d  '¡ }tj( )|¡}|  |||j¡ |jr|jd dvr|  *d||j¡ t"t#j+ƒgt|ƒ }
t"t#j+ƒ}Y n+w t,j-dkr9|j.r9|  /|j.¡}	dd„ |D ƒ}
t| j|jrK|jjn|d  |j¡}t0||
ƒD ]\}}|  1||j2¡ qXd	}t|
ƒso|rËt|
ƒdkrŠtdd„ |
D ƒƒrŠ|  tj3||j¡ nAt|
ƒt|ƒkrŸ| jtj4||jdd n,t|
ƒt|ƒk r´| jtj5||jdd nt6dd„ |
D ƒ|||d	urÄ|nt"t#j7ƒt8ƒ}t9|dd	ƒ}t9|dd	ƒ}| j  :¡  | j  d ¡ | j;|j<d|d!}t=|j	||||	ƒ}t|j>t6ƒr|j> ?¡ |_@|rd|_A|d	ur||_B||_C|jrT|jd j}tD|j	ƒ}d|_E| F|¡ d|_G||_H| F||j||¡ tI||  |j¡|ƒ}|jd }| F|j|j||¡ |}n| F||j||¡ |}| jJjKrltLjM|dd"|_N| j  :¡  |S )#zCHelper shared between visit_FunctionDef and visit_AsyncFunctionDef.ÚDc                 s  s    | ]}t |ƒV  qd S r  )r  )rÝ   Údr™   r™   rš   r«  †  s   € z+ASTConverter.do_func_def.<locals>.<genexpr>)r  Tc                 S  ó   g | ]}|j ‘qS r™   )Úkind©rÝ   Úargr™   r™   rš   rÞ     ó    z,ASTConverter.do_func_def.<locals>.<listcomp>c                 S  s   g | ]}|j r	d n|jj‘qS r  )Úpos_onlyÚvariabler–  rÌ  r™   r™   rš   rÞ     s    Nz<func_type>Ú	func_typer‚   r   c                 S  s&   g | ]}|j d ur|j nttjƒ‘qS r  )Útype_annotationrq   r|   Úunannotated©rÝ   Úar™   r™   rš   rÞ   ¥  s    
ýÿüc                 s  s    | ]}|j d uV  qd S r  ©rÒ  rÔ  r™   r™   rš   r«  ¯  r¬  )rè   rï   ©rè   rV  rW  rÛ   rí   )r   rÛ   z.Suggestion: wrap argument types in parenthesesrŸ   c                 S  rÊ  r™   rÖ  rÔ  r™   r™   rš   rÞ   Ê  rÎ  c                 s  s    | ]}t |tƒV  qd S r  )rÐ   rt   ©rÝ   Útr™   r™   rš   r«  Ô  r¬  Fr·  c                 S  s"   g | ]}|d ur
|nt tjƒ‘qS r  )rq   r|   rÓ  rÔ  r™   r™   rš   rÞ   æ  s   " r7  r8  rU  r’  ©Úclean)Or  r@  r
  rM  ÚanyrÈ   Útransform_argsÚargsro   r–  rÏ  ra  rç   r›   rÐ   r‡   ÚargtypesÚConstantró   ÚEllipsisÚreturnsr&  r   ÚDUPLICATE_TYPE_SIGNATURESr9  rõ   r©   rG  r   r   r   ry   rÄ   Úinsertrq   r|   Úspecial_formrÅ   rä   rÜ   rñ   rò   r   Ú
from_errorrÆ   rÇ   Útype_paramsÚtranslate_type_paramsÚzipÚset_type_optionalÚinitializerÚELLIPSIS_WITH_OTHER_TYPEARGSÚTYPE_SIGNATURE_TOO_MANY_ARGSÚTYPE_SIGNATURE_TOO_FEW_ARGSrs   rÓ  r¤   r1  r™  r“  rö   r5   r-  Úcopy_modifiedÚunanalyzed_typerQ  Ú
definitionrè   r]   Úis_readyr<  Úis_decoratedÚ	deco_liner,   rª   Úinclude_docstringsr—   Úget_docstringÚ	docstring)r  r5  rQ  r  rÈ   rÞ  rÍ  Ú	arg_kindsÚ	arg_namesÚexplicit_type_paramsÚ	arg_typesÚreturn_typeÚfunc_type_astÚtranslated_argsÚin_method_scoperø   rù   Úarg_typerÑ  r:  r;  rö   Úfunc_defrô  ÚvarÚdecor‹  Úretvalr™   r™   rš   r¿  €  sî   ÿ
ÿú

ÿþ€ÿ÷ÿþ"üüû	






zASTConverter.do_func_defr-  úType | Nonerë  úExpression | Nonec                 C  s8   | j jsd S t|tƒo|jdk}t|tƒr||_d S d S )Nr  )rª   Úimplicit_optionalrÐ   rE   r–  r}   Úoptional)r  r-  rë  r  r™   r™   rš   rê    s   

ÿzASTConverter.set_type_optionalrÞ  úast3.argumentsr  úlist[Argument]c              
   C  sš  g }g }t |dtttj g ƒƒ}||j }|j}t|ƒt|ƒ }	t|d |	… ƒD ]\}
}|
t|ƒk }| 	|  
|d t||¡¡ | 	|¡ q(tt||	d … |ƒƒD ]\}
\}}|	|
 t|ƒk }| 	|  
||t||¡¡ | 	|¡ qO|jd ur†| 	|  
|jd t|¡¡ | 	|j¡ t|j|jƒD ]\}}| 	|  
|||d u rtnt|¡¡ | 	|¡ q|jd ur¿| 	|  
|jd t|¡¡ | 	|j¡ tdd„ |D ƒ|| jƒ |S )NÚposonlyargsc                 S  s   g | ]}|j j‘qS r™   )rÐ  r–  rÌ  r™   r™   rš   rÞ   H  rß   z/ASTConverter.transform_args.<locals>.<listcomp>)r1  r   r   r—   rÍ  rÞ  r   ra  Ú	enumerater@  Úmake_argumentr   ré  r   Úvarargr   Ú
kwonlyargsÚkw_defaultsr   r   Úkwargr   rb   Úfail_arg)r  rÞ  rè   r  Únew_argsÚnamesr  Ú	args_argsÚargs_defaultsÚnum_no_defaultsÚirÕ  rÏ  rÉ  Úkdr™   r™   rš   rÝ     s:   
"
ÿÿ
zASTConverter.transform_argsrÍ  úast3.argÚdefaultr  rË  r   rÏ  r   c           
   	   C  s¾   |rd }n0|j }|j}|d ur|d ur|  tj|j|j¡ d }|d ur/t| j|jd 	|¡}n|  
||¡}t|jƒr<d}tt|j|ƒ||  	|¡||ƒ}	|	 |j|jt|dd ƒt|dd ƒ¡ |	S )Nr×  Tr7  r8  )Ú
annotationrç   r&  r   rã  rÈ   r9  rõ   r©   rÄ   rp  rn   rÍ  r   r]   r<  r1  )
r  rÍ  r  rË  r  rÏ  r   r  rç   Úargumentr™   r™   rš   r  L  s(   


üzASTConverter.make_argumentc                 C  s   |   t|ƒ|j|j¡ d S r  )r&  r   rÈ   r9  )r  rÉ   rÍ  r™   r™   rš   r  l  ó   zASTConverter.fail_argúast3.ClassDefr'   c              	     sê   ˆ j  d¡ ‡ fdd„|jD ƒ}d }tjdkr |jr ˆ  |j¡}t|jˆ  	|j
¡d ˆ  |j¡t|ƒ d¡||d}ˆ  |j¡|_|j|_|jrM|jd jnd |_ˆ jjr\tj|dd	|_|j|_t|d
d ƒ|_t|dd ƒ|_ˆ j  ¡  |S )NrW  c                   s$   g | ]}|j r|j ˆ  |j¡f‘qS r™   )rÍ  rÄ   ró   )rÝ   Úkwrª  r™   rš   rÞ   v  s   $ z/ASTConverter.visit_ClassDef.<locals>.<listcomp>rŸ   Ú	metaclass)r!  ÚkeywordsÚ	type_argsr   FrÚ  r7  r8  )r  r@  r"  rÆ   rÇ   rç  rè  r'   r–  r“  rö   rG  ÚbasesÚdictr.  rM  Ú
decoratorsrÈ   rè   rô  rª   rõ  r—   rö  r÷  r9  ré   r1  r:  r;  r™  )r  r5  r"  rú  Úcdefr™   rª  rš   Úvisit_ClassDeft  s0   

ù	
zASTConverter.visit_ClassDefÚ
type_paramÚast_TypeVarc                 C  ó„   t |jƒ}|d u rd S t|tjtjfƒr|  tj|j	|j
¡ t|tjƒr.|  tj|j	|j
¡ t|tjƒr@|  tj|j	|j
¡ d S d S r  )r  r¢   rÐ   r—   r  r  r&  r   Ú"TYPE_VAR_YIELD_EXPRESSION_IN_BOUNDrÈ   r9  r  Ú"TYPE_VAR_NAMED_EXPRESSION_IN_BOUNDr  Ú"TYPE_VAR_AWAIT_EXPRESSION_IN_BOUND)r  r)  Úincorrect_exprr™   r™   rš   Úvalidate_type_param•  s,   
ýýýÿz ASTConverter.validate_type_paramrç  ú	list[Any]úlist[TypeParam]c                   s,  g }|D ]}d }g }t jdkr |jd ur | jtj|j|jdd t|t	ƒr1| 
t|jtd g ƒ¡ qt|tƒrB| 
t|jtd g ƒ¡ qt|jtjƒrrt|jjƒdk r^| jtj|j|jdd n*t| j|jd‰ ‡ fdd„|jjD ƒ}n|jd urˆ|  |¡ t| j|jd |j¡}| 
t|jt||ƒ¡ q|S )N)rœ   é   Fr·  rí   r×  c                   ó   g | ]}ˆ   |¡‘qS r™   ©rÄ   rØ  ©Úconvr™   rš   rÞ   Ç  ó    z6ASTConverter.translate_type_params.<locals>.<listcomp>)rÆ   rÇ   Údefault_valuer&  r   Ú TYPE_PARAM_DEFAULT_NOT_SUPPORTEDrÈ   r9  rÐ   Úast_ParamSpecr@  r[   r–  r   Úast_TypeVarTupler   r¢   r—   ÚTuplera  ÚeltsÚ"TYPE_VAR_TOO_FEW_CONSTRAINED_TYPESrõ   r©   r0  rÄ   r   )r  rç  rú  Úpr¢   Úvaluesr™   r6  rš   rè  ¬  s<   ü

ü

z"ASTConverter.translate_type_paramsúast3.ReturnrO   c                 C  ó   t |  |j¡ƒ}|  ||¡S r  )rO   rÄ   ró   r<  ©r  r5  r  r™   r™   rš   Úvisit_ReturnÏ  ó   zASTConverter.visit_Returnúast3.Deleter-   c                 C  sT   t |jƒdkrt|  |j¡ƒ}| |j¡ t|ƒ}n
t|  |jd ¡ƒ}|  ||¡S )Nr‚   r   )ra  ÚtargetsrY   rG  r<  rÈ   r-   rÄ   )r  r5  Útupr  r™   r™   rš   Úvisit_DeleteÔ  s   
zASTConverter.visit_Deleteúast3.Assignr!   c                 C  sB   |   |j¡}|  |j¡}|  ||j¡}t|||dd}|  ||¡S )NF©r-  Ú
new_syntax)rG  rH  rÄ   ró   rp  rç   r!   r<  )r  r5  ÚlvaluesÚrvaluer÷   rl  r™   r™   rš   Úvisit_AssignÞ  s
   zASTConverter.visit_Assignúast3.AnnAssignc                 C  s   |j }|jd u rtttjƒdd}||_|j|_n|  	|j¡}t
| j|d 	|j¡}|d us0J ‚|jj|_t|  	|j¡g||dd}|  ||¡S )NT)Úno_rhsr×  rL  )rÈ   ró   rW   rq   r|   rå  rè   r9  ré   rÄ   rõ   r©   r  r!   Útargetr<  )r  r5  rè   rO  r÷   rl  r™   r™   rš   Úvisit_AnnAssignæ  s   


zASTConverter.visit_AnnAssignúast3.AugAssignrH   c                 C  s0   t |  |j¡|  |j¡|  |j¡ƒ}|  ||¡S r  )rH   r  r{  rÄ   rS  ró   r<  ©r  r5  rl  r™   r™   rš   Úvisit_AugAssignõ  ó   ÿzASTConverter.visit_AugAssignúast3.Forr4   c                 C  sJ   |   ||j¡}t|  |j¡|  |j¡|  |j¡|  |j	¡|ƒ}|  
||¡S r  )rp  rç   r4   rÄ   rS  Úiterr“  rö   r‘  Úorelser<  ©r  r5  Útarget_typer  r™   r™   rš   Ú	visit_Forü  s   



ûzASTConverter.visit_Forúast3.AsyncForc                 C  sP   |   ||j¡}t|  |j¡|  |j¡|  |j¡|  |j	¡|ƒ}d|_
|  ||¡S ©NT)rp  rç   r4   rÄ   rS  rZ  r“  rö   r‘  r[  Úis_asyncr<  r\  r™   r™   rš   Úvisit_AsyncFor  s   



ûzASTConverter.visit_AsyncForú
ast3.Whiler^   c                 C  s0   t |  |j¡|  |j¡|  |j¡ƒ}|  ||¡S r  )r^   rÄ   Útestr“  rö   r‘  r[  r<  rD  r™   r™   rš   Úvisit_While  rX  zASTConverter.visit_Whileúast3.Ifc                 C  s4   t |  |j¡g|  |j¡g|  |j¡ƒ}|  ||¡S r  )r8   rÄ   rd  r“  rö   r‘  r[  r<  rD  r™   r™   rš   Úvisit_If  s   "ÿzASTConverter.visit_Ifú	ast3.Withr_   c                   sP   ˆ   ||j¡}t‡ fdd„|jD ƒ‡ fdd„|jD ƒˆ  |j¡|ƒ}ˆ  ||¡S )Nc                   ó   g | ]}ˆ   |j¡‘qS r™   ©rÄ   Úcontext_expr©rÝ   r  rª  r™   rš   rÞ   &  ó    z+ASTConverter.visit_With.<locals>.<listcomp>c                   ri  r™   ©rÄ   Úoptional_varsrl  rª  r™   rš   rÞ   '  rm  )rp  rç   r_   r˜  r“  rö   r<  r\  r™   rª  rš   Ú
visit_With#  s   
üzASTConverter.visit_Withúast3.AsyncWithc                   sV   ˆ   ||j¡}t‡ fdd„|jD ƒ‡ fdd„|jD ƒˆ  |j¡|ƒ}d|_ˆ  ||¡S )Nc                   ri  r™   rj  rl  rª  r™   rš   rÞ   1  rm  z0ASTConverter.visit_AsyncWith.<locals>.<listcomp>c                   ri  r™   rn  rl  rª  r™   rš   rÞ   2  rm  T)rp  rç   r_   r˜  r“  rö   ra  r<  )r  r5  r]  rl  r™   rª  rš   Úvisit_AsyncWith.  s   
üzASTConverter.visit_AsyncWithú
ast3.RaiserM   c                 C  ó&   t |  |j¡|  |j¡ƒ}|  ||¡S r  )rM   rÄ   ÚexcÚcauser<  rD  r™   r™   rš   Úvisit_Raise:  ó   zASTConverter.visit_Raiseúast3.TryrX   c              	     sr   ‡ fdd„|j D ƒ}‡ fdd„|j D ƒ}‡ fdd„|j D ƒ}tˆ  |j¡|||ˆ  |j¡ˆ  |j¡ƒ}ˆ  ||¡S )Nc                   ó,   g | ]}|j d urˆ  t|j ƒ|¡nd ‘qS r  ©r–  r<  rE   ©rÝ   Úhrª  r™   rš   rÞ   @  ó     ÿz*ASTConverter.visit_Try.<locals>.<listcomp>c                   ri  r™   ©rÄ   r-  r|  rª  r™   rš   rÞ   C  rm  c                   ri  r™   ©r“  rö   r|  rª  r™   rš   rÞ   D  rm  )ÚhandlersrX   r“  rö   r‘  r[  Ú	finalbodyr<  ©r  r5  ÚvsÚtypesr  r  r™   rª  rš   Ú	visit_Try?  s   
ÿ


úzASTConverter.visit_TryÚTryStarc              	     sx   ‡ fdd„|j D ƒ}‡ fdd„|j D ƒ}‡ fdd„|j D ƒ}tˆ  |j¡|||ˆ  |j¡ˆ  |j¡ƒ}d|_ˆ  ||¡S )Nc                   rz  r  r{  r|  rª  r™   rš   rÞ   Q  r~  z.ASTConverter.visit_TryStar.<locals>.<listcomp>c                   ri  r™   r  r|  rª  r™   rš   rÞ   T  rm  c                   ri  r™   r€  r|  rª  r™   rš   rÞ   U  rm  T)	r  rX   r“  rö   r‘  r[  r‚  Úis_starr<  rƒ  r™   rª  rš   Úvisit_TryStarP  s   
ÿ


úzASTConverter.visit_TryStarúast3.Assertr   c                 C  rt  r  )r   rÄ   rd  rÉ   r<  rD  r™   r™   rš   Úvisit_Assertc  rx  zASTConverter.visit_Assertúast3.Importr9   c                 C  sh   g }|j D ]}|  |j¡}|j}|d u r||jkr|j}| ||f¡ qt|ƒ}| j |¡ |  ||¡S r  )r  r´  r–  Úasnamer@  r9   r  r<  )r  r5  r  Úaliasr–  r  r  r™   r™   rš   Úvisit_Importh  s   
zASTConverter.visit_Importúast3.ImportFromr;   c                 C  s–   |j d usJ ‚t|jƒdkr'|jd jdkr'|jd ur|jnd}t||j ƒ}nt|jd ur3|  |j¡nd|j dd„ |jD ƒƒ}| j 	|¡ |  
||¡S )Nr‚   r   rs  rÚ   c                 S  s   g | ]}|j |jf‘qS r™   )r–  r  rÔ  r™   r™   rš   rÞ     rm  z1ASTConverter.visit_ImportFrom.<locals>.<listcomp>)Úlevelra  r  r–  r§   r:   r<   r´  r  r@  r<  )r  r5  rµ  r  r™   r™   rš   Úvisit_ImportFromx  s   ýzASTConverter.visit_ImportFromúast3.Globalr7   c                 C  ó   t |jƒ}|  ||¡S r  )r7   r  r<  )r  r5  Úgr™   r™   rš   Úvisit_Global‡  ó   
zASTConverter.visit_Globalúast3.NonlocalrG   c                 C  r”  r  )rG   r  r<  )r  r5  rÉ  r™   r™   rš   Úvisit_NonlocalŒ  r—  zASTConverter.visit_Nonlocalú	ast3.Exprr2   c                 C  ó    |   |j¡}t|ƒ}|  ||¡S r  )rÄ   ró   r2   r<  )r  r5  ró   r  r™   r™   rš   Ú
visit_Expr‘  ó   zASTConverter.visit_Exprú	ast3.PassrL   c                 C  ó   t ƒ }|  ||¡S r  )rL   r<  rV  r™   r™   rš   Ú
visit_Pass—  ó   zASTConverter.visit_Passú
ast3.Breakr$   c                 C  rŸ  r  )r$   r<  rV  r™   r™   rš   Úvisit_Breakœ  r¡  zASTConverter.visit_Breakúast3.Continuer+   c                 C  rŸ  r  )r+   r<  rV  r™   r™   rš   Úvisit_Continue¡  r¡  zASTConverter.visit_Continuer  r    c                 C  rt  r  )r    rÄ   rS  ró   r<  rV  r™   r™   rš   Úvisit_NamedExpr§  rx  zASTConverter.visit_NamedExprúast3.BoolOprI   c                 C  sf   t |jƒdks	J ‚|j}t|tjƒrd}nt|tjƒrd}n
tdtt	|ƒƒ ƒ‚|  
||  |j¡|¡S )Nrí   ÚandÚorzunknown BoolOp )ra  rA  r{  rÐ   r—   ÚAndÚOrr~  r‘   r-  rã   rG  )r  r5  Úop_noder{  r™   r™   rš   Úvisit_BoolOp¬  s   zASTConverter.visit_BoolOpÚvalsr	  c              	   C  sP   t |ƒdkrt||d |d ƒ}nt||d |  ||dd … |¡ƒ}|  ||¡S )Nrí   r   r‚   )ra  rI   rã   r<  )r  r{  r®  r5  rÔ   r™   r™   rš   rã   º  s   "zASTConverter.groupú
ast3.BinOpc                 C  sR   |   |j¡}|d u rtdtt|jƒƒ ƒ‚t||  |j¡|  |j¡ƒ}|  	||¡S )Nzcannot translate BinOp )
r  r{  r~  r‘   r-  rI   rÄ   ÚleftÚrightr<  ©r  r5  r{  rÔ   r™   r™   rš   Úvisit_BinOpÂ  s
   zASTConverter.visit_BinOpúast3.UnaryOpr\   c                 C  sŽ   d }t |jtjƒrd}nt |jtjƒrd}nt |jtjƒr d}n	t |jtjƒr)d}|d u r8tdtt	|jƒƒ ƒ‚t
||  |j¡ƒ}|  ||¡S )Nú~Únotrq  rr  zcannot translate UnaryOp )rÐ   r{  r—   ÚInvertÚNotr‹   r   r~  r‘   r-  r\   rÄ   Úoperandr<  r²  r™   r™   rš   Úvisit_UnaryOpÌ  s   zASTConverter.visit_UnaryOpúast3.Lambdar?   c                 C  sh   t  |j¡}|jj|_|jj|_| j d¡ t|  |j	|j¡|  
|g¡ƒ}| j ¡  | |j|j¡ |S )NÚL)r—   ÚReturnrö   rÈ   r9  r  r@  r?   rÝ  rÞ  r“  r™  r<  )r  r5  rö   rÔ   r™   r™   rš   Úvisit_LambdaÞ  s   


zASTConverter.visit_Lambdaú
ast3.IfExpr*   c                 C  s0   t |  |j¡|  |j¡|  |j¡ƒ}|  ||¡S r  )r*   rÄ   rd  rö   r[  r<  ©r  r5  rÔ   r™   r™   rš   Úvisit_IfExpê  s   $zASTConverter.visit_IfExpú	ast3.Dictr.   c                 C  s.   t tt|  |j¡|  |j¡ƒƒƒ}|  ||¡S r  )r.   Úlistré  rC  ÚkeysrG  rA  r<  rÀ  r™   r™   rš   Ú
visit_Dictï  s   ÿzASTConverter.visit_Dictúast3.SetrQ   c                 C  rC  r  )rQ   rG  r>  r<  rÀ  r™   r™   rš   Ú	visit_Setö  rF  zASTConverter.visit_Setúast3.ListCompr@   c                 C  ó"   t |  ttj|ƒ¡ƒ}|  ||¡S r  )r@   Úvisit_GeneratorExpr   r—   ÚGeneratorExpr<  rÀ  r™   r™   rš   Úvisit_ListCompû  ó   zASTConverter.visit_ListCompúast3.SetComprP   c                 C  rÉ  r  )rP   rÊ  r   r—   rË  r<  rÀ  r™   r™   rš   Úvisit_SetComp   rÍ  zASTConverter.visit_SetCompúast3.DictCompr/   c                   sz   ‡ fdd„|j D ƒ}‡ fdd„|j D ƒ}‡ fdd„|j D ƒ}dd„ |j D ƒ}tˆ  |j¡ˆ  |j¡||||ƒ}ˆ  ||¡S )Nc                   ri  r™   ©rÄ   rS  ©rÝ   Úcrª  r™   rš   rÞ     rm  z/ASTConverter.visit_DictComp.<locals>.<listcomp>c                   ri  r™   ©rÄ   rZ  rÒ  rª  r™   rš   rÞ     rm  c                   ri  r™   ©rG  ÚifsrÒ  rª  r™   rš   rÞ     rm  c                 S  ó   g | ]}t |jƒ‘qS r™   ©r
  ra  rÒ  r™   r™   rš   rÞ   	  r8  )Ú
generatorsr/   rÄ   Úkeyró   r<  ©r  r5  rH  ÚitersÚifs_listra  rÔ   r™   rª  rš   Úvisit_DictComp  s   ÿzASTConverter.visit_DictCompúast3.GeneratorExpr6   c                   sp   ‡ fdd„|j D ƒ}‡ fdd„|j D ƒ}‡ fdd„|j D ƒ}dd„ |j D ƒ}tˆ  |j¡||||ƒ}ˆ  ||¡S )Nc                   ri  r™   rÑ  rÒ  rª  r™   rš   rÞ     rm  z3ASTConverter.visit_GeneratorExp.<locals>.<listcomp>c                   ri  r™   rÔ  rÒ  rª  r™   rš   rÞ     rm  c                   ri  r™   rÕ  rÒ  rª  r™   rš   rÞ     rm  c                 S  r×  r™   rØ  rÒ  r™   r™   rš   rÞ     r8  )rÙ  r6   rÄ   Úeltr<  rÛ  r™   rª  rš   rÊ    s   zASTConverter.visit_GeneratorExpú
ast3.Awaitr"   c                 C  r›  r  )rÄ   ró   r"   r<  )r  r5  ÚvrÔ   r™   r™   rš   Úvisit_Await  r  zASTConverter.visit_Awaitú
ast3.Yieldr`   c                 C  rC  r  )r`   rÄ   ró   r<  rÀ  r™   r™   rš   Úvisit_Yield  rF  zASTConverter.visit_Yieldúast3.YieldFromra   c                 C  rC  r  )ra   rÄ   ró   r<  rÀ  r™   r™   rš   Úvisit_YieldFrom$  rF  zASTConverter.visit_YieldFromúast3.Comparer(   c                   s>   ‡ fdd„|j D ƒ}ˆ  |jg|j ¡}t||ƒ}ˆ  ||¡S )Nc                   r4  r™   )r‰  )rÝ   Úorª  r™   rš   rÞ   *  r8  z.ASTConverter.visit_Compare.<locals>.<listcomp>)ÚopsrG  r°  Úcomparatorsr(   r<  )r  r5  Ú	operatorsÚoperandsrÔ   r™   rª  rš   Úvisit_Compare)  s   
zASTConverter.visit_Comparer†   r&   c              	   C  sŽ   |j }|j}dd„ |D ƒ}|  dd„ |D ƒdd„ |D ƒ ¡}dd„ |D ƒdd„ |D ƒ }t|  |j¡||tdd gt|ƒ ƒ| ƒ}|  ||¡S )Nc                 S  rÊ  r™   )rÍ  ©rÝ   Úkr™   r™   rš   rÞ   4  rÎ  z+ASTConverter.visit_Call.<locals>.<listcomp>c                 S  s    g | ]}t |tƒr|jn|‘qS r™   )rÐ   rŠ   ró   rÔ  r™   r™   rš   rÞ   6  ó     c                 S  rÊ  r™   )ró   rï  r™   r™   rš   rÞ   6  rÎ  c                 S  s    g | ]}t |ƒtu rtnt‘qS r™   )r-  rŠ   r   r   rÔ  r™   r™   rš   rÞ   8  rñ  c                 S  s   g | ]
}|d u r
t nt‘qS r  )r   r   rÌ  r™   r™   rš   rÞ   8  s    ÿzList[Optional[str]])	rÞ  r"  rG  r&   rÄ   Úfuncr   ra  r<  )r  r5  rÞ  r"  Úkeyword_namesrû  rø  rÔ   r™   r™   rš   Ú
visit_Call1  s    ÿÿ
üzASTConverter.visit_Callrà  c                 C  sÌ   |j }d }|d u rtdƒ}nRt|tƒrt|ƒ}nHt|tƒr$tt|ƒƒ}n<t|tƒr0tt|ƒƒ}n0t|t	ƒr:t
|ƒ}n&t|tƒrDt|ƒ}nt|tƒrNt|ƒ}n|tu rVtƒ }n
tdtt|ƒƒ ƒ‚|  ||¡S )Nr  zConstant not implemented for )ró   rE   rÐ   r‘   rU   Úbytesr%   r€   r
  r”   r>   Úfloatr3   Úcomplexr)   rá  r0   r~  r-  r<  )r  r5  ÚvalrÔ   r™   r™   rš   Úvisit_ConstantD  s(   










zASTConverter.visit_Constantúast3.JoinedStrr1   c                 C  s¾   t dƒ}| |j|j¡ t|  |j¡ƒ}| |¡ t|jƒdkr)|  |jd |¡S t|jƒdkrE|jd }t	|t ƒrE|j
dkrE|jdd …= t|dƒ}| |¡ t||gtgd gƒ}|  ||¡S )NrÚ   r‚   r   r£   rY  )rU   r<  rÈ   r9  rA   rG  rA  ra  r˜  rÐ   ró   rC   r&   r   )r  r5  Úempty_stringÚstrs_to_joinrŒ  Újoin_methodÚresult_expressionr™   r™   rš   Úvisit_JoinedStr\  s   



zASTConverter.visit_JoinedStrúast3.FormattedValuec                 C  s°   |   |j¡}| |j|j¡ |jdk rdndt|jƒ }td| d ƒ}|jd ur/|   |j¡ntdƒ}| |j|j¡ t	|dƒ}| |¡ t
|||gttgd d gƒ}|  ||¡S )Nr   rÚ   ú!Ú{z:{}}rò   )rÄ   ró   r<  rÈ   r9  Ú
conversionÚchrrU   Úformat_specrC   r&   r   )r  r5  Úval_expÚconv_strÚformat_stringÚformat_spec_expÚformat_methodrþ  r™   r™   rš   Úvisit_FormattedValuer  s   

ÿz!ASTConverter.visit_FormattedValuer…   úMemberExpr | SuperExprc                 C  s^   |j }t|  |¡|jƒ}|j}t|tƒr't|jtƒr'|jj	dkr't
|j	|ƒ}n|}|  ||¡S )NÚsuper)ró   rC   rÄ   r  r  rÐ   r&   ÚcalleerE   r–  rV   r<  )r  r5  ró   Úmember_exprÚobjrÔ   r™   r™   rš   Úvisit_Attribute…  s   ÿ
þzASTConverter.visit_Attributeúast3.Subscriptr=   c                 C  sh   t |  |j¡|  |j¡ƒ}|  ||¡ tjdk }t|jtj	ƒs(|r2t|jtj
ƒr2|j|j_|j|j_|S )Nr²   )r=   rÄ   ró   Úslicer<  rÆ   rÇ   rÐ   r—   ÚSliceÚExtSlicerè   Úindexré   )r  r5  rÔ   rÕ   r™   r™   rš   Úvisit_Subscript”  s   
ÿÿ

zASTConverter.visit_SubscriptrŠ   rS   c                 C  rC  r  )rS   rÄ   ró   r<  rÀ  r™   r™   rš   Úvisit_Starred¥  rF  zASTConverter.visit_Starredr‰   rE   c                 C  r”  r  )rE   r  r<  rÀ  r™   r™   rš   Ú
visit_Nameª  r—  zASTConverter.visit_Nameú	ast3.ListúListExpr | TupleExprc                   s@   ‡ fdd„|j D ƒ}t|jtjƒrt|ƒ}nt|ƒ}ˆ  ||¡S )Nc                   r4  r™   r5  ©rÝ   rÔ   rª  r™   rš   rÞ   °  r8  z+ASTConverter.visit_List.<locals>.<listcomp>)r>  rÐ   Úctxr—   ÚStorerY   rA   r<  )r  r5  Ú	expr_listrÔ   r™   rª  rš   Ú
visit_List¯  s
   
zASTConverter.visit_Listú
ast3.TuplerY   c                 C  rC  r  )rY   rG  r>  r<  rÀ  r™   r™   rš   Úvisit_Tuple¹  rF  zASTConverter.visit_Tupleú
ast3.SlicerR   c                 C  s$   t |  |j¡|  |j¡|  |j¡ƒS r  )rR   rÄ   ÚlowerÚupperÚsteprÀ  r™   r™   rš   Úvisit_SliceÀ  s   $zASTConverter.visit_Sliceúast3.ExtSlicec                 C  s   t |  tt|ƒj¡ƒS r  )rY   rG  r   r   ÚdimsrÀ  r™   r™   rš   Úvisit_ExtSliceÄ  s   zASTConverter.visit_ExtSlicerˆ   rF   c                 C  ó$   |   tt|ƒj¡}t|tƒsJ ‚|S r  )rÄ   r   r   ró   rÐ   rF   ©r  r5  ró   r™   r™   rš   Úvisit_IndexÉ  ó   zASTConverter.visit_IndexÚMatchrB   c                   sR   t ˆ  |j¡‡ fdd„|jD ƒ‡ fdd„|jD ƒ‡ fdd„|jD ƒƒ}ˆ  ||¡S )Nc                   ri  r™   )rÄ   ÚpatternrÒ  rª  r™   rš   rÞ   Ó  rm  z,ASTConverter.visit_Match.<locals>.<listcomp>c                   ri  r™   )rÄ   ÚguardrÒ  rª  r™   rš   rÞ   Ô  rm  c                   ri  r™   r€  rÒ  rª  r™   rš   rÞ   Õ  rm  )rB   rÄ   ÚsubjectÚcasesr<  rD  r™   rª  rš   Úvisit_MatchÐ  s   
üzASTConverter.visit_MatchÚ
MatchValuerk   c                 C  rC  r  )rk   rÄ   ró   r<  rD  r™   r™   rš   Úvisit_MatchValueÙ  rF  zASTConverter.visit_MatchValueÚMatchSingletonri   c                 C  r”  r  )ri   ró   r<  rD  r™   r™   rš   Úvisit_MatchSingletonÝ  r—  z!ASTConverter.visit_MatchSingletonÚMatchSequencerh   c                   sF   ‡ fdd„|j D ƒ}dd„ |D ƒ}t|ƒdk sJ ‚t|ƒ}ˆ  ||¡S )Nc                   r4  r™   r5  ©rÝ   r@  rª  r™   rš   rÞ   â  r8  z4ASTConverter.visit_MatchSequence.<locals>.<listcomp>c                 S  s   g | ]	}t |tƒr|‘qS r™   )rÐ   rj   r:  r™   r™   rš   rÞ   ã  s    rí   )Úpatternsra  rh   r<  )r  r5  r;  Ústarsr  r™   rª  rš   Úvisit_MatchSequenceá  s
   z ASTConverter.visit_MatchSequenceÚ	MatchStarrj   c                 C  s:   |j d u r
td ƒ}n|  t|j ƒ|¡}t|ƒ}|  ||¡S r  )r–  rj   r<  rE   )r  r5  r  r–  r™   r™   rš   Úvisit_MatchStaré  s
   

zASTConverter.visit_MatchStarÚMatchMappingrf   c                   sZ   ‡ fdd„|j D ƒ}‡ fdd„|jD ƒ}|jd u rd }nt|jƒ}t|||ƒ}ˆ  ||¡S )Nc                   r4  r™   r5  rï  rª  r™   rš   rÞ   ó  r8  z3ASTConverter.visit_MatchMapping.<locals>.<listcomp>c                   r4  r™   r5  )rÝ   râ  rª  r™   rš   rÞ   ô  r8  )rÄ  r;  ÚrestrE   rf   r<  )r  r5  rÄ  rA  rA  r  r™   rª  rš   Úvisit_MatchMappingò  s   

zASTConverter.visit_MatchMappingÚ
MatchClassre   c                   sb   ˆ   |j¡}t|tƒsJ ‚‡ fdd„|jD ƒ}|j}‡ fdd„|jD ƒ}t||||ƒ}ˆ  ||¡S )Nc                   r4  r™   r5  r:  rª  r™   rš   rÞ     r8  z1ASTConverter.visit_MatchClass.<locals>.<listcomp>c                   r4  r™   r5  r:  rª  r™   rš   rÞ     r8  )	rÄ   ÚclsrÐ   rN   r;  Ú	kwd_attrsÚkwd_patternsre   r<  )r  r5  Ú	class_refÚpositionalsÚkeyword_keysÚkeyword_valuesr  r™   rª  rš   Úvisit_MatchClassþ  s   zASTConverter.visit_MatchClassÚMatchAsrd   c                 C  sD   |j d u rd }nt|j ƒ}|  ||¡}t|  |j¡|ƒ}|  ||¡S r  )r–  rE   r<  rd   rÄ   r0  )r  r5  r–  r  r™   r™   rš   Úvisit_MatchAs	  s   

zASTConverter.visit_MatchAsÚMatchOrrg   c                   s$   t ‡ fdd„|jD ƒƒ}ˆ  ||¡S )Nc                   r4  r™   r5  )rÝ   r0  rª  r™   rš   rÞ     r8  z.ASTConverter.visit_MatchOr.<locals>.<listcomp>)rg   r;  r<  rD  r™   rª  rš   Úvisit_MatchOr  s   zASTConverter.visit_MatchOrÚast_TypeAliasc                 C  r+  r  )r  ró   rÐ   r—   r  r  r&  r   Ú TYPE_ALIAS_WITH_YIELD_EXPRESSIONrÈ   r9  r  Ú TYPE_ALIAS_WITH_NAMED_EXPRESSIONr  Ú TYPE_ALIAS_WITH_AWAIT_EXPRESSION)r  r5  r/  r™   r™   rš   Úvalidate_type_alias  s   
ÿz ASTConverter.validate_type_aliasúTypeAliasStmt | AssignmentStmtc                 C  sv   |   |j¡}|  |¡ |  |j¡}t|ƒ}|  ||j¡ tt|gƒd}|  ||j¡ t	|  
|j¡||ƒ}|  ||¡S )N)rö   )rè  rç  rT  rÄ   ró   rO   r<  r?   r#   rZ   r  r–  )r  r5  rç  ró   r›  Ú
value_funcr  r™   r™   rš   Úvisit_TypeAlias#  s   
zASTConverter.visit_TypeAlias)rª   rc   r¯   r
  r©   r   r°   r
  r±   r‘   r•   r  ©rÉ   r‘   rè   r”   ré   r”   r•   r  )T)
rÉ   r   rè   r”   ré   r”   r¶   r
  r•   r  )r  r8   r•   r  )r  r+  r•   r   )r  r¡   r5  r6  r•   r¡   )r=  r>  r•   r?  )r=  rD  r•   rE  )r  rI  r•   r”   )
rR  rS  rO  r
  rP  r
  rQ  r
  r•   rT  )r5  rn  rç   r¨   r•   ro  )r{  r|  r•   r‘   )r{  rˆ  r•   r‘   )rŠ  r#   rR  rS  r•   r  )rR  rŽ  r•   r  )rR  rŽ  rP  r
  rQ  r
  r•   r#   )rR  rT  r•   rT  r  )rk  r8   r  r¨   r•   r¨   )rk  r8   r•   r°  )rk  r8   r•   r  )rk  rT   r•   r
  )r  r‘   r•   r‘   )rµ  r¶  r•   rD   )r5  r¼  r•   r½  )r5  rÃ  r•   r½  )F)r5  rÇ  rQ  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  )r5  r  r•   r'   )r)  r*  r•   r  )rç  r1  r•   r2  )r5  rB  r•   rO   )r5  rG  r•   r-   )r5  rK  r•   r!   )r5  rQ  r•   r!   )r5  rU  r•   rH   )r5  rY  r•   r4   )r5  r_  r•   r4   )r5  rc  r•   r^   )r5  rf  r•   r8   )r5  rh  r•   r_   )r5  rq  r•   r_   )r5  rs  r•   rM   )r5  ry  r•   rX   )r5  r‡  r•   rX   )r5  rŠ  r•   r   )r5  rŒ  r•   r9   )r5  r  r•   r;   )r5  r“  r•   r7   )r5  r˜  r•   rG   )r5  rš  r•   r2   )r5  rž  r•   rL   )r5  r¢  r•   r$   )r5  r¤  r•   r+   )r5  r  r•   r    )r5  r§  r•   rI   )r{  r‘   r®  rE  r5  r	  r•   rI   )r5  r¯  r•   rI   )r5  r´  r•   r\   )r5  r»  r•   r?   )r5  r¿  r•   r*   )r5  rÂ  r•   r.   )r5  rÆ  r•   rQ   )r5  rÈ  r•   r@   )r5  rÎ  r•   rP   )r5  rÐ  r•   r/   )r5  rß  r•   r6   )r5  rá  r•   r"   )r5  rä  r•   r`   )r5  ræ  r•   ra   )r5  rè  r•   r(   )r5  r†   r•   r&   )r5  rà  r•   r   )r5  rú  r•   r1   )r5  r   r•   r1   )r5  r…   r•   r  )r5  r  r•   r=   )r5  rŠ   r•   rS   )r5  r‰   r•   rE   )r5  r  r•   r  )r5  r!  r•   rY   )r5  r#  r•   rR   )r5  r(  r•   rY   )r5  rˆ   r•   rF   )r5  r/  r•   rB   )r5  r5  r•   rk   )r5  r7  r•   ri   )r5  r9  r•   rh   )r5  r>  r•   rj   )r5  r@  r•   rf   )r5  rC  r•   re   )r5  rL  r•   rd   )r5  rN  r•   rg   )r5  rP  r•   r  )r5  rP  r•   rU  )r0  Ú
__module__Ú__qualname__r  r   r&  r*  rÄ   r<  rC  rG  rN  r_  rp  r—   ÚAddÚSubÚMultÚMatMultÚDivÚModÚPowÚLShiftÚRShiftÚBitOrÚBitXorÚBitAndÚFloorDivrz  Ú__annotations__r  ÚGtÚLtÚEqÚGtEÚLtEÚNotEqÚIsÚIsNotÚInÚNotInr‡  r‰  r`  r‘  r“  r^  r”  r•  rš  r©  r´  r»  rÁ  rÅ  r¿  rê  rÝ  r  r  r(  r0  rè  rE  rJ  rP  rT  rW  r^  rb  re  rg  rp  rr  rw  r†  r‰  r‹  r  r’  r–  r™  rœ  r   r£  r¥  r¦  r­  rã   r³  rº  r¾  rÁ  rÅ  rÇ  rÌ  rÏ  rÞ  rÊ  rã  rå  rç  rî  rô  rù  rÿ  r  r  r  r  r  r   r"  r'  r*  r-  r4  r6  r8  r=  r?  rB  rK  rM  rO  rT  rW  r™   r™   r™   rš   rÃ   l  s
  
 úNóöÿ ÿ+ ÿ 	ÿ2ú !#

	
		
rÃ   c                   @  s"  e Zd Z			dbdcdd„Zdddd„Zdedfdd„Zedgdd„ƒZedhdd„ƒZdhd d„Zdid!d"„Zdjd%d&„Z	dkd(d)„Z
dld-d.„Zdmd2d3„Zdnd5d6„Zdod8d9„Zdpd;d<„Zdqd>d?„ZdrdAdB„ZdsdDdE„ZdtdHdI„ZdudKdL„ZdvdNdO„ZdwdQdR„ZdxdTdU„ZdydWdX„ZdzdZd[„Zd{d]d^„Zd|d`da„ZdS )}rõ   r£   Tr©   rê   rè   r”   rï   rð   r
  r•   r  c                 C  s"   || _ || _|| _g | _|| _d S r  )r©   rè   rï   Ú
node_stackrð   )r  r©   rè   rï   rð   r™   r™   rš   r  3  s
   
zTypeConverter.__init__ré   c                 C  s   | j dk r|S | j S )z¿Apply 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é   r™   r™   rš   Úconvert_column@  s   
zTypeConverter.convert_columnNr  r„   r   r¨   rw   c                 C  s   t dd| jt|ddƒ|dS )aÊ  Constructs a type representing some expression that normally forms an invalid type.
        For example, if we see a type hint that says "3 + 4", we would transform that
        expression into a RawExpressionType.

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

        See RawExpressionType's docstring for more details on how it's used.
        Nz
typing.Anyr9  r£   )rè   ré   r   )rw   rè   r1  )r  r  r   r™   r™   rš   Úinvalid_typeK  s   
ÿzTypeConverter.invalid_typer	  rv   c                 C  ó   d S r  r™   r)  r™   r™   rš   rÄ   Y  ó   zTypeConverter.visitr+  ro  c                 C  rv  r  r™   r)  r™   r™   rš   rÄ   \  rw  c                 C  s‚   |du rdS | j  |¡ z.d|jj }t| |dƒ}|dur0||ƒ}t|tƒs(J ‚|W | j  ¡  S |  |¡W | j  ¡  S | j  ¡  w )z2Modified visit -- keep track of the stack of nodesNr,  )	rs  r@  r/  r0  r1  rÐ   rv   r™  ru  )r  r  r4  r3  r÷   r™   r™   rš   rÄ   _  s   
þc                 C  s   t | jƒdk r	dS | jd S )z3Return the AST node above the one we are processingrí   NrV  )ra  rs  rª  r™   r™   rš   Úparentp  s   
zTypeConverter.parentrÉ   r   c                 C  s(   | j r| j j|||jd|jd d S d S )NTrµ   )r©   rÌ   ró   r·   r#  r™   r™   rš   r&  v  s   ÿzTypeConverter.failr‘   c                 C  s&   | j r| j j|||dtjd d S d S r  r"  r#  r™   r™   rš   r   z  s   ÿzTypeConverter.noter=  úSequence[ast3.expr]ú
list[Type]c                   s   ‡ fdd„|D ƒS )Nc                   r4  r™   r5  r  rª  r™   rš   rÞ     r8  z5TypeConverter.translate_expr_list.<locals>.<listcomp>r™   rF  r™   rª  rš   rG  ~  s   z!TypeConverter.translate_expr_listrÔ   r†   ry   c                 C  sŠ  |j }t|ƒ}t|  ¡ tjƒsd }|rd |¡}| j||dS |s+|  t	j
|j|j¡ d }ttjƒ}|}t|jƒD ]*\}}	|dkrO|  |	¡}
|
d usLJ ‚|
}q9|dkrY|  |	¡}q9|  t	j|j|j¡ q9|jD ]S}|j}|jdkrˆ|d ur‚|  t	j |¡|j|j¡ |  |¡}qg|jdkr¬||urž|  t	j |¡|j|j¡ |  |¡}
|
d us©J ‚|
}qg|  t	j |j¡|j|j¡ qgt||||j|jƒS )Nz,Suggestion: use {0}[...] instead of {0}(...)©r   r   r‚   r–  r-  )rò  Ústringify_namerÐ   rx  r—   r   rò   ru  r&  r   ÚARG_CONSTRUCTOR_NAME_EXPECTEDrÈ   r9  rq   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_ARGrr   )r  rÔ   ÚfÚconstructorr   r–  Údefault_typer÷   r  rÍ  rü   rð  ró   r™   r™   rš   rô    s\   





ý

ý
ýzTypeConverter.visit_Callr{   c                   s   t ‡ fdd„|D ƒˆ jdS )Nc                   r4  r™   r5  r  rª  r™   rš   rÞ   ·  r8  z9TypeConverter.translate_argument_list.<locals>.<listcomp>r×  )r{   rè   rF  r™   rª  rš   Útranslate_argument_list¶  r$  z%TypeConverter.translate_argument_listr5  c                 C  sZ   t |tƒrt |jtƒr|j ¡ S t |tƒr|jd u rd S |  tj t	|ƒj
¡| jd¡ d S rJ  )rÐ   rà  ró   r‘   rÜ   r&  r   Ú ARG_NAME_EXPECTED_STRING_LITERALrò   r-  r0  rè   rÀ  r™   r™   rš   r~  ¹  s   
ýz$TypeConverter._extract_argument_namer‰   c                 C  s   t |j| j|  |j¡dS )N©rè   ré   )r}   r  rè   rt  r9  rÀ  r™   r™   rš   r  Å  r  zTypeConverter.visit_Namer¯  c                 C  sR   t |jtjƒs|  |¡S |  |j¡}|  |j¡}t||g| j	|  
|j¡| jddS )NT)rè   ré   rð   Úuses_pep604_syntax)rÐ   r{  r—   rd  ru  rÄ   r°  r±  r~   rè   rt  r9  rð   )r  r5  r°  r±  r™   r™   rš   r³  È  s   

ûzTypeConverter.visit_BinOprà  c                 C  s²   |j }|d u rtd| jdS t|tƒrt|d| j|jƒS |tu r&t| jdS t|t	ƒr3t
|d| jdS t|tttfƒrA|  ||¡S t|tƒrTt|ƒ}t
|d| j|jdS |  |¡S )Nr  r×  zbuiltins.strzbuiltins.boolzbuiltins.bytes)ré   )ró   r}   rè   rÐ   r‘   r  r9  rá  rt   r
  rw   r”   rö  r÷  Únumeric_typerõ  r€   ru  )r  r5  rø  Úcontentsr™   r™   rš   rù  Ö  s   



zTypeConverter.visit_ConstantrŒ   c                 C  s\   |   |j¡}t|tƒr)t|jƒtu r)t|jtƒr!| jd9  _|S t|jt	ƒr)|S |  
|¡S )Nr£   )rÄ   r¹  rÐ   rw   r-  Úliteral_valuer”   r{  r   r‹   ru  )r  r5  r÷   r™   r™   rš   rº  í  s   ÿ
zTypeConverter.visit_UnaryOpró   Úobjectc                 C  sB   t |tƒr
|}d}n
d }dt|ƒj› }t||| jt|ddƒdS )Nzbuiltins.intz	builtins.r9  r£   rˆ  )rÐ   r”   r-  r0  rw   rè   r1  )r  ró   r5  Únumeric_valueÚ	type_namer™   r™   rš   rŠ  ý  s   
ÿzTypeConverter.numeric_typeú
ast3.Indexc                 C  r+  r  )rÄ   r   r   ró   rÐ   ry   r,  r™   r™   rš   r-    r.  zTypeConverter.visit_Indexr#  c                 C  rÄ  )Nz(did you mean to use ',' instead of ':' ?r{  )ru  rÀ  r™   r™   rš   r'    rÆ  zTypeConverter.visit_Slicer  c                 C  sj  t jdkr	|j}not|jtjƒr|jj}nct|jtjƒr0t 	|j¡}t
|dd ƒd u r/|jj|_nHt|jtjƒs9J ‚tttj t 	|jj¡ƒ}|D ](}t
|dd ƒd u rpt|tjƒr^|jj|_qHt|tjƒrp|jd uskJ ‚|jj|_qHt ||j¡}d}t|tjƒr|  |j¡}t|jƒdkrd}n|  |¡g}|  |j¡}t|tƒr°|js°t|j|| j|j|dS |  |¡S )Nr²   r9  Fr   T)rè   ré   Úempty_tuple_index)rÆ   rÇ   r  rÐ   r—   rˆ   ró   r  ÚcopyÚdeepcopyr1  r$  r9  r  r   r   r  r)  r=  r  rG  r>  ra  rÄ   r}   rÞ  r–  rè   ré   ru  )r  r5  Úslicevalr)  rl  r‘  Úparamsró   r™   r™   rš   r    sJ   


€
€€û
zTypeConverter.visit_Subscriptr!  c                 C  s$   t |  |j¡td| j|  |j¡dS )NT)Úimplicitrè   ré   )rx   rG  r>  r¤   rè   rt  r9  rÀ  r™   r™   rš   r"  G  s   

ûzTypeConverter.visit_TuplerÂ  c                 C  s¤   |j s|  |¡S i }g }t|j |jƒD ],\}}t|tjƒr#t|jtƒs7|d u r0| 	|  
|¡¡ q|  |¡  S |  
|¡||j< qt|tƒ tƒ t|j|jƒ}||_|S r  )rÄ  ru  ré  rA  rÐ   r—   rà  ró   r‘   r@  rÄ   rz   Úsetr¤   rÈ   r9  Úextra_items_from)r  r5  r˜  r˜  Ú	item_nameró   Úresultr™   r™   rš   rÅ  P  s   
zTypeConverter.visit_Dictr…   c                 C  sB   |   |j¡}t|tƒr|jst|j› d|j› | jdS |  |¡S )Nr´   r×  )	rÄ   ró   rÐ   r}   rÞ  r–  r  rè   ru  )r  r5  Ú
before_dotr™   r™   rš   r  a  s   
zTypeConverter.visit_Attributeúast3.Starredc                 C  s   t |  |j¡ddS )NT)Úfrom_star_syntax)r   rÄ   ró   rÀ  r™   r™   rš   r  j  rH  zTypeConverter.visit_Starredr  c                 C  s"   t |jtjƒs	J ‚|  |j¡}|S r  )rÐ   r  r—   ÚLoadr†  r>  )r  r5  rš  r™   r™   rš   r   n  s   zTypeConverter.visit_List)r£   r£   T)
r©   rê   rè   r”   rï   r”   rð   r
  r•   r  )ré   r”   r•   r”   r  )r  r„   r   r¨   r•   rw   )r  r	  r•   rv   )r  r+  r•   ro  )r•   r+  )rÉ   r   rè   r”   ré   r”   r•   r  rX  )r=  ry  r•   rz  )rÔ   r†   r•   ry   )r=  ry  r•   r{   )r5  r	  r•   r¨   )r5  r‰   r•   ry   )r5  r¯  r•   ry   )r5  rà  r•   ry   )r5  rŒ   r•   ry   )ró   r  r5  r„   r•   ry   )r5  r  r•   ry   )r5  r#  r•   ry   )r5  r  r•   ry   )r5  r!  r•   ry   )r5  rÂ  r•   ry   )r5  r…   r•   ry   )r5  rœ  r•   ry   )r5  r  r•   ry   )r0  rY  rZ  r  rt  ru  r   rÄ   rx  r&  r   rG  rô  r†  r~  r  r³  rù  rº  rŠ  r-  r'  r  r"  rÅ  r  r  r   r™   r™   r™   rš   rõ   2  s@    û







5









-
	

	rõ   r5  c                 C  s@   t | tƒr| jS t | tƒrt| jƒ}|d ur|› d| j› S d S )Nr´   )rÐ   r‰   r  r…   r|  ró   r  )r5  Úsvr™   r™   rš   r|  t  s   


r|  c                   @  s`   e Zd ZdZddd„Zddd	„Zd dd„Zd!dd„Zd"dd„Zd#dd„Z	d$dd„Z
d%dd„ZdS )&rc  zACheck if an AST contains attribute assignments (e.g. self.x = 0).r•   r  c                 C  s   d| _ d| _d S ©NF©Úlvaluere  rª  r™   r™   rš   r    s   
zFindAttributeAssign.__init__rl  r!   c                 C  s&   d| _ |jD ]}| | ¡ qd| _ d S ©NTF)r¢  rN  rd  ©r  rl  Úlvr™   r™   rš   Úvisit_assignment_stmt…  s   

z)FindAttributeAssign.visit_assignment_stmtr_   c                 C  s:   d| _ |jD ]}|d ur| | ¡ qd| _ |j | ¡ d S r£  )r¢  rS  rd  rö   r¤  r™   r™   rš   Úvisit_with_stmt‹  s   

€z#FindAttributeAssign.visit_with_stmtr4   c                 C  s>   d| _ |j | ¡ d| _ |j | ¡ |jr|j | ¡ d S d S r£  )r¢  r  rd  rö   r®  ©r  rl  r™   r™   rš   Úvisit_for_stmt“  s   ÿz"FindAttributeAssign.visit_for_stmtr2   c                 C  rv  r  r™   r¨  r™   r™   rš   Úvisit_expression_stmt›  ó   z)FindAttributeAssign.visit_expression_stmtrÔ   r&   c                 C  rv  r  r™   ©r  rÔ   r™   r™   rš   Úvisit_call_exprŸ  r«  z#FindAttributeAssign.visit_call_exprr=   c                 C  rv  r  r™   r¬  r™   r™   rš   Úvisit_index_expr£  r«  z$FindAttributeAssign.visit_index_exprrC   c                 C  s   | j rd| _d S d S r`  r¡  r¬  r™   r™   rš   Úvisit_member_expr§  s   
ÿz%FindAttributeAssign.visit_member_exprN©r•   r  )rl  r!   r•   r  )rl  r_   r•   r  )rl  r4   r•   r  )rl  r2   r•   r  )rÔ   r&   r•   r  )rÔ   r=   r•   r  )rÔ   rC   r•   r  )r0  rY  rZ  Ú__doc__r  r¦  r§  r©  rª  r­  r®  r¯  r™   r™   r™   rš   rc  ~  s    






rc  c                   @  s.   e Zd ZdZddd„Zddd	„Zddd„ZdS )rf  z/Check if an AST contains yields or yield froms.r•   r  c                 C  ó
   d| _ d S r   ©re  rª  r™   r™   rš   r  ¯  rÂ  zFindYield.__init__rÔ   r`   c                 C  r²  r`  r³  r¬  r™   r™   rš   Úvisit_yield_expr²  rÂ  zFindYield.visit_yield_exprra   c                 C  r²  r`  r³  r¬  r™   r™   rš   Úvisit_yield_from_exprµ  rÂ  zFindYield.visit_yield_from_exprNr°  )rÔ   r`   r•   r  )rÔ   ra   r•   r  )r0  rY  rZ  r±  r  r´  rµ  r™   r™   r™   rš   rf  ¬  s
    

rf  rl  rT  c                 C  s†   t | ƒ}|dkr
dS d}t| d tƒrt| d jtƒr|d7 }||kr%dS ||d kr-dS | | }t|ttfƒpBt|tƒoBt|jtƒS )zÈCould 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)ra  rÐ   r2   r  rU   rL   rM   r0   )rl  r=  r  rk  r™   r™   rš   rb  ¹  s   ÿrb  )
rŽ   r   r   r‘   r’   r‘   r“   r”   r•   r„   r  )rŽ   r   r¦   r‘   r§   r¨   r©   r   rª   r«   r•   rD   )rØ   r¨   r•   rÙ   )
rç   r‘   rè   r”   ré   r”   r©   rê   r•   rë   )
rþ   r‘   rÿ   r‘   rè   r”   ré   r”   r•   rv   )r  r	  r•   r
  )r  r  r•   r  )r5  r„   r•   r¨   )rl  rT  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.   r/   r0   r1   r2   r3   r4   r5   r6   r7   r8   r9   r:   r;   r<   r=   r>   r?   r@   rA   rB   rC   rD   rE   rF   rG   rH   rI   rJ   rK   rL   rM   rN   rO   rP   rQ   rR   rS   rT   rU   rV   rW   rX   rY   rZ   r[   r\   r]   r^   r_   r`   ra   rb   Úmypy.optionsrc   Úmypy.patternsrd   re   rf   rg   rh   ri   rj   rk   Úmypy.reachabilityrl   rm   Úmypy.sharedparsern   ro   Úmypy.traverserrp   Ú
mypy.typesrq   rr   rs   rt   ru   rv   rw   rx   ry   rz   r{   r|   r}   r~   r   Ú	mypy.utilr€   r   rÇ   rƒ   rh  rÒ   r—   r„   r…   r†   r‡   rˆ   r‰   rŠ   r‹   rŒ   r   r›   r  rà  r/  r5  r7  r9  r>  r@  rC  rL  rN  r  rk  r0  ÚExceptHandlerr6  r‡  Ú	TypeAliasrP  Ú	ParamSpecr;  r*  ÚTypeVarTupler<  r¡   r¤   Úcompiler¥   r˜   ræ   rý   r  r  r  rÃ   rõ   r|  rc  rf  rb  r™   r™   r™   rš   Ú<module>   s°    ,þJ R(
D0ÿû
C

&

		           Q  
D
.