
    5 f                       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, dd	l-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8 dd
l9m:Z: ddl;m<Z<m=Z= ddl>m?Z?m@Z@mAZA ddlBmCZC ddlDmEZE ddlFmGZGmHZH ddlImJZJmKZKmLZLmMZMmNZN ddlOmPZPmQZQmRZRmSZSmTZTmUZUmVZVmWZWmXZXmYZYmZZZm[Z[m\Z\m]Z]m^Z^m_Z_m`Z` ddlambZbmcZcmdZdmeZemfZfmgZgmhZhmiZimjZjmkZkmlZlmmZmmnZnmoZompZpmqZqmrZr ddlsmtZtmuZu ddlvmwZw ddlxmyZy ddlzm{Z{m|Z|m}Z}m~Z~ ddlmZ 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%e<e`         e=d&                   Z G d' d(e          Zeeef         Z G d) d*          Zd5d.Zd6d1Zd7d4Zd&S )8a  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ArgKindCallExpr	Decorator
ExpressionFuncDef	IndexExprIntExprLvalue
MemberExprMypyFileNameExprOpExprOverloadedFuncDefRefExprStarExpr	Statement
SymbolNode	TupleExpr	TypeAliasTypeInfo	UnaryExprVar)AnyTypeDeletedTypeInstance
ProperType	TupleTypeTypeTypedDictType	TypeOfAnyUninhabitedType	UnionTypeget_proper_type)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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__     K/var/www/equiseq/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
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d/Zdd1Zdd6Zdd8Zdd9Zdd:Zdd<Zdd?ZddAZdddFZddGZddHZddIZddJZddMZddNZddOZ	 	 dddWZd dZZd!d\Z	 	 dd"dbZd#dcZ d$dgZ!d%dkZ"d&dlZ#d&dmZ$d'doZ%d(dqZ&d)duZ'd*dwZ(d+dzZ)d,d|Z*d-d}Z+d.dZ,d/dZ-ddZ.ddZ/ddZ0d0dZ1d1dZ2d2dZ3	 d3dPdd4dZ4	 d3d5dZ5d6dZ6	 d7ddd8dZ7	 d9d:dZ8d;dZ9d<dZ:d=dZ;d>dZ<d?dZ=d@dZ>ddZ?dAdZ@dBdZAdCdZBdDdZCdEdZDdFdZEdGdZFdHdZGdFdZHdFdZIdFdZJdIdZKdJdZLdKdZMdKdÄZNdLdńZOdMdȄZPdNd̄ZQdOd̈́ZRdPdЄZSdQd҄ZTdRdքZUdSdTdڄZVdUd܄ZWeX	 	 dVdWd            ZYeZfdXdZ[dYdZ\ddZdZ]	 dd[dZ^d\dZ_d]dZ`d^dZad_dZb	 dd`dZcdKdZddadZedbdZfddZgdcdZhdOdZidd ZjdddZkdedZldedZmdedZndfd	ZodPS (g  	IRBuildercurrent_modulestrtypesdict[Expression, Type]graphr   errorsr:   mapperrg   pbvrl   visitorr   optionsru   singledispatch_impls%dict[FuncDef, list[RegisterImplInfo]]returnNonec
                   t          ||||          | _        | j        g| _        i g| _        g g| _        g | _        g | _        dg| _        || _        || _	        || _
        || _        g | _        g | _        t                      | _        g | _        g | _        t                      | _        || _        d| _        d| _        |j        | _        |j        | _        |j        | _        |j                                        | _        |j        | _        |j        | _        |	| _        || _         tC          tD          dd          | _#        | j#        g| _$        g | _%        || _&        i | _'        d| _(        d S )NTr    F))rf   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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   rd   r=   fn_infofn_infosnonlocal_controlr   imports
can_borrow)
selfr   r   r   r   r   r   r   r   r   s
             r   __init__zIRBuilder.__init__   sc    )QQ@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   boolrR   c                   d S Nr   )r   r   r   s      r   acceptzIRBuilder.accept       r   r!   c                    d S r   r   )r   r   s     r   r   zIRBuilder.accept   r   r   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)r9   line
isinstancer   r   r   r   coerce	node_typer   rN   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   oprL   c                6    | j                             |          S r   )r   add)r   r   s     r   r   zIRBuilder.add  s    |###r   targetrD   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_block  s    ##E*****r   c                :    | j                             |           d S r   )r   goto_and_activater   s     r   r   zIRBuilder.goto_and_activate  s    &&u-----r   rN   c                4    | j                                         S r   )r   r   r   s    r   r   zIRBuilder.self!      |  """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_bytesrs   r   s     r   load_bytes_from_str_literalz%IRBuilder.load_bytes_from_str_literal*  s"     |&&~e'<'<===r   c                6    | j                             |          S r   )r   load_intr   s     r   r   zIRBuilder.load_int3  r   r   floatc                6    | j                             |          S r   )r   
load_floatr   s     r   r  zIRBuilder.load_float6  s    |&&u---r   lregexpr_opc                :    | j                             |||          S r   )r   unary_op)r   r  r  r   s       r   r  zIRBuilder.unary_op9  s    |$$T7D999r   rregc                <    | j                             ||||          S r   )r   	binary_opr   r  r  r  r   s        r   r  zIRBuilder.binary_op<  s    |%%dD'4@@@r   srctarget_typerU   forcec                J    | j                             ||||| j                  S )Nr   )r   r   r   )r   r
  r  r   r  s        r   r   zIRBuilder.coerce?  s%    |""3T5T_"]]]r   c                4    | j                                         S r   )r   none_objectr   s    r   r  zIRBuilder.none_objectB  s    |'')))r   c                4    | j                                         S r   )r   noner   s    r   r  zIRBuilder.noneE  r   r   c                4    | j                                         S r   )r   truer   s    r   r  zIRBuilder.trueH  r   r   c                4    | j                                         S r   )r   falser   s    r   r  zIRBuilder.falseK  s    |!!###r   valueslist[Value]c                8    | j                             ||          S r   )r   new_list_opr   r  r   s      r   r  zIRBuilder.new_list_opN  s    |''555r   c                8    | j                             ||          S r   )r   
new_set_opr  s      r   r  zIRBuilder.new_set_opQ  s    |&&vt444r   c                <    | j                             ||||          S r   )r   translate_is_opr	  s        r   r  zIRBuilder.translate_is_opT  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_callW  s"     |##Hj$	9UUUr   r  r  c                >    | j                             |||           d S r   )r   add_bool_branch)r   r   r  r  s       r   r(  zIRBuilder.add_bool_brancha  s"    $$UD%88888r   fullnamec                6    | j                             |          S r   )r   load_native_type_object)r   r)  s     r   r+  z!IRBuilder.load_native_type_objectd  s    |33H===r   basenameresult_typeRType | Nonelist[str | None] | Nonec           
     N    | j                             |||||||| j                  S r   )r   gen_method_callr   )r   r,  r-  r   r.  r   r!  r#  s           r   r2  zIRBuilder.gen_method_callg  s1     |++$
Ky)T_
 
 	
r   c                6    | j                             |          S r   )r   load_module)r   r-  s     r   r4  zIRBuilder.load_moduleu  s    |''---r   descr   argsc                :    | j                             |||          S r   )r   call_c)r   r5  r6  r   s       r   r8  zIRBuilder.call_cx  s    |""4t444r   typelhsrhsc                >    | j                             |||||          S r   )r   int_op)r   r9  r:  r;  r   r   s         r   r=  zIRBuilder.int_op{  s     |""4c2t<<<r   c                <    | j                             ||||          S r   )r   compare_taggedr   r:  r;  r   r   s        r   r?  zIRBuilder.compare_tagged~      |**3R>>>r   c                <    | j                             ||||          S r   )r   compare_tuplesr@  s        r   rC  zIRBuilder.compare_tuples  rA  r   valc                8    | j                             ||          S r   )r   builtin_len)r   rD  r   s      r   rF  zIRBuilder.builtin_len  s    |''T222r   itemsc                8    | j                             ||          S r   )r   	new_tuple)r   rG  r   s      r   rI  zIRBuilder.new_tuple  s    |%%eT222r   non_extr<   keyc                x    |                      |          }|                     t          |j        ||g|           d S r   )r   r8  rw   dict)r   rJ  rK  rD  r   key_unicodes         r   add_to_non_ext_dictzIRBuilder.add_to_non_ext_dict  s;     mmC(($w|[#&FMMMMMr   idc                   d | j         |<   t                      t                      }}|                     ||||           |                     |           |                     t
          |                     |          g|          }|                     t          ||t                               | 
                    |           d S )N)	namespace)r   rD   check_if_module_loadedr   r8  r   r   r   rH   rB   r   )r   rP  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   rT  rU  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)r4  r  r  r(  )r   rP  r   rT  rU  
first_load
comparisons          r   rS  z IRBuilder.check_if_module_loaded  s[     %%b))
))*d6F6F6H6H(TXYY
Zl;;;;;r   modulec                    |                      t          g |          }|                      t          ||                     |          g|          S r   )r8  r   rv   r   )r   rZ  r   mod_dicts       r   
get_modulezIRBuilder.get_module  sA    ;;12t<<{{+hf8M8M-NPTUUUr   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.
        )rV  r]  r   )r   rZ  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)	rD   r   rE   IS_ERRORr   rC   r   r9  r   )r   r   ra  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   )rD   r=  rW   r   r6  r6   rI   rJ   ANDr   rF   EQrE   BOOLr   rC   r   r9  r   )	r   r   ra  rh  r   re  rf  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 Nrj  )r]   r   r^   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 rs  )r   blocks
terminatedr   r  r   r   
gen_returnr   fitemr   )r   r   retvals      r   rt  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 rs  )r   rx  ry  r   rQ   r   s     r   ru  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%   r-  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_valuer-  r   r   r   r   appendr9  r   rH   r   )r   r  r  r  r  r-  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)r3   r   r   load_static_checked)r   r)  r  r   r  
split_namerZ  r-  s           r   load_final_staticzIRBuilder.load_final_static  sc     "$*h77
%%%!|//HzHHH 0 
 
 	
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   rD  s     r   load_literal_valuezIRBuilder.load_literal_value$  s   c4   	6 $yy{{"zz||#S!! 	6<((---U## 		6<**3///S!! 	6<((---U## 	6<**3///W%% 	6<,,S11155555r   rj  )for_readr  rn   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              )Nrj  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_clsr  kindr   r   r9  r)   type_to_rtyper   r   is_generatoradd_var_to_env_classgenerator_classadd_local_reglookupr   load_globals_dictr   rp   r   r   r,  rh  r   is_native_attr_refr  ro   r#   	enumeraterG  get_assignment_targetr  r    rr   )r   r  r   r  symbolreg_typeglobals_dictr-  r,  rh  r   r   star_idxr~  idxitemtargs                    r   r  zIRBuilder.get_assignment_target8  sA    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))u	** 	;;;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7ur   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   rR   rq   registerrp   r2  r,  rh  r9  ro   r   rS   class_iris_ext_classr   r   rG   r   r   )r   r   r   r   regr  s         r   readzIRBuilder.read  s/    fe$$ 	Mf677 	#?"f344 	+&&]V\NFK C 
*&+***5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7ur   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   rN   r   rC   coerce_rvaluer9  rq   r  ro   obj_typerS   rO   r   r   r   r   boxr8  rz   rp   r2  r,  rh  rr   rT   r  r   r  rG  rangerP   assignr\   r`   process_sequence_assignment!process_iterator_tuple_assignment)
r   r   r  r   rK  	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 O!//
FKNN
V[*dKKLLLLLmmFK00 L,,Z88	MFJY+GNNNNN 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95r   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"))r[   r_   r9  
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   rr   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)rI   r  rG  rX   r   r8  r~   r  r   r\   r9  r{   r2  r  zipr  )r   r   r  r   expected_lenr  r  r  rh  r  r  r   s               r   r  z%IRBuilder.process_sequence_assignment  s6   
 s6<002HII1FL3I4PPP s6<(()) 		& 		&A<?DL))!,,E!&+.. ![[)@65/SWXX

!\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)	rD   r   rE   rd  r   rM   VALUE_ERRORrQ   r  )r   r  r  r   re  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  rk  r   ztoo many values to unpack)r8  rx   r  r  rG  ry   rD   r   rE   rd  r   rM   r  rQ   r  r}   rF  rI   r  rn  reversedr|   )r   r   r  r   iterator	split_idxr  r  re  r  post_star_vals	iter_listiter_list_lenpost_star_len	conditionextras                   r   r  z+IRBuilder.process_iterator_tuple_assignment  sn    ;;wd;; (.'BFOOFLHYHY	 \*9*- 	, 	,EKK(T::E$.LL*,,KHHVE;&/JJKKK,,,HH"&24QSW   
 HH[]]###)))KKud++++ ?&#\)a-//:NGhZ>>I ,,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MI;EE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 rs  )r   r  rj   )r   r  r  s      r   push_loop_stackzIRBuilder.push_loop_stack6  s>    $$ 5b 9>;WW	
 	
 	
 	
 	
r   c                8    | j                                          d S r   )r   popr   s    r   pop_loop_stackzIRBuilder.pop_loop_stack;  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.rk  )r8   r   r  r'   r   r  )r   r9  r-  r   s       r   make_spill_targetzIRBuilder.make_spill_target>  sP     5$"355Q**3t99dDL<XYYr   c                h    |                      |j                  }|                     ||d           |S )r  rj  )r  r9  r  )r   r   r   s      r   spillzIRBuilder.spillE  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_spillL  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.
        rj  )r   r  r  r   rN   r9  r  )r   r   r  s      r   maybe_spill_assignablez IRBuilder.maybe_spill_assignableX  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_intk  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_types  s    //
40@AAAr   r-   c                B    t          |          }t          |t                    r%t          j         fd|j        D                       S t          |t                    s
J |            |j        j        dk    rt          S  
                    |j        d                   S )Nc                :    g | ]}                     |          S r   )r  ).0r  r   s     r   
<listcomp>z9IRBuilder.get_sequence_type_from_type.<locals>.<listcomp>z  s'    VVVD11$77VVVr   zbuiltins.strr   )r2   r   r1   rV   make_simplified_unionrG  r*   r9  r)  rc   r  r6  )r   r  s   ` r   r  z%IRBuilder.get_sequence_type_from_typev  s    %k22k9-- 	/VVVVKDUVVV   +x00==+==0$66!!%%k&6q&9:::r   list[Instance]c                   t          | j        |                   }t          |t                    rd |j        D             }n|g}g }|D ]}t          |t
                    r+|j        }t          d |j        j	        D                       }nBt          |t                    s
J |            t          d |j        j	        D                       }|                    t          ||                     |S )zpFind dict type of a dict-like expression.

        This is useful for dict subclasses like SymbolTable.
        c                ,    g | ]}t          |          S r   )r2   )r  r  s     r   r  z0IRBuilder.get_dict_base_type.<locals>.<listcomp>  s     IIIt_T**IIIr   c              3  0   K   | ]}|j         d k    |V  dS )ztyping.MappingNr)  r  r,  s     r   	<genexpr>z/IRBuilder.get_dict_base_type.<locals>.<genexpr>  s/       b b$Qa@a@a@a@a@a@a b br   c              3  0   K   | ]}|j         d k    |V  dS )zbuiltins.dictNr  r  s     r   r  z/IRBuilder.get_dict_base_type.<locals>.<genexpr>  s/       a a$Q`@`@`@`@`@`@` a ar   )r2   r   r   r1   rG  r.   fallbacknextr9  mror*   r  r   )r   r  r  r   
dict_typest	dict_bases          r   get_dict_base_typezIRBuilder.get_dict_base_type  s   
 &dj&677k9-- 	"II{7HIIIEE ME
 	G 	GA!]++ bJ  b b!&* b b bbb		!!X..1111.  a a!&* a a aaa	79EEFFFFr   c                                           |          }t          |          dk    r&                     |d         j        d                   S  fd|D             }t	          j        |          S )Nrk  r   c                P    g | ]"}                     |j        d                    #S )r   r  r6  r  r  r   s     r   r  z/IRBuilder.get_dict_key_type.<locals>.<listcomp>  -    MMMd((33MMMr   r  r  r  r6  rV   r  r   r  dict_base_typesr  s   `   r   get_dict_key_typezIRBuilder.get_dict_key_type  t    11$771$$%%oa&8&=a&@AAAMMMM_MMMF/777r   c                                           |          }t          |          dk    r&                     |d         j        d                   S  fd|D             }t	          j        |          S )Nrk  r   c                P    g | ]"}                     |j        d                    #S )rk  r  r   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%  r)  rT   )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(   r/   
from_errorr2   r   r   type_checkerexpr_checkercheck_method_call_by_name	mypy.joinr0  r   r,   r0   rG  )r   r  iterableechkr  r0  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                    || j         j        v S )z*Is the given module one compiled by mypyc?)r   	group_map)r   rZ  s     r   is_native_modulezIRBuilder.is_native_module  s    ...r   r   c                    |j         dS d|j         j        v r8|                     |j         j                            d          d                   S dS )NFr  r   T)r   r)  r=  
rpartitionr  s     r   is_native_ref_exprzIRBuilder.is_native_ref_expr  sP    95$)$$$(();)F)Fs)K)KA)NOOOtr   c                L    |                      |          o|j        t          k    S r   )r@  r  r   r  s     r   is_native_module_ref_exprz#IRBuilder.is_native_module_ref_expr  s"    &&t,,Bd1BBr   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%   getr-  r'   basesr9  r)  is_finalinfor=  r   is_module_member_exprr@  )r   r  	final_varsymexpr_fullnamerM  r)  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   rP  r'   rS  c                    |j         |                     |j                   S |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  r  r   r  )r   rP  r)  r-  rS  r  r   s          r   emit_load_finalzIRBuilder.emit_load_final  s]      ,**9+@AAA 	))(DK4M4Mc4R4RTXZ^___4r   c                t    t          |j        t                    ot          |j        j        t                    S r   )r   r  r   r   r   r  s     r   rO  zIRBuilder.is_module_member_expr  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   r  z3IRBuilder.call_refexpr_with_args.<locals>.<genexpr>+  s,      LLTDWi00LLLLLLr   )r!  r#  )r)  r!  r   r  get_call_target_fullnamer   rK  r   matching_call_cr   r   r   r   r   implr   r  r   r   r   func_to_declallcallr#  r   r&  )
r   r  rX  r   r)  call_c_ops_candidatesr   callee_nodedeclr  s
             r   call_refexpr_with_argsz IRBuilder.call_refexpr_with_args  s    ? 	t~'S__1LLL/77H$0$4Xr$B$B!\11%z49dnnT>R>R 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>:  s    DKK	** r   c                 8                          j                  S r   )r   rightrh  s   r   ri  z-IRBuilder.shortcircuit_expr.<locals>.<lambda>;  s    DKK
++ r   )r   shortcircuit_helperr   r   r   r  s   ``r   shortcircuit_exprzIRBuilder.shortcircuit_expr6  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%   rB  r   
type_to_irrK  rG  r#   flatten_classesextend)r   rn  irr   r  	item_parts         r   rs  zIRBuilder.flatten_classesA  s    
 c7## 	#(H--  $2P2PQT2U2U  [+//99  4K4!#C	    dWi$899   $ 4 4T : :I (#ttJJy))))44Jr   r   r   FuncInfo | strc                
   t          |t                    rt          |          }t          | j        | j        | j        | j                  | _        | j        	                    | j
        | j                   | j                            | j                   | j                            i            | j                            g            || _        | j                            | j                   | j                            t&                     |j        r'| j                            t-                                 n&| j                            t/                                 |                     t3                                 d S )Nr-  )r   r   rd   rf   r   r   r   r   r   r   r   r   r   r  r   r   r   r   r   ra   r  r   ri   rh   r   rD   )r   r   s     r   enterzIRBuilder.enterX  sJ   gs## 	-G,,,G(dk4<
 
 	 0$2BCCCT\***b!!!  $$$T\***o... 	@!(()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 rs  )r   r  r   r   r   r   r   r   r   r6  rx  )r   r   r   ret_typer   s        r   leavezIRBuilder.leavek  s    -##%%(,,..>%%''-##%%!!###}R(}R(|\7>8WLLr   r  r;   r}  	self_typeIterator[None]c              #    K   |                      |           | j                            |           | j                            |           || j        d<   |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)
        rj  N)rz  r   r  r   r   rS   add_argumentr7   r~  r@   r  r>   r-  r   r?   methodsrc  method_declsr   )r   r  r-  r}  r   r  arg_regsr6  rx  sigrc  ru  s               r   enter_methodzIRBuilder.enter_methodv  s     , 	

7 ''---""8,,,%r!(++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   E B>H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_argrj  )r   r   r'   	add_localr   r  rA   r-  )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 rs  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   rj  )r   r"   rN   remangle_redefinition_namer-  r   rq   r   r   r6  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   rq   c                    |                      |||           | j        d         |         }t          |t                    sJ |S )zALike add_local, but return an assignment target instead of value.rj  )r  r   r   rq   )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'   r7   rS   )r   r  s     r   add_self_to_envzIRBuilder.add_self_to_env  s+    
 !!#i..)C..!NNNr   c                &    || j         d         |<   |S rs  r  )r   r  r   s      r   
add_targetzIRBuilder.add_target  s    %+r6"r   Type | Nonec                6    | j                             |          S r   )r   r  rG  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   rZ   r   rb   r  )r   r   	mypy_types      r   r   zIRBuilder.node_type  sM    dG$$ 	"!!tz!!$$Jt$	!!),,,r   FuncInfo | ImplicitClassr  c                   || j         j        j        |j        <   t	          |j        |j                  }|rv|                     |                     |          | j         j        j	                  }| 
                    t          |j        |j        || j         j        j	                             |                     ||          S r   )r   	env_class
attributesr-  ro   curr_env_regr  r  r{  r   r   rO   r  )r   r  r  r,  r  attr_targetr  s          r   r  zIRBuilder.add_var_to_env_class  s    
 7<)#(3*4+<chGG 	Y ))DKK,,dl.@.EFFCHHWT.#t|?Q?VWWXXX 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   r)  splitr  s     r   is_builtin_ref_exprzIRBuilder.is_builtin_ref_expr  sK    y00000y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_fullnamer)  r   rB  r   r%   rH  r+  load_global_strr-  r  s     r   load_globalzIRBuilder.load_global  s     ##D)) 	T944444944TY5GSSS**400	?49h//	? **4955	?
 =  =//>>>##DIty999r   c                    |                                  }|                     |          }|                     t          ||g|          S r   )r  r   r8  rv   )r   r-  r   _globalsr  s        r   r  zIRBuilder.load_global_str  s?    ))++mmD!!{{+h_dCCCr   c                ^    |                      t          t          d| j                            S )Nglobals)r   rK   rY   r   r   s    r   r  zIRBuilder.load_globals_dict  s#    xx
?It?OPPQQQr   c                    |                     d          \  }}}|                     |          }|                     |||          S Nr  )r?  r4  r   )r   r)  r   rZ  _r-  rg  s          r   r  z&IRBuilder.load_module_attr_by_fullname  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   rS   r  r  has_attrr-  
get_method)r   r  	obj_rtypes      r   r  zIRBuilder.is_native_attr_ref  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'.
        Frj  N)r   r   s    r   mark_block_unreachablez IRBuilder.mark_block_unreachable  s     */"2&&&r   r   c                ,    t          | j        |          S r   )r9   r   )r   r   s     r   r9   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.warning)  s%    C!1488888r   c                H    | j                             || j        |           d S r   )r   r  r   r  s      r   r  zIRBuilder.error,  s%    #t/66666r   c                H    | j                             || j        |           d S r   )r   noter   r  s      r   r  zIRBuilder.note/  s%    d.55555r   func_irr?   c                    |j         |j        f}|| j        v r"|                     d|d          d|           d S | j                            |           | j                            |           d S )NzDuplicate definition of "rk  z" not supported by mypyc)r  r-  r   r  r   r   r  )r   r  r   r-  s       r   add_functionzIRBuilder.add_function2  s|    "GL14&&&JJT47TTTVZ[[[F%%%g&&&&&r   )r   r   r   r   r   r   r   r:   r   rg   r   rl   r   r   r   ru   r   r   r   r   )r   r   r   r   r   r   )r   r   r   r   r   rR   )r   r!   r   r   )r   r   r   r   r   r   )r   r   )r   rL   r   rR   )r   rD   r   r   )r   rD   r   r   )r   rN   )r   rR   r   r   r   r   r   rR   )r   r   r   rR   )r   r   r   rR   )r   r   r   rR   )r  rR   r  r   r   r   r   rR   )
r  rR   r  rR   r  r   r   r   r   rR   )F)
r
  rR   r  rU   r   r   r  r   r   rR   r   rR   )r  r  r   r   r   rR   )NN)r  rR   r   r  r   r   r!  r"  r#  r$  r   rR   )r   rR   r  rD   r  rD   r   r   )r)  r   r   rR   )r,  rR   r-  r   r   r  r.  r/  r   r   r!  r"  r#  r0  r   rR   )r-  r   r   rR   )r5  r   r6  r  r   r   r   rR   )r9  rU   r:  rR   r;  rR   r   r   r   r   r   rR   )
r:  rR   r;  rR   r   r   r   r   r   rR   )rD  rR   r   r   r   rR   )rG  r  r   r   r   rR   )
rJ  r<   rK  r   rD  rR   r   r   r   r   )rP  r   r   r   r   r   )
rP  r   r   r   rT  rD   rU  rD   r   r   )rZ  r   r   r   r   rR   )rZ  r   r   r   r   r   r   rR   )r   rN   ra  rb  r   r   r   r   )
r   rN   ra  rb  rh  r   r   r   r   r   )r~  r  r   r   r   r   )r   r   )r   r  r   )
r  r   r  rR   r  r  r  r/  r   r   )
r)  r   r  rU   r   r   r  r  r   rR   )rD  r  r   rR   )rj  )r  r   r   r   r  r   r   rn   )rj  F)r   r  r   r   r   r   r   rR   )r   r  r  rR   r   r   r   r   )r  rR   r  rU   r   r   r   rR   )r   rr   r  rR   r   r   r   r   )r  rn   r  rR   r   r   r   r   )r   rr   r  rR   r   r   r   r   )r  rD   r  rD   r   r   )r9  rU   r   rn   )r   rR   r   rn   )r   rR   r   r  )r   rR   r   r  )r  r   r   r  )r  r   r   rU   )r  r-   r   rU   )r  r   r   r  )r  r   r   r-   )rZ  r   r   r   )r  r   r   r   )r  r%   r   r   )r  r   r   rI  )rP  r'   r)  r   r-  r   rS  r   r  r-   r   r   r   r   )r  r   r   r   )r  r   rX  r   r   r  r   rR   )r  r   r   rR   )rn  ro  r   rp  )r   )r   rw  r   r   )r   r{  )r   N)r  r;   r-  r   r}  rU   r   rw  r  r/  r   r  )r  r  r  rU   r  r   r   rN   )r  r"   r   r  )r  r"   r  rU   r  r   r   rN   )r  r"   r  rU   r  r   r   rq   )r  r;   r   rq   )r  r"   r   r  r   r  )r  r  r   rU   )r   r   r   rU   )
r  r"   r  rU   r,  r  r  r   r   rn   )r  r   r   rR   )r-  r   r   r   r   rR   )r)  r   r   r   r   rR   )r   r   r   r   )r  r   r   r   r   r   )r  r?   r   r   r   r   )pr   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+  r2  r4  r8  r=  r?  rC  rF  rI  rO  rV  rS  r]  r`  rg  rq  rv  rt  ru  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@  rB  rH  rT  rV  rO  rd  rm  rs  rz  r~  r   r  r   r  r  r  r  r  r  r  r   r  r  r  r  r  r  r  r  r9   r  r  r  r  r   r   r   r   r      s	       F  F  F  F T: : : : =B      X    X JO      >) ) ) )
$ $ $ $" " " "+ + + +. . . .# # # #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= = = =? ? ? ?? ? ? ?3 3 3 33 3 3 3
N N N N	$ 	$ 	$ 	$< < < <V V V V
8 
8 
8 
8( ( ( (( ( ( ($, , , ,X X X X$ $ $ $
d d d d' ' ' '        "&	B '+B B B B B B* NR
 
 
 
 
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
; 
; 
; 
;   ,8 8 8 88 8 8 8. . . .
Y Y Y Y,/ / / /   C C C CV V V V   >   (W W W W)
 )
 )
 )
V
 
 
 
   .* * * * *&	M 	M 	M 	M  #%"&'& '& '& '& ^'&R HO 	 	 	 	 	* * * *      >C    O O O O   . . . .- - - - _d1 1 1 1 1$\ \ \ \: : : :&D D D D
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   rR   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  )initializerrt   r   r   	is_nestedr)  variabler-  r   r  r9  r   rK   r   callable_classru  r  rG   self_regr   )r-  rn  r   r{  r   s    r   get_defaultz%gen_arg_defaults.<locals>.get_defaultG  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   rk  Nr  )r   r{  	argumentsr  r  r  r   rq   r  r9  error_overlaprg  r   rq  )r   nbr  r  rn  r{  r   s   `   @@@r   gen_arg_defaultsr  ;  s     O!E	
B    ? 	^^CL11F        ( f&>?????/C8) &&vS_EYZZZZ..O["co6J   aA   r   r-  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__)replacery  s    r   r  r  f  s     <<[)))r   refr   c                    t          | j        t                    r:t          | j        j                  }t          |t
                    r|j        j        S | j        S r   )r   r   r$   r2   r   r*   r9  r)  )r  r   s     r   r[  r[  q  sL    #(I&& ( 11fh'' 	(;''<r   )r   r   r   r   )r-  r   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'   
mypy.typesr(   r)   r*   r+   r,   r-   r.   r/   r0   r1   r2   	mypy.utilr3   mypy.visitorr4   r5   mypyc.commonr6   r7   r8   mypyc.crashr9   mypyc.errorsr:   mypyc.ir.class_irr;   r<   mypyc.ir.func_irr=   r>   r?   r@   rA   mypyc.ir.opsrB   rC   rD   rE   rF   rG   rH   rI   rJ   rK   rL   rM   rN   rO   rP   rQ   rR   mypyc.ir.rtypesrS   rT   rU   rV   rW   rX   rY   rZ   r[   r\   r]   r^   r_   r`   ra   rb   rc   mypyc.irbuild.contextrd   re   mypyc.irbuild.ll_builderrf   mypyc.irbuild.mapperrg   mypyc.irbuild.nonlocalcontrolrh   ri   rj   rk   mypyc.irbuild.prebuildvisitorrl   mypyc.irbuild.preparerm   mypyc.irbuild.targetsrn   ro   rp   rq   rr   mypyc.irbuild.utilrs   rt   mypyc.optionsru   mypyc.primitives.dict_opsrv   rw   mypyc.primitives.generic_opsrx   ry   rz   mypyc.primitives.list_opsr{   r|   r}   mypyc.primitives.misc_opsr~   r   r   mypyc.primitives.registryr   r   r   __annotations__r   	Exceptionr   r  r   r  r  r[  r   r   r   <module>r     s
     # " " " " " % % % % % % B B B B B B B B B B B B B B B B & & & & & &       2 2 2 2 2 2                                                       8                          # " " " " " < < < < < < < < ? ? ? ? ? ? ? ? ? ? $ $ $ $ $ $       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c' c' c' c' c' c' c' c'L%( ( ( (V* * * *     r   