Add files using upload-large-folder tool

.gitattributes

@@ -89,3 +89,4 @@ lib/python3.10/site-packages/av/container/input.cpython-310-x86_64-linux-gnu.so
 lib/python3.10/site-packages/av/container/output.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 lib/python3.10/site-packages/av/container/streams.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 lib/python3.10/site-packages/av/data/stream.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+lib/python3.10/site-packages/av/video/plane.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text

lib/python3.10/site-packages/av/video/plane.cpython-310-x86_64-linux-gnu.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:971d0d600b4e6f4731d029f1f83d780b6ac9a80d69b1e4cec0f3ab6d30db253c
+size 429249

lib/python3.10/site-packages/numba/tests/__init__.py

@@ -0,0 +1,33 @@
+import gc
+from os.path import dirname, join
+import multiprocessing
+import sys
+import time
+import unittest
+import warnings
+
+from unittest.suite import TestSuite
+from numba.testing import load_testsuite
+
+
+try:
+    import faulthandler
+except ImportError:
+    faulthandler = None
+else:
+    try:
+        # May fail in IPython Notebook with UnsupportedOperation
+        faulthandler.enable()
+    except Exception as e:
+        msg = "Failed to enable faulthandler due to:\n{err}"
+        warnings.warn(msg.format(err=e))
+
+def load_tests(loader, tests, pattern):
+    suite = TestSuite()
+    suite.addTests(load_testsuite(loader, dirname(__file__)))
+    # Numba CUDA tests are located in a separate directory:
+    cuda_dir = join(dirname(dirname(__file__)), 'cuda/tests')
+    suite.addTests(loader.discover(cuda_dir))
+
+    return suite
+

lib/python3.10/site-packages/numba/tests/cache_usecases.py

@@ -0,0 +1,172 @@
+"""
+This file will be copied to a temporary directory in order to
+exercise caching compiled Numba functions.
+
+See test_dispatcher.py.
+"""
+
+import sys
+
+import numpy as np
+
+from numba import jit, prange
+from numba.core import types
+
+from numba.tests.ctypes_usecases import c_sin
+from numba.tests.support import TestCase, captured_stderr
+
+
+@jit(cache=True, nopython=True)
+def simple_usecase(x):
+    return x
+
+def simple_usecase_caller(x):
+    return simple_usecase(x)
+
+
+@jit(cache=True, nopython=True)
+def add_usecase(x, y):
+    return x + y + Z
+
+
+@jit(cache=True, forceobj=True)
+def add_objmode_usecase(x, y):
+    object()
+    return x + y + Z
+
+
+@jit(nopython=True)
+def add_nocache_usecase(x, y):
+    return x + y + Z
+
+
+@jit(cache=True, nopython=True)
+def inner(x, y):
+    return x + y + Z
+
+@jit(cache=True, nopython=True)
+def outer(x, y):
+    return inner(-y, x)
+
+@jit(cache=False, nopython=True)
+def outer_uncached(x, y):
+    return inner(-y, x)
+
+
+@jit(cache=True, forceobj=True)
+def looplifted(n):
+    object()
+    res = 0
+    for i in range(n):
+        res = res + i
+    return res
+
+
+@jit(cache=True, nopython=True)
+def use_c_sin(x):
+    return c_sin(x)
+
+@jit(cache=True, nopython=True)
+def use_c_sin_nest1(x):
+    return use_c_sin(x)
+
+@jit(cache=True, nopython=True)
+def use_c_sin_nest2(x):
+    return use_c_sin_nest1(x)
+
+
+@jit(cache=True, nopython=True)
+def ambiguous_function(x):
+    return x + 2
+
+renamed_function1 = ambiguous_function
+
+@jit(cache=True, nopython=True)
+def ambiguous_function(x):
+    return x + 6
+
+renamed_function2 = ambiguous_function
+
+
+def make_closure(x):
+    @jit(cache=True, nopython=True)
+    def closure(y):
+        return x + y
+
+    return closure
+
+closure1 = make_closure(3)
+closure2 = make_closure(5)
+closure3 = make_closure(7)
+closure4 = make_closure(9)
+
+
+biggie = np.arange(10**6)
+
+@jit(cache=True, nopython=True)
+def use_big_array():
+    return biggie
+
+
+Z = 1
+
+# Exercise returning a record instance.  This used to hardcode the dtype
+# pointer's value in the bitcode.
+
+packed_record_type = np.dtype([('a', np.int8), ('b', np.float64)])
+aligned_record_type = np.dtype([('a', np.int8), ('b', np.float64)], align=True)
+
+packed_arr = np.empty(2, dtype=packed_record_type)
+for i in range(packed_arr.size):
+    packed_arr[i]['a'] = i + 1
+    packed_arr[i]['b'] = i + 42.5
+
+aligned_arr = np.array(packed_arr, dtype=aligned_record_type)
+
+@jit(cache=True, nopython=True)
+def record_return(ary, i):
+    return ary[i]
+
+
+class _TestModule(TestCase):
+    """
+    Tests for functionality of this module's functions.
+    Note this does not define any "test_*" method, instead check_module()
+    should be called by hand.
+    """
+
+    def check_module(self, mod):
+        self.assertPreciseEqual(mod.add_usecase(2, 3), 6)
+        self.assertPreciseEqual(mod.add_objmode_usecase(2, 3), 6)
+        self.assertPreciseEqual(mod.outer_uncached(3, 2), 2)
+        self.assertPreciseEqual(mod.outer(3, 2), 2)
+
+        packed_rec = mod.record_return(mod.packed_arr, 1)
+        self.assertPreciseEqual(tuple(packed_rec), (2, 43.5))
+        aligned_rec = mod.record_return(mod.aligned_arr, 1)
+        self.assertPreciseEqual(tuple(aligned_rec), (2, 43.5))
+
+
+@jit(cache=True)
+def first_class_function_mul(x):
+    return x * x
+
+
+@jit(cache=True)
+def first_class_function_add(x):
+    return x + x
+
+
+@jit(cache=True)
+def first_class_function_usecase(f, x):
+    return f(x)
+
+
+def self_test():
+    mod = sys.modules[__name__]
+    _TestModule().check_module(mod)
+
+
+@jit(parallel=True, cache=True, nopython=True)
+def parfor_usecase(ary):
+    return ary * ary + ary

lib/python3.10/site-packages/numba/tests/cffi_usecases.py

@@ -0,0 +1,197 @@
+import sys
+
+import numpy as np
+
+import numba.core.typing.cffi_utils as cffi_support
+from numba.tests.support import import_dynamic, temp_directory
+from numba.core.types import complex128
+
+
+def load_inline_module():
+    """
+    Create an inline module, return the corresponding ffi and dll objects.
+    """
+    from cffi import FFI
+
+    # We can't rely on libc availability on Windows anymore, so we use our
+    # own compiled wrappers (see https://bugs.python.org/issue23606).
+
+    defs = """
+    double _numba_test_sin(double x);
+    double _numba_test_cos(double x);
+    double _numba_test_funcptr(double (*func)(double));
+    bool _numba_test_boolean(void);
+    """
+
+    ffi = FFI()
+    ffi.cdef(defs)
+    # Load the _helperlib namespace
+    from numba import _helperlib
+    return ffi, ffi.dlopen(_helperlib.__file__)
+
+
+def load_ool_module():
+    """
+    Compile an out-of-line module, return the corresponding ffi and
+    module objects.
+    """
+    from cffi import FFI
+
+    numba_complex = """
+    typedef struct _numba_complex {
+        double real;
+        double imag;
+    } numba_complex;
+    """
+
+    bool_define = """
+    #ifdef _MSC_VER
+        #define false 0
+        #define true 1
+        #define bool int
+    #else
+        #include <stdbool.h>
+    #endif
+    """
+
+    defs = numba_complex + """
+    bool boolean(void);
+    double sin(double x);
+    double cos(double x);
+    int foo(int a, int b, int c);
+    void vsSin(int n, float* x, float* y);
+    void vdSin(int n, double* x, double* y);
+    void vector_real(numba_complex *c, double *real, int n);
+    void vector_imag(numba_complex *c, double *imag, int n);
+    """
+
+    source = numba_complex + bool_define + """
+    static bool boolean(void)
+    {
+        return true;
+    }
+
+    static int foo(int a, int b, int c)
+    {
+        return a + b * c;
+    }
+
+    void vsSin(int n, float* x, float* y) {
+        int i;
+        for (i=0; i<n; i++)
+            y[i] = sin(x[i]);
+    }
+
+    void vdSin(int n, double* x, double* y) {
+        int i;
+        for (i=0; i<n; i++)
+            y[i] = sin(x[i]);
+    }
+
+    static void vector_real(numba_complex *c, double *real, int n) {
+        int i;
+        for (i = 0; i < n; i++)
+            real[i] = c[i].real;
+    }
+
+    static void vector_imag(numba_complex *c, double *imag, int n) {
+        int i;
+        for (i = 0; i < n; i++)
+            imag[i] = c[i].imag;
+    }
+    """
+
+    ffi = FFI()
+    ffi.set_source('cffi_usecases_ool', source)
+    ffi.cdef(defs, override=True)
+    tmpdir = temp_directory('test_cffi')
+    ffi.compile(tmpdir=tmpdir)
+    sys.path.append(tmpdir)
+    try:
+        mod = import_dynamic('cffi_usecases_ool')
+        cffi_support.register_module(mod)
+        cffi_support.register_type(mod.ffi.typeof('struct _numba_complex'),
+                                   complex128)
+        return mod.ffi, mod
+    finally:
+        sys.path.remove(tmpdir)
+
+
+def init():
+    """
+    Initialize module globals.  This can invoke external utilities, hence not
+    being executed implicitly at module import.
+    """
+    global ffi, cffi_sin, cffi_cos, cffi_bool
+
+    if ffi is None:
+        ffi, dll = load_inline_module()
+        cffi_sin = dll._numba_test_sin
+        cffi_cos = dll._numba_test_cos
+        cffi_bool = dll._numba_test_boolean
+        del dll
+
+def init_ool():
+    """
+    Same as init() for OOL mode.
+    """
+    global ffi_ool, cffi_sin_ool, cffi_cos_ool, cffi_foo, cffi_bool_ool
+    global vsSin, vdSin, vector_real, vector_imag
+
+    if ffi_ool is None:
+        ffi_ool, mod = load_ool_module()
+        cffi_sin_ool = mod.lib.sin
+        cffi_cos_ool = mod.lib.cos
+        cffi_foo = mod.lib.foo
+        cffi_bool_ool = mod.lib.boolean
+        vsSin = mod.lib.vsSin
+        vdSin = mod.lib.vdSin
+        vector_real = mod.lib.vector_real
+        vector_imag = mod.lib.vector_imag
+        del mod
+
+ffi = ffi_ool = None
+
+
+def use_cffi_sin(x):
+    return cffi_sin(x) * 2
+
+def use_two_funcs(x):
+    return cffi_sin(x) - cffi_cos(x)
+
+def use_cffi_sin_ool(x):
+    return cffi_sin_ool(x) * 2
+
+def use_cffi_boolean_true():
+    return cffi_bool_ool()
+
+def use_two_funcs_ool(x):
+    return cffi_sin_ool(x) - cffi_cos_ool(x)
+
+def use_func_pointer(fa, fb, x):
+    if x > 0:
+        return fa(x)
+    else:
+        return fb(x)
+
+def use_user_defined_symbols():
+    return cffi_foo(1, 2, 3)
+
+# The from_buffer method is member of cffi.FFI, and also of CompiledFFI objects
+# (cffi_usecases_ool.ffi is a CompiledFFI object) so we use both in these
+# functions.
+
+def vector_sin_float32(x, y):
+    vsSin(len(x), ffi.from_buffer(x), ffi_ool.from_buffer(y))
+
+def vector_sin_float64(x, y):
+    vdSin(len(x), ffi.from_buffer(x), ffi_ool.from_buffer(y))
+
+
+# For testing pointer to structs from buffers
+
+def vector_extract_real(x, y):
+    vector_real(ffi.from_buffer(x), ffi.from_buffer(y), len(x))
+
+def vector_extract_imag(x, y):
+    vector_imag(ffi.from_buffer(x), ffi.from_buffer(y), len(x))

lib/python3.10/site-packages/numba/tests/complex_usecases.py

@@ -0,0 +1,93 @@
+import cmath
+
+
+def div_usecase(x, y):
+    return x / y
+
+
+def real_usecase(x):
+    return x.real
+
+def imag_usecase(x):
+    return x.imag
+
+def conjugate_usecase(x):
+    return x.conjugate()
+
+
+def acos_usecase(x):
+    return cmath.acos(x)
+
+def cos_usecase(x):
+    return cmath.cos(x)
+
+def asin_usecase(x):
+    return cmath.asin(x)
+
+def sin_usecase(x):
+    return cmath.sin(x)
+
+def atan_usecase(x):
+    return cmath.atan(x)
+
+def tan_usecase(x):
+    return cmath.tan(x)
+
+def acosh_usecase(x):
+    return cmath.acosh(x)
+
+def cosh_usecase(x):
+    return cmath.cosh(x)
+
+def asinh_usecase(x):
+    return cmath.asinh(x)
+
+def sinh_usecase(x):
+    return cmath.sinh(x)
+
+def atanh_usecase(x):
+    return cmath.atanh(x)
+
+def tanh_usecase(x):
+    return cmath.tanh(x)
+
+def exp_usecase(x):
+    return cmath.exp(x)
+
+def isfinite_usecase(x):
+    return cmath.isfinite(x)
+
+def isinf_usecase(x):
+    return cmath.isinf(x)
+
+def isnan_usecase(x):
+    return cmath.isnan(x)
+
+def log_usecase(x):
+    return cmath.log(x)
+
+def log_base_usecase(x, base):
+    return cmath.log(x, base)
+
+def log10_usecase(x):
+    return cmath.log10(x)
+
+def phase_usecase(x):
+    return cmath.phase(x)
+
+def polar_usecase(x):
+    return cmath.polar(x)
+
+_two = 2.0
+
+def polar_as_complex_usecase(x):
+    # HACK: clear errno by invoking float.__pow__
+    # (workaround for http://bugs.python.org/issue24489)
+    _two ** _two
+    return complex(*cmath.polar(x))
+
+def rect_usecase(r, phi):
+    return cmath.rect(r, phi)
+
+def sqrt_usecase(x):
+    return cmath.sqrt(x)

lib/python3.10/site-packages/numba/tests/ctypes_usecases.py

@@ -0,0 +1,114 @@
+from ctypes import *
+import sys
+
+import numpy as np
+
+
+is_windows = sys.platform.startswith('win32')
+
+# We can't rely on libc availability on Windows anymore, so we use our
+# own compiled wrappers (see https://bugs.python.org/issue23606).
+
+from numba import _helperlib
+libnumba = CDLL(_helperlib.__file__)
+del _helperlib
+
+# A typed C function (cdecl under Windows)
+
+c_sin = libnumba._numba_test_sin
+c_sin.argtypes = [c_double]
+c_sin.restype = c_double
+
+def use_c_sin(x):
+    return c_sin(x)
+
+c_cos = libnumba._numba_test_cos
+c_cos.argtypes = [c_double]
+c_cos.restype = c_double
+
+def use_two_funcs(x):
+    return c_sin(x) - c_cos(x)
+
+# Typed C functions accepting an array pointer
+# (either as a "void *" or as a typed pointer)
+
+c_vsquare = libnumba._numba_test_vsquare
+c_vsquare.argtypes = [c_int, c_void_p, c_void_p]
+
+c_vcube = libnumba._numba_test_vsquare
+c_vcube.argtypes = [c_int, POINTER(c_double), POINTER(c_double)]
+
+def use_c_vsquare(x):
+    out = np.empty_like(x)
+    c_vsquare(x.size, x.ctypes, out.ctypes)
+    return out
+
+def use_c_vcube(x):
+    out = np.empty_like(x)
+    c_vcube(x.size, x.ctypes, out.ctypes)
+    return out
+
+# An untyped C function
+
+c_untyped = libnumba._numba_test_exp
+
+def use_c_untyped(x):
+    return c_untyped(x)
+
+# A C function wrapped in a CFUNCTYPE
+
+ctype_wrapping = CFUNCTYPE(c_double, c_double)(use_c_sin)
+
+def use_ctype_wrapping(x):
+    return ctype_wrapping(x)
+
+# A Python API function
+
+savethread = pythonapi.PyEval_SaveThread
+savethread.argtypes = []
+savethread.restype = c_void_p
+
+restorethread = pythonapi.PyEval_RestoreThread
+restorethread.argtypes = [c_void_p]
+restorethread.restype = None
+
+if is_windows:
+    # A function with the stdcall calling convention
+    c_sleep = windll.kernel32.Sleep
+    c_sleep.argtypes = [c_uint]
+    c_sleep.restype = None
+
+    def use_c_sleep(x):
+        c_sleep(x)
+
+
+def use_c_pointer(x):
+    """
+    Running in Python will cause a segfault.
+    """
+    threadstate = savethread()
+    x += 1
+    restorethread(threadstate)
+    return x
+
+
+def use_func_pointer(fa, fb, x):
+    if x > 0:
+        return fa(x)
+    else:
+        return fb(x)
+
+
+mydct = {'what': 1232121}
+
+def call_me_maybe(arr):
+    return mydct[arr[0].decode('ascii')]
+
+# Create a callback into the python interpreter
+py_call_back = CFUNCTYPE(c_int, py_object)(call_me_maybe)
+
+
+def take_array_ptr(ptr):
+    return ptr
+
+c_take_array_ptr = CFUNCTYPE(c_void_p, c_void_p)(take_array_ptr)

lib/python3.10/site-packages/numba/tests/doctest_usecase.py

@@ -0,0 +1,31 @@
+"""
+Test that all docstrings are the same:
+
+>>> len({f.__doc__ for f in (a, b, c, d)})
+1
+"""
+from numba import guvectorize, int64, njit, vectorize
+
+
+def a():
+    """>>> x = 1"""
+    return 1
+
+
+@njit
+def b():
+    """>>> x = 1"""
+    return 1
+
+
+@guvectorize([(int64[:], int64, int64[:])], "(n),()->(n)")
+def c(x, y, res):
+    """>>> x = 1"""
+    for i in range(x.shape[0]):
+        res[i] = x[i] + y
+
+
+@vectorize([int64(int64, int64)])
+def d(x, y):
+    """>>> x = 1"""
+    return x + y

lib/python3.10/site-packages/numba/tests/enum_usecases.py

@@ -0,0 +1,55 @@
+from enum import Enum, IntEnum
+
+
+class Color(Enum):
+    red = 1
+    green = 2
+    blue = 3
+
+
+class Shake(Enum):
+    vanilla = 7
+    chocolate = 4
+    cookies = 9
+    # Same as Color.blue
+    mint = 3
+
+
+class Planet(Enum):
+    MERCURY = (3.303e+23, 2.4397e6)
+    VENUS   = (4.869e+24, 6.0518e6)
+    EARTH   = (5.976e+24, 6.37814e6)
+    MARS    = (6.421e+23, 3.3972e6)
+    JUPITER = (1.9e+27,   7.1492e7)
+    SATURN  = (5.688e+26, 6.0268e7)
+    URANUS  = (8.686e+25, 2.5559e7)
+    NEPTUNE = (1.024e+26, 2.4746e7)
+
+
+class HeterogeneousEnum(Enum):
+    red = 1.0
+    green = 2.0
+    blue = 3j
+
+
+class Shape(IntEnum):
+    # Same as Color.green
+    circle = 2
+    # Same as RequestError.internal_error
+    square = 500
+
+
+class RequestError(IntEnum):
+    dummy = 2
+    not_found = 404
+    internal_error = 500
+
+class IntEnumWithNegatives(IntEnum):
+    # Used for testing of hash, need to make sure -1 -> -2 to comply with CPy
+    one = 1
+    two = 2
+    too = 2
+    three = 3
+    negone = -1
+    negtwo = -2
+    negthree = -3

lib/python3.10/site-packages/numba/tests/parfor_iss9490_usecase.py

@@ -0,0 +1,78 @@
+"""
+This is a testcase for https://github.com/numba/numba/issues/9490.
+The bug is very sensitive to the control-flow and variable uses.
+It is impossible to shrink the reproducer in any meaningful way.
+
+The test is also sensitive to PYTHONHASHSEED.
+PYTHONHASHSEED=1 will trigger the bug.
+
+Example of traceback:
+
+  File "/numba/parfors/parfor.py", line 2070, in _arrayexpr_to_parfor
+    index_vars, loopnests = _mk_parfor_loops(pass_states.typemap, size_vars,
+                                             scope, loc)
+  File "/numba/parfors/parfor.py", line 1981, in _mk_parfor_loops
+    for size_var in size_vars:
+TypeError: Failed in nopython mode pipeline (step: convert to parfors)
+'NoneType' object is not iterable
+"""
+
+import numba
+import numpy as np
+
+
+@numba.jit(nopython=True, parallel=True)
+def stable_fit(X, y, threshold=3):
+    min_obs = int(X.shape[1] * 1.5)
+    beta = np.zeros((X.shape[1], y.shape[1]), dtype=np.float64)
+    residuals = np.full_like(y, np.nan)
+    stable = np.empty((y.shape[1]))
+    for idx in numba.prange(y.shape[1]):
+        y_sub = y[:, idx]
+        isna = np.isnan(y_sub)
+        X_sub = X[~isna]
+        y_sub = y_sub[~isna]
+        is_stable = False
+
+        # Run until minimum observations
+        # or until stability is reached
+        for jdx in range(len(y_sub), min_obs - 1, -2):
+            # Timeseries gets reduced by two elements
+            # each iteration
+            y_ = y_sub[-jdx:]
+            X_ = X_sub[-jdx:]
+            beta_sub = np.linalg.solve(np.dot(X_.T, X_), np.dot(X_.T, y_))
+            resid_sub = np.dot(X_, beta_sub) - y_
+            # Check for stability
+            rmse = np.sqrt(np.mean(resid_sub ** 2))
+            first = np.fabs(resid_sub[0]) / rmse < threshold
+            last = np.fabs(resid_sub[-1]) / rmse < threshold
+            slope = np.fabs(beta_sub[1]) / rmse < threshold
+            # Break if stability is reached
+            is_stable = slope & first & last
+            if is_stable:
+                break
+
+        beta[:, idx] = beta_sub
+        residuals[-jdx:, idx] = resid_sub
+        stable[idx] = is_stable
+    return beta, residuals, stable.astype(np.bool_)
+
+
+def check():
+    np.random.seed(0)
+    X_shape = (10, 4)
+    y_shape = (10, 5)
+    X = np.random.random(X_shape)
+    y = np.random.random(y_shape)
+
+    got_beta, got_residuals, got_stable = stable_fit(X, y)
+    exp_beta, exp_residuals, exp_stable = stable_fit.py_func(X, y)
+
+    np.testing.assert_allclose(got_beta, exp_beta)
+    np.testing.assert_allclose(got_residuals, exp_residuals)
+    np.testing.assert_allclose(got_stable, exp_stable)
+
+
+if __name__ == "__main__":
+    check()

lib/python3.10/site-packages/numba/tests/test_analysis.py

@@ -0,0 +1,1007 @@
+# Tests numba.analysis functions
+import collections
+import types as pytypes
+
+import numpy as np
+from numba.core.compiler import run_frontend, Flags, StateDict
+from numba import jit, njit, literal_unroll
+from numba.core import types, errors, ir, rewrites, ir_utils, cpu
+from numba.core import postproc
+from numba.core.inline_closurecall import InlineClosureCallPass
+from numba.tests.support import (TestCase, MemoryLeakMixin, SerialMixin,
+                                 IRPreservingTestPipeline)
+from numba.core.analysis import dead_branch_prune, rewrite_semantic_constants
+from numba.core.untyped_passes import (ReconstructSSA, TranslateByteCode,
+                                       IRProcessing, DeadBranchPrune,
+                                       PreserveIR)
+from numba.core.compiler import DefaultPassBuilder, CompilerBase, PassManager
+
+
+_GLOBAL = 123
+
+enable_pyobj_flags = Flags()
+enable_pyobj_flags.enable_pyobject = True
+
+
+def compile_to_ir(func):
+    func_ir = run_frontend(func)
+    state = StateDict()
+    state.func_ir = func_ir
+    state.typemap = None
+    state.calltypes = None
+    # Transform to SSA
+    ReconstructSSA().run_pass(state)
+    # call this to get print etc rewrites
+    rewrites.rewrite_registry.apply('before-inference', state)
+    return func_ir
+
+
+class TestBranchPruneBase(MemoryLeakMixin, TestCase):
+    """
+    Tests branch pruning
+    """
+    _DEBUG = False
+
+    # find *all* branches
+    def find_branches(self, the_ir):
+        branches = []
+        for blk in the_ir.blocks.values():
+            tmp = [_ for _ in blk.find_insts(cls=ir.Branch)]
+            branches.extend(tmp)
+        return branches
+
+    def assert_prune(self, func, args_tys, prune, *args, **kwargs):
+        # This checks that the expected pruned branches have indeed been pruned.
+        # func is a python function to assess
+        # args_tys is the numba types arguments tuple
+        # prune arg is a list, one entry per branch. The value in the entry is
+        # encoded as follows:
+        # True: using constant inference only, the True branch will be pruned
+        # False: using constant inference only, the False branch will be pruned
+        # None: under no circumstances should this branch be pruned
+        # *args: the argument instances to pass to the function to check
+        #        execution is still valid post transform
+        # **kwargs:
+        #        - flags: args to pass to `jit` default is `nopython=True`,
+        #          e.g. permits use of e.g. object mode.
+
+        func_ir = compile_to_ir(func)
+        before = func_ir.copy()
+        if self._DEBUG:
+            print("=" * 80)
+            print("before inline")
+            func_ir.dump()
+
+        # run closure inlining to ensure that nonlocals in closures are visible
+        inline_pass = InlineClosureCallPass(func_ir,
+                                            cpu.ParallelOptions(False),)
+        inline_pass.run()
+
+        # Remove all Dels, and re-run postproc
+        post_proc = postproc.PostProcessor(func_ir)
+        post_proc.run()
+
+        rewrite_semantic_constants(func_ir, args_tys)
+        if self._DEBUG:
+            print("=" * 80)
+            print("before prune")
+            func_ir.dump()
+
+        dead_branch_prune(func_ir, args_tys)
+
+        after = func_ir
+        if self._DEBUG:
+            print("after prune")
+            func_ir.dump()
+
+        before_branches = self.find_branches(before)
+        self.assertEqual(len(before_branches), len(prune))
+
+        # what is expected to be pruned
+        expect_removed = []
+        for idx, prune in enumerate(prune):
+            branch = before_branches[idx]
+            if prune is True:
+                expect_removed.append(branch.truebr)
+            elif prune is False:
+                expect_removed.append(branch.falsebr)
+            elif prune is None:
+                pass  # nothing should be removed!
+            elif prune == 'both':
+                expect_removed.append(branch.falsebr)
+                expect_removed.append(branch.truebr)
+            else:
+                assert 0, "unreachable"
+
+        # compare labels
+        original_labels = set([_ for _ in before.blocks.keys()])
+        new_labels = set([_ for _ in after.blocks.keys()])
+        # assert that the new labels are precisely the original less the
+        # expected pruned labels
+        try:
+            self.assertEqual(new_labels, original_labels - set(expect_removed))
+        except AssertionError as e:
+            print("new_labels", sorted(new_labels))
+            print("original_labels", sorted(original_labels))
+            print("expect_removed", sorted(expect_removed))
+            raise e
+
+        supplied_flags = kwargs.pop('flags', {'nopython': True})
+        # NOTE: original testing used `compile_isolated` hence use of `cres`.
+        cres = jit(args_tys, **supplied_flags)(func).overloads[args_tys]
+        if args is None:
+            res = cres.entry_point()
+            expected = func()
+        else:
+            res = cres.entry_point(*args)
+            expected = func(*args)
+        self.assertEqual(res, expected)
+
+
+class TestBranchPrune(TestBranchPruneBase, SerialMixin):
+
+    def test_single_if(self):
+
+        def impl(x):
+            if 1 == 0:
+                return 3.14159
+
+        self.assert_prune(impl, (types.NoneType('none'),), [True], None)
+
+        def impl(x):
+            if 1 == 1:
+                return 3.14159
+
+        self.assert_prune(impl, (types.NoneType('none'),), [False], None)
+
+        def impl(x):
+            if x is None:
+                return 3.14159
+
+        self.assert_prune(impl, (types.NoneType('none'),), [False], None)
+        self.assert_prune(impl, (types.IntegerLiteral(10),), [True], 10)
+
+        def impl(x):
+            if x == 10:
+                return 3.14159
+
+        self.assert_prune(impl, (types.NoneType('none'),), [True], None)
+        self.assert_prune(impl, (types.IntegerLiteral(10),), [None], 10)
+
+        def impl(x):
+            if x == 10:
+                z = 3.14159  # noqa: F841 # no effect
+
+        self.assert_prune(impl, (types.NoneType('none'),), [True], None)
+        self.assert_prune(impl, (types.IntegerLiteral(10),), [None], 10)
+
+        def impl(x):
+            z = None
+            y = z
+            if x == y:
+                return 100
+
+        self.assert_prune(impl, (types.NoneType('none'),), [False], None)
+        self.assert_prune(impl, (types.IntegerLiteral(10),), [True], 10)
+
+    def test_single_if_else(self):
+
+        def impl(x):
+            if x is None:
+                return 3.14159
+            else:
+                return 1.61803
+
+        self.assert_prune(impl, (types.NoneType('none'),), [False], None)
+        self.assert_prune(impl, (types.IntegerLiteral(10),), [True], 10)
+
+    def test_single_if_const_val(self):
+
+        def impl(x):
+            if x == 100:
+                return 3.14159
+
+        self.assert_prune(impl, (types.NoneType('none'),), [True], None)
+        self.assert_prune(impl, (types.IntegerLiteral(100),), [None], 100)
+
+        def impl(x):
+            # switch the condition order
+            if 100 == x:
+                return 3.14159
+
+        self.assert_prune(impl, (types.NoneType('none'),), [True], None)
+        self.assert_prune(impl, (types.IntegerLiteral(100),), [None], 100)
+
+    def test_single_if_else_two_const_val(self):
+
+        def impl(x, y):
+            if x == y:
+                return 3.14159
+            else:
+                return 1.61803
+
+        self.assert_prune(impl, (types.IntegerLiteral(100),) * 2, [None], 100,
+                          100)
+        self.assert_prune(impl, (types.NoneType('none'),) * 2, [False], None,
+                          None)
+        self.assert_prune(impl, (types.IntegerLiteral(100),
+                                 types.NoneType('none'),), [True], 100, None)
+        self.assert_prune(impl, (types.IntegerLiteral(100),
+                                 types.IntegerLiteral(1000)), [None], 100, 1000)
+
+    def test_single_if_else_w_following_undetermined(self):
+
+        def impl(x):
+            x_is_none_work = False
+            if x is None:
+                x_is_none_work = True
+            else:
+                dead = 7  # noqa: F841 # no effect
+
+            if x_is_none_work:
+                y = 10
+            else:
+                y = -3
+            return y
+
+        self.assert_prune(impl, (types.NoneType('none'),), [False, None], None)
+        self.assert_prune(impl, (types.IntegerLiteral(10),), [True, None], 10)
+
+        def impl(x):
+            x_is_none_work = False
+            if x is None:
+                x_is_none_work = True
+            else:
+                pass
+
+            if x_is_none_work:
+                y = 10
+            else:
+                y = -3
+            return y
+
+        # Python 3.10 creates a block with a NOP in it for the `pass` which
+        # means it gets pruned.
+        self.assert_prune(impl, (types.NoneType('none'),), [False, None],
+                          None)
+
+        self.assert_prune(impl, (types.IntegerLiteral(10),), [True, None], 10)
+
+    def test_double_if_else_rt_const(self):
+
+        def impl(x):
+            one_hundred = 100
+            x_is_none_work = 4
+            if x is None:
+                x_is_none_work = 100
+            else:
+                dead = 7  # noqa: F841 # no effect
+
+            if x_is_none_work == one_hundred:
+                y = 10
+            else:
+                y = -3
+
+            return y, x_is_none_work
+
+        self.assert_prune(impl, (types.NoneType('none'),), [False, None], None)
+        self.assert_prune(impl, (types.IntegerLiteral(10),), [True, None], 10)
+
+    def test_double_if_else_non_literal_const(self):
+
+        def impl(x):
+            one_hundred = 100
+            if x == one_hundred:
+                y = 3.14159
+            else:
+                y = 1.61803
+            return y
+
+        # no prune as compilation specialization on literal value not permitted
+        self.assert_prune(impl, (types.IntegerLiteral(10),), [None], 10)
+        self.assert_prune(impl, (types.IntegerLiteral(100),), [None], 100)
+
+    def test_single_two_branches_same_cond(self):
+
+        def impl(x):
+            if x is None:
+                y = 10
+            else:
+                y = 40
+
+            if x is not None:
+                z = 100
+            else:
+                z = 400
+
+            return z, y
+
+        self.assert_prune(impl, (types.NoneType('none'),), [False, True], None)
+        self.assert_prune(impl, (types.IntegerLiteral(10),), [True, False], 10)
+
+    def test_cond_is_kwarg_none(self):
+
+        def impl(x=None):
+            if x is None:
+                y = 10
+            else:
+                y = 40
+
+            if x is not None:
+                z = 100
+            else:
+                z = 400
+
+            return z, y
+
+        self.assert_prune(impl, (types.Omitted(None),),
+                          [False, True], None)
+        self.assert_prune(impl, (types.NoneType('none'),), [False, True], None)
+        self.assert_prune(impl, (types.IntegerLiteral(10),), [True, False], 10)
+
+    def test_cond_is_kwarg_value(self):
+
+        def impl(x=1000):
+            if x == 1000:
+                y = 10
+            else:
+                y = 40
+
+            if x != 1000:
+                z = 100
+            else:
+                z = 400
+
+            return z, y
+
+        self.assert_prune(impl, (types.Omitted(1000),), [None, None], 1000)
+        self.assert_prune(impl, (types.IntegerLiteral(1000),), [None, None],
+                          1000)
+        self.assert_prune(impl, (types.IntegerLiteral(0),), [None, None], 0)
+        self.assert_prune(impl, (types.NoneType('none'),), [True, False], None)
+
+    def test_cond_rewrite_is_correct(self):
+        # this checks that when a condition is replaced, it is replace by a
+        # true/false bit that correctly represents the evaluated condition
+        def fn(x):
+            if x is None:
+                return 10
+            return 12
+
+        def check(func, arg_tys, bit_val):
+            func_ir = compile_to_ir(func)
+
+            # check there is 1 branch
+            before_branches = self.find_branches(func_ir)
+            self.assertEqual(len(before_branches), 1)
+
+            # check the condition in the branch is a binop
+            pred_var = before_branches[0].cond
+            pred_defn = ir_utils.get_definition(func_ir, pred_var)
+            self.assertEqual(pred_defn.op, 'call')
+            condition_var = pred_defn.args[0]
+            condition_op = ir_utils.get_definition(func_ir, condition_var)
+            self.assertEqual(condition_op.op, 'binop')
+
+            # do the prune, this should kill the dead branch and rewrite the
+            #'condition to a true/false const bit
+            if self._DEBUG:
+                print("=" * 80)
+                print("before prune")
+                func_ir.dump()
+            dead_branch_prune(func_ir, arg_tys)
+            if self._DEBUG:
+                print("=" * 80)
+                print("after prune")
+                func_ir.dump()
+
+            # after mutation, the condition should be a const value `bit_val`
+            new_condition_defn = ir_utils.get_definition(func_ir, condition_var)
+            self.assertTrue(isinstance(new_condition_defn, ir.Const))
+            self.assertEqual(new_condition_defn.value, bit_val)
+
+        check(fn, (types.NoneType('none'),), 1)
+        check(fn, (types.IntegerLiteral(10),), 0)
+
+    def test_global_bake_in(self):
+
+        def impl(x):
+            if _GLOBAL == 123:
+                return x
+            else:
+                return x + 10
+
+        self.assert_prune(impl, (types.IntegerLiteral(1),), [False], 1)
+
+        global _GLOBAL
+        tmp = _GLOBAL
+
+        try:
+            _GLOBAL = 5
+
+            def impl(x):
+                if _GLOBAL == 123:
+                    return x
+                else:
+                    return x + 10
+
+            self.assert_prune(impl, (types.IntegerLiteral(1),), [True], 1)
+        finally:
+            _GLOBAL = tmp
+
+    def test_freevar_bake_in(self):
+
+        _FREEVAR = 123
+
+        def impl(x):
+            if _FREEVAR == 123:
+                return x
+            else:
+                return x + 10
+
+        self.assert_prune(impl, (types.IntegerLiteral(1),), [False], 1)
+
+        _FREEVAR = 12
+
+        def impl(x):
+            if _FREEVAR == 123:
+                return x
+            else:
+                return x + 10
+
+        self.assert_prune(impl, (types.IntegerLiteral(1),), [True], 1)
+
+    def test_redefined_variables_are_not_considered_in_prune(self):
+        # see issue #4163, checks that if a variable that is an argument is
+        # redefined in the user code it is not considered const
+
+        def impl(array, a=None):
+            if a is None:
+                a = 0
+            if a < 0:
+                return 10
+            return 30
+
+        self.assert_prune(impl,
+                          (types.Array(types.float64, 2, 'C'),
+                           types.NoneType('none'),),
+                          [None, None],
+                          np.zeros((2, 3)), None)
+
+    def test_comparison_operators(self):
+        # see issue #4163, checks that a variable that is an argument and has
+        # value None survives TypeError from invalid comparison which should be
+        # dead
+
+        def impl(array, a=None):
+            x = 0
+            if a is None:
+                return 10 # dynamic exec would return here
+            # static analysis requires that this is executed with a=None,
+            # hence TypeError
+            if a < 0:
+                return 20
+            return x
+
+        self.assert_prune(impl,
+                          (types.Array(types.float64, 2, 'C'),
+                           types.NoneType('none'),),
+                          [False, 'both'],
+                          np.zeros((2, 3)), None)
+
+        self.assert_prune(impl,
+                          (types.Array(types.float64, 2, 'C'),
+                           types.float64,),
+                          [None, None],
+                          np.zeros((2, 3)), 12.)
+
+    def test_redefinition_analysis_same_block(self):
+        # checks that a redefinition in a block with prunable potential doesn't
+        # break
+
+        def impl(array, x, a=None):
+            b = 2
+            if x < 4:
+                b = 12
+            if a is None: # known true
+                a = 7 # live
+            else:
+                b = 15 # dead
+            if a < 0: # valid as a result of the redefinition of 'a'
+                return 10
+            return 30 + b + a
+
+        self.assert_prune(impl,
+                          (types.Array(types.float64, 2, 'C'),
+                           types.float64, types.NoneType('none'),),
+                          [None, False, None],
+                          np.zeros((2, 3)), 1., None)
+
+    def test_redefinition_analysis_different_block_can_exec(self):
+        # checks that a redefinition in a block that may be executed prevents
+        # pruning
+
+        def impl(array, x, a=None):
+            b = 0
+            if x > 5:
+                a = 11 # a redefined, cannot tell statically if this will exec
+            if x < 4:
+                b = 12
+            if a is None: # cannot prune, cannot determine if re-defn occurred
+                b += 5
+            else:
+                b += 7
+                if a < 0:
+                    return 10
+            return 30 + b
+
+        self.assert_prune(impl,
+                          (types.Array(types.float64, 2, 'C'),
+                           types.float64, types.NoneType('none'),),
+                          [None, None, None, None],
+                          np.zeros((2, 3)), 1., None)
+
+    def test_redefinition_analysis_different_block_cannot_exec(self):
+        # checks that a redefinition in a block guarded by something that
+        # has prune potential
+
+        def impl(array, x=None, a=None):
+            b = 0
+            if x is not None:
+                a = 11
+            if a is None:
+                b += 5
+            else:
+                b += 7
+            return 30 + b
+
+        self.assert_prune(impl,
+                          (types.Array(types.float64, 2, 'C'),
+                           types.NoneType('none'), types.NoneType('none')),
+                          [True, None],
+                          np.zeros((2, 3)), None, None)
+
+        self.assert_prune(impl,
+                          (types.Array(types.float64, 2, 'C'),
+                           types.NoneType('none'), types.float64),
+                          [True, None],
+                          np.zeros((2, 3)), None, 1.2)
+
+        self.assert_prune(impl,
+                          (types.Array(types.float64, 2, 'C'),
+                           types.float64, types.NoneType('none')),
+                          [None, None],
+                          np.zeros((2, 3)), 1.2, None)
+
+    def test_closure_and_nonlocal_can_prune(self):
+        # Closures must be inlined ahead of branch pruning in case nonlocal
+        # is used. See issue #6585.
+        def impl():
+            x = 1000
+
+            def closure():
+                nonlocal x
+                x = 0
+
+            closure()
+
+            if x == 0:
+                return True
+            else:
+                return False
+
+        self.assert_prune(impl, (), [False,],)
+
+    def test_closure_and_nonlocal_cannot_prune(self):
+        # Closures must be inlined ahead of branch pruning in case nonlocal
+        # is used. See issue #6585.
+        def impl(n):
+            x = 1000
+
+            def closure(t):
+                nonlocal x
+                x = t
+
+            closure(n)
+
+            if x == 0:
+                return True
+            else:
+                return False
+
+        self.assert_prune(impl, (types.int64,), [None,], 1)
+
+
+class TestBranchPrunePredicates(TestBranchPruneBase, SerialMixin):
+    # Really important thing to remember... the branch on predicates end up as
+    # POP_JUMP_IF_<bool> and the targets are backwards compared to normal, i.e.
+    # the true condition is far jump and the false the near i.e. `if x` would
+    # end up in Numba IR as e.g. `branch x 10, 6`.
+
+    _TRUTHY = (1, "String", True, 7.4, 3j)
+    _FALSEY = (0, "", False, 0.0, 0j, None)
+
+    def _literal_const_sample_generator(self, pyfunc, consts):
+        """
+        This takes a python function, pyfunc, and manipulates its co_const
+        __code__ member to create a new function with different co_consts as
+        supplied in argument consts.
+
+        consts is a dict {index: value} of co_const tuple index to constant
+        value used to update a pyfunc clone's co_const.
+        """
+        pyfunc_code = pyfunc.__code__
+
+        # translate consts spec to update the constants
+        co_consts = {k: v for k, v in enumerate(pyfunc_code.co_consts)}
+        for k, v in consts.items():
+            co_consts[k] = v
+        new_consts = tuple([v for _, v in sorted(co_consts.items())])
+
+        # create code object with mutation
+        new_code = pyfunc_code.replace(co_consts=new_consts)
+
+        # get function
+        return pytypes.FunctionType(new_code, globals())
+
+    def test_literal_const_code_gen(self):
+        def impl(x):
+            _CONST1 = "PLACEHOLDER1"
+            if _CONST1:
+                return 3.14159
+            else:
+                _CONST2 = "PLACEHOLDER2"
+            return _CONST2 + 4
+
+        new = self._literal_const_sample_generator(impl, {1:0, 3:20})
+        iconst = impl.__code__.co_consts
+        nconst = new.__code__.co_consts
+        self.assertEqual(iconst, (None, "PLACEHOLDER1", 3.14159,
+                                  "PLACEHOLDER2", 4))
+        self.assertEqual(nconst, (None, 0, 3.14159,  20, 4))
+        self.assertEqual(impl(None), 3.14159)
+        self.assertEqual(new(None), 24)
+
+    def test_single_if_const(self):
+
+        def impl(x):
+            _CONST1 = "PLACEHOLDER1"
+            if _CONST1:
+                return 3.14159
+
+        for c_inp, prune in (self._TRUTHY, False), (self._FALSEY, True):
+            for const in c_inp:
+                func = self._literal_const_sample_generator(impl, {1: const})
+                self.assert_prune(func, (types.NoneType('none'),), [prune],
+                                  None)
+
+    def test_single_if_negate_const(self):
+
+        def impl(x):
+            _CONST1 = "PLACEHOLDER1"
+            if not _CONST1:
+                return 3.14159
+
+        for c_inp, prune in (self._TRUTHY, False), (self._FALSEY, True):
+            for const in c_inp:
+                func = self._literal_const_sample_generator(impl, {1: const})
+                self.assert_prune(func, (types.NoneType('none'),), [prune],
+                                  None)
+
+    def test_single_if_else_const(self):
+
+        def impl(x):
+            _CONST1 = "PLACEHOLDER1"
+            if _CONST1:
+                return 3.14159
+            else:
+                return 1.61803
+
+        for c_inp, prune in (self._TRUTHY, False), (self._FALSEY, True):
+            for const in c_inp:
+                func = self._literal_const_sample_generator(impl, {1: const})
+                self.assert_prune(func, (types.NoneType('none'),), [prune],
+                                  None)
+
+    def test_single_if_else_negate_const(self):
+
+        def impl(x):
+            _CONST1 = "PLACEHOLDER1"
+            if not _CONST1:
+                return 3.14159
+            else:
+                return 1.61803
+
+        for c_inp, prune in (self._TRUTHY, False), (self._FALSEY, True):
+            for const in c_inp:
+                func = self._literal_const_sample_generator(impl, {1: const})
+                self.assert_prune(func, (types.NoneType('none'),), [prune],
+                                  None)
+
+    def test_single_if_freevar(self):
+        for c_inp, prune in (self._TRUTHY, False), (self._FALSEY, True):
+            for const in c_inp:
+
+                def func(x):
+                    if const:
+                        return 3.14159, const
+                self.assert_prune(func, (types.NoneType('none'),), [prune],
+                                  None)
+
+    def test_single_if_negate_freevar(self):
+        for c_inp, prune in (self._TRUTHY, False), (self._FALSEY, True):
+            for const in c_inp:
+
+                def func(x):
+                    if not const:
+                        return 3.14159, const
+                self.assert_prune(func, (types.NoneType('none'),), [prune],
+                                  None)
+
+    def test_single_if_else_freevar(self):
+        for c_inp, prune in (self._TRUTHY, False), (self._FALSEY, True):
+            for const in c_inp:
+
+                def func(x):
+                    if const:
+                        return 3.14159, const
+                    else:
+                        return 1.61803, const
+                self.assert_prune(func, (types.NoneType('none'),), [prune],
+                                  None)
+
+    def test_single_if_else_negate_freevar(self):
+        for c_inp, prune in (self._TRUTHY, False), (self._FALSEY, True):
+            for const in c_inp:
+
+                def func(x):
+                    if not const:
+                        return 3.14159, const
+                    else:
+                        return 1.61803, const
+                self.assert_prune(func, (types.NoneType('none'),), [prune],
+                                  None)
+
+    # globals in this section have absurd names after their test usecase names
+    # so as to prevent collisions and permit tests to run in parallel
+    def test_single_if_global(self):
+        global c_test_single_if_global
+
+        for c_inp, prune in (self._TRUTHY, False), (self._FALSEY, True):
+            for c in c_inp:
+                c_test_single_if_global = c
+
+                def func(x):
+                    if c_test_single_if_global:
+                        return 3.14159, c_test_single_if_global
+
+                self.assert_prune(func, (types.NoneType('none'),), [prune],
+                                  None)
+
+    def test_single_if_negate_global(self):
+        global c_test_single_if_negate_global
+
+        for c_inp, prune in (self._TRUTHY, False), (self._FALSEY, True):
+            for c in c_inp:
+                c_test_single_if_negate_global = c
+
+                def func(x):
+                    if c_test_single_if_negate_global:
+                        return 3.14159, c_test_single_if_negate_global
+
+                self.assert_prune(func, (types.NoneType('none'),), [prune],
+                                  None)
+
+    def test_single_if_else_global(self):
+        global c_test_single_if_else_global
+
+        for c_inp, prune in (self._TRUTHY, False), (self._FALSEY, True):
+            for c in c_inp:
+                c_test_single_if_else_global = c
+
+                def func(x):
+                    if c_test_single_if_else_global:
+                        return 3.14159, c_test_single_if_else_global
+                    else:
+                        return 1.61803, c_test_single_if_else_global
+                self.assert_prune(func, (types.NoneType('none'),), [prune],
+                                  None)
+
+    def test_single_if_else_negate_global(self):
+        global c_test_single_if_else_negate_global
+
+        for c_inp, prune in (self._TRUTHY, False), (self._FALSEY, True):
+            for c in c_inp:
+                c_test_single_if_else_negate_global = c
+
+                def func(x):
+                    if not c_test_single_if_else_negate_global:
+                        return 3.14159, c_test_single_if_else_negate_global
+                    else:
+                        return 1.61803, c_test_single_if_else_negate_global
+                self.assert_prune(func, (types.NoneType('none'),), [prune],
+                                  None)
+
+    def test_issue_5618(self):
+
+        @njit
+        def foo():
+            values = np.zeros(1)
+            tmp = 666
+            if tmp:
+                values[0] = tmp
+            return values
+
+        self.assertPreciseEqual(foo.py_func()[0], 666.)
+        self.assertPreciseEqual(foo()[0], 666.)
+
+
+class TestBranchPruneSSA(MemoryLeakMixin, TestCase):
+    # Tests SSA rewiring of phi nodes after branch pruning.
+
+    class SSAPrunerCompiler(CompilerBase):
+        def define_pipelines(self):
+            # This is a simple pipeline that does branch pruning on IR in SSA
+            # form, then types and lowers as per the standard nopython pipeline.
+            pm = PassManager("testing pm")
+            pm.add_pass(TranslateByteCode, "analyzing bytecode")
+            pm.add_pass(IRProcessing, "processing IR")
+            # SSA early
+            pm.add_pass(ReconstructSSA, "ssa")
+            pm.add_pass(DeadBranchPrune, "dead branch pruning")
+            # type and then lower as usual
+            pm.add_pass(PreserveIR, "preserves the IR as metadata")
+            dpb = DefaultPassBuilder
+            typed_passes = dpb.define_typed_pipeline(self.state)
+            pm.passes.extend(typed_passes.passes)
+            lowering_passes = dpb.define_nopython_lowering_pipeline(self.state)
+            pm.passes.extend(lowering_passes.passes)
+            pm.finalize()
+            return [pm]
+
+    def test_ssa_update_phi(self):
+        # This checks that dead branch pruning is rewiring phi nodes correctly
+        # after a block containing an incoming for a phi is removed.
+
+        @njit(pipeline_class=self.SSAPrunerCompiler)
+        def impl(p=None, q=None):
+            z = 1
+            r = False
+            if p is None:
+                r = True # live
+
+            if r and q is not None:
+                z = 20 # dead
+
+            # one of the incoming blocks for z is dead, the phi needs an update
+            # were this not done, it would refer to variables that do not exist
+            # and result in a lowering error.
+            return z, r
+
+        self.assertPreciseEqual(impl(), impl.py_func())
+
+    def test_ssa_replace_phi(self):
+        # This checks that when a phi only has one incoming, because the other
+        # has been pruned, that a direct assignment is used instead.
+
+        @njit(pipeline_class=self.SSAPrunerCompiler)
+        def impl(p=None):
+            z = 0
+            if p is None:
+                z = 10
+            else:
+                z = 20
+
+            return z
+
+        self.assertPreciseEqual(impl(), impl.py_func())
+        func_ir = impl.overloads[impl.signatures[0]].metadata['preserved_ir']
+
+        # check the func_ir, make sure there's no phi nodes
+        for blk in func_ir.blocks.values():
+            self.assertFalse([*blk.find_exprs('phi')])
+
+
+class TestBranchPrunePostSemanticConstRewrites(TestBranchPruneBase):
+    # Tests that semantic constants rewriting works by virtue of branch pruning
+
+    def test_array_ndim_attr(self):
+
+        def impl(array):
+            if array.ndim == 2:
+                if array.shape[1] == 2:
+                    return 1
+            else:
+                return 10
+
+        self.assert_prune(impl, (types.Array(types.float64, 2, 'C'),), [False,
+                                                                        None],
+                          np.zeros((2, 3)))
+        self.assert_prune(impl, (types.Array(types.float64, 1, 'C'),), [True,
+                                                                        'both'],
+                          np.zeros((2,)))
+
+    def test_tuple_len(self):
+
+        def impl(tup):
+            if len(tup) == 3:
+                if tup[2] == 2:
+                    return 1
+            else:
+                return 0
+
+        self.assert_prune(impl, (types.UniTuple(types.int64, 3),), [False,
+                                                                    None],
+                          tuple([1, 2, 3]))
+        self.assert_prune(impl, (types.UniTuple(types.int64, 2),), [True,
+                                                                    'both'],
+                          tuple([1, 2]))
+
+    def test_attr_not_len(self):
+        # The purpose of this test is to make sure that the conditions guarding
+        # the rewrite part do not themselves raise exceptions.
+        # This produces an `ir.Expr` call node for `float.as_integer_ratio`,
+        # which is a getattr() on `float`.
+
+        @njit
+        def test():
+            float.as_integer_ratio(1.23)
+
+        # this should raise a TypingError
+        with self.assertRaises(errors.TypingError) as e:
+            test()
+
+        self.assertIn("Unknown attribute 'as_integer_ratio'", str(e.exception))
+
+    def test_ndim_not_on_array(self):
+
+        FakeArray = collections.namedtuple('FakeArray', ['ndim'])
+        fa = FakeArray(ndim=2)
+
+        def impl(fa):
+            if fa.ndim == 2:
+                return fa.ndim
+            else:
+                object()
+
+        # check prune works for array ndim
+        self.assert_prune(impl, (types.Array(types.float64, 2, 'C'),), [False],
+                          np.zeros((2, 3)))
+
+        # check prune fails for something with `ndim` attr that is not array
+        FakeArrayType = types.NamedUniTuple(types.int64, 1, FakeArray)
+        self.assert_prune(impl, (FakeArrayType,), [None], fa,
+                          flags={'nopython':False, 'forceobj':True})
+
+    def test_semantic_const_propagates_before_static_rewrites(self):
+        # see issue #5015, the ndim needs writing in as a const before
+        # the rewrite passes run to make e.g. getitems static where possible
+        @njit
+        def impl(a, b):
+            return a.shape[:b.ndim]
+
+        args = (np.zeros((5, 4, 3, 2)), np.zeros((1, 1)))
+
+        self.assertPreciseEqual(impl(*args), impl.py_func(*args))
+
+    def test_tuple_const_propagation(self):
+        @njit(pipeline_class=IRPreservingTestPipeline)
+        def impl(*args):
+            s = 0
+            for arg in literal_unroll(args):
+                s += len(arg)
+            return s
+
+        inp = ((), (1, 2, 3), ())
+        self.assertPreciseEqual(impl(*inp), impl.py_func(*inp))
+
+        ol = impl.overloads[impl.signatures[0]]
+        func_ir = ol.metadata['preserved_ir']
+        # make sure one of the inplace binop args is a Const
+        binop_consts = set()
+        for blk in func_ir.blocks.values():
+            for expr in blk.find_exprs('inplace_binop'):
+                inst = blk.find_variable_assignment(expr.rhs.name)
+                self.assertIsInstance(inst.value, ir.Const)
+                binop_consts.add(inst.value.value)
+        self.assertEqual(binop_consts, {len(x) for x in inp})

lib/python3.10/site-packages/numba/tests/test_annotations.py

@@ -0,0 +1,252 @@
+import re
+from io import StringIO
+
+import numba
+from numba.core import types
+from numba import jit, njit
+from numba.tests.support import override_config, TestCase
+import unittest
+
+try:
+    import jinja2
+except ImportError:
+    jinja2 = None
+
+try:
+    import pygments
+except ImportError:
+    pygments = None
+
+
+@unittest.skipIf(jinja2 is None, "please install the 'jinja2' package")
+class TestAnnotation(TestCase):
+
+    @TestCase.run_test_in_subprocess # annotations compound per module
+    def test_exercise_code_path(self):
+        """
+        Ensures template.html is available
+        """
+
+        def foo(n, a):
+            s = a
+            for i in range(n):
+                s += i
+            return s
+
+        cfunc = njit((types.int32, types.int32))(foo)
+        cres = cfunc.overloads[cfunc.signatures[0]]
+        ta = cres.type_annotation
+
+        buf = StringIO()
+        ta.html_annotate(buf)
+        output = buf.getvalue()
+        buf.close()
+        self.assertIn("foo", output)
+
+    @TestCase.run_test_in_subprocess # annotations compound per module
+    def test_exercise_code_path_with_lifted_loop(self):
+        """
+        Ensures that lifted loops are handled correctly in obj mode
+        """
+        # the functions to jit
+        def bar(x):
+            return x
+
+        def foo(x):
+            h = 0.
+            for i in range(x): # py 38 needs two loops for one to lift?!
+                h = h + i
+            for k in range(x):
+                h = h + k
+            if x:
+                h = h - bar(x)
+            return h
+
+        # compile into an isolated context
+        cfunc = jit((types.intp,), forceobj=True, looplift=True)(foo)
+        cres = cfunc.overloads[cfunc.signatures[0]]
+
+        ta = cres.type_annotation
+
+        buf = StringIO()
+        ta.html_annotate(buf)
+        output = buf.getvalue()
+        buf.close()
+        self.assertIn("bar", output)
+        self.assertIn("foo", output)
+        self.assertIn("LiftedLoop", output)
+
+    @TestCase.run_test_in_subprocess # annotations compound per module
+    def test_html_output_with_lifted_loop(self):
+        """
+        Test some format and behavior of the html annotation with lifted loop
+        """
+        @numba.jit(forceobj=True)
+        def udt(x):
+            object()  # to force object mode
+            z = 0
+            for i in range(x):  # this line is tagged
+                z += i
+            return z
+
+        # Regex pattern to check for the "lifted_tag" in the line of the loop
+        re_lifted_tag = re.compile(
+            r'<td class="lifted_tag">\s*'
+            r'\s*<details>'
+            r'\s*<summary>'
+            r'\s*<code>'
+            r'\s*[0-9]+:'
+            r'\s*[&nbsp;]+for i in range\(x\):  # this line is tagged\s*',
+            re.MULTILINE)
+
+        # Compile int64 version
+        sig_i64 = (types.int64,)
+        udt.compile(sig_i64)  # compile with lifted loop
+        cres = udt.overloads[sig_i64]
+
+        # Make html output
+        buf = StringIO()
+        cres.type_annotation.html_annotate(buf)
+        output = buf.getvalue()
+        buf.close()
+
+        # There should be only one function output.
+        self.assertEqual(output.count("Function name: udt"), 1)
+
+        sigfmt = "with signature: {} -&gt; pyobject"
+        self.assertEqual(output.count(sigfmt.format(sig_i64)), 1)
+        # Ensure the loop is tagged
+        self.assertEqual(len(re.findall(re_lifted_tag, output)), 1,
+                         msg='%s not found in %s' % (re_lifted_tag, output))
+
+        # Compile float64 version
+        sig_f64 = (types.float64,)
+        udt.compile(sig_f64)
+        cres = udt.overloads[sig_f64]
+
+        # Make html output
+        buf = StringIO()
+        cres.type_annotation.html_annotate(buf)
+        output = buf.getvalue()
+        buf.close()
+
+        # There should be two function output
+        self.assertEqual(output.count("Function name: udt"), 2)
+        self.assertEqual(output.count(sigfmt.format(sig_i64)), 1)
+        self.assertEqual(output.count(sigfmt.format(sig_f64)), 1)
+        # Ensure the loop is tagged in both output
+        self.assertEqual(len(re.findall(re_lifted_tag, output)), 2)
+
+    @unittest.skipIf(pygments is None, "please install the 'pygments' package")
+    def test_pretty_print(self):
+
+        @numba.njit
+        def foo(x, y):
+            return x, y
+
+        foo(1, 2)
+        # Exercise the method
+        foo.inspect_types(pretty=True)
+
+        # Exercise but supply a not None file kwarg, this is invalid
+        with self.assertRaises(ValueError) as raises:
+            foo.inspect_types(pretty=True, file='should be None')
+        self.assertIn('`file` must be None if `pretty=True`',
+                      str(raises.exception))
+
+
+class TestTypeAnnotation(unittest.TestCase):
+
+    def findpatloc(self, lines, pat):
+        for i, ln in enumerate(lines):
+            if pat in ln:
+                return i
+        raise ValueError("can't find {!r}".format(pat))
+
+    def getlines(self, func):
+        strbuf = StringIO()
+        func.inspect_types(strbuf)
+        return strbuf.getvalue().splitlines()
+
+    def test_delete(self):
+        @numba.njit
+        def foo(appleorange, berrycherry):
+            return appleorange + berrycherry
+
+        foo(1, 2)
+
+        lines = self.getlines(foo)
+
+        # Ensure deletion show up after their use
+        sa = self.findpatloc(lines, 'appleorange = arg(0, name=appleorange)')
+        sb = self.findpatloc(lines, 'berrycherry = arg(1, name=berrycherry)')
+
+        ea = self.findpatloc(lines, 'del appleorange')
+        eb = self.findpatloc(lines, 'del berrycherry')
+
+        self.assertLess(sa, ea)
+        self.assertLess(sb, eb)
+
+    def _lifetimes_impl(self, extend):
+        with override_config('EXTEND_VARIABLE_LIFETIMES', extend):
+            @njit
+            def foo(a):
+                b = a
+                return b
+            x = 10
+            b = foo(x)
+            self.assertEqual(b, x)
+
+        lines = self.getlines(foo)
+
+        sa = self.findpatloc(lines, 'a = arg(0, name=a)')
+        sb = self.findpatloc(lines, 'b = a')
+
+        cast_ret = self.findpatloc(lines, 'cast(value=b)')
+
+        dela = self.findpatloc(lines, 'del a')
+        delb = self.findpatloc(lines, 'del b')
+
+        return sa, sb, cast_ret, dela, delb
+
+    def test_delete_standard_lifetimes(self):
+        # without extended lifetimes, dels occur as soon as dead
+        #
+        # label 0
+        #   a = arg(0, name=a)  :: int64
+        #   b = a  :: int64
+        #   del a
+        #   $8return_value.2 = cast(value=b)  :: int64
+        #   del b
+        #   return $8return_value.2
+
+        sa, sb, cast_ret, dela, delb = self._lifetimes_impl(extend=0)
+
+        self.assertLess(sa, dela)
+        self.assertLess(sb, delb)
+        # del a is before cast and del b is after
+        self.assertLess(dela, cast_ret)
+        self.assertGreater(delb, cast_ret)
+
+    def test_delete_extended_lifetimes(self):
+        # with extended lifetimes, dels are last in block:
+        #
+        # label 0
+        #   a = arg(0, name=a)  :: int64
+        #   b = a  :: int64
+        #   $8return_value.2 = cast(value=b)  :: int64
+        #   del a
+        #   del b
+        #   return $8return_value.2
+
+        sa, sb, cast_ret, dela, delb = self._lifetimes_impl(extend=1)
+
+        self.assertLess(sa, dela)
+        self.assertLess(sb, delb)
+        # dels are after the cast
+        self.assertGreater(dela, cast_ret)
+        self.assertGreater(delb, cast_ret)
+
+
+if __name__ == '__main__':
+    unittest.main()

lib/python3.10/site-packages/numba/tests/test_array_exprs.py

@@ -0,0 +1,742 @@
+import gc
+from io import StringIO
+
+import numpy as np
+
+from numba import njit, vectorize
+from numba import typeof
+from numba.core import utils, types, typing, ir, compiler, cpu, cgutils
+from numba.core.compiler import Compiler, Flags
+from numba.core.registry import cpu_target
+from numba.tests.support import (MemoryLeakMixin, TestCase, temp_directory,
+                                 create_temp_module)
+from numba.extending import (
+    overload,
+    models,
+    lower_builtin,
+    register_model,
+    make_attribute_wrapper,
+    type_callable,
+    typeof_impl
+)
+import operator
+import textwrap
+
+import unittest
+
+
+class Namespace(dict):
+    def __getattr__(s, k):
+        return s[k] if k in s else super(Namespace, s).__getattr__(k)
+
+def axy(a, x, y):
+    return a * x + y
+
+def ax2(a, x, y):
+    return a * x + y
+
+def pos_root(As, Bs, Cs):
+    return (-Bs + (((Bs ** 2.) - (4. * As * Cs)) ** 0.5)) / (2. * As)
+
+def neg_root_common_subexpr(As, Bs, Cs):
+    _2As = 2. * As
+    _4AsCs = 2. * _2As * Cs
+    _Bs2_4AsCs = (Bs ** 2. - _4AsCs)
+    return (-Bs - (_Bs2_4AsCs ** 0.5)) / _2As
+
+def neg_root_complex_subexpr(As, Bs, Cs):
+    _2As = 2. * As
+    _4AsCs = 2. * _2As * Cs
+    _Bs2_4AsCs = (Bs ** 2. - _4AsCs) + 0j # Force into the complex domain.
+    return (-Bs - (_Bs2_4AsCs ** 0.5)) / _2As
+
+vaxy = vectorize(axy)
+
+def call_stuff(a0, a1):
+    return np.cos(vaxy(a0, np.sin(a1) - 1., 1.))
+
+def are_roots_imaginary(As, Bs, Cs):
+    return (Bs ** 2 - 4 * As * Cs) < 0
+
+def div_add(As, Bs, Cs):
+    return As / Bs + Cs
+
+def cube(As):
+    return As ** 3
+
+def explicit_output(a, b, out):
+    np.cos(a, out)
+    return np.add(out, b, out)
+
+def variable_name_reuse(a, b, c, d):
+    u = a + b
+    u = u - a * b
+    u = u * c + d
+    return u
+
+
+# From issue #1264
+def distance_matrix(vectors):
+    n_vectors = vectors.shape[0]
+    result = np.empty((n_vectors, n_vectors), dtype=np.float64)
+
+    for i in range(n_vectors):
+        for j in range(i, n_vectors):
+            result[i,j] = result[j,i] = np.sum(
+                (vectors[i] - vectors[j]) ** 2) ** 0.5
+
+    return result
+
+
+class RewritesTester(Compiler):
+    @classmethod
+    def mk_pipeline(cls, args, return_type=None, flags=None, locals={},
+                    library=None, typing_context=None, target_context=None):
+        if not flags:
+            flags = Flags()
+        flags.nrt = True
+        if typing_context is None:
+            typing_context = cpu_target.typing_context
+        if target_context is None:
+            target_context = cpu_target.target_context
+        return cls(typing_context, target_context, library, args, return_type,
+                   flags, locals)
+
+    @classmethod
+    def mk_no_rw_pipeline(cls, args, return_type=None, flags=None, locals={},
+                          library=None, **kws):
+        if not flags:
+            flags = Flags()
+        flags.no_rewrites = True
+        return cls.mk_pipeline(args, return_type, flags, locals, library, **kws)
+
+
+class TestArrayExpressions(MemoryLeakMixin, TestCase):
+
+    def _compile_function(self, fn, arg_tys):
+        """
+        Compile the given function both without and with rewrites enabled.
+        """
+        control_pipeline = RewritesTester.mk_no_rw_pipeline(arg_tys)
+        cres_0 = control_pipeline.compile_extra(fn)
+        control_cfunc = cres_0.entry_point
+
+        test_pipeline = RewritesTester.mk_pipeline(arg_tys)
+        cres_1 = test_pipeline.compile_extra(fn)
+        test_cfunc = cres_1.entry_point
+
+        return control_pipeline, control_cfunc, test_pipeline, test_cfunc
+
+    def test_simple_expr(self):
+        '''
+        Using a simple array expression, verify that rewriting is taking
+        place, and is fusing loops.
+        '''
+        A = np.linspace(0,1,10)
+        X = np.linspace(2,1,10)
+        Y = np.linspace(1,2,10)
+        arg_tys = [typeof(arg) for arg in (A, X, Y)]
+
+        control_pipeline, nb_axy_0, test_pipeline, nb_axy_1 = \
+            self._compile_function(axy, arg_tys)
+
+        control_pipeline2 = RewritesTester.mk_no_rw_pipeline(arg_tys)
+        cres_2 = control_pipeline2.compile_extra(ax2)
+        nb_ctl = cres_2.entry_point
+
+        expected = nb_axy_0(A, X, Y)
+        actual = nb_axy_1(A, X, Y)
+        control = nb_ctl(A, X, Y)
+        np.testing.assert_array_equal(expected, actual)
+        np.testing.assert_array_equal(control, actual)
+
+        ir0 = control_pipeline.state.func_ir.blocks
+        ir1 = test_pipeline.state.func_ir.blocks
+        ir2 = control_pipeline2.state.func_ir.blocks
+        self.assertEqual(len(ir0), len(ir1))
+        self.assertEqual(len(ir0), len(ir2))
+        # The rewritten IR should be smaller than the original.
+        self.assertGreater(len(ir0[0].body), len(ir1[0].body))
+        self.assertEqual(len(ir0[0].body), len(ir2[0].body))
+
+    def _get_array_exprs(self, block):
+        for instr in block:
+            if isinstance(instr, ir.Assign):
+                if isinstance(instr.value, ir.Expr):
+                    if instr.value.op == 'arrayexpr':
+                        yield instr
+
+    def _array_expr_to_set(self, expr, out=None):
+        '''
+        Convert an array expression tree into a set of operators.
+        '''
+        if out is None:
+            out = set()
+        if not isinstance(expr, tuple):
+            raise ValueError("{0} not a tuple".format(expr))
+        operation, operands = expr
+        processed_operands = []
+        for operand in operands:
+            if isinstance(operand, tuple):
+                operand, _ = self._array_expr_to_set(operand, out)
+            processed_operands.append(operand)
+        processed_expr = operation, tuple(processed_operands)
+        out.add(processed_expr)
+        return processed_expr, out
+
+    def _test_root_function(self, fn=pos_root):
+        A = np.random.random(10)
+        B = np.random.random(10) + 1. # Increase likelihood of real
+                                      # root (could add 2 to force all
+                                      # roots to be real).
+        C = np.random.random(10)
+        arg_tys = [typeof(arg) for arg in (A, B, C)]
+
+        control_pipeline = RewritesTester.mk_no_rw_pipeline(arg_tys)
+        control_cres = control_pipeline.compile_extra(fn)
+        nb_fn_0 = control_cres.entry_point
+
+        test_pipeline = RewritesTester.mk_pipeline(arg_tys)
+        test_cres = test_pipeline.compile_extra(fn)
+        nb_fn_1 = test_cres.entry_point
+
+        np_result = fn(A, B, C)
+        nb_result_0 = nb_fn_0(A, B, C)
+        nb_result_1 = nb_fn_1(A, B, C)
+        np.testing.assert_array_almost_equal(np_result, nb_result_0)
+        np.testing.assert_array_almost_equal(nb_result_0, nb_result_1)
+
+        return Namespace(locals())
+
+    def _test_cube_function(self, fn=cube):
+        A = np.arange(10, dtype=np.float64)
+        arg_tys = (typeof(A),)
+
+        control_pipeline = RewritesTester.mk_no_rw_pipeline(arg_tys)
+        control_cres = control_pipeline.compile_extra(fn)
+        nb_fn_0 = control_cres.entry_point
+
+        test_pipeline = RewritesTester.mk_pipeline(arg_tys)
+        test_cres = test_pipeline.compile_extra(fn)
+        nb_fn_1 = test_cres.entry_point
+
+        expected = A ** 3
+        self.assertPreciseEqual(expected, nb_fn_0(A))
+        self.assertPreciseEqual(expected, nb_fn_1(A))
+
+        return Namespace(locals())
+
+    def _test_explicit_output_function(self, fn):
+        """
+        Test function having a (a, b, out) signature where *out* is
+        an output array the function writes into.
+        """
+        A = np.arange(10, dtype=np.float64)
+        B = A + 1
+        arg_tys = (typeof(A),) * 3
+
+        control_pipeline, control_cfunc, test_pipeline, test_cfunc = \
+            self._compile_function(fn, arg_tys)
+
+        def run_func(fn):
+            out = np.zeros_like(A)
+            fn(A, B, out)
+            return out
+
+        expected = run_func(fn)
+        self.assertPreciseEqual(expected, run_func(control_cfunc))
+        self.assertPreciseEqual(expected, run_func(test_cfunc))
+
+        return Namespace(locals())
+
+    def _assert_array_exprs(self, block, expected_count):
+        """
+        Assert the *block* has the expected number of array expressions
+        in it.
+        """
+        rewrite_count = len(list(self._get_array_exprs(block)))
+        self.assertEqual(rewrite_count, expected_count)
+
+    def _assert_total_rewrite(self, control_ir, test_ir, trivial=False):
+        """
+        Given two dictionaries of Numba IR blocks, check to make sure the
+        control IR has no array expressions, while the test IR
+        contains one and only one.
+        """
+        # Both IRs have the same number of blocks (presumably 1)
+        self.assertEqual(len(control_ir), len(test_ir))
+        control_block = control_ir[0].body
+        test_block = test_ir[0].body
+        self._assert_array_exprs(control_block, 0)
+        self._assert_array_exprs(test_block, 1)
+        if not trivial:
+            # If the expression wasn't trivial, the block length should
+            # have decreased (since a sequence of exprs was replaced
+            # with a single nested array expr).
+            self.assertGreater(len(control_block), len(test_block))
+
+    def _assert_no_rewrite(self, control_ir, test_ir):
+        """
+        Given two dictionaries of Numba IR blocks, check to make sure
+        the control IR and the test IR both have no array expressions.
+        """
+        self.assertEqual(len(control_ir), len(test_ir))
+        # All blocks should be identical, and not rewritten
+        for k, v in control_ir.items():
+            control_block = v.body
+            test_block = test_ir[k].body
+            self.assertEqual(len(control_block), len(test_block))
+            self._assert_array_exprs(control_block, 0)
+            self._assert_array_exprs(test_block, 0)
+
+    def test_trivial_expr(self):
+        """
+        Ensure even a non-nested expression is rewritten, as it can enable
+        scalar optimizations such as rewriting `x ** 2`.
+        """
+        ns = self._test_cube_function()
+        self._assert_total_rewrite(ns.control_pipeline.state.func_ir.blocks,
+                                   ns.test_pipeline.state.func_ir.blocks,
+                                   trivial=True)
+
+    def test_complicated_expr(self):
+        '''
+        Using the polynomial root function, ensure the full expression is
+        being put in the same kernel with no remnants of intermediate
+        array expressions.
+        '''
+        ns = self._test_root_function()
+        self._assert_total_rewrite(ns.control_pipeline.state.func_ir.blocks,
+                                   ns.test_pipeline.state.func_ir.blocks)
+
+    def test_common_subexpressions(self, fn=neg_root_common_subexpr):
+        '''
+        Attempt to verify that rewriting will incorporate user common
+        subexpressions properly.
+        '''
+        ns = self._test_root_function(fn)
+        ir0 = ns.control_pipeline.state.func_ir.blocks
+        ir1 = ns.test_pipeline.state.func_ir.blocks
+        self.assertEqual(len(ir0), len(ir1))
+        self.assertGreater(len(ir0[0].body), len(ir1[0].body))
+        self.assertEqual(len(list(self._get_array_exprs(ir0[0].body))), 0)
+        # Verify that we didn't rewrite everything into a monolithic
+        # array expression since we stored temporary values in
+        # variables that might be used later (from the optimization's
+        # point of view).
+        array_expr_instrs = list(self._get_array_exprs(ir1[0].body))
+        self.assertGreater(len(array_expr_instrs), 1)
+        # Now check that we haven't duplicated any subexpressions in
+        # the rewritten code.
+        array_sets = list(self._array_expr_to_set(instr.value.expr)[1]
+                          for instr in array_expr_instrs)
+        for expr_set_0, expr_set_1 in zip(array_sets[:-1], array_sets[1:]):
+            intersections = expr_set_0.intersection(expr_set_1)
+            if intersections:
+                self.fail("Common subexpressions detected in array "
+                          "expressions ({0})".format(intersections))
+
+    def test_complex_subexpression(self):
+        return self.test_common_subexpressions(neg_root_complex_subexpr)
+
+    def test_ufunc_and_dufunc_calls(self):
+        '''
+        Verify that ufunc and DUFunc calls are being properly included in
+        array expressions.
+        '''
+        A = np.random.random(10)
+        B = np.random.random(10)
+        arg_tys = [typeof(arg) for arg in (A, B)]
+
+        vaxy_descr = vaxy._dispatcher.targetdescr
+        control_pipeline = RewritesTester.mk_no_rw_pipeline(
+            arg_tys,
+            typing_context=vaxy_descr.typing_context,
+            target_context=vaxy_descr.target_context)
+        cres_0 = control_pipeline.compile_extra(call_stuff)
+        nb_call_stuff_0 = cres_0.entry_point
+
+        test_pipeline = RewritesTester.mk_pipeline(
+            arg_tys,
+            typing_context=vaxy_descr.typing_context,
+            target_context=vaxy_descr.target_context)
+        cres_1 = test_pipeline.compile_extra(call_stuff)
+        nb_call_stuff_1 = cres_1.entry_point
+
+        expected = call_stuff(A, B)
+        control = nb_call_stuff_0(A, B)
+        actual = nb_call_stuff_1(A, B)
+        np.testing.assert_array_almost_equal(expected, control)
+        np.testing.assert_array_almost_equal(expected, actual)
+
+        self._assert_total_rewrite(control_pipeline.state.func_ir.blocks,
+                                   test_pipeline.state.func_ir.blocks)
+
+    def test_cmp_op(self):
+        '''
+        Verify that comparison operators are supported by the rewriter.
+        '''
+        ns = self._test_root_function(are_roots_imaginary)
+        self._assert_total_rewrite(ns.control_pipeline.state.func_ir.blocks,
+                                   ns.test_pipeline.state.func_ir.blocks)
+
+    def test_explicit_output(self):
+        """
+        Check that ufunc calls with explicit outputs are not rewritten.
+        """
+        ns = self._test_explicit_output_function(explicit_output)
+        self._assert_no_rewrite(ns.control_pipeline.state.func_ir.blocks,
+                                ns.test_pipeline.state.func_ir.blocks)
+
+
+class TestRewriteIssues(MemoryLeakMixin, TestCase):
+
+    def test_issue_1184(self):
+        from numba import jit
+        import numpy as np
+
+        @jit(nopython=True)
+        def foo(arr):
+            return arr
+
+        @jit(nopython=True)
+        def bar(arr):
+            c = foo(arr)
+            d = foo(arr)   # two calls to trigger rewrite
+            return c, d
+
+        arr = np.arange(10)
+        out_c, out_d = bar(arr)
+        self.assertIs(out_c, out_d)
+        self.assertIs(out_c, arr)
+
+    def test_issue_1264(self):
+        n = 100
+        x = np.random.uniform(size=n*3).reshape((n,3))
+        expected = distance_matrix(x)
+        actual = njit(distance_matrix)(x)
+        np.testing.assert_array_almost_equal(expected, actual)
+        # Avoid sporadic failures in MemoryLeakMixin.tearDown()
+        gc.collect()
+
+    def test_issue_1372(self):
+        """Test array expression with duplicated term"""
+        from numba import njit
+
+        @njit
+        def foo(a, b):
+            b = np.sin(b)
+            return b + b + a
+
+        a = np.random.uniform(10)
+        b = np.random.uniform(10)
+        expect = foo.py_func(a, b)
+        got = foo(a, b)
+        np.testing.assert_allclose(got, expect)
+
+    def test_unary_arrayexpr(self):
+        """
+        Typing of unary array expression (np.negate) can be incorrect.
+        """
+        @njit
+        def foo(a, b):
+            return b - a + -a
+
+        b = 1.5
+        a = np.arange(10, dtype=np.int32)
+
+        expect = foo.py_func(a, b)
+        got = foo(a, b)
+        self.assertPreciseEqual(got, expect)
+
+    def test_bitwise_arrayexpr(self):
+        """
+        Typing of bitwise boolean array expression can be incorrect
+        (issue #1813).
+        """
+        @njit
+        def foo(a, b):
+            return ~(a & (~b))
+
+        a = np.array([True, True, False, False])
+        b = np.array([False, True, False, True])
+
+        expect = foo.py_func(a, b)
+        got = foo(a, b)
+        self.assertPreciseEqual(got, expect)
+
+    def test_annotations(self):
+        """
+        Type annotation of array expressions with disambiguated
+        variable names (issue #1466).
+        """
+        cfunc = njit(variable_name_reuse)
+
+        a = np.linspace(0, 1, 10)
+        cfunc(a, a, a, a)
+
+        buf = StringIO()
+        cfunc.inspect_types(buf)
+        res = buf.getvalue()
+        self.assertIn("#   u.1 = ", res)
+        self.assertIn("#   u.2 = ", res)
+
+    def test_issue_5599_name_collision(self):
+        # The original error will fail in lowering of the array_expr
+        @njit
+        def f(x):
+            arr = np.ones(x)
+
+            for _ in range(2):
+                val =  arr * arr
+                arr = arr.copy()
+            return arr
+
+        got = f(5)
+        expect = f.py_func(5)
+        np.testing.assert_array_equal(got, expect)
+
+
+class TestSemantics(MemoryLeakMixin, unittest.TestCase):
+
+    def test_division_by_zero(self):
+        # Array expressions should follow the Numpy error model
+        # i.e. 1./0. returns +inf instead of raising ZeroDivisionError
+        pyfunc = div_add
+        cfunc = njit(pyfunc)
+
+        a = np.float64([0.0, 1.0, float('inf')])
+        b = np.float64([0.0, 0.0, 1.0])
+        c = np.ones_like(a)
+
+        expect = pyfunc(a, b, c)
+        got = cfunc(a, b, c)
+        np.testing.assert_array_equal(expect, got)
+
+
+class TestOptionals(MemoryLeakMixin, unittest.TestCase):
+    """ Tests the arrival and correct lowering of Optional types at a arrayexpr
+    derived ufunc, see #3972"""
+
+    def test_optional_scalar_type(self):
+
+        @njit
+        def arr_expr(x, y):
+            return x + y
+
+        @njit
+        def do_call(x, y):
+            if y > 0:
+                z = None
+            else:
+                z = y
+            return arr_expr(x, z)
+
+        args = (np.arange(5), -1.2)
+
+        # check result
+        res = do_call(*args)
+        expected = do_call.py_func(*args)
+        np.testing.assert_allclose(res, expected)
+
+        # check type
+        s = arr_expr.signatures
+        oty = s[0][1]
+        self.assertTrue(isinstance(oty, types.Optional))
+        self.assertTrue(isinstance(oty.type, types.Float))
+
+    def test_optional_array_type(self):
+
+        @njit
+        def arr_expr(x, y):
+            return x + y
+
+        @njit
+        def do_call(x, y):
+            if y[0] > 0:
+                z = None
+            else:
+                z = y
+            return arr_expr(x, z)
+
+        args = (np.arange(5), np.arange(5.))
+
+        # check result
+        res = do_call(*args)
+        expected = do_call.py_func(*args)
+        np.testing.assert_allclose(res, expected)
+
+        # check type
+        s = arr_expr.signatures
+        oty = s[0][1]
+        self.assertTrue(isinstance(oty, types.Optional))
+        self.assertTrue(isinstance(oty.type, types.Array))
+        self.assertTrue(isinstance(oty.type.dtype, types.Float))
+
+
+class TestOptionalsExceptions(MemoryLeakMixin, unittest.TestCase):
+    # same as above, but the Optional resolves to None and TypeError's
+
+    def test_optional_scalar_type_exception_on_none(self):
+
+        self.disable_leak_check()
+
+        @njit
+        def arr_expr(x, y):
+            return x + y
+
+        @njit
+        def do_call(x, y):
+            if y > 0:
+                z = None
+            else:
+                z = y
+            return arr_expr(x, z)
+
+        args = (np.arange(5), 1.0)
+
+        # check result
+        with self.assertRaises(TypeError) as raises:
+            do_call(*args)
+
+        self.assertIn("expected float64, got None", str(raises.exception))
+
+        # check type
+        s = arr_expr.signatures
+        oty = s[0][1]
+        self.assertTrue(isinstance(oty, types.Optional))
+        self.assertTrue(isinstance(oty.type, types.Float))
+
+    def test_optional_array_type_exception_on_none(self):
+
+        self.disable_leak_check()
+
+        @njit
+        def arr_expr(x, y):
+            return x + y
+
+        @njit
+        def do_call(x, y):
+            if y[0] > 0:
+                z = None
+            else:
+                z = y
+            return arr_expr(x, z)
+
+        args = (np.arange(5), np.arange(1., 5.))
+
+        # check result
+        with self.assertRaises(TypeError) as raises:
+            do_call(*args)
+
+        excstr = str(raises.exception)
+        self.assertIn("expected array(float64,", excstr)
+        self.assertIn("got None", excstr)
+
+        # check type
+        s = arr_expr.signatures
+        oty = s[0][1]
+        self.assertTrue(isinstance(oty, types.Optional))
+        self.assertTrue(isinstance(oty.type, types.Array))
+        self.assertTrue(isinstance(oty.type.dtype, types.Float))
+
+
+class TestExternalTypes(MemoryLeakMixin, unittest.TestCase):
+    """ Tests RewriteArrayExprs with external (user defined) types,
+    see #5157"""
+
+    source_lines = textwrap.dedent("""
+        from numba.core import types
+
+        class FooType(types.Type):
+            def __init__(self):
+                super(FooType, self).__init__(name='Foo')
+        """)
+
+    def make_foo_type(self, FooType):
+        class Foo(object):
+            def __init__(self, value):
+                self.value = value
+
+        @register_model(FooType)
+        class FooModel(models.StructModel):
+            def __init__(self, dmm, fe_type):
+                members = [("value", types.intp)]
+                models.StructModel.__init__(self, dmm, fe_type, members)
+
+        make_attribute_wrapper(FooType, "value", "value")
+
+        @type_callable(Foo)
+        def type_foo(context):
+            def typer(value):
+                return FooType()
+
+            return typer
+
+        @lower_builtin(Foo, types.intp)
+        def impl_foo(context, builder, sig, args):
+            typ = sig.return_type
+            [value] = args
+            foo = cgutils.create_struct_proxy(typ)(context, builder)
+            foo.value = value
+            return foo._getvalue()
+
+        @typeof_impl.register(Foo)
+        def typeof_foo(val, c):
+            return FooType()
+
+        return Foo, FooType
+
+    def test_external_type(self):
+        with create_temp_module(self.source_lines) as test_module:
+            Foo, FooType = self.make_foo_type(test_module.FooType)
+
+            # sum of foo class instance and array return an array
+            # binary operation with foo class instance as one of args
+            @overload(operator.add)
+            def overload_foo_add(lhs, rhs):
+                if isinstance(lhs, FooType) and isinstance(rhs, types.Array):
+                    def imp(lhs, rhs):
+                        return np.array([lhs.value, rhs[0]])
+
+                    return imp
+
+            # sum of 2 foo class instances return an array
+            # binary operation with 2 foo class instances as args
+            @overload(operator.add)
+            def overload_foo_add(lhs, rhs):
+                if isinstance(lhs, FooType) and isinstance(rhs, FooType):
+                    def imp(lhs, rhs):
+                        return np.array([lhs.value, rhs.value])
+
+                    return imp
+
+            # neg of foo class instance return an array
+            # unary operation with foo class instance arg
+            @overload(operator.neg)
+            def overload_foo_neg(x):
+                if isinstance(x, FooType):
+                    def imp(x):
+                        return np.array([-x.value])
+
+                    return imp
+
+            @njit
+            def arr_expr_sum1(x, y):
+                return Foo(x) + np.array([y])
+
+            @njit
+            def arr_expr_sum2(x, y):
+                return Foo(x) + Foo(y)
+
+            @njit
+            def arr_expr_neg(x):
+                return -Foo(x)
+
+            np.testing.assert_array_equal(arr_expr_sum1(0, 1), np.array([0, 1]))
+            np.testing.assert_array_equal(arr_expr_sum2(2, 3), np.array([2, 3]))
+            np.testing.assert_array_equal(arr_expr_neg(4), np.array([-4]))
+
+
+if __name__ == "__main__":
+    unittest.main()

lib/python3.10/site-packages/numba/tests/test_array_manipulation.py

@@ -0,0 +1,1588 @@
+from functools import partial
+from itertools import permutations
+
+import numpy as np
+
+import unittest
+from numba import jit, njit, from_dtype, typeof
+from numba.core.errors import TypingError
+from numba.core import types, errors
+from numba.tests.support import TestCase, MemoryLeakMixin
+
+enable_pyobj_flags = {'forceobj': True}
+
+no_pyobj_flags = {'_nrt': True, 'nopython': True}
+
+
+def from_generic(pyfuncs_to_use):
+    """Decorator for generic check functions.
+        Iterates over 'pyfuncs_to_use', calling 'func' with the iterated
+        item as first argument. Example:
+
+        @from_generic(numpy_array_reshape, array_reshape)
+        def check_only_shape(pyfunc, arr, shape, expected_shape):
+            # Only check Numba result to avoid Numpy bugs
+            self.memory_leak_setup()
+            got = generic_run(pyfunc, arr, shape)
+            self.assertEqual(got.shape, expected_shape)
+            self.assertEqual(got.size, arr.size)
+            del got
+            self.memory_leak_teardown()
+    """
+    def decorator(func):
+        def result(*args, **kwargs):
+            return [func(pyfunc, *args, **kwargs) for pyfunc in pyfuncs_to_use]
+        return result
+    return decorator
+
+
+@njit
+def array_reshape(arr, newshape):
+    return arr.reshape(newshape)
+
+@njit
+def numpy_array_reshape(arr, newshape):
+    return np.reshape(arr, newshape)
+
+
+def numpy_broadcast_to(arr, shape):
+    return np.broadcast_to(arr, shape)
+
+
+def numpy_broadcast_shapes(*args):
+    return np.broadcast_shapes(*args)
+
+
+def numpy_broadcast_arrays(*args):
+    return np.broadcast_arrays(*args)
+
+
+def numpy_broadcast_to_indexing(arr, shape, idx):
+    return np.broadcast_to(arr, shape)[idx]
+
+
+def flatten_array(a):
+    return a.flatten()
+
+
+def ravel_array(a):
+    return a.ravel()
+
+
+def ravel_array_size(a):
+    return a.ravel().size
+
+
+def numpy_ravel_array(a):
+    return np.ravel(a)
+
+
+def transpose_array(a):
+    return a.transpose()
+
+
+def numpy_transpose_array(a):
+    return np.transpose(a)
+
+
+@njit
+def numpy_transpose_array_axes_kwarg(arr, axes):
+    return np.transpose(arr, axes=axes)
+
+
+@njit
+def numpy_transpose_array_axes_kwarg_copy(arr, axes):
+    return np.transpose(arr, axes=axes).copy()
+
+
+@njit
+def array_transpose_axes(arr, axes):
+    return arr.transpose(axes)
+
+
+@njit
+def array_transpose_axes_copy(arr, axes):
+    return arr.transpose(axes).copy()
+
+
+@njit
+def transpose_issue_4708(m, n):
+    r1 = np.reshape(np.arange(m * n * 3), (m, 3, n))
+    r2 = np.reshape(np.arange(n * 3), (n, 3))
+    r_dif = (r1 - r2.T).T
+    r_dif = np.transpose(r_dif, (2, 0, 1))
+    z = r_dif + 1
+    return z
+
+
+def squeeze_array(a):
+    return a.squeeze()
+
+
+def expand_dims(a, axis):
+    return np.expand_dims(a, axis)
+
+
+def atleast_1d(*args):
+    return np.atleast_1d(*args)
+
+
+def atleast_2d(*args):
+    return np.atleast_2d(*args)
+
+
+def atleast_3d(*args):
+    return np.atleast_3d(*args)
+
+
+def as_strided1(a):
+    # as_strided() with implicit shape
+    strides = (a.strides[0] // 2,) + a.strides[1:]
+    return np.lib.stride_tricks.as_strided(a, strides=strides)
+
+
+def as_strided2(a):
+    # Rolling window example as in https://github.com/numba/numba/issues/1884
+    window = 3
+    shape = a.shape[:-1] + (a.shape[-1] - window + 1, window)
+    strides = a.strides + (a.strides[-1],)
+    return np.lib.stride_tricks.as_strided(a, shape=shape, strides=strides)
+
+
+@njit
+def sliding_window_view(x, window_shape, axis=None):
+    return np.lib.stride_tricks.sliding_window_view(x, window_shape, axis=axis)
+
+
+def bad_index(arr, arr2d):
+    x = arr.x,
+    y = arr.y
+    # note that `x` is a tuple, which causes a new axis to be created.
+    arr2d[x, y] = 1.0
+
+
+def bad_float_index(arr):
+    # 2D index required for this function because 1D index
+    # fails typing
+    return arr[1, 2.0]
+
+
+def numpy_fill_diagonal(arr, val, wrap=False):
+    return np.fill_diagonal(arr, val, wrap)
+
+
+def numpy_shape(arr):
+    return np.shape(arr)
+
+def numpy_size(arr):
+    return np.size(arr)
+
+
+def numpy_flatnonzero(a):
+    return np.flatnonzero(a)
+
+
+def numpy_argwhere(a):
+    return np.argwhere(a)
+
+def numpy_resize(a, new_shape):
+    return np.resize(a, new_shape)
+
+
+class TestArrayManipulation(MemoryLeakMixin, TestCase):
+    """
+    Check shape-changing operations on arrays.
+    """
+    def test_array_reshape(self):
+        pyfuncs_to_use = [array_reshape, numpy_array_reshape]
+
+        def generic_run(pyfunc, arr, shape):
+            return pyfunc(arr, shape)
+
+        @from_generic(pyfuncs_to_use)
+        def check(pyfunc, arr, shape):
+            expected = pyfunc.py_func(arr, shape)
+            self.memory_leak_setup()
+            got = generic_run(pyfunc, arr, shape)
+            self.assertPreciseEqual(got, expected)
+            del got
+            self.memory_leak_teardown()
+
+        @from_generic(pyfuncs_to_use)
+        def check_only_shape(pyfunc, arr, shape, expected_shape):
+            # Only check Numba result to avoid Numpy bugs
+            self.memory_leak_setup()
+            got = generic_run(pyfunc, arr, shape)
+            self.assertEqual(got.shape, expected_shape)
+            self.assertEqual(got.size, arr.size)
+            del got
+            self.memory_leak_teardown()
+
+        @from_generic(pyfuncs_to_use)
+        def check_err_shape(pyfunc, arr, shape):
+            with self.assertRaises(NotImplementedError) as raises:
+                generic_run(pyfunc, arr, shape)
+            self.assertEqual(str(raises.exception),
+                             "incompatible shape for array")
+
+        @from_generic(pyfuncs_to_use)
+        def check_err_size(pyfunc, arr, shape):
+            with self.assertRaises(ValueError) as raises:
+                generic_run(pyfunc, arr, shape)
+            self.assertEqual(str(raises.exception),
+                             "total size of new array must be unchanged")
+
+        @from_generic(pyfuncs_to_use)
+        def check_err_multiple_negative(pyfunc, arr, shape):
+            with self.assertRaises(ValueError) as raises:
+                generic_run(pyfunc, arr, shape)
+            self.assertEqual(str(raises.exception),
+                             "multiple negative shape values")
+
+
+        # C-contiguous
+        arr = np.arange(24)
+        check(arr, (24,))
+        check(arr, (4, 6))
+        check(arr, (8, 3))
+        check(arr, (8, 1, 3))
+        check(arr, (1, 8, 1, 1, 3, 1))
+        arr = np.arange(24).reshape((2, 3, 4))
+        check(arr, (24,))
+        check(arr, (4, 6))
+        check(arr, (8, 3))
+        check(arr, (8, 1, 3))
+        check(arr, (1, 8, 1, 1, 3, 1))
+        check_err_size(arr, ())
+        check_err_size(arr, (25,))
+        check_err_size(arr, (8, 4))
+        arr = np.arange(24).reshape((1, 8, 1, 1, 3, 1))
+        check(arr, (24,))
+        check(arr, (4, 6))
+        check(arr, (8, 3))
+        check(arr, (8, 1, 3))
+
+        # F-contiguous
+        arr = np.arange(24).reshape((2, 3, 4)).T
+        check(arr, (4, 3, 2))
+        check(arr, (1, 4, 1, 3, 1, 2, 1))
+        check_err_shape(arr, (2, 3, 4))
+        check_err_shape(arr, (6, 4))
+        check_err_shape(arr, (2, 12))
+
+        # Test negative shape value
+        arr = np.arange(25).reshape(5,5)
+        check(arr, -1)
+        check(arr, (-1,))
+        check(arr, (-1, 5))
+        check(arr, (5, -1, 5))
+        check(arr, (5, 5, -1))
+        check_err_size(arr, (-1, 4))
+        check_err_multiple_negative(arr, (-1, -2, 5, 5))
+        check_err_multiple_negative(arr, (5, 5, -1, -1))
+
+        # 0-sized arrays
+        def check_empty(arr):
+            check(arr, 0)
+            check(arr, (0,))
+            check(arr, (1, 0, 2))
+            check(arr, (0, 55, 1, 0, 2))
+            # -1 is buggy in Numpy with 0-sized arrays
+            check_only_shape(arr, -1, (0,))
+            check_only_shape(arr, (-1,), (0,))
+            check_only_shape(arr, (0, -1), (0, 0))
+            check_only_shape(arr, (4, -1), (4, 0))
+            check_only_shape(arr, (-1, 0, 4), (0, 0, 4))
+            check_err_size(arr, ())
+            check_err_size(arr, 1)
+            check_err_size(arr, (1, 2))
+
+        arr = np.array([])
+        check_empty(arr)
+        check_empty(arr.reshape((3, 2, 0)))
+
+        # Exceptions leak references
+        self.disable_leak_check()
+
+    def test_array_transpose_axes(self):
+        pyfuncs_to_use = [numpy_transpose_array_axes_kwarg,
+                          numpy_transpose_array_axes_kwarg_copy,
+                          array_transpose_axes,
+                          array_transpose_axes_copy]
+
+        @from_generic(pyfuncs_to_use)
+        def check(pyfunc, arr, axes):
+            expected = pyfunc.py_func(arr, axes)
+            got = pyfunc(arr, axes)
+            self.assertPreciseEqual(got, expected)
+            self.assertEqual(got.flags.f_contiguous,
+                             expected.flags.f_contiguous)
+            self.assertEqual(got.flags.c_contiguous,
+                             expected.flags.c_contiguous)
+
+        @from_generic(pyfuncs_to_use)
+        def check_err_axis_repeated(pyfunc, arr, axes):
+            with self.assertRaises(ValueError) as raises:
+                pyfunc(arr, axes)
+            self.assertEqual(str(raises.exception),
+                             "repeated axis in transpose")
+
+        @from_generic(pyfuncs_to_use)
+        def check_err_axis_oob(pyfunc, arr, axes):
+            with self.assertRaises(ValueError) as raises:
+                pyfunc(arr, axes)
+            self.assertEqual(str(raises.exception),
+                             "axis is out of bounds for array of given dimension")
+
+        @from_generic(pyfuncs_to_use)
+        def check_err_invalid_args(pyfunc, arr, axes):
+            with self.assertRaises((TypeError, TypingError)):
+                pyfunc(arr, axes)
+
+        arrs = [np.arange(24),
+                np.arange(24).reshape(4, 6),
+                np.arange(24).reshape(2, 3, 4),
+                np.arange(24).reshape(1, 2, 3, 4),
+                np.arange(64).reshape(8, 4, 2)[::3,::2,:]]
+
+        for i in range(len(arrs)):
+            # First check `None`, the default, which is to reverse dims
+            check(arrs[i], None)
+            # Check supplied axis permutations
+            for axes in permutations(tuple(range(arrs[i].ndim))):
+                ndim = len(axes)
+                neg_axes = tuple([x - ndim for x in axes])
+                check(arrs[i], axes)
+                check(arrs[i], neg_axes)
+
+        @from_generic([transpose_issue_4708])
+        def check_issue_4708(pyfunc, m, n):
+            expected = pyfunc.py_func(m, n)
+            got = pyfunc(m, n)
+            # values in arrays are equals,
+            # but stronger assertions not hold (layout and strides equality)
+            np.testing.assert_equal(got, expected)
+
+        check_issue_4708(3, 2)
+        check_issue_4708(2, 3)
+        check_issue_4708(5, 4)
+
+        # Exceptions leak references
+        self.disable_leak_check()
+
+        check_err_invalid_args(arrs[1], "foo")
+        check_err_invalid_args(arrs[1], ("foo",))
+        check_err_invalid_args(arrs[1], 5.3)
+        check_err_invalid_args(arrs[2], (1.2, 5))
+
+        check_err_axis_repeated(arrs[1], (0, 0))
+        check_err_axis_repeated(arrs[2], (2, 0, 0))
+        check_err_axis_repeated(arrs[3], (3, 2, 1, 1))
+
+        check_err_axis_oob(arrs[0], (1,))
+        check_err_axis_oob(arrs[0], (-2,))
+        check_err_axis_oob(arrs[1], (0, 2))
+        check_err_axis_oob(arrs[1], (-3, 2))
+        check_err_axis_oob(arrs[1], (0, -3))
+        check_err_axis_oob(arrs[2], (3, 1, 2))
+        check_err_axis_oob(arrs[2], (-4, 1, 2))
+        check_err_axis_oob(arrs[3], (3, 1, 2, 5))
+        check_err_axis_oob(arrs[3], (3, 1, 2, -5))
+
+        with self.assertRaises(TypingError) as e:
+            jit(nopython=True)(numpy_transpose_array)((np.array([0, 1]),))
+        self.assertIn("np.transpose does not accept tuples",
+                        str(e.exception))
+
+    def test_numpy_resize_basic(self):
+        pyfunc = numpy_resize
+        cfunc = njit(pyfunc)
+        def inputs():
+            # Taken from https://github.com/numpy/numpy/blob/f0b2fca91a1f5f50ff696895072f6fe9e69c1466/numpy/core/tests/test_numeric.py#L24-L64  noqa: E501
+            yield np.array([[1, 2], [3, 4]]), (2, 4)
+            yield np.array([[1, 2], [3, 4]]), (4, 2)
+            yield np.array([[1, 2], [3, 4]]), (4, 3)
+            yield np.array([[1, 2], [3, 4]]), (0,)
+            yield np.array([[1, 2], [3, 4]]), (0, 2)
+            yield np.array([[1, 2], [3, 4]]), (2, 0)
+            yield np.zeros(0, dtype = float), (2, 1)
+            # other
+            yield np.array([[1, 2], [3, 4]]), (4,)
+            yield np.array([[1, 2], [3, 4]]), 4
+            yield np.zeros((1, 3), dtype = int), (2, 1)
+            yield np.array([], dtype = float), (4, 2)
+            yield [0, 1, 2, 3], (2, 3)
+            yield 4, (2, 3)
+
+        for a, new_shape in inputs():
+            self.assertPreciseEqual(pyfunc(a, new_shape), cfunc(a, new_shape))
+
+    def test_numpy_resize_exception(self):
+        # Exceptions leak references
+        self.disable_leak_check()
+
+        cfunc = njit(numpy_resize)
+
+        with self.assertRaises(TypingError) as raises:
+            cfunc("abc", (2, 3))
+        self.assertIn(('The argument "a" must be array-like'),
+                      str(raises.exception))
+
+        with self.assertRaises(TypingError) as raises:
+            cfunc(np.array([[0,1],[2,3]]), "abc")
+        self.assertIn(('The argument "new_shape" must be an integer or '
+                       'a tuple of integers'),
+                      str(raises.exception))
+
+        with self.assertRaises(ValueError) as raises:
+            cfunc(np.array([[0,1],[2,3]]), (-2, 3))
+        self.assertIn(('All elements of `new_shape` must be non-negative'),
+                      str(raises.exception))
+
+        with self.assertRaises(ValueError) as raises:
+            cfunc(np.array([[0,1],[2,3]]), -4)
+        self.assertIn(('All elements of `new_shape` must be non-negative'),
+                      str(raises.exception))
+
+    def test_expand_dims(self):
+        pyfunc = expand_dims
+        cfunc = njit(pyfunc)
+
+        def check(arr, axis):
+            expected = pyfunc(arr, axis)
+            self.memory_leak_setup()
+            got = cfunc(arr, axis)
+            self.assertPreciseEqual(got, expected)
+            del got
+            self.memory_leak_teardown()
+
+        def check_all_axes(arr):
+            for axis in range(-arr.ndim - 1, arr.ndim + 1):
+                check(arr, axis)
+
+        # 1d
+        arr = np.arange(5)
+        check_all_axes(arr)
+        # 3d (C, F, A)
+        arr = np.arange(24).reshape((2, 3, 4))
+        check_all_axes(arr)
+        check_all_axes(arr.T)
+        check_all_axes(arr[::-1])
+        # 0d
+        arr = np.array(42)
+        check_all_axes(arr)
+
+    def test_expand_dims_exceptions(self):
+        pyfunc = expand_dims
+        cfunc = jit(nopython=True)(pyfunc)
+        arr = np.arange(5)
+
+        with self.assertTypingError() as raises:
+            cfunc('hello', 3)
+        self.assertIn('First argument "a" must be an array', str(raises.exception))
+
+        with self.assertTypingError() as raises:
+            cfunc(arr, 'hello')
+        self.assertIn('Argument "axis" must be an integer', str(raises.exception))
+
+
+    def check_atleast_nd(self, pyfunc, cfunc):
+        def check_result(got, expected):
+            # We would like to check the result has the same contiguity,
+            # but we can't rely on the "flags" attribute when there are
+            # 1-sized dimensions.
+            self.assertStridesEqual(got, expected)
+            self.assertPreciseEqual(got.flatten(), expected.flatten())
+
+        def check_single(arg):
+            check_result(cfunc(arg), pyfunc(arg))
+
+        def check_tuple(*args):
+            expected_tuple = pyfunc(*args)
+            got_tuple = cfunc(*args)
+            self.assertEqual(len(got_tuple), len(expected_tuple))
+            for got, expected in zip(got_tuple, expected_tuple):
+                check_result(got, expected)
+
+        # 0d
+        a1 = np.array(42)
+        a2 = np.array(5j)
+        check_single(a1)
+        check_tuple(a1, a2)
+        # 1d
+        b1 = np.arange(5)
+        b2 = np.arange(6) + 1j
+        b3 = b1[::-1]
+        check_single(b1)
+        check_tuple(b1, b2, b3)
+        # 2d
+        c1 = np.arange(6).reshape((2, 3))
+        c2 = c1.T
+        c3 = c1[::-1]
+        check_single(c1)
+        check_tuple(c1, c2, c3)
+        # 3d
+        d1 = np.arange(24).reshape((2, 3, 4))
+        d2 = d1.T
+        d3 = d1[::-1]
+        check_single(d1)
+        check_tuple(d1, d2, d3)
+        # 4d
+        e = np.arange(16).reshape((2, 2, 2, 2))
+        check_single(e)
+        # mixed dimensions
+        check_tuple(a1, b2, c3, d2)
+
+    def test_atleast_1d(self):
+        pyfunc = atleast_1d
+        cfunc = jit(nopython=True)(pyfunc)
+        self.check_atleast_nd(pyfunc, cfunc)
+
+    def test_atleast_2d(self):
+        pyfunc = atleast_2d
+        cfunc = jit(nopython=True)(pyfunc)
+        self.check_atleast_nd(pyfunc, cfunc)
+
+    def test_atleast_3d(self):
+        pyfunc = atleast_3d
+        cfunc = jit(nopython=True)(pyfunc)
+        self.check_atleast_nd(pyfunc, cfunc)
+
+    def check_as_strided(self, pyfunc):
+        cfunc = njit(pyfunc)
+
+        def check(arr):
+            expected = pyfunc(arr)
+            got = cfunc(arr)
+            self.assertPreciseEqual(got, expected)
+
+        arr = np.arange(24)
+        check(arr)
+        check(arr.reshape((6, 4)))
+        check(arr.reshape((4, 1, 6)))
+
+    def test_as_strided(self):
+        self.check_as_strided(as_strided1)
+        self.check_as_strided(as_strided2)
+
+    def test_as_strided_stride_none(self):
+
+        @jit
+        def foo():
+            arr = np.arange(24).reshape((6, 4))
+            return np.lib.stride_tricks.as_strided(arr, strides=None)
+
+        with self.assertRaises(errors.TypingError) as raises:
+            foo()
+
+        msg = "strides argument cannot be None"
+        self.assertIn(msg, str(raises.exception))
+
+    def test_sliding_window_view(self):
+        def check(arr, window_shape, axis):
+            # Our version is always writeable (NumPy default is False).
+            expected = np.lib.stride_tricks.sliding_window_view(
+                arr, window_shape, axis, writeable=True
+            )
+            got = sliding_window_view(arr, window_shape, axis)
+            self.assertPreciseEqual(got, expected)
+
+        # 1d array, different ways of specifying the axis.
+        arr1 = np.arange(24)
+        for axis in [None, 0, -1, (0,)]:
+            with self.subTest(f"1d array, axis={axis}"):
+                check(arr1, 5, axis)
+
+        # 2d array, 1d window.
+        arr2 = np.arange(200).reshape(10, 20)
+        for axis in [0, -1]:
+            with self.subTest(f"2d array, axis={axis}"):
+                check(arr2, 5, axis)
+
+        # 2d array, 2d window.
+        for axis in [None, (0, 1), (1, 0), (1, -2)]:
+            with self.subTest(f"2d array, axis={axis}"):
+                check(arr2, (5, 8), axis)
+
+        # 4d array, 2d window.
+        arr4 = np.arange(200).reshape(4, 5, 5, 2)
+        for axis in [(1, 2), (-2, -3)]:
+            with self.subTest(f"4d array, axis={axis}"):
+                check(arr4, (3, 2), axis)
+
+        # Repeated axis.
+        with self.subTest("2d array, repeated axes"):
+            check(arr2, (5, 3, 3), (0, 1, 0))
+
+    def test_sliding_window_view_errors(self):
+        def _raises(msg, *args):
+            with self.assertRaises(ValueError) as raises:
+                sliding_window_view(*args)
+            self.assertIn(msg, str(raises.exception))
+
+        def _typing_error(msg, *args):
+            with self.assertRaises(errors.TypingError) as raises:
+                sliding_window_view(*args)
+            self.assertIn(msg, str(raises.exception))
+
+        # Exceptions leak references
+        self.disable_leak_check()
+
+        arr1 = np.arange(24)
+        arr2 = np.arange(200).reshape(10, 20)
+
+        # Window shape cannot be larger than dimension or negative.
+        with self.subTest("1d window shape too large"):
+            _raises("window_shape cannot be larger", arr1, 25, None)
+        with self.subTest("2d window shape too large"):
+            _raises("window_shape cannot be larger", arr2, (4, 21), None)
+        with self.subTest("1d window negative size"):
+            _raises("`window_shape` cannot contain negative", arr1, -1, None)
+        with self.subTest("2d window with a negative size"):
+            _raises("`window_shape` cannot contain negative", arr2, (4, -3), None)
+
+        # window_shape and axis parameters must be compatible.
+        with self.subTest("1d array, 2d window shape"):
+            _raises("matching length window_shape and axis", arr1, (10, 2), None)
+        with self.subTest("2d window shape, only one axis given"):
+            _raises("matching length window_shape and axis", arr2, (10, 2), 1)
+        with self.subTest("1d window shape, 2 axes given"):
+            _raises("matching length window_shape and axis", arr1, 5, (0, 0))
+
+        # Axis values out of bounds.
+        with self.subTest("1d array, second axis"):
+            _raises("Argument axis out of bounds", arr1, 4, 1)
+        with self.subTest("1d array, axis -2"):
+            _raises("Argument axis out of bounds", arr1, 4, -2)
+        with self.subTest("2d array, fourth axis"):
+            _raises("Argument axis out of bounds", arr2, (4, 4), (0, 3))
+        with self.subTest("2d array, axis -3"):
+            _raises("Argument axis out of bounds", arr2, (4, 4), (0, -3))
+
+        # Useful messages for unsupported types.
+        with self.subTest("window_shape=None"):
+            _typing_error(
+                "window_shape must be an integer or tuple of integer", arr1, None
+            )
+        with self.subTest("window_shape=float"):
+            _typing_error(
+                "window_shape must be an integer or tuple of integer", arr1, 3.1
+            )
+        with self.subTest("window_shape=tuple(float)"):
+            _typing_error(
+                "window_shape must be an integer or tuple of integer", arr1, (3.1,)
+            )
+        with self.subTest("axis=float"):
+            _typing_error(
+                "axis must be None, an integer or tuple of integer", arr1, 4, 3.1
+            )
+        with self.subTest("axis=tuple(float)"):
+            _typing_error(
+                "axis must be None, an integer or tuple of integer", arr1, 4, (3.1,)
+            )
+
+
+    def test_flatten_array(self, flags=enable_pyobj_flags, layout='C'):
+        a = np.arange(9).reshape(3, 3)
+        if layout == 'F':
+            a = a.T
+
+        pyfunc = flatten_array
+        arraytype1 = typeof(a)
+        if layout == 'A':
+            # Force A layout
+            arraytype1 = arraytype1.copy(layout='A')
+
+        self.assertEqual(arraytype1.layout, layout)
+        cfunc = jit((arraytype1,), **flags)(pyfunc)
+
+        expected = pyfunc(a)
+        got = cfunc(a)
+        np.testing.assert_equal(expected, got)
+
+    def test_flatten_array_npm(self):
+        self.test_flatten_array(flags=no_pyobj_flags)
+        self.test_flatten_array(flags=no_pyobj_flags, layout='F')
+        self.test_flatten_array(flags=no_pyobj_flags, layout='A')
+
+    def test_ravel_array(self, flags=enable_pyobj_flags):
+        def generic_check(pyfunc, a, assume_layout):
+            # compile
+            arraytype1 = typeof(a)
+            self.assertEqual(arraytype1.layout, assume_layout)
+            cfunc = jit((arraytype1,), **flags)(pyfunc)
+
+            expected = pyfunc(a)
+            got = cfunc(a)
+            # Check result matches
+            np.testing.assert_equal(expected, got)
+            # Check copying behavior
+            py_copied = (a.ctypes.data != expected.ctypes.data)
+            nb_copied = (a.ctypes.data != got.ctypes.data)
+            self.assertEqual(py_copied, assume_layout != 'C')
+            self.assertEqual(py_copied, nb_copied)
+
+        check_method = partial(generic_check, ravel_array)
+        check_function = partial(generic_check, numpy_ravel_array)
+
+        def check(*args, **kwargs):
+            check_method(*args, **kwargs)
+            check_function(*args, **kwargs)
+
+        # Check 2D
+        check(np.arange(9).reshape(3, 3), assume_layout='C')
+        check(np.arange(9).reshape(3, 3, order='F'), assume_layout='F')
+        check(np.arange(18).reshape(3, 3, 2)[:, :, 0], assume_layout='A')
+
+        # Check 3D
+        check(np.arange(18).reshape(2, 3, 3), assume_layout='C')
+        check(np.arange(18).reshape(2, 3, 3, order='F'), assume_layout='F')
+        check(np.arange(36).reshape(2, 3, 3, 2)[:, :, :, 0], assume_layout='A')
+
+    def test_ravel_array_size(self, flags=enable_pyobj_flags):
+        a = np.arange(9).reshape(3, 3)
+
+        pyfunc = ravel_array_size
+        arraytype1 = typeof(a)
+        cfunc = jit((arraytype1,), **flags)(pyfunc)
+
+        expected = pyfunc(a)
+        got = cfunc(a)
+        np.testing.assert_equal(expected, got)
+
+    def test_ravel_array_npm(self):
+        self.test_ravel_array(flags=no_pyobj_flags)
+
+    def test_ravel_array_size_npm(self):
+        self.test_ravel_array_size(flags=no_pyobj_flags)
+
+    def test_transpose_array(self, flags=enable_pyobj_flags):
+        @from_generic([transpose_array, numpy_transpose_array])
+        def check(pyfunc):
+            a = np.arange(9).reshape(3, 3)
+
+            arraytype1 = typeof(a)
+            cfunc = jit((arraytype1,), **flags)(pyfunc)
+
+            expected = pyfunc(a)
+            got = cfunc(a)
+            np.testing.assert_equal(expected, got)
+
+        check()
+
+    def test_transpose_array_npm(self):
+        self.test_transpose_array(flags=no_pyobj_flags)
+
+    def test_squeeze_array(self, flags=enable_pyobj_flags):
+        a = np.arange(2 * 1 * 3 * 1 * 4).reshape(2, 1, 3, 1, 4)
+
+        pyfunc = squeeze_array
+        arraytype1 = typeof(a)
+        cfunc = jit((arraytype1,), **flags)(pyfunc)
+
+        expected = pyfunc(a)
+        got = cfunc(a)
+        np.testing.assert_equal(expected, got)
+
+    def test_squeeze_array_npm(self):
+        with self.assertRaises(errors.TypingError) as raises:
+            self.test_squeeze_array(flags=no_pyobj_flags)
+
+        self.assertIn("squeeze", str(raises.exception))
+
+    def test_add_axis(self):
+        @njit
+        def np_new_axis_getitem(a, idx):
+            return a[idx]
+
+        @njit
+        def np_new_axis_setitem(a, idx, item):
+            a[idx] = item
+            return a
+
+        a = np.arange(4 * 5 * 6 * 7).reshape((4, 5, 6, 7))
+        idx_cases = [
+            (slice(None), np.newaxis),
+            (np.newaxis, slice(None)),
+            (slice(1), np.newaxis, 1),
+            (np.newaxis, 2, slice(None)),
+            (slice(1), Ellipsis, np.newaxis, 1),
+            (1, np.newaxis, Ellipsis),
+            (np.newaxis, slice(1), np.newaxis, 1),
+            (1, Ellipsis, None, np.newaxis),
+            (np.newaxis, slice(1), Ellipsis, np.newaxis, 1),
+            (1, np.newaxis, np.newaxis, Ellipsis),
+            (np.newaxis, 1, np.newaxis, Ellipsis),
+            (slice(3), 1, np.newaxis, None),
+            (np.newaxis, 1, Ellipsis, None),
+        ]
+        pyfunc_getitem = np_new_axis_getitem.py_func
+        cfunc_getitem = np_new_axis_getitem
+
+        pyfunc_setitem = np_new_axis_setitem.py_func
+        cfunc_setitem = np_new_axis_setitem
+
+        for idx in idx_cases:
+            expected = pyfunc_getitem(a, idx)
+            got = cfunc_getitem(a, idx)
+            np.testing.assert_equal(expected, got)
+
+            a_empty = np.zeros_like(a)
+            item = a[idx]
+
+            expected = pyfunc_setitem(a_empty.copy(), idx, item)
+            got = cfunc_setitem(a_empty.copy(), idx, item)
+            np.testing.assert_equal(expected, got)
+
+    def test_bad_index_npm(self):
+        with self.assertTypingError() as raises:
+            arraytype1 = from_dtype(np.dtype([('x', np.int32),
+                                              ('y', np.int32)]))
+            arraytype2 = types.Array(types.int32, 2, 'C')
+            njit((arraytype1, arraytype2))(bad_index)
+        self.assertIn('Unsupported array index type', str(raises.exception))
+
+    def test_bad_float_index_npm(self):
+        with self.assertTypingError() as raises:
+            njit((types.Array(types.float64, 2, 'C'),))(bad_float_index)
+        self.assertIn('Unsupported array index type float64',
+                      str(raises.exception))
+
+    def test_fill_diagonal_basic(self):
+        pyfunc = numpy_fill_diagonal
+        cfunc = jit(nopython=True)(pyfunc)
+
+        def _shape_variations(n):
+            # square
+            yield (n, n)
+            # tall and thin
+            yield (2 * n, n)
+            # short and fat
+            yield (n, 2 * n)
+            # a bit taller than wide; odd numbers of rows and cols
+            yield ((2 * n + 1), (2 * n - 1))
+            # 4d, all dimensions same
+            yield (n, n, n, n)
+            # weird edge case
+            yield (1, 1, 1)
+
+        def _val_variations():
+            yield 1
+            yield 3.142
+            yield np.nan
+            yield -np.inf
+            yield True
+            yield np.arange(4)
+            yield (4,)
+            yield [8, 9]
+            yield np.arange(54).reshape(9, 3, 2, 1)  # contiguous C
+            yield np.asfortranarray(np.arange(9).reshape(3, 3))  # contiguous F
+            yield np.arange(9).reshape(3, 3)[::-1]  # non-contiguous
+
+        # contiguous arrays
+        def _multi_dimensional_array_variations(n):
+            for shape in _shape_variations(n):
+                yield np.zeros(shape, dtype=np.float64)
+                yield np.asfortranarray(np.ones(shape, dtype=np.float64))
+
+        # non-contiguous arrays
+        def _multi_dimensional_array_variations_strided(n):
+            for shape in _shape_variations(n):
+                tmp = np.zeros(tuple([x * 2 for x in shape]), dtype=np.float64)
+                slicer = tuple(slice(0, x * 2, 2) for x in shape)
+                yield tmp[slicer]
+
+        def _check_fill_diagonal(arr, val):
+            for wrap in None, True, False:
+                a = arr.copy()
+                b = arr.copy()
+
+                if wrap is None:
+                    params = {}
+                else:
+                    params = {'wrap': wrap}
+
+                pyfunc(a, val, **params)
+                cfunc(b, val, **params)
+                self.assertPreciseEqual(a, b)
+
+        for arr in _multi_dimensional_array_variations(3):
+            for val in _val_variations():
+                _check_fill_diagonal(arr, val)
+
+        for arr in _multi_dimensional_array_variations_strided(3):
+            for val in _val_variations():
+                _check_fill_diagonal(arr, val)
+
+        # non-numeric input arrays
+        arr = np.array([True] * 9).reshape(3, 3)
+        _check_fill_diagonal(arr, False)
+        _check_fill_diagonal(arr, [False, True, False])
+        _check_fill_diagonal(arr, np.array([True, False, True]))
+
+    def test_fill_diagonal_exception_cases(self):
+        pyfunc = numpy_fill_diagonal
+        cfunc = jit(nopython=True)(pyfunc)
+        val = 1
+
+        # Exceptions leak references
+        self.disable_leak_check()
+
+        # first argument unsupported number of dimensions
+        for a in np.array([]), np.ones(5):
+            with self.assertRaises(TypingError) as raises:
+                cfunc(a, val)
+            assert "The first argument must be at least 2-D" in str(raises.exception)
+
+        # multi-dimensional input where dimensions are not all equal
+        with self.assertRaises(ValueError) as raises:
+            a = np.zeros((3, 3, 4))
+            cfunc(a, val)
+            self.assertEqual("All dimensions of input must be of equal length", str(raises.exception))
+
+        # cases where val has incompatible type / value
+        def _assert_raises(arr, val):
+            with self.assertRaises(ValueError) as raises:
+                cfunc(arr, val)
+            self.assertEqual("Unable to safely conform val to a.dtype", str(raises.exception))
+
+        arr = np.zeros((3, 3), dtype=np.int32)
+        val = np.nan
+        _assert_raises(arr, val)
+
+        val = [3.3, np.inf]
+        _assert_raises(arr, val)
+
+        val = np.array([1, 2, 1e10], dtype=np.int64)
+        _assert_raises(arr, val)
+
+        arr = np.zeros((3, 3), dtype=np.float32)
+        val = [1.4, 2.6, -1e100]
+        _assert_raises(arr, val)
+
+        val = 1.1e100
+        _assert_raises(arr, val)
+
+        val = np.array([-1e100])
+        _assert_raises(arr, val)
+
+    def test_broadcast_to(self):
+        pyfunc = numpy_broadcast_to
+        cfunc = jit(nopython=True)(pyfunc)
+
+        # Tests taken from
+        # https://github.com/numpy/numpy/blob/75f852edf94a7293e7982ad516bee314d7187c2d/numpy/lib/tests/test_stride_tricks.py#L234-L257  # noqa: E501
+        data = [
+            [np.array(0), (0,)],
+            [np.array(0), (1,)],
+            [np.array(0), (3,)],
+            [np.ones(1), (1,)],
+            [np.ones(1), (2,)],
+            [np.ones(1), (1, 2, 3)],
+            [np.arange(3), (3,)],
+            [np.arange(3), (1, 3)],
+            [np.arange(3), (2, 3)],
+            # test if shape is not a tuple
+            [np.ones(0), 0],
+            [np.ones(1), 1],
+            [np.ones(1), 2],
+            # these cases with size 0 are strange, but they reproduce the behavior
+            # of broadcasting with ufuncs
+            [np.ones(1), (0,)],
+            [np.ones((1, 2)), (0, 2)],
+            [np.ones((2, 1)), (2, 0)],
+            # numpy accepts scalar values as first argument to np.broadcast_to
+            [2, (2, 2)],
+            # tuple input
+            [(1, 2), (2, 2)],
+        ]
+        for input_array, shape in data:
+            expected = pyfunc(input_array, shape)
+            got = cfunc(input_array, shape)
+            self.assertPreciseEqual(got, expected)
+
+    def test_broadcast_to_0d_array(self):
+        pyfunc = numpy_broadcast_to
+        cfunc = jit(nopython=True)(pyfunc)
+
+        inputs = [
+            np.array(123),
+            123,
+            True,
+            # can't do np.asarray() on the types below
+            # 'hello',
+            # np.timedelta64(10, 'Y'),
+            # np.datetime64(10, 'Y'),
+        ]
+
+        shape = ()
+        for arr in inputs:
+            expected = pyfunc(arr, shape)
+            got = cfunc(arr, shape)
+            self.assertPreciseEqual(expected, got)
+            # ensure that np.broadcast_to returned a read-only array
+            self.assertFalse(got.flags['WRITEABLE'])
+
+    def test_broadcast_to_raises(self):
+        pyfunc = numpy_broadcast_to
+        cfunc = jit(nopython=True)(pyfunc)
+
+        # Tests taken from
+        # https://github.com/numpy/numpy/blob/75f852edf94a7293e7982ad516bee314d7187c2d/numpy/lib/tests/test_stride_tricks.py#L260-L276  # noqa: E501
+        data = [
+            [np.zeros((0,)), (), TypingError,
+             'Cannot broadcast a non-scalar to a scalar array'],
+            [np.zeros((1,)), (), TypingError,
+             'Cannot broadcast a non-scalar to a scalar array'],
+            [np.zeros((3,)), (), TypingError,
+             'Cannot broadcast a non-scalar to a scalar array'],
+            [(), (), TypingError,
+             'Cannot broadcast a non-scalar to a scalar array'],
+            [(123,), (), TypingError,
+             'Cannot broadcast a non-scalar to a scalar array'],
+            [np.zeros((3,)), (1,), ValueError,
+             'operands could not be broadcast together with remapped shapes'],
+            [np.zeros((3,)), (2,), ValueError,
+             'operands could not be broadcast together with remapped shapes'],
+            [np.zeros((3,)), (4,), ValueError,
+             'operands could not be broadcast together with remapped shapes'],
+            [np.zeros((1, 2)), (2, 1), ValueError,
+             'operands could not be broadcast together with remapped shapes'],
+            [np.zeros((1, 1)), (1,), ValueError,
+             'input operand has more dimensions than allowed by the axis remapping'],
+            [np.zeros((2, 2)), (3,), ValueError,
+             'input operand has more dimensions than allowed by the axis remapping'],
+            [np.zeros((1,)), -1, ValueError,
+             'all elements of broadcast shape must be non-negative'],
+            [np.zeros((1,)), (-1,), ValueError,
+             'all elements of broadcast shape must be non-negative'],
+            [np.zeros((1, 2)), (-1, 2), ValueError,
+             'all elements of broadcast shape must be non-negative'],
+            [np.zeros((1, 2)), (1.1, 2.2), TypingError,
+             'The second argument "shape" must be a tuple of integers'],
+            ['hello', (3,), TypingError,
+             'The first argument "array" must be array-like'],
+            [3, (2, 'a'), TypingError,
+             'object cannot be interpreted as an integer'],
+        ]
+        self.disable_leak_check()
+        for arr, target_shape, err, msg in data:
+            with self.assertRaises(err) as raises:
+                cfunc(arr, target_shape)
+            self.assertIn(msg, str(raises.exception))
+
+    def test_broadcast_to_corner_cases(self):
+        @njit
+        def _broadcast_to_1():
+            return np.broadcast_to('a', (2, 3))
+
+        expected = _broadcast_to_1.py_func()
+        got = _broadcast_to_1()
+        self.assertPreciseEqual(expected, got)
+
+    def test_broadcast_to_change_view(self):
+        pyfunc = numpy_broadcast_to
+        cfunc = jit(nopython=True)(pyfunc)
+        input_array = np.zeros(2, dtype=np.int32)
+        shape = (2, 2)
+        view = cfunc(input_array, shape)
+        input_array[0] = 10
+
+        self.assertEqual(input_array.sum(), 10)
+        self.assertEqual(view.sum(), 20)
+
+    def test_broadcast_to_indexing(self):
+        pyfunc = numpy_broadcast_to_indexing
+        cfunc = jit(nopython=True)(pyfunc)
+        data = [
+            [np.ones(2), (2, 2), (1,)],
+        ]
+        for input_array, shape, idx in data:
+            expected = pyfunc(input_array, shape, idx)
+            got = cfunc(input_array, shape, idx)
+            self.assertPreciseEqual(got, expected)
+
+    def test_broadcast_to_array_attrs(self):
+        # See issue #8534. This tests that broadcast array attributes have the
+        # correct value when accessed.
+        @njit
+        def foo(arr):
+            ret = np.broadcast_to(arr, (2, 3))
+            return ret, ret.size, ret.shape, ret.strides
+
+        arr = np.arange(3)
+
+        expected = foo.py_func(arr)
+        got = foo(arr)
+        self.assertPreciseEqual(expected, got)
+
+    def test_broadcast_shapes(self):
+        pyfunc = numpy_broadcast_shapes
+        cfunc = jit(nopython=True)(pyfunc)
+
+        # Tests taken from
+        # https://github.com/numpy/numpy/blob/623bc1fae1d47df24e7f1e29321d0c0ba2771ce0/numpy/lib/tests/test_stride_tricks.py#L296-L334
+        data = [
+            # [[], ()],  # cannot compute fingerprint of empty list
+            [()],
+            [(), ()],
+            [(7,)],
+            [(1, 2),],
+            [(1, 1)],
+            [(1, 1), (3, 4)],
+            [(6, 7), (5, 6, 1), (7,), (5, 1, 7)],
+            [(5, 6, 1)],
+            [(1, 3), (3, 1)],
+            [(1, 0), (0, 0)],
+            [(0, 1), (0, 0)],
+            [(1, 0), (0, 1)],
+            [(1, 1), (0, 0)],
+            [(1, 1), (1, 0)],
+            [(1, 1), (0, 1)],
+            [(), (0,)],
+            [(0,), (0, 0)],
+            [(0,), (0, 1)],
+            [(1,), (0, 0)],
+            [(), (0, 0)],
+            [(1, 1), (0,)],
+            [(1,), (0, 1)],
+            [(1,), (1, 0)],
+            [(), (1, 0)],
+            [(), (0, 1)],
+            [(1,), (3,)],
+            [2, (3, 2)],
+        ]
+        for input_shape in data:
+            expected = pyfunc(*input_shape)
+            got = cfunc(*input_shape)
+            self.assertIsInstance(got, tuple)
+            self.assertPreciseEqual(expected, got)
+
+    def test_broadcast_shapes_raises(self):
+        pyfunc = numpy_broadcast_shapes
+        cfunc = jit(nopython=True)(pyfunc)
+
+        self.disable_leak_check()
+
+        # Tests taken from
+        # https://github.com/numpy/numpy/blob/623bc1fae1d47df24e7f1e29321d0c0ba2771ce0/numpy/lib/tests/test_stride_tricks.py#L337-L351
+        data = [
+            [(3,), (4,)],
+            [(2, 3), (2,)],
+            [(3,), (3,), (4,)],
+            [(1, 3, 4), (2, 3, 3)],
+            [(1, 2), (3, 1), (3, 2), (10, 5)],
+            [2, (2, 3)],
+        ]
+        for input_shape in data:
+            with self.assertRaises(ValueError) as raises:
+                cfunc(*input_shape)
+
+            self.assertIn("shape mismatch: objects cannot be broadcast to a single shape",
+                          str(raises.exception))
+
+    def test_broadcast_shapes_negative_dimension(self):
+        pyfunc = numpy_broadcast_shapes
+        cfunc = jit(nopython=True)(pyfunc)
+
+        self.disable_leak_check()
+        with self.assertRaises(ValueError) as raises:
+            cfunc((1, 2), (2), (-2))
+
+        self.assertIn("negative dimensions are not allowed", str(raises.exception))
+
+    def test_broadcast_shapes_invalid_type(self):
+        pyfunc = numpy_broadcast_shapes
+        cfunc = jit(nopython=True)(pyfunc)
+
+        self.disable_leak_check()
+
+        inps = [
+            ((1, 2), ('hello',)),
+            (3.4,),
+            ('string',),
+            ((1.2, 'a')),
+            (1, ((1.2, 'a'))),
+        ]
+
+        for inp in inps:
+            with self.assertRaises(TypingError) as raises:
+                cfunc(*inp)
+
+            self.assertIn("must be either an int or tuple[int]", str(raises.exception))
+
+    def test_shape(self):
+        pyfunc = numpy_shape
+        cfunc = jit(nopython=True)(pyfunc)
+
+        def check(x):
+            expected = pyfunc(x)
+            got = cfunc(x)
+            self.assertPreciseEqual(got, expected)
+
+        # check arrays
+        for t in [(), (1,), (2, 3,), (4, 5, 6)]:
+            arr = np.empty(t)
+            check(arr)
+
+        # check some types that go via asarray
+        for t in [1, False, [1,], [[1, 2,],[3, 4]], (1,), (1, 2, 3)]:
+            check(arr)
+
+        with self.assertRaises(TypingError) as raises:
+            cfunc('a')
+
+        self.assertIn("The argument to np.shape must be array-like",
+                      str(raises.exception))
+
+    def test_size(self):
+        pyfunc = numpy_size
+        cfunc = jit(nopython=True)(pyfunc)
+
+        def check(x):
+            expected = pyfunc(x)
+            got = cfunc(x)
+            self.assertPreciseEqual(got, expected)
+
+        # check arrays
+        for t in [(), (1,), (2, 3,), (4, 5, 6)]:
+            arr = np.empty(t)
+            check(arr)
+
+        # check scalar values
+        for t in [1, False, 3.14, np.int8(4), np.float32(2.718)]:
+            check(t)
+
+        with self.assertRaises(TypingError) as raises:
+            cfunc('a')
+
+        self.assertIn("The argument to np.size must be array-like",
+                      str(raises.exception))
+
+    def test_flatnonzero_basic(self):
+        pyfunc = numpy_flatnonzero
+        cfunc = jit(nopython=True)(pyfunc)
+
+        def a_variations():
+            yield np.arange(-5, 5)
+            yield np.full(5, fill_value=0)
+            yield np.array([])
+            a = self.random.randn(100)
+            a[np.abs(a) > 0.2] = 0.0
+            yield a
+            yield a.reshape(5, 5, 4)
+            yield a.reshape(50, 2, order='F')
+            yield a.reshape(25, 4)[1::2]
+            yield a * 1j
+
+        for a in a_variations():
+            expected = pyfunc(a)
+            got = cfunc(a)
+            self.assertPreciseEqual(expected, got)
+
+    def test_argwhere_basic(self):
+        pyfunc = numpy_argwhere
+        cfunc = jit(nopython=True)(pyfunc)
+
+        def a_variations():
+            yield np.arange(-5, 5) > 2
+            yield np.full(5, fill_value=0)
+            yield np.full(5, fill_value=1)
+            yield np.array([])
+            yield np.array([-1.0, 0.0, 1.0])
+            a = self.random.randn(100)
+            yield a > 0.2
+            yield a.reshape(5, 5, 4) > 0.5
+            yield a.reshape(50, 2, order='F') > 0.5
+            yield a.reshape(25, 4)[1::2] > 0.5
+            yield a == a - 1
+            yield a > -a
+
+        for a in a_variations():
+            expected = pyfunc(a)
+            got = cfunc(a)
+            self.assertPreciseEqual(expected, got)
+
+    @staticmethod
+    def array_like_variations():
+        yield ((1.1, 2.2), (3.3, 4.4), (5.5, 6.6))
+        yield (0.0, 1.0, 0.0, -6.0)
+        yield ([0, 1], [2, 3])
+        yield ()
+        yield np.nan
+        yield 0
+        yield 1
+        yield False
+        yield True
+        yield (True, False, True)
+        yield 2 + 1j
+        # the following are not array-like, but NumPy does not raise
+        yield None
+        yield 'a_string'
+        yield ''
+
+
+    def test_flatnonzero_array_like(self):
+        pyfunc = numpy_flatnonzero
+        cfunc = jit(nopython=True)(pyfunc)
+
+        for a in self.array_like_variations():
+            expected = pyfunc(a)
+            got = cfunc(a)
+            self.assertPreciseEqual(expected, got)
+
+    def test_argwhere_array_like(self):
+        pyfunc = numpy_argwhere
+        cfunc = jit(nopython=True)(pyfunc)
+        for a in self.array_like_variations():
+            expected = pyfunc(a)
+            got = cfunc(a)
+            self.assertPreciseEqual(expected, got)
+
+    def broadcast_arrays_assert_correct_shape(self, input_shapes, expected_shape):
+        # Broadcast a list of arrays with the given input shapes and check the
+        # common output shape.
+        pyfunc = numpy_broadcast_arrays
+        cfunc = jit(nopython=True)(pyfunc)
+
+        inarrays = [np.zeros(s) for s in input_shapes]
+        outarrays = cfunc(*inarrays)
+        expected = [expected_shape] * len(inarrays)
+        got = [a.shape for a in outarrays]
+        self.assertPreciseEqual(expected, got)
+
+    def test_broadcast_arrays_same_input_shapes(self):
+        # Tests taken from
+        # https://github.com/numpy/numpy/blob/623bc1fae1d47df24e7f1e29321d0c0ba2771ce0/numpy/lib/tests/test_stride_tricks.py#L83-L107  # noqa: E501
+        # Check that the final shape is just the input shape.
+        pyfunc = numpy_broadcast_arrays
+        cfunc = jit(nopython=True)(pyfunc)
+
+        data = [
+            # (),
+            (1,),
+            (3,),
+            (0, 1),
+            (0, 3),
+            (1, 0),
+            (3, 0),
+            (1, 3),
+            (3, 1),
+            (3, 3),
+        ]
+        for shape in data:
+            input_shapes = [shape]
+            # Single input.
+            self.broadcast_arrays_assert_correct_shape(input_shapes, shape)
+            # Double input.
+            input_shapes2 = [shape, shape]
+            self.broadcast_arrays_assert_correct_shape(input_shapes2, shape)
+            # Triple input.
+            input_shapes3 = [shape, shape, shape]
+            self.broadcast_arrays_assert_correct_shape(input_shapes3, shape)
+
+    def test_broadcast_arrays_two_compatible_by_ones_input_shapes(self):
+        # Tests taken from
+        # https://github.com/numpy/numpy/blob/623bc1fae1d47df24e7f1e29321d0c0ba2771ce0/numpy/lib/tests/test_stride_tricks.py#L110-L132
+        # Check that two different input shapes of the same length, but some have
+        # ones, broadcast to the correct shape.
+
+        data = [
+            [[(1,), (3,)], (3,)],
+            [[(1, 3), (3, 3)], (3, 3)],
+            [[(3, 1), (3, 3)], (3, 3)],
+            [[(1, 3), (3, 1)], (3, 3)],
+            [[(1, 1), (3, 3)], (3, 3)],
+            [[(1, 1), (1, 3)], (1, 3)],
+            [[(1, 1), (3, 1)], (3, 1)],
+            [[(1, 0), (0, 0)], (0, 0)],
+            [[(0, 1), (0, 0)], (0, 0)],
+            [[(1, 0), (0, 1)], (0, 0)],
+            [[(1, 1), (0, 0)], (0, 0)],
+            [[(1, 1), (1, 0)], (1, 0)],
+            [[(1, 1), (0, 1)], (0, 1)],
+        ]
+        for input_shapes, expected_shape in data:
+            self.broadcast_arrays_assert_correct_shape(input_shapes, expected_shape)
+            # Reverse the input shapes since broadcasting should be symmetric.
+            self.broadcast_arrays_assert_correct_shape(input_shapes[::-1], expected_shape)
+
+    def test_broadcast_arrays_two_compatible_by_prepending_ones_input_shapes(self):
+        # Tests taken from
+        # https://github.com/numpy/numpy/blob/623bc1fae1d47df24e7f1e29321d0c0ba2771ce0/numpy/lib/tests/test_stride_tricks.py#L135-L164
+        # Check that two different input shapes (of different lengths) broadcast
+        # to the correct shape.
+
+        data = [
+            [[(), (3,)], (3,)],
+            [[(3,), (3, 3)], (3, 3)],
+            [[(3,), (3, 1)], (3, 3)],
+            [[(1,), (3, 3)], (3, 3)],
+            [[(), (3, 3)], (3, 3)],
+            [[(1, 1), (3,)], (1, 3)],
+            [[(1,), (3, 1)], (3, 1)],
+            [[(1,), (1, 3)], (1, 3)],
+            [[(), (1, 3)], (1, 3)],
+            [[(), (3, 1)], (3, 1)],
+            [[(), (0,)], (0,)],
+            [[(0,), (0, 0)], (0, 0)],
+            [[(0,), (0, 1)], (0, 0)],
+            [[(1,), (0, 0)], (0, 0)],
+            [[(), (0, 0)], (0, 0)],
+            [[(1, 1), (0,)], (1, 0)],
+            [[(1,), (0, 1)], (0, 1)],
+            [[(1,), (1, 0)], (1, 0)],
+            [[(), (1, 0)], (1, 0)],
+            [[(), (0, 1)], (0, 1)],
+        ]
+        for input_shapes, expected_shape in data:
+            self.broadcast_arrays_assert_correct_shape(input_shapes, expected_shape)
+            # Reverse the input shapes since broadcasting should be symmetric.
+            self.broadcast_arrays_assert_correct_shape(input_shapes[::-1], expected_shape)
+
+    def test_broadcast_arrays_scalar_input(self):
+        pyfunc = numpy_broadcast_arrays
+        cfunc = jit(nopython=True)(pyfunc)
+        data = [
+            [[True, False], (1,)],
+            [[1, 2], (1,)],
+            [[(1, 2), 2], (2,)],
+        ]
+        for inarrays, expected_shape in data:
+            outarrays = cfunc(*inarrays)
+            got = [a.shape for a in outarrays]
+            expected = [expected_shape] * len(inarrays)
+            self.assertPreciseEqual(expected, got)
+
+    def test_broadcast_arrays_tuple_input(self):
+        pyfunc = numpy_broadcast_arrays
+        cfunc = jit(nopython=True)(pyfunc)
+        outarrays = cfunc((123, 456), (789,))
+        expected = [(2,), (2,)]
+        got = [a.shape for a in outarrays]
+        self.assertPreciseEqual(expected, got)
+
+    def test_broadcast_arrays_non_array_input(self):
+        pyfunc = numpy_broadcast_arrays
+        cfunc = jit(nopython=True)(pyfunc)
+        outarrays = cfunc(np.intp(2), np.zeros((1, 3), dtype=np.intp))
+        expected = [(1, 3), (1, 3)]
+        got = [a.shape for a in outarrays]
+        self.assertPreciseEqual(expected, got)
+
+    def test_broadcast_arrays_invalid_mixed_input_types(self):
+        pyfunc = numpy_broadcast_arrays
+        cfunc = jit(nopython=True)(pyfunc)
+
+        self.disable_leak_check()
+
+        with self.assertRaises(TypingError) as raises:
+            arr = np.arange(6).reshape((2, 3))
+            b = True
+            cfunc(arr, b)
+        self.assertIn('Mismatch of argument types', str(raises.exception))
+
+    def test_broadcast_arrays_invalid_input(self):
+        pyfunc = numpy_broadcast_arrays
+        cfunc = jit(nopython=True)(pyfunc)
+
+        self.disable_leak_check()
+
+        with self.assertRaises(TypingError) as raises:
+            arr = np.zeros(3, dtype=np.int64)
+            s = 'hello world'
+            cfunc(arr, s)
+        self.assertIn('Argument "1" must be array-like', str(raises.exception))
+
+    def test_broadcast_arrays_incompatible_shapes_raise_valueerror(self):
+        # Check that a ValueError is raised for incompatible shapes.
+        pyfunc = numpy_broadcast_arrays
+        cfunc = jit(nopython=True)(pyfunc)
+
+        self.disable_leak_check()
+
+        data = [
+            [(3,), (4,)],
+            [(2, 3), (2,)],
+            [(3,), (3,), (4,)],
+            [(1, 3, 4), (2, 3, 3)],
+        ]
+        for input_shapes in data:
+            for shape in [input_shapes, input_shapes[::-1]]:
+                # Reverse the input shapes since broadcasting should be symmetric.
+                with self.assertRaises(ValueError) as raises:
+                    inarrays = [np.zeros(s) for s in shape]
+                    cfunc(*inarrays)
+                self.assertIn("shape mismatch: objects cannot be broadcast to a single shape",
+                              str(raises.exception))
+
+    def test_readonly_after_flatten(self):
+        # Reproduces Issue #8370
+        def unfold_flatten(x, y):
+            r, c = x.shape
+            a = np.broadcast_to(x, (y, r, c))
+            b = np.swapaxes(a, 0, 1)
+            cc = b.flatten()
+            d = np.reshape(cc, (-1, c))
+            d[y - 1:, :] = d[: 1 - y]
+            return d
+
+        pyfunc = unfold_flatten
+        cfunc = jit(nopython=True)(pyfunc)
+
+        # If issue #8370 is not fixed: This will fail.
+        res_nb = cfunc(np.array([[1, 1, 1], [2, 2, 2], [3, 3, 3]]), 2)
+        res_py = pyfunc(np.array([[1, 1, 1], [2, 2, 2], [3, 3, 3]]), 2)
+
+        np.testing.assert_array_equal(res_py, res_nb)
+
+    def test_readonly_after_ravel(self):
+        # Reproduces another suggested problem in Issue #8370
+        def unfold_ravel(x, y):
+            r, c = x.shape
+            a = np.broadcast_to(x, (y, r, c))
+            b = np.swapaxes(a, 0, 1)
+            cc = b.ravel()
+            d = np.reshape(cc, (-1, c))
+            d[y - 1:, :] = d[: 1 - y]
+            return d
+
+        pyfunc = unfold_ravel
+        cfunc = jit(nopython=True)(pyfunc)
+
+        # If issue #8370 is not fixed: This will fail.
+        res_nb = cfunc(np.array([[1, 1, 1], [2, 2, 2], [3, 3, 3]]), 2)
+        res_py = pyfunc(np.array([[1, 1, 1], [2, 2, 2], [3, 3, 3]]), 2)
+
+        np.testing.assert_array_equal(res_py, res_nb)
+
+    def test_mutability_after_ravel(self):
+        # Reproduces another suggested problem in Issue #8370
+        # Namely that ravel should only return a writable array
+        # if a copy took place... otherwise leave it as it is.
+        self.disable_leak_check()
+        a_c = np.arange(9).reshape((3, 3)).copy()
+        a_f = a_c.copy(order='F')
+        a_c.flags.writeable = False
+        a_f.flags.writeable = False
+
+        def try_ravel_w_copy(a):
+            result = a.ravel()
+            return result
+
+        pyfunc = try_ravel_w_copy
+        cfunc = jit(nopython=True)(pyfunc)
+
+        ret_c = cfunc(a_c)
+        ret_f = cfunc(a_f)
+
+        msg = 'No copy was performed, so the ' \
+              'resulting array must not be writeable'
+        self.assertTrue(not ret_c.flags.writeable, msg)
+
+        msg = 'A copy was performed, yet the resulting array is not modifiable'
+        self.assertTrue(ret_f.flags.writeable, msg)
+
+
+if __name__ == '__main__':
+    unittest.main()

lib/python3.10/site-packages/numba/tests/test_asnumbatype.py

@@ -0,0 +1,170 @@
+"""
+Tests for the as_numba_type() machinery.
+"""
+import typing as py_typing
+
+
+import unittest
+
+from numba.core import types
+from numba.core.errors import TypingError
+from numba.core.typing.typeof import typeof
+from numba.core.typing.asnumbatype import as_numba_type, AsNumbaTypeRegistry
+from numba.experimental.jitclass import jitclass
+from numba.tests.support import TestCase
+
+
+class TestAsNumbaType(TestCase):
+
+    int_nb_type = typeof(0)
+    float_nb_type = typeof(0.0)
+    complex_nb_type = typeof(complex(0))
+    str_nb_type = typeof("numba")
+    bool_nb_type = typeof(True)
+    none_nb_type = typeof(None)
+
+    def test_simple_types(self):
+        self.assertEqual(as_numba_type(int), self.int_nb_type)
+        self.assertEqual(as_numba_type(float), self.float_nb_type)
+        self.assertEqual(as_numba_type(complex), self.complex_nb_type)
+        self.assertEqual(as_numba_type(str), self.str_nb_type)
+        self.assertEqual(as_numba_type(bool), self.bool_nb_type)
+        self.assertEqual(as_numba_type(type(None)), self.none_nb_type)
+
+    def test_numba_types(self):
+        numba_types = [
+            types.intp,
+            types.boolean,
+            types.ListType(types.float64),
+            types.DictType(
+                types.intp, types.Tuple([types.float32, types.float32])
+            ),
+        ]
+
+        for ty in numba_types:
+            self.assertEqual(as_numba_type(ty), ty)
+
+    def test_single_containers(self):
+        self.assertEqual(
+            as_numba_type(py_typing.List[float]),
+            types.ListType(self.float_nb_type),
+        )
+        self.assertEqual(
+            as_numba_type(py_typing.Dict[float, str]),
+            types.DictType(self.float_nb_type, self.str_nb_type),
+        )
+        self.assertEqual(
+            as_numba_type(py_typing.Set[complex]),
+            types.Set(self.complex_nb_type),
+        )
+        self.assertEqual(
+            as_numba_type(py_typing.Tuple[float, float]),
+            types.Tuple([self.float_nb_type, self.float_nb_type]),
+        )
+        self.assertEqual(
+            as_numba_type(py_typing.Tuple[float, complex]),
+            types.Tuple([self.float_nb_type, self.complex_nb_type]),
+        )
+
+    def test_optional(self):
+        self.assertEqual(
+            as_numba_type(py_typing.Optional[float]),
+            types.Optional(self.float_nb_type),
+        )
+        self.assertEqual(
+            as_numba_type(py_typing.Union[str, None]),
+            types.Optional(self.str_nb_type),
+        )
+        self.assertEqual(
+            as_numba_type(py_typing.Union[None, bool]),
+            types.Optional(self.bool_nb_type),
+        )
+
+        # Optional[x] is a special case of Union[x, None].  We raise a
+        # TypingError if the right type is not NoneType.
+        with self.assertRaises(TypingError) as raises:
+            as_numba_type(py_typing.Union[int, float])
+        self.assertIn("Cannot type Union that is not an Optional",
+                      str(raises.exception))
+
+    def test_nested_containers(self):
+        IntList = py_typing.List[int]
+        self.assertEqual(
+            as_numba_type(py_typing.List[IntList]),
+            types.ListType(types.ListType(self.int_nb_type)),
+        )
+        self.assertEqual(
+            as_numba_type(py_typing.List[py_typing.Dict[float, bool]]),
+            types.ListType(
+                types.DictType(self.float_nb_type, self.bool_nb_type)
+            ),
+        )
+        self.assertEqual(
+            as_numba_type(
+                py_typing.Set[py_typing.Tuple[py_typing.Optional[int], float]]),
+            types.Set(types.Tuple(
+                [types.Optional(self.int_nb_type), self.float_nb_type])),
+        )
+
+    def test_jitclass_registers(self):
+
+        @jitclass
+        class MyInt:
+            x: int
+
+            def __init__(self, value):
+                self.x = value
+
+        self.assertEqual(as_numba_type(MyInt), MyInt.class_type.instance_type)
+
+    def test_type_alias(self):
+        Pair = py_typing.Tuple[int, int]
+        ListOfPairs = py_typing.List[Pair]
+
+        pair_nb_type = types.Tuple((self.int_nb_type, self.int_nb_type))
+        self.assertEqual(as_numba_type(Pair), pair_nb_type)
+        self.assertEqual(
+            as_numba_type(ListOfPairs), types.ListType(pair_nb_type)
+        )
+
+    def test_overwrite_type(self):
+        as_numba_type = AsNumbaTypeRegistry()
+        self.assertEqual(as_numba_type(float), self.float_nb_type)
+        as_numba_type.register(float, types.float32)
+        self.assertEqual(as_numba_type(float), types.float32)
+        self.assertNotEqual(as_numba_type(float), self.float_nb_type)
+
+    def test_any_throws(self):
+        Any = py_typing.Any
+
+        any_types = [
+            py_typing.Optional[Any],
+            py_typing.List[Any],
+            py_typing.Set[Any],
+            py_typing.Dict[float, Any],
+            py_typing.Dict[Any, float],
+            py_typing.Tuple[int, Any],
+        ]
+
+        for bad_py_type in any_types:
+            with self.assertRaises(TypingError) as raises:
+                as_numba_type(bad_py_type)
+            self.assertIn(
+                "Cannot infer numba type of python type",
+                str(raises.exception),
+            )
+
+    def test_bad_union_throws(self):
+        bad_unions = [
+            py_typing.Union[str, int],
+            py_typing.Union[int, type(None), py_typing.Tuple[bool, bool]],
+        ]
+
+        for bad_py_type in bad_unions:
+            with self.assertRaises(TypingError) as raises:
+                as_numba_type(bad_py_type)
+            self.assertIn("Cannot type Union", str(raises.exception))
+
+
+if __name__ == '__main__':
+    unittest.main()

lib/python3.10/site-packages/numba/tests/test_auto_constants.py

@@ -0,0 +1,38 @@
+import math
+import sys
+
+import numpy as np
+
+from numba import njit
+import numba.tests.usecases as uc
+import unittest
+
+
+class TestAutoConstants(unittest.TestCase):
+    def test_numpy_nan(self):
+
+        @njit
+        def f():
+            return np.nan
+
+        self.assertTrue(math.isnan(f()))
+        self.assertTrue(math.isnan(f.py_func()))
+
+    def test_sys_constant(self):
+
+        @njit
+        def f():
+            return sys.hexversion
+
+        self.assertEqual(f(), f.py_func())
+
+    def test_module_string_constant(self):
+
+        @njit
+        def f():
+            return uc._GLOBAL_STR
+        self.assertEqual(f(), f.py_func())
+
+
+if __name__ == '__main__':
+    unittest.main()

lib/python3.10/site-packages/numba/tests/test_boundscheck.py

@@ -0,0 +1,268 @@
+import numpy as np
+
+from numba.cuda.testing import SerialMixin
+from numba import typeof, cuda, njit
+from numba.core.types import float64
+from numba.tests.support import TestCase, MemoryLeakMixin
+from numba.core import config
+import unittest
+
+
+def basic_array_access(a):
+    return a[10]
+
+
+def slice_array_access(a):
+    # The first index (slice) is not bounds checked
+    return a[10:, 10]
+
+
+def fancy_array_access(x):
+    a = np.array([1, 2, 3])
+    return x[a]
+
+
+def fancy_array_modify(x):
+    a = np.array([1, 2, 3])
+    x[a] = 0
+    return x
+
+
+class TestBoundsCheckNoError(MemoryLeakMixin, TestCase):
+
+    @TestCase.run_test_in_subprocess(envvars={'NUMBA_BOUNDSCHECK': ''})
+    def test_basic_array_boundscheck(self):
+        self.assertIsNone(config.BOUNDSCHECK)
+
+        a = np.arange(5)
+        # Check the numpy behavior to make sure the test is correct
+        with self.assertRaises(IndexError):
+            # TODO: When we raise the same error message as numpy, test that
+            # they are the same
+            basic_array_access(a)
+
+        at = typeof(a)
+        noboundscheck = njit((at,))(basic_array_access)
+        # Check that the default flag doesn't raise
+        noboundscheck(a)
+        # boundscheck(a) is tested in TestBoundsCheckError below
+
+    @TestCase.run_test_in_subprocess(envvars={'NUMBA_BOUNDSCHECK': ''})
+    def test_slice_array_boundscheck(self):
+        self.assertIsNone(config.BOUNDSCHECK)
+
+        a = np.ones((5, 5))
+        b = np.ones((5, 20))
+        with self.assertRaises(IndexError):
+            # TODO: When we raise the same error message as numpy, test that
+            # they are the same
+            slice_array_access(a)
+        # Out of bounds on a slice doesn't raise
+        slice_array_access(b)
+
+        at = typeof(a)
+        rt = float64[:]
+        noboundscheck = njit(rt(at))(slice_array_access)
+        boundscheck = njit(rt(at), boundscheck=True)(slice_array_access)
+        # Check that the default flag doesn't raise
+        noboundscheck(a)
+        noboundscheck(b)
+        # boundscheck(a) is tested in TestBoundsCheckError below
+
+        # Doesn't raise
+        boundscheck(b)
+
+    @TestCase.run_test_in_subprocess(envvars={'NUMBA_BOUNDSCHECK': ''})
+    def test_fancy_indexing_boundscheck(self):
+        self.assertIsNone(config.BOUNDSCHECK)
+
+        a = np.arange(3)
+        b = np.arange(4)
+
+        # Check the numpy behavior to ensure the test is correct.
+        with self.assertRaises(IndexError):
+            # TODO: When we raise the same error message as numpy, test that
+            # they are the same
+            fancy_array_access(a)
+        fancy_array_access(b)
+
+        at = typeof(a)
+        rt = at.dtype[:]
+        noboundscheck = njit(rt(at))(fancy_array_access)
+        boundscheck = njit(rt(at), boundscheck=True)(fancy_array_access)
+        # Check that the default flag doesn't raise
+        noboundscheck(a)
+        noboundscheck(b)
+        # boundscheck(a) is tested in TestBoundsCheckError below
+
+        # Doesn't raise
+        boundscheck(b)
+
+
+class TestNoCudaBoundsCheck(SerialMixin, TestCase):
+    @unittest.skipIf(not cuda.is_available(), "NO CUDA")
+    @TestCase.run_test_in_subprocess(envvars={'NUMBA_BOUNDSCHECK': '1'})
+    def test_no_cuda_boundscheck(self):
+        self.assertTrue(config.BOUNDSCHECK)
+        with self.assertRaises(NotImplementedError):
+            @cuda.jit(boundscheck=True)
+            def func():
+                pass
+
+        # Make sure we aren't raising "not supported" error if we aren't
+        # requesting bounds checking anyway. Related pull request: #5257
+        @cuda.jit(boundscheck=False)
+        def func3():
+            pass
+
+        @cuda.jit
+        def func2(x, a):
+            a[1] = x[1]
+
+        a = np.ones((1,))
+        x = np.zeros((1,))
+        # Out of bounds but doesn't raise (it does raise in the simulator,
+        # so skip there)
+        if not config.ENABLE_CUDASIM:
+            func2[1, 1](x, a)
+
+
+# This is a separate test because the jitted functions that raise exceptions
+# have memory leaks.
+class TestBoundsCheckError(TestCase):
+    @TestCase.run_test_in_subprocess(envvars={'NUMBA_BOUNDSCHECK': ''})
+    def test_basic_array_boundscheck(self):
+        self.assertIsNone(config.BOUNDSCHECK)
+
+        a = np.arange(5)
+        # Check the numpy behavior to make sure the test is correct
+        with self.assertRaises(IndexError):
+            # TODO: When we raise the same error message as numpy, test that
+            # they are the same
+            basic_array_access(a)
+
+        at = typeof(a)
+        boundscheck = njit((at,), boundscheck=True)(basic_array_access)
+
+        with self.assertRaises(IndexError):
+            boundscheck(a)
+
+    @TestCase.run_test_in_subprocess(envvars={'NUMBA_BOUNDSCHECK': ''})
+    def test_slice_array_boundscheck(self):
+        self.assertIsNone(config.BOUNDSCHECK)
+
+        a = np.ones((5, 5))
+        b = np.ones((5, 20))
+        with self.assertRaises(IndexError):
+            # TODO: When we raise the same error message as numpy, test that
+            # they are the same
+            slice_array_access(a)
+        # Out of bounds on a slice doesn't raise
+        slice_array_access(b)
+
+        at = typeof(a)
+        rt = float64[:]
+        boundscheck = njit(rt(at), boundscheck=True)(slice_array_access)
+
+        with self.assertRaises(IndexError):
+            boundscheck(a)
+
+    @TestCase.run_test_in_subprocess(envvars={'NUMBA_BOUNDSCHECK': ''})
+    def test_fancy_indexing_boundscheck(self):
+        self.assertIsNone(config.BOUNDSCHECK)
+
+        a = np.arange(3)
+        b = np.arange(4)
+
+        # Check the numpy behavior to ensure the test is correct.
+        with self.assertRaises(IndexError):
+            # TODO: When we raise the same error message as numpy, test that
+            # they are the same
+            fancy_array_access(a)
+        fancy_array_access(b)
+
+        at = typeof(a)
+        rt = at.dtype[:]
+        boundscheck = njit(rt(at), boundscheck=True)(fancy_array_access)
+
+        with self.assertRaises(IndexError):
+            boundscheck(a)
+
+    @TestCase.run_test_in_subprocess(envvars={'NUMBA_BOUNDSCHECK': ''})
+    def test_fancy_indexing_with_modification_boundscheck(self):
+        self.assertIsNone(config.BOUNDSCHECK)
+
+        a = np.arange(3)
+        b = np.arange(4)
+
+        # Check the numpy behavior to ensure the test is correct.
+        with self.assertRaises(IndexError):
+            # TODO: When we raise the same error message as numpy, test that
+            # they are the same
+            fancy_array_modify(a)
+        fancy_array_modify(b)
+
+        at = typeof(a)
+        rt = at.dtype[:]
+        boundscheck = njit(rt(at), boundscheck=True)(fancy_array_modify)
+
+        with self.assertRaises(IndexError):
+            boundscheck(a)
+
+
+class TestBoundsEnvironmentVariable(TestCase):
+    def setUp(self):
+        @njit
+        def default(x):
+            return x[1]
+
+        @njit(boundscheck=False)
+        def off(x):
+            return x[1]
+
+        @njit(boundscheck=True)
+        def on(x):
+            return x[1]
+
+        self.default = default
+        self.off = off
+        self.on = on
+
+    @TestCase.run_test_in_subprocess(envvars={'NUMBA_BOUNDSCHECK': ''})
+    def test_boundscheck_unset(self):
+        self.assertIsNone(config.BOUNDSCHECK)
+
+        a = np.array([1])
+
+        # Doesn't raise
+        self.default(a)
+        self.off(a)
+
+        with self.assertRaises(IndexError):
+            self.on(a)
+
+    @TestCase.run_test_in_subprocess(envvars={'NUMBA_BOUNDSCHECK': '1'})
+    def test_boundscheck_enabled(self):
+        self.assertTrue(config.BOUNDSCHECK)
+
+        a = np.array([1])
+
+        with self.assertRaises(IndexError):
+            self.default(a)
+            self.off(a)
+            self.on(a)
+
+    @TestCase.run_test_in_subprocess(envvars={'NUMBA_BOUNDSCHECK': '0'})
+    def test_boundscheck_disabled(self):
+        self.assertFalse(config.BOUNDSCHECK)
+
+        a = np.array([1])
+
+        # Doesn't raise
+        self.default(a)
+        self.off(a)
+        self.on(a)
+
+
+if __name__ == '__main__':
+    unittest.main()

lib/python3.10/site-packages/numba/tests/test_byteflow.py

@@ -0,0 +1,94 @@
+"""
+Test byteflow.py specific issues
+"""
+import unittest
+
+from numba.tests.support import TestCase
+from numba.core.compiler import run_frontend
+
+
+class TestByteFlowIssues(TestCase):
+    def test_issue_5087(self):
+        # This is an odd issue. The exact number of print below is
+        # necessary to trigger it. Too many or too few will alter the behavior.
+        # Also note that the function below will not be executed. The problem
+        # occurs at compilation. The definition below is invalid for execution.
+        # The problem occurs in the bytecode analysis.
+        def udt():
+            print
+            print
+            print
+
+            for i in range:
+                print
+                print
+                print
+                print
+                print
+                print
+                print
+                print
+                print
+                print
+                print
+                print
+                print
+                print
+                print
+                print
+                print
+                print
+
+                for j in range:
+                    print
+                    print
+                    print
+                    print
+                    print
+                    print
+                    print
+                    for k in range:
+                        for l in range:
+                            print
+
+                    print
+                    print
+                    print
+                    print
+                    print
+                    print
+                    print
+                    print
+                    print
+                    if print:
+                        for n in range:
+                            print
+                    else:
+                        print
+
+        run_frontend(udt)
+
+    def test_issue_5097(self):
+        # Inspired by https://github.com/numba/numba/issues/5097
+        def udt():
+            for i in range(0):
+                if i > 0:
+                    pass
+                a = None # noqa: F841
+
+        run_frontend(udt)
+
+    def test_issue_5680(self):
+        # From https://github.com/numba/numba/issues/5680#issuecomment-625351336
+        def udt():
+            for k in range(0):
+                if 1 == 1:
+                    ...
+                if 'a' == 'a':
+                    ...
+
+        run_frontend(udt)
+
+
+if __name__ == '__main__':
+    unittest.main()

lib/python3.10/site-packages/numba/tests/test_cfunc.py

@@ -0,0 +1,408 @@
+"""
+Tests for @cfunc and friends.
+"""
+
+
+import ctypes
+import os
+import subprocess
+import sys
+from collections import namedtuple
+
+import numpy as np
+
+from numba import cfunc, carray, farray, njit
+from numba.core import types, typing, utils
+import numba.core.typing.cffi_utils as cffi_support
+from numba.tests.support import (TestCase, skip_unless_cffi, tag,
+                                 captured_stderr)
+import unittest
+from numba.np import numpy_support
+
+
+def add_usecase(a, b):
+    return a + b
+
+def div_usecase(a, b):
+    c = a / b
+    return c
+
+def square_usecase(a):
+    return a ** 2
+
+add_sig = "float64(float64, float64)"
+
+div_sig = "float64(int64, int64)"
+
+square_sig = "float64(float64)"
+
+def objmode_usecase(a, b):
+    object()
+    return a + b
+
+# Test functions for carray() and farray()
+
+CARRAY_USECASE_OUT_LEN = 8
+
+def make_cfarray_usecase(func):
+
+    def cfarray_usecase(in_ptr, out_ptr, m, n):
+        # Tuple shape
+        in_ = func(in_ptr, (m, n))
+        # Integer shape
+        out = func(out_ptr, CARRAY_USECASE_OUT_LEN)
+        out[0] = in_.ndim
+        out[1:3] = in_.shape
+        out[3:5] = in_.strides
+        out[5] = in_.flags.c_contiguous
+        out[6] = in_.flags.f_contiguous
+        s = 0
+        for i, j in np.ndindex(m, n):
+            s += in_[i, j] * (i - j)
+        out[7] = s
+
+    return cfarray_usecase
+
+carray_usecase = make_cfarray_usecase(carray)
+farray_usecase = make_cfarray_usecase(farray)
+
+
+def make_cfarray_dtype_usecase(func):
+    # Same as make_cfarray_usecase(), but with explicit dtype.
+
+    def cfarray_usecase(in_ptr, out_ptr, m, n):
+        # Tuple shape
+        in_ = func(in_ptr, (m, n), dtype=np.float32)
+        # Integer shape
+        out = func(out_ptr, CARRAY_USECASE_OUT_LEN, np.float32)
+        out[0] = in_.ndim
+        out[1:3] = in_.shape
+        out[3:5] = in_.strides
+        out[5] = in_.flags.c_contiguous
+        out[6] = in_.flags.f_contiguous
+        s = 0
+        for i, j in np.ndindex(m, n):
+            s += in_[i, j] * (i - j)
+        out[7] = s
+
+    return cfarray_usecase
+
+carray_dtype_usecase = make_cfarray_dtype_usecase(carray)
+farray_dtype_usecase = make_cfarray_dtype_usecase(farray)
+
+carray_float32_usecase_sig = types.void(types.CPointer(types.float32),
+                                        types.CPointer(types.float32),
+                                        types.intp, types.intp)
+
+carray_float64_usecase_sig = types.void(types.CPointer(types.float64),
+                                        types.CPointer(types.float64),
+                                        types.intp, types.intp)
+
+carray_voidptr_usecase_sig = types.void(types.voidptr, types.voidptr,
+                                        types.intp, types.intp)
+
+
+class TestCFunc(TestCase):
+
+    def test_basic(self):
+        """
+        Basic usage and properties of a cfunc.
+        """
+        f = cfunc(add_sig)(add_usecase)
+
+        self.assertEqual(f.__name__, "add_usecase")
+        self.assertEqual(f.__qualname__, "add_usecase")
+        self.assertIs(f.__wrapped__, add_usecase)
+
+        symbol = f.native_name
+        self.assertIsInstance(symbol, str)
+        self.assertIn("add_usecase", symbol)
+
+        addr = f.address
+        self.assertIsInstance(addr, int)
+
+        ct = f.ctypes
+        self.assertEqual(ctypes.cast(ct, ctypes.c_void_p).value, addr)
+
+        self.assertPreciseEqual(ct(2.0, 3.5), 5.5)
+
+    @skip_unless_cffi
+    def test_cffi(self):
+        from numba.tests import cffi_usecases
+        ffi, lib = cffi_usecases.load_inline_module()
+
+        f = cfunc(square_sig)(square_usecase)
+
+        res = lib._numba_test_funcptr(f.cffi)
+        self.assertPreciseEqual(res, 2.25)  # 1.5 ** 2
+
+    def test_locals(self):
+        # By forcing the intermediate result into an integer, we
+        # truncate the ultimate function result
+        f = cfunc(div_sig, locals={'c': types.int64})(div_usecase)
+        self.assertPreciseEqual(f.ctypes(8, 3), 2.0)
+
+    def test_errors(self):
+        f = cfunc(div_sig)(div_usecase)
+
+        with captured_stderr() as err:
+            self.assertPreciseEqual(f.ctypes(5, 2), 2.5)
+        self.assertEqual(err.getvalue(), "")
+
+        with captured_stderr() as err:
+            res = f.ctypes(5, 0)
+            # This is just a side effect of Numba zero-initializing
+            # stack variables, and could change in the future.
+            self.assertPreciseEqual(res, 0.0)
+        err = err.getvalue()
+        self.assertIn("ZeroDivisionError:", err)
+        self.assertIn("Exception ignored", err)
+
+    def test_llvm_ir(self):
+        f = cfunc(add_sig)(add_usecase)
+        ir = f.inspect_llvm()
+        self.assertIn(f.native_name, ir)
+        self.assertIn("fadd double", ir)
+
+    def test_object_mode(self):
+        """
+        Object mode is currently unsupported.
+        """
+        with self.assertRaises(NotImplementedError):
+            cfunc(add_sig, forceobj=True)(add_usecase)
+        with self.assertTypingError() as raises:
+            cfunc(add_sig)(objmode_usecase)
+        self.assertIn("Untyped global name 'object'", str(raises.exception))
+
+
+class TestCArray(TestCase):
+    """
+    Tests for carray() and farray().
+    """
+
+    def run_carray_usecase(self, pointer_factory, func):
+        a = np.arange(10, 16).reshape((2, 3)).astype(np.float32)
+        out = np.empty(CARRAY_USECASE_OUT_LEN, dtype=np.float32)
+        func(pointer_factory(a), pointer_factory(out), *a.shape)
+        return out
+
+    def check_carray_usecase(self, pointer_factory, pyfunc, cfunc):
+        expected = self.run_carray_usecase(pointer_factory, pyfunc)
+        got = self.run_carray_usecase(pointer_factory, cfunc)
+        self.assertPreciseEqual(expected, got)
+
+    def make_voidptr(self, arr):
+        return arr.ctypes.data_as(ctypes.c_void_p)
+
+    def make_float32_pointer(self, arr):
+        return arr.ctypes.data_as(ctypes.POINTER(ctypes.c_float))
+
+    def make_float64_pointer(self, arr):
+        return arr.ctypes.data_as(ctypes.POINTER(ctypes.c_double))
+
+    def check_carray_farray(self, func, order):
+        def eq(got, expected):
+            # Same layout, dtype, shape, etc.
+            self.assertPreciseEqual(got, expected)
+            # Same underlying data
+            self.assertEqual(got.ctypes.data, expected.ctypes.data)
+
+        base = np.arange(6).reshape((2, 3)).astype(np.float32).copy(order=order)
+
+        # With typed pointer and implied dtype
+        a = func(self.make_float32_pointer(base), base.shape)
+        eq(a, base)
+        # Integer shape
+        a = func(self.make_float32_pointer(base), base.size)
+        eq(a, base.ravel('K'))
+
+        # With typed pointer and explicit dtype
+        a = func(self.make_float32_pointer(base), base.shape, base.dtype)
+        eq(a, base)
+        a = func(self.make_float32_pointer(base), base.shape, np.float32)
+        eq(a, base)
+
+        # With voidptr and explicit dtype
+        a = func(self.make_voidptr(base), base.shape, base.dtype)
+        eq(a, base)
+        a = func(self.make_voidptr(base), base.shape, np.int32)
+        eq(a, base.view(np.int32))
+
+        # voidptr without dtype
+        with self.assertRaises(TypeError):
+            func(self.make_voidptr(base), base.shape)
+        # Invalid pointer type
+        with self.assertRaises(TypeError):
+            func(base.ctypes.data, base.shape)
+        # Mismatching dtype
+        with self.assertRaises(TypeError) as raises:
+            func(self.make_float32_pointer(base), base.shape, np.int32)
+        self.assertIn("mismatching dtype 'int32' for pointer",
+                      str(raises.exception))
+
+    def test_carray(self):
+        """
+        Test pure Python carray().
+        """
+        self.check_carray_farray(carray, 'C')
+
+    def test_farray(self):
+        """
+        Test pure Python farray().
+        """
+        self.check_carray_farray(farray, 'F')
+
+    def make_carray_sigs(self, formal_sig):
+        """
+        Generate a bunch of concrete signatures by varying the width
+        and signedness of size arguments (see issue #1923).
+        """
+        for actual_size in (types.intp, types.int32, types.intc,
+                            types.uintp, types.uint32, types.uintc):
+            args = tuple(actual_size if a == types.intp else a
+                         for a in formal_sig.args)
+            yield formal_sig.return_type(*args)
+
+    def check_numba_carray_farray(self, usecase, dtype_usecase):
+        # With typed pointers and implicit dtype
+        pyfunc = usecase
+        for sig in self.make_carray_sigs(carray_float32_usecase_sig):
+            f = cfunc(sig)(pyfunc)
+            self.check_carray_usecase(self.make_float32_pointer, pyfunc, f.ctypes)
+
+        # With typed pointers and explicit (matching) dtype
+        pyfunc = dtype_usecase
+        for sig in self.make_carray_sigs(carray_float32_usecase_sig):
+            f = cfunc(sig)(pyfunc)
+            self.check_carray_usecase(self.make_float32_pointer, pyfunc, f.ctypes)
+        # With typed pointers and mismatching dtype
+        with self.assertTypingError() as raises:
+            f = cfunc(carray_float64_usecase_sig)(pyfunc)
+        self.assertIn("mismatching dtype 'float32' for pointer type 'float64*'",
+                      str(raises.exception))
+
+        # With voidptr
+        pyfunc = dtype_usecase
+        for sig in self.make_carray_sigs(carray_voidptr_usecase_sig):
+            f = cfunc(sig)(pyfunc)
+            self.check_carray_usecase(self.make_float32_pointer, pyfunc, f.ctypes)
+
+    def test_numba_carray(self):
+        """
+        Test Numba-compiled carray() against pure Python carray()
+        """
+        self.check_numba_carray_farray(carray_usecase, carray_dtype_usecase)
+
+    def test_numba_farray(self):
+        """
+        Test Numba-compiled farray() against pure Python farray()
+        """
+        self.check_numba_carray_farray(farray_usecase, farray_dtype_usecase)
+
+
+@skip_unless_cffi
+class TestCffiStruct(TestCase):
+    c_source = """
+typedef struct _big_struct {
+    int    i1;
+    float  f2;
+    double d3;
+    float  af4[9];
+} big_struct;
+
+typedef struct _error {
+    int bits:4;
+} error;
+
+typedef double (*myfunc)(big_struct*, size_t);
+"""
+
+    def get_ffi(self, src=c_source):
+        from cffi import FFI
+
+        ffi = FFI()
+        ffi.cdef(src)
+        return ffi
+
+    def test_type_parsing(self):
+        ffi = self.get_ffi()
+        # Check struct typedef
+        big_struct = ffi.typeof('big_struct')
+        nbtype = cffi_support.map_type(big_struct, use_record_dtype=True)
+        self.assertIsInstance(nbtype, types.Record)
+        self.assertEqual(len(nbtype), 4)
+        self.assertEqual(nbtype.typeof('i1'), types.int32)
+        self.assertEqual(nbtype.typeof('f2'), types.float32)
+        self.assertEqual(nbtype.typeof('d3'), types.float64)
+        self.assertEqual(
+            nbtype.typeof('af4'),
+            types.NestedArray(dtype=types.float32, shape=(9,)),
+        )
+
+        # Check function typedef
+        myfunc = ffi.typeof('myfunc')
+        sig = cffi_support.map_type(myfunc, use_record_dtype=True)
+        self.assertIsInstance(sig, typing.Signature)
+        self.assertEqual(sig.args[0], types.CPointer(nbtype))
+        self.assertEqual(sig.args[1], types.uintp)
+        self.assertEqual(sig.return_type, types.float64)
+
+    def test_cfunc_callback(self):
+        ffi = self.get_ffi()
+        big_struct = ffi.typeof('big_struct')
+        nb_big_struct = cffi_support.map_type(big_struct, use_record_dtype=True)
+        sig = cffi_support.map_type(ffi.typeof('myfunc'), use_record_dtype=True)
+
+        @njit
+        def calc(base):
+            tmp = 0
+            for i in range(base.size):
+                elem = base[i]
+                tmp += elem.i1 * elem.f2 / elem.d3
+                tmp += base[i].af4.sum()
+            return tmp
+
+        @cfunc(sig)
+        def foo(ptr, n):
+            base = carray(ptr, n)
+            return calc(base)
+
+        # Make data
+        mydata = ffi.new('big_struct[3]')
+        ptr = ffi.cast('big_struct*', mydata)
+        for i in range(3):
+            ptr[i].i1 = i * 123
+            ptr[i].f2 = i * 213
+            ptr[i].d3 = (1 + i) * 213
+            for j in range(9):
+                ptr[i].af4[j] = i * 10 + j
+
+        # Address of my data
+        addr = int(ffi.cast('size_t', ptr))
+        got = foo.ctypes(addr, 3)
+
+        # Make numpy array from the cffi buffer
+        array = np.ndarray(
+            buffer=ffi.buffer(mydata),
+            dtype=numpy_support.as_dtype(nb_big_struct),
+            shape=3,
+            )
+        expect = calc(array)
+        self.assertEqual(got, expect)
+
+    def test_unsupport_bitsize(self):
+        ffi = self.get_ffi()
+        with self.assertRaises(ValueError) as raises:
+            cffi_support.map_type(
+                ffi.typeof('error'),
+                use_record_dtype=True,
+            )
+        # When bitsize is provided, bitshift defaults to 0.
+        self.assertEqual(
+            "field 'bits' has bitshift, this is not supported",
+            str(raises.exception)
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()

lib/python3.10/site-packages/numba/tests/test_codegen.py

@@ -0,0 +1,264 @@
+"""
+Tests for numba.core.codegen.
+"""
+
+
+import warnings
+import base64
+import ctypes
+import pickle
+import re
+import subprocess
+import sys
+import weakref
+
+import llvmlite.binding as ll
+
+import unittest
+from numba import njit
+from numba.core.codegen import JITCPUCodegen
+from numba.core.compiler_lock import global_compiler_lock
+from numba.tests.support import TestCase
+
+
+asm_sum = r"""
+    define i32 @sum(i32 %.1, i32 %.2) {
+      %.3 = add i32 %.1, %.2
+      ret i32 %.3
+    }
+    """
+
+# Note we're using a rather mangled function name to check that it
+# is compatible with object serialization.
+
+asm_sum_inner = """
+    define i32 @"__main__.ising_element_update$1.array(int8,_2d,_C).int64.int64"(i32 %.1, i32 %.2) {
+      %.3 = add i32 %.1, %.2
+      ret i32 %.3
+    }
+"""    # noqa: E501
+
+asm_sum_outer = """
+    declare i32 @"__main__.ising_element_update$1.array(int8,_2d,_C).int64.int64"(i32 %.1, i32 %.2)
+
+    define i32 @sum(i32 %.1, i32 %.2) {
+      %.3 = call i32 @"__main__.ising_element_update$1.array(int8,_2d,_C).int64.int64"(i32 %.1, i32 %.2)
+      ret i32 %.3
+    }
+"""    # noqa: E501
+
+
+ctypes_sum_ty = ctypes.CFUNCTYPE(ctypes.c_int, ctypes.c_int, ctypes.c_int)
+
+
+class JITCPUCodegenTestCase(TestCase):
+    """
+    Test the JIT code generation.
+    """
+
+    def setUp(self):
+        global_compiler_lock.acquire()
+        self.codegen = JITCPUCodegen('test_codegen')
+
+    def tearDown(self):
+        del self.codegen
+        global_compiler_lock.release()
+
+    def compile_module(self, asm, linking_asm=None):
+        library = self.codegen.create_library('compiled_module')
+        ll_module = ll.parse_assembly(asm)
+        ll_module.verify()
+        library.add_llvm_module(ll_module)
+        if linking_asm:
+            linking_library = self.codegen.create_library('linking_module')
+            ll_module = ll.parse_assembly(linking_asm)
+            ll_module.verify()
+            linking_library.add_llvm_module(ll_module)
+            library.add_linking_library(linking_library)
+        return library
+
+    @classmethod
+    def _check_unserialize_sum(cls, state):
+        codegen = JITCPUCodegen('other_codegen')
+        library = codegen.unserialize_library(state)
+        ptr = library.get_pointer_to_function("sum")
+        assert ptr, ptr
+        cfunc = ctypes_sum_ty(ptr)
+        res = cfunc(2, 3)
+        assert res == 5, res
+
+    def test_get_pointer_to_function(self):
+        library = self.compile_module(asm_sum)
+        ptr = library.get_pointer_to_function("sum")
+        self.assertIsInstance(ptr, int)
+        cfunc = ctypes_sum_ty(ptr)
+        self.assertEqual(cfunc(2, 3), 5)
+        # Note: With llvm3.9.1, deleting `library` will cause memory error in
+        #       the following code during running of optimization passes in
+        #       LLVM. The reason of the error is unclear. The error is known to
+        #       replicate on osx64 and linux64.
+
+        # Same, but with dependency on another library
+        library2 = self.compile_module(asm_sum_outer, asm_sum_inner)
+        ptr = library2.get_pointer_to_function("sum")
+        self.assertIsInstance(ptr, int)
+        cfunc = ctypes_sum_ty(ptr)
+        self.assertEqual(cfunc(2, 3), 5)
+
+    def test_magic_tuple(self):
+        tup = self.codegen.magic_tuple()
+        pickle.dumps(tup)
+        cg2 = JITCPUCodegen('xxx')
+        self.assertEqual(cg2.magic_tuple(), tup)
+
+    # Serialization tests.
+
+    def _check_serialize_unserialize(self, state):
+        self._check_unserialize_sum(state)
+
+    def _check_unserialize_other_process(self, state):
+        arg = base64.b64encode(pickle.dumps(state, -1))
+        code = """if 1:
+            import base64
+            import pickle
+            import sys
+            from numba.tests.test_codegen import %(test_class)s
+
+            state = pickle.loads(base64.b64decode(sys.argv[1]))
+            %(test_class)s._check_unserialize_sum(state)
+            """ % dict(test_class=self.__class__.__name__)
+        subprocess.check_call([sys.executable, '-c', code, arg.decode()])
+
+    def test_serialize_unserialize_bitcode(self):
+        library = self.compile_module(asm_sum_outer, asm_sum_inner)
+        state = library.serialize_using_bitcode()
+        self._check_serialize_unserialize(state)
+
+    def test_unserialize_other_process_bitcode(self):
+        library = self.compile_module(asm_sum_outer, asm_sum_inner)
+        state = library.serialize_using_bitcode()
+        self._check_unserialize_other_process(state)
+
+    def test_serialize_unserialize_object_code(self):
+        library = self.compile_module(asm_sum_outer, asm_sum_inner)
+        library.enable_object_caching()
+        state = library.serialize_using_object_code()
+        self._check_serialize_unserialize(state)
+
+    def test_unserialize_other_process_object_code(self):
+        library = self.compile_module(asm_sum_outer, asm_sum_inner)
+        library.enable_object_caching()
+        state = library.serialize_using_object_code()
+        self._check_unserialize_other_process(state)
+
+    def test_cache_disabled_inspection(self):
+        """
+        """
+        library = self.compile_module(asm_sum_outer, asm_sum_inner)
+        library.enable_object_caching()
+        state = library.serialize_using_object_code()
+
+        # exercise the valid behavior
+        with warnings.catch_warnings(record=True) as w:
+            old_llvm = library.get_llvm_str()
+            old_asm = library.get_asm_str()
+            library.get_function_cfg('sum')
+        self.assertEqual(len(w), 0)
+
+        # unserialize
+        codegen = JITCPUCodegen('other_codegen')
+        library = codegen.unserialize_library(state)
+
+        # the inspection methods would warn and give incorrect result
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always")
+            self.assertNotEqual(old_llvm, library.get_llvm_str())
+        self.assertEqual(len(w), 1)
+        self.assertIn("Inspection disabled", str(w[0].message))
+
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always")
+            self.assertNotEqual(library.get_asm_str(), old_asm)
+        self.assertEqual(len(w), 1)
+        self.assertIn("Inspection disabled", str(w[0].message))
+
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always")
+            with self.assertRaises(NameError) as raises:
+                library.get_function_cfg('sum')
+        self.assertEqual(len(w), 1)
+        self.assertIn("Inspection disabled", str(w[0].message))
+        self.assertIn("sum", str(raises.exception))
+
+    # Lifetime tests
+
+    @unittest.expectedFailure  # MCJIT removeModule leaks and it is disabled
+    def test_library_lifetime(self):
+        library = self.compile_module(asm_sum_outer, asm_sum_inner)
+        # Exercise code generation
+        library.enable_object_caching()
+        library.serialize_using_bitcode()
+        library.serialize_using_object_code()
+        u = weakref.ref(library)
+        v = weakref.ref(library._final_module)
+        del library
+        # Both the library and its backing LLVM module are collected
+        self.assertIs(u(), None)
+        self.assertIs(v(), None)
+
+
+class TestWrappers(TestCase):
+
+    def test_noinline_on_main_call(self):
+        # Checks that the cpython and cfunc wrapper produces a call with the
+        # "noinline" attr present for the decorated function.
+
+        # Creating a refcounted object induces a side-effect that prevents IPO
+        # from eliding the call to the function with LLVM 15. See Issue #9658:
+        # https://github.com/numba/numba/issues/9658
+        @njit
+        def foo():
+            return list([1])
+
+        foo()
+        sig = foo.signatures[0]
+
+        ol = foo.overloads[sig]
+        name = ol.fndesc.mangled_name.replace("$", r"\$")
+        p1 = r".*call.*{}".format(name)
+        p2 = r".*(#[0-9]+).*"
+        call_site = re.compile(p1 + p2)
+
+        lines = foo.inspect_llvm(sig).splitlines()
+        meta_data_idx = []
+        for l in lines:
+            matched = call_site.match(l)
+            if matched:
+                meta_data_idx.append(matched.groups()[0])
+
+        # should be 2 calls, one from cpython wrapper one from cfunc wrapper
+        self.assertEqual(len(meta_data_idx), 2)
+        # both calls should refer to the same metadata item
+        self.assertEqual(meta_data_idx[0], meta_data_idx[1])
+
+        p1 = r"^attributes\s+{}".format(meta_data_idx[0])
+        p2 = r"\s+=\s+{(.*)}.*$"
+        attr_site = re.compile(p1 + p2)
+
+        for l in reversed(lines):
+            matched = attr_site.match(l)
+            if matched:
+                meta_data = matched.groups()[0]
+                lmeta = meta_data.strip().split(' ')
+                for x in lmeta:
+                    if 'noinline' in x:
+                        break
+                else:
+                    continue
+                break
+        else:
+            return self.fail("Metadata did not match 'noinline'")
+
+
+if __name__ == '__main__':
+    unittest.main()

lib/python3.10/site-packages/numba/tests/test_ctypes.py

@@ -0,0 +1,255 @@
+from ctypes import *
+import sys
+import threading
+
+import numpy as np
+
+
+from numba import jit, njit
+from numba.core import types, errors
+from numba.core.typing import ctypes_utils
+from numba.tests.support import MemoryLeakMixin, tag, TestCase
+from numba.tests.ctypes_usecases import *
+import unittest
+
+
+class TestCTypesTypes(TestCase):
+
+    def _conversion_tests(self, check):
+        check(c_double, types.float64)
+        check(c_int, types.intc)
+        check(c_uint16, types.uint16)
+        check(c_size_t, types.size_t)
+        check(c_ssize_t, types.ssize_t)
+
+        check(c_void_p, types.voidptr)
+        check(POINTER(c_float), types.CPointer(types.float32))
+        check(POINTER(POINTER(c_float)),
+              types.CPointer(types.CPointer(types.float32)))
+
+        check(None, types.void)
+
+    def test_from_ctypes(self):
+        """
+        Test converting a ctypes type to a Numba type.
+        """
+        def check(cty, ty):
+            got = ctypes_utils.from_ctypes(cty)
+            self.assertEqual(got, ty)
+
+        self._conversion_tests(check)
+
+        # An unsupported type
+        with self.assertRaises(TypeError) as raises:
+            ctypes_utils.from_ctypes(c_wchar_p)
+        self.assertIn("Unsupported ctypes type", str(raises.exception))
+
+    def test_to_ctypes(self):
+        """
+        Test converting a Numba type to a ctypes type.
+        """
+        def check(cty, ty):
+            got = ctypes_utils.to_ctypes(ty)
+            self.assertEqual(got, cty)
+
+        self._conversion_tests(check)
+
+        # An unsupported type
+        with self.assertRaises(TypeError) as raises:
+            ctypes_utils.to_ctypes(types.ellipsis)
+        self.assertIn("Cannot convert Numba type '...' to ctypes type",
+                      str(raises.exception))
+
+
+class TestCTypesUseCases(MemoryLeakMixin, TestCase):
+
+    def test_c_sin(self):
+        pyfunc = use_c_sin
+        cfunc = njit((types.double,))(pyfunc)
+        x = 3.14
+        self.assertEqual(pyfunc(x), cfunc(x))
+
+    def test_two_funcs(self):
+        # Check that two constant functions don't get mixed up.
+        pyfunc = use_two_funcs
+        cfunc = njit((types.double,))(pyfunc)
+        x = 3.14
+        self.assertEqual(pyfunc(x), cfunc(x))
+
+    @unittest.skipUnless(is_windows, "Windows-specific test")
+    def test_stdcall(self):
+        # Just check that it doesn't crash
+        cfunc = njit((types.uintc,))(use_c_sleep)
+
+        cfunc(1)
+
+    def test_ctype_wrapping(self):
+        pyfunc = use_ctype_wrapping
+        cfunc = njit((types.double,))(pyfunc)
+        x = 3.14
+        self.assertEqual(pyfunc(x), cfunc(x))
+
+    def test_ctype_voidptr(self):
+        pyfunc = use_c_pointer
+        # pyfunc will segfault if called
+        cfunc = njit((types.int32,))(pyfunc)
+        x = 123
+        self.assertEqual(cfunc(x), x + 1)
+
+    def test_function_pointer(self):
+        pyfunc = use_func_pointer
+        cfunc = jit(nopython=True)(pyfunc)
+        for (fa, fb, x) in [
+            (c_sin, c_cos, 1.0),
+            (c_sin, c_cos, -1.0),
+            (c_cos, c_sin, 1.0),
+            (c_cos, c_sin, -1.0)]:
+            expected = pyfunc(fa, fb, x)
+            got = cfunc(fa, fb, x)
+            self.assertEqual(got, expected)
+        # A single specialization was compiled for all calls
+        self.assertEqual(len(cfunc.overloads), 1, cfunc.overloads)
+
+    def test_untyped_function(self):
+        with self.assertRaises(TypeError) as raises:
+            njit((types.double,))(use_c_untyped)
+        self.assertIn("ctypes function '_numba_test_exp' doesn't define its argument types",
+                      str(raises.exception))
+
+    def test_python_call_back(self):
+        mydct = {'what': 1232121}
+
+        def call_me_maybe(arr):
+            return mydct[arr[0].decode('ascii')]
+
+        # Create a callback into the python interpreter
+        py_call_back = CFUNCTYPE(c_int, py_object)(call_me_maybe)
+
+        def pyfunc(a):
+            what = py_call_back(a)
+            return what
+
+        cfunc = jit(nopython=True, nogil=True)(pyfunc)
+        arr = np.array(["what"], dtype='S10')
+        self.assertEqual(pyfunc(arr), cfunc(arr))
+
+    def test_python_call_back_threaded(self):
+        def pyfunc(a, repeat):
+            out = 0
+            for _ in range(repeat):
+                out += py_call_back(a)
+            return out
+
+        cfunc = jit(nopython=True, nogil=True)(pyfunc)
+
+        arr = np.array(["what"], dtype='S10')
+        repeat = 1000
+
+        expected = pyfunc(arr, repeat)
+        outputs = []
+
+        # Warm up
+        cfunc(arr, repeat)
+
+        # Test the function in multiple threads to exercise the
+        # GIL ensure/release code
+
+        def run(func, arr, repeat):
+            outputs.append(func(arr, repeat))
+
+        threads = [threading.Thread(target=run, args=(cfunc, arr, repeat))
+                   for _ in range(10)]
+
+        # Start threads
+        for th in threads:
+            th.start()
+
+        # End threads
+        for th in threads:
+            th.join()
+
+        # Check results
+        for got in outputs:
+            self.assertEqual(expected, got)
+
+    def test_passing_array_ctypes_data(self):
+        """
+        Test the ".ctypes.data" attribute of an array can be passed
+        as a "void *" parameter.
+        """
+        def pyfunc(arr):
+            return c_take_array_ptr(arr.ctypes.data)
+
+        cfunc = jit(nopython=True, nogil=True)(pyfunc)
+
+        arr = np.arange(5)
+
+        expected = pyfunc(arr)
+        got = cfunc(arr)
+
+        self.assertEqual(expected, got)
+
+    def check_array_ctypes(self, pyfunc):
+        cfunc = jit(nopython=True)(pyfunc)
+
+        arr = np.linspace(0, 10, 5)
+        expected = arr ** 2.0
+        got = cfunc(arr)
+        self.assertPreciseEqual(expected, got)
+        return cfunc
+
+    def test_passing_array_ctypes_voidptr(self):
+        """
+        Test the ".ctypes" attribute of an array can be passed
+        as a "void *" parameter.
+        """
+        self.check_array_ctypes(use_c_vsquare)
+
+    def test_passing_array_ctypes_voidptr_pass_ptr(self):
+        """
+        Test the ".ctypes" attribute of an array can be passed
+        as a pointer parameter of the right type.
+        """
+        cfunc = self.check_array_ctypes(use_c_vcube)
+
+        # Non-compatible pointers are not accepted (here float32* vs. float64*)
+        with self.assertRaises(errors.TypingError) as raises:
+            cfunc(np.float32([0.0]))
+
+        self.assertIn("No implementation of function ExternalFunctionPointer",
+                      str(raises.exception))
+
+    def test_storing_voidptr_to_int_array(self):
+        # Make C callback that returns a void*
+        cproto = CFUNCTYPE(c_void_p)
+
+        @cproto
+        def get_voidstar():
+            return 0xdeadbeef
+
+        # Make python functions that use the C callback
+        def pyfunc(a):
+            ptr = get_voidstar()
+            a[0] = ptr
+            return ptr
+
+        # Compile it
+        cfunc = njit((types.uintp[::1],))(pyfunc)
+
+        # Setup inputs
+        arr_got = np.zeros(1, dtype=np.uintp)
+        arr_expect = arr_got.copy()
+
+        # Run functions
+        ret_got = cfunc(arr_got)
+        ret_expect = pyfunc(arr_expect)
+
+        # Check
+        self.assertEqual(ret_expect, 0xdeadbeef)
+        self.assertPreciseEqual(ret_got, ret_expect)
+        self.assertPreciseEqual(arr_got, arr_expect)
+
+
+if __name__ == '__main__':
+    unittest.main()
+

lib/python3.10/site-packages/numba/tests/test_deprecations.py

@@ -0,0 +1,262 @@
+import warnings
+import unittest
+from contextlib import contextmanager
+
+from numba import jit, vectorize, guvectorize
+from numba.core.errors import (NumbaDeprecationWarning,
+                               NumbaPendingDeprecationWarning, NumbaWarning)
+from numba.tests.support import TestCase, needs_setuptools
+
+
+@contextmanager
+def _catch_numba_deprecation_warnings():
+    with warnings.catch_warnings(record=True) as w:
+        warnings.simplefilter("ignore", category=NumbaWarning)
+        warnings.simplefilter("always", category=NumbaDeprecationWarning)
+        yield w
+
+
+class TestDeprecation(TestCase):
+
+    def check_warning(self, warnings, expected_str, category, check_rtd=True):
+        self.assertEqual(len(warnings), 1)
+        self.assertEqual(warnings[0].category, category)
+        self.assertIn(expected_str, str(warnings[0].message))
+        if check_rtd:
+            self.assertIn("https://numba.readthedocs.io",
+                          str(warnings[0].message))
+
+    @TestCase.run_test_in_subprocess
+    def test_explicit_false_nopython_kwarg(self):
+        # tests that explicitly setting `nopython=False` in @jit raises a
+        # warning about it doing nothing.
+        with _catch_numba_deprecation_warnings() as w:
+
+            @jit(nopython=False)
+            def foo():
+                pass
+
+            foo()
+
+            msg = "The keyword argument 'nopython=False' was supplied"
+            self.check_warning(w, msg, NumbaDeprecationWarning, check_rtd=False)
+
+    @TestCase.run_test_in_subprocess
+    def test_vectorize_missing_nopython_kwarg_not_reported(self):
+        # Checks that use of @vectorize without a nopython kwarg doesn't raise
+        # a warning about lack of said kwarg.
+
+        with _catch_numba_deprecation_warnings() as w:
+            # This compiles via nopython mode directly
+            @vectorize('float64(float64)')
+            def foo(a):
+                return a + 1
+
+        self.assertFalse(w)
+
+    @TestCase.run_test_in_subprocess
+    def test_vectorize_nopython_false_is_reported(self):
+        # Checks that use of @vectorize with nopython=False raises a warning
+        # about supplying it.
+
+        with _catch_numba_deprecation_warnings() as w:
+            # This compiles via nopython mode directly
+            @vectorize('float64(float64)', nopython=False)
+            def foo(a):
+                return a + 1
+
+        msg = "The keyword argument 'nopython=False' was supplied"
+        self.check_warning(w, msg, NumbaDeprecationWarning, check_rtd=False)
+
+    @TestCase.run_test_in_subprocess
+    def test_vectorize_objmode_direct_compilation_no_warnings(self):
+        # Checks that use of @vectorize with forceobj=True raises no warnings.
+
+        with _catch_numba_deprecation_warnings() as w:
+            # Compiles via objmode directly with no warnings raised
+            @vectorize('float64(float64)', forceobj=True)
+            def foo(a):
+                object()
+                return a + 1
+
+        self.assertFalse(w)
+
+    @TestCase.run_test_in_subprocess
+    def test_vectorize_objmode_compilation_nopython_false_warns(self):
+        # Checks that use of @vectorize with forceobj set and nopython set as
+        # False raises no warnings.
+
+        with _catch_numba_deprecation_warnings() as w:
+            # Compiles via objmode directly with no warnings raised
+            @vectorize('float64(float64)', forceobj=True, nopython=False)
+            def foo(a):
+                object()
+                return a + 1
+
+        msg = "The keyword argument 'nopython=False' was supplied"
+        self.check_warning(w, msg, NumbaDeprecationWarning, check_rtd=False)
+
+    @TestCase.run_test_in_subprocess
+    def test_vectorize_parallel_true_no_warnings(self):
+        # Checks that use of @vectorize with the parallel target doesn't
+        # raise warnings about nopython kwarg, the parallel target doesn't
+        # support objmode so nopython=True is implicit.
+        with _catch_numba_deprecation_warnings() as w:
+            @vectorize('float64(float64)', target='parallel')
+            def foo(x):
+                return x + 1
+
+        self.assertFalse(w)
+
+    @TestCase.run_test_in_subprocess
+    def test_vectorize_parallel_true_nopython_true_no_warnings(self):
+        # Checks that use of @vectorize with the parallel target and
+        # nopython=True doesn't raise warnings about nopython kwarg.
+        with _catch_numba_deprecation_warnings() as w:
+            @vectorize('float64(float64)', target='parallel', nopython=True)
+            def foo(x):
+                return x + 1
+
+        self.assertFalse(w)
+
+    @TestCase.run_test_in_subprocess
+    def test_vectorize_parallel_true_nopython_false_warns(self):
+        # Checks that use of @vectorize with the parallel target and
+        # nopython=False raises a warning about the nopython kwarg being False.
+        with _catch_numba_deprecation_warnings() as w:
+            @vectorize('float64(float64)', target='parallel', nopython=False)
+            def foo(x):
+                return x + 1
+
+        msg = "The keyword argument 'nopython=False' was supplied"
+        self.check_warning(w, msg, NumbaDeprecationWarning, check_rtd=False)
+
+    @TestCase.run_test_in_subprocess
+    def test_vectorize_calling_jit_with_nopython_false_warns_from_jit(self):
+        # Checks the scope of the suppression of deprecation warnings that are
+        # present in e.g. vectorize. The function `bar` should raise a
+        # deprecation warning, the `@vectorize`d `foo` function should not,
+        # even though both don't have a nopython kwarg.
+
+        # First check that the @vectorize call doesn't raise anything
+        with _catch_numba_deprecation_warnings() as w:
+            @vectorize('float64(float64)', forceobj=True)
+            def foo(x):
+                return bar(x + 1)
+
+            def bar(*args):
+                pass
+
+        self.assertFalse(w)
+
+    @TestCase.run_test_in_subprocess
+    def test_guvectorize_implicit_nopython_no_warnings(self):
+        # Checks that use of @guvectorize with implicit nopython compilation
+        # does not warn on compilation.
+        with _catch_numba_deprecation_warnings() as w:
+
+            @guvectorize('void(float64[::1], float64[::1])', '(n)->(n)')
+            def bar(a, b):
+                a += 1
+
+        self.assertFalse(w)
+
+    @TestCase.run_test_in_subprocess
+    def test_guvectorize_forceobj_no_warnings(self):
+        # Checks that use of @guvectorize with direct objmode compilation does
+        # not warn.
+        with _catch_numba_deprecation_warnings() as w:
+
+            @guvectorize('void(float64[::1], float64[::1])', '(n)->(n)',
+                         forceobj=True)
+            def bar(a, b):
+                object()
+                a += 1
+
+        self.assertFalse(w)
+
+    @TestCase.run_test_in_subprocess
+    def test_guvectorize_parallel_implicit_nopython_no_warnings(self):
+        # Checks that use of @guvectorize with parallel target and implicit
+        # nopython mode compilation does not warn.
+        with _catch_numba_deprecation_warnings() as w:
+
+            @guvectorize('void(float64[::1], float64[::1])', '(n)->(n)',
+                         target='parallel')
+            def bar(a, b):
+                a += 1
+
+        self.assertFalse(w)
+
+    @TestCase.run_test_in_subprocess
+    def test_guvectorize_parallel_forceobj_no_warnings(self):
+        # Checks that use of @guvectorize with parallel target and direct
+        # objmode compilation does not warn.
+        with _catch_numba_deprecation_warnings() as w:
+
+            # This compiles somewhat surprisingly for the parallel target using
+            # object mode?!
+            @guvectorize('void(float64[::1], float64[::1])', '(n)->(n)',
+                         target='parallel', forceobj=True)
+            def bar(a, b):
+                object()
+                a += 1
+
+        self.assertFalse(w)
+
+    @TestCase.run_test_in_subprocess
+    def test_reflection_of_mutable_container(self):
+        # tests that reflection in list/set warns
+        def foo_list(a):
+            return a.append(1)
+
+        def foo_set(a):
+            return a.add(1)
+
+        for f in [foo_list, foo_set]:
+            container = f.__name__.strip('foo_')
+            inp = eval(container)([10, ])
+            with warnings.catch_warnings(record=True) as w:
+                warnings.simplefilter("ignore", category=NumbaWarning)
+                warnings.simplefilter("always",
+                                      category=NumbaPendingDeprecationWarning)
+                jit(nopython=True)(f)(inp)
+                self.assertEqual(len(w), 1)
+                self.assertEqual(w[0].category, NumbaPendingDeprecationWarning)
+                warn_msg = str(w[0].message)
+                msg = ("Encountered the use of a type that is scheduled for "
+                       "deprecation")
+                self.assertIn(msg, warn_msg)
+                msg = ("\'reflected %s\' found for argument" % container)
+                self.assertIn(msg, warn_msg)
+                self.assertIn("https://numba.readthedocs.io", warn_msg)
+
+    @needs_setuptools
+    @TestCase.run_test_in_subprocess
+    def test_pycc_module(self):
+        # checks import of module warns
+
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always",
+                                  category=NumbaPendingDeprecationWarning)
+            import numba.pycc # noqa: F401
+
+            expected_str = ("The 'pycc' module is pending deprecation.")
+            self.check_warning(w, expected_str, NumbaPendingDeprecationWarning)
+
+    @needs_setuptools
+    @TestCase.run_test_in_subprocess
+    def test_pycc_CC(self):
+        # check the most commonly used functionality (CC) warns
+
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always",
+                                  category=NumbaPendingDeprecationWarning)
+            from numba.pycc import CC # noqa: F401
+
+            expected_str = ("The 'pycc' module is pending deprecation.")
+            self.check_warning(w, expected_str, NumbaPendingDeprecationWarning)
+
+
+if __name__ == '__main__':
+    unittest.main()

lib/python3.10/site-packages/numba/tests/test_dispatcher.py

@@ -0,0 +1,1193 @@
+import multiprocessing
+import platform
+import threading
+import pickle
+import weakref
+from itertools import chain
+from io import StringIO
+
+import numpy as np
+
+from numba import njit, jit, typeof, vectorize
+from numba.core import types, errors
+from numba import _dispatcher
+from numba.tests.support import TestCase, captured_stdout
+from numba.np.numpy_support import as_dtype
+from numba.core.dispatcher import Dispatcher
+from numba.extending import overload
+from numba.tests.support import needs_lapack, SerialMixin
+from numba.testing.main import _TIMEOUT as _RUNNER_TIMEOUT
+import unittest
+
+
+_TEST_TIMEOUT = _RUNNER_TIMEOUT - 60.
+
+
+try:
+    import jinja2
+except ImportError:
+    jinja2 = None
+
+try:
+    import pygments
+except ImportError:
+    pygments = None
+
+_is_armv7l = platform.machine() == 'armv7l'
+
+
+def dummy(x):
+    return x
+
+
+def add(x, y):
+    return x + y
+
+
+def addsub(x, y, z):
+    return x - y + z
+
+
+def addsub_defaults(x, y=2, z=3):
+    return x - y + z
+
+
+def star_defaults(x, y=2, *z):
+    return x, y, z
+
+
+def generated_usecase(x, y=5):
+    if isinstance(x, types.Complex):
+        def impl(x, y):
+            return x + y
+    else:
+        def impl(x, y):
+            return x - y
+    return impl
+
+
+def bad_generated_usecase(x, y=5):
+    if isinstance(x, types.Complex):
+        def impl(x):
+            return x
+    else:
+        def impl(x, y=6):
+            return x - y
+    return impl
+
+
+def dtype_generated_usecase(a, b, dtype=None):
+    if isinstance(dtype, (types.misc.NoneType, types.misc.Omitted)):
+        out_dtype = np.result_type(*(np.dtype(ary.dtype.name)
+                                   for ary in (a, b)))
+    elif isinstance(dtype, (types.DType, types.NumberClass)):
+        out_dtype = as_dtype(dtype)
+    else:
+        raise TypeError("Unhandled Type %s" % type(dtype))
+
+    def _fn(a, b, dtype=None):
+        return np.ones(a.shape, dtype=out_dtype)
+
+    return _fn
+
+
+class BaseTest(TestCase):
+
+    jit_args = dict(nopython=True)
+
+    def compile_func(self, pyfunc):
+        def check(*args, **kwargs):
+            expected = pyfunc(*args, **kwargs)
+            result = f(*args, **kwargs)
+            self.assertPreciseEqual(result, expected)
+        f = jit(**self.jit_args)(pyfunc)
+        return f, check
+
+
+class TestDispatcher(BaseTest):
+
+    def test_equality(self):
+        @jit
+        def foo(x):
+            return x
+
+        @jit
+        def bar(x):
+            return x
+
+        # Written this way to verify `==` returns a bool (gh-5838). Using
+        # `assertTrue(foo == foo)` or `assertEqual(foo, foo)` would defeat the
+        # purpose of this test.
+        self.assertEqual(foo == foo, True)
+        self.assertEqual(foo == bar, False)
+        self.assertEqual(foo == None, False)  # noqa: E711
+
+    def test_dyn_pyfunc(self):
+        @jit
+        def foo(x):
+            return x
+
+        foo(1)
+        [cr] = foo.overloads.values()
+        # __module__ must be match that of foo
+        self.assertEqual(cr.entry_point.__module__, foo.py_func.__module__)
+
+    def test_no_argument(self):
+        @jit
+        def foo():
+            return 1
+
+        # Just make sure this doesn't crash
+        foo()
+
+    def test_coerce_input_types(self):
+        # Issue #486: do not allow unsafe conversions if we can still
+        # compile other specializations.
+        c_add = jit(nopython=True)(add)
+        self.assertPreciseEqual(c_add(123, 456), add(123, 456))
+        self.assertPreciseEqual(c_add(12.3, 45.6), add(12.3, 45.6))
+        self.assertPreciseEqual(c_add(12.3, 45.6j), add(12.3, 45.6j))
+        self.assertPreciseEqual(c_add(12300000000, 456), add(12300000000, 456))
+
+        # Now force compilation of only a single specialization
+        c_add = jit('(i4, i4)', nopython=True)(add)
+        self.assertPreciseEqual(c_add(123, 456), add(123, 456))
+        # Implicit (unsafe) conversion of float to int
+        self.assertPreciseEqual(c_add(12.3, 45.6), add(12, 45))
+        with self.assertRaises(TypeError):
+            # Implicit conversion of complex to int disallowed
+            c_add(12.3, 45.6j)
+
+    def test_ambiguous_new_version(self):
+        """Test compiling new version in an ambiguous case
+        """
+        @jit
+        def foo(a, b):
+            return a + b
+
+        INT = 1
+        FLT = 1.5
+        self.assertAlmostEqual(foo(INT, FLT), INT + FLT)
+        self.assertEqual(len(foo.overloads), 1)
+        self.assertAlmostEqual(foo(FLT, INT), FLT + INT)
+        self.assertEqual(len(foo.overloads), 2)
+        self.assertAlmostEqual(foo(FLT, FLT), FLT + FLT)
+        self.assertEqual(len(foo.overloads), 3)
+        # The following call is ambiguous because (int, int) can resolve
+        # to (float, int) or (int, float) with equal weight.
+        self.assertAlmostEqual(foo(1, 1), INT + INT)
+        self.assertEqual(len(foo.overloads), 4, "didn't compile a new "
+                                                "version")
+
+    def test_lock(self):
+        """
+        Test that (lazy) compiling from several threads at once doesn't
+        produce errors (see issue #908).
+        """
+        errors = []
+
+        @jit
+        def foo(x):
+            return x + 1
+
+        def wrapper():
+            try:
+                self.assertEqual(foo(1), 2)
+            except Exception as e:
+                errors.append(e)
+
+        threads = [threading.Thread(target=wrapper) for i in range(16)]
+        for t in threads:
+            t.start()
+        for t in threads:
+            t.join()
+        self.assertFalse(errors)
+
+    def test_explicit_signatures(self):
+        f = jit("(int64,int64)")(add)
+        # Approximate match (unsafe conversion)
+        self.assertPreciseEqual(f(1.5, 2.5), 3)
+        self.assertEqual(len(f.overloads), 1, f.overloads)
+        f = jit(["(int64,int64)", "(float64,float64)"])(add)
+        # Exact signature matches
+        self.assertPreciseEqual(f(1, 2), 3)
+        self.assertPreciseEqual(f(1.5, 2.5), 4.0)
+        # Approximate match (int32 -> float64 is a safe conversion)
+        self.assertPreciseEqual(f(np.int32(1), 2.5), 3.5)
+        # No conversion
+        with self.assertRaises(TypeError) as cm:
+            f(1j, 1j)
+        self.assertIn("No matching definition", str(cm.exception))
+        self.assertEqual(len(f.overloads), 2, f.overloads)
+        # A more interesting one...
+        f = jit(["(float32,float32)", "(float64,float64)"])(add)
+        self.assertPreciseEqual(f(np.float32(1), np.float32(2**-25)), 1.0)
+        self.assertPreciseEqual(f(1, 2**-25), 1.0000000298023224)
+        # Fail to resolve ambiguity between the two best overloads
+        f = jit(["(float32,float64)",
+                 "(float64,float32)",
+                 "(int64,int64)"])(add)
+        with self.assertRaises(TypeError) as cm:
+            f(1.0, 2.0)
+        # The two best matches are output in the error message, as well
+        # as the actual argument types.
+        self.assertRegex(
+            str(cm.exception),
+            r"Ambiguous overloading for <function add [^>]*> "
+            r"\(float64, float64\):\n"
+            r"\(float32, float64\) -> float64\n"
+            r"\(float64, float32\) -> float64"
+        )
+        # The integer signature is not part of the best matches
+        self.assertNotIn("int64", str(cm.exception))
+
+    def test_signature_mismatch(self):
+        tmpl = ("Signature mismatch: %d argument types given, but function "
+                "takes 2 arguments")
+        with self.assertRaises(TypeError) as cm:
+            jit("()")(add)
+        self.assertIn(tmpl % 0, str(cm.exception))
+        with self.assertRaises(TypeError) as cm:
+            jit("(intc,)")(add)
+        self.assertIn(tmpl % 1, str(cm.exception))
+        with self.assertRaises(TypeError) as cm:
+            jit("(intc,intc,intc)")(add)
+        self.assertIn(tmpl % 3, str(cm.exception))
+        # With forceobj=True, an empty tuple is accepted
+        jit("()", forceobj=True)(add)
+        with self.assertRaises(TypeError) as cm:
+            jit("(intc,)", forceobj=True)(add)
+        self.assertIn(tmpl % 1, str(cm.exception))
+
+    def test_matching_error_message(self):
+        f = jit("(intc,intc)")(add)
+        with self.assertRaises(TypeError) as cm:
+            f(1j, 1j)
+        self.assertEqual(str(cm.exception),
+                         "No matching definition for argument type(s) "
+                         "complex128, complex128")
+
+    def test_disabled_compilation(self):
+        @jit
+        def foo(a):
+            return a
+
+        foo.compile("(float32,)")
+        foo.disable_compile()
+        with self.assertRaises(RuntimeError) as raises:
+            foo.compile("(int32,)")
+        self.assertEqual(str(raises.exception), "compilation disabled")
+        self.assertEqual(len(foo.signatures), 1)
+
+    def test_disabled_compilation_through_list(self):
+        @jit(["(float32,)", "(int32,)"])
+        def foo(a):
+            return a
+
+        with self.assertRaises(RuntimeError) as raises:
+            foo.compile("(complex64,)")
+        self.assertEqual(str(raises.exception), "compilation disabled")
+        self.assertEqual(len(foo.signatures), 2)
+
+    def test_disabled_compilation_nested_call(self):
+        @jit(["(intp,)"])
+        def foo(a):
+            return a
+
+        @jit
+        def bar():
+            foo(1)
+            foo(np.ones(1))  # no matching definition
+
+        with self.assertRaises(errors.TypingError) as raises:
+            bar()
+
+        m = r".*Invalid use of.*with parameters \(array\(float64, 1d, C\)\).*"
+        self.assertRegex(str(raises.exception), m)
+
+    def test_fingerprint_failure(self):
+        """
+        Failure in computing the fingerprint cannot affect a nopython=False
+        function.  On the other hand, with nopython=True, a ValueError should
+        be raised to report the failure with fingerprint.
+        """
+        def foo(x):
+            return x
+
+        # Empty list will trigger failure in compile_fingerprint
+        errmsg = 'cannot compute fingerprint of empty list'
+        with self.assertRaises(ValueError) as raises:
+            _dispatcher.compute_fingerprint([])
+        self.assertIn(errmsg, str(raises.exception))
+        # It should work in objmode
+        objmode_foo = jit(forceobj=True)(foo)
+        self.assertEqual(objmode_foo([]), [])
+        # But, not in nopython=True
+        strict_foo = jit(nopython=True)(foo)
+        with self.assertRaises(ValueError) as raises:
+            strict_foo([])
+        self.assertIn(errmsg, str(raises.exception))
+
+        # Test in loop lifting context
+        @jit(forceobj=True)
+        def bar():
+            object()  # force looplifting
+            x = []
+            for i in range(10):
+                x = objmode_foo(x)
+            return x
+
+        self.assertEqual(bar(), [])
+        # Make sure it was looplifted
+        [cr] = bar.overloads.values()
+        self.assertEqual(len(cr.lifted), 1)
+
+    def test_serialization(self):
+        """
+        Test serialization of Dispatcher objects
+        """
+        @jit(nopython=True)
+        def foo(x):
+            return x + 1
+
+        self.assertEqual(foo(1), 2)
+
+        # get serialization memo
+        memo = Dispatcher._memo
+        Dispatcher._recent.clear()
+        memo_size = len(memo)
+
+        # pickle foo and check memo size
+        serialized_foo = pickle.dumps(foo)
+        # increases the memo size
+        self.assertEqual(memo_size + 1, len(memo))
+
+        # unpickle
+        foo_rebuilt = pickle.loads(serialized_foo)
+        self.assertEqual(memo_size + 1, len(memo))
+
+        self.assertIs(foo, foo_rebuilt)
+
+        # do we get the same object even if we delete all the explicit
+        # references?
+        id_orig = id(foo_rebuilt)
+        del foo
+        del foo_rebuilt
+        self.assertEqual(memo_size + 1, len(memo))
+        new_foo = pickle.loads(serialized_foo)
+        self.assertEqual(id_orig, id(new_foo))
+
+        # now clear the recent cache
+        ref = weakref.ref(new_foo)
+        del new_foo
+        Dispatcher._recent.clear()
+        self.assertEqual(memo_size, len(memo))
+
+        # show that deserializing creates a new object
+        pickle.loads(serialized_foo)
+        self.assertIs(ref(), None)
+
+    @needs_lapack
+    @unittest.skipIf(_is_armv7l, "Unaligned loads unsupported")
+    def test_misaligned_array_dispatch(self):
+        # for context see issue #2937
+        def foo(a):
+            return np.linalg.matrix_power(a, 1)
+
+        jitfoo = jit(nopython=True)(foo)
+
+        n = 64
+        r = int(np.sqrt(n))
+        dt = np.int8
+        count = np.complex128().itemsize // dt().itemsize
+
+        tmp = np.arange(n * count + 1, dtype=dt)
+
+        # create some arrays as Cartesian production of:
+        # [F/C] x [aligned/misaligned]
+        C_contig_aligned = tmp[:-1].view(np.complex128).reshape(r, r)
+        C_contig_misaligned = tmp[1:].view(np.complex128).reshape(r, r)
+        F_contig_aligned = C_contig_aligned.T
+        F_contig_misaligned = C_contig_misaligned.T
+
+        # checking routine
+        def check(name, a):
+            a[:, :] = np.arange(n, dtype=np.complex128).reshape(r, r)
+            expected = foo(a)
+            got = jitfoo(a)
+            np.testing.assert_allclose(expected, got)
+
+        # The checks must be run in this order to create the dispatch key
+        # sequence that causes invalid dispatch noted in #2937.
+        # The first two should hit the cache as they are aligned, supported
+        # order and under 5 dimensions. The second two should end up in the
+        # fallback path as they are misaligned.
+        check("C_contig_aligned", C_contig_aligned)
+        check("F_contig_aligned", F_contig_aligned)
+        check("C_contig_misaligned", C_contig_misaligned)
+        check("F_contig_misaligned", F_contig_misaligned)
+
+    @unittest.skipIf(_is_armv7l, "Unaligned loads unsupported")
+    def test_immutability_in_array_dispatch(self):
+
+        # RO operation in function
+        def foo(a):
+            return np.sum(a)
+
+        jitfoo = jit(nopython=True)(foo)
+
+        n = 64
+        r = int(np.sqrt(n))
+        dt = np.int8
+        count = np.complex128().itemsize // dt().itemsize
+
+        tmp = np.arange(n * count + 1, dtype=dt)
+
+        # create some arrays as Cartesian production of:
+        # [F/C] x [aligned/misaligned]
+        C_contig_aligned = tmp[:-1].view(np.complex128).reshape(r, r)
+        C_contig_misaligned = tmp[1:].view(np.complex128).reshape(r, r)
+        F_contig_aligned = C_contig_aligned.T
+        F_contig_misaligned = C_contig_misaligned.T
+
+        # checking routine
+        def check(name, a, disable_write_bit=False):
+            a[:, :] = np.arange(n, dtype=np.complex128).reshape(r, r)
+            if disable_write_bit:
+                a.flags.writeable = False
+            expected = foo(a)
+            got = jitfoo(a)
+            np.testing.assert_allclose(expected, got)
+
+        # all of these should end up in the fallback path as they have no write
+        # bit set
+        check("C_contig_aligned", C_contig_aligned, disable_write_bit=True)
+        check("F_contig_aligned", F_contig_aligned, disable_write_bit=True)
+        check("C_contig_misaligned", C_contig_misaligned,
+              disable_write_bit=True)
+        check("F_contig_misaligned", F_contig_misaligned,
+              disable_write_bit=True)
+
+    @needs_lapack
+    @unittest.skipIf(_is_armv7l, "Unaligned loads unsupported")
+    def test_misaligned_high_dimension_array_dispatch(self):
+
+        def foo(a):
+            return np.linalg.matrix_power(a[0, 0, 0, 0, :, :], 1)
+
+        jitfoo = jit(nopython=True)(foo)
+
+        def check_properties(arr, layout, aligned):
+            self.assertEqual(arr.flags.aligned, aligned)
+            if layout == "C":
+                self.assertEqual(arr.flags.c_contiguous, True)
+            if layout == "F":
+                self.assertEqual(arr.flags.f_contiguous, True)
+
+        n = 729
+        r = 3
+        dt = np.int8
+        count = np.complex128().itemsize // dt().itemsize
+
+        tmp = np.arange(n * count + 1, dtype=dt)
+
+        # create some arrays as Cartesian production of:
+        # [F/C] x [aligned/misaligned]
+        C_contig_aligned = tmp[:-1].view(np.complex128).\
+            reshape(r, r, r, r, r, r)
+        check_properties(C_contig_aligned, 'C', True)
+        C_contig_misaligned = tmp[1:].view(np.complex128).\
+            reshape(r, r, r, r, r, r)
+        check_properties(C_contig_misaligned, 'C', False)
+        F_contig_aligned = C_contig_aligned.T
+        check_properties(F_contig_aligned, 'F', True)
+        F_contig_misaligned = C_contig_misaligned.T
+        check_properties(F_contig_misaligned, 'F', False)
+
+        # checking routine
+        def check(name, a):
+            a[:, :] = np.arange(n, dtype=np.complex128).\
+                reshape(r, r, r, r, r, r)
+            expected = foo(a)
+            got = jitfoo(a)
+            np.testing.assert_allclose(expected, got)
+
+        # these should all hit the fallback path as the cache is only for up to
+        # 5 dimensions
+        check("F_contig_misaligned", F_contig_misaligned)
+        check("C_contig_aligned", C_contig_aligned)
+        check("F_contig_aligned", F_contig_aligned)
+        check("C_contig_misaligned", C_contig_misaligned)
+
+    def test_dispatch_recompiles_for_scalars(self):
+        # for context #3612, essentially, compiling a lambda x:x for a
+        # numerically wide type (everything can be converted to a complex128)
+        # and then calling again with e.g. an int32 would lead to the int32
+        # being converted to a complex128 whereas it ought to compile an int32
+        # specialization.
+        def foo(x):
+            return x
+
+        # jit and compile on dispatch for 3 scalar types, expect 3 signatures
+        jitfoo = jit(nopython=True)(foo)
+        jitfoo(np.complex128(1 + 2j))
+        jitfoo(np.int32(10))
+        jitfoo(np.bool_(False))
+        self.assertEqual(len(jitfoo.signatures), 3)
+        expected_sigs = [(types.complex128,), (types.int32,), (types.bool_,)]
+        self.assertEqual(jitfoo.signatures, expected_sigs)
+
+        # now jit with signatures so recompilation is forbidden
+        # expect 1 signature and type conversion
+        jitfoo = jit([(types.complex128,)], nopython=True)(foo)
+        jitfoo(np.complex128(1 + 2j))
+        jitfoo(np.int32(10))
+        jitfoo(np.bool_(False))
+        self.assertEqual(len(jitfoo.signatures), 1)
+        expected_sigs = [(types.complex128,)]
+        self.assertEqual(jitfoo.signatures, expected_sigs)
+
+    def test_dispatcher_raises_for_invalid_decoration(self):
+        # For context see https://github.com/numba/numba/issues/4750.
+
+        @jit(nopython=True)
+        def foo(x):
+            return x
+
+        with self.assertRaises(TypeError) as raises:
+            jit(foo)
+        err_msg = str(raises.exception)
+        self.assertIn(
+            "A jit decorator was called on an already jitted function", err_msg)
+        self.assertIn("foo", err_msg)
+        self.assertIn(".py_func", err_msg)
+
+        with self.assertRaises(TypeError) as raises:
+            jit(BaseTest)
+        err_msg = str(raises.exception)
+        self.assertIn("The decorated object is not a function", err_msg)
+        self.assertIn(f"{type(BaseTest)}", err_msg)
+
+
+class TestSignatureHandling(BaseTest):
+    """
+    Test support for various parameter passing styles.
+    """
+
+    def test_named_args(self):
+        """
+        Test passing named arguments to a dispatcher.
+        """
+        f, check = self.compile_func(addsub)
+        check(3, z=10, y=4)
+        check(3, 4, 10)
+        check(x=3, y=4, z=10)
+        # All calls above fall under the same specialization
+        self.assertEqual(len(f.overloads), 1)
+        # Errors
+        with self.assertRaises(TypeError) as cm:
+            f(3, 4, y=6, z=7)
+        self.assertIn("too many arguments: expected 3, got 4",
+                      str(cm.exception))
+        with self.assertRaises(TypeError) as cm:
+            f()
+        self.assertIn("not enough arguments: expected 3, got 0",
+                      str(cm.exception))
+        with self.assertRaises(TypeError) as cm:
+            f(3, 4, y=6)
+        self.assertIn("missing argument 'z'", str(cm.exception))
+
+    def test_default_args(self):
+        """
+        Test omitting arguments with a default value.
+        """
+        f, check = self.compile_func(addsub_defaults)
+        check(3, z=10, y=4)
+        check(3, 4, 10)
+        check(x=3, y=4, z=10)
+        # Now omitting some values
+        check(3, z=10)
+        check(3, 4)
+        check(x=3, y=4)
+        check(3)
+        check(x=3)
+        # Errors
+        with self.assertRaises(TypeError) as cm:
+            f(3, 4, y=6, z=7)
+        self.assertIn("too many arguments: expected 3, got 4",
+                      str(cm.exception))
+        with self.assertRaises(TypeError) as cm:
+            f()
+        self.assertIn("not enough arguments: expected at least 1, got 0",
+                      str(cm.exception))
+        with self.assertRaises(TypeError) as cm:
+            f(y=6, z=7)
+        self.assertIn("missing argument 'x'", str(cm.exception))
+
+    def test_star_args(self):
+        """
+        Test a compiled function with starargs in the signature.
+        """
+        f, check = self.compile_func(star_defaults)
+        check(4)
+        check(4, 5)
+        check(4, 5, 6)
+        check(4, 5, 6, 7)
+        check(4, 5, 6, 7, 8)
+        check(x=4)
+        check(x=4, y=5)
+        check(4, y=5)
+        with self.assertRaises(TypeError) as cm:
+            f(4, 5, y=6)
+        self.assertIn("some keyword arguments unexpected", str(cm.exception))
+        with self.assertRaises(TypeError) as cm:
+            f(4, 5, z=6)
+        self.assertIn("some keyword arguments unexpected", str(cm.exception))
+        with self.assertRaises(TypeError) as cm:
+            f(4, x=6)
+        self.assertIn("some keyword arguments unexpected", str(cm.exception))
+
+
+class TestSignatureHandlingObjectMode(TestSignatureHandling):
+    """
+    Sams as TestSignatureHandling, but in object mode.
+    """
+
+    jit_args = dict(forceobj=True)
+
+
+class TestDispatcherMethods(TestCase):
+
+    def test_recompile(self):
+        closure = 1
+
+        @jit
+        def foo(x):
+            return x + closure
+        self.assertPreciseEqual(foo(1), 2)
+        self.assertPreciseEqual(foo(1.5), 2.5)
+        self.assertEqual(len(foo.signatures), 2)
+        closure = 2
+        self.assertPreciseEqual(foo(1), 2)
+        # Recompiling takes the new closure into account.
+        foo.recompile()
+        # Everything was recompiled
+        self.assertEqual(len(foo.signatures), 2)
+        self.assertPreciseEqual(foo(1), 3)
+        self.assertPreciseEqual(foo(1.5), 3.5)
+
+    def test_recompile_signatures(self):
+        # Same as above, but with an explicit signature on @jit.
+        closure = 1
+
+        @jit("int32(int32)")
+        def foo(x):
+            return x + closure
+        self.assertPreciseEqual(foo(1), 2)
+        self.assertPreciseEqual(foo(1.5), 2)
+        closure = 2
+        self.assertPreciseEqual(foo(1), 2)
+        # Recompiling takes the new closure into account.
+        foo.recompile()
+        self.assertPreciseEqual(foo(1), 3)
+        self.assertPreciseEqual(foo(1.5), 3)
+
+    def test_inspect_llvm(self):
+        # Create a jited function
+        @jit
+        def foo(explicit_arg1, explicit_arg2):
+            return explicit_arg1 + explicit_arg2
+
+        # Call it in a way to create 3 signatures
+        foo(1, 1)
+        foo(1.0, 1)
+        foo(1.0, 1.0)
+
+        # base call to get all llvm in a dict
+        llvms = foo.inspect_llvm()
+        self.assertEqual(len(llvms), 3)
+
+        # make sure the function name shows up in the llvm
+        for llvm_bc in llvms.values():
+            # Look for the function name
+            self.assertIn("foo", llvm_bc)
+
+            # Look for the argument names
+            self.assertIn("explicit_arg1", llvm_bc)
+            self.assertIn("explicit_arg2", llvm_bc)
+
+    def test_inspect_asm(self):
+        # Create a jited function
+        @jit
+        def foo(explicit_arg1, explicit_arg2):
+            return explicit_arg1 + explicit_arg2
+
+        # Call it in a way to create 3 signatures
+        foo(1, 1)
+        foo(1.0, 1)
+        foo(1.0, 1.0)
+
+        # base call to get all llvm in a dict
+        asms = foo.inspect_asm()
+        self.assertEqual(len(asms), 3)
+
+        # make sure the function name shows up in the llvm
+        for asm in asms.values():
+            # Look for the function name
+            self.assertTrue("foo" in asm)
+
+    def _check_cfg_display(self, cfg, wrapper=''):
+        # simple stringify test
+        if wrapper:
+            wrapper = "{}{}".format(len(wrapper), wrapper)
+        module_name = __name__.split('.', 1)[0]
+        module_len = len(module_name)
+        prefix = r'^digraph "CFG for \'_ZN{}{}{}'.format(wrapper,
+                                                         module_len,
+                                                         module_name)
+        self.assertRegex(str(cfg), prefix)
+        # .display() requires an optional dependency on `graphviz`.
+        # just test for the attribute without running it.
+        self.assertTrue(callable(cfg.display))
+
+    def test_inspect_cfg(self):
+        # Exercise the .inspect_cfg(). These are minimal tests and do not fully
+        # check the correctness of the function.
+        @jit
+        def foo(the_array):
+            return the_array.sum()
+
+        # Generate 3 overloads
+        a1 = np.ones(1)
+        a2 = np.ones((1, 1))
+        a3 = np.ones((1, 1, 1))
+        foo(a1)
+        foo(a2)
+        foo(a3)
+
+        # Call inspect_cfg() without arguments
+        cfgs = foo.inspect_cfg()
+
+        # Correct count of overloads
+        self.assertEqual(len(cfgs), 3)
+
+        # Makes sure all the signatures are correct
+        [s1, s2, s3] = cfgs.keys()
+        self.assertEqual(set([s1, s2, s3]),
+                         set(map(lambda x: (typeof(x),), [a1, a2, a3])))
+
+        for cfg in cfgs.values():
+            self._check_cfg_display(cfg)
+        self.assertEqual(len(list(cfgs.values())), 3)
+
+        # Call inspect_cfg(signature)
+        cfg = foo.inspect_cfg(signature=foo.signatures[0])
+        self._check_cfg_display(cfg)
+
+    def test_inspect_cfg_with_python_wrapper(self):
+        # Exercise the .inspect_cfg() including the python wrapper.
+        # These are minimal tests and do not fully check the correctness of
+        # the function.
+        @jit
+        def foo(the_array):
+            return the_array.sum()
+
+        # Generate 3 overloads
+        a1 = np.ones(1)
+        a2 = np.ones((1, 1))
+        a3 = np.ones((1, 1, 1))
+        foo(a1)
+        foo(a2)
+        foo(a3)
+
+        # Call inspect_cfg(signature, show_wrapper="python")
+        cfg = foo.inspect_cfg(signature=foo.signatures[0],
+                              show_wrapper="python")
+        self._check_cfg_display(cfg, wrapper='cpython')
+
+    def test_inspect_types(self):
+        @jit
+        def foo(a, b):
+            return a + b
+
+        foo(1, 2)
+        # Exercise the method
+        foo.inspect_types(StringIO())
+
+        # Test output
+        expected = str(foo.overloads[foo.signatures[0]].type_annotation)
+        with captured_stdout() as out:
+            foo.inspect_types()
+        assert expected in out.getvalue()
+
+    def test_inspect_types_with_signature(self):
+        @jit
+        def foo(a):
+            return a + 1
+
+        foo(1)
+        foo(1.0)
+        # Inspect all signatures
+        with captured_stdout() as total:
+            foo.inspect_types()
+        # Inspect first signature
+        with captured_stdout() as first:
+            foo.inspect_types(signature=foo.signatures[0])
+        # Inspect second signature
+        with captured_stdout() as second:
+            foo.inspect_types(signature=foo.signatures[1])
+
+        self.assertEqual(total.getvalue(), first.getvalue() + second.getvalue())
+
+    @unittest.skipIf(jinja2 is None, "please install the 'jinja2' package")
+    @unittest.skipIf(pygments is None, "please install the 'pygments' package")
+    def test_inspect_types_pretty(self):
+        @jit
+        def foo(a, b):
+            return a + b
+
+        foo(1, 2)
+
+        # Exercise the method, dump the output
+        with captured_stdout():
+            ann = foo.inspect_types(pretty=True)
+
+        # ensure HTML <span> is found in the annotation output
+        for k, v in ann.ann.items():
+            span_found = False
+            for line in v['pygments_lines']:
+                if 'span' in line[2]:
+                    span_found = True
+            self.assertTrue(span_found)
+
+        # check that file+pretty kwarg combo raises
+        with self.assertRaises(ValueError) as raises:
+            foo.inspect_types(file=StringIO(), pretty=True)
+
+        self.assertIn("`file` must be None if `pretty=True`",
+                      str(raises.exception))
+
+    def test_get_annotation_info(self):
+        @jit
+        def foo(a):
+            return a + 1
+
+        foo(1)
+        foo(1.3)
+
+        expected = dict(chain.from_iterable(foo.get_annotation_info(i).items()
+                                            for i in foo.signatures))
+        result = foo.get_annotation_info()
+        self.assertEqual(expected, result)
+
+    def test_issue_with_array_layout_conflict(self):
+        """
+        This test an issue with the dispatcher when an array that is both
+        C and F contiguous is supplied as the first signature.
+        The dispatcher checks for F contiguous first but the compiler checks
+        for C contiguous first. This results in an C contiguous code inserted
+        as F contiguous function.
+        """
+        def pyfunc(A, i, j):
+            return A[i, j]
+
+        cfunc = jit(pyfunc)
+
+        ary_c_and_f = np.array([[1.]])
+        ary_c = np.array([[0., 1.], [2., 3.]], order='C')
+        ary_f = np.array([[0., 1.], [2., 3.]], order='F')
+
+        exp_c = pyfunc(ary_c, 1, 0)
+        exp_f = pyfunc(ary_f, 1, 0)
+
+        self.assertEqual(1., cfunc(ary_c_and_f, 0, 0))
+        got_c = cfunc(ary_c, 1, 0)
+        got_f = cfunc(ary_f, 1, 0)
+
+        self.assertEqual(exp_c, got_c)
+        self.assertEqual(exp_f, got_f)
+
+
+class TestDispatcherFunctionBoundaries(TestCase):
+    def test_pass_dispatcher_as_arg(self):
+        # Test that a Dispatcher object can be pass as argument
+        @jit(nopython=True)
+        def add1(x):
+            return x + 1
+
+        @jit(nopython=True)
+        def bar(fn, x):
+            return fn(x)
+
+        @jit(nopython=True)
+        def foo(x):
+            return bar(add1, x)
+
+        # Check dispatcher as argument inside NPM
+        inputs = [1, 11.1, np.arange(10)]
+        expected_results = [x + 1 for x in inputs]
+
+        for arg, expect in zip(inputs, expected_results):
+            self.assertPreciseEqual(foo(arg), expect)
+
+        # Check dispatcher as argument from python
+        for arg, expect in zip(inputs, expected_results):
+            self.assertPreciseEqual(bar(add1, arg), expect)
+
+    def test_dispatcher_as_arg_usecase(self):
+        @jit(nopython=True)
+        def maximum(seq, cmpfn):
+            tmp = seq[0]
+            for each in seq[1:]:
+                cmpval = cmpfn(tmp, each)
+                if cmpval < 0:
+                    tmp = each
+            return tmp
+
+        got = maximum([1, 2, 3, 4], cmpfn=jit(lambda x, y: x - y))
+        self.assertEqual(got, 4)
+        got = maximum(list(zip(range(5), range(5)[::-1])),
+                      cmpfn=jit(lambda x, y: x[0] - y[0]))
+        self.assertEqual(got, (4, 0))
+        got = maximum(list(zip(range(5), range(5)[::-1])),
+                      cmpfn=jit(lambda x, y: x[1] - y[1]))
+        self.assertEqual(got, (0, 4))
+
+    def test_dispatcher_can_return_to_python(self):
+        @jit(nopython=True)
+        def foo(fn):
+            return fn
+
+        fn = jit(lambda x: x)
+
+        self.assertEqual(foo(fn), fn)
+
+    def test_dispatcher_in_sequence_arg(self):
+        @jit(nopython=True)
+        def one(x):
+            return x + 1
+
+        @jit(nopython=True)
+        def two(x):
+            return one(one(x))
+
+        @jit(nopython=True)
+        def three(x):
+            return one(one(one(x)))
+
+        @jit(nopython=True)
+        def choose(fns, x):
+            return fns[0](x), fns[1](x), fns[2](x)
+
+        # Tuple case
+        self.assertEqual(choose((one, two, three), 1), (2, 3, 4))
+        # List case
+        self.assertEqual(choose([one, one, one], 1), (2, 2, 2))
+
+
+class TestBoxingDefaultError(unittest.TestCase):
+    # Testing default error at boxing/unboxing
+    def test_unbox_runtime_error(self):
+        # Dummy type has no unbox support
+        def foo(x):
+            pass
+        argtys = (types.Dummy("dummy_type"),)
+        # This needs `compile_isolated`-like behaviour so as to bypass
+        # dispatcher type checking logic
+        cres = njit(argtys)(foo).overloads[argtys]
+        with self.assertRaises(TypeError) as raises:
+            # Can pass in whatever and the unbox logic will always raise
+            # without checking the input value.
+            cres.entry_point(None)
+        self.assertEqual(str(raises.exception), "can't unbox dummy_type type")
+
+    def test_box_runtime_error(self):
+        @njit
+        def foo():
+            return unittest  # Module type has no boxing logic
+        with self.assertRaises(TypeError) as raises:
+            foo()
+        pat = "cannot convert native Module.* to Python object"
+        self.assertRegex(str(raises.exception), pat)
+
+
+class TestNoRetryFailedSignature(unittest.TestCase):
+    """Test that failed-to-compile signatures are not recompiled.
+    """
+
+    def run_test(self, func):
+        fcom = func._compiler
+        self.assertEqual(len(fcom._failed_cache), 0)
+        # expected failure because `int` has no `__getitem__`
+        with self.assertRaises(errors.TypingError):
+            func(1)
+        self.assertEqual(len(fcom._failed_cache), 1)
+        # retry
+        with self.assertRaises(errors.TypingError):
+            func(1)
+        self.assertEqual(len(fcom._failed_cache), 1)
+        # retry with double
+        with self.assertRaises(errors.TypingError):
+            func(1.0)
+        self.assertEqual(len(fcom._failed_cache), 2)
+
+    def test_direct_call(self):
+        @jit(nopython=True)
+        def foo(x):
+            return x[0]
+
+        self.run_test(foo)
+
+    def test_nested_call(self):
+        @jit(nopython=True)
+        def bar(x):
+            return x[0]
+
+        @jit(nopython=True)
+        def foobar(x):
+            bar(x)
+
+        @jit(nopython=True)
+        def foo(x):
+            return bar(x) + foobar(x)
+
+        self.run_test(foo)
+
+    @unittest.expectedFailure
+    # NOTE: @overload does not have an error cache. See PR #9259 for this
+    # feature and remove the xfail once this is merged.
+    def test_error_count(self):
+        def check(field, would_fail):
+            # Slightly modified from the reproducer in issue #4117.
+            # Before the patch, the compilation time of the failing case is
+            # much longer than of the successful case. This can be detected
+            # by the number of times `trigger()` is visited.
+            k = 10
+            counter = {'c': 0}
+
+            def trigger(x):
+                assert 0, "unreachable"
+
+            @overload(trigger)
+            def ol_trigger(x):
+                # Keep track of every visit
+                counter['c'] += 1
+                if would_fail:
+                    raise errors.TypingError("invoke_failed")
+                return lambda x: x
+
+            @jit(nopython=True)
+            def ident(out, x):
+                pass
+
+            def chain_assign(fs, inner=ident):
+                tab_head, tab_tail = fs[-1], fs[:-1]
+
+                @jit(nopython=True)
+                def assign(out, x):
+                    inner(out, x)
+                    out[0] += tab_head(x)
+
+                if tab_tail:
+                    return chain_assign(tab_tail, assign)
+                else:
+                    return assign
+
+            chain = chain_assign((trigger,) * k)
+            out = np.ones(2)
+            if would_fail:
+                with self.assertRaises(errors.TypingError) as raises:
+                    chain(out, 1)
+                self.assertIn('invoke_failed', str(raises.exception))
+            else:
+                chain(out, 1)
+
+            # Returns the visit counts
+            return counter['c']
+
+        ct_ok = check('a', False)
+        ct_bad = check('c', True)
+        # `trigger()` is visited exactly once for both successful and failed
+        # compilation.
+        self.assertEqual(ct_ok, 1)
+        self.assertEqual(ct_bad, 1)
+
+
+@njit
+def add_y1(x, y=1):
+    return x + y
+
+
+@njit
+def add_ynone(x, y=None):
+    return x + (1 if y else 2)
+
+
+@njit
+def mult(x, y):
+    return x * y
+
+
+@njit
+def add_func(x, func=mult):
+    return x + func(x, x)
+
+
+def _checker(f1, arg):
+    assert f1(arg) == f1.py_func(arg)
+
+
+class TestMultiprocessingDefaultParameters(SerialMixin, unittest.TestCase):
+    def run_fc_multiproc(self, fc):
+        try:
+            ctx = multiprocessing.get_context('spawn')
+        except AttributeError:
+            ctx = multiprocessing
+
+        # RE: issue #5973, this doesn't use multiprocessing.Pool.map as doing so
+        # causes the TBB library to segfault under certain conditions. It's not
+        # clear whether the cause is something in the complexity of the Pool
+        # itself, e.g. watcher threads etc, or if it's a problem synonymous with
+        # a "timing attack".
+        for a in [1, 2, 3]:
+            p = ctx.Process(target=_checker, args=(fc, a,))
+            p.start()
+            p.join(_TEST_TIMEOUT)
+            self.assertEqual(p.exitcode, 0)
+
+    def test_int_def_param(self):
+        """ Tests issue #4888"""
+
+        self.run_fc_multiproc(add_y1)
+
+    def test_none_def_param(self):
+        """ Tests None as a default parameter"""
+
+        self.run_fc_multiproc(add_func)
+
+    def test_function_def_param(self):
+        """ Tests a function as a default parameter"""
+
+        self.run_fc_multiproc(add_func)
+
+
+class TestVectorizeDifferentTargets(unittest.TestCase):
+    """Test that vectorize can be reapplied if the target is different
+    """
+
+    def test_cpu_vs_parallel(self):
+        @jit
+        def add(x, y):
+            return x + y
+
+        custom_vectorize = vectorize([], identity=None, target='cpu')
+
+        custom_vectorize(add)
+
+        custom_vectorize_2 = vectorize([], identity=None, target='parallel')
+
+        custom_vectorize_2(add)
+
+
+if __name__ == '__main__':
+    unittest.main()

lib/python3.10/site-packages/numba/tests/test_exceptions.py

@@ -0,0 +1,475 @@
+import numpy as np
+import sys
+import traceback
+
+from numba import jit, njit
+from numba.core import types, errors, utils
+from numba.tests.support import (TestCase, expected_failure_py311,
+                                 expected_failure_py312,
+                                 expected_failure_py313,
+                                 )
+import unittest
+
+
+force_pyobj_flags = {'nopython': False, 'forceobj': True}
+no_pyobj_flags = {'nopython': True, '_nrt': False}
+no_pyobj_flags_w_nrt = {'nopython': True, '_nrt': True}
+no_gil_flags = {'nopython': True, 'nogil': True, '_nrt': True}
+
+
+class MyError(Exception):
+    pass
+
+
+class OtherError(Exception):
+    pass
+
+
+class UDEArgsToSuper(Exception):
+    def __init__(self, arg, value0):
+        super(UDEArgsToSuper, self).__init__(arg)
+        self.value0 = value0
+
+    def __eq__(self, other):
+        if not isinstance(other, self.__class__):
+            return False
+        same = True
+        same |= self.args == other.args
+        same |= self.value0 == other.value0
+        return same
+
+    def __hash__(self):
+        return hash((super(UDEArgsToSuper).__hash__(), self.value0))
+
+
+class UDENoArgSuper(Exception):
+    def __init__(self, arg, value0):
+        super(UDENoArgSuper, self).__init__()
+        self.deferarg = arg
+        self.value0 = value0
+
+    def __eq__(self, other):
+        if not isinstance(other, self.__class__):
+            return False
+        same = True
+        same |= self.args == other.args
+        same |= self.deferarg == other.deferarg
+        same |= self.value0 == other.value0
+        return same
+
+    def __hash__(self):
+        return hash((super(UDENoArgSuper).__hash__(), self.deferarg,
+                     self.value0))
+
+
+def raise_class(exc):
+    def raiser(i):
+        if i == 1:
+            raise exc
+        elif i == 2:
+            raise ValueError
+        elif i == 3:
+            # The exception type is looked up on a module (issue #1624)
+            raise np.linalg.LinAlgError
+        return i
+    return raiser
+
+
+def raise_instance(exc, arg):
+    def raiser(i):
+        if i == 1:
+            raise exc(arg, 1)
+        elif i == 2:
+            raise ValueError(arg, 2)
+        elif i == 3:
+            raise np.linalg.LinAlgError(arg, 3)
+        return i
+    return raiser
+
+
+def raise_instance_runtime_args(exc):
+    def raiser(i, arg):
+        if i == 1:
+            raise exc(arg, 1)
+        elif i == 2:
+            raise ValueError(arg, 2)
+        elif i == 3:
+            raise np.linalg.LinAlgError(arg, 3)
+        return i
+    return raiser
+
+
+def reraise():
+    raise
+
+
+def outer_function(inner):
+    def outer(i):
+        if i == 3:
+            raise OtherError("bar", 3)
+        return inner(i)
+    return outer
+
+
+def assert_usecase(i):
+    assert i == 1, "bar"
+
+
+def ude_bug_usecase():
+    raise UDEArgsToSuper()  # oops user forgot args to exception ctor
+
+
+def raise_runtime_value(arg):
+    raise ValueError(arg)
+
+
+class TestRaising(TestCase):
+
+    def test_unituple_index_error(self):
+        def pyfunc(a, i):
+            return a.shape[i]
+
+        cfunc = njit((types.Array(types.int32, 1, 'A'), types.int32),)(pyfunc)
+
+        a = np.empty(2, dtype=np.int32)
+
+        self.assertEqual(cfunc(a, 0), pyfunc(a, 0))
+
+        with self.assertRaises(IndexError) as cm:
+            cfunc(a, 2)
+        self.assertEqual(str(cm.exception), "tuple index out of range")
+
+    def check_against_python(self, exec_mode, pyfunc, cfunc,
+                             expected_error_class, *args):
+
+        assert exec_mode in (force_pyobj_flags, no_pyobj_flags,
+                             no_pyobj_flags_w_nrt, no_gil_flags)
+
+        # invariant of mode, check the error class and args are the same
+        with self.assertRaises(expected_error_class) as pyerr:
+            pyfunc(*args)
+        with self.assertRaises(expected_error_class) as jiterr:
+            cfunc(*args)
+        self.assertEqual(pyerr.exception.args, jiterr.exception.args)
+
+        # special equality check for UDEs
+        if isinstance(pyerr.exception, (UDEArgsToSuper, UDENoArgSuper)):
+            self.assertTrue(pyerr.exception == jiterr.exception)
+
+        # in npm check bottom of traceback matches as frame injection with
+        # location info should ensure this
+        if exec_mode is no_pyobj_flags:
+
+            # we only care about the bottom two frames, the error and the
+            # location it was raised.
+            try:
+                pyfunc(*args)
+            except Exception:
+                py_frames = traceback.format_exception(*sys.exc_info())
+                expected_frames = py_frames[-2:]
+
+            try:
+                cfunc(*args)
+            except Exception:
+                c_frames = traceback.format_exception(*sys.exc_info())
+                got_frames = c_frames[-2:]
+
+            # check exception and the injected frame are the same
+            for expf, gotf in zip(expected_frames, got_frames):
+                # Note use of assertIn not assertEqual, Py 3.11 has markers (^)
+                # that point to the variable causing the problem, Numba doesn't
+                # do this so only the start of the string will match.
+                self.assertIn(gotf, expf)
+
+    def check_raise_class(self, flags):
+        pyfunc = raise_class(MyError)
+        cfunc = jit((types.int32,), **flags)(pyfunc)
+        self.assertEqual(cfunc(0), 0)
+        self.check_against_python(flags, pyfunc, cfunc, MyError, 1)
+        self.check_against_python(flags, pyfunc, cfunc, ValueError, 2)
+        self.check_against_python(flags, pyfunc, cfunc,
+                                  np.linalg.linalg.LinAlgError, 3)
+
+    def test_raise_class_nopython(self):
+        self.check_raise_class(flags=no_pyobj_flags)
+
+    def test_raise_class_objmode(self):
+        self.check_raise_class(flags=force_pyobj_flags)
+
+    def check_raise_instance(self, flags):
+        for clazz in [MyError, UDEArgsToSuper,
+                      UDENoArgSuper]:
+            pyfunc = raise_instance(clazz, "some message")
+            cfunc = jit((types.int32,), **flags)(pyfunc)
+
+            self.assertEqual(cfunc(0), 0)
+            self.check_against_python(flags, pyfunc, cfunc, clazz, 1)
+            self.check_against_python(flags, pyfunc, cfunc, ValueError, 2)
+            self.check_against_python(flags, pyfunc, cfunc,
+                                      np.linalg.linalg.LinAlgError, 3)
+
+    def test_raise_instance_objmode(self):
+        self.check_raise_instance(flags=force_pyobj_flags)
+
+    def test_raise_instance_nopython(self):
+        self.check_raise_instance(flags=no_pyobj_flags)
+
+    def check_raise_nested(self, flags, **jit_args):
+        """
+        Check exception propagation from nested functions.
+        """
+        for clazz in [MyError, UDEArgsToSuper,
+                      UDENoArgSuper]:
+            inner_pyfunc = raise_instance(clazz, "some message")
+            pyfunc = outer_function(inner_pyfunc)
+            inner_cfunc = jit(**jit_args)(inner_pyfunc)
+            cfunc = jit(**jit_args)(outer_function(inner_cfunc))
+
+            self.check_against_python(flags, pyfunc, cfunc, clazz, 1)
+            self.check_against_python(flags, pyfunc, cfunc, ValueError, 2)
+            self.check_against_python(flags, pyfunc, cfunc, OtherError, 3)
+
+    def test_raise_nested_objmode(self):
+        self.check_raise_nested(force_pyobj_flags, forceobj=True)
+
+    def test_raise_nested_nopython(self):
+        self.check_raise_nested(no_pyobj_flags, nopython=True)
+
+    def check_reraise(self, flags):
+        def raise_exc(exc):
+            raise exc
+        pyfunc = reraise
+        cfunc = jit((), **flags)(pyfunc)
+        for op, err in [(lambda : raise_exc(ZeroDivisionError),
+                         ZeroDivisionError),
+                        (lambda : raise_exc(UDEArgsToSuper("msg", 1)),
+                         UDEArgsToSuper),
+                        (lambda : raise_exc(UDENoArgSuper("msg", 1)),
+                         UDENoArgSuper)]:
+            def gen_impl(fn):
+                def impl():
+                    try:
+                        op()
+                    except err:
+                        fn()
+                return impl
+            pybased = gen_impl(pyfunc)
+            cbased = gen_impl(cfunc)
+            self.check_against_python(flags, pybased, cbased, err,)
+
+    def test_reraise_objmode(self):
+        self.check_reraise(flags=force_pyobj_flags)
+
+    def test_reraise_nopython(self):
+        self.check_reraise(flags=no_pyobj_flags)
+
+    def check_raise_invalid_class(self, cls, flags):
+        pyfunc = raise_class(cls)
+        cfunc = jit((types.int32,), **flags)(pyfunc)
+        with self.assertRaises(TypeError) as cm:
+            cfunc(1)
+        self.assertEqual(str(cm.exception),
+                         "exceptions must derive from BaseException")
+
+    def test_raise_invalid_class_objmode(self):
+        self.check_raise_invalid_class(int, flags=force_pyobj_flags)
+        self.check_raise_invalid_class(1, flags=force_pyobj_flags)
+
+    def test_raise_invalid_class_nopython(self):
+        msg = "Encountered unsupported constant type used for exception"
+        with self.assertRaises(errors.UnsupportedError) as raises:
+            self.check_raise_invalid_class(int, flags=no_pyobj_flags)
+        self.assertIn(msg, str(raises.exception))
+        with self.assertRaises(errors.UnsupportedError) as raises:
+            self.check_raise_invalid_class(1, flags=no_pyobj_flags)
+        self.assertIn(msg, str(raises.exception))
+
+    def test_raise_bare_string_nopython(self):
+        @njit
+        def foo():
+            raise "illegal"
+        msg = ("Directly raising a string constant as an exception is not "
+               "supported")
+        with self.assertRaises(errors.UnsupportedError) as raises:
+            foo()
+        self.assertIn(msg, str(raises.exception))
+
+    def check_assert_statement(self, flags):
+        pyfunc = assert_usecase
+        cfunc = jit((types.int32,), **flags)(pyfunc)
+        cfunc(1)
+        self.check_against_python(flags, pyfunc, cfunc, AssertionError, 2)
+
+    def test_assert_statement_objmode(self):
+        self.check_assert_statement(flags=force_pyobj_flags)
+
+    def test_assert_statement_nopython(self):
+        self.check_assert_statement(flags=no_pyobj_flags)
+
+    def check_raise_from_exec_string(self, flags):
+        # issue #3428
+        simple_raise = "def f(a):\n  raise exc('msg', 10)"
+        assert_raise = "def f(a):\n  assert a != 1"
+        py312_pep695_raise = "def f[T: int](a: T) -> T:\n  assert a != 1"
+        py312_pep695_raise_2 = "def f[T: int\n](a: T) -> T:\n  assert a != 1"
+        test_cases = [
+            (assert_raise, AssertionError),
+            (simple_raise, UDEArgsToSuper),
+            (simple_raise, UDENoArgSuper),
+        ]
+        if utils.PYVERSION >= (3, 12):
+            # Added for https://github.com/numba/numba/issues/9443
+            test_cases.append((py312_pep695_raise, AssertionError))
+            test_cases.append((py312_pep695_raise_2, AssertionError))
+        for f_text, exc in test_cases:
+            loc = {}
+            exec(f_text, {'exc': exc}, loc)
+            pyfunc = loc['f']
+            cfunc = jit((types.int32,), **flags)(pyfunc)
+            self.check_against_python(flags, pyfunc, cfunc, exc, 1)
+
+    def test_assert_from_exec_string_objmode(self):
+        self.check_raise_from_exec_string(flags=force_pyobj_flags)
+
+    def test_assert_from_exec_string_nopython(self):
+        self.check_raise_from_exec_string(flags=no_pyobj_flags)
+
+    def check_user_code_error_traceback(self, flags):
+        # this test checks that if a user tries to compile code that contains
+        # a bug in exception initialisation (e.g. missing arg) then this also
+        # has a frame injected with the location information.
+        pyfunc = ude_bug_usecase
+        cfunc = jit((), **flags)(pyfunc)
+        self.check_against_python(flags, pyfunc, cfunc, TypeError)
+
+    def test_user_code_error_traceback_objmode(self):
+        self.check_user_code_error_traceback(flags=force_pyobj_flags)
+
+    def test_user_code_error_traceback_nopython(self):
+        self.check_user_code_error_traceback(flags=no_pyobj_flags)
+
+    def check_raise_runtime_value(self, flags):
+        pyfunc = raise_runtime_value
+        cfunc = jit((types.string,), **flags)(pyfunc)
+        self.check_against_python(flags, pyfunc, cfunc, ValueError, 'hello')
+
+    def test_raise_runtime_value_objmode(self):
+        self.check_raise_runtime_value(flags=force_pyobj_flags)
+
+    def test_raise_runtime_value_nopython(self):
+        self.check_raise_runtime_value(flags=no_pyobj_flags_w_nrt)
+
+    def test_raise_runtime_value_nogil(self):
+        self.check_raise_runtime_value(flags=no_gil_flags)
+
+    def check_raise_instance_with_runtime_args(self, flags):
+        for clazz in [MyError, UDEArgsToSuper,
+                      UDENoArgSuper]:
+            pyfunc = raise_instance_runtime_args(clazz)
+            cfunc = jit((types.int32, types.string), **flags)(pyfunc)
+
+            self.assertEqual(cfunc(0, 'test'), 0)
+            self.check_against_python(flags, pyfunc, cfunc, clazz, 1, 'hello')
+            self.check_against_python(flags, pyfunc, cfunc, ValueError, 2,
+                                      'world')
+            self.check_against_python(flags, pyfunc, cfunc,
+                                      np.linalg.linalg.LinAlgError, 3, 'linalg')
+
+    def test_raise_instance_with_runtime_args_objmode(self):
+        self.check_raise_instance_with_runtime_args(flags=force_pyobj_flags)
+
+    def test_raise_instance_with_runtime_args_nopython(self):
+        self.check_raise_instance_with_runtime_args(flags=no_pyobj_flags_w_nrt)
+
+    def test_raise_instance_with_runtime_args_nogil(self):
+        self.check_raise_instance_with_runtime_args(flags=no_gil_flags)
+
+    def test_dynamic_raise_bad_args(self):
+        def raise_literal_dict():
+            raise ValueError({'a': 1, 'b': np.ones(4)})
+
+        def raise_range():
+            raise ValueError(range(3))
+
+        def raise_rng(rng):
+            raise ValueError(rng.bit_generator)
+
+        funcs = [
+            (raise_literal_dict, ()),
+            (raise_range, ()),
+            (raise_rng, (types.npy_rng,)),
+        ]
+
+        for pyfunc, argtypes in funcs:
+            msg = '.*Cannot convert native .* to a Python object.*'
+            with self.assertRaisesRegex(errors.TypingError, msg):
+                njit(argtypes)(pyfunc)
+
+    def test_dynamic_raise_dict(self):
+        @njit
+        def raise_literal_dict2():
+            raise ValueError({'a': 1, 'b': 3})
+
+        msg = "{a: 1, b: 3}"
+        with self.assertRaisesRegex(ValueError, msg):
+            raise_literal_dict2()
+
+    def test_disable_nrt(self):
+        @njit(_nrt=False)
+        def raise_with_no_nrt(i):
+            raise ValueError(i)
+
+        msg = 'NRT required but not enabled'
+        with self.assertRaisesRegex(errors.NumbaRuntimeError, msg):
+            raise_with_no_nrt(123)
+
+    def test_try_raise(self):
+
+        @njit
+        def raise_(a):
+            raise ValueError(a)
+
+        @njit
+        def try_raise(a):
+            try:
+                raise_(a)
+            except Exception:
+                pass
+            return a + 1
+
+        self.assertEqual(try_raise.py_func(3), try_raise(3))
+
+    @expected_failure_py311
+    @expected_failure_py312
+    @expected_failure_py313
+    def test_dynamic_raise(self):
+
+        @njit
+        def raise_(a):
+            raise ValueError(a)
+
+        @njit
+        def try_raise_(a):
+            try:
+                raise_(a)
+            except Exception:
+                raise ValueError(a)
+
+        args = [
+            1,
+            1.1,
+            'hello',
+            np.ones(3),
+            [1, 2],
+            (1, 2),
+            set([1, 2]),
+        ]
+        for fn in (raise_, try_raise_):
+            for arg in args:
+                with self.assertRaises(ValueError) as e:
+                    fn(arg)
+                self.assertEqual((arg,), e.exception.args)
+
+
+if __name__ == '__main__':
+    unittest.main()

lib/python3.10/site-packages/numba/tests/test_function_type.py

@@ -0,0 +1,1408 @@
+import re
+import sys
+import unittest
+import types as pytypes
+from numba import jit, njit, cfunc, types, int64, float64, float32, errors
+from numba import literal_unroll, typeof
+from numba.core.config import IS_WIN32
+import ctypes
+import warnings
+
+from .support import TestCase, MemoryLeakMixin
+from .support import redirect_c_stderr, captured_stderr
+
+import numpy as np
+
+
+def dump(foo):  # FOR DEBUGGING, TO BE REMOVED
+    from numba.core import function
+    foo_type = function.fromobject(foo)
+    foo_sig = foo_type.signature()
+    foo.compile(foo_sig)
+    print('{" LLVM IR OF "+foo.__name__+" ":*^70}')
+    print(foo.inspect_llvm(foo_sig.args))
+    print('{"":*^70}')
+
+
+# Decorators for transforming a Python function to different kinds of
+# functions:
+
+def mk_cfunc_func(sig):
+    def cfunc_func(func):
+        assert isinstance(func, pytypes.FunctionType), repr(func)
+        f = cfunc(sig)(func)
+        f.pyfunc = func
+        return f
+    return cfunc_func
+
+
+def njit_func(func):
+    assert isinstance(func, pytypes.FunctionType), repr(func)
+    f = jit(nopython=True)(func)
+    f.pyfunc = func
+    return f
+
+
+def mk_njit_with_sig_func(sig):
+    def njit_with_sig_func(func):
+        assert isinstance(func, pytypes.FunctionType), repr(func)
+        f = jit(sig, nopython=True)(func)
+        f.pyfunc = func
+        return f
+    return njit_with_sig_func
+
+
+def mk_ctypes_func(sig):
+    def ctypes_func(func, sig=int64(int64)):
+        assert isinstance(func, pytypes.FunctionType), repr(func)
+        cfunc = mk_cfunc_func(sig)(func)
+        addr = cfunc._wrapper_address
+        if sig == int64(int64):
+            f = ctypes.CFUNCTYPE(ctypes.c_int64)(addr)
+            f.pyfunc = func
+            return f
+        raise NotImplementedError(
+            f'ctypes decorator for {func} with signature {sig}')
+    return ctypes_func
+
+
+class WAP(types.WrapperAddressProtocol):
+    """An example implementation of wrapper address protocol.
+
+    """
+    def __init__(self, func, sig):
+        self.pyfunc = func
+        self.cfunc = cfunc(sig)(func)
+        self.sig = sig
+
+    def __wrapper_address__(self):
+        return self.cfunc._wrapper_address
+
+    def signature(self):
+        return self.sig
+
+    def __call__(self, *args, **kwargs):
+        return self.pyfunc(*args, **kwargs)
+
+
+def mk_wap_func(sig):
+    def wap_func(func):
+        return WAP(func, sig)
+    return wap_func
+
+
+class TestFunctionType(TestCase):
+    """Test first-class functions in the context of a Numba jit compiled
+    function.
+
+    """
+
+    def test_in__(self):
+        """Function is passed in as an argument.
+        """
+
+        def a(i):
+            return i + 1
+
+        def foo(f):
+            return 0
+
+        sig = int64(int64)
+
+        for decor in [mk_cfunc_func(sig),
+                      njit_func,
+                      mk_njit_with_sig_func(sig),
+                      mk_ctypes_func(sig),
+                      mk_wap_func(sig)]:
+            for jit_opts in [dict(nopython=True), dict(forceobj=True)]:
+                jit_ = jit(**jit_opts)
+                with self.subTest(decor=decor.__name__, jit=jit_opts):
+                    a_ = decor(a)
+                    self.assertEqual(jit_(foo)(a_), foo(a))
+
+    def test_in_call__(self):
+        """Function is passed in as an argument and called.
+        Also test different return values.
+        """
+
+        def a_i64(i):
+            return i + 1234567
+
+        def a_f64(i):
+            return i + 1.5
+
+        def a_str(i):
+            return "abc"
+
+        def foo(f):
+            return f(123)
+
+        for f, sig in [(a_i64, int64(int64)), (a_f64, float64(int64))]:
+            for decor in [mk_cfunc_func(sig), njit_func,
+                          mk_njit_with_sig_func(sig),
+                          mk_wap_func(sig)]:
+                for jit_opts in [dict(nopython=True), dict(forceobj=True)]:
+                    jit_ = jit(**jit_opts)
+                    with self.subTest(
+                            sig=sig, decor=decor.__name__, jit=jit_opts):
+                        f_ = decor(f)
+                        self.assertEqual(jit_(foo)(f_), foo(f))
+
+    def test_in_call_out(self):
+        """Function is passed in as an argument, called, and returned.
+        """
+
+        def a(i):
+            return i + 1
+
+        def foo(f):
+            f(123)
+            return f
+
+        sig = int64(int64)
+
+        for decor in [mk_cfunc_func(sig), njit_func,
+                      mk_njit_with_sig_func(sig), mk_wap_func(sig)]:
+            for jit_opts in [dict(nopython=True), dict(forceobj=True)]:
+                jit_ = jit(**jit_opts)
+                with self.subTest(decor=decor.__name__):
+                    a_ = decor(a)
+                    r1 = jit_(foo)(a_).pyfunc
+                    r2 = foo(a)
+                    self.assertEqual(r1, r2)
+
+    def test_in_seq_call(self):
+        """Functions are passed in as arguments, used as tuple items, and
+        called.
+
+        """
+        def a(i):
+            return i + 1
+
+        def b(i):
+            return i + 2
+
+        def foo(f, g):
+            r = 0
+            for f_ in (f, g):
+                r = r + f_(r)
+            return r
+
+        sig = int64(int64)
+
+        for decor in [mk_cfunc_func(sig), mk_wap_func(sig),
+                      mk_njit_with_sig_func(sig)]:
+            for jit_opts in [dict(nopython=True), dict(forceobj=True)]:
+                jit_ = jit(**jit_opts)
+                with self.subTest(decor=decor.__name__):
+                    a_ = decor(a)
+                    b_ = decor(b)
+                    self.assertEqual(jit_(foo)(a_, b_), foo(a, b))
+
+    def test_in_ns_seq_call(self):
+        """Functions are passed in as an argument and via namespace scoping
+        (mixed pathways), used as tuple items, and called.
+
+        """
+
+        def a(i):
+            return i + 1
+
+        def b(i):
+            return i + 2
+
+        def mkfoo(b_):
+            def foo(f):
+                r = 0
+                for f_ in (f, b_):
+                    r = r + f_(r)
+                return r
+            return foo
+
+        sig = int64(int64)
+
+        for decor in [mk_cfunc_func(sig),
+                      mk_njit_with_sig_func(sig), mk_wap_func(sig),
+                      mk_ctypes_func(sig)][:-1]:
+            for jit_opts in [dict(nopython=True), dict(forceobj=True)]:
+                jit_ = jit(**jit_opts)
+                with self.subTest(decor=decor.__name__):
+                    a_ = decor(a)
+                    b_ = decor(b)
+                    self.assertEqual(jit_(mkfoo(b_))(a_), mkfoo(b)(a))
+
+    def test_ns_call(self):
+        """Function is passed in via namespace scoping and called.
+
+        """
+
+        def a(i):
+            return i + 1
+
+        def mkfoo(a_):
+            def foo():
+                return a_(123)
+            return foo
+
+        sig = int64(int64)
+
+        for decor in [mk_cfunc_func(sig), njit_func,
+                      mk_njit_with_sig_func(sig), mk_wap_func(sig)]:
+            for jit_opts in [dict(nopython=True), dict(forceobj=True)]:
+                jit_ = jit(**jit_opts)
+                with self.subTest(decor=decor.__name__):
+                    a_ = decor(a)
+                    self.assertEqual(jit_(mkfoo(a_))(), mkfoo(a)())
+
+    def test_ns_out(self):
+        """Function is passed in via namespace scoping and returned.
+
+        """
+        def a(i):
+            return i + 1
+
+        def mkfoo(a_):
+            def foo():
+                return a_
+            return foo
+
+        sig = int64(int64)
+
+        for decor in [mk_cfunc_func(sig), njit_func,
+                      mk_njit_with_sig_func(sig), mk_wap_func(sig),
+                      mk_ctypes_func(sig)][:-1]:
+            for jit_opts in [dict(nopython=True), dict(forceobj=True)]:
+                jit_ = jit(**jit_opts)
+                with self.subTest(decor=decor.__name__):
+                    a_ = decor(a)
+                    self.assertEqual(jit_(mkfoo(a_))().pyfunc, mkfoo(a)())
+
+    def test_ns_call_out(self):
+        """Function is passed in via namespace scoping, called, and then
+        returned.
+
+        """
+        def a(i):
+            return i + 1
+
+        def mkfoo(a_):
+            def foo():
+                a_(123)
+                return a_
+            return foo
+
+        sig = int64(int64)
+
+        for decor in [mk_cfunc_func(sig), njit_func,
+                      mk_njit_with_sig_func(sig), mk_wap_func(sig),
+                      mk_ctypes_func(sig)]:
+            for jit_opts in [dict(nopython=True), dict(forceobj=True)]:
+                jit_ = jit(**jit_opts)
+            with self.subTest(decor=decor.__name__):
+                a_ = decor(a)
+                self.assertEqual(jit_(mkfoo(a_))().pyfunc, mkfoo(a)())
+
+    def test_in_overload(self):
+        """Function is passed in as an argument and called with different
+        argument types.
+
+        """
+        def a(i):
+            return i + 1
+
+        def foo(f):
+            r1 = f(123)
+            r2 = f(123.45)
+            return (r1, r2)
+
+        for decor in [njit_func]:
+            for jit_opts in [dict(nopython=True), dict(forceobj=True)]:
+                jit_ = jit(**jit_opts)
+                with self.subTest(decor=decor.__name__):
+                    a_ = decor(a)
+                    self.assertEqual(jit_(foo)(a_), foo(a))
+
+    def test_ns_overload(self):
+        """Function is passed in via namespace scoping and called with
+        different argument types.
+
+        """
+        def a(i):
+            return i + 1
+
+        def mkfoo(a_):
+            def foo():
+                r1 = a_(123)
+                r2 = a_(123.45)
+                return (r1, r2)
+            return foo
+
+        for decor in [njit_func]:
+            for jit_opts in [dict(nopython=True), dict(forceobj=True)]:
+                jit_ = jit(**jit_opts)
+                with self.subTest(decor=decor.__name__):
+                    a_ = decor(a)
+                    self.assertEqual(jit_(mkfoo(a_))(), mkfoo(a)())
+
+    def test_in_choose(self):
+        """Functions are passed in as arguments and called conditionally.
+
+        """
+        def a(i):
+            return i + 1
+
+        def b(i):
+            return i + 2
+
+        def foo(a, b, choose_left):
+            if choose_left:
+                r = a(1)
+            else:
+                r = b(2)
+            return r
+
+        sig = int64(int64)
+
+        for decor in [mk_cfunc_func(sig), njit_func,
+                      mk_njit_with_sig_func(sig), mk_wap_func(sig)]:
+            for jit_opts in [dict(nopython=True), dict(forceobj=True)]:
+                jit_ = jit(**jit_opts)
+                with self.subTest(decor=decor.__name__):
+                    a_ = decor(a)
+                    b_ = decor(b)
+                    self.assertEqual(jit_(foo)(a_, b_, True), foo(a, b, True))
+                    self.assertEqual(jit_(foo)(a_, b_, False),
+                                     foo(a, b, False))
+                    self.assertNotEqual(jit_(foo)(a_, b_, True),
+                                        foo(a, b, False))
+
+    def test_ns_choose(self):
+        """Functions are passed in via namespace scoping and called
+        conditionally.
+
+        """
+        def a(i):
+            return i + 1
+
+        def b(i):
+            return i + 2
+
+        def mkfoo(a_, b_):
+            def foo(choose_left):
+                if choose_left:
+                    r = a_(1)
+                else:
+                    r = b_(2)
+                return r
+            return foo
+
+        sig = int64(int64)
+
+        for decor in [mk_cfunc_func(sig), njit_func,
+                      mk_njit_with_sig_func(sig), mk_wap_func(sig)]:
+            for jit_opts in [dict(nopython=True), dict(forceobj=True)]:
+                jit_ = jit(**jit_opts)
+                with self.subTest(decor=decor.__name__):
+                    a_ = decor(a)
+                    b_ = decor(b)
+                    self.assertEqual(jit_(mkfoo(a_, b_))(True),
+                                     mkfoo(a, b)(True))
+                    self.assertEqual(jit_(mkfoo(a_, b_))(False),
+                                     mkfoo(a, b)(False))
+                    self.assertNotEqual(jit_(mkfoo(a_, b_))(True),
+                                        mkfoo(a, b)(False))
+
+    def test_in_choose_out(self):
+        """Functions are passed in as arguments and returned conditionally.
+
+        """
+        def a(i):
+            return i + 1
+
+        def b(i):
+            return i + 2
+
+        def foo(a, b, choose_left):
+            if choose_left:
+                return a
+            else:
+                return b
+
+        sig = int64(int64)
+
+        for decor in [mk_cfunc_func(sig), njit_func,
+                      mk_njit_with_sig_func(sig), mk_wap_func(sig)]:
+            for jit_opts in [dict(nopython=True), dict(forceobj=True)]:
+                jit_ = jit(**jit_opts)
+                with self.subTest(decor=decor.__name__):
+                    a_ = decor(a)
+                    b_ = decor(b)
+                    self.assertEqual(jit_(foo)(a_, b_, True).pyfunc,
+                                     foo(a, b, True))
+                    self.assertEqual(jit_(foo)(a_, b_, False).pyfunc,
+                                     foo(a, b, False))
+                    self.assertNotEqual(jit_(foo)(a_, b_, True).pyfunc,
+                                        foo(a, b, False))
+
+    def test_in_choose_func_value(self):
+        """Functions are passed in as arguments, selected conditionally and
+        called.
+
+        """
+        def a(i):
+            return i + 1
+
+        def b(i):
+            return i + 2
+
+        def foo(a, b, choose_left):
+            if choose_left:
+                f = a
+            else:
+                f = b
+            return f(1)
+
+        sig = int64(int64)
+
+        for decor in [mk_cfunc_func(sig), mk_wap_func(sig), njit_func,
+                      mk_njit_with_sig_func(sig)]:
+            for jit_opts in [dict(nopython=True), dict(forceobj=True)]:
+                jit_ = jit(**jit_opts)
+                with self.subTest(decor=decor.__name__):
+                    a_ = decor(a)
+                    b_ = decor(b)
+                    self.assertEqual(jit_(foo)(a_, b_, True), foo(a, b, True))
+                    self.assertEqual(jit_(foo)(a_, b_, False),
+                                     foo(a, b, False))
+                    self.assertNotEqual(jit_(foo)(a_, b_, True),
+                                        foo(a, b, False))
+
+    def test_in_pick_func_call(self):
+        """Functions are passed in as items of tuple argument, retrieved via
+        indexing, and called.
+
+        """
+        def a(i):
+            return i + 1
+
+        def b(i):
+            return i + 2
+
+        def foo(funcs, i):
+            f = funcs[i]
+            r = f(123)
+            return r
+
+        sig = int64(int64)
+
+        for decor in [mk_cfunc_func(sig), mk_wap_func(sig),
+                      mk_njit_with_sig_func(sig)]:
+            for jit_opts in [dict(nopython=True), dict(forceobj=True)]:
+                jit_ = jit(**jit_opts)
+                with self.subTest(decor=decor.__name__):
+                    a_ = decor(a)
+                    b_ = decor(b)
+                    self.assertEqual(jit_(foo)((a_, b_), 0), foo((a, b), 0))
+                    self.assertEqual(jit_(foo)((a_, b_), 1), foo((a, b), 1))
+                    self.assertNotEqual(jit_(foo)((a_, b_), 0), foo((a, b), 1))
+
+    def test_in_iter_func_call(self):
+        """Functions are passed in as items of tuple argument, retrieved via
+        indexing, and called within a variable for-loop.
+
+        """
+        def a(i):
+            return i + 1
+
+        def b(i):
+            return i + 2
+
+        def foo(funcs, n):
+            r = 0
+            for i in range(n):
+                f = funcs[i]
+                r = r + f(r)
+            return r
+
+        sig = int64(int64)
+
+        for decor in [mk_cfunc_func(sig), mk_wap_func(sig),
+                      mk_njit_with_sig_func(sig)]:
+            for jit_opts in [dict(nopython=True), dict(forceobj=True)]:
+                jit_ = jit(**jit_opts)
+                with self.subTest(decor=decor.__name__):
+                    a_ = decor(a)
+                    b_ = decor(b)
+                    self.assertEqual(jit_(foo)((a_, b_), 2), foo((a, b), 2))
+
+    def test_experimental_feature_warning(self):
+        @jit(nopython=True)
+        def more(x):
+            return x + 1
+
+        @jit(nopython=True)
+        def less(x):
+            return x - 1
+
+        @jit(nopython=True)
+        def foo(sel, x):
+            fn = more if sel else less
+            return fn(x)
+
+        with warnings.catch_warnings(record=True) as ws:
+            warnings.simplefilter("always")
+            res = foo(True, 10)
+
+        self.assertEqual(res, 11)
+        self.assertEqual(foo(False, 10), 9)
+
+        self.assertGreaterEqual(len(ws), 1)
+        pat = "First-class function type feature is experimental"
+        for w in ws:
+            if pat in str(w.message):
+                break
+        else:
+            self.fail("missing warning")
+
+
+class TestFunctionTypeExtensions(TestCase):
+    """Test calling external library functions within Numba jit compiled
+    functions.
+
+    """
+
+    def test_wrapper_address_protocol_libm(self):
+        """Call cos and sinf from standard math library.
+
+        """
+        import ctypes.util
+
+        class LibM(types.WrapperAddressProtocol):
+
+            def __init__(self, fname):
+                if IS_WIN32:
+                    lib = ctypes.cdll.msvcrt
+                else:
+                    libpath = ctypes.util.find_library('m')
+                    lib = ctypes.cdll.LoadLibrary(libpath)
+                self.lib = lib
+                self._name = fname
+                if fname == 'cos':
+                    # test for double-precision math function
+                    addr = ctypes.cast(self.lib.cos, ctypes.c_voidp).value
+                    signature = float64(float64)
+                elif fname == 'sinf':
+                    # test for single-precision math function
+                    # Other 32/64 bit platforms define sinf as the
+                    # single-precision sin function
+                    addr = ctypes.cast(self.lib.sinf, ctypes.c_voidp).value
+                    signature = float32(float32)
+                else:
+                    raise NotImplementedError(
+                        f'wrapper address of `{fname}`'
+                        f' with signature `{signature}`')
+                self._signature = signature
+                self._address = addr
+
+            def __repr__(self):
+                return f'{type(self).__name__}({self._name!r})'
+
+            def __wrapper_address__(self):
+                return self._address
+
+            def signature(self):
+                return self._signature
+
+        mycos = LibM('cos')
+        mysin = LibM('sinf')
+
+        def myeval(f, x):
+            return f(x)
+
+        # Not testing forceobj=True as it requires implementing
+        # LibM.__call__ using ctypes which would be out-of-scope here.
+        for jit_opts in [dict(nopython=True)]:
+            jit_ = jit(**jit_opts)
+            with self.subTest(jit=jit_opts):
+                if mycos.signature() is not None:
+                    self.assertEqual(jit_(myeval)(mycos, 0.0), 1.0)
+                if mysin.signature() is not None:
+                    self.assertEqual(jit_(myeval)(mysin, float32(0.0)), 0.0)
+
+    def test_compilation_results(self):
+        """Turn the existing compilation results of a dispatcher instance to
+        first-class functions with precise types.
+        """
+
+        @jit(nopython=True)
+        def add_template(x, y):
+            return x + y
+
+        # Trigger compilations
+        self.assertEqual(add_template(1, 2), 3)
+        self.assertEqual(add_template(1.2, 3.4), 4.6)
+
+        cres1, cres2 = add_template.overloads.values()
+
+        # Turn compilation results into first-class functions
+        iadd = types.CompileResultWAP(cres1)
+        fadd = types.CompileResultWAP(cres2)
+
+        @jit(nopython=True)
+        def foo(add, x, y):
+            return add(x, y)
+
+        @jit(forceobj=True)
+        def foo_obj(add, x, y):
+            return add(x, y)
+
+        self.assertEqual(foo(iadd, 3, 4), 7)
+        self.assertEqual(foo(fadd, 3.4, 4.5), 7.9)
+
+        self.assertEqual(foo_obj(iadd, 3, 4), 7)
+        self.assertEqual(foo_obj(fadd, 3.4, 4.5), 7.9)
+
+
+class TestMiscIssues(TestCase):
+    """Test issues of using first-class functions in the context of Numba
+    jit compiled functions.
+
+    """
+
+    def test_issue_3405_using_cfunc(self):
+
+        @cfunc('int64()')
+        def a():
+            return 2
+
+        @cfunc('int64()')
+        def b():
+            return 3
+
+        def g(arg):
+            if arg:
+                f = a
+            else:
+                f = b
+            return f()
+
+        self.assertEqual(jit(nopython=True)(g)(True), 2)
+        self.assertEqual(jit(nopython=True)(g)(False), 3)
+
+    def test_issue_3405_using_njit(self):
+
+        @jit(nopython=True)
+        def a():
+            return 2
+
+        @jit(nopython=True)
+        def b():
+            return 3
+
+        def g(arg):
+            if not arg:
+                f = b
+            else:
+                f = a
+            return f()
+
+        self.assertEqual(jit(nopython=True)(g)(True), 2)
+        self.assertEqual(jit(nopython=True)(g)(False), 3)
+
+    def test_pr4967_example(self):
+
+        @cfunc('int64(int64)')
+        def a(i):
+            return i + 1
+
+        @cfunc('int64(int64)')
+        def b(i):
+            return i + 2
+
+        @jit(nopython=True)
+        def foo(f, g):
+            i = f(2)
+            seq = (f, g)
+            for fun in seq:
+                i += fun(i)
+            return i
+
+        a_ = a._pyfunc
+        b_ = b._pyfunc
+        self.assertEqual(foo(a, b),
+                         a_(2) + a_(a_(2)) + b_(a_(2) + a_(a_(2))))
+
+    def test_pr4967_array(self):
+        import numpy as np
+
+        @cfunc("intp(intp[:], float64[:])")
+        def foo1(x, y):
+            return x[0] + y[0]
+
+        @cfunc("intp(intp[:], float64[:])")
+        def foo2(x, y):
+            return x[0] - y[0]
+
+        def bar(fx, fy, i):
+            a = np.array([10], dtype=np.intp)
+            b = np.array([12], dtype=np.float64)
+            if i == 0:
+                f = fx
+            elif i == 1:
+                f = fy
+            else:
+                return
+            return f(a, b)
+
+        r = jit(nopython=True, no_cfunc_wrapper=True)(bar)(foo1, foo2, 0)
+        self.assertEqual(r, bar(foo1, foo2, 0))
+        self.assertNotEqual(r, bar(foo1, foo2, 1))
+
+    def test_reference_example(self):
+        import numba
+
+        @numba.njit
+        def composition(funcs, x):
+            r = x
+            for f in funcs[::-1]:
+                r = f(r)
+            return r
+
+        @numba.cfunc("double(double)")
+        def a(x):
+            return x + 1.0
+
+        @numba.njit()
+        def b(x):
+            return x * x
+
+        r = composition((a, b, b, a), 0.5)
+        self.assertEqual(r, (0.5 + 1.0) ** 4 + 1.0)
+
+        r = composition((b, a, b, b, a), 0.5)
+        self.assertEqual(r, ((0.5 + 1.0) ** 4 + 1.0) ** 2)
+
+    def test_apply_function_in_function(self):
+
+        def foo(f, f_inner):
+            return f(f_inner)
+
+        @cfunc('int64(float64)')
+        def f_inner(i):
+            return int64(i * 3)
+
+        @cfunc(int64(types.FunctionType(f_inner._sig)))
+        def f(f_inner):
+            return f_inner(123.4)
+
+        self.assertEqual(jit(nopython=True)(foo)(f, f_inner),
+                         foo(f._pyfunc, f_inner._pyfunc))
+
+    def test_function_with_none_argument(self):
+
+        @cfunc(int64(types.none))
+        def a(i):
+            return 1
+
+        @jit(nopython=True)
+        def foo(f):
+            return f(None)
+
+        self.assertEqual(foo(a), 1)
+
+    def test_constant_functions(self):
+
+        @jit(nopython=True)
+        def a():
+            return 123
+
+        @jit(nopython=True)
+        def b():
+            return 456
+
+        @jit(nopython=True)
+        def foo():
+            return a() + b()
+
+        r = foo()
+        if r != 123 + 456:
+            print(foo.overloads[()].library.get_llvm_str())
+        self.assertEqual(r, 123 + 456)
+
+    def test_generators(self):
+
+        @jit(forceobj=True)
+        def gen(xs):
+            for x in xs:
+                x += 1
+                yield x
+
+        @jit(forceobj=True)
+        def con(gen_fn, xs):
+            return [it for it in gen_fn(xs)]
+
+        self.assertEqual(con(gen, (1, 2, 3)), [2, 3, 4])
+
+        @jit(nopython=True)
+        def gen_(xs):
+            for x in xs:
+                x += 1
+                yield x
+        self.assertEqual(con(gen_, (1, 2, 3)), [2, 3, 4])
+
+    def test_jit_support(self):
+
+        @jit(nopython=True)
+        def foo(f, x):
+            return f(x)
+
+        @jit()
+        def a(x):
+            return x + 1
+
+        @jit()
+        def a2(x):
+            return x - 1
+
+        @jit()
+        def b(x):
+            return x + 1.5
+
+        self.assertEqual(foo(a, 1), 2)
+        a2(5)  # pre-compile
+        self.assertEqual(foo(a2, 2), 1)
+        self.assertEqual(foo(a2, 3), 2)
+        self.assertEqual(foo(a, 2), 3)
+        self.assertEqual(foo(a, 1.5), 2.5)
+        self.assertEqual(foo(a2, 1), 0)
+        self.assertEqual(foo(a, 2.5), 3.5)
+        self.assertEqual(foo(b, 1.5), 3.0)
+        self.assertEqual(foo(b, 1), 2.5)
+
+    def test_signature_mismatch(self):
+        @jit(nopython=True)
+        def f1(x):
+            return x
+
+        @jit(nopython=True)
+        def f2(x):
+            return x
+
+        @jit(nopython=True)
+        def foo(disp1, disp2, sel):
+            if sel == 1:
+                fn = disp1
+            else:
+                fn = disp2
+            return fn([1]), fn(2)
+
+        with self.assertRaises(errors.UnsupportedError) as cm:
+            foo(f1, f2, sel=1)
+        self.assertRegex(
+            str(cm.exception), 'mismatch of function types:')
+
+        # this works because `sel == 1` condition is optimized away:
+        self.assertEqual(foo(f1, f1, sel=1), ([1], 2))
+
+    def test_unique_dispatcher(self):
+        # In general, the type of a dispatcher instance is imprecise
+        # and when used as an input to type-inference, the typing will
+        # likely fail. However, if a dispatcher instance contains
+        # exactly one overload and compilation is disabled for the dispatcher,
+        # then the type of dispatcher instance is interpreted as precise
+        # and is transformed to a FunctionType instance with the defined
+        # signature of the single overload.
+
+        def foo_template(funcs, x):
+            r = x
+            for f in funcs:
+                r = f(r)
+            return r
+
+        a = jit(nopython=True)(lambda x: x + 1)
+        b = jit(nopython=True)(lambda x: x + 2)
+        foo = jit(nopython=True)(foo_template)
+
+        # compiling and disabling compilation for `a` is sufficient,
+        # `b` will inherit its type from the container Tuple type
+        a(0)
+        a.disable_compile()
+
+        r = foo((a, b), 0)
+        self.assertEqual(r, 3)
+        # the Tuple type of foo's first argument is a precise FunctionType:
+        self.assertEqual(foo.signatures[0][0].dtype.is_precise(), True)
+
+    def test_zero_address(self):
+
+        sig = int64()
+
+        @cfunc(sig)
+        def test():
+            return 123
+
+        class Good(types.WrapperAddressProtocol):
+            """A first-class function type with valid address.
+            """
+
+            def __wrapper_address__(self):
+                return test.address
+
+            def signature(self):
+                return sig
+
+        class Bad(types.WrapperAddressProtocol):
+            """A first-class function type with invalid 0 address.
+            """
+
+            def __wrapper_address__(self):
+                return 0
+
+            def signature(self):
+                return sig
+
+        class BadToGood(types.WrapperAddressProtocol):
+            """A first-class function type with invalid address that is
+            recovered to a valid address.
+            """
+
+            counter = -1
+
+            def __wrapper_address__(self):
+                self.counter += 1
+                return test.address * min(1, self.counter)
+
+            def signature(self):
+                return sig
+
+        good = Good()
+        bad = Bad()
+        bad2good = BadToGood()
+
+        @jit(int64(sig.as_type()))
+        def foo(func):
+            return func()
+
+        @jit(int64())
+        def foo_good():
+            return good()
+
+        @jit(int64())
+        def foo_bad():
+            return bad()
+
+        @jit(int64())
+        def foo_bad2good():
+            return bad2good()
+
+        self.assertEqual(foo(good), 123)
+
+        self.assertEqual(foo_good(), 123)
+
+        with self.assertRaises(ValueError) as cm:
+            foo(bad)
+        self.assertRegex(
+            str(cm.exception),
+            'wrapper address of <.*> instance must be a positive')
+
+        with self.assertRaises(RuntimeError) as cm:
+            foo_bad()
+        self.assertRegex(
+            str(cm.exception), r'.* function address is null')
+
+        self.assertEqual(foo_bad2good(), 123)
+
+    def test_issue_5470(self):
+
+        @njit()
+        def foo1():
+            return 10
+
+        @njit()
+        def foo2():
+            return 20
+
+        formulae_foo = (foo1, foo1)
+
+        @njit()
+        def bar_scalar(f1, f2):
+            return f1() + f2()
+
+        @njit()
+        def bar():
+            return bar_scalar(*formulae_foo)
+
+        self.assertEqual(bar(), 20)
+
+        formulae_foo = (foo1, foo2)
+
+        @njit()
+        def bar():
+            return bar_scalar(*formulae_foo)
+
+        self.assertEqual(bar(), 30)
+
+    def test_issue_5540(self):
+
+        @njit(types.int64(types.int64))
+        def foo(x):
+            return x + 1
+
+        @njit
+        def bar_bad(foos):
+            f = foos[0]
+            return f(x=1)
+
+        @njit
+        def bar_good(foos):
+            f = foos[0]
+            return f(1)
+
+        self.assertEqual(bar_good((foo, )), 2)
+
+        # new/old style error handling
+        with self.assertRaises((errors.UnsupportedError,
+                                errors.TypingError)) as cm:
+            bar_bad((foo, ))
+
+        self.assertRegex(
+            str(cm.exception),
+            r'.*first-class function call cannot use keyword arguments')
+
+    def test_issue_5615(self):
+
+        @njit
+        def foo1(x):
+            return x + 1
+
+        @njit
+        def foo2(x):
+            return x + 2
+
+        @njit
+        def bar(fcs):
+            x = 0
+            a = 10
+            i, j = fcs[0]
+            x += i(j(a))
+            for t in literal_unroll(fcs):
+                i, j = t
+                x += i(j(a))
+            return x
+
+        tup = ((foo1, foo2), (foo2, foo1))
+
+        self.assertEqual(bar(tup), 39)
+
+    def test_issue_5685(self):
+
+        @njit
+        def foo1():
+            return 1
+
+        @njit
+        def foo2(x):
+            return x + 1
+
+        @njit
+        def foo3(x):
+            return x + 2
+
+        @njit
+        def bar(fcs):
+            r = 0
+            for pair in literal_unroll(fcs):
+                f1, f2 = pair
+                r += f1() + f2(2)
+            return r
+
+        self.assertEqual(bar(((foo1, foo2),)), 4)
+        self.assertEqual(bar(((foo1, foo2), (foo1, foo3))), 9)  # reproducer
+
+
+class TestBasicSubtyping(TestCase):
+    def test_basic(self):
+        """
+        Test that a dispatcher object *with* a pre-compiled overload
+        can be used as input to another function with locked-down signature
+        """
+        a = 1
+
+        @njit
+        def foo(x):
+            return x + 1
+
+        foo(a)
+        int_int_fc = types.FunctionType(types.int64(types.int64,))
+
+        @njit(types.int64(int_int_fc))
+        def bar(fc):
+            return fc(a)
+
+        self.assertEqual(bar(foo), foo(a))
+
+    def test_basic2(self):
+        """
+        Test that a dispatcher object *without* a pre-compiled overload
+        can be used as input to another function with locked-down signature
+        """
+        a = 1
+
+        @njit
+        def foo(x):
+            return x + 1
+
+        int_int_fc = types.FunctionType(types.int64(types.int64,))
+
+        @njit(types.int64(int_int_fc))
+        def bar(fc):
+            return fc(a)
+
+        self.assertEqual(bar(foo), foo(a))
+
+    def test_basic3(self):
+        """
+        Test that a dispatcher object *without* a pre-compiled overload
+        can be used as input to another function with locked-down signature and
+        that it behaves as a truly generic function (foo1 does not get locked)
+        """
+        a = 1
+
+        @njit
+        def foo1(x):
+            return x + 1
+
+        @njit
+        def foo2(x):
+            return x + 2
+
+        int_int_fc = types.FunctionType(types.int64(types.int64,))
+
+        @njit(types.int64(int_int_fc))
+        def bar(fc):
+            return fc(a)
+
+        self.assertEqual(bar(foo1) + 1, bar(foo2))
+
+    def test_basic4(self):
+        """
+        Test that a dispatcher object can be used as input to another
+         function with signature as part of a tuple
+        """
+        a = 1
+
+        @njit
+        def foo1(x):
+            return x + 1
+
+        @njit
+        def foo2(x):
+            return x + 2
+
+        tup = (foo1, foo2)
+        int_int_fc = types.FunctionType(types.int64(types.int64,))
+
+        @njit(types.int64(types.UniTuple(int_int_fc, 2)))
+        def bar(fcs):
+            x = 0
+            for i in range(2):
+                x += fcs[i](a)
+            return x
+        self.assertEqual(bar(tup), foo1(a) + foo2(a))
+
+    def test_basic5(self):
+        a = 1
+
+        @njit
+        def foo1(x):
+            return x + 1
+
+        @njit
+        def foo2(x):
+            return x + 2
+
+        @njit
+        def bar1(x):
+            return x / 10
+
+        @njit
+        def bar2(x):
+            return x / 1000
+
+        tup = (foo1, foo2)
+        tup_bar = (bar1, bar2)
+        int_int_fc = types.FunctionType(types.int64(types.int64,))
+
+        flt_flt_fc = types.FunctionType(types.float64(types.float64,))
+
+        @njit((types.UniTuple(int_int_fc, 2), types.UniTuple(flt_flt_fc, 2)))
+        def bar(fcs, ffs):
+            x = 0
+            for i in range(2):
+                x += fcs[i](a)
+            for fn in ffs:
+                x += fn(a)
+            return x
+
+        got = bar(tup, tup_bar)
+        expected = foo1(a) + foo2(a) + bar1(a) + bar2(a)
+        self.assertEqual(got, expected)
+
+
+class TestMultiFunctionType(MemoryLeakMixin, TestCase):
+
+    def test_base(self):
+        # The test is adapted from https://github.com/numba/numba/issues/9071
+        nb_array = typeof(np.ones(2))
+        callee_int_type = types.FunctionType(int64(int64))
+        sig_int = int64(callee_int_type, int64)
+        callee_array_type = types.FunctionType(float64(nb_array))
+        sig_array = float64(callee_array_type, nb_array)
+
+        @njit([sig_int, sig_array])
+        def caller(callee, a):
+            return callee(a)
+
+        @njit
+        def callee_int(b):
+            return b
+
+        @njit
+        def callee_array(c):
+            return c.sum()
+
+        b = 1
+        c = np.ones(2)
+
+        self.assertEqual(caller(callee_int, b), b)
+        self.assertEqual(caller(callee_array, c), c.sum())
+
+
+class TestInliningFunctionType(MemoryLeakMixin, TestCase):
+    def count_num_bb_in_cfg(self, dispatcher):
+        dot = dispatcher.inspect_cfg(dispatcher.signatures[0]).dot
+        num_of_nodes = re.findall(r"Node0x[0-9a-z]+", dot)
+        return len(num_of_nodes)
+
+    def test_inlining_global_dispatcher(self):
+        @njit
+        def add(x, y):
+            return x + y
+
+        fnty = types.FunctionType(int64(int64, int64))
+
+        @njit(int64(fnty, int64, int64))
+        def callme(fn, x, y):
+            c = 0
+            for i in range(100):
+                c += fn(x, y)
+            return c
+
+        @njit
+        def bar(x, y):
+            return callme(add, x, y)
+
+        res = bar(123, 321)
+        self.assertEqual(100 * (123 + 321), res)
+        # There's only one BB because LLVM will be able to fully optimize
+        # the reduce-add loop if add() is properly inlined.
+        self.assertEqual(self.count_num_bb_in_cfg(bar), 1)
+
+    def test_not_inlining_dispatcher_args(self):
+        @njit
+        def add(x, y):
+            return x + y
+
+        fnty = types.FunctionType(int64(int64, int64))
+
+        @njit(int64(fnty, int64, int64))
+        def callme(fn, x, y):
+            c = 0
+            for i in range(100):
+                c += fn(x, y)
+            return c
+
+        res = callme(add, 123, 321)
+
+        self.assertEqual(100 * (123 + 321), res)
+        # Since add() is not inline-able. The number of BB will be greater
+        # than 1. See test_inlining_global_dispatcher().
+        self.assertGreater(self.count_num_bb_in_cfg(callme), 1)
+
+
+class TestExceptionInFunctionType(MemoryLeakMixin, TestCase):
+    def test_exception_raising(self):
+        class MyError(Exception):
+            pass
+
+        @njit
+        def add(x, y):
+            res = x + y
+            if res > 100:
+                raise MyError(res)
+            return res
+
+        fnty = types.FunctionType(int64(int64, int64))
+
+        @njit(int64(fnty))
+        def callme(fn):
+            c = 0
+            for i in range(100):
+                c = fn(c, i)
+            return c
+
+        @njit
+        def bar():
+            return callme(add)
+
+        # Pass Dispatcher as a global reference
+        with self.assertRaises(MyError) as exc:
+            bar()
+        self.assertEqual(exc.exception.args, (105,))
+
+        # Pass Dispatcher by argument
+        with self.assertRaises(MyError) as exc:
+            callme(add)
+        self.assertEqual(exc.exception.args, (105,))
+
+    def test_exception_ignored_in_cfunc(self):
+        class MyError(Exception):
+            pass
+
+        @njit
+        def add(x, y):
+            res = x + y
+            if res > 100:
+                raise MyError(res)
+            return res
+
+        fnty = types.FunctionType(int64(int64, int64))
+
+        @njit(int64(fnty, int64, int64))
+        def callme(fn, x, y):
+            return fn(x, y)
+
+        # Cfunc as argument will ignore raised exception
+        @cfunc(int64(int64, int64))
+        def c_add(x, y):
+            return add(x, y)
+
+        self.assertEqual(callme(c_add, 12, 32), 44)
+
+        # If unittest is buffering (-b), the message goes to Python level stderr
+        # otherwise, it goes to C stderr.
+        with redirect_c_stderr() as c_stderr, captured_stderr() as stderr:
+            # raise ignored and result is garbage
+            callme(c_add, 100, 1)
+            sys.stderr.flush()
+
+        err = c_stderr.read()
+        if not err:
+            err = stderr.getvalue()
+
+        self.assertIn("Exception ignored in:", err)
+        self.assertIn(str(MyError(101)), err)
+
+
+if __name__ == '__main__':
+    unittest.main()

lib/python3.10/site-packages/numba/tests/test_gdb_bindings.py

@@ -0,0 +1,277 @@
+"""
+Tests gdb bindings
+"""
+import os
+import platform
+import re
+import subprocess
+import sys
+import threading
+from itertools import permutations
+
+from numba import njit, gdb, gdb_init, gdb_breakpoint, prange
+from numba.core import errors
+from numba import jit
+
+from numba.tests.support import (TestCase, captured_stdout, tag,
+                                 skip_parfors_unsupported)
+from numba.tests.gdb_support import needs_gdb
+import unittest
+
+
+_platform = sys.platform
+
+_unix_like = (_platform.startswith('linux')
+              or _platform.startswith('darwin')
+              or ('bsd' in _platform))
+
+unix_only = unittest.skipUnless(_unix_like, "unix-like OS is required")
+not_unix = unittest.skipIf(_unix_like, "non unix-like OS is required")
+
+_arch_name = platform.machine()
+_is_arm = _arch_name in {'aarch64', 'armv7l'}
+not_arm = unittest.skipIf(_is_arm, "testing disabled on ARM")
+
+_gdb_cond = os.environ.get('GDB_TEST', None) == '1'
+needs_gdb_harness = unittest.skipUnless(_gdb_cond, "needs gdb harness")
+
+long_running = tag('long_running')
+
+_dbg_njit = njit(debug=True)
+_dbg_jit = jit(forceobj=True, debug=True)
+
+
+def impl_gdb_call(a):
+    gdb('-ex', 'set confirm off', '-ex', 'c', '-ex', 'q')
+    b = a + 1
+    c = a * 2.34
+    d = (a, b, c)
+    print(a, b, c, d)
+
+
+def impl_gdb_call_w_bp(a):
+    gdb_init('-ex', 'set confirm off', '-ex', 'c', '-ex', 'q')
+    b = a + 1
+    c = a * 2.34
+    d = (a, b, c)
+    gdb_breakpoint()
+    print(a, b, c, d)
+
+
+def impl_gdb_split_init_and_break_w_parallel(a):
+    gdb_init('-ex', 'set confirm off', '-ex', 'c', '-ex', 'q')
+    a += 3
+    for i in prange(4):
+        b = a + 1
+        c = a * 2.34
+        d = (a, b, c)
+        gdb_breakpoint()
+        print(a, b, c, d)
+
+
+@not_arm
+@unix_only
+class TestGdbBindImpls(TestCase):
+    """
+    Contains unit test implementations for gdb binding testing. Test must be
+    decorated with `@needs_gdb_harness` to prevent their running under normal
+    test conditions, the test methods must also end with `_impl` to be
+    considered for execution. The tests themselves are invoked by the
+    `TestGdbBinding` test class through the parsing of this class for test
+    methods and then running the discovered tests in a separate process. Test
+    names not including the word `quick` will be tagged as @tag('long_running')
+    """
+
+    @needs_gdb_harness
+    def test_gdb_cmd_lang_cpython_quick_impl(self):
+        with captured_stdout():
+            impl_gdb_call(10)
+
+    @needs_gdb_harness
+    def test_gdb_cmd_lang_nopython_quick_impl(self):
+        with captured_stdout():
+            _dbg_njit(impl_gdb_call)(10)
+
+    @needs_gdb_harness
+    def test_gdb_cmd_lang_objmode_quick_impl(self):
+        with captured_stdout():
+            _dbg_jit(impl_gdb_call)(10)
+
+    @needs_gdb_harness
+    def test_gdb_split_init_and_break_cpython_impl(self):
+        with captured_stdout():
+            impl_gdb_call_w_bp(10)
+
+    @needs_gdb_harness
+    def test_gdb_split_init_and_break_nopython_impl(self):
+        with captured_stdout():
+            _dbg_njit(impl_gdb_call_w_bp)(10)
+
+    @needs_gdb_harness
+    def test_gdb_split_init_and_break_objmode_impl(self):
+        with captured_stdout():
+            _dbg_jit(impl_gdb_call_w_bp)(10)
+
+    @skip_parfors_unsupported
+    @needs_gdb_harness
+    def test_gdb_split_init_and_break_w_parallel_cpython_impl(self):
+        with captured_stdout():
+            impl_gdb_split_init_and_break_w_parallel(10)
+
+    @skip_parfors_unsupported
+    @needs_gdb_harness
+    def test_gdb_split_init_and_break_w_parallel_nopython_impl(self):
+        with captured_stdout():
+            _dbg_njit(impl_gdb_split_init_and_break_w_parallel)(10)
+
+    @skip_parfors_unsupported
+    @needs_gdb_harness
+    def test_gdb_split_init_and_break_w_parallel_objmode_impl(self):
+        with captured_stdout():
+            _dbg_jit(impl_gdb_split_init_and_break_w_parallel)(10)
+
+
+@not_arm
+@unix_only
+@needs_gdb
+class TestGdbBinding(TestCase):
+    """
+    This test class is used to generate tests which will run the test cases
+    defined in TestGdbBindImpls in isolated subprocesses, this is for safety
+    in case something goes awry.
+    """
+
+    # test mutates env
+    _numba_parallel_test_ = False
+
+    _DEBUG = True
+
+    def run_cmd(self, cmdline, env, kill_is_ok=False):
+        popen = subprocess.Popen(cmdline,
+                                 stdout=subprocess.PIPE,
+                                 stderr=subprocess.PIPE,
+                                 env=env,
+                                 shell=True)
+        # finish in 20s or kill it, there's no work being done
+
+        def kill():
+            popen.stdout.flush()
+            popen.stderr.flush()
+            popen.kill()
+        timeout = threading.Timer(20., kill)
+        try:
+            timeout.start()
+            out, err = popen.communicate()
+            retcode = popen.returncode
+            if retcode != 0:
+                raise AssertionError(
+                    "process failed with code %s: "
+                    "stderr follows\n%s\n"
+                    "stdout :%s" % (retcode, err.decode(), out.decode()))
+            return out.decode(), err.decode()
+        finally:
+            timeout.cancel()
+        return None, None
+
+    def run_test_in_separate_process(self, test, **kwargs):
+        env_copy = os.environ.copy()
+        env_copy['NUMBA_OPT'] = '1'
+        # Set GDB_TEST to permit the execution of tests decorated with
+        # @needs_gdb_harness
+        env_copy['GDB_TEST'] = '1'
+        cmdline = [sys.executable, "-m", "numba.runtests", test]
+        return self.run_cmd(' '.join(cmdline), env_copy, **kwargs)
+
+    @classmethod
+    def _inject(cls, name):
+        themod = TestGdbBindImpls.__module__
+        thecls = TestGdbBindImpls.__name__
+        # strip impl
+        assert name.endswith('_impl')
+        methname = name.replace('_impl', '')
+        injected_method = '%s.%s.%s' % (themod, thecls, name)
+
+        def test_template(self):
+            o, e = self.run_test_in_separate_process(injected_method)
+            dbgmsg = f'\nSTDOUT={o}\nSTDERR={e}\n'
+            # If the test was skipped in the subprocess, then mark this as a
+            # skipped test.
+            m = re.search(r"\.\.\. skipped '(.*?)'", e)
+            if m is not None:
+                self.skipTest(m.group(1))
+            self.assertIn('GNU gdb', o, msg=dbgmsg)
+            self.assertIn('OK', e, msg=dbgmsg)
+            self.assertNotIn('FAIL', e, msg=dbgmsg)
+            self.assertNotIn('ERROR', e, msg=dbgmsg)
+        if 'quick' in name:
+            setattr(cls, methname, test_template)
+        else:
+            setattr(cls, methname, long_running(test_template))
+
+    @classmethod
+    def generate(cls):
+        for name in dir(TestGdbBindImpls):
+            if name.startswith('test_gdb'):
+                cls._inject(name)
+
+
+TestGdbBinding.generate()
+
+
+@not_arm
+@unix_only
+@needs_gdb
+class TestGdbMisc(TestCase):
+
+    @long_running
+    def test_call_gdb_twice(self):
+        def gen(f1, f2):
+            @njit
+            def impl():
+                a = 1
+                f1()
+                b = 2
+                f2()
+                return a + b
+            return impl
+
+        msg_head = "Calling either numba.gdb() or numba.gdb_init() more than"
+
+        def check(func):
+            with self.assertRaises(errors.UnsupportedError) as raises:
+                func()
+            self.assertIn(msg_head, str(raises.exception))
+
+        for g1, g2 in permutations([gdb, gdb_init]):
+            func = gen(g1, g2)
+            check(func)
+
+        @njit
+        def use_globals():
+            a = 1
+            gdb()
+            b = 2
+            gdb_init()
+            return a + b
+
+        check(use_globals)
+
+
+@not_unix
+class TestGdbExceptions(TestCase):
+
+    def test_call_gdb(self):
+        def nop_compiler(x):
+            return x
+        for compiler in [nop_compiler, jit(forceobj=True), njit]:
+            for meth in [gdb, gdb_init]:
+                def python_func():
+                    meth()
+                with self.assertRaises(errors.TypingError) as raises:
+                    compiler(python_func)()
+                msg = "gdb support is only available on unix-like systems"
+                self.assertIn(msg, str(raises.exception))
+
+
+if __name__ == '__main__':
+    unittest.main()

lib/python3.10/site-packages/numba/tests/test_gil.py

@@ -0,0 +1,182 @@
+import ctypes
+import ctypes.util
+import os
+import sys
+import threading
+import warnings
+
+import numpy as np
+
+import unittest
+from numba import jit
+from numba.core import errors
+from numba.tests.support import TestCase, tag
+
+
+# This CPython API function is a portable way to get the current thread id.
+PyThread_get_thread_ident = ctypes.pythonapi.PyThread_get_thread_ident
+PyThread_get_thread_ident.restype = ctypes.c_long
+PyThread_get_thread_ident.argtypes = []
+
+# A way of sleeping from nopython code
+if os.name == 'nt':
+    sleep = ctypes.windll.kernel32.Sleep
+    sleep.argtypes = [ctypes.c_uint]
+    sleep.restype = None
+    sleep_factor = 1  # milliseconds
+else:
+    sleep = ctypes.CDLL(ctypes.util.find_library("c")).usleep
+    sleep.argtypes = [ctypes.c_uint]
+    sleep.restype = ctypes.c_int
+    sleep_factor = 1000  # microseconds
+
+
+def f(a, indices):
+    # If run from one thread at a time, the function will always fill the
+    # array with identical values.
+    # If run from several threads at a time, the function will probably
+    # fill the array with differing values.
+    for idx in indices:
+        # Let another thread run
+        sleep(10 * sleep_factor)
+        a[idx] = PyThread_get_thread_ident()
+
+f_sig = "void(int64[:], intp[:])"
+
+def lifted_f(a, indices):
+    """
+    Same as f(), but inside a lifted loop
+    """
+    object()   # Force object mode
+    for idx in indices:
+        # Let another thread run
+        sleep(10 * sleep_factor)
+        a[idx] = PyThread_get_thread_ident()
+
+def object_f(a, indices):
+    """
+    Same as f(), but in object mode
+    """
+    for idx in indices:
+        # Let another thread run
+        sleep(10 * sleep_factor)
+        object()   # Force object mode
+        a[idx] = PyThread_get_thread_ident()
+
+
+class TestGILRelease(TestCase):
+
+    def make_test_array(self, n_members):
+        return np.arange(n_members, dtype=np.int64)
+
+    def run_in_threads(self, func, n_threads):
+        # Run the function in parallel over an array and collect results.
+        threads = []
+        # Warm up compilation, since we don't want that to interfere with
+        # the test proper.
+        func(self.make_test_array(1), np.arange(1, dtype=np.intp))
+        arr = self.make_test_array(50)
+        for i in range(n_threads):
+            # Ensure different threads write into the array in different
+            # orders.
+            indices = np.arange(arr.size, dtype=np.intp)
+            np.random.shuffle(indices)
+            t = threading.Thread(target=func, args=(arr, indices))
+            threads.append(t)
+        for t in threads:
+            t.start()
+        for t in threads:
+            t.join()
+        return arr
+
+    def check_gil_held(self, func):
+        arr = self.run_in_threads(func, n_threads=4)
+        distinct = set(arr)
+        self.assertEqual(len(distinct), 1, distinct)
+
+    def check_gil_released(self, func):
+        for n_threads in (4, 12, 32):
+            # Try harder each time. On an empty machine 4 threads seems
+            # sufficient, but in some contexts (e.g. Travis CI) we need more.
+            arr = self.run_in_threads(func, n_threads)
+            distinct = set(arr)
+            try:
+                self.assertGreater(len(distinct), 1, distinct)
+            except AssertionError as e:
+                failure = e
+            else:
+                return
+        raise failure
+
+    def test_gil_held(self):
+        """
+        Test the GIL is held by default, by checking serialized runs
+        produce deterministic results.
+        """
+        cfunc = jit(f_sig, nopython=True)(f)
+        self.check_gil_held(cfunc)
+
+    def test_gil_released(self):
+        """
+        Test releasing the GIL, by checking parallel runs produce
+        unpredictable results.
+        """
+        cfunc = jit(f_sig, nopython=True, nogil=True)(f)
+        self.check_gil_released(cfunc)
+
+    def test_gil_released_inside_lifted_loop(self):
+        """
+        Test the GIL can by released by a lifted loop even though the
+        surrounding code uses object mode.
+        """
+        cfunc = jit(f_sig, forceobj=True, nogil=True)(lifted_f)
+        self.check_gil_released(cfunc)
+
+    def test_gil_released_by_caller(self):
+        """
+        Releasing the GIL in the caller is sufficient to have it
+        released in a callee.
+        """
+        compiled_f = jit(f_sig, nopython=True)(f)
+        @jit(f_sig, nopython=True, nogil=True)
+        def caller(a, i):
+            compiled_f(a, i)
+        self.check_gil_released(caller)
+
+    def test_gil_released_by_caller_and_callee(self):
+        """
+        Same, but with both caller and callee asking to release the GIL.
+        """
+        compiled_f = jit(f_sig, nopython=True, nogil=True)(f)
+        @jit(f_sig, nopython=True, nogil=True)
+        def caller(a, i):
+            compiled_f(a, i)
+        self.check_gil_released(caller)
+
+    def test_gil_ignored_by_callee(self):
+        """
+        When only the callee asks to release the GIL, it gets ignored.
+        """
+        compiled_f = jit(f_sig, nopython=True, nogil=True)(f)
+        @jit(f_sig, nopython=True)
+        def caller(a, i):
+            compiled_f(a, i)
+        self.check_gil_held(caller)
+
+    def test_object_mode(self):
+        """
+        When the function is compiled in object mode, a warning is
+        printed out.
+        """
+        with warnings.catch_warnings(record=True) as wlist:
+            warnings.simplefilter('always', errors.NumbaWarning)
+            cfunc = jit(f_sig, forceobj=True, nogil=True)(object_f)
+        self.assertTrue(any(w.category is errors.NumbaWarning
+                            and "Code running in object mode won't allow parallel execution" in str(w.message)
+                            for w in wlist), wlist)
+        # Just check it doesn't crash.
+        self.run_in_threads(cfunc, 2)
+
+
+if __name__ == '__main__':
+    unittest.main()

lib/python3.10/site-packages/numba/tests/test_hashing.py

@@ -0,0 +1,529 @@
+# -*- coding: utf-8 -*-
+"""
+Test hashing of various supported types.
+"""
+
+import unittest
+
+import os
+import sys
+import subprocess
+from collections import defaultdict
+from textwrap import dedent
+
+import numpy as np
+
+from numba import jit, config, typed, typeof
+from numba.core import types, utils
+import unittest
+from numba.tests.support import (TestCase, skip_unless_py10_or_later,
+                                 run_in_subprocess)
+
+from numba.cpython.unicode import compile_time_get_string_data
+from numba.cpython import hashing
+from numba.np.numpy_support import numpy_version
+
+
+def hash_usecase(x):
+    return hash(x)
+
+
+class TestHashingSetup(TestCase):
+
+    def test_warn_on_fnv(self):
+        # FNV hash alg variant is not supported, check Numba warns
+        work = """
+        import sys
+        import warnings
+        from collections import namedtuple
+
+        # hash_info is a StructSequence, mock as a named tuple
+        fields = ["width", "modulus", "inf", "nan", "imag", "algorithm",
+                  "hash_bits", "seed_bits", "cutoff"]
+
+        hinfo = sys.hash_info
+        FAKE_HASHINFO = namedtuple('FAKE_HASHINFO', fields)
+
+        fd = dict()
+        for f in fields:
+            fd[f] = getattr(hinfo, f)
+
+        fd['algorithm'] = 'fnv'
+
+        fake_hashinfo = FAKE_HASHINFO(**fd)
+
+        # replace the hashinfo with the fnv version
+        sys.hash_info = fake_hashinfo
+        with warnings.catch_warnings(record=True) as warns:
+            # Cause all warnings to always be triggered.
+            warnings.simplefilter("always")
+            from numba import njit
+            @njit
+            def foo():
+                hash(1)
+            foo()
+            assert len(warns) > 0
+            expect = "FNV hashing is not implemented in Numba. See PEP 456"
+            for w in warns:
+                if expect in str(w.message):
+                    break
+            else:
+                raise RuntimeError("Expected warning not found")
+        """
+        subprocess.check_call([sys.executable, '-c', dedent(work)])
+
+
+class TestHashAlgs(TestCase):
+    # This tests Numba hashing replication against cPython "gold", i.e. the
+    # actual hash values for given inputs, algs and PYTHONHASHSEEDs
+    # Test adapted from:
+    # https://github.com/python/cpython/blob/9dda9020abcf0d51d59b283a89c58c8e1fb0f574/Lib/test/test_hash.py#L197-L264
+    # and
+    # https://github.com/python/cpython/blob/9dda9020abcf0d51d59b283a89c58c8e1fb0f574/Lib/test/test_hash.py#L174-L189
+
+    # 32bit little, 64bit little, 32bit big, 64bit big
+    known_hashes = {
+        'djba33x': [ # only used for small strings
+            # seed 0, 'abc'
+            [193485960, 193485960,  193485960, 193485960],
+            # seed 42, 'abc'
+            [-678966196, 573763426263223372, -820489388, -4282905804826039665],
+            ],
+        'siphash13': [
+            # NOTE: PyUCS2 layout depends on endianness
+            # seed 0, 'abc'
+            [69611762, -4594863902769663758, 69611762, -4594863902769663758],
+            # seed 42, 'abc'
+            [-975800855, 3869580338025362921, -975800855, 3869580338025362921],
+            # seed 42, 'abcdefghijk'
+            [-595844228, 7764564197781545852, -595844228, 7764564197781545852],
+            # seed 0, 'äú∑ℇ'
+            [-1093288643, -2810468059467891395, -1041341092, 4925090034378237276],
+            # seed 42, 'äú∑ℇ'
+            [-585999602, -2845126246016066802, -817336969, -2219421378907968137],
+        ],
+        'siphash24': [
+            # NOTE: PyUCS2 layout depends on endianness
+            # seed 0, 'abc'
+            [1198583518, 4596069200710135518, 1198583518, 4596069200710135518],
+            # seed 42, 'abc'
+            [273876886, -4501618152524544106, 273876886, -4501618152524544106],
+            # seed 42, 'abcdefghijk'
+            [-1745215313, 4436719588892876975, -1745215313, 4436719588892876975],
+            # seed 0, 'äú∑ℇ'
+            [493570806, 5749986484189612790, -1006381564, -5915111450199468540],
+            # seed 42, 'äú∑ℇ'
+            [-1677110816, -2947981342227738144, -1860207793, -4296699217652516017],
+        ],
+    }
+
+    def get_expected_hash(self, position, length):
+        if length < sys.hash_info.cutoff:
+            algorithm = "djba33x"
+        else:
+            algorithm = sys.hash_info.algorithm
+        IS_64BIT = not config.IS_32BITS
+        if sys.byteorder == 'little':
+            platform = 1 if IS_64BIT else 0
+        else:
+            assert(sys.byteorder == 'big')
+            platform = 3 if IS_64BIT else 2
+        return self.known_hashes[algorithm][position][platform]
+
+    def get_hash_command(self, repr_):
+        return 'print(hash(eval(%a)))' % repr_
+
+    def get_hash(self, repr_, seed=None):
+        env = os.environ.copy()
+        if seed is not None:
+            env['PYTHONHASHSEED'] = str(seed)
+        else:
+            env.pop('PYTHONHASHSEED', None)
+        out, _ = run_in_subprocess(code=self.get_hash_command(repr_),
+                                   env=env)
+        stdout = out.decode().strip()
+        return int(stdout)
+
+    def test_against_cpython_gold(self):
+
+        args = (('abc', 0, 0), ('abc', 42, 1), ('abcdefghijk', 42, 2),
+                ('äú∑ℇ', 0, 3), ('äú∑ℇ', 42, 4),)
+
+        for input_str, seed, position in args:
+            with self.subTest(input_str=input_str, seed=seed):
+                got = self.get_hash(repr(input_str), seed=seed)
+                expected = self.get_expected_hash(position, len(input_str))
+                self.assertEqual(got, expected)
+
+
+class BaseTest(TestCase):
+
+    def setUp(self):
+        self.cfunc = jit(nopython=True)(hash_usecase)
+
+    def check_hash_values(self, values):
+        cfunc = self.cfunc
+        for val in list(values):
+            nb_hash = cfunc(val)
+            self.assertIsInstance(nb_hash, int)
+            try:
+                self.assertEqual(nb_hash, hash(val))
+            except AssertionError as e:
+                print("val, nb_hash, hash(val)")
+                print(val, nb_hash, hash(val))
+                print("abs(val), hashing._PyHASH_MODULUS - 1")
+                print(abs(val), hashing._PyHASH_MODULUS - 1)
+                raise e
+
+    def int_samples(self, typ=np.int64):
+        for start in (0, -50, 60000, 1 << 32):
+            info = np.iinfo(typ)
+            if not info.min <= start <= info.max:
+                continue
+            n = 100
+            yield range(start, start + n)
+            yield range(start, start + 100 * n, 100)
+            yield range(start, start + 128 * n, 128)
+            yield [-1]
+
+    def float_samples(self, typ):
+        info = np.finfo(typ)
+
+        for start in (0, 10, info.max ** 0.5, info.max / 1000.0):
+            n = 100
+            min_step = max(info.tiny, start * info.resolution)
+            for step in (1.2, min_step ** 0.5, min_step):
+                if step < min_step:
+                    continue
+                a = np.linspace(start, start + n * step, n)
+                a = a.astype(typ)
+                yield a
+                yield -a
+                yield a + a.mean()
+
+        # Infs, nans, zeros, magic -1
+        a = [0.0, 0.5, -0.0, -1.0, float('inf'), -float('inf'),]
+
+        # Python 3.10 has a hash for nan based on the pointer to the PyObject
+        # containing the nan, skip this input and use explicit test instead.
+
+        yield typ(a)
+
+    def complex_samples(self, typ, float_ty):
+        for real in self.float_samples(float_ty):
+            for imag in self.float_samples(float_ty):
+                # Ensure equal sizes
+                real = real[:len(imag)]
+                imag = imag[:len(real)]
+                a = real + typ(1j) * imag
+                # Python 3.10 has a hash for nan based on the pointer to the
+                # PyObject containing the nan, skip input that ends up as nan
+                if not np.any(np.isnan(a)):
+                    yield a
+
+
+class TestNumberHashing(BaseTest):
+    """
+    Test hashing of number types.
+    """
+
+    def setUp(self):
+        if numpy_version >= (2, 0):
+            # Temporarily set promotions state to legacy,
+            # to ensure overflow logic works
+            self.initial_state = np._get_promotion_state()
+            np._set_promotion_state("legacy")
+
+        return super().setUp()
+
+    def tearDown(self) -> None:
+        if numpy_version >= (2, 0):
+            # Reset numpy promotion state to initial state
+            # since the setting is global
+            np._set_promotion_state(self.initial_state)
+
+        return super().tearDown()
+
+    def check_floats(self, typ):
+        for a in self.float_samples(typ):
+            self.assertEqual(a.dtype, np.dtype(typ))
+            self.check_hash_values(a)
+
+    def check_complex(self, typ, float_ty):
+        for a in self.complex_samples(typ, float_ty):
+            self.assertEqual(a.dtype, np.dtype(typ))
+            self.check_hash_values(a)
+
+    def test_floats(self):
+        self.check_floats(np.float32)
+        self.check_floats(np.float64)
+
+    def test_complex(self):
+        self.check_complex(np.complex64, np.float32)
+        self.check_complex(np.complex128, np.float64)
+
+    def test_bool(self):
+        self.check_hash_values([False, True])
+
+    def test_ints(self):
+        minmax = []
+
+        for ty in [np.int8, np.uint8, np.int16, np.uint16,
+                   np.int32, np.uint32, np.int64, np.uint64]:
+            for a in self.int_samples(ty):
+                self.check_hash_values(a)
+            info = np.iinfo(ty)
+            # check hash(-1) = -2
+            # check hash(0) = 0
+            self.check_hash_values([ty(-1)])
+            self.check_hash_values([ty(0)])
+            signed = 'uint' not in str(ty)
+            # check bit shifting patterns from min through to max
+            sz = ty().itemsize
+            for x in [info.min, info.max]:
+                shifts = 8 * sz
+                # x is a python int, do shifts etc as a python int and init
+                # numpy type from that to avoid numpy type rules
+                y = x
+                for i in range(shifts):
+                    twiddle1 = 0xaaaaaaaaaaaaaaaa
+                    twiddle2 = 0x5555555555555555
+                    vals = [y]
+                    for tw in [twiddle1, twiddle2]:
+                        val = y & twiddle1
+                        if val < sys.maxsize:
+                            vals.append(val)
+                    for v in vals:
+                        self.check_hash_values([ty(v)])
+                    if signed:  # try the same with flipped signs
+                        # negated signed INT_MIN will overflow
+                        for v in vals:
+                            if v != info.min:
+                                self.check_hash_values([ty(-v)])
+                    if x == 0:  # unsigned min is 0, shift up
+                        y = (y | 1) << 1
+                    else:  # everything else shift down
+                        y = y >> 1
+
+        # these straddle the branch between returning the int as the hash and
+        # doing the PyLong hash alg
+        self.check_hash_values([np.int64(0x1ffffffffffffffe)])
+        self.check_hash_values([np.int64(0x1fffffffffffffff)])
+        self.check_hash_values([np.uint64(0x1ffffffffffffffe)])
+        self.check_hash_values([np.uint64(0x1fffffffffffffff)])
+
+        # check some values near sys int mins
+        self.check_hash_values([np.int64(-0x7fffffffffffffff)])
+        self.check_hash_values([np.int64(-0x7ffffffffffffff6)])
+        self.check_hash_values([np.int64(-0x7fffffffffffff9c)])
+        self.check_hash_values([np.int32(-0x7fffffff)])
+        self.check_hash_values([np.int32(-0x7ffffff6)])
+        self.check_hash_values([np.int32(-0x7fffff9c)])
+
+    @skip_unless_py10_or_later
+    def test_py310_nan_hash(self):
+        # On Python 3.10+ nan's hash to a value which is based on the pointer to
+        # the PyObject containing the nan. Numba cannot replicate as there's no
+        # object, it instead produces equivalent behaviour, i.e. hashes to
+        # something "unique".
+
+        # Run 10 hashes, make sure that the "uniqueness" is sufficient that
+        # there's more than one hash value. Not much more can be done!
+        x = [float('nan') for i in range(10)]
+        out = set([self.cfunc(z) for z in x])
+        self.assertGreater(len(out), 1)
+
+
+class TestTupleHashing(BaseTest):
+    """
+    Test hashing of tuples.
+    """
+
+    def setUp(self):
+        if numpy_version >= (2, 0):
+            # Temporarily set promotions state to legacy,
+            # to ensure overflow logic works
+            self.initial_state = np._get_promotion_state()
+            np._set_promotion_state("legacy")
+
+        return super().setUp()
+
+    def tearDown(self) -> None:
+        if numpy_version >= (2, 0):
+            # Reset numpy promotion state to initial state
+            # since the setting is global
+            np._set_promotion_state(self.initial_state)
+
+        return super().tearDown()
+
+    def check_tuples(self, value_generator, split):
+        for values in value_generator:
+            tuples = [split(a) for a in values]
+            self.check_hash_values(tuples)
+
+    def test_homogeneous_tuples(self):
+        typ = np.uint64
+
+        def split2(i):
+            """
+            Split i's bits into 2 integers.
+            """
+            i = typ(i)
+            return (i & typ(0x5555555555555555),
+                    i & typ(0xaaaaaaaaaaaaaaaa),
+                    )
+
+        def split3(i):
+            """
+            Split i's bits into 3 integers.
+            """
+            i = typ(i)
+            return (i & typ(0x2492492492492492),
+                    i & typ(0x4924924924924924),
+                    i & typ(0x9249249249249249),
+                    )
+
+        self.check_tuples(self.int_samples(), split2)
+        self.check_tuples(self.int_samples(), split3)
+
+        # Check exact. Sample values from:
+        # https://github.com/python/cpython/blob/b738237d6792acba85b1f6e6c8993a812c7fd815/Lib/test/test_tuple.py#L80-L93
+        # Untypable empty tuples are replaced with (7,).
+        self.check_hash_values([(7,), (0,), (0, 0), (0.5,),
+                                (0.5, (7,), (-2, 3, (4, 6)))])
+
+    def test_heterogeneous_tuples(self):
+        modulo = 2**63
+
+        def split(i):
+            a = i & 0x5555555555555555
+            b = (i & 0xaaaaaaaa) ^ ((i >> 32) & 0xaaaaaaaa)
+            return np.int64(a), np.float64(b * 0.0001)
+
+        self.check_tuples(self.int_samples(), split)
+
+
+class TestUnicodeHashing(BaseTest):
+
+    def test_basic_unicode(self):
+        kind1_string = "abcdefghijklmnopqrstuvwxyz"
+        for i in range(len(kind1_string)):
+            self.check_hash_values([kind1_string[:i]])
+
+        sep = "眼"
+        kind2_string = sep.join(list(kind1_string))
+        for i in range(len(kind2_string)):
+            self.check_hash_values([kind2_string[:i]])
+
+        sep = "🐍⚡"
+        kind4_string = sep.join(list(kind1_string))
+        for i in range(len(kind4_string)):
+            self.check_hash_values([kind4_string[:i]])
+
+        empty_string = ""
+        self.check_hash_values(empty_string)
+
+    def test_hash_passthrough(self):
+        # no `hash` call made, this just checks that `._hash` is correctly
+        # passed through from an already existing string
+        kind1_string = "abcdefghijklmnopqrstuvwxyz"
+
+        @jit(nopython=True)
+        def fn(x):
+            return x._hash
+
+        hash_value = compile_time_get_string_data(kind1_string)[-1]
+        self.assertTrue(hash_value != -1)
+        self.assertEqual(fn(kind1_string), hash_value)
+
+    def test_hash_passthrough_call(self):
+        # check `x._hash` and hash(x) are the same
+        kind1_string = "abcdefghijklmnopqrstuvwxyz"
+
+        @jit(nopython=True)
+        def fn(x):
+            return x._hash, hash(x)
+
+        hash_value = compile_time_get_string_data(kind1_string)[-1]
+        self.assertTrue(hash_value != -1)
+        self.assertEqual(fn(kind1_string), (hash_value, hash_value))
+
+    @unittest.skip("Needs hash computation at const unpickling time")
+    def test_hash_literal(self):
+        # a strconst always seem to have an associated hash value so the hash
+        # member of the returned value should contain the correct hash
+        @jit(nopython=True)
+        def fn():
+            x = "abcdefghijklmnopqrstuvwxyz"
+            return x
+        val = fn()
+        tmp = hash("abcdefghijklmnopqrstuvwxyz")
+        self.assertEqual(tmp, (compile_time_get_string_data(val)[-1]))
+
+    def test_hash_on_str_creation(self):
+        # In cPython some? new strings do not have a cached hash until hash() is
+        # called
+        def impl(do_hash):
+            const1 = "aaaa"
+            const2 = "眼眼眼眼"
+            new = const1 + const2
+            if do_hash:
+                hash(new)
+            return new
+
+        jitted = jit(nopython=True)(impl)
+
+        # do not compute the hash, cPython will have no cached hash, but Numba
+        # will
+        compute_hash = False
+        expected = impl(compute_hash)
+        got = jitted(compute_hash)
+        a = (compile_time_get_string_data(expected))
+        b = (compile_time_get_string_data(got))
+        self.assertEqual(a[:-1], b[:-1])
+        self.assertTrue(a[-1] != b[-1])
+
+        # now with compute hash enabled, cPython will have a cached hash as will
+        # Numba
+        compute_hash = True
+        expected = impl(compute_hash)
+        got = jitted(compute_hash)
+        a = (compile_time_get_string_data(expected))
+        b = (compile_time_get_string_data(got))
+        self.assertEqual(a, b)
+
+
+class TestUnhashable(TestCase):
+    # Tests that unhashable types behave correctly and raise a TypeError at
+    # runtime.
+
+    def test_hash_unhashable(self):
+        unhashables = (typed.Dict().empty(types.int64, types.int64),
+                       typed.List().empty_list(types.int64),
+                       np.ones(4))
+        cfunc = jit(nopython=True)(hash_usecase)
+        for ty in unhashables:
+            with self.assertRaises(TypeError) as raises:
+                cfunc(ty)
+            expected = f"unhashable type: '{str(typeof(ty))}'"
+            self.assertIn(expected, str(raises.exception))
+
+    def test_no_generic_hash(self):
+        # In CPython, if there's no attr `__hash__` on an object, a hash of the
+        # object's pointer is returned (see: _Py_HashPointer in the CPython
+        # source). Numba has no access to such objects and can't create them
+        # either, so it catches this case and raises an exception.
+
+        @jit(nopython=True)
+        def foo():
+            hash(np.cos)
+
+        with self.assertRaises(TypeError) as raises:
+            foo()
+
+        expected = ("No __hash__ is defined for object ")
+        self.assertIn(expected, str(raises.exception))
+
+
+if __name__ == "__main__":
+    unittest.main()

lib/python3.10/site-packages/numba/tests/test_heapq.py

@@ -0,0 +1,484 @@
+import heapq as hq
+import itertools
+
+import numpy as np
+
+from numba import jit, typed
+from numba.tests.support import TestCase, MemoryLeakMixin
+
+
+def heapify(x):
+    return hq.heapify(x)
+
+
+def heappop(heap):
+    return hq.heappop(heap)
+
+
+def heappush(heap, item):
+    return hq.heappush(heap, item)
+
+
+def heappushpop(heap, item):
+    return hq.heappushpop(heap, item)
+
+
+def heapreplace(heap, item):
+    return hq.heapreplace(heap, item)
+
+
+def nsmallest(n, iterable):
+    return hq.nsmallest(n, iterable)
+
+
+def nlargest(n, iterable):
+    return hq.nlargest(n, iterable)
+
+
+class _TestHeapq(MemoryLeakMixin):
+
+    def setUp(self):
+        super(_TestHeapq, self).setUp()
+        self.rnd = np.random.RandomState(42)
+
+    def test_heapify_basic_sanity(self):
+        pyfunc = heapify
+        cfunc = jit(nopython=True)(pyfunc)
+
+        a = [1, 3, 5, 7, 9, 2, 4, 6, 8, 0]
+        b = self.listimpl(a)
+
+        pyfunc(a)
+        cfunc(b)
+        self.assertPreciseEqual(a, list(b))
+
+        # includes non-finite elements
+        element_pool = [3.142, -10.0, 5.5, np.nan, -np.inf, np.inf]
+
+        # list which may contain duplicate elements
+        for x in itertools.combinations_with_replacement(element_pool, 6):
+            a = list(x)
+            b = self.listimpl(a)
+
+            pyfunc(a)
+            cfunc(b)
+            self.assertPreciseEqual(a, list(b))
+
+        # single element list
+        for i in range(len(element_pool)):
+            a = [element_pool[i]]
+            b = self.listimpl(a)
+
+            pyfunc(a)
+            cfunc(b)
+            self.assertPreciseEqual(a, list(b))
+
+        # elements are tuples
+        a = [(3, 33), (1, 11), (2, 22)]
+        b = self.listimpl(a)
+        pyfunc(a)
+        cfunc(b)
+        self.assertPreciseEqual(a, list(b))
+
+    def check_invariant(self, heap):
+        for pos, item in enumerate(heap):
+            if pos:
+                parentpos = (pos - 1) >> 1
+                self.assertTrue(heap[parentpos] <= item)
+
+    def test_push_pop(self):
+        # inspired by
+        # https://github.com/python/cpython/blob/e42b7051/Lib/test/test_heapq.py
+        pyfunc_heappush = heappush
+        cfunc_heappush = jit(nopython=True)(pyfunc_heappush)
+
+        pyfunc_heappop = heappop
+        cfunc_heappop = jit(nopython=True)(pyfunc_heappop)
+
+        heap = self.listimpl([-1.0])
+        data = self.listimpl([-1.0])
+        self.check_invariant(heap)
+        for i in range(256):
+            item = self.rnd.randn(1).item(0)
+            data.append(item)
+            cfunc_heappush(heap, item)
+            self.check_invariant(heap)
+        results = []
+        while heap:
+            item = cfunc_heappop(heap)
+            self.check_invariant(heap)
+            results.append(item)
+        data_sorted = data[:]
+        data_sorted.sort()
+        self.assertPreciseEqual(list(data_sorted), results)
+        self.check_invariant(results)
+
+    def test_heapify(self):
+        # inspired by
+        # https://github.com/python/cpython/blob/e42b7051/Lib/test/test_heapq.py
+        pyfunc = heapify
+        cfunc = jit(nopython=True)(pyfunc)
+
+        for size in list(range(1, 30)) + [20000]:
+            heap = self.listimpl(self.rnd.random_sample(size))
+            cfunc(heap)
+            self.check_invariant(heap)
+
+    def test_heapify_exceptions(self):
+        pyfunc = heapify
+        cfunc = jit(nopython=True)(pyfunc)
+
+        # Exceptions leak references
+        self.disable_leak_check()
+
+        with self.assertTypingError() as e:
+            cfunc((1, 5, 4))
+
+        msg = 'heap argument must be a list'
+        self.assertIn(msg, str(e.exception))
+
+        with self.assertTypingError() as e:
+            cfunc(self.listimpl([1 + 1j, 2 - 3j]))
+
+        msg = ("'<' not supported between instances "
+               "of 'complex' and 'complex'")
+        self.assertIn(msg, str(e.exception))
+
+    def test_heappop_basic_sanity(self):
+        pyfunc = heappop
+        cfunc = jit(nopython=True)(pyfunc)
+
+        def a_variations():
+            yield [1, 3, 5, 7, 9, 2, 4, 6, 8, 0]
+            yield [(3, 33), (1, 111), (2, 2222)]
+            yield np.full(5, fill_value=np.nan).tolist()
+            yield np.linspace(-10, -5, 100).tolist()
+
+        for a in a_variations():
+            heapify(a)
+            b = self.listimpl(a)
+
+            for i in range(len(a)):
+                val_py = pyfunc(a)
+                val_c = cfunc(b)
+                self.assertPreciseEqual(a, list(b))
+                self.assertPreciseEqual(val_py, val_c)
+
+    def test_heappop_exceptions(self):
+        pyfunc = heappop
+        cfunc = jit(nopython=True)(pyfunc)
+
+        # Exceptions leak references
+        self.disable_leak_check()
+
+        with self.assertTypingError() as e:
+            cfunc((1, 5, 4))
+
+        msg = 'heap argument must be a list'
+        self.assertIn(msg, str(e.exception))
+
+    def iterables(self):
+        yield self.listimpl([1, 3, 5, 7, 9, 2, 4, 6, 8, 0])
+        a = np.linspace(-10, 2, 23)
+        yield self.listimpl(a)
+        yield self.listimpl(a[::-1])
+        self.rnd.shuffle(a)
+        yield self.listimpl(a)
+
+    def test_heappush_basic(self):
+        pyfunc_push = heappush
+        cfunc_push = jit(nopython=True)(pyfunc_push)
+
+        pyfunc_pop = heappop
+        cfunc_pop = jit(nopython=True)(pyfunc_pop)
+
+        for iterable in self.iterables():
+            expected = sorted(iterable)
+            heap = self.listimpl([iterable.pop(0)])  # must initialise heap
+
+            for value in iterable:
+                cfunc_push(heap, value)
+
+            got = [cfunc_pop(heap) for _ in range(len(heap))]
+            self.assertPreciseEqual(expected, got)
+
+    def test_heappush_exceptions(self):
+        pyfunc = heappush
+        cfunc = jit(nopython=True)(pyfunc)
+
+        # Exceptions leak references
+        self.disable_leak_check()
+
+        with self.assertTypingError() as e:
+            cfunc((1, 5, 4), 6)
+
+        msg = 'heap argument must be a list'
+        self.assertIn(msg, str(e.exception))
+
+        with self.assertTypingError() as e:
+            cfunc(self.listimpl([1, 5, 4]), 6.0)
+
+        msg = 'heap type must be the same as item type'
+        self.assertIn(msg, str(e.exception))
+
+    def test_nsmallest_basic(self):
+        pyfunc = nsmallest
+        cfunc = jit(nopython=True)(pyfunc)
+
+        for iterable in self.iterables():
+            for n in range(-5, len(iterable) + 3):
+                expected = pyfunc(1, iterable)
+                got = cfunc(1, iterable)
+                self.assertPreciseEqual(expected, got)
+
+        # n is boolean
+        out = cfunc(False, self.listimpl([3, 2, 1]))
+        self.assertPreciseEqual(out, [])
+
+        out = cfunc(True, self.listimpl([3, 2, 1]))
+        self.assertPreciseEqual(out, [1])
+
+        # iterable is not a list
+        out = cfunc(2, (6, 5, 4, 3, 2, 1))
+        self.assertPreciseEqual(out, [1, 2])
+
+        out = cfunc(3, np.arange(6))
+        self.assertPreciseEqual(out, [0, 1, 2])
+
+    def test_nlargest_basic(self):
+        pyfunc = nlargest
+        cfunc = jit(nopython=True)(pyfunc)
+
+        for iterable in self.iterables():
+            for n in range(-5, len(iterable) + 3):
+                expected = pyfunc(1, iterable)
+                got = cfunc(1, iterable)
+                self.assertPreciseEqual(expected, got)
+
+        # n is boolean
+        out = cfunc(False, self.listimpl([3, 2, 1]))
+        self.assertPreciseEqual(out, [])
+
+        out = cfunc(True, self.listimpl([3, 2, 1]))
+        self.assertPreciseEqual(out, [3])
+
+        # iterable is not a list
+        out = cfunc(2, (6, 5, 4, 3, 2, 1))
+        self.assertPreciseEqual(out, [6, 5])
+
+        out = cfunc(3, np.arange(6))
+        self.assertPreciseEqual(out, [5, 4, 3])
+
+    def _assert_typing_error(self, cfunc):
+
+        # Exceptions leak references
+        self.disable_leak_check()
+
+        with self.assertTypingError() as e:
+            cfunc(2.2, self.listimpl([3, 2, 1]))
+
+        msg = "First argument 'n' must be an integer"
+        self.assertIn(msg, str(e.exception))
+
+        with self.assertTypingError() as e:
+            cfunc(2, 100)
+
+        msg = "Second argument 'iterable' must be iterable"
+        self.assertIn(msg, str(e.exception))
+
+    def test_nsmallest_exceptions(self):
+        pyfunc = nsmallest
+        cfunc = jit(nopython=True)(pyfunc)
+        self._assert_typing_error(cfunc)
+
+    def test_nlargest_exceptions(self):
+        pyfunc = nlargest
+        cfunc = jit(nopython=True)(pyfunc)
+        self._assert_typing_error(cfunc)
+
+    def test_heapreplace_basic(self):
+        pyfunc = heapreplace
+        cfunc = jit(nopython=True)(pyfunc)
+
+        a = [1, 3, 5, 7, 9, 2, 4, 6, 8, 0]
+
+        heapify(a)
+        b = self.listimpl(a)
+
+        for item in [-4, 4, 14]:
+            pyfunc(a, item)
+            cfunc(b, item)
+            self.assertPreciseEqual(a, list(b))
+
+        a = np.linspace(-3, 13, 20)
+        a[4] = np.nan
+        a[-1] = np.inf
+        a = a.tolist()
+
+        heapify(a)
+        b = self.listimpl(a)
+
+        for item in [-4.0, 3.142, -np.inf, np.inf]:
+            pyfunc(a, item)
+            cfunc(b, item)
+            self.assertPreciseEqual(a, list(b))
+
+    def test_heapreplace_exceptions(self):
+        pyfunc = heapreplace
+        cfunc = jit(nopython=True)(pyfunc)
+
+        # Exceptions leak references
+        self.disable_leak_check()
+
+        with self.assertTypingError() as e:
+            cfunc((1, 5, 4), -1)
+
+        msg = 'heap argument must be a list'
+        self.assertIn(msg, str(e.exception))
+
+        with self.assertTypingError() as e:
+            cfunc(self.listimpl([1, 5, 4]), -1.0)
+
+        msg = 'heap type must be the same as item type'
+        self.assertIn(msg, str(e.exception))
+
+    def heapiter(self, heap):
+        try:
+            while 1:
+                yield heappop(heap)
+        except IndexError:
+            pass
+
+    def test_nbest(self):
+        # inspired by
+        # https://github.com/python/cpython/blob/e42b7051/Lib/test/test_heapq.py
+        cfunc_heapify = jit(nopython=True)(heapify)
+        cfunc_heapreplace = jit(nopython=True)(heapreplace)
+
+        data = self.rnd.choice(range(2000), 1000).tolist()
+        heap = self.listimpl(data[:10])
+        cfunc_heapify(heap)
+
+        for item in data[10:]:
+            if item > heap[0]:
+                cfunc_heapreplace(heap, item)
+
+        self.assertPreciseEqual(list(self.heapiter(list(heap))),
+                                sorted(data)[-10:])
+
+    def test_heapsort(self):
+        # inspired by
+        # https://github.com/python/cpython/blob/e42b7051/Lib/test/test_heapq.py
+        cfunc_heapify = jit(nopython=True)(heapify)
+        cfunc_heappush = jit(nopython=True)(heappush)
+        cfunc_heappop = jit(nopython=True)(heappop)
+
+        for trial in range(100):
+            # Ensure consistency of typing, use float64 as it's double
+            # everywhere
+            values = np.arange(5, dtype=np.float64)
+            data = self.listimpl(self.rnd.choice(values, 10))
+            if trial & 1:
+                heap = data[:]
+                cfunc_heapify(heap)
+            else:
+                heap = self.listimpl([data[0]])
+                for item in data[1:]:
+                    cfunc_heappush(heap, item)
+            heap_sorted = [cfunc_heappop(heap) for _ in range(10)]
+            self.assertPreciseEqual(heap_sorted, sorted(data))
+
+    def test_nsmallest(self):
+        # inspired by
+        # https://github.com/python/cpython/blob/e42b7051/Lib/test/test_heapq.py
+        pyfunc = nsmallest
+        cfunc = jit(nopython=True)(pyfunc)
+
+        data = self.listimpl(self.rnd.choice(range(2000), 1000))
+
+        for n in (0, 1, 2, 10, 100, 400, 999, 1000, 1100):
+            self.assertPreciseEqual(list(cfunc(n, data)), sorted(data)[:n])
+
+    def test_nlargest(self):
+        # inspired by
+        # https://github.com/python/cpython/blob/e42b7051/Lib/test/test_heapq.py
+        pyfunc = nlargest
+        cfunc = jit(nopython=True)(pyfunc)
+
+        data = self.listimpl(self.rnd.choice(range(2000), 1000))
+
+        for n in (0, 1, 2, 10, 100, 400, 999, 1000, 1100):
+            self.assertPreciseEqual(list(cfunc(n, data)),
+                                    sorted(data, reverse=True)[:n])
+
+    def test_nbest_with_pushpop(self):
+        # inspired by
+        # https://github.com/python/cpython/blob/e42b7051/Lib/test/test_heapq.py
+        pyfunc_heappushpop = heappushpop
+        cfunc_heappushpop = jit(nopython=True)(pyfunc_heappushpop)
+
+        pyfunc_heapify = heapify
+        cfunc_heapify = jit(nopython=True)(pyfunc_heapify)
+
+        # Ensure consistency of typing, use float64 as it's double everywhere
+        values = np.arange(2000, dtype=np.float64)
+        data = self.listimpl(self.rnd.choice(values, 1000))
+        heap = data[:10]
+        cfunc_heapify(heap)
+
+        for item in data[10:]:
+            cfunc_heappushpop(heap, item)
+
+        self.assertPreciseEqual(list(self.heapiter(list(heap))),
+                                sorted(data)[-10:])
+
+    def test_heappushpop(self):
+        # inspired by
+        # https://github.com/python/cpython/blob/e42b7051/Lib/test/test_heapq.py
+        pyfunc = heappushpop
+        cfunc = jit(nopython=True)(pyfunc)
+
+        h = self.listimpl([1.0])
+        x = cfunc(h, 10.0)
+        self.assertPreciseEqual((list(h), x), ([10.0], 1.0))
+        self.assertPreciseEqual(type(h[0]), float)
+        self.assertPreciseEqual(type(x), float)
+
+        h = self.listimpl([10])
+        x = cfunc(h, 9)
+        self.assertPreciseEqual((list(h), x), ([10], 9))
+
+        h = self.listimpl([10])
+        x = cfunc(h, 11)
+        self.assertPreciseEqual((list(h), x), ([11], 10))
+
+    def test_heappushpop_exceptions(self):
+        pyfunc = heappushpop
+        cfunc = jit(nopython=True)(pyfunc)
+
+        # Exceptions leak references
+        self.disable_leak_check()
+
+        with self.assertTypingError() as e:
+            cfunc((1, 5, 4), -1)
+
+        msg = 'heap argument must be a list'
+        self.assertIn(msg, str(e.exception))
+
+        with self.assertTypingError() as e:
+            cfunc(self.listimpl([1, 5, 4]), False)
+
+        msg = 'heap type must be the same as item type'
+        self.assertIn(msg, str(e.exception))
+
+
+class TestHeapqReflectedList(_TestHeapq, TestCase):
+    """Test heapq with reflected lists"""
+
+    listimpl = list
+
+
+class TestHeapqTypedList(_TestHeapq, TestCase):
+    """Test heapq with typed lists"""
+
+    listimpl = typed.List

lib/python3.10/site-packages/numba/tests/test_inlining.py

@@ -0,0 +1,279 @@
+import re
+import numpy as np
+
+from numba.tests.support import (TestCase, override_config, captured_stdout,
+                      skip_parfors_unsupported)
+from numba import jit, njit
+from numba.core import types, ir, postproc, compiler
+from numba.core.ir_utils import (guard, find_callname, find_const,
+                                 get_definition, simplify_CFG)
+from numba.core.registry import CPUDispatcher
+from numba.core.inline_closurecall import inline_closure_call
+
+from numba.core.untyped_passes import (ExtractByteCode, TranslateByteCode, FixupArgs,
+                             IRProcessing, DeadBranchPrune,
+                             RewriteSemanticConstants, GenericRewrites,
+                             WithLifting, PreserveIR, InlineClosureLikes)
+
+from numba.core.typed_passes import (NopythonTypeInference, AnnotateTypes,
+                           NopythonRewrites, PreParforPass, ParforPass,
+                           DumpParforDiagnostics, NativeLowering,
+                           NativeParforLowering, IRLegalization,
+                           NoPythonBackend, NativeLowering,
+                           ParforFusionPass, ParforPreLoweringPass)
+
+from numba.core.compiler_machinery import FunctionPass, PassManager, register_pass
+import unittest
+
+@register_pass(analysis_only=False, mutates_CFG=True)
+class InlineTestPass(FunctionPass):
+    _name = "inline_test_pass"
+
+    def __init__(self):
+        FunctionPass.__init__(self)
+
+    def run_pass(self, state):
+        # assuming the function has one block with one call inside
+        assert len(state.func_ir.blocks) == 1
+        block = list(state.func_ir.blocks.values())[0]
+        for i, stmt in enumerate(block.body):
+            if guard(find_callname,state.func_ir, stmt.value) is not None:
+                inline_closure_call(state.func_ir, {}, block, i, lambda: None,
+                                    state.typingctx, state.targetctx, (),
+                                    state.typemap, state.calltypes)
+                break
+        # also fix up the IR
+        post_proc = postproc.PostProcessor(state.func_ir)
+        post_proc.run()
+        post_proc.remove_dels()
+        return True
+
+
+def gen_pipeline(state, test_pass):
+        name = 'inline_test'
+        pm = PassManager(name)
+        pm.add_pass(TranslateByteCode, "analyzing bytecode")
+        pm.add_pass(FixupArgs, "fix up args")
+        pm.add_pass(IRProcessing, "processing IR")
+        pm.add_pass(WithLifting, "Handle with contexts")
+        # pre typing
+        if not state.flags.no_rewrites:
+            pm.add_pass(GenericRewrites, "nopython rewrites")
+            pm.add_pass(RewriteSemanticConstants, "rewrite semantic constants")
+            pm.add_pass(DeadBranchPrune, "dead branch pruning")
+        pm.add_pass(InlineClosureLikes,
+                    "inline calls to locally defined closures")
+        # typing
+        pm.add_pass(NopythonTypeInference, "nopython frontend")
+
+        if state.flags.auto_parallel.enabled:
+            pm.add_pass(PreParforPass, "Preprocessing for parfors")
+        if not state.flags.no_rewrites:
+            pm.add_pass(NopythonRewrites, "nopython rewrites")
+        if state.flags.auto_parallel.enabled:
+            pm.add_pass(ParforPass, "convert to parfors")
+            pm.add_pass(ParforFusionPass, "fuse parfors")
+            pm.add_pass(ParforPreLoweringPass, "parfor prelowering")
+
+        pm.add_pass(test_pass, "inline test")
+
+        # legalise
+        pm.add_pass(IRLegalization, "ensure IR is legal prior to lowering")
+        pm.add_pass(AnnotateTypes, "annotate types")
+        pm.add_pass(PreserveIR, "preserve IR")
+
+        # lower
+        if state.flags.auto_parallel.enabled:
+            pm.add_pass(NativeParforLowering, "native parfor lowering")
+        else:
+            pm.add_pass(NativeLowering, "native lowering")
+        pm.add_pass(NoPythonBackend, "nopython mode backend")
+        pm.add_pass(DumpParforDiagnostics, "dump parfor diagnostics")
+        return pm
+
+class InlineTestPipeline(compiler.CompilerBase):
+    """compiler pipeline for testing inlining after optimization
+    """
+    def define_pipelines(self):
+        pm = gen_pipeline(self.state, InlineTestPass)
+        pm.finalize()
+        return [pm]
+
+class TestInlining(TestCase):
+    """
+    Check that jitted inner functions are inlined into outer functions,
+    in nopython mode.
+    Note that not all inner functions are guaranteed to be inlined.
+    We just trust LLVM's inlining heuristics.
+    """
+
+    def make_pattern(self, fullname):
+        """
+        Make regexpr to match mangled name
+        """
+        parts = fullname.split('.')
+        return r'_ZN?' + r''.join([r'\d+{}'.format(p) for p in parts])
+
+    def assert_has_pattern(self, fullname, text):
+        pat = self.make_pattern(fullname)
+        self.assertIsNotNone(re.search(pat, text),
+                             msg='expected {}'.format(pat))
+
+    def assert_not_has_pattern(self, fullname, text):
+        pat = self.make_pattern(fullname)
+        self.assertIsNone(re.search(pat, text),
+                          msg='unexpected {}'.format(pat))
+
+    def test_inner_function(self):
+        from numba.tests.inlining_usecases import outer_simple, \
+            __name__ as prefix
+
+        with override_config('DUMP_ASSEMBLY', True):
+            with captured_stdout() as out:
+                cfunc = jit((types.int32,), nopython=True)(outer_simple)
+        self.assertPreciseEqual(cfunc(1), 4)
+        # Check the inner function was elided from the output (which also
+        # guarantees it was inlined into the outer function).
+        asm = out.getvalue()
+        self.assert_has_pattern('%s.outer_simple' % prefix, asm)
+        self.assert_not_has_pattern('%s.inner' % prefix, asm)
+
+    def test_multiple_inner_functions(self):
+        from numba.tests.inlining_usecases import outer_multiple, \
+            __name__ as prefix
+        # Same with multiple inner functions, and multiple calls to
+        # the same inner function (inner()).  This checks that linking in
+        # the same library/module twice doesn't produce linker errors.
+        with override_config('DUMP_ASSEMBLY', True):
+            with captured_stdout() as out:
+                cfunc = jit((types.int32,), nopython=True)(outer_multiple)
+        self.assertPreciseEqual(cfunc(1), 6)
+        asm = out.getvalue()
+        self.assert_has_pattern('%s.outer_multiple' % prefix, asm)
+        self.assert_not_has_pattern('%s.more' % prefix, asm)
+        self.assert_not_has_pattern('%s.inner' % prefix, asm)
+
+    @skip_parfors_unsupported
+    def test_inline_call_after_parfor(self):
+        from numba.tests.inlining_usecases import __dummy__
+        # replace the call to make sure inlining doesn't cause label conflict
+        # with parfor body
+        def test_impl(A):
+            __dummy__()
+            return A.sum()
+        j_func = njit(parallel=True, pipeline_class=InlineTestPipeline)(
+                                                                    test_impl)
+        A = np.arange(10)
+        self.assertEqual(test_impl(A), j_func(A))
+
+    @skip_parfors_unsupported
+    def test_inline_update_target_def(self):
+
+        def test_impl(a):
+            if a == 1:
+                b = 2
+            else:
+                b = 3
+            return b
+
+        func_ir = compiler.run_frontend(test_impl)
+        blocks = list(func_ir.blocks.values())
+        for block in blocks:
+            for i, stmt in enumerate(block.body):
+                # match b = 2 and replace with lambda: 2
+                if (isinstance(stmt, ir.Assign) and isinstance(stmt.value, ir.Var)
+                        and guard(find_const, func_ir, stmt.value) == 2):
+                    # replace expr with a dummy call
+                    func_ir._definitions[stmt.target.name].remove(stmt.value)
+                    stmt.value = ir.Expr.call(ir.Var(block.scope, "myvar", loc=stmt.loc), (), (), stmt.loc)
+                    func_ir._definitions[stmt.target.name].append(stmt.value)
+                    #func = g.py_func#
+                    inline_closure_call(func_ir, {}, block, i, lambda: 2)
+                    break
+
+        self.assertEqual(len(func_ir._definitions['b']), 2)
+
+    @skip_parfors_unsupported
+    def test_inline_var_dict_ret(self):
+        # make sure inline_closure_call returns the variable replacement dict
+        # and it contains the original variable name used in locals
+        @njit(locals={'b': types.float64})
+        def g(a):
+            b = a + 1
+            return b
+
+        def test_impl():
+            return g(1)
+
+        func_ir = compiler.run_frontend(test_impl)
+        blocks = list(func_ir.blocks.values())
+        for block in blocks:
+            for i, stmt in enumerate(block.body):
+                if (isinstance(stmt, ir.Assign)
+                        and isinstance(stmt.value, ir.Expr)
+                        and stmt.value.op == 'call'):
+                    func_def = guard(get_definition, func_ir, stmt.value.func)
+                    if (isinstance(func_def, (ir.Global, ir.FreeVar))
+                            and isinstance(func_def.value, CPUDispatcher)):
+                        py_func = func_def.value.py_func
+                        _, var_map = inline_closure_call(
+                            func_ir, py_func.__globals__, block, i, py_func)
+                        break
+
+        self.assertTrue('b' in var_map)
+
+    @skip_parfors_unsupported
+    def test_inline_call_branch_pruning(self):
+        # branch pruning pass should run properly in inlining to enable
+        # functions with type checks
+        @njit
+        def foo(A=None):
+            if A is None:
+                return 2
+            else:
+                return A
+
+        def test_impl(A=None):
+            return foo(A)
+
+        @register_pass(analysis_only=False, mutates_CFG=True)
+        class PruningInlineTestPass(FunctionPass):
+            _name = "pruning_inline_test_pass"
+
+            def __init__(self):
+                FunctionPass.__init__(self)
+
+            def run_pass(self, state):
+                # assuming the function has one block with one call inside
+                assert len(state.func_ir.blocks) == 1
+                block = list(state.func_ir.blocks.values())[0]
+                for i, stmt in enumerate(block.body):
+                    if (guard(find_callname, state.func_ir, stmt.value)
+                            is not None):
+                        inline_closure_call(state.func_ir, {}, block, i,
+                            foo.py_func, state.typingctx, state.targetctx,
+                            (state.typemap[stmt.value.args[0].name],),
+                             state.typemap, state.calltypes)
+                        break
+                return True
+
+        class InlineTestPipelinePrune(compiler.CompilerBase):
+
+            def define_pipelines(self):
+                pm = gen_pipeline(self.state, PruningInlineTestPass)
+                pm.finalize()
+                return [pm]
+
+        # make sure inline_closure_call runs in full pipeline
+        j_func = njit(pipeline_class=InlineTestPipelinePrune)(test_impl)
+        A = 3
+        self.assertEqual(test_impl(A), j_func(A))
+        self.assertEqual(test_impl(), j_func())
+
+        # make sure IR doesn't have branches
+        fir = j_func.overloads[(types.Omitted(None),)].metadata['preserved_ir']
+        fir.blocks = simplify_CFG(fir.blocks)
+        self.assertEqual(len(fir.blocks), 1)
+
+if __name__ == '__main__':
+    unittest.main()

lib/python3.10/site-packages/numba/tests/test_ir_utils.py

@@ -0,0 +1,273 @@
+import numba
+from numba.tests.support import TestCase, unittest
+from numba.core.registry import cpu_target
+from numba.core.compiler import CompilerBase, Flags
+from numba.core.compiler_machinery import PassManager
+from numba.core import types, ir, bytecode, compiler, ir_utils, registry
+from numba.core.untyped_passes import (ExtractByteCode, TranslateByteCode,
+                                       FixupArgs, IRProcessing,)
+
+from numba.core.typed_passes import (NopythonTypeInference,
+                                     type_inference_stage, DeadCodeElimination)
+from numba.experimental import jitclass
+
+# global constant for testing find_const
+GLOBAL_B = 11
+
+
+@jitclass([('val', numba.core.types.List(numba.intp))])
+class Dummy(object):
+    def __init__(self, val):
+        self.val = val
+
+
+class TestIrUtils(TestCase):
+    """
+    Tests ir handling utility functions like find_callname.
+    """
+
+    def test_obj_func_match(self):
+        """Test matching of an object method (other than Array see #3449)
+        """
+
+        def test_func():
+            d = Dummy([1])
+            d.val.append(2)
+
+        test_ir = compiler.run_frontend(test_func)
+        typingctx = cpu_target.typing_context
+        targetctx = cpu_target.target_context
+        typing_res = type_inference_stage(
+            typingctx, targetctx, test_ir, (), None)
+        matched_call = ir_utils.find_callname(
+            test_ir, test_ir.blocks[0].body[7].value, typing_res.typemap)
+        self.assertTrue(isinstance(matched_call, tuple) and
+                        len(matched_call) == 2 and
+                        matched_call[0] == 'append')
+
+    def test_dead_code_elimination(self):
+
+        class Tester(CompilerBase):
+
+            @classmethod
+            def mk_pipeline(cls, args, return_type=None, flags=None, locals={},
+                            library=None, typing_context=None,
+                            target_context=None):
+                if not flags:
+                    flags = Flags()
+                flags.nrt = True
+                if typing_context is None:
+                    typing_context = registry.cpu_target.typing_context
+                if target_context is None:
+                    target_context = registry.cpu_target.target_context
+                return cls(typing_context, target_context, library, args,
+                           return_type, flags, locals)
+
+            def compile_to_ir(self, func, DCE=False):
+                """
+                Compile and return IR
+                """
+                func_id = bytecode.FunctionIdentity.from_function(func)
+                self.state.func_id = func_id
+                ExtractByteCode().run_pass(self.state)
+                state = self.state
+
+                name = "DCE_testing"
+                pm = PassManager(name)
+                pm.add_pass(TranslateByteCode, "analyzing bytecode")
+                pm.add_pass(FixupArgs, "fix up args")
+                pm.add_pass(IRProcessing, "processing IR")
+                pm.add_pass(NopythonTypeInference, "nopython frontend")
+                if DCE is True:
+                    pm.add_pass(DeadCodeElimination, "DCE after typing")
+                pm.finalize()
+                pm.run(state)
+                return state.func_ir
+
+        def check_initial_ir(the_ir):
+            # dead stuff:
+            # a const int value 0xdead
+            # an assign of above into to variable `dead`
+            # a const int above 0xdeaddead
+            # an assign of said int to variable `deaddead`
+            # this is 2 statements to remove
+
+            self.assertEqual(len(the_ir.blocks), 1)
+            block = the_ir.blocks[0]
+            deads = []
+            for x in block.find_insts(ir.Assign):
+                if isinstance(getattr(x, 'target', None), ir.Var):
+                    if 'dead' in getattr(x.target, 'name', ''):
+                        deads.append(x)
+
+            self.assertEqual(len(deads), 2)
+            for d in deads:
+                # check the ir.Const is the definition and the value is expected
+                const_val = the_ir.get_definition(d.value)
+                self.assertTrue(int('0x%s' % d.target.name, 16),
+                                const_val.value)
+
+            return deads
+
+        def check_dce_ir(the_ir):
+            self.assertEqual(len(the_ir.blocks), 1)
+            block = the_ir.blocks[0]
+            deads = []
+            consts = []
+            for x in block.find_insts(ir.Assign):
+                if isinstance(getattr(x, 'target', None), ir.Var):
+                    if 'dead' in getattr(x.target, 'name', ''):
+                        deads.append(x)
+                if isinstance(getattr(x, 'value', None), ir.Const):
+                    consts.append(x)
+            self.assertEqual(len(deads), 0)
+
+            # check the consts to make sure there's no reference to 0xdead or
+            # 0xdeaddead
+            for x in consts:
+                self.assertTrue(x.value.value not in [0xdead, 0xdeaddead])
+
+        def foo(x):
+            y = x + 1
+            dead = 0xdead  # noqa
+            z = y + 2
+            deaddead = 0xdeaddead  # noqa
+            ret = z * z
+            return ret
+
+        test_pipeline = Tester.mk_pipeline((types.intp,))
+        no_dce = test_pipeline.compile_to_ir(foo)
+        removed = check_initial_ir(no_dce)
+
+        test_pipeline = Tester.mk_pipeline((types.intp,))
+        w_dce = test_pipeline.compile_to_ir(foo, DCE=True)
+        check_dce_ir(w_dce)
+
+        # check that the count of initial - removed = dce
+        self.assertEqual(len(no_dce.blocks[0].body) - len(removed),
+                         len(w_dce.blocks[0].body))
+
+    def test_find_const_global(self):
+        """
+        Test find_const() for values in globals (ir.Global) and freevars
+        (ir.FreeVar) that are considered constants for compilation.
+        """
+        FREEVAR_C = 12
+
+        def foo(a):
+            b = GLOBAL_B
+            c = FREEVAR_C
+            return a + b + c
+
+        f_ir = compiler.run_frontend(foo)
+        block = f_ir.blocks[0]
+        const_b = None
+        const_c = None
+
+        for inst in block.body:
+            if isinstance(inst, ir.Assign) and inst.target.name == 'b':
+                const_b = ir_utils.guard(
+                    ir_utils.find_const, f_ir, inst.target)
+            if isinstance(inst, ir.Assign) and inst.target.name == 'c':
+                const_c = ir_utils.guard(
+                    ir_utils.find_const, f_ir, inst.target)
+
+        self.assertEqual(const_b, GLOBAL_B)
+        self.assertEqual(const_c, FREEVAR_C)
+
+    def test_flatten_labels(self):
+        """ tests flatten_labels """
+        def foo(a):
+            acc = 0
+            if a > 3:
+                acc += 1
+                if a > 19:
+                    return 53
+            elif a < 1000:
+                if a >= 12:
+                    acc += 1
+                for x in range(10):
+                    acc -= 1
+                    if acc < 2:
+                        break
+                else:
+                    acc += 7
+            else:
+                raise ValueError("some string")
+            # prevents inline of return on py310
+            py310_defeat1 = 1  # noqa
+            py310_defeat2 = 2  # noqa
+            py310_defeat3 = 3  # noqa
+            py310_defeat4 = 4  # noqa
+            return acc
+
+        def bar(a):
+            acc = 0
+            z = 12
+            if a > 3:
+                acc += 1
+                z += 12
+                if a > 19:
+                    z += 12
+                    return 53
+            elif a < 1000:
+                if a >= 12:
+                    z += 12
+                    acc += 1
+                for x in range(10):
+                    z += 12
+                    acc -= 1
+                    if acc < 2:
+                        break
+                else:
+                    z += 12
+                    acc += 7
+            else:
+                raise ValueError("some string")
+            py310_defeat1 = 1  # noqa
+            py310_defeat2 = 2  # noqa
+            py310_defeat3 = 3  # noqa
+            py310_defeat4 = 4  # noqa
+            return acc
+
+        def baz(a):
+            acc = 0
+            if a > 3:
+                acc += 1
+                if a > 19:
+                    return 53
+                else: # extra control flow in comparison to foo
+                    return 55
+            elif a < 1000:
+                if a >= 12:
+                    acc += 1
+                for x in range(10):
+                    acc -= 1
+                    if acc < 2:
+                        break
+                else:
+                    acc += 7
+            else:
+                raise ValueError("some string")
+            py310_defeat1 = 1  # noqa
+            py310_defeat2 = 2  # noqa
+            py310_defeat3 = 3  # noqa
+            py310_defeat4 = 4  # noqa
+            return acc
+
+        def get_flat_cfg(func):
+            func_ir = ir_utils.compile_to_numba_ir(func, dict())
+            flat_blocks = ir_utils.flatten_labels(func_ir.blocks)
+            self.assertEqual(max(flat_blocks.keys()) + 1, len(func_ir.blocks))
+            return ir_utils.compute_cfg_from_blocks(flat_blocks)
+
+        foo_cfg = get_flat_cfg(foo)
+        bar_cfg = get_flat_cfg(bar)
+        baz_cfg = get_flat_cfg(baz)
+
+        self.assertEqual(foo_cfg, bar_cfg)
+        self.assertNotEqual(foo_cfg, baz_cfg)
+
+
+if __name__ == "__main__":
+    unittest.main()

lib/python3.10/site-packages/numba/tests/test_jitmethod.py

@@ -0,0 +1,70 @@
+import unittest
+
+import numpy as np
+
+from numba import jit
+from numba.tests.support import override_config
+
+
+class TestJITMethod(unittest.TestCase):
+    def test_bound_jit_method_with_loop_lift(self):
+        class Something(object):
+            def __init__(self, x0):
+                self.x0 = x0
+
+            @jit(forceobj=True)
+            def method(self, x):
+                a = np.empty(shape=5, dtype=np.float32)
+                x0 = self.x0
+
+                for i in range(a.shape[0]):
+                    a[i] = x0 * x
+
+                return a
+
+        something = Something(3)
+        np.testing.assert_array_equal(something.method(5),
+            np.array([15, 15, 15, 15, 15], dtype=np.float32))
+
+        # Check that loop lifting in nopython mode was successful
+        [cres] = something.method.overloads.values()
+        jitloop = cres.lifted[0]
+        [loopcres] = jitloop.overloads.values()
+        self.assertTrue(loopcres.fndesc.native)
+
+    def test_unbound_jit_method(self):
+        class Something(object):
+            def __init__(self, x0):
+                self.x0 = x0
+
+            @jit(forceobj=True)
+            def method(self):
+                return self.x0
+
+        something = Something(3)
+        self.assertEqual(Something.method(something), 3)
+
+
+class TestDisabledJIT(unittest.TestCase):
+    def test_decorated_function(self):
+        with override_config('DISABLE_JIT', True):
+            def method(x):
+                return x
+            jitted = jit(method)
+
+        self.assertEqual(jitted, method)
+        self.assertEqual(10, method(10))
+        self.assertEqual(10, jitted(10))
+
+    def test_decorated_function_with_kwargs(self):
+        with override_config('DISABLE_JIT', True):
+            def method(x):
+                return x
+            jitted = jit(nopython=True)(method)
+
+        self.assertEqual(jitted, method)
+        self.assertEqual(10, method(10))
+        self.assertEqual(10, jitted(10))
+
+if __name__ == '__main__':
+    unittest.main()

lib/python3.10/site-packages/numba/tests/test_listimpl.py

@@ -0,0 +1,527 @@
+"""
+Testing C implementation of the numba typed-list
+"""
+
+import ctypes
+import struct
+
+from numba.tests.support import TestCase
+from numba import _helperlib
+
+
+LIST_OK = 0
+LIST_ERR_INDEX = -1
+LIST_ERR_NO_MEMORY = -2
+LIST_ERR_MUTATED = -3
+LIST_ERR_ITER_EXHAUSTED = -4
+LIST_ERR_IMMUTABLE = -5
+
+
+class List(object):
+    """A wrapper around the C-API to provide a minimal list object for
+    testing.
+    """
+    def __init__(self, tc, item_size, allocated):
+        """
+        Parameters
+        ----------
+        tc : TestCase instance
+        item_size : int
+            byte size for the items
+        allocated : int
+            number of items to allocate for
+        """
+        self.tc = tc
+        self.item_size = item_size
+        self.lp = self.list_new(item_size, allocated)
+
+    # The following methods implement part of the list API
+
+    def __del__(self):
+        self.tc.numba_list_free(self.lp)
+
+    def __len__(self):
+        return self.list_length()
+
+    def __setitem__(self, i, item):
+        return self.list_setitem(i, item)
+
+    def __getitem__(self, i):
+        return self.list_getitem(i)
+
+    def __iter__(self):
+        return ListIter(self)
+
+    def __delitem__(self, i):
+        self.list_delitem(i)
+
+    def handle_index(self, i):
+        # handling negative indices is done at the compiler level, so we only
+        # support -1 to be last element of the list here
+        if i < -1 or len(self) == 0:
+            IndexError("list index out of range")
+        elif i == -1:
+            i = len(self) - 1
+        return i
+
+    @property
+    def allocated(self):
+        return self.list_allocated()
+
+    @property
+    def is_mutable(self):
+        return self.list_is_mutable()
+
+    def set_mutable(self):
+        return self.list_set_is_mutable(1)
+
+    def set_immutable(self):
+        return self.list_set_is_mutable(0)
+
+    def append(self, item):
+        self.list_append(item)
+
+    def pop(self, i=-1):
+        return self.list_pop(i)
+
+    # The methods below are higher-level wrappers for the C-API wrappers
+
+    def list_new(self, item_size, allocated):
+        lp = ctypes.c_void_p()
+        status = self.tc.numba_list_new(
+            ctypes.byref(lp), item_size, allocated,
+        )
+        self.tc.assertEqual(status, LIST_OK)
+        return lp
+
+    def list_length(self):
+        return self.tc.numba_list_length(self.lp)
+
+    def list_allocated(self):
+        return self.tc.numba_list_allocated(self.lp)
+
+    def list_is_mutable(self):
+        return self.tc.numba_list_is_mutable(self.lp)
+
+    def list_set_is_mutable(self, is_mutable):
+        return self.tc.numba_list_set_is_mutable(self.lp, is_mutable)
+
+    def list_setitem(self, i, item):
+        status = self.tc.numba_list_setitem(self.lp, i, item)
+        if status == LIST_ERR_INDEX:
+            raise IndexError("list index out of range")
+        elif status == LIST_ERR_IMMUTABLE:
+            raise ValueError("list is immutable")
+        else:
+            self.tc.assertEqual(status, LIST_OK)
+
+    def list_getitem(self, i):
+        i = self.handle_index(i)
+        item_out_buffer = ctypes.create_string_buffer(self.item_size)
+        status = self.tc.numba_list_getitem(self.lp, i, item_out_buffer)
+        if status == LIST_ERR_INDEX:
+            raise IndexError("list index out of range")
+        else:
+            self.tc.assertEqual(status, LIST_OK)
+            return item_out_buffer.raw
+
+    def list_append(self, item):
+        status = self.tc.numba_list_append(self.lp, item)
+        if status == LIST_ERR_IMMUTABLE:
+            raise ValueError("list is immutable")
+        self.tc.assertEqual(status, LIST_OK)
+
+    def list_pop(self, i):
+        # pop is getitem and delitem
+        i = self.handle_index(i)
+        item = self.list_getitem(i)
+        self.list_delitem(i)
+        return item
+
+    def list_delitem(self, i):
+        # special case slice
+        if isinstance(i, slice):
+            status = self.tc.numba_list_delete_slice(self.lp,
+                                                     i.start,
+                                                     i.stop,
+                                                     i.step)
+            if status == LIST_ERR_IMMUTABLE:
+                raise ValueError("list is immutable")
+            self.tc.assertEqual(status, LIST_OK)
+        # must be an integer, defer to delitem
+        else:
+            i = self.handle_index(i)
+            status = self.tc.numba_list_delitem(self.lp, i)
+            if status == LIST_ERR_INDEX:
+                raise IndexError("list index out of range")
+            elif status == LIST_ERR_IMMUTABLE:
+                raise ValueError("list is immutable")
+            self.tc.assertEqual(status, LIST_OK)
+
+    def list_iter(self, itptr):
+        self.tc.numba_list_iter(itptr, self.lp)
+
+    def list_iter_next(self, itptr):
+        bi = ctypes.c_void_p(0)
+        status = self.tc.numba_list_iter_next(
+            itptr, ctypes.byref(bi),
+        )
+        if status == LIST_ERR_MUTATED:
+            raise ValueError('list mutated')
+        elif status == LIST_ERR_ITER_EXHAUSTED:
+            raise StopIteration
+        else:
+            self.tc.assertGreaterEqual(status, 0)
+            item = (ctypes.c_char * self.item_size).from_address(bi.value)
+            return item.value
+
+
+class ListIter(object):
+    """An iterator for the `List`.
+    """
+    def __init__(self, parent):
+        self.parent = parent
+        itsize = self.parent.tc.numba_list_iter_sizeof()
+        self.it_state_buf = (ctypes.c_char_p * itsize)(0)
+        self.it = ctypes.cast(self.it_state_buf, ctypes.c_void_p)
+        self.parent.list_iter(self.it)
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        return self.parent.list_iter_next(self.it)
+
+    next = __next__    # needed for py2 only
+
+
+class TestListImpl(TestCase):
+    def setUp(self):
+        """Bind to the c_helper library and provide the ctypes wrapper.
+        """
+        list_t = ctypes.c_void_p
+        iter_t = ctypes.c_void_p
+
+        def wrap(name, restype, argtypes=()):
+            proto = ctypes.CFUNCTYPE(restype, *argtypes)
+            return proto(_helperlib.c_helpers[name])
+
+        # numba_test_list()
+        self.numba_test_list = wrap(
+            'test_list',
+            ctypes.c_int,
+        )
+
+        # numba_list_new(NB_List *l, Py_ssize_t item_size, Py_ssize_t allocated)
+        self.numba_list_new = wrap(
+            'list_new',
+            ctypes.c_int,
+            [ctypes.POINTER(list_t), ctypes.c_ssize_t, ctypes.c_ssize_t],
+        )
+        # numba_list_free(NB_List *l)
+        self.numba_list_free = wrap(
+            'list_free',
+            None,
+            [list_t],
+        )
+        # numba_list_length(NB_List *l)
+        self.numba_list_length = wrap(
+            'list_length',
+            ctypes.c_int,
+            [list_t],
+        )
+        # numba_list_allocated(NB_List *l)
+        self.numba_list_allocated = wrap(
+            'list_allocated',
+            ctypes.c_int,
+            [list_t],
+        )
+        # numba_list_is_mutable(NB_List *lp)
+        self.numba_list_is_mutable = wrap(
+            'list_is_mutable',
+            ctypes.c_int,
+            [list_t],
+        )
+        # numba_list_set_is_mutable(NB_List *lp, int is_mutable)
+        self.numba_list_set_is_mutable = wrap(
+            'list_set_is_mutable',
+            None,
+            [list_t, ctypes.c_int],
+        )
+        # numba_list_setitem(NB_List *l, Py_ssize_t i, const char *item)
+        self.numba_list_setitem = wrap(
+            'list_setitem',
+            ctypes.c_int,
+            [list_t, ctypes.c_ssize_t, ctypes.c_char_p],
+        )
+        # numba_list_append(NB_List *l, const char *item)
+        self.numba_list_append = wrap(
+            'list_append',
+            ctypes.c_int,
+            [list_t, ctypes.c_char_p],
+        )
+        # numba_list_getitem(NB_List *l,  Py_ssize_t i, char *out)
+        self.numba_list_getitem = wrap(
+            'list_getitem',
+            ctypes.c_int,
+            [list_t, ctypes.c_ssize_t, ctypes.c_char_p],
+        )
+        # numba_list_delitem(NB_List *l,  Py_ssize_t i)
+        self.numba_list_delitem = wrap(
+            'list_delitem',
+            ctypes.c_int,
+            [list_t, ctypes.c_ssize_t],
+        )
+        # numba_list_delete_slice(NB_List *l,
+        #                         Py_ssize_t start,
+        #                         Py_ssize_t stop,
+        #                         Py_ssize_t step)
+        self.numba_list_delete_slice = wrap(
+            'list_delete_slice',
+            ctypes.c_int,
+            [list_t, ctypes.c_ssize_t, ctypes.c_ssize_t, ctypes.c_ssize_t],
+        )
+        # numba_list_iter_sizeof()
+        self.numba_list_iter_sizeof = wrap(
+            'list_iter_sizeof',
+            ctypes.c_size_t,
+        )
+        # numba_list_iter(NB_ListIter *it, NB_List *l)
+        self.numba_list_iter = wrap(
+            'list_iter',
+            None,
+            [
+                iter_t,
+                list_t,
+            ],
+        )
+        # numba_list_iter_next(NB_ListIter *it, const char **item_ptr)
+        self.numba_list_iter_next = wrap(
+            'list_iter_next',
+            ctypes.c_int,
+            [
+                iter_t,                             # it
+                ctypes.POINTER(ctypes.c_void_p),    # item_ptr
+            ],
+        )
+
+    def test_simple_c_test(self):
+        # Runs the basic test in C.
+        ret = self.numba_test_list()
+        self.assertEqual(ret, 0)
+
+    def test_length(self):
+        l = List(self, 8, 0)
+        self.assertEqual(len(l), 0)
+
+    def test_allocation(self):
+        for i in range(16):
+            l = List(self, 8, i)
+            self.assertEqual(len(l), 0)
+            self.assertEqual(l.allocated, i)
+
+    def test_append_get_string(self):
+        l = List(self, 8, 1)
+        l.append(b"abcdefgh")
+        self.assertEqual(len(l), 1)
+        r = l[0]
+        self.assertEqual(r, b"abcdefgh")
+
+    def test_append_get_int(self):
+        l = List(self, 8, 1)
+        l.append(struct.pack("q", 1))
+        self.assertEqual(len(l), 1)
+        r = struct.unpack("q", l[0])[0]
+        self.assertEqual(r, 1)
+
+    def test_append_get_string_realloc(self):
+        l = List(self, 8, 1)
+        l.append(b"abcdefgh")
+        self.assertEqual(len(l), 1)
+        l.append(b"hijklmno")
+        self.assertEqual(len(l), 2)
+        r = l[1]
+        self.assertEqual(r, b"hijklmno")
+
+    def test_set_item_getitem_index_error(self):
+        l = List(self, 8, 0)
+        with self.assertRaises(IndexError):
+            l[0]
+        with self.assertRaises(IndexError):
+            l[0] = b"abcdefgh"
+
+    def test_iter(self):
+        l = List(self, 1, 0)
+        values = [b'a', b'b', b'c', b'd', b'e', b'f', b'g', b'h']
+        for i in values:
+            l.append(i)
+        received = []
+        for j in l:
+            received.append(j)
+        self.assertEqual(values, received)
+
+    def test_pop(self):
+        l = List(self, 1, 0)
+        values = [b'a', b'b', b'c', b'd', b'e', b'f', b'g', b'h']
+        for i in values:
+            l.append(i)
+        self.assertEqual(len(l), 8)
+
+        received = l.pop()
+        self.assertEqual(b'h', received)
+        self.assertEqual(len(l), 7)
+        received = [j for j in l]
+        self.assertEqual(received, values[:-1])
+
+        received = l.pop(0)
+        self.assertEqual(b'a', received)
+        self.assertEqual(len(l), 6)
+
+        received = l.pop(2)
+        self.assertEqual(b'd', received)
+        self.assertEqual(len(l), 5)
+
+        expected = [b'b', b'c', b'e', b'f', b'g']
+        received = [j for j in l]
+        self.assertEqual(received, expected)
+
+    def test_pop_index_error(self):
+        l = List(self, 8, 0)
+        with self.assertRaises(IndexError):
+            l.pop()
+
+    def test_pop_byte(self):
+        l = List(self, 4, 0)
+        values = [b'aaaa', b'bbbb', b'cccc', b'dddd',
+                  b'eeee', b'ffff', b'gggg', b'hhhhh']
+        for i in values:
+            l.append(i)
+        self.assertEqual(len(l), 8)
+
+        received = l.pop()
+        self.assertEqual(b'hhhh', received)
+        self.assertEqual(len(l), 7)
+        received = [j for j in l]
+        self.assertEqual(received, values[:-1])
+
+        received = l.pop(0)
+        self.assertEqual(b'aaaa', received)
+        self.assertEqual(len(l), 6)
+
+        received = l.pop(2)
+        self.assertEqual(b'dddd', received)
+        self.assertEqual(len(l), 5)
+
+        expected = [b'bbbb', b'cccc', b'eeee', b'ffff', b'gggg']
+        received = [j for j in l]
+        self.assertEqual(received, expected)
+
+    def test_delitem(self):
+        l = List(self, 1, 0)
+        values = [b'a', b'b', b'c', b'd', b'e', b'f', b'g', b'h']
+        for i in values:
+            l.append(i)
+        self.assertEqual(len(l), 8)
+
+        # delete first item
+        del l[0]
+        self.assertEqual(len(l), 7)
+        self.assertEqual(list(l), values[1:])
+        # delete last item
+        del l[-1]
+        self.assertEqual(len(l), 6)
+        self.assertEqual(list(l), values[1:-1])
+        # delete item from middle
+        del l[2]
+        self.assertEqual(len(l), 5)
+        self.assertEqual(list(l), [b'b', b'c', b'e', b'f', b'g'])
+
+    def test_delete_slice(self):
+        l = List(self, 1, 0)
+        values = [b'a', b'b', b'c', b'd', b'e', b'f', b'g', b'h']
+        for i in values:
+            l.append(i)
+        self.assertEqual(len(l), 8)
+
+        # delete every second item
+        # no slice default normalization here, be explicit about start anb stop
+        del l[0:8:2]
+        self.assertEqual(len(l), 4)
+        self.assertEqual(list(l), values[1:8:2])
+
+        # delete first item
+        del l[0:1:1]
+        self.assertEqual(len(l), 3)
+        self.assertEqual(list(l), [b'd', b'f', b'h'])
+
+        # delete last item
+        del l[2:3:1]
+        self.assertEqual(len(l), 2)
+        self.assertEqual(list(l), [b'd', b'f'])
+
+        # delete all left items
+        del l[0:2:1]
+        self.assertEqual(len(l), 0)
+        self.assertEqual(list(l), [])
+
+    def check_sizing(self, item_size, nmax):
+        # Helper to verify different item_sizes
+        l = List(self, item_size, 0)
+
+        def make_item(v):
+            tmp = "{:0{}}".format(nmax - v - 1, item_size).encode("latin-1")
+            return tmp[:item_size]
+
+        for i in range(nmax):
+            l.append(make_item(i))
+
+        self.assertEqual(len(l), nmax)
+
+        for i in range(nmax):
+            self.assertEqual(l[i], make_item(i))
+
+    def test_sizing(self):
+        # Check different sizes of the key & value.
+        for i in range(1, 16):
+            self.check_sizing(item_size=i, nmax=2**i)
+
+    def test_mutability(self):
+        # setup and populate a singleton
+        l = List(self, 8, 1)
+        one = struct.pack("q", 1)
+        l.append(one)
+        self.assertTrue(l.is_mutable)
+        self.assertEqual(len(l), 1)
+        r = struct.unpack("q", l[0])[0]
+        self.assertEqual(r, 1)
+
+        # set to immutable and test guards
+        l.set_immutable()
+        self.assertFalse(l.is_mutable)
+        # append
+        with self.assertRaises(ValueError) as raises:
+            l.append(one)
+        self.assertIn("list is immutable", str(raises.exception))
+        # setitem
+        with self.assertRaises(ValueError) as raises:
+            l[0] = one
+        self.assertIn("list is immutable", str(raises.exception))
+        # pop
+        with self.assertRaises(ValueError) as raises:
+            l.pop()
+        self.assertIn("list is immutable", str(raises.exception))
+        # delitem with index
+        with self.assertRaises(ValueError) as raises:
+            del l[0]
+        self.assertIn("list is immutable", str(raises.exception))
+        # delitem with slice
+        with self.assertRaises(ValueError) as raises:
+            del l[0:1:1]
+        self.assertIn("list is immutable", str(raises.exception))
+        l.set_mutable()
+
+        # check that nothing has changed
+        self.assertTrue(l.is_mutable)
+        self.assertEqual(len(l), 1)
+        r = struct.unpack("q", l[0])[0]
+        self.assertEqual(r, 1)

lib/python3.10/site-packages/numba/tests/test_llvm_version_check.py

@@ -0,0 +1,42 @@
+import importlib
+import sys
+
+import unittest
+
+
+class TestLlvmVersion(unittest.TestCase):
+
+    def test_llvmlite_version(self):
+        # test the system it's running on
+        import llvmlite
+        import numba
+        self.assertTrue(numba.__version__)
+
+        llvmlite_version = llvmlite.__version__
+        def cleanup():
+            llvmlite.__version__ = llvmlite_version
+        self.addCleanup(cleanup)
+
+        # explicitly test all 3 cases of version string
+        ver = numba._min_llvmlite_version
+        version_pass = '%d.%d.%d' % ver
+        git_version_pass = '%d.%d.%d-10-g92584ed' % ver
+        rc_version_pass = '%d.%d.%drc1' % (ver[0], ver[1], ver[2] + 1)
+        version_fail = '%d.%d.0' % (ver[0], ver[1] - 1)
+        git_version_fail = '%d.%d.9-10-g92584ed' % (ver[0], ver[1] - 1)
+
+        ver_pass = (version_pass, git_version_pass, rc_version_pass)
+        ver_fail = (version_fail, git_version_fail)
+        for v in ver_pass:
+            llvmlite.__version__ = v
+            importlib.reload(numba)
+            self.assertTrue(numba.__version__)
+
+        for v in ver_fail:
+            with self.assertRaises(ImportError):
+                llvmlite.__version__ = v
+                importlib.reload(numba)
+
+
+if __name__ == '__main__':
+    unittest.main()

lib/python3.10/site-packages/numba/tests/test_mandelbrot.py

@@ -0,0 +1,28 @@
+import unittest
+from numba import njit
+from numba.core import types
+
+
+def is_in_mandelbrot(c):
+    i = 0
+    z = 0.0j
+    for i in range(100):
+        z = z ** 2 + c
+        if (z.real * z.real + z.imag * z.imag) >= 4:
+            return False
+    return True
+
+
+class TestMandelbrot(unittest.TestCase):
+
+    def test_mandelbrot(self):
+        pyfunc = is_in_mandelbrot
+        cfunc = njit((types.complex64,))(pyfunc)
+
+        points = [0+0j, 1+0j, 0+1j, 1+1j, 0.1+0.1j]
+        for p in points:
+            self.assertEqual(cfunc(p), pyfunc(p))
+
+
+if __name__ == '__main__':
+    unittest.main()

lib/python3.10/site-packages/numba/tests/test_mathlib.py

@@ -0,0 +1,559 @@
+import itertools
+import math
+import sys
+import unittest
+import warnings
+
+import numpy as np
+
+from numba import njit, types
+from numba.tests.support import TestCase
+from numba.np import numpy_support
+
+
+def sin(x):
+    return math.sin(x)
+
+
+def cos(x):
+    return math.cos(x)
+
+
+def tan(x):
+    return math.tan(x)
+
+
+def sinh(x):
+    return math.sinh(x)
+
+
+def cosh(x):
+    return math.cosh(x)
+
+
+def tanh(x):
+    return math.tanh(x)
+
+
+def asin(x):
+    return math.asin(x)
+
+
+def acos(x):
+    return math.acos(x)
+
+
+def atan(x):
+    return math.atan(x)
+
+
+def atan2(y, x):
+    return math.atan2(y, x)
+
+
+def asinh(x):
+    return math.asinh(x)
+
+
+def acosh(x):
+    return math.acosh(x)
+
+
+def atanh(x):
+    return math.atanh(x)
+
+
+def sqrt(x):
+    return math.sqrt(x)
+
+
+def npy_sqrt(x):
+    return np.sqrt(x)
+
+
+def exp(x):
+    return math.exp(x)
+
+
+def expm1(x):
+    return math.expm1(x)
+
+
+def log(x):
+    return math.log(x)
+
+
+def log1p(x):
+    return math.log1p(x)
+
+
+def log10(x):
+    return math.log10(x)
+
+
+def log2(x):
+    return math.log2(x)
+
+
+def floor(x):
+    return math.floor(x)
+
+
+def ceil(x):
+    return math.ceil(x)
+
+
+def trunc(x):
+    return math.trunc(x)
+
+
+def isnan(x):
+    return math.isnan(x)
+
+
+def isinf(x):
+    return math.isinf(x)
+
+
+def isfinite(x):
+    return math.isfinite(x)
+
+
+def hypot(x, y):
+    return math.hypot(x, y)
+
+
+def nextafter(x, y):
+    return math.nextafter(x, y)
+
+
+def degrees(x):
+    return math.degrees(x)
+
+
+def radians(x):
+    return math.radians(x)
+
+
+def erf(x):
+    return math.erf(x)
+
+
+def erfc(x):
+    return math.erfc(x)
+
+
+def gamma(x):
+    return math.gamma(x)
+
+
+def lgamma(x):
+    return math.lgamma(x)
+
+
+def pow(x, y):
+    return math.pow(x, y)
+
+def gcd(x, y):
+    return math.gcd(x, y)
+
+def copysign(x, y):
+    return math.copysign(x, y)
+
+
+def frexp(x):
+    return math.frexp(x)
+
+
+def ldexp(x, e):
+    return math.ldexp(x, e)
+
+
+def get_constants():
+    return math.pi, math.e
+
+
+class TestMathLib(TestCase):
+
+    def test_constants(self):
+        cfunc = njit(get_constants)
+        self.assertPreciseEqual(cfunc(), cfunc.py_func())
+
+    def run_unary(self, pyfunc, x_types, x_values, prec='exact', **kwargs):
+        cfunc = njit(pyfunc)
+        for tx, vx in zip(x_types, x_values):
+            got = cfunc(vx)
+            expected = pyfunc(vx)
+            actual_prec = 'single' if tx is types.float32 else prec
+            msg = 'for input %r' % (vx,)
+            self.assertPreciseEqual(got, expected, prec=actual_prec, msg=msg,
+                                    **kwargs)
+
+    def run_binary(self, pyfunc, x_types, x_values, y_values, prec='exact'):
+        cfunc = njit(pyfunc)
+        for ty, x, y in zip(x_types, x_values, y_values):
+            got = cfunc(x, y)
+            expected = pyfunc(x, y)
+            actual_prec = 'single' if ty is types.float32 else prec
+            msg = 'for inputs (%r, %r)' % (x, y)
+            self.assertPreciseEqual(got, expected, prec=actual_prec, msg=msg)
+
+    def check_predicate_func(self, pyfunc):
+        x_types = [types.int16, types.int32, types.int64,
+                   types.uint16, types.uint32, types.uint64,
+                   types.float32, types.float32, types.float32,
+                   types.float64, types.float64, types.float64]
+        x_values = [0, 0, 0, 0, 0, 0,
+                    float('inf'), 0.0, float('nan'),
+                    float('inf'), 0.0, float('nan')]
+        self.run_unary(pyfunc, x_types, x_values)
+
+    def test_sin(self):
+        pyfunc = sin
+        x_types = [types.int16, types.int32, types.int64,
+                   types.uint16, types.uint32, types.uint64,
+                   types.float32, types.float64]
+        x_values = [-2, -1, -2, 2, 1, 2, .1, .2]
+        self.run_unary(pyfunc, x_types, x_values)
+
+    @unittest.skipIf(sys.platform == 'win32',
+                     "not exactly equal on win32 (issue #597)")
+    def test_cos(self):
+        pyfunc = cos
+        x_types = [types.int16, types.int32, types.int64,
+                   types.uint16, types.uint32, types.uint64,
+                   types.float32, types.float64]
+        x_values = [-2, -1, -2, 2, 1, 2, .1, .2]
+        self.run_unary(pyfunc, x_types, x_values)
+
+    def test_tan(self):
+        pyfunc = tan
+        x_types = [types.int16, types.int32, types.int64,
+                   types.uint16, types.uint32, types.uint64,
+                   types.float32, types.float64]
+        x_values = [-2, -1, -2, 2, 1, 2, .1, .2]
+        self.run_unary(pyfunc, x_types, x_values)
+
+    def test_sqrt(self):
+        pyfunc = sqrt
+        x_types = [types.int16, types.int32, types.int64,
+                   types.uint16, types.uint32, types.uint64,
+                   types.float32, types.float64]
+        x_values = [2, 1, 2, 2, 1, 2, .1, .2]
+        self.run_unary(pyfunc, x_types, x_values)
+
+    def test_npy_sqrt(self):
+        pyfunc = npy_sqrt
+        x_values = [2, 1, 2, 2, 1, 2, .1, .2]
+        # XXX poor precision for int16 inputs
+        x_types = [types.int16, types.uint16]
+        self.run_unary(pyfunc, x_types, x_values, prec='single')
+        x_types = [types.int32, types.int64,
+                   types.uint32, types.uint64,
+                   types.float32, types.float64]
+        self.run_unary(pyfunc, x_types, x_values)
+
+    def test_exp(self):
+        pyfunc = exp
+        x_types = [types.int16, types.int32, types.int64,
+                   types.uint16, types.uint32, types.uint64,
+                   types.float32, types.float64]
+        x_values = [-2, -1, -2, 2, 1, 2, .1, .2]
+        self.run_unary(pyfunc, x_types, x_values)
+
+    def test_expm1(self):
+        pyfunc = expm1
+        x_types = [types.int16, types.int32, types.int64,
+                   types.uint16, types.uint32, types.uint64,
+                   types.float32, types.float64]
+        x_values = [-2, -1, -2, 2, 1, 2, .1, .2]
+        self.run_unary(pyfunc, x_types, x_values)
+
+    def test_log(self):
+        pyfunc = log
+        x_types = [types.int16, types.int32, types.int64,
+                   types.uint16, types.uint32, types.uint64,
+                   types.float32, types.float64]
+        x_values = [1, 10, 100, 1000, 100000, 1000000, 0.1, 1.1]
+        self.run_unary(pyfunc, x_types, x_values)
+
+    def test_log1p(self):
+        pyfunc = log1p
+        x_types = [types.int16, types.int32, types.int64,
+                   types.uint16, types.uint32, types.uint64,
+                   types.float32, types.float64]
+        x_values = [1, 10, 100, 1000, 100000, 1000000, 0.1, 1.1]
+        self.run_unary(pyfunc, x_types, x_values)
+
+    def test_log10(self):
+        pyfunc = log10
+        x_types = [types.int16, types.int32, types.int64,
+                   types.uint16, types.uint32, types.uint64,
+                   types.float32, types.float64]
+        x_values = [1, 10, 100, 1000, 100000, 1000000, 0.1, 1.1]
+        self.run_unary(pyfunc, x_types, x_values)
+
+    def test_log2(self):
+        pyfunc = log2
+        x_types = [types.int16, types.int32, types.int64,
+                   types.uint16, types.uint32, types.uint64,
+                   types.float32, types.float64]
+        x_values = [1, 10, 100, 1000, 100000, 1000000, 0.1, 1.1]
+        self.run_unary(pyfunc, x_types, x_values)
+
+    def test_asin(self):
+        pyfunc = asin
+        x_types = [types.int16, types.int32, types.int64,
+                   types.uint16, types.uint32, types.uint64,
+                   types.float32, types.float64]
+        x_values = [1, 1, 1, 1, 1, 1, 1., 1.]
+        self.run_unary(pyfunc, x_types, x_values)
+
+    def test_acos(self):
+        pyfunc = acos
+        x_types = [types.int16, types.int32, types.int64,
+                   types.uint16, types.uint32, types.uint64,
+                   types.float32, types.float64]
+        x_values = [1, 1, 1, 1, 1, 1, 1., 1.]
+        self.run_unary(pyfunc, x_types, x_values)
+
+    def test_atan(self):
+        pyfunc = atan
+        x_types = [types.int16, types.int32, types.int64,
+                   types.uint16, types.uint32, types.uint64,
+                   types.float32, types.float64]
+        x_values = [-2, -1, -2, 2, 1, 2, .1, .2]
+        self.run_unary(pyfunc, x_types, x_values)
+
+    def test_atan2(self):
+        pyfunc = atan2
+        x_types = [types.int16, types.int32, types.int64,
+                   types.uint16, types.uint32, types.uint64,
+                   types.float32, types.float64]
+        x_values = [-2, -1, -2, 2, 1, 2, .1, .2]
+        y_values = [x * 2 for x in x_values]
+        self.run_binary(pyfunc, x_types, x_values, y_values)
+
+    def test_asinh(self):
+        pyfunc = asinh
+        x_types = [types.int16, types.int32, types.int64,
+                   types.uint16, types.uint32, types.uint64,
+                   types.float32, types.float64]
+        x_values = [1, 1, 1, 1, 1, 1, 1., 1.]
+        self.run_unary(pyfunc, x_types, x_values, prec='double')
+
+    def test_acosh(self):
+        pyfunc = acosh
+        x_types = [types.int16, types.int32, types.int64,
+                   types.uint16, types.uint32, types.uint64,
+                   types.float32, types.float64]
+        x_values = [1, 1, 1, 1, 1, 1, 1., 1.]
+        self.run_unary(pyfunc, x_types, x_values)
+
+    def test_atanh(self):
+        pyfunc = atanh
+        x_types = [types.int16, types.int32, types.int64,
+                   types.uint16, types.uint32, types.uint64,
+                   types.float32, types.float64]
+        x_values = [0, 0, 0, 0, 0, 0, 0.1, 0.1]
+        self.run_unary(pyfunc, x_types, x_values, prec='double')
+
+    def test_sinh(self):
+        pyfunc = sinh
+        x_types = [types.int16, types.int32, types.int64,
+                   types.uint16, types.uint32, types.uint64,
+                   types.float32, types.float64]
+        x_values = [1, 1, 1, 1, 1, 1, 1., 1.]
+        self.run_unary(pyfunc, x_types, x_values)
+
+    def test_cosh(self):
+        pyfunc = cosh
+        x_types = [types.int16, types.int32, types.int64,
+                   types.uint16, types.uint32, types.uint64,
+                   types.float32, types.float64]
+        x_values = [1, 1, 1, 1, 1, 1, 1., 1.]
+        self.run_unary(pyfunc, x_types, x_values)
+
+    def test_tanh(self):
+        pyfunc = tanh
+        x_types = [types.int16, types.int32, types.int64,
+                   types.uint16, types.uint32, types.uint64,
+                   types.float32, types.float64]
+        x_values = [0, 0, 0, 0, 0, 0, 0.1, 0.1]
+        self.run_unary(pyfunc, x_types, x_values)
+
+    def test_floor(self):
+        pyfunc = floor
+        x_types = [types.int16, types.int32, types.int64,
+                   types.uint16, types.uint32, types.uint64,
+                   types.float32, types.float64]
+        x_values = [0, 0, 0, 0, 0, 0, 0.1, 1.9]
+        self.run_unary(pyfunc, x_types, x_values)
+
+    def test_ceil(self):
+        pyfunc = ceil
+        x_types = [types.int16, types.int32, types.int64,
+                   types.uint16, types.uint32, types.uint64,
+                   types.float32, types.float64]
+        x_values = [0, 0, 0, 0, 0, 0, 0.1, 1.9]
+        self.run_unary(pyfunc, x_types, x_values)
+
+    def test_trunc(self):
+        pyfunc = trunc
+        x_types = [types.int16, types.int32, types.int64,
+                   types.uint16, types.uint32, types.uint64,
+                   types.float32, types.float64]
+        x_values = [0, 0, 0, 0, 0, 0, 0.1, 1.9]
+        self.run_unary(pyfunc, x_types, x_values)
+
+    def test_isnan(self):
+        self.check_predicate_func(isnan)
+
+    def test_isinf(self):
+        self.check_predicate_func(isinf)
+
+    def test_isfinite(self):
+        self.check_predicate_func(isfinite)
+
+    def test_hypot(self):
+        pyfunc = hypot
+        x_types = [types.int64, types.uint64,
+                   types.float32, types.float64]
+        x_values = [1, 2, 3, 4, 5, 6, .21, .34]
+        y_values = [x + 2 for x in x_values]
+        # Issue #563: precision issues with math.hypot() under Windows.
+        prec = 'single'
+        self.run_binary(pyfunc, x_types, x_values, y_values, prec)
+        # Check that values that overflow in naive implementations do not
+        # in the numba impl
+
+        def naive_hypot(x, y):
+            return math.sqrt(x * x + y * y)
+
+        cfunc = njit(pyfunc)
+        for fltty in (types.float32, types.float64):
+            dt = numpy_support.as_dtype(fltty).type
+            val = dt(np.finfo(dt).max / 30.)
+            nb_ans = cfunc(val, val)
+            self.assertPreciseEqual(nb_ans, pyfunc(val, val), prec='single')
+            self.assertTrue(np.isfinite(nb_ans))
+
+            with warnings.catch_warnings():
+                warnings.simplefilter("error", RuntimeWarning)
+                self.assertRaisesRegex(RuntimeWarning,
+                                        'overflow encountered in .*scalar',
+                                        naive_hypot, val, val)
+
+    def test_nextafter(self):
+        pyfunc = nextafter
+        x_types = [types.float32, types.float64,
+                   types.int32, types.int64,
+                   types.uint32, types.uint64]
+        x_values = [0.0, .21, .34, 1005382.042, -25.328]
+        y1_values = [x + 2 for x in x_values]
+        y2_values = [x - 2 for x in x_values]
+
+        self.run_binary(pyfunc, x_types, x_values, y1_values)
+        self.run_binary(pyfunc, x_types, x_values, y2_values)
+
+        # Test using pos/neg inf
+        self.run_binary(pyfunc, x_types, [0.0, -.5, .5], [math.inf]*3)
+        self.run_binary(pyfunc, x_types, [0.0, -.5, .5], [-math.inf]*3)
+
+        # if both args to nextafter are equal, then it is returned unchanged.
+        self.run_binary(pyfunc, x_types, x_values, x_values)
+
+    def test_degrees(self):
+        pyfunc = degrees
+        x_types = [types.int16, types.int32, types.int64,
+                   types.uint16, types.uint32, types.uint64,
+                   types.float32, types.float64]
+        x_values = [1, 1, 1, 1, 1, 1, 1., 1.]
+        self.run_unary(pyfunc, x_types, x_values)
+
+    def test_radians(self):
+        pyfunc = radians
+        x_types = [types.int16, types.int32, types.int64,
+                   types.uint16, types.uint32, types.uint64,
+                   types.float32, types.float64]
+        x_values = [1, 1, 1, 1, 1, 1, 1., 1.]
+        self.run_unary(pyfunc, x_types, x_values)
+
+    def test_erf(self):
+        pyfunc = erf
+        x_values = [1., 1., -1., -0.0, 0.0, 0.5, 5, float('inf')]
+        x_types = [types.float32, types.float64] * (len(x_values) // 2)
+        self.run_unary(pyfunc, x_types, x_values, prec='double', ulps=2)
+
+    def test_erfc(self):
+        pyfunc = erfc
+        x_values = [1., 1., -1., -0.0, 0.0, 0.5, 5, float('inf')]
+        x_types = [types.float32, types.float64] * (len(x_values) // 2)
+        self.run_unary(pyfunc, x_types, x_values, prec='double', ulps=4)
+
+    def test_gamma(self):
+        pyfunc = gamma
+        x_values = [1., -0.9, -0.5, 0.5]
+        x_types = [types.float32, types.float64] * (len(x_values) // 2)
+        self.run_unary(pyfunc, x_types, x_values, prec='double', ulps=3)
+        x_values = [-0.1, 0.1, 2.5, 10.1, 50., float('inf')]
+        x_types = [types.float64] * len(x_values)
+        self.run_unary(pyfunc, x_types, x_values, prec='double', ulps=8)
+
+    def test_lgamma(self):
+        pyfunc = lgamma
+        x_values = [1., -0.9, -0.1, 0.1, 200., 1e10, 1e30, float('inf')]
+        x_types = [types.float32, types.float64] * (len(x_values) // 2)
+        self.run_unary(pyfunc, x_types, x_values, prec='double')
+
+    def test_pow(self):
+        pyfunc = pow
+        x_types = [types.int16, types.int32, types.int64,
+                   types.uint16, types.uint32, types.uint64,
+                   types.float32, types.float64]
+        x_values = [-2, -1, -2, 2, 1, 2, .1, .2]
+        y_values = [x * 2 for x in x_values]
+        self.run_binary(pyfunc, x_types, x_values, y_values)
+
+    def test_gcd(self):
+        from itertools import product, repeat, chain
+        pyfunc = gcd
+        signed_args = product(
+            sorted(types.signed_domain), *repeat((-2, -1, 0, 1, 2, 7, 10), 2)
+        )
+        unsigned_args = product(
+            sorted(types.unsigned_domain), *repeat((0, 1, 2, 7, 9, 16), 2)
+        )
+        x_types, x_values, y_values = zip(*chain(signed_args, unsigned_args))
+        self.run_binary(pyfunc, x_types, x_values, y_values)
+
+    def test_copysign(self):
+        pyfunc = copysign
+        value_types = [types.float32, types.float64]
+        values = [-2, -1, -0.0, 0.0, 1, 2, float('-inf'), float('inf'),
+                  float('nan')]
+        x_types, x_values, y_values = list(zip(
+            *itertools.product(value_types, values, values)))
+        self.run_binary(pyfunc, x_types, x_values, y_values)
+
+    def test_frexp(self):
+        pyfunc = frexp
+        x_types = [types.float32, types.float64]
+        x_values = [-2.5, -0.0, 0.0, 3.5,
+                    float('-inf'), float('inf'), float('nan')]
+        self.run_unary(pyfunc, x_types, x_values, prec='exact')
+
+    def test_ldexp(self):
+        pyfunc = ldexp
+        cfunc = njit(pyfunc)
+        for fltty in (types.float32, types.float64):
+            for args in [(2.5, -2), (2.5, 1), (0.0, 0), (0.0, 1),
+                         (-0.0, 0), (-0.0, 1),
+                         (float('inf'), 0), (float('-inf'), 0),
+                         (float('nan'), 0)]:
+                msg = 'for input %r' % (args,)
+                self.assertPreciseEqual(cfunc(*args), pyfunc(*args))
+
+
+if __name__ == '__main__':
+    unittest.main()

lib/python3.10/site-packages/numba/tests/test_misc_coverage_support.py

@@ -0,0 +1,75 @@
+import unittest
+from unittest.mock import patch
+
+from numba.tests.support import TestCase
+
+from numba import njit
+from numba.core import ir
+from numba.misc.coverage_support import NotifyLocBase, _the_registry
+
+
+class TestMiscCoverageSupport(TestCase):
+    @TestCase.run_test_in_subprocess(envvars={"NUMBA_JIT_COVERAGE": "1"})
+    def test_custom_loc_notifier(self):
+        class MyNotify(NotifyLocBase):
+            records = []
+
+            def notify(self, loc):
+                self.records.append(("NOTIFY", loc))
+
+            def close(self):
+                self.records.append(("CLOSE", None))
+
+        # Patch to install registry for testing
+        new_the_registry = _the_registry + [MyNotify]
+        gv = "numba.misc.coverage_support._the_registry"
+        with patch(gv, new_the_registry):
+
+            @njit
+            def foo():
+                return 123
+
+            res = foo()
+
+        self.assertEqual(res, 123)
+
+        # offset by +2 because:
+        # +1 for the decorator
+        # +1 for the `def` line
+        first_offset = 2
+        offset = foo.__code__.co_firstlineno + first_offset
+        loc = ir.Loc(__file__, 1)
+        self.assertIn(("NOTIFY", loc.with_lineno(offset)), MyNotify.records)
+        self.assertIn(("CLOSE", None), MyNotify.records)
+
+        # Test dead branch pruned
+        with patch(gv, new_the_registry):
+            cond = False
+
+            @njit
+            def foo():
+                if cond:
+                    return 321
+                return 123
+
+            res = foo()
+
+        self.assertEqual(res, 123)
+
+        # `if cond` line is compiled
+        offset = foo.__code__.co_firstlineno + first_offset
+        self.assertIn(("NOTIFY", loc.with_lineno(offset)), MyNotify.records)
+
+        # `    return 321` line is not compiled
+        self.assertNotIn(
+            ("NOTIFY", loc.with_lineno(offset + 1)), MyNotify.records
+        )
+
+        # `    return 123` line is compiled
+        self.assertIn(("NOTIFY", loc.with_lineno(offset + 2)), MyNotify.records)
+
+        self.assertIn(("CLOSE", None), MyNotify.records)
+
+
+if __name__ == "__main__":
+    unittest.main()

lib/python3.10/site-packages/numba/tests/test_nested_calls.py

@@ -0,0 +1,153 @@
+"""
+Test problems in nested calls.
+Usually due to invalid type conversion between function boundaries.
+"""
+
+
+from numba import int32, int64
+from numba import jit
+from numba.core import types
+from numba.extending import overload
+from numba.tests.support import TestCase, tag
+import unittest
+
+
+@jit(nopython=True)
+def f_inner(a, b, c):
+    return a, b, c
+
+def f(x, y, z):
+    return f_inner(x, c=y, b=z)
+
+@jit(nopython=True)
+def g_inner(a, b=2, c=3):
+    return a, b, c
+
+def g(x, y, z):
+    return g_inner(x, b=y), g_inner(a=z, c=x)
+
+@jit(nopython=True)
+def star_inner(a=5, *b):
+    return a, b
+
+def star(x, y, z):
+    return star_inner(a=x), star_inner(x, y, z)
+
+def star_call(x, y, z):
+    return star_inner(x, *y), star_inner(*z)
+
+@jit(nopython=True)
+def argcast_inner(a, b):
+    if b:
+        # Here `a` is unified to int64 (from int32 originally)
+        a = int64(0)
+    return a
+
+def argcast(a, b):
+    return argcast_inner(int32(a), b)
+
+
+def generated_inner(x, y=5, z=6):
+    assert 0, "unreachable"
+
+
+@overload(generated_inner)
+def ol_generated_inner(x, y=5, z=6):
+    if isinstance(x, types.Complex):
+        def impl(x, y=5, z=6):
+            return x + y, z
+    else:
+        def impl(x, y=5, z=6):
+            return x - y, z
+    return impl
+
+
+def call_generated(a, b):
+    return generated_inner(a, z=b)
+
+
+class TestNestedCall(TestCase):
+
+    def compile_func(self, pyfunc, objmode=False):
+        def check(*args, **kwargs):
+            expected = pyfunc(*args, **kwargs)
+            result = f(*args, **kwargs)
+            self.assertPreciseEqual(result, expected)
+        flags = dict(forceobj=True) if objmode else dict(nopython=True)
+        f = jit(**flags)(pyfunc)
+        return f, check
+
+    def test_boolean_return(self):
+        @jit(nopython=True)
+        def inner(x):
+            return not x
+
+        @jit(nopython=True)
+        def outer(x):
+            if inner(x):
+                return True
+            else:
+                return False
+
+        self.assertFalse(outer(True))
+        self.assertTrue(outer(False))
+
+    def test_named_args(self, objmode=False):
+        """
+        Test a nested function call with named (keyword) arguments.
+        """
+        cfunc, check = self.compile_func(f, objmode)
+        check(1, 2, 3)
+        check(1, y=2, z=3)
+
+    def test_named_args_objmode(self):
+        self.test_named_args(objmode=True)
+
+    def test_default_args(self, objmode=False):
+        """
+        Test a nested function call using default argument values.
+        """
+        cfunc, check = self.compile_func(g, objmode)
+        check(1, 2, 3)
+        check(1, y=2, z=3)
+
+    def test_default_args_objmode(self):
+        self.test_default_args(objmode=True)
+
+    def test_star_args(self):
+        """
+        Test a nested function call to a function with *args in its signature.
+        """
+        cfunc, check = self.compile_func(star)
+        check(1, 2, 3)
+
+    def test_star_call(self, objmode=False):
+        """
+        Test a function call with a *args.
+        """
+        cfunc, check = self.compile_func(star_call, objmode)
+        check(1, (2,), (3,))
+
+    def test_star_call_objmode(self):
+        self.test_star_call(objmode=True)
+
+    def test_argcast(self):
+        """
+        Issue #1488: implicitly casting an argument variable should not
+        break nested calls.
+        """
+        cfunc, check = self.compile_func(argcast)
+        check(1, 0)
+        check(1, 1)
+
+    def test_call_generated(self):
+        """
+        Test a nested function call to a generated jit function.
+        """
+        cfunc = jit(nopython=True)(call_generated)
+        self.assertPreciseEqual(cfunc(1, 2), (-4, 2))
+        self.assertPreciseEqual(cfunc(1j, 2), (1j + 5, 2))
+
+
+if __name__ == '__main__':
+    unittest.main()

lib/python3.10/site-packages/numba/tests/test_new_type_system.py

@@ -0,0 +1,37 @@
+import numpy as np
+
+from numba import njit, config
+from numba.tests.support import TestCase
+
+
+class TestTypes(TestCase):
+
+    def setUp(self) -> None:
+        if config.USE_LEGACY_TYPE_SYSTEM:
+            self.skipTest("This test is only for the new type system")
+        return super().setUp()
+
+    def test_return_types(self):
+        @njit
+        def foo(x):
+            return x
+
+        cases = [
+            # Python types
+            1,
+            1.2,
+            (1 + 2j),
+            True,
+            # NumPy types
+            np.int32(1),
+            np.float64(1.2),
+            np.complex64(1 + 2j),
+            np.complex128(1 + 2j),
+            np.bool_(True),
+            np.datetime64('2020-01-01'),
+            np.timedelta64(1, 'D'),
+        ]
+
+        for case in cases:
+            self.assertEqual(foo(case), case)
+            self.assertEqual(type(foo(case)), type(case))

lib/python3.10/site-packages/numba/tests/test_npdatetime.py

@@ -0,0 +1,1180 @@
+"""
+Test np.datetime64 and np.timedelta64 support.
+"""
+
+# NOTE: datetime64 and timedelta64 ufuncs are tested in test_ufuncs.
+
+
+import contextlib
+import itertools
+import re
+import unittest
+import warnings
+
+import numpy as np
+
+from numba import jit, vectorize, njit
+from numba.np.numpy_support import numpy_version
+from numba.core import types, config
+from numba.core.errors import TypingError
+from numba.tests.support import TestCase, tag, skip_parfors_unsupported
+from numba.np import npdatetime_helpers, numpy_support
+
+TIMEDELTA_M = np.dtype('timedelta64[M]')
+TIMEDELTA_Y = np.dtype('timedelta64[Y]')
+
+def value_unit(val):
+    ty = numpy_support.from_dtype(val.dtype)
+    return ty.unit
+
+
+date_units = ('Y', 'M')
+time_units = ('W', 'D', 'h', 'm', 's', 'ms', 'us', 'ns', 'ps', 'fs', 'as')
+# All except generic ("")
+all_units = date_units + time_units
+
+
+def add_usecase(x, y):
+    return x + y
+
+def sub_usecase(x, y):
+    return x - y
+
+def mul_usecase(x, y):
+    return x * y
+
+def div_usecase(x, y):
+    return x / y
+
+def floordiv_usecase(x, y):
+    return x // y
+
+def eq_usecase(x, y):
+    return x == y
+
+def ne_usecase(x, y):
+    return x != y
+
+def lt_usecase(x, y):
+    return x < y
+
+def le_usecase(x, y):
+    return x <= y
+
+def gt_usecase(x, y):
+    return x > y
+
+def ge_usecase(x, y):
+    return x >= y
+
+def pos_usecase(x):
+    return +x
+
+def neg_usecase(x):
+    return -x
+
+def abs_usecase(x):
+    return abs(x)
+
+def hash_usecase(x):
+    return hash(x)
+
+def min_usecase(x, y):
+    return min(x, y)
+
+def max_usecase(x, y):
+    return max(x, y)
+
+def int_cast_usecase(x):
+    return int(x)
+
+def make_add_constant(const):
+    def add_constant(x):
+        return x + const
+    return add_constant
+
+
+class TestModuleHelpers(TestCase):
+    """
+    Test the various helpers in numba.npdatetime_helpers.
+    """
+
+    def test_can_cast_timedelta(self):
+        f = npdatetime_helpers.can_cast_timedelta_units
+        for a, b in itertools.product(date_units, time_units):
+            self.assertFalse(f(a, b), (a, b))
+            self.assertFalse(f(b, a), (a, b))
+        for unit in all_units:
+            self.assertFalse(f(unit, ''))
+            self.assertTrue(f('', unit))
+        for unit in all_units + ('',):
+            self.assertTrue(f(unit, unit))
+
+        def check_units_group(group):
+            for i, a in enumerate(group):
+                for b in group[:i]:
+                    # large into smaller is ok
+                    self.assertTrue(f(b, a))
+                    # small into larger is not
+                    self.assertFalse(f(a, b))
+
+        check_units_group(date_units)
+        check_units_group(time_units)
+
+    def test_timedelta_conversion(self):
+        f = npdatetime_helpers.get_timedelta_conversion_factor
+        for unit in all_units + ('',):
+            self.assertEqual(f(unit, unit), 1)
+        for unit in all_units:
+            self.assertEqual(f('', unit), 1)
+        for a, b in itertools.product(time_units, date_units):
+            self.assertIs(f(a, b), None)
+            self.assertIs(f(b, a), None)
+
+        def check_units_group(group):
+            for i, a in enumerate(group):
+                for b in group[:i]:
+                    self.assertGreater(f(b, a), 1, (b, a))
+                    self.assertIs(f(a, b), None)
+
+        check_units_group(date_units)
+        check_units_group(time_units)
+
+        # Check some hand-picked values
+        self.assertEqual(f('Y', 'M'), 12)
+        self.assertEqual(f('W', 'h'), 24 * 7)
+        self.assertEqual(f('W', 'm'), 24 * 7 * 60)
+        self.assertEqual(f('W', 'us'), 24 * 7 * 3600 * 1000 * 1000)
+
+    def test_datetime_timedelta_scaling(self):
+        f = npdatetime_helpers.get_datetime_timedelta_conversion
+        def check_error(dt_unit, td_unit):
+            with self.assertRaises(RuntimeError):
+                f(dt_unit, td_unit)
+        # Cannot combine a Y or M timedelta64 with a finer-grained datetime64
+        for dt_unit, td_unit in itertools.product(time_units, date_units):
+            check_error(dt_unit, td_unit)
+        # Sanity check that all other unit pairs can be converted, we'll
+        # check individual results below
+        for dt_unit, td_unit in itertools.product(time_units, time_units):
+            f(dt_unit, td_unit)
+        for dt_unit, td_unit in itertools.product(date_units, time_units):
+            f(dt_unit, td_unit)
+        for dt_unit, td_unit in itertools.product(date_units, date_units):
+            f(dt_unit, td_unit)
+        # No-op conversions
+        for unit in all_units:
+            self.assertEqual(f(unit, unit), (unit, 1, 1))
+            self.assertEqual(f(unit, ''), (unit, 1, 1))
+            self.assertEqual(f('', unit), ('', 1, 1))
+        self.assertEqual(f('', ''), ('', 1, 1))
+        # "Regular" values
+        self.assertEqual(f('Y', 'M'), ('M', 12, 1))
+        self.assertEqual(f('M', 'Y'), ('M', 1, 12))
+        self.assertEqual(f('W', 'D'), ('D', 7, 1))
+        self.assertEqual(f('D', 'W'), ('D', 1, 7))
+        self.assertEqual(f('W', 's'), ('s', 7 * 24 * 3600, 1))
+        self.assertEqual(f('s', 'W'), ('s', 1, 7 * 24 * 3600))
+        self.assertEqual(f('s', 'as'), ('as', 1000 ** 6, 1))
+        self.assertEqual(f('as', 's'), ('as', 1, 1000 ** 6))
+        # "Interesting" values
+        self.assertEqual(f('Y', 'D'), ('D', 97 + 400 * 365, 400))
+        self.assertEqual(f('Y', 'W'), ('W', 97 + 400 * 365, 400 * 7))
+        self.assertEqual(f('M', 'D'), ('D', 97 + 400 * 365, 400 * 12))
+        self.assertEqual(f('M', 'W'), ('W', 97 + 400 * 365, 400 * 12 * 7))
+        self.assertEqual(f('Y', 's'), ('s', (97 + 400 * 365) *  24 * 3600, 400))
+        self.assertEqual(f('M', 's'), ('s', (97 + 400 * 365) *  24 * 3600, 400 * 12))
+
+    def test_combine_datetime_timedelta_units(self):
+        f = npdatetime_helpers.combine_datetime_timedelta_units
+        for unit in all_units:
+            self.assertEqual(f(unit, unit), unit)
+            self.assertEqual(f('', unit), unit)
+            self.assertEqual(f(unit, ''), unit)
+        self.assertEqual(f('', ''), '')
+        for dt_unit, td_unit in itertools.product(time_units, date_units):
+            self.assertIs(f(dt_unit, td_unit), None)
+        for dt_unit, td_unit in itertools.product(date_units, time_units):
+            self.assertEqual(f(dt_unit, td_unit), td_unit)
+
+    def test_same_kind(self):
+        f = npdatetime_helpers.same_kind
+        for u in all_units:
+            self.assertTrue(f(u, u))
+        A = ('Y', 'M', 'W', 'D')
+        B = ('h', 'm', 's', 'ms', 'us', 'ns', 'ps', 'fs', 'as')
+        for a, b in itertools.product(A, A):
+            self.assertTrue(f(a, b))
+        for a, b in itertools.product(B, B):
+            self.assertTrue(f(a, b))
+        for a, b in itertools.product(A, B):
+            self.assertFalse(f(a, b))
+            self.assertFalse(f(b, a))
+
+
+TD = np.timedelta64
+DT = np.datetime64
+
+
+class TestMiscCompiling(TestCase):
+
+    def test_jit_explicit_signature(self):
+        def _check_explicit_signature(sig):
+            f = jit(sig, nopython=True)(add_usecase)
+            # Just a sanity check
+            args = DT(1, 'ms'), TD(2, 'us')
+            expected = add_usecase(*args)
+            self.assertPreciseEqual(f(*args), expected)
+
+        # Test passing the signature in object form
+        sig = types.NPDatetime('us')(types.NPDatetime('ms'), types.NPTimedelta('us'))
+        _check_explicit_signature(sig)
+        # Same with the signature in string form
+        sig = "NPDatetime('us')(NPDatetime('ms'), NPTimedelta('us'))"
+        _check_explicit_signature(sig)
+
+    def test_vectorize_explicit_signature(self):
+        def _check_explicit_signature(sig):
+            f = vectorize([sig], nopython=True)(mul_usecase)
+            # This isn't really right but we can't do better than this,
+            # since Numpy's ufuncs don't store the metadata of return types.
+            # Related to https://github.com/numpy/numpy/issues/5429
+            self.assertPreciseEqual(f(TD(2), 3), TD(6))
+
+        # Test passing the signature in object form (issue #917)
+        sig = types.NPTimedelta('s')(types.NPTimedelta('s'), types.int64)
+        _check_explicit_signature(sig)
+        # Same with the signature in string form
+        sig = "NPTimedelta('s')(NPTimedelta('s'), int64)"
+        _check_explicit_signature(sig)
+
+    def test_constant_datetime(self):
+        def check(const):
+            pyfunc = make_add_constant(const)
+            f = jit(nopython=True)(pyfunc)
+            x = TD(4, 'D')
+            expected = pyfunc(x)
+            self.assertPreciseEqual(f(x), expected)
+        check(DT('2001-01-01'))
+        check(DT('NaT', 'D'))
+
+    def test_constant_timedelta(self):
+        def check(const):
+            pyfunc = make_add_constant(const)
+            f = jit(nopython=True)(pyfunc)
+            x = TD(4, 'D')
+            expected = pyfunc(x)
+            self.assertPreciseEqual(f(x), expected)
+        check(TD(4, 'D'))
+        check(TD(-4, 'D'))
+        check(TD('NaT', 'D'))
+
+
+class TestTimedeltaArithmetic(TestCase):
+
+    jitargs = dict(forceobj=True)
+
+    def jit(self, pyfunc):
+        return jit(**self.jitargs)(pyfunc)
+
+    def test_add(self):
+        f = self.jit(add_usecase)
+        def check(a, b, expected):
+            self.assertPreciseEqual(f(a, b), expected)
+            self.assertPreciseEqual(f(b, a), expected)
+
+        check(TD(1), TD(2), TD(3))
+        check(TD(1, 's'), TD(2, 's'), TD(3, 's'))
+        # Implicit unit promotion
+        check(TD(1, 's'), TD(2, 'us'), TD(1000002, 'us'))
+        check(TD(1, 'W'), TD(2, 'D'), TD(9, 'D'))
+        # NaTs
+        check(TD('NaT'), TD(1), TD('NaT'))
+        check(TD('NaT', 's'), TD(1, 'D'), TD('NaT', 's'))
+        check(TD('NaT', 's'), TD(1, 'ms'), TD('NaT', 'ms'))
+        # Cannot add days and months
+        with self.assertRaises((TypeError, TypingError)):
+            f(TD(1, 'M'), TD(1, 'D'))
+
+    def test_sub(self):
+        f = self.jit(sub_usecase)
+        def check(a, b, expected):
+            self.assertPreciseEqual(f(a, b), expected)
+            self.assertPreciseEqual(f(b, a), -expected)
+
+        check(TD(3), TD(2), TD(1))
+        check(TD(3, 's'), TD(2, 's'), TD(1, 's'))
+        # Implicit unit promotion
+        check(TD(3, 's'), TD(2, 'us'), TD(2999998, 'us'))
+        check(TD(1, 'W'), TD(2, 'D'), TD(5, 'D'))
+        # NaTs
+        check(TD('NaT'), TD(1), TD('NaT'))
+        check(TD('NaT', 's'), TD(1, 'D'), TD('NaT', 's'))
+        check(TD('NaT', 's'), TD(1, 'ms'), TD('NaT', 'ms'))
+        # Cannot sub days to months
+        with self.assertRaises((TypeError, TypingError)):
+            f(TD(1, 'M'), TD(1, 'D'))
+
+    def test_mul(self):
+        f = self.jit(mul_usecase)
+        def check(a, b, expected):
+            self.assertPreciseEqual(f(a, b), expected)
+            self.assertPreciseEqual(f(b, a), expected)
+
+        # non-int64 int * timedelta64
+        check(TD(3), np.uint32(2), TD(6))
+        # int * timedelta64
+        check(TD(3), 2, TD(6))
+        check(TD(3, 'ps'), 2, TD(6, 'ps'))
+        check(TD('NaT', 'ps'), 2, TD('NaT', 'ps'))
+        # float * timedelta64
+        check(TD(7), 1.5, TD(10))
+        check(TD(-7), 1.5, TD(-10))
+        check(TD(7, 'ps'), -1.5, TD(-10, 'ps'))
+        check(TD(-7), -1.5, TD(10))
+        check(TD('NaT', 'ps'), -1.5, TD('NaT', 'ps'))
+        check(TD(7, 'ps'), float('nan'), TD('NaT', 'ps'))
+        # wraparound on overflow
+        check(TD(2**62, 'ps'), 16, TD(0, 'ps'))
+
+    def test_div(self):
+        div = self.jit(div_usecase)
+        floordiv = self.jit(floordiv_usecase)
+        def check(a, b, expected):
+            self.assertPreciseEqual(div(a, b), expected)
+            self.assertPreciseEqual(floordiv(a, b), expected)
+
+        # timedelta64 / non-int64 int
+        check(TD(-3, 'ps'), np.uint32(2), TD(-1, 'ps'))
+        # timedelta64 / int
+        check(TD(3), 2, TD(1))
+        check(TD(-3, 'ps'), 2, TD(-1, 'ps'))
+        check(TD('NaT', 'ps'), 2, TD('NaT', 'ps'))
+        check(TD(3, 'ps'), 0, TD('NaT', 'ps'))
+        check(TD('NaT', 'ps'), 0, TD('NaT', 'ps'))
+        # timedelta64 / float
+        check(TD(7), 0.5, TD(14))
+        check(TD(-7, 'ps'), 1.5, TD(-4, 'ps'))
+        check(TD('NaT', 'ps'), 2.5, TD('NaT', 'ps'))
+        check(TD(3, 'ps'), 0.0, TD('NaT', 'ps'))
+        check(TD('NaT', 'ps'), 0.0, TD('NaT', 'ps'))
+        check(TD(3, 'ps'), float('nan'), TD('NaT', 'ps'))
+        check(TD('NaT', 'ps'), float('nan'), TD('NaT', 'ps'))
+
+    def test_homogeneous_div(self):
+        div = self.jit(div_usecase)
+        def check(a, b, expected):
+            self.assertPreciseEqual(div(a, b), expected)
+
+        # timedelta64 / timedelta64
+        check(TD(7), TD(3), 7. / 3.)
+        check(TD(7, 'us'), TD(3, 'ms'), 7. / 3000.)
+        check(TD(7, 'ms'), TD(3, 'us'), 7000. / 3.)
+        check(TD(7), TD(0), float('+inf'))
+        check(TD(-7), TD(0), float('-inf'))
+        check(TD(0), TD(0), float('nan'))
+        # NaTs
+        check(TD('nat'), TD(3), float('nan'))
+        check(TD(3), TD('nat'), float('nan'))
+        check(TD('nat'), TD(0), float('nan'))
+        # Cannot div months with days
+        with self.assertRaises((TypeError, TypingError)):
+            div(TD(1, 'M'), TD(1, 'D'))
+
+    def test_eq_ne(self):
+        eq = self.jit(eq_usecase)
+        ne = self.jit(ne_usecase)
+        def check(a, b, expected):
+            expected_val = expected
+            not_expected_val = not expected
+
+            # all NaT comparisons are False, including NaT==NaT,
+            # conversely != is True
+            if np.isnat(a) or np.isnat(a):
+                expected_val = False
+                not_expected_val = True
+
+            self.assertPreciseEqual(eq(a, b), expected_val)
+            self.assertPreciseEqual(eq(b, a), expected_val)
+            self.assertPreciseEqual(ne(a, b), not_expected_val)
+            self.assertPreciseEqual(ne(b, a), not_expected_val)
+
+        check(TD(1), TD(2), False)
+        check(TD(1), TD(1), True)
+        check(TD(1, 's'), TD(2, 's'), False)
+        check(TD(1, 's'), TD(1, 's'), True)
+        check(TD(2000, 's'), TD(2, 's'), False)
+        check(TD(2000, 'ms'), TD(2, 's'), True)
+        check(TD(1, 'Y'), TD(12, 'M'), True)
+        # NaTs
+        check(TD('Nat'), TD('Nat'), True)
+        check(TD('Nat', 'ms'), TD('Nat', 's'), True)
+        check(TD('Nat'), TD(1), False)
+        # Incompatible units => timedeltas compare unequal
+        if numpy_version < (1, 25):
+            check(TD(1, 'Y'), TD(365, 'D'), False)
+            check(TD(1, 'Y'), TD(366, 'D'), False)
+            # ... except when both are NaT!
+            check(TD('NaT', 'W'), TD('NaT', 'D'), True)
+        else:
+            # incompatible units raise
+            # The exception is different depending on Python mode
+            with self.assertRaises((TypeError, TypingError)):
+                eq(TD(1, 'Y'), TD(365, 'D'))
+            with self.assertRaises((TypeError, TypingError)):
+                ne(TD(1, 'Y'), TD(365, 'D'))
+
+    def test_lt_ge(self):
+        lt = self.jit(lt_usecase)
+        ge = self.jit(ge_usecase)
+        def check(a, b, expected):
+            expected_val = expected
+            not_expected_val = not expected
+
+            # since np 1.16 all NaT magnitude comparisons including equality
+            # are False (as NaT == NaT is now False)
+            if np.isnat(a) or np.isnat(a):
+                expected_val = False
+                not_expected_val = False
+
+            self.assertPreciseEqual(lt(a, b), expected_val)
+            self.assertPreciseEqual(ge(a, b), not_expected_val)
+
+        check(TD(1), TD(2), True)
+        check(TD(1), TD(1), False)
+        check(TD(2), TD(1), False)
+        check(TD(1, 's'), TD(2, 's'), True)
+        check(TD(1, 's'), TD(1, 's'), False)
+        check(TD(2, 's'), TD(1, 's'), False)
+        check(TD(1, 'm'), TD(61, 's'), True)
+        check(TD(1, 'm'), TD(60, 's'), False)
+        # NaTs
+        check(TD('Nat'), TD('Nat'), False)
+        check(TD('Nat', 'ms'), TD('Nat', 's'), False)
+        check(TD('Nat'), TD(-(2**63)+1), True)
+        # Incompatible units => exception raised
+        with self.assertRaises((TypeError, TypingError)):
+            lt(TD(1, 'Y'), TD(365, 'D'))
+        with self.assertRaises((TypeError, TypingError)):
+            ge(TD(1, 'Y'), TD(365, 'D'))
+        # ... even when both are NaT
+        with self.assertRaises((TypeError, TypingError)):
+            lt(TD('NaT', 'Y'), TD('NaT', 'D'))
+        with self.assertRaises((TypeError, TypingError)):
+            ge(TD('NaT', 'Y'), TD('NaT', 'D'))
+
+    def test_le_gt(self):
+        le = self.jit(le_usecase)
+        gt = self.jit(gt_usecase)
+        def check(a, b, expected):
+            expected_val = expected
+            not_expected_val = not expected
+
+            # since np 1.16 all NaT magnitude comparisons including equality
+            # are False (as NaT == NaT is now False)
+            if np.isnat(a) or np.isnat(a):
+                expected_val = False
+                not_expected_val = False
+            self.assertPreciseEqual(le(a, b), expected_val)
+            self.assertPreciseEqual(gt(a, b), not_expected_val)
+
+        check(TD(1), TD(2), True)
+        check(TD(1), TD(1), True)
+        check(TD(2), TD(1), False)
+        check(TD(1, 's'), TD(2, 's'), True)
+        check(TD(1, 's'), TD(1, 's'), True)
+        check(TD(2, 's'), TD(1, 's'), False)
+        check(TD(1, 'm'), TD(61, 's'), True)
+        check(TD(1, 'm'), TD(60, 's'), True)
+        check(TD(1, 'm'), TD(59, 's'), False)
+        # NaTs
+        check(TD('Nat'), TD('Nat'), True)
+        check(TD('Nat', 'ms'), TD('Nat', 's'), True)
+        check(TD('Nat'), TD(-(2**63)+1), True)
+        # Incompatible units => exception raised
+        with self.assertRaises((TypeError, TypingError)):
+            le(TD(1, 'Y'), TD(365, 'D'))
+        with self.assertRaises((TypeError, TypingError)):
+            gt(TD(1, 'Y'), TD(365, 'D'))
+        # ... even when both are NaT
+        with self.assertRaises((TypeError, TypingError)):
+            le(TD('NaT', 'Y'), TD('NaT', 'D'))
+        with self.assertRaises((TypeError, TypingError)):
+            gt(TD('NaT', 'Y'), TD('NaT', 'D'))
+
+    def test_pos(self):
+        pos = self.jit(pos_usecase)
+        def check(a):
+            self.assertPreciseEqual(pos(a), +a)
+
+        check(TD(3))
+        check(TD(-4))
+        check(TD(3, 'ms'))
+        check(TD(-4, 'ms'))
+        check(TD('NaT'))
+        check(TD('NaT', 'ms'))
+
+    def test_neg(self):
+        neg = self.jit(neg_usecase)
+        def check(a):
+            self.assertPreciseEqual(neg(a), -a)
+
+        check(TD(3))
+        check(TD(-4))
+        check(TD(3, 'ms'))
+        check(TD(-4, 'ms'))
+        check(TD('NaT'))
+        check(TD('NaT', 'ms'))
+
+    def test_abs(self):
+        f = self.jit(abs_usecase)
+        def check(a):
+            self.assertPreciseEqual(f(a), abs(a))
+
+        check(TD(3))
+        check(TD(-4))
+        check(TD(3, 'ms'))
+        check(TD(-4, 'ms'))
+        check(TD('NaT'))
+        check(TD('NaT', 'ms'))
+
+    def test_hash(self):
+        f = self.jit(hash_usecase)
+        def check(a):
+            self.assertPreciseEqual(f(a), hash(a))
+
+        TD_CASES = ((3,), (-4,), (3, 'ms'), (-4, 'ms'), (27, 'D'),
+                    (2, 'D'), (2, 'W'), (2, 'Y'), (3, 'W'),
+                    (365, 'D'), (10000, 'D'), (-10000, 'D'),
+                    ('NaT',), ('NaT', 'ms'), ('NaT', 'D'), (-1,))
+        DT_CASES = (('2014',), ('2016',), ('2000',), ('2014-02',),
+                    ('2014-03',), ('2014-04',), ('2016-02',), ('2000-12-31',),
+                    ('2014-01-16',), ('2014-01-05',), ('2014-01-07',),
+                    ('2014-01-06',), ('2014-02-02',), ('2014-02-27',),
+                    ('2014-02-16',), ('2014-03-01',), ('2000-01-01T01:02:03.002Z',),
+                    ('2000-01-01T01:02:03Z',), ('NaT',))
+
+        for case, typ in zip(TD_CASES + DT_CASES,
+                             (TD,) * len(TD_CASES) + (DT,) * len(TD_CASES)):
+            check(typ(*case))
+
+    def _test_min_max(self, usecase):
+        f = self.jit(usecase)
+        def check(a, b):
+            self.assertPreciseEqual(f(a, b), usecase(a, b))
+
+        for cases in (
+            (TD(0), TD(1), TD(2), TD('NaT')),
+            (TD(0, 's'), TD(1, 's'), TD(2, 's'), TD('NaT', 's')),
+        ):
+            for a, b in itertools.product(cases, cases):
+                check(a, b)
+
+    def test_min(self):
+        self._test_min_max(min_usecase)
+
+    def test_max(self):
+        self._test_min_max(max_usecase)
+
+
+class TestTimedeltaArithmeticNoPython(TestTimedeltaArithmetic):
+
+    jitargs = dict(nopython=True)
+
+    def test_int_cast(self):
+        f = self.jit(int_cast_usecase)
+        def check(a):
+            self.assertPreciseEqual(f(a), int(a))
+
+        for (delta, unit) in ((3, 'ns'), (-4, 'ns'), (30000, 'ns'),
+                        (-40000000, 'ns'), (1, 'Y')):
+            check(TD(delta, unit).astype('timedelta64[ns]'))
+
+        for time in ('2014', '2016', '2000', '2014-02', '2014-03', '2014-04',
+                     '2016-02', '2000-12-31', '2014-01-16', '2014-01-05',
+                     '2014-01-07', '2014-01-06', '2014-02-02', '2014-02-27',
+                     '2014-02-16', '2014-03-01', '2000-01-01T01:02:03.002Z',
+                     '2000-01-01T01:02:03Z'):
+            check(DT(time).astype('datetime64[ns]'))
+
+        with self.assertRaises(TypingError, msg=('Only datetime64[ns] can be ' +
+                                                 'converted, but got ' +
+                                                 'datetime64[y]')):
+            f(DT('2014'))
+
+
+class TestDatetimeArithmetic(TestCase):
+
+    jitargs = dict(forceobj=True)
+
+    def jit(self, pyfunc):
+        return jit(**self.jitargs)(pyfunc)
+
+    @contextlib.contextmanager
+    def silence_numpy_warnings(self):
+        # Numpy can raise warnings when combining e.g. a generic timedelta64
+        # with a non-generic datetime64.
+        with warnings.catch_warnings():
+            warnings.filterwarnings('ignore',
+                                    message='Implicitly casting between incompatible kinds',
+                                    category=DeprecationWarning)
+            yield
+
+    def test_add_sub_timedelta(self):
+        """
+        Test `datetime64 + timedelta64` and `datetime64 - timedelta64`.
+        """
+        add = self.jit(add_usecase)
+        sub = self.jit(sub_usecase)
+        def check(a, b, expected):
+            with self.silence_numpy_warnings():
+                self.assertPreciseEqual(add(a, b), expected, (a, b))
+                self.assertPreciseEqual(add(b, a), expected, (a, b))
+                self.assertPreciseEqual(sub(a, -b), expected, (a, b))
+                # Did we get it right?
+                self.assertPreciseEqual(a + b, expected)
+
+        # Y + ...
+        check(DT('2014'), TD(2, 'Y'), DT('2016'))
+        check(DT('2014'), TD(2, 'M'), DT('2014-03'))
+        check(DT('2014'), TD(3, 'W'), DT('2014-01-16', 'W'))
+        check(DT('2014'), TD(4, 'D'), DT('2014-01-05'))
+        check(DT('2000'), TD(365, 'D'), DT('2000-12-31'))
+        # M + ...
+        check(DT('2014-02'), TD(2, 'Y'), DT('2016-02'))
+        check(DT('2014-02'), TD(2, 'M'), DT('2014-04'))
+        check(DT('2014-02'), TD(2, 'D'), DT('2014-02-03'))
+        # W + ...
+        check(DT('2014-01-07', 'W'), TD(2, 'W'), DT('2014-01-16', 'W'))
+        # D + ...
+        check(DT('2014-02-02'), TD(27, 'D'), DT('2014-03-01'))
+        check(DT('2012-02-02'), TD(27, 'D'), DT('2012-02-29'))
+        check(DT('2012-02-02'), TD(2, 'W'), DT('2012-02-16'))
+        # s + ...
+        check(DT('2000-01-01T01:02:03Z'), TD(2, 'h'), DT('2000-01-01T03:02:03Z'))
+        check(DT('2000-01-01T01:02:03Z'), TD(2, 'ms'), DT('2000-01-01T01:02:03.002Z'))
+        # More thorough checking with leap years and faraway years
+        for dt_str in ('600', '601', '604', '801',
+                       '1900', '1904', '2200', '2300', '2304',
+                       '2400', '6001'):
+            for dt_suffix in ('', '-01', '-12'):
+                dt = DT(dt_str + dt_suffix)
+                for td in [TD(2, 'D'), TD(2, 'W'),
+                           TD(100, 'D'), TD(10000, 'D'),
+                           TD(-100, 'D'), TD(-10000, 'D'),
+                           TD(100, 'W'), TD(10000, 'W'),
+                           TD(-100, 'W'), TD(-10000, 'W'),
+                           TD(100, 'M'), TD(10000, 'M'),
+                           TD(-100, 'M'), TD(-10000, 'M')]:
+                    self.assertEqual(add(dt, td), dt + td, (dt, td))
+                    self.assertEqual(add(td, dt), dt + td, (dt, td))
+                    self.assertEqual(sub(dt, -td), dt + td, (dt, td))
+
+        # NaTs
+        check(DT('NaT'), TD(2), DT('NaT'))
+        check(DT('NaT', 's'), TD(2, 'h'), DT('NaT', 's'))
+        check(DT('NaT', 's'), TD(2, 'ms'), DT('NaT', 'ms'))
+        check(DT('2014'), TD('NaT', 'W'), DT('NaT', 'W'))
+        check(DT('2014-01-01'), TD('NaT', 'W'), DT('NaT', 'D'))
+        check(DT('NaT', 's'), TD('NaT', 'ms'), DT('NaT', 'ms'))
+
+        # Cannot add datetime days and timedelta months or years
+        for f in (add, sub):
+            with self.assertRaises((TypeError, TypingError)):
+                f(DT(1, '2014-01-01'), TD(1, 'Y'))
+            with self.assertRaises((TypeError, TypingError)):
+                f(DT(1, '2014-01-01'), TD(1, 'M'))
+
+    def datetime_samples(self):
+        dt_years = ['600', '601', '604', '1968', '1969', '1973',
+                   '2000', '2004', '2005', '2100', '2400', '2401']
+        dt_suffixes = ['', '-01', '-12', '-02-28', '-12-31',
+                       '-01-05T12:30:56Z', '-01-05T12:30:56.008Z']
+        dts = [DT(a + b) for (a, b) in itertools.product(dt_years, dt_suffixes)]
+        dts += [DT(s, 'W') for s in dt_years]
+        return dts
+
+    def test_datetime_difference(self):
+        """
+        Test `datetime64 - datetime64`.
+        """
+        sub = self.jit(sub_usecase)
+        def check(a, b, expected=None):
+            with self.silence_numpy_warnings():
+                self.assertPreciseEqual(sub(a, b), a - b, (a, b))
+                self.assertPreciseEqual(sub(b, a), b - a, (a, b))
+                # Did we get it right?
+                self.assertPreciseEqual(a - b, expected)
+
+        check(DT('2014'), DT('2017'), TD(-3, 'Y'))
+        check(DT('2014-02'), DT('2017-01'), TD(-35, 'M'))
+        check(DT('2014-02-28'), DT('2015-03-01'), TD(-366, 'D'))
+        # NaTs
+        check(DT('NaT', 'M'), DT('2000'), TD('NaT', 'M'))
+        check(DT('NaT', 'M'), DT('2000-01-01'), TD('NaT', 'D'))
+        check(DT('NaT'), DT('NaT'), TD('NaT'))
+        # Test many more values
+        with self.silence_numpy_warnings():
+            dts = self.datetime_samples()
+            for a, b in itertools.product(dts, dts):
+                if (not npdatetime_helpers.same_kind(value_unit(a), value_unit(b))):
+                    continue
+                self.assertPreciseEqual(sub(a, b), a - b, (a, b))
+
+    def test_comparisons(self):
+        # Test all datetime comparisons all at once
+        eq = self.jit(eq_usecase)
+        ne = self.jit(ne_usecase)
+        lt = self.jit(lt_usecase)
+        le = self.jit(le_usecase)
+        gt = self.jit(gt_usecase)
+        ge = self.jit(ge_usecase)
+
+        def check_eq(a, b, expected):
+            expected_val = expected
+            not_expected_val = not expected
+
+            # since np 1.16 all NaT comparisons bar != are False, including
+            # NaT==NaT
+            if np.isnat(a) or np.isnat(b):
+                expected_val = False
+                not_expected_val = True
+                self.assertFalse(le(a, b), (a, b))
+                self.assertFalse(ge(a, b), (a, b))
+                self.assertFalse(le(b, a), (a, b))
+                self.assertFalse(ge(b, a), (a, b))
+                self.assertFalse(lt(a, b), (a, b))
+                self.assertFalse(gt(a, b), (a, b))
+                self.assertFalse(lt(b, a), (a, b))
+                self.assertFalse(gt(b, a), (a, b))
+
+            with self.silence_numpy_warnings():
+                self.assertPreciseEqual(eq(a, b), expected_val, (a, b, expected))
+                self.assertPreciseEqual(eq(b, a), expected_val, (a, b, expected))
+                self.assertPreciseEqual(ne(a, b), not_expected_val, (a, b, expected))
+                self.assertPreciseEqual(ne(b, a), not_expected_val, (a, b, expected))
+                if expected_val:
+                    # If equal, then equal-ordered comparisons are true
+                    self.assertTrue(le(a, b), (a, b))
+                    self.assertTrue(ge(a, b), (a, b))
+                    self.assertTrue(le(b, a), (a, b))
+                    self.assertTrue(ge(b, a), (a, b))
+                    # and strictly ordered comparisons are false
+                    self.assertFalse(lt(a, b), (a, b))
+                    self.assertFalse(gt(a, b), (a, b))
+                    self.assertFalse(lt(b, a), (a, b))
+                    self.assertFalse(gt(b, a), (a, b))
+                # Did we get it right?
+                self.assertPreciseEqual(a == b, expected_val)
+
+        def check_lt(a, b, expected):
+            expected_val = expected
+            not_expected_val = not expected
+
+            # since np 1.16 all NaT magnitude comparisons including equality
+            # are False (as NaT == NaT is now False)
+            if np.isnat(a) or np.isnat(b):
+                expected_val = False
+                not_expected_val = False
+
+            with self.silence_numpy_warnings():
+                lt = self.jit(lt_usecase)
+                self.assertPreciseEqual(lt(a, b), expected_val, (a, b, expected))
+                self.assertPreciseEqual(gt(b, a), expected_val, (a, b, expected))
+                self.assertPreciseEqual(ge(a, b), not_expected_val, (a, b, expected))
+                self.assertPreciseEqual(le(b, a), not_expected_val, (a, b, expected))
+                if expected_val:
+                    # If true, then values are not equal
+                    check_eq(a, b, False)
+                # Did we get it right?
+                self.assertPreciseEqual(a < b, expected_val)
+
+        check_eq(DT('2014'), DT('2017'), False)
+        check_eq(DT('2014'), DT('2014-01'), True)
+        check_eq(DT('2014'), DT('2014-01-01'), True)
+        check_eq(DT('2014'), DT('2014-01-01', 'W'), True)
+        check_eq(DT('2014-01'), DT('2014-01-01', 'W'), True)
+        # Yes, it's not transitive
+        check_eq(DT('2014-01-01'), DT('2014-01-01', 'W'), False)
+        check_eq(DT('2014-01-02'), DT('2014-01-06', 'W'), True)
+        # with times
+        check_eq(DT('2014-01-01T00:01:00Z', 's'),
+              DT('2014-01-01T00:01Z', 'm'), True)
+        check_eq(DT('2014-01-01T00:01:01Z', 's'),
+              DT('2014-01-01T00:01Z', 'm'), False)
+        # NaTs
+        check_lt(DT('NaT', 'Y'), DT('2017'), True)
+        check_eq(DT('NaT'), DT('NaT'), True)
+
+        # Check comparison between various units
+        dts = self.datetime_samples()
+        for a in dts:
+            # Take a number of smaller units
+            a_unit = a.dtype.str.split('[')[1][:-1]
+            i = all_units.index(a_unit)
+            units = all_units[i:i+6]
+            for unit in units:
+                # Force conversion
+                b = a.astype('M8[%s]' % unit)
+                if (not npdatetime_helpers.same_kind(value_unit(a),
+                                                     value_unit(b))):
+                    continue
+                check_eq(a, b, True)
+                check_lt(a, b + np.timedelta64(1, unit), True)
+                check_lt(b - np.timedelta64(1, unit), a, True)
+
+    def _test_min_max(self, usecase):
+        f = self.jit(usecase)
+        def check(a, b):
+            self.assertPreciseEqual(f(a, b), usecase(a, b))
+
+        for cases in (
+            (DT(0, 'ns'), DT(1, 'ns'), DT(2, 'ns'), DT('NaT', 'ns')),
+            (DT(0, 's'), DT(1, 's'), DT(2, 's'), DT('NaT', 's')),
+        ):
+            for a, b in itertools.product(cases, cases):
+                check(a, b)
+
+    def test_min(self):
+        self._test_min_max(min_usecase)
+
+    def test_max(self):
+        self._test_min_max(max_usecase)
+
+class TestDatetimeArithmeticNoPython(TestDatetimeArithmetic):
+
+    jitargs = dict(nopython=True)
+
+
+class TestMetadataScalingFactor(TestCase):
+    """
+    Tests than non-1 scaling factors are not supported in datetime64
+    and timedelta64 dtypes.
+    """
+
+    def test_datetime(self, jitargs={'forceobj':True}):
+        eq = jit(**jitargs)(eq_usecase)
+        self.assertTrue(eq(DT('2014', '10Y'), DT('2010')))
+
+    def test_datetime_npm(self):
+        with self.assertTypingError():
+            self.test_datetime(jitargs={'nopython':True})
+
+    def test_timedelta(self, jitargs={'forceobj':True}):
+        eq = jit(**jitargs)(eq_usecase)
+        self.assertTrue(eq(TD(2, '10Y'), TD(20, 'Y')))
+
+    def test_timedelta_npm(self):
+        with self.assertTypingError():
+            self.test_timedelta(jitargs={'nopython':True})
+
+
+class TestDatetimeDeltaOps(TestCase):
+    def test_div(self):
+        """
+        Test the division of a timedelta by numeric types
+        """
+        def arr_div(a, b):
+            return a / b
+
+        py_func = arr_div
+        cfunc = njit(arr_div)
+        test_cases = [
+            (np.ones(3, TIMEDELTA_M), np.ones(3, TIMEDELTA_M)),
+            (np.ones(3, TIMEDELTA_M), np.ones(3, TIMEDELTA_Y)),
+            (np.ones(3, TIMEDELTA_Y), np.ones(3, TIMEDELTA_M)),
+            (np.ones(3, TIMEDELTA_Y), np.ones(3, TIMEDELTA_Y)),
+            (np.ones(3, TIMEDELTA_M), 1),
+            (np.ones(3, TIMEDELTA_M), np.ones(3, np.int64)),
+            (np.ones(3, TIMEDELTA_M), np.ones(3, np.float64)),
+        ]
+        for a, b in test_cases:
+            self.assertTrue(np.array_equal(py_func(a, b), cfunc(a, b)))
+
+
+class TestDatetimeArrayOps(TestCase):
+
+    def _test_td_add_or_sub(self, operation, parallel):
+        """
+        Test the addition/subtraction of a datetime array with a timedelta type
+        """
+        def impl(a, b):
+            return operation(a, b)
+
+        arr_one = np.array([
+                        np.datetime64("2011-01-01"),
+                        np.datetime64("1971-02-02"),
+                        np.datetime64("2021-03-03"),
+                        np.datetime64("2004-12-07"),
+                    ], dtype="datetime64[ns]")
+        arr_two = np.array([
+                        np.datetime64("2011-01-01"),
+                        np.datetime64("1971-02-02"),
+                        np.datetime64("2021-03-03"),
+                        np.datetime64("2004-12-07"),
+                    ], dtype="datetime64[D]")
+        py_func = impl
+        cfunc = njit(parallel=parallel)(impl)
+        test_cases = [
+            (arr_one, np.timedelta64(1000)),
+            (arr_two, np.timedelta64(1000)),
+            (arr_one, np.timedelta64(-54557)),
+            (arr_two, np.timedelta64(-54557)),
+        ]
+        # np.add is commutative so test the reversed order
+        if operation is np.add:
+            test_cases.extend([
+                (np.timedelta64(1000), arr_one),
+                (np.timedelta64(1000), arr_two),
+                (np.timedelta64(-54557), arr_one),
+                (np.timedelta64(-54557), arr_two),
+            ])
+        for a, b in test_cases:
+            self.assertTrue(np.array_equal(py_func(a, b), cfunc(a, b)))
+
+    def test_add_td(self):
+        self._test_td_add_or_sub(np.add, False)
+
+    @skip_parfors_unsupported
+    def test_add_td_parallel(self):
+        self._test_td_add_or_sub(np.add, True)
+
+    def test_sub_td(self):
+        self._test_td_add_or_sub(np.subtract, False)
+
+    @skip_parfors_unsupported
+    def test_sub_td_parallel(self):
+        self._test_td_add_or_sub(np.subtract, True)
+
+    def _test_add_sub_td_no_match(self, operation):
+        """
+        Tests that attempting to add/sub a datetime64 and timedelta64
+        with types that cannot be cast raises a reasonable exception.
+        """
+        @njit
+        def impl(a, b):
+            return operation(a, b)
+
+        fname = operation.__name__
+        expected = re.escape((f"ufunc '{fname}' is not supported between "
+                              "datetime64[ns] and timedelta64[M]"))
+        with self.assertRaisesRegex((TypingError, TypeError), expected):
+            impl(
+                np.array([np.datetime64("2011-01-01"),],
+                         dtype="datetime64[ns]"),
+                np.timedelta64(1000,'M')
+            )
+
+    def test_add_td_no_match(self):
+        self._test_add_sub_td_no_match(np.add)
+
+    def test_sub_td_no_match(self):
+        self._test_add_sub_td_no_match(np.subtract)
+
+    def _get_testcases(self):
+        test_cases = [
+            np.array([
+                DT(0, "ns"),
+                DT(1, "ns"),
+                DT(2, "ns"),
+                DT(3, "ns"),
+            ]),
+            np.array([
+                DT("2011-01-01", "ns"),
+                DT("1971-02-02", "ns"),
+                DT("1900-01-01", "ns"),
+                DT("2021-03-03", "ns"),
+                DT("2004-12-07", "ns"),
+            ]),
+            np.array([
+                DT("2011-01-01", "D"),
+                DT("1971-02-02", "D"),
+                DT("1900-01-01", "D"),
+                DT("2021-03-03", "D"),
+                DT("2004-12-07", "D"),
+            ]),
+            np.array([
+                DT("2011-01-01", "ns"),
+                DT("1971-02-02", "ns"),
+                DT("1900-01-01", "ns"),
+                DT("2021-03-03", "ns"),
+                DT("2004-12-07", "ns"),
+                DT("NaT", "ns"),
+            ]),
+            np.array([
+                DT("NaT", "ns"),
+                DT("2011-01-01", "ns"),
+                DT("1971-02-02", "ns"),
+                DT("1900-01-01", "ns"),
+                DT("2021-03-03", "ns"),
+                DT("2004-12-07", "ns"),
+            ]),
+            np.array([
+                DT("1971-02-02", "ns"),
+                DT("NaT", "ns"),
+            ]),
+            np.array([
+                DT("NaT", "ns"),
+                DT("NaT", "ns"),
+                DT("NaT", "ns"),
+            ]),
+            np.array([
+                TD(1, "ns"),
+                TD(2, "ns"),
+                TD(3, "ns"),
+                TD(4, "ns"),
+            ]),
+            np.array([
+                TD(1, "D"),
+                TD(2, "D"),
+                TD(3, "D"),
+                TD(4, "D"),
+            ]),
+            np.array([
+                TD("NaT", "ns"),
+                TD(1, "ns"),
+                TD(2, "ns"),
+                TD(3, "ns"),
+                TD(4, "ns"),
+            ]),
+            np.array([
+                TD(1, "ns"),
+                TD(2, "ns"),
+                TD(3, "ns"),
+                TD(4, "ns"),
+                TD("NaT", "ns"),
+            ]),
+            np.array([
+                TD("NaT", "ns"),
+            ]),
+            np.array([
+                TD("NaT", "ns"),
+                TD("NaT", "ns"),
+                TD("NaT", "ns"),
+            ]),
+        ]
+        return test_cases
+
+    def _test_min_max(self, operation, parallel, method):
+        if method:
+            if operation is np.min:
+                def impl(arr):
+                    return arr.min()
+            else:
+                def impl(arr):
+                    return arr.max()
+        else:
+            def impl(arr):
+                return operation(arr)
+
+        py_func = impl
+        cfunc = njit(parallel=parallel)(impl)
+
+        test_cases = self._get_testcases()
+        for arr in test_cases:
+            py_res = py_func(arr)
+            c_res = cfunc(arr)
+            if np.isnat(py_res) or np.isnat(c_res):
+                self.assertTrue(np.isnat(py_res))
+                self.assertTrue(np.isnat(c_res))
+            else:
+                self.assertEqual(py_res, c_res)
+
+    def test_min_func(self):
+        self._test_min_max(min, False, False)
+
+    def test_np_min_func(self):
+        self._test_min_max(np.min, False, False)
+
+    def test_min_method(self):
+        self._test_min_max(np.min, False, True)
+
+    def test_max_func(self):
+        self._test_min_max(max, False, False)
+
+    def test_np_max_func(self):
+        self._test_min_max(np.max, False, False)
+
+    def test_max_method(self):
+        self._test_min_max(np.max, False, True)
+
+    @skip_parfors_unsupported
+    def test_min_func_parallel(self):
+        self._test_min_max(np.min, True, False)
+
+    @skip_parfors_unsupported
+    def test_min_method_parallel(self):
+        self._test_min_max(np.min, True, True)
+
+    @skip_parfors_unsupported
+    def test_max_func_parallel(self):
+        self._test_min_max(np.max, True, False)
+
+    @skip_parfors_unsupported
+    def test_max_method_parallel(self):
+        self._test_min_max(np.max, True, True)
+
+    def test_searchsorted_datetime(self):
+        from .test_np_functions import (
+            searchsorted, searchsorted_left, searchsorted_right,
+        )
+        pyfunc_list = [searchsorted, searchsorted_left, searchsorted_right]
+        cfunc_list = [jit(fn) for fn in pyfunc_list]
+
+        def check(pyfunc, cfunc, a, v):
+            expected = pyfunc(a, v)
+            got = cfunc(a, v)
+            self.assertPreciseEqual(expected, got)
+
+        cases = self._get_testcases()
+        for pyfunc, cfunc in zip(pyfunc_list, cfunc_list):
+            for arr in cases:
+                arr = np.sort(arr)
+                for n in range(1, min(3, arr.size) + 1):
+                    idx = np.random.randint(0, arr.size, n)
+                    vs = arr[idx]
+                    if n == 1:
+                        [v] = vs
+                        check(pyfunc, cfunc, arr, v)
+                    check(pyfunc, cfunc, arr, vs)
+
+
+
+class TestDatetimeTypeOps(TestCase):
+    def test_isinstance_datetime(self):
+        @njit
+        def is_complex(a):
+            return isinstance(a, complex)
+        @njit
+        def is_datetime(a):
+            return isinstance(a, np.datetime64)
+        @njit
+        def is_timedelta(a):
+            return isinstance(a, np.timedelta64)
+
+        dt_a = np.datetime64(1, 'ns')
+        dt_b = np.datetime64(2, 'ns')
+        td_c = dt_b - dt_a
+
+        def check(jit_func, x):
+            with self.subTest(f'{jit_func.__name__}({type(x).__name__})'):
+                got = jit_func(x)
+                expect = jit_func.py_func(x)
+                self.assertEqual(got, expect)
+
+        fns = [
+            is_complex,
+            is_datetime,
+            is_timedelta,
+        ]
+        args = [
+            dt_a,
+            dt_b,
+            td_c,
+        ]
+        for fn, arg in itertools.product(fns, args):
+            check(fn, arg)
+
+
+if __name__ == '__main__':
+    unittest.main()

lib/python3.10/site-packages/numba/tests/test_nrt.py

@@ -0,0 +1,857 @@
+import math
+import os
+import platform
+import sys
+import re
+
+import numpy as np
+
+from numba import njit
+from numba.core import types
+from numba.core.runtime import (
+    rtsys,
+    nrtopt,
+    _nrt_python,
+    nrt,
+)
+from numba.core.extending import intrinsic, include_path
+from numba.core.typing import signature
+from numba.core.imputils import impl_ret_untracked
+from llvmlite import ir
+import llvmlite.binding as llvm
+from numba.core.unsafe.nrt import NRT_get_api
+
+from numba.tests.support import (EnableNRTStatsMixin, TestCase, temp_directory,
+                                 import_dynamic, skip_if_32bit,
+                                 skip_unless_cffi, run_in_subprocess)
+from numba.core.registry import cpu_target
+import unittest
+
+
+linux_only = unittest.skipIf(not sys.platform.startswith('linux'),
+                             'linux only test')
+x86_only = unittest.skipIf(platform.machine() not in ('i386', 'x86_64'),
+                           'x86 only test')
+
+
+class Dummy(object):
+    alive = 0
+
+    def __init__(self):
+        type(self).alive += 1
+
+    def __del__(self):
+        type(self).alive -= 1
+
+
+class TestNrtMemInfoNotInitialized(unittest.TestCase):
+    """
+    Unit test for checking the use of the NRT fails if the
+    initialization sequence has not been run.
+    """
+    _numba_parallel_test_ = False
+
+    def test_init_fail(self):
+        methods = {'library': (),
+                   'meminfo_new': ((), ()),
+                   'meminfo_alloc': ((),),
+                   }
+
+        for meth, args in methods.items():
+            try:
+                with self.assertRaises(RuntimeError) as raises:
+                    rtsys._init = False
+                    fn = getattr(rtsys, meth)
+                    fn(*args)
+
+                msg = "Runtime must be initialized before use."
+                self.assertIn(msg, str(raises.exception))
+            finally:
+                rtsys._init = True
+
+
+class TestNrtMemInfo(unittest.TestCase):
+    """
+    Unit test for core MemInfo functionality
+    """
+
+    def setUp(self):
+        # Reset the Dummy class
+        Dummy.alive = 0
+        # initialize the NRT (in case the tests are run in isolation)
+        rtsys.initialize(cpu_target.target_context)
+        super(TestNrtMemInfo, self).setUp()
+
+    def test_meminfo_refct_1(self):
+        d = Dummy()
+        self.assertEqual(Dummy.alive, 1)
+        addr = 0xdeadcafe  # some made up location
+
+        mi = rtsys.meminfo_new(addr, d)
+        self.assertEqual(mi.refcount, 1)
+        del d
+        self.assertEqual(Dummy.alive, 1)
+        mi.acquire()
+        self.assertEqual(mi.refcount, 2)
+        self.assertEqual(Dummy.alive, 1)
+        mi.release()
+        self.assertEqual(mi.refcount, 1)
+        del mi
+        self.assertEqual(Dummy.alive, 0)
+
+    def test_meminfo_refct_2(self):
+        d = Dummy()
+        self.assertEqual(Dummy.alive, 1)
+        addr = 0xdeadcafe  # some made up location
+
+        mi = rtsys.meminfo_new(addr, d)
+        self.assertEqual(mi.refcount, 1)
+        del d
+        self.assertEqual(Dummy.alive, 1)
+        for ct in range(100):
+            mi.acquire()
+        self.assertEqual(mi.refcount, 1 + 100)
+        self.assertEqual(Dummy.alive, 1)
+        for _ in range(100):
+            mi.release()
+        self.assertEqual(mi.refcount, 1)
+        del mi
+        self.assertEqual(Dummy.alive, 0)
+
+    def test_fake_memoryview(self):
+        d = Dummy()
+        self.assertEqual(Dummy.alive, 1)
+        addr = 0xdeadcafe  # some made up location
+
+        mi = rtsys.meminfo_new(addr, d)
+        self.assertEqual(mi.refcount, 1)
+        mview = memoryview(mi)
+        self.assertEqual(mi.refcount, 1)
+        self.assertEqual(addr, mi.data)
+        self.assertFalse(mview.readonly)
+        self.assertIs(mi, mview.obj)
+        self.assertTrue(mview.c_contiguous)
+        self.assertEqual(mview.itemsize, 1)
+        self.assertEqual(mview.ndim, 1)
+        del d
+        del mi
+
+        self.assertEqual(Dummy.alive, 1)
+        del mview
+        self.assertEqual(Dummy.alive, 0)
+
+    def test_memoryview(self):
+        from ctypes import c_uint32, c_void_p, POINTER, cast
+
+        dtype = np.dtype(np.uint32)
+        bytesize = dtype.itemsize * 10
+        mi = rtsys.meminfo_alloc(bytesize, safe=True)
+        addr = mi.data
+        c_arr = cast(c_void_p(mi.data), POINTER(c_uint32 * 10))
+        # Check 0xCB-filling
+        for i in range(10):
+            self.assertEqual(c_arr.contents[i], 0xcbcbcbcb)
+
+        # Init array with ctypes
+        for i in range(10):
+            c_arr.contents[i] = i + 1
+        mview = memoryview(mi)
+        self.assertEqual(mview.nbytes, bytesize)
+        self.assertFalse(mview.readonly)
+        self.assertIs(mi, mview.obj)
+        self.assertTrue(mview.c_contiguous)
+        self.assertEqual(mview.itemsize, 1)
+        self.assertEqual(mview.ndim, 1)
+        del mi
+        arr = np.ndarray(dtype=dtype, shape=mview.nbytes // dtype.itemsize,
+                         buffer=mview)
+        del mview
+        # Modify array with NumPy
+        np.testing.assert_equal(np.arange(arr.size) + 1, arr)
+
+        arr += 1
+
+        # Check value reflected in ctypes
+        for i in range(10):
+            self.assertEqual(c_arr.contents[i], i + 2)
+
+        self.assertEqual(arr.ctypes.data, addr)
+        del arr
+        # At this point the memory is zero filled
+        # We can't check this deterministically because the memory could be
+        # consumed by another thread.
+
+    def test_buffer(self):
+        from ctypes import c_uint32, c_void_p, POINTER, cast
+
+        dtype = np.dtype(np.uint32)
+        bytesize = dtype.itemsize * 10
+        mi = rtsys.meminfo_alloc(bytesize, safe=True)
+        self.assertEqual(mi.refcount, 1)
+        addr = mi.data
+        c_arr = cast(c_void_p(addr), POINTER(c_uint32 * 10))
+        # Check 0xCB-filling
+        for i in range(10):
+            self.assertEqual(c_arr.contents[i], 0xcbcbcbcb)
+
+        # Init array with ctypes
+        for i in range(10):
+            c_arr.contents[i] = i + 1
+
+        arr = np.ndarray(dtype=dtype, shape=bytesize // dtype.itemsize,
+                         buffer=mi)
+        self.assertEqual(mi.refcount, 1)
+        del mi
+        # Modify array with NumPy
+        np.testing.assert_equal(np.arange(arr.size) + 1, arr)
+
+        arr += 1
+
+        # Check value reflected in ctypes
+        for i in range(10):
+            self.assertEqual(c_arr.contents[i], i + 2)
+
+        self.assertEqual(arr.ctypes.data, addr)
+        del arr
+        # At this point the memory is zero filled
+        # We can't check this deterministically because the memory could be
+        # consumed by another thread.
+
+    @skip_if_32bit
+    def test_allocate_invalid_size(self):
+        # Checks that attempting to allocate too big a region fails gracefully.
+        size = types.size_t.maxval // 8 // 2
+        for pred in (True, False):
+            with self.assertRaises(MemoryError) as raises:
+                rtsys.meminfo_alloc(size, safe=pred)
+            self.assertIn(f"Requested allocation of {size} bytes failed.",
+                          str(raises.exception))
+
+    def test_allocate_negative_size(self):
+        # Checks that attempting to allocate negative number of bytes fails
+        # gracefully.
+        size = -10
+        for pred in (True, False):
+            with self.assertRaises(ValueError) as raises:
+                rtsys.meminfo_alloc(size, safe=pred)
+            msg = f"Cannot allocate a negative number of bytes: {size}."
+            self.assertIn(msg, str(raises.exception))
+
+
+class TestTracemalloc(unittest.TestCase):
+    """
+    Test NRT-allocated memory can be tracked by tracemalloc.
+    """
+
+    def measure_memory_diff(self, func):
+        try:
+            import tracemalloc
+        except ImportError:
+            self.skipTest("tracemalloc not available")
+        tracemalloc.start()
+        try:
+            before = tracemalloc.take_snapshot()
+            # Keep the result and only delete it after taking a snapshot
+            res = func()
+            after = tracemalloc.take_snapshot()
+            del res
+            return after.compare_to(before, 'lineno')
+        finally:
+            tracemalloc.stop()
+
+    def test_snapshot(self):
+        N = 1000000
+        dtype = np.int8
+
+        @njit
+        def alloc_nrt_memory():
+            """
+            Allocate and return a large array.
+            """
+            return np.empty(N, dtype)
+
+        def keep_memory():
+            return alloc_nrt_memory()
+
+        def release_memory():
+            alloc_nrt_memory()
+
+        alloc_lineno = keep_memory.__code__.co_firstlineno + 1
+
+        # Warmup JIT
+        alloc_nrt_memory()
+
+        # The large NRT-allocated array should appear topmost in the diff
+        diff = self.measure_memory_diff(keep_memory)
+        stat = diff[0]
+        # There is a slight overhead, so the allocated size won't exactly be N
+        self.assertGreaterEqual(stat.size, N)
+        self.assertLess(stat.size, N * 1.015,
+                        msg=("Unexpected allocation overhead encountered. "
+                             "May be due to difference in CPython "
+                             "builds or running under coverage"))
+        frame = stat.traceback[0]
+        self.assertEqual(os.path.basename(frame.filename), "test_nrt.py")
+        self.assertEqual(frame.lineno, alloc_lineno)
+
+        # If NRT memory is released before taking a snapshot, it shouldn't
+        # appear.
+        diff = self.measure_memory_diff(release_memory)
+        stat = diff[0]
+        # Something else appears, but nothing the magnitude of N
+        self.assertLess(stat.size, N * 0.01)
+
+
+class TestNRTIssue(TestCase):
+    def test_issue_with_refct_op_pruning(self):
+        """
+        GitHub Issue #1244 https://github.com/numba/numba/issues/1244
+        """
+        @njit
+        def calculate_2D_vector_mag(vector):
+            x, y = vector
+
+            return math.sqrt(x ** 2 + y ** 2)
+
+        @njit
+        def normalize_2D_vector(vector):
+            normalized_vector = np.empty(2, dtype=np.float64)
+
+            mag = calculate_2D_vector_mag(vector)
+            x, y = vector
+
+            normalized_vector[0] = x / mag
+            normalized_vector[1] = y / mag
+
+            return normalized_vector
+
+        @njit
+        def normalize_vectors(num_vectors, vectors):
+            normalized_vectors = np.empty((num_vectors, 2), dtype=np.float64)
+
+            for i in range(num_vectors):
+                vector = vectors[i]
+
+                normalized_vector = normalize_2D_vector(vector)
+
+                normalized_vectors[i, 0] = normalized_vector[0]
+                normalized_vectors[i, 1] = normalized_vector[1]
+
+            return normalized_vectors
+
+        num_vectors = 10
+        test_vectors = np.random.random((num_vectors, 2))
+        got = normalize_vectors(num_vectors, test_vectors)
+        expected = normalize_vectors.py_func(num_vectors, test_vectors)
+
+        np.testing.assert_almost_equal(expected, got)
+
+    def test_incref_after_cast(self):
+        # Issue #1427: when casting a value before returning it, the
+        # cast result should be incref'ed, not the original value.
+        def f():
+            return 0.0, np.zeros(1, dtype=np.int32)
+
+        # Note the return type isn't the same as the tuple type above:
+        # the first element is a complex rather than a float.
+        cfunc = njit((types.Tuple((types.complex128,
+                                   types.Array(types.int32, 1, 'C') )))())(f)
+        z, arr = cfunc()
+        self.assertPreciseEqual(z, 0j)
+        self.assertPreciseEqual(arr, np.zeros(1, dtype=np.int32))
+
+    def test_refct_pruning_issue_1511(self):
+        @njit
+        def f():
+            a = np.ones(10, dtype=np.float64)
+            b = np.ones(10, dtype=np.float64)
+            return a, b[:]
+
+        a, b = f()
+        np.testing.assert_equal(a, b)
+        np.testing.assert_equal(a, np.ones(10, dtype=np.float64))
+
+    def test_refct_pruning_issue_1526(self):
+        @njit
+        def udt(image, x, y):
+            next_loc = np.where(image == 1)
+
+            if len(next_loc[0]) == 0:
+                y_offset = 1
+                x_offset = 1
+            else:
+                y_offset = next_loc[0][0]
+                x_offset = next_loc[1][0]
+
+            next_loc_x = (x - 1) + x_offset
+            next_loc_y = (y - 1) + y_offset
+
+            return next_loc_x, next_loc_y
+
+        a = np.array([[1, 0, 1, 0, 1, 0, 0, 1, 0, 0]])
+        expect = udt.py_func(a, 1, 6)
+        got = udt(a, 1, 6)
+
+        self.assertEqual(expect, got)
+
+    @TestCase.run_test_in_subprocess
+    def test_no_nrt_on_njit_decoration(self):
+        # Checks that the NRT is not initialized/compiled as a result of
+        # decorating a function with `@njit`.
+        from numba import njit
+
+        # check the NRT is not initialized.
+        self.assertFalse(rtsys._init)
+
+        # decorate
+        @njit
+        def foo():
+            return 123
+
+        # check the NRT is still not initialized
+        self.assertFalse(rtsys._init)
+
+        # execute
+        self.assertEqual(foo(), foo.py_func())
+
+        # check the NRT is still now initialized as execution has definitely
+        # occurred.
+        self.assertTrue(rtsys._init)
+
+
+class TestRefCtPruning(unittest.TestCase):
+
+    sample_llvm_ir = '''
+define i32 @"MyFunction"(i8** noalias nocapture %retptr, { i8*, i32 }** noalias nocapture %excinfo, i8* noalias nocapture readnone %env, double %arg.vt.0, double %arg.vt.1, double %arg.vt.2, double %arg.vt.3, double %arg.bounds.0, double %arg.bounds.1, double %arg.bounds.2, double %arg.bounds.3, i8* %arg.xs.0, i8* nocapture readnone %arg.xs.1, i64 %arg.xs.2, i64 %arg.xs.3, double* nocapture readonly %arg.xs.4, i64 %arg.xs.5.0, i64 %arg.xs.6.0, i8* %arg.ys.0, i8* nocapture readnone %arg.ys.1, i64 %arg.ys.2, i64 %arg.ys.3, double* nocapture readonly %arg.ys.4, i64 %arg.ys.5.0, i64 %arg.ys.6.0, i8* %arg.aggs_and_cols.0.0, i8* nocapture readnone %arg.aggs_and_cols.0.1, i64 %arg.aggs_and_cols.0.2, i64 %arg.aggs_and_cols.0.3, i32* nocapture %arg.aggs_and_cols.0.4, i64 %arg.aggs_and_cols.0.5.0, i64 %arg.aggs_and_cols.0.5.1, i64 %arg.aggs_and_cols.0.6.0, i64 %arg.aggs_and_cols.0.6.1) local_unnamed_addr {
+entry:
+tail call void @NRT_incref(i8* %arg.xs.0)
+tail call void @NRT_incref(i8* %arg.ys.0)
+tail call void @NRT_incref(i8* %arg.aggs_and_cols.0.0)
+%.251 = icmp sgt i64 %arg.xs.5.0, 0
+br i1 %.251, label %B42.preheader, label %B160
+
+B42.preheader:                                    ; preds = %entry
+%0 = add i64 %arg.xs.5.0, 1
+br label %B42
+
+B42:                                              ; preds = %B40.backedge, %B42.preheader
+%lsr.iv3 = phi i64 [ %lsr.iv.next, %B40.backedge ], [ %0, %B42.preheader ]
+%lsr.iv1 = phi double* [ %scevgep2, %B40.backedge ], [ %arg.xs.4, %B42.preheader ]
+%lsr.iv = phi double* [ %scevgep, %B40.backedge ], [ %arg.ys.4, %B42.preheader ]
+%.381 = load double, double* %lsr.iv1, align 8
+%.420 = load double, double* %lsr.iv, align 8
+%.458 = fcmp ole double %.381, %arg.bounds.1
+%not..432 = fcmp oge double %.381, %arg.bounds.0
+%"$phi82.1.1" = and i1 %.458, %not..432
+br i1 %"$phi82.1.1", label %B84, label %B40.backedge
+
+B84:                                              ; preds = %B42
+%.513 = fcmp ole double %.420, %arg.bounds.3
+%not..487 = fcmp oge double %.420, %arg.bounds.2
+%"$phi106.1.1" = and i1 %.513, %not..487
+br i1 %"$phi106.1.1", label %B108.endif.endif.endif, label %B40.backedge
+
+B160:                                             ; preds = %B40.backedge, %entry
+tail call void @NRT_decref(i8* %arg.ys.0)
+tail call void @NRT_decref(i8* %arg.xs.0)
+tail call void @NRT_decref(i8* %arg.aggs_and_cols.0.0)
+store i8* null, i8** %retptr, align 8
+ret i32 0
+
+B108.endif.endif.endif:                           ; preds = %B84
+%.575 = fmul double %.381, %arg.vt.0
+%.583 = fadd double %.575, %arg.vt.1
+%.590 = fptosi double %.583 to i64
+%.630 = fmul double %.420, %arg.vt.2
+%.638 = fadd double %.630, %arg.vt.3
+%.645 = fptosi double %.638 to i64
+tail call void @NRT_incref(i8* %arg.aggs_and_cols.0.0)              ; GONE 1
+tail call void @NRT_decref(i8* null)                                ; GONE 2
+tail call void @NRT_incref(i8* %arg.aggs_and_cols.0.0), !noalias !0 ; GONE 3
+%.62.i.i = icmp slt i64 %.645, 0
+%.63.i.i = select i1 %.62.i.i, i64 %arg.aggs_and_cols.0.5.0, i64 0
+%.64.i.i = add i64 %.63.i.i, %.645
+%.65.i.i = icmp slt i64 %.590, 0
+%.66.i.i = select i1 %.65.i.i, i64 %arg.aggs_and_cols.0.5.1, i64 0
+%.67.i.i = add i64 %.66.i.i, %.590
+%.84.i.i = mul i64 %.64.i.i, %arg.aggs_and_cols.0.5.1
+%.87.i.i = add i64 %.67.i.i, %.84.i.i
+%.88.i.i = getelementptr i32, i32* %arg.aggs_and_cols.0.4, i64 %.87.i.i
+%.89.i.i = load i32, i32* %.88.i.i, align 4, !noalias !3
+%.99.i.i = add i32 %.89.i.i, 1
+store i32 %.99.i.i, i32* %.88.i.i, align 4, !noalias !3
+tail call void @NRT_decref(i8* %arg.aggs_and_cols.0.0), !noalias !0 ; GONE 4
+tail call void @NRT_decref(i8* %arg.aggs_and_cols.0.0)              ; GONE 5
+br label %B40.backedge
+
+B40.backedge:                                     ; preds = %B108.endif.endif.endif, %B84, %B42
+%scevgep = getelementptr double, double* %lsr.iv, i64 1
+%scevgep2 = getelementptr double, double* %lsr.iv1, i64 1
+%lsr.iv.next = add i64 %lsr.iv3, -1
+%.294 = icmp sgt i64 %lsr.iv.next, 1
+br i1 %.294, label %B42, label %B160
+}
+    ''' # noqa
+
+    def test_refct_pruning_op_recognize(self):
+        input_ir = self.sample_llvm_ir
+        input_lines = list(input_ir.splitlines())
+        before_increfs = [ln for ln in input_lines if 'NRT_incref' in ln]
+        before_decrefs = [ln for ln in input_lines if 'NRT_decref' in ln]
+
+        # prune
+        output_ir = nrtopt._remove_redundant_nrt_refct(input_ir)
+        output_lines = list(output_ir.splitlines())
+        after_increfs = [ln for ln in output_lines if 'NRT_incref' in ln]
+        after_decrefs = [ln for ln in output_lines if 'NRT_decref' in ln]
+
+        # check
+        self.assertNotEqual(before_increfs, after_increfs)
+        self.assertNotEqual(before_decrefs, after_decrefs)
+
+        pruned_increfs = set(before_increfs) - set(after_increfs)
+        pruned_decrefs = set(before_decrefs) - set(after_decrefs)
+
+        # the symm difference == or-combined
+        combined = pruned_increfs | pruned_decrefs
+        self.assertEqual(combined, pruned_increfs ^ pruned_decrefs)
+        pruned_lines = '\n'.join(combined)
+
+        # all GONE lines are pruned
+        for i in [1, 2, 3, 4, 5]:
+            gone = '; GONE {}'.format(i)
+            self.assertIn(gone, pruned_lines)
+        # no other lines
+        self.assertEqual(len(list(pruned_lines.splitlines())), len(combined))
+
+    @unittest.skip("Pass removed as it was buggy. Re-enable when fixed.")
+    def test_refct_pruning_with_branches(self):
+        '''testcase from #2350'''
+        @njit
+        def _append_non_na(x, y, agg, field):
+            if not np.isnan(field):
+                agg[y, x] += 1
+
+        @njit
+        def _append(x, y, agg, field):
+            if not np.isnan(field):
+                if np.isnan(agg[y, x]):
+                    agg[y, x] = field
+                else:
+                    agg[y, x] += field
+
+        @njit
+        def append(x, y, agg, field):
+            _append_non_na(x, y, agg, field)
+            _append(x, y, agg, field)
+
+        # Disable python wrapper to avoid detecting necessary
+        # refcount inside it
+        @njit(no_cpython_wrapper=True)
+        def extend(arr, field):
+            for i in range(arr.shape[0]):
+                for j in range(arr.shape[1]):
+                    append(j, i, arr, field)
+
+        # Compile
+        extend.compile("(f4[:,::1], f4)")
+
+        # Test there are no reference count operations
+        llvmir = str(extend.inspect_llvm(extend.signatures[0]))
+        refops = list(re.finditer(r'(NRT_incref|NRT_decref)\([^\)]+\)', llvmir))
+        self.assertEqual(len(refops), 0)
+
+    @linux_only
+    @x86_only
+    def test_inline_asm(self):
+        """The InlineAsm class from llvmlite.ir has no 'name' attr the refcount
+        pruning pass should be tolerant to this"""
+        llvm.initialize()
+        llvm.initialize_native_target()
+        llvm.initialize_native_asmprinter()
+        llvm.initialize_native_asmparser()
+
+        @intrinsic
+        def bar(tyctx, x, y):
+            def codegen(cgctx, builder, sig, args):
+                (arg_0, arg_1) = args
+                fty = ir.FunctionType(ir.IntType(32), [ir.IntType(32),
+                                                       ir.IntType(32)])
+                mul = builder.asm(fty, "mov $2, $0; imul $1, $0", "=&r,r,r",
+                                  (arg_0, arg_1), name="asm_mul",
+                                  side_effect=False)
+                return impl_ret_untracked(cgctx, builder, sig.return_type, mul)
+            return signature(types.int32, types.int32, types.int32), codegen
+
+        @njit(['int32(int32)'])
+        def foo(x):
+            x += 1
+            z = bar(x, 2)
+            return z
+
+        self.assertEqual(foo(10), 22) # expect (10 + 1) * 2 = 22
+
+
+@skip_unless_cffi
+class TestNrtExternalCFFI(EnableNRTStatsMixin, TestCase):
+    """Testing the use of externally compiled C code that use NRT
+    """
+    def setUp(self):
+        # initialize the NRT (in case the tests are run in isolation)
+        cpu_target.target_context
+        super(TestNrtExternalCFFI, self).setUp()
+
+    def compile_cffi_module(self, name, source, cdef):
+        from cffi import FFI
+
+        ffi = FFI()
+        ffi.set_source(name, source, include_dirs=[include_path()])
+        ffi.cdef(cdef)
+        tmpdir = temp_directory("cffi_test_{}".format(name))
+        ffi.compile(tmpdir=tmpdir)
+        sys.path.append(tmpdir)
+        try:
+            mod = import_dynamic(name)
+        finally:
+            sys.path.remove(tmpdir)
+
+        return ffi, mod
+
+    def get_nrt_api_table(self):
+        from cffi import FFI
+
+        ffi = FFI()
+        nrt_get_api = ffi.cast("void* (*)()", _nrt_python.c_helpers['get_api'])
+        table = nrt_get_api()
+        return table
+
+    def test_manage_memory(self):
+        name = "{}_test_manage_memory".format(self.__class__.__name__)
+        source = r"""
+#include <stdio.h>
+#include "numba/core/runtime/nrt_external.h"
+
+int status = 0;
+
+void my_dtor(void *ptr) {
+    free(ptr);
+    status = 0xdead;
+}
+
+NRT_MemInfo* test_nrt_api(NRT_api_functions *nrt) {
+    void * data = malloc(10);
+    NRT_MemInfo *mi = nrt->manage_memory(data, my_dtor);
+    nrt->acquire(mi);
+    nrt->release(mi);
+    status = 0xa110c;
+    return mi;
+}
+        """
+        cdef = """
+void* test_nrt_api(void *nrt);
+extern int status;
+        """
+
+        ffi, mod = self.compile_cffi_module(name, source, cdef)
+        # Init status is 0
+        self.assertEqual(mod.lib.status, 0)
+        table = self.get_nrt_api_table()
+        out = mod.lib.test_nrt_api(table)
+        # status is now 0xa110c
+        self.assertEqual(mod.lib.status, 0xa110c)
+        mi_addr = int(ffi.cast("size_t", out))
+        mi = nrt.MemInfo(mi_addr)
+        self.assertEqual(mi.refcount, 1)
+        del mi   # force deallocation on mi
+        # status is now 0xdead
+        self.assertEqual(mod.lib.status, 0xdead)
+
+    def test_allocate(self):
+        name = "{}_test_allocate".format(self.__class__.__name__)
+        source = r"""
+#include <stdio.h>
+#include "numba/core/runtime/nrt_external.h"
+
+NRT_MemInfo* test_nrt_api(NRT_api_functions *nrt, size_t n) {
+    size_t *data = NULL;
+    NRT_MemInfo *mi = nrt->allocate(n);
+    data = nrt->get_data(mi);
+    data[0] = 0xded;
+    data[1] = 0xabc;
+    data[2] = 0xdef;
+    return mi;
+}
+        """
+        cdef = "void* test_nrt_api(void *nrt, size_t n);"
+        ffi, mod = self.compile_cffi_module(name, source, cdef)
+
+        table = self.get_nrt_api_table()
+
+        numbytes = 3 * np.dtype(np.intp).itemsize
+        out = mod.lib.test_nrt_api(table, numbytes)
+
+        mi_addr = int(ffi.cast("size_t", out))
+        mi = nrt.MemInfo(mi_addr)
+        self.assertEqual(mi.refcount, 1)
+
+        buffer = ffi.buffer(ffi.cast("char [{}]".format(numbytes), mi.data))
+        arr = np.ndarray(shape=(3,), dtype=np.intp, buffer=buffer)
+        np.testing.assert_equal(arr, [0xded, 0xabc, 0xdef])
+
+    def test_get_api(self):
+        from cffi import FFI
+
+        @njit
+        def test_nrt_api():
+            return NRT_get_api()
+
+        ffi = FFI()
+        expect = int(ffi.cast('size_t', self.get_nrt_api_table()))
+        got = test_nrt_api()
+        self.assertEqual(expect, got)
+
+
+class TestNrtStatistics(TestCase):
+
+    def setUp(self):
+        # Store the current stats state
+        self.__stats_state = _nrt_python.memsys_stats_enabled()
+
+    def tearDown(self):
+        # Set stats state back to whatever it was before the test ran
+        if self.__stats_state:
+            _nrt_python.memsys_enable_stats()
+        else:
+            _nrt_python.memsys_disable_stats()
+
+    def test_stats_env_var_explicit_on(self):
+        # Checks that explicitly turning the stats on via the env var works.
+        src = """if 1:
+        from numba import njit
+        import numpy as np
+        from numba.core.runtime import rtsys, _nrt_python
+        from numba.core.registry import cpu_target
+
+        @njit
+        def foo():
+            return np.arange(10)[0]
+
+        # initialize the NRT before use
+        rtsys.initialize(cpu_target.target_context)
+        assert _nrt_python.memsys_stats_enabled()
+        orig_stats = rtsys.get_allocation_stats()
+        foo()
+        new_stats = rtsys.get_allocation_stats()
+        total_alloc = new_stats.alloc - orig_stats.alloc
+        total_free = new_stats.free - orig_stats.free
+        total_mi_alloc = new_stats.mi_alloc - orig_stats.mi_alloc
+        total_mi_free = new_stats.mi_free - orig_stats.mi_free
+
+        expected = 1
+        assert total_alloc == expected
+        assert total_free == expected
+        assert total_mi_alloc == expected
+        assert total_mi_free == expected
+        """
+        # Check env var explicitly being set works
+        env = os.environ.copy()
+        env['NUMBA_NRT_STATS'] = "1"
+        run_in_subprocess(src, env=env)
+
+    def check_env_var_off(self, env):
+
+        src = """if 1:
+        from numba import njit
+        import numpy as np
+        from numba.core.runtime import rtsys, _nrt_python
+
+        @njit
+        def foo():
+            return np.arange(10)[0]
+
+        assert _nrt_python.memsys_stats_enabled() == False
+        try:
+            rtsys.get_allocation_stats()
+        except RuntimeError as e:
+            assert "NRT stats are disabled." in str(e)
+        """
+        run_in_subprocess(src, env=env)
+
+    def test_stats_env_var_explicit_off(self):
+        # Checks that explicitly turning the stats off via the env var works.
+        env = os.environ.copy()
+        env['NUMBA_NRT_STATS'] = "0"
+        self.check_env_var_off(env)
+
+    def test_stats_env_var_default_off(self):
+        # Checks that the env var not being set is the same as "off", i.e.
+        # default for Numba is off.
+        env = os.environ.copy()
+        env.pop('NUMBA_NRT_STATS', None)
+        self.check_env_var_off(env)
+
+    def test_stats_status_toggle(self):
+
+        @njit
+        def foo():
+            tmp = np.ones(3)
+            return np.arange(5 * tmp[0])
+
+        # Switch on stats
+        _nrt_python.memsys_enable_stats()
+        # check the stats are on
+        self.assertTrue(_nrt_python.memsys_stats_enabled())
+
+        for i in range(2):
+            # capture the stats state
+            stats_1 = rtsys.get_allocation_stats()
+            # Switch off stats
+            _nrt_python.memsys_disable_stats()
+            # check the stats are off
+            self.assertFalse(_nrt_python.memsys_stats_enabled())
+            # run something that would move the counters were they enabled
+            foo()
+            # Switch on stats
+            _nrt_python.memsys_enable_stats()
+            # check the stats are on
+            self.assertTrue(_nrt_python.memsys_stats_enabled())
+            # capture the stats state (should not have changed)
+            stats_2 = rtsys.get_allocation_stats()
+            # run something that will move the counters
+            foo()
+            # capture the stats state (should have changed)
+            stats_3 = rtsys.get_allocation_stats()
+            # check stats_1 == stats_2
+            self.assertEqual(stats_1, stats_2)
+            # check stats_2 < stats_3
+            self.assertLess(stats_2, stats_3)
+
+    def test_rtsys_stats_query_raises_exception_when_disabled(self):
+        # Checks that the standard rtsys.get_allocation_stats() query raises
+        # when stats counters are turned off.
+
+        _nrt_python.memsys_disable_stats()
+        self.assertFalse(_nrt_python.memsys_stats_enabled())
+
+        with self.assertRaises(RuntimeError) as raises:
+            rtsys.get_allocation_stats()
+
+        self.assertIn("NRT stats are disabled.", str(raises.exception))
+
+    def test_nrt_explicit_stats_query_raises_exception_when_disabled(self):
+        # Checks the various memsys_get_stats functions raise if queried when
+        # the stats counters are disabled.
+        method_variations = ('alloc', 'free', 'mi_alloc', 'mi_free')
+        for meth in method_variations:
+            stats_func = getattr(_nrt_python, f'memsys_get_stats_{meth}')
+            with self.subTest(stats_func=stats_func):
+                # Turn stats off
+                _nrt_python.memsys_disable_stats()
+                self.assertFalse(_nrt_python.memsys_stats_enabled())
+                with self.assertRaises(RuntimeError) as raises:
+                    stats_func()
+                self.assertIn("NRT stats are disabled.", str(raises.exception))
+
+
+if __name__ == '__main__':
+    unittest.main()