U
    iâËd-v  ã                0   @   sº   d Z ddlZddlmZmZmZmZmZ ddlm	Z	 ddl
mZ ddlmZ ddlmZmZmZ eddd	„ƒZG d
d„ deeƒZG dd„ deeƒZG dd„ deeƒZedk� r¶e ¡  dS )z0
Test bytecode fixes provided in interpreter.py
é    N)ÚjitÚnjitÚobjmodeÚtypeofÚ	literally)Úoverload)Útypes)ÚUnsupportedError)ÚTestCaseÚMemoryLeakMixinÚskip_unless_py10_or_laterc/           /      C   s¼   | | | | | | | | | |	 |
 | | | | | | | | | | | | | | | | | | | | | |  |! |" |# |$ |% |& |' |( |) |* |+ |, |- |. S ©N© )/Úarg0Úarg1Úarg2Úarg3Úarg4Úarg5Úarg6Úarg7Úarg8Úarg9Úarg10Úarg11Úarg12Úarg13Úarg14Úarg15Zarg16Zarg17Zarg18Zarg19Zarg20Zarg21Zarg22Zarg23Zarg24Zarg25Zarg26Zarg27Zarg28Zarg29Zarg30Zarg31Zarg32Zarg33Zarg34Zarg35Zarg36Zarg37Zarg38Zarg39Zarg40Úarg41Zarg42Zarg43Zarg44Zarg45Zarg46r   r   úU/home/sam/Atlas/atlas_env/lib/python3.8/site-packages/numba/tests/test_interpreter.pyÚsum_jit_func   s¼    3ÿþýüûúùø	÷
öõôóòñðïîíìëêéèçæåäãâá à!ß"Þ#Ý$Ü%Û&Ú'Ù(Ø)×*Ö+Õ,Ô-Ó.Òÿr!   c                   @   s¼   e Zd ZdZdZdZdd„ Zedd„ ƒZedd	„ ƒZ	ed
d„ ƒZ
edd„ ƒZedd„ ƒZedd„ ƒZedd„ ƒZedd„ ƒZedd„ ƒZedd„ ƒZedd„ ƒZedd„ ƒZedd„ ƒZd S )!ÚTestCallFunctionExPeepHoleaž  
    gh #7812

    Tests that check a peephole optimization for Function calls
    in Python 3.10. The bytecode changes when
    (n_args / 2) + n_kws > 15, which moves the arguments from
    the stack into a tuple and dictionary.

    This peephole optimization updates the IR to use the original format.
    There are different paths when n_args > 30 and n_args <= 30 and when
    n_kws > 15 and n_kws <= 15.
    é   é   c           
      C   sð   dd„ t || ƒD ƒ}g }t || ƒD ]2}|d dkrDd|› d�}n
d|› �}| |¡ q&d |¡}d	|› d
�}|d7 }t |ƒD ]}|d|| › d�7 }q€t ||| ƒD ]"}|d|| › d|| › d�7 }q¨|d7 }i }	t|dti|	ƒ |	d S )zw
            Generates a function that calls sum_jit_func
            with the desired number of args and kws.
        c                 S   s   g | ]}d |› �‘qS )Úargr   ©Ú.0Úir   r   r    Ú
<listcomp>Š   s     z7TestCallFunctionExPeepHole.gen_func.<locals>.<listcomp>é   r   zpow(argz, 2)r%   z, z	def impl(z):
z    return sum_jit_func(
z        z,
ú=z    )
r!   Úimpl)ÚrangeÚappendÚjoinÚexecr!   )
ÚselfZn_argsZn_kwsZ
param_listZ	args_listr(   Úarg_valZtotal_paramsZ	func_textÚ
local_varsr   r   r    Úgen_func…   s$    

 z#TestCallFunctionExPeepHole.gen_funcc                 C   sP   dd„ t | jƒD ƒ}|  | jd¡}|}tƒ |ƒ}||Ž }||Ž }|  ||¡ dS )z˜
        Tests calling a function when n_args > 30 and
        n_kws = 0. This shouldn't use the peephole, but
        it should still succeed.
        c                 S   s   g | ]}|‘qS r   r   r&   r   r   r    r)   §   s     z<TestCallFunctionExPeepHole.test_all_args.<locals>.<listcomp>r   N)r-   ÚTHRESHOLD_ARGSr4   r   ÚassertEqual©r1   Ú
total_argsÚfÚpy_funcÚcfuncÚaÚbr   r   r    Útest_all_args    s    
z(TestCallFunctionExPeepHole.test_all_argsc                 C   sP   dd„ t | jƒD ƒ}|  d| j¡}|}tƒ |ƒ}||Ž }||Ž }|  ||¡ dS )zR
        Tests calling a function when n_kws > 15 and
        n_args = 0.
        c                 S   s   g | ]}|‘qS r   r   r&   r   r   r    r)   µ   s     z;TestCallFunctionExPeepHole.test_all_kws.<locals>.<listcomp>r   N)r-   ÚTHRESHOLD_KWSr4   r   r6   r7   r   r   r    Útest_all_kws¯   s    
z'TestCallFunctionExPeepHole.test_all_kwsc           	      C   sd   | j d }| jd }dd„ t|| ƒD ƒ}|  ||¡}|}tƒ |ƒ}||Ž }||Ž }|  ||¡ dS )zs
        Tests calling a function when (n_args / 2) + n_kws > 15,
        but n_args <= 30 and n_kws <= 15
        é   c                 S   s   g | ]}|‘qS r   r   r&   r   r   r    r)   Å   s     zHTestCallFunctionExPeepHole.test_small_args_small_kws.<locals>.<listcomp>N©r5   r?   r-   r4   r   r6   ©	r1   Ú	used_argsZused_kwsr8   r9   r:   r;   r<   r=   r   r   r    Útest_small_args_small_kws½   s    


z4TestCallFunctionExPeepHole.test_small_args_small_kwsc           	      C   s`   | j d }| j}dd„ t|| ƒD ƒ}|  ||¡}|}tƒ |ƒ}||Ž }||Ž }|  ||¡ dS )zr
        Tests calling a function when (n_args / 2) + n_kws > 15,
        but n_args <= 30 and n_kws > 15
        rA   c                 S   s   g | ]}|‘qS r   r   r&   r   r   r    r)   Õ   s     zHTestCallFunctionExPeepHole.test_small_args_large_kws.<locals>.<listcomp>NrB   rC   r   r   r    Útest_small_args_large_kwsÍ   s    

z4TestCallFunctionExPeepHole.test_small_args_large_kwsc           	      C   s`   | j }| jd }dd„ t|| ƒD ƒ}|  ||¡}|}tƒ |ƒ}||Ž }||Ž }|  ||¡ dS )zr
        Tests calling a function when (n_args / 2) + n_kws > 15,
        but n_args > 30 and n_kws <= 15
        rA   c                 S   s   g | ]}|‘qS r   r   r&   r   r   r    r)   å   s     zHTestCallFunctionExPeepHole.test_large_args_small_kws.<locals>.<listcomp>NrB   rC   r   r   r    Útest_large_args_small_kwsÝ   s    

z4TestCallFunctionExPeepHole.test_large_args_small_kwsc           	      C   s\   | j }| j}dd„ t|| ƒD ƒ}|  ||¡}|}tƒ |ƒ}||Ž }||Ž }|  ||¡ dS )zq
        Tests calling a function when (n_args / 2) + n_kws > 15,
        but n_args > 30 and n_kws > 15
        c                 S   s   g | ]}|‘qS r   r   r&   r   r   r    r)   õ   s     zHTestCallFunctionExPeepHole.test_large_args_large_kws.<locals>.<listcomp>NrB   rC   r   r   r    Útest_large_args_large_kwsí   s    
z4TestCallFunctionExPeepHole.test_large_args_large_kwsc                    s<   dd„ ‰ t ‡ fdd„ƒ}ttˆ ƒ ƒƒ}|ƒ }|  ||¡ dS )zO
        Tests calling an objectmode function with > 15 return values.
        c                   S   s   dS )N)r   rA   é   é   é   r*   é   é   é   é	   é
   é   é   é   é   é   r   r   r   r   r    r:     s    zBTestCallFunctionExPeepHole.test_large_kws_objmode.<locals>.py_funcc                     sš   t ddddddddddddddddd��, ˆ ƒ \} }}}}}}}}}	}
}}}}}W 5 Q R X | | | | | | | | | |	 |
 | | | | | S )zÆ
            Wrapper to call py_func from objmode. This tests
            large kws with objmode. If the definition for the
            call is not properly updated this test will fail.
            Zint64©r<   r=   ÚcÚdÚer9   ÚgÚhr(   ÚjÚkÚlÚmÚnÚoÚp)r   rV   ©r:   r   r    Úobjmode_func  sŠ    ð#ïð
ÿþýüûúùø	÷
öõôóòñÿzGTestCallFunctionExPeepHole.test_large_kws_objmode.<locals>.objmode_funcN)r   ÚsumÚlistr6   )r1   rd   r<   r=   r   rc   r    Útest_large_kws_objmodeý   s    =z1TestCallFunctionExPeepHole.test_large_kws_objmodec              	   C   sB   dd„ }|   t¡�}tƒ |ƒdƒ W 5 Q R X |  dt|jƒ¡ dS )ze
        Tests generating large args when one of the inputs
        has inlined controlflow.
        c              '   S   sZ   t ddddddddddddddddddddd| r4dnddddddddddddddddd�%S ©NrA   rI   )r   ©r!   ©Úflagr   r   r    Úinline_func^  sN    
ÛzRTestCallFunctionExPeepHole.test_large_args_inline_controlflow.<locals>.inline_funcFú9You can resolve this issue by moving the control flow outN©ÚassertRaisesr	   r   ZassertInÚstrÚ	exception©r1   rl   Zraisesr   r   r    Ú"test_large_args_inline_controlflowX  s    )þz=TestCallFunctionExPeepHole.test_large_args_inline_controlflowc                 C   s6   dd„ }|}t ƒ |ƒ}|dƒ}|dƒ}|  ||¡ dS )úœ
        Tests generating large args when one of the inputs
        has the change suggested in the error message
        for inlined control flow.
        c              '   S   s^   | rdnd}t ddddddddddddddddddddd|dddddddddddddddd�%S rh   ri   ©rk   Za_valr   r   r    rl   •  sP    ÛzVTestCallFunctionExPeepHole.test_large_args_noninlined_controlflow.<locals>.inline_funcFN©r   r6   ©r1   rl   r:   r;   r<   r=   r   r   r    Ú&test_large_args_noninlined_controlflowŽ  s    *
zATestCallFunctionExPeepHole.test_large_args_noninlined_controlflowc              	   C   sB   dd„ }|   t¡�}tƒ |ƒdƒ W 5 Q R X |  dt|jƒ¡ dS )zù
        Tests generating only large args when one of the inputs
        has inlined controlflow. This requires a special check
        inside peep_hole_call_function_ex_to_call_function_kw
        because it usually only handles varkwargs.
        c              %   S   sV   t ddddddddddddddddddddd| r4dndddddddddddddddƒ$S ©NrA   rI   ri   rj   r   r   r    rl   Í  sL    
ÜzPTestCallFunctionExPeepHole.test_all_args_inline_controlflow.<locals>.inline_funcFrm   Nrn   rr   r   r   r    Ú test_all_args_inline_controlflowÅ  s    (þz;TestCallFunctionExPeepHole.test_all_args_inline_controlflowc                 C   s6   dd„ }|}t ƒ |ƒ}|dƒ}|dƒ}|  ||¡ dS )rt   c              %   S   sZ   | rdnd}t ddddddddddddddddddddd|ddddddddddddddƒ$S ry   ri   ru   r   r   r    rl     sN    ÜzTTestCallFunctionExPeepHole.test_all_args_noninlined_controlflow.<locals>.inline_funcFNrv   rw   r   r   r    Ú$test_all_args_noninlined_controlflowü  s    )
z?TestCallFunctionExPeepHole.test_all_args_noninlined_controlflowc              	   C   sB   dd„ }|   t¡�}tƒ |ƒdƒ W 5 Q R X |  dt|jƒ¡ dS )zd
        Tests generating large kws when one of the inputs
        has inlined controlflow.
        c                 S   s0   t ddddddddddddddd| r(dndd�S ©NrA   rI   )r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   ri   rj   r   r   r    rl   8  s$    
ðzQTestCallFunctionExPeepHole.test_large_kws_inline_controlflow.<locals>.inline_funcFrm   Nrn   rr   r   r   r    Ú!test_large_kws_inline_controlflow2  s    þz<TestCallFunctionExPeepHole.test_large_kws_inline_controlflowc                 C   s6   dd„ }|}t ƒ |ƒ}|dƒ}|dƒ}|  ||¡ dS )z›
        Tests generating large kws when one of the inputs
        has the change suggested in the error message
        for inlined control flow.
        c                 S   s4   | rdnd}t ddddddddddddddd|d�S r|   ri   ru   r   r   r    rl   Z  s&    ðzUTestCallFunctionExPeepHole.test_large_kws_noninlined_controlflow.<locals>.inline_funcFNrv   rw   r   r   r    Ú%test_large_kws_noninlined_controlflowS  s    
z@TestCallFunctionExPeepHole.test_large_kws_noninlined_controlflowN)Ú__name__Ú
__module__Ú__qualname__Ú__doc__r5   r?   r4   r   r>   r@   rE   rF   rG   rH   rg   rs   rx   rz   r{   r}   r~   r   r   r   r    r"   u   s<   






Z
5
6
6
5
 r"   c                   @   sp   e Zd ZdZedd„ ƒZedd„ ƒZedd„ ƒZedd	„ ƒZed
d„ ƒZ	edd„ ƒZ
edd„ ƒZedd„ ƒZdS )ÚTestLargeConstDictað  
    gh #7894

    Tests that check a peephole optimization for constant
    dictionaries in Python 3.10. The bytecode changes when
    number of elements > 15, which splits the constant dictionary
    into multiple dictionaries that are joined by a DICT_UPDATE
    bytecode instruction.

    This optimization modifies the IR to rejoin dictionaries
    and remove the DICT_UPDATE generated code. This then allows
    code that depends on literal dictionaries or literal keys
    to succeed.
    c                 C   s2   dd„ }|}t ƒ |ƒ}|ƒ }|ƒ }|  ||¡ dS )úr
        Tests that a function with a large heterogeneous constant
        dictionary remains a constant.
        c                  S   s4   ddddddddddddddddddddœ} | d S )NrA   r<   ©ÚAÚBÚCÚDÚEÚFÚGÚHÚIÚJÚKÚLÚMÚNÚOÚPÚQÚRÚSr˜   r   ©rX   r   r   r    Ú
const_funcŒ  s*    ízJTestLargeConstDict.test_large_heterogeneous_const_dict.<locals>.const_funcNrv   )r1   rš   r:   r;   r<   r=   r   r   r    Ú#test_large_heterogeneous_const_dict†  s    
z6TestLargeConstDict.test_large_heterogeneous_const_dictc                    s6   dd„ ‰ t ˆ ƒ‡fdd„ƒ}t‡ fdd„ƒ}|ƒ  dS )zvCheck the literal values for a LiteralStrKeyDict requiring
        optimizations because it is heterogeneous.
        c                 S   s   d S r   r   r™   r   r   r    Úbar³  s    zYTestLargeConstDict.test_large_heterogeneous_LiteralStrKeyDict_literal_values.<locals>.barc                    s„   ddddddddddddddddddddœ}dd„ ‰ ‡ fdd„|  ¡ D ƒ}ˆ t| tjƒ¡ ˆ | j|¡ ˆ t| dƒd	¡ d
d„ S )NrA   r<   r…   c                 S   s   t  | ¡rt  | ¡S t| ƒS r   )r   Zmaybe_literalÚliteralr   )Úzr   r   r    Úspecific_tyÎ  s    zqTestLargeConstDict.test_large_heterogeneous_LiteralStrKeyDict_literal_values.<locals>.ol_bar.<locals>.specific_tyc                    s    i | ]\}}t  |¡ˆ |ƒ“qS r   )r   r�   )r'   ÚxÚy©rŸ   r   r    Ú
<dictcomp>Ð  s      zpTestLargeConstDict.test_large_heterogeneous_LiteralStrKeyDict_literal_values.<locals>.ol_bar.<locals>.<dictcomp>Úinitial_valueFc                 S   s   | S r   r   r™   r   r   r    Ú<lambda>Ô  ó    znTestLargeConstDict.test_large_heterogeneous_LiteralStrKeyDict_literal_values.<locals>.ol_bar.<locals>.<lambda>)ÚitemsÚ
assertTrueÚ
isinstancer   ZLiteralStrKeyDictr6   Zliteral_valueÚhasattr)rX   r<   Úexpected©r1   r¢   r    Úol_bar¶  s4    íz\TestLargeConstDict.test_large_heterogeneous_LiteralStrKeyDict_literal_values.<locals>.ol_barc                     s8   ddddddddddddddddddddœ} ˆ | ƒ d S )NrA   r<   r…   r   r™   ©rœ   r   r    ÚfooÖ  s*    ízYTestLargeConstDict.test_large_heterogeneous_LiteralStrKeyDict_literal_values.<locals>.fooN©r   r   ©r1   r­   r¯   r   ©rœ   r1   r    Ú9test_large_heterogeneous_LiteralStrKeyDict_literal_values­  s    zLTestLargeConstDict.test_large_heterogeneous_LiteralStrKeyDict_literal_valuesc                 C   s:   dd„ }|}t ƒ |ƒ}d}||ƒ}||ƒ}|  ||¡ dS )r„   c                 S   s4   dddddddddddddddddd| dœ}|d S )NrA   r…   r˜   r   )r<   rX   r   r   r    Úconst_keys_funcú  s*    ízTTestLargeConstDict.test_large_heterogeneous_const_keys_dict.<locals>.const_keys_funcÚa_stringNrv   )r1   r´   r:   r;   Úvaluer<   r=   r   r   r    Ú(test_large_heterogeneous_const_keys_dictô  s    
z;TestLargeConstDict.test_large_heterogeneous_const_keys_dictc                    s6   dd„ ‰ t ˆ ƒ‡fdd„ƒ}t‡ fdd„ƒ}|ƒ  dS )z�Checks that the optimization for large dictionaries
        do not incorrectly update initial values due to other
        mutations.
        c                 S   s   d S r   r   r™   r   r   r    rœ   #  s    zDTestLargeConstDict.test_large_dict_mutation_not_carried.<locals>.barc                    sf   ddddddddddddddddddddœ}| j d kr>dd„ S ˆ  t| tjƒ¡ ˆ  | j |¡ dd„ S )NrA   rM   r…   c                 S   s   t | ƒS r   ©r   r™   r   r   r    r¥   >  r¦   zYTestLargeConstDict.test_large_dict_mutation_not_carried.<locals>.ol_bar.<locals>.<lambda>c                 S   s   | S r   r   r™   r   r   r    r¥   A  r¦   ©r¤   r¨   r©   r   ÚDictTyper6   ©rX   r<   r¬   r   r    r­   &  s2    í
zGTestLargeConstDict.test_large_dict_mutation_not_carried.<locals>.ol_barc                     s@   ddddddddddddddddddddœ} d| d< ˆ | ƒ d S )NrA   rM   r…   rK   ÚXr   r™   r®   r   r    r¯   C  s,    ízDTestLargeConstDict.test_large_dict_mutation_not_carried.<locals>.fooNr°   r±   r   r²   r    Ú$test_large_dict_mutation_not_carried  s    z7TestLargeConstDict.test_large_dict_mutation_not_carriedc                    s„   dd„ ‰dd„ ‰ d‰d‰t ˆdd�‡‡fdd	„ƒ}t ˆ dd�‡‡fd
d„ƒ}‡ ‡fdd„}|}tƒ |ƒ}|ƒ }|ƒ }ˆ ||¡ dS )zf
        Tests an example using a regular update is
        not modified by the optimization.
        c                 S   s   d S r   r   ©r    r   r   r    Úcheck_beforeh  s    zDTestLargeConstDict.test_usercode_update_use_d2.<locals>.check_beforec                 S   s   d S r   r   r¾   r   r   r    Úcheck_afterk  s    zCTestLargeConstDict.test_usercode_update_use_d2.<locals>.check_afterFT)Zprefer_literalc                    s<   ˆ s4d‰ ddddœ}ˆ  t| tjƒ¡ ˆ | j|¡ dd„ S )NTrA   rI   rJ   ©r<   r=   rW   c                 S   s   d S r   r   r™   r   r   r    r¥   �  r¦   zYTestLargeConstDict.test_usercode_update_use_d2.<locals>.ol_check_before.<locals>.<lambda>)r¨   r©   r   rº   r6   r¤   r»   )Úchecked_beforer1   r   r    Úol_check_beforeq  s    ýzGTestLargeConstDict.test_usercode_update_use_d2.<locals>.ol_check_beforec                    s2   ˆ s*d‰ ˆ  t| tjƒ¡ ˆ  | jd k¡ dd„ S )NTc                 S   s   d S r   r   r™   r   r   r    r¥   Ž  r¦   zXTestLargeConstDict.test_usercode_update_use_d2.<locals>.ol_check_after.<locals>.<lambda>)r¨   r©   r   rº   r¤   r™   )Úchecked_afterr1   r   r    Úol_check_afterƒ  s
    zFTestLargeConstDict.test_usercode_update_use_d2.<locals>.ol_check_afterc                     sD   ddddœ} dddœ}ˆ| ƒ |   |¡ ˆ | ƒ t| ƒdkr@|S | S )z˜
            Dictionary update between two constant
            dictionaries. This verifies d2 doesn't
            get incorrectly removed.
            rA   rI   rJ   rÁ   rK   )rX   rY   )ÚupdateÚlen)Zd1Zd2)rÀ   r¿   r   r    Úconst_dict_func�  s    ýþ
zGTestLargeConstDict.test_usercode_update_use_d2.<locals>.const_dict_funcN)r   r   r6   )r1   rÃ   rÅ   rÈ   r:   r;   r<   r=   r   )rÀ   r¿   rÄ   rÂ   r1   r    Útest_usercode_update_use_d2a  s    


z.TestLargeConstDict.test_usercode_update_use_d2c              	   C   sD   dd„ }|   t¡�}tƒ |ƒddƒ W 5 Q R X |  dt|jƒ¡ dS )zÉ
        Tests generating a large dictionary when one of
        the inputs requires inline control flow
        has the change suggested in the error message
        for inlined control flow.
        c                 S   s<   ddddddd|rdnddddddddddd| dœ}|d S ©NrA   rI   r…   r˜   r   )r<   rk   rX   r   r   r    rl   µ  s*    
ízPTestLargeConstDict.test_large_const_dict_inline_controlflow.<locals>.inline_funcrµ   Frm   Nrn   rr   r   r   r    Ú(test_large_const_dict_inline_controlflow­  s    þz;TestLargeConstDict.test_large_const_dict_inline_controlflowc                 C   s>   dd„ }|}t ƒ |ƒ}d}||dƒ}||dƒ}|  ||¡ dS )z¥
        Tests generating large constant dict when one of the
        inputs has the change suggested in the error message
        for inlined control flow.
        c                 S   s@   |rdnd}ddddddd|dddddddddd| dœ}|d S rÊ   r   )r<   rk   ÚvalrX   r   r   r    Únon_inline_funcÞ  s,    ízWTestLargeConstDict.test_large_const_dict_noninline_controlflow.<locals>.non_inline_funcrµ   FNrv   )r1   rÍ   r:   r;   r¶   r<   r=   r   r   r    Ú+test_large_const_dict_noninline_controlflow×  s    


z>TestLargeConstDict.test_large_const_dict_noninline_controlflowc                    s6   dd„ ‰ t ˆ ƒ‡fdd„ƒ}t‡ fdd„ƒ}|ƒ  dS )z®
        Tests that the correct literal values are generated
        for a dictionary that produces two DICT_UPDATE
        bytecode entries for the same dictionary.
        c                 S   s   d S r   r   r™   r   r   r    rœ     s    z>TestLargeConstDict.test_fuse_twice_literal_values.<locals>.barc              $      s†   ddddddddd	d
dddddddddddddddddddddd d!d"d#d$œ#}| j d kr^d%d&„ S ˆ  t| tjƒ¡ ˆ  | j |¡ d'd&„ S )(NrA   rI   rJ   rK   r*   rL   rM   rN   rO   rP   rQ   rR   rS   rT   rU   r$   é   é   é   é   é   é   é   é   é   é   é   é   é   é   r#   é    é!   é"   é#   ©#Za1Za2Úa3Za4Za5Za6Za7Za8Za9Za10Za11Za12Za13Za14Za15Za16Za17Za18Za19Za20Za21Za22Za23Za24Za25Za26Za27Za28Za29Za30Za31Za32Za33Za34Za35c                 S   s   t | ƒS r   r¸   r™   r   r   r    r¥   4  r¦   zSTestLargeConstDict.test_fuse_twice_literal_values.<locals>.ol_bar.<locals>.<lambda>c                 S   s   | S r   r   r™   r   r   r    r¥   7  r¦   r¹   r»   r¬   r   r    r­     sR    Ü&
zATestLargeConstDict.test_fuse_twice_literal_values.<locals>.ol_barc               $      sX   ddddddddd	d
dddddddddddddddddddddd d!d"d#d$œ#} ˆ | ƒ d S )%NrA   rI   rJ   rK   r*   rL   rM   rN   rO   rP   rQ   rR   rS   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¯   9  sJ    Ü&z>TestLargeConstDict.test_fuse_twice_literal_values.<locals>.fooNr°   r±   r   r²   r    Útest_fuse_twice_literal_values  s    -+z1TestLargeConstDict.test_fuse_twice_literal_valuesN)r   r€   r�   r‚   r   r›   r³   r·   r½   rÉ   rË   rÎ   rã   r   r   r   r    rƒ   v  s"   
&
F
(
C
K
)
)rƒ   c                   @   s   e Zd ZdZdd„ ZdS )Ú'TestListExtendInStarArgNonTupleIterablea^  Test `fn(pos_arg0, pos_arg1, *args)` where args is a non-tuple iterable.

    Python 3.9+ will generate LIST_EXTEND bytecode to combine the positional
    arguments with the `*args`.

    See #8059

    NOTE: At the moment, there are no meaningful tests for NoPython because the
    lack of support for `tuple(iterable)` for most iterable types.
    c                    sL   dd„ ‰ t dd�‡ fdd„ƒ}|dƒ}| d¡}|  |d¡ |  ||¡ d S )	Nc                  W   s   | S r   r   r¾   r   r   r    Úconsumert  s    zSTestListExtendInStarArgNonTupleIterable.test_list_extend_forceobj.<locals>.consumerT)Zforceobjc                    s   ˆ d| žŽ S )NrA   rI   )rA   rI   r   r¾   ©rå   r   r    r¯   w  s    zNTestListExtendInStarArgNonTupleIterable.test_list_extend_forceobj.<locals>.fooZijo)rA   rI   r(   r\   ra   )r   r:   r6   )r1   r¯   ÚgotÚexpectr   ræ   r    Útest_list_extend_forceobjs  s    
zATestListExtendInStarArgNonTupleIterable.test_list_extend_forceobjN)r   r€   r�   r‚   ré   r   r   r   r    rä   h  s   
rä   Ú__main__)/r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   )r‚   ZunittestZnumbar   r   r   r   r   Znumba.extendingr   Z
numba.corer   Znumba.core.errorsr	   Znumba.tests.supportr
   r   r   r!   r"   rƒ   rä   r   Úmainr   r   r   r    Ú<module>   s†                                                  Ñd       u
