
    X-Ph                       U d Z ddlmZ ddlmZ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 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<m=Z= dd
l>m?Z?m@Z@ ddlAmBZBmCZC ddlDmEZEmFZFmGZG ddlHmIZI ddlJmKZK ddlLmMZMmNZN ddlOmPZPmQZQmRZRmSZSmTZT ddlUmVZVmWZWmXZXmYZYmZZZm[Z[m\Z\m]Z]m^Z^m_Z_m`Z`maZambZbmcZcmdZdmeZemfZfmgZgmhZh ddlimjZjmkZkmlZlmmZmmnZnmoZompZpmqZqmrZrmsZsmtZtmuZumvZvmwZwmxZxmyZymzZz ddl{m|Z|m}Z} ddl~mZ ddlmZ ddlmZmZmZmZ ddlmZ ddlmZ ddlmZmZmZmZmZ ddlmZmZ ddlmZ ddlmZmZ ddlmZmZmZ ddlmZmZmZ ddlmZmZmZ dd lmZmZ h d!Zd"ed#<    G d$ d%eBeh         eCd&                   Z G d' d(e          Zeeef         Z G d) d*          ZdDd.ZdEd1ZdFd4ZdGd<ZdHdCZd&S )IzrBuilder class to transform a mypy AST to the IR form.

See the docstring of class IRBuilder for more information.
    )annotations)IteratorSequence)contextmanager)AnyCallableFinal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TypeVarLikeType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PrimitiveDescription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__     U/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/mypyc/irbuild/builder.pyr   r              Dr   r   Nc                      e Zd ZdS )UnsupportedExceptionNr   r   r   r   r   r      r   r   r   c                  ,   e Zd ZdZddZddZedddd!            Zedd#            Zdddd&Zdd'Zdd*Z	dd-Z
dd/Zdd0Zdd2Zdd7Zdd9Zdd:Zdd;Zd d=Zd!d@Zd"dBZd#d$dGZd%dHZd%dIZd%dJZd%dKZd&dNZd&dOZd"dPZ	 	 d'd(dXZd)d[Zd*d]Z	 	 d'd+dcZ d,ddZ!d-dhZ"	 d.d/djZ#d0dnZ$d1doZ%d2dqZ&d3dsZ'd4dvZ(d5dzZ)d6d|Z*d7dZ+d8dZ,d9dZ-d:dZ.d;dZ/ddZ0ddZ1ddZ2d<dZ3d=dZ4d>dZ5	 d.dQdd?dZ6	 d.d@dZ7dAdZ8dBdZ9dCdZ:	 dDdddEdZ;	 dFdGdZ<dHdZ=dIdZ>dJdZ?dKdZ@dLdZAdMdZBddZCdNdZDdOdZEdPdZFdQdZGdRdZHdSdZIdTdZJdUdZKdVdÄZLdSdĄZMdSdńZNdSdƄZOdWdǄZPdXdȄZQdYdʄZRdYd˄ZSdZd̈́ZTd[dЄZUd\dԄZVd]dՄZWd^d؄ZXd_dڄZYd`dބZZdae[ddbdZ\dcdZ]e^	 	 ddded            Z_e`fdfdZadgdZbd#dhdZc	 d#didZddjdZedkdZfdldZgdmdZh	 d#dndZidYdZjdodZkdBdZld%dZmdpdZnd]dZodd	ZpdqdZqdrdZrdrdZsdrdZtdsdZudQS (t  	IRBuilderah  Builder class used to construct mypyc IR from a mypy AST.

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

    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.

    Use the "accept()" method to translate individual mypy AST nodes to IR.
    Other methods are used to generate IR for various lower-level operations.

    This class wraps the lower-level LowLevelIRBuilder class, an instance
    of which is available through the "builder" attribute. The low-level
    builder class doesn't have any knowledge of the mypy AST. Wrappers for
    some LowLevelIRBuilder method are provided for convenience, but others
    can also be accessed via the "builder" attribute.

    See also:
     * The mypyc IR is defined in the mypyc.ir package.
     * The top-level IR transform control logic is in mypyc.irbuild.main.
    current_modulestrtypesdict[Expression, Type]graphr   errorsr@   mapperro   pbvrt   visitorr   optionsr}   singledispatch_impls%dict[FuncDef, list[RegisterImplInfo]]returnNonec
                   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        | _        |	| _         || _!        tE          tF          dd          | _$        | j$        g| _%        g | _&        || _'        i | _(        d| _)        d S )NTr    F)*rn   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   rl   rC   fn_infofn_infosnonlocal_controlr   imports
can_borrow)
selfr   r   r   r   r   r   r   r   r   s
             r   __init__zIRBuilder.__init__   sg    )99@Bt57D.0 -/ 37",

&(');>55&(46)+.1ee!
   "0,#&#:  -2244#&#: $'$<!$8!   0"b99)- 8: )+r   module_namemodule_pathc                X    || _         || _        | 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   s      r   r   zIRBuilder.set_module   s2    
 '&[99999r   Fr   noder   r   boolrZ   c                   d S Nr   )r   r   r   s      r   acceptzIRBuilder.accept  s    NQcr   r$   c                    d S r   r   )r   r   s     r   r   zIRBuilder.accept  s    /2sr   Statement | ExpressionValue | Nonec               \   |                      |j                  5  t          |t                    r| j        }|| _        	 |                    | j                  }|                     ||                     |          |j                  }n2# t          $ r% t          |                     |                    }Y nw xY w|| _        |s|                                  |cddd           S 	 |                    | j                   n# t          $ r Y nw xY w	 ddd           dS # 1 swxY w 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   rV   flush_keep_alives)r   r   r   old_can_borrowress        r   r   zIRBuilder.accept  s    ty)) 	 	$
++ !%",9++dl33C++c4>>$+?+?KKCC
 , 9 9 9"4>>$#7#788CCC9"0! -**,,,!	 	 	 	 	 	 	 	$KK----+   D-	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	sZ   $D! A	B
	D!
,B96D!8B99!D!(DD!
DD!DD!!D%(D%c                8    | j                                          d S r   )r   r   r   s    r   r   zIRBuilder.flush_keep_alives'  s    &&(((((r   oprS   c                6    | j                             |          S r   )r   add)r   r   s     r   r   zIRBuilder.add,  s    |###r   targetrK   c                :    | j                             |           d S r   )r   goto)r   r   s     r   r   zIRBuilder.goto/  s    &!!!!!r   blockc                :    | j                             |           d S r   )r   activate_blockr   r   s     r   r   zIRBuilder.activate_block2  s    ##E*****r   c                :    | j                             |           d S r   )r   goto_and_activater   s     r   r   zIRBuilder.goto_and_activate5  s    &&u-----r   rV   c                4    | j                                         S r   )r   r   r   s    r   r   zIRBuilder.self8      |  """r   objattrr   intc                :    | j                             |||          S r   )r   py_get_attr)r   r   r   r   s       r   r   zIRBuilder.py_get_attr;  s    |''T4888r   valuec                6    | j                             |          S r   )r   load_strr   r   s     r   r   zIRBuilder.load_str>      |$$U+++r   c                P    | j                             t          |                    S )zLoad 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_bytesr{   r   s     r   load_bytes_from_str_literalz%IRBuilder.load_bytes_from_str_literalA  s"     |&&~e'<'<===r   c                6    | j                             |          S r   )r   load_intr   s     r   r  zIRBuilder.load_intJ  r  r   floatc                6    | j                             |          S r   )r   
load_floatr   s     r   r	  zIRBuilder.load_floatM  s    |&&u---r   lregexpr_opc                :    | j                             |||          S r   )r   unary_op)r   r
  r  r   s       r   r  zIRBuilder.unary_opP  s    |$$T7D999r   rregc                <    | j                             ||||          S r   )r   	binary_opr   r
  r  r  r   s        r   r  zIRBuilder.binary_opS  s    |%%dD'4@@@r   srctarget_typer]   forcec                J    | j                             ||||| j                  S )Nr   )r   r   r   )r   r  r  r   r  s        r   r   zIRBuilder.coerceV  s%    |""3T5T_"]]]r   c                4    | j                                         S r   )r   none_objectr   s    r   r  zIRBuilder.none_objectY  s    |'')))r   c                4    | j                                         S r   )r   noner   s    r   r  zIRBuilder.none\  r   r   c                4    | j                                         S r   )r   truer   s    r   r  zIRBuilder.true_  r   r   c                4    | j                                         S r   )r   falser   s    r   r  zIRBuilder.falseb  s    |!!###r   valueslist[Value]c                8    | j                             ||          S r   )r   new_list_opr   r  r   s      r   r!  zIRBuilder.new_list_ope  s    |''555r   c                8    | j                             ||          S r   )r   
new_set_opr"  s      r   r$  zIRBuilder.new_set_oph  s    |&&vt444r   c                <    | j                             ||||          S r   )r   translate_is_opr  s        r   r&  zIRBuilder.translate_is_opk  s    |++D$FFFr   Nfunction
arg_values	arg_kindslist[ArgKind] | None	arg_namesSequence[str | None] | Nonec                >    | j                             |||||          S r   )r   py_call)r   r'  r(  r   r)  r+  s         r   r.  zIRBuilder.py_calln  s"     |##Hj$	9UUUr   r  r  c                >    | j                             |||           d S r   )r   add_bool_branch)r   r   r  r  s       r   r0  zIRBuilder.add_bool_branchx  s"    $$UD%88888r   fullnamec                6    | j                             |          S r   )r   load_native_type_object)r   r1  s     r   r3  z!IRBuilder.load_native_type_object{  s    |33H===r   basenameresult_typeRType | Nonelist[str | None] | Nonec           
     N    | j                             |||||||| j                  S r   )r   gen_method_callr   )r   r4  r5  r(  r6  r   r)  r+  s           r   r:  zIRBuilder.gen_method_call~  s1     |++$
Ky)T_
 
 	
r   c                6    | j                             |          S r   )r   load_module)r   r5  s     r   r<  zIRBuilder.load_module  s    |''---r   descr   argsc                :    | j                             |||          S r   )r   call_c)r   r=  r>  r   s       r   r@  zIRBuilder.call_c  s    |""4t444r   rT   c                <    | j                             ||||          S r   )r   primitive_op)r   r=  r>  r   r6  s        r   rB  zIRBuilder.primitive_op  s      |((tT;GGGr   typelhsrhsc                >    | j                             |||||          S r   )r   int_op)r   rC  rD  rE  r   r   s         r   rG  zIRBuilder.int_op  s     |""4c2t<<<r   c                <    | j                             ||||          S r   )r   compare_tuples)r   rD  rE  r   r   s        r   rI  zIRBuilder.compare_tuples  s    |**3R>>>r   valc                8    | j                             ||          S r   )r   builtin_len)r   rJ  r   s      r   rL  zIRBuilder.builtin_len  s    |''T222r   itemsc                8    | j                             ||          S r   )r   	new_tuple)r   rM  r   s      r   rO  zIRBuilder.new_tuple  s    |%%eT222r   toprintstr | Valuec                6    | j                             |          S r   )r   debug_print)r   rP  s     r   rS  zIRBuilder.debug_print  s    |''000r   non_extrB   keyc                x    |                      |          }|                     t          |j        ||g|           d S r   )r   rB  r   dict)r   rT  rU  rJ  r   key_unicodes         r   add_to_non_ext_dictzIRBuilder.add_to_non_ext_dict  s=     mmC((*W\;,LdSSSSSr   idc                   d | j         |<   t                      t                      }}|                     ||||           |                     |           |                     t
          |                     |          g|          }|                     t          ||t                               | 
                    |           d S )N	namespace)r   rK   check_if_module_loadedr   r@  r   r   r   rO   rH   r   )r   rZ  r   needs_importoutr   s         r   
gen_importzIRBuilder.gen_import  s    R&LL*,,c##BlC@@@L)))Ib(9(9':DAAE21ABBBCCCs#####r   r_  r`  c                    |                      |          }|                     ||                                 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  r0  )r   rZ  r   r_  r`  
first_load
comparisons          r   r^  z IRBuilder.check_if_module_loaded  s[     %%b))
))*d6F6F6H6H(TXYY
Zl;;;;;r   modulec                    |                      t          g |          }|                     t          ||                     |          g|          S r   )r@  r   rB  r~   r   )r   re  r   mod_dicts       r   
get_modulezIRBuilder.get_module  sC    ;;12t<<  !1HdmmF>S>S3TVZ[[[r   c                    |                      ||           |                     ||          }|                     |||          S )zLook 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.
        )ra  rh  r   )r   re  r   r   
module_objs        r   get_module_attrzIRBuilder.get_module_attr  sC     	%%%__VT22

D$777r   get_valCallable[[], Value]c           
        t                      t                      }}|                     t          |||t          j                             |                     |           |                     t          ||                      |            |j        |                               |                     |           |                     |           dS )z:If target is NULL, assign value produced by get_val to it.N)	rK   r   rL   IS_ERRORr   rJ   r   rC  r   )r   r   rl  r   error_block
body_blocks         r   assign_if_nullzIRBuilder.assign_if_null  s    ",,,
ZZIIJJJK(((GGIIv{D I IJJKKK		*J'''''r   indexc           
        t                      t                      }}|                     t          | j        j        d|t
          z  z
           t          d|t
          dz
  z  z  t                    t          j        |          }| 	                    t          |t          dt                    t          j                            }| 	                    t          |||t          j                             |                     |           | 	                    t          ||                      |            |j        |                               |                     |           |                     |           d S )N   r   )rK   rG  r_   r   r>  r<   rP   rQ   ANDr   rM   EQrL   BOOLr   rJ   r   rC  r   )	r   r   rl  rs  r   rp  rq  obs	            r   assign_if_bitmap_unsetz IRBuilder.assign_if_bitmap_unset  s(    #-,,
ZKKLb5K#778A%;?346GHHI
 
 HH\!WQ0A%B%BLOTTUU;
FK@@AAAK(((GGIIv{D I IJJKKK		*J'''''r   c                    t          | j        d                   st          | j        d                   r|                                  d S |                                  d S Nru  )re   r   rf   add_implicit_returnadd_implicit_unreachabler   s    r   maybe_add_implicit_returnz#IRBuilder.maybe_add_implicit_return  sa    dnR011 	,5I$.Y[J\5]5] 	,$$&&&&&))+++++r   c                   | j         j        d         }|j        sl|                     | j                                         | j        d         d          }| j        d                             | || j        j	        j
                   d S d S r~  )r   blocks
terminatedr   r  r   r   
gen_returnr   fitemr   )r   r   retvals      r   r  zIRBuilder.add_implicit_return  s    #B' 	X[[!2!2!4!4dnR6H"MMF!"%00vt|?Q?VWWWWW	X 	Xr   c                ~    | j         j        d         }|j        s#|                     t	                                 d S d S r~  )r   r  r  r   rY   r   s     r   r  z"IRBuilder.add_implicit_unreachable  sB    #B' 	$HH[]]#####	$ 	$r   lvalueslist[Lvalue]c                H   |D ]}t          |t                    rt          |j        t                    rmt          |j        j        t
                    rN|j        j        |j                 j        }t          |t                    r|j        s| 	                    d|           d S )Nz;Only class variables defined as ClassVar can be assigned to)
r   r   exprr"   r   r(   r5  r+   is_classvarerror)r   r  r   lvaluevars        r   disallow_class_assignmentsz$IRBuilder.disallow_class_assignments
  s    
  	d 	dF6:..dv{G44d v{/::d
 k&v{38c3'' d dJJ\^bccc	d 	dr   c                2    t          | j                  dk    S N   )lenr   r   s    r   non_function_scopezIRBuilder.non_function_scope  s    4=!!Q&&r   FuncInfo | Nonec                H    |                                  rd S | j        d         S r  )r  r   r   s    r   top_level_fn_infozIRBuilder.top_level_fn_info  s(    ""$$ 	4}Qr   )type_overrider  r   
rvalue_reg
class_name
str | Noner  c                  t          |t                    sJ t          |j        t                    sJ |j        j        ||j        }n| d|j         }|
J d            |                     ||p|                     |          |j                  }| j	        
                    ||j        f           |                     t          ||| j                             d S d S )N.zFull name not set for variable)r   r   r   r+   final_valuer5  r   r   r   r   appendrC  r   rO   r   )r   r  r  r  r  r5  coerceds          r   init_final_staticzIRBuilder.init_final_static"  s     &(+++++&+s+++++;"*!{$44v{44##%E###kk*m.Ut~~f?U?UW]WbccG##T7<$8999HHZt/?@@AAAAA +*r   typ
error_namec           	         t          | j        |          }|J |\  }}| j                            ||||d| d          S )Nzvalue for final name "z" was not set)r   	error_msg)r9   r   r   load_static_checked)r   r1  r  r   r  
split_namere  r5  s           r   load_final_staticzIRBuilder.load_final_static6  sc     "$*h77
%%%!|//HzHHH 0 
 
 	
r   c                    |dz   t          |          z   }| j                            |           |                     t	          ||| j        t                               d S N___r\  )r   r   r  r   rO   r   rI   )r   r   r5  r   unique_names        r   init_type_varzIRBuilder.init_type_varD  sZ    UlSYY."";///E;0@L^___`````r   c           	         |                      t          t          |dz   t          |          z   | j        t
                              S r  )r   rR   rj   r   r   rI   )r   r5  r   s      r   load_type_varzIRBuilder.load_type_varI  sH    xx!us4yy( ,	  
 
 	
r   *int | str | bytes | float | complex | boolc                j   t          |t                    r*|r|                                 S |                                 S t          |t                    r| j                            |          S t          |t                    r| j                            |          S t          |t                    r| j        
                    |          S t          |t                    r| j                            |          S t          |t                    r| 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   rJ  s     r   load_literal_valuezIRBuilder.load_literal_valueS  s   c4   	6 $yy{{"zz||#S!! 	6<((---U## 		6<**3///S!! 	6<((---U## 	6<**3///W%% 	6<,,S11155555r   ru  )for_readr  rv   c                  |dk    r|j         }t          |t                    r|j        }t          |t                    r|j        }||j        sJ t          |j                  }|s2t          |t                    r|j	        r| 
                    d|           |j        t          k    r|| j        d         vrt          |t                    r5t          |j        t                    s|                     |j                  }n|                     |          }| j        j        r#|                     ||| j        j        d          S |                     ||          S |                     |          S |j        t0          k    r>|                                 }|                     |j                  }t7          ||          S J |j                    t          |t8                    rD|                     |j                  }|                     |j                  }	t7          ||	          S t          |t@                    rH| !                    |          }
|                     |j"        |
          }tG          ||j        |
          S t          |tH                    rd }g }tK          |j&                  D ]^\  }}| '                    |          }|(                    |           t          |tR                    r|| 
                    d|           |}_tU          ||          S t          |tR                    r| '                    |j"                  S J d|z              )Nru  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+   r5  is_clsr  kindr   r   rC  r-   type_to_rtyper   r   is_generatoradd_var_to_env_classgenerator_classadd_local_reglookupr   load_globals_dictr   rx   r   r   r4  rs  r   is_native_attr_refr  rw   r&   	enumeraterM  get_assignment_targetr  r#   rz   )r   r  r   r  symbolreg_typeglobals_dictr5  r4  rs  r   r   star_idxr  idxitemtargs                    r   r  zIRBuilder.get_assignment_targetg  sC    2::;Dfh'' @	; [F&),, %~----V[)) W
63 7 7 WFM W

OQUVVV{d""!333!&#.. :z&+{7[7[ :#'#5#5fk#B#B#'>>&#9#9 |0 #88"Hdl.JUZ  9     
  --fh???  ;;v...$$#5577}}V[11,\4@@@)fk)))	** 	;;;v{++DKK--E(u555
++ 	;0088J++fkj+AAC'V[ZPPPP	** 	;#'HG&v|44 # #	T11$77t$$$dH-- #+

#JDQQQ"H((;;;)) 	;--fk:::7.7777r   Value | AssignmentTargetc                v   t          |t                    r|S t          |t                    r|j        S t          |t                    rA|                     |j        d|j        g|j        |          }||S J |j        j                    t          |t                    rt          |j
        j        t                    rO|j
        j        j        j        r9|o|j        }|                     t!          |j
        |j        ||                    S |                     |j
        |j        |          S J d|z              )N__getitem__F)borrowr  )r   rZ   ry   registerrx   r:  r4  rs  rC  rw   r   r[   class_iris_ext_classr   r   rN   r   r   )r   r   r   r   regr  s         r   readzIRBuilder.read  s1    fe$$ 	Mf677 	#?"f344 	+&&]V\NFK C 
*&+****f233 	G&*/955 G&*/:R:_ G#9(9xx
FKf U U UVVV''
FKFFF7.7777r   Register | AssignmentTargetc           
     (   t          |t                    r?|                     t          ||                     ||j        |                               d S t          |t                    rF|                     ||j        |          }|                     t          |j        |                     d S t          |t                    rt          |j	        t                    rM|                     ||j        |          }|                     t          |j        |j        ||                     d S |                     |j                  }| j                            |          }|                     t$          |j        ||g|           d S t          |t&                    r=|                     |j        d|j        |gd |          }|J |j        j                    d S t          |t.                    rt          |j        t0                    r|j        |j        j        }t7          |          t7          |j                  k    sJ t;          t7          |                    D ]H}|                     t=          |||                    }	|                     |j        |         |	|           Id S tA          |j                  stC          |j                  r |j        | "                    |||           d S | #                    |||           d S J d            )N__setitem__FzUnsupported assignment target)$r   rV   r   rJ   coerce_rvaluerC  ry   r  rw   obj_typer[   rW   r   r   r   r   boxrB  r   rx   r:  r4  rs  rz   r\   r  r   r  rM  rangerX   assignrd   rh   process_sequence_assignment!process_iterator_tuple_assignment)
r   r   r  r   rU  	boxed_regtarget_reg2rtypesi
item_values
             r   r  zIRBuilder.assign  s   fh''  	:HHVFD$6$6z6;PT$U$UVVWWWWW 899 	:++JTJJJHHVFOZ8899999 455 	:&/955 U!//
FKNN
V[*dKKLLLLLmmFK00 L,,Z88	!!-&*c91MtTTTTT 566 	:..]V\:,Fd K **FK,<***** 566 	:*/622 Qv7N#.6{{c&,&7&77777s6{{++ C CA!%(:q$*G*G!H!HJKKQTBBBBC C #:?33Q7J:?7[7[Q/)00TJJJJJ66vz4PPPPP99999r   rvaluertypec                    t          |          rRt          |j                  r>|j                                        }|dk    rd}|                     dd| dz   |           |                     |||          S )N	short_intr   z1Incompatible value representations in assignment z(expression has type "z", variable has type "float"))rc   rg   rC  
short_namer  r   )r   r  r  r   typenames        r   r  zIRBuilder.coerce_rvalue  s    u%% 	)FK*@*@ 	{--//H;&& JJCR8RRRS  
 {{65$///r   rz   c                p   t          t          |j                  t                    }| j                            t          ||g|           g }t          t          |j                            D ]}|j        |         }| j                            |          }t          |j
                  r|                     t          ||g|          }	n$| j                            |d|g|j
        |          }	|                    |	           t          |j        |          D ]\  }
}|                     |
||           dS )zOProcess assignment like 'x, y = s', where s is a variable-length list or tuple.r  N)rP   r  rM  r`   r   r@  r   r  r  rd   rC  rB  r   r:  r  zipr  )r   r   r  r   expected_lenr  r  r  rs  r  r  r   s               r   r  z%IRBuilder.process_sequence_assignment  s9   
 s6<002HII1FL3I4PPP s6<(()) 		& 		&A<?DL))!,,E!&+.. !../FQVY]^^

!\99ME7DIt 
 MM*%%%% !v66 	- 	-MFEKKt,,,,	- 	-r   litemritemc                   t                      t                      }}|                     t          |||t          j                             |                     |           |                     t          t
          j        d|                     |                     t                                 |                     |           |                     |||           d S )Nnot enough values to unpack)	rK   r   rL   ro  r   rU   VALUE_ERRORrY   r  )r   r  r  r   rp  ok_blocks         r   (process_iterator_tuple_assignment_helperz2IRBuilder.process_iterator_tuple_assignment_helper  s     !+jllX{HfoFFGGGK(((1=?\^bcc	
 	
 	
 	H%%%E5$'''''r   c           	        |                      t          |g|          }|j        |j        nt          |j                  }|j        d |         D ]}|                     t          |g|          }t                      t                      }	}|                     t          |||	t          j
                             |                     |           |                     t          t          j        d|                     |                     t                                 |                     |	           |                     |||           |j        |j        |dz   d          }
|                      t           |g|          }|                     ||          }t%          t          |
                    }|                     ||d|          }t                      t                      }	}|                     t          ||	|t          j                             |                     |           |                     t          t          j        d|                     |                     t                                 |                     |	           t+          |
          D ]6}|                      t,          |g|          }|                     |||           7|                     |j        |j                 ||           d S |                     t          |g|          }t                      t                      }	}|                     t          ||	|t          j
                             |                     |           |                     t          t          j        d|                     |                     t                                 |                     |	           d S )Nr  rv  r   ztoo many values to unpack)rB  r   r  r  rM  r@  r   rK   r   rL   ro  r   rU   r  rY   r  r   rL  rP   r  ry  reversedr   )r   r   r  r   iterator	split_idxr  r  rp  r  post_star_vals	iter_listiter_list_lenpost_star_len	conditionextras                   r   r  z+IRBuilder.process_iterator_tuple_assignment  st    $$WzlDAA (.'BFOOFLHYHY	 \*9*- 	, 	,EKK(T::E$.LL*,,KHHVE;&/JJKKK,,,HH"&24QSW   
 HH[]]###)))KKud++++ ?&#\)a-//:N))'H:tDDI ,,Y==M#C$7$788M}mT4PPI$.LL*,,KHHVIxfkJJKKK,,,HH"&24QSW   
 HH[]]###)))!.11 0 0))-)dKKE5$//// KKV_5y$GGGGG
 KK(T::E$.LL*,,KHHVE8[&/JJKKK,,,HH"&24OQU   
 HH[]]###)))))r   continue_blockbreak_blockc                n    | j                             t          | j         d         ||                     d S r~  )r   r  rr   )r   r  r  s      r   push_loop_stackzIRBuilder.push_loop_stacke  s>    $$ 5b 9>;WW	
 	
 	
 	
 	
r   c                8    | j                                          d S r   )r   popr   s    r   pop_loop_stackzIRBuilder.pop_loop_stackj  s    !!#####r   c                    t            | j         }| xj        dz  c_        |                     t          |          || j        j                  }|S )IMoves a given Value instance into the generator class' environment class.rv  )r>   r   r  r+   r   r  )r   rC  r5  r   s       r   make_spill_targetzIRBuilder.make_spill_targetm  sP     5$"355Q**3t99dDL<XYYr   c                h    |                      |j                  }|                     ||d           |S )r  ru  )r  rC  r  )r   r   r   s      r   spillzIRBuilder.spillt  s2    ''
33FE2&&&r   c                H    | 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   s     r   maybe_spillzIRBuilder.maybe_spill{  s(     <$ 	%::e$$$r   c                    | 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.
        ru  )r   r  r  r   rV   rC  r  )r   r   r  s      r   maybe_spill_assignablez IRBuilder.maybe_spill_assignable  sf     <$ 	%::e$$$eX&& 	L uz""C###
r   e
int | Nonec                    t          |t                    r|j        S t          |t                    r2|j        dk    r't          |j        t                    r|j        j         S d S )Nr   )r   r   r   r*   r   r  )r   r  s     r   extract_intzIRBuilder.extract_int  sX    a!! 	7N9%% 	!$#++*QVW:U:U+FL= 4r   r  c                B    |                      | j        |                   S r   )get_sequence_type_from_typer   r   r  s     r   get_sequence_typezIRBuilder.get_sequence_type  s    //
40@AAAr   r1   c                    t          |          }t          |t                    r%t          j         fd|j        D                       S t          |t                    r7|j        j        dk    rt          S  
                    |j        d                   S t          |t                    r                     |j                  S t          |t                    r[ fd|j        D             }t!          |          dk    r|                                S t          j        t%          |                    S J |            )Nc                :    g | ]}                     |          S r   )r  .0r  r   s     r   
<listcomp>z9IRBuilder.get_sequence_type_from_type.<locals>.<listcomp>  s'    VVVD11$77VVVr   zbuiltins.strr   c                D    h | ]}j                             |          S r   r   r  r  s     r   	<setcomp>z8IRBuilder.get_sequence_type_from_type.<locals>.<setcomp>  s)    TTT$dk//55TTTr   rv  )r7   r   r6   r^   make_simplified_unionrM  r.   rC  r1  rk   r  r>  r4   r  upper_boundr0   r  r  list)r   r  r  s   `  r   r  z%IRBuilder.get_sequence_type_from_type  s7   %k22k9-- 	B/VVVVKDUVVV   X.. 	B(N::%%))+*:1*=>>>_55 	B33K4KLLLY// 	BTTTT+BSTTTF6{{azz||#3DLLAAA!k!!!r   list[Instance]c                B    |                      | j        |                   S )zpFind dict type of a dict-like expression.

        This is useful for dict subclasses like SymbolTable.
        )get_dict_base_type_from_typer   r  s     r   get_dict_base_typezIRBuilder.get_dict_base_type  s    
 00D1ABBBr   c                    t          |          }t          |t                    r fd|j        D             S t          |t                    r                     |j                  S t          |t                    r+|j        }t          d |j
        j        D                       }nFt          |t                    r$t          d |j
        j        D                       }nJ d|             t          ||          gS )Nc                D    g | ]}                     |          D ]}|S r   )r(  )r  r  innerr   s      r   r  z:IRBuilder.get_dict_base_type_from_type.<locals>.<listcomp>  sN       !>>tDD      r   c              3  0   K   | ]}|j         d k    |V  dS )ztyping.MappingNr1  r  r4  s     r   	<genexpr>z9IRBuilder.get_dict_base_type_from_type.<locals>.<genexpr>  s8        JZ9Z9Z9Z9Z9Z9Z r   c              3  0   K   | ]}|j         d k    |V  dS )zbuiltins.dictNr.  r/  s     r   r0  z9IRBuilder.get_dict_base_type_from_type.<locals>.<genexpr>  s7        /9Y9Y9Y9Y9Y9Y r   Fz!Failed to extract dict base from )r7   r   r6   rM  r4   r(  r$  r2   fallbacknextrC  mror.   r   )r   r  	dict_bases   `  r   r(  z&IRBuilder.get_dict_base_type_from_type  sA   %k22k9-- 	   '-   
 k?33 	N 44[5LMMMk=11 
	L%.K  !,!1!5    II X.. 	L  !,!1!5    II LKkKKKKK)+yAABBr   c                r                           |          } fd|D             }t          j        |          S )Nc                P    g | ]"}                     |j        d                    #S )r   r  r>  r  tr   s     r   r  z/IRBuilder.get_dict_key_type.<locals>.<listcomp>  -    IIIA$$$QVAY//IIIr   r)  r^   r#  r   r  dict_base_typesr  s   `   r   get_dict_key_typezIRBuilder.get_dict_key_type  @    11$77IIIIIII+F333r   c                r                           |          } fd|D             }t          j        |          S )Nc                P    g | ]"}                     |j        d                    #S )rv  r8  r9  s     r   r  z1IRBuilder.get_dict_value_type.<locals>.<listcomp>  r;  r   r<  r=  s   `   r   get_dict_value_typezIRBuilder.get_dict_value_type  r@  r   c                x    |                      |          }|                     |          }t          ||g          S r   )r?  rC  r\   )r   r  key_type
value_types       r   get_dict_item_typezIRBuilder.get_dict_item_type  s;    ))$//--d33
x,---r   c                   || j         vrt          t          j                  }nt	          | j         |                   }| j        | j                                                 j        }|	                    d|g g |          d         }ddl
m} t          |t                    r&t                      }|j        D ]} |||          }|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,   r3   
from_errorr7   r   r   type_checkerexpr_checkercheck_method_call_by_name	mypy.joinrJ  r   r0   r5   rM  )r   r  iterableechkr  rJ  joinedr  s           r   _analyze_iterable_item_typez%IRBuilder._analyze_iterable_item_type  s     tz!!#*9+?#@#@HH&tz$'788Hz$*+88::G11*hBPTUUVWX((((((h	** 	Y*,,F  2 2#FD11M 11*hBPTUUVWXXr   c                6    | j                             |          S )z*Is the given module one compiled by mypyc?)r   is_native_module)r   re  s     r   rV  zIRBuilder.is_native_module  s    {++F333r   r"   c                6    | j                             |          S r   )r   is_native_ref_exprr  s     r   rX  zIRBuilder.is_native_ref_expr  s    {--d333r   c                6    | j                             |          S r   )r   is_native_module_ref_exprr  s     r   rZ  z#IRBuilder.is_native_module_ref_expr
  s    {44T:::r   r(   c                0    |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   r  s     r   is_synthetic_typezIRBuilder.is_synthetic_type  s     !US^Us7IQU7UUr   r   tuple[str, Var, bool] | Nonec                   d}t          |j        t                    rt          |j        j        t                    r|j        j                            |j                  }|rt          |j        t                    r{|j        j        j        d         j	        j
        }|j        j        p|dk    }|rF|j        }|j        j        j
         d|j         }|                     |j        j        j                  }nc|                     |          rNt          |j        t                    r4|j        j        r(|j        }|j        j
        }|                     |          }||||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   r  r"   r   r(   getr5  r+   basesrC  r1  is_finalinforV  r   is_module_member_exprrX  )r   r  	final_varsymexpr_fullnamere  r1  natives           r   get_final_refzIRBuilder.get_final_ref  sL    	di)) 	7j.R.R 	7).$$TY//C Oz#(C00 O $	 4Q 7 < E8,L0L O #I"%(-"8KK9>KKH!2249>3MNNF''-- 	7$)S)) 7di.@ 7 I	9-0066 Y..tr   rh  r+   rk  c                    |j         |                     |j                   S |rEt          | j        |          r0|                     || 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  r  r8   r   r  r   r  )r   rh  r1  r5  rk  r  r   s          r   emit_load_finalzIRBuilder.emit_load_final0  sp      ,**9+@AAA 	dj(;; 	))(DK4M4Mc4R4RTXZ^___4r   c                t    t          |j        t                    ot          |j        j        t                    S r   )r   r  r"   r   r   r  s     r   rg  zIRBuilder.is_module_member_exprD  s'    $)W--V*TY^X2V2VVr   r   calleec                &   |j         r~|j        t          gt          |          z  k    r]t	          |          }t          j        |g           }| j                            |||j	        | 
                    |                    }|r|S |j        }t          |t                    r|j        }t          |t                    r#|j        | j        vr|j        | j        v r|j        }|r|j         rk|| j        j        v r]t+          d |j        D                       r?| j        j        |         }| j                            |||j        |j        |j	                  S |                     |          }	|                     |	||j	        |j        |j                  S )Nc              3  6   K   | ]}|t           t          fv V  d S r   )r   r   )r  r  s     r   r0  z3IRBuilder.call_refexpr_with_args.<locals>.<genexpr>g  s,      LLTDWi00LLLLLLr   r)  r+  )r1  r)  r   r  get_call_target_fullnamer   rc  r   matching_primitive_opr   r   r   r   r!   implr   r  r   r   r   func_to_declallcallr+  r   r.  )
r   r  rp  r(  r1  primitive_candidatesr   callee_nodedeclr'  s
             r   call_refexpr_with_argsz IRBuilder.call_refexpr_with_argsG  s    ? 	t~'S__1LLL/77H#/#3Hb#A#A \77$j$)T^^D=Q=Q F   kk#455 	+%*K {I..	+ (@@@ D$===%*K# $t{777LLT^LLLLL 8 ;+K8D<$$T:t~t~W[W`aaa ;;v&&||j$)t~QUQ_  
 
 	
r   r    c                      j                             j                                        fd fdj                  S )Nc                 8                          j                  S r   )r   leftr  r   s   r   <lambda>z-IRBuilder.shortcircuit_expr.<locals>.<lambda>v  s    DKK	** r   c                 8                          j                  S r   )r   rightr  s   r   r  z-IRBuilder.shortcircuit_expr.<locals>.<lambda>w  s    DKK
++ r   )r   shortcircuit_helperr   r   r   r  s   ``r   shortcircuit_exprzIRBuilder.shortcircuit_exprr  sU    |//GNN4  *****+++++I
 
 	
r   argRefExpr | TupleExprlist[ClassIR] | Nonec                   t          |t                    rZt          |j        t                    r>|                     |          r)| j        j                            |j                  }|r|gS dS g }|j        D ]P}t          |t          t          f          r0| 
                    |          }| dS |                    |           N dS |S )zFlatten 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(   rZ  r   
type_to_irrc  rM  r&   flatten_classesextend)r   r  irr   r  	item_parts         r   r  zIRBuilder.flatten_classes}  s    
 c7## 	#(H--  $2P2PQT2U2U  [+//99  4K4!#C	    dWi$899   $ 4 4T : :I (#ttJJy))))44Jr   r   ret_typer   FuncInfo | strr  c                  t          |t                    rt          |          }t          | j        | j                  | _        | j                            | j        | j	                   | j
                            | j                   | j                            i            | j                            g            || _        | j                            | j                   | j                            |           |j        r'| j                            t'                                 n&| j                            t)                                 |                     t-                                 d S )Nr5  )r   r   rl   rn   r   r   r   r   r   r   r   r  r   r   r   r   r   r  r   rq   rp   r   rK   )r   r   r  s      r   enterzIRBuilder.enter  s:   gs## 	-G,,,G(dlCC 0$2BCCCT\***b!!!  $$$T\***h''' 	@!(()A)C)CDDDD!(()<)>)>???JLL)))))r   Jtuple[list[Register], list[RuntimeArg], list[BasicBlock], RType, FuncInfo]c                   | j                                         }| j                                         | j                                        }| j                                        }| j                                        }| j                                         | j         d         | _        | j        d         | _        |j	        ||j
        ||fS r~  )r   r  r   r   r   r   r   r   r   r>  r  )r   r   r   r  r   s        r   leavezIRBuilder.leave  s    -##%%(,,..>%%''-##%%!!###}R(}R(|\7>8WLLr   r  rA   	self_typeIterator[None]c              #    K   |                      ||           | j                            |           | j                            |           |t	          |          }|                     t          |           	 dV  |                                 \  }}}}}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 xY 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)
        r  N)r  r   r  r   r[   add_argumentr=   r  rF   r  rD   r5  r   rE   methodsr|  method_declsr   )r   r  r5  r  r   r  arg_regsr>  r  sigr|  r  s               r   enter_methodzIRBuilder.enter_method  s     , 	

7X
... ''---""8,,,!(++I)Y///	&EEE8<

5HdFHgh//C+//11D*..00HD(-1A3GGDh//B%'HT"*,'H!$'N!!"%%%%% 9=

5HdFHgh//C+//11D*..00HD(-1A3GGDh//B%'HT"*,'H!$'N!!"%%%%s   ;D= =B>G;r  	str | Varr  r   c                    t          |t                    rt          |          }|                     ||d          }| j        d                             t          |j        ||                     |S )zDeclare an argument in the current function.

        You should use this instead of directly calling add_local() in new code.
        Tis_argru  )r   r   r+   	add_localr   r  rG   r5  )r   r  r  r  r  s        r   r  zIRBuilder.add_argument  sg    
 c3 	c((CnnS#dn33"$$Z#t%D%DEEE
r   r  r%   SymbolTargetc                (    | j         d         |         S r~  r   )r   r  s     r   r  zIRBuilder.lookup  s    ~b!&))r   r  c                   t          |t                    sJ t          |t          |j                  ||j                  }t          |          | j        d         |<   |r| j        j	        
                    |           |S )zAdd register that represents a symbol to the symbol table.

        Args:
            is_arg: is this a function argument
        )r  r   ru  )r   r%   rV   remangle_redefinition_namer5  r   ry   r   r   r>  r  )r   r  r  r  r  s        r   r  zIRBuilder.add_local  s     &*-----+FK88fk
 
 
 &>c%B%Br6" 	*L$$S)))
r   ry   c                    |                      |||           | j        d         |         }t          |t                    sJ |S )zALike add_local, but return an assignment target instead of value.ru  )r  r   r   ry   )r   r  r  r  r   s        r   r  zIRBuilder.add_local_reg  sG     	vsF+++#F+&":;;;;;r   clsc                p    |                      t          t                    t          |          d          S )zLow-level function that adds a 'self' argument.

        This is only useful if using enter() instead of enter_method().
        Tr  )r  r+   r=   r[   )r   r  s     r   add_self_to_envzIRBuilder.add_self_to_env  s+    
 !!#i..)C..!NNNr   c                &    || j         d         |<   |S r~  r  )r   r  r   s      r   
add_targetzIRBuilder.add_target  s    %+r6"r   Type | Nonec                6    | j                             |          S r   r!  r_  s     r   r  zIRBuilder.type_to_rtype
  s    {((---r   c                    t          |t                    rt          S || j        vrt          S | j        |         }|                     |          S r   )r   r   rb   r   rj   r  )r   r   	mypy_types      r   r   zIRBuilder.node_type  sM    dG$$ 	"!!tz!!$$Jt$	!!),,,r   FuncInfo | ImplicitClassr  c                   t          |j                  }|| j        j        j        |<   t          |j        |          }|rq|                     |                     |          | j        j	        j
                  }|                     t          |j        ||| j        j	        j
                             |                     ||          S r   )r  r5  r   	env_class
attributesrw   curr_env_regr  r  r  r   r   rW   r  )r   r  r  r4  r  r5  attr_targetr  s           r   r  zIRBuilder.add_var_to_env_class  s    
 *#(3327)$/*4+<dCC 	U ))DKK,,dl.@.EFFCHHWT.c4<;M;RSSTTT sK000r   c                    |j         s
J d            d|j         j        v o(|j         j                            d          d         dk    S )NRefExpr not resolvedr  r   builtins)r   r1  splitr  s     r   is_builtin_ref_exprzIRBuilder.is_builtin_ref_expr)  sL    y000000di(([TY-?-E-Ec-J-J1-MQ[-[[r   r   c                   |                      |          r6|j        s
J d            |                     |j        j        |j                  S |                     |          rWt          |j        t                    r=|                     |j                  s#|j        sJ | 	                    |j                  S | 
                    |j        |j                  S )zLoads 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  )r  r   load_module_attr_by_fullnamer1  r   rZ  r   r(   r`  r3  load_global_strr5  r  s     r   load_globalzIRBuilder.load_global-  s     ##D)) 	T944444444TY5GSSS**400	?49h//	? **4955	?
 =   //>>>##DIty999r   c                    |                                  }|                     |          }|                     t          ||g|          S r   )r  r   rB  r~   )r   r5  r   _globalsr  s        r   r  zIRBuilder.load_global_str@  sA    ))++mmD!!  !1Hc?DIIIr   c                ^    |                      t          t          d| j                            S )Nglobals)r   rR   ra   r   r   s    r   r  zIRBuilder.load_globals_dictE  s#    xx
?It?OPPQQQr   c                    |                     d          \  }}}|                     |          }|                     |||          S Nr  )
rpartitionr<  r   )r   r1  r   re  _r5  r  s          r   r  z&IRBuilder.load_module_attr_by_fullnameH  sF    "--c224''dD111r   c                    |                      |j                  }t          |t                    oJ|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   r[   r  r  has_attrr5  
get_method)r   r  	obj_rtypes      r   r  zIRBuilder.is_native_attr_refM  sp    NN49--	y),, ="/="++DI66= &11$)<<<		
r   c                    d| j         d<   dS )zMark 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'.
        Fru  N)r   r   s    r   mark_block_unreachablez IRBuilder.mark_block_unreachableW  s     */"2&&&r   r   c                ,    t          | j        |          S r   )r?   r   )r   r   s     r   r?   zIRBuilder.catch_errors`  s    D,d333r   msgc                H    | j                             || j        |           d S r   )r   warningr   r   r  r   s      r   r  zIRBuilder.warningc  s%    C!1488888r   c                H    | j                             || j        |           d S r   )r   r  r   r  s      r   r  zIRBuilder.errorf  s%    #t/66666r   c                H    | j                             || j        |           d S r   )r   noter   r  s      r   r  zIRBuilder.notei  s%    d.55555r   func_irrE   c                    |j         |j        f}|| j        v r"|                     d|d          d|           d S | j                            |           | j                            |           d S )NzDuplicate definition of "rv  z" not supported by mypyc)r  r5  r   r  r   r   r  )r   r  r   r5  s       r   add_functionzIRBuilder.add_functionl  s|    "GL14&&&JJT47TTTVZ[[[F%%%g&&&&&r   )r   r   r   r   r   r   r   r@   r   ro   r   rt   r   r   r   r}   r   r   r   r   )r   r   r   r   r   r   )r   r   r   r   r   rZ   )r   r$   r   r   )r   r   r   r   r   r   )r   r   )r   rS   r   rZ   )r   rK   r   r   )r   rK   r   r   )r   rV   )r   rZ   r   r   r   r   r   rZ   )r   r   r   rZ   )r   r   r   rZ   )r   r  r   rZ   )r
  rZ   r  r   r   r   r   rZ   )
r
  rZ   r  rZ   r  r   r   r   r   rZ   )F)
r  rZ   r  r]   r   r   r  r   r   rZ   r   rZ   )r  r  r   r   r   rZ   )NN)r'  rZ   r(  r  r   r   r)  r*  r+  r,  r   rZ   )r   rZ   r  rK   r  rK   r   r   )r1  r   r   rZ   )r4  rZ   r5  r   r(  r  r6  r7  r   r   r)  r*  r+  r8  r   rZ   )r5  r   r   rZ   )r=  r   r>  r  r   r   r   rZ   r   )
r=  rT   r>  r  r   r   r6  r7  r   rZ   )rC  r]   rD  rZ   rE  rZ   r   r   r   r   r   rZ   )
rD  rZ   rE  rZ   r   r   r   r   r   rZ   )rJ  rZ   r   r   r   rZ   )rM  r  r   r   r   rZ   )rP  rQ  r   r   )
rT  rB   rU  r   rJ  rZ   r   r   r   r   )rZ  r   r   r   r   r   )
rZ  r   r   r   r_  rK   r`  rK   r   r   )re  r   r   r   r   rZ   )re  r   r   r   r   r   r   rZ   )r   rV   rl  rm  r   r   r   r   )
r   rV   rl  rm  rs  r   r   r   r   r   )r  r  r   r   r   r   )r   r   )r   r  )
r  r   r  rZ   r  r  r  r7  r   r   )
r1  r   r  r]   r   r   r  r  r   rZ   )r   rZ   r5  r   r   r   r   r   )r5  r   r   r   r   rZ   )rJ  r  r   rZ   )ru  )r  r   r   r   r  r   r   rv   )ru  F)r   r  r   r   r   r   r   rZ   )r   r  r  rZ   r   r   r   r   )r  rZ   r  r]   r   r   r   rZ   )r   rz   r  rZ   r   r   r   r   )r  rv   r  rZ   r   r   r   r   )r   rz   r  rZ   r   r   r   r   )r  rK   r  rK   r   r   )rC  r]   r   rv   )r   rZ   r   rv   )r   rZ   r   r  )r   rZ   r   r  )r  r   r   r  )r  r   r   r]   )r  r1   r   r]   )r  r   r   r&  )r  r1   r   r&  )r  r   r   r1   )re  r   r   r   )r  r"   r   r   )r  r(   r   r   )r  r   r   ra  )rh  r+   r1  r   r5  r   rk  r   r  r1   r   r   r   r   )r  r   r   r   )r  r   rp  r"   r(  r  r   rZ   )r  r    r   rZ   )r  r  r   r  )r   )r   r  r  r]   r   r   )r   r  )r   N)r  rA   r5  r   r  r]   r   r  r  r7  r   r  )r  r  r  r]   r  r   r   rV   )r  r%   r   r  )r  r%   r  r]   r  r   r   rV   )r  r%   r  r]   r  r   r   ry   )r  rA   r   ry   )r  r%   r   r  r   r  )r  r  r   r]   )r   r   r   r]   )
r  r%   r  r]   r4  r  r  r   r   rv   )r  r   r   rZ   )r1  r   r   r   r   rZ   )r   r   r   r   )r  r   r   r   r   r   )r  rE   r   r   r   r   )vr   r   r   __doc__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  r3  r:  r<  r@  rB  rG  rI  rL  rO  rS  rY  ra  r^  rh  rk  rr  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?  rC  rG  rT  rV  rX  rZ  r`  rl  rn  rg  r}  r  r  ri   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      s0
        0G  G  G  G V: : : : =BQQQQQ XQ222 X2IN      >) ) ) )
$ $ $ $" " " "+ + + +. . . .# # # #9 9 9 9, , , ,> > > >, , , ,. . . .: : : :A A A A^ ^ ^ ^ ^* * * *# # # ## # # #$ $ $ $6 6 6 65 5 5 5G G G G +/15V V V V V9 9 9 9> > > > +/-1
 
 
 
 
. . . .5 5 5 5 %)H H H H H= = = =? ? ? ?3 3 3 33 3 3 31 1 1 1
T T T T	$ 	$ 	$ 	$< < < <\ \ \ \
8 
8 
8 
8( ( ( (( ( ( ($, , , ,X X X X$ $ $ $
d d d d' ' ' '        "&	B '+B B B B B B* NR
 
 
 
 
a a a a

 
 
 
6 6 6 6* +-G8BGG8 G8 G8 G8 G8 G8T TY8 8 8 8 8.!: !: !: !:F
0 
0 
0 
0- - - -2( ( ( (E* E* E* E*N
 
 
 

$ $ $ $      
 
 
 
   &   B B B B" " " ".C C C CC C C C64 4 4 4
4 4 4 4
. . . .
Y Y Y Y,4 4 4 44 4 4 4; ; ; ;V V V V   >   (W W W W)
 )
 )
 )
V
 
 
 
   .* * * * * * *"	M 	M 	M 	M  #%"&&& && && && ^&&P HO 	 	 	 	 	* * * *      >C    O O O O   . . . .- - - - _d1 1 1 1 1&\ \ \ \: : : :&J J J J
R R R R2 2 2 2

 
 
 
/ / / /4 4 4 49 9 9 97 7 7 76 6 6 6' ' ' ' ' 'r   r   r   r   r   c                     j         j        d}j        D ]j        r                     j                  d fd}t          t                    sJ j        }|j	        j
        s'                     j        |j        j                   }                     j        ||j        j                   |dz  }dS )zGenerate 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   rZ   c                    j         J t          j                   r                    j                   S j        j        sfj        dz   j        j        z   } j        	                    | j
        f                               t          j
        | j                            S j        j        } j
        j        j        j        j        | <                       t#          j        j        j        | j                            S r  )initializerr|   r   r   	is_nestedr1  variabler5  r   r  rC  r   rR   r   callable_classr  r  rN   self_regr   )r5  r  r   r  r   s    r   get_defaultz%gen_arg_defaults.<locals>.get_default  s    222 s// ">>#/::: !2 	 >C/#,2CCD'..fk/BCCC";;z&+tWEX'Y'YZZZ<,DIOGO25@F";; > GsxXX  r   rv  Nr  )r   r  	argumentsr  r  r  r   ry   r  rC  error_overlaprr  r   r|  )r   nbr  r  r  r  r   s   `   @@@r   gen_arg_defaultsr  u  s     O!E	
B    ? 	^^CL11F        ( f&>?????/C8) &&vS_EYZZZZ..O["co6J   aA   r   r5  r   c                .    |                      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  s    r   r  r    s     <<[)))r   refr"   c                    t          | j        t                    r:t          | j        j                  }t          |t
                    r|j        j        S | j        S r   )r   r   r'   r7   r   r.   rC  r1  )r  r   s     r   rt  rt    sL    #(I&& ( 11fh'' 	(;''<r   
typing_modrZ   	type_argslist[TypeParam]r   r   r  c           	        g }d}|D ]I}|j         t          k    r|r|}nk|                     |d|          }|}nQ|j         t          k    r|                     |d|          }n)|j         t          k    sJ |                     |d|          }|j         t          k    rU|                     ||                     |j                  |                                 g|t          t          gddg          }n0|                     ||                     |j                  g|          }|                     ||j        |           |                    |           K|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_variancers  )r  r   r   r   r   r.  r   r5  r  r   r   r  r  )	r   r  r  r   tvstype_var_imported
type_paramtvttvs	            r   create_type_paramsr    sd    C&*  
?m++  ('))*iFF$'!!_ 333%%j.$GGCC?o5555%%j+tDDC?111!!*/22GLLNNC"I.!12 !  BB w'7'7
'H'H&I4PPBb*/4888

2Jr   r   rl   func_regr   symtabledict[SymbolNode, SymbolTarget]c           	        |j         }|j        D ]}|j        rt          |j                  s|                     |                     |j                  ||j                 j        |j                  }|j	        sA|j
        dz   |j        j        z   }|                     t          ||| j                             |J |                     t          ||j        j        ||j                             dS )zCalculate default argument values and store them.

    They are stored in statics for top level functions and in
    the function objects for nested functions (while constants are
    still stored computed on demand).
    r  N)r  r  r  r|   r   r   r  rC  r   r  r1  r5  r   rO   r   rW   )r   r   r   r  r  r  r   r5  s           r   calculate_arg_defaultsr    s     ME S S? 		S;s#?#? 		SNNs//#,1G1Lch E $ S~+cl.??JudG4GHHIIII+++GHcl.?QQRRRS Sr   )r   r   r   r   )r5  r   r   r   )r  r"   r   r   )
r   r   r  rZ   r  r  r   r   r   r  )
r   r   r   rl   r   r   r  r  r   r   )r  
__future__r   collections.abcr   r   
contextlibr   typingr   r   r	   r
   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&   r'   r(   r)   r*   r+   
mypy.typesr,   r-   r.   r/   r0   r1   r2   r3   r4   r5   r6   r7   	mypy.utilr8   r9   mypy.visitorr:   r;   mypyc.commonr<   r=   r>   mypyc.crashr?   mypyc.errorsr@   mypyc.ir.class_irrA   rB   mypyc.ir.func_irrC   rD   rE   rF   rG   mypyc.ir.opsrH   rI   rJ   rK   rL   rM   rN   rO   rP   rQ   rR   rS   rT   rU   rV   rW   rX   rY   rZ   mypyc.ir.rtypesr[   r\   r]   r^   r_   r`   ra   rb   rc   rd   re   rf   rg   rh   ri   rj   rk   mypyc.irbuild.contextrl   rm   mypyc.irbuild.ll_builderrn   mypyc.irbuild.mapperro   mypyc.irbuild.nonlocalcontrolrp   rq   rr   rs   mypyc.irbuild.prebuildvisitorrt   mypyc.irbuild.prepareru   mypyc.irbuild.targetsrv   rw   rx   ry   rz   mypyc.irbuild.utilr{   r|   mypyc.optionsr}   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   r  r   r  r  rt  r  r  r   r   r   <module>r&     s    
 # " " " " " . . . . . . . . % % % % % % 8 8 8 8 8 8 8 8 8 8 8 8 8 8       2 2 2 2 2 2                                                               @                            2 1 1 1 1 1 1 1 < < < < < < < < ? ? ? ? ? ? ? ? ? ? $ $ $ $ $ $       6 6 6 6 6 6 6 6 Z Z Z Z Z Z Z Z Z Z Z Z Z Z                                         *                                     & : 9 9 9 9 9 9 9 6 6 6 6 6 6 ' ' ' ' ' '            : 9 9 9 9 9 2 2 2 2 2 2              ; : : : : : : : ) ) ) ) ) ) H H H H H H H H H H H H H H H H H H U U U U U U U U U U Z Z Z Z Z Z Z Z Z Z H H H H H H H H !M L L  L L L L	 	 	 	 	!%(*:4*@ 	 	 		 	 	 	 	9 	 	 	 -/CCD]' ]' ]' ]' ]' ]' ]' ]'@'( ( ( (V* * * *   ' ' ' 'TS S S S S Sr   