o
    ØÝ2gðæ  ã                   @  s–  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
mZ ddl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+m,Z,m-Z-m.Z.m/Z/m0Z0 dd	l1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;m<Z< dd
l=m>Z>m?Z? ddl@mAZAmBZB ddlCmDZDmEZEmFZF ddlGmHZH ddlImJZJ ddlKmLZLmMZM ddlNmOZOmPZPmQZQmRZRmSZS ddlTmUZUmVZVmWZWmXZXmYZYmZZZm[Z[m\Z\m]Z]m^Z^m_Z_m`Z`maZambZbmcZcmdZdmeZemfZf ddlgmhZhmiZimjZjmkZkmlZlmmZmmnZnmoZompZpmqZqmrZrmsZsmtZtmuZumvZvmwZwmxZx ddlymzZzm{Z{ ddl|m}Z} ddl~mZ ddl€mZm‚Z‚mƒZƒm„Z„ ddl…m†Z† ddl‡mˆZˆ ddl‰mŠZŠm‹Z‹mŒZŒmZmŽZŽ ddlmZm‘Z‘ ddl’m“Z“ ddl”m•Z•m–Z– ddl—m˜Z˜m™Z™mšZš ddl›mœZœmZmžZž ddlŸm Z m¡Z¡m¢Z¢ dd l£m¤Z¤m¥Z¥ h d!£Z¦d"e§d#< G d$d%„ d%eAef eBd& ƒZ¨G d'd(„ d(e©ƒZªeee‹f Z«G d)d*„ d*ƒZ¬dAd.d/„Z­dBd2d3„Z®dCd6d7„Z¯dDd?d@„Z°d&S )Eaÿ  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ÚFinalÚIteratorÚSequenceÚUnion)Úoverload)ÚGraph)Úmap_instance_to_supertype)Ú	ARG_NAMEDÚARG_POSÚGDEFÚLDEFÚPARAM_SPEC_KINDÚTYPE_VAR_KINDÚTYPE_VAR_TUPLE_KINDÚArgKindÚCallExprÚ	DecoratorÚ
ExpressionÚFuncDefÚ	IndexExprÚIntExprÚLvalueÚ
MemberExprÚMypyFileÚNameExprÚOpExprÚOverloadedFuncDefÚRefExprÚStarExprÚ	StatementÚ
SymbolNodeÚ	TupleExprÚ	TypeAliasÚTypeInfoÚ	TypeParamÚ	UnaryExprÚVar)ÚAnyTypeÚDeletedTypeÚInstanceÚ
ProperTypeÚ	TupleTypeÚTypeÚTypedDictTypeÚ	TypeOfAnyÚUninhabitedTypeÚ	UnionTypeÚget_proper_type)Úmodule_prefixÚsplit_target)ÚExpressionVisitorÚStatementVisitor)ÚBITMAP_BITSÚ	SELF_NAMEÚTEMP_ATTR_NAME)Úcatch_errors)ÚErrors)ÚClassIRÚNonExtClassInfo)ÚINVALID_FUNC_DEFÚFuncDeclÚFuncIRÚFuncSignatureÚ
RuntimeArg)ÚNAMESPACE_MODULEÚNAMESPACE_TYPE_VARÚAssignÚ
BasicBlockÚBranchÚComparisonOpÚGetAttrÚ
InitStaticÚIntegerÚIntOpÚ
LoadStaticÚOpÚRaiseStandardErrorÚRegisterÚSetAttrÚTupleGetÚUnreachableÚValue)Ú	RInstanceÚRTupleÚRTypeÚRUnionÚbitmap_rprimitiveÚc_pyssize_t_rprimitiveÚdict_rprimitiveÚint_rprimitiveÚis_float_rprimitiveÚis_list_rprimitiveÚis_none_rprimitiveÚis_object_rprimitiveÚ	is_taggedÚis_tuple_rprimitiveÚnone_rprimitiveÚobject_rprimitiveÚstr_rprimitive)ÚFuncInfoÚImplicitClass)ÚLowLevelIRBuilder)ÚMapper)ÚBaseNonlocalControlÚGeneratorNonlocalControlÚLoopNonlocalControlÚNonlocalControl)ÚPreBuildVisitor)ÚRegisterImplInfo)ÚAssignmentTargetÚAssignmentTargetAttrÚAssignmentTargetIndexÚAssignmentTargetRegisterÚAssignmentTargetTuple)Úbytes_from_strÚ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_op)ÚCFunctionDescriptionÚfunction_ops>   ú!=ú==ú>=ú+ú-ú<ú>ú<=r   Úint_borrow_friendly_opc                   @  ó   e Zd ZdS )Ú	IRVisitorN©Ú__name__Ú
__module__Ú__qualname__© r—   r—   úM/home/garg/my-data/venv/lib/python3.10/site-packages/mypyc/irbuild/builder.pyr’      ó    r’   Nc                   @  r‘   )ÚUnsupportedExceptionNr“   r—   r—   r—   r˜   rš   ”   r™   rš   c                   @  s6  e Zd Zdvdd„Zdwdd„Zeddœdxd"d#„ƒZedyd%d#„ƒZddœdzd(d#„Zd{d)d*„Zd|d-d.„Zd}d1d2„Z	d~d4d5„Z
d~d6d7„Zdd9d:„Zd€d?d@„ZddBdC„ZddDdE„Zd‚dFdG„ZdƒdIdJ„Zd„dMdN„Zd…dPdQ„Zd†d‡dVdW„ZdˆdXdY„ZdˆdZd[„Zdˆd\d]„Zdˆd^d_„Zd‰dbdc„Zd‰ddde„Zd…dfdg„Z	h	hdŠd‹dodp„ZdŒdsdt„Zddvdw„Z	h	hdŠdŽd}d~„Zddd€„Z dd„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—ddž„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´„Z0ddµd¶„Z1džd¸d¹„Z2	hdŸdhdºœd dÁdÂ„Z3	hdŸd¡dÅdÆ„Z4d¢dÇdÈ„Z5d£dÉdÊ„Z6d¤dÌdÍ„Z7	Îd¥ddÏœd¦dÒdÓ„Z8	d§d¨dÕdÖ„Z9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.d/„ZWdÃd1d2„ZXeY	+	hdÄdÅd8d9„ƒZZe[fdÆd>d?„Z\dÇdCdD„Z]d†dÈdFdG„Z^	d†dÉdIdJ„Z_dÊdLdM„Z`dËdNdO„ZadÌdQdR„ZbdÍdSdT„Zc	d†dÎdWdX„Zdd¹dYdZ„ZedÏd\d]„Zfd£d^d_„Zgdˆd`da„ZhdÐdbdc„Zid½ddde„Zjd{dfdg„ZkdÑdidj„ZldÒdldm„ZmdÒdndo„ZndÒdpdq„ZodÓdtdu„ZpdhS (Ô  Ú	IRBuilderÚcurrent_moduleÚstrÚtypesúdict[Expression, Type]Úgraphr   Úerrorsr>   Úmapperrl   Úpbvrq   Úvisitorr’   Úoptionsrz   Úsingledispatch_implsú%dict[FuncDef, list[RegisterImplInfo]]ÚreturnÚNonec
           
      C  s  t ||ƒ| _| jg| _i g| _g g| _g | _g | _dg| _|| _|| _	|| _
|| _g | _g | _tƒ | _g | _g | _g | _tƒ | _|| _d| _d| _|j| _|j| _|j| _|j ¡ | _|j| _|j| _|	| _ || _!t"t#ddƒ| _$| j$g| _%g | _&|| _'i | _(d| _)d S )NTr   Ú F)*rk   ÚbuilderÚbuildersÚ	symtablesÚruntime_argsÚfunction_name_stackÚclass_ir_stackÚblock_reachable_stackrœ   r¢   rž   r    Ú	ret_typesÚ	functionsÚsetÚfunction_namesÚclassesÚfinal_namesÚtype_var_namesÚcallable_class_namesr¥   Úlambda_counterÚtemp_counterÚfree_variablesÚprop_settersÚencapsulating_funcsÚnested_funcsÚkeysÚnested_fitemsÚfuncs_to_decoratorsÚfdefs_to_decoratorsÚmodule_import_groupsr¦   r¤   ri   rA   Úfn_infoÚfn_infosÚnonlocal_controlr¡   ÚimportsÚ
can_borrow)
Úselfrœ   rž   r    r¡   r¢   r£   r¤   r¥   r¦   r—   r—   r˜   Ú__init__œ   sF   


zIRBuilder.__init__Úmodule_nameÚmodule_pathc                 C  s   || _ || _| j ||¡ dS )zuSet the name and path of the current module.

        This must be called before transforming any AST nodes.
        N)rÌ   rÍ   r«   Ú
set_module)rÊ   rÌ   rÍ   r—   r—   r˜   rÎ   ç   s   zIRBuilder.set_moduleF©rÉ   Únoder   rÉ   ÚboolrW   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)r=   ÚlineÚ
isinstancer   rÉ   rÔ   r¤   ÚcoerceÚ	node_typerš   rS   Ú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ÚoprQ   c                 C  ó   | j  |¡S rÓ   )r«   Úadd)rÊ   râ   r—   r—   r˜   rä     ó   zIRBuilder.addÚtargetrI   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_activaterS   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   | j  t|ƒ¡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.
        )r«   Ú
load_bytesrx   r÷   r—   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ú   8  rå   zIRBuilder.load_intÚfloatc                 C  rã   rÓ   )r«   Ú
load_floatr÷   r—   r—   r˜   rü   ;  rå   zIRBuilder.load_floatÚ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  A  ó   zIRBuilder.binary_opÚsrcÚtarget_typerZ   Úforcec                 C  s   | j j||||| jdS )NrÏ   )r«   rÚ   rÉ   )rÊ   r  r  rØ   r  r—   r—   r˜   rÚ   D  s   zIRBuilder.coercec                 C  rî   rÓ   )r«   Únone_objectrà   r—   r—   r˜   r  G  rï   zIRBuilder.none_objectc                 C  rî   rÓ   )r«   Únonerà   r—   r—   r˜   r	  J  rï   zIRBuilder.nonec                 C  rî   rÓ   )r«   Útruerà   r—   r—   r˜   r
  M  rï   zIRBuilder.truec                 C  rî   rÓ   )r«   Úfalserà   r—   r—   r˜   r  P  rï   zIRBuilder.falseÚvaluesúlist[Value]c                 C  ó   | j  ||¡S rÓ   )r«   Únew_list_op©rÊ   r  rØ   r—   r—   r˜   r  S  rá   zIRBuilder.new_list_opc                 C  r  rÓ   )r«   Ú
new_set_opr  r—   r—   r˜   r  V  rá   zIRBuilder.new_set_opc                 C  r  rÓ   )r«   Útranslate_is_opr  r—   r—   r˜   r  Y  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  \  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  f  ó   zIRBuilder.add_bool_branchÚfullnamec                 C  rã   rÓ   )r«   Úload_native_type_object)rÊ   r  r—   r—   r˜   r  i  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$  l  s   
ÿzIRBuilder.gen_method_callc                 C  rã   rÓ   )r«   Úload_module)rÊ   r   r—   r—   r˜   r%  z  rå   zIRBuilder.load_moduleÚdescr†   Úargsc                 C  ró   rÓ   )r«   Úcall_c)rÊ   r&  r'  rØ   r—   r—   r˜   r(  }  ré   zIRBuilder.call_cÚtypeÚlhsÚrhsc                 C  r  rÓ   )r«   Úint_op)rÊ   r)  r*  r+  râ   rØ   r—   r—   r˜   r,  €  r  zIRBuilder.int_opc                 C  r  rÓ   )r«   Úcompare_tuples)rÊ   r*  r+  râ   rØ   r—   r—   r˜   r-  ƒ  r  zIRBuilder.compare_tuplesÚvalc                 C  r  rÓ   )r«   Úbuiltin_len)rÊ   r.  rØ   r—   r—   r˜   r/  †  rá   zIRBuilder.builtin_lenÚitemsc                 C  r  rÓ   )r«   Ú	new_tuple)rÊ   r0  rØ   r—   r—   r˜   r1  ‰  rá   zIRBuilder.new_tupleÚnon_extr@   Úkeyc                 C  s$   |   |¡}|  t|j||g|¡ d S rÓ   )rö   r(  r|   Údict)rÊ   r2  r3  r.  rØ   Úkey_unicoder—   r—   r˜   Úadd_to_non_ext_dictŽ  s   
zIRBuilder.add_to_non_ext_dictÚidc                 C  sj   d | j |< tƒ tƒ }}|  ||||¡ |  |¡ |  t|  |¡g|¡}|  t||t	d¡ |  
|¡ d S )N©Ú	namespace)rÈ   rI   Úcheck_if_module_loadedrë   r(  r…   rö   rä   rM   rF   rí   )rÊ   r7  rØ   Úneeds_importÚoutrõ   r—   r—   r˜   Ú
gen_import•  s   

zIRBuilder.gen_importr;  r<  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Ê   r7  rØ   r;  r<  Ú
first_loadÚ
comparisonr—   r—   r˜   r:     s   

z IRBuilder.check_if_module_loadedÚmodulec                 C  s&   |   tg |¡}|   t||  |¡g|¡S rÓ   )r(  r„   r{   rö   )rÊ   r@  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.
        )r=  rB  rô   )rÊ   r@  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)	rI   rä   rJ   ÚIS_ERRORrë   rH   rÚ   r)  rè   )rÊ   ræ   rE  rØ   Úerror_blockÚ
body_blockr—   r—   r˜   Úassign_if_nullÀ  s   

zIRBuilder.assign_if_nullÚindexc           	   	   C  s´   t ƒ t ƒ }}|  t| jjd|t   td|td @ > tƒtj|¡}|  	t
|tdtƒt
jƒ¡}|  	t|||tjƒ¡ |  |¡ |  	t||  |ƒ |j|¡ƒ¡ |  |¡ |  |¡ d S )Néÿÿÿÿé   r   )rI   r,  r\   r«   r'  r:   rN   rO   ÚANDrä   rK   ÚEQrJ   ÚBOOLrë   rH   rÚ   r)  rè   )	rÊ   ræ   rE  rK  rØ   rH  rI  ÚoÚbr—   r—   r˜   Úassign_if_bitmap_unsetÉ  s   û

z IRBuilder.assign_if_bitmap_unsetc                 C  s4   t | jd ƒst| jd ƒr|  ¡  d S |  ¡  d S ©NrL  )rb   r²   rc   Ú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 rT  )r«   ÚblocksÚ
terminatedrÚ   r	  r²   rÇ   Ú
gen_returnrÅ   ÚfitemrØ   )rÊ   rê   Úretvalr—   r—   r˜   rU  á  s
   þzIRBuilder.add_implicit_returnc                 C  s&   | j jd }|js|  tƒ ¡ d S d S rT  )r«   rX  rY  rä   rV   rì   r—   r—   r˜   rV  ç  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Ê   r]  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úFuncInfo | Nonec                 C  s   |   ¡ rd S | jd S re  )rh  rÆ   rà   r—   r—   r˜   Útop_level_fn_infoÿ  s   
zIRBuilder.top_level_fn_info)Útype_overriderb  r   Ú
rvalue_regÚ
class_nameú
str | Nonerk  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ä   rM   rÌ   )rÊ   rb  rl  rm  rk  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)r7   r    r«   Úload_static_checked)rÊ   r  rt  rØ   ru  Ú
split_namer@  r   r—   r—   r˜   Úload_final_static  s   
ûzIRBuilder.load_final_staticc                 C  s8   |d t |ƒ }| j |¡ |  t||| jtd¡ d S ©NÚ___r8  )r   r¸   rq  rä   rM   rÌ   rG   )rÊ   rõ   r   rØ   Úunique_namer—   r—   r˜   Úinit_type_var&  s   zIRBuilder.init_type_varc                 C  s$   |   tt|d t|ƒ | jtd¡S rz  )rä   rP   rg   r   rÌ   rG   )rÊ   r   rØ   r—   r—   r˜   Úload_type_var+  s   üÿzIRBuilder.load_type_varú*int | str | bytes | float | complex | 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 t |tƒrF| j |¡S J dƒ‚)zQLoad value of a final name, class-level attribute, or constant folded expression.FzUnsupported literal value)rÙ   rÑ   r
  r  rò   r«   rú   rû   rü   r   rö   Úbytesrø   ÚcomplexÚload_complex)rÊ   r.  r—   r—   r˜   Úload_literal_value5  s   





zIRBuilder.load_literal_valuerL  )Úfor_readr„  rs   c                C  sþ  |dkr|j }t|tƒr‹|j}t|tƒr|j}|d u r%|js J ‚t|jƒ}|s5t|tƒr5|j	r5|  
d|¡ |jtkrr|| jd vrmt|tƒrSt|jtƒsS|  |j¡}n|  |¡}| jjrg| j||| jjddS |  ||¡S |  |¡S |jtkr†|  ¡ }|  |j¡}t||ƒS J |jƒ‚t|tƒr¡|  |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| ƒ‚)NrL  z2Cannot assign to the first argument of classmethodF)ÚreassignrÏ   z%Two starred expressions in assignmentúUnsupported lvalue: %r)+rØ   rÙ   r   rÐ   r   ÚfuncÚis_special_formr*   r   Úis_clsra  Úkindr   r­   r)  r,   Útype_to_rtyperÛ   rÅ   Úis_generatorÚadd_var_to_env_classÚgenerator_classÚadd_local_regÚlookupr   Úload_globals_dictrö   ru   r   rÔ   r  rK  r   Úis_native_attr_refr_  rt   r%   Ú	enumerater0  Úget_assignment_targetrq  r"   rw   )rÊ   rb  rØ   r„  ÚsymbolÚreg_typeÚglobals_dictr   r  rK  rÉ   rð   Ústar_idxr]  ÚidxÚitemÚtargr—   r—   r˜   r”  I  sd   





ÿ











€

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)Úborrowr†  )rÙ   rW   rv   Úregisterru   r$  r  rK  r)  rt   rð   rX   Úclass_irÚis_ext_classrÉ   rä   rL   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Ù   rS   rä   rH   Úcoerce_rvaluer)  rv   rŸ  rt   Úobj_typerX   rT   rð   rñ   rö   r«   Úboxr(  r   ru   r$  r  rK  rw   rY   r˜  rž   rg  r0  ÚrangerU   Úassignra   re   Úprocess_sequence_assignmentÚ!process_iterator_tuple_assignment)
rÊ   ræ   rl  rØ   r3  Ú	boxed_regÚtarget_reg2ÚrtypesÚiÚ
item_valuer—   r—   r˜   rª  ©  sB   
 


ÿ
þÿÿ
zIRBuilder.assignÚrvalueÚrtypec                 C  sN   t |ƒr t|jƒr |j ¡ }|dkrd}|  dd|› d |¡ |  |||¡S )NÚ	short_intrò   z1Incompatible value representations in assignment z(expression has type "z", variable has type "float"))r`   rd   r)  Ú
short_namera  rÚ   )rÊ   r²  r³  rØ   Útypenamer—   r—   r˜   r¦  Ì  s   

ÿýzIRBuilder.coerce_rvaluerw   c                 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)rN   rg  r0  r]   r«   r(  rƒ   r©  rú   ra   r)  r€   r$  rq  Úziprª  )rÊ   ræ   r²  rØ   Úexpected_lenr  r°  rš  rK  r±  rb  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)	rI   rä   rJ   rG  rë   rR   ÚVALUE_ERRORrV   rª  )rÊ   r¹  rº  rØ   rH  Ú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»  rM  r   ztoo many values to unpack)r(  r}   r˜  rg  r0  r~   rI   rä   rJ   rG  rë   rR   r¼  rV   rª  r‚   r/  rN   r  rP  Úreversedr   )rÊ   ræ   rl  rØ   ÚiteratorÚ	split_idxr¹  rº  rH  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 rT  )rÇ   rq  ro   )rÊ   rÈ  rÉ  r—   r—   r˜   Úpush_loop_stackG  s   ÿzIRBuilder.push_loop_stackc                 C  rß   rÓ   )rÇ   Úpoprà   r—   r—   r˜   Úpop_loop_stackL  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.rM  )r<   r»   r  r*   rÅ   rŽ  )rÊ   r)  r   ræ   r—   r—   r˜   Úmake_spill_targetO  s   zIRBuilder.make_spill_targetc                 C  s   |   |j¡}|  ||d¡ |S )rÍ  rL  )rÎ  r)  rª  )rÊ   rõ   ræ   r—   r—   r˜   ÚspillV  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Å   rŒ  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.
        rL  )rÅ   rŒ  rÏ  rÙ   rS   r)  rª  )rÊ   rõ   r¢  r—   r—   r˜   Úmaybe_spill_assignablei  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 )NrŒ   )rÙ   r   rõ   r)   râ   r_  )rÊ   rÒ  r—   r—   r˜   Úextract_int|  s
   
 
zIRBuilder.extract_intr_  c                 C  s   |   | j| ¡S rÓ   )Úget_sequence_type_from_typerž   ©rÊ   r_  r—   r—   r˜   Úget_sequence_type„  ré   zIRBuilder.get_sequence_typer0   c                   s^   t |ƒ}t|tƒrt ‡ fdd„|jD ƒ¡S t|tƒsJ |ƒ‚|jjdkr't	S ˆ  
|jd ¡S )Nc                   s   g | ]}ˆ   |¡‘qS r—   )rÕ  ©Ú.0rš  rà   r—   r˜   Ú
<listcomp>‹  s    z9IRBuilder.get_sequence_type_from_type.<locals>.<listcomp>zbuiltins.strr   )r5   rÙ   r4   r[   Úmake_simplified_unionr0  r-   r)  r  rh   r‹  r'  )rÊ   r  r—   rà   r˜   rÕ  ‡  s   
ÿz%IRBuilder.get_sequence_type_from_typeúlist[Instance]c                 C  s¢   t | j| ƒ}t|tƒrdd„ |jD ƒ}n|g}g }|D ]2}t|tƒr2|j}tdd„ |jj	D ƒƒ}nt|t
ƒs;J |ƒ‚tdd„ |jj	D ƒƒ}| t||ƒ¡ q|S )zpFind dict type of a dict-like expression.

        This is useful for dict subclasses like SymbolTable.
        c                 S  s   g | ]}t |ƒ‘qS r—   )r5   rØ  r—   r—   r˜   rÚ  š  s    z0IRBuilder.get_dict_base_type.<locals>.<listcomp>c                 s  ó    | ]
}|j d kr|V  qdS )ztyping.MappingN©r  ©rÙ  r  r—   r—   r˜   Ú	<genexpr>¢  ó   € z/IRBuilder.get_dict_base_type.<locals>.<genexpr>c                 s  rÝ  )zbuiltins.dictNrÞ  rß  r—   r—   r˜   rà  ¥  rá  )r5   rž   rÙ   r4   r0  r1   ÚfallbackÚnextr)  Úmror-   rq  r   )rÊ   r_  r  rž   Ú
dict_typesÚtÚ	dict_baser—   r—   r˜   Úget_dict_base_type“  s   

zIRBuilder.get_dict_base_typec                   sF   ˆ   |¡}t|ƒdkrˆ  |d jd ¡S ‡ fdd„|D ƒ}t |¡S )NrM  r   c                   ó   g | ]
}ˆ   |jd  ¡‘qS )r   ©r‹  r'  ©rÙ  ræ  rà   r—   r˜   rÚ  ®  ó    z/IRBuilder.get_dict_key_type.<locals>.<listcomp>©rè  rg  r‹  r'  r[   rÛ  ©rÊ   r_  Údict_base_typesr¯  r—   rà   r˜   Úget_dict_key_type©  ó
   

zIRBuilder.get_dict_key_typec                   sF   ˆ   |¡}t|ƒdkrˆ  |d jd ¡S ‡ fdd„|D ƒ}t |¡S )NrM  r   c                   ré  )rM  rê  rë  rà   r—   r˜   rÚ  ¶  rì  z1IRBuilder.get_dict_value_type.<locals>.<listcomp>rí  rî  r—   rà   r˜   Úget_dict_value_type±  rñ  zIRBuilder.get_dict_value_typec                 C  s    |   |¡}|  |¡}t||gƒS rÓ   )rð  rò  rY   )rÊ   r_  Úkey_typeÚ
value_typer—   r—   r˜   Úget_dict_item_type¹  s   

zIRBuilder.get_dict_item_typec                 C  s˜   || j vrttjƒ}nt| j | ƒ}| j| j  ¡ j}| 	d|g g |¡d }ddl
m} t|tƒrAtƒ }|jD ]}|||ƒ}q7|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+   r2   Ú
from_errorr5   r    rÌ   Útype_checkerÚexpr_checkerÚcheck_method_call_by_nameÚ	mypy.joinr÷  rÙ   r/   r3   r0  )rÊ   r_  ÚiterableÚechkrÀ  r÷  Újoinedrš  r—   r—   r˜   Ú_analyze_iterable_item_type¾  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Ê   r@  r—   r—   r˜   Úis_native_moduleÔ  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 )NFro  r   T)rÐ   r  r  Ú
rpartitionrÖ  r—   r—   r˜   Úis_native_ref_exprØ  s
   
zIRBuilder.is_native_ref_exprc                 C  s   |   |¡o	|jtkS rÓ   )r  rŠ  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Ê   rt  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.Enumro  )rÙ   r_  r!   rÐ   r'   Úgetr   r*   Úbasesr)  r  Úis_finalÚinfor  rÌ   Úis_module_member_exprr  )rÊ   r_  Ú	final_varÚsymÚexpr_fullnamer  r  Únativer—   r—   r˜   Úget_final_refæ  s&   	€


zIRBuilder.get_final_refr  r*   r  c                 C  sB   |j dur|  |j ¡S |rt| j|ƒ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)rp  rƒ  r6   r    ry  r¢   r‹  )rÊ   r  r  r   r  rt  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Ù   r_  r!   rÐ   r   rÖ  r—   r—   r˜   r    s   zIRBuilder.is_module_member_exprr   Úcalleec           
      C  s  |j r(|jtgt|ƒ kr(t|ƒ}t |g ¡}| j |||j	|  
|¡¡}|r(|S |j}t|tƒr3|j}t|tƒrG|j| jvrG|j| jv rG|j}|d urq|j rq|| jjv rqtdd„ |jD ƒƒrq| 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Ù  rŠ  r—   r—   r˜   rà  <  s   € z3IRBuilder.call_refexpr_with_args.<locals>.<genexpr>©r  r  )r  r  r   rg  Úget_call_target_fullnamer‡   r  r«   Úmatching_call_crØ   rÛ   rÐ   rÙ   r    Úimplr   r‡  rÃ   r¦   r¢   Úfunc_to_declÚallÚcallr  rÔ   r  )
rÊ   r_  r  r  r  Úcall_c_ops_candidatesræ   Úcallee_nodeÚdeclr  r—   r—   r˜   Úcall_refexpr_with_args  s8   ÿ
ÿÿÿ
ÿz IRBuilder.call_refexpr_with_argsr   c                   s2   ˆj  ˆ jˆ ˆ ¡‡ ‡fdd„‡ ‡fdd„ˆ j¡S )Nc                     ó   ˆ  ˆ j¡S rÓ   )rÔ   Úleftr—   ©r_  rÊ   r—   r˜   Ú<lambda>K  ó    z-IRBuilder.shortcircuit_expr.<locals>.<lambda>c                     r$  rÓ   )rÔ   Úrightr—   r&  r—   r˜   r'  L  r(  )r«   Úshortcircuit_helperrâ   rÛ   rØ   rÖ  r—   r&  r˜   Úshortcircuit_exprG  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  r0  r%   Úflatten_classesÚextend)rÊ   r,  ÚirrÞ   rš  Ú	item_partr—   r—   r˜   r0  R  s   


zIRBuilder.flatten_classesrª   rÅ   úFuncInfo | strc                 C  s°   t |tƒr
t|d}t| j| jƒ| _| j | j| j	¡ | j
 | j¡ | j i ¡ | j g ¡ || _| j | j¡ | j t¡ |jrI| j tƒ ¡ n| j tƒ ¡ |  tƒ ¡ d S )N©r   )rÙ   r   ri   rk   r¡   r¥   r«   rÎ   rÌ   rÍ   r¬   rq  r­   r®   rÅ   rÆ   r²   rf   rŒ  rÇ   rn   rm   rë   rI   )rÊ   rÅ   r—   r—   r˜   Úenteri  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 rT  )r¬   rË  r­   r®   r²   rÆ   rÇ   r«   rÅ   r'  rX  )rÊ   r«   r®   Úret_typerÅ   r—   r—   r˜   Úleavez  s   





zIRBuilder.leaver   r?   r8  Ú	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)
        rL  N)r6  r¯   rq  r°   r²   rX   Úadd_argumentr;   r9  rD   rË  rB   r   rÌ   rC   Úmethodsr"  Úmethod_declsr³   )rÊ   r   r   r8  rÅ   r:  Úarg_regsr'  rX  Úsigr"  r2  r—   r—   r˜   Úenter_method…  s8   €





ø



zIRBuilder.enter_methodrc  ú	str | VarrŠ  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_argrL  )rÙ   r   r*   Ú	add_localr®   rq  rE   r   )rÊ   rc  rt  rŠ  r¢  r—   r—   r˜   r<  ¯  s
   
zIRBuilder.add_argumentr•  r$   ÚSymbolTargetc                 C  s   | j d | S rT  ©r­   )rÊ   r•  r—   r—   r˜   r  º  rá   zIRBuilder.lookuprD  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
        )rD  rØ   rL  )rÙ   r$   rS   Úremangle_redefinition_namer   rØ   rv   r­   r«   r'  rq  )rÊ   r•  rt  rD  r¢  r—   r—   r˜   rE  ½  s   ÿzIRBuilder.add_localrv   c                 C  s.   |   |||¡ | jd | }t|tƒsJ ‚|S )zALike add_local, but return an assignment target instead of value.rL  )rE  r­   rÙ   rv   )rÊ   r•  rt  rD  ræ   r—   r—   r˜   r  Ì  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().
        TrC  )r  r*   r;   rX   )rÊ   rI  r—   r—   r˜   Úadd_self_to_envÕ  s   zIRBuilder.add_self_to_envc                 C  s   || j d |< |S rT  rG  )rÊ   r•  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   r_   rž   rg   r‹  )rÊ   rÐ   Ú	mypy_typer—   r—   r˜   rÛ   ã  s   



zIRBuilder.node_typeúFuncInfo | ImplicitClassr…  c                 C  sh   t |jƒ}|| jjj|< t|j|ƒ}|r.|  |  |¡| jj	j
¡}|  t|j||| jj	j
ƒ¡ |  ||¡S rÓ   )rH  r   rÅ   Ú	env_classÚ
attributesrt   Úcurr_env_regr£  r  r[  rØ   rä   rT   rK  )rÊ   rc  r³  r  r…  r   Úattr_targetr¢  r—   r—   r˜   r  ì  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 resolvedro  r   Úbuiltins)rÐ   r  ÚsplitrÖ  r—   r—   r˜   Úis_builtin_ref_exprÿ  s   "zIRBuilder.is_builtin_ref_exprr   c                 C  sr   |   |¡r|jsJ dƒ‚|  |jj|j¡S |  |¡r1t|jtƒr1|  |j¡s1|j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.
        rS  )rV  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Ó   )r‘  rö   r(  r{   )rÊ   r   rØ   Ú_globalsr¢  r—   r—   r˜   rX    s   
zIRBuilder.load_global_strc                 C  s   |   ttd| jƒ¡S )NÚglobals)rä   rP   r^   rÌ   rà   r—   r—   r˜   r‘    r  zIRBuilder.load_globals_dictc                 C  s(   |  d¡\}}}|  |¡}|  |||¡S ©Nro  )r  r%  rô   )rÊ   r  rØ   r@  Ú_r   r%  r—   r—   r˜   rW    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Û   r_  rÙ   rX   r   r¡  Úhas_attrr   Ú
get_method)rÊ   r_  Ú	obj_rtyper—   r—   r˜   r’  #  s   
ÿþüzIRBuilder.is_native_attr_refc                 C  s   d| j d< dS )zÌMark statements in the innermost block being processed as unreachable.

        This should be called after a statement that unconditionally leaves the
        block, such as 'break' or 'return'.
        FrL  N)r±   rà   r—   r—   r˜   Úmark_block_unreachable-  s   z IRBuilder.mark_block_unreachabler   c                 C  s   t | j|ƒS rÓ   )r=   rÍ   )rÊ   rØ   r—   r—   r˜   r=   6  rå   zIRBuilder.catch_errorsÚmsgc                 C  ó   | j  || j|¡ d S rÓ   )r¡   ÚwarningrÍ   ©rÊ   rb  rØ   r—   r—   r˜   rd  9  ó   zIRBuilder.warningc                 C  rc  rÓ   )r¡   ra  rÍ   re  r—   r—   r˜   ra  <  rf  zIRBuilder.errorc                 C  rc  rÓ   )r¡   ÚnoterÍ   re  r—   r—   r˜   rg  ?  rf  zIRBuilder.noteÚfunc_irrC   c                 C  sN   |j |jf}|| jv r|  d|d › d|¡ d S | j |¡ | j |¡ d S )NzDuplicate definition of "rM  z" not supported by mypyc)rm  r   rµ   ra  rä   r³   rq  )rÊ   rh  rØ   r   r—   r—   r˜   Úadd_functionB  s   
zIRBuilder.add_function)rœ   r   rž   rŸ   r    r   r¡   r>   r¢   rl   r£   rq   r¤   r’   r¥   rz   r¦   r§   r¨   r©   )rÌ   r   rÍ   r   r¨   r©   )rÐ   r   rÉ   rÑ   r¨   rW   )rÐ   r#   r¨   r©   )rÐ   rÖ   rÉ   rÑ   r¨   r×   )r¨   r©   )râ   rQ   r¨   rW   )ræ   rI   r¨   r©   )rê   rI   r¨   r©   )r¨   rS   )rð   rW   rñ   r   rØ   rò   r¨   rW   )rõ   r   r¨   rW   )rõ   rò   r¨   rW   )rõ   rû   r¨   rW   )rý   rW   rþ   r   rØ   rò   r¨   rW   )
rý   rW   r   rW   rþ   r   rØ   rò   r¨   rW   )F)
r  rW   r  rZ   rØ   rò   r  rÑ   r¨   rW   ©r¨   rW   )r  r  rØ   rò   r¨   rW   )NN)r  rW   r  r  rØ   rò   r  r  r  r  r¨   rW   )rõ   rW   r
  rI   r  rI   r¨   r©   )r  r   r¨   rW   )r  rW   r   r   r  r  r!  r"  rØ   rò   r  r  r  r#  r¨   rW   )r   r   r¨   rW   )r&  r†   r'  r  rØ   rò   r¨   rW   )r)  rZ   r*  rW   r+  rW   râ   rò   rØ   rò   r¨   rW   )
r*  rW   r+  rW   râ   r   rØ   rò   r¨   rW   )r.  rW   rØ   rò   r¨   rW   )r0  r  rØ   rò   r¨   rW   )
r2  r@   r3  r   r.  rW   rØ   rò   r¨   r©   )r7  r   rØ   rò   r¨   r©   )
r7  r   rØ   rò   r;  rI   r<  rI   r¨   r©   )r@  r   rØ   rò   r¨   rW   )r@  r   rñ   r   rØ   rò   r¨   rW   )ræ   rS   rE  rF  rØ   rò   r¨   r©   )
ræ   rS   rE  rF  rK  rò   rØ   rò   r¨   r©   )r]  r^  rØ   rò   r¨   r©   )r¨   rÑ   )r¨   ri  rÓ   )
rb  r   rl  rW   rm  rn  rk  r"  r¨   r©   )
r  r   rt  rZ   rØ   rò   ru  rn  r¨   rW   )rõ   rW   r   r   rØ   rò   r¨   r©   )r   r   rØ   rò   r¨   rW   )r.  r  r¨   rW   )rL  )rb  r   rØ   rò   r„  rÑ   r¨   rs   )rL  F)ræ   rœ  rØ   rò   rÉ   rÑ   r¨   rW   )ræ   r¤  rl  rW   rØ   rò   r¨   r©   )r²  rW   r³  rZ   rØ   rò   r¨   rW   )ræ   rw   r²  rW   rØ   rò   r¨   r©   )r¹  rs   rº  rW   rØ   rò   r¨   r©   )ræ   rw   rl  rW   rØ   rò   r¨   r©   )rÈ  rI   rÉ  rI   r¨   r©   )r)  rZ   r¨   rs   )rõ   rW   r¨   rs   )rõ   rW   r¨   rœ  )rõ   rW   r¨   r¤  )rÒ  r   r¨   rÓ  )r_  r   r¨   rZ   )r  r0   r¨   rZ   )r_  r   r¨   rÜ  )r_  r   r¨   r0   )r@  r   r¨   rÑ   )r_  r!   r¨   rÑ   )rt  r'   r¨   rÑ   )r_  r   r¨   r  )r  r*   r  r   r   r   r  rÑ   rt  r0   rØ   rò   r¨   r×   )r_  r   r¨   rÑ   )r_  r   r  r!   r  r  r¨   rW   )r_  r   r¨   rW   )r,  r-  r¨   r.  )rª   )rÅ   r4  r¨   r©   )r¨   r7  )rª   N)r   r?   r   r   r8  rZ   rÅ   r4  r:  r"  r¨   r;  )rc  rB  rt  rZ   rŠ  r   r¨   rS   )r•  r$   r¨   rF  )r•  r$   rt  rZ   rD  rÑ   r¨   rS   )r•  r$   rt  rZ   rD  rÑ   r¨   rv   )rI  r?   r¨   rv   )r•  r$   ræ   rF  r¨   rF  )rt  rL  r¨   rZ   )rÐ   r   r¨   rZ   )
rc  r$   r³  rZ   r  rN  r…  rÑ   r¨   rs   )r_  r   r¨   rW   )r  r   rØ   rò   r¨   rW   )rØ   rò   r¨   r   )rb  r   rØ   rò   r¨   r©   )rh  rC   rØ   rò   r¨   r©   )qr”   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  r6  r=  r:  rB  rD  rJ  rS  rW  rU  rV  rd  rh  rj  rs  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+  r0  r6  r9  r   rA  r   r<  r  rE  r  rJ  rK  r‹  rÛ   r  rV  rY  rX  r‘  rW  r’  ra  r=   rd  ra  rg  ri  r—   r—   r—   r˜   r›   ›   s   K		ú

ø		üúÿ
ÿÿJÿ#G+ú)ÿ	
ÿ
	r›   r«   r¨   r©   c                   s’   ˆj j‰d}ˆjD ]=‰ ˆ jrFˆ ˆ j¡‰d‡ ‡‡‡fdd„}tˆtƒs%J ‚ˆj}|j	j
s7ˆ ˆj|ˆ jj¡ q	ˆ ˆj||ˆ jj¡ |d7 }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   r¨   rW   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\  )Úinitializerry   rÔ   rÅ   Ú	is_nestedr  Úvariabler   r·   rq  r)  rä   rP   rÌ   Úcallable_classr2  rP  rL   Úself_regrØ   r5  ©r,  r«   r[  ræ   r—   r˜   Úget_defaultW  s   
ÿz%gen_arg_defaults.<locals>.get_defaultrM  Nrj  )rÅ   r[  Ú	argumentsrk  r  rm  rÙ   rv   rŸ  r)  Úerror_overlaprJ  rØ   rS  )r«   Únbrq  r¢  r—   rp  r˜   Úgen_arg_defaultsK  s    
ÿ€àru  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__)Úreplacer5  r—   r—   r˜   rH  v  s   rH  Úrefr!   c                 C  s0   t | jtƒrt| jjƒ}t |tƒr|jjS | jS rÓ   )rÙ   rÐ   r&   r5   ræ   r-   r)  r  )ry  ræ   r—   r—   r˜   r    s
   
r  Ú
typing_modrW   Ú	type_argsúlist[TypeParam]rØ   rò   r  c           	      C  sÞ   g }d}|D ]f}|j tkr|r|}n%|  |d|¡}|}n|j tkr)|  |d|¡}n|j tks0J ‚|  |d|¡}|j tkrS| j||  |j¡|  ¡ g|t	t
gddgd}n|  ||  |j¡g|¡}|  ||j|¡ | |¡ q|S )aR  Create objects representing various kinds of Python 3.12 type parameters.

    The "typing_mod" argument is the "_typing" module object. The type objects
    are looked up from it.

    The returned list has one item for each "type_args" item, in the same order.
    Each item is either a TypeVar, TypeVarTuple or ParamSpec instance.
    NÚTypeVarÚTypeVarTupleÚ	ParamSpecÚinfer_variancer  )rŠ  r   rô   r   r   r  rö   r   r
  r   r   r}  rq  )	r«   rz  r{  rØ   ÚtvsÚtype_var_importedÚ
type_paramÚtvtÚtvr—   r—   r˜   Úcreate_type_paramsŠ  s0   


ûr†  )r«   r›   r¨   r©   )r   r   r¨   r   )ry  r!   r¨   r   )
r«   r›   rz  rW   r{  r|  rØ   rò   r¨   r  )±Ú__doc__Ú
__future__r   Ú
contextlibr   Útypingr   r   r   r   r   r	   Útyping_extensionsr
   Ú
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%   r&   r'   r(   r)   r*   Ú
mypy.typesr+   r,   r-   r.   r/   r0   r1   r2   r3   r4   r5   Ú	mypy.utilr6   r7   Úmypy.visitorr8   r9   Úmypyc.commonr:   r;   r<   Úmypyc.crashr=   Úmypyc.errorsr>   Úmypyc.ir.class_irr?   r@   Úmypyc.ir.func_irrA   rB   rC   rD   rE   Úmypyc.ir.opsrF   rG   rH   rI   rJ   rK   rL   rM   rN   rO   rP   rQ   rR   rS   rT   rU   rV   rW   Úmypyc.ir.rtypesrX   rY   rZ   r[   r\   r]   r^   r_   r`   ra   rb   rc   rd   re   rf   rg   rh   Úmypyc.irbuild.contextri   rj   Úmypyc.irbuild.ll_builderrk   Úmypyc.irbuild.mapperrl   Úmypyc.irbuild.nonlocalcontrolrm   rn   ro   rp   Úmypyc.irbuild.prebuildvisitorrq   Úmypyc.irbuild.preparerr   Úmypyc.irbuild.targetsrs   rt   ru   rv   rw   Úmypyc.irbuild.utilrx   ry   Úmypyc.optionsrz   Úmypyc.primitives.dict_opsr{   r|   Úmypyc.primitives.generic_opsr}   r~   r   Úmypyc.primitives.list_opsr€   r   r‚   Úmypyc.primitives.misc_opsrƒ   r„   r…   Úmypyc.primitives.registryr†   r‡   r   Ú__annotations__r’   Ú	Exceptionrš   rF  r›   ru  rH  r  r†  r—   r—   r—   r˜   Ú<module>   sd     €4 PL         
9
+
	