o
    2g                     @  s  d Z ddlmZ ddlZddlmZmZ ddlm	Z	m
Z
mZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z( ddl)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;m<Z< ddl=m>Z>m?Z?m@Z@mAZAmBZBmCZCmDZDmEZE ddlFmGZGmHZH dd	lImJZJmKZKmLZL dd
lMmNZN ddlOmPZP ddlQmRZRmSZSmTZT ddlUmVZVmWZWmXZXmYZYmZZZ ddl[m\Z\m]Z]m^Z^m_Z_m`Z`maZambZbmcZc ddldmeZemfZfmgZg ddlhmiZimjZjmkZkmlZlmmZmmnZnmoZompZpmqZq ddlrmsZs eg df Zteg e<f ZudddZvdddZwdd d!Zxdd#d$Zydd(d)Zzdd+d,Z{dd2d3Z|dd6d7Z}dd9d:Z~dd<d=Zdd?d@ZddCdDZddFdGZddIdJZddLdMZddOdPZddYdZZdd]d^ZddedfZddjdkZddodpZddtduZddvdwZddxdyZdd{d|ZdddZdddZdddZdddZdddZdddZdddZdddZdddZdddZdddZdddZdddZdS )a  Transform mypy statement ASTs to mypyc IR (Intermediate Representation).

The top-level AST transformation logic is implemented in mypyc.irbuild.visitor
and mypyc.irbuild.builder.

A few statements are transformed in mypyc.irbuild.function (yield, for example).
    )annotationsN)CallableSequence) 	ARG_NAMEDARG_POS
AssertStmtAssignmentStmt	AwaitExprBlock	BreakStmtContinueStmtDelStmt
ExpressionExpressionStmtForStmtIfStmtImport	ImportAll
ImportFromListExprLvalue	MatchStmtOperatorAssignmentStmt	RaiseStmt
ReturnStmtStarExprStrExprTempNodeTryStmt	TupleExprTypeAliasStmt	WhileStmtWithStmt	YieldExprYieldFromExpr)NAMESPACE_MODULENO_TRACEBACK_LINE_NOAssign
BasicBlockBranch
InitStaticIntegerLoadAddressLoadErrorValueLoadLiteral
LoadStatic
MethodCallRaiseStandardErrorRegisterReturnTupleGetUnborrowUnreachableValue)	RInstanceRTuplec_pyssize_t_rprimitive
exc_rtuple	is_taggednone_rprimitiveobject_pointer_rprimitiveobject_rprimitive)is_borrow_friendly_exprprocess_conditional)	IRBuildercreate_type_paramsint_borrow_friendly_op)for_loop_helper)-add_raise_exception_blocks_to_generator_class)ExceptNonlocalControlFinallyNonlocalControlTryFinallyNonlocalControl)AssignmentTargetAssignmentTargetAttrAssignmentTargetIndexAssignmentTargetRegisterAssignmentTargetTuple)error_catch_opexc_matches_opget_exc_info_opget_exc_value_opkeep_propagating_opraise_exception_opreraise_exception_oprestore_exc_info_op)iter_opnext_raw_oppy_delattr_op)	check_stop_opcoro_opimport_from_many_opimport_many_op	import_opsend_op"set_type_alias_compute_function_optype_opyield_from_except_op   )MatchVisitorbuilderrB   blockr
   returnNonec                 C  st   |j s"| jd |jD ]}| | | jd s nq| j  d S |jr8| ttjd|j	 | t
  d S d S )NTz#Reached allegedly unreachable code!)is_unreachableblock_reachable_stackappendbodyacceptpopaddr1   RUNTIME_ERRORliner6   )re   rf   stmt rt   O/home/garg/my-data/venv/lib/python3.10/site-packages/mypyc/irbuild/statement.pytransform_block|   s    



rv   rs   r   c                 C  s*   t |jtrd S |j| j |   d S N)
isinstanceexprr   rn   visitorflush_keep_alives)re   rs   rt   rt   ru   transform_expression_stmt   s   r|   r   c                 C  sN   |j r
| |j }n| j }| || jd |j}| jd | ||j d S Nri   )	ry   rn   re   nonecoerce	ret_typesrr   nonlocal_control
gen_return)re   rs   retvalrt   rt   ru   transform_return_stmt   s
   
r   r   c                 C  s^  |j }|sJ | ||j |d }|jr$t|jtr$| ||j d S t|tt	frt|jtt	frt
|jt
|jjkrtdd |jD rt
|dkrg }|jjD ]}| |}t|j}| |||j || qTt|j|D ]\}}| |}	| |	||j qt|   d S |jj}
| |j}|  r|jr| || t|tt	frt|jtrt
|jjt
|jkrt
|dkrtdd |jD rtdd |jjD rt
|j}t|D ]"}| |j| }| t||dd}| t|}| |||
 q| jj|gdd	 |   d S |D ]}| |}| |||
 |   qd S )
Nr   c                 s      | ]}t |V  qd S rw   is_simple_lvalue.0itemrt   rt   ru   	<genexpr>       z,transform_assignment_stmt.<locals>.<genexpr>rc   c                 s  r   rw   r   r   rt   rt   ru   r      r   c                 s  s    | ]}|j V  qd S rw   )is_refcounted)r   trt   rt   ru   r      s    T)borrow)steal)lvaluesdisallow_class_assignmentsrr   typerx   rvaluer   get_assignment_targetr   r   lenitemsallrn   r2   assignrl   zipr{   non_function_scopeis_final_definit_final_staticr9   typesanyrangerp   r4   r5   re   
keep_alive)re   rs   r   first_lvaluetempsright
rvalue_regtempleftassignment_targetrr   nitargetrvalue_itemlvaluert   rt   ru   transform_assignment_stmt   sl   





r   ry   r   boolc                 C  s   t | tttf S rw   )rx   r   r   r   )ry   rt   rt   ru   r      s   r   r   c                 C  s   |  |jg|j t| |jr+t| |jr+|jtv r+t| |jo)t| |j}nd}| 	|j}| j
||j|d}| j|j|d}|jd }| ||||j}| |||j |   dS )z,Operator assignment statement such as x += 1F)
can_borrow=N)r   r   rr   r<   	node_typer   oprD   r@   r   readrn   	binary_opr   r{   )re   rs   r   r   target_valuerregr   resrt   rt   ru   "transform_operator_assignment_stmt   s"   

r   	module_idstras_name
str | Nonetuple[str, str]c                 C  s.   |r
| }|}||fS |  dd  }}||fS )a  Compute names for updating the globals dict with the appropriate module.

    * For 'import foo.bar as baz' we add 'foo.bar' with the name 'baz'
    * For 'import foo.bar' we add 'foo' with the name 'foo'

    Typically we then ignore these entries and access things directly
    via the module static, but we will use the globals version for
    modules that mypy couldn't find, since it doesn't analyze module
    references from those properly..r   )split)r   r   
globals_idglobals_namert   rt   ru   import_globals_id_and_name   s   
r   noder   c              
   C  sd  |j rd S |js9|  }|jD ]'\}}| ||j t||\}}| j|d| || 	||jgd |jd qd S || j
vr@d S g }g }g }	| j
| D ]6}
|
jD ]0\}}d | j|< ||gt||R  tt|td}|| tt| |	t|
jt qPqK| jt|}| jt|	}| t| tt|t||  | | j| | jj|gt d S )N__setitem__result_typerr   	namespace)is_mypy_onlyis_top_levelload_globals_dictids
gen_importrr   r   gen_method_callload_str
get_modulemodule_import_groupsimportsrl   r/   r?   r%   rp   r,   r>   r+   r:   re   setup_rarraycall_cr]   r.   tuplemodule_pathfn_infonamer&   )re   r   globalsmod_idr   r   r   modulesstatic_ptrs	mod_linesimport_node
mod_staticstatic_array_ptrimport_line_ptrrt   rt   ru   transform_import  sR   


r   r   c           
      C  s   |j rd S | j| j }|jd ur|jr|jd }n| jdr#| j}nd}tjd|j	 |j
 |}d | j|< dd |jD }dd |jD }| tt|t}||krX|}n
| tt|t}| t| ||||  g|j}	| t|	|td d S )	Nr   z__init__.py r   c                 S  s   g | ]\}}|qS rt   rt   )r   r   _rt   rt   ru   
<listcomp>h  s    z)transform_import_from.<locals>.<listcomp>c                 S  s   g | ]\}}|p	|qS rt   rt   )r   r   r   rt   rt   ru   r   i      r   )r   graphmodule_name	ancestorsr   endswith	importlibutilresolve_namerelativeidr   namesrp   r.   r   r?   r   r\   r   r   rr   r*   r%   )
re   r   module_statemodule_packager   r   as_namesnames_literalas_names_literalmodulert   rt   ru   transform_import_fromY  s,   
r   r   c                 C  s   |j rd S | |j|j d S rw   )r   r   r   rr   re   r   rt   rt   ru   transform_import_all{  s   r   r   c                 C  s   t  t  }}|jrt  n|}t|jdksJ t| |jd || | | | |jd  | | |jrG| | | |j | | | | d S )Nrc   r   )	r(   	else_bodyr   ry   rA   activate_blockrn   rm   goto)re   rs   if_bodynextr   rt   rt   ru   transform_if_stmt  s   



r   sr!   c                 C  s   t  t  t  t  f\}}}}|jd ur|n|}| || | | t| |j|| | | | |j | 	| | 
  |jd urS| | | |j | 	| | | d S rw   )r(   r   push_loop_stackgoto_and_activaterA   ry   r   rn   rm   r   pop_loop_stack)re   r  rm   r   top
else_blocknormal_loop_exitrt   rt   ru   transform_while_stmt  s   





r  r   c                   sJ   d fdd}d fdd}t  jj|jr|nd jj d S )Nrg   rh   c                          j d S rw   rn   rm   rt   re   r  rt   ru   rm        z transform_for_stmt.<locals>.bodyc                     s   j d usJ  j  d S rw   )r   rn   rt   r  rt   ru   r    s   z&transform_for_stmt.<locals>.else_blockrg   rh   )rE   indexry   r   is_asyncrr   )re   r  rm   r  rt   r  ru   transform_for_stmt  s
    r  r   c                 C     | j d | |j d S r}   )r   	gen_breakrr   r   rt   rt   ru   transform_break_stmt     r  r   c                 C  r  r}   )r   gen_continuerr   r   rt   rt   ru   transform_continue_stmt  r  r  r   c                 C  sV   |j d u r| tg t | t  d S | |j }| t|g|j | t  d S rw   )	ry   r   rU   r&   rp   r6   rn   rT   rr   )re   r  excrt   rt   ru   transform_raise_stmt  s   
r  rm   GenFunchandlersLSequence[tuple[tuple[ValueGenFunc, int] | None, Expression | None, GenFunc]]r   GenFunc | Nonerr   intc              	   C  s  |sJ dt  t  t  }}}t  }|rt  n|}	| j| | t   |  | |	 | j  | j| | | | | t	g |}
| j
t| j
d |
 |D ]Q\}}}d}|r|\}}t  t  }}| t| g|}| t|||tj | | |r| |}| || tg |j|j |  | | |r| | qW|r| tg t | t  | j
  | j  | | | t| |
g| | | | | | t| |
g| | tg t | t  |r| |	 |  | | | | dS )zGeneralized try/except/else handling that takes functions to gen the bodies.

    The point of this is to also be able to support with.ztry needs exceptri   N)r(   re   push_error_handlerr  r   pop_error_handlerr   maybe_spillr   rO   r   rl   rG   rP   rp   r)   BOOLr   r   rR   rr   rU   r&   r6   ro   rV   r   rS   )re   rm   r  r   rr   except_entry
exit_blockcleanup_blockdouble_except_blockr  old_excr   varhandler_body
next_blocktype_f	type_line
body_blockmatchesr   rt   rt   ru   transform_try_except  s\   














r.  r   r   c                   s|   d fdd}d fdd	d fddfddt jjjD }jr1 fddnd }t |||j d S )Nrg   rh   c                     r	  rw   r
  rt   re   r   rt   ru   rm   "  r  z'transform_try_except_stmt.<locals>.bodyrm   r
   r  c                   s    fddS )Nc                     
     S rw   rn   rt   rm   re   rt   ru   <lambda>'     
 zAtransform_try_except_stmt.<locals>.make_handler.<locals>.<lambda>rt   rm   re   r5  ru   make_handler&  s   z/transform_try_except_stmt.<locals>.make_handlerr   r   tuple[ValueGenFunc, int]c                   s    fdd j fS )Nc                     s
     S rw   r1  rt   )re   r   rt   ru   r3  *  r4  z?transform_try_except_stmt.<locals>.make_entry.<locals>.<lambda>)rr   r   r6  r9  ru   
make_entry)     z-transform_try_except_stmt.<locals>.make_entryc                   s,   g | ]\}}}|r |nd ||fqS rw   rt   )r   r   r'  rm   )r:  r7  rt   ru   r   ,  s    z-transform_try_except_stmt.<locals>.<listcomp>c                     s     jS rw   )rn   r   rt   r/  rt   ru   r3  0      z+transform_try_except_stmt.<locals>.<lambda>r  )rm   r
   rg   r  )r   r   rg   r8  )r   r   varsr  r   r.  rr   )re   r   rm   r  r   rt   )re   r:  r7  r   ru   transform_try_except_stmt!  s   r>  err_handlerr(   return_entry
main_entrytry_body"Register | AssignmentTarget | Nonec                 C  sV   t |}| j| | j| | t  |  | | | j  | j	  |j
S rw   )rI   re   r  r   rl   r  r(   r   ro   r  ret_reg)re   r?  r@  rA  rB  controlrt   rt   ru   try_finally_try4  s   


rF  finally_blockrD  r7   c              	   C  s   t t}| | |r| || t| jd d | | | | | t|| tt | | | | |rL| || t| jd d | t|| 	t
g d | | |S r}   )r2   r;   r   r   rp   r-   r   r   r'   r   rO   )re   r?  r@  rA  rG  rD  r&  rt   rt   ru   try_finally_entry_blocksI  s   





rH  finally_bodyr&  )tuple[BasicBlock, FinallyNonlocalControl]c                 C  sP   t  }| j| t| jd |}| j| | | |  | j  ||fS r}   )r(   re   r  rH   r   rl   r   ro   )re   rG  rI  r&  r$  finally_controlrt   rt   ru   try_finally_bodyg  s   

rL  r$  rK  rH   c           	      C  s   t  t  }}| t|||tj | | | tg t | t  | j	
  |rW| | t  t  }}| t| |||tj | | | jd | | |d | | t  }| | | | || d | tg t | t  |S )zResolve the control flow out of a finally block.

    This means returning if there was a return, propagating
    exceptions, break/continue (soon), or just continuing on.
    ri   )r(   rp   r)   IS_ERRORr   r   rU   r&   r6   re   r  r   r   r   r   gen_cleanuprS   )	re   r$  rK  r&  rD  reraiserestreturn_block	out_blockrt   rt   ru   try_finally_resolve_controlv  s(   






rS  c                 C  sn   t  t  t  t  f\}}}}t| ||||}t| |||||}t| |||\}	}
t| |	|
||}| | dS )zGeneralized try/finally handling that takes functions to gen the bodies.

    The point of this is to also be able to support with.N)r(   rF  rH  rL  rS  r   )re   rB  rI  r?  rA  r@  rG  rD  r&  r$  rK  rR  rt   rt   ru   transform_try_finally_stmt  s    

rT  c                   sX   j r
dj jr%dfdd}j t| fdd d S t d S )	Nz3Exception groups and except* cannot be compiled yetrg   rh   c                     s$   j r
t  d S  j d S rw   )r  r>  rn   rm   rt   r/  rt   ru   transform_try_body  s   z.transform_try_stmt.<locals>.transform_try_bodyc                     r0  rw   r1  rt   r2  rt   ru   r3    r4  z$transform_try_stmt.<locals>.<lambda>r  )is_starerrorrr   rI  rT  r>  )re   r   rU  rt   )rm   re   r   ru   transform_try_stmt  s   rX  list[Value]c                   s&     tg d fddtdD S )Nri   c                   s   g | ]}  t|d qS )ri   )rp   r4   )r   r   re   exc_infort   ru   r     s    z$get_sys_exc_info.<locals>.<listcomp>   )r   rQ   r   r6  rt   rZ  ru   get_sys_exc_info  s   r]  r   Lvalue | Noner  c              	     s6  rdnd  |tjtr%td  dg dd n'tg}	|d  d
	|d  dg
 r`td 
fdd	dfddd	fddd	fdd}tfdd| d S )Nar   __enter__)argsrr   exit__r[  r   rg   r7   c                   s   | rt }n	 }|||g}r,tjtsJ jd  d|td}nd us2J g| }rJt	|S |S )Nr`  rc  )
arg_valuesrr   r   )
r]  none_objectrx   r   r8   r   r   r=   py_call
emit_await)r[  rb  r~   exit_val)alre   exit_r  	is_nativerr   mgrmgr_vrt   ru   maybe_natively_call_exit  s$   


 z0transform_with.<locals>.maybe_natively_call_exitrh   c                     s"   r     d S rw   )r   r   rt   )rm   re   rr   r   valuert   ru   rB    s   
z transform_with.<locals>.try_bodyc                    sf        t t } } dd| |  |  tg t  t	   |  d S )NTr[  )
r   falser(   add_bool_branchr   r   rU   r&   rp   r6   )rR  reraise_block)re   r  rr   rn  rt   ru   except_body  s   
z#transform_with.<locals>.except_bodyc                    sL   t  t  } } t || tj  | dd  |  d S )NFrp  )r(   rp   r)   r   r!  r   r  )rR  r#  )re   r  rn  rt   ru   rI  (  s
   

z$transform_with.<locals>.finally_bodyc                     s   t  d d fgd S rw   )r.  rt   )re   rt  rr   rB  rt   ru   r3  2  r   z transform_with.<locals>.<lambda>)r[  r   rg   r7   r  )rn   rx   r   r8   rp   r0   r   ra   r   py_get_attrrf  maybe_spill_assignabletruerg  rT  )re   ry   r   rm   r  rr   typrI  rt   )ri  rm   re   r  rt  rj  r  rk  rr   rn  rl  rm  r   rB  ro  ru   transform_with  s,   
"
	ry  or"   c                   s   d fddd d S )	Nr   r  rg   rh   c                   sN    t jkrj d S tj  j   fddjj d S )Nc                     s    d S )Nrc   rt   rt   )generater   rt   ru   r3  >  r<  z7transform_with_stmt.<locals>.generate.<locals>.<lambda>)r   ry   rn   rm   ry  r   r  rr   r   re   r{  rz  r|  ru   r{  9  s
   &z%transform_with_stmt.<locals>.generater   )r   r  rg   rh   rt   re   rz  rt   r}  ru   transform_with_stmt7  s   r  r_  r   c                 C  s   | j jrd S | |j}t t }}| ||| | | |jd u r0| t	t	j
d |j n3t|jtrD| t	t	j
|jj|j n| |j}| d|j}| ||g|j}| t|g|j | t  | | d S )Nzbuiltins.AssertionError)optionsstrip_assertsrn   ry   r(   rr  r   msgrp   r1   ASSERTION_ERRORrr   rx   r   ro  load_module_attr_by_fullnamerf  r   rT   r6   )re   r_  condok_blockerror_blockmessageexc_typer  rt   rt   ru   transform_assert_stmtD  s    

r  r   c                 C  s   t | | |j|j d S rw   )transform_del_itemr   ry   rr   r~  rt   rt   ru   transform_del_stmt[     r  rJ   c              
   C  s   t |tr| j|jd|jgd |d d S t |trLt |jtr:|jj}|	|j
s:| d|j
 d| | d| | |j
}| t|j|g| d S t |trd| t|j| t|jdd d S t |tru|jD ]
}t| || qld S d S )N__delitem__r   "z" cannot be deletedzMUsing "__deletable__ = ['<attr>']" in the class body enables "del obj.<attr>"T)	undefines)rx   rL   r   baser  rK   obj_typer8   class_iris_deletableattrrW  noter   r   rY   objrM   rp   r'   registerr-   r   rN   r   r  )re   r   rr   clkey	subtargetrt   rt   ru   r  _  s0   





r  valc                 C  s   |  || jd |}| jj}t }t|j}|j| | |j	t
|| | t| | | t| | |jd us>J |jS r}   )r   r   r   generator_classr(   r   continuation_blocksrl   r   next_label_targetr+   rp   r3   r   rF   send_arg_reg)re   r  rr   r   clsr)  
next_labelrt   rt   ru   
emit_yield  s   


r  is_awaitc                  sV  t tt tt t|rtnt} ||g} |t t t }}} t g}	 	t
|	||t
j  |   tg   |  |  |	 t }
 |
 d	 fdd}d	 fdd}d	 fdd} |
| t |d d |fg|     |  S )
Nrg   rh   c                     s      t   d S rw   )r   r  r   rt   )re   rr   received_regto_yield_regrt   ru   rB    s    z*emit_yield_from_or_await.<locals>.try_bodyc                    s   t t}  tt| } t |g}t t }} t	|||t	j
  |  |   jd    |  |   jd   d S r}   )r2   r?   rp   r,   r>   r   rb   r   r(   r)   r!  r   r   r   r  r  )r  val_addressto_stopokstop)re   iter_regrr   resultr  rt   ru   rt    s   

z-emit_yield_from_or_await.<locals>.except_bodyc                    s     t  g} t t }} t| ||tj  |  |   j	d 
   |    tg   j	d   d S r}   )r   r_   r   r(   rp   r)   rM  r   r   r   r  rZ   r  )_yr  r  re   r  rr   r  r  r  rt   ru   r     s   

z+emit_yield_from_or_await.<locals>.else_bodyr  )r2   r?   r[   rW   r   rv  r(   rX   r   rp   r)   rM  r   r   rZ   r   r  r  r.  r  )re   r  rr   r  get_opiter_val
stop_block
main_block
done_block_y_init
loop_blockrB  rt  r   rt   r  ru   emit_yield_from_or_await  s0   






r  c                 C  s   t | ||ddS NTr  )r  )re   r  rr   rt   rt   ru   rg    r  rg  r#   c                 C  sB   | j jr| d|j |jr| |j}n| j }t| ||jS )Nz"async generators are unimplemented)	r   is_coroutinerW  rr   ry   rn   re   r~   r  )re   ry   r   rt   rt   ru   transform_yield_expr  s   
r  r$   c                 C     t | | |j|jddS )NFr  r  rn   ry   rr   r~  rt   rt   ru   transform_yield_from_expr  r  r  r	   c                 C  r  r  r  r~  rt   rt   ru   transform_await_expr  r  r  mr   c                 C  s   | t| | d S rw   )rn   rd   )re   r  rt   rt   ru   transform_match_stmt  r;  r  r    c                 C  s   |j }| t| dg|}t| ||j|j }| |d|}| |jj|  g}d d g}t	t	g}|jrG|
| || |
d |
t | j|||||d}	|j| j}
| jt|	|
g| | |j}| ||	| d S )N_typingTypeAliasTypetype_params)	arg_names	arg_kinds)rr   r   r^   r   rC   	type_argsru  r   r~   r   rl   	new_tupler   rf  ro  rn   rz   re   primitive_opr`   r   r   )re   r  rr   modr  type_alias_typerb  r  r  alias
compute_fnr   rt   rt   ru   transform_type_alias_stmt  s    

r  )re   rB   rf   r
   rg   rh   )re   rB   rs   r   rg   rh   )re   rB   rs   r   rg   rh   )re   rB   rs   r   rg   rh   )ry   r   rg   r   )re   rB   rs   r   rg   rh   )r   r   r   r   rg   r   )re   rB   r   r   rg   rh   )re   rB   r   r   rg   rh   )re   rB   r   r   rg   rh   )re   rB   rs   r   rg   rh   )re   rB   r  r!   rg   rh   )re   rB   r  r   rg   rh   )re   rB   r   r   rg   rh   )re   rB   r   r   rg   rh   )re   rB   r  r   rg   rh   )re   rB   rm   r  r  r  r   r  rr   r  rg   rh   )re   rB   r   r   rg   rh   )re   rB   r?  r(   r@  r(   rA  r(   rB  r  rg   rC  )re   rB   r?  r(   r@  r(   rA  r(   rG  r(   rD  rC  rg   r7   )
re   rB   rG  r(   rI  r  r&  r7   rg   rJ  )re   rB   r$  r(   rK  rH   r&  r7   rD  rC  rg   r(   )re   rB   rB  r  rI  r  rg   rh   )re   rB   rg   rY  )re   rB   ry   r   r   r^  rm   r  r  r   rr   r  rg   rh   )re   rB   rz  r"   rg   rh   )re   rB   r_  r   rg   rh   )re   rB   rz  r   rg   rh   )re   rB   r   rJ   rr   r  rg   rh   )re   rB   r  r7   rr   r  rg   r7   )
re   rB   r  r7   rr   r  r  r   rg   r7   )re   rB   ry   r#   rg   r7   )re   rB   rz  r$   rg   r7   )re   rB   rz  r	   rg   r7   )re   rB   r  r   rg   rh   )re   rB   r  r    rg   rh   )__doc__
__future__r   importlib.utilr   typingr   r   
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!   r"   r#   r$   mypyc.ir.opsr%   r&   r'   r(   r)   r*   r+   r,   r-   r.   r/   r0   r1   r2   r3   r4   r5   r6   r7   mypyc.ir.rtypesr8   r9   r:   r;   r<   r=   r>   r?   mypyc.irbuild.ast_helpersr@   rA   mypyc.irbuild.builderrB   rC   rD   mypyc.irbuild.for_helpersrE   mypyc.irbuild.generatorrF   mypyc.irbuild.nonlocalcontrolrG   rH   rI   mypyc.irbuild.targetsrJ   rK   rL   rM   rN   mypyc.primitives.exc_opsrO   rP   rQ   rR   rS   rT   rU   rV   mypyc.primitives.generic_opsrW   rX   rY   mypyc.primitives.misc_opsrZ   r[   r\   r]   r^   r_   r`   ra   rb   matchrd   r  ValueGenFuncrv   r|   r   r   r   r   r   r   r   r   r   r  r  r  r  r  r.  r>  rF  rH  rL  rS  rT  rX  r]  ry  r  r  r  r  r  r  rg  r  r  r  r  r  rt   rt   rt   ru   <module>   sr    T"(
(
,




	
?



F
"







U




,
%


T



!

R



