
    J/PhUv                     d   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                     dS dS )z0
Test bytecode fixes provided in interpreter.py
    N)jitnjitobjmodetypeof	literally)overload)types)UnsupportedBytecodeError)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/                                                  \/var/www/html/test/jupyter/venv/lib/python3.11/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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                    d t          ||z             D             }g }t          ||z             D ],}|dz  dk    rd| d}nd| }|                    |           -d                    |          }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 )zw
            Generates a function that calls sum_jit_func
            with the desired number of args and kws.
        c                     g | ]}d | S )argr   .0is     r@   
<listcomp>z7TestCallFunctionExPeepHole.gen_func.<locals>.<listcomp>   s    ???AiAii???rB      r   zpow(argz, 2)rI   z, z	def impl(z):
z    return sum_jit_func(
z        z,
=z    )
rA   impl)rangeappendjoinexecrA   )
selfn_argsn_kws
param_list	args_listrL   arg_valtotal_params	func_text
local_varss
             r@   gen_funcz#TestCallFunctionExPeepHole.gen_func   s\   
 @?v~)>)>???
	v~&& 	& 	&A 1uzz+A+++#))W%%%%yy,,2222	11	v 	6 	6A5IaL5555IIvv~.. 	F 	FAEJqMEEIaLEEEEIIY	
Y6
CCC&!!rB   c                     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                     g | ]}|S r   r   rJ   s     r@   rM   z<TestCallFunctionExPeepHole.test_all_args.<locals>.<listcomp>   s    <<<Aa<<<rB   r   N)rQ   THRESHOLD_ARGSr^   r   assertEqualrU   
total_argsfpy_funccfuncabs          r@   test_all_argsz(TestCallFunctionExPeepHole.test_all_args   s     =<t':!;!;<<<
MM$-q11q		GZ E:ArB   c                     d t          | j                  D             }|                     d| j                  }|} t                      |          } || } || }|                     ||           dS )zR
        Tests calling a function when n_kws > 15 and
        n_args = 0.
        c                     g | ]}|S r   r   rJ   s     r@   rM   z;TestCallFunctionExPeepHole.test_all_kws.<locals>.<listcomp>   s    ;;;Aa;;;rB   r   N)rQ   THRESHOLD_KWSr^   r   rb   rc   s          r@   test_all_kwsz'TestCallFunctionExPeepHole.test_all_kws   s     <;t'9!:!:;;;
MM!T/00q		GZ E:ArB   c                    | j         dz
  }| j        dz
  }d t          ||z             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                     g | ]}|S r   r   rJ   s     r@   rM   zHTestCallFunctionExPeepHole.test_small_args_small_kws.<locals>.<listcomp>       AAAAaAAArB   Nra   rm   rQ   r^   r   rb   	rU   	used_argsused_kwsrd   re   rf   rg   rh   ri   s	            r@   test_small_args_small_kwsz4TestCallFunctionExPeepHole.test_small_args_small_kws   s     '!+	%)AA	h'?!@!@AAA
MM)X..q		GZ E:ArB   c                     | j         dz
  }| j        }d t          ||z             D             }|                     ||          }|} t	                      |          } || } || }|                     ||           dS )zr
        Tests calling a function when (n_args / 2) + n_kws > 15,
        but n_args <= 30 and n_kws > 15
        rp   c                     g | ]}|S r   r   rJ   s     r@   rM   zHTestCallFunctionExPeepHole.test_small_args_large_kws.<locals>.<listcomp>   rr   rB   Nrs   rt   s	            r@   test_small_args_large_kwsz4TestCallFunctionExPeepHole.test_small_args_large_kws   s     '!+	%AA	h'?!@!@AAA
MM)X..q		GZ E:ArB   c                     | j         }| j        dz
  }d t          ||z             D             }|                     ||          }|} t	                      |          } || } || }|                     ||           dS )zr
        Tests calling a function when (n_args / 2) + n_kws > 15,
        but n_args > 30 and n_kws <= 15
        rp   c                     g | ]}|S r   r   rJ   s     r@   rM   zHTestCallFunctionExPeepHole.test_large_args_small_kws.<locals>.<listcomp>   rr   rB   Nrs   rt   s	            r@   test_large_args_small_kwsz4TestCallFunctionExPeepHole.test_large_args_small_kws   s     '	%)AA	h'?!@!@AAA
MM)X..q		GZ E:ArB   c                     | j         }| j        }d t          ||z             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                     g | ]}|S r   r   rJ   s     r@   rM   zHTestCallFunctionExPeepHole.test_large_args_large_kws.<locals>.<listcomp>   rr   rB   Nrs   rt   s	            r@   test_large_args_large_kwsz4TestCallFunctionExPeepHole.test_large_args_large_kws   s     '	%AA	h'?!@!@AAA
MM)X..q		GZ E:ArB   c                     d t           fd            }t          t                                           } |            }|                     ||           dS )zO
        Tests calling an objectmode function with > 15 return values.
        c                      dS )N)r   rp            rN            	   
                  r   r   rB   r@   rf   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           n# 1 swxY w Y   | |z   |z   |z   |z   |z   |z   |z   |z   |	z   |
z   |z   |z   |z   |z   |z   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.
            rh   int64ri   cdere   ghrL   jklmnopNr   )r   )rh   ri   r   r   r   re   r   r   rL   r   r   r   r   r   r   r   rf   s                   r@   objmode_funczGTestCallFunctionExPeepHole.test_large_kws_objmode.<locals>.objmode_func  s
       '' ' '	
 ' ' ' ' ' ' ' ' ' ' '  '! # #F GII#E# # # # # # # # # # # # # # #J   	
     	 
     s   A$$A(+A(N)r   sumlistrb   )rU   r   rh   ri   rf   s       @r@   test_large_kws_objmodez1TestCallFunctionExPeepHole.test_large_kws_objmode   sz    
	 	 	( 
;	 ;	 ;	 ;	 
;	z WWYY  LNNArB   c                     d }|                      t                    5 }  t                      |          d           ddd           n# 1 swxY w Y   |                     dt	          |j                             dS )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R ddiS Nrp   r   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rU   r   raisess      r@   "test_large_args_inline_controlflowz=TestCallFunctionExPeepHole.test_large_args_inline_controlflowX  s    '	 '	 '	R 788 	'FFDFF;&&&	' 	' 	' 	' 	' 	' 	' 	' 	' 	' 	' 	' 	' 	' 	'G !!	
 	
 	
 	
 	
   !AAAc                     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                     | 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R ddiS r   r   r   a_vals     r@   r   zVTestCallFunctionExPeepHole.test_large_args_noninlined_controlflow.<locals>.inline_func  s   $AA1E &&& & 	&
 & & & & & & & & & & &  !&" #&$ %&& '&( )&* +&, -&. /&0 1&2 3&4 5&6 7&8 9&: ;&< =&> ?&@ A&B C&D E&F G&H I& & &J K& & &rB   FNr   rb   rU   r   rf   rg   rh   ri   s         r@   &test_large_args_noninlined_controlflowzATestCallFunctionExPeepHole.test_large_args_noninlined_controlflow  sb    (	 (	 (	T {##GENNE%LLArB   c                     d }|                      t                    5 }  t                      |          d           ddd           n# 1 swxY w Y   |                     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                     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R  S Nrp   r   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  s    &	 &	 &	P 788 	'FFDFF;&&&	' 	' 	' 	' 	' 	' 	' 	' 	' 	' 	' 	' 	' 	' 	'G !!	
 	
 	
 	
 	
r   c                     d }|} t                      |          } |d          } |d          }|                     ||           dS )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R  S r   r   r   s     r@   r   zTTestCallFunctionExPeepHole.test_all_args_noninlined_controlflow.<locals>.inline_func  s   $AA1E %%% % 	%
 % % % % % % % % % % %  !%" #%$ %%& '%( )%* +%, -%. /%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  sb    '	 '	 '	R {##GENNE%LLArB   c                     d }|                      t                    5 }  t                      |          d           ddd           n# 1 swxY w Y   |                     dt	          |j                             dS )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ndS )Nr   rp   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r    r   r   r   r   s    r@   r   zQTestCallFunctionExPeepHole.test_large_kws_inline_controlflow.<locals>.inline_func8  s       QQ Q Q	
 Q Q Q Q Q Q a a a a a   &aaQ! rB   FNr   r   r   s      r@   !test_large_kws_inline_controlflowz<TestCallFunctionExPeepHole.test_large_kws_inline_controlflow2  s    	 	 	( 788 	'FFDFF;&&&	' 	' 	' 	' 	' 	' 	' 	' 	' 	' 	' 	' 	' 	' 	'G !!	
 	
 	
 	
 	
r   c                     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                     | 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 )Nrp   r   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    $AA1E   QQ Q Q	
 Q Q Q Q Q Q a a a a a  e! rB   FNr   r   s         r@   %test_large_kws_noninlined_controlflowz@TestCallFunctionExPeepHole.test_large_kws_noninlined_controlflowS  sa    	 	 	* {##GENNE%LLArB   N)__name__
__module____qualname____doc__ra   rm   r^   r   rj   rn   rw   rz   r}   r   r   r   r   r   r   r   r   r   rB   r@   rD   rD   u   s         NM" " "6                   X X Xt 3
 3
 3
j 4 4 4l 4
 4
 4
l 3 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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                     d }|} t                      |          } |            } |            }|                     ||           dS )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Arp   BCDEFGHIJKLMNOPQrh   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   )rU   r   rf   rg   rh   ri   s         r@   #test_large_heterogeneous_const_dictz6TestLargeConstDict.test_large_heterogeneous_const_dict  s]    	 	 	6 z""GIIEGGArB   c                 |     d t                     fd            }t          fd            } |             dS )zvCheck the literal values for a LiteralStrKeyDict requiring
        optimizations because it is heterogeneous.
        c                     d S r   r   r   s    r@   barzYTestLargeConstDict.test_large_heterogeneous_LiteralStrKeyDict_literal_values.<locals>.bar      CrB   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 fd|                                 D             }                    t          | t          j                                                 | j        |                               t          | d          d           d S )Nr   rp   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   rh   r   c                 p    t          j        |           rt          j        |           n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+A+APu}Q'''vayyPrB   c                 R    i | ]#\  }}t          j        |           |          $S r   )r	   r   )rK   xyr   s      r@   
<dictcomp>zpTestLargeConstDict.test_large_heterogeneous_LiteralStrKeyDict_literal_values.<locals>.ol_bar.<locals>.<dictcomp>  s1    OOOTQa((++a..OOOrB   initial_valueFc                     | S r   r   r   s    r@   <lambda>znTestLargeConstDict.test_large_heterogeneous_LiteralStrKeyDict_literal_values.<locals>.ol_bar.<locals>.<lambda>      Q rB   )items
assertTrue
isinstancer	   LiteralStrKeyDictrb   literal_valuehasattr)r   rh   expectedr   rU   s      @r@   ol_barz\TestLargeConstDict.test_large_heterogeneous_LiteralStrKeyDict_literal_values.<locals>.ol_bar  s|   QQ Q Q	
 Q Q Q Q Q Q Q Q Q Q Q  Q!" Q#$ '  A,Q Q QOOOOQWWYYOOOHOOJq%*ABBCCCQ_h777WQ88%@@@;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 S )Nr   rp   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   rh   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* CFFFFFrB   Nr   r   rU   r  r  r   s   `  @r@   9test_large_heterogeneous_LiteralStrKeyDict_literal_valueszLTestLargeConstDict.test_large_heterogeneous_LiteralStrKeyDict_literal_values  st    	 	 	 
#	 	 	 	 
	> 
	 	 	 	 
	6 	rB   c                     d }|} t                      |          }d} ||          } ||          }|                     ||           dS )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   rp   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   )rh   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   )rU   r
  rf   rg   valuerh   ri   s          r@   (test_large_heterogeneous_const_keys_dictz;TestLargeConstDict.test_large_heterogeneous_const_keys_dict  sf    	 	 	6 "''GENNE%LLArB   c                 |     d t                     fd            }t          fd            } |             dS )zChecks that the optimization for large dictionaries
        do not incorrectly update initial values due to other
        mutations.
        c                     d S 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                     t          | t          j                                                 | j         |           d S )Nr   rp   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	   DictTyperb   r   rh   rU   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9:::Q_a00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<    |            d S )Nr   rp   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CFFFFFrB   Nr  r  s   `  @r@   $test_large_dict_mutation_not_carriedz7TestLargeConstDict.test_large_dict_mutation_not_carried  st    	 	 	 
#	 	 	 	 
	8 
	 	 	 	 
	6 	rB   c                 *   	
 d 	d dd
t          	d           fd            }t          d          
 fd            }	fd}|} t                      |          } |            } |            }                     ||           d	S )
zf
        Tests an example using a regular update is
        not modified by the optimization.
        c                     d S r   r   r   s    r@   check_beforezDTestLargeConstDict.test_usercode_update_use_d2.<locals>.check_beforeh      DrB   c                     d S r   r   r  s    r@   check_afterzCTestLargeConstDict.test_usercode_update_use_d2.<locals>.check_afterk  r  rB   FT)prefer_literalc                     sPddddd}                     t          | t          j                                                 | j        |           d S )NTrp   r   r   rh   ri   r   c                     d S r   r   r   s    r@   r   zYTestLargeConstDict.test_usercode_update_use_d2.<locals>.ol_check_before.<locals>.<lambda>      T rB   )r   r   r	   r  rb   r   )r   rh   checked_beforerU   s     r@   ol_check_beforezGTestLargeConstDict.test_usercode_update_use_d2.<locals>.ol_check_beforeq  sg     " 5!% 
 
1en = =>>>  !444!>!rB   c                     sKd                     t          | t          j                                                  | j        d u            d S )NTc                     d S 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_afterrU   s    r@   ol_check_afterzFTestLargeConstDict.test_usercode_update_use_d2.<locals>.ol_check_after  sQ     ! 9 $
1en = =>>>4 7888!>!rB   c                      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.
            rp   r   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 LIIbMMMKOOO2ww{{	IrB   N)r   r   rb   )rU   r(  r,  r2  rf   rg   rh   ri   r!  r  r+  r'  s   `       @@@@r@   test_usercode_update_use_d2z.TestLargeConstDict.test_usercode_update_use_d2a  s	   	 	 		 	 	 	,t	4	4	4	" 	" 	" 	" 	" 
5	4	"" 
+d	3	3	3
	" 
	" 
	" 
	" 
	" 
4	3
	"	 	 	 	 	 	. "''GIIEGGArB   c                    d }|                      t                    5 }  t                      |          dd           ddd           n# 1 swxY w Y   |                     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                     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   rp   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   )rh   r   r   s      r@   r   zPTestLargeConstDict.test_large_const_dict_inline_controlflow.<locals>.inline_func  s    QQ Q Q	
 Q Q Q $%QQA 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  s    	 	 	6 788 	3FFDFF;
E222	3 	3 	3 	3 	3 	3 	3 	3 	3 	3 	3 	3 	3 	3 	3G !!	
 	
 	
 	
 	
s   "AAAc                     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                     |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 )Nrp   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   )rh   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   )rU   r:  rf   rg   r  rh   ri   s          r@   +test_large_const_dict_noninline_controlflowz>TestLargeConstDict.test_large_const_dict_noninline_controlflow  sn    	 	 	8 "''GE5!!E%ArB   c                 |     d t                     fd            }t          f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                     d S 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                     t          | t          j                                                 | j         |           dH S )INa1rp   a2r   a3r   a4r   a5rN   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9:::Q_a00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}  |            d S )GNr?  rp   r@  r   rA  r   rB  r   rC  rN   rD  r   rE  r   rF  r   rG  r   rH  r   rI  r   rJ  r   rK  r   rL  r   rM  r   rN  rF   rO  rP  rQ  rR  rS  rT  rU  rV  rW  rX  rY  rZ  r[  r\  r]  r^  r_  r`  ra  rb  rc  rd  re  rf  rg  rh  ri  rj  rk  rE   rl  rm  rn  ro  rp  rq  rr  rs  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 CFFFFFrB   Nr  r  s   `  @r@   test_fuse_twice_literal_valuesz1TestLargeConstDict.test_fuse_twice_literal_values  sv    	 	 	 
#+	 +	 +	 +	 
+	Z 
)	 )	 )	 )	 
)	V 	rB   N)r   r   r   r   r   r   r  r  r  r3  r6  r;  rw  r   rB   r@   r   r   v  s         $ $ $L D D DL & & &P A A AF I I IV '
 '
 '
R ' ' 'R c c c c crB   r   c                       e Zd ZdZ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                     d t          d          fd            } |d          }|                    d          }|                     |d           |                     ||           d S )Nc                      | S r   r   r  s    r@   consumerzSTestListExtendInStarArgNonTupleIterable.test_list_extend_forceobj.<locals>.consumert  s    HrB   T)forceobjc                      ddg| R  S r   r   )r   r|  s    r@   r  zNTestListExtendInStarArgNonTupleIterable.test_list_extend_forceobj.<locals>.foow  s    8Aq%1%%%%rB   ijo)rp   r   rL   r   r   )r   rf   rb   )rU   r  gotexpectr|  s       @r@   test_list_extend_forceobjzATestListExtendInStarArgNonTupleIterable.test_list_extend_forceobjs  s    	 	 	 
d				& 	& 	& 	& 
		& c%jjU##3444f%%%%%rB   N)r   r   r   r   r  r   rB   r@   ry  ry  h  s-        	 	& & & & &rB   ry  __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   ry  r   mainr   rB   r@   <module>r     s     7 7 7 7 7 7 7 7 7 7 7 7 7 7 $ $ $ $ $ $       6 6 6 6 6 6          	
	
	
	
	
	
	
	
	
	

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