o
    8ήcl                     @   s   d dl Z d dlZd dlZd dlZd dlZd dlZd dlmZ d dlm	Z	 d dl
mZmZmZmZmZmZ d dlmZ d dlmZmZ d dlmZ d dlmZmZ d d	lmZ d d
lmZmZ d dl Z ej!Z"ej#Z$ej%Z&ej'Z(ej)Z*ej+Z,ej-Z.ej/Z0ej1Z2ej3Z4ej5Z6ej7Z8G dd de jZ9G dd de jZ:G dd dee jZ;G dd de jZ<G dd de jZ=dd Z>dd Z?dd Z@dd ZAdd ZBdd  ZCG d!d" d"eZDG d#d$ d$e jZEed%d&d'G d(d) d)eZFG d*d+ d+ejGjHjIZJd,d- ZKG d.d/ d/e jZLeMd0kre N  dS dS )1    N)compile_isolated)jit)errorsirtypestyping	typeinferutils)
Conversion)TestCasetag)CompatibilityTestMixin)TranslateByteCodeIRProcessing)PartialTypeInference)FunctionPassregister_passc                   @   s$   e Zd Zdd Zdd Zdd ZdS )TestArgRetCastingc                 C   sX   dd }t f}t}t|||}| t|dt | |jj	| | |jj
| d S )Nc                 S      | S N xr   r   A/tmp/pip-target-vg8gfxp4/lib/python/numba/tests/test_typeinfer.pyfoo$      z3TestArgRetCasting.test_arg_ret_casting.<locals>.foo{   )i32f32r   
assertTrue
isinstanceentry_pointfloatassertEqual	signatureargsreturn_type)selfr   r%   r&   cresr   r   r   test_arg_ret_casting#   s   z&TestArgRetCasting.test_arg_ret_castingc              
   C   sd   dd }t tddf}t}zt|||}W n tjy* } zW Y d }~d S d }~ww | d d S )Nc                 S   r   r   r   r   r   r   r   r   /   r   z4TestArgRetCasting.test_arg_ret_mismatch.<locals>.foo   Cz.Should complain about array casting to float32)r   Arrayr   r   r   r   TypingErrorfail)r'   r   r%   r&   r(   er   r   r   test_arg_ret_mismatch.   s   z'TestArgRetCasting.test_arg_ret_mismatchc                 C   s:   dd }t f}t}t|||}|jj}| |d t  d S )Nc                 S   s   t | }| S r   range)itersar   r   r   r   <   s   z<TestArgRetCasting.test_invalid_arg_type_forcing.<locals>.foor3   )u32u8r   type_annotationtypemapr#   )r'   r   r%   r&   r(   r8   r   r   r   test_invalid_arg_type_forcing;   s   z/TestArgRetCasting.test_invalid_arg_type_forcingN)__name__
__module____qualname__r)   r0   r9   r   r   r   r   r   "   s    r   c                   @   sf  e Zd ZdZ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"dd#dd$dd%dd&dd'dd(dd)dd*dd+dd,dddd-Zd.d/ Zd0d1 Zd2d3 Zd4d5 Zd6d7 Z	d8d9 Z
d:d; Zd<d= Zd>d? Zd@dA ZdBdC ZdDdE ZdFdG ZdHdI ZdJdK ZdLS )M	TestUnifyz;
    Tests for type unification with a typing context.
    )uint8r>   r>   )int8r?   r?   )uint16r@   r@   )int16rA   rA   )uint32rB   rB   )int32rC   rC   )uint64rD   rD   )int64rE   rE   )r?   r>   )r?   r@   )r?   rB   )r>   rC   )r>   rD   )rA   r?   )rA   r>   )rA   r@   )rA   rB   )rA   rE   )rA   rD   float64)r@   r>   )r@   rB   )r@   rC   )r@   rD   )rC   r?   )rC   rA   )rC   rB   )rC   rE   )rB   r>   )rB   rE   )rB   rD   )rE   r?   )rE   r>   )rE   r@   )rD   r?   ))rD   rC   )rD   rE   c              
   C   sn   t  }d}|j|jfD ](}|||}| j|||||||d |||}| j|||||||d qd S )Nz{0}, {1} -> {2} != {3})msg)r   Contextunify_typesunify_pairsr#   format)r'   atybtyexpectedctxtemplate
unify_funcunifiedr   r   r   assert_unify|   s   

zTestUnify.assert_unifyc                 C   s   |  ||d  d S r   )rS   r'   rL   rM   r   r   r   assert_unify_failure   s   zTestUnify.assert_unify_failurec              	   C   s   t  }ttjtjD ]1\}}t|t|f}z| j| }W n ty2   | j|d d d  }Y nw | 	||t
t| qd S N)r   rH   	itertoolsproductr   integer_domainstr	int_unifyKeyErrorrS   getattr)r'   rO   rL   rM   keyrN   r   r   r   test_integer   s   zTestUnify.test_integerc                 C   s>   t j}t jD ]	}| ||| qt jD ]	}| ||| qd S r   )r   booleanrZ   rS   real_domainr'   rL   rM   ctyr   r   r   	test_bool   s   

zTestUnify.test_boolc                    sl   t   ttj|D ](} fddt|D }|d }| |tj |dd D ]}| 	|| q*qdS )z
        Test all permutations of N-combinations of numeric types and ensure
        that the order of types in the sequence is irrelevant.
        c                       g | ]} j | qS r   rI   .0combrO   r   r   
<listcomp>       z4TestUnify.unify_number_pair_test.<locals>.<listcomp>r   r*   N)
r   rH   rX   combinationsr   number_domainpermutationsassertIsInstanceNumberr#   )r'   ntysresfirst_resultotherr   rk   r   unify_number_pair_test   s   
z TestUnify.unify_number_pair_testc                 C   s   |  d |  d d S )N      )rx   r'   r   r   r   test_unify_number_pair   s   
z TestUnify.test_unify_number_pairc                    sn   t   ttjdD ])}t|}t j| } fddt	|tj
g D }|D ]}| || q+qdS )zW
        Test unification of `none` and multiple number types to optional type
        ry   c                    rf   r   rg   rh   rk   r   r   rl      rm   z3TestUnify.test_none_to_optional.<locals>.<listcomp>N)r   rH   rX   rn   r   ro   listOptionalrI   rp   noner#   )r'   rt   rN   resultsru   r   rk   r   test_none_to_optional   s   
zTestUnify.test_none_to_optionalc                 C   s    t j}t j}| ||t j d S r   )r   r   rS   rT   r   r   r   	test_none   s   zTestUnify.test_nonec                 C   s   t t}t j}| ||| t t}t t}| ||| t t}t}| ||t t t t}t t j}| || d S r   )r   r~   r   r   rS   i64slice3_typerU   rT   r   r   r   test_optional   s   




zTestUnify.test_optionalc              
   C   s  t td}t td}| ||t td t td}t ttf}| ||t ttf t td}t d}| ||| t tttf}t tttf}| ||t tttf t ttf}t ttf}| ||t ttf t ttf}t ttf}| ||t ttf t td}t t	d}| ||t t
d t t ttfd}t t ttfd}| ||t t ttfd t td}t t jd}| || t td}t td}| || t tt jf}t ttf}| || d S )Nrz   ry   r   r   r*   )r   UniTupler   r   rS   Tuplei16i8f64c64c128r5   r   r   rU   rT   r   r   r   
test_tuple   sF   
zTestUnify.test_tuplec              
   C   s   t j}t td}| ||t t td t t td}t td}| ||t t td t t jtf}t tt jf}| ||t t tt tf t t ttf}t tt t	f}| ||t t tt tf d S )Nry   )
r   r   r   r   rS   r~   r   r   r   r   rT   r   r   r   test_optional_tuple   s    zTestUnify.test_optional_tuplec              
   C   s  t tdd}t tdd}| ||| t tdd}t tdd}| ||t tdd t tdd}t jtdddd}| ||| t tdd}t jtdddd}| ||t jtdddd t tdd}t tdd}| || t tdd}t tdd}| || d S )Nrz   r+   AFTreadonlyry   )r   r,   r   rS   rU   r5   rT   r   r   r   test_arrays  s(   zTestUnify.test_arraysc                 C   s   t t j}t t}| ||| t t}t t}| ||| t t ttg}t t ttg}t t ttg}| ||| t jtdd}t t}t jtdd}| ||| t t}t t tg}| || d S NT)	reflected)	r   List	undefinedr   rS   r   r   r   rU   rc   r   r   r   	test_list%  s"   




zTestUnify.test_listc                 C   s`   t jtdd}t t}t jtdd}| ||| t t}t t tg}| || d S r   )r   Setr   r   rS   r   rU   rc   r   r   r   test_set:  s   

zTestUnify.test_setc                 C   s   t j}t j}| ||| d S r   )r   range_state32_typerange_state64_typerS   rT   r   r   r   
test_rangeE  s   zTestUnify.test_rangeN)r:   r;   r<   __doc__r\   rS   rU   r`   re   rx   r|   r   r   r   r   r   r   r   r   r   r   r   r   r   r=   H   s    
 "#$&'(*+/)r=   c                   @   s@   e Zd ZdZdd Zdd Zdd Zdd	 Zd
d Zdd Z	dS )TestTypeConversionzB
    Test for conversion between types with a typing context.
    c                 C   s$   t  }|||}| || d S r   )r   rH   can_convertr#   )r'   rL   rM   rN   rO   gotr   r   r   assert_can_convertP  s   z%TestTypeConversion.assert_can_convertc                 C   s"   t  }|||}| | d S r   )r   rH   r   assertIsNone)r'   rL   rM   rO   r   r   r   r   assert_cannot_convertU  s   z(TestTypeConversion.assert_cannot_convertc                 C   s   t  }| |j d S r   )r   rH   check_number_compatibilityr   )r'   rO   r   r   r   test_convert_number_typesZ  s   z,TestTypeConversion.test_convert_number_typesc                 C   sj  t td}t td}| ||tj | ||tj t td}t td}| ||tj	 t 
ttf}t 
ttf}| ||tj t td}t 
ttf}| ||tj | ||tj t td}t td}t 
d}| ||tj	 | ||tj	 | ||tj	 | ||tj	 t td}t t jd}| || t td}t td}d S )Nrz   ry   r   r   )r   r   r   r   r   r
   exactpromoter   safer   unsafer   r   rc   r   r   r   r   a  s4   
zTestTypeConversion.test_tuplec                 C   s  t tdd}t tdd}| ||tj t tdd}t tdd}| || t tdd}t jtdddd}| ||tj | ||tj | ||tj | || t tdd}t tdd}| || t tdd}t tdd}| || d S )Nrz   r+   r   ry   r   Tr   )	r   r,   r   r   r
   r   r   r   r   rT   r   r   r   r     s$   zTestTypeConversion.test_arraysc                 C   s  t j}t t}| t j|tj | ||tj | |t j | ||tj	 t 
tdd}t |}| t j|tj | ||tj | ||tj	 t 
tdd}t |jdd}| ||tj	 | || t 
tdd}t |jdd}| || | || d S )Nry   r+   r   )layoutr   )r   rC   r~   r   r   r   r
   r   r   r   r,   copyrT   r   r   r   r     s&   

z TestTypeConversion.test_optionalN)
r:   r;   r<   r   r   r   r   r   r   r   r   r   r   r   r   K  s    !r   c                   @   s0   e Zd ZdZdd Zdd Zdd Zdd	 Zd
S )TestResolveOverloadz6
    Tests for typing.Context.resolve_overload().
    c                 C   s(   t  }|d||i }| || d S )Nr   )r   rH   resolve_overloadr#   )r'   casesr%   rN   rO   r   r   r   r   assert_resolve_overload  s   z+TestResolveOverload.assert_resolve_overloadc                    s    fdd}t t t ttttttg |t t f d  |ttf d  |ttf d  |t tf d  |tt f d  |tt f d  |ttf d  |ttf d  |ttf d  d S )Nc                    s*     | |   d d d | | d S rV   r   )r%   rN   r   r'   r   r   check  s   z;TestResolveOverload.test_non_ambiguous_match.<locals>.checkr   r*   ry   )r   r   r   r   r   r5   r   r'   r   r   r   r   test_non_ambiguous_match  s   z,TestResolveOverload.test_non_ambiguous_matchc                    s    fdd}t t t ttttttg |ttf d  d  |ttf d  d  ttttttg |ttf d  d  d S )Nc                    s*     | |   d d d | | d S rV   r   )r%   rN   expected_reverser   r   r   r     s   z7TestResolveOverload.test_ambiguous_match.<locals>.checkr   r*   ry   )r   r   r   r   u16r   r5   r   r   r   r   test_ambiguous_match  s   z(TestResolveOverload.test_ambiguous_matchc                 C   s|   t  }ttttttg}| t}|jd|ttfi dd W d    n1 s*w   Y  | t	|j
 g d d S )Nr   F)allow_ambiguous)z+Ambiguous overloading for foo (int8, int8):z(int16, int16) -> int16z(int32, int32) -> int32)r   rH   r   r   assertRaises	TypeErrorr   r   r#   r[   	exception
splitlines)r'   rO   r   raisesr   r   r   test_ambiguous_error  s   z(TestResolveOverload.test_ambiguous_errorN)r:   r;   r<   r   r   r   r   r   r   r   r   r   r     s    r   c                   @   s4   e Zd ZdZedd Zdd Zdd Zdd	 Zd
S )TestUnifyUseCasesz6
    Concrete cases where unification would fail.
    c                  C   s*   dd } t tddg}t| |}| |fS )Nc                 S   s&   d}t t| D ]}|| | 7 }q|S )Ng        )r2   len)r4   ru   ir   r   r   pyfunc  s   z>TestUnifyUseCases._actually_test_complex_unify.<locals>.pyfuncr*   r+   )r   r,   r   r   )r   argtysr(   r   r   r   _actually_test_complex_unify  s   
z.TestUnifyUseCases._actually_test_complex_unifyc                 C   s6   |   \}}tdg}|j}| |||| d S )Ny              ?)r   nparrayr!   r#   )r'   r   r(   argcfuncr   r   r   test_complex_unify_issue599  s   z-TestUnifyUseCases.test_complex_unify_issue599c                 C   sR   t j }dD ]}t||d< tjtjddg|d}|  | 	|j
dd qdS )	zH
        Test issue #599 for multiple values of PYTHONHASHSEED.
        )r*   ry   i   PYTHONHASHSEEDz-czgimport numba.tests.test_typeinfer as test_mod
test_mod.TestUnifyUseCases._actually_test_complex_unify())envr   zChild process failed.N)osenvironr   r[   
subprocessPopensys
executablewaitr#   
returncode)r'   r   seedvalsubprocr   r   r   %test_complex_unify_issue599_multihash  s   
z7TestUnifyUseCases.test_complex_unify_issue599_multihashc                 C   s   dd }t tf}t||}dS )z!
        Test issue #493
        c                 S   s   | | f}	 | |f}qr   r   )an_int32an_int64r4   r   r   r   r     s   z3TestUnifyUseCases.test_int_tuple_unify.<locals>.fooN)r   r   r   )r'   r   r%   r(   r   r   r   test_int_tuple_unify  s   z&TestUnifyUseCases.test_int_tuple_unifyN)	r:   r;   r<   r   staticmethodr   r   r   r   r   r   r   r   r     s    
r   c                 C   s   |j \}}t||  }t|| }d}	| |k rd}	nd}	d}
||k r%d}
nd}
|| }	 | |kr6||kr6d S d|   kr@|k rXn nd|  krL|k rXn n
|| |f  d7  < d| }|| kri||8 }| |	7 } ||k ru||7 }||
7 }q,)Nr   r*   rW   Try   )shapeabs)x0y0x1y1gridnrowsncolsdxdysxsyerre2r   r   r   	issue_797"  s2   
0
r   c                 C   s   | sdS |S )NTr   )r4   br   r   r   
issue_1080E  s   r   c                 C   s   d}g }| dk r| t|  nt| D ]
}| t| q| d tt|D ]
}||||  7 }q+|D ]}|t|t|@ 7 }q8t|dkrW|| 7 }t|dksK|S )Nr   
   g      @)appendr   rC   r2   rE   r   intpop)rs   ru   r   r   jvalr   r   r   list_unify_usecase1K  s   
r   c                 C   sF   g }t | D ]}|d@ r||df q|d|f q|d |S )Nr*   g      ?g       @)y             ^@*   )r2   r   )rs   ru   r   r   r   r   list_unify_usecase2^  s   
r   c                 C   s6   | r
t td}nt td}|D ]}|  S d S )Nrz      )r2   r   rC   rE   )vrr   r   r   r   range_unify_usecaseh  s   r   c                 C   s2   | rt | D ]}| |7 } qd}| |fS d}| |fS )Ng333333?rz   r1   )r4   r   r   r   r   
issue_1394p  s   
r   c                   @   sD   e Zd Zdd Zdd Zdd Zdd Zd	d
 Zdd Zdd Z	dS )TestMiscIssuesc                 C   sJ   t ddt}tjdtjd}|tdtdtdtd| dS )zhttps://github.com/numba/numba/issues/797#issuecomment-58592401

        Undeterministic triggering of tuple coercion error
        Tnopython)r   r   )r   dtyper   r*   N)r   r   r   zerosrC   )r'   r   gr   r   r   test_issue_797|  s   ,zTestMiscIssues.test_issue_797c                 C   s   t ddt}|dd dS )zihttps://github.com/numba/numba/issues/1080

        Erroneous promotion of boolean args to int64
        Tr   FN)r   r   )r'   r   r   r   r   test_issue_1080  s   zTestMiscIssues.test_issue_1080c                 C   s8   t }tdd|}dD ]}||}| ||| qdS )zA
        Exercise back-propagation of refined list type.
        Tr   )r   d   N)r   r   assertPreciseEqual)r'   r   r   rs   ru   r   r   r   test_list_unify1  s   zTestMiscIssues.test_list_unify1c                 C   s.   t }tdd|}|d}| ||d d S )NTr   rz   )r   r   r#   )r'   r   r   ru   r   r   r   test_list_unify2  s   zTestMiscIssues.test_list_unify2c                 C   8   t }tdd|}dD ]}||}| ||| qd S )NTr   )r   r*   )r   r   r  r'   r   r   r   ru   r   r   r   test_range_unify     zTestMiscIssues.test_range_unifyc                 C   r  )NTr   )r   r*   ry   )r   r   r#   r	  r   r   r   test_issue_1394  r  zTestMiscIssues.test_issue_1394c                 C   s   t dddd }|tjf |jtjf }|jj}i }|jj D ]}|j	D ]}t
|tjr:|jj}|| ||< q(q#| tdd | D  dS )zyhttps://github.com/numba/numba/issues/6293

        Typer does not propagate return type to all return variables
        Tr   c                 S   s   | | krt | S | S r   )r   r   r   r   r   confuse_typer  s   z5TestMiscIssues.test_issue_6293.<locals>.confuse_typerc                 s   s    | ]}|t jkV  qd S r   )r   rF   )ri   vtr   r   r   	<genexpr>  s    z1TestMiscIssues.test_issue_6293.<locals>.<genexpr>N)r   compiler   rF   	overloadsr7   r8   blocksvaluesbodyr    r   Returnvaluenamer   all)r'   r  r(   r8   return_varsblockinstvarnamer   r   r   test_issue_6293  s   

 zTestMiscIssues.test_issue_6293N)
r:   r;   r<   r  r  r  r  r
  r  r  r   r   r   r   r   z  s    	
r   c                   @   s   e Zd Zdd Zdd ZdS )TestFoldArgumentsc              	   C   s  dd }d }t |}t|j}| jdd4 t||||||}tt||D ]\}	\}
}|
\}}}| 	||	 | 	|d|  q(W d    n1 sMw   Y  t|
 }| jdd t||||||}| 	|| W d    d S 1 szw   Y  d S )Nc                  W   r   r   r   )r%   r   r   r   
make_tuple  r   zFTestFoldArguments.check_fold_arguments_list_inputs.<locals>.make_tupledict)kindzarg.r}   )r	   pysignaturer}   
parameterssubTestr   fold_arguments	enumeratezipr#   items)r'   funcr%   kwsr  unused_handlerpysignamesfolded_dictr   r   k	got_index	got_paramgot_namefolded_listr   r   r    check_fold_arguments_list_inputs  s*   



"z2TestFoldArguments.check_fold_arguments_list_inputsc              	   C   s   t dd ddgt ddddt d	d g t  dt d
d dgi dt dd g t dddg}|D ]"}| jdi | | jdi | W d    n1 sLw   Y  q/d S )Nc                 S      d S r   r   )r4   r   cdr   r   r   <lambda>      zCTestFoldArguments.test_fold_arguments_list_inputs.<locals>.<lambda>zarg.azarg.bzarg.czarg.d)r6  r7  )r)  r%   r*  c                   S   r5  r   r   r   r   r   r   r8    r9  c                 S   r5  r   r   r4   r   r   r   r8    r9  c                 S   r5  r   r   r:  r   r   r   r8    r9  r:  r   )r   r$  r4  )r'   r   caser   r   r   test_fold_arguments_list_inputs  s6   
z1TestFoldArguments.test_fold_arguments_list_inputsN)r:   r;   r<   r4  r<  r   r   r   r   r    s    r  FT)mutates_CFGanalysis_onlyc                   @   s$   e Zd ZdZdZdd Zdd ZdS )DummyCRzrDummy pass to add "cr" to compiler state to avoid errors in TyperCompiler since
    it doesn't have lowering.
    dummy_crc                 C   s   t |  d S r   )r   __init__r{   r   r   r   rA    s   zDummyCR.__init__c                 C   s
   d|_ dS )Nr*   T)cr)r'   stater   r   r   run_pass	  s   zDummyCR.run_passN)r:   r;   r<   r   _namerA  rD  r   r   r   r   r?    s
    r?  c                   @      e Zd ZdZdd ZdS )TyperCompilerzlA compiler pipeline that skips passes after typing (provides partial typing info
    but not lowering).
    c                 C   sL   t jjd}|td |td |td |t	t |
  |gS )Ncustom_pipelinezanalyzing bytecodezprocessing IRzdo partial typing)numbacorecompiler_machineryPassManageradd_passr   r   r   add_pass_afterr?  finalize)r'   pmr   r   r   define_pipelines  s   zTyperCompiler.define_pipelinesN)r:   r;   r<   r   rQ  r   r   r   r   rG    s    rG  c           	      C   s\   t jjjj}t jjjj}d}d}i }t jj }d|_t	|||||||}|
|  |jjS )z~
    Get typing errors for function 'func'. It creates a pipeline that runs untyped
    passes as well as type inference.
    NT)rI  rJ  registry
cpu_targettyping_contexttarget_contextcompilerFlagsnrtrG  compile_extrarC  typing_errors)	r)  	arg_types	typingctx	targetctxlibraryr&   _localsflagspipeliner   r   r   get_func_typing_errs  s   
rb  c                   @   rF  )TestPartialTypingErrorszP
    Make sure partial typing stores type errors in compiler state properly
    c                 C   sZ   dd }t |tjf}| t|tot|dk | t|d tjo)d|d j	v  d S )Nc                 S   s   | rd}|S t d}|S )Nr*   )r[   )flagr4   r   r   r   impl7  s
   z?TestPartialTypingErrors.test_partial_typing_error.<locals>.implr*   r   zCannot unify)
rb  r   bool_r   r    r}   r   r   r-   rG   )r'   re  typing_errsr   r   r   test_partial_typing_error5  s   z1TestPartialTypingErrors.test_partial_typing_errorN)r:   r;   r<   r   rh  r   r   r   r   rc  1  s    rc  __main__)Or   r   r   rX   numpyr   rI  numba.core.compilerr   r   
numba.corer   r   r   r   r   r	   numba.core.typeconvr
   numba.tests.supportr   r   numba.tests.test_typeconvr   numba.core.untyped_passesr   r   numba.core.typed_passesr   numba.core.compiler_machineryr   r   unittestr?   r   rA   r   rC   r   rE   r   r>   r6   r@   r   rB   r5   rD   u64float32r   rF   r   	complex64r   
complex128r   r   r=   r   r   r   r   r   r   r   r   r   r   r  r?  rJ  rV  CompilerBaserG  rb  rc  r:   mainr   r   r   r   <module>   sb     &  e=5#

M
7
