
    5 fAr                       U d Z ddlmZ ddlmZmZ ddlmZmZm	Z	m
Z
mZmZmZmZmZmZmZmZmZ ddlmZmZ ddlmZmZmZmZmZmZmZmZ 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/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9 ddl:m;Z; dd	l<m=Z=m>Z>m?Z?m@Z@ dd
lAmBZBmCZCmDZDmEZE ddlFmGZGmHZHmIZImJZJ ddlKmLZL ddlMmNZN ede	egee         f         ZOi ZPdeQd<   	 dldmdZRdndZS	 dldod ZT	 dldpd#ZU eUd$          dnd%            ZV eUd&           eUd'           eUd(           eUd)           eUd*           eUd+           eUd,           eUd-          dnd.                                                                                                ZW eUd/          dnd0            ZX eUd1          dnd2            ZY eUd1          dnd3            ZZ eUd4          dnd5            Z[ eUd6          dnd7            Z\ eUd8           eUd9          dnd:                        Z] eUd4           eUd;           eUd<           eUd8           eUd9           eUd=           eUd>           eUd?e8           eUd@e6           eUdAe'           eUdAe7          dndB                                                                                                                                    Z^ eUdC          dndD            Z_ eUdE          dndF            Z`dqdOZa eUdP          dndQ            Zb eUdR           eUdS           eUdT           eUdU          dndV                                                Zc eUdW          dndX            Zd eUdY          dndZ            Ze eUd[e'          dnd\            Zf eUd]e8          dnd^            Zg eUd?e8          dnd_            Zh eUd*          dnd`            Zi eUd+          dnda            Zj eUd,          dndb            Zk eUd-          dndc            ZldrdgZm eUd'          dndh            Zn eUdi          dndj            Zo eUd(          dndk            ZpdS )sa0  Special case IR generation of calls to specific builtin functions.

Most special cases should be handled using the data driven "primitive
ops" system, but certain operations require special handling that has
access to the AST/IR directly and can make decisions/optimizations
based on it. These special cases can be implemented here.

For example, we use specializers to statically emit the length of a
fixed length tuple and to emit optimized code for any()/all() calls with
generator comprehensions as the argument.

See comment below for more documentation.
    )annotations)CallableOptional)	ARG_NAMEDARG_POSCallExprDictExpr
ExpressionGeneratorExprIntExprListExpr
MemberExprNameExprRefExprStrExpr	TupleExpr)AnyType	TypeOfAny)
BasicBlockExtendIntegerRaiseStandardErrorRegisterTruncateUnreachableValue)	RInstance
RPrimitiveRTupleRTypebool_rprimitivec_int_rprimitivedict_rprimitiveint16_rprimitiveint32_rprimitiveint64_rprimitiveint_rprimitiveis_bool_rprimitiveis_dict_rprimitiveis_fixed_width_rtypeis_float_rprimitiveis_int16_rprimitiveis_int32_rprimitiveis_int64_rprimitiveis_int_rprimitiveis_list_rprimitiveis_uint8_rprimitivelist_rprimitiveset_rprimitivestr_rprimitiveuint8_rprimitive)	IRBuilder)comprehension_helper*sequence_from_generator_preallocate_helpertranslate_list_comprehensiontranslate_set_comprehension)FormatOpconvert_format_expr_to_strjoin_formatted_stringstokenizer_format_call)dict_items_opdict_keys_opdict_setdefault_spec_init_opdict_values_op)new_list_set_item_op)new_tuple_set_item_opr6   z1dict[tuple[str, RType | None], list[Specializer]]specializersNbuilderexprr   calleer   name
str | NonetypRType | NonereturnValue | Nonec                j    |r0||ft           v r%t           ||f         D ]} || ||          }||c S d S N)rE   )rF   rG   rH   rI   rK   specializervals          N/var/www/equiseq/venv/lib/python3.11/site-packages/mypyc/irbuild/specialize.py_apply_specializationrT   n   s]      s|++'c	2 	 	K+gtV44C


 4    c                0    t          | |||j                  S )zIInvoke the Specializer callback for a function if one has been registered)rT   fullnamerF   rG   rH   s      rS   apply_function_specializationrY   ~   s     !$HHHrU   r   c                H    ||j         n|j        }t          | ||||          S )zGInvoke the Specializer callback for a method if one has been registered)rW   rI   rT   )rF   rG   rH   rK   rI   s        rS   apply_method_specializationr[      s+     "k6??v{D $cBBBrU   str$Callable[[Specializer], Specializer]c                     d fd}|S )zDecorator to register a function as being a specializer.

    There may exist multiple specializers for one function. When
    translating method calls, the earlier appended specializer has
    higher priority.
    fSpecializerrM   c                h    t                               fg                               |            | S rP   )rE   
setdefaultappend)r_   rI   rK   s    rS   wrapperz$specialize_function.<locals>.wrapper   s0    sR0077:::rU   )r_   r`   rM   r`    )rI   rK   rd   s   `` rS   specialize_functionrf      s.           NrU   zbuiltins.globalsc                ^    t          |j                  dk    r|                                 S d S )Nr   )lenargsload_globals_dictrX   s      rS   translate_globalsrk      s,    
49~~((***4rU   zbuiltins.abszbuiltins.intzbuiltins.floatzbuiltins.complexzmypy_extensions.i64zmypy_extensions.i32zmypy_extensions.i16zmypy_extensions.u8c                   t          |j                  dk    r|j        t          gk    rt	          |t
                    r|j        d         }|                     |          }|j                            d          d         }|dv rd}nd| d}t	          |t                    rM|j
                            |          r3|                     |          }|                     ||g d|j                  S dS )zSpecialize calls on native classes that implement the associated dunder.

    E.g. i64(x) gets specialized to x.__int__() if x is a native instance.
       r   .)i64i32i16u8__int____N)rh   ri   	arg_kindsr   
isinstancer   	node_typerW   splitr   class_ir
has_methodacceptgen_method_callline)rF   rG   rH   argarg_typ	shortnamemethodobjs           rS   $translate_builtins_with_unary_dunderr      s     49~~t~'::z&RZ?[?[:il##C((O))#..q1	333FF')'''Fgy)) 	Mg.>.I.I&.Q.Q 	M..%%C**3D$)LLL4rU   zbuiltins.lenc                   t          |j                  dk    r|j        t          gk    r|j        d         }|                     |          }t          |t                    r6|                     |           t          t          |j	                            S t          |                     |                    rd}nd}|                     ||          }|                     ||j                  S d S )Nrm   r   TF
can_borrow)rh   ri   ru   r   rw   rv   r   r{   r   typesr0   builtin_lenr}   )rF   rG   rH   r~   
expr_rtypeborrowr   s          rS   translate_lenr      s    
49~~t~'::il&&s++
j&)) 	7 NN33z/00111!'"3"3C"8"899 ...88C&&sDI6664rU   zbuiltins.listc                t   t          |j                  dk    r|j        t          gk    sdS |j        d         }t	          |t
                    r!|j        st	          |j        t                    sdS |j        j        }|j        j	        }| 
                    |          }t          |          r|dv sdS |                     |          }|dk    r"|                     t          |g|j                  S |dk    r"|                     t           |g|j                  S |                     t"          |g|j                  S )zSpecialize a common case when list() is called on a dictionary
    view method call.

    For example:
        foo = list(bar.keys())
    rm   Nr   )keysvaluesitemsr   r   )rh   ri   ru   r   rv   r   rH   r   rG   rI   rw   r)   r{   call_cr@   r}   rB   r?   )rF   rG   rH   r~   baseattrrtyper   s           rS   dict_methods_fast_pathr      s#    	NNaDNwi$?$?t
)A,CsH%% ch :cjR\;];] t:?D:?Dd##Eu%% $2M*M*Mt
..

C v~~~~lSE49===			~~nseTY???~~mcUDI>>>rU   c                    t          |j                  dk    rc|j        d         t          k    rMt	          |j        d         t
                    r-t          | |j        d         | j        j        t                    S dS )zSpecial case for simplest list comprehension.

    For example:
        list(f(x) for x in some_list/some_tuple/some_str)
    'translate_list_comprehension()' would take care of other cases
    if this fails.
    rm   r   empty_op_llbuilderset_item_opN)
rh   ri   ru   r   rv   r   r8   rF   new_list_op_with_lengthrC   rX   s      rS   "translate_list_from_generator_callr      sx     	DI!N1((ty|]33 ) :IaL&F,	
 
 
 	
 4rU   zbuiltins.tuplec                    t          |j                  dk    rc|j        d         t          k    rMt	          |j        d         t
                    r-t          | |j        d         | j        j        t                    S dS )zSpecial case for simplest tuple creation from a generator.

    For example:
        tuple(f(x) for x in some_list/some_tuple/some_str)
    'translate_safe_generator_call()' would take care of other cases
    if this fails.
    rm   r   r   N)
rh   ri   ru   r   rv   r   r8   rF   new_tuple_with_lengthrD   rX   s      rS   #translate_tuple_from_generator_callr     sx     	DI!N1((ty|]33 ) :IaL&D-	
 
 
 	
 4rU   builtins.setc                    t          |j                  dk    rQ|j        d         t          k    r;t	          |j        d         t
                    rt          | |j        d                   S dS )zSpecial case for set creation from a generator.

    For example:
        set(f(...) for ... in iterator/nested_generators...)
    rm   r   N)rh   ri   ru   r   rv   r   r:   rX   s      rS   !translate_set_from_generator_callr   (  s^     	DI!N1((ty|]33 ) +7DIaLAAA4rU   builtins.minzbuiltins.maxc                   |j         t          t          gk    r|                     |j        d                   |                     |j        d                   }}t	          |                     |                    }|j        dk    r|                     ||d|j                  }n|                     ||d|j                  }t                      t                      t                      }	}}| 
                    |||           |                     |           |                     ||                     ||j        |j                  |j                   |                     |	           |                     |           |                     ||                     ||j        |j                  |j                   |                     |	           |                     |	           |S d S )Nr   rm   r   <>)ru   r   r{   ri   r   rw   rW   	binary_opr}   r   add_bool_branchactivate_blockassigncoercetypegoto)
rF   rG   rH   xyresult
comparison
true_blockfalse_block
next_blocks
             rS   faster_min_maxr   :  s    ~'7+++~~dil++W^^DIaL-I-I1'++D1122?n,, **1adi@@JJ **1adi@@J.8llJLL*,,K

JDDDz***vw~~adiHH$)TTTZ   {+++vw~~adiHH$)TTTZ   z***4rU   zbuiltins.frozensetzbuiltins.dictzbuiltins.sortedzcollections.OrderedDictjoinextendupdatec           	         t          |j                  dk    r)|j        d         t          k    rt	          |j        d         t
                    rt	          |t                    r                                          |j	                  |j
        t           |j        d                   g fd|j        dd         D             z                        |          |j        |j        |j                  S                      ||t           |j        d                   g fd|j        dd         D             z             S dS )zuSpecial cases for things that consume iterators where we know we
    can safely compile a generator into a list.
    r   c                :    g | ]}                     |          S re   r{   .0r~   rF   s     rS   
<listcomp>z1translate_safe_generator_call.<locals>.<listcomp>r  %    DDDsw~~c**DDDrU   rm   Nc                :    g | ]}                     |          S re   r   r   s     rS   r   z1translate_safe_generator_call.<locals>.<listcomp>  r   rU   )rh   ri   ru   r   rv   r   r   r|   r{   rG   rI   r9   rw   r}   	arg_namescall_refexpr_with_argsrX   s   `  rS   translate_safe_generator_callr   V  sG   $ 	DIN1((ty|]33 ) fj)) 	**v{++1'49Q<HHIDDDDdimDDDE !!$''	   111'49Q<HHIDDDDdimDDDE	   4rU   zbuiltins.anyc                    t          |j                  dk    rZ|j        t          gk    rIt	          |j        d         t
                    r)t          | |j        d         | j        d | j                  S d S )Nrm   r   c                    | S rP   re   )r   s    rS   <lambda>z$translate_any_call.<locals>.<lambda>  s    a rU   )	rh   ri   ru   r   rv   r   any_all_helperfalsetruerX   s      rS   translate_any_callr     si     	DI!Nwi''ty|]33 ( gty|W]KKQXQ]^^^4rU   zbuiltins.allc                     t          j                  dk    r]j        t          gk    rLt	          j        d         t
                    r,t           j        d          j         fd j                  S d S )Nrm   r   c                <                         | dj                  S )Nnot)unary_opr}   )r   rF   rG   s    rS   r   z$translate_all_call.<locals>.<lambda>  s    g&&q%;; rU   )	rh   ri   ru   r   rv   r   r   r   r   rX   s   `` rS   translate_all_callr     s     	DI!Nwi''ty|]33 ( IaLL;;;;;M
 
 	
 4rU   genr   initial_valueCallable[[], Value]modifyCallable[[Value], Value]	new_valuer   c           	        	
 t          t                    	                     	 |            d           t          t	          j        j        j        j                            }t                      t                      t                      c
d 	
fd}t           ||j                                                   	S )NrM   Nonec                 8                         j                            }                     |                                                                            d                                                                         d S )Nr   )r{   	left_exprr   r   r   r   )	r   rF   
exit_blockr   r   r   r   retvalr   s	    rS   gen_inner_stmtsz'any_all_helper.<locals>.gen_inner_stmts  s    VGNN3=99::

JDDDz***vyy{{B///Z   {+++++rU   rM   r   )r   r!   r   listzipindices	sequences	condlistsis_asyncr   r7   r}   goto_and_activate)rF   r   r   r   r   loop_paramsr   r   r   r   r   s   `` ``  @@@@rS   r   r     s     o&&FNN6==??B///s3;s}clSSTTK*4,,
jll'JZ, , , , , , , , , , , , , +IIIj)))MrU   zbuiltins.sumc                    t          |j                  dv r6|j        d         t          k    r t	          |j        d         t
                    sd S t          |j                  dk    r+|j        d         t          t          fvrd S |j        d         }nt          d          }|j        d                              |          }t          |           
                                                              |          |d          d           d	 fd}t          t          j        j        j        j                            }t'           ||j                   S )
N)rm      r   r   rm   r   rM   r   c            	                              j                  }                                         | dd          d           d S )N+r   )r{   r   r   r   )	call_exprrF   gen_exprr   s    rS   r   z+translate_sum_call.<locals>.gen_inner_stmts  sG    NN8#566	vw00CLLbQQQQQrU   r   )rh   ri   ru   r   rv   r   r   r   rw   r   r   r   r{   r   r   r   r   r   r   r7   r}   )	rF   rG   rH   
start_exprtarget_typer   r   r   r   s	   `      @@rS   translate_sum_callr     sn    	DI&  N1((ty|]33 ) t 49~~>!Wi$8884Yq\

QZZ
y|H##D))Kk""FNN67>>'..*D*DkSUVVXZ[[[R R R R R R R R Hh0(2DhFWXX K +NNNMrU   zdataclasses.fieldzattr.ibzattr.attribzattr.Factoryc                H    t          t          j                  | j        |<   dS )a,  Special case for 'dataclasses.field', 'attr.attrib', and 'attr.Factory'
    function calls because the results of such calls are type-checked
    by mypy using the types of the arguments to their respective
    functions, resulting in attempted coercions by mypyc that throw a
    runtime error.
    N)r   r   
from_errorr   rX   s      rS    translate_dataclasses_field_callr     s      ")"677GM$4rU   zbuiltins.nextc                d    |j         t          gt          t          gfv r t          |j        d         t                    sdS |j        d         t                               |                    t          |j                  dk    r                      |j        d                   nd}t                      d fd}t          t          j        j        j        j                            }t!           ||j                   |r7                     |j        j                                                   nT                     t-          t,          j        d|j                                                  t1                                                                 S )a6  Special case for calling next() on a generator expression, an
    idiom that shows up some in mypy.

    For example, next(x for x in l if x.id == 12, None) will
    generate code that searches l for an element where x.id == 12
    and produce the first such object, or None if no such element
    exists.
    r   Nrm   rM   r   c                                                                j                  j        j                                                   d S rP   )r   r{   r   r}   r   )rF   r   r   r   s   rS   r   z,translate_next_call.<locals>.gen_inner_stmts  sF     	vw~~cm<<cm>PQQQZ     rU   r   )ru   r   rv   ri   r   r   rw   rh   r{   r   r   r   r   r   r   r   r7   r}   r   r   r   addr   STOP_ITERATIONr   r   )	rF   rG   rH   default_valr   r   r   r   r   s	   `     @@@rS   translate_next_callr     s    	G9w&8999ty|]33 	: t
)A,Cg''--..F25di..12D2D'..1...$KJ! ! ! ! ! ! ! ! ! s3;s}clSSTTK+III
  #v{CM,>???Z    &'9'H$PTPYZZ[[[KMM""":&&&MrU   zbuiltins.isinstancec                   t          |j                  dk    r|j        t          t          gk    rt	          |j        d         t
          t          f          rt          t          j	                  | j
        |j        d         <   |                     |j        d                   }|\t          d |D                       }|                     |j        d         |          }| j                            |||j                  S dS )zSpecial case for builtins.isinstance.

    Prevent coercions on the thing we are checking the instance of -
    there is no need to coerce something to a new type before checking
    what type it is, and the coercion could lead to bugs.
    r   rm   r   Nc              3  D   K   | ]}|j         o|j         o|j         V  d S rP   )is_ext_classinherits_pythonallow_interpreted_subclasses)r   irs     rS   	<genexpr>z'translate_isinstance.<locals>.<genexpr>0  sN         b(:$:b2Cb?b     rU   r   )rh   ri   ru   r   rv   r   r   r   r   r   r   flatten_classesallr{   rF   isinstance_helperr}   )rF   rG   rH   irsr   r   s         rS   translate_isinstancer    s     	DI!Nw000ty|gy%9:: 1 '.i.B&C&Cdil#%%dil33?      J ..1*.EEC?44S#tyIII4rU   rb   c                l   t          |j                  dk    r|j        t          t          gk    rt	          |t
                    rl|j        d         }t	          |t                    r2t          |j                  rdS t          dt          |j
                  }nt	          |t                    r2t          |j                  rdS t          dt          |j
                  }nst	          |t                    r\t	          |j        t                    rB|j        j        dk    r2t          |j                  rdS t          dt          |j
                  }ndS |                     |j                  }|                     |j        d                   }|                     t&          |||g|j
                  S dS )a  Special case for 'dict.setdefault' which would only construct
    default empty collection when needed.

    The dict_setdefault_spec_init_op checks whether the dict contains
    the key and would construct the empty collection only once.

    For example, this specializer works for the following cases:
         d.setdefault(key, set()).add(value)
         d.setdefault(key, []).append(value)
         d.setdefault(key, {})[inner_key] = inner_val
    r   rm   Nr      r   )rh   ri   ru   r   rv   r   r   r   r   r"   r}   r	   r   rH   r   rW   r{   rG   r   rA   )rF   rG   rH   r~   	data_typecallee_dictkey_vals          rS   translate_dict_setdefaultr  9  s    	DI!Nw000vz** 1 ilc8$$ 	39~~ t#3TY??IIX&& 	39~~ t#3TY??IIsH%%		3:x00		 
#~5538}} t#3TY??II4nnV[11..1..~~(;*KTY
 
 	
 4rU   formatc                   t          |t                    rt          |j        t                    r|j                            t                    t          |j                  k    r[|j        j        }t          |          }|d S |\  }}t          | ||j        |j                  }|d S t          | |||j                  S d S rP   )rv   r   rG   r   ru   countr   rh   valuer>   r<   ri   r}   r=   )rF   rG   rH   
format_strtokensliterals
format_opssubstitutionss           rS   translate_str_formatr  g  s     	6:&&Sv{G,,S N  ))S-@-@@@[&
&z22>4%*27J	SWS\]] 4%gx	RRR4rU   c                   t          |t                    r3t          |j        t                    r|j        j        dk    r|j        t          gk    rt          |j        d         t                    r|j        d         j	        D ]}t          |t                    rt          |t                    rt          |j        t                    r|j        j        dk    r dS t          |j        j        t                    r|j        j        j        dk    r dS t          |j        d         t                    r|j        d         j        dk    r dS  dS g }g }|j        d         j	        D ]}t          |t                    r@|j        dk    r5|                    t          j                   |                    |           Wt          |t                    r?|                    t          j                   |                    |j        d                    t!          | |||j                  }|dS t%          | d||j                  S dS )zSpecial case for f-string, which is translated into str.join()
    in mypy AST.

    This specializer optimizes simplest f-strings which don't contain
    any format operation.
     r   r	  Nz{:{}}rm   )rv   r   rG   r   r  ru   r   ri   r   r   r   rH   rI   rc   r;   STRr<   r}   r=   )rF   rG   rH   itemr  exprsr  s          rS   translate_fstringr  {  s,    	6:&&&Ov{G,,&O K##Nwi''ty|X.. ( IaL& 	 	D$(( D(++ !$+z::  dk>NRZ>Z>Z44"4;#3W== AEAQAW[bAbAb44!$)A,88  DIaL<NRT<T<T44 =U tt
"$IaL& 	+ 	+D$(( +TZ2-=-=!!(,///T""""D(++ +!!(,///TYq\***27JtyYY 4%gt]DINNN4rU   c                   t          |j                  dk    s|j        d         t          k    rd S |j        d         }|                     |          }t          |          r|                     |          S t          |          st          |          rE|                     |          }| 	                    t          |t          d|j                            S t          |          rE|                     |          }| 	                    t          |t          d|j                            S t          |          st          |          r6|                     |          }|                     |t          |j                  S d S )Nrm   r   Tsignedr}   F)rh   ri   ru   r   rw   r.   r{   r-   r,   r   r   r&   r}   r1   r/   r(   r   rF   rG   rH   r~   arg_typerR   s         rS   translate_i64r    s^   
49~~dnQ/7::t
)A,C  %%H8$$ 
@~~c"""	X	&	& @*=h*G*G @nnS!!{{6#'749UUUVVV	X	&	& @nnS!!{{6#'7DIVVVWWW	8	$	$ @(:8(D(D @nnS!!~~c#3TY???4rU   c                   t          |j                  dk    s|j        d         t          k    rd S |j        d         }|                     |          }t          |          r|                     |          S t          |          rD|                     |          }|                     t          |t          |j                            S t          |          rE|                     |          }|                     t          |t          d|j                            S t          |          rE|                     |          }|                     t          |t          d|j                            S t          |          st!          |          rK|                     |          }t#          |t                    }|                     |t          |j                  S d S )Nrm   r   r}   Tr  F)rh   ri   ru   r   rw   r-   r{   r.   r   r   r%   r}   r,   r   r1   r/   r(   truncate_literalr   r  s         rS   translate_i32r"    s   
49~~dnQ/7::t
)A,C  %%H8$$ @~~c"""	X	&	& @nnS!!{{8C)9	JJJKKK	X	&	& 	@nnS!!{{6#'749UUUVVV	X	&	& @nnS!!{{6#'7DIVVVWWW	8	$	$ @(:8(D(D @nnS!!s$455~~c#3TY???4rU   c                0   t          |j                  dk    s|j        d         t          k    rd S |j        d         }|                     |          }t          |          r|                     |          S t          |          st          |          rD|                     |          }| 	                    t          |t          |j                            S t          |          rE|                     |          }| 	                    t          |t          d|j                            S t          |          st!          |          rK|                     |          }t#          |t                    }|                     |t          |j                  S d S )Nrm   r   r   Fr  )rh   ri   ru   r   rw   r,   r{   r-   r.   r   r   r$   r}   r1   r   r/   r(   r!  r   r  s         rS   translate_i16r$    sl   
49~~dnQ/7::t
)A,C  %%H8$$ @~~c"""	X	&	& 	@*=h*G*G 	@nnS!!{{8C)9	JJJKKK	X	&	& @nnS!!{{6#'7DIVVVWWW	8	$	$ @(:8(D(D @nnS!!s$455~~c#3TY???4rU   c                   t          |j                  dk    s|j        d         t          k    rd S |j        d         }|                     |          }t          |          r|                     |          S t          |          st          |          st          |          rD|                     |          }| 
                    t          |t          |j                            S t          |          st          |          rK|                     |          }t!          |t                    }|                     |t          |j                  S d S )Nrm   r   r   )rh   ri   ru   r   rw   r1   r{   r,   r-   r.   r   r   r5   r}   r/   r(   r!  r   r  s         rS   translate_u8r&    s9   
49~~dnQ/7::t
)A,C  %%H8$$ @~~c"""H%%
@x((
@ x((
@
 nnS!!{{8C)9	JJJKKK	8	$	$ @(:8(D(D @nnS!!s$455~~c#3TY???4rU   r  r   r   c                    t          | t                    s| S |                                 }d|j        dz  z  dz
  }||z  }|j        r||dz   dz  k    r||dz   z  }t          ||          S )zIf value is an integer literal value, truncate it to given native int rtype.

    For example, truncate 256 into 0 if rtype is u8.
    rm      r   )rv   r   numeric_valuesize	is_signed)r  r   r   max_unsigneds       rS   r!  r!    s    
 eW%% A%*q.)Q.L	LA 1!1a 777	\A1erU   c                p   t          |j                  dk    s|j        d         t          k    rd S |j        d         }|                     |          }t          |          st          |          st          |          r6|                     |          }| 	                    |t          |j                  S d S Nrm   r   )rh   ri   ru   r   rw   r(   r/   r*   r{   r   r'   r}   )rF   rG   rH   r~   r  srcs         rS   translate_intr0    s    
49~~dnQ/7::t
)A,C  %%H8$$>X&&>  ))>
 nnS!!~~c>49===4rU   zbuiltins.boolc                    t          |j                  dk    s|j        d         t          k    rd S |j        d         }|                     |          }| j                            |          S r.  )rh   ri   ru   r   r{   rF   
bool_value)rF   rG   rH   r~   r/  s        rS   translate_boolr3  $  s]    
49~~dnQ/7::t
)A,C
..

C?%%c***rU   c                    t          |j                  dk    s|j        d         t          k    rd S |j        d         }|                     |          }t          |          r|                     |          S d S r.  )rh   ri   ru   r   rw   r+   r{   )rF   rG   rH   r~   r  s        rS   translate_floatr5  -  sp    
49~~dnQ/7::t
)A,C  %%H8$$ #~~c"""4rU   rP   )rF   r6   rG   r   rH   r   rI   rJ   rK   rL   rM   rN   )rF   r6   rG   r   rH   r   rM   rN   )
rF   r6   rG   r   rH   r   rK   rL   rM   rN   )rI   r\   rK   rL   rM   r]   )rF   r6   r   r   r   r   r   r   r   r   rM   r   )r  r   r   r   rM   r   )q__doc__
__future__r   typingr   r   
mypy.nodesr   r   r   r	   r
   r   r   r   r   r   r   r   r   
mypy.typesr   r   mypyc.ir.opsr   r   r   r   r   r   r   r   mypyc.ir.rtypesr   r   r   r    r!   r"   r#   r$   r%   r&   r'   r(   r)   r*   r+   r,   r-   r.   r/   r0   r1   r2   r3   r4   r5   mypyc.irbuild.builderr6   mypyc.irbuild.for_helpersr7   r8   r9   r:   "mypyc.irbuild.format_str_tokenizerr;   r<   r=   r>   mypyc.primitives.dict_opsr?   r@   rA   rB   mypyc.primitives.list_opsrC   mypyc.primitives.tuple_opsrD   r`   rE   __annotations__rT   rY   r[   rf   rk   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  r5  re   rU   rS   <module>rD     sn
     # " " " " " % % % % % % % %                              * ) ) ) ) ) ) )	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	                                                     6 , + + + + +                                  ; : : : : : < < < < < < Xw7%HI CE D D D D `d     I I I I QUC C C C C $(    " '((   )( ^$$^$$%&&'((*++*++*++)**   +* ,+ ,+ ,+ )( '& %$ %$, ^$$   %$& _%%? ? ? &%?< _%%   &%0 %&&   '&0 ^$$   %$" ^$$^$$   %$ %$4 %&&)**_%%^$$^$$&''.//V^,,X//X//X~..! ! ! /. 0/ 0/ -, 0/ (' %$ %$ &% +* '&!H ^$$   %$ ^$$   %$    4 ^$$# # # %$#L ())Y]##^$$
 
 
 %$ $#   *)
 _%%( ( ( &%(V *++   ,+2 \?33* * * 43*Z X~..   /.& V^,,. . . -,.b *++   ,+& *++   ,+. *++   ,+( )**   +**     ^$$   %$ _%%+ + + &%+ %&&   '&  rU   