o
    ÕtBh^Ì  ã                   @  s6  U d Z ddlmZ ddlmZ ddlmZmZmZm	Z	m
Z
 ddlmZmZ ddlmZ ddlmZ ddlmZmZmZmZmZmZmZmZmZmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+ dd	l,m-Z-m.Z.m/Z/m0Z0m1Z1 dd
l2m3Z3 ddl4m5Z5m6Z6 ddl7m8Z8m9Z9 ddl:m;Z; ddl<m=Z= ddl>m?Z?m@Z@ ddlAmBZBmCZCmDZDmEZEmFZF ddlGmHZHmIZImJZJmKZKmLZLmMZMmNZNmOZOmPZPmQZQmRZRmSZSmTZTmUZUmVZV ddlWmXZXmYZYmZZZm[Z[m\Z\m]Z]m^Z^m_Z_m`Z`maZambZbmcZcmdZdmeZe ddlfmgZgmhZh ddlimjZj ddlkmlZl ddlmmnZnmoZompZpmqZq ddlrmsZs ddltmuZu ddlvmwZwmxZxmyZymzZzm{Z{ ddl|m}Z} ddl~mZ ddl€mZm‚Z‚ ddlƒm„Z„m…Z…m†Z† ddl‡mˆZˆm‰Z‰mŠZŠ ddl‹mŒZŒmZmŽZŽmZ dd lm‘Z‘m’Z’ h d!£Z“d"e”d#< G d$d%„ d%e5eV e6d& ƒZ•G d'd(„ d(e–ƒZ—e
ezexf Z˜G d)d*„ d*ƒZ™d4d.d/„Zšd5d2d3„Z›d&S )6aÿ  Builder class used to transform a mypy AST to the IR form.

The IRBuilder class maintains transformation state and provides access
to various helpers used to implement the transform.

The top-level transform control logic is in mypyc.irbuild.main.

mypyc.irbuild.visitor.IRBuilderVisitor is used to dispatch based on mypy
AST node type to code that actually does the bulk of the work. For
example, expressions are transformed in mypyc.irbuild.expression and
functions are transformed in mypyc.irbuild.function.
é    )Úannotations)Úcontextmanager)ÚAnyÚCallableÚIteratorÚSequenceÚUnion)ÚFinalÚoverload)ÚGraph)Úmap_instance_to_supertype)Ú	ARG_NAMEDÚARG_POSÚGDEFÚLDEFÚArgKindÚCallExprÚ	DecoratorÚ
ExpressionÚFuncDefÚ	IndexExprÚIntExprÚLvalueÚ
MemberExprÚMypyFileÚNameExprÚOpExprÚOverloadedFuncDefÚRefExprÚStarExprÚ	StatementÚ
SymbolNodeÚ	TupleExprÚTypeInfoÚ	UnaryExprÚVar)ÚInstanceÚ	TupleTypeÚTypeÚUninhabitedTypeÚget_proper_type)Úsplit_target)ÚExpressionVisitorÚStatementVisitor)Ú	SELF_NAMEÚTEMP_ATTR_NAME)Úcatch_errors)ÚErrors)ÚClassIRÚNonExtClassInfo)ÚINVALID_FUNC_DEFÚFuncDeclÚFuncIRÚFuncSignatureÚ
RuntimeArg)ÚNAMESPACE_MODULEÚAssignÚ
BasicBlockÚBranchÚGetAttrÚ
InitStaticÚIntegerÚ
LoadStaticÚOpÚRaiseStandardErrorÚRegisterÚSetAttrÚTupleGetÚUnreachableÚValue)Ú	RInstanceÚRTupleÚRTypeÚc_int_rprimitiveÚc_pyssize_t_rprimitiveÚdict_rprimitiveÚint_rprimitiveÚis_list_rprimitiveÚis_none_rprimitiveÚis_object_rprimitiveÚis_tuple_rprimitiveÚnone_rprimitiveÚobject_rprimitiveÚstr_rprimitive)ÚFuncInfoÚImplicitClass)ÚLowLevelIRBuilder)ÚMapper)ÚBaseNonlocalControlÚGeneratorNonlocalControlÚLoopNonlocalControlÚNonlocalControl)ÚPreBuildVisitor)ÚRegisterImplInfo)ÚAssignmentTargetÚAssignmentTargetAttrÚAssignmentTargetIndexÚAssignmentTargetRegisterÚAssignmentTargetTuple)Úis_constant)ÚCompilerOptions)Údict_get_item_opÚdict_set_item_op)Úiter_opÚnext_opÚpy_setattr_op)Úlist_get_item_unsafe_opÚlist_pop_lastÚto_list)Úcheck_unpack_count_opÚget_module_dict_opÚimport_extra_args_opÚ	import_op)ÚCFunctionDescriptionÚfunction_ops>   ú!=ú==ú>=ú+ú-ú<ú>ú<=r	   Úint_borrow_friendly_opc                   @  ó   e Zd ZdS )Ú	IRVisitorN©Ú__name__Ú
__module__Ú__qualname__© r„   r„   úl/var/www/html/riverr-enterprise-integrations-main/venv/lib/python3.10/site-packages/mypyc/irbuild/builder.pyr   }   ó    r   Nc                   @  r~   )ÚUnsupportedExceptionNr€   r„   r„   r„   r…   r‡      r†   r‡   c                   @  sº  e Zd Zdddd„Zdedd„Zeddœdfd"d#„ƒZedgd%d#„ƒZddœdhd(d#„Zdid)d*„Zdjd-d.„Zdkd1d2„Z	dld4d5„Z
dld6d7„Zdmd9d:„Zdnd?d@„ZdodBdC„ZdodDdE„ZdpdFdG„ZdqdJdK„ZdrdMdN„ZdsdtdSdT„ZdudUdV„ZdudWdX„ZdudYdZ„Zdud[d\„Zdvd_d`„Zdvdadb„Zdrdcdd„Z	e	edwdxdldm„Zdydpdq„Zdzdsdt„Z	e	edwd{dzd{„Zd|d|d}„Zd}dd‚„Z d~d†d‡„Z!ddˆd‰„Z"ddŠd‹„Z#d€ddŽ„Z$ddd‘„Z%d‚d•d–„Z&dƒd›dœ„Z'd„ddž„Z(d…d¡d¢„Z)d†d¤d¥„Z*d‡d¦d§„Z+dˆdªd«„Z,did¬d­„Z-did®d¯„Z.did°d±„Z/d‰d´dµ„Z0dŠd¶d·„Z1	ed‹ded¸œdŒd¿dÀ„Z2	ed‹ddÃdÄ„Z3dŽdÆdÇ„Z4dddÊdË„Z5	d‘d’dÍdÎ„Z6d“dÐdÑ„Z7d”dÔdÕ„Z8d•dØdÙ„Z9d–dÚdÛ„Z:d—dÞdß„Z;didàdá„Z<d˜dâdã„Z=d™dädå„Z>dšdædç„Z?d›dèdé„Z@dœdìdí„ZAddïdð„ZBdždòdó„ZCddôdõ„ZDddöd÷„ZEddø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!d"„ZRd«d$d%„ZSeT		ed¬d­d+d,„ƒZUeVfd®d1d2„ZWd¯d6d7„ZXdsd°d9d:„ZY	dsd±d<d=„ZZd²d?d@„Z[d³dAdB„Z\d´dDdE„Z]dµdFdG„Z^	dsd¶dKdL„Z_d¡dMdN„Z`d·dPdQ„Zad¸dRdS„ZbdudTdU„Zcd¹dVdW„Zdd¥dXdY„Zedºd[d\„Zfd»d^d_„Zgd»d`da„Zhd»dbdc„ZideS (¼  Ú	IRBuilderÚcurrent_moduleÚstrÚtypesúdict[Expression, Type]Úgraphr   Úerrorsr1   ÚmapperrY   Úpbvr^   Úvisitorr   Úoptionsrf   Úsingledispatch_implsú%dict[FuncDef, list[RegisterImplInfo]]ÚreturnÚNonec
           
      C  sê   t |||ƒ| _| jg| _i g| _g g| _g | _g | _|| _|| _|| _	|| _
g | _g | _g | _g | _tƒ | _|| _d| _d| _|j| _|j| _|j| _|j ¡ | _|j| _|	| _|| _ttddƒ| _ | j g| _!g | _"|| _#i | _$d| _%d S )Nr   Ú F)&rX   ÚbuilderÚbuildersÚ	symtablesÚruntime_argsÚfunction_name_stackÚclass_ir_stackr‰   r   r‹   r   Ú	ret_typesÚ	functionsÚclassesÚfinal_namesÚsetÚcallable_class_namesr’   Úlambda_counterÚtemp_counterÚfree_variablesÚprop_settersÚencapsulating_funcsÚnested_funcsÚkeysÚnested_fitemsÚfuncs_to_decoratorsÚfdefs_to_decoratorsr“   r‘   rV   r4   Úfn_infoÚfn_infosÚnonlocal_controlrŽ   ÚimportsÚ
can_borrow)
Úselfr‰   r‹   r   rŽ   r   r   r‘   r’   r“   r„   r„   r…   Ú__init__‰   s>   


zIRBuilder.__init__Úmodule_nameÚmodule_pathc                 C  s   || _ || _dS )zuSet the name and path of the current module.

        This must be called before transforming any AST nodes.
        N)rµ   r¶   )r³   rµ   r¶   r„   r„   r…   Ú
set_moduleÍ   s   
zIRBuilder.set_moduleF©r²   Únoder   r²   ÚboolrG   c                C  ó   d S ©Nr„   )r³   r¹   r²   r„   r„   r…   ÚacceptÕ   ó   zIRBuilder.acceptr    c                 C  r»   r¼   r„   )r³   r¹   r„   r„   r…   r½   Ù   r¾   úStatement | ExpressionúValue | Nonec             	   C  sÚ   |   |j¡] t|tƒrH| j}|| _z| | j¡}|  ||  |¡|j¡}W n t	y5   t
|  |¡ƒ}Y nw || _|s?|  ¡  |W  d  ƒ S z| | j¡ W n	 t	yY   Y nw 	 W d  ƒ dS 1 sfw   Y  dS )a  Transform an expression or a statement.

        If can_borrow is true, prefer to generate a borrowed reference.
        Borrowed references are faster since they don't require reference count
        manipulation, but they are only safe to use in specific contexts.
        N)r0   ÚlineÚ
isinstancer   r²   r½   r‘   ÚcoerceÚ	node_typer‡   rC   Úflush_keep_alives)r³   r¹   r²   Úold_can_borrowÚresr„   r„   r…   r½   Ý   s,   
ÿðÿ$êc                 C  ó   | j  ¡  d S r¼   )r˜   rÅ   ©r³   r„   r„   r…   rÅ   ü   ó   zIRBuilder.flush_keep_alivesÚoprA   c                 C  ó   | j  |¡S r¼   )r˜   Úadd)r³   rË   r„   r„   r…   rÍ     ó   zIRBuilder.addÚtargetr;   c                 C  ó   | j  |¡ d S r¼   )r˜   Úgoto)r³   rÏ   r„   r„   r…   rÑ     ó   zIRBuilder.gotoÚblockc                 C  rÐ   r¼   )r˜   Úactivate_block©r³   rÓ   r„   r„   r…   rÔ     rÒ   zIRBuilder.activate_blockc                 C  rÐ   r¼   )r˜   Úgoto_and_activaterÕ   r„   r„   r…   rÖ   
  rÒ   zIRBuilder.goto_and_activaterC   c                 C  ó
   | j  ¡ S r¼   )r˜   r³   rÉ   r„   r„   r…   r³     ó   
zIRBuilder.selfÚobjÚattrrÁ   Úintc                 C  ó   | j  |||¡S r¼   )r˜   Úpy_get_attr)r³   rÙ   rÚ   rÁ   r„   r„   r…   rÝ     rÒ   zIRBuilder.py_get_attrÚvaluec                 C  rÌ   r¼   )r˜   Úload_str©r³   rÞ   r„   r„   r…   rß     rÎ   zIRBuilder.load_strc                 C  s"   t |dƒ d¡ d¡}| j |¡S )zõLoad bytes object from a string literal.

        The literal characters of BytesExpr (the characters inside b'')
        are stored in BytesExpr.value, whose type is 'str' not 'bytes'.
        Thus we perform a special conversion here.
        Úutf8zunicode-escapezraw-unicode-escape)ÚbytesÚdecodeÚencoder˜   Ú
load_bytes)r³   rÞ   Úbytes_valuer„   r„   r…   Úload_bytes_from_str_literal  s   z%IRBuilder.load_bytes_from_str_literalc                 C  rÌ   r¼   )r˜   Úload_intrà   r„   r„   r…   rè      rÎ   zIRBuilder.load_intÚlregÚexpr_opc                 C  rÜ   r¼   )r˜   Úunary_op)r³   ré   rê   rÁ   r„   r„   r…   rë   #  rÒ   zIRBuilder.unary_opÚrregc                 C  ó   | j  ||||¡S r¼   )r˜   Ú	binary_op©r³   ré   rì   rê   rÁ   r„   r„   r…   rî   &  ó   zIRBuilder.binary_opÚsrcÚtarget_typerJ   Úforcec                 C  s   | j j||||| jdS )Nr¸   )r˜   rÃ   r²   )r³   rñ   rò   rÁ   ró   r„   r„   r…   rÃ   )  s   zIRBuilder.coercec                 C  r×   r¼   )r˜   Únone_objectrÉ   r„   r„   r…   rô   ,  rØ   zIRBuilder.none_objectc                 C  r×   r¼   )r˜   ÚnonerÉ   r„   r„   r…   rõ   /  rØ   zIRBuilder.nonec                 C  r×   r¼   )r˜   ÚtruerÉ   r„   r„   r…   rö   2  rØ   zIRBuilder.truec                 C  r×   r¼   )r˜   ÚfalserÉ   r„   r„   r…   r÷   5  rØ   zIRBuilder.falseÚvaluesúlist[Value]c                 C  ó   | j  ||¡S r¼   )r˜   Únew_list_op©r³   rø   rÁ   r„   r„   r…   rû   8  rÊ   zIRBuilder.new_list_opc                 C  rú   r¼   )r˜   Ú
new_set_oprü   r„   r„   r…   rý   ;  rÊ   zIRBuilder.new_set_opc                 C  rí   r¼   )r˜   Útranslate_is_oprï   r„   r„   r…   rþ   >  rð   zIRBuilder.translate_is_opNÚfunctionÚ
arg_valuesÚ	arg_kindsúlist[ArgKind] | NoneÚ	arg_namesúSequence[str | None] | Nonec                 C  ó   | j  |||||¡S r¼   )r˜   Úpy_call)r³   rÿ   r   rÁ   r  r  r„   r„   r…   r  A  s   zIRBuilder.py_callrö   r÷   c                 C  s   | j  |||¡ d S r¼   )r˜   Úadd_bool_branch)r³   rÞ   rö   r÷   r„   r„   r…   r  K  ó   zIRBuilder.add_bool_branchÚfullnamec                 C  rÌ   r¼   )r˜   Úload_native_type_object)r³   r	  r„   r„   r…   r
  N  rÎ   z!IRBuilder.load_native_type_objectÚbaseÚnameÚresult_typeúRType | Noneúlist[str | None] | Nonec              
   C  s   | j  |||||||| j¡S r¼   )r˜   Úgen_method_callr²   )r³   r  r  r   r  rÁ   r  r  r„   r„   r…   r  Q  s   
ÿzIRBuilder.gen_method_callc                 C  rÌ   r¼   )r˜   Úload_module)r³   r  r„   r„   r…   r  _  rÎ   zIRBuilder.load_moduleÚdescrs   Úargsc                 C  rÜ   r¼   )r˜   Úcall_c)r³   r  r  rÁ   r„   r„   r…   r  b  rÒ   zIRBuilder.call_cÚtypeÚlhsÚrhsc                 C  r  r¼   )r˜   Úint_op)r³   r  r  r  rË   rÁ   r„   r„   r…   r  e  r  zIRBuilder.int_opc                 C  rí   r¼   )r˜   Úcompare_tagged©r³   r  r  rË   rÁ   r„   r„   r…   r  h  rð   zIRBuilder.compare_taggedc                 C  rí   r¼   )r˜   Úcompare_tuplesr  r„   r„   r…   r  k  rð   zIRBuilder.compare_tuplesÚvalc                 C  rú   r¼   )r˜   Úbuiltin_len©r³   r  rÁ   r„   r„   r…   r  n  rÊ   zIRBuilder.builtin_lenÚitemsc                 C  rú   r¼   )r˜   Ú	new_tuple)r³   r  rÁ   r„   r„   r…   r   q  rÊ   zIRBuilder.new_tupleÚnon_extr3   Úkeyc                 C  s$   |   |¡}|  t|j||g|¡ d S r¼   )rß   r  rh   Údict)r³   r!  r"  r  rÁ   Úkey_unicoder„   r„   r…   Úadd_to_non_ext_dictv  s   
zIRBuilder.add_to_non_ext_dictÚidÚglobals_dictÚimportedú	list[str]c           	        sr   d ˆ j |< tdt|ƒ}ˆ  ‡ fdd„|D ƒ|¡}tdt|ƒ}ˆ  tˆ  |¡||||g|¡}ˆ  t	||t
d¡ |S )Nr   c                   s   g | ]}ˆ   |¡‘qS r„   )rß   )Ú.0r  rÉ   r„   r…   Ú
<listcomp>ƒ  s    z-IRBuilder.gen_import_from.<locals>.<listcomp>©Ú	namespace)r±   r?   rM   rû   rK   r  rq   rß   rÍ   r>   r9   )	r³   r&  r'  r(  rÁ   Ú	null_dictÚnames_to_importÚzero_intrÞ   r„   rÉ   r…   Úgen_import_from}  s   
ýzIRBuilder.gen_import_fromc                 C  sj   d | j |< tƒ tƒ }}|  ||||¡ |  |¡ |  t|  |¡g|¡}|  t||t	d¡ |  
|¡ d S )Nr,  )r±   r;   Úcheck_if_module_loadedrÔ   r  rr   rß   rÍ   r>   r9   rÖ   )r³   r&  rÁ   Úneeds_importÚoutrÞ   r„   r„   r…   Ú
gen_import  s   

zIRBuilder.gen_importr3  r4  c                 C  s0   |   |¡}|  ||  ¡ d|¡}|  |||¡ dS )an  Generate code that checks if the module `id` has been loaded yet.

        Arguments:
            id: name of module to check if imported
            line: line number that the import occurs on
            needs_import: the BasicBlock that is run if the module has not been loaded yet
            out: the BasicBlock that is run if the module has already been loadedzis notN)r  rþ   rô   r  )r³   r&  rÁ   r3  r4  Ú
first_loadÚ
comparisonr„   r„   r…   r2  ˜  s   

z IRBuilder.check_if_module_loadedÚmodulec                 C  s&   |   tg |¡}|   t||  |¡g|¡S r¼   )r  rp   rg   rß   )r³   r8  rÁ   Úmod_dictr„   r„   r…   Ú
get_module¦  s   zIRBuilder.get_modulec                 C  s&   |   ||¡ |  ||¡}|  |||¡S )zñLook up an attribute of a module without storing it in the local namespace.

        For example, get_module_attr('typing', 'TypedDict', line) results in
        the value of 'typing.TypedDict'.

        Import the module if needed.
        )r5  r:  rÝ   )r³   r8  rÚ   rÁ   Ú
module_objr„   r„   r…   Úget_module_attr¬  s   zIRBuilder.get_module_attrÚget_valúCallable[[], Value]c              	   C  sd   t ƒ t ƒ }}|  t|||tjƒ¡ |  |¡ |  t||  |ƒ |j|¡ƒ¡ |  |¡ |  |¡ dS )z:If target is NULL, assign value produced by get_val to it.N)	r;   rÍ   r<   ÚIS_ERRORrÔ   r:   rÃ   r  rÑ   )r³   rÏ   r=  rÁ   Úerror_blockÚ
body_blockr„   r„   r…   Úassign_if_null¸  s   

zIRBuilder.assign_if_nullc                 C  s4   t | jd ƒst| jd ƒr|  ¡  d S |  ¡  d S ©Néÿÿÿÿ)rP   rž   rQ   Úadd_implicit_returnÚadd_implicit_unreachablerÉ   r„   r„   r…   Úmaybe_add_implicit_returnÁ  s   z#IRBuilder.maybe_add_implicit_returnc                 C  sN   | j jd }|js%|  | j  ¡ | jd d¡}| jd  | || jj	j
¡ d S d S rC  )r˜   ÚblocksÚ
terminatedrÃ   rõ   rž   r°   Ú
gen_returnr®   ÚfitemrÁ   )r³   rÓ   Úretvalr„   r„   r…   rE  Ç  s
   þzIRBuilder.add_implicit_returnc                 C  s&   | j jd }|js|  tƒ ¡ d S d S rC  )r˜   rH  rI  rÍ   rF   rÕ   r„   r„   r…   rF  Í  s   ÿz"IRBuilder.add_implicit_unreachableÚlvaluesúlist[Lvalue]c                 C  s^   |D ]*}t |tƒr,t |jtƒr,t |jjtƒr,|jj|j j}t |tƒr,|js,|  	d|¡ qd S )Nz;Only class variables defined as ClassVar can be assigned to)
rÂ   r   Úexprr   r¹   r#   r  r%   Úis_classvarÚerror)r³   rM  rÁ   ÚlvalueÚvarr„   r„   r…   Údisallow_class_assignmentsÒ  s   ÿ
þý€øz$IRBuilder.disallow_class_assignmentsc                 C  s   t | jƒdkS )Né   )Úlenr¯   rÉ   r„   r„   r…   Únon_function_scopeá  s   zIRBuilder.non_function_scope)Útype_overriderR  r   Ú
rvalue_regÚ
class_nameú
str | NonerX  c                C  s¢   t |tƒsJ ‚t |jtƒsJ ‚|jjd u rO|d u r|j}n|› d|j› }|d us-J dƒ‚|  ||p6|  |¡|j¡}| j	 
||jf¡ |  t||| jƒ¡ d S d S )NÚ.zFull name not set for variable)rÂ   r   r¹   r%   Úfinal_valuer  rÃ   rÄ   rÁ   r¡   Úappendr  rÍ   r>   rµ   )r³   rR  rY  rZ  rX  r  Úcoercedr„   r„   r…   Úinit_final_staticå  s   øzIRBuilder.init_final_staticÚtypÚ
error_namec                 C  s>   t | j|ƒ}|d usJ ‚|\}}| jj||||d|› ddS )Nzvalue for final name "z" was not set)rÁ   Ú	error_msg)r+   r   r˜   Úload_static_checked)r³   r	  ra  rÁ   rb  Ú
split_namer8  r  r„   r„   r…   Úload_final_staticù  s   
ûzIRBuilder.load_final_staticú int | str | bytes | float | boolc                 C  s~   t |tƒr|r|  ¡ S |  ¡ S t |tƒr| j |¡S t |tƒr%| j |¡S t |t	ƒr0| j 
|¡S t |tƒr;| j |¡S J dƒ‚)z4Load value of a final name or class-level attribute.FzUnsupported final literal value)rÂ   rº   rö   r÷   rÛ   r˜   rè   ÚfloatÚ
load_floatrŠ   rß   râ   rå   r  r„   r„   r…   Úload_final_literal_value  s   




z"IRBuilder.load_final_literal_valuerD  r`   c                 C  s®  t |tƒrc|j}t |tƒr|j}|d u r|jsJ ‚t|jƒ}|jt	krJ|| j
d vrE| jjr<| j||  |¡| jjddS |  ||  |¡¡S |  |¡S |jtkr^|  ¡ }|  |j¡}t||ƒS J |jƒ‚t |tƒry|  |j¡}|  |j¡}t||ƒS t |tƒr“|  |¡}| j|j|d}	t|	|j|dS t |tƒrÆd }
g }t|j ƒD ]\}}|  !|¡}| "|¡ t |t#ƒrÀ|
d ur¾|  $d|¡ |}
q¡t%||
ƒS t |t#ƒrÑ|  !|j¡S J d| ƒ‚)NrD  F)Úreassignr¸   z%Two starred expressions in assignmentúUnsupported lvalue: %r)&rÂ   r   r¹   r   ÚfuncÚis_special_formr%   r  Úkindr   rš   r®   Úis_generatorÚadd_var_to_env_classrÄ   Úgenerator_classÚadd_local_regÚlookupr   Úload_globals_dictrß   rb   r   r½   r  Úindexr   Úis_native_attr_refrO  ra   r"   Ú	enumerater  Úget_assignment_targetr^  r   rQ  rd   )r³   rR  rÁ   Úsymbolr'  r  r  rv  r²   rÙ   Ústar_idxrM  ÚidxÚitemÚtargr„   r„   r…   ry    s\   




ü











€

zIRBuilder.get_assignment_targetúValue | AssignmentTargetc                 C  sÀ   t |tƒr|S t |tƒr|jS t |tƒr-|  |jd|jg|j|¡}|d ur'|S J |jjƒ‚t |t	ƒrZt |j
jtƒrQ|j
jjjrQ|oC|j}|  t|j
|j||d¡S |  |j
|j|¡S J d| ƒ‚)NÚ__getitem__F)Úborrowrl  )rÂ   rG   rc   Úregisterrb   r  r  rv  r  ra   rÙ   rH   Úclass_irÚis_ext_classr²   rÍ   r=   rÚ   rÝ   )r³   rÏ   rÁ   r²   Úregr  r„   r„   r…   Úread]  s"   


ÿ

zIRBuilder.readúRegister | AssignmentTargetc           
   	   C  sÎ  t |tƒr|  t||  ||j|¡ƒ¡ d S t |tƒr-|  ||j|¡}|  t|j|ƒ¡ d S t |tƒrgt |j	t
ƒrN|  ||j|¡}|  t|j|j||ƒ¡ d S |  |j¡}| j |¡}|  t|j||g|¡ d S t |tƒr…|  |jd|j|gd |¡}|d usƒJ |jjƒ‚d S t |tƒrãt |jtƒrÂ|jd u rÂ|jj}t|ƒt|jƒks¤J ‚tt|ƒƒD ]}|  t|||ƒ¡}	|  |j| |	|¡ qªd S t |jƒsÌt!|jƒrÚ|jd u rÚ|  "|||¡ d S |  #|||¡ d S J dƒ‚)NÚ__setitem__FzUnsupported assignment target)$rÂ   rC   rÍ   r:   rÃ   r  rc   r‚  ra   Úobj_typerH   rD   rÙ   rÚ   rß   r˜   Úboxr  rk   rb   r  r  rv  rd   rI   r{  r‹   rV  r  ÚrangerE   ÚassignrO   rR   Úprocess_sequence_assignmentÚ!process_iterator_tuple_assignment)
r³   rÏ   rY  rÁ   r"  Ú	boxed_regÚtarget_reg2ÚrtypesÚiÚ
item_valuer„   r„   r…   rŒ  t  sB   
 


ÿ
þÿÿ
zIRBuilder.assignrd   Úrvaluec                 C  sº   t t|jƒtƒ}| j t||g|¡ g }tt|jƒƒD ]-}|j| }| j |¡}t	|j
ƒr7|  t||g|¡}	n| j |d|g|j
|¡}	| |	¡ qt|j|ƒD ]\}
}|  |
||¡ qOdS )zOProcess assignment like 'x, y = s', where s is a variable-length list or tuple.r€  N)r?   rV  r  rL   r˜   r  ro   r‹  rè   rO   r  rl   r  r^  ÚziprŒ  )r³   rÏ   r”  rÁ   Úexpected_lenrø   r’  r}  rv  r“  rR  rÞ   r„   r„   r…   r  —  s   

ÿÿz%IRBuilder.process_sequence_assignmentÚlitemÚritemc                 C  sj   t ƒ t ƒ }}|  t|||tjƒ¡ |  |¡ |  ttjd|ƒ¡ |  tƒ ¡ |  |¡ |  |||¡ d S )Núnot enough values to unpack)	r;   rÍ   r<   r?  rÔ   rB   ÚVALUE_ERRORrF   rŒ  )r³   r—  r˜  rÁ   r@  Úok_blockr„   r„   r…   Ú(process_iterator_tuple_assignment_helper°  s   
ÿ
z2IRBuilder.process_iterator_tuple_assignment_helperc                 C  s  |   t|g|¡}|jd ur|jnt|jƒ}|jd |… D ]=}|   t|g|¡}tƒ tƒ }}	|  t|||	tj	ƒ¡ |  
|¡ |  ttjd|ƒ¡ |  tƒ ¡ |  
|	¡ |  |||¡ q|jd urÓ|j|d d … }
|   t|g|¡}|  ||¡}tt|
ƒƒ}|  ||d|¡}tƒ tƒ }}	|  t||	|tjƒ¡ |  
|¡ |  ttjd|ƒ¡ |  tƒ ¡ |  
|	¡ t|
ƒD ]}|   t|g|¡}|  |||¡ q´|  |j|j ||¡ d S |   t|g|¡}tƒ tƒ }}	|  t||	|tj	ƒ¡ |  
|¡ |  ttjd|ƒ¡ |  tƒ ¡ |  
|	¡ d S )Nr™  é   r|   ztoo many values to unpack)r  ri   r{  rV  r  rj   r;   rÍ   r<   r?  rÔ   rB   rš  rF   rŒ  rn   r  r?   rî   ÚBOOLÚreversedrm   )r³   rÏ   rY  rÁ   ÚiteratorÚ	split_idxr—  r˜  r@  r›  Úpost_star_valsÚ	iter_listÚiter_list_lenÚpost_star_lenÚ	conditionÚextrar„   r„   r…   rŽ  ¿  s\   
ÿÿ


ÿÿ

ÿÿz+IRBuilder.process_iterator_tuple_assignmentÚcontinue_blockÚbreak_blockc                 C  s   | j  t| j d ||ƒ¡ d S rC  )r°   r^  r\   )r³   r¨  r©  r„   r„   r…   Úpush_loop_stack  s   ÿzIRBuilder.push_loop_stackc                 C  rÈ   r¼   )r°   ÚpoprÉ   r„   r„   r…   Úpop_loop_stack  rÊ   zIRBuilder.pop_loop_stackc                 C  s6   t › | j› }|  jd7  _|  t|ƒ|| jj¡}|S )úIMoves a given Value instance into the generator class' environment class.r  )r/   r¥   rq  r%   r®   rr  )r³   r  r  rÏ   r„   r„   r…   Úmake_spill_target  s   zIRBuilder.make_spill_targetc                 C  s   |   |j¡}|  ||d¡ |S )r­  rD  )r®  r  rŒ  )r³   rÞ   rÏ   r„   r„   r…   Úspill  s   zIRBuilder.spillc                 C  s   | j jr	|  |¡S |S )aE  
        Moves a given Value instance into the environment class for generator functions. For
        non-generator functions, leaves the Value instance as it is.

        Returns an AssignmentTarget associated with the Value for generator functions and the
        original Value itself for non-generator functions.
        )r®   rp  r¯  rà   r„   r„   r…   Úmaybe_spill  s   
zIRBuilder.maybe_spillc                 C  s<   | j jr	|  |¡S t|tƒr|S t|jƒ}|  ||d¡ |S )a=  
        Moves a given Value instance into the environment class for generator functions. For
        non-generator functions, allocate a temporary Register.

        Returns an AssignmentTarget associated with the Value for generator functions and an
        assignable Register for non-generator functions.
        rD  )r®   rp  r¯  rÂ   rC   r  rŒ  )r³   rÞ   r…  r„   r„   r…   Úmaybe_spill_assignable)  s   


z IRBuilder.maybe_spill_assignableÚeú
int | Nonec                 C  s>   t |tƒr|jS t |tƒr|jdkrt |jtƒr|jj S d S )Nry   )rÂ   r   rÞ   r$   rË   rO  )r³   r²  r„   r„   r…   Úextract_int<  s
   
 
zIRBuilder.extract_intrO  c                 C  s<   t | j| ƒ}t|tƒsJ ‚|jjdkrtS |  |jd ¡S )Nzbuiltins.strr   )	r*   r‹   rÂ   r&   r  r	  rU   Útype_to_rtyper  )r³   rO  rò   r„   r„   r…   Úget_sequence_typeD  s
   zIRBuilder.get_sequence_typer&   c                 C  s<   t | j| ƒ}t|tƒsJ ‚tdd„ |jjD ƒƒ}t||ƒS )zpFind dict type of a dict-like expression.

        This is useful for dict subclasses like SymbolTable.
        c                 s  s    | ]
}|j d kr|V  qdS )zbuiltins.dictN)r	  )r*  r  r„   r„   r…   Ú	<genexpr>S  s   € z/IRBuilder.get_dict_base_type.<locals>.<genexpr>)r*   r‹   rÂ   r&   Únextr  Úmror   )r³   rO  rò   Ú	dict_baser„   r„   r…   Úget_dict_base_typeL  s   
zIRBuilder.get_dict_base_typec                 C  ó   |   |¡}|  |jd ¡S )Nr   ©r»  rµ  r  ©r³   rO  Údict_base_typer„   r„   r…   Úget_dict_key_typeV  ó   
zIRBuilder.get_dict_key_typec                 C  r¼  )Nr  r½  r¾  r„   r„   r…   Úget_dict_value_typeZ  rÁ  zIRBuilder.get_dict_value_typec                 C  s    |   |¡}|  |¡}t||gƒS r¼   )rÀ  rÂ  rI   )r³   rO  Úkey_typeÚ
value_typer„   r„   r…   Úget_dict_item_type^  s   

zIRBuilder.get_dict_item_typer(   c                 C  s‚   t | j| ƒ}| j| j  ¡ j}| d|g g |¡d }ddlm} t	|t
ƒr6tƒ }|jD ]}|||ƒ}q,|S | d|g g |¡d S )z<Return the item type given by 'expr' in an iterable context.Ú__iter__r   )Ú
join_typesÚ__next__)r*   r‹   r   rµ   Útype_checkerÚexpr_checkerÚcheck_method_call_by_nameÚ	mypy.joinrÇ  rÂ   r'   r)   r  )r³   rO  ÚiterableÚechkr   rÇ  Újoinedr}  r„   r„   r…   Ú_analyze_iterable_item_typec  s   

z%IRBuilder._analyze_iterable_item_typec                 C  s   || j jv S )z*Is the given module one compiled by mypyc?)r   Ú	group_map)r³   r8  r„   r„   r…   Úis_native_moduleu  s   zIRBuilder.is_native_moduler   c                 C  s6   |j d u rdS d|j jv r|  |j j d¡d ¡S dS )NFr\  r   T)r¹   r	  rÒ  Ú
rpartition©r³   rO  r„   r„   r…   Úis_native_ref_expry  s
   
zIRBuilder.is_native_ref_exprc                 C  s   |   |¡o	|jtkS r¼   )rÕ  ro  r   rÔ  r„   r„   r…   Úis_native_module_ref_expr€  r  z#IRBuilder.is_native_module_ref_exprr#   c                 C  s   |j p
|jp
|jduS )z:Is a type something other than just a class we've created?N)Úis_named_tupleÚ
is_newtypeÚtypeddict_type©r³   ra  r„   r„   r…   Úis_synthetic_typeƒ  s   zIRBuilder.is_synthetic_typer   útuple[str, Var, bool] | Nonec                 C  sÞ   d}t |jtƒrIt |jjtƒrI|jj |j¡}|rHt |jtƒrH|jjjd j	j
}|jjp/|dk}|rH|j}|jjj
› d|j› }|  |jjj¡}n|  |¡rdt |jtƒrd|jjrd|j}|jj
}|  |¡}|durm|||fS dS )a   Check if `expr` is a final attribute.

        This needs to be done differently for class and module attributes to
        correctly determine fully qualified name. Return a tuple that consists of
        the qualified name, the corresponding Var node, and a flag indicating whether
        the final name was defined in a compiled module. Return None if `expr` does not
        refer to a final attribute.
        Nr   z	enum.Enumr\  )rÂ   rO  r   r¹   r#   Úgetr  r%   Úbasesr  r	  Úis_finalÚinforÒ  rµ   Úis_module_member_exprrÕ  )r³   rO  Ú	final_varÚsymÚexpr_fullnamerß  r	  Únativer„   r„   r…   Úget_final_ref‡  s&   	€


zIRBuilder.get_final_refrâ  r%   rå  c                 C  s8   |j dur|  |j |¡S |r|  || j |¡||¡S dS )az  Emit code for loading value of a final name (if possible).

        Args:
            final_var: Var corresponding to the final name
            fullname: its qualified name
            name: shorter name to show in errors
            native: whether the name was defined in a compiled module
            typ: its type
            line: line number where loading occurs
        N)r]  rj  rf  r   rµ  )r³   râ  r	  r  rå  ra  rÁ   r„   r„   r…   Úemit_load_final¦  s
   
zIRBuilder.emit_load_finalc                 C  s   t |jtƒot |jjtƒS r¼   )rÂ   rO  r   r¹   r   rÔ  r„   r„   r…   rá  º  s   zIRBuilder.is_module_member_exprr   Úcalleec           	      C  s  |j d ur'|jtgt|ƒ kr't |j g ¡}| j |||j|  	|¡¡}|r'|S |j
}t|tƒr2|j}t|tƒrF|j| jvrF|j| jv rF|j}|d urr|j d urr|| jjv rrtdd„ |jD ƒƒrr| jj| }| j |||j|j|j¡S |  |¡}| j|||j|j|jdS )Nc                 s  s    | ]	}|t tfv V  qd S r¼   )r   r   )r*  ro  r„   r„   r…   r·  Ý  s   € z3IRBuilder.call_refexpr_with_args.<locals>.<genexpr>)r  r  )r	  r  r   rV  rt   rÝ  r˜   Úmatching_call_crÁ   rÄ   r¹   rÂ   r   Úimplr   rm  r­   r“   r   Úfunc_to_declÚallÚcallr  r½   r  )	r³   rO  rè  r   Úcall_c_ops_candidatesrÏ   Úcallee_nodeÚdeclrÿ   r„   r„   r…   Úcall_refexpr_with_args½  s4   ÿ
ÿ
ÿ
ÿz IRBuilder.call_refexpr_with_argsr   c                   s2   ˆj  ˆ jˆ ˆ ¡‡ ‡fdd„‡ ‡fdd„ˆ j¡S )Nc                     ó   ˆ  ˆ j¡S r¼   )r½   Úleftr„   ©rO  r³   r„   r…   Ú<lambda>ì  ó    z-IRBuilder.shortcircuit_expr.<locals>.<lambda>c                     rò  r¼   )r½   Úrightr„   rô  r„   r…   rõ  í  rö  )r˜   Úshortcircuit_helperrË   rÄ   rÁ   rÔ  r„   rô  r…   Úshortcircuit_exprè  s   ûzIRBuilder.shortcircuit_exprÚargúRefExpr | TupleExprúlist[ClassIR] | Nonec                 C  sˆ   t |tƒrt |jtƒr|  |¡r| jj |j¡}|r|gS dS g }|jD ]}t |tt	fƒr?|  
|¡}|du r9 dS | |¡ q$ dS |S )zŠFlatten classes in isinstance(obj, (A, (B, C))).

        If at least one item is not a reference to a native class, return None.
        N)rÂ   r   r¹   r#   rÖ  r   Ú
type_to_irrÝ  r  r"   Úflatten_classesÚextend)r³   rú  ÚirrÇ   r}  Ú	item_partr„   r„   r…   rþ  ó  s   


zIRBuilder.flatten_classesr—   r®   úFuncInfo | strc                 C  s¢   t |tƒr
t|d}t| j| j| jƒ| _| j 	| j¡ | j
 	i ¡ | j 	g ¡ || _| j 	| j¡ | j 	t¡ |jrB| j 	tƒ ¡ n| j 	tƒ ¡ |  tƒ ¡ d S )N©r  )rÂ   rŠ   rV   rX   r‰   r   r’   r˜   r™   r^  rš   r›   r®   r¯   rž   rS   rp  r°   r[   rZ   rÔ   r;   )r³   r®   r„   r„   r…   Úenter
  s   

zIRBuilder.enterúJtuple[list[Register], list[RuntimeArg], list[BasicBlock], RType, FuncInfo]c                 C  sf   | j  ¡ }| j ¡  | j ¡ }| j ¡ }| j ¡ }| j ¡  | j d | _| jd | _|j	||j
||fS rC  )r™   r«  rš   r›   rž   r¯   r°   r˜   r®   r  rH  )r³   r˜   r›   Úret_typer®   r„   r„   r…   Úleave  s   





zIRBuilder.leaverƒ  r2   r  Ú	self_typeúIterator[None]c                 c  s:   |   |¡ | j |¡ | j |¡ || jd< |du rt|ƒ}|  t|¡ z>dV  W |  ¡ \}}}}}t	||ƒ}	| j 
¡ }| j 
¡ }t||j| j|	ƒ}
t|
||ƒ}||j|< |j|j|< | j |¡ dS |  ¡ \}}}}}t	||ƒ}	| j 
¡ }| j 
¡ }t||j| j|	ƒ}
t|
||ƒ}||j|< |j|j|< | j |¡ w )a5  Generate IR for a method.

        If the method takes arguments, you should immediately afterwards call
        add_argument() for each non-self argument (self is created implicitly).

        Args:
            class_ir: Add method to this class
            name: Short name of the method
            ret_type: Return type of the method
            fn_info: Optionally, additional information about the method
            self_type: If not None, override default type of the implicit 'self'
                argument (by default, derive type from class_ir)
        rD  N)r  rœ   r^  r   rž   rH   Úadd_argumentr.   r  r7   r«  r5   r  rµ   r6   Úmethodsrð  Úmethod_declsrŸ   )r³   rƒ  r  r  r®   r  Úarg_regsr  rH  Úsigrð  r   r„   r„   r…   Úenter_method%  s8   €





ø



zIRBuilder.enter_methodrS  ú	str | Varro  r   c                 C  s@   t |tƒr	t|ƒ}| j||dd}| jd  t|j||ƒ¡ |S )z‡Declare an argument in the current function.

        You should use this instead of directly calling add_local() in new code.
        T©Úis_argrD  )rÂ   rŠ   r%   Ú	add_localr›   r^  r8   r  )r³   rS  ra  ro  r…  r„   r„   r…   r
  O  s
   
zIRBuilder.add_argumentrz  r!   ÚSymbolTargetc                 C  s   | j d | S rC  ©rš   )r³   rz  r„   r„   r…   rt  Z  rÊ   zIRBuilder.lookupr  c                 C  sN   t |tƒsJ ‚t|t|jƒ||jd}t|ƒ| jd |< |r%| jj	 
|¡ |S )z‚Add register that represents a symbol to the symbol table.

        Args:
            is_arg: is this a function argument
        )r  rÁ   rD  )rÂ   r!   rC   Úremangle_redefinition_namer  rÁ   rc   rš   r˜   r  r^  )r³   rz  ra  r  r…  r„   r„   r…   r  ]  s   ÿzIRBuilder.add_localrc   c                 C  s.   |   |||¡ | jd | }t|tƒsJ ‚|S )zALike add_local, but return an assignment target instead of value.rD  )r  rš   rÂ   rc   )r³   rz  ra  r  rÏ   r„   r„   r…   rs  l  s   zIRBuilder.add_local_regÚclsc                 C  s   | j ttƒt|ƒddS )zLow-level function that adds a 'self' argument.

        This is only useful if using enter() instead of enter_method().
        Tr  )rs  r%   r.   rH   )r³   r  r„   r„   r…   Úadd_self_to_envu  s   zIRBuilder.add_self_to_envc                 C  s   || j d |< |S rC  r  )r³   rz  rÏ   r„   r„   r…   Ú
add_target|  s   zIRBuilder.add_targetúType | Nonec                 C  rÌ   r¼   )r   rµ  rÚ  r„   r„   r…   rµ  €  rÎ   zIRBuilder.type_to_rtypec                 C  s0   t |tƒrtS || jvrtS | j| }|  |¡S r¼   )rÂ   r   rN   r‹   rT   rµ  )r³   r¹   Ú	mypy_typer„   r„   r…   rÄ   ƒ  s   



zIRBuilder.node_typeÚrtypeúFuncInfo | ImplicitClassrk  c                 C  sd   || j jj|j< t|j|jƒ}|r,|  |  |¡| j jj	¡}|  
t|j|j|| j jj	ƒ¡ |  ||¡S r¼   )r®   Ú	env_classÚ
attributesr  ra   Úcurr_env_regr†  rt  rK  rÁ   rÍ   rD   r  )r³   rS  r  r  rk  Úattr_targetr…  r„   r„   r…   rq  Œ  s   zIRBuilder.add_var_to_env_classc                 C  s0   |j sJ dƒ‚d|j jv o|j j d¡d dkS )NúRefExpr not resolvedr\  r   Úbuiltins)r¹   r	  ÚsplitrÔ  r„   r„   r…   Úis_builtin_ref_exprž  s   "zIRBuilder.is_builtin_ref_exprr   c                 C  sv   |   |¡r|jsJ dƒ‚|  |jj|j¡S |  |¡r3t|jtƒr3|  |j¡s3|jdus-J ‚|  	|j¡S |  
|j|j¡S )zÆLoads a Python-level global.

        This takes a NameExpr and uses its name as a key to retrieve the corresponding PyObject *
        from the _globals dictionary in the C-generated code.
        r"  N)r%  r¹   Úload_module_attr_by_fullnamer	  rÁ   rÖ  rÂ   r#   rÛ  r
  Úload_global_strr  rÔ  r„   r„   r…   Úload_global¢  s   
ÿ
þ
ýzIRBuilder.load_globalc                 C  s$   |   ¡ }|  |¡}|  t||g|¡S r¼   )ru  rß   r  rg   )r³   r  rÁ   Ú_globalsr…  r„   r„   r…   r'  µ  s   
zIRBuilder.load_global_strc                 C  s   |   ttd| jƒ¡S )NÚglobals)rÍ   r@   rM   rµ   rÉ   r„   r„   r…   ru  º  r  zIRBuilder.load_globals_dictc                 C  s(   |  d¡\}}}|  |¡}|  |||¡S ©Nr\  )rÓ  r  rÝ   )r³   r	  rÁ   r8  Ú_r  ró  r„   r„   r…   r&  ½  s   
z&IRBuilder.load_module_attr_by_fullnamec                 C  s<   |   |j¡}t|tƒo|jjo|j |j¡o|j |j¡ S )zIIs expr a direct reference to a native (struct) attribute of an instance?)	rÄ   rO  rÂ   rH   rƒ  r„  Úhas_attrr  Ú
get_method)r³   rO  Ú	obj_rtyper„   r„   r…   rw  Â  s   
ÿþüzIRBuilder.is_native_attr_refr   c                 C  s   t | j|ƒS r¼   )r0   r¶   )r³   rÁ   r„   r„   r…   r0   Í  rÎ   zIRBuilder.catch_errorsÚmsgc                 C  ó   | j  || j|¡ d S r¼   )rŽ   Úwarningr¶   ©r³   r0  rÁ   r„   r„   r…   r2  Ð  ó   zIRBuilder.warningc                 C  r1  r¼   )rŽ   rQ  r¶   r3  r„   r„   r…   rQ  Ó  r4  zIRBuilder.errorc                 C  r1  r¼   )rŽ   Únoter¶   r3  r„   r„   r…   r5  Ö  r4  zIRBuilder.note)r‰   rŠ   r‹   rŒ   r   r   rŽ   r1   r   rY   r   r^   r‘   r   r’   rf   r“   r”   r•   r–   )rµ   rŠ   r¶   rŠ   r•   r–   )r¹   r   r²   rº   r•   rG   )r¹   r    r•   r–   )r¹   r¿   r²   rº   r•   rÀ   )r•   r–   )rË   rA   r•   rG   )rÏ   r;   r•   r–   )rÓ   r;   r•   r–   )r•   rC   )rÙ   rG   rÚ   rŠ   rÁ   rÛ   r•   rG   )rÞ   rŠ   r•   rG   )rÞ   rÛ   r•   rG   )ré   rG   rê   rŠ   rÁ   rÛ   r•   rG   )
ré   rG   rì   rG   rê   rŠ   rÁ   rÛ   r•   rG   )F)
rñ   rG   rò   rJ   rÁ   rÛ   ró   rº   r•   rG   ©r•   rG   )rø   rù   rÁ   rÛ   r•   rG   )NN)rÿ   rG   r   rù   rÁ   rÛ   r  r  r  r  r•   rG   )rÞ   rG   rö   r;   r÷   r;   r•   r–   )r	  rŠ   r•   rG   )r  rG   r  rŠ   r   rù   r  r  rÁ   rÛ   r  r  r  r  r•   rG   )r  rŠ   r•   rG   )r  rs   r  rù   rÁ   rÛ   r•   rG   )r  rJ   r  rG   r  rG   rË   rÛ   rÁ   rÛ   r•   rG   )
r  rG   r  rG   rË   rŠ   rÁ   rÛ   r•   rG   )r  rG   rÁ   rÛ   r•   rG   )r  rù   rÁ   rÛ   r•   rG   )
r!  r3   r"  rŠ   r  rG   rÁ   rÛ   r•   r–   )
r&  rŠ   r'  rG   r(  r)  rÁ   rÛ   r•   rG   )r&  rŠ   rÁ   rÛ   r•   r–   )
r&  rŠ   rÁ   rÛ   r3  r;   r4  r;   r•   r–   )r8  rŠ   rÁ   rÛ   r•   rG   )r8  rŠ   rÚ   rŠ   rÁ   rÛ   r•   rG   )rÏ   rC   r=  r>  rÁ   rÛ   r•   r–   )rM  rN  rÁ   rÛ   r•   r–   )r•   rº   r¼   )
rR  r   rY  rG   rZ  r[  rX  r  r•   r–   )
r	  rŠ   ra  rJ   rÁ   rÛ   rb  r[  r•   rG   )r  rg  rÁ   rÛ   r•   rG   )rD  )rR  r   rÁ   rÛ   r•   r`   )rD  F)rÏ   r  rÁ   rÛ   r²   rº   r•   rG   )rÏ   r‡  rY  rG   rÁ   rÛ   r•   r–   )rÏ   rd   r”  rG   rÁ   rÛ   r•   r–   )r—  r`   r˜  rG   rÁ   rÛ   r•   r–   )rÏ   rd   rY  rG   rÁ   rÛ   r•   r–   )r¨  r;   r©  r;   r•   r–   )r  rJ   r•   r`   )rÞ   rG   r•   r`   )rÞ   rG   r•   r  )rÞ   rG   r•   r‡  )r²  r   r•   r³  )rO  r   r•   rJ   )rO  r   r•   r&   )rO  r   r•   r(   )r8  rŠ   r•   rº   )rO  r   r•   rº   )ra  r#   r•   rº   )rO  r   r•   rÜ  )râ  r%   r	  rŠ   r  rŠ   rå  rº   ra  r(   rÁ   rÛ   r•   rÀ   )rO  r   r•   rº   )rO  r   rè  r   r   rù   r•   rG   )rO  r   r•   rG   )rú  rû  r•   rü  )r—   )r®   r  r•   r–   )r•   r  )r—   N)rƒ  r2   r  rŠ   r  rJ   r®   r  r  r  r•   r	  )rS  r  ra  rJ   ro  r   r•   rC   )rz  r!   r•   r  )rz  r!   ra  rJ   r  rº   r•   rC   )rz  r!   ra  rJ   r  rº   r•   rc   )r  r2   r•   rc   )rz  r!   rÏ   r  r•   r  )ra  r  r•   rJ   )r¹   r   r•   rJ   )
rS  r!   r  rJ   r  r  rk  rº   r•   r`   )rO  r   r•   rG   )r  rŠ   rÁ   rÛ   r•   rG   )r	  rŠ   rÁ   rÛ   r•   rG   )rÁ   rÛ   r•   r   )r0  rŠ   rÁ   rÛ   r•   r–   )jr   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%  r1  r5  r2  r:  r<  rB  rG  rE  rF  rT  rW  r`  rf  rj  ry  r†  rŒ  r  rœ  rŽ  rª  r¬  r®  r¯  r°  r±  r´  r¶  r»  rÀ  rÂ  rÅ  rÐ  rÒ  rÕ  rÖ  rÛ  ræ  rç  rá  rñ  rù  rþ  r  r  r   r  r   r
  rt  r  rs  r  r  rµ  rÄ   rq  r%  r(  r'  ru  r&  rw  r0   r2  rQ  r5  r„   r„   r„   r…   rˆ   ˆ   sî    D
ú

ø	üúÿCÿ#H
+ú)ÿ	
ÿrˆ   r˜   r•   r–   c                   s`   ˆj j‰ˆjD ]&‰ ˆ jr-ˆ ˆ j¡‰d‡ ‡‡‡fdd„}tˆtƒs#J ‚ˆ ˆj	|ˆ jj
¡ qdS )z›Generate blocks for arguments that have default values.

    If the passed value is an error value, then assign the default
    value to the argument.
    r•   rG   c                    sš   ˆ j d usJ ‚tˆ j ƒrˆ ˆ j ¡S ˆjjs3ˆjd ˆ jj } ˆj 	| ˆj
f¡ ˆ tˆj
| ˆjƒ¡S ˆ jj} ˆj
ˆjjjj| < ˆ tˆjjj| ˆ jƒ¡S r+  )Úinitializerre   r½   r®   Ú	is_nestedr	  Úvariabler  r¡   r^  r  rÍ   r@   rµ   Úcallable_classr   r  r=   Úself_regrÁ   r  ©rú  r˜   rK  rÏ   r„   r…   Úget_defaultå  s   
ÿz%gen_arg_defaults.<locals>.get_defaultNr6  )r®   rK  Ú	argumentsr7  rt  r9  rÂ   rc   rB  r‚  rÁ   )r˜   r=  r„   r<  r…   Úgen_arg_defaultsÚ  s   
€çr?  r  rŠ   c                 C  s   |   dd¡S )aI  Remangle names produced by mypy when allow-redefinition is used and a name
    is used with multiple types within a single block.

    We only need to do this for locals, because the name is used as the name of the register;
    for globals, the name itself is stored in a register for the purpose of doing dict
    lookups.
    ú'Ú	__redef__)Úreplacer  r„   r„   r…   r  ý  s   r  )r˜   rˆ   r•   r–   )r  rŠ   r•   rŠ   )œÚ__doc__Ú
__future__r   Ú
contextlibr   Útypingr   r   r   r   r   Útyping_extensionsr	   r
   Ú
mypy.buildr   Úmypy.maptyper   Ú
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%   Ú
mypy.typesr&   r'   r(   r)   r*   Ú	mypy.utilr+   Úmypy.visitorr,   r-   Úmypyc.commonr.   r/   Úmypyc.crashr0   Úmypyc.errorsr1   Úmypyc.ir.class_irr2   r3   Úmypyc.ir.func_irr4   r5   r6   r7   r8   Úmypyc.ir.opsr9   r:   r;   r<   r=   r>   r?   r@   rA   rB   rC   rD   rE   rF   rG   Úmypyc.ir.rtypesrH   rI   rJ   rK   rL   rM   rN   rO   rP   rQ   rR   rS   rT   rU   Úmypyc.irbuild.contextrV   rW   Úmypyc.irbuild.ll_builderrX   Úmypyc.irbuild.mapperrY   Úmypyc.irbuild.nonlocalcontrolrZ   r[   r\   r]   Úmypyc.irbuild.prebuildvisitorr^   Úmypyc.irbuild.preparer_   Úmypyc.irbuild.targetsr`   ra   rb   rc   rd   Úmypyc.irbuild.utilre   Úmypyc.optionsrf   Úmypyc.primitives.dict_opsrg   rh   Úmypyc.primitives.generic_opsri   rj   rk   Úmypyc.primitives.list_opsrl   rm   rn   Úmypyc.primitives.misc_opsro   rp   rq   rr   Úmypyc.primitives.registryrs   rt   r}   Ú__annotations__r   Ú	Exceptionr‡   r  rˆ   r?  r  r„   r„   r„   r…   Ú<module>   s^    lD@        
Z#