
    xKg-v                     J   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       Z G d	 d
ee      Z G d dee      Z G d dee      Zedk(  r ej.                          yy)z0
Test bytecode fixes provided in interpreter.py
    N)jitnjitobjmodetypeof	literally)overload)types)UnsupportedError)TestCaseMemoryLeakMixinskip_unless_py10_or_laterc/                    | |z   |z   |z   |z   |z   |z   |z   |z   |	z   |
z   |z   |z   |z   |z   |z   |z   |z   |z   |z   |z   |z   |z   |z   |z   |z   |z   |z   |z   |z   |z   |z   | z   |!z   |"z   |#z   |$z   |%z   |&z   |'z   |(z   |)z   |*z   |+z   |,z   |-z   |.z   S N )/arg0arg1arg2arg3arg4arg5arg6arg7arg8arg9arg10arg11arg12arg13arg14arg15arg16arg17arg18arg19arg20arg21arg22arg23arg24arg25arg26arg27arg28arg29arg30arg31arg32arg33arg34arg35arg36arg37arg38arg39arg40arg41arg42arg43arg44arg45arg46s/                                                  `/home/alanp/www/video.onchill/myenv/lib/python3.12/site-packages/numba/tests/test_interpreter.pysum_jit_funcrA      s   f 	
	
	 	 		
 	 	 	 	 		 
	 	 	 	 	 	  !	" #	$ %	& '	( )	* +	, -	. /	0 1	2 3	4 5	6 7	8 9	: ;	< =	> ?	@ A 	B C!	D E"	F G#	H I$	J K%	L M&	N O'	P Q(	R S)	T U*	V W+	X Y,	Z [-	\ ].	0    c                       e Zd ZdZdZdZd Zed        Zed        Z	ed        Z
ed        Zed	        Zed
        Zed        Zed        Zed        Zed        Zed        Zed        Zed        Zy)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                    t        ||z         D cg c]  }d| 	 }}g }t        ||z         D ]'  }|dz  dk(  rd| d}nd| }|j                  |       ) dj                  |      }d| d}|d	z  }t        |      D ]  }|d
||    dz  } t        |||z         D ]  }|d
||    d||    dz  } |dz  }i }	t        |dt        i|	       |	d   S c c}w )zw
            Generates a function that calls sum_jit_func
            with the desired number of args and kws.
        arg   r   zpow(argz, 2)z, z	def impl(z):
z    return sum_jit_func(
z        z,
=z    )
rA   impl)rangeappendjoinexecrA   )
selfn_argsn_kwsi
param_list	args_listarg_valtotal_params	func_text
local_varss
             r@   gen_funcz#TestCallFunctionExPeepHole.gen_func   s*   
 */v~)>?)>AA3i)>
?	v~&A 1uz#A3d+s)W% ' yy,~T2	11	vA8IaL>55I vv~.A8JqM?!IaL>EEI /Y	
Y6
C&!!) @s   Cc                     t        | j                        D cg c]  }| }}| j                  | j                  d      }|} t               |      } || } || }| j	                  ||       yc c}w )z
        Tests calling a function when n_args > 30 and
        n_kws = 0. This shouldn't use the peephole, but
        it should still succeed.
        r   N)rL   THRESHOLD_ARGSrZ   r   assertEqualrP   rS   
total_argsfpy_funccfuncabs           r@   test_all_argsz(TestCallFunctionExPeepHole.test_all_args   sv     "'t':':!;<!;Aa!;
<MM$--q1q	Z :A =   	A.c                     t        | j                        D cg c]  }| }}| j                  d| j                        }|} t               |      } || } || }| j	                  ||       yc c}w )zR
        Tests calling a function when n_kws > 15 and
        n_args = 0.
        r   N)rL   THRESHOLD_KWSrZ   r   r]   r^   s           r@   test_all_kwsz'TestCallFunctionExPeepHole.test_all_kws   sv     "'t'9'9!:;!:Aa!:
;MM!T//0q	Z :A <rf   c                     | j                   dz
  }| j                  dz
  }t        ||z         D cg c]  }| }}| j                  ||      }|} t	               |      } || } || }	| j                  ||	       yc c}w )zs
        Tests calling a function when (n_args / 2) + n_kws > 15,
        but n_args <= 30 and n_kws <= 15
           Nr\   rh   rL   rZ   r   r]   
rP   	used_argsused_kwsrS   r_   r`   ra   rb   rc   rd   s
             r@   test_small_args_small_kwsz4TestCallFunctionExPeepHole.test_small_args_small_kws   s     ''!+	%%)!&	h'?!@A!@Aa!@
AMM)X.q	Z :A Bs   	A;c                     | j                   dz
  }| j                  }t        ||z         D cg c]  }| }}| j                  ||      }|} t	               |      } || } || }	| j                  ||	       yc c}w )zr
        Tests calling a function when (n_args / 2) + n_kws > 15,
        but n_args <= 30 and n_kws > 15
        rk   Nrl   rm   s
             r@   test_small_args_large_kwsz4TestCallFunctionExPeepHole.test_small_args_large_kws   s     ''!+	%%!&	h'?!@A!@Aa!@
AMM)X.q	Z :A B   	A8c                     | j                   }| j                  dz
  }t        ||z         D cg c]  }| }}| j                  ||      }|} t	               |      } || } || }	| j                  ||	       yc c}w )zr
        Tests calling a function when (n_args / 2) + n_kws > 15,
        but n_args > 30 and n_kws <= 15
        rk   Nrl   rm   s
             r@   test_large_args_small_kwsz4TestCallFunctionExPeepHole.test_large_args_small_kws   s     ''	%%)!&	h'?!@A!@Aa!@
AMM)X.q	Z :A Brs   c                     | j                   }| j                  }t        ||z         D cg c]  }| }}| j                  ||      }|} t	               |      } || } || }	| j                  ||	       yc c}w )zq
        Tests calling a function when (n_args / 2) + n_kws > 15,
        but n_args > 30 and n_kws > 15
        Nrl   rm   s
             r@   test_large_args_large_kwsz4TestCallFunctionExPeepHole.test_large_args_large_kws   s     ''	%%!&	h'?!@A!@Aa!@
AMM)X.q	Z :A Bs   	A5c                     d t         fd       }t        t                            } |       }| j                  ||       y)zO
        Tests calling an objectmode function with > 15 return values.
        c                       y)N)r   rk            rI            	   
                  r   r   rB   r@   ra   zBTestCallFunctionExPeepHole.test_large_kws_objmode.<locals>.py_func  s    rB   c                  .   t        di 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5          \  } }}}}}}}}}	}
}}}}}ddd        z   z   z   z   z   z   z   z   	z   
z   z   z   z   z   z   S # 1 sw Y   8xY w)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.
            rc   int64rd   cder`   ghrS   jklmnopNr   )r   )rc   rd   r   r   r   r`   r   r   rS   r   r   r   r   r   r   r   ra   s                   r@   objmode_funczGTestCallFunctionExPeepHole.test_large_kws_objmode.<locals>.objmode_func  s       	
             !F I#EJ   	
     	 
     I s   BBN)r   sumlistr]   )rP   r   rc   rd   ra   s       @r@   test_large_kws_objmodez1TestCallFunctionExPeepHole.test_large_kws_objmode   sF    
	( 
;	 
;	z WY NArB   c                     d }| j                  t              5 }  t               |      d       ddd       | j                  dt	        j
                               y# 1 sw Y   /xY w)ze
        Tests generating large args when one of the inputs
        has inlined controlflow.
        c                     t        g ddddddddddddddddddddd| rdndddddddddddddddddiS Nrk   rz   r:   rA   flags    r@   inline_funczRTestCallFunctionExPeepHole.test_large_args_inline_controlflow.<locals>.inline_func^  s    &&& & 	&
 & & & & & & & & & & &  !&" #&$ %&& '&( )&* +&, q-&. /&0 1&2 3&4 5&6 7&8 9&: ;&< =&> ?&@ A&B C&D E&F G&H I&J K& &rB   FN9You can resolve this issue by moving the control flow outassertRaisesr
   r   assertInstr	exceptionrP   r   raisess      r@   "test_large_args_inline_controlflowz=TestCallFunctionExPeepHole.test_large_args_inline_controlflowX  sY    '	R /0FFDF;& 1G  !	
 10   AA'c                 r    d }|} t               |      } |d      } |d      }| j                  ||       y)
        Tests generating large args when one of the inputs
        has the change suggested in the error message
        for inlined control flow.
        c                     | rdnd}t        g 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iS r   r   r   a_vals     r@   r   zVTestCallFunctionExPeepHole.test_large_args_noninlined_controlflow.<locals>.inline_func  s   A1E &&& & 	&
 & & & & & & & & & & &  !&" #&$ %&& '&( )&* +&, -&. /&0 1&2 3&4 5&6 7&8 9&: ;&< =&> ?&@ A&B C&D E&F G&H I&J K& &rB   FNr   r]   rP   r   ra   rb   rc   rd   s         r@   &test_large_args_noninlined_controlflowzATestCallFunctionExPeepHole.test_large_args_noninlined_controlflow  s?    (	T {#EN%LArB   c                     d }| j                  t              5 }  t               |      d       ddd       | j                  dt	        j
                               y# 1 sw Y   /xY w)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                     t        g ddddddddddddddddddddd| rdnddddddddddddddd S Nrk   rz   r   r   s    r@   r   zPTestCallFunctionExPeepHole.test_all_args_inline_controlflow.<locals>.inline_func  s    %%% % 	%
 % % % % % % % % % % %  !%" #%$ %%& '%( )%* +%, q-%. /%0 1%2 3%4 5%6 7%8 9%: ;%< =%> ?%@ A%B C%D E%F G%H I% %rB   FNr   r   r   s      r@    test_all_args_inline_controlflowz;TestCallFunctionExPeepHole.test_all_args_inline_controlflow  sY    &	P /0FFDF;& 1G  !	
 10r   c                 r    d }|} t               |      } |d      } |d      }| j                  ||       y)r   c                     | rdnd}t        g 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 r   r   r   s     r@   r   zTTestCallFunctionExPeepHole.test_all_args_noninlined_controlflow.<locals>.inline_func  s   A1E %%% % 	%
 % % % % % % % % % % %  !%" #%$ %%& '%( )%* +%, -%. /%0 1%2 3%4 5%6 7%8 9%: ;%< =%> ?%@ A%B C%D E%F G%H I% %rB   FNr   r   s         r@   $test_all_args_noninlined_controlflowz?TestCallFunctionExPeepHole.test_all_args_noninlined_controlflow  s?    '	R {#EN%LArB   c                     d }| j                  t              5 }  t               |      d       ddd       | j                  dt	        j
                               y# 1 sw Y   /xY w)zd
        Tests generating large kws when one of the inputs
        has inlined controlflow.
        c                     t        di 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| rdS dS )Nr   rk   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r    rz   r   r   r   s    r@   r   zQTestCallFunctionExPeepHole.test_large_kws_inline_controlflow.<locals>.inline_func8  s       	
              a!   &'! rB   FNr   r   r   s      r@   !test_large_kws_inline_controlflowz<TestCallFunctionExPeepHole.test_large_kws_inline_controlflow2  sX    	( /0FFDF;& 1G  !	
 10r   c                 r    d }|} t               |      } |d      } |d      }| j                  ||       y)z
        Tests generating large kws when one of the inputs
        has the change suggested in the error message
        for inlined control flow.
        c                     | rdnd}t        di 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 )Nrk   rz   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r    r   r   r   s     r@   r   zUTestCallFunctionExPeepHole.test_large_kws_noninlined_controlflow.<locals>.inline_funcZ  s    A1E   	
             ! rB   FNr   r   s         r@   %test_large_kws_noninlined_controlflowz@TestCallFunctionExPeepHole.test_large_kws_noninlined_controlflowS  s>    	* {#EN%LArB   N)__name__
__module____qualname____doc__r\   rh   rZ   r   re   ri   rp   rr   ru   rw   r   r   r   r   r   r   r   r   rB   r@   rD   rD   u   s$    NM"6             X Xt 3
 3
j 4 4l 4
 4
l 3 3j 
 
@  rB   rD   c                       e Zd ZdZed        Zed        Zed        Zed        Zed        Z	ed        Z
ed        Zed	        Zy
)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                 n    d }|} t               |      } |       } |       }| j                  ||       y)r
        Tests that a function with a large heterogeneous constant
        dictionary remains a constant.
        c                      i 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} | d   S )NArk   BCDEFGHIJKLMNOPQrc   RSr   r   r   s    r@   
const_funczJTestLargeConstDict.test_large_heterogeneous_const_dict.<locals>.const_func  s    QQ Q Q	
 Q Q Q Q Q Q Q Q Q Q Q  Q!" Q#$ 'A* S6MrB   Nr   )rP   r   ra   rb   rc   rd   s         r@   #test_large_heterogeneous_const_dictz6TestLargeConstDict.test_large_heterogeneous_const_dict  s:    	6 z"IGArB   c                 ^     d t               fd       }t        fd       } |        y)zvCheck the literal values for a LiteralStrKeyDict requiring
        optimizations because it is heterogeneous.
        c                      y r   r   r   s    r@   barzYTestLargeConstDict.test_large_heterogeneous_LiteralStrKeyDict_literal_values.<locals>.bar      rB   c                    i 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}d }|j                         D ci c]!  \  }}t        j                  |       ||      # }}}j                  t	        | t        j
                               j                  | j                  |       j                  t        | d      d       d S c c}}w )Nr   rk   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   rc   r   c                 l    t        j                  |       rt        j                  |       S t        |       S r   )r	   maybe_literalliteralr   )zs    r@   specific_tyzqTestLargeConstDict.test_large_heterogeneous_LiteralStrKeyDict_literal_values.<locals>.ol_bar.<locals>.specific_ty  s'    +0+>+>q+Au}}Q'PvayPrB   initial_valueFc                     | S r   r   r   s    r@   <lambda>znTestLargeConstDict.test_large_heterogeneous_LiteralStrKeyDict_literal_values.<locals>.ol_bar.<locals>.<lambda>      QrB   )	itemsr	   r   
assertTrue
isinstanceLiteralStrKeyDictr]   literal_valuehasattr)r   rc   r   xyexpectedrP   s         r@   ol_barz\TestLargeConstDict.test_large_heterogeneous_LiteralStrKeyDict_literal_values.<locals>.ol_bar  se   QQ Q Q	
 Q Q Q Q Q Q Q Q Q Q Q  Q!" Q#$ 'A,QEFWWYOYTQa(+a.8YHOOOJq%*A*ABCQ__h7WQ8%@	 Ps   &Cc                      i 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}  |        y )Nr   rk   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   rc   r   r   r   r   s    r@   foozYTestLargeConstDict.test_large_heterogeneous_LiteralStrKeyDict_literal_values.<locals>.foo  s    
QQ Q Q	
 Q Q Q Q Q Q Q Q Q Q Q  Q!" Q#$ 'A* FrB   Nr   r   rP   r   r   r   s   `  @r@   9test_large_heterogeneous_LiteralStrKeyDict_literal_valueszLTestLargeConstDict.test_large_heterogeneous_LiteralStrKeyDict_literal_values  s;    	 
#	 
	> 
	 
	6 	rB   c                 v    d }|} t               |      }d} ||      } ||      }| j                  ||       y)r   c                     i 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 )Nr   rk   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   )rc   r   s     r@   const_keys_funczTTestLargeConstDict.test_large_heterogeneous_const_keys_dict.<locals>.const_keys_func  s    QQ Q Q	
 Q Q Q Q Q Q Q Q Q Q Q  Q!" Q#$ 'A* S6MrB   a_stringNr   )rP   r   ra   rb   valuerc   rd   s          r@   (test_large_heterogeneous_const_keys_dictz;TestLargeConstDict.test_large_heterogeneous_const_keys_dict  sC    	6 "'EN%LArB   c                 ^     d t               fd       }t        fd       } |        y)zChecks that the optimization for large dictionaries
        do not incorrectly update initial values due to other
        mutations.
        c                      y r   r   r   s    r@   r   zDTestLargeConstDict.test_large_dict_mutation_not_carried.<locals>.bar#  r   rB   c                 &   i 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}| j                   d S j                  t        | t        j                               j                  | j                   |       d S )Nr   rk   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r~   r   c                     t        |       S r   r   r   s    r@   r   zYTestLargeConstDict.test_large_dict_mutation_not_carried.<locals>.ol_bar.<locals>.<lambda>>      1rB   c                     | S r   r   r   s    r@   r   zYTestLargeConstDict.test_large_dict_mutation_not_carried.<locals>.ol_bar.<locals>.<lambda>A  r   rB   r   r   r   r	   DictTyper]   r   rc   rP   s     r@   r   zGTestLargeConstDict.test_large_dict_mutation_not_carried.<locals>.ol_bar&  s"   QQ Q Q	
 Q Q Q Q Q Q Q Q Q Q Q  Q!" Q#$ 'A* &--OOJq%..9:Q__a0rB   c                      i 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} d| d<    |        y )Nr   rk   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r~   r   r|   Xr   r   s    r@   r   zDTestLargeConstDict.test_large_dict_mutation_not_carried.<locals>.fooC  s    QQ Q Q	
 Q Q Q Q Q Q Q Q Q Q Q  Q!" Q#$ 'A* AcFFrB   Nr   r   s   `  @r@   $test_large_dict_mutation_not_carriedz7TestLargeConstDict.test_large_dict_mutation_not_carried  s;    	 
#	 
	8 
	 
	6 	rB   c                     	
 d 	d dd
t        	d       fd       }t        d      
 fd       }	fd}|} t               |      } |       } |       } j                  ||       y	)
zf
        Tests an example using a regular update is
        not modified by the optimization.
        c                      y r   r   r   s    r@   check_beforezDTestLargeConstDict.test_usercode_update_use_d2.<locals>.check_beforeh      rB   c                      y r   r   r  s    r@   check_afterzCTestLargeConstDict.test_usercode_update_use_d2.<locals>.check_afterk  r  rB   FT)prefer_literalc                     sMddddd}j                  t        | t        j                               j	                  | j
                  |       d S )NTrk   rz   r{   rc   rd   r   c                      y r   r   r   s    r@   r   zYTestLargeConstDict.test_usercode_update_use_d2.<locals>.ol_check_before.<locals>.<lambda>      TrB   )r   r   r	   r  r]   r   )r   rc   checked_beforerP   s     r@   ol_check_beforezGTestLargeConstDict.test_usercode_update_use_d2.<locals>.ol_check_beforeq  sP     "!%
 
1enn =>  !4!!rB   c                     sHdj                  t        | t        j                               j                  | j                  d u        d S )NTc                      y r   r   r   s    r@   r   zXTestLargeConstDict.test_usercode_update_use_d2.<locals>.ol_check_after.<locals>.<lambda>  r  rB   )r   r   r	   r  r   )r   checked_afterrP   s    r@   ol_check_afterzFTestLargeConstDict.test_usercode_update_use_d2.<locals>.ol_check_after  s?     ! $
1enn =>4 78!!rB   c                      dddd} ddd} |        | j                  |        |        t        |       dkD  r|S | S )z
            Dictionary update between two constant
            dictionaries. This verifies d2 doesn't
            get incorrectly removed.
            rk   rz   r{   r  r|   )r   r   )updatelen)d1d2r  r  s     r@   const_dict_funczGTestLargeConstDict.test_usercode_update_use_d2.<locals>.const_dict_func  sU     B B IIbMO2w{	IrB   N)r   r   r]   )rP   r  r!  r'  ra   rb   rc   rd   r  r  r   r  s   `       @@@@r@   test_usercode_update_use_d2z.TestLargeConstDict.test_usercode_update_use_d2a  s    		 	,t	4	" 
5	"" 
+d	3
	" 
4
	"	. "'IGArB   c                     d }| j                  t              5 }  t               |      dd       ddd       | j                  dt	        j
                               y# 1 sw Y   /xY w)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                     i ddddddddddddddd	|rdnd
ddddddddddddddddddd| d}|d   S )Nr   rk   r   r   r   r   r   r   r   rz   r   r   r   r   r   r   r   r   r   r   r   r   )rc   r   r   s      r@   r   zPTestLargeConstDict.test_large_const_dict_inline_controlflow.<locals>.inline_func  s    QQ Q Q	
 Q Q Q $QA Q Q Q Q Q Q Q  Q!" Q#$ 'A* S6MrB   r   FNr   r   r   s      r@   (test_large_const_dict_inline_controlflowz;TestLargeConstDict.test_large_const_dict_inline_controlflow  sZ    	6 /0FFDF;
E2 1G  !	
 10s   AA(c                 z    d }|} t               |      }d} ||d      } ||d      }| j                  ||       y)z
        Tests generating large constant dict when one of the
        inputs has the change suggested in the error message
        for inlined control flow.
        c                     |rdnd}i 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 )Nrk   rz   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   )rc   r   valr   s       r@   non_inline_funczWTestLargeConstDict.test_large_const_dict_noninline_controlflow.<locals>.non_inline_func  s     !CQQ Q Q	
 Q Q Q S Q Q Q Q Q Q Q  Q!" Q#$ 'A* S6MrB   r   FNr   )rP   r/  ra   rb   r  rc   rd   s          r@   +test_large_const_dict_noninline_controlflowz>TestLargeConstDict.test_large_const_dict_noninline_controlflow  sI    	8 "'E5!%ArB   c                 ^     d t               fd       }t        fd       } |        y)z
        Tests that the correct literal values are generated
        for a dictionary that produces two DICT_UPDATE
        bytecode entries for the same dictionary.
        c                      y r   r   r   s    r@   r   z>TestLargeConstDict.test_fuse_twice_literal_values.<locals>.bar  r   rB   c                    i 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"i d#d$d%d&d'd(d)d*d+d,d-d.d/d0d1d2d3d4d5d6d7d8d9d:d;d<d=d>d?d@dAdBdCdDdEdFi}| j                   dG S j                  t        | t        j                               j                  | j                   |       dH S )INa1rk   a2rz   a3r{   a4r|   a5rI   a6r}   a7r~   a8r   a9r   a10r   a11r   a12r   a13r   a14r   a15r   a16rF   a17   a18   a19   a20   a21   a22   a23   a24   a25   a26   a27   a28   a29   a30   a31rE   a32    a33!   a34"   a35#   c                     t        |       S r   r  r   s    r@   r   zSTestLargeConstDict.test_fuse_twice_literal_values.<locals>.ol_bar.<locals>.<lambda>4  r  rB   c                     | S r   r   r   s    r@   r   zSTestLargeConstDict.test_fuse_twice_literal_values.<locals>.ol_bar.<locals>.<lambda>7  r   rB   r
  r  s     r@   r   zATestLargeConstDict.test_fuse_twice_literal_values.<locals>.ol_bar  s   %q%q% q% q	%
 q% q% q% q% q% % % % % % %  !%" #%$ %%& '%( )%* +%, -%. /%0 1%2 3%4 5%6 7%8 9%: ;%< =%> ?%@ A%B C%D E%H I%AL &--OOJq%..9:Q__a0rB   c                      i 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"i d#d$d%d&d'd(d)d*d+d,d-d.d/d0d1d2d3d4d5d6d7d8d9d:d;d<d=d>d?d@dAdBdCdDdEdFi}  |        y )GNr4  rk   r5  rz   r6  r{   r7  r|   r8  rI   r9  r}   r:  r~   r;  r   r<  r   r=  r   r>  r   r?  r   r@  r   rA  r   rB  r   rC  rF   rD  rE  rF  rG  rH  rI  rJ  rK  rL  rM  rN  rO  rP  rQ  rR  rS  rT  rU  rV  rW  rX  rY  rZ  r[  r\  r]  r^  r_  r`  rE   ra  rb  rc  rd  re  rf  rg  rh  r   r   s    r@   r   z>TestLargeConstDict.test_fuse_twice_literal_values.<locals>.foo9  s   %q%q% q% q	%
 q% q% q% q% q% % % % % % %  !%" #%$ %%& '%( )%* +%, -%. /%0 1%2 3%4 5%6 7%8 9%: ;%< =%> ?%@ A%B C%D E%H I%AL FrB   Nr   r   s   `  @r@   test_fuse_twice_literal_valuesz1TestLargeConstDict.test_fuse_twice_literal_values  s=    	 
#+	 
+	Z 
)	 
)	V 	rB   N)r   r   r   r   r   r   r   r  r  r(  r+  r0  rl  r   rB   r@   r   r   v  s     $ $L D DL & &P A AF I IV '
 '
R ' 'R c crB   r   c                       e Zd ZdZd Zy)'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                     d t        d      fd       } |d      }|j                  d      }| j                  |d       | j                  ||       y )Nc                      | S r   r   r  s    r@   consumerzSTestListExtendInStarArgNonTupleIterable.test_list_extend_forceobj.<locals>.consumert  s    HrB   T)forceobjc                      ddg|  S r   r   )r   rq  s    r@   r   zNTestListExtendInStarArgNonTupleIterable.test_list_extend_forceobj.<locals>.foow  s    Aq%1%%rB   ijo)rk   rz   rS   r   r   )r   ra   r]   )rP   r   gotexpectrq  s       @r@   test_list_extend_forceobjzATestListExtendInStarArgNonTupleIterable.test_list_extend_forceobjs  s[    	 
d		& 
	& %jU#34f%rB   N)r   r   r   r   rw  r   rB   r@   rn  rn  h  s    	&rB   rn  __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   unittestnumbar   r   r   r   r   numba.extendingr   
numba.corer	   numba.core.errorsr
   numba.tests.supportr   r   r   rA   rD   r   rn  r   mainr   rB   r@   <module>r     s    7 7 $  .  	
	
	
	
	
	
	
	
	
	





































_a aH~( ~Bo? od&ox &2 zHMMO rB   