
    iUv                     N   S r SSKrSSKJrJrJrJrJr  SSKJ	r	  SSK
Jr  SSKJr  SSKJrJrJr  \                                               SS j5       r " S	 S
\\5      r " S S\\5      r " S S\\5      r\S:X  a  \R.                  " 5         gg)z0
Test bytecode fixes provided in interpreter.py
    N)jitnjitobjmodetypeof	literally)overload)types)UnsupportedBytecodeError)TestCaseMemoryLeakMixinskip_unless_py10_or_laterc/                    U U-   U-   U-   U-   U-   U-   U-   U-   U	-   U
-   U-   U-   U-   U-   U-   U-   U-   U-   U-   U-   U-   U-   U-   U-   U-   U-   U-   U-   U-   U-   U-   U -   U!-   U"-   U#-   U$-   U%-   U&-   U'-   U(-   U)-   U*-   U+-   U,-   U--   U.-   $ 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/                                                  W/var/www/html/trading/venv/lib/python3.13/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                       \ rS rSrSrSrSrS r\S 5       r	\S 5       r
\S 5       r\S	 5       r\S
 5       r\S 5       r\S 5       r\S 5       r\S 5       r\S 5       r\S 5       r\S 5       r\S 5       rSrg)TestCallFunctionExPeepHoleu   az  
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                    [        X-   5       Vs/ s H  nSU 3PM
     nn/ n[        X-   5       H)  nUS-  S:X  a  SU S3nOSU 3nUR                  U5        M+     SR                  U5      nSU S3nUS	-  n[        U5       H  nUS
XS    S3-  nM     [        XU-   5       H  nUS
XC    SXS    S3-  nM     US-  n0 n	[        US[        0U	5        U	S   $ s  snf )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_func#TestCallFunctionExPeepHole.gen_func   s   
 */v~)>?)>AA3i)>
?	v~&A 1uz#A3d+s)W% ' yy,~T2	11	vA8IL>55I v~.A8JM?!IL>EEI /Y	
Y6
C&!!) @s   Cc                     [        U R                  5       Vs/ s H  oPM     nnU R                  U R                  S5      nUn[        5       " U5      nU" U6 nU" U6 nU R	                  Xg5        gs  snf )zx
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)rM   THRESHOLD_ARGSr[   r   assertEqualrQ   rT   
total_argsfpy_funccfuncabs           r@   test_all_args(TestCallFunctionExPeepHole.test_all_args   sr     "'t':':!;<!;Aa!;
<MM$--q1q	Z : =   A/c                     [        U R                  5       Vs/ s H  oPM     nnU R                  SU R                  5      nUn[        5       " U5      nU" U6 nU" U6 nU R	                  Xg5        gs  snf )z:
Tests calling a function when n_kws > 15 and
n_args = 0.
r   N)rM   THRESHOLD_KWSr[   r   r_   r`   s           r@   test_all_kws'TestCallFunctionExPeepHole.test_all_kws   sr     "'t'9'9!:;!:Aa!:
;MM!T//0q	Z : <ri   c                     U R                   S-
  nU R                  S-
  n[        X-   5       Vs/ s H  o3PM     nnU R                  X5      nUn[	        5       " U5      nU" U6 nU" U6 n	U R                  X5        gs  snf )z[
Tests calling a function when (n_args / 2) + n_kws > 15,
but n_args <= 30 and n_kws <= 15
   Nr^   rk   rM   r[   r   r_   
rQ   	used_argsused_kwsrT   ra   rb   rc   rd   re   rf   s
             r@   test_small_args_small_kws4TestCallFunctionExPeepHole.test_small_args_small_kws   s     ''!+	%%)!&	'?!@A!@Aa!@
AMM).q	Z : Bs   A:c                     U R                   S-
  nU R                  n[        X-   5       Vs/ s H  o3PM     nnU R                  X5      nUn[	        5       " U5      nU" U6 nU" U6 n	U R                  X5        gs  snf )zZ
Tests calling a function when (n_args / 2) + n_kws > 15,
but n_args <= 30 and n_kws > 15
ro   Nrp   rq   s
             r@   test_small_args_large_kws4TestCallFunctionExPeepHole.test_small_args_large_kws   s     ''!+	%%!&	'?!@A!@Aa!@
AMM).q	Z : B   A7c                     U R                   nU R                  S-
  n[        X-   5       Vs/ s H  o3PM     nnU R                  X5      nUn[	        5       " U5      nU" U6 nU" U6 n	U R                  X5        gs  snf )zZ
Tests calling a function when (n_args / 2) + n_kws > 15,
but n_args > 30 and n_kws <= 15
ro   Nrp   rq   s
             r@   test_large_args_small_kws4TestCallFunctionExPeepHole.test_large_args_small_kws   s     ''	%%)!&	'?!@A!@Aa!@
AMM).q	Z : Bry   c                     U R                   nU R                  n[        X-   5       Vs/ s H  o3PM     nnU R                  X5      nUn[	        5       " U5      nU" U6 nU" U6 n	U R                  X5        gs  snf )zY
Tests calling a function when (n_args / 2) + n_kws > 15,
but n_args > 30 and n_kws > 15
Nrp   rq   s
             r@   test_large_args_large_kws4TestCallFunctionExPeepHole.test_large_args_large_kws   s~     ''	%%!&	'?!@A!@Aa!@
AMM).q	Z : Bs   A4c                    ^ S m[         U4S j5       n[        [        T" 5       5      5      nU" 5       nU R                  X#5        g)z?
Tests calling an objectmode function with > 15 return values.
c                      g)N)r   ro            rJ            	   
                  r   r   rB   r@   rc   BTestCallFunctionExPeepHole.test_large_kws_objmode.<locals>.py_func  s    rB   c                  8  > [        S0 SS_SS_SS_SS_SS_SS_SS_S	S_S
S_SS_SS_SS_SS_SS_SS_SS_6   T" 5       u  n nnnnnnnnn	n
nnnnnSSS5        W W-   W-   W-   W-   W-   W-   W-   W-   W	-   W
-   W-   W-   W-   W-   W-   $ ! , (       d  f       N== f)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.
re   int64rf   cderb   ghrT   jklmnopNr   )r   )re   rf   r   r   r   rb   r   r   rT   r   r   r   r   r   r   r   rc   s                   r@   objmode_funcGTestCallFunctionExPeepHole.test_large_kws_objmode.<locals>.objmode_func  s       	
             !F I#EJ   	
     	 
     I s   B
BN)r   sumlistr_   )rQ   r   re   rf   rc   s       @r@   test_large_kws_objmode1TestCallFunctionExPeepHole.test_large_kws_objmode   sD    
	( 
;	 
;	z WY NrB   c                     S nU R                  [        5       n[        5       " U5      " S5        SSS5        U R                  S[	        WR
                  5      5        g! , (       d  f       N4= f)zM
Tests generating large args when one of the inputs
has inlined controlflow.
c                     [        / SPSPSPSPSPSPSPSPSPSPSPSPSPSPSPSPSPSPSPSPSPU (       a  SOSPSPSPSPSPSPSPSPSPSPSPSPSPSPSP7SS06$ Nro   r   r:   rA   flags    r@   inline_funcRTestCallFunctionExPeepHole.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rQ   r   raisess      r@   "test_large_args_inline_controlflow=TestCallFunctionExPeepHole.test_large_args_inline_controlflowX  sU    '	R 78FF;& 9G  !	
 98   A
A,c                 p    S nUn[        5       " U5      nU" S5      nU" S5      nU R                  XE5        g)|
Tests generating large args when one of the inputs
has the change suggested in the error message
for inlined control flow.
c                     U (       a  SOSn[        / SPSPSPSPSPSPSPSPSPSPSPSPSPSPSPSPSPSPSPSPSPUPSPSPSPSPSPSPSPSPSPSPSPSPSPSP7SS06$ r   r   r   a_vals     r@   r   VTestCallFunctionExPeepHole.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_   rQ   r   rc   rd   re   rf   s         r@   &test_large_args_noninlined_controlflowATestCallFunctionExPeepHole.test_large_args_noninlined_controlflow  s;    (	T {#EN%LrB   c                     S nU R                  [        5       n[        5       " U5      " S5        SSS5        U R                  S[	        WR
                  5      5        g! , (       d  f       N4= f)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PSPSPSPSPSPSPSPSPSPSPSPSPSPSPSPSPSPSPSPSPU (       a  SOSPSPSPSPSPSPSPSPSPSPSPSPSPSPSP76 $ Nro   r   r   r   s    r@   r   PTestCallFunctionExPeepHole.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_controlflow;TestCallFunctionExPeepHole.test_all_args_inline_controlflow  sU    &	P 78FF;& 9G  !	
 98r   c                 p    S nUn[        5       " U5      nU" S5      nU" S5      nU R                  XE5        g)r   c                     U (       a  SOSn[        / SPSPSPSPSPSPSPSPSPSPSPSPSPSPSPSPSPSPSPSPSPUPSPSPSPSPSPSPSPSPSPSPSPSPSPSP76 $ r   r   r   s     r@   r   TTestCallFunctionExPeepHole.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_controlflow?TestCallFunctionExPeepHole.test_all_args_noninlined_controlflow  s;    '	R {#EN%LrB   c                     S nU R                  [        5       n[        5       " U5      " S5        SSS5        U R                  S[	        WR
                  5      5        g! , (       d  f       N4= f)zL
Tests generating large kws when one of the inputs
has inlined controlflow.
c                     [        S0 SS_SS_SS_SS_SS_SS_SS_S	S_S
S_SS_SS_SS_SS_SS_SS_SU (       a  S_6$ S_6$ )Nr   ro   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r    r   r   r   r   s    r@   r   QTestCallFunctionExPeepHole.test_large_kws_inline_controlflow.<locals>.inline_func8  s       	
              a!   &'! rB   FNr   r   r   s      r@   !test_large_kws_inline_controlflow<TestCallFunctionExPeepHole.test_large_kws_inline_controlflow2  sT    	( 78FF;& 9G  !	
 98r   c                 p    S nUn[        5       " U5      nU" S5      nU" S5      nU R                  XE5        g)z{
Tests generating large kws when one of the inputs
has the change suggested in the error message
for inlined control flow.
c                     U (       a  SOSn[        S0 SS_SS_SS_SS_SS_SS_S	S_S
S_SS_SS_SS_SS_SS_SS_SS_SU_6$ )Nro   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r    r   r   r   s     r@   r   UTestCallFunctionExPeepHole.test_large_kws_noninlined_controlflow.<locals>.inline_funcZ  s    A1E   	
             ! rB   FNr   r   s         r@   %test_large_kws_noninlined_controlflow@TestCallFunctionExPeepHole.test_large_kws_noninlined_controlflowS  s:    	* {#EN%LrB   r   N)__name__
__module____qualname____firstlineno____doc__r^   rk   r[   r   rg   rl   rt   rw   r{   r~   r   r   r   r   r   r   r   __static_attributes__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                       \ rS rSrSr\S 5       r\S 5       r\S 5       r\S 5       r	\S 5       r
\S 5       r\S	 5       r\S
 5       rSrg)TestLargeConstDictiv  a  
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                 l    S nUn[        5       " U5      nU" 5       nU" 5       nU R                  XE5        g)Z
Tests that a function with a large heterogeneous constant
dictionary remains a constant.
c                      0 SS_SS_SS_SS_SS_SS_SS_S	S_S
S_SS_SS_SS_SS_SS_SS_SS_SS_SSS.En U S   $ )NAro   BCDEFGHIJKLMNOPQre   RSr   r   r   s    r@   
const_funcJTestLargeConstDict.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   )rQ   r   rc   rd   re   rf   s         r@   #test_large_heterogeneous_const_dict6TestLargeConstDict.test_large_heterogeneous_const_dict  s6    	6 z"IGrB   c                 b   ^ ^ S m[        T5      U 4S j5       n[        U4S j5       nU" 5         g)zfCheck the literal values for a LiteralStrKeyDict requiring
optimizations because it is heterogeneous.
c                     g r   r   r   s    r@   barYTestLargeConstDict.test_large_heterogeneous_LiteralStrKeyDict_literal_values.<locals>.bar      rB   c                   > 0 SS_SS_SS_SS_SS_SS_SS_S	S_S
S_SS_SS_SS_SS_SS_SS_SS_SS_SSS.EnS nUR                  5        VVs0 s H"  u  p4[        R                  " U5      U" U5      _M$     nnnTR                  [	        U [        R
                  5      5        TR                  U R                  U5        TR                  [        U S5      S5        S $ s  snnf )Nr   ro   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   re   r   c                 z    [         R                  " U 5      (       a  [         R                  " U 5      $ [        U 5      $ r   )r	   maybe_literalliteralr   )zs    r@   specific_tyqTestLargeConstDict.test_large_heterogeneous_LiteralStrKeyDict_literal_values.<locals>.ol_bar.<locals>.specific_ty  s*    +0+>+>q+A+Au}}Q'PvayPrB   initial_valueFc                     U $ r   r   r   s    r@   <lambda>nTestLargeConstDict.test_large_heterogeneous_LiteralStrKeyDict_literal_values.<locals>.ol_bar.<locals>.<lambda>      QrB   )	itemsr	   r  
assertTrue
isinstanceLiteralStrKeyDictr_   literal_valuehasattr)r   re   r  xyexpectedrQ   s         r@   ol_bar\TestLargeConstDict.test_large_heterogeneous_LiteralStrKeyDict_literal_values.<locals>.ol_bar  sc   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                     > 0 SS_SS_SS_SS_SS_SS_SS_S	S_S
S_SS_SS_SS_SS_SS_SS_SS_SS_SSS.En T" U 5        g )Nr   ro   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   re   r   r   r   r   s    r@   fooYTestLargeConstDict.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   rQ   r  r  r   s   `  @r@   9test_large_heterogeneous_LiteralStrKeyDict_literal_valuesLTestLargeConstDict.test_large_heterogeneous_LiteralStrKeyDict_literal_values  s;    	 
#	 
	> 
	 
	6 	rB   c                 t    S nUn[        5       " U5      nSnU" U5      nU" U5      nU R                  XV5        g)r   c                     0 SS_SS_SS_SS_SS_SS_SS_S	S_S
S_SS_SS_SS_SS_SS_SS_SS_SS_SU S.EnUS   $ )Nr   ro   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   )re   r   s     r@   const_keys_funcTTestLargeConstDict.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   )rQ   r   rc   rd   valuere   rf   s          r@   (test_large_heterogeneous_const_keys_dict;TestLargeConstDict.test_large_heterogeneous_const_keys_dict  s?    	6 "'EN%LrB   c                 b   ^ ^ S m[        T5      U 4S j5       n[        U4S j5       nU" 5         g)zuChecks that the optimization for large dictionaries
do not incorrectly update initial values due to other
mutations.
c                     g r   r   r   s    r@   r   DTestLargeConstDict.test_large_dict_mutation_not_carried.<locals>.bar#  r   rB   c                 (  > 0 SS_SS_SS_SS_SS_SS_SS_S	S_S
S_SS_SS_SS_SS_SS_SS_SS_SS_SSS.EnU R                   c  S $ TR                  [        U [        R                  5      5        TR                  U R                   U5        S $ )Nr   ro   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   c                     [        U 5      $ r   r   r   s    r@   r  YTestLargeConstDict.test_large_dict_mutation_not_carried.<locals>.ol_bar.<locals>.<lambda>>      1rB   c                     U $ r   r   r   s    r@   r  r,  A  r
  rB   r  r  r  r	   DictTyper_   r   re   rQ   s     r@   r  GTestLargeConstDict.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                     > 0 SS_SS_SS_SS_SS_SS_SS_S	S_S
S_SS_SS_SS_SS_SS_SS_SS_SS_SSS.En SU S'   T" U 5        g )Nr   ro   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   Xr   r  s    r@   r  DTestLargeConstDict.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_carried7TestLargeConstDict.test_large_dict_mutation_not_carried  s;    	 
#	 
	8 
	 
	6 	rB   c                    ^ ^^	^
^ S m	S mSmSm
[        T	SS9UU 4S j5       n[        TSS9U
U 4S j5       nUU	4S jnUn[        5       " U5      nU" 5       nU" 5       nT R                  Xg5        g	)
zN
Tests an example using a regular update is
not modified by the optimization.
c                     g r   r   r  s    r@   check_beforeDTestLargeConstDict.test_usercode_update_use_d2.<locals>.check_beforeh      rB   c                     g r   r   r:  s    r@   check_afterCTestLargeConstDict.test_usercode_update_use_d2.<locals>.check_afterk  r=  rB   FT)prefer_literalc                    > T(       dM  SmSSSS.nTR                  [        U [        R                  5      5        TR	                  U R
                  U5        S $ )NTro   r   r   re   rf   r   c                     g r   r   r   s    r@   r  YTestLargeConstDict.test_usercode_update_use_d2.<locals>.ol_check_before.<locals>.<lambda>      TrB   )r  r  r	   r0  r_   r  )r   re   checked_beforerQ   s     r@   ol_check_beforeGTestLargeConstDict.test_usercode_update_use_d2.<locals>.ol_check_beforeq  sP     "!%
 
1enn =>  !4!!rB   c                    > T(       dH  SmTR                  [        U [        R                  5      5        TR                  U R                  S L 5        S $ )NTc                     g r   r   r   s    r@   r  XTestLargeConstDict.test_usercode_update_use_d2.<locals>.ol_check_after.<locals>.<lambda>  rF  rB   )r  r  r	   r0  r  )r   checked_afterrQ   s    r@   ol_check_afterFTestLargeConstDict.test_usercode_update_use_d2.<locals>.ol_check_after  s?     ! $
1enn =>4 78!!rB   c                     > SSSS.n SSS.nT" U 5        U R                  U5        T" U 5        [        U 5      S:  a  U$ U $ )zh
Dictionary update between two constant
dictionaries. This verifies d2 doesn't
get incorrectly removed.
ro   r   r   rC  r   )r   r   )updatelen)d1d2r?  r;  s     r@   const_dict_funcGTestLargeConstDict.test_usercode_update_use_d2.<locals>.const_dict_func  sU     B B IIbMO2w{	IrB   N)r   r   r_   )rQ   rH  rN  rU  rc   rd   re   rf   r?  r;  rM  rG  s   `       @@@@r@   test_usercode_update_use_d2.TestLargeConstDict.test_usercode_update_use_d2a  s    		 	,t	4	" 
5	"" 
+d	3
	" 
4
	"	. "'IGrB   c                     S nU R                  [        5       n[        5       " U5      " SS5        SSS5        U R                  S[	        WR
                  5      5        g! , (       d  f       N4= f)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                     0 SS_SS_SS_SS_SS_SS_SS_S	U(       a  SOS
_SS_SS_SS_SS_SS_SS_SS_SS_SS_SU S.EnUS   $ )Nr   ro   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   )re   r   r   s      r@   r   PTestLargeConstDict.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_controlflow;TestLargeConstDict.test_large_const_dict_inline_controlflow  sV    	6 78FF;
E2 9G  !	
 98s   A
A-c                 x    S nUn[        5       " U5      nSnU" US5      nU" US5      nU R                  XV5        g)z
Tests generating large constant dict when one of the
inputs has the change suggested in the error message
for inlined control flow.
c                     U(       a  SOSn0 SS_SS_SS_SS_SS_SS_S	S_S
U_SS_SS_SS_SS_SS_SS_SS_SS_SS_SU S.EnUS   $ )Nro   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   )re   r   valr   s       r@   non_inline_funcWTestLargeConstDict.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   )rQ   ra  rc   rd   r#  re   rf   s          r@   +test_large_const_dict_noninline_controlflow>TestLargeConstDict.test_large_const_dict_noninline_controlflow  sE    	8 "'E5!%rB   c                 b   ^ ^ S m[        T5      U 4S j5       n[        U4S j5       nU" 5         g)z
Tests that the correct literal values are generated
for a dictionary that produces two DICT_UPDATE
bytecode entries for the same dictionary.
c                     g r   r   r   s    r@   r   >TestLargeConstDict.test_fuse_twice_literal_values.<locals>.bar  r   rB   c                   > 0 SS_SS_SS_SS_S	S
_SS_SS_SS_SS_SS_SS_SS_SS_SS_SS_SS _S!S"_0 S#S$_S%S&_S'S(_S)S*_S+S,_S-S._S/S0_S1S2_S3S4_S5S6_S7S8_S9S:_S;S<_S=S>_S?S@_SASB_SCSD_ESESF0EnU R                   c  SG $ TR                  [        U [        R                  5      5        TR                  U R                   U5        SH $ )INa1ro   a2r   a3r   a4r   a5rJ   a6r   a7r   a8r   a9r   a10r   a11r   a12r   a13r   a14r   a15r   a16rG   a17   a18   a19   a20   a21   a22   a23   a24   a25   a26   a27   a28   a29   a30   a31rF   a32    a33!   a34"   a35#   c                     [        U 5      $ r   r+  r   s    r@   r  STestLargeConstDict.test_fuse_twice_literal_values.<locals>.ol_bar.<locals>.<lambda>4  r-  rB   c                     U $ r   r   r   s    r@   r  r  7  r
  rB   r/  r1  s     r@   r  ATestLargeConstDict.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                     > 0 SS_SS_SS_SS_S	S
_SS_SS_SS_SS_SS_SS_SS_SS_SS_SS_SS _S!S"_0 S#S$_S%S&_S'S(_S)S*_S+S,_S-S._S/S0_S1S2_S3S4_S5S6_S7S8_S9S:_S;S<_S=S>_S?S@_SASB_SCSD_ESESF0En T" U 5        g )GNri  ro   rj  r   rk  r   rl  r   rm  rJ   rn  r   ro  r   rp  r   rq  r   rr  r   rs  r   rt  r   ru  r   rv  r   rw  r   rx  rG   ry  rz  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  rF   r  r  r  r  r  r  r  r  r   r  s    r@   r  >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_values1TestLargeConstDict.test_fuse_twice_literal_values  s=    	 
#+	 
+	Z 
)	 
)	V 	rB   r   N)r   r   r   r   r   r   r   r  r$  r6  rW  r\  rc  r  r   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                       \ rS rSrSrS rSrg)'TestListExtendInStarArgNonTupleIterableih  aF  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                    ^ S m[        SS9U4S j5       nU" S5      nUR                  S5      nU R                  US5        U R                  X#5        g )Nc                      U $ r   r   r:  s    r@   consumerSTestListExtendInStarArgNonTupleIterable.test_list_extend_forceobj.<locals>.consumert  s    HrB   T)forceobjc                    > T" SS/U Q76 $ r   r   )r  r  s    r@   r  NTestListExtendInStarArgNonTupleIterable.test_list_extend_forceobj.<locals>.foow  s    Aq%1%%rB   ijo)ro   r   rT   r   r   )r   rc   r_   )rQ   r  gotexpectr  s       @r@   test_list_extend_forceobjATestListExtendInStarArgNonTupleIterable.test_list_extend_forceobjs  sY    	 
d		& 
	& %jU#34%rB   r   N)r   r   r   r   r   r  r   r   rB   r@   r  r  h  s    	&rB   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   unittestnumbar   r   r   r   r   numba.extendingr   
numba.corer	   numba.core.errorsr
   numba.tests.supportr   r   r   rA   rD   r   r  r   mainr   rB   r@   <module>r     s    7 7 $  6  	
	
	
	
	
	
	
	
	
	

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