Add files using upload-large-folder tool

.gitattributes

@@ -86,3 +86,6 @@ lib/python3.10/site-packages/av/dictionary.cpython-310-x86_64-linux-gnu.so filte
 lib/python3.10/site-packages/av/container/core.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 lib/python3.10/site-packages/av/container/pyio.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 lib/python3.10/site-packages/av/container/input.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+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/container/output.cpython-310-x86_64-linux-gnu.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3119d0482fe49241a5554cd873c307100ac476deaa889b84f41bd286f6b1b959
+size 966769

lib/python3.10/site-packages/av/container/streams.cpython-310-x86_64-linux-gnu.so

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

lib/python3.10/site-packages/av/data/stream.cpython-310-x86_64-linux-gnu.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:236c39dfb44f94888f4273a010a82b8608396a3ebb762ed4001f95d92f89d3a6
+size 363729

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

@@ -0,0 +1,134 @@
+import cmath
+
+import numpy as np
+
+from numba import float32
+from numba.types import unicode_type, i8
+from numba.pycc import CC, exportmany, export
+from numba.tests.support import has_blas
+from numba import typed
+
+
+#
+# New API
+#
+
+cc = CC('pycc_test_simple')
+cc.use_nrt = False
+
+# Note the first signature omits the return type
+@cc.export('multf', (float32, float32))
+@cc.export('multi', 'i4(i4, i4)')
+def mult(a, b):
+    return a * b
+
+# Test imported C globals such as Py_None, PyExc_ZeroDivisionError
+@cc.export('get_none', 'none()')
+def get_none():
+    return None
+
+@cc.export('div', 'f8(f8, f8)')
+def div(x, y):
+    return x / y
+
+_two = 2
+
+# This one can't be compiled by the legacy API as it doesn't execute
+# the script in a proper module.
+@cc.export('square', 'i8(i8)')
+def square(u):
+    return u ** _two
+
+# These ones need helperlib
+cc_helperlib = CC('pycc_test_helperlib')
+cc_helperlib.use_nrt = False
+
+@cc_helperlib.export('power', 'i8(i8, i8)')
+def power(u, v):
+    return u ** v
+
+@cc_helperlib.export('sqrt', 'c16(c16)')
+def sqrt(u):
+    return cmath.sqrt(u)
+
+@cc_helperlib.export('size', 'i8(f8[:])')
+def size(arr):
+    return arr.size
+
+# Exercise linking to Numpy math functions
+@cc_helperlib.export('np_sqrt', 'f8(f8)')
+def np_sqrt(u):
+    return np.sqrt(u)
+
+@cc_helperlib.export('spacing', 'f8(f8)')
+def np_spacing(u):
+    return np.spacing(u)
+
+
+# This one clashes with libc random() unless pycc is careful with naming.
+@cc_helperlib.export('random', 'f8(i4)')
+def random_impl(seed):
+    if seed != -1:
+        np.random.seed(seed)
+    return np.random.random()
+
+# These ones need NRT
+cc_nrt = CC('pycc_test_nrt')
+
+@cc_nrt.export('zero_scalar', 'f8(i4)')
+def zero_scalar(n):
+    arr = np.zeros(n)
+    return arr[-1]
+
+if has_blas:
+    # This one also needs BLAS
+    @cc_nrt.export('vector_dot', 'f8(i4)')
+    def vector_dot(n):
+        a = np.linspace(1, n, n)
+        return np.dot(a, a)
+
+# This one needs an environment
+@cc_nrt.export('zeros', 'f8[:](i4)')
+def zeros(n):
+    return np.zeros(n)
+
+# requires list dtor, #issue3535
+@cc_nrt.export('np_argsort', 'intp[:](float64[:])')
+def np_argsort(arr):
+    return np.argsort(arr)
+
+#
+# Legacy API
+#
+
+exportmany(['multf f4(f4,f4)', 'multi i4(i4,i4)'])(mult)
+# Needs to link to helperlib to due with complex arguments
+# export('multc c16(c16,c16)')(mult)
+export('mult f8(f8, f8)')(mult)
+
+
+@cc_nrt.export('dict_usecase', 'intp[:](intp[:])')
+def dict_usecase(arr):
+    d = typed.Dict()
+    for i in range(arr.size):
+        d[i] = arr[i]
+    out = np.zeros_like(arr)
+    for k, v in d.items():
+        out[k] = k * v
+    return out
+
+# checks for issue #6386
+@cc_nrt.export('internal_str_dict', i8(unicode_type))
+def internal_str_dict(x):
+    d = typed.Dict.empty(unicode_type,i8)
+    if(x not in d):
+        d[x] = len(d)
+    return len(d)
+
+@cc_nrt.export('hash_str', i8(unicode_type))
+def internal_str_dict(x):
+    return hash(x)
+
+@cc_nrt.export('hash_literal_str_A', i8())
+def internal_str_dict():
+    return hash("A")

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

@@ -0,0 +1,6 @@
+import numba as nb
+
+
+@nb.jit(nopython=True, parallel=True)
+def foo():
+    pass

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

@@ -0,0 +1,14 @@
+from numba import typed, int64
+
+# used in TestMiscErrorHandling::test_handling_of_write_to_*_global
+_global_list = [1, 2, 3, 4]
+
+_global_dict = typed.Dict.empty(int64, int64)
+
+
+def global_reflected_write():
+    _global_list[0] = 10
+
+
+def global_dict_write():
+    _global_dict[0] = 10

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

@@ -0,0 +1,197 @@
+"""Helpers for running gdb related testing"""
+import os
+import re
+import sys
+import unittest
+from numba.core import config
+from numba.misc.gdb_hook import _confirm_gdb
+from numba.misc.numba_gdbinfo import collect_gdbinfo
+
+# check if gdb is present and working
+try:
+    _confirm_gdb(need_ptrace_attach=False)  # The driver launches as `gdb EXE`.
+    _HAVE_GDB = True
+    _gdb_info = collect_gdbinfo()
+    _GDB_HAS_PY3 = _gdb_info.py_ver.startswith('3')
+except Exception:
+    _HAVE_GDB = False
+    _GDB_HAS_PY3 = False
+
+_msg = "functioning gdb with correct ptrace permissions is required"
+needs_gdb = unittest.skipUnless(_HAVE_GDB, _msg)
+
+_msg = "gdb with python 3 support needed"
+needs_gdb_py3 = unittest.skipUnless(_GDB_HAS_PY3, _msg)
+
+
+try:
+    import pexpect
+    _HAVE_PEXPECT = True
+except ImportError:
+    _HAVE_PEXPECT = False
+
+
+_msg = "pexpect module needed for test"
+skip_unless_pexpect = unittest.skipUnless(_HAVE_PEXPECT, _msg)
+
+
+class GdbMIDriver(object):
+    """
+    Driver class for the GDB machine interface:
+    https://sourceware.org/gdb/onlinedocs/gdb/GDB_002fMI.html
+    """
+    def __init__(self, file_name, debug=False, timeout=120, init_cmds=None):
+        if not _HAVE_PEXPECT:
+            msg = ("This driver requires the pexpect module. This can be "
+                   "obtained via:\n\n$ conda install pexpect")
+            raise RuntimeError(msg)
+        if not _HAVE_GDB:
+            msg = ("This driver requires a gdb binary. This can be "
+                   "obtained via the system package manager.")
+            raise RuntimeError(msg)
+        self._gdb_binary = config.GDB_BINARY
+        self._python = sys.executable
+        self._debug = debug
+        self._file_name = file_name
+        self._timeout = timeout
+        self._init_cmds = init_cmds
+        self._drive()
+
+    def _drive(self):
+        """This function sets up the caputured gdb instance"""
+        assert os.path.isfile(self._file_name)
+        cmd = [self._gdb_binary, '--interpreter', 'mi']
+        if self._init_cmds is not None:
+            cmd += list(self._init_cmds)
+        cmd += ['--args', self._python, self._file_name]
+        self._captured = pexpect.spawn(' '.join(cmd))
+        if self._debug:
+            self._captured.logfile = sys.stdout.buffer
+
+    def supports_python(self):
+        """Returns True if the underlying gdb implementation has python support
+           False otherwise"""
+        return "python" in self.list_features()
+
+    def supports_numpy(self):
+        """Returns True if the underlying gdb implementation has NumPy support
+           (and by extension Python support) False otherwise"""
+        if not self.supports_python():
+            return False
+        # Some gdb's have python 2!
+        cmd = ('python from __future__ import print_function;'
+               'import numpy; print(numpy)')
+        self.interpreter_exec('console', cmd)
+        return "module \'numpy\' from" in self._captured.before.decode()
+
+    def _captured_expect(self, expect):
+        try:
+            self._captured.expect(expect, timeout=self._timeout)
+        except pexpect.exceptions.TIMEOUT as e:
+            msg = f"Expected value did not arrive: {expect}."
+            raise ValueError(msg) from e
+
+    def assert_output(self, expected):
+        """Asserts that the current output string contains the expected."""
+        output = self._captured.after
+        decoded = output.decode('utf-8')
+        assert expected in decoded, f'decoded={decoded}\nexpected={expected})'
+
+    def assert_regex_output(self, expected):
+        """Asserts that the current output string contains the expected
+        regex."""
+        output = self._captured.after
+        decoded = output.decode('utf-8')
+        done_str = decoded.splitlines()[0]
+        found = re.match(expected, done_str)
+        assert found, f'decoded={decoded}\nexpected={expected})'
+
+    def _run_command(self, command, expect=''):
+        self._captured.sendline(command)
+        self._captured_expect(expect)
+
+    def run(self):
+        """gdb command ~= 'run'"""
+        self._run_command('-exec-run', expect=r'\^running.*\r\n')
+
+    def cont(self):
+        """gdb command ~= 'continue'"""
+        self._run_command('-exec-continue', expect=r'\^running.*\r\n')
+
+    def quit(self):
+        """gdb command ~= 'quit'"""
+        self._run_command('-gdb-exit', expect=r'-gdb-exit')
+        self._captured.terminate()
+
+    def next(self):
+        """gdb command ~= 'next'"""
+        self._run_command('-exec-next', expect=r'\*stopped,.*\r\n')
+
+    def step(self):
+        """gdb command ~= 'step'"""
+        self._run_command('-exec-step', expect=r'\*stopped,.*\r\n')
+
+    def set_breakpoint(self, line=None, symbol=None, condition=None):
+        """gdb command ~= 'break'"""
+        if line is not None and symbol is not None:
+            raise ValueError("Can only supply one of line or symbol")
+        bp = '-break-insert '
+        if condition is not None:
+            bp += f'-c "{condition}" '
+        if line is not None:
+            assert isinstance(line, int)
+            bp += f'-f {self._file_name}:{line} '
+        if symbol is not None:
+            assert isinstance(symbol, str)
+            bp += f'-f {symbol} '
+        self._run_command(bp, expect=r'\^done')
+
+    def check_hit_breakpoint(self, number=None, line=None):
+        """Checks that a breakpoint has been hit"""
+        self._captured_expect(r'\*stopped,.*\r\n')
+        self.assert_output('*stopped,reason="breakpoint-hit",')
+        if number is not None:
+            assert isinstance(number, int)
+            self.assert_output(f'bkptno="{number}"')
+        if line is not None:
+            assert isinstance(line, int)
+            self.assert_output(f'line="{line}"')
+
+    def stack_list_arguments(self, print_values=1, low_frame=0, high_frame=0):
+        """gdb command ~= 'info args'"""
+        for x in (print_values, low_frame, high_frame):
+            assert isinstance(x, int) and x in (0, 1, 2)
+        cmd = f'-stack-list-arguments {print_values} {low_frame} {high_frame}'
+        self._run_command(cmd, expect=r'\^done,.*\r\n')
+
+    def stack_list_variables(self, print_values=1):
+        """gdb command ~= 'info locals'"""
+        assert isinstance(print_values, int) and print_values in (0, 1, 2)
+        cmd = f'-stack-list-variables {print_values}'
+        self._run_command(cmd, expect=r'\^done,.*\r\n')
+
+    def interpreter_exec(self, interpreter=None, command=None):
+        """gdb command ~= 'interpreter-exec'"""
+        if interpreter is None:
+            raise ValueError("interpreter cannot be None")
+        if command is None:
+            raise ValueError("command cannot be None")
+        cmd = f'-interpreter-exec {interpreter} "{command}"'
+        self._run_command(cmd, expect=r'\^(done|error).*\r\n')  # NOTE no `,`
+
+    def _list_features_raw(self):
+        cmd = '-list-features'
+        self._run_command(cmd, expect=r'\^done,.*\r\n')
+
+    def list_features(self):
+        """No equivalent gdb command? Returns a list of supported gdb
+           features.
+        """
+        self._list_features_raw()
+        output = self._captured.after
+        decoded = output.decode('utf-8')
+        m = re.match('.*features=\\[(.*)\\].*', decoded)
+        assert m is not None, "No match found for features string"
+        g = m.groups()
+        assert len(g) == 1, "Invalid number of match groups found"
+        return g[0].replace('"', '').split(',')

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

@@ -0,0 +1,69 @@
+""" Test cases for inlining IR from another module """
+from numba import jit, njit
+from numba.core import types
+from numba.core.extending import overload
+
+_GLOBAL1 = 100
+
+
+@njit(inline='always')
+def bar():
+    return _GLOBAL1 + 10
+
+
+def baz_factory(a):
+    b = 17 + a
+
+    @njit(inline='always')
+    def baz():
+        return _GLOBAL1 + a - b
+    return baz
+
+
+def baz():
+    return _GLOBAL1 + 10
+
+
+@overload(baz, inline='always')
+def baz_ol():
+    def impl():
+        return _GLOBAL1 + 10
+    return impl
+
+
+def bop_factory(a):
+    b = 17 + a
+
+    def bop():
+        return _GLOBAL1 + a - b
+
+    @overload(bop, inline='always')
+    def baz():
+        def impl():
+            return _GLOBAL1 + a - b
+        return impl
+
+    return bop
+
+
+@jit((types.int32,), nopython=True)
+def inner(a):
+    return a + 1
+
+
+@jit((types.int32,), nopython=True)
+def more(a):
+    return inner(inner(a))
+
+
+def outer_simple(a):
+    return inner(a) * 2
+
+
+def outer_multiple(a):
+    return inner(a) * more(a)
+
+
+@njit
+def __dummy__():
+    return

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

@@ -0,0 +1,24 @@
+"""Use cases for testing matmul (@)
+"""
+def matmul_usecase(x, y):
+    return x @ y
+
+def imatmul_usecase(x, y):
+    x @= y
+    return x
+
+class DumbMatrix(object):
+
+    def __init__(self, value):
+        self.value = value
+
+    def __matmul__(self, other):
+        if isinstance(other, DumbMatrix):
+            return DumbMatrix(self.value * other.value)
+        return NotImplemented
+
+    def __imatmul__(self, other):
+        if isinstance(other, DumbMatrix):
+            self.value *= other.value
+            return self
+        return NotImplemented

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

@@ -0,0 +1,24 @@
+# See issue: https://github.com/numba/numba/issues/4348
+# this file must be run in isolation to replicate, test:
+# numba.tests.test_parallel_backend.TestInitSafetyIssues.test_orphaned_semaphore
+# does this to check semaphores are not leaking.
+
+import multiprocessing as mp
+
+import numba # noqa, deliberately unused, here to test import is safe
+
+
+def w():
+    pass
+
+
+def main():
+    ps = [mp.Process(target=w) for _ in range(4)]
+    [p.start() for p in ps]
+    [p.join() for p in ps]
+
+
+if __name__ == '__main__':
+    p = mp.get_context('spawn').Process(target=main)
+    p.start()
+    p.join()

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

@@ -0,0 +1,228 @@
+"""
+Usecases of recursive functions.
+
+Some functions are compiled at import time, hence a separate module.
+"""
+
+from numba import jit
+
+
+@jit("i8(i8)", nopython=True)
+def fib1(n):
+    if n < 2:
+        return n
+    # Note the second call uses a named argument
+    return fib1(n - 1) + fib1(n=n - 2)
+
+
+def make_fib2():
+    @jit("i8(i8)", nopython=True)
+    def fib2(n):
+        if n < 2:
+            return n
+        return fib2(n - 1) + fib2(n=n - 2)
+
+    return fib2
+
+fib2 = make_fib2()
+
+
+def make_type_change_self(jit=lambda x: x):
+    @jit
+    def type_change_self(x, y):
+        if x > 1 and y > 0:
+            return x + type_change_self(x - y, y)
+        else:
+            return y
+    return type_change_self
+
+
+# Implicit signature
+@jit(nopython=True)
+def fib3(n):
+    if n < 2:
+        return n
+    return fib3(n - 1) + fib3(n - 2)
+
+
+# Run-away self recursion
+@jit(nopython=True)
+def runaway_self(x):
+    return runaway_self(x)
+
+
+@jit(nopython=True)
+def raise_self(x):
+    if x == 1:
+        raise ValueError("raise_self")
+    elif x > 0:
+        return raise_self(x - 1)
+    else:
+        return 1
+
+
+# Mutual recursion
+@jit(nopython=True)
+def outer_fac(n):
+    if n < 1:
+        return 1
+    return n * inner_fac(n - 1)
+
+
+@jit(nopython=True)
+def inner_fac(n):
+    if n < 1:
+        return 1
+    return n * outer_fac(n - 1)
+
+
+# Mutual recursion with different arg names
+def make_mutual2(jit=lambda x: x):
+    @jit
+    def foo(x):
+        if x > 0:
+            return 2 * bar(z=1, y=x)
+        return 1 + x
+
+    @jit
+    def bar(y, z):
+        return foo(x=y - z)
+
+    return foo, bar
+
+
+# Mutual runaway recursion
+
+@jit(nopython=True)
+def runaway_mutual(x):
+    return runaway_mutual_inner(x)
+
+
+@jit(nopython=True)
+def runaway_mutual_inner(x):
+    return runaway_mutual(x)
+
+
+# Mutual type changing recursion
+
+def make_type_change_mutual(jit=lambda x: x):
+    @jit
+    def foo(x, y):
+        if x > 1 and y > 0:
+            # call bar first to exercise partial type inference.
+            # typeinferer suspended at the call to bar() and haven't determined
+            # the potential return type from the else-branch
+            return x + bar(x - y, y)
+        else:
+            return y
+
+    @jit
+    def bar(x, y):
+        if x > 1 and y > 0:
+            return x + foo(x - y, y)
+        else:
+            return y
+
+    return foo
+
+
+# Indirect mutual recursion
+def make_four_level(jit=lambda x: x):
+    @jit
+    def first(x):
+        # The recursing call must have a path that is non-recursing.
+        if x > 0:
+            return second(x) * 2
+        else:
+            return 1
+
+    @jit
+    def second(x):
+        return third(x) * 3
+
+    @jit
+    def third(x):
+        return fourth(x) * 4
+
+    @jit
+    def fourth(x):
+        return first(x / 2 - 1)
+
+    return first
+
+
+def make_inner_error(jit=lambda x: x):
+    @jit
+    def outer(x):
+        if x > 0:
+            return inner(x)
+
+        else:
+            return 1
+
+    @jit
+    def inner(x):
+        if x > 0:
+            return outer(x - 1)
+        else:
+            # this branch is actually never executed
+            return error_fun(x)
+
+    @jit
+    def error_fun(x):
+        # to trigger an untyped attribute error
+        return x.ndim
+
+    return outer
+
+
+def make_raise_mutual(jit=lambda x: x):
+    @jit
+    def outer(x):
+        if x > 0:
+            return inner(x)
+        else:
+            return 1
+
+    @jit
+    def inner(x):
+        if x == 1:
+            raise ValueError('raise_mutual')
+        elif x > 0:
+            return outer(x - 1)
+        else:
+            return 1
+
+    return outer
+
+
+def make_optional_return_case(jit=lambda x: x):
+    @jit
+    def foo(x):
+        if x > 5:
+            return x - 1
+        else:
+            return
+
+    @jit
+    def bar(x):
+        out = foo(x)
+        if out is None:
+            return out
+        elif out < 8:
+            return out
+        else:
+            return x * bar(out)
+
+    return bar
+
+
+def make_growing_tuple_case(jit=lambda x: x):
+    # From issue #4387
+    @jit
+    def make_list(n):
+        if n <= 0:
+            return None
+
+        return (n, make_list(n - 1))
+    return make_list

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

@@ -0,0 +1,410 @@
+import numpy as np
+
+import unittest
+from numba.np.numpy_support import from_dtype
+from numba import njit, typeof
+from numba.core import types
+from numba.tests.support import (TestCase, MemoryLeakMixin,
+                                 skip_parfors_unsupported)
+from numba.core.errors import TypingError
+from numba.experimental import jitclass
+
+
+def array_dtype(a):
+    return a.dtype
+
+
+def use_dtype(a, b):
+    return a.view(b.dtype)
+
+
+def dtype_eq_int64(a):
+    return a.dtype == np.dtype('int64')
+
+
+def array_itemsize(a):
+    return a.itemsize
+
+
+def array_nbytes(a):
+    return a.nbytes
+
+
+def array_shape(a, i):
+    return a.shape[i]
+
+
+def array_strides(a, i):
+    return a.strides[i]
+
+
+def array_ndim(a):
+    return a.ndim
+
+
+def array_size(a):
+    return a.size
+
+
+def array_flags_contiguous(a):
+    return a.flags.contiguous
+
+def array_flags_c_contiguous(a):
+    return a.flags.c_contiguous
+
+def array_flags_f_contiguous(a):
+    return a.flags.f_contiguous
+
+
+def nested_array_itemsize(a):
+    return a.f.itemsize
+
+def nested_array_nbytes(a):
+    return a.f.nbytes
+
+def nested_array_shape(a):
+    return a.f.shape
+
+
+def nested_array_strides(a):
+    return a.f.strides
+
+
+def nested_array_ndim(a):
+    return a.f.ndim
+
+
+def nested_array_size(a):
+    return a.f.size
+
+
+def size_after_slicing_usecase(buf, i):
+    sliced = buf[i]
+    # Make sure size attribute is not lost
+    return sliced.size
+
+
+def array_ctypes_data(arr):
+    return arr.ctypes.data
+
+
+def array_real(arr):
+    return arr.real
+
+
+def array_imag(arr):
+    return arr.imag
+
+
+class TestArrayAttr(MemoryLeakMixin, TestCase):
+
+    def setUp(self):
+        super(TestArrayAttr, self).setUp()
+        self.a = np.arange(20, dtype=np.int32).reshape(4, 5)
+
+    def check_unary(self, pyfunc, arr):
+        aryty = typeof(arr)
+        cfunc = self.get_cfunc(pyfunc, (aryty,))
+        expected = pyfunc(arr)
+        self.assertPreciseEqual(cfunc(arr), expected)
+        # Retry with forced any layout
+        cfunc = self.get_cfunc(pyfunc, (aryty.copy(layout='A'),))
+        self.assertPreciseEqual(cfunc(arr), expected)
+
+    def check_unary_with_arrays(self, pyfunc,):
+        self.check_unary(pyfunc, self.a)
+        self.check_unary(pyfunc, self.a.T)
+        self.check_unary(pyfunc, self.a[::2])
+        # 0-d array
+        arr = np.array([42]).reshape(())
+        self.check_unary(pyfunc, arr)
+        # array with an empty dimension
+        arr = np.zeros(0)
+        self.check_unary(pyfunc, arr)
+
+        # check with reshape
+        self.check_unary(pyfunc, arr.reshape((1, 0, 2)))
+
+    def get_cfunc(self, pyfunc, argspec):
+        return njit(argspec)(pyfunc)
+
+    def test_shape(self):
+        pyfunc = array_shape
+        cfunc = self.get_cfunc(pyfunc, (types.int32[:,:], types.int32))
+
+        for i in range(self.a.ndim):
+            self.assertEqual(pyfunc(self.a, i), cfunc(self.a, i))
+
+    def test_strides(self):
+        pyfunc = array_strides
+        cfunc = self.get_cfunc(pyfunc, (types.int32[:,:], types.int32))
+
+        for i in range(self.a.ndim):
+            self.assertEqual(pyfunc(self.a, i), cfunc(self.a, i))
+
+    def test_ndim(self):
+        self.check_unary_with_arrays(array_ndim)
+
+    def test_size(self):
+        self.check_unary_with_arrays(array_size)
+
+    def test_itemsize(self):
+        self.check_unary_with_arrays(array_itemsize)
+
+    def test_nbytes(self):
+        self.check_unary_with_arrays(array_nbytes)
+
+    def test_dtype(self):
+        pyfunc = array_dtype
+        self.check_unary(pyfunc, self.a)
+        dtype = np.dtype([('x', np.int8), ('y', np.int8)])
+        arr = np.zeros(4, dtype=dtype)
+        self.check_unary(pyfunc, arr)
+
+    def test_use_dtype(self):
+        # Test using the dtype attribute inside the Numba function itself
+        b = np.empty(1, dtype=np.int16)
+        pyfunc = use_dtype
+        cfunc = self.get_cfunc(pyfunc, (typeof(self.a), typeof(b)))
+        expected = pyfunc(self.a, b)
+        self.assertPreciseEqual(cfunc(self.a, b), expected)
+
+    def test_dtype_equal(self):
+        # Test checking if a dtype is equal to another dtype
+        pyfunc = dtype_eq_int64
+        self.check_unary(pyfunc, np.empty(1, dtype=np.int16))
+        self.check_unary(pyfunc, np.empty(1, dtype=np.int64))
+
+    def test_flags_contiguous(self):
+        self.check_unary_with_arrays(array_flags_contiguous)
+
+    def test_flags_c_contiguous(self):
+        self.check_unary_with_arrays(array_flags_c_contiguous)
+
+    def test_flags_f_contiguous(self):
+        self.check_unary_with_arrays(array_flags_f_contiguous)
+
+
+class TestNestedArrayAttr(MemoryLeakMixin, unittest.TestCase):
+    def setUp(self):
+        super(TestNestedArrayAttr, self).setUp()
+        dtype = np.dtype([('a', np.int32), ('f', np.int32, (2, 5))])
+        self.a = np.recarray(1, dtype)[0]
+        self.nbrecord = from_dtype(self.a.dtype)
+
+    def get_cfunc(self, pyfunc):
+        return njit((self.nbrecord,))(pyfunc)
+
+    def test_shape(self):
+        pyfunc = nested_array_shape
+        cfunc = self.get_cfunc(pyfunc)
+
+        self.assertEqual(pyfunc(self.a), cfunc(self.a))
+
+    def test_strides(self):
+        pyfunc = nested_array_strides
+        cfunc = self.get_cfunc(pyfunc)
+
+        self.assertEqual(pyfunc(self.a), cfunc(self.a))
+
+    def test_ndim(self):
+        pyfunc = nested_array_ndim
+        cfunc = self.get_cfunc(pyfunc)
+
+        self.assertEqual(pyfunc(self.a), cfunc(self.a))
+
+    def test_nbytes(self):
+        pyfunc = nested_array_nbytes
+        cfunc = self.get_cfunc(pyfunc)
+
+        self.assertEqual(pyfunc(self.a), cfunc(self.a))
+
+    def test_size(self):
+        pyfunc = nested_array_size
+        cfunc = self.get_cfunc(pyfunc)
+
+        self.assertEqual(pyfunc(self.a), cfunc(self.a))
+
+    def test_itemsize(self):
+        pyfunc = nested_array_itemsize
+        cfunc = self.get_cfunc(pyfunc)
+
+        self.assertEqual(pyfunc(self.a), cfunc(self.a))
+
+
+class TestSlicedArrayAttr(MemoryLeakMixin, unittest.TestCase):
+    def test_size_after_slicing(self):
+        pyfunc = size_after_slicing_usecase
+        cfunc = njit(pyfunc)
+        arr = np.arange(2 * 5).reshape(2, 5)
+        for i in range(arr.shape[0]):
+            self.assertEqual(pyfunc(arr, i), cfunc(arr, i))
+        arr = np.arange(2 * 5 * 3).reshape(2, 5, 3)
+        for i in range(arr.shape[0]):
+            self.assertEqual(pyfunc(arr, i), cfunc(arr, i))
+
+
+class TestArrayCTypes(MemoryLeakMixin, TestCase):
+
+    _numba_parallel_test_ = False
+
+    def test_array_ctypes_data(self):
+        pyfunc = array_ctypes_data
+        cfunc = njit(pyfunc)
+        arr = np.arange(3)
+        self.assertEqual(pyfunc(arr), cfunc(arr))
+
+    @skip_parfors_unsupported
+    def test_array_ctypes_ref_error_in_parallel(self):
+        # Issue #2887
+        from ctypes import CFUNCTYPE, c_void_p, c_int32, c_double, c_bool
+
+        @CFUNCTYPE(c_bool, c_void_p, c_int32, c_void_p)
+        def callback(inptr, size, outptr):
+            # A ctypes callback that manipulate the incoming pointers.
+            try:
+                inbuf = (c_double * size).from_address(inptr)
+                outbuf = (c_double * 1).from_address(outptr)
+                a = np.ndarray(size, buffer=inbuf, dtype=np.float64)
+                b = np.ndarray(1, buffer=outbuf, dtype=np.float64)
+                b[0] = (a + a.size)[0]
+                return True
+            except:
+                import traceback
+                traceback.print_exception()
+                return False
+
+
+        # parallel=True is required to reproduce the error.
+        @njit(parallel=True)
+        def foo(size):
+            arr = np.ones(size)
+            out = np.empty(1)
+            # Exercise array.ctypes
+            inct = arr.ctypes
+            outct = out.ctypes
+            # The reference to `arr` is dead by now
+            status = callback(inct.data, size, outct.data)
+            return status, out[0]
+
+        size = 3
+        status, got = foo(size)
+        self.assertTrue(status)
+        self.assertPreciseEqual(got, (np.ones(size) + size)[0])
+
+
+class TestRealImagAttr(MemoryLeakMixin, TestCase):
+    def check_complex(self, pyfunc):
+        cfunc = njit(pyfunc)
+        # test 1D
+        size = 10
+        arr = np.arange(size) + np.arange(size) * 10j
+        self.assertPreciseEqual(pyfunc(arr), cfunc(arr))
+        # test 2D
+        arr = arr.reshape(2, 5)
+        self.assertPreciseEqual(pyfunc(arr), cfunc(arr))
+
+    def test_complex_real(self):
+        self.check_complex(array_real)
+
+    def test_complex_imag(self):
+        self.check_complex(array_imag)
+
+    def check_number_real(self, dtype):
+        pyfunc = array_real
+        cfunc = njit(pyfunc)
+        # test 1D
+        size = 10
+        arr = np.arange(size, dtype=dtype)
+        self.assertPreciseEqual(pyfunc(arr), cfunc(arr))
+        # test 2D
+        arr = arr.reshape(2, 5)
+        self.assertPreciseEqual(pyfunc(arr), cfunc(arr))
+        # test identity
+        self.assertEqual(arr.data, pyfunc(arr).data)
+        self.assertEqual(arr.data, cfunc(arr).data)
+        # test writable
+        real = cfunc(arr)
+        self.assertNotEqual(arr[0, 0], 5)
+        real[0, 0] = 5
+        self.assertEqual(arr[0, 0], 5)
+
+    def test_number_real(self):
+        """
+        Testing .real of non-complex dtypes
+        """
+        for dtype in [np.uint8, np.int32, np.float32, np.float64]:
+            self.check_number_real(dtype)
+
+    def check_number_imag(self, dtype):
+        pyfunc = array_imag
+        cfunc = njit(pyfunc)
+        # test 1D
+        size = 10
+        arr = np.arange(size, dtype=dtype)
+        self.assertPreciseEqual(pyfunc(arr), cfunc(arr))
+        # test 2D
+        arr = arr.reshape(2, 5)
+        self.assertPreciseEqual(pyfunc(arr), cfunc(arr))
+        # test are zeros
+        self.assertEqual(cfunc(arr).tolist(), np.zeros_like(arr).tolist())
+        # test readonly
+        imag = cfunc(arr)
+        with self.assertRaises(ValueError) as raises:
+            imag[0] = 1
+        self.assertEqual('assignment destination is read-only',
+                         str(raises.exception))
+
+    def test_number_imag(self):
+        """
+        Testing .imag of non-complex dtypes
+        """
+        for dtype in [np.uint8, np.int32, np.float32, np.float64]:
+            self.check_number_imag(dtype)
+
+    def test_record_real(self):
+        rectyp = np.dtype([('real', np.float32), ('imag', np.complex64)])
+        arr = np.zeros(3, dtype=rectyp)
+        arr['real'] = np.random.random(arr.size)
+        arr['imag'] = np.random.random(arr.size) * 1.3j
+
+        # check numpy behavior
+        # .real is identity
+        self.assertIs(array_real(arr), arr)
+        # .imag is zero_like
+        self.assertEqual(array_imag(arr).tolist(), np.zeros_like(arr).tolist())
+
+        # check numba behavior
+        # it's most likely a user error, anyway
+        jit_array_real = njit(array_real)
+        jit_array_imag = njit(array_imag)
+
+        with self.assertRaises(TypingError) as raises:
+            jit_array_real(arr)
+        self.assertIn("cannot access .real of array of Record",
+                      str(raises.exception))
+
+        with self.assertRaises(TypingError) as raises:
+            jit_array_imag(arr)
+        self.assertIn("cannot access .imag of array of Record",
+                      str(raises.exception))
+
+class TestJitclassFlagsSegfault(MemoryLeakMixin, TestCase):
+    """Regression test for: https://github.com/numba/numba/issues/4775 """
+
+    def test(self):
+
+        @jitclass(dict())
+        class B(object):
+
+            def __init__(self):
+                pass
+
+            def foo(self, X):
+                X.flags
+
+        Z = B()
+        Z.foo(np.ones(4))
+
+if __name__ == '__main__':
+    unittest.main()

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

@@ -0,0 +1,555 @@
+import itertools
+
+import numpy as np
+
+from numba import jit, njit, typeof
+from numba.core import types
+from numba.tests.support import TestCase, MemoryLeakMixin
+import unittest
+
+
+def array_iter(arr):
+    total = 0
+    for i, v in enumerate(arr):
+        total += i * v
+    return total
+
+def array_iter_items(arr):
+    return list(iter(arr))
+
+def array_view_iter(arr, idx):
+    total = 0
+    for i, v in enumerate(arr[idx]):
+        total += i * v
+    return total
+
+def array_flat(arr, out):
+    for i, v in enumerate(arr.flat):
+        out[i] = v
+
+def array_flat_getitem(arr, ind):
+    return arr.flat[ind]
+
+def array_flat_setitem(arr, ind, val):
+    arr.flat[ind] = val
+
+def array_flat_sum(arr):
+    s = 0
+    for i, v in enumerate(arr.flat):
+        s = s + (i + 1) * v
+    return s
+
+def array_flat_len(arr):
+    return len(arr.flat)
+
+def array_ndenumerate_sum(arr):
+    s = 0
+    for (i, j), v in np.ndenumerate(arr):
+        s = s + (i + 1) * (j + 1) * v
+    return s
+
+def np_ndindex_empty():
+    s = 0
+    for ind in np.ndindex(()):
+        s += s + len(ind) + 1
+    return s
+
+def np_ndindex(x, y):
+    s = 0
+    n = 0
+    for i, j in np.ndindex(x, y):
+        s = s + (i + 1) * (j + 1)
+    return s
+
+def np_ndindex_array(arr):
+    s = 0
+    n = 0
+    for indices in np.ndindex(arr.shape):
+        for i, j in enumerate(indices):
+            s = s + (i + 1) * (j + 1)
+    return s
+
+def np_nditer1(a):
+    res = []
+    for u in np.nditer(a):
+        res.append(u.item())
+    return res
+
+def np_nditer2(a, b):
+    res = []
+    for u, v in np.nditer((a, b)):
+        res.append((u.item(), v.item()))
+    return res
+
+def np_nditer3(a, b, c):
+    res = []
+    for u, v, w in np.nditer((a, b, c)):
+        res.append((u.item(), v.item(), w.item()))
+    return res
+
+def iter_next(arr):
+    it = iter(arr)
+    it2 = iter(arr)
+    return next(it), next(it), next(it2)
+
+
+#
+# Test premature free (see issue #2112).
+# The following test allocates an array ``x`` inside the body.
+# The compiler will put a ``del x`` right after the last use of ``x``,
+# which is right after the creation of the array iterator and
+# before the loop is entered.  If the iterator does not incref the array,
+# the iterator will be reading garbage data of free'ed memory.
+#
+
+def array_flat_premature_free(size):
+    x = np.arange(size)
+    res = np.zeros_like(x, dtype=np.intp)
+    for i, v in enumerate(x.flat):
+        res[i] = v
+    return res
+
+def array_ndenumerate_premature_free(size):
+    x = np.arange(size)
+    res = np.zeros_like(x, dtype=np.intp)
+    for i, v in np.ndenumerate(x):
+        res[i] = v
+    return res
+
+
+class TestArrayIterators(MemoryLeakMixin, TestCase):
+    """
+    Test array.flat, np.ndenumerate(), etc.
+    """
+
+    def setUp(self):
+        super(TestArrayIterators, self).setUp()
+
+    def check_array_iter_1d(self, arr):
+        pyfunc = array_iter
+        cfunc = njit((typeof(arr),))(pyfunc)
+        expected = pyfunc(arr)
+        self.assertPreciseEqual(cfunc(arr), expected)
+
+    def check_array_iter_items(self, arr):
+        pyfunc = array_iter_items
+        cfunc = njit((typeof(arr),))(pyfunc)
+        expected = pyfunc(arr)
+        self.assertPreciseEqual(cfunc(arr), expected)
+
+    def check_array_view_iter(self, arr, index):
+        pyfunc = array_view_iter
+        cfunc = njit((typeof(arr), typeof(index),))(pyfunc)
+        expected = pyfunc(arr, index)
+        self.assertPreciseEqual(cfunc(arr, index), expected)
+
+    def check_array_flat(self, arr, arrty=None):
+        out = np.zeros(arr.size, dtype=arr.dtype)
+        nb_out = out.copy()
+        if arrty is None:
+            arrty = typeof(arr)
+
+        cfunc = njit((arrty, typeof(out),))(array_flat)
+
+        array_flat(arr, out)
+        cfunc(arr, nb_out)
+
+        self.assertPreciseEqual(out, nb_out)
+
+    def check_array_unary(self, arr, arrty, func):
+        cfunc = njit((arrty,))(func)
+        self.assertPreciseEqual(cfunc(arr), func(arr))
+
+    def check_array_ndenumerate_sum(self, arr, arrty):
+        self.check_array_unary(arr, arrty, array_ndenumerate_sum)
+
+    def test_array_iter(self):
+        # Test iterating over arrays
+        arr = np.arange(6)
+        self.check_array_iter_1d(arr)
+        self.check_array_iter_items(arr)
+        arr = arr[::2]
+        self.assertFalse(arr.flags.c_contiguous)
+        self.assertFalse(arr.flags.f_contiguous)
+        self.check_array_iter_1d(arr)
+        self.check_array_iter_items(arr)
+        arr = np.bool_([1, 0, 0, 1])
+        self.check_array_iter_1d(arr)
+        self.check_array_iter_items(arr)
+        arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
+        self.check_array_iter_items(arr)
+        self.check_array_iter_items(arr.T)
+
+    def test_array_iter_yielded_order(self):
+        # See issue #5692
+        @jit(nopython=True)
+        def foo(arr):
+            t = []
+            for y1 in arr:
+                for y2 in y1:
+                    t.append(y2.ravel())
+            return t
+
+        # 'F' ordered
+        arr = np.arange(24).reshape((2, 3, 4), order='F')
+        expected = foo.py_func(arr)
+        got = foo(arr)
+        self.assertPreciseEqual(expected, got)
+
+        # 'A' ordered, outer strided
+        arr = np.arange(64).reshape((4, 8, 2), order='F')[::2, :, :]
+        expected = foo.py_func(arr)
+        got = foo(arr)
+        self.assertPreciseEqual(expected, got)
+
+        # 'A' ordered, middle strided
+        arr = np.arange(64).reshape((4, 8, 2), order='F')[:, ::2, :]
+        expected = foo.py_func(arr)
+        got = foo(arr)
+        self.assertPreciseEqual(expected, got)
+
+        # 'A' ordered, inner strided
+        arr = np.arange(64).reshape((4, 8, 2), order='F')[:, :, ::2]
+        expected = foo.py_func(arr)
+        got = foo(arr)
+        self.assertPreciseEqual(expected, got)
+
+        @jit(nopython=True)
+        def flag_check(arr):
+            out = []
+            for sub in arr:
+                out.append((sub, sub.flags.c_contiguous,
+                            sub.flags.f_contiguous))
+            return out
+
+        arr = np.arange(10).reshape((2, 5), order='F')
+        expected = flag_check.py_func(arr)
+        got = flag_check(arr)
+
+        self.assertEqual(len(expected), len(got))
+        ex_arr, e_flag_c, e_flag_f = expected[0]
+        go_arr, g_flag_c, g_flag_f = got[0]
+        np.testing.assert_allclose(ex_arr, go_arr)
+        self.assertEqual(e_flag_c, g_flag_c)
+        self.assertEqual(e_flag_f, g_flag_f)
+
+    def test_array_view_iter(self):
+        # Test iterating over a 1d view over a 2d array
+        arr = np.arange(12).reshape((3, 4))
+        self.check_array_view_iter(arr, 1)
+        self.check_array_view_iter(arr.T, 1)
+        arr = arr[::2]
+        self.check_array_view_iter(arr, 1)
+        arr = np.bool_([1, 0, 0, 1]).reshape((2, 2))
+        self.check_array_view_iter(arr, 1)
+
+    def test_array_flat_3d(self):
+        arr = np.arange(24).reshape(4, 2, 3)
+
+        arrty = typeof(arr)
+        self.assertEqual(arrty.ndim, 3)
+        self.assertEqual(arrty.layout, 'C')
+        self.assertTrue(arr.flags.c_contiguous)
+        # Test with C-contiguous array
+        self.check_array_flat(arr)
+        # Test with Fortran-contiguous array
+        arr = arr.transpose()
+        self.assertFalse(arr.flags.c_contiguous)
+        self.assertTrue(arr.flags.f_contiguous)
+        self.assertEqual(typeof(arr).layout, 'F')
+        self.check_array_flat(arr)
+        # Test with non-contiguous array
+        arr = arr[::2]
+        self.assertFalse(arr.flags.c_contiguous)
+        self.assertFalse(arr.flags.f_contiguous)
+        self.assertEqual(typeof(arr).layout, 'A')
+        self.check_array_flat(arr)
+        # Boolean array
+        arr = np.bool_([1, 0, 0, 1] * 2).reshape((2, 2, 2))
+        self.check_array_flat(arr)
+
+    def test_array_flat_empty(self):
+        # Test .flat with various shapes of empty arrays, contiguous
+        # and non-contiguous (see issue #846).
+
+        # Define a local checking function, Numba's `typeof` ends up aliasing
+        # 0d C and F ordered arrays, so the check needs to go via the compile
+        # result entry point to bypass type checking.
+        def check(arr, arrty):
+            cfunc = njit((arrty,))(array_flat_sum)
+            cres = cfunc.overloads[(arrty,)]
+            got = cres.entry_point(arr)
+            expected = cfunc.py_func(arr)
+            self.assertPreciseEqual(expected, got)
+
+        arr = np.zeros(0, dtype=np.int32)
+        arr = arr.reshape(0, 2)
+        arrty = types.Array(types.int32, 2, layout='C')
+        check(arr, arrty)
+        arrty = types.Array(types.int32, 2, layout='F')
+        check(arr, arrty)
+        arrty = types.Array(types.int32, 2, layout='A')
+        check(arr, arrty)
+        arr = arr.reshape(2, 0)
+        arrty = types.Array(types.int32, 2, layout='C')
+        check(arr, arrty)
+        arrty = types.Array(types.int32, 2, layout='F')
+        check(arr, arrty)
+        arrty = types.Array(types.int32, 2, layout='A')
+        check(arr, arrty)
+
+    def test_array_flat_getitem(self):
+        # Test indexing of array.flat object
+        pyfunc = array_flat_getitem
+        cfunc = njit(pyfunc)
+        def check(arr, ind):
+            expected = pyfunc(arr, ind)
+            self.assertEqual(cfunc(arr, ind), expected)
+
+        arr = np.arange(24).reshape(4, 2, 3)
+        for i in range(arr.size):
+            check(arr, i)
+        arr = arr.T
+        for i in range(arr.size):
+            check(arr, i)
+        arr = arr[::2]
+        for i in range(arr.size):
+            check(arr, i)
+        arr = np.array([42]).reshape(())
+        for i in range(arr.size):
+            check(arr, i)
+        # Boolean array
+        arr = np.bool_([1, 0, 0, 1])
+        for i in range(arr.size):
+            check(arr, i)
+        arr = arr[::2]
+        for i in range(arr.size):
+            check(arr, i)
+
+    def test_array_flat_setitem(self):
+        # Test indexing of array.flat object
+        pyfunc = array_flat_setitem
+        cfunc = njit(pyfunc)
+        def check(arr, ind):
+            # Use np.copy() to keep the layout
+            expected = np.copy(arr)
+            got = np.copy(arr)
+            pyfunc(expected, ind, 123)
+            cfunc(got, ind, 123)
+            self.assertPreciseEqual(got, expected)
+
+        arr = np.arange(24).reshape(4, 2, 3)
+        for i in range(arr.size):
+            check(arr, i)
+        arr = arr.T
+        for i in range(arr.size):
+            check(arr, i)
+        arr = arr[::2]
+        for i in range(arr.size):
+            check(arr, i)
+        arr = np.array([42]).reshape(())
+        for i in range(arr.size):
+            check(arr, i)
+        # Boolean array
+        arr = np.bool_([1, 0, 0, 1])
+        for i in range(arr.size):
+            check(arr, i)
+        arr = arr[::2]
+        for i in range(arr.size):
+            check(arr, i)
+
+    def test_array_flat_len(self):
+        # Test len(array.flat)
+        pyfunc = array_flat_len
+        cfunc = njit(array_flat_len)
+        def check(arr):
+            expected = pyfunc(arr)
+            self.assertPreciseEqual(cfunc(arr), expected)
+
+        arr = np.arange(24).reshape(4, 2, 3)
+        check(arr)
+        arr = arr.T
+        check(arr)
+        arr = arr[::2]
+        check(arr)
+        arr = np.array([42]).reshape(())
+        check(arr)
+
+    def test_array_flat_premature_free(self):
+        cfunc = njit((types.intp,))(array_flat_premature_free)
+        expect = array_flat_premature_free(6)
+        got = cfunc(6)
+        self.assertTrue(got.sum())
+        self.assertPreciseEqual(expect, got)
+
+    def test_array_ndenumerate_2d(self):
+        arr = np.arange(12).reshape(4, 3)
+        arrty = typeof(arr)
+        self.assertEqual(arrty.ndim, 2)
+        self.assertEqual(arrty.layout, 'C')
+        self.assertTrue(arr.flags.c_contiguous)
+        # Test with C-contiguous array
+        self.check_array_ndenumerate_sum(arr, arrty)
+        # Test with Fortran-contiguous array
+        arr = arr.transpose()
+        self.assertFalse(arr.flags.c_contiguous)
+        self.assertTrue(arr.flags.f_contiguous)
+        arrty = typeof(arr)
+        self.assertEqual(arrty.layout, 'F')
+        self.check_array_ndenumerate_sum(arr, arrty)
+        # Test with non-contiguous array
+        arr = arr[::2]
+        self.assertFalse(arr.flags.c_contiguous)
+        self.assertFalse(arr.flags.f_contiguous)
+        arrty = typeof(arr)
+        self.assertEqual(arrty.layout, 'A')
+        self.check_array_ndenumerate_sum(arr, arrty)
+        # Boolean array
+        arr = np.bool_([1, 0, 0, 1]).reshape((2, 2))
+        self.check_array_ndenumerate_sum(arr, typeof(arr))
+
+    def test_array_ndenumerate_empty(self):
+        # Define a local checking function, Numba's `typeof` ends up aliasing
+        # 0d C and F ordered arrays, so the check needs to go via the compile
+        # result entry point to bypass type checking.
+        def check(arr, arrty):
+            cfunc = njit((arrty,))(array_ndenumerate_sum)
+            cres = cfunc.overloads[(arrty,)]
+            got = cres.entry_point(arr)
+            expected = cfunc.py_func(arr)
+            np.testing.assert_allclose(expected, got)
+
+        arr = np.zeros(0, dtype=np.int32)
+        arr = arr.reshape(0, 2)
+        arrty = types.Array(types.int32, 2, layout='C')
+        check(arr, arrty)
+        arrty = types.Array(types.int32, 2, layout='F')
+        check(arr, arrty)
+        arrty = types.Array(types.int32, 2, layout='A')
+        check(arr, arrty)
+        arr = arr.reshape(2, 0)
+        arrty = types.Array(types.int32, 2, layout='C')
+        check(arr, arrty)
+        arrty = types.Array(types.int32, 2, layout='F')
+        check(arr, arrty)
+        arrty = types.Array(types.int32, 2, layout='A')
+        check(arr, arrty)
+
+    def test_array_ndenumerate_premature_free(self):
+        cfunc = njit((types.intp,))(array_ndenumerate_premature_free)
+        expect = array_ndenumerate_premature_free(6)
+        got = cfunc(6)
+        self.assertTrue(got.sum())
+        self.assertPreciseEqual(expect, got)
+
+    def test_np_ndindex(self):
+        func = np_ndindex
+        cfunc = njit((types.int32, types.int32,))(func)
+        self.assertPreciseEqual(cfunc(3, 4), func(3, 4))
+        self.assertPreciseEqual(cfunc(3, 0), func(3, 0))
+        self.assertPreciseEqual(cfunc(0, 3), func(0, 3))
+        self.assertPreciseEqual(cfunc(0, 0), func(0, 0))
+
+    def test_np_ndindex_array(self):
+        func = np_ndindex_array
+        arr = np.arange(12, dtype=np.int32) + 10
+        self.check_array_unary(arr, typeof(arr), func)
+        arr = arr.reshape((4, 3))
+        self.check_array_unary(arr, typeof(arr), func)
+        arr = arr.reshape((2, 2, 3))
+        self.check_array_unary(arr, typeof(arr), func)
+
+    def test_np_ndindex_empty(self):
+        func = np_ndindex_empty
+        cfunc = njit((),)(func)
+        self.assertPreciseEqual(cfunc(), func())
+
+    def test_iter_next(self):
+        # This also checks memory management with iter() and next()
+        func = iter_next
+        arr = np.arange(12, dtype=np.int32) + 10
+        self.check_array_unary(arr, typeof(arr), func)
+
+
+class TestNdIter(MemoryLeakMixin, TestCase):
+    """
+    Test np.nditer()
+    """
+
+    def inputs(self):
+        # All those inputs are compatible with a (3, 4) main shape
+
+        # scalars
+        yield np.float32(100)
+
+        # 0-d arrays
+        yield np.array(102, dtype=np.int16)
+
+        # 1-d arrays
+        yield np.arange(4).astype(np.complex64)
+        yield np.arange(8)[::2]
+
+        # 2-d arrays
+        a = np.arange(12).reshape((3, 4))
+        yield a
+        yield a.copy(order='F')
+        a = np.arange(24).reshape((6, 4))[::2]
+        yield a
+
+    def basic_inputs(self):
+        yield np.arange(4).astype(np.complex64)
+        yield np.arange(8)[::2]
+        a = np.arange(12).reshape((3, 4))
+        yield a
+        yield a.copy(order='F')
+
+    def check_result(self, got, expected):
+        self.assertEqual(set(got), set(expected), (got, expected))
+
+    def test_nditer1(self):
+        pyfunc = np_nditer1
+        cfunc = jit(nopython=True)(pyfunc)
+        for a in self.inputs():
+            expected = pyfunc(a)
+            got = cfunc(a)
+            self.check_result(got, expected)
+
+    def test_nditer2(self):
+        pyfunc = np_nditer2
+        cfunc = jit(nopython=True)(pyfunc)
+        for a, b in itertools.product(self.inputs(), self.inputs()):
+            expected = pyfunc(a, b)
+            got = cfunc(a, b)
+            self.check_result(got, expected)
+
+    def test_nditer3(self):
+        pyfunc = np_nditer3
+        cfunc = jit(nopython=True)(pyfunc)
+        # Use a restricted set of inputs, to shorten test time
+        inputs = self.basic_inputs
+        for a, b, c in itertools.product(inputs(), inputs(), inputs()):
+            expected = pyfunc(a, b, c)
+            got = cfunc(a, b, c)
+            self.check_result(got, expected)
+
+    def test_errors(self):
+        # Incompatible shapes
+        pyfunc = np_nditer2
+        cfunc = jit(nopython=True)(pyfunc)
+
+        self.disable_leak_check()
+
+        def check_incompatible(a, b):
+            with self.assertRaises(ValueError) as raises:
+                cfunc(a, b)
+            self.assertIn("operands could not be broadcast together",
+                          str(raises.exception))
+
+        check_incompatible(np.arange(2), np.arange(3))
+        a = np.arange(12).reshape((3, 4))
+        b = np.arange(3)
+        check_incompatible(a, b)
+
+
+if __name__ == '__main__':
+    unittest.main()

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

@@ -0,0 +1,289 @@
+import array
+
+import numpy as np
+
+from numba import jit
+from numba.tests.support import TestCase, compile_function, MemoryLeakMixin
+import unittest
+
+
+@jit(nopython=True)
+def len_usecase(buf):
+    return len(buf)
+
+
+@jit(nopython=True)
+def getitem_usecase(buf, i):
+    return buf[i]
+
+
+@jit(nopython=True)
+def getslice_usecase(buf, i, j):
+    s = buf[i:j]
+    return s[0] + 2 * s[-1]
+
+
+@jit(nopython=True)
+def setitem_usecase(buf, i, v):
+    buf[i] = v
+
+
+@jit(nopython=True)
+def iter_usecase(buf):
+    res = 0.0
+    for i, x in enumerate(buf):
+        res += x
+        res *= i + 1
+    return res
+
+
+def attrgetter(attr):
+    code = """def func(x):
+        return x.%(attr)s
+""" % locals()
+    pyfunc = compile_function("func", code, globals())
+    return jit(nopython=True)(pyfunc)
+
+
+contiguous_usecase = attrgetter("contiguous")
+c_contiguous_usecase = attrgetter("c_contiguous")
+f_contiguous_usecase = attrgetter("f_contiguous")
+itemsize_usecase = attrgetter("itemsize")
+nbytes_usecase = attrgetter("nbytes")
+ndim_usecase = attrgetter("ndim")
+readonly_usecase = attrgetter("readonly")
+shape_usecase = attrgetter("shape")
+strides_usecase = attrgetter("strides")
+
+
+class TestBufferProtocol(MemoryLeakMixin, TestCase):
+    """
+    Test operations on buffer-providing objects.
+    """
+
+    def _arrays(self):
+        n = 10
+        for letter, offset in [
+            ('b', -3),
+            ('B', 0),
+            ('h', -5000),
+            ('H', 40000),
+            ('i', -100000),
+            ('I', 1000000),
+            ('l', -100000),
+            ('L', 1000000),
+            ('q', -2**60),
+            ('Q', 2**63 + 1),
+            ('f', 1.5),
+            ('d', -1.5),
+            ]:
+            yield array.array(letter, [i + offset for i in range(n)])
+
+    def _memoryviews(self):
+        n = 10
+        yield memoryview(bytearray(b"abcdefghi"))
+        yield memoryview(b"abcdefghi")
+        # Different item types
+        for dtype, start, stop in [
+            ('int8', -10, 10),
+            ('uint8', 0, 10),
+            ('int16', -5000, 1000),
+            ('uint16', 40000, 50000),
+            ('int32', -100000, 100000),
+            ('uint32', 0, 1000000),
+            ('int64', -2**60, 10),
+            ('uint64', 0, 2**64 - 10),
+            ('float32', 1.5, 3.5),
+            ('float64', 1.5, 3.5),
+            ('complex64', -8j, 12 + 5j),
+            ('complex128', -8j, 12 + 5j),
+            ]:
+            yield memoryview(np.linspace(start, stop, n).astype(dtype))
+        # Different layouts
+        arr = np.arange(12).reshape((3, 4))
+        assert arr.flags.c_contiguous and not arr.flags.f_contiguous
+        yield memoryview(arr)
+        arr = arr.T
+        assert arr.flags.f_contiguous and not arr.flags.c_contiguous
+        yield memoryview(arr)
+        arr = arr[::2]
+        assert not arr.flags.f_contiguous and not arr.flags.c_contiguous
+        yield memoryview(arr)
+
+    def _readonlies(self):
+        yield b"xyz"
+        yield memoryview(b"abcdefghi")
+        arr = np.arange(5)
+        arr.setflags(write=False)
+        yield memoryview(arr)
+
+    def _check_unary(self, jitfunc, *args):
+        pyfunc = jitfunc.py_func
+        self.assertPreciseEqual(jitfunc(*args), pyfunc(*args))
+
+    def check_len(self, obj):
+        self._check_unary(len_usecase, obj)
+
+    def check_iter(self, obj):
+        self._check_unary(iter_usecase, obj)
+
+    def check_getitem(self, obj):
+        # Be careful to index all dimensions, since we don't support
+        # partial indexing yet.
+        def yield_indices(obj):
+            try:
+                shape = obj.shape
+            except AttributeError:
+                shape = len(obj),
+            for tup in np.ndindex(shape):
+                # Simple 1d buffer-providing objects usually don't support
+                # tuple indexing.
+                if len(tup) == 1:
+                    yield tup[0]
+                else:
+                    yield tup
+
+        for i in yield_indices(obj):
+            try:
+                expected = obj[i]
+            except (NotImplementedError, TypeError):
+                if isinstance(obj, memoryview):
+                    # The memoryview object doesn't support all codes yet,
+                    # fall back on the underlying object.
+                    expected = obj.obj[i]
+                else:
+                    raise
+            self.assertPreciseEqual(getitem_usecase(obj, i), expected)
+
+    def check_setitem(self, obj):
+        for i in range(len(obj)):
+            orig = list(obj)
+            val = obj[i] // 2 + 1
+            setitem_usecase(obj, i, val)
+            self.assertEqual(obj[i], val)
+            for j, val in enumerate(orig):
+                if j != i:
+                    self.assertEqual(obj[j], val)
+
+    def check_getslice(self, obj):
+        self._check_unary(getslice_usecase, obj, 1, len(obj) - 1)
+
+    def test_len(self):
+        self.check_len(bytearray(5))
+        self.check_len(b"xyz")
+        for mem in self._memoryviews():
+            self.check_len(mem)
+        for arr in self._arrays():
+            self.check_len(arr)
+        for buf in self._readonlies():
+            self.check_getitem(buf)
+
+    def test_getitem(self):
+        self.check_getitem(bytearray(b"abc"))
+        self.check_getitem(b"xyz")
+        for mem in self._memoryviews():
+            self.check_getitem(mem)
+        for arr in self._arrays():
+            self.check_getitem(arr)
+        for buf in self._readonlies():
+            self.check_getitem(buf)
+
+    def test_getslice(self):
+        with self.assertTypingError():
+            self.check_getslice(bytearray(b"abcde"))
+        self.check_getslice(b"xyzuvw")
+        self.check_getslice(memoryview(b"xyzuvw"))
+        with self.assertTypingError():
+            self.check_getslice(array.array('i', range(10)))
+        for buf in self._readonlies():
+            self.check_getitem(buf)
+
+    def test_setitem(self):
+        self.check_setitem(bytearray(b"abcdefghi"))
+        for arr in self._arrays():
+            self.check_setitem(arr)
+        for mem in self._memoryviews():
+            self.check_getitem(mem)
+        # Read-only buffers
+        for buf in self._readonlies():
+            with self.assertTypingError():
+                self.check_setitem(buf)
+
+    def test_iter(self):
+        self.check_iter(bytearray(b"abc"))
+        self.check_iter(b"xyz")
+        self.check_iter(memoryview(b"xyz"))
+        for arr in self._arrays():
+            self.check_iter(arr)
+        for buf in self._readonlies():
+            self.check_getitem(buf)
+
+
+class TestMemoryView(MemoryLeakMixin, TestCase):
+    """
+    Test memoryview-specific attributes and operations.
+    """
+
+    def _arrays(self):
+        arr = np.arange(12)
+        yield arr
+        arr = arr.reshape((3, 4))
+        yield arr
+        yield arr.T
+        yield arr[::2]
+        arr.setflags(write=False)
+        yield arr
+        arr = np.zeros(())
+        assert arr.ndim == 0
+        yield arr
+
+    def test_ndim(self):
+        for arr in self._arrays():
+            m = memoryview(arr)
+            self.assertPreciseEqual(ndim_usecase(m), arr.ndim)
+
+    def test_shape(self):
+        for arr in self._arrays():
+            m = memoryview(arr)
+            self.assertPreciseEqual(shape_usecase(m), arr.shape)
+
+    def test_strides(self):
+        for arr in self._arrays():
+            m = memoryview(arr)
+            self.assertPreciseEqual(strides_usecase(m), arr.strides)
+
+    def test_itemsize(self):
+        for arr in self._arrays():
+            m = memoryview(arr)
+            self.assertPreciseEqual(itemsize_usecase(m), arr.itemsize)
+
+    def test_nbytes(self):
+        for arr in self._arrays():
+            m = memoryview(arr)
+            self.assertPreciseEqual(nbytes_usecase(m), arr.size * arr.itemsize)
+
+    def test_readonly(self):
+        for arr in self._arrays():
+            m = memoryview(arr)
+            self.assertIs(readonly_usecase(m), not arr.flags.writeable)
+        m = memoryview(b"xyz")
+        self.assertIs(readonly_usecase(m), True)
+        m = memoryview(bytearray(b"xyz"))
+        self.assertIs(readonly_usecase(m), False)
+
+    def test_contiguous(self):
+        m = memoryview(bytearray(b"xyz"))
+        self.assertIs(contiguous_usecase(m), True)
+        self.assertIs(c_contiguous_usecase(m), True)
+        self.assertIs(f_contiguous_usecase(m), True)
+        for arr in self._arrays():
+            m = memoryview(arr)
+            # Note `arr.flags.contiguous` is wrong (it mimics c_contiguous)
+            self.assertIs(contiguous_usecase(m),
+                          arr.flags.f_contiguous or arr.flags.c_contiguous)
+            self.assertIs(c_contiguous_usecase(m), arr.flags.c_contiguous)
+            self.assertIs(f_contiguous_usecase(m), arr.flags.f_contiguous)
+
+
+if __name__ == '__main__':
+    unittest.main()

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

@@ -0,0 +1,1682 @@
+import itertools
+import functools
+import sys
+import operator
+from collections import namedtuple
+
+import numpy as np
+
+import unittest
+import warnings
+
+from numba import jit, typeof, njit, typed
+from numba.core import errors, types, config
+from numba.tests.support import (TestCase, tag, ignore_internal_warnings,
+                                 MemoryLeakMixin)
+from numba.core.extending import overload_method, box, register_jitable
+
+
+forceobj_flags = {'forceobj': True}
+
+no_pyobj_flags = {'nopython': True, '_nrt': False}
+
+nrt_no_pyobj_flags = {'nopython': True}
+
+
+def abs_usecase(x):
+    return abs(x)
+
+def all_usecase(x, y):
+    if x == None and y == None:
+        return all([])
+    elif x == None:
+        return all([y])
+    elif y == None:
+        return all([x])
+    else:
+        return all([x, y])
+
+def any_usecase(x, y):
+    if x == None and y == None:
+        return any([])
+    elif x == None:
+        return any([y])
+    elif y == None:
+        return any([x])
+    else:
+        return any([x, y])
+
+def bool_usecase(x):
+    return bool(x)
+
+def complex_usecase(x, y):
+    return complex(x, y)
+
+def divmod_usecase(x, y):
+    return divmod(x, y)
+
+def enumerate_usecase():
+    result = 0
+    for i, j in enumerate((1., 2.5, 3.)):
+        result += i * j
+    return result
+
+def enumerate_start_usecase():
+    result = 0
+    for i, j in enumerate((1., 2.5, 3.), 42):
+        result += i * j
+    return result
+
+def enumerate_invalid_start_usecase():
+    result = 0
+    for i, j in enumerate((1., 2.5, 3.), 3.14159):
+        result += i * j
+    return result
+
+def filter_usecase(x, filter_func):
+    return filter(filter_func, x)
+
+def float_usecase(x):
+    return float(x)
+
+def float_inf_usecase(x):
+    d = {
+        0: float('inf'),
+        1: float('INF'),
+        2: float('-inf'),
+        3: float('-INF'),
+        4: float('\r\nINF\r       '),
+        5: float('       \r\n\t-INF'),
+        6: float('1234.45'),
+        7: float('\n-123.4\r'),
+    }
+    return d.get(x)
+
+def format_usecase(x, y):
+    return x.format(y)
+
+def globals_usecase():
+    return globals()
+
+# NOTE: hash() is tested in test_hashing
+
+def hex_usecase(x):
+    return hex(x)
+
+def str_usecase(x):
+    return str(x)
+
+def int_usecase(x, base):
+    return int(x, base=base)
+
+def iter_next_usecase(x):
+    it = iter(x)
+    return next(it), next(it)
+
+def locals_usecase(x):
+    y = 5
+    return locals()['y']
+
+def long_usecase(x, base):
+    return long(x, base=base)
+
+def map_usecase(x, map_func):
+    return map(map_func, x)
+
+
+def max_usecase1(x, y):
+    return max(x, y)
+
+def max_usecase2(x, y):
+    return max([x, y])
+
+def max_usecase3(x):
+    return max(x)
+
+def max_usecase4():
+    return max(())
+
+
+def min_usecase1(x, y):
+    return min(x, y)
+
+def min_usecase2(x, y):
+    return min([x, y])
+
+def min_usecase3(x):
+    return min(x)
+
+def min_usecase4():
+    return min(())
+
+def oct_usecase(x):
+    return oct(x)
+
+def reduce_usecase(reduce_func, x):
+    return functools.reduce(reduce_func, x)
+
+def round_usecase1(x):
+    return round(x)
+
+def round_usecase2(x, n):
+    return round(x, n)
+
+def sum_usecase(x):
+    return sum(x)
+
+def type_unary_usecase(a, b):
+    return type(a)(b)
+
+def truth_usecase(p):
+    return operator.truth(p)
+
+def unichr_usecase(x):
+    return unichr(x)
+
+def zip_usecase():
+    result = 0
+    for i, j in zip((1, 2, 3), (4.5, 6.7)):
+        result += i * j
+    return result
+
+def zip_0_usecase():
+    result = 0
+    for i in zip():
+        result += 1
+    return result
+
+def zip_1_usecase():
+    result = 0
+    for i, in zip((1, 2)):
+        result += i
+    return result
+
+
+def zip_3_usecase():
+    result = 0
+    for i, j, k in zip((1, 2), (3, 4, 5), (6.7, 8.9)):
+        result += i * j * k
+    return result
+
+
+def zip_first_exhausted():
+    iterable = range(7)
+    n = 3
+    it = iter(iterable)
+    # 1st iterator is shorter
+    front = list(zip(range(n), it))
+    # Make sure that we didn't skip one in `it`
+    back = list(it)
+    return front, back
+
+
+def pow_op_usecase(x, y):
+    return x ** y
+
+
+def pow_usecase(x, y):
+    return pow(x, y)
+
+
+def sum_usecase(x):
+    return sum(x)
+
+
+def sum_kwarg_usecase(x, start=0):
+    ret = sum(x, start)
+    return sum(x, start=start), ret
+
+
+def isinstance_usecase(a):
+    if isinstance(a, (int, float)):
+        if isinstance(a, int):
+            return a + 1, 'int'
+        if isinstance(a, float):
+            return a + 2.0, 'float'
+    elif isinstance(a, str):
+        return a + ", world!", 'str'
+    elif isinstance(a, complex):
+        return a.imag, 'complex'
+    elif isinstance(a, (tuple, list)):
+        if isinstance(a, tuple):
+            return 'tuple'
+        else:
+            return 'list'
+    elif isinstance(a, set):
+        return 'set'
+    elif isinstance(a, bytes):
+        return 'bytes'
+    return 'no match'
+
+
+def isinstance_dict():
+    a = {1: 2, 3: 4}
+    b = {'a': 10, 'b': np.zeros(3)}
+    if isinstance(a, dict) and isinstance(b, dict):
+        return 'dict'
+    else:
+        return 'not dict'
+
+
+def isinstance_usecase_numba_types(a):
+    if isinstance(a, typed.List):
+        return 'typed list'
+    elif isinstance(a, (types.int32, types.int64)):
+        if isinstance(a, types.int32):
+            return 'int32'
+        else:
+            return 'int64'
+    elif isinstance(a, (types.float32, types.float64)):
+        if isinstance(a, types.float32):
+            return 'float32'
+        elif isinstance(a, types.float64):
+            return 'float64'
+    elif isinstance(a, typed.Dict):
+        return 'typed dict'
+    else:
+        return 'no match'
+
+
+def isinstance_usecase_numba_types_2():
+    # some types cannot be passed as argument to njit functions
+    a = b'hello'
+    b = range(1, 2)
+    c = dict()
+    c[2] = 3
+    if isinstance(a, bytes) and \
+            isinstance(b, range) and \
+            isinstance(c, dict):
+        return True
+    return False
+
+
+def invalid_isinstance_usecase(x):
+    if isinstance(x, ('foo',)):
+        return 'true branch'
+    else:
+        return 'false branch'
+
+
+def isinstance_usecase_invalid_type(x):
+    # this should be a valid call when x := float
+    if isinstance(x, (float, 'not a type')):
+        return True
+    else:
+        return False
+
+
+def invalid_isinstance_usecase_phi_nopropagate(x):
+    if x > 4:
+        z = 10
+    else:
+        z = 'a'
+    if isinstance(z, int):
+        return True
+    else:
+        return False
+
+
+def invalid_isinstance_usecase_phi_nopropagate2(a):
+    # Numba issue #9125
+    x = 0
+    if isinstance(a, int):
+        a = (a, a)
+
+    for i in range(len(a)):
+        x += i
+    return x
+
+
+def invalid_isinstance_optional_usecase(x):
+    if x > 4:
+        z = 10
+    else:
+        z = None
+    if isinstance(z, int):
+        return True
+    else:
+        return False
+
+def invalid_isinstance_unsupported_type_usecase():
+    ntpl = namedtuple('ntpl', ['a', 'b'])
+    inst = ntpl(1, 2)
+    def impl(x):
+        return isinstance(inst, ntpl)
+    return impl
+
+class TestBuiltins(TestCase):
+
+    def run_nullary_func(self, pyfunc, flags):
+        cfunc = jit((), **flags)(pyfunc)
+        expected = pyfunc()
+        self.assertPreciseEqual(cfunc(), expected)
+
+    def test_abs(self, flags=forceobj_flags):
+        pyfunc = abs_usecase
+
+        cfunc = jit((types.int32,), **flags)(pyfunc)
+        for x in [-1, 0, 1]:
+            self.assertPreciseEqual(cfunc(x), pyfunc(x))
+
+        cfunc = jit((types.float32,), **flags)(pyfunc)
+        for x in [-1.1, 0.0, 1.1]:
+            self.assertPreciseEqual(cfunc(x), pyfunc(x), prec='single')
+
+        complex_values = [-1.1 + 0.5j, 0.0 + 0j, 1.1 + 3j,
+                          float('inf') + 1j * float('nan'),
+                          float('nan') - 1j * float('inf')]
+        cfunc = jit((types.complex64,), **flags)(pyfunc)
+        for x in complex_values:
+            self.assertPreciseEqual(cfunc(x), pyfunc(x), prec='single')
+        cfunc = jit((types.complex128,), **flags)(pyfunc)
+        for x in complex_values:
+            self.assertPreciseEqual(cfunc(x), pyfunc(x))
+
+        for unsigned_type in types.unsigned_domain:
+            unsigned_values = [0, 10, 2, 2 ** unsigned_type.bitwidth - 1]
+            cfunc = jit((unsigned_type,), **flags)(pyfunc)
+            for x in unsigned_values:
+                self.assertPreciseEqual(cfunc(x), pyfunc(x))
+
+    def test_abs_npm(self):
+        self.test_abs(flags=no_pyobj_flags)
+
+    def test_all(self, flags=forceobj_flags):
+        pyfunc = all_usecase
+
+        cfunc = jit((types.int32,types.int32), **flags)(pyfunc)
+        x_operands = [-1, 0, 1, None]
+        y_operands = [-1, 0, 1, None]
+        for x, y in itertools.product(x_operands, y_operands):
+            self.assertPreciseEqual(cfunc(x, y), pyfunc(x, y))
+
+    def test_all_npm(self):
+        with self.assertTypingError():
+            self.test_all(flags=no_pyobj_flags)
+
+    def test_any(self, flags=forceobj_flags):
+        pyfunc = any_usecase
+
+        cfunc = jit((types.int32,types.int32), **flags)(pyfunc)
+        x_operands = [-1, 0, 1, None]
+        y_operands = [-1, 0, 1, None]
+        for x, y in itertools.product(x_operands, y_operands):
+            self.assertPreciseEqual(cfunc(x, y), pyfunc(x, y))
+
+    def test_any_npm(self):
+        with self.assertTypingError():
+            self.test_any(flags=no_pyobj_flags)
+
+    def test_bool(self, flags=forceobj_flags):
+        pyfunc = bool_usecase
+
+        cfunc = jit((types.int32,), **flags)(pyfunc)
+        for x in [-1, 0, 1]:
+            self.assertPreciseEqual(cfunc(x), pyfunc(x))
+        cfunc = jit((types.float64,), **flags)(pyfunc)
+        for x in [0.0, -0.0, 1.5, float('inf'), float('nan')]:
+            self.assertPreciseEqual(cfunc(x), pyfunc(x))
+        cfunc = jit((types.complex128,), **flags)(pyfunc)
+        for x in [complex(0, float('inf')), complex(0, float('nan'))]:
+            self.assertPreciseEqual(cfunc(x), pyfunc(x))
+
+    def test_bool_npm(self):
+        self.test_bool(flags=no_pyobj_flags)
+
+    def test_bool_nonnumber(self, flags=forceobj_flags):
+        pyfunc = bool_usecase
+
+        cfunc = jit((types.string,), **flags)(pyfunc)
+        for x in ['x', '']:
+            self.assertPreciseEqual(cfunc(x), pyfunc(x))
+
+        cfunc = jit((types.Dummy('list'),), **flags)(pyfunc)
+        for x in [[1], []]:
+            self.assertPreciseEqual(cfunc(x), pyfunc(x))
+
+    def test_bool_nonnumber_npm(self):
+        with self.assertTypingError():
+            self.test_bool_nonnumber(flags=no_pyobj_flags)
+
+    def test_complex(self, flags=forceobj_flags):
+        pyfunc = complex_usecase
+
+        cfunc = jit((types.int32, types.int32), **flags)(pyfunc)
+
+        x_operands = [-1, 0, 1]
+        y_operands = [-1, 0, 1]
+        for x, y in itertools.product(x_operands, y_operands):
+            self.assertPreciseEqual(cfunc(x, y), pyfunc(x, y))
+
+    def test_complex_npm(self):
+        self.test_complex(flags=no_pyobj_flags)
+
+    def test_divmod_ints(self, flags=forceobj_flags):
+        pyfunc = divmod_usecase
+
+        cfunc = jit((types.int64, types.int64), **flags)(pyfunc)
+
+        def truncate_result(x, bits=64):
+            # Remove any extraneous bits (since Numba will return
+            # a 64-bit result by definition)
+            if x >= 0:
+                x &= (1 << (bits - 1)) - 1
+            return x
+
+        denominators = [1, 3, 7, 15, -1, -3, -7, -15, 2**63 - 1, -2**63]
+        numerators = denominators + [0]
+        for x, y, in itertools.product(numerators, denominators):
+            expected_quot, expected_rem = pyfunc(x, y)
+            quot, rem = cfunc(x, y)
+            f = truncate_result
+            self.assertPreciseEqual((f(quot), f(rem)),
+                                    (f(expected_quot), f(expected_rem)))
+
+        for x in numerators:
+            with self.assertRaises(ZeroDivisionError):
+                cfunc(x, 0)
+
+    def test_divmod_ints_npm(self):
+        self.test_divmod_ints(flags=no_pyobj_flags)
+
+    def test_divmod_floats(self, flags=forceobj_flags):
+        pyfunc = divmod_usecase
+
+        cfunc = jit((types.float64, types.float64), **flags)(pyfunc)
+
+        denominators = [1., 3.5, 1e100, -2., -7.5, -1e101,
+                        np.inf, -np.inf, np.nan]
+        numerators = denominators + [-0.0, 0.0]
+        for x, y, in itertools.product(numerators, denominators):
+            expected_quot, expected_rem = pyfunc(x, y)
+            quot, rem = cfunc(x, y)
+            self.assertPreciseEqual((quot, rem), (expected_quot, expected_rem))
+
+        for x in numerators:
+            with self.assertRaises(ZeroDivisionError):
+                cfunc(x, 0.0)
+
+    def test_divmod_floats_npm(self):
+        self.test_divmod_floats(flags=no_pyobj_flags)
+
+    def test_enumerate(self, flags=forceobj_flags):
+        self.run_nullary_func(enumerate_usecase, flags)
+
+    def test_enumerate_npm(self):
+        self.test_enumerate(flags=no_pyobj_flags)
+
+    def test_enumerate_start(self, flags=forceobj_flags):
+        self.run_nullary_func(enumerate_start_usecase, flags)
+
+    def test_enumerate_start_npm(self):
+        self.test_enumerate_start(flags=no_pyobj_flags)
+
+    def test_enumerate_start_invalid_start_type(self):
+        pyfunc = enumerate_invalid_start_usecase
+
+        cfunc = jit((), **forceobj_flags)(pyfunc)
+
+        with self.assertRaises(TypeError) as raises:
+            cfunc()
+
+        msg = "'float' object cannot be interpreted as an integer"
+        self.assertIn(msg, str(raises.exception))
+
+    def test_enumerate_start_invalid_start_type_npm(self):
+        pyfunc = enumerate_invalid_start_usecase
+        with self.assertRaises(errors.TypingError) as raises:
+            jit((), **no_pyobj_flags)(pyfunc)
+        msg = "Only integers supported as start value in enumerate"
+        self.assertIn(msg, str(raises.exception))
+
+    def test_filter(self, flags=forceobj_flags):
+        pyfunc = filter_usecase
+        argtys = (types.Dummy('list'), types.Dummy('function_ptr'))
+        cfunc = jit(argtys, **flags)(pyfunc)
+
+        filter_func = lambda x: x % 2
+        x = [0, 1, 2, 3, 4]
+        self.assertSequenceEqual(list(cfunc(x, filter_func)),
+                                 list(pyfunc(x, filter_func)))
+
+    def test_filter_npm(self):
+        with self.assertTypingError():
+            self.test_filter(flags=no_pyobj_flags)
+
+    def test_float(self, flags=forceobj_flags):
+        pyfunc = float_usecase
+
+        cfunc = jit((types.int32,), **flags)(pyfunc)
+        for x in [-1, 0, 1]:
+            self.assertPreciseEqual(cfunc(x), pyfunc(x))
+
+        cfunc = jit((types.float32,), **flags)(pyfunc)
+        for x in [-1.1, 0.0, 1.1]:
+            self.assertPreciseEqual(cfunc(x), pyfunc(x), prec='single')
+
+        cfunc = jit((types.string,), **flags)(pyfunc)
+        for x in ['-1.1', '0.0', '1.1', 'inf', '-inf', 'INF', '-INF']:
+            self.assertPreciseEqual(cfunc(x), pyfunc(x))
+
+    def test_float_npm(self):
+        with self.assertTypingError():
+            self.test_float(flags=no_pyobj_flags)
+
+    def test_float_string_literal(self):
+        pyfunc = float_inf_usecase
+        cfunc = njit(pyfunc)
+        for x in range(8):
+            self.assertPreciseEqual(cfunc(x), pyfunc(x))
+
+    def test_format(self, flags=forceobj_flags):
+        pyfunc = format_usecase
+
+        cfunc = jit((types.string, types.int32,), **flags)(pyfunc)
+        x = '{0}'
+        for y in [-1, 0, 1]:
+            self.assertPreciseEqual(cfunc(x, y), pyfunc(x, y))
+
+        cfunc = jit((types.string, types.float32,), **flags)(pyfunc)
+        x = '{0}'
+        for y in [-1.1, 0.0, 1.1]:
+            self.assertPreciseEqual(cfunc(x, y), pyfunc(x, y))
+
+        cfunc = jit((types.string, types.string,), **flags)(pyfunc)
+        x = '{0}'
+        for y in ['a', 'b', 'c']:
+            self.assertPreciseEqual(cfunc(x, y), pyfunc(x, y))
+
+    def test_format_npm(self):
+        with self.assertTypingError():
+            self.test_format(flags=no_pyobj_flags)
+
+    def test_globals(self, flags=forceobj_flags):
+        pyfunc = globals_usecase
+        cfunc = jit((), **flags)(pyfunc)
+        g = cfunc()
+        self.assertIs(g, globals())
+
+    def test_globals_npm(self):
+        with self.assertTypingError():
+            self.test_globals(flags=no_pyobj_flags)
+
+    def test_globals_jit(self, flags=forceobj_flags):
+        # Issue #416: weird behaviour of globals() in combination with
+        # the @jit decorator.
+        pyfunc = globals_usecase
+        jitted = jit(**flags)(pyfunc)
+        self.assertIs(jitted(), globals())
+        self.assertIs(jitted(), globals())
+
+    def test_globals_jit_npm(self):
+        with self.assertTypingError():
+            self.test_globals_jit(nopython=True)
+
+    def test_hex(self, flags=forceobj_flags):
+        pyfunc = hex_usecase
+
+        cfunc = jit((types.int32,), **flags)(pyfunc)
+        for x in [-1, 0, 1]:
+            self.assertPreciseEqual(cfunc(x), pyfunc(x))
+
+    def test_hex_npm(self):
+        with self.assertTypingError():
+            self.test_hex(flags=no_pyobj_flags)
+
+    def test_int_str(self):
+        pyfunc = str_usecase
+
+        small_inputs = [
+            1234,
+            1,
+            0,
+            10,
+            1000,
+        ]
+
+        large_inputs = [
+            123456789,
+            2222222,
+            1000000,
+            ~0x0
+        ]
+
+        args = [*small_inputs, *large_inputs]
+
+        typs = [
+            types.int8,
+            types.int16,
+            types.int32,
+            types.int64,
+            types.uint,
+            types.uint8,
+            types.uint16,
+            types.uint32,
+            types.uint64,
+        ]
+
+        for typ in typs:
+            cfunc = jit((typ,), **nrt_no_pyobj_flags)(pyfunc)
+            for v in args:
+                tp_info = np.iinfo(typ.key)
+                if not (tp_info.min <= v <= tp_info.max):
+                    continue
+                self.assertPreciseEqual(cfunc(typ(v)), pyfunc(typ(v)))
+
+                if typ.signed:
+                    self.assertPreciseEqual(cfunc(typ(-v)), pyfunc(typ(-v)))
+
+    def test_int(self, flags=forceobj_flags):
+        pyfunc = int_usecase
+
+        cfunc = jit((types.string, types.int32,), **flags)(pyfunc)
+
+        x_operands = ['-1', '0', '1', '10']
+        y_operands = [2, 8, 10, 16]
+        for x, y in itertools.product(x_operands, y_operands):
+            self.assertPreciseEqual(cfunc(x, y), pyfunc(x, y))
+
+    def test_int_npm(self):
+        with self.assertTypingError():
+            self.test_int(flags=no_pyobj_flags)
+
+    def test_iter_next(self, flags=forceobj_flags):
+        pyfunc = iter_next_usecase
+        cfunc = jit((types.UniTuple(types.int32, 3),), **flags)(pyfunc)
+        self.assertPreciseEqual(cfunc((1, 42, 5)), (1, 42))
+
+        cfunc = jit((types.UniTuple(types.int32, 1),), **flags)(pyfunc)
+        with self.assertRaises(StopIteration):
+            cfunc((1,))
+
+    def test_iter_next_npm(self):
+        self.test_iter_next(flags=no_pyobj_flags)
+
+    def test_locals(self, flags=forceobj_flags):
+        pyfunc = locals_usecase
+        with self.assertRaises(errors.ForbiddenConstruct):
+            jit((types.int64,), **flags)(pyfunc)
+
+    def test_locals_forceobj(self):
+        self.test_locals(flags=forceobj_flags)
+
+    def test_locals_npm(self):
+        with self.assertTypingError():
+            self.test_locals(flags=no_pyobj_flags)
+
+    def test_map(self, flags=forceobj_flags):
+        pyfunc = map_usecase
+        argtys = (types.Dummy('list'), types.Dummy('function_ptr'))
+        cfunc = jit(argtys, **flags)(pyfunc)
+
+        map_func = lambda x: x * 2
+        x = [0, 1, 2, 3, 4]
+        self.assertSequenceEqual(list(cfunc(x, map_func)),
+                                 list(pyfunc(x, map_func)))
+
+    def test_map_npm(self):
+        with self.assertTypingError():
+            self.test_map(flags=no_pyobj_flags)
+
+    #
+    # min() and max()
+    #
+
+    def check_minmax_1(self, pyfunc, flags):
+        cfunc = jit((types.int32, types.int32), **flags)(pyfunc)
+
+        x_operands = [-1, 0, 1]
+        y_operands = [-1, 0, 1]
+        for x, y in itertools.product(x_operands, y_operands):
+            self.assertPreciseEqual(cfunc(x, y), pyfunc(x, y))
+
+    def test_max_1(self, flags=forceobj_flags):
+        """
+        max(*args)
+        """
+        self.check_minmax_1(max_usecase1, flags)
+
+    def test_min_1(self, flags=forceobj_flags):
+        """
+        min(*args)
+        """
+        self.check_minmax_1(min_usecase1, flags)
+
+    def test_max_npm_1(self):
+        self.test_max_1(flags=no_pyobj_flags)
+
+    def test_min_npm_1(self):
+        self.test_min_1(flags=no_pyobj_flags)
+
+    def check_minmax_2(self, pyfunc, flags):
+        cfunc = jit((types.int32, types.int32), **flags)(pyfunc)
+
+        x_operands = [-1, 0, 1]
+        y_operands = [-1, 0, 1]
+        for x, y in itertools.product(x_operands, y_operands):
+            self.assertPreciseEqual(cfunc(x, y), pyfunc(x, y))
+
+    def test_max_2(self, flags=forceobj_flags):
+        """
+        max(list)
+        """
+        self.check_minmax_2(max_usecase2, flags)
+
+    def test_min_2(self, flags=forceobj_flags):
+        """
+        min(list)
+        """
+        self.check_minmax_2(min_usecase2, flags)
+
+    def test_max_npm_2(self):
+        with self.assertTypingError():
+            self.test_max_2(flags=no_pyobj_flags)
+
+    def test_min_npm_2(self):
+        with self.assertTypingError():
+            self.test_min_2(flags=no_pyobj_flags)
+
+    def check_minmax_3(self, pyfunc, flags):
+        def check(argty):
+            cfunc = jit((argty,), **flags)(pyfunc)
+            # Check that the algorithm matches Python's with a non-total order
+            tup = (1.5, float('nan'), 2.5)
+            for val in [tup, tup[::-1]]:
+                self.assertPreciseEqual(cfunc(val), pyfunc(val))
+
+        check(types.UniTuple(types.float64, 3))
+        check(types.Tuple((types.float32, types.float64, types.float32)))
+
+    def test_max_3(self, flags=forceobj_flags):
+        """
+        max(tuple)
+        """
+        self.check_minmax_3(max_usecase3, flags)
+
+    def test_min_3(self, flags=forceobj_flags):
+        """
+        min(tuple)
+        """
+        self.check_minmax_3(min_usecase3, flags)
+
+    def test_max_npm_3(self):
+        self.test_max_3(flags=no_pyobj_flags)
+
+    def test_min_npm_3(self):
+        self.test_min_3(flags=no_pyobj_flags)
+
+    def check_min_max_invalid_types(self, pyfunc, flags=forceobj_flags):
+        cfunc = jit((types.int32, types.Dummy('list'),), **flags)(pyfunc)
+        cfunc(1, [1])
+
+    def test_max_1_invalid_types(self):
+        with self.assertRaises(TypeError):
+            self.check_min_max_invalid_types(max_usecase1)
+
+    def test_max_1_invalid_types_npm(self):
+        with self.assertTypingError():
+            self.check_min_max_invalid_types(max_usecase1, flags=no_pyobj_flags)
+
+    def test_min_1_invalid_types(self):
+        with self.assertRaises(TypeError):
+            self.check_min_max_invalid_types(min_usecase1)
+
+    def test_min_1_invalid_types_npm(self):
+        with self.assertTypingError():
+            self.check_min_max_invalid_types(min_usecase1, flags=no_pyobj_flags)
+
+    def check_minmax_bool1(self, pyfunc, flags):
+        cfunc = jit((types.bool_, types.bool_), **flags)(pyfunc)
+
+        operands = (False, True)
+        for x, y in itertools.product(operands, operands):
+            self.assertPreciseEqual(cfunc(x, y), pyfunc(x, y))
+
+    def test_max_bool1(self, flags=forceobj_flags):
+        # tests max(<booleans>)
+        self.check_minmax_bool1(max_usecase1, flags)
+
+    def test_min_bool1(self, flags=forceobj_flags):
+        # tests min(<booleans>)
+        self.check_minmax_bool1(min_usecase1, flags)
+
+    # Test that max(1) and min(1) fail
+
+    def check_min_max_unary_non_iterable(self, pyfunc, flags=forceobj_flags):
+        cfunc = jit((types.int32,), **flags)(pyfunc)
+        cfunc(1)
+
+    def test_max_unary_non_iterable(self):
+        with self.assertRaises(TypeError):
+            self.check_min_max_unary_non_iterable(max_usecase3)
+
+    def test_max_unary_non_iterable_npm(self):
+        with self.assertTypingError():
+            self.check_min_max_unary_non_iterable(max_usecase3)
+
+    def test_min_unary_non_iterable(self):
+        with self.assertRaises(TypeError):
+            self.check_min_max_unary_non_iterable(min_usecase3)
+
+    def test_min_unary_non_iterable_npm(self):
+        with self.assertTypingError():
+            self.check_min_max_unary_non_iterable(min_usecase3)
+
+    # Test that max(()) and min(()) fail
+
+    def check_min_max_empty_tuple(self, pyfunc, func_name):
+        with self.assertTypingError() as raises:
+            jit((), **no_pyobj_flags)(pyfunc)
+        self.assertIn("%s() argument is an empty tuple" % func_name,
+                      str(raises.exception))
+
+    def test_max_empty_tuple(self):
+        self.check_min_max_empty_tuple(max_usecase4, "max")
+
+    def test_min_empty_tuple(self):
+        self.check_min_max_empty_tuple(min_usecase4, "min")
+
+
+    def test_oct(self, flags=forceobj_flags):
+        pyfunc = oct_usecase
+
+        cfunc = jit((types.int32,), **flags)(pyfunc)
+        for x in [-8, -1, 0, 1, 8]:
+            self.assertPreciseEqual(cfunc(x), pyfunc(x))
+
+    def test_oct_npm(self):
+        with self.assertTypingError():
+            self.test_oct(flags=no_pyobj_flags)
+
+    def test_reduce(self, flags=forceobj_flags):
+        pyfunc = reduce_usecase
+        argtys = (types.Dummy('function_ptr'), types.Dummy('list'))
+        cfunc = jit(argtys, **flags)(pyfunc)
+
+        reduce_func = lambda x, y: x + y
+
+        x = range(10)
+        self.assertPreciseEqual(cfunc(reduce_func, x), pyfunc(reduce_func, x))
+
+        x = [x + x/10.0 for x in range(10)]
+        self.assertPreciseEqual(cfunc(reduce_func, x), pyfunc(reduce_func, x))
+
+        x = [complex(x, x) for x in range(10)]
+        self.assertPreciseEqual(cfunc(reduce_func, x), pyfunc(reduce_func, x))
+
+    def test_reduce_npm(self):
+        with self.assertTypingError():
+            self.test_reduce(flags=no_pyobj_flags)
+
+    def test_round1(self, flags=forceobj_flags):
+        pyfunc = round_usecase1
+
+        for tp in (types.float64, types.float32):
+            cfunc = jit((tp,), **flags)(pyfunc)
+            values = [-1.6, -1.5, -1.4, -0.5, 0.0, 0.1, 0.5, 0.6, 1.4, 1.5, 5.0]
+            values += [-0.1, -0.0]
+            for x in values:
+                self.assertPreciseEqual(cfunc(x), pyfunc(x))
+
+    def test_round1_npm(self):
+        self.test_round1(flags=no_pyobj_flags)
+
+    def test_round2(self, flags=forceobj_flags):
+        pyfunc = round_usecase2
+
+        for tp in (types.float64, types.float32):
+            prec = 'single' if tp is types.float32 else 'exact'
+            cfunc = jit((tp, types.int32), **flags)(pyfunc)
+            for x in [0.0, 0.1, 0.125, 0.25, 0.5, 0.75, 1.25,
+                      1.5, 1.75, 2.25, 2.5, 2.75, 12.5, 15.0, 22.5]:
+                for n in (-1, 0, 1, 2):
+                    self.assertPreciseEqual(cfunc(x, n), pyfunc(x, n),
+                                            prec=prec)
+                    expected = pyfunc(-x, n)
+                    self.assertPreciseEqual(cfunc(-x, n), pyfunc(-x, n),
+                                            prec=prec)
+
+    def test_round2_npm(self):
+        self.test_round2(flags=no_pyobj_flags)
+
+    def test_sum_objmode(self, flags=forceobj_flags):
+        pyfunc = sum_usecase
+
+        cfunc = jit((types.Dummy('list'),), **flags)(pyfunc)
+
+        x = range(10)
+        self.assertPreciseEqual(cfunc(x), pyfunc(x))
+
+        x = [x + x/10.0 for x in range(10)]
+        self.assertPreciseEqual(cfunc(x), pyfunc(x))
+
+        x = [complex(x, x) for x in range(10)]
+        self.assertPreciseEqual(cfunc(x), pyfunc(x))
+
+    def test_sum(self):
+        # In Python 3.8+ "start" can be specified as a kwarg, so test that too
+        sum_default = njit(sum_usecase)
+        sum_kwarg = njit(sum_kwarg_usecase)
+
+        @njit
+        def sum_range(sz, start=0):
+            tmp = range(sz)
+            ret = sum(tmp, start)
+            return sum(tmp, start=start), ret
+
+        ntpl = namedtuple('ntpl', ['a', 'b'])
+
+        # check call with default kwarg, start=0
+        def args():
+            yield [*range(10)]
+            yield [x + x/10.0 for x in range(10)]
+            yield [x * 1j for x in range(10)]
+            yield (1, 2, 3)
+            yield (1, 2, 3j)
+            # uints will likely end up as floats as `start` is signed, so just
+            # test mixed signed ints
+            yield (np.int64(32), np.int32(2), np.int8(3))
+            tl = typed.List(range(5))
+            yield tl
+            yield np.ones(5)
+            yield ntpl(100, 200)
+            yield ntpl(100, 200j)
+
+        for x in args():
+            self.assertPreciseEqual(sum_default(x), sum_default.py_func(x))
+
+        # Check the uint use case, as start is signed, NumPy will end up with
+        # a float result whereas Numba will end up with an int (see integer
+        # typing NBEP).
+        x = (np.uint64(32), np.uint32(2), np.uint8(3))
+        self.assertEqual(sum_default(x), sum_default.py_func(x))
+
+        # check call with changing default kwarg, start
+        def args_kws():
+            yield [*range(10)], 12
+            yield [x + x/10.0 for x in range(10)], 19j
+            yield [x * 1j for x in range(10)], -2
+            yield (1, 2, 3), 9
+            yield (1, 2, 3j), -0
+            # uints will likely end up as floats as `start` is signed, so just
+            # test mixed signed ints
+            yield (np.int64(32), np.int32(2), np.int8(3)), np.uint32(7)
+            tl = typed.List(range(5))
+            yield tl, 100
+            yield np.ones((5, 5)), 10 * np.ones((5,))
+            yield ntpl(100, 200), -50
+            yield ntpl(100, 200j), 9
+
+        for x, start in args_kws():
+            self.assertPreciseEqual(sum_kwarg(x, start=start),
+                                    sum_kwarg.py_func(x, start=start))
+
+        # check call with range()
+        for start in range(-3, 4):
+            for sz in range(-3, 4):
+                self.assertPreciseEqual(sum_range(sz, start=start),
+                                        sum_range.py_func(sz, start=start))
+
+    def test_sum_exceptions(self):
+        sum_default = njit(sum_usecase)
+        sum_kwarg = njit(sum_kwarg_usecase)
+
+        # check start as string/bytes/bytearray is error
+        msg = "sum() can't sum {}"
+
+        with self.assertRaises(errors.TypingError) as raises:
+            sum_kwarg((1, 2, 3), 'a')
+
+        self.assertIn(msg.format('strings'), str(raises.exception))
+
+        with self.assertRaises(errors.TypingError) as raises:
+            sum_kwarg((1, 2, 3), b'123')
+
+        self.assertIn(msg.format('bytes'), str(raises.exception))
+
+        with self.assertRaises(errors.TypingError) as raises:
+            sum_kwarg((1, 2, 3), bytearray(b'123'))
+
+        self.assertIn(msg.format('bytearray'), str(raises.exception))
+
+        # check invalid type has no impl
+        with self.assertRaises(errors.TypingError) as raises:
+            sum_default('abcd')
+
+        self.assertIn('No implementation', str(raises.exception))
+
+    def test_truth(self):
+        pyfunc = truth_usecase
+        cfunc = jit(nopython=True)(pyfunc)
+
+        self.assertEqual(pyfunc(True), cfunc(True))
+        self.assertEqual(pyfunc(False), cfunc(False))
+
+    def test_type_unary(self):
+        # Test type(val) and type(val)(other_val)
+        pyfunc = type_unary_usecase
+        cfunc = jit(nopython=True)(pyfunc)
+
+        def check(*args):
+            expected = pyfunc(*args)
+            self.assertPreciseEqual(cfunc(*args), expected)
+
+        check(1.5, 2)
+        check(1, 2.5)
+        check(1.5j, 2)
+        check(True, 2)
+        check(2.5j, False)
+
+    def test_zip(self, flags=forceobj_flags):
+        self.run_nullary_func(zip_usecase, flags)
+
+    def test_zip_npm(self):
+        self.test_zip(flags=no_pyobj_flags)
+
+    def test_zip_1(self, flags=forceobj_flags):
+        self.run_nullary_func(zip_1_usecase, flags)
+
+    def test_zip_1_npm(self):
+        self.test_zip_1(flags=no_pyobj_flags)
+
+    def test_zip_3(self, flags=forceobj_flags):
+        self.run_nullary_func(zip_3_usecase, flags)
+
+    def test_zip_3_npm(self):
+        self.test_zip_3(flags=no_pyobj_flags)
+
+    def test_zip_0(self, flags=forceobj_flags):
+        self.run_nullary_func(zip_0_usecase, flags)
+
+    def test_zip_0_npm(self):
+        self.test_zip_0(flags=no_pyobj_flags)
+
+    def test_zip_first_exhausted(self, flags=forceobj_flags):
+        """
+        Test side effect to the input iterators when a left iterator has been
+        exhausted before the ones on the right.
+        """
+        self.run_nullary_func(zip_first_exhausted, flags)
+
+    def test_zip_first_exhausted_npm(self):
+        self.test_zip_first_exhausted(flags=nrt_no_pyobj_flags)
+
+    def test_pow_op_usecase(self):
+        args = [
+            (2, 3),
+            (2.0, 3),
+            (2, 3.0),
+            (2j, 3.0j),
+        ]
+
+        for x, y in args:
+            argtys = (typeof(x), typeof(y))
+            cfunc = jit(argtys, **no_pyobj_flags)(pow_op_usecase)
+            r = cfunc(x, y)
+            self.assertPreciseEqual(r, pow_op_usecase(x, y))
+
+    def test_pow_usecase(self):
+        args = [
+            (2, 3),
+            (2.0, 3),
+            (2, 3.0),
+            (2j, 3.0j),
+        ]
+
+        for x, y in args:
+            argtys = (typeof(x), typeof(y))
+            cfunc = jit(argtys, **no_pyobj_flags)(pow_usecase)
+            r = cfunc(x, y)
+            self.assertPreciseEqual(r, pow_usecase(x, y))
+
+    def _check_min_max(self, pyfunc):
+        cfunc = njit()(pyfunc)
+        expected = pyfunc()
+        got = cfunc()
+        self.assertPreciseEqual(expected, got)
+
+    def test_min_max_iterable_input(self):
+
+        @njit
+        def frange(start, stop, step):
+            i = start
+            while i < stop:
+                yield i
+                i += step
+
+        def sample_functions(op):
+            yield lambda: op(range(10))
+            yield lambda: op(range(4, 12))
+            yield lambda: op(range(-4, -15, -1))
+            yield lambda: op([6.6, 5.5, 7.7])
+            yield lambda: op([(3, 4), (1, 2)])
+            yield lambda: op(frange(1.1, 3.3, 0.1))
+            yield lambda: op([np.nan, -np.inf, np.inf, np.nan])
+            yield lambda: op([(3,), (1,), (2,)])
+
+        for fn in sample_functions(op=min):
+            self._check_min_max(fn)
+
+        for fn in sample_functions(op=max):
+            self._check_min_max(fn)
+
+
+class TestOperatorMixedTypes(TestCase):
+
+    def test_eq_ne(self):
+        for opstr in ('eq', 'ne'):
+            op = getattr(operator, opstr)
+
+            @njit
+            def func(a, b):
+                return op(a, b)
+
+            # all these things should evaluate to being equal or not, all should
+            # survive typing.
+            things = (1, 0, True, False, 1.0, 2.0, 1.1, 1j, None, "", "1")
+            for x, y in itertools.product(things, things):
+                self.assertPreciseEqual(func.py_func(x, y), func(x, y))
+
+    def test_cmp(self):
+        for opstr in ('gt', 'lt', 'ge', 'le', 'eq', 'ne'):
+            op = getattr(operator, opstr)
+            @njit
+            def func(a, b):
+                return op(a, b)
+
+            # numerical things should all be comparable
+            things = (1, 0, True, False, 1.0, 0.0, 1.1)
+            for x, y in itertools.product(things, things):
+                expected = func.py_func(x, y)
+                got = func(x, y)
+                message = ("%s %s %s does not match between Python and Numba"
+                           % (x, opstr, y))
+                self.assertEqual(expected, got, message)
+
+
+class TestIsinstanceBuiltin(TestCase):
+    def test_isinstance(self):
+        pyfunc = isinstance_usecase
+        cfunc = jit(nopython=True)(pyfunc)
+
+        inputs = (
+            3,              # int
+            5.0,            # float
+            "Hello",        # string
+            b'world',       # bytes
+            1j,             # complex
+            [1, 2, 3],      # list
+            (1, 3, 3, 3),   # UniTuple
+            set([1, 2]),    # set
+            (1, 'nba', 2),  # Heterogeneous Tuple
+            # {'hello': 2},   # dict - doesn't work as input
+            None,
+        )
+
+        for inpt in inputs:
+            expected = pyfunc(inpt)
+            got = cfunc(inpt)
+            self.assertEqual(expected, got)
+
+    def test_isinstance_dict(self):
+        # Tests typed.Dict and LiteralStrKeyDict
+        pyfunc = isinstance_dict
+        cfunc = jit(nopython=True)(pyfunc)
+        self.assertEqual(pyfunc(), cfunc())
+
+    def test_isinstance_issue9125(self):
+        pyfunc = invalid_isinstance_usecase_phi_nopropagate2
+        cfunc = jit(nopython=True)(pyfunc)
+        self.assertEqual(pyfunc(3), cfunc(3))
+
+    def test_isinstance_numba_types(self):
+        # This makes use of type aliasing between python scalars and NumPy
+        # scalars, see also test_numba_types()
+        pyfunc = isinstance_usecase_numba_types
+        cfunc = jit(nopython=True)(pyfunc)
+
+        inputs = (
+            (types.int32(1), 'int32'),
+            (types.int64(2), 'int64'),
+            (types.float32(3.0), 'float32'),
+            (types.float64(4.0), 'float64'),
+            (types.complex64(5j), 'no match'),
+            (typed.List([1, 2]), 'typed list'),
+            (typed.Dict.empty(types.int64, types.int64), 'typed dict')
+        )
+
+        for inpt, expected in inputs:
+            got = cfunc(inpt)
+            self.assertEqual(expected, got)
+
+    def test_isinstance_numba_types_2(self):
+        pyfunc = isinstance_usecase_numba_types_2
+        cfunc = jit(nopython=True)(pyfunc)
+        self.assertEqual(pyfunc(), cfunc())
+
+    def test_isinstance_invalid_type(self):
+        pyfunc = isinstance_usecase_invalid_type
+        cfunc = jit(nopython=True)(pyfunc)
+
+        # valid type
+        self.assertTrue(cfunc(3.4))
+
+        # invalid type
+        msg = 'Cannot infer numba type of python type'
+
+        with self.assertRaises(errors.TypingError) as raises:
+            cfunc(100)
+
+        self.assertIn(msg, str(raises.exception))
+
+    def test_isinstance_exceptions(self):
+        fns = [
+            (invalid_isinstance_usecase,
+             'Cannot infer numba type of python type'),
+            (invalid_isinstance_usecase_phi_nopropagate,
+             ('isinstance() cannot determine the type of variable "z" due to a '
+             'branch.')),
+            (invalid_isinstance_optional_usecase,
+             ('isinstance() cannot determine the type of variable "z" due to a '
+             'branch.')),
+            (invalid_isinstance_unsupported_type_usecase(),
+             ('isinstance() does not support variables of type "ntpl(')),
+        ]
+
+        for fn, msg in fns:
+            fn = njit(fn)
+
+            with self.assertRaises(errors.TypingError) as raises:
+                fn(100)
+
+            self.assertIn(msg, str(raises.exception))
+
+    def test_combinations(self):
+        # Combinatorically test common classes and instances
+        def gen_w_arg(clazz_type):
+            def impl(x):
+                return isinstance(x, clazz_type)
+            return impl
+
+        clazz_types = (int, float, complex, str, list, tuple, bytes, set, range,
+                       np.int8, np.float32,)
+        instances = (1, 2.3, 4j, '5', [6,], (7,), b'8', {9,}, None,
+                     (10, 11, 12), (13, 'a', 14j), np.array([15, 16, 17]),
+                     np.int8(18), np.float32(19),
+                     typed.Dict.empty(types.unicode_type, types.float64),
+                     typed.List.empty_list(types.complex128), np.ones(4))
+
+        for ct in clazz_types:
+            fn = njit(gen_w_arg(ct))
+            for x in instances:
+                expected = fn.py_func(x)
+                got = fn(x)
+                self.assertEqual(got, expected)
+
+    def test_numba_types(self):
+        # Check types which are Numba types, this would break without the jit
+        # decorator in all cases except numba.typed containers.
+        def gen_w_arg(clazz_type):
+            def impl():
+                return isinstance(1, clazz_type)
+            return impl
+
+        clazz_types = (types.Integer, types.Float, types.Array,)
+
+        msg = "Numba type classes.*are not supported"
+        for ct in clazz_types:
+            fn = njit(gen_w_arg(ct))
+            with self.assertRaises(errors.TypingError) as raises:
+                fn()
+            self.assertRegex(str(raises.exception), msg)
+
+    def test_python_numpy_scalar_alias_problem(self):
+        # There's a problem due to Python and NumPy scalars being aliased in the
+        # type system. This is because e.g. int scalar values and NumPy np.intp
+        # type alias to types.intp. This test merely records this fact.
+
+        @njit
+        def foo():
+            return isinstance(np.intp(10), int)
+
+        self.assertEqual(foo(), True)
+        self.assertEqual(foo.py_func(), False)
+
+        @njit
+        def bar():
+            return isinstance(1, np.intp)
+
+        self.assertEqual(bar(), True)
+        self.assertEqual(bar.py_func(), False)
+
+    def test_branch_prune(self):
+        # Check that isinstance branches are pruned allowing otherwise
+        # impossible type specific specialisation.
+
+        @njit
+        def foo(x):
+            if isinstance(x, str):
+                return x + 'some_string'
+            elif isinstance(x, complex):
+                return np.imag(x)
+            elif isinstance(x, tuple):
+                return len(x)
+            else:
+                assert 0
+
+        for x in ('string', 1 + 2j, ('a', 3, 4j)):
+            expected = foo.py_func(x)
+            got = foo(x)
+            self.assertEqual(got, expected)
+
+    def test_branch_prune_and_bind_to_sig(self):
+        # see issue 9795
+        @register_jitable
+        def f(x, y):
+            return x + y
+
+        @njit
+        def call_f(x):
+            if isinstance(x, tuple):
+                return f(*x)
+            else:
+                return f(x)
+
+        # The issue is that without isinstance and branch pruning working
+        # correctly, an attempt will be made to bind the function `f` with
+        # argument `x`. If `x` is a Tuple type, this will fail on the `else`
+        # branch as `f` takes two arguments opposed to one.
+        x = (1, 2)
+        self.assertEqual(call_f(x), call_f.py_func(x))
+
+
+        # This should raise as partial type inference and branch pruning will
+        # remove the `f(*x)` branch and just leave `f(x)`, which then won't
+        # bind because `f` takes two arguments and only one is supplied.
+        with self.assertRaises(errors.TypingError) as raises:
+            call_f(1)
+
+        msg = str(raises.exception)
+        self.assertIn("Cannot bind", msg)
+        self.assertIn("TypeError: missing a required argument: 'y'", msg)
+
+    def test_branch_prune_non_tuples_as_star_arg(self):
+
+        # see issue 9795
+        @register_jitable
+        def f(x, y):
+            return x + y
+
+        @register_jitable
+        def g(x):
+            return x
+
+        @njit
+        def call_f(x):
+            if isinstance(x, tuple):
+                return f(*x)
+            else:
+                return g(x)
+
+        # The issue is that without isinstance and branch pruning working
+        # correctly, an attempt will be made to bind the function `f` with
+        # argument `x`. If `x` is a non-tuple type `*x` will not bind to the
+        # signature of `f`.
+        x = 1
+        self.assertEqual(call_f(x), call_f.py_func(x))
+
+    def test_branch_prune_literal_as_star_arg(self):
+
+        # see issue 9795
+        @register_jitable
+        def f(x, y):
+            return x + y
+
+        @register_jitable
+        def g(x):
+            return x
+
+        one = 1
+        @njit
+        def call_f():
+            x = one
+            if isinstance(x, tuple):
+                return f(*x)
+            else:
+                return g(x)
+
+        # The issue is that without isinstance and branch pruning working
+        # correctly, an attempt will be made to bind the function `f` with
+        # argument `x`. If `x` is a non-tuple const value type `*x` will not
+        # bind to the signature of `f`.
+        self.assertEqual(call_f(), call_f.py_func())
+
+
+class TestGetattrBuiltin(MemoryLeakMixin, TestCase):
+    # Tests the getattr() builtin
+
+    def test_getattr_func_retty(self):
+
+        @njit
+        def foo(x):
+            attr = getattr(x, '__hash__')
+            return attr()
+
+        for x in (1, 2.34, (5, 6, 7)):
+            self.assertPreciseEqual(foo(x), foo.py_func(x))
+
+    def test_getattr_value_retty(self):
+
+        @njit
+        def foo(x):
+            return getattr(x, 'ndim')
+
+        for x in range(3):
+            tmp = np.empty((1, ) * x)
+            self.assertPreciseEqual(foo(tmp), foo.py_func(tmp))
+
+    def test_getattr_module_obj(self):
+        # Consts on modules work ok
+
+        @njit
+        def foo():
+            return getattr(np, 'pi')
+
+        self.assertPreciseEqual(foo(), foo.py_func())
+
+    def test_getattr_module_obj_not_implemented(self):
+        # Functions on modules do not work at present
+
+        @njit
+        def foo():
+            return getattr(np, 'cos')(1)
+
+        with self.assertRaises(errors.TypingError) as raises:
+            foo()
+
+        msg = "Returning function objects is not implemented"
+        self.assertIn(msg, str(raises.exception))
+
+    def test_getattr_raises_attribute_error(self):
+
+        invalid_attr = '__not_a_valid_attr__'
+
+        @njit
+        def foo(x):
+            return getattr(x, invalid_attr)
+
+        with self.assertRaises(AttributeError) as raises:
+            foo(1.23)
+
+        self.assertIn(f"'float64' has no attribute '{invalid_attr}'",
+                      str(raises.exception))
+
+    def test_getattr_with_default(self):
+        # Checks returning a default works
+
+        @njit
+        def foo(x, default):
+            return getattr(x, '__not_a_valid_attr__', default)
+
+        for x, y in zip((1, 2.34, (5, 6, 7),), (None, 20, 'some_string')):
+            self.assertPreciseEqual(foo(x, y), foo.py_func(x, y))
+
+    def test_getattr_non_literal_str(self):
+
+        @njit
+        def foo(x, nonliteral_str):
+            return getattr(x, nonliteral_str)
+
+        with self.assertRaises(errors.TypingError) as raises:
+            foo(1, '__hash__')
+
+        msg = "argument 'name' must be a literal string"
+        self.assertIn(msg, str(raises.exception))
+
+    def test_getattr_no_optional_type_generated(self):
+
+        @njit
+        def default_hash():
+            return 12345
+
+        @njit
+        def foo():
+            hash_func = getattr(np.ones(1), "__not_a_valid_attr__",
+                                default_hash)
+            return hash_func() # Optionals have no call support
+
+        self.assertPreciseEqual(foo(), foo.py_func())
+
+
+class TestHasattrBuiltin(MemoryLeakMixin, TestCase):
+    # Tests the hasattr() builtin
+
+    def test_hasattr(self):
+
+        @njit
+        def foo(x):
+            return hasattr(x, '__hash__'), hasattr(x, '__not_a_valid_attr__')
+
+        ty = types.int64
+        for x in (1, 2.34, (5, 6, 7), typed.Dict.empty(ty, ty),
+                  typed.List.empty_list(ty), np.ones(4), 'ABC'):
+            self.assertPreciseEqual(foo(x), foo.py_func(x))
+
+    def test_hasattr_non_const_attr(self):
+        # This tests that an error is raised in the case that a hasattr() call
+        # is made on an attribute that cannot be resolved as a compile time
+        # constant (there's a phi in the way!).
+
+        @njit
+        def foo(pred):
+            if pred > 3:
+                attr = "__hash__"
+            else:
+                attr = "__str__"
+
+            hasattr(1, attr)
+
+        with self.assertRaises(errors.NumbaTypeError) as raises:
+            foo(6)
+
+        msg = ('hasattr() cannot determine the type of variable '
+               '"attr" due to a branch.')
+        self.assertIn(msg, str(raises.exception))
+
+
+class TestStrAndReprBuiltin(MemoryLeakMixin, TestCase):
+
+    def test_str_default(self):
+
+        @njit
+        def foo():
+            return str()
+
+        self.assertEqual(foo(), foo.py_func())
+
+    def test_str_object_kwarg(self):
+
+        @njit
+        def foo(x):
+            return str(object=x)
+
+        value = "a string"
+        self.assertEqual(foo(value), foo.py_func(value))
+
+    def test_str_calls_dunder_str(self):
+
+        @njit
+        def foo(x):
+            return str(x)
+
+        Dummy, DummyType = self.make_dummy_type()
+        dummy = Dummy()
+        string_repr = "this is the dummy object str"
+        Dummy.__str__= lambda inst: string_repr
+
+        @overload_method(DummyType, "__str__")
+        def ol_dummy_string(dummy):
+            def impl(dummy):
+                return string_repr
+            return impl
+
+        @overload_method(DummyType, "__repr__")
+        def ol_dummy_repr(dummy):
+            def impl(dummy):
+                return "SHOULD NOT BE CALLED"
+            return impl
+
+        self.assertEqual(foo(dummy), foo.py_func(dummy))
+
+    def test_str_falls_back_to_repr(self):
+
+        @njit
+        def foo(x):
+            return str(x)
+
+        Dummy, DummyType = self.make_dummy_type()
+        dummy = Dummy()
+        string_repr = "this is the dummy object repr"
+        Dummy.__repr__= lambda inst: string_repr
+
+        @overload_method(DummyType, "__repr__")
+        def ol_dummy_repr(dummy):
+            def impl(dummy):
+                return string_repr
+            return impl
+
+        self.assertEqual(foo(dummy), foo.py_func(dummy))
+
+    def test_repr(self):
+        @njit
+        def foo(x):
+            return repr(x), x
+
+        for x in ("abc", False, 123):
+            self.assertEqual(foo(x), foo.py_func(x))
+
+    def test_repr_fallback(self):
+        # checks str/repr fallback, there's no overloaded __str__ or __repr__
+        # for the dummy type so it has to use generic '<object type:(type)>'
+        # string for the `repr` call.
+
+        Dummy, DummyType = self.make_dummy_type()
+        dummy = Dummy()
+        string_repr = f"<object type:{typeof(dummy)}>"
+        Dummy.__repr__= lambda inst: string_repr
+
+        @box(DummyType)
+        def box_dummy(typ, obj, c):
+            clazobj = c.pyapi.unserialize(c.pyapi.serialize_object(Dummy))
+            return c.pyapi.call_function_objargs(clazobj, ())
+
+        @njit
+        def foo(x):
+            return str(x)
+
+        self.assertEqual(foo(dummy), foo.py_func(dummy))
+
+
+
+if __name__ == '__main__':
+    unittest.main()

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

@@ -0,0 +1,189 @@
+import array
+import numpy as np
+
+from numba import jit, njit
+import numba.core.typing.cffi_utils as cffi_support
+from numba.core import types, errors
+from numba.tests.support import TestCase, skip_unless_cffi
+
+
+import numba.tests.cffi_usecases as mod
+import unittest
+
+
+enable_pyobj_flags = {'forceobj': True}
+no_pyobj_flags = {'nopython': True}
+
+
+@skip_unless_cffi
+class TestCFFI(TestCase):
+
+    # Need to run the tests serially because of race conditions in
+    # cffi's OOL mode.
+    _numba_parallel_test_ = False
+
+    def setUp(self):
+        mod.init()
+        mod.init_ool()
+
+    def test_type_map(self):
+        signature = cffi_support.map_type(mod.ffi.typeof(mod.cffi_sin))
+        self.assertEqual(len(signature.args), 1)
+        self.assertEqual(signature.args[0], types.double)
+
+    def _test_function(self, pyfunc, flags=enable_pyobj_flags):
+        cfunc = jit((types.double,), **flags)(pyfunc)
+
+        for x in [-1.2, -1, 0, 0.1, 3.14]:
+            self.assertPreciseEqual(pyfunc(x), cfunc(x))
+
+    def test_sin_function(self):
+        self._test_function(mod.use_cffi_sin)
+
+    def test_bool_function_ool(self):
+        pyfunc = mod.use_cffi_boolean_true
+        cfunc = njit((),)(pyfunc)
+        self.assertEqual(pyfunc(), True)
+        self.assertEqual(cfunc(), True)
+
+    def test_sin_function_npm(self):
+        self._test_function(mod.use_cffi_sin, flags=no_pyobj_flags)
+
+    def test_sin_function_ool(self, flags=enable_pyobj_flags):
+        self._test_function(mod.use_cffi_sin_ool)
+
+    def test_sin_function_npm_ool(self):
+        self._test_function(mod.use_cffi_sin_ool, flags=no_pyobj_flags)
+
+    def test_two_funcs(self):
+        # Check that two constant functions don't get mixed up.
+        self._test_function(mod.use_two_funcs)
+
+    def test_two_funcs_ool(self):
+        self._test_function(mod.use_two_funcs_ool)
+
+    def test_function_pointer(self):
+        pyfunc = mod.use_func_pointer
+        cfunc = jit(nopython=True)(pyfunc)
+        for (fa, fb, x) in [
+            (mod.cffi_sin, mod.cffi_cos, 1.0),
+            (mod.cffi_sin, mod.cffi_cos, -1.0),
+            (mod.cffi_cos, mod.cffi_sin, 1.0),
+            (mod.cffi_cos, mod.cffi_sin, -1.0),
+            (mod.cffi_sin_ool, mod.cffi_cos_ool, 1.0),
+            (mod.cffi_sin_ool, mod.cffi_cos_ool, -1.0),
+            (mod.cffi_cos_ool, mod.cffi_sin_ool, 1.0),
+            (mod.cffi_cos_ool, mod.cffi_sin_ool, -1.0),
+            (mod.cffi_sin, mod.cffi_cos_ool, 1.0),
+            (mod.cffi_sin, mod.cffi_cos_ool, -1.0),
+            (mod.cffi_cos, mod.cffi_sin_ool, 1.0),
+            (mod.cffi_cos, mod.cffi_sin_ool, -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_user_defined_symbols(self):
+        pyfunc = mod.use_user_defined_symbols
+        cfunc = jit(nopython=True)(pyfunc)
+        self.assertEqual(pyfunc(), cfunc())
+
+    def check_vector_sin(self, cfunc, x, y):
+        cfunc(x, y)
+        np.testing.assert_allclose(y, np.sin(x))
+
+    def _test_from_buffer_numpy_array(self, pyfunc, dtype):
+        x = np.arange(10).astype(dtype)
+        y = np.zeros_like(x)
+        cfunc = jit(nopython=True)(pyfunc)
+        self.check_vector_sin(cfunc, x, y)
+
+    def test_from_buffer_float32(self):
+        self._test_from_buffer_numpy_array(mod.vector_sin_float32, np.float32)
+
+    def test_from_buffer_float64(self):
+        self._test_from_buffer_numpy_array(mod.vector_sin_float64, np.float64)
+
+    def test_from_buffer_struct(self):
+        n = 10
+        x = np.arange(n) + np.arange(n * 2, n * 3) * 1j
+        y = np.zeros(n)
+        real_cfunc = jit(nopython=True)(mod.vector_extract_real)
+        real_cfunc(x, y)
+        np.testing.assert_equal(x.real, y)
+        imag_cfunc = jit(nopython=True)(mod.vector_extract_imag)
+        imag_cfunc(x, y)
+        np.testing.assert_equal(x.imag, y)
+
+    def test_from_buffer_pyarray(self):
+        pyfunc = mod.vector_sin_float32
+        cfunc = jit(nopython=True)(pyfunc)
+        x = array.array("f", range(10))
+        y = array.array("f", [0] * len(x))
+        self.check_vector_sin(cfunc, x, y)
+
+    def test_from_buffer_error(self):
+        pyfunc = mod.vector_sin_float32
+        cfunc = jit(nopython=True)(pyfunc)
+        # Non-contiguous array
+        x = np.arange(10).astype(np.float32)[::2]
+        y = np.zeros_like(x)
+        with self.assertRaises(errors.TypingError) as raises:
+            cfunc(x, y)
+        self.assertIn("from_buffer() unsupported on non-contiguous buffers",
+                      str(raises.exception))
+
+    def test_from_buffer_numpy_multi_array(self):
+        c1 = np.array([1, 2], order='C', dtype=np.float32)
+        c1_zeros = np.zeros_like(c1)
+        c2 = np.array([[1, 2], [3, 4]], order='C', dtype=np.float32)
+        c2_zeros = np.zeros_like(c2)
+        f1 = np.array([1, 2], order='F', dtype=np.float32)
+        f1_zeros = np.zeros_like(f1)
+        f2 = np.array([[1, 2], [3, 4]], order='F', dtype=np.float32)
+        f2_zeros = np.zeros_like(f2)
+        f2_copy = f2.copy('K')
+        pyfunc = mod.vector_sin_float32
+        cfunc = jit(nopython=True)(pyfunc)
+        # No exception because of C layout and single dimension
+        self.check_vector_sin(cfunc, c1, c1_zeros)
+        # No exception because of C layout
+        cfunc(c2, c2_zeros)
+        sin_c2 = np.sin(c2)
+        sin_c2[1] = [0, 0]  # Reset to zero, since cfunc only processes one row
+        np.testing.assert_allclose(c2_zeros, sin_c2)
+        # No exception because of single dimension
+        self.check_vector_sin(cfunc, f1, f1_zeros)
+        # Exception because multi-dimensional with F layout
+        with self.assertRaises(errors.TypingError) as raises:
+            cfunc(f2, f2_zeros)
+        np.testing.assert_allclose(f2, f2_copy)
+        self.assertIn("from_buffer() only supports multidimensional arrays with C layout",
+                      str(raises.exception))
+
+    def test_indirect_multiple_use(self):
+        """
+        Issue #2263
+
+        Linkage error due to multiple definition of global tracking symbol.
+        """
+        my_sin = mod.cffi_sin
+
+        # Use two jit functions that references `my_sin` to ensure multiple
+        # modules
+        @jit(nopython=True)
+        def inner(x):
+            return my_sin(x)
+
+        @jit(nopython=True)
+        def foo(x):
+            return inner(x) + my_sin(x + 1)
+
+        # Error occurs when foo is being compiled
+        x = 1.123
+        self.assertEqual(foo(x), my_sin(x) + my_sin(x + 1))
+
+
+if __name__ == '__main__':
+    unittest.main()

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

@@ -0,0 +1,152 @@
+import contextlib
+import ctypes
+import struct
+import sys
+
+import llvmlite.ir as ir
+import numpy as np
+
+import unittest
+from numba.core import types, typing, cgutils, cpu
+from numba.core.compiler_lock import global_compiler_lock
+from numba.tests.support import TestCase, run_in_subprocess
+
+
+machine_int = ir.IntType(types.intp.bitwidth)
+
+def machine_const(n):
+    return ir.Constant(machine_int, n)
+
+
+class StructureTestCase(TestCase):
+
+    def setUp(self):
+        typing_context = typing.Context()
+        self.context = cpu.CPUContext(typing_context)
+
+    @contextlib.contextmanager
+    def compile_function(self, nargs):
+        llvm_fnty = ir.FunctionType(machine_int, [machine_int] * nargs)
+        ctypes_fnty = ctypes.CFUNCTYPE(ctypes.c_size_t,
+                                    * (ctypes.c_size_t,) * nargs)
+        module = self.context.create_module("")
+
+        function = cgutils.get_or_insert_function(module, llvm_fnty, self.id())
+        assert function.is_declaration
+        entry_block = function.append_basic_block('entry')
+        builder = ir.IRBuilder(entry_block)
+
+        first = [True]
+
+        @global_compiler_lock
+        def call_func(*args):
+            codegen = self.context.codegen()
+            library = codegen.create_library("test_module.%s" % self.id())
+            library.add_ir_module(module)
+            cptr = library.get_pointer_to_function(function.name)
+            cfunc = ctypes_fnty(cptr)
+            return cfunc(*args)
+
+        yield self.context, builder, function.args, call_func
+
+
+    def get_bytearray_addr(self, ba):
+        assert isinstance(ba, bytearray)
+        ba_as_string = ctypes.pythonapi.PyByteArray_AsString
+        ba_as_string.argtypes = [ctypes.py_object]
+        ba_as_string.restype = ctypes.c_void_p
+        return ba_as_string(ba)
+
+    def test_compile_function(self):
+        # Simple self-test for compile_function()
+        with self.compile_function(2) as (context, builder, args, call):
+            res = builder.add(args[0], args[1])
+            builder.ret(res)
+        self.assertEqual(call(5, -2), 3)
+        self.assertEqual(call(4, 2), 6)
+
+    @contextlib.contextmanager
+    def run_struct_access(self, struct_class, buf, offset=0):
+        with self.compile_function(1) as (context, builder, args, call):
+            inst = struct_class(context, builder)
+            sptr = builder.add(args[0], machine_const(offset))
+            sptr = builder.inttoptr(sptr, ir.PointerType(inst._type))
+            inst = struct_class(context, builder, ref=sptr)
+
+            yield context, builder, args, inst
+
+            builder.ret(ir.Constant(machine_int, 0))
+        call(self.get_bytearray_addr(buf))
+
+    @contextlib.contextmanager
+    def run_simple_struct_test(self, struct_class, struct_fmt, struct_args):
+        # By using a too large buffer and a non-zero offset, we also check
+        # that surrounding memory isn't touched.
+        buf = bytearray(b'!') * 40
+        expected = buf[:]
+        offset = 8
+
+        with self.run_struct_access(struct_class, buf, offset) \
+            as (context, builder, args, inst):
+            yield context, builder, inst
+
+        self.assertNotEqual(buf, expected)
+        struct.pack_into(struct_fmt, expected, offset, *struct_args)
+        self.assertEqual(buf, expected)
+
+    def test_int_fields(self):
+        class S(cgutils.Structure):
+            _fields = [('a', types.int32),
+                       ('b', types.uint16)]
+
+        fmt = "=iH"
+        with self.run_simple_struct_test(S, fmt, (0x12345678, 0xABCD)) \
+            as (context, builder, inst):
+            inst.a = ir.Constant(ir.IntType(32), 0x12345678)
+            inst.b = ir.Constant(ir.IntType(16), 0xABCD)
+
+    def test_float_fields(self):
+        class S(cgutils.Structure):
+            _fields = [('a', types.float64),
+                       ('b', types.float32)]
+
+        fmt = "=df"
+        with self.run_simple_struct_test(S, fmt, (1.23, 4.56)) \
+            as (context, builder, inst):
+            inst.a = ir.Constant(ir.DoubleType(), 1.23)
+            inst.b = ir.Constant(ir.FloatType(), 4.56)
+
+
+class TestCGContext(TestCase):
+    """Tests for code generation context functionality"""
+
+    def test_printf(self):
+        # Tests the printf() method
+
+        value = 123456
+
+        code = f"""if 1:
+        from numba import njit, types
+        from numba.extending import intrinsic
+
+        @intrinsic
+        def printf(tyctx, int_arg):
+            sig = types.void(int_arg)
+            def codegen(cgctx, builder, sig, llargs):
+                cgctx.printf(builder, \"%d\\n\", *llargs)
+            return sig, codegen
+
+        @njit
+        def foo():
+            printf({value})
+
+        foo()
+        """
+
+        out, _ = run_in_subprocess(code)
+        self.assertIn(str(value), out.decode())
+
+
+
+if __name__ == '__main__':
+    unittest.main()

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

@@ -0,0 +1,281 @@
+# Tests for the CLI
+
+import os
+import subprocess
+import sys
+import threading
+import json
+from subprocess import CompletedProcess
+from tempfile import TemporaryDirectory
+from unittest import mock
+
+import unittest
+from numba.tests.support import TestCase, linux_only
+import numba.misc.numba_sysinfo as nsi
+from numba.tests.gdb_support import needs_gdb
+from numba.misc.numba_gdbinfo import collect_gdbinfo
+# Going to mock parts of this in testing
+from numba.misc.numba_gdbinfo import _GDBTestWrapper
+
+
+def run_cmd(cmdline, env=os.environ, timeout=60):
+    popen = subprocess.Popen(cmdline,
+                             stdout=subprocess.PIPE,
+                             stderr=subprocess.PIPE,
+                             env=env)
+
+    timeout_timer = threading.Timer(timeout, popen.kill)
+    try:
+        timeout_timer.start()
+        out, err = popen.communicate()
+        if popen.returncode != 0:
+            raise AssertionError(
+                "process failed with code %s: stderr follows\n%s\n" %
+                (popen.returncode, err.decode()))
+        return out.decode(), err.decode()
+    finally:
+        timeout_timer.cancel()
+    return None, None
+
+
+class TestCLI(TestCase):
+
+    def test_as_module_exit_code(self):
+        cmdline = [sys.executable, "-m", "numba"]
+        with self.assertRaises(AssertionError) as raises:
+            run_cmd(cmdline)
+
+        self.assertIn("process failed with code 1", str(raises.exception))
+
+    def test_sysinfo_from_module(self):
+        cmdline = [sys.executable, "-m", "numba", "-s"]
+        o, _ = run_cmd(cmdline)
+        self.assertIn("System info", o)
+
+    def test_json_sysinfo_from_module(self):
+        with TemporaryDirectory() as d:
+            path = os.path.join(d, "test_json_sysinfo.json")
+            cmdline = [sys.executable, "-m", "numba", "--sys-json", path]
+            run_cmd(cmdline)
+            with self.subTest(msg=f"{path} exists"):
+                self.assertTrue(os.path.exists(path))
+            with self.subTest(msg="json load"):
+                with open(path, 'r') as f:
+                    info = json.load(f)
+            safe_contents = {
+                int: (
+                    nsi._cpu_count,
+                ),
+                float: (
+                    nsi._runtime,
+                ),
+                str: (
+                    nsi._start,
+                    nsi._start_utc,
+                    nsi._machine,
+                    nsi._cpu_name,
+                    nsi._platform_name,
+                    nsi._os_name,
+                    nsi._os_version,
+                    nsi._python_comp,
+                    nsi._python_impl,
+                    nsi._python_version,
+                    nsi._llvm_version,
+                ),
+                bool: (
+                    nsi._cu_dev_init,
+                    nsi._svml_state,
+                    nsi._svml_loaded,
+                    nsi._svml_operational,
+                    nsi._llvm_svml_patched,
+                    nsi._tbb_thread,
+                    nsi._openmp_thread,
+                    nsi._wkq_thread,
+                ),
+                list: (
+                    nsi._errors,
+                    nsi._warnings,
+                ),
+                dict: (
+                    nsi._numba_env_vars,
+                ),
+            }
+            for t, keys in safe_contents.items():
+                for k in keys:
+                    with self.subTest(k=k):
+                        self.assertIsInstance(info[k], t)
+
+    @needs_gdb
+    def test_gdb_status_from_module(self):
+        # Check that the `python -m numba -g` works ok
+        cmdline = [sys.executable, "-m", "numba", "-g"]
+        o, _ = run_cmd(cmdline)
+        self.assertIn("GDB info", o)
+        # It's not known a priori whether the extension is supported, this just
+        # checks that the last logical item in the output is printed.
+        self.assertIn("Numba printing extension support", o)
+
+
+class TestGDBCLIInfo(TestCase):
+
+    def setUp(self):
+        # Mock the entire class, to report valid things,
+        # then override bits of it locally to check failures etc.
+
+        self._patches = []
+
+        mock_init = lambda self: None
+        self._patches.append(mock.patch.object(_GDBTestWrapper, '__init__',
+                                               mock_init))
+
+        bpath = 'numba.misc.numba_gdbinfo._GDBTestWrapper.gdb_binary'
+        self._patches.append(mock.patch(bpath, 'PATH_TO_GDB'))
+
+        def _patch(fnstr, func):
+            self._patches.append(mock.patch.object(_GDBTestWrapper, fnstr,
+                                                   func))
+
+        def mock_check_launch(self):
+            return CompletedProcess('COMMAND STRING', 0)
+
+        _patch('check_launch', mock_check_launch)
+
+        # NOTE: The Python and NumPy versions are set to something unsupported!
+        def mock_check_python(self):
+            return CompletedProcess('COMMAND STRING', 0,
+                                    stdout='(3, 2)',
+                                    stderr='')
+
+        _patch('check_python', mock_check_python)
+
+        def mock_check_numpy(self):
+            return CompletedProcess('COMMAND STRING', 0, stdout='True',
+                                    stderr='')
+
+        _patch('check_numpy', mock_check_numpy)
+
+        def mock_check_numpy_version(self):
+            return CompletedProcess('COMMAND STRING', 0, stdout='1.15',
+                                    stderr='')
+
+        _patch('check_numpy_version', mock_check_numpy_version)
+
+        # start the patching
+        for p in self._patches:
+            p.start()
+
+    def tearDown(self):
+        # stop the patching
+        for p in self._patches:
+            p.stop()
+
+    def test_valid(self):
+        collected = collect_gdbinfo()
+        self.assertEqual(collected.binary_loc, 'PATH_TO_GDB')
+        extp = os.path.exists(os.path.abspath(collected.extension_loc))
+        self.assertTrue(extp)
+        self.assertEqual(collected.py_ver, '3.2')
+        self.assertEqual(collected.np_ver, '1.15')
+        self.assertIn('Full', collected.supported)
+
+    def test_invalid_binary(self):
+
+        def mock_fn(self):
+            return CompletedProcess('INVALID_BINARY', 1)
+
+        with mock.patch.object(_GDBTestWrapper, 'check_launch', mock_fn):
+            info = collect_gdbinfo()
+            self.assertIn("Testing gdb binary failed.", info.binary_loc)
+            self.assertIn("gdb at 'PATH_TO_GDB' does not appear to work",
+                          info.binary_loc)
+
+    def test_no_python(self):
+        def mock_fn(self):
+            return CompletedProcess('NO PYTHON', 1)
+
+        with mock.patch.object(_GDBTestWrapper, 'check_python', mock_fn):
+            collected = collect_gdbinfo()
+            self.assertEqual(collected.py_ver, 'No Python support')
+            self.assertEqual(collected.supported, 'None')
+
+    def test_unparsable_python_version(self):
+        def mock_fn(self):
+            return CompletedProcess('NO PYTHON', 0, stdout='(NOT A VERSION)')
+
+        with mock.patch.object(_GDBTestWrapper, 'check_python', mock_fn):
+            collected = collect_gdbinfo()
+            self.assertEqual(collected.py_ver, 'No Python support')
+
+    def test_no_numpy(self):
+        def mock_fn(self):
+            return CompletedProcess('NO NUMPY', 1)
+
+        with mock.patch.object(_GDBTestWrapper, 'check_numpy', mock_fn):
+            collected = collect_gdbinfo()
+            self.assertEqual(collected.np_ver, 'No NumPy support')
+            self.assertEqual(collected.py_ver, '3.2')
+            self.assertIn('Partial', collected.supported)
+
+    def test_no_numpy_version(self):
+        def mock_fn(self):
+            return CompletedProcess('NO NUMPY VERSION', 1)
+
+        with mock.patch.object(_GDBTestWrapper, 'check_numpy_version', mock_fn):
+            collected = collect_gdbinfo()
+            self.assertEqual(collected.np_ver, 'Unknown')
+
+    def test_traceback_in_numpy_version(self):
+        def mock_fn(self):
+            return CompletedProcess('NO NUMPY VERSION', 0,
+                                    stdout='(NOT A VERSION)',
+                                    stderr='Traceback')
+
+        with mock.patch.object(_GDBTestWrapper, 'check_numpy_version', mock_fn):
+            collected = collect_gdbinfo()
+            self.assertEqual(collected.np_ver, 'Unknown')
+
+
+@linux_only
+class TestGDBCLIInfoBrokenGdbs(TestCase):
+    # In these tests, it's necessary to actually run the entry point in an env
+    # with the env var set as it's in part testing the processing of the
+    # handling of consumption of variables by numba.core.config.
+
+    def test_cannot_find_gdb_from_name(self):
+        # Tests that supplying an invalid gdb binary name is handled ok
+        env = os.environ.copy()
+        env['NUMBA_GDB_BINARY'] = 'THIS_IS_NOT_A_VALID_GDB_BINARY_NAME'
+        cmdline = [sys.executable, "-m", "numba", "-g"]
+        stdout, stderr = run_cmd(cmdline, env=env)
+        self.assertIn("Testing gdb binary failed", stdout)
+        self.assertIn("No such file or directory", stdout)
+        self.assertIn("'THIS_IS_NOT_A_VALID_GDB_BINARY_NAME'", stdout)
+
+    def test_cannot_find_gdb_from_path(self):
+        # Tests that an invalid path is handled ok
+        env = os.environ.copy()
+        with TemporaryDirectory() as d:
+            # This wont exist as a path...
+            path = os.path.join(d, 'CANNOT_EXIST')
+            env['NUMBA_GDB_BINARY'] = path
+            cmdline = [sys.executable, "-m", "numba", "-g"]
+            stdout, stderr = run_cmd(cmdline, env=env)
+            self.assertIn("Testing gdb binary failed", stdout)
+            self.assertIn("No such file or directory", stdout)
+            self.assertIn(path, stdout)
+
+    def test_nonsense_gdb_binary(self):
+        # Tests that a nonsense binary specified as gdb it picked up ok
+        env = os.environ.copy()
+        env['NUMBA_GDB_BINARY'] = 'python' # 'python' isn't gdb!
+        cmdline = [sys.executable, "-m", "numba", "-g"]
+        stdout, stderr = run_cmd(cmdline, env=env)
+        self.assertIn("Testing gdb binary failed", stdout)
+        # NOTE: should 'python' ever add support for the same flags as the gdb
+        # commands used in the information gathering code in `numba_gdbinfo`
+        # this test will fail, it's reasonably unlikely.
+        self.assertIn("Unknown option", stdout)
+
+
+if __name__ == '__main__':
+    unittest.main()

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

@@ -0,0 +1,119 @@
+import re
+
+from numba import njit
+from numba.core.extending import overload
+from numba.core.targetconfig import ConfigStack
+from numba.core.compiler import Flags, DEFAULT_FLAGS
+from numba.core import types
+from numba.core.funcdesc import default_mangler
+
+from numba.tests.support import TestCase, unittest
+
+
+class TestCompilerFlags(TestCase):
+    def test_setting_invalid_attribute(self):
+        flags = Flags()
+        msg = "'Flags' object has no attribute 'this_really_does_not_exist'"
+        with self.assertRaisesRegex(AttributeError, msg):
+            flags.this_really_does_not_exist = True
+
+
+class TestCompilerFlagCachedOverload(TestCase):
+    def test_fastmath_in_overload(self):
+        def fastmath_status():
+            pass
+
+        @overload(fastmath_status)
+        def ov_fastmath_status():
+            flags = ConfigStack().top()
+            val = "Has fastmath" if flags.fastmath else "No fastmath"
+
+            def codegen():
+                return val
+
+            return codegen
+
+        @njit(fastmath=True)
+        def set_fastmath():
+            return fastmath_status()
+
+        @njit()
+        def foo():
+            a = fastmath_status()
+            b = set_fastmath()
+            return (a, b)
+
+        a, b = foo()
+        self.assertEqual(a, "No fastmath")
+        self.assertEqual(b, "Has fastmath")
+
+
+class TestFlagMangling(TestCase):
+
+    def test_demangle(self):
+
+        def check(flags):
+            mangled = flags.get_mangle_string()
+            out = flags.demangle(mangled)
+            # Demangle result MUST match summary()
+            self.assertEqual(out, flags.summary())
+
+        # test empty flags
+        flags = Flags()
+        check(flags)
+
+        # test default
+        check(DEFAULT_FLAGS)
+
+        # test other
+        flags = Flags()
+        flags.no_cpython_wrapper = True
+        flags.nrt = True
+        flags.fastmath = True
+        check(flags)
+
+    def test_mangled_flags_is_shorter(self):
+        # at least for these control cases
+        flags = Flags()
+        flags.nrt = True
+        flags.auto_parallel = True
+        self.assertLess(len(flags.get_mangle_string()), len(flags.summary()))
+
+    def test_mangled_flags_with_fastmath_parfors_inline(self):
+        # at least for these control cases
+        flags = Flags()
+        flags.nrt = True
+        flags.auto_parallel = True
+        flags.fastmath = True
+        flags.inline = "always"
+        self.assertLess(len(flags.get_mangle_string()), len(flags.summary()))
+        demangled = flags.demangle(flags.get_mangle_string())
+        # There should be no pointer value in the demangled string.
+        self.assertNotIn("0x", demangled)
+
+    def test_demangling_from_mangled_symbols(self):
+        """Test demangling of flags from mangled symbol"""
+        # Use default mangler to mangle the string
+        fname = 'foo'
+        argtypes = types.int32,
+        flags = Flags()
+        flags.nrt = True
+        flags.inline = "always"
+        name = default_mangler(
+            fname, argtypes, abi_tags=[flags.get_mangle_string()],
+        )
+        # Find the ABI-tag. Starts with "B"
+        prefix = "_Z3fooB"
+        # Find the length of the ABI-tag
+        m = re.match("[0-9]+", name[len(prefix):])
+        size = m.group(0)
+        # Extract the ABI tag
+        base = len(prefix) + len(size)
+        abi_mangled = name[base:base + int(size)]
+        # Demangle and check
+        demangled = Flags.demangle(abi_mangled)
+        self.assertEqual(demangled, flags.summary())
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,23 @@
+import unittest
+from numba.core.compiler_lock import (
+    global_compiler_lock,
+    require_global_compiler_lock,
+)
+from numba.tests.support import TestCase
+
+
+class TestCompilerLock(TestCase):
+    def test_gcl_as_context_manager(self):
+        with global_compiler_lock:
+            require_global_compiler_lock()
+
+    def test_gcl_as_decorator(self):
+        @global_compiler_lock
+        def func():
+            require_global_compiler_lock()
+
+        func()
+
+
+if __name__ == '__main__':
+    unittest.main()

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

@@ -0,0 +1,309 @@
+import itertools
+import math
+import sys
+
+from numba import jit, types
+from numba.tests.support import TestCase
+from .complex_usecases import *
+import unittest
+
+enable_pyobj_flags = {'forceobj': True}
+no_pyobj_flags = {'nopython': True}
+
+
+class BaseComplexTest(object):
+
+    def basic_values(self):
+        reals = [-0.0, +0.0, 1, -1, +1.5, -3.5,
+                 float('-inf'), float('+inf')]
+        if sys.platform != 'win32':
+            reals += [float('nan')]
+        return [complex(x, y) for x, y in itertools.product(reals, reals)]
+
+    def more_values(self):
+        reals = [-0.0, +0.0, 1, -1, -math.pi, +math.pi,
+                 float('-inf'), float('+inf')]
+        if sys.platform != 'win32':
+            reals += [float('nan')]
+        return [complex(x, y) for x, y in itertools.product(reals, reals)]
+
+    def non_nan_values(self):
+        reals = [-0.0, +0.0, 1, -1, -math.pi, +math.pi,
+                 float('inf'), float('-inf')]
+        return [complex(x, y) for x, y in itertools.product(reals, reals)]
+
+    def run_unary(self, pyfunc, x_types, x_values, ulps=1, abs_tol=None,
+                  flags=enable_pyobj_flags):
+        for tx in x_types:
+            cfunc = jit((tx,), **flags)(pyfunc)
+            prec = 'single' if tx in (types.float32, types.complex64) else 'double'
+            for vx in x_values:
+                try:
+                    expected = pyfunc(vx)
+                except ValueError as e:
+                    self.assertIn("math domain error", str(e))
+                    continue
+                got = cfunc(vx)
+                msg = 'for input %r with prec %r' % (vx, prec)
+                self.assertPreciseEqual(got, expected, prec=prec,
+                                        ulps=ulps, abs_tol=abs_tol, msg=msg)
+
+    def run_binary(self, pyfunc, value_types, values, ulps=1,
+                   flags=enable_pyobj_flags):
+        for tx, ty in value_types:
+            cfunc = jit((tx, ty), **flags)(pyfunc)
+            prec = ('single'
+                    if set([tx, ty]) & set([types.float32, types.complex64])
+                    else 'double')
+            for vx, vy in values:
+                try:
+                    expected = pyfunc(vx, vy)
+                except ValueError as e:
+                    self.assertIn("math domain error", str(e))
+                    continue
+                except ZeroDivisionError:
+                    continue
+                got = cfunc(vx, vy)
+                msg = 'for input %r with prec %r' % ((vx, vy), prec)
+                self.assertPreciseEqual(got, expected, prec=prec,
+                                        ulps=ulps, msg=msg)
+
+
+class TestComplex(BaseComplexTest, TestCase):
+
+    def test_real(self, flags=enable_pyobj_flags):
+        self.run_unary(real_usecase, [types.complex64, types.complex128],
+                       self.basic_values(), flags=flags)
+        self.run_unary(real_usecase, [types.int8, types.int64],
+                       [1, 0, -3], flags=flags)
+        self.run_unary(real_usecase, [types.float32, types.float64],
+                       [1.5, -0.5], flags=flags)
+
+    def test_real_npm(self):
+        self.test_real(flags=no_pyobj_flags)
+
+    def test_imag(self, flags=enable_pyobj_flags):
+        self.run_unary(imag_usecase, [types.complex64, types.complex128],
+                       self.basic_values(), flags=flags)
+        self.run_unary(imag_usecase, [types.int8, types.int64],
+                       [1, 0, -3], flags=flags)
+        self.run_unary(imag_usecase, [types.float32, types.float64],
+                       [1.5, -0.5], flags=flags)
+
+    def test_imag_npm(self):
+        self.test_imag(flags=no_pyobj_flags)
+
+    def test_conjugate(self, flags=enable_pyobj_flags):
+        self.run_unary(conjugate_usecase, [types.complex64, types.complex128],
+                       self.basic_values(), flags=flags)
+        self.run_unary(conjugate_usecase, [types.int8, types.int64],
+                       [1, 0, -3], flags=flags)
+        self.run_unary(conjugate_usecase, [types.float32, types.float64],
+                       [1.5, -0.5], flags=flags)
+
+    def test_conjugate_npm(self):
+        self.test_conjugate(flags=no_pyobj_flags)
+
+    def test_div(self, flags=enable_pyobj_flags):
+        """
+        Test complex.__div__ implementation with non-trivial values.
+        """
+        # XXX Fold into test_operator?
+        values = list(itertools.product(self.more_values(), self.more_values()))
+        value_types = [(types.complex128, types.complex128),
+                       (types.complex64, types.complex64)]
+        self.run_binary(div_usecase, value_types, values, flags=flags)
+
+    def test_div_npm(self):
+        self.test_div(flags=no_pyobj_flags)
+
+
+class TestCMath(BaseComplexTest, TestCase):
+    """
+    Tests for cmath module support.
+    """
+
+    def check_predicate_func(self, pyfunc, flags):
+        self.run_unary(pyfunc, [types.complex128, types.complex64],
+                       self.basic_values(), flags=flags)
+
+    def check_unary_func(self, pyfunc, flags, ulps=1, abs_tol=None,
+                         values=None):
+        self.run_unary(pyfunc, [types.complex128],
+                       values or self.more_values(), flags=flags, ulps=ulps,
+                       abs_tol=abs_tol)
+        # Avoid discontinuities around pi when in single precision.
+        self.run_unary(pyfunc, [types.complex64],
+                       values or self.basic_values(), flags=flags, ulps=ulps,
+                       abs_tol=abs_tol)
+
+    # Conversions
+
+    def test_phase(self):
+        self.check_unary_func(phase_usecase, enable_pyobj_flags)
+
+    def test_phase_npm(self):
+        self.check_unary_func(phase_usecase, no_pyobj_flags)
+
+    def test_polar(self):
+        self.check_unary_func(polar_usecase, enable_pyobj_flags)
+
+    def test_polar_npm(self):
+        self.check_unary_func(polar_usecase, no_pyobj_flags)
+
+    def test_rect(self, flags=enable_pyobj_flags):
+        def do_test(tp, seed_values):
+            values = [(z.real, z.imag) for z in seed_values
+                      if not math.isinf(z.imag) or z.real == 0]
+            self.run_binary(rect_usecase, [(tp, tp)], values, flags=flags)
+        do_test(types.float64, self.more_values())
+        # Avoid discontinuities around pi when in single precision.
+        do_test(types.float32, self.basic_values())
+
+    def test_rect_npm(self):
+        self.test_rect(flags=no_pyobj_flags)
+
+    # Classification
+
+    def test_isnan(self, flags=enable_pyobj_flags):
+        self.check_predicate_func(isnan_usecase, enable_pyobj_flags)
+
+    def test_isnan_npm(self):
+        self.check_predicate_func(isnan_usecase, no_pyobj_flags)
+
+    def test_isinf(self, flags=enable_pyobj_flags):
+        self.check_predicate_func(isinf_usecase, enable_pyobj_flags)
+
+    def test_isinf_npm(self):
+        self.check_predicate_func(isinf_usecase, no_pyobj_flags)
+
+    def test_isfinite(self, flags=enable_pyobj_flags):
+        self.check_predicate_func(isfinite_usecase, enable_pyobj_flags)
+
+    def test_isfinite_npm(self):
+        self.check_predicate_func(isfinite_usecase, no_pyobj_flags)
+
+    # Power and logarithms
+
+    def test_exp(self):
+        self.check_unary_func(exp_usecase, enable_pyobj_flags, ulps=2)
+
+    def test_exp_npm(self):
+        # Aggressive optimization fixes the following subnormal float problem.
+        ## The two tests are failing due to subnormal float problems.
+        ## We are seeing (6.9532198665326e-310+2.1221202807e-314j) != 0j
+        self.check_unary_func(exp_usecase, no_pyobj_flags, ulps=2)
+
+    def test_log(self):
+        self.check_unary_func(log_usecase, enable_pyobj_flags)
+
+    def test_log_npm(self):
+        self.check_unary_func(log_usecase, no_pyobj_flags)
+
+    def test_log_base(self, flags=enable_pyobj_flags):
+        values = list(itertools.product(self.more_values(), self.more_values()))
+        value_types = [(types.complex128, types.complex128),
+                       (types.complex64, types.complex64)]
+        self.run_binary(log_base_usecase, value_types, values, flags=flags,
+                        ulps=3)
+
+    def test_log_base_npm(self):
+        self.test_log_base(flags=no_pyobj_flags)
+
+    def test_log10(self):
+        self.check_unary_func(log10_usecase, enable_pyobj_flags)
+
+    def test_log10_npm(self):
+        self.check_unary_func(log10_usecase, no_pyobj_flags)
+
+    def test_sqrt(self):
+        self.check_unary_func(sqrt_usecase, enable_pyobj_flags)
+
+    def test_sqrt_npm(self):
+        self.check_unary_func(sqrt_usecase, no_pyobj_flags)
+        # issue #3499, check large complex128 values, values cross the float32
+        # representation limit threshold
+        values = [-10 ** i for i in range(36, 41)]
+        self.run_unary(sqrt_usecase, [types.complex128],
+                       values, flags=no_pyobj_flags)
+
+    # Trigonometric functions
+
+    def test_acos(self):
+        self.check_unary_func(acos_usecase, enable_pyobj_flags, ulps=2)
+
+    def test_acos_npm(self):
+        self.check_unary_func(acos_usecase, no_pyobj_flags, ulps=2)
+
+    def test_asin(self):
+        self.check_unary_func(asin_usecase, enable_pyobj_flags, ulps=2)
+
+    def test_asin_npm(self):
+        self.check_unary_func(asin_usecase, no_pyobj_flags, ulps=2)
+
+    def test_atan(self):
+        self.check_unary_func(atan_usecase, enable_pyobj_flags, ulps=2,)
+
+    def test_atan_npm(self):
+        self.check_unary_func(atan_usecase, no_pyobj_flags, ulps=2,)
+
+    def test_cos(self):
+        self.check_unary_func(cos_usecase, enable_pyobj_flags, ulps=2)
+
+    def test_cos_npm(self):
+        self.check_unary_func(cos_usecase, no_pyobj_flags, ulps=2)
+
+    def test_sin(self):
+        # See test_sinh.
+        self.check_unary_func(sin_usecase, enable_pyobj_flags, abs_tol='eps')
+
+    def test_sin_npm(self):
+        self.check_unary_func(sin_usecase, no_pyobj_flags, abs_tol='eps')
+
+    def test_tan(self):
+        self.check_unary_func(tan_usecase, enable_pyobj_flags, ulps=2)
+
+    def test_tan_npm(self):
+        self.check_unary_func(tan_usecase, enable_pyobj_flags, ulps=2)
+
+    # Hyperbolic functions
+
+    def test_acosh(self):
+        self.check_unary_func(acosh_usecase, enable_pyobj_flags)
+
+    def test_acosh_npm(self):
+        self.check_unary_func(acosh_usecase, no_pyobj_flags)
+
+    def test_asinh(self):
+        self.check_unary_func(asinh_usecase, enable_pyobj_flags, ulps=2)
+
+    def test_asinh_npm(self):
+        self.check_unary_func(asinh_usecase, no_pyobj_flags, ulps=2)
+
+    def test_atanh(self):
+        self.check_unary_func(atanh_usecase, enable_pyobj_flags, ulps=2)
+
+    def test_atanh_npm(self):
+        self.check_unary_func(atanh_usecase, no_pyobj_flags, ulps=2)
+
+    def test_cosh(self):
+        self.check_unary_func(cosh_usecase, enable_pyobj_flags, ulps=2)
+
+    def test_cosh_npm(self):
+        self.check_unary_func(cosh_usecase, no_pyobj_flags, ulps=2)
+
+    def test_sinh(self):
+        self.check_unary_func(sinh_usecase, enable_pyobj_flags, abs_tol='eps')
+
+    def test_sinh_npm(self):
+        self.check_unary_func(sinh_usecase, no_pyobj_flags, abs_tol='eps')
+
+    def test_tanh(self):
+        self.check_unary_func(tanh_usecase, enable_pyobj_flags, ulps=2)
+
+    def test_tanh_npm(self):
+        self.check_unary_func(tanh_usecase, enable_pyobj_flags, ulps=2)
+
+
+if __name__ == '__main__':
+    unittest.main()

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

@@ -0,0 +1,223 @@
+import gc
+import itertools
+
+import numpy as np
+
+import unittest
+from numba import jit, njit
+from numba.core import types
+from numba.tests.support import TestCase
+from numba.np import numpy_support
+
+
+def identity(x):
+    return x
+
+def addition(x, y):
+    return x + y
+
+def equality(x, y):
+    return x == y
+
+def foobar(x, y, z):
+    return x
+
+
+class TestConversion(TestCase):
+    """
+    Testing Python to Native conversion
+    """
+
+    def test_complex_identity(self):
+        pyfunc = identity
+        cfunc = njit(types.complex64(types.complex64))(pyfunc)
+
+        xs = [1.0j, (1+1j), (-1-1j), (1+0j)]
+        for x in xs:
+            self.assertEqual(cfunc(x), x)
+        for x in np.complex64(xs):
+            self.assertEqual(cfunc(x), x)
+
+        cfunc = njit(types.complex128(types.complex128))(pyfunc)
+
+        xs = [1.0j, (1+1j), (-1-1j), (1+0j)]
+        for x in xs:
+            self.assertEqual(cfunc(x), x)
+        for x in np.complex128(xs):
+            self.assertEqual(cfunc(x), x)
+
+    def test_complex_addition(self):
+        pyfunc = addition
+        cfunc = njit(types.complex64(types.complex64, types.complex64))(pyfunc)
+
+        xs = [1.0j, (1+1j), (-1-1j), (1+0j)]
+        for x in xs:
+            y = x
+            self.assertEqual(cfunc(x, y), x + y)
+        for x in np.complex64(xs):
+            y = x
+            self.assertEqual(cfunc(x, y), x + y)
+
+
+        cfunc = njit(types.complex128(types.complex128,
+                                      types.complex128))(pyfunc)
+
+        xs = [1.0j, (1+1j), (-1-1j), (1+0j)]
+        for x in xs:
+            y = x
+            self.assertEqual(cfunc(x, y), x + y)
+        for x in np.complex128(xs):
+            y = x
+            self.assertEqual(cfunc(x, y), x + y)
+
+    def test_boolean_as_int(self):
+        pyfunc = equality
+        cfunc = njit((types.boolean, types.intp))(pyfunc)
+
+        xs = True, False
+        ys = -1, 0, 1
+
+        for xs, ys in itertools.product(xs, ys):
+            self.assertEqual(pyfunc(xs, ys), cfunc(xs, ys))
+
+    def test_boolean_as_float(self):
+        pyfunc = equality
+        cfunc = njit((types.boolean, types.float64))(pyfunc)
+
+        xs = True, False
+        ys = -1, 0, 1
+
+        for xs, ys in itertools.product(xs, ys):
+            self.assertEqual(pyfunc(xs, ys), cfunc(xs, ys))
+
+    def test_boolean_eq_boolean(self):
+        pyfunc = equality
+        cfunc = njit((types.boolean, types.boolean))(pyfunc)
+
+        xs = True, False
+        ys = True, False
+
+        for xs, ys in itertools.product(xs, ys):
+            self.assertEqual(pyfunc(xs, ys), cfunc(xs, ys))
+
+    # test when a function parameters are jitted as unsigned types
+    # the function is called with negative parameters the Python error
+    # that it generates is correctly handled -- a Python error is returned to the user
+    # For more info, see the comment in Include/longobject.h for _PyArray_AsByteArray
+    # which PyLong_AsUnsignedLongLong calls
+    def test_negative_to_unsigned(self):
+        def f(x):
+            return x
+        with self.assertRaises(OverflowError):
+            jit('uintp(uintp)', nopython=True)(f)(-5)
+
+    # test the switch logic in callwraper.py:build_wrapper() works for more than one argument
+    # and where the error occurs 
+    def test_multiple_args_negative_to_unsigned(self): 
+        pyfunc = foobar
+        cfunc = njit(types.uint64(types.uint64, types.uint64,
+                                  types.uint64),)(pyfunc)
+
+        test_fail_args = ((-1, 0, 1), (0, -1, 1), (0, 1, -1))
+        with self.assertRaises(OverflowError):
+            for a, b, c in test_fail_args:
+                cfunc(a, b, c)
+
+    # test switch logic of callwraper.py:build_wrapper() with records as function parameters
+    def test_multiple_args_records(self): 
+        pyfunc = foobar
+
+        mystruct_dt = np.dtype([('p', np.float64),
+                           ('row', np.float64),
+                           ('col', np.float64)])
+        mystruct = numpy_support.from_dtype(mystruct_dt)
+
+        cfunc = njit(mystruct[:](mystruct[:], types.uint64,
+                                 types.uint64),)(pyfunc)
+
+        st1 = np.recarray(3, dtype=mystruct_dt)
+
+        st1.p = np.arange(st1.size) + 1
+        st1.row = np.arange(st1.size) + 1
+        st1.col = np.arange(st1.size) + 1
+
+        with self.assertRefCount(st1):
+            test_fail_args = ((st1, -1, 1), (st1, 1, -1))
+
+            for a, b, c in test_fail_args:
+                with self.assertRaises(OverflowError):
+                    cfunc(a, b, c)
+
+            del test_fail_args, a, b, c
+            gc.collect()
+
+    # test switch logic of callwraper.py:build_wrapper() with no function parameters
+    def test_with_no_parameters(self):
+        def f():
+            pass 
+        self.assertEqual(f(), jit('()', nopython=True)(f)())
+
+    def check_argument_cleanup(self, typ, obj):
+        """
+        Check that argument cleanup doesn't leak references.
+        """
+        def f(x, y):
+            pass
+
+        def _objects(obj):
+            objs = [obj]
+            if isinstance(obj, tuple):
+                for v in obj:
+                    objs += _objects(v)
+            return objs
+
+        objects = _objects(obj)
+
+        cfunc = njit((typ, types.uint32))(f)
+        with self.assertRefCount(*objects):
+            cfunc(obj, 1)
+        with self.assertRefCount(*objects):
+            with self.assertRaises(OverflowError):
+                cfunc(obj, -1)
+
+        cfunc = njit((types.uint32, typ))(f)
+        with self.assertRefCount(*objects):
+            cfunc(1, obj)
+        with self.assertRefCount(*objects):
+            with self.assertRaises(OverflowError):
+                cfunc(-1, obj)
+
+    def test_cleanup_buffer(self):
+        mem = memoryview(bytearray(b"xyz"))
+        self.check_argument_cleanup(types.MemoryView(types.byte, 1, 'C'), mem)
+
+    def test_cleanup_record(self):
+        dtype = np.dtype([('x', np.float64), ('y', np.float64)])
+        recarr = np.zeros(1, dtype=dtype)
+        self.check_argument_cleanup(numpy_support.from_dtype(dtype), recarr[0])
+
+    def test_cleanup_tuple(self):
+        mem = memoryview(bytearray(b"xyz"))
+        tp = types.UniTuple(types.MemoryView(types.byte, 1, 'C'), 2)
+        self.check_argument_cleanup(tp, (mem, mem))
+
+    def test_cleanup_optional(self):
+        mem = memoryview(bytearray(b"xyz"))
+        tp = types.Optional(types.MemoryView(types.byte, 1, 'C'))
+        self.check_argument_cleanup(tp, mem)
+
+    def test_stringliteral_to_unicode(self):
+        # See issue #6907, explicit signature on bar() takes a unicode_type but
+        # the call to bar() in foo() is with a StringLiteral
+
+        @jit(types.void(types.unicode_type), nopython=True)
+        def bar(string):
+            pass
+
+        @jit(types.void(), nopython=True)
+        def foo2():
+            bar("literal string")
+
+
+if __name__ == '__main__':
+    unittest.main()

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

@@ -0,0 +1,257 @@
+from llvmlite import ir, binding as ll
+
+from numba.core import types, datamodel
+from numba.core.datamodel.testing import test_factory
+from numba.core.datamodel.manager import DataModelManager
+from numba.core.datamodel.models import OpaqueModel
+import unittest
+
+
+class TestBool(test_factory()):
+    fe_type = types.boolean
+
+
+class TestPyObject(test_factory()):
+    fe_type = types.pyobject
+
+
+class TestInt8(test_factory()):
+    fe_type = types.int8
+
+
+class TestInt16(test_factory()):
+    fe_type = types.int16
+
+
+class TestInt32(test_factory()):
+    fe_type = types.int32
+
+
+class TestInt64(test_factory()):
+    fe_type = types.int64
+
+
+class TestUInt8(test_factory()):
+    fe_type = types.uint8
+
+
+class TestUInt16(test_factory()):
+    fe_type = types.uint16
+
+
+class TestUInt32(test_factory()):
+    fe_type = types.uint32
+
+
+class TestUInt64(test_factory()):
+    fe_type = types.uint64
+
+
+class TestFloat(test_factory()):
+    fe_type = types.float32
+
+
+class TestDouble(test_factory()):
+    fe_type = types.float64
+
+
+class TestComplex(test_factory()):
+    fe_type = types.complex64
+
+
+class TestDoubleComplex(test_factory()):
+    fe_type = types.complex128
+
+
+class TestPointerOfInt32(test_factory()):
+    fe_type = types.CPointer(types.int32)
+
+
+class TestUniTupleOf2xInt32(test_factory()):
+    fe_type = types.UniTuple(types.int32, 2)
+
+
+class TestUniTupleEmpty(test_factory()):
+    fe_type = types.UniTuple(types.int32, 0)
+
+
+class TestTupleInt32Float32(test_factory()):
+    fe_type = types.Tuple([types.int32, types.float32])
+
+
+class TestTupleEmpty(test_factory()):
+    fe_type = types.Tuple([])
+
+
+class Test1DArrayOfInt32(test_factory()):
+    fe_type = types.Array(types.int32, 1, 'C')
+
+
+class Test2DArrayOfComplex128(test_factory()):
+    fe_type = types.Array(types.complex128, 2, 'C')
+
+
+class Test0DArrayOfInt32(test_factory()):
+    fe_type = types.Array(types.int32, 0, 'C')
+
+
+class TestArgInfo(unittest.TestCase):
+
+    def _test_as_arguments(self, fe_args):
+        """
+        Test round-tripping types *fe_args* through the default data model's
+        argument conversion and unpacking logic.
+        """
+        dmm = datamodel.default_manager
+        fi = datamodel.ArgPacker(dmm, fe_args)
+
+        module = ir.Module()
+        fnty = ir.FunctionType(ir.VoidType(), [])
+        function = ir.Function(module, fnty, name="test_arguments")
+        builder = ir.IRBuilder()
+        builder.position_at_end(function.append_basic_block())
+
+        args = [ir.Constant(dmm.lookup(t).get_value_type(), None)
+                for t in fe_args]
+
+        # Roundtrip
+        values = fi.as_arguments(builder, args)
+        asargs = fi.from_arguments(builder, values)
+
+        self.assertEqual(len(asargs), len(fe_args))
+        valtys = tuple([v.type for v in values])
+        self.assertEqual(valtys, fi.argument_types)
+
+        expect_types = [a.type for a in args]
+        got_types = [a.type for a in asargs]
+
+        self.assertEqual(expect_types, got_types)
+
+        # Assign names (check this doesn't raise)
+        fi.assign_names(values, ["arg%i" for i in range(len(fe_args))])
+
+        builder.ret_void()
+
+        ll.parse_assembly(str(module))
+
+    def test_int32_array_complex(self):
+        fe_args = [types.int32,
+                   types.Array(types.int32, 1, 'C'),
+                   types.complex64]
+        self._test_as_arguments(fe_args)
+
+    def test_two_arrays(self):
+        fe_args = [types.Array(types.int32, 1, 'C')] * 2
+        self._test_as_arguments(fe_args)
+
+    def test_two_0d_arrays(self):
+        fe_args = [types.Array(types.int32, 0, 'C')] * 2
+        self._test_as_arguments(fe_args)
+
+    def test_tuples(self):
+        fe_args = [types.UniTuple(types.int32, 2),
+                   types.UniTuple(types.int32, 3)]
+        self._test_as_arguments(fe_args)
+        # Tuple of struct-likes
+        arrty = types.Array(types.int32, 1, 'C')
+        fe_args = [types.UniTuple(arrty, 2),
+                   types.UniTuple(arrty, 3)]
+        self._test_as_arguments(fe_args)
+        # Nested tuple
+        fe_args = [types.UniTuple(types.UniTuple(types.int32, 2), 3)]
+        self._test_as_arguments(fe_args)
+
+    def test_empty_tuples(self):
+        # Empty tuple
+        fe_args = [types.UniTuple(types.int16, 0),
+                   types.Tuple(()),
+                   types.int32]
+        self._test_as_arguments(fe_args)
+
+    def test_nested_empty_tuples(self):
+        fe_args = [types.int32,
+                   types.UniTuple(types.Tuple(()), 2),
+                   types.int64]
+        self._test_as_arguments(fe_args)
+
+
+class TestMemInfo(unittest.TestCase):
+    def setUp(self):
+        self.dmm = datamodel.default_manager
+
+    def test_number(self):
+        ty = types.int32
+        dm = self.dmm[ty]
+        self.assertFalse(dm.contains_nrt_meminfo())
+
+    def test_array(self):
+        ty = types.int32[:]
+        dm = self.dmm[ty]
+        self.assertTrue(dm.contains_nrt_meminfo())
+
+    def test_tuple_of_number(self):
+        ty = types.UniTuple(dtype=types.int32, count=2)
+        dm = self.dmm[ty]
+        self.assertFalse(dm.contains_nrt_meminfo())
+
+    def test_tuple_of_array(self):
+        ty = types.UniTuple(dtype=types.int32[:], count=2)
+        dm = self.dmm[ty]
+        self.assertTrue(dm.contains_nrt_meminfo())
+
+
+class TestMisc(unittest.TestCase):
+
+    def test_issue2921(self):
+        import numpy as np
+        from numba import njit
+
+        @njit
+        def copy(a, b):
+            for i in range(a.shape[0]):
+                a[i] = b[i]
+
+        b = np.arange(5, dtype=np.uint8).view(np.bool_)
+        a = np.zeros_like(b)
+        copy(a, b)
+        np.testing.assert_equal(a, np.array((False,) + (True,) * 4))
+
+
+class TestDMMChaining(unittest.TestCase):
+    def test_basic(self):
+        dmm = DataModelManager()
+
+        class int_handler(OpaqueModel):
+            pass
+
+        class float_handler(OpaqueModel):
+            pass
+
+        dmm.register(types.Integer, int_handler)
+        dmm.register(types.Float, float_handler)
+
+        inter_dmm = DataModelManager()
+
+        class new_int_handler(OpaqueModel):
+            pass
+
+        inter_dmm.register(types.Integer, new_int_handler)
+        chained_dmm = inter_dmm.chain(dmm)
+
+        # Check that the chained DMM has the new handler
+        self.assertIsInstance(chained_dmm.lookup(types.intp), new_int_handler)
+        # and not the old handler
+        self.assertNotIsInstance(chained_dmm.lookup(types.intp), int_handler)
+        # Check that the base DMM has the old handler
+        self.assertIsInstance(dmm.lookup(types.intp), int_handler)
+        # Check that float goes to the float_handler
+        self.assertIsInstance(chained_dmm.lookup(types.float32), float_handler)
+        self.assertIsInstance(dmm.lookup(types.float32), float_handler)
+        # Check the intermediate DMM
+        self.assertIsInstance(inter_dmm.lookup(types.intp), new_int_handler)
+        with self.assertRaises(KeyError):
+            inter_dmm.lookup(types.float32)
+
+
+if __name__ == '__main__':
+    unittest.main()

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

@@ -0,0 +1,759 @@
+from collections import namedtuple
+import inspect
+import re
+import numpy as np
+import math
+from textwrap import dedent
+import unittest
+import warnings
+
+from numba.tests.support import (TestCase, override_config,
+                                 ignore_internal_warnings)
+from numba import jit, njit
+from numba.core import types
+from numba.core.datamodel import default_manager
+from numba.core.errors import NumbaDebugInfoWarning
+import llvmlite.binding as llvm
+
+#NOTE: These tests are potentially sensitive to changes in SSA or lowering
+# behaviour and may need updating should changes be made to the corresponding
+# algorithms.
+
+
+class TestDebugInfo(TestCase):
+    """
+    These tests only checks the compiled assembly for debuginfo.
+    """
+
+    def _getasm(self, fn, sig):
+        fn.compile(sig)
+        return fn.inspect_asm(sig)
+
+    def _check(self, fn, sig, expect):
+        asm = self._getasm(fn, sig=sig)
+        m = re.search(r"\.section.+debug", asm, re.I)
+        got = m is not None
+        self.assertEqual(expect, got, msg='debug info not found in:\n%s' % asm)
+
+    def test_no_debuginfo_in_asm(self):
+        @jit(nopython=True, debug=False)
+        def foo(x):
+            return x
+
+        self._check(foo, sig=(types.int32,), expect=False)
+
+    def test_debuginfo_in_asm(self):
+        @jit(nopython=True, debug=True)
+        def foo(x):
+            return x
+
+        self._check(foo, sig=(types.int32,), expect=True)
+
+    def test_environment_override(self):
+        with override_config('DEBUGINFO_DEFAULT', 1):
+            # Using default value
+            @jit(nopython=True)
+            def foo(x):
+                return x
+            self._check(foo, sig=(types.int32,), expect=True)
+
+            # User override default
+            @jit(nopython=True, debug=False)
+            def bar(x):
+                return x
+            self._check(bar, sig=(types.int32,), expect=False)
+
+    def test_llvm_inliner_flag_conflict(self):
+        # bar will be marked as 'alwaysinline', but when DEBUGINFO_DEFAULT is
+        # set functions are marked as 'noinline' this results in a conflict.
+        # baz will be marked as 'noinline' as a result of DEBUGINFO_DEFAULT
+
+        @njit(forceinline=True)
+        def bar(x):
+            return math.sin(x)
+
+        @njit(forceinline=False)
+        def baz(x):
+            return math.cos(x)
+
+        @njit
+        def foo(x):
+            a = bar(x)
+            b = baz(x)
+            return a, b
+
+        # check it compiles
+        with override_config('DEBUGINFO_DEFAULT', 1):
+            result = foo(np.pi)
+
+        self.assertPreciseEqual(result, foo.py_func(np.pi))
+
+        # check the LLVM IR has bar marked as 'alwaysinline' and baz as noinline
+        full_ir = foo.inspect_llvm(foo.signatures[0])
+        module = llvm.parse_assembly(full_ir)
+        name = foo.overloads[foo.signatures[0]].fndesc.mangled_name
+        funcs = [x for x in module.functions if x.name == name]
+        self.assertEqual(len(funcs), 1)
+        func = funcs[0]
+
+        # find the function calls and save the associated statements
+        f_names = []
+        for blk in func.blocks:
+            for stmt in blk.instructions:
+                if stmt.opcode == 'call':
+                    # stmt.function.name  This is the function being called
+                    f_names.append(str(stmt).strip())
+
+        # Need to check there's two specific things in the calls in the IR
+        # 1. a call to the llvm.sin.f64 intrinsic, this is from the inlined bar
+        # 2. a call to the baz function, this is from the noinline baz
+        found_sin = False
+        found_baz = False
+        baz_name = baz.overloads[baz.signatures[0]].fndesc.mangled_name
+        for x in f_names:
+            if not found_sin and re.match('.*llvm.sin.f64.*', x):
+                found_sin = True
+            if not found_baz and re.match(f'.*{baz_name}.*', x):
+                found_baz = True
+
+        self.assertTrue(found_sin)
+        self.assertTrue(found_baz)
+
+
+class TestDebugInfoEmission(TestCase):
+    """ Tests that debug info is emitted correctly.
+    """
+
+    _NUMBA_OPT_0_ENV = {'NUMBA_OPT': '0'}
+
+    def _get_llvmir(self, fn, sig):
+        with override_config('OPT', 0):
+            fn.compile(sig)
+            return fn.inspect_llvm(sig)
+
+    def _get_metadata(self, fn, sig):
+        ll = self._get_llvmir(fn, sig).splitlines()
+        meta_re = re.compile(r'![0-9]+ =.*')
+        metadata = []
+        for line in ll:
+            if meta_re.match(line):
+                metadata.append(line)
+        return metadata
+
+    def _get_metadata_map(self, metadata):
+        """Gets the map of DI label to md, e.g.
+        '!33' -> '!{!"branch_weights", i32 1, i32 99}'
+        """
+        metadata_definition_map = dict()
+        meta_definition_split = re.compile(r'(![0-9]+) = (.*)')
+        for line in metadata:
+            matched = meta_definition_split.match(line)
+            if matched:
+                dbg_val, info = matched.groups()
+                metadata_definition_map[dbg_val] = info
+        return metadata_definition_map
+
+    def _get_lines_from_debuginfo(self, metadata):
+        # Get the lines contained in the debug info
+        md_def_map = self._get_metadata_map(metadata)
+
+        lines = set()
+        for md in md_def_map.values():
+            m = re.match(r"!DILocation\(line: (\d+),", md)
+            if m:
+                ln = int(m.group(1))
+                lines.add(ln)
+        return lines
+
+    def test_DW_LANG(self):
+
+        @njit(debug=True)
+        def foo():
+            pass
+
+        metadata = self._get_metadata(foo, sig=())
+        DICompileUnit = metadata[0]
+        self.assertEqual('!0', DICompileUnit[:2])
+        self.assertIn('!DICompileUnit(language: DW_LANG_C_plus_plus',
+                      DICompileUnit)
+        self.assertIn('producer: "clang (Numba)"', DICompileUnit)
+
+    def test_DILocation(self):
+        """ Tests that DILocation information is reasonable.
+        """
+        @njit(debug=True, error_model='numpy')
+        def foo(a):
+            b = a + 1.23
+            c = b * 2.34
+            d = b / c
+            print(d)
+            return d
+
+        # the above produces LLVM like:
+        # define function() {
+        # entry:
+        #   alloca
+        #   store 0 to alloca
+        #   <arithmetic for doing the operations on b, c, d>
+        #   setup for print
+        #   branch
+        # other_labels:
+        # ... <elided>
+        # }
+        #
+        # The following checks that:
+        # * the alloca and store have no !dbg
+        # * the arithmetic occurs in the order defined and with !dbg
+        # * that the !dbg entries are monotonically increasing in value with
+        #   source line number
+
+        sig = (types.float64,)
+        metadata = self._get_metadata(foo, sig=sig)
+        full_ir = self._get_llvmir(foo, sig=sig)
+
+        module = llvm.parse_assembly(full_ir)
+
+        name = foo.overloads[foo.signatures[0]].fndesc.mangled_name
+        funcs = [x for x in module.functions if x.name == name]
+        self.assertEqual(len(funcs), 1)
+        func = funcs[0]
+        blocks = [x for x in func.blocks]
+        self.assertGreater(len(blocks), 1)
+        block = blocks[0]
+
+        # Find non-call/non-memory instr and check the sequence is as expected
+        instrs = [x for x in block.instructions if x.opcode not in
+                  ['call', 'load', 'store']]
+        op_expect = {'fadd', 'fmul', 'fdiv'}
+        started = False
+        for x in instrs:
+            if x.opcode in op_expect:
+                op_expect.remove(x.opcode)
+                if not started:
+                    started = True
+            elif op_expect and started:
+                self.fail("Math opcodes are not contiguous")
+        self.assertFalse(op_expect, "Math opcodes were not found")
+
+        # Parse out metadata from end of each line, check it monotonically
+        # ascends with LLVM source line. Also store all the dbg references,
+        # these will be checked later.
+        line2dbg = set()
+        re_dbg_ref = re.compile(r'.*!dbg (![0-9]+).*$')
+        found = -1
+        for instr in instrs:
+            inst_as_str = str(instr)
+            matched = re_dbg_ref.match(inst_as_str)
+            if not matched:
+                # if there's no match, ensure it is one of alloca or store,
+                # it's important that the zero init/alloca instructions have
+                # no dbg data
+                accepted = ('alloca ', 'store ')
+                self.assertTrue(any([x in inst_as_str for x in accepted]))
+                continue
+            groups = matched.groups()
+            self.assertEqual(len(groups), 1)
+            dbg_val = groups[0]
+            int_dbg_val = int(dbg_val[1:])
+            if found >= 0:
+                self.assertTrue(int_dbg_val >= found)
+            found = int_dbg_val
+            # some lines will alias dbg info, this is fine, it's only used to
+            # make sure that the line numbers are correct WRT python
+            line2dbg.add(dbg_val)
+
+        pysrc, pysrc_line_start = inspect.getsourcelines(foo)
+
+        # build a map of dbg reference to DI* information
+        metadata_definition_map = self._get_metadata_map(metadata)
+
+        # Pull out metadata entries referred to by the llvm line end !dbg
+        # check they match the python source, the +2 is for the @njit decorator
+        # and the function definition line.
+        offsets = [0,  # b = a + 1
+                   1,  # a * 2.34
+                   2,  # d = b / c
+                   3,  # print(d)
+                   ]
+        pyln_range = [pysrc_line_start + 2 + x for x in offsets]
+
+        # do the check
+        for (k, line_no) in zip(sorted(line2dbg, key=lambda x: int(x[1:])),
+                                pyln_range):
+            dilocation_info = metadata_definition_map[k]
+            self.assertIn(f'line: {line_no}', dilocation_info)
+
+        # Check that variable "a" is declared as on the same line as function
+        # definition.
+        expr = r'.*!DILocalVariable\(name: "a",.*line: ([0-9]+),.*'
+        match_local_var_a = re.compile(expr)
+        for entry in metadata_definition_map.values():
+            matched = match_local_var_a.match(entry)
+            if matched:
+                groups = matched.groups()
+                self.assertEqual(len(groups), 1)
+                dbg_line = int(groups[0])
+                # +1 for the decorator.
+                # Recall that Numba's DWARF refers to the "def" line, but
+                # `inspect` uses the decorator as the first line.
+                defline = pysrc_line_start + 1
+                self.assertEqual(dbg_line, defline)
+                break
+        else:
+            self.fail('Assertion on DILocalVariable not made')
+
+    @TestCase.run_test_in_subprocess(envvars=_NUMBA_OPT_0_ENV)
+    def test_DILocation_entry_blk(self):
+        # Needs a subprocess as jitting literally anything at any point in the
+        # lifetime of the process ends up with a codegen at opt 3. This is not
+        # amenable to this test!
+        # This test relies on the CFG not being simplified as it checks the jump
+        # from the entry block to the first basic block. Force OPT as 0, if set
+        # via the env var the targetmachine and various pass managers all end up
+        # at OPT 0 and the IR is minimally transformed prior to lowering to ELF.
+        #
+        # This tests that the unconditional jump emitted at the tail of
+        # the entry block has no debug metadata associated with it. In practice,
+        # if debug metadata is associated with it, it manifests as the
+        # prologue_end being associated with the end_sequence or similar (due to
+        # the way code gen works for the entry block).
+
+        @njit(debug=True)
+        def foo(a):
+            return a + 1
+        foo(123)
+
+        full_ir = foo.inspect_llvm(foo.signatures[0])
+        # The above produces LLVM like:
+        #
+        # define function() {
+        # entry:
+        #   alloca
+        #   store 0 to alloca
+        #   unconditional jump to body:
+        #
+        # body:
+        # ... <elided>
+        # }
+
+        module = llvm.parse_assembly(full_ir)
+        name = foo.overloads[foo.signatures[0]].fndesc.mangled_name
+        funcs = [x for x in module.functions if x.name == name]
+        self.assertEqual(len(funcs), 1)
+        func = funcs[0]
+        blocks = [x for x in func.blocks]
+        self.assertEqual(len(blocks), 2)
+        entry_block, body_block = blocks
+
+        # Assert that the tail of the entry block is an unconditional jump to
+        # the body block and that the jump has no associated debug info.
+        entry_instr = [x for x in entry_block.instructions]
+        ujmp = entry_instr[-1]
+        self.assertEqual(ujmp.opcode, 'br')
+        ujmp_operands = [x for x in ujmp.operands]
+        self.assertEqual(len(ujmp_operands), 1)
+        target_data = ujmp_operands[0]
+        target = str(target_data).split(':')[0].strip()
+        # check the unconditional jump target is to the body block
+        self.assertEqual(target, body_block.name)
+        # check the uncondition jump instr itself has no metadata
+        self.assertTrue(str(ujmp).endswith(target))
+
+    @TestCase.run_test_in_subprocess(envvars=_NUMBA_OPT_0_ENV)
+    def test_DILocation_decref(self):
+        """ This tests that decref's generated from `ir.Del`s as variables go
+        out of scope do not have debuginfo associated with them (the location of
+        `ir.Del` is an implementation detail).
+        """
+
+        @njit(debug=True)
+        def sink(*x):
+            pass
+
+        # This function has many decrefs!
+        @njit(debug=True)
+        def foo(a):
+            x = (a, a)
+            if a[0] == 0:
+                sink(x)
+                return 12
+            z = x[0][0]
+            return z
+
+        sig = (types.float64[::1],)
+        full_ir = self._get_llvmir(foo, sig=sig)
+
+        # make sure decref lines end with `meminfo.<number>)` without !dbg info.
+        count = 0
+        for line in full_ir.splitlines():
+            line_stripped = line.strip()
+            if line_stripped.startswith('call void @NRT_decref'):
+                self.assertRegex(line, r'.*meminfo\.[0-9]+\)$')
+                count += 1
+        self.assertGreater(count, 0) # make sure there were some decrefs!
+
+    def test_DILocation_undefined(self):
+        """ Tests that DILocation information for undefined vars is associated
+        with the line of the function definition (so it ends up in the prologue)
+        """
+        @njit(debug=True)
+        def foo(n):
+            if n:
+                if n > 0:
+                    c = 0
+                return c
+            else:
+                # variable c is not defined in this branch
+                c += 1
+                return c
+
+        sig = (types.intp,)
+        metadata = self._get_metadata(foo, sig=sig)
+        pysrc, pysrc_line_start = inspect.getsourcelines(foo)
+        # Looks for versions of variable "c" and captures the line number
+        expr = r'.*!DILocalVariable\(name: "c\$?[0-9]?",.*line: ([0-9]+),.*'
+        matcher = re.compile(expr)
+        associated_lines = set()
+        for md in metadata:
+            match = matcher.match(md)
+            if match:
+                groups = match.groups()
+                self.assertEqual(len(groups), 1)
+                associated_lines.add(int(groups[0]))
+        # 3 versions of 'c': `c = 0`, `return c`, `c+=1`
+        self.assertEqual(len(associated_lines), 3)
+        self.assertIn(pysrc_line_start, associated_lines)
+
+    def test_DILocation_versioned_variables(self):
+        """ Tests that DILocation information for versions of variables matches
+        up to their definition site."""
+        # Note: there's still something wrong in the DI/SSA naming, the ret c is
+        # associated with the logically first definition.
+
+        @njit(debug=True)
+        def foo(n):
+            if n:
+                c = 5
+            else:
+                c = 1
+            # prevents inline of return on py310
+            py310_defeat1 = 1  # noqa
+            py310_defeat2 = 2  # noqa
+            py310_defeat3 = 3  # noqa
+            py310_defeat4 = 4  # noqa
+            return c
+
+        sig = (types.intp,)
+        metadata = self._get_metadata(foo, sig=sig)
+        pysrc, pysrc_line_start = inspect.getsourcelines(foo)
+
+        # Looks for SSA versioned names i.e. <basename>$<version id> of the
+        # variable 'c' and captures the line
+        expr = r'.*!DILocalVariable\(name: "c\$[0-9]?",.*line: ([0-9]+),.*'
+        matcher = re.compile(expr)
+        associated_lines = set()
+        for md in metadata:
+            match = matcher.match(md)
+            if match:
+                groups = match.groups()
+                self.assertEqual(len(groups), 1)
+                associated_lines.add(int(groups[0]))
+        self.assertEqual(len(associated_lines), 2) # 2 SSA versioned names 'c'
+
+        # Now find the `c = ` lines in the python source
+        py_lines = set()
+        for ix, pyln in enumerate(pysrc):
+            if 'c = ' in pyln:
+                py_lines.add(ix + pysrc_line_start)
+        self.assertEqual(len(py_lines), 2) # 2 assignments to c
+
+        # check that the DILocation from the DI for `c` matches the python src
+        self.assertEqual(associated_lines, py_lines)
+
+    def test_numeric_scalars(self):
+        """ Tests that dwarf info is correctly emitted for numeric scalars."""
+
+        DI = namedtuple('DI', 'name bits encoding')
+
+        type_infos = {np.float32: DI("float32", 32, "DW_ATE_float"),
+                      np.float64: DI("float64", 64, "DW_ATE_float"),
+                      np.int8: DI("int8", 8, "DW_ATE_signed"),
+                      np.int16: DI("int16", 16, "DW_ATE_signed"),
+                      np.int32: DI("int32", 32, "DW_ATE_signed"),
+                      np.int64: DI("int64", 64, "DW_ATE_signed"),
+                      np.uint8: DI("uint8", 8, "DW_ATE_unsigned"),
+                      np.uint16: DI("uint16", 16, "DW_ATE_unsigned"),
+                      np.uint32: DI("uint32", 32, "DW_ATE_unsigned"),
+                      np.uint64: DI("uint64", 64, "DW_ATE_unsigned"),
+                      np.complex64: DI("complex64", 64,
+                                       "DW_TAG_structure_type"),
+                      np.complex128: DI("complex128", 128,
+                                        "DW_TAG_structure_type"),}
+
+        for ty, dwarf_info in type_infos.items():
+
+            @njit(debug=True)
+            def foo():
+                a = ty(10)
+                return a
+
+            metadata = self._get_metadata(foo, sig=())
+            metadata_definition_map = self._get_metadata_map(metadata)
+
+            for k, v in metadata_definition_map.items():
+                if 'DILocalVariable(name: "a"' in v:
+                    lvar = metadata_definition_map[k]
+                    break
+            else:
+                assert 0, "missing DILocalVariable 'a'"
+
+            type_marker = re.match('.*type: (![0-9]+).*', lvar).groups()[0]
+            type_decl = metadata_definition_map[type_marker]
+
+            if 'DW_ATE' in dwarf_info.encoding:
+                expected = (f'!DIBasicType(name: "{dwarf_info.name}", '
+                            f'size: {dwarf_info.bits}, '
+                            f'encoding: {dwarf_info.encoding})')
+                self.assertEqual(type_decl, expected)
+            else: # numerical complex type
+                # Don't match the whole string, just the known parts
+                raw_flt = 'float' if dwarf_info.bits == 64 else 'double'
+                expected = (f'distinct !DICompositeType('
+                            f'tag: {dwarf_info.encoding}, '
+                            f'name: "{dwarf_info.name} '
+                            f'({{{raw_flt}, {raw_flt}}})", '
+                            f'size: {dwarf_info.bits}')
+                self.assertIn(expected, type_decl)
+
+    def test_arrays(self):
+
+        @njit(debug=True)
+        def foo():
+            a = np.ones((2, 3), dtype=np.float64)
+            return a
+
+        metadata = self._get_metadata(foo, sig=())
+        metadata_definition_map = self._get_metadata_map(metadata)
+
+        for k, v in metadata_definition_map.items():
+            if 'DILocalVariable(name: "a"' in v:
+                lvar = metadata_definition_map[k]
+                break
+        else:
+            assert 0, "missing DILocalVariable 'a'"
+
+        type_marker = re.match('.*type: (![0-9]+).*', lvar).groups()[0]
+        type_decl = metadata_definition_map[type_marker]
+
+        # check type
+        self.assertIn("!DICompositeType(tag: DW_TAG_structure_type", type_decl)
+        # check name encoding
+        self.assertIn(f'name: "{str(types.float64[:, ::1])}', type_decl)
+
+        # pop out the "elements" of the composite type
+        match_elements = re.compile(r'.*elements: (![0-9]+),.*')
+        elem_matches = match_elements.match(type_decl).groups()
+        self.assertEqual(len(elem_matches), 1)
+        elem_match = elem_matches[0]
+        # The match should be something like, it's the elements from an array
+        # data model.
+        # !{!35, !36, !37, !39, !40, !43, !45}'
+        struct_markers = metadata_definition_map[elem_match]
+        struct_pattern = '!{' + '(![0-9]+), ' * 6 + '(![0-9]+)}'
+        match_struct = re.compile(struct_pattern)
+        struct_member_matches = match_struct.match(struct_markers).groups()
+        self.assertIsNotNone(struct_member_matches is not None)
+        data_model = default_manager.lookup(types.float64[:, ::1])
+        self.assertEqual(len(struct_member_matches), len(data_model._fields))
+
+        ptr_size = types.intp.bitwidth
+        ptr_re = (r'!DIDerivedType\(tag: DW_TAG_pointer_type, '
+                  rf'baseType: ![0-9]+, size: {ptr_size}\)')
+        int_re = (rf'!DIBasicType\(name: "int{ptr_size}", size: {ptr_size}, '
+                  r'encoding: DW_ATE_signed\)')
+        utuple_re = (r'!DICompositeType\(tag: DW_TAG_array_type, '
+                     rf'name: "UniTuple\(int{ptr_size} x 2\) '
+                     rf'\(\[2 x i{ptr_size}\]\)", baseType: ![0-9]+, '
+                     rf'size: {2 * ptr_size}, elements: ![0-9]+, '
+                     rf'identifier: "\[2 x i{ptr_size}\]"\)')
+        expected = {'meminfo': ptr_re,
+                    'parent': ptr_re,
+                    'nitems': int_re,
+                    'itemsize': int_re,
+                    'data': ptr_re,
+                    'shape': utuple_re,
+                    'strides': utuple_re}
+
+        # look for `baseType: <>` for the type
+        base_type_pattern = r'!DIDerivedType\(.*, baseType: (![0-9]+),.*'
+        base_type_matcher = re.compile(base_type_pattern)
+
+        for ix, field in enumerate(data_model._fields):
+            derived_type = metadata_definition_map[struct_member_matches[ix]]
+            self.assertIn("DIDerivedType", derived_type)
+            self.assertIn(f'name: "{field}"', derived_type)
+            base_type_match = base_type_matcher.match(derived_type)
+            base_type_matches = base_type_match.groups()
+            self.assertEqual(len(base_type_matches), 1)
+            base_type_marker = base_type_matches[0]
+            data_type = metadata_definition_map[base_type_marker]
+            self.assertRegex(data_type, expected[field])
+
+    def test_debug_optnone(self):
+        def get_debug_lines(fn):
+            metadata = self._get_metadata(fn, fn.signatures[0])
+            lines = self._get_lines_from_debuginfo(metadata)
+            return lines
+
+        def get_func_attrs(fn):
+            cres = fn.overloads[fn.signatures[0]]
+            lib = cres.library
+            fn = lib._final_module.get_function(cres.fndesc.mangled_name)
+            attrs = set(b' '.join(fn.attributes).split())
+            return attrs
+
+        def foo():
+            n = 10
+            c = 0
+            for i in range(n):
+                c += i
+            return c
+
+        foo_debug = njit(debug=True)(foo)
+        foo_debug_optnone = njit(debug=True, _dbg_optnone=True)(foo)
+        foo_debug_optnone_inline = njit(debug=True, _dbg_optnone=True,
+                                        forceinline=True)(foo)
+
+        firstline = foo.__code__.co_firstlineno
+
+        expected_info = {}
+        expected_info[foo_debug] = dict(
+            # just the dummy line-0 and the line of the return statement
+            lines={0, firstline + 5},
+            must_have_attrs=set(),
+            must_not_have_attrs=set([b"optnone"]),
+        )
+        expected_info[foo_debug_optnone] = dict(
+            # all the lines should be included
+            lines=set(range(firstline + 1, firstline + 6)),
+            must_have_attrs=set([b"optnone"]),
+            must_not_have_attrs=set(),
+        )
+        expected_info[foo_debug_optnone_inline] = dict(
+            # optnone=True is overridden by forceinline, so this looks like the
+            # foo_debug version
+            lines={0, firstline + 5},
+            must_have_attrs=set([b"alwaysinline"]),
+            must_not_have_attrs=set([b"optnone"]),
+        )
+
+        expected_ret = foo()
+
+        for udt, expected in expected_info.items():
+            with self.subTest(udt.targetoptions):
+                got = udt()
+                self.assertEqual(got, expected_ret)
+
+                # Compare the line locations in the debug info.
+                self.assertEqual(get_debug_lines(udt), expected["lines"])
+
+                # Check for attributes on the LLVM function
+                attrs = get_func_attrs(udt)
+                must_have = expected["must_have_attrs"]
+                self.assertEqual(attrs & must_have, must_have)
+                must_not_have = expected["must_not_have_attrs"]
+                self.assertFalse(attrs & must_not_have)
+
+    def test_omitted_arg(self):
+        # See issue 7726
+        @njit(debug=True)
+        def foo(missing=None):
+            pass
+
+        # check that it will actually compile (verifies DI emission is ok)
+        with override_config('DEBUGINFO_DEFAULT', 1):
+            foo()
+
+        metadata = self._get_metadata(foo, sig=(types.Omitted(None),))
+        metadata_definition_map = self._get_metadata_map(metadata)
+
+        # Find DISubroutineType
+        tmp_disubr = []
+        for md in metadata:
+            if "DISubroutineType" in md:
+                tmp_disubr.append(md)
+        self.assertEqual(len(tmp_disubr), 1)
+        disubr = tmp_disubr.pop()
+
+        disubr_matched = re.match(r'.*!DISubroutineType\(types: ([!0-9]+)\)$',
+                                  disubr)
+        self.assertIsNotNone(disubr_matched)
+        disubr_groups = disubr_matched.groups()
+        self.assertEqual(len(disubr_groups), 1)
+        disubr_meta = disubr_groups[0]
+
+        # Find the types in the DISubroutineType arg list
+        disubr_types = metadata_definition_map[disubr_meta]
+        disubr_types_matched = re.match(r'!{(.*)}', disubr_types)
+        self.assertIsNotNone(disubr_matched)
+        disubr_types_groups = disubr_types_matched.groups()
+        self.assertEqual(len(disubr_types_groups), 1)
+
+        # fetch out and assert the last argument type, should be void *
+        md_fn_arg = [x.strip() for x in disubr_types_groups[0].split(',')][-1]
+        arg_ty = metadata_definition_map[md_fn_arg]
+        expected_arg_ty = (r'^.*!DICompositeType\(tag: DW_TAG_structure_type, '
+                           r'name: "Anonymous struct \({}\)", elements: '
+                           r'(![0-9]+), identifier: "{}"\)')
+        self.assertRegex(arg_ty, expected_arg_ty)
+        md_base_ty = re.match(expected_arg_ty, arg_ty).groups()[0]
+        base_ty = metadata_definition_map[md_base_ty]
+        # expect ir.LiteralStructType([])
+        self.assertEqual(base_ty, ('!{}'))
+
+    def test_missing_source(self):
+        strsrc = """
+        def foo():
+            return 1
+        """
+        l = dict()
+        exec(dedent(strsrc), {}, l)
+        foo = njit(debug=True)(l['foo'])
+
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter('always', NumbaDebugInfoWarning)
+            ignore_internal_warnings()
+            foo()
+
+        self.assertEqual(len(w), 1)
+        found = w[0]
+        self.assertEqual(found.category, NumbaDebugInfoWarning)
+        msg = str(found.message)
+        # make sure the warning contains the right message
+        self.assertIn('Could not find source for function', msg)
+        # and refers to the offending function
+        self.assertIn(str(foo.py_func), msg)
+
+    def test_irregularly_indented_source(self):
+
+        @njit(debug=True)
+        def foo():
+# NOTE: THIS COMMENT MUST START AT COLUMN 0 FOR THIS SAMPLE CODE TO BE VALID # noqa: E115, E501
+            return 1
+
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter('always', NumbaDebugInfoWarning)
+            ignore_internal_warnings()
+            foo()
+
+        # No warnings
+        self.assertEqual(len(w), 0)
+
+        metadata = self._get_metadata(foo, foo.signatures[0])
+        lines = self._get_lines_from_debuginfo(metadata)
+        # Only one line
+        self.assertEqual(len(lines), 1)
+
+
+if __name__ == '__main__':
+    unittest.main()

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

@@ -0,0 +1,656 @@
+"""
+Testing C implementation of the numba dictionary
+"""
+
+import ctypes
+import random
+
+from numba.tests.support import TestCase
+from numba import _helperlib, jit, typed, types
+from numba.core.config import IS_32BITS
+from numba.core.datamodel.models import UniTupleModel
+from numba.extending import register_model, typeof_impl, unbox, overload
+
+
+DKIX_EMPTY = -1
+
+
+ALIGN = 4 if IS_32BITS else 8
+
+
+class Dict(object):
+    """A wrapper around the C-API to provide a minimal dictionary object for
+    testing.
+    """
+    def __init__(self, tc, keysize, valsize):
+        """
+        Parameters
+        ----------
+        tc : TestCase instance
+        keysize : int
+            byte size for the key
+        valsize : int
+            byte size for the value
+        """
+        self.tc = tc
+        self.keysize = keysize
+        self.valsize = valsize
+        self.dp = self.dict_new_minsize(keysize, valsize)
+
+    def __del__(self):
+        self.tc.numba_dict_free(self.dp)
+
+    def __len__(self):
+        return self.dict_length()
+
+    def __setitem__(self, k, v):
+        bk = bytes(k.encode())
+        bv = bytes(v.encode())
+        self.tc.assertEqual(len(bk), self.keysize)
+        self.tc.assertEqual(len(bv), self.valsize)
+        self.dict_insert(bk, bv)
+
+    def __getitem__(self, k):
+        bk = bytes(k.encode())
+        self.tc.assertEqual(len(bk), self.keysize)
+        ix, old = self.dict_lookup(bk)
+        if ix == DKIX_EMPTY:
+            raise KeyError
+        else:
+            return old.decode()
+
+    def __delitem__(self, k):
+        bk = bytes(k.encode())
+        self.tc.assertEqual(len(bk), self.keysize)
+        if not self.dict_delitem(bk):
+            raise KeyError(k)
+
+    def get(self, k):
+        try:
+            return self[k]
+        except KeyError:
+            return
+
+    def items(self):
+        return DictIter(self)
+
+    def popitem(self):
+        k, v = self.dict_popitem()
+        return k.decode(), v.decode()
+
+    #
+    # The methods below are higher-level wrappers for the C-API
+    #
+
+    def dict_new_minsize(self, key_size, val_size):
+        dp = ctypes.c_void_p()
+        status = self.tc.numba_dict_new_sized(
+            ctypes.byref(dp), 0, key_size, val_size,
+        )
+        self.tc.assertEqual(status, 0)
+        return dp
+
+    def dict_length(self):
+        return self.tc.numba_dict_length(self.dp)
+
+    def dict_insert(self, key_bytes, val_bytes):
+        hashval = hash(key_bytes)
+        status = self.tc.numba_dict_insert_ez(
+            self.dp, key_bytes, hashval, val_bytes,
+        )
+        self.tc.assertGreaterEqual(status, 0)
+
+    def dict_lookup(self, key_bytes):
+        hashval = hash(key_bytes)
+        oldval_bytes = ctypes.create_string_buffer(self.valsize)
+        ix = self.tc.numba_dict_lookup(
+            self.dp, key_bytes, hashval, oldval_bytes,
+        )
+        self.tc.assertGreaterEqual(ix, DKIX_EMPTY)
+        return ix, oldval_bytes.value
+
+    def dict_delitem(self, key_bytes):
+        ix, oldval = self.dict_lookup(key_bytes)
+        if ix == DKIX_EMPTY:
+            return False
+        hashval = hash(key_bytes)
+        status = self.tc.numba_dict_delitem(self.dp, hashval, ix)
+        self.tc.assertEqual(status, 0)
+        return True
+
+    def dict_popitem(self):
+        key_bytes = ctypes.create_string_buffer(self.keysize)
+        val_bytes = ctypes.create_string_buffer(self.valsize)
+        status = self.tc.numba_dict_popitem(self.dp, key_bytes, val_bytes)
+        if status != 0:
+            if status == -4:
+                raise KeyError('popitem(): dictionary is empty')
+            else:
+                self.tc._fail('Unknown')
+        return key_bytes.value, val_bytes.value
+
+    def dict_iter(self, itptr):
+        self.tc.numba_dict_iter(itptr, self.dp)
+
+    def dict_iter_next(self, itptr):
+        bk = ctypes.c_void_p(0)
+        bv = ctypes.c_void_p(0)
+        status = self.tc.numba_dict_iter_next(
+            itptr, ctypes.byref(bk), ctypes.byref(bv),
+        )
+        if status == -2:
+            raise ValueError('dictionary mutated')
+        elif status == -3:
+            return
+        else:
+            self.tc.assertGreaterEqual(status, 0)
+
+            # Check the alignment of the key-value in the entries.
+            # We know we are getting the pointers to data in the entries.
+
+            self.tc.assertEqual(bk.value % ALIGN, 0, msg='key not aligned')
+            self.tc.assertEqual(bv.value % ALIGN, 0, msg='val not aligned')
+
+            key = (ctypes.c_char * self.keysize).from_address(bk.value)
+            val = (ctypes.c_char * self.valsize).from_address(bv.value)
+            return key.value, val.value
+
+
+class DictIter(object):
+    """A iterator for the `Dict.items()`.
+
+    Only the `.items()` is needed.  `.keys` and `.values` can be trivially
+    implemented on the `.items` iterator.
+    """
+    def __init__(self, parent):
+        self.parent = parent
+        itsize = self.parent.tc.numba_dict_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.dict_iter(self.it)
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        out = self.parent.dict_iter_next(self.it)
+        if out is None:
+            raise StopIteration
+        else:
+            k, v = out
+            return k.decode(), v.decode()
+
+    next = __next__    # needed for py2 only
+
+
+class Parametrized(tuple):
+    """supporting type for TestDictImpl.test_parametrized_types
+    needs to be global to be cacheable"""
+    def __init__(self, tup):
+        assert all(isinstance(v, str) for v in tup)
+
+
+class ParametrizedType(types.Type):
+    """this is essentially UniTuple(unicode_type, n)
+    BUT type name is the same for all n"""
+
+    def __init__(self, value):
+        super(ParametrizedType, self).__init__('ParametrizedType')
+        self.dtype = types.unicode_type
+        self.n = len(value)
+
+    @property
+    def key(self):
+        return self.n
+
+    def __len__(self):
+        return self.n
+
+
+class TestDictImpl(TestCase):
+    def setUp(self):
+        """Bind to the c_helper library and provide the ctypes wrapper.
+        """
+        dict_t = ctypes.c_void_p
+        iter_t = ctypes.c_void_p
+        hash_t = ctypes.c_ssize_t
+
+        def wrap(name, restype, argtypes=()):
+            proto = ctypes.CFUNCTYPE(restype, *argtypes)
+            return proto(_helperlib.c_helpers[name])
+
+        # numba_test_dict()
+        self.numba_test_dict = wrap(
+            'test_dict',
+            ctypes.c_int,
+        )
+        # numba_dict_new_sized(
+        #    NB_Dict **out,
+        #    Py_ssize_t n_keys,
+        #    Py_ssize_t key_size,
+        #    Py_ssize_t val_size
+        # )
+        self.numba_dict_new_sized = wrap(
+            'dict_new_sized',
+            ctypes.c_int,
+            [
+                ctypes.POINTER(dict_t),  # out
+                ctypes.c_ssize_t,        # n_keys
+                ctypes.c_ssize_t,        # key_size
+                ctypes.c_ssize_t,        # val_size
+            ],
+        )
+        # numba_dict_free(NB_Dict *d)
+        self.numba_dict_free = wrap(
+            'dict_free',
+            None,
+            [dict_t],
+        )
+        # numba_dict_length(NB_Dict *d)
+        self.numba_dict_length = wrap(
+            'dict_length',
+            ctypes.c_ssize_t,
+            [dict_t],
+        )
+        # numba_dict_insert_ez(
+        #     NB_Dict    *d,
+        #     const char *key_bytes,
+        #     Py_hash_t   hash,
+        #     const char *val_bytes,
+        #     )
+        self.numba_dict_insert_ez = wrap(
+            'dict_insert_ez',
+            ctypes.c_int,
+            [
+                dict_t,             # d
+                ctypes.c_char_p,    # key_bytes
+                hash_t,             # hash
+                ctypes.c_char_p,    # val_bytes
+            ],
+        )
+        # numba_dict_lookup(
+        #       NB_Dict *d,
+        #       const char *key_bytes,
+        #       Py_hash_t hash,
+        #       char *oldval_bytes
+        # )
+        self.numba_dict_lookup = wrap(
+            'dict_lookup',
+            ctypes.c_ssize_t,
+            [
+                dict_t,             # d
+                ctypes.c_char_p,    # key_bytes
+                hash_t,             # hash
+                ctypes.c_char_p,    # oldval_bytes
+            ],
+        )
+        # numba_dict_delitem(
+        #     NB_Dict *d,
+        #     Py_hash_t hash,
+        #     Py_ssize_t ix
+        # )
+        self.numba_dict_delitem = wrap(
+            'dict_delitem',
+            ctypes.c_int,
+            [
+                dict_t,             # d
+                hash_t,             # hash
+                ctypes.c_ssize_t,   # ix
+            ],
+        )
+        # numba_dict_popitem(
+        #   NB_Dict *d,
+        #   char *key_bytes,
+        #   char *val_bytes
+        # )
+        self.numba_dict_popitem = wrap(
+            'dict_popitem',
+            ctypes.c_int,
+            [
+                dict_t,             # d
+                ctypes.c_char_p,    # key_bytes
+                ctypes.c_char_p,    # val_bytes
+            ],
+        )
+        # numba_dict_iter_sizeof()
+        self.numba_dict_iter_sizeof = wrap(
+            'dict_iter_sizeof',
+            ctypes.c_size_t,
+        )
+        # numba_dict_iter(
+        #     NB_DictIter *it,
+        #     NB_Dict     *d
+        # )
+        self.numba_dict_iter = wrap(
+            'dict_iter',
+            None,
+            [
+                iter_t,
+                dict_t,
+            ],
+        )
+        # numba_dict_iter_next(
+        #     NB_DictIter *it,
+        #     const char **key_ptr,
+        #     const char **val_ptr
+        # )
+        self.numba_dict_iter_next = wrap(
+            'dict_iter_next',
+            ctypes.c_int,
+            [
+                iter_t,                             # it
+                ctypes.POINTER(ctypes.c_void_p),    # key_ptr
+                ctypes.POINTER(ctypes.c_void_p),    # val_ptr
+            ],
+        )
+
+    def test_simple_c_test(self):
+        # Runs the basic test in C.
+        ret = self.numba_test_dict()
+        self.assertEqual(ret, 0)
+
+    def test_insertion_small(self):
+        # Tests insertion and lookup for a small dict.
+        d = Dict(self, 4, 8)
+        self.assertEqual(len(d), 0)
+        self.assertIsNone(d.get('abcd'))
+
+        # First key
+        d['abcd'] = 'beefcafe'
+        self.assertEqual(len(d), 1)
+        self.assertIsNotNone(d.get('abcd'))
+        self.assertEqual(d['abcd'], 'beefcafe')
+
+        # Duplicated key replaces
+        d['abcd'] = 'cafe0000'
+        self.assertEqual(len(d), 1)
+        self.assertEqual(d['abcd'], 'cafe0000')
+
+        # Second key
+        d['abce'] = 'cafe0001'
+        self.assertEqual(len(d), 2)
+        self.assertEqual(d['abcd'], 'cafe0000')
+        self.assertEqual(d['abce'], 'cafe0001')
+
+        # Third key
+        d['abcf'] = 'cafe0002'
+        self.assertEqual(len(d), 3)
+        self.assertEqual(d['abcd'], 'cafe0000')
+        self.assertEqual(d['abce'], 'cafe0001')
+        self.assertEqual(d['abcf'], 'cafe0002')
+
+    def check_insertion_many(self, nmax):
+        # Helper to test insertion/lookup/resize
+        d = Dict(self, 8, 8)
+
+        def make_key(v):
+            return "key_{:04}".format(v)
+
+        def make_val(v):
+            return "val_{:04}".format(v)
+
+        # Check insert
+        for i in range(nmax):
+            d[make_key(i)] = make_val(i)
+            self.assertEqual(len(d), i + 1)
+
+        # Check lookup
+        for i in range(nmax):
+            self.assertEqual(d[make_key(i)], make_val(i))
+
+    def test_insertion_many(self):
+        # Test insertion for differently sized dict
+        # Around minsize
+        self.check_insertion_many(nmax=7)
+        self.check_insertion_many(nmax=8)
+        self.check_insertion_many(nmax=9)
+        # Around nmax = 32
+        self.check_insertion_many(nmax=31)
+        self.check_insertion_many(nmax=32)
+        self.check_insertion_many(nmax=33)
+        # Around nmax = 1024
+        self.check_insertion_many(nmax=1023)
+        self.check_insertion_many(nmax=1024)
+        self.check_insertion_many(nmax=1025)
+        # Around nmax = 4096
+        self.check_insertion_many(nmax=4095)
+        self.check_insertion_many(nmax=4096)
+        self.check_insertion_many(nmax=4097)
+
+    def test_deletion_small(self):
+        # Test deletion
+        d = Dict(self, 4, 8)
+        self.assertEqual(len(d), 0)
+        self.assertIsNone(d.get('abcd'))
+
+        d['abcd'] = 'cafe0000'
+        d['abce'] = 'cafe0001'
+        d['abcf'] = 'cafe0002'
+
+        self.assertEqual(len(d), 3)
+        self.assertEqual(d['abcd'], 'cafe0000')
+        self.assertEqual(d['abce'], 'cafe0001')
+        self.assertEqual(d['abcf'], 'cafe0002')
+        self.assertEqual(len(d), 3)
+
+        # Delete first item
+        del d['abcd']
+        self.assertIsNone(d.get('abcd'))
+        self.assertEqual(d['abce'], 'cafe0001')
+        self.assertEqual(d['abcf'], 'cafe0002')
+        self.assertEqual(len(d), 2)
+
+        # Delete first item again
+        with self.assertRaises(KeyError):
+            del d['abcd']
+
+        # Delete third
+        del d['abcf']
+        self.assertIsNone(d.get('abcd'))
+        self.assertEqual(d['abce'], 'cafe0001')
+        self.assertIsNone(d.get('abcf'))
+        self.assertEqual(len(d), 1)
+
+        # Delete second
+        del d['abce']
+        self.assertIsNone(d.get('abcd'))
+        self.assertIsNone(d.get('abce'))
+        self.assertIsNone(d.get('abcf'))
+        self.assertEqual(len(d), 0)
+
+    def check_delete_randomly(self, nmax, ndrop, nrefill, seed=0):
+        # Helper to test deletion
+        random.seed(seed)
+
+        d = Dict(self, 8, 8)
+        keys = {}
+
+        def make_key(v):
+            return "k_{:06x}".format(v)
+
+        def make_val(v):
+            return "v_{:06x}".format(v)
+
+        for i in range(nmax):
+            d[make_key(i)] = make_val(i)
+
+        # Fill to nmax
+        for i in range(nmax):
+            k = make_key(i)
+            v = make_val(i)
+            keys[k] = v
+            self.assertEqual(d[k], v)
+
+        self.assertEqual(len(d), nmax)
+
+        # Randomly drop
+        droplist = random.sample(list(keys), ndrop)
+        remain = keys.copy()
+        for i, k in enumerate(droplist, start=1):
+            del d[k]
+            del remain[k]
+            self.assertEqual(len(d), nmax - i)
+        self.assertEqual(len(d), nmax - ndrop)
+
+        # Make sure everything dropped is gone
+        for k in droplist:
+            self.assertIsNone(d.get(k))
+
+        # Make sure everything else is still here
+        for k in remain:
+            self.assertEqual(d[k], remain[k])
+
+        # Refill
+        for i in range(nrefill):
+            k = make_key(nmax + i)
+            v = make_val(nmax + i)
+            remain[k] = v
+            d[k] = v
+
+        self.assertEqual(len(remain), len(d))
+
+        # Make sure everything is here
+        for k in remain:
+            self.assertEqual(d[k], remain[k])
+
+    def test_delete_randomly(self):
+        # Test deletion for differently sized dict
+        self.check_delete_randomly(nmax=8, ndrop=2, nrefill=2)
+        self.check_delete_randomly(nmax=13, ndrop=10, nrefill=31)
+        self.check_delete_randomly(nmax=100, ndrop=50, nrefill=200)
+        self.check_delete_randomly(nmax=100, ndrop=99, nrefill=100)
+        self.check_delete_randomly(nmax=100, ndrop=100, nrefill=100)
+        self.check_delete_randomly(nmax=1024, ndrop=999, nrefill=1)
+        self.check_delete_randomly(nmax=1024, ndrop=999, nrefill=2048)
+
+    def test_delete_randomly_large(self):
+        # Go beyond 2^16 to exercise large indices.
+        # Internally, size of index changes as the hashtable size changes.
+        # Size of index can be 8, 16, 32 or 64 bytes (on 64-bit).
+        # We are not inserting >2^32 elements because of limitation of time.
+        self.check_delete_randomly(nmax=2**17, ndrop=2**16, nrefill=2**10)
+
+    def test_popitem(self):
+        nmax = 10
+        d = Dict(self, 8, 8)
+
+        def make_key(v):
+            return "k_{:06x}".format(v)
+
+        def make_val(v):
+            return "v_{:06x}".format(v)
+
+        for i in range(nmax):
+            d[make_key(i)] = make_val(i)
+
+        self.assertEqual(len(d), nmax)
+        k, v = d.popitem()
+        self.assertEqual(len(d), nmax - 1)
+        self.assertEqual(k, make_key(len(d)))
+        self.assertEqual(v, make_val(len(d)))
+
+        while len(d):
+            n = len(d)
+            k, v = d.popitem()
+            self.assertEqual(len(d), n - 1)
+            self.assertEqual(k, make_key(len(d)))
+            self.assertEqual(v, make_val(len(d)))
+
+        self.assertEqual(len(d), 0)
+        with self.assertRaises(KeyError) as raises:
+            d.popitem()
+        self.assertIn(
+            'popitem(): dictionary is empty',
+            str(raises.exception),
+        )
+
+    def test_iter_items(self):
+        # Test .items iteration
+        d = Dict(self, 4, 4)
+        nmax = 1000
+
+        def make_key(v):
+            return "{:04}".format(v)
+
+        def make_val(v):
+            return "{:04}".format(v + nmax)
+
+        for i in range(nmax):
+            d[make_key(i)] = make_val(i)
+
+        # Check that the everything is ordered
+        for i, (k, v) in enumerate(d.items()):
+            self.assertEqual(make_key(i), k)
+            self.assertEqual(make_val(i), v)
+
+    def check_sizing(self, key_size, val_size, nmax):
+        # Helper to verify different key/value sizes.
+        d = Dict(self, key_size, val_size)
+
+        def make_key(v):
+            return "{:0{}}".format(v, key_size)[:key_size]
+
+        def make_val(v):
+            return "{:0{}}".format(nmax - v - 1, val_size)[:val_size]
+
+        for i in range(nmax):
+            d[make_key(i)] = make_val(i)
+
+        # Check that the everything is ordered
+        for i, (k, v) in enumerate(d.items()):
+            self.assertEqual(make_key(i), k)
+            self.assertEqual(make_val(i), v)
+
+    def test_sizing(self):
+        # Check different sizes of the key & value.
+        for i in range(1, 8):
+            self.check_sizing(key_size=i, val_size=i, nmax=2**i)
+
+    def test_parameterized_types(self):
+        """https://github.com/numba/numba/issues/6401"""
+
+        register_model(ParametrizedType)(UniTupleModel)
+
+        @typeof_impl.register(Parametrized)
+        def typeof_unit(val, c):
+            return ParametrizedType(val)
+
+        @unbox(ParametrizedType)
+        def unbox_parametrized(typ, obj, context):
+            return context.unbox(types.UniTuple(typ.dtype, len(typ)), obj)
+
+        def dict_vs_cache_vs_parametrized(v):
+            assert 0
+
+        @overload(dict_vs_cache_vs_parametrized)
+        def ol_dict_vs_cache_vs_parametrized(v):
+            typ = v
+
+            def objmode_vs_cache_vs_parametrized_impl(v):
+                # typed.List shows same behaviour after fix for #6397
+                d = typed.Dict.empty(types.unicode_type, typ)
+                d['data'] = v
+
+            return objmode_vs_cache_vs_parametrized_impl
+
+        @jit(nopython=True, cache=True)
+        def set_parametrized_data(x, y):
+            # Has had a tendency to segfault when the compiled function
+            # was loaded from cache in a different process than the one
+            # it was originally compiled in.
+            # The new process is simulated below by resetting the dispatchers
+            # and the target context
+            dict_vs_cache_vs_parametrized(x)
+            dict_vs_cache_vs_parametrized(y)
+
+        x, y = Parametrized(('a', 'b')), Parametrized(('a',))
+        set_parametrized_data(x, y)
+
+        # reset dispatchers and targetctx to force re-load from cache as if a
+        # new process would jit the function
+        set_parametrized_data._make_finalizer()()
+        set_parametrized_data._reset_overloads()
+        set_parametrized_data.targetctx.init()
+
+        for ii in range(50):  # <- sometimes works a few times
+            self.assertIsNone(set_parametrized_data(x, y))

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

@@ -0,0 +1,233 @@
+import numpy as np
+from numba import njit, jit
+from numba.core.errors import TypingError
+import unittest
+from numba.tests.support import TestCase
+
+
+def build_map():
+    return {0: 1, 2: 3}
+
+def build_map_from_local_vars():
+    # There used to be a crash due to wrong IR generation for STORE_MAP
+    x = TestCase
+    return {0: x, x: 1}
+
+
+class DictTestCase(TestCase):
+
+    def check(self, pyfunc):
+        cfunc = jit(forceobj=True)(pyfunc)
+        self.assertPreciseEqual(pyfunc(), cfunc())
+
+    def test_build_map(self):
+        self.check(build_map)
+
+    def test_build_map_from_local_vars(self):
+        self.check(build_map_from_local_vars)
+
+
+class TestCompiledDict(TestCase):
+    """Testing `dict()` and `{}` usage that are redirected to
+    `numba.typed.Dict`.
+    """
+    def test_use_dict(self):
+        # Test dict()
+        @njit
+        def foo():
+            d = dict()
+            d[1] = 2
+            return d
+
+        d = foo()
+        self.assertEqual(d, {1: 2})
+
+    def test_use_dict_iterable_args(self):
+        # Test dict(iterable)
+        @njit
+        def dict_iterable_1(a, b):
+            d = dict(zip(a, b))
+            return d
+
+        @njit
+        def dict_iterable_2():
+            # from python docs
+            return dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])
+
+        inps = (
+            ([1, 2, 3], [4, 5, 6]),
+            (np.arange(4), np.arange(4)),
+            ([1, 2, 3], 'abc'),
+            ([1, 2, 3, 4], 'abc'),
+        )
+        for a, b in inps:
+            d = dict_iterable_1(a, b)
+            self.assertEqual(d, dict(zip(a, b)))
+
+        self.assertEqual(dict_iterable_2(), dict_iterable_2.py_func())
+
+    def test_ctor_iterable_tuple(self):
+        @njit
+        def ctor():
+            return dict(((1, 2), (1, 2)))
+
+        expected = dict({1: 2})
+        got = ctor()
+        self.assertEqual(expected, got)
+
+    def test_unsupported_dict_usage(self):
+        # Test dict(dict())
+        from numba.core.typing.dictdecl import _message_dict_support
+
+        @njit
+        def ctor1():
+            d = dict()
+            d[1] = 2
+            return dict(d)
+
+        @njit
+        def ctor2():
+            return dict(((1, 2), (3, 'a')))
+
+        @njit
+        def ctor3():
+            return dict((('a', 'b', 'c'), ('d', 'e', 'f')))
+
+        @njit
+        def ctor4():
+            return dict((({}, 1), ({}, 2)))
+
+        _non_iter_args = "Non-iterable args used in dict(iterable)"
+        _dict_upd_item_len = "dictionary update sequence element has length 3;"
+        _unhashable_type = "Unhashable type"
+
+        inputs = [
+            (ctor1, TypingError, _message_dict_support),
+            (ctor2, TypingError, _non_iter_args),
+            (ctor3, TypingError, _dict_upd_item_len),
+            (ctor4, TypingError, _unhashable_type),
+        ]
+
+        for func, exc, msg in inputs:
+            with self.assertRaises(exc) as raises:
+                func()
+
+            self.assertIn(msg, str(raises.exception))
+
+    def test_use_curlybraces(self):
+        # Test {} with empty args
+        @njit
+        def foo():
+            d = {}
+            d[1] = 2
+            return d
+
+        d = foo()
+        self.assertEqual(d, {1: 2})
+
+    def test_use_curlybraces_with_init1(self):
+        # Test {} with 1 item
+        @njit
+        def foo():
+            return {1: 2}
+
+        d = foo()
+        self.assertEqual(d, {1: 2})
+
+    def test_use_curlybraces_with_initmany(self):
+        # Test {} with many items
+        @njit
+        def foo():
+            return {1: 2.2, 3: 4.4, 5: 6.6}
+
+        d = foo()
+        self.assertEqual(d, {1: 2.2, 3: 4.4, 5: 6.6})
+
+    def test_curlybraces_init_with_coercion(self):
+        # Type coercion at dict init is tested
+        @njit
+        def foo():
+            return {1: 2.2, 3: 4, 5: 6}
+
+        self.assertEqual(foo(), foo.py_func())
+
+    def test_use_curlybraces_with_manyvar(self):
+        # Test using variable in {}
+        @njit
+        def foo(x, y):
+            return {x: 1, y: x + y}
+
+        x, y = 10, 20
+        self.assertEqual(foo(x, y), foo.py_func(x, y))
+
+    def test_mixed_curlybraces_and_dict(self):
+        # Test mixed use of {} and dict()
+        @njit
+        def foo():
+            k = dict()
+            k[1] = {1: 3}
+            k[2] = {4: 2}
+            return k
+
+        self.assertEqual(foo(), foo.py_func())
+
+    def test_dict_use_with_none_value(self):
+        # Test that NoneType cannot be used as value for Dict
+        @njit
+        def foo():
+            k = {1: None}
+            return k
+
+        with self.assertRaises(TypingError) as raises:
+            foo()
+        self.assertIn(
+            "Dict.value_type cannot be of type none",
+            str(raises.exception),
+        )
+
+
+    def test_dict_use_with_optional_value(self):
+        # Test that Optional cannot be used as value for Dict
+        @njit
+        def foo(choice):
+            optional = 2.5 if choice else None
+            k = {1: optional}
+            return k
+
+        with self.assertRaises(TypingError) as raises:
+            foo(True)
+        self.assertIn(
+            "Dict.value_type cannot be of type OptionalType(float64)",
+            str(raises.exception),
+        )
+
+    def test_dict_use_with_optional_key(self):
+        # Test that Optional cannot be used as a key for Dict
+        @njit
+        def foo(choice):
+            k = {2.5 if choice else None: 1}
+            return k
+
+        with self.assertRaises(TypingError) as raises:
+            foo(True)
+        self.assertIn(
+            "Dict.key_type cannot be of type OptionalType(float64)",
+            str(raises.exception),
+        )
+
+    def test_dict_use_with_none_key(self):
+        # Test that NoneType cannot be used as a key for Dict
+        @njit
+        def foo():
+            k = {None: 1}
+            return k
+
+        with self.assertRaises(TypingError) as raises:
+            foo()
+        self.assertIn(
+            "Dict.key_type cannot be of type none",
+            str(raises.exception),
+        )
+
+if __name__ == '__main__':
+    unittest.main()

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

@@ -0,0 +1,43 @@
+import numpy as np
+
+import numba
+from numba.tests.support import TestCase
+
+
+class Issue455(object):
+    """
+    Test code from issue 455.
+    """
+
+    def __init__(self):
+        self.f = []
+
+    def create_f(self):
+        code = """
+        def f(x):
+            n = x.shape[0]
+            for i in range(n):
+                x[i] = 1.
+        """
+        d = {}
+        exec(code.strip(), d)
+        self.f.append(numba.jit("void(f8[:])", nopython=True)(d['f']))
+
+    def call_f(self):
+        a = np.zeros(10)
+        for f in self.f:
+            f(a)
+        return a
+
+
+class TestDynFunc(TestCase):
+
+    def test_issue_455(self):
+        inst = Issue455()
+        inst.create_f()
+        a = inst.call_f()
+        self.assertPreciseEqual(a, np.ones_like(a))
+
+
+if __name__ == '__main__':
+    unittest.main()

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

@@ -0,0 +1,181 @@
+"""
+Tests for enum support.
+"""
+
+
+import numpy as np
+import unittest
+from numba import jit, vectorize, int8, int16, int32
+
+from numba.tests.support import TestCase
+from numba.tests.enum_usecases import (Color, Shape, Shake,
+                                       Planet, RequestError,
+                                       IntEnumWithNegatives)
+
+
+def compare_usecase(a, b):
+    return a == b, a != b, a is b, a is not b
+
+
+def getattr_usecase(a):
+    # Lookup of a enum member on its class
+    return a is Color.red
+
+
+def getitem_usecase(a):
+    """Lookup enum member by string name"""
+    return a is Color['red']
+
+
+def identity_usecase(a, b, c):
+    return (a is Shake.mint,
+            b is Shape.circle,
+            c is RequestError.internal_error,
+            )
+
+
+def make_constant_usecase(const):
+    def constant_usecase(a):
+        return a is const
+    return constant_usecase
+
+
+def return_usecase(a, b, pred):
+    return a if pred else b
+
+
+def int_coerce_usecase(x):
+    # Implicit coercion of intenums to ints
+    if x > RequestError.internal_error:
+        return x - RequestError.not_found
+    else:
+        return x + Shape.circle
+
+def int_cast_usecase(x):
+    # Explicit coercion of intenums to ints
+    if x > int16(RequestError.internal_error):
+        return x - int32(RequestError.not_found)
+    else:
+        return x + int16(Shape.circle)
+
+
+def vectorize_usecase(x):
+    if x != RequestError.not_found:
+        return RequestError['internal_error']
+    else:
+        return RequestError.dummy
+
+
+class BaseEnumTest(object):
+
+    def test_compare(self):
+        pyfunc = compare_usecase
+        cfunc = jit(nopython=True)(pyfunc)
+
+        for args in self.pairs:
+            self.assertPreciseEqual(pyfunc(*args), cfunc(*args))
+
+    def test_return(self):
+        """
+        Passing and returning enum members.
+        """
+        pyfunc = return_usecase
+        cfunc = jit(nopython=True)(pyfunc)
+
+        for pair in self.pairs:
+            for pred in (True, False):
+                args = pair + (pred,)
+                self.assertIs(pyfunc(*args), cfunc(*args))
+
+    def check_constant_usecase(self, pyfunc):
+        cfunc = jit(nopython=True)(pyfunc)
+
+        for arg in self.values:
+            self.assertPreciseEqual(pyfunc(arg), cfunc(arg))
+
+    def test_constant(self):
+        self.check_constant_usecase(getattr_usecase)
+        self.check_constant_usecase(getitem_usecase)
+        self.check_constant_usecase(make_constant_usecase(self.values[0]))
+
+
+class TestEnum(BaseEnumTest, TestCase):
+    """
+    Tests for Enum classes and members.
+    """
+    values = [Color.red, Color.green]
+
+    pairs = [
+        (Color.red, Color.red),
+        (Color.red, Color.green),
+        (Shake.mint, Shake.vanilla),
+        (Planet.VENUS, Planet.MARS),
+        (Planet.EARTH, Planet.EARTH),
+        ]
+
+    def test_identity(self):
+        """
+        Enum with equal values should not compare identical
+        """
+        pyfunc = identity_usecase
+        cfunc = jit(nopython=True)(pyfunc)
+        args = (Color.blue, Color.green, Shape.square)
+        self.assertPreciseEqual(pyfunc(*args), cfunc(*args))
+
+
+class TestIntEnum(BaseEnumTest, TestCase):
+    """
+    Tests for IntEnum classes and members.
+    """
+    values = [Shape.circle, Shape.square]
+
+    pairs = [
+        (Shape.circle, Shape.circle),
+        (Shape.circle, Shape.square),
+        (RequestError.not_found, RequestError.not_found),
+        (RequestError.internal_error, RequestError.not_found),
+        ]
+
+    def test_int_coerce(self):
+        pyfunc = int_coerce_usecase
+        cfunc = jit(nopython=True)(pyfunc)
+
+        for arg in [300, 450, 550]:
+            self.assertPreciseEqual(pyfunc(arg), cfunc(arg))
+
+    def test_int_cast(self):
+        pyfunc = int_cast_usecase
+        cfunc = jit(nopython=True)(pyfunc)
+
+        for arg in [300, 450, 550]:
+            self.assertPreciseEqual(pyfunc(arg), cfunc(arg))
+
+    def test_vectorize(self):
+        cfunc = vectorize(nopython=True)(vectorize_usecase)
+        arg = np.array([2, 404, 500, 404])
+        sol = np.array([vectorize_usecase(i) for i in arg], dtype=arg.dtype)
+        self.assertPreciseEqual(sol, cfunc(arg))
+
+    def test_hash(self):
+        def pyfun(x):
+            return hash(x)
+        cfunc = jit(nopython=True)(pyfun)
+        for member in IntEnumWithNegatives:
+            self.assertPreciseEqual(pyfun(member), cfunc(member))
+
+    def test_int_shape_cast(self):
+        def pyfun_empty(x):
+            return np.empty((x, x), dtype='int64').fill(-1)
+        def pyfun_zeros(x):
+            return np.zeros((x, x), dtype='int64')
+        def pyfun_ones(x):
+            return np.ones((x, x), dtype='int64')
+        for pyfun in [pyfun_empty, pyfun_zeros, pyfun_ones]:
+            cfunc = jit(nopython=True)(pyfun)
+            for member in IntEnumWithNegatives:
+                if member >= 0:
+                    self.assertPreciseEqual(pyfun(member), cfunc(member))
+
+
+if __name__ == '__main__':
+    unittest.main()

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

@@ -0,0 +1,469 @@
+"""
+Unspecified error handling tests
+"""
+
+import numpy as np
+import os
+import warnings
+
+from numba import jit, njit, types
+from numba.core import errors
+from numba.experimental import structref
+from numba.extending import (overload, intrinsic, overload_method,
+                             overload_attribute)
+from numba.core.compiler import CompilerBase
+from numba.core.untyped_passes import (TranslateByteCode, FixupArgs,
+                                       IRProcessing,)
+from numba.core.typed_passes import (NopythonTypeInference, DeadCodeElimination,
+                                     NoPythonBackend, NativeLowering)
+from numba.core.compiler_machinery import PassManager
+from numba.core.types.functions import _err_reasons as error_reasons
+
+from numba.tests.support import (skip_parfors_unsupported, override_config,
+                                 SerialMixin, skip_unless_cffi,
+                                 skip_unless_scipy, TestCase)
+import unittest
+
+
+class TestErrorHandlingBeforeLowering(unittest.TestCase):
+
+    def test_unsupported_make_function_return_inner_func(self):
+        def func(x):
+            """ return the closure """
+            z = x + 1
+
+            def inner(x):
+                return x + z
+            return inner
+
+        for pipeline in jit, njit:
+            with self.assertRaises(errors.TypingError) as raises:
+                pipeline(func)(1)
+
+            expected = "Cannot capture the non-constant value"
+            self.assertIn(expected, str(raises.exception))
+
+
+class TestUnsupportedReporting(unittest.TestCase):
+
+    def test_unsupported_numpy_function(self):
+        # np.asanyarray(list) currently unsupported
+        @njit
+        def func():
+            np.asanyarray([1,2,3])
+
+        with self.assertRaises(errors.TypingError) as raises:
+            func()
+
+        expected = "Use of unsupported NumPy function 'numpy.asanyarray'"
+        self.assertIn(expected, str(raises.exception))
+
+
+class TestMiscErrorHandling(unittest.TestCase):
+
+    def test_use_of_exception_for_flow_control(self):
+        # constant inference uses exceptions with no Loc specified to determine
+        # flow control, this asserts that the construction of the lowering
+        # error context handler works in the case of an exception with no Loc
+        # specified. See issue #3135.
+        @njit
+        def fn(x):
+            return 10**x
+
+        a = np.array([1.0],dtype=np.float64)
+        fn(a) # should not raise
+
+    def test_commented_func_definition_is_not_a_definition(self):
+        # See issue #4056, the commented def should not be found as the
+        # definition for reporting purposes when creating the synthetic
+        # traceback because it is commented! Use of def in docstring would also
+        # cause this issue hence is tested.
+
+        def foo_commented():
+            #def commented_definition()
+            raise Exception('test_string')
+
+        def foo_docstring():
+            """ def docstring containing def might match function definition!"""
+            raise Exception('test_string')
+
+        for func in (foo_commented, foo_docstring):
+            with self.assertRaises(Exception) as raises:
+                func()
+
+            self.assertIn("test_string", str(raises.exception))
+
+    def test_use_of_ir_unknown_loc(self):
+        # for context see # 3390
+        class TestPipeline(CompilerBase):
+            def define_pipelines(self):
+                name = 'bad_DCE_pipeline'
+                pm = PassManager(name)
+                pm.add_pass(TranslateByteCode, "analyzing bytecode")
+                pm.add_pass(FixupArgs, "fix up args")
+                pm.add_pass(IRProcessing, "processing IR")
+                # remove dead before type inference so that the Arg node is
+                # removed and the location of the arg cannot be found
+                pm.add_pass(DeadCodeElimination, "DCE")
+                # typing
+                pm.add_pass(NopythonTypeInference, "nopython frontend")
+                pm.add_pass(NativeLowering, "native lowering")
+                pm.add_pass(NoPythonBackend, "nopython mode backend")
+                pm.finalize()
+                return [pm]
+
+        @njit(pipeline_class=TestPipeline)
+        def f(a):
+            return 0
+
+        with self.assertRaises(errors.TypingError) as raises:
+            f(iter([1,2]))  # use a type that Numba doesn't recognize
+
+        expected = 'File "unknown location", line 0:'
+        self.assertIn(expected, str(raises.exception))
+
+    def check_write_to_globals(self, func):
+        with self.assertRaises(errors.TypingError) as raises:
+            func()
+
+        expected = ["The use of a", "in globals, is not supported as globals"]
+        for ex in expected:
+            self.assertIn(ex, str(raises.exception))
+
+    def test_handling_of_write_to_reflected_global(self):
+        from numba.tests.errorhandling_usecases import global_reflected_write
+        self.check_write_to_globals(njit(global_reflected_write))
+
+    def test_handling_of_write_to_typed_dict_global(self):
+        from numba.tests.errorhandling_usecases import global_dict_write
+        self.check_write_to_globals(njit(global_dict_write))
+
+    @skip_parfors_unsupported
+    def test_handling_forgotten_numba_internal_import(self):
+        @njit(parallel=True)
+        def foo():
+            for i in prange(10): # noqa: F821 prange is not imported
+                pass
+
+        with self.assertRaises(errors.TypingError) as raises:
+            foo()
+
+        expected = ("'prange' looks like a Numba internal function, "
+                    "has it been imported")
+        self.assertIn(expected, str(raises.exception))
+
+    def test_handling_unsupported_generator_expression(self):
+        def foo():
+            (x for x in range(10))
+
+        expected = "The use of yield in a closure is unsupported."
+
+        for dec in jit(forceobj=True), njit:
+            with self.assertRaises(errors.UnsupportedError) as raises:
+                dec(foo)()
+            self.assertIn(expected, str(raises.exception))
+
+    def test_handling_undefined_variable(self):
+        @njit
+        def foo():
+            return a # noqa: F821
+
+        expected = "NameError: name 'a' is not defined"
+
+        with self.assertRaises(errors.TypingError) as raises:
+            foo()
+        self.assertIn(expected, str(raises.exception))
+
+
+class TestErrorMessages(unittest.TestCase):
+
+    def test_specific_error(self):
+
+        given_reason = "specific_reason"
+
+        def foo():
+            pass
+
+        @overload(foo)
+        def ol_foo():
+            raise errors.NumbaValueError(given_reason)
+
+        @njit
+        def call_foo():
+            foo()
+
+        with self.assertRaises(errors.TypingError) as raises:
+            call_foo()
+
+        excstr = str(raises.exception)
+        self.assertIn(error_reasons['specific_error'].splitlines()[0], excstr)
+        self.assertIn(given_reason, excstr)
+
+    def test_no_match_error(self):
+
+        def foo():
+            pass
+
+        @overload(foo)
+        def ol_foo():
+            return None # emulate no impl available for type
+
+        @njit
+        def call_foo():
+            foo()
+
+        with self.assertRaises(errors.TypingError) as raises:
+            call_foo()
+
+        excstr = str(raises.exception)
+        self.assertIn("No match", excstr)
+
+    @skip_unless_scipy
+    def test_error_function_source_is_correct(self):
+        """ Checks that the reported source location for an overload is the
+        overload implementation source, not the actual function source from the
+        target library."""
+
+        @njit
+        def foo():
+            np.linalg.svd("chars")
+
+        with self.assertRaises(errors.TypingError) as raises:
+            foo()
+
+        excstr = str(raises.exception)
+        self.assertIn(error_reasons['specific_error'].splitlines()[0], excstr)
+        expected_file = os.path.join("numba", "np", "linalg.py")
+        expected = f"Overload in function 'svd_impl': File: {expected_file}:"
+        self.assertIn(expected.format(expected_file), excstr)
+
+    def test_concrete_template_source(self):
+        # hits ConcreteTemplate
+        @njit
+        def foo():
+            return 'a' + 1
+
+        with self.assertRaises(errors.TypingError) as raises:
+            foo()
+
+        excstr = str(raises.exception)
+
+        self.assertIn("Overload of function 'add'", excstr)
+        # there'll be numerous matched templates that don't work but as they
+        # are mostly "overload"s they'll just appear as "No match".
+        self.assertIn("No match.", excstr)
+
+    def test_abstract_template_source(self):
+        # hits AbstractTemplate
+        @njit
+        def foo():
+            return len(1)
+
+        with self.assertRaises(errors.TypingError) as raises:
+            foo()
+
+        excstr = str(raises.exception)
+        self.assertIn("Overload of function 'len'", excstr)
+
+    def test_callable_template_source(self):
+        # hits CallableTemplate
+        @njit
+        def foo():
+            return np.angle(None)
+
+        with self.assertRaises(errors.TypingError) as raises:
+            foo()
+
+        excstr = str(raises.exception)
+        self.assertIn("No implementation of function Function(<function angle",
+                      excstr)
+
+    def test_overloadfunction_template_source(self):
+        # hits _OverloadFunctionTemplate
+        def bar(x):
+            pass
+
+        @overload(bar)
+        def ol_bar(x):
+            pass
+
+        @njit
+        def foo():
+            return bar(1)
+
+        with self.assertRaises(errors.TypingError) as raises:
+            foo()
+
+        excstr = str(raises.exception)
+        # there will not be "numerous" matched templates, there's just one,
+        # the one above, so assert it is reported
+        self.assertNotIn("<numerous>", excstr)
+        expected_file = os.path.join("numba", "tests",
+                                     "test_errorhandling.py")
+        expected_ol = f"Overload of function 'bar': File: {expected_file}:"
+        self.assertIn(expected_ol.format(expected_file), excstr)
+        self.assertIn("No match.", excstr)
+
+    def test_intrinsic_template_source(self):
+        # hits _IntrinsicTemplate
+        given_reason1 = "x must be literal"
+        given_reason2 = "array.ndim must be 1"
+
+        @intrinsic
+        def myintrin(typingctx, x, arr):
+            if not isinstance(x, types.IntegerLiteral):
+                raise errors.RequireLiteralValue(given_reason1)
+
+            if arr.ndim != 1:
+                raise errors.NumbaValueError(given_reason2)
+
+            sig = types.intp(x, arr)
+
+            def codegen(context, builder, signature, args):
+                pass
+            return sig, codegen
+
+        @njit
+        def call_intrin():
+            arr = np.zeros((2, 2))
+            myintrin(1, arr)
+
+        with self.assertRaises(errors.TypingError) as raises:
+            call_intrin()
+
+        excstr = str(raises.exception)
+        self.assertIn(error_reasons['specific_error'].splitlines()[0], excstr)
+        self.assertIn(given_reason1, excstr)
+        self.assertIn(given_reason2, excstr)
+        self.assertIn("Intrinsic in function", excstr)
+
+    def test_overloadmethod_template_source(self):
+        # doesn't hit _OverloadMethodTemplate for source as it's a nested
+        # exception
+        @overload_method(types.UnicodeType, 'isnonsense')
+        def ol_unicode_isnonsense(self):
+            pass
+
+        @njit
+        def foo():
+            "abc".isnonsense()
+
+        with self.assertRaises(errors.TypingError) as raises:
+            foo()
+
+        excstr = str(raises.exception)
+        self.assertIn("Overload of function 'ol_unicode_isnonsense'", excstr)
+
+    def test_overloadattribute_template_source(self):
+        # doesn't hit _OverloadMethodTemplate for source as it's a nested
+        # exception
+        @overload_attribute(types.UnicodeType, 'isnonsense')
+        def ol_unicode_isnonsense(self):
+            pass
+
+        @njit
+        def foo():
+            "abc".isnonsense
+
+        with self.assertRaises(errors.TypingError) as raises:
+            foo()
+
+        excstr = str(raises.exception)
+        self.assertIn("Overload of function 'ol_unicode_isnonsense'", excstr)
+
+    def test_external_function_pointer_template_source(self):
+        from numba.tests.ctypes_usecases import c_cos
+
+        @njit
+        def foo():
+            c_cos('a')
+
+        with self.assertRaises(errors.TypingError) as raises:
+            foo()
+
+        excstr = str(raises.exception)
+        self.assertIn("Type Restricted Function in function 'unknown'", excstr)
+
+    @skip_unless_cffi
+    def test_cffi_function_pointer_template_source(self):
+        from numba.tests import cffi_usecases as mod
+        mod.init()
+        func = mod.cffi_cos
+
+        @njit
+        def foo():
+            func('a')
+
+        with self.assertRaises(errors.TypingError) as raises:
+            foo()
+
+        excstr = str(raises.exception)
+        self.assertIn("Type Restricted Function in function 'unknown'", excstr)
+
+    def test_missing_source(self):
+
+        @structref.register
+        class ParticleType(types.StructRef):
+            pass
+
+        class Particle(structref.StructRefProxy):
+            def __new__(cls, pos, mass):
+                return structref.StructRefProxy.__new__(cls, pos)
+                # didn't provide the required mass argument ----^
+
+        structref.define_proxy(Particle, ParticleType, ["pos", "mass"])
+
+        with self.assertRaises(errors.TypingError) as raises:
+            Particle(pos=1, mass=2)
+
+        excstr = str(raises.exception)
+        self.assertIn("missing a required argument: 'mass'", excstr)
+
+
+class TestDeveloperSpecificErrorMessages(SerialMixin, unittest.TestCase):
+
+    def test_bound_function_error_string(self):
+        # See PR #5952
+        def foo(x):
+            x.max(-1)
+
+        with override_config('DEVELOPER_MODE', 1):
+            with self.assertRaises(errors.TypingError) as raises:
+                njit("void(int64[:,:])")(foo)
+
+        excstr = str(raises.exception)
+        self.assertIn("too many positional arguments", excstr)
+
+
+class TestCapturedErrorHandling(SerialMixin, TestCase):
+    """Checks that the way errors are captured.
+    """
+
+    def test_error_in_overload(self):
+
+        def bar(x):
+            pass
+
+        @overload(bar)
+        def ol_bar(x):
+            x.some_invalid_attr # doesn't exist!
+
+            def impl(x):
+                pass
+            return impl
+
+        with warnings.catch_warnings():
+            # Suppress error going into stdout
+            warnings.simplefilter("ignore",
+                                  errors.NumbaPendingDeprecationWarning)
+
+            with self.assertRaises(AttributeError) as raises:
+                @njit('void(int64)')
+                def foo(x):
+                    bar(x)
+            expected = "object has no attribute 'some_invalid_attr'"
+            self.assertIn(expected, str(raises.exception))
+
+
+if __name__ == '__main__':
+    unittest.main()

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

@@ -0,0 +1,28 @@
+"""
+Test setting/overriding error models
+"""
+
+from numba import jit
+import unittest
+
+
+class TestErrorModel(unittest.TestCase):
+
+    def test_div_by_zero_python(self):
+        @jit   # python model is the default
+        def model_python(val):
+            return 1 / val
+
+        with self.assertRaises(ZeroDivisionError):
+            model_python(0)
+
+    def test_div_by_zero_numpy(self):
+        @jit(error_model='numpy')
+        def model_numpy(val):
+            return 1 / val
+
+        self.assertEqual(model_numpy(0), float('inf'))
+
+
+if __name__ == '__main__':
+    unittest.main()

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

@@ -0,0 +1,2248 @@
+import inspect
+import math
+import operator
+import sys
+import pickle
+import multiprocessing
+import ctypes
+import warnings
+import re
+
+import numpy as np
+from llvmlite import ir
+
+import numba
+from numba import njit, jit, vectorize, guvectorize, objmode
+from numba.core import types, errors, typing, compiler, cgutils
+from numba.core.typed_passes import type_inference_stage
+from numba.core.registry import cpu_target
+from numba.core.imputils import lower_constant
+from numba.tests.support import (
+    TestCase,
+    captured_stdout,
+    temp_directory,
+    override_config,
+    run_in_new_process_in_cache_dir,
+    skip_if_typeguard,
+)
+from numba.core.errors import LoweringError
+import unittest
+
+from numba.extending import (
+    typeof_impl,
+    type_callable,
+    lower_builtin,
+    lower_cast,
+    overload,
+    overload_attribute,
+    overload_method,
+    models,
+    register_model,
+    box,
+    unbox,
+    NativeValue,
+    intrinsic,
+    _Intrinsic,
+    register_jitable,
+    get_cython_function_address,
+    is_jitted,
+    overload_classmethod,
+)
+from numba.core.typing.templates import (
+    ConcreteTemplate,
+    signature,
+    infer,
+    infer_global,
+    AbstractTemplate,
+)
+
+
+# Pandas-like API implementation
+from .pdlike_usecase import Index, Series
+
+
+try:
+    import scipy.special.cython_special as sc
+except ImportError:
+    sc = None
+
+
+# -----------------------------------------------------------------------
+# Define a custom type and an implicit cast on it
+
+
+class MyDummy(object):
+    pass
+
+
+class MyDummyType(types.Opaque):
+    def can_convert_to(self, context, toty):
+        if isinstance(toty, types.Number):
+            from numba.core.typeconv import Conversion
+
+            return Conversion.safe
+
+
+mydummy_type = MyDummyType("mydummy")
+mydummy = MyDummy()
+
+
+@typeof_impl.register(MyDummy)
+def typeof_mydummy(val, c):
+    return mydummy_type
+
+
+@lower_cast(MyDummyType, types.Number)
+def mydummy_to_number(context, builder, fromty, toty, val):
+    """
+    Implicit conversion from MyDummy to int.
+    """
+    return context.get_constant(toty, 42)
+
+
+def get_dummy():
+    return mydummy
+
+
+register_model(MyDummyType)(models.OpaqueModel)
+
+
+@unbox(MyDummyType)
+def unbox_index(typ, obj, c):
+    return NativeValue(c.context.get_dummy_value())
+
+
+# -----------------------------------------------------------------------
+# Define a second custom type but w/o implicit cast to Number
+
+
+def base_dummy_type_factory(name):
+    class DynType(object):
+        pass
+
+    class DynTypeType(types.Opaque):
+        pass
+
+    dyn_type_type = DynTypeType(name)
+
+    @typeof_impl.register(DynType)
+    def typeof_mydummy(val, c):
+        return dyn_type_type
+
+    register_model(DynTypeType)(models.OpaqueModel)
+    return DynTypeType, DynType, dyn_type_type
+
+
+MyDummyType2, MyDummy2, mydummy_type_2 = base_dummy_type_factory("mydummy2")
+
+
+@unbox(MyDummyType2)
+def unbox_index2(typ, obj, c):
+    return NativeValue(c.context.get_dummy_value())
+
+
+# -----------------------------------------------------------------------
+# Define a function's typing and implementation using the classical
+# two-step API
+
+
+def func1(x=None):
+    raise NotImplementedError
+
+
+def type_func1_(context):
+    def typer(x=None):
+        if x in (None, types.none):
+            # 0-arg or 1-arg with None
+            return types.int32
+        elif isinstance(x, types.Float):
+            # 1-arg with float
+            return x
+
+    return typer
+
+
+type_func1 = type_callable(func1)(type_func1_)
+
+
+@lower_builtin(func1)
+@lower_builtin(func1, types.none)
+def func1_nullary(context, builder, sig, args):
+    return context.get_constant(sig.return_type, 42)
+
+
+@lower_builtin(func1, types.Float)
+def func1_unary(context, builder, sig, args):
+    def func1_impl(x):
+        return math.sqrt(2 * x)
+
+    return context.compile_internal(builder, func1_impl, sig, args)
+
+
+# We can do the same for a known internal operation, here "print_item"
+# which we extend to support MyDummyType.
+
+
+@infer
+class PrintDummy(ConcreteTemplate):
+    key = "print_item"
+    cases = [signature(types.none, mydummy_type)]
+
+
+@lower_builtin("print_item", MyDummyType)
+def print_dummy(context, builder, sig, args):
+    [x] = args
+    pyapi = context.get_python_api(builder)
+    strobj = pyapi.unserialize(pyapi.serialize_object("hello!"))
+    pyapi.print_object(strobj)
+    pyapi.decref(strobj)
+    return context.get_dummy_value()
+
+
+# -----------------------------------------------------------------------
+# Define an overloaded function (combined API)
+
+
+def where(cond, x, y):
+    raise NotImplementedError
+
+
+def np_where(cond, x, y):
+    """
+    Wrap np.where() to allow for keyword arguments
+    """
+    return np.where(cond, x, y)
+
+
+def call_where(cond, x, y):
+    return where(cond, y=y, x=x)
+
+
+@overload(where)
+def overload_where_arrays(cond, x, y):
+    """
+    Implement where() for arrays.
+    """
+    # Choose implementation based on argument types.
+    if isinstance(cond, types.Array):
+        if x.dtype != y.dtype:
+            raise errors.TypingError("x and y should have the same dtype")
+
+        # Array where() => return an array of the same shape
+        if all(ty.layout == "C" for ty in (cond, x, y)):
+
+            def where_impl(cond, x, y):
+                """
+                Fast implementation for C-contiguous arrays
+                """
+                shape = cond.shape
+                if x.shape != shape or y.shape != shape:
+                    raise ValueError("all inputs should have the same shape")
+                res = np.empty_like(x)
+                cf = cond.flat
+                xf = x.flat
+                yf = y.flat
+                rf = res.flat
+                for i in range(cond.size):
+                    rf[i] = xf[i] if cf[i] else yf[i]
+                return res
+
+        else:
+
+            def where_impl(cond, x, y):
+                """
+                Generic implementation for other arrays
+                """
+                shape = cond.shape
+                if x.shape != shape or y.shape != shape:
+                    raise ValueError("all inputs should have the same shape")
+                res = np.empty_like(x)
+                for idx, c in np.ndenumerate(cond):
+                    res[idx] = x[idx] if c else y[idx]
+                return res
+
+        return where_impl
+
+
+# We can define another overload function for the same function, they
+# will be tried in turn until one succeeds.
+
+
+@overload(where)
+def overload_where_scalars(cond, x, y):
+    """
+    Implement where() for scalars.
+    """
+    if not isinstance(cond, types.Array):
+        if x != y:
+            raise errors.TypingError("x and y should have the same type")
+
+        def where_impl(cond, x, y):
+            """
+            Scalar where() => return a 0-dim array
+            """
+            scal = x if cond else y
+            # Can't use full_like() on Numpy < 1.8
+            arr = np.empty_like(scal)
+            arr[()] = scal
+            return arr
+
+        return where_impl
+
+
+# -----------------------------------------------------------------------
+# Overload an already defined built-in function, extending it for new types.
+
+
+@overload(len)
+def overload_len_dummy(arg):
+    if isinstance(arg, MyDummyType):
+
+        def len_impl(arg):
+            return 13
+
+        return len_impl
+
+
+@overload(operator.add)
+def overload_add_dummy(arg1, arg2):
+    if isinstance(arg1, (MyDummyType, MyDummyType2)) and isinstance(
+        arg2, (MyDummyType, MyDummyType2)
+    ):
+
+        def dummy_add_impl(arg1, arg2):
+            return 42
+
+        return dummy_add_impl
+
+
+@overload(operator.delitem)
+def overload_dummy_delitem(obj, idx):
+    if isinstance(obj, MyDummyType) and isinstance(idx, types.Integer):
+
+        def dummy_delitem_impl(obj, idx):
+            print("del", obj, idx)
+
+        return dummy_delitem_impl
+
+
+@overload(operator.getitem)
+def overload_dummy_getitem(obj, idx):
+    if isinstance(obj, MyDummyType) and isinstance(idx, types.Integer):
+
+        def dummy_getitem_impl(obj, idx):
+            return idx + 123
+
+        return dummy_getitem_impl
+
+
+@overload(operator.setitem)
+def overload_dummy_setitem(obj, idx, val):
+    if all(
+        [
+            isinstance(obj, MyDummyType),
+            isinstance(idx, types.Integer),
+            isinstance(val, types.Integer),
+        ]
+    ):
+
+        def dummy_setitem_impl(obj, idx, val):
+            print(idx, val)
+
+        return dummy_setitem_impl
+
+
+def call_add_operator(arg1, arg2):
+    return operator.add(arg1, arg2)
+
+
+def call_add_binop(arg1, arg2):
+    return arg1 + arg2
+
+
+@overload(operator.iadd)
+def overload_iadd_dummy(arg1, arg2):
+    if isinstance(arg1, (MyDummyType, MyDummyType2)) and isinstance(
+        arg2, (MyDummyType, MyDummyType2)
+    ):
+
+        def dummy_iadd_impl(arg1, arg2):
+            return 42
+
+        return dummy_iadd_impl
+
+
+def call_iadd_operator(arg1, arg2):
+    return operator.add(arg1, arg2)
+
+
+def call_iadd_binop(arg1, arg2):
+    arg1 += arg2
+
+    return arg1
+
+
+def call_delitem(obj, idx):
+    del obj[idx]
+
+
+def call_getitem(obj, idx):
+    return obj[idx]
+
+
+def call_setitem(obj, idx, val):
+    obj[idx] = val
+
+
+@overload_method(MyDummyType, "length")
+def overload_method_length(arg):
+    def imp(arg):
+        return len(arg)
+
+    return imp
+
+
+def cache_overload_method_usecase(x):
+    return x.length()
+
+
+def call_func1_nullary():
+    return func1()
+
+
+def call_func1_unary(x):
+    return func1(x)
+
+
+def len_usecase(x):
+    return len(x)
+
+
+def print_usecase(x):
+    print(x)
+
+
+def getitem_usecase(x, key):
+    return x[key]
+
+
+def npyufunc_usecase(x):
+    return np.cos(np.sin(x))
+
+
+def get_data_usecase(x):
+    return x._data
+
+
+def get_index_usecase(x):
+    return x._index
+
+
+def is_monotonic_usecase(x):
+    return x.is_monotonic_increasing
+
+
+def make_series_usecase(data, index):
+    return Series(data, index)
+
+
+def clip_usecase(x, lo, hi):
+    return x.clip(lo, hi)
+
+
+# -----------------------------------------------------------------------
+
+
+def return_non_boxable():
+    return np
+
+
+@overload(return_non_boxable)
+def overload_return_non_boxable():
+    def imp():
+        return np
+
+    return imp
+
+
+def non_boxable_ok_usecase(sz):
+    mod = return_non_boxable()
+    return mod.arange(sz)
+
+
+def non_boxable_bad_usecase():
+    return return_non_boxable()
+
+
+def mk_func_input(f):
+    pass
+
+
+@infer_global(mk_func_input)
+class MkFuncTyping(AbstractTemplate):
+    def generic(self, args, kws):
+        assert isinstance(args[0], types.MakeFunctionLiteral)
+        return signature(types.none, *args)
+
+
+def mk_func_test_impl():
+    mk_func_input(lambda a: a)
+
+
+# -----------------------------------------------------------------------
+# Define a types derived from types.Callable and overloads for them
+
+
+class MyClass(object):
+    pass
+
+
+class CallableTypeRef(types.Callable):
+
+    def __init__(self, instance_type):
+        self.instance_type = instance_type
+        self.sig_to_impl_key = {}
+        self.compiled_templates = []
+        super(CallableTypeRef, self).__init__('callable_type_ref'
+                                              '[{}]'.format(self.instance_type))
+
+    def get_call_type(self, context, args, kws):
+
+        res_sig = None
+        for template in context._functions[type(self)]:
+            try:
+                res_sig = template.apply(args, kws)
+            except Exception:
+                pass  # for simplicity assume args must match exactly
+            else:
+                compiled_ovlds = getattr(template, '_compiled_overloads', {})
+                if args in compiled_ovlds:
+                    self.sig_to_impl_key[res_sig] = compiled_ovlds[args]
+                    self.compiled_templates.append(template)
+                    break
+
+        return res_sig
+
+    def get_call_signatures(self):
+        sigs = list(self.sig_to_impl_key.keys())
+        return sigs, True
+
+    def get_impl_key(self, sig):
+        return self.sig_to_impl_key[sig]
+
+
+@register_model(CallableTypeRef)
+class CallableTypeModel(models.OpaqueModel):
+
+    def __init__(self, dmm, fe_type):
+
+        models.OpaqueModel.__init__(self, dmm, fe_type)
+
+
+infer_global(MyClass, CallableTypeRef(MyClass))
+
+
+@lower_constant(CallableTypeRef)
+def constant_callable_typeref(context, builder, ty, pyval):
+    return context.get_dummy_value()
+
+
+# -----------------------------------------------------------------------
+
+
+@overload(np.exp)
+def overload_np_exp(obj):
+    if isinstance(obj, MyDummyType):
+
+        def imp(obj):
+            # Returns a constant if a MyDummyType is seen
+            return 0xDEADBEEF
+
+        return imp
+
+
+class TestLowLevelExtending(TestCase):
+    """
+    Test the low-level two-tier extension API.
+    """
+
+    # Check with `@jit` from within the test process and also in a new test
+    # process so as to check the registration mechanism.
+
+    def test_func1(self):
+        pyfunc = call_func1_nullary
+        cfunc = jit(nopython=True)(pyfunc)
+        self.assertPreciseEqual(cfunc(), 42)
+        pyfunc = call_func1_unary
+        cfunc = jit(nopython=True)(pyfunc)
+        self.assertPreciseEqual(cfunc(None), 42)
+        self.assertPreciseEqual(cfunc(18.0), 6.0)
+
+    @TestCase.run_test_in_subprocess
+    def test_func1_isolated(self):
+        self.test_func1()
+
+    def test_type_callable_keeps_function(self):
+        self.assertIs(type_func1, type_func1_)
+        self.assertIsNotNone(type_func1)
+
+    @TestCase.run_test_in_subprocess
+    def test_cast_mydummy(self):
+        pyfunc = get_dummy
+        cfunc = njit(types.float64(),)(pyfunc)
+        self.assertPreciseEqual(cfunc(), 42.0)
+
+    def test_mk_func_literal(self):
+        """make sure make_function is passed to typer class as a literal
+        """
+        test_ir = compiler.run_frontend(mk_func_test_impl)
+        typingctx = cpu_target.typing_context
+        targetctx = cpu_target.target_context
+        typingctx.refresh()
+        targetctx.refresh()
+        typing_res = type_inference_stage(typingctx, targetctx, test_ir, (),
+                                          None)
+        self.assertTrue(
+            any(
+                isinstance(a, types.MakeFunctionLiteral)
+                for a in typing_res.typemap.values()
+            )
+        )
+
+
+class TestPandasLike(TestCase):
+    """
+    Test implementing a pandas-like Index object.
+    Also stresses most of the high-level API.
+    """
+
+    def test_index_len(self):
+        i = Index(np.arange(3))
+        cfunc = jit(nopython=True)(len_usecase)
+        self.assertPreciseEqual(cfunc(i), 3)
+
+    def test_index_getitem(self):
+        i = Index(np.int32([42, 8, -5]))
+        cfunc = jit(nopython=True)(getitem_usecase)
+        self.assertPreciseEqual(cfunc(i, 1), 8)
+        ii = cfunc(i, slice(1, None))
+        self.assertIsInstance(ii, Index)
+        self.assertEqual(list(ii), [8, -5])
+
+    def test_index_ufunc(self):
+        """
+        Check Numpy ufunc on an Index object.
+        """
+        i = Index(np.int32([42, 8, -5]))
+        cfunc = jit(nopython=True)(npyufunc_usecase)
+        ii = cfunc(i)
+        self.assertIsInstance(ii, Index)
+        self.assertPreciseEqual(ii._data, np.cos(np.sin(i._data)))
+
+    def test_index_get_data(self):
+        # The _data attribute is exposed with make_attribute_wrapper()
+        i = Index(np.int32([42, 8, -5]))
+        cfunc = jit(nopython=True)(get_data_usecase)
+        data = cfunc(i)
+        self.assertIs(data, i._data)
+
+    def test_index_is_monotonic(self):
+        # The is_monotonic_increasing attribute is exposed with
+        # overload_attribute()
+        cfunc = jit(nopython=True)(is_monotonic_usecase)
+        for values, expected in [
+            ([8, 42, 5], False),
+            ([5, 8, 42], True),
+            ([], True),
+        ]:
+            i = Index(np.int32(values))
+            got = cfunc(i)
+            self.assertEqual(got, expected)
+
+    def test_series_len(self):
+        i = Index(np.int32([2, 4, 3]))
+        s = Series(np.float64([1.5, 4.0, 2.5]), i)
+        cfunc = jit(nopython=True)(len_usecase)
+        self.assertPreciseEqual(cfunc(s), 3)
+
+    def test_series_get_index(self):
+        i = Index(np.int32([2, 4, 3]))
+        s = Series(np.float64([1.5, 4.0, 2.5]), i)
+        cfunc = jit(nopython=True)(get_index_usecase)
+        got = cfunc(s)
+        self.assertIsInstance(got, Index)
+        self.assertIs(got._data, i._data)
+
+    def test_series_ufunc(self):
+        """
+        Check Numpy ufunc on an Series object.
+        """
+        i = Index(np.int32([42, 8, -5]))
+        s = Series(np.int64([1, 2, 3]), i)
+        cfunc = jit(nopython=True)(npyufunc_usecase)
+        ss = cfunc(s)
+        self.assertIsInstance(ss, Series)
+        self.assertIsInstance(ss._index, Index)
+        self.assertIs(ss._index._data, i._data)
+        self.assertPreciseEqual(ss._values, np.cos(np.sin(s._values)))
+
+    def test_series_constructor(self):
+        i = Index(np.int32([42, 8, -5]))
+        d = np.float64([1.5, 4.0, 2.5])
+        cfunc = jit(nopython=True)(make_series_usecase)
+        got = cfunc(d, i)
+        self.assertIsInstance(got, Series)
+        self.assertIsInstance(got._index, Index)
+        self.assertIs(got._index._data, i._data)
+        self.assertIs(got._values, d)
+
+    def test_series_clip(self):
+        i = Index(np.int32([42, 8, -5]))
+        s = Series(np.float64([1.5, 4.0, 2.5]), i)
+        cfunc = jit(nopython=True)(clip_usecase)
+        ss = cfunc(s, 1.6, 3.0)
+        self.assertIsInstance(ss, Series)
+        self.assertIsInstance(ss._index, Index)
+        self.assertIs(ss._index._data, i._data)
+        self.assertPreciseEqual(ss._values, np.float64([1.6, 3.0, 2.5]))
+
+
+class TestHighLevelExtending(TestCase):
+    """
+    Test the high-level combined API.
+    """
+
+    def test_where(self):
+        """
+        Test implementing a function with @overload.
+        """
+        pyfunc = call_where
+        cfunc = jit(nopython=True)(pyfunc)
+
+        def check(*args, **kwargs):
+            expected = np_where(*args, **kwargs)
+            got = cfunc(*args, **kwargs)
+            self.assertPreciseEqual(expected, got)
+
+        check(x=3, cond=True, y=8)
+        check(True, 3, 8)
+        check(
+            np.bool_([True, False, True]),
+            np.int32([1, 2, 3]),
+            np.int32([4, 5, 5]),
+        )
+
+        # The typing error is propagated
+        with self.assertRaises(errors.TypingError) as raises:
+            cfunc(np.bool_([]), np.int32([]), np.int64([]))
+        self.assertIn(
+            "x and y should have the same dtype", str(raises.exception)
+        )
+
+    def test_len(self):
+        """
+        Test re-implementing len() for a custom type with @overload.
+        """
+        cfunc = jit(nopython=True)(len_usecase)
+        self.assertPreciseEqual(cfunc(MyDummy()), 13)
+        self.assertPreciseEqual(cfunc([4, 5]), 2)
+
+    def test_print(self):
+        """
+        Test re-implementing print() for a custom type with @overload.
+        """
+        cfunc = jit(nopython=True)(print_usecase)
+        with captured_stdout():
+            cfunc(MyDummy())
+            self.assertEqual(sys.stdout.getvalue(), "hello!\n")
+
+    def test_add_operator(self):
+        """
+        Test re-implementing operator.add() for a custom type with @overload.
+        """
+        pyfunc = call_add_operator
+        cfunc = jit(nopython=True)(pyfunc)
+
+        self.assertPreciseEqual(cfunc(1, 2), 3)
+        self.assertPreciseEqual(cfunc(MyDummy2(), MyDummy2()), 42)
+
+        # this will call add(Number, Number) as MyDummy implicitly casts to
+        # Number
+        self.assertPreciseEqual(cfunc(MyDummy(), MyDummy()), 84)
+
+    def test_add_binop(self):
+        """
+        Test re-implementing '+' for a custom type via @overload(operator.add).
+        """
+        pyfunc = call_add_binop
+        cfunc = jit(nopython=True)(pyfunc)
+
+        self.assertPreciseEqual(cfunc(1, 2), 3)
+        self.assertPreciseEqual(cfunc(MyDummy2(), MyDummy2()), 42)
+
+        # this will call add(Number, Number) as MyDummy implicitly casts to
+        # Number
+        self.assertPreciseEqual(cfunc(MyDummy(), MyDummy()), 84)
+
+    def test_iadd_operator(self):
+        """
+        Test re-implementing operator.add() for a custom type with @overload.
+        """
+        pyfunc = call_iadd_operator
+        cfunc = jit(nopython=True)(pyfunc)
+
+        self.assertPreciseEqual(cfunc(1, 2), 3)
+        self.assertPreciseEqual(cfunc(MyDummy2(), MyDummy2()), 42)
+
+        # this will call add(Number, Number) as MyDummy implicitly casts to
+        # Number
+        self.assertPreciseEqual(cfunc(MyDummy(), MyDummy()), 84)
+
+    def test_iadd_binop(self):
+        """
+        Test re-implementing '+' for a custom type via @overload(operator.add).
+        """
+        pyfunc = call_iadd_binop
+        cfunc = jit(nopython=True)(pyfunc)
+
+        self.assertPreciseEqual(cfunc(1, 2), 3)
+        self.assertPreciseEqual(cfunc(MyDummy2(), MyDummy2()), 42)
+
+        # this will call add(Number, Number) as MyDummy implicitly casts to
+        # Number
+        self.assertPreciseEqual(cfunc(MyDummy(), MyDummy()), 84)
+
+    def test_delitem(self):
+        pyfunc = call_delitem
+        cfunc = jit(nopython=True)(pyfunc)
+        obj = MyDummy()
+        e = None
+
+        with captured_stdout() as out:
+            try:
+                cfunc(obj, 321)
+            except Exception as exc:
+                e = exc
+
+        if e is not None:
+            raise e
+        self.assertEqual(out.getvalue(), "del hello! 321\n")
+
+    def test_getitem(self):
+        pyfunc = call_getitem
+        cfunc = jit(nopython=True)(pyfunc)
+        self.assertPreciseEqual(cfunc(MyDummy(), 321), 321 + 123)
+
+    def test_setitem(self):
+        pyfunc = call_setitem
+        cfunc = jit(nopython=True)(pyfunc)
+        obj = MyDummy()
+        e = None
+
+        with captured_stdout() as out:
+            try:
+                cfunc(obj, 321, 123)
+            except Exception as exc:
+                e = exc
+
+        if e is not None:
+            raise e
+        self.assertEqual(out.getvalue(), "321 123\n")
+
+    def test_no_cpython_wrapper(self):
+        """
+        Test overloading whose return value cannot be represented in CPython.
+        """
+        # Test passing Module type from a @overload implementation to ensure
+        # that the *no_cpython_wrapper* flag works
+        ok_cfunc = jit(nopython=True)(non_boxable_ok_usecase)
+        n = 10
+        got = ok_cfunc(n)
+        expect = non_boxable_ok_usecase(n)
+        np.testing.assert_equal(expect, got)
+        # Verify that the Module type cannot be returned to CPython
+        bad_cfunc = jit(nopython=True)(non_boxable_bad_usecase)
+        with self.assertRaises(TypeError) as raises:
+            bad_cfunc()
+        errmsg = str(raises.exception)
+        expectmsg = "cannot convert native Module"
+        self.assertIn(expectmsg, errmsg)
+
+    def test_typing_vs_impl_signature_mismatch_handling(self):
+        """
+        Tests that an overload which has a differing typing and implementing
+        signature raises an exception.
+        """
+
+        def gen_ol(impl=None):
+            def myoverload(a, b, c, kw=None):
+                pass
+
+            @overload(myoverload)
+            def _myoverload_impl(a, b, c, kw=None):
+                return impl
+
+            @jit(nopython=True)
+            def foo(a, b, c, d):
+                myoverload(a, b, c, kw=d)
+
+            return foo
+
+        sentinel = "Typing and implementation arguments differ in"
+
+        # kwarg value is different
+        def impl1(a, b, c, kw=12):
+            if a > 10:
+                return 1
+            else:
+                return -1
+
+        with self.assertRaises(errors.TypingError) as e:
+            gen_ol(impl1)(1, 2, 3, 4)
+        msg = str(e.exception)
+        self.assertIn(sentinel, msg)
+        self.assertIn("keyword argument default values", msg)
+        self.assertIn('<Parameter "kw=12">', msg)
+        self.assertIn('<Parameter "kw=None">', msg)
+
+        # kwarg name is different
+        def impl2(a, b, c, kwarg=None):
+            if a > 10:
+                return 1
+            else:
+                return -1
+
+        with self.assertRaises(errors.TypingError) as e:
+            gen_ol(impl2)(1, 2, 3, 4)
+        msg = str(e.exception)
+        self.assertIn(sentinel, msg)
+        self.assertIn("keyword argument names", msg)
+        self.assertIn('<Parameter "kwarg=None">', msg)
+        self.assertIn('<Parameter "kw=None">', msg)
+
+        # arg name is different
+        def impl3(z, b, c, kw=None):
+            if a > 10:      # noqa: F821
+                return 1
+            else:
+                return -1
+
+        with self.assertRaises(errors.TypingError) as e:
+            gen_ol(impl3)(1, 2, 3, 4)
+        msg = str(e.exception)
+        self.assertIn(sentinel, msg)
+        self.assertIn("argument names", msg)
+        self.assertFalse("keyword" in msg)
+        self.assertIn('<Parameter "a">', msg)
+        self.assertIn('<Parameter "z">', msg)
+
+        from .overload_usecases import impl4, impl5
+
+        with self.assertRaises(errors.TypingError) as e:
+            gen_ol(impl4)(1, 2, 3, 4)
+        msg = str(e.exception)
+        self.assertIn(sentinel, msg)
+        self.assertIn("argument names", msg)
+        self.assertFalse("keyword" in msg)
+        self.assertIn("First difference: 'z'", msg)
+
+        with self.assertRaises(errors.TypingError) as e:
+            gen_ol(impl5)(1, 2, 3, 4)
+        msg = str(e.exception)
+        self.assertIn(sentinel, msg)
+        self.assertIn("argument names", msg)
+        self.assertFalse("keyword" in msg)
+        self.assertIn('<Parameter "a">', msg)
+        self.assertIn('<Parameter "z">', msg)
+
+        # too many args
+        def impl6(a, b, c, d, e, kw=None):
+            if a > 10:
+                return 1
+            else:
+                return -1
+
+        with self.assertRaises(errors.TypingError) as e:
+            gen_ol(impl6)(1, 2, 3, 4)
+        msg = str(e.exception)
+        self.assertIn(sentinel, msg)
+        self.assertIn("argument names", msg)
+        self.assertFalse("keyword" in msg)
+        self.assertIn('<Parameter "d">', msg)
+        self.assertIn('<Parameter "e">', msg)
+
+        # too few args
+        def impl7(a, b, kw=None):
+            if a > 10:
+                return 1
+            else:
+                return -1
+
+        with self.assertRaises(errors.TypingError) as e:
+            gen_ol(impl7)(1, 2, 3, 4)
+        msg = str(e.exception)
+        self.assertIn(sentinel, msg)
+        self.assertIn("argument names", msg)
+        self.assertFalse("keyword" in msg)
+        self.assertIn('<Parameter "c">', msg)
+
+        # too many kwargs
+        def impl8(a, b, c, kw=None, extra_kwarg=None):
+            if a > 10:
+                return 1
+            else:
+                return -1
+
+        with self.assertRaises(errors.TypingError) as e:
+            gen_ol(impl8)(1, 2, 3, 4)
+        msg = str(e.exception)
+        self.assertIn(sentinel, msg)
+        self.assertIn("keyword argument names", msg)
+        self.assertIn('<Parameter "extra_kwarg=None">', msg)
+
+        # too few kwargs
+        def impl9(a, b, c):
+            if a > 10:
+                return 1
+            else:
+                return -1
+
+        with self.assertRaises(errors.TypingError) as e:
+            gen_ol(impl9)(1, 2, 3, 4)
+        msg = str(e.exception)
+        self.assertIn(sentinel, msg)
+        self.assertIn("keyword argument names", msg)
+        self.assertIn('<Parameter "kw=None">', msg)
+
+    def test_typing_vs_impl_signature_mismatch_handling_var_positional(self):
+        """
+        Tests that an overload which has a differing typing and implementing
+        signature raises an exception and uses VAR_POSITIONAL (*args) in typing
+        """
+
+        def myoverload(a, kw=None):
+            pass
+
+        from .overload_usecases import var_positional_impl
+
+        overload(myoverload)(var_positional_impl)
+
+        @jit(nopython=True)
+        def foo(a, b):
+            return myoverload(a, b, 9, kw=11)
+
+        with self.assertRaises(errors.TypingError) as e:
+            foo(1, 5)
+        msg = str(e.exception)
+        self.assertIn("VAR_POSITIONAL (e.g. *args) argument kind", msg)
+        self.assertIn("offending argument name is '*star_args_token'", msg)
+
+    def test_typing_vs_impl_signature_mismatch_handling_var_keyword(self):
+        """
+        Tests that an overload which uses **kwargs (VAR_KEYWORD)
+        """
+
+        def gen_ol(impl, strict=True):
+            def myoverload(a, kw=None):
+                pass
+
+            overload(myoverload, strict=strict)(impl)
+
+            @jit(nopython=True)
+            def foo(a, b):
+                return myoverload(a, kw=11)
+
+            return foo
+
+        # **kwargs in typing
+        def ol1(a, **kws):
+            def impl(a, kw=10):
+                return a
+
+            return impl
+
+        gen_ol(ol1, False)(1, 2)  # no error if strictness not enforced
+        with self.assertRaises(errors.TypingError) as e:
+            gen_ol(ol1)(1, 2)
+        msg = str(e.exception)
+        self.assertIn("use of VAR_KEYWORD (e.g. **kwargs) is unsupported", msg)
+        self.assertIn("offending argument name is '**kws'", msg)
+
+        # **kwargs in implementation
+        def ol2(a, kw=0):
+            def impl(a, **kws):
+                return a
+
+            return impl
+
+        with self.assertRaises(errors.TypingError) as e:
+            gen_ol(ol2)(1, 2)
+        msg = str(e.exception)
+        self.assertIn("use of VAR_KEYWORD (e.g. **kwargs) is unsupported", msg)
+        self.assertIn("offending argument name is '**kws'", msg)
+
+    def test_overload_method_kwargs(self):
+        # Issue #3489
+        @overload_method(types.Array, "foo")
+        def fooimpl(arr, a_kwarg=10):
+            def impl(arr, a_kwarg=10):
+                return a_kwarg
+
+            return impl
+
+        @njit
+        def bar(A):
+            return A.foo(), A.foo(20), A.foo(a_kwarg=30)
+
+        Z = np.arange(5)
+
+        self.assertEqual(bar(Z), (10, 20, 30))
+
+    def test_overload_method_literal_unpack(self):
+        # Issue #3683
+        @overload_method(types.Array, "litfoo")
+        def litfoo(arr, val):
+            # Must be an integer
+            if isinstance(val, types.Integer):
+                # Must not be literal
+                if not isinstance(val, types.Literal):
+
+                    def impl(arr, val):
+                        return val
+
+                    return impl
+
+        @njit
+        def bar(A):
+            return A.litfoo(0xCAFE)
+
+        A = np.zeros(1)
+        bar(A)
+        self.assertEqual(bar(A), 0xCAFE)
+
+    def test_overload_ufunc(self):
+        # Issue #4133.
+        # Use an extended type (MyDummyType) to use with a customized
+        # ufunc (np.exp).
+        @njit
+        def test():
+            return np.exp(mydummy)
+
+        self.assertEqual(test(), 0xDEADBEEF)
+
+    def test_overload_method_stararg(self):
+        @overload_method(MyDummyType, "method_stararg")
+        def _ov_method_stararg(obj, val, val2, *args):
+            def get(obj, val, val2, *args):
+                return (val, val2, args)
+
+            return get
+
+        @njit
+        def foo(obj, *args):
+            # Test with expanding stararg
+            return obj.method_stararg(*args)
+
+        obj = MyDummy()
+        self.assertEqual(foo(obj, 1, 2), (1, 2, ()))
+        self.assertEqual(foo(obj, 1, 2, 3), (1, 2, (3,)))
+        self.assertEqual(foo(obj, 1, 2, 3, 4), (1, 2, (3, 4)))
+
+        @njit
+        def bar(obj):
+            # Test with explicit argument
+            return (
+                obj.method_stararg(1, 2),
+                obj.method_stararg(1, 2, 3),
+                obj.method_stararg(1, 2, 3, 4),
+            )
+
+        self.assertEqual(
+            bar(obj), ((1, 2, ()), (1, 2, (3,)), (1, 2, (3, 4))),
+        )
+
+        # Check cases that put tuple type into stararg
+        # NOTE: the expected result has an extra tuple because of stararg.
+        self.assertEqual(
+            foo(obj, 1, 2, (3,)), (1, 2, ((3,),)),
+        )
+        self.assertEqual(
+            foo(obj, 1, 2, (3, 4)), (1, 2, ((3, 4),)),
+        )
+        self.assertEqual(
+            foo(obj, 1, 2, (3, (4, 5))), (1, 2, ((3, (4, 5)),)),
+        )
+
+    def test_overload_classmethod(self):
+        # Add classmethod to a subclass of Array
+        class MyArray(types.Array):
+            pass
+
+        @overload_classmethod(MyArray, "array_alloc")
+        def ol_array_alloc(cls, nitems):
+            def impl(cls, nitems):
+                arr = np.arange(nitems)
+                return arr
+            return impl
+
+        @njit
+        def foo(nitems):
+            return MyArray.array_alloc(nitems)
+
+        nitems = 13
+        self.assertPreciseEqual(foo(nitems), np.arange(nitems))
+
+        # Check that the base type doesn't get the classmethod
+
+        @njit
+        def no_classmethod_in_base(nitems):
+            return types.Array.array_alloc(nitems)
+
+        with self.assertRaises(errors.TypingError) as raises:
+            no_classmethod_in_base(nitems)
+        self.assertIn(
+            "Unknown attribute 'array_alloc' of",
+            str(raises.exception),
+        )
+
+    def test_overload_callable_typeref(self):
+
+        @overload(CallableTypeRef)
+        def callable_type_call_ovld1(x):
+            if isinstance(x, types.Integer):
+                def impl(x):
+                    return 42.5 + x
+                return impl
+
+        @overload(CallableTypeRef)
+        def callable_type_call_ovld2(x):
+            if isinstance(x, types.UnicodeType):
+                def impl(x):
+                    return '42.5' + x
+
+                return impl
+
+        @njit
+        def foo(a, b):
+            return MyClass(a), MyClass(b)
+
+        args = (4, '4')
+        expected = (42.5 + args[0], '42.5' + args[1])
+        self.assertPreciseEqual(foo(*args), expected)
+
+
+def _assert_cache_stats(cfunc, expect_hit, expect_misses):
+    hit = cfunc._cache_hits[cfunc.signatures[0]]
+    if hit != expect_hit:
+        raise AssertionError("cache not used")
+    miss = cfunc._cache_misses[cfunc.signatures[0]]
+    if miss != expect_misses:
+        raise AssertionError("cache not used")
+
+
+@skip_if_typeguard
+class TestOverloadMethodCaching(TestCase):
+    # Nested multiprocessing.Pool raises AssertionError:
+    # "daemonic processes are not allowed to have children"
+    _numba_parallel_test_ = False
+
+    def test_caching_overload_method(self):
+        self._cache_dir = temp_directory(self.__class__.__name__)
+        with override_config("CACHE_DIR", self._cache_dir):
+            self.run_caching_overload_method()
+
+    def run_caching_overload_method(self):
+        cfunc = jit(nopython=True, cache=True)(cache_overload_method_usecase)
+        self.assertPreciseEqual(cfunc(MyDummy()), 13)
+        _assert_cache_stats(cfunc, 0, 1)
+        llvmir = cfunc.inspect_llvm((mydummy_type,))
+        # Ensure the inner method is not a declaration
+        decls = [
+            ln
+            for ln in llvmir.splitlines()
+            if ln.startswith("declare") and "overload_method_length" in ln
+        ]
+        self.assertEqual(len(decls), 0)
+        # Test in a separate process
+        try:
+            ctx = multiprocessing.get_context("spawn")
+        except AttributeError:
+            ctx = multiprocessing
+        q = ctx.Queue()
+        p = ctx.Process(
+            target=run_caching_overload_method, args=(q, self._cache_dir)
+        )
+        p.start()
+        q.put(MyDummy())
+        p.join()
+        # Ensure subprocess exited normally
+        self.assertEqual(p.exitcode, 0)
+        res = q.get(timeout=1)
+        self.assertEqual(res, 13)
+
+
+def run_caching_overload_method(q, cache_dir):
+    """
+    Used by TestOverloadMethodCaching.test_caching_overload_method
+    """
+    with override_config("CACHE_DIR", cache_dir):
+        arg = q.get()
+        cfunc = jit(nopython=True, cache=True)(cache_overload_method_usecase)
+        res = cfunc(arg)
+        q.put(res)
+        # Check cache stat
+        _assert_cache_stats(cfunc, 1, 0)
+
+
+class TestIntrinsic(TestCase):
+    def test_void_return(self):
+        """
+        Verify that returning a None from codegen function is handled
+        automatically for void functions, otherwise raise exception.
+        """
+
+        @intrinsic
+        def void_func(typingctx, a):
+            sig = types.void(types.int32)
+
+            def codegen(context, builder, signature, args):
+                pass  # do nothing, return None, should be turned into
+                # dummy value
+
+            return sig, codegen
+
+        @intrinsic
+        def non_void_func(typingctx, a):
+            sig = types.int32(types.int32)
+
+            def codegen(context, builder, signature, args):
+                pass  # oops, should be returning a value here, raise exception
+
+            return sig, codegen
+
+        @jit(nopython=True)
+        def call_void_func():
+            void_func(1)
+            return 0
+
+        @jit(nopython=True)
+        def call_non_void_func():
+            non_void_func(1)
+            return 0
+
+        # void func should work
+        self.assertEqual(call_void_func(), 0)
+        # not void function should raise exception
+        with self.assertRaises(LoweringError) as e:
+            call_non_void_func()
+        self.assertIn("non-void function returns None", e.exception.msg)
+
+    def test_ll_pointer_cast(self):
+        """
+        Usecase test: custom reinterpret cast to turn int values to pointers
+        """
+        from ctypes import CFUNCTYPE, POINTER, c_float, c_int
+
+        # Use intrinsic to make a reinterpret_cast operation
+        def unsafe_caster(result_type):
+            assert isinstance(result_type, types.CPointer)
+
+            @intrinsic
+            def unsafe_cast(typingctx, src):
+                self.assertIsInstance(typingctx, typing.Context)
+                if isinstance(src, types.Integer):
+                    sig = result_type(types.uintp)
+
+                    # defines the custom code generation
+                    def codegen(context, builder, signature, args):
+                        [src] = args
+                        rtype = signature.return_type
+                        llrtype = context.get_value_type(rtype)
+                        return builder.inttoptr(src, llrtype)
+
+                    return sig, codegen
+
+            return unsafe_cast
+
+        # make a nopython function to use our cast op.
+        # this is not usable from cpython due to the returning of a pointer.
+        def unsafe_get_ctypes_pointer(src):
+            raise NotImplementedError("not callable from python")
+
+        @overload(unsafe_get_ctypes_pointer, strict=False)
+        def array_impl_unsafe_get_ctypes_pointer(arrtype):
+            if isinstance(arrtype, types.Array):
+                unsafe_cast = unsafe_caster(types.CPointer(arrtype.dtype))
+
+                def array_impl(arr):
+                    return unsafe_cast(src=arr.ctypes.data)
+
+                return array_impl
+
+        # the ctype wrapped function for use in nopython mode
+        def my_c_fun_raw(ptr, n):
+            for i in range(n):
+                print(ptr[i])
+
+        prototype = CFUNCTYPE(None, POINTER(c_float), c_int)
+        my_c_fun = prototype(my_c_fun_raw)
+
+        # Call our pointer-cast in a @jit compiled function and use
+        # the pointer in a ctypes function
+        @jit(nopython=True)
+        def foo(arr):
+            ptr = unsafe_get_ctypes_pointer(arr)
+            my_c_fun(ptr, arr.size)
+
+        # Test
+        arr = np.arange(10, dtype=np.float32)
+        with captured_stdout() as buf:
+            foo(arr)
+            got = buf.getvalue().splitlines()
+        buf.close()
+        expect = list(map(str, arr))
+        self.assertEqual(expect, got)
+
+    def test_serialization(self):
+        """
+        Test serialization of intrinsic objects
+        """
+        # define a intrinsic
+        @intrinsic
+        def identity(context, x):
+            def codegen(context, builder, signature, args):
+                return args[0]
+
+            sig = x(x)
+            return sig, codegen
+
+        # use in a jit function
+        @jit(nopython=True)
+        def foo(x):
+            return identity(x)
+
+        self.assertEqual(foo(1), 1)
+
+        # get serialization memo
+        memo = _Intrinsic._memo
+        memo_size = len(memo)
+
+        # pickle foo and check memo size
+        serialized_foo = pickle.dumps(foo)
+        # increases the memo size
+        memo_size += 1
+        self.assertEqual(memo_size, len(memo))
+        # unpickle
+        foo_rebuilt = pickle.loads(serialized_foo)
+        self.assertEqual(memo_size, len(memo))
+        # check rebuilt foo
+        self.assertEqual(foo(1), foo_rebuilt(1))
+
+        # pickle identity directly
+        serialized_identity = pickle.dumps(identity)
+        # memo size unchanged
+        self.assertEqual(memo_size, len(memo))
+        # unpickle
+        identity_rebuilt = pickle.loads(serialized_identity)
+        # must be the same object
+        self.assertIs(identity, identity_rebuilt)
+        # memo size unchanged
+        self.assertEqual(memo_size, len(memo))
+
+    def test_deserialization(self):
+        """
+        Test deserialization of intrinsic
+        """
+
+        def defn(context, x):
+            def codegen(context, builder, signature, args):
+                return args[0]
+
+            return x(x), codegen
+
+        memo = _Intrinsic._memo
+        memo_size = len(memo)
+        # invoke _Intrinsic indirectly to avoid registration which keeps an
+        # internal reference inside the compiler
+        original = _Intrinsic("foo", defn)
+        self.assertIs(original._defn, defn)
+        pickled = pickle.dumps(original)
+        # by pickling, a new memo entry is created
+        memo_size += 1
+        self.assertEqual(memo_size, len(memo))
+        del original  # remove original before unpickling
+
+        # by deleting, the memo entry is NOT removed due to recent
+        # function queue
+        self.assertEqual(memo_size, len(memo))
+
+        # Manually force clear of _recent queue
+        _Intrinsic._recent.clear()
+        memo_size -= 1
+        self.assertEqual(memo_size, len(memo))
+
+        rebuilt = pickle.loads(pickled)
+        # verify that the rebuilt object is different
+        self.assertIsNot(rebuilt._defn, defn)
+
+        # the second rebuilt object is the same as the first
+        second = pickle.loads(pickled)
+        self.assertIs(rebuilt._defn, second._defn)
+
+    def test_docstring(self):
+
+        @intrinsic
+        def void_func(typingctx, a: int):
+            """void_func docstring"""
+            sig = types.void(types.int32)
+
+            def codegen(context, builder, signature, args):
+                pass  # do nothing, return None, should be turned into
+                # dummy value
+
+            return sig, codegen
+
+        self.assertEqual("numba.tests.test_extending", void_func.__module__)
+        self.assertEqual("void_func", void_func.__name__)
+        self.assertEqual("TestIntrinsic.test_docstring.<locals>.void_func",
+                         void_func.__qualname__)
+        self.assertDictEqual({'a': int}, void_func.__annotations__)
+        self.assertEqual("void_func docstring", void_func.__doc__)
+
+
+class TestRegisterJitable(unittest.TestCase):
+    def test_no_flags(self):
+        @register_jitable
+        def foo(x, y):
+            return x + y
+
+        def bar(x, y):
+            return foo(x, y)
+
+        cbar = jit(nopython=True)(bar)
+
+        expect = bar(1, 2)
+        got = cbar(1, 2)
+        self.assertEqual(expect, got)
+
+    def test_flags_no_nrt(self):
+        @register_jitable(_nrt=False)
+        def foo(n):
+            return np.arange(n)
+
+        def bar(n):
+            return foo(n)
+
+        self.assertEqual(bar(3).tolist(), [0, 1, 2])
+
+        cbar = jit(nopython=True)(bar)
+        with self.assertRaises(errors.TypingError) as raises:
+            cbar(2)
+        msg = (
+            "Only accept returning of array passed into the function as "
+            "argument"
+        )
+        self.assertIn(msg, str(raises.exception))
+
+
+class TestImportCythonFunction(unittest.TestCase):
+    @unittest.skipIf(sc is None, "Only run if SciPy >= 0.19 is installed")
+    def test_getting_function(self):
+        addr = get_cython_function_address(
+            "scipy.special.cython_special", "j0"
+        )
+        functype = ctypes.CFUNCTYPE(ctypes.c_double, ctypes.c_double)
+        _j0 = functype(addr)
+        j0 = jit(nopython=True)(lambda x: _j0(x))
+        self.assertEqual(j0(0), 1)
+
+    def test_missing_module(self):
+        with self.assertRaises(ImportError) as raises:
+            get_cython_function_address("fakemodule", "fakefunction")
+        # The quotes are not there in Python 2
+        msg = "No module named '?fakemodule'?"
+        match = re.match(msg, str(raises.exception))
+        self.assertIsNotNone(match)
+
+    @unittest.skipIf(sc is None, "Only run if SciPy >= 0.19 is installed")
+    def test_missing_function(self):
+        with self.assertRaises(ValueError) as raises:
+            get_cython_function_address(
+                "scipy.special.cython_special", "foo"
+            )
+        msg = (
+            "No function 'foo' found in __pyx_capi__ of "
+            "'scipy.special.cython_special'"
+        )
+        self.assertEqual(msg, str(raises.exception))
+
+
+@overload_method(
+    MyDummyType, "method_jit_option_check_nrt", jit_options={"_nrt": True}
+)
+def ov_method_jit_option_check_nrt(obj):
+    def imp(obj):
+        return np.arange(10)
+
+    return imp
+
+
+@overload_method(
+    MyDummyType, "method_jit_option_check_no_nrt", jit_options={"_nrt": False}
+)
+def ov_method_jit_option_check_no_nrt(obj):
+    def imp(obj):
+        return np.arange(10)
+
+    return imp
+
+
+@overload_attribute(
+    MyDummyType, "attr_jit_option_check_nrt", jit_options={"_nrt": True}
+)
+def ov_attr_jit_option_check_nrt(obj):
+    def imp(obj):
+        return np.arange(10)
+
+    return imp
+
+
+@overload_attribute(
+    MyDummyType, "attr_jit_option_check_no_nrt", jit_options={"_nrt": False}
+)
+def ov_attr_jit_option_check_no_nrt(obj):
+    def imp(obj):
+        return np.arange(10)
+
+    return imp
+
+
+class TestJitOptionsNoNRT(TestCase):
+    # Test overload*(jit_options={...}) by turning off _nrt
+
+    def check_error_no_nrt(self, func, *args, **kwargs):
+        # Check that the compilation fails with a complaint about dynamic array
+        msg = (
+            "Only accept returning of array passed into "
+            "the function as argument"
+        )
+        with self.assertRaises(errors.TypingError) as raises:
+            func(*args, **kwargs)
+        self.assertIn(msg, str(raises.exception))
+
+    def no_nrt_overload_check(self, flag):
+        def dummy():
+            return np.arange(10)
+
+        @overload(dummy, jit_options={"_nrt": flag})
+        def ov_dummy():
+            def dummy():
+                return np.arange(10)
+
+            return dummy
+
+        @njit
+        def foo():
+            return dummy()
+
+        if flag:
+            self.assertPreciseEqual(foo(), np.arange(10))
+        else:
+            self.check_error_no_nrt(foo)
+
+    def test_overload_no_nrt(self):
+        self.no_nrt_overload_check(True)
+        self.no_nrt_overload_check(False)
+
+    def test_overload_method_no_nrt(self):
+        @njit
+        def udt(x):
+            return x.method_jit_option_check_nrt()
+
+        self.assertPreciseEqual(udt(mydummy), np.arange(10))
+
+        @njit
+        def udt(x):
+            return x.method_jit_option_check_no_nrt()
+
+        self.check_error_no_nrt(udt, mydummy)
+
+    def test_overload_attribute_no_nrt(self):
+        @njit
+        def udt(x):
+            return x.attr_jit_option_check_nrt
+
+        self.assertPreciseEqual(udt(mydummy), np.arange(10))
+
+        @njit
+        def udt(x):
+            return x.attr_jit_option_check_no_nrt
+
+        self.check_error_no_nrt(udt, mydummy)
+
+
+class TestBoxingCallingJIT(TestCase):
+    def setUp(self):
+        super().setUp()
+        many = base_dummy_type_factory("mydummy2")
+        self.DynTypeType, self.DynType, self.dyn_type_type = many
+        self.dyn_type = self.DynType()
+
+    def test_unboxer_basic(self):
+        # Implements an unboxer on DynType that calls an intrinsic into the
+        # unboxer code.
+        magic_token = 0xCAFE
+        magic_offset = 123
+
+        @intrinsic
+        def my_intrinsic(typingctx, val):
+            # An intrinsic that returns `val + magic_offset`
+            def impl(context, builder, sig, args):
+                [val] = args
+                return builder.add(val, val.type(magic_offset))
+
+            sig = signature(val, val)
+            return sig, impl
+
+        @unbox(self.DynTypeType)
+        def unboxer(typ, obj, c):
+            # The unboxer that calls some jitcode
+            def bridge(x):
+                # proof that this is a jit'ed context by calling jit only
+                # intrinsic
+                return my_intrinsic(x)
+
+            args = [c.context.get_constant(types.intp, magic_token)]
+            sig = signature(types.voidptr, types.intp)
+            is_error, res = c.pyapi.call_jit_code(bridge, sig, args)
+            return NativeValue(res, is_error=is_error)
+
+        @box(self.DynTypeType)
+        def boxer(typ, val, c):
+            # The boxer that returns an integer representation
+            res = c.builder.ptrtoint(val, cgutils.intp_t)
+            return c.pyapi.long_from_ssize_t(res)
+
+        @njit
+        def passthru(x):
+            return x
+
+        out = passthru(self.dyn_type)
+        self.assertEqual(out, magic_token + magic_offset)
+
+    def test_unboxer_raise(self):
+        # Testing exception raising in jitcode called from unboxing.
+        @unbox(self.DynTypeType)
+        def unboxer(typ, obj, c):
+            # The unboxer that calls some jitcode
+            def bridge(x):
+                if x > 0:
+                    raise ValueError("cannot be x > 0")
+                return x
+
+            args = [c.context.get_constant(types.intp, 1)]
+            sig = signature(types.voidptr, types.intp)
+            is_error, res = c.pyapi.call_jit_code(bridge, sig, args)
+            return NativeValue(res, is_error=is_error)
+
+        @box(self.DynTypeType)
+        def boxer(typ, val, c):
+            # The boxer that returns an integer representation
+            res = c.builder.ptrtoint(val, cgutils.intp_t)
+            return c.pyapi.long_from_ssize_t(res)
+
+        @njit
+        def passthru(x):
+            return x
+
+        with self.assertRaises(ValueError) as raises:
+            passthru(self.dyn_type)
+        self.assertIn(
+            "cannot be x > 0", str(raises.exception),
+        )
+
+    def test_boxer(self):
+        # Call jitcode inside the boxer
+        magic_token = 0xCAFE
+        magic_offset = 312
+
+        @intrinsic
+        def my_intrinsic(typingctx, val):
+            # An intrinsic that returns `val + magic_offset`
+            def impl(context, builder, sig, args):
+                [val] = args
+                return builder.add(val, val.type(magic_offset))
+
+            sig = signature(val, val)
+            return sig, impl
+
+        @unbox(self.DynTypeType)
+        def unboxer(typ, obj, c):
+            return NativeValue(c.context.get_dummy_value())
+
+        @box(self.DynTypeType)
+        def boxer(typ, val, c):
+            # Note: this doesn't do proper error handling
+            def bridge(x):
+                return my_intrinsic(x)
+
+            args = [c.context.get_constant(types.intp, magic_token)]
+            sig = signature(types.intp, types.intp)
+            is_error, res = c.pyapi.call_jit_code(bridge, sig, args)
+            return c.pyapi.long_from_ssize_t(res)
+
+        @njit
+        def passthru(x):
+            return x
+
+        r = passthru(self.dyn_type)
+        self.assertEqual(r, magic_token + magic_offset)
+
+    def test_boxer_raise(self):
+        # Call jitcode inside the boxer
+        @unbox(self.DynTypeType)
+        def unboxer(typ, obj, c):
+            return NativeValue(c.context.get_dummy_value())
+
+        @box(self.DynTypeType)
+        def boxer(typ, val, c):
+            def bridge(x):
+                if x > 0:
+                    raise ValueError("cannot do x > 0")
+                return x
+
+            args = [c.context.get_constant(types.intp, 1)]
+            sig = signature(types.intp, types.intp)
+            is_error, res = c.pyapi.call_jit_code(bridge, sig, args)
+            # The error handling
+            retval = cgutils.alloca_once(c.builder, c.pyapi.pyobj, zfill=True)
+            with c.builder.if_then(c.builder.not_(is_error)):
+                obj = c.pyapi.long_from_ssize_t(res)
+                c.builder.store(obj, retval)
+            return c.builder.load(retval)
+
+        @njit
+        def passthru(x):
+            return x
+
+        with self.assertRaises(ValueError) as raises:
+            passthru(self.dyn_type)
+        self.assertIn(
+            "cannot do x > 0", str(raises.exception),
+        )
+
+
+def with_objmode_cache_ov_example(x):
+    # This is the function stub for overloading inside
+    # TestCachingOverloadObjmode.test_caching_overload_objmode
+    pass
+
+
+@skip_if_typeguard
+class TestCachingOverloadObjmode(TestCase):
+    """Test caching of the use of overload implementations that use
+    `with objmode`
+    """
+    _numba_parallel_test_ = False
+
+    def setUp(self):
+        warnings.simplefilter("error", errors.NumbaWarning)
+
+    def tearDown(self):
+        warnings.resetwarnings()
+
+    def test_caching_overload_objmode(self):
+        cache_dir = temp_directory(self.__class__.__name__)
+        with override_config("CACHE_DIR", cache_dir):
+
+            def realwork(x):
+                # uses numpy code
+                arr = np.arange(x) / x
+                return np.linalg.norm(arr)
+
+            def python_code(x):
+                # create indirections
+                return realwork(x)
+
+            @overload(with_objmode_cache_ov_example)
+            def _ov_with_objmode_cache_ov_example(x):
+                def impl(x):
+                    with objmode(y="float64"):
+                        y = python_code(x)
+                    return y
+
+                return impl
+
+            @njit(cache=True)
+            def testcase(x):
+                return with_objmode_cache_ov_example(x)
+
+            expect = realwork(123)
+            got = testcase(123)
+            self.assertEqual(got, expect)
+
+            testcase_cached = njit(cache=True)(testcase.py_func)
+            got = testcase_cached(123)
+            self.assertEqual(got, expect)
+
+    @classmethod
+    def check_objmode_cache_ndarray(cls):
+        def do_this(a, b):
+            return np.sum(a + b)
+
+        def do_something(a, b):
+            return np.sum(a + b)
+
+        @overload(do_something)
+        def overload_do_something(a, b):
+            def _do_something_impl(a, b):
+                with objmode(y='float64'):
+                    y = do_this(a, b)
+                return y
+            return _do_something_impl
+
+        @njit(cache=True)
+        def test_caching():
+            a = np.arange(20)
+            b = np.arange(20)
+            return do_something(a, b)
+
+        got = test_caching()
+        expect = test_caching.py_func()
+
+        # Check result
+        if got != expect:
+            raise AssertionError("incorrect result")
+        return test_caching
+
+    @classmethod
+    def populate_objmode_cache_ndarray_check_cache(cls):
+        cls.check_objmode_cache_ndarray()
+
+    @classmethod
+    def check_objmode_cache_ndarray_check_cache(cls):
+        disp = cls.check_objmode_cache_ndarray()
+        if len(disp.stats.cache_misses) != 0:
+            raise AssertionError('unexpected cache miss')
+        if len(disp.stats.cache_hits) <= 0:
+            raise AssertionError("unexpected missing cache hit")
+
+    def test_check_objmode_cache_ndarray(self):
+        # See issue #6130.
+        # Env is missing after cache load.
+        cache_dir = temp_directory(self.__class__.__name__)
+        with override_config("CACHE_DIR", cache_dir):
+            # Run in new process to populate the cache
+            run_in_new_process_in_cache_dir(
+                self.populate_objmode_cache_ndarray_check_cache, cache_dir
+            )
+            # Run in new process to use the cache in a fresh process.
+            res = run_in_new_process_in_cache_dir(
+                self.check_objmode_cache_ndarray_check_cache, cache_dir
+            )
+        self.assertEqual(res['exitcode'], 0)
+
+
+class TestMisc(TestCase):
+    def test_is_jitted(self):
+        def foo(x):
+            pass
+
+        self.assertFalse(is_jitted(foo))
+        self.assertTrue(is_jitted(njit(foo)))
+        self.assertFalse(is_jitted(vectorize(foo)))
+        self.assertFalse(is_jitted(vectorize(parallel=True)(foo)))
+        self.assertFalse(
+            is_jitted(guvectorize("void(float64[:])", "(m)")(foo))
+        )
+
+    def test_overload_arg_binding(self):
+        # See issue #7982, checks that calling a function with named args works
+        # correctly irrespective of the order in which the names are supplied.
+        @njit
+        def standard_order():
+            return np.full(shape=123, fill_value=456).shape
+
+        @njit
+        def reversed_order():
+            return np.full(fill_value=456, shape=123).shape
+
+        self.assertPreciseEqual(standard_order(), standard_order.py_func())
+        self.assertPreciseEqual(reversed_order(), reversed_order.py_func())
+
+
+class TestOverloadPreferLiteral(TestCase):
+    def test_overload(self):
+        def prefer_lit(x):
+            pass
+
+        def non_lit(x):
+            pass
+
+        def ov(x):
+            if isinstance(x, types.IntegerLiteral):
+                # With prefer_literal=False, this branch will not be reached.
+                if x.literal_value == 1:
+                    def impl(x):
+                        return 0xcafe
+                    return impl
+                else:
+                    raise errors.TypingError('literal value')
+            else:
+                def impl(x):
+                    return x * 100
+                return impl
+
+        overload(prefer_lit, prefer_literal=True)(ov)
+        overload(non_lit)(ov)
+
+        @njit
+        def check_prefer_lit(x):
+            return prefer_lit(1), prefer_lit(2), prefer_lit(x)
+
+        a, b, c = check_prefer_lit(3)
+        self.assertEqual(a, 0xcafe)
+        self.assertEqual(b, 200)
+        self.assertEqual(c, 300)
+
+        @njit
+        def check_non_lit(x):
+            return non_lit(1), non_lit(2), non_lit(x)
+
+        a, b, c = check_non_lit(3)
+        self.assertEqual(a, 100)
+        self.assertEqual(b, 200)
+        self.assertEqual(c, 300)
+
+    def test_overload_method(self):
+        def ov(self, x):
+            if isinstance(x, types.IntegerLiteral):
+                # With prefer_literal=False, this branch will not be reached.
+                if x.literal_value == 1:
+                    def impl(self, x):
+                        return 0xcafe
+                    return impl
+                else:
+                    raise errors.TypingError('literal value')
+            else:
+                def impl(self, x):
+                    return x * 100
+                return impl
+
+        overload_method(
+            MyDummyType, "method_prefer_literal",
+            prefer_literal=True,
+        )(ov)
+
+        overload_method(
+            MyDummyType, "method_non_literal",
+            prefer_literal=False,
+        )(ov)
+
+        @njit
+        def check_prefer_lit(dummy, x):
+            return (
+                dummy.method_prefer_literal(1),
+                dummy.method_prefer_literal(2),
+                dummy.method_prefer_literal(x),
+            )
+
+        a, b, c = check_prefer_lit(MyDummy(), 3)
+        self.assertEqual(a, 0xcafe)
+        self.assertEqual(b, 200)
+        self.assertEqual(c, 300)
+
+        @njit
+        def check_non_lit(dummy, x):
+            return (
+                dummy.method_non_literal(1),
+                dummy.method_non_literal(2),
+                dummy.method_non_literal(x),
+            )
+
+        a, b, c = check_non_lit(MyDummy(), 3)
+        self.assertEqual(a, 100)
+        self.assertEqual(b, 200)
+        self.assertEqual(c, 300)
+
+
+class TestIntrinsicPreferLiteral(TestCase):
+    def test_intrinsic(self):
+        def intrin(context, x):
+            # This intrinsic will return 0xcafe if `x` is a literal `1`.
+            sig = signature(types.intp, x)
+            if isinstance(x, types.IntegerLiteral):
+                # With prefer_literal=False, this branch will not be reached
+                if x.literal_value == 1:
+                    def codegen(context, builder, signature, args):
+                        atype = signature.args[0]
+                        llrtype = context.get_value_type(atype)
+                        return ir.Constant(llrtype, 0xcafe)
+                    return sig, codegen
+                else:
+                    raise errors.TypingError('literal value')
+            else:
+                def codegen(context, builder, signature, args):
+                    atype = signature.return_type
+                    llrtype = context.get_value_type(atype)
+                    int_100 = ir.Constant(llrtype, 100)
+                    return builder.mul(args[0], int_100)
+                return sig, codegen
+
+        prefer_lit = intrinsic(prefer_literal=True)(intrin)
+        non_lit = intrinsic(prefer_literal=False)(intrin)
+
+        @njit
+        def check_prefer_lit(x):
+            return prefer_lit(1), prefer_lit(2), prefer_lit(x)
+
+        a, b, c = check_prefer_lit(3)
+        self.assertEqual(a, 0xcafe)
+        self.assertEqual(b, 200)
+        self.assertEqual(c, 300)
+
+        @njit
+        def check_non_lit(x):
+            return non_lit(1), non_lit(2), non_lit(x)
+
+        a, b, c = check_non_lit(3)
+        self.assertEqual(a, 100)
+        self.assertEqual(b, 200)
+        self.assertEqual(c, 300)
+
+
+class TestNumbaInternalOverloads(TestCase):
+
+    def test_signatures_match_overloaded_api(self):
+        # This is a "best-effort" test to try and ensure that Numba's internal
+        # overload declarations have signatures with argument names that match
+        # the API they are overloading. The purpose of ensuring there is a
+        # match is so that users can use call-by-name for positional arguments.
+
+        # Set this to:
+        # 0 to make violations raise a ValueError (default).
+        # 1 to get violations reported to STDOUT
+        # 2 to get a verbose output of everything that was checked and its state
+        #   reported to STDOUT.
+        DEBUG = 0
+
+        # np.random.* does not have a signature exposed to `inspect`... so
+        # custom parse the docstrings.
+        def sig_from_np_random(x):
+            if not x.startswith('_'):
+                thing = getattr(np.random, x)
+                if inspect.isbuiltin(thing):
+                    docstr = thing.__doc__.splitlines()
+                    for l in docstr:
+                        if l:
+                            sl = l.strip()
+                            if sl.startswith(x): # its the signature
+                                # special case np.random.seed, it has `self` in
+                                # the signature whereas all the other functions
+                                # do not!?
+                                if x == "seed":
+                                    sl = "seed(seed)"
+
+                                fake_impl = f"def {sl}:\n\tpass"
+                                l = {}
+                                try:
+                                    exec(fake_impl, {}, l)
+                                except SyntaxError:
+                                    # likely elipsis, e.g. rand(d0, d1, ..., dn)
+                                    if DEBUG == 2:
+                                        print("... skipped as cannot parse "
+                                              "signature")
+                                    return None
+                                else:
+                                    fn = l.get(x)
+                                    return inspect.signature(fn)
+
+        def checker(func, overload_func):
+            if DEBUG == 2:
+                print(f"Checking: {func}")
+
+            def create_message(func, overload_func, func_sig, ol_sig):
+                msg = []
+                s = (f"{func} from module '{getattr(func, '__module__')}' "
+                     "has mismatched sig.")
+                msg.append(s)
+                msg.append(f"    - expected: {func_sig}")
+                msg.append(f"    -      got: {ol_sig}")
+                lineno = inspect.getsourcelines(overload_func)[1]
+                tmpsrcfile = inspect.getfile(overload_func)
+                srcfile = tmpsrcfile.replace(numba.__path__[0], '')
+                msg.append(f"from {srcfile}:{lineno}")
+                msgstr = '\n' + '\n'.join(msg)
+                return msgstr
+
+            func_sig = None
+            try:
+                func_sig = inspect.signature(func)
+            except ValueError:
+                # probably a built-in/C code, see if it's a np.random function
+                if fname := getattr(func, '__name__', False):
+                    if maybe_func := getattr(np.random, fname, False):
+                        if maybe_func == func:
+                            # it's a built-in from np.random
+                            func_sig = sig_from_np_random(fname)
+
+            if func_sig is not None:
+                ol_sig = inspect.signature(overload_func)
+                x = list(func_sig.parameters.keys())
+                y = list(ol_sig.parameters.keys())
+                for a, b in zip(x[:len(y)], y):
+                    if a != b:
+                        p = func_sig.parameters[a]
+                        if p.kind == p.POSITIONAL_ONLY:
+                            # probably a built-in/C code
+                            if DEBUG == 2:
+                                print("... skipped as positional only "
+                                      "arguments found")
+                            break
+                        elif '*' in str(p): # probably *args or similar
+                            if DEBUG == 2:
+                                print("... skipped as contains *args")
+                            break
+                        else:
+                            # Only error/report on functions that have a module
+                            # or are from somewhere other than Numba.
+                            if (not func.__module__ or
+                                    not func.__module__.startswith("numba")):
+                                msgstr = create_message(func, overload_func,
+                                                        func_sig, ol_sig)
+                                if DEBUG != 0:
+                                    if DEBUG == 2:
+                                        print("... INVALID")
+                                    if msgstr:
+                                        print(msgstr)
+                                    break
+                                else:
+                                    raise ValueError(msgstr)
+                            else:
+                                if DEBUG == 2:
+                                    if not func.__module__:
+                                        print("... skipped as no __module__ "
+                                              "present")
+                                    else:
+                                        print("... skipped as Numba internal")
+                                break
+                else:
+                    if DEBUG == 2:
+                        print("... OK")
+
+        # Compile something to make sure that the typing context registries
+        # are populated with everything from the CPU target.
+        njit(lambda : None).compile(())
+        tyctx = numba.core.typing.context.Context()
+        tyctx.refresh()
+
+        # Walk the registries and check each function that is an overload
+        regs = tyctx._registries
+        for k, v in regs.items():
+            for item in k.functions:
+                if getattr(item, '_overload_func', False):
+                    checker(item.key, item._overload_func)
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,170 @@
+"""
+Test extending types via the numba.extending.* API.
+"""
+import operator
+
+from numba import njit, literally
+from numba.core import types, cgutils
+from numba.core.errors import TypingError, NumbaTypeError
+from numba.core.extending import lower_builtin
+from numba.core.extending import models, register_model
+from numba.core.extending import make_attribute_wrapper
+from numba.core.extending import type_callable
+from numba.core.extending import overload
+from numba.core.extending import typeof_impl
+
+import unittest
+
+
+def gen_mock_float():
+    # Stub to overload, pretending to be `float`. The real `float` function is
+    # not used as multiple registrations can collide.
+    def mock_float(x):
+        pass
+    return mock_float
+
+
+class TestExtTypDummy(unittest.TestCase):
+
+    def setUp(self):
+        class Dummy(object):
+            def __init__(self, value):
+                self.value = value
+
+        class DummyType(types.Type):
+            def __init__(self):
+                super(DummyType, self).__init__(name='Dummy')
+
+        dummy_type = DummyType()
+
+        @register_model(DummyType)
+        class DummyModel(models.StructModel):
+            def __init__(self, dmm, fe_type):
+                members = [
+                    ('value', types.intp),
+                ]
+                models.StructModel.__init__(self, dmm, fe_type, members)
+
+        make_attribute_wrapper(DummyType, 'value', 'value')
+
+        @type_callable(Dummy)
+        def type_dummy(context):
+            def typer(value):
+                return dummy_type
+            return typer
+
+        @lower_builtin(Dummy, types.intp)
+        def impl_dummy(context, builder, sig, args):
+            typ = sig.return_type
+            [value] = args
+            dummy = cgutils.create_struct_proxy(typ)(context, builder)
+            dummy.value = value
+            return dummy._getvalue()
+
+        @typeof_impl.register(Dummy)
+        def typeof_dummy(val, c):
+            return DummyType()
+
+        # Store attributes
+        self.Dummy = Dummy
+        self.DummyType = DummyType
+
+    def _add_float_overload(self, mock_float_inst):
+        @overload(mock_float_inst)
+        def dummy_to_float(x):
+            if isinstance(x, self.DummyType):
+                def codegen(x):
+                    return float(x.value)
+                return codegen
+            else:
+                raise NumbaTypeError('cannot type float({})'.format(x))
+
+    def test_overload_float(self):
+        mock_float = gen_mock_float()
+        self._add_float_overload(mock_float)
+        Dummy = self.Dummy
+
+        @njit
+        def foo(x):
+            return mock_float(Dummy(x))
+
+        self.assertEqual(foo(123), float(123))
+
+    def test_overload_float_error_msg(self):
+        mock_float = gen_mock_float()
+        self._add_float_overload(mock_float)
+
+        @njit
+        def foo(x):
+            return mock_float(x)
+
+        with self.assertRaises(TypingError) as raises:
+            foo(1j)
+
+        self.assertIn("cannot type float(complex128)",
+                      str(raises.exception))
+
+    def test_unboxing(self):
+        """A test for the unboxing logic on unknown type
+        """
+        Dummy = self.Dummy
+
+        @njit
+        def foo(x):
+            # pass a dummy object into another function
+            bar(Dummy(x))
+
+        # make sure a cpython wrapper is created
+        @njit(no_cpython_wrapper=False)
+        def bar(dummy_obj):
+            pass
+
+        foo(123)
+        with self.assertRaises(TypeError) as raises:
+            bar(Dummy(123))
+        self.assertIn("can't unbox Dummy type", str(raises.exception))
+
+    def test_boxing(self):
+        """A test for the boxing logic on unknown type
+        """
+        Dummy = self.Dummy
+
+        @njit
+        def foo(x):
+            return Dummy(x)
+
+        with self.assertRaises(TypeError) as raises:
+            foo(123)
+        self.assertIn("cannot convert native Dummy to Python object",
+                      str(raises.exception))
+
+    def test_issue5565_literal_getitem(self):
+        # the following test is adapted from
+        # https://github.com/numba/numba/issues/5565
+        Dummy, DummyType = self.Dummy, self.DummyType
+
+        MAGIC_NUMBER = 12321
+
+        @overload(operator.getitem)
+        def dummy_getitem_ovld(self, idx):
+            if not isinstance(self, DummyType):
+                return None
+            # suppose we can only support idx as literal argument
+            if isinstance(idx, types.StringLiteral):
+                def dummy_getitem_impl(self, idx):
+                    return MAGIC_NUMBER
+                return dummy_getitem_impl
+
+            if isinstance(idx, types.UnicodeType):
+                def dummy_getitem_impl(self, idx):
+                    return literally(idx)
+                return dummy_getitem_impl
+
+            return None
+
+        @njit
+        def test_impl(x, y):
+            return Dummy(x)[y]
+
+        var = 'abc'
+        self.assertEqual(test_impl(1, var), MAGIC_NUMBER)

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

@@ -0,0 +1,12 @@
+from numba.tests.support import TestCase, unittest
+from numba.misc import findlib
+
+
+class TestFindlib(TestCase):
+    def test_find_file_nonexistent_path(self):
+        candidates = findlib.find_file('libirrelevant.so', 'NONEXISTENT')
+        self.assertEqual(candidates, [])
+
+
+if __name__ == '__main__':
+    unittest.main()

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

@@ -0,0 +1,114 @@
+import unittest
+import inspect
+
+from numba import njit
+from numba.tests.support import TestCase
+from numba.misc.firstlinefinder import get_func_body_first_lineno
+
+
+class TestFirstLineFinder(TestCase):
+    """
+    The following methods contains tests that are sensitive to the source
+    locations w.r.t. the beginning of each method.
+    """
+
+    def _get_grandparent_caller_code(self):
+        frame = inspect.currentframe()
+        caller_frame = inspect.getouterframes(frame)
+        return caller_frame[2].frame.f_code
+
+    def assert_line_location(self, expected, offset_from_caller):
+        grandparent_co = self._get_grandparent_caller_code()
+        lno = grandparent_co.co_firstlineno
+        self.assertEqual(expected, lno + offset_from_caller)
+
+    def test_decorated_odd_comment_indent(self):
+        @njit
+        def foo():
+# NOTE: THIS COMMENT MUST START AT COLUMN 0 FOR THIS SAMPLE CODE TO BE VALID # noqa: E115, E501
+            return 1
+
+        first_def_line = get_func_body_first_lineno(foo)
+        self.assert_line_location(first_def_line, 4)
+
+    def test_undecorated_odd_comment_indent(self):
+        def foo():
+# NOTE: THIS COMMENT MUST START AT COLUMN 0 FOR THIS SAMPLE CODE TO BE VALID # noqa: E115, E501
+            return 1
+
+        first_def_line = get_func_body_first_lineno(njit(foo))
+        self.assert_line_location(first_def_line, 3)
+
+    def test_unnamed_lambda(self):
+        foo = lambda: 1
+        first_def_line = get_func_body_first_lineno(njit(foo))
+        # Cannot determine first line of lambda function
+        self.assertIsNone(first_def_line)
+
+    def test_nested_function(self):
+        def foo():
+            @njit
+            def foo():
+                # This function is intentionally named the same as the parent
+                return 1
+
+            return foo
+
+        inner = foo()
+        first_def_line = get_func_body_first_lineno(inner)
+        self.assert_line_location(first_def_line, 5)
+
+    def test_pass_statement(self):
+        @njit
+        def foo():
+            pass
+
+        first_def_line = get_func_body_first_lineno(foo)
+        self.assert_line_location(first_def_line, 3)
+
+    def test_string_eval(self):
+        source = """def foo():
+            pass
+        """
+
+        globalns = {}
+        exec(source, globalns)
+        foo = globalns['foo']
+
+        first_def_line = get_func_body_first_lineno(foo)
+        # Cannot determine first line of string evaled functions
+        self.assertIsNone(first_def_line)
+
+    def test_single_line_function(self):
+        @njit
+        def foo(): pass   # noqa: E704
+
+        first_def_line = get_func_body_first_lineno(foo)
+        self.assert_line_location(first_def_line, 2)
+
+    def test_docstring(self):
+        @njit
+        def foo():
+            """Docstring
+            """
+            pass
+
+        first_def_line = get_func_body_first_lineno(foo)
+        self.assert_line_location(first_def_line, 5)
+
+    def test_docstring_2(self):
+        @njit
+        def foo():
+            """Docstring
+            """
+            """Not Docstring, but a bare string literal
+            """
+            pass
+        # Variation on test_docstring but with a "fake" docstring following
+        # the true docstring.
+        first_def_line = get_func_body_first_lineno(foo)
+        self.assert_line_location(first_def_line, 5)
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,1280 @@
+import itertools
+
+import unittest
+from numba import jit
+from numba.core.controlflow import CFGraph, ControlFlowAnalysis
+from numba.core import types
+from numba.core.bytecode import FunctionIdentity, ByteCode, _fix_LOAD_GLOBAL_arg
+from numba.tests.support import TestCase
+
+enable_pyobj_flags = {}
+
+no_pyobj_flags = {'_nrt': True, 'nopython': True}
+
+
+def for_loop_usecase1(x, y):
+    result = 0
+    for i in range(x):
+        result += i
+    return result
+
+
+def for_loop_usecase2(x, y):
+    result = 0
+    for i, j in enumerate(range(x, y, -1)):
+        result += i * j
+    return result
+
+
+def for_loop_usecase3(x, y):
+    result = 0
+    lst = [x, y]
+    for i in lst:
+        result += i
+    return result
+
+
+def for_loop_usecase4(x, y):
+    result = 0
+    for i in range(10):
+        for j in range(10):
+            result += 1
+    return result
+
+
+def for_loop_usecase5(x, y):
+    result = 0
+    for i in range(x):
+        result += 1
+        if result > y:
+            break
+    return result
+
+
+def for_loop_usecase6(x, y):
+    result = 0
+    for i in range(x):
+        if i > y:
+            continue
+        result += 1
+    return result
+
+
+def for_loop_usecase7(x, y):
+    for i in range(x):
+        x = 0
+        for j in range(x):
+            return 1
+        else:
+            pass
+    return 0
+
+
+def for_loop_usecase8(x, y):
+    result = 0
+    for i in range(x, y, y - x + 1):
+        result += 1
+    return result
+
+
+def for_loop_usecase9(x, y):
+    z = 0
+    for i in range(x):
+        x = 0
+        for j in range(x):
+            if j == x / 2:
+                z += j
+                break
+        else:
+            z += y
+
+    return z
+
+
+def for_loop_usecase10(x, y):
+    for i in range(x):
+        if i == y:
+            z = y
+            break
+    else:
+        z = i * 2
+    return z
+
+
+def while_loop_usecase1(x, y):
+    result = 0
+    i = 0
+    while i < x:
+        result += i
+        i += 1
+    return result
+
+
+def while_loop_usecase2(x, y):
+    result = 0
+    while result != x:
+        result += 1
+    return result
+
+
+def while_loop_usecase3(x, y):
+    result = 0
+    i = 0
+    j = 0
+    while i < x:
+        while j < y:
+            result += i + j
+            i += 1
+            j += 1
+    return result
+
+
+def while_loop_usecase4(x, y):
+    result = 0
+    while True:
+        result += 1
+        if result > x:
+            break
+    return result
+
+
+def while_loop_usecase5(x, y):
+    result = 0
+    while result < x:
+        if result > y:
+            result += 2
+            continue
+        result += 1
+    return result
+
+
+def ifelse_usecase1(x, y):
+    if x > 0:
+        pass
+    elif y > 0:
+        pass
+    else:
+        pass
+    return True
+
+
+def ifelse_usecase2(x, y):
+    if x > y:
+        return 1
+    elif x == 0 or y == 0:
+        return 2
+    else:
+        return 3
+
+
+def ifelse_usecase3(x, y):
+    if x > 0:
+        if y > 0:
+            return 1
+        elif y < 0:
+            return 1
+        else:
+            return 0
+    elif x < 0:
+        return 1
+    else:
+        return 0
+
+
+def ifelse_usecase4(x, y):
+    if x == y:
+        return 1
+
+
+def ternary_ifelse_usecase1(x, y):
+    return True if x > y else False
+
+
+def double_infinite_loop(x, y):
+    L = x
+    i = y
+
+    while True:
+        while True:
+            if i == L - 1:
+                break
+            i += 1
+        i += 1
+        if i >= L:
+            break
+
+    return i, L
+
+
+def try_except_usecase():
+    try:
+        pass
+    except Exception:
+        pass
+
+
+class TestFlowControl(TestCase):
+
+    def run_test(self, pyfunc, x_operands, y_operands,
+                 flags=enable_pyobj_flags):
+        cfunc = jit((types.intp, types.intp), **flags)(pyfunc)
+        for x, y in itertools.product(x_operands, y_operands):
+            pyerr = None
+            cerr = None
+            try:
+                pyres = pyfunc(x, y)
+            except Exception as e:
+                pyerr = e
+
+            try:
+                cres = cfunc(x, y)
+            except Exception as e:
+                if pyerr is None:
+                    raise
+                cerr = e
+                self.assertEqual(type(pyerr), type(cerr))
+            else:
+                if pyerr is not None:
+                    self.fail("Invalid for pure-python but numba works\n" +
+                              pyerr)
+                self.assertEqual(pyres, cres)
+
+    def test_for_loop1(self, flags=enable_pyobj_flags):
+        self.run_test(for_loop_usecase1, [-10, 0, 10], [0], flags=flags)
+
+    def test_for_loop1_npm(self):
+        self.test_for_loop1(flags=no_pyobj_flags)
+
+    def test_for_loop2(self, flags=enable_pyobj_flags):
+        self.run_test(for_loop_usecase2, [-10, 0, 10], [-10, 0, 10],
+                      flags=flags)
+
+    def test_for_loop2_npm(self):
+        self.test_for_loop2(flags=no_pyobj_flags)
+
+    def test_for_loop3(self, flags=enable_pyobj_flags):
+        """
+        List requires pyobject
+        """
+        self.run_test(for_loop_usecase3, [1], [2],
+                      flags=flags)
+
+    def test_for_loop3_npm(self):
+        self.test_for_loop3(flags=no_pyobj_flags)
+
+    def test_for_loop4(self, flags=enable_pyobj_flags):
+        self.run_test(for_loop_usecase4, [10], [10], flags=flags)
+
+    def test_for_loop4_npm(self):
+        self.test_for_loop4(flags=no_pyobj_flags)
+
+    def test_for_loop5(self, flags=enable_pyobj_flags):
+        self.run_test(for_loop_usecase5, [100], [50], flags=flags)
+
+    def test_for_loop5_npm(self):
+        self.test_for_loop5(flags=no_pyobj_flags)
+
+    def test_for_loop6(self, flags=enable_pyobj_flags):
+        self.run_test(for_loop_usecase6, [100], [50], flags=flags)
+
+    def test_for_loop6_npm(self):
+        self.test_for_loop6(flags=no_pyobj_flags)
+
+    def test_for_loop7(self, flags=enable_pyobj_flags):
+        self.run_test(for_loop_usecase7, [5], [0], flags=flags)
+
+    def test_for_loop7_npm(self):
+        self.test_for_loop7(flags=no_pyobj_flags)
+
+    def test_for_loop8(self, flags=enable_pyobj_flags):
+        self.run_test(for_loop_usecase8, [0, 1], [0, 2, 10], flags=flags)
+
+    def test_for_loop8_npm(self):
+        self.test_for_loop8(flags=no_pyobj_flags)
+
+    def test_for_loop9(self, flags=enable_pyobj_flags):
+        self.run_test(for_loop_usecase9, [0, 1], [0, 2, 10], flags=flags)
+
+    def test_for_loop9_npm(self):
+        self.test_for_loop9(flags=no_pyobj_flags)
+
+    def test_for_loop10(self, flags=enable_pyobj_flags):
+        self.run_test(for_loop_usecase10, [5], [2, 7], flags=flags)
+
+    def test_for_loop10_npm(self):
+        self.test_for_loop10(flags=no_pyobj_flags)
+
+    def test_while_loop1(self, flags=enable_pyobj_flags):
+        self.run_test(while_loop_usecase1, [10], [0], flags=flags)
+
+    def test_while_loop1_npm(self):
+        self.test_while_loop1(flags=no_pyobj_flags)
+
+    def test_while_loop2(self, flags=enable_pyobj_flags):
+        self.run_test(while_loop_usecase2, [10], [0], flags=flags)
+
+    def test_while_loop2_npm(self):
+        self.test_while_loop2(flags=no_pyobj_flags)
+
+    def test_while_loop3(self, flags=enable_pyobj_flags):
+        self.run_test(while_loop_usecase3, [10], [10], flags=flags)
+
+    def test_while_loop3_npm(self):
+        self.test_while_loop3(flags=no_pyobj_flags)
+
+    def test_while_loop4(self, flags=enable_pyobj_flags):
+        self.run_test(while_loop_usecase4, [10], [0], flags=flags)
+
+    def test_while_loop4_npm(self):
+        self.test_while_loop4(flags=no_pyobj_flags)
+
+    def test_while_loop5(self, flags=enable_pyobj_flags):
+        self.run_test(while_loop_usecase5, [0, 5, 10], [0, 5, 10], flags=flags)
+
+    def test_while_loop5_npm(self):
+        self.test_while_loop5(flags=no_pyobj_flags)
+
+    def test_ifelse1(self, flags=enable_pyobj_flags):
+        self.run_test(ifelse_usecase1, [-1, 0, 1], [-1, 0, 1], flags=flags)
+
+    def test_ifelse1_npm(self):
+        self.test_ifelse1(flags=no_pyobj_flags)
+
+    def test_ifelse2(self, flags=enable_pyobj_flags):
+        self.run_test(ifelse_usecase2, [-1, 0, 1], [-1, 0, 1], flags=flags)
+
+    def test_ifelse2_npm(self):
+        self.test_ifelse2(flags=no_pyobj_flags)
+
+    def test_ifelse3(self, flags=enable_pyobj_flags):
+        self.run_test(ifelse_usecase3, [-1, 0, 1], [-1, 0, 1], flags=flags)
+
+    def test_ifelse3_npm(self):
+        self.test_ifelse3(flags=no_pyobj_flags)
+
+    def test_ifelse4(self, flags=enable_pyobj_flags):
+        self.run_test(ifelse_usecase4, [-1, 0, 1], [-1, 0, 1], flags=flags)
+
+    def test_ifelse4_npm(self):
+        self.test_ifelse4(flags=no_pyobj_flags)
+
+    def test_ternary_ifelse1(self, flags=enable_pyobj_flags):
+        self.run_test(ternary_ifelse_usecase1, [-1, 0, 1], [-1, 0, 1],
+                      flags=flags)
+
+    def test_ternary_ifelse1_npm(self):
+        self.test_ternary_ifelse1(flags=no_pyobj_flags)
+
+    def test_double_infinite_loop(self, flags=enable_pyobj_flags):
+        self.run_test(double_infinite_loop, [10], [0],
+                      flags=flags)
+
+    def test_double_infinite_loop_npm(self):
+        self.test_double_infinite_loop(flags=no_pyobj_flags)
+
+
+class TestCFGraph(TestCase):
+    """
+    Test the numba.controlflow.CFGraph class.
+    """
+
+    def from_adj_list(self, d, entry_point=0):
+        """
+        Build a CFGraph class from a dict of adjacency lists.
+        """
+        g = CFGraph()
+        # Need to add all nodes before adding edges
+        for node in d:
+            g.add_node(node)
+        for node, dests in d.items():
+            for dest in dests:
+                g.add_edge(node, dest)
+        return g
+
+    def loopless1(self):
+        """
+        A simple CFG corresponding to the following code structure:
+
+            c = (... if ... else ...) + ...
+            return b + c
+        """
+        g = self.from_adj_list({0: [18, 12], 12: [21], 18: [21], 21: []})
+        g.set_entry_point(0)
+        g.process()
+        return g
+
+    def loopless1_dead_nodes(self):
+        """
+        Same as loopless1(), but with added dead blocks (some of them
+        in a loop).
+        """
+        g = self.from_adj_list(
+            {0: [18, 12],
+             12: [21],
+             18: [21],
+             21: [],
+             91: [12, 0],
+             92: [91, 93],
+             93: [92],
+             94: [],
+             })
+        g.set_entry_point(0)
+        g.process()
+        return g
+
+    def loopless2(self):
+        """
+        A loopless CFG corresponding to the following code structure:
+
+            c = (... if ... else ...) + ...
+            if c:
+                return ...
+            else:
+                return ...
+
+        Note there are two exit points, and the entry point has been
+        changed to a non-zero value.
+        """
+        g = self.from_adj_list(
+            {99: [18, 12], 12: [21], 18: [21], 21: [42, 34], 34: [], 42: []})
+        g.set_entry_point(99)
+        g.process()
+        return g
+
+    def multiple_loops(self):
+        """
+        A CFG with multiple nested loops:
+
+            for y in b:
+                for x in a:
+                    # This loop has two back edges
+                    if b:
+                        continue
+                    else:
+                        continue
+            for z in c:
+                if z:
+                    return ...
+        """
+        g = self.from_adj_list({0: [7],
+                                7: [10, 60],
+                                10: [13],
+                                13: [20],
+                                20: [56, 23],
+                                23: [32, 44],
+                                32: [20],
+                                44: [20],
+                                56: [57],
+                                57: [7],
+                                60: [61],
+                                61: [68],
+                                68: [87, 71],
+                                71: [80, 68],
+                                80: [],
+                                87: [88],
+                                88: []}
+                               )
+        g.set_entry_point(0)
+        g.process()
+        return g
+
+    def multiple_exits(self):
+        """
+        A CFG with three loop exits, one of which is also a function
+        exit point, and another function exit point:
+
+            for x in a:
+                if a:
+                    return b
+                elif b:
+                    break
+            return c
+        """
+        g = self.from_adj_list(
+            {0: [7],
+             7: [10, 36],
+             10: [19, 23],
+             19: [],
+             23: [29, 7],
+             29: [37],
+             36: [37],
+             37: []
+             })
+        g.set_entry_point(0)
+        g.process()
+        return g
+
+    def infinite_loop1(self):
+        """
+        A CFG with a infinite loop and an alternate exit point:
+
+            if c:
+                return
+            while True:
+                if a:
+                    ...
+                else:
+                    ...
+        """
+        g = self.from_adj_list(
+            {0: [10, 6], 6: [], 10: [13], 13: [26, 19], 19: [13], 26: [13]})
+        g.set_entry_point(0)
+        g.process()
+        return g
+
+    def infinite_loop2(self):
+        """
+        A CFG with no exit point at all:
+
+            while True:
+                if a:
+                    ...
+                else:
+                    ...
+        """
+        g = self.from_adj_list({0: [3], 3: [16, 9], 9: [3], 16: [3]})
+        g.set_entry_point(0)
+        g.process()
+        return g
+
+    def test_simple_properties(self):
+        g = self.loopless1()
+        self.assertEqual(sorted(g.successors(0)), [(12, None), (18, None)])
+        self.assertEqual(sorted(g.successors(21)), [])
+        self.assertEqual(sorted(g.predecessors(0)), [])
+        self.assertEqual(sorted(g.predecessors(21)), [(12, None), (18, None)])
+
+    def test_exit_points(self):
+        g = self.loopless1()
+        self.assertEqual(sorted(g.exit_points()), [21])
+        g = self.loopless1_dead_nodes()
+        self.assertEqual(sorted(g.exit_points()), [21])
+        g = self.loopless2()
+        self.assertEqual(sorted(g.exit_points()), [34, 42])
+        g = self.multiple_loops()
+        self.assertEqual(sorted(g.exit_points()), [80, 88])
+        g = self.infinite_loop1()
+        self.assertEqual(sorted(g.exit_points()), [6])
+        g = self.infinite_loop2()
+        self.assertEqual(sorted(g.exit_points()), [])
+        g = self.multiple_exits()
+        self.assertEqual(sorted(g.exit_points()), [19, 37])
+
+    def test_dead_nodes(self):
+        g = self.loopless1()
+        self.assertEqual(len(g.dead_nodes()), 0)
+        self.assertEqual(sorted(g.nodes()),
+                         [0, 12, 18, 21])
+        g = self.loopless2()
+        self.assertEqual(len(g.dead_nodes()), 0)
+        self.assertEqual(sorted(g.nodes()),
+                         [12, 18, 21, 34, 42, 99])
+        g = self.multiple_loops()
+        self.assertEqual(len(g.dead_nodes()), 0)
+        g = self.infinite_loop1()
+        self.assertEqual(len(g.dead_nodes()), 0)
+        g = self.multiple_exits()
+        self.assertEqual(len(g.dead_nodes()), 0)
+        # Only this example has dead nodes
+        g = self.loopless1_dead_nodes()
+        self.assertEqual(sorted(g.dead_nodes()),
+                         [91, 92, 93, 94])
+        self.assertEqual(sorted(g.nodes()),
+                         [0, 12, 18, 21])
+
+    def test_descendents(self):
+        g = self.loopless2()
+        d = g.descendents(34)
+        self.assertEqual(sorted(d), [])
+        d = g.descendents(42)
+        self.assertEqual(sorted(d), [])
+        d = g.descendents(21)
+        self.assertEqual(sorted(d), [34, 42])
+        d = g.descendents(99)
+        self.assertEqual(sorted(d), [12, 18, 21, 34, 42])
+        g = self.infinite_loop1()
+        d = g.descendents(26)
+        self.assertEqual(sorted(d), [])
+        d = g.descendents(19)
+        self.assertEqual(sorted(d), [])
+        d = g.descendents(13)
+        self.assertEqual(sorted(d), [19, 26])
+        d = g.descendents(10)
+        self.assertEqual(sorted(d), [13, 19, 26])
+        d = g.descendents(6)
+        self.assertEqual(sorted(d), [])
+        d = g.descendents(0)
+        self.assertEqual(sorted(d), [6, 10, 13, 19, 26])
+
+    def test_topo_order(self):
+        g = self.loopless1()
+        self.assertIn(g.topo_order(),
+                      ([0, 12, 18, 21], [0, 18, 12, 21]))
+        g = self.loopless2()
+        self.assertIn(g.topo_order(),
+                      ([99, 18, 12, 21, 34, 42], [99, 12, 18, 21, 34, 42]))
+        g = self.infinite_loop2()
+        self.assertIn(g.topo_order(),
+                      ([0, 3, 9, 16], [0, 3, 16, 9]))
+        g = self.infinite_loop1()
+        self.assertIn(g.topo_order(),
+                      ([0, 6, 10, 13, 19, 26], [0, 6, 10, 13, 26, 19],
+                       [0, 10, 13, 19, 26, 6], [0, 10, 13, 26, 19, 6]))
+
+    def test_topo_sort(self):
+        def check_topo_sort(nodes, expected):
+            self.assertIn(list(g.topo_sort(nodes)), expected)
+            self.assertIn(list(g.topo_sort(nodes[::-1])), expected)
+            self.assertIn(list(g.topo_sort(nodes, reverse=True))[::-1],
+                          expected)
+            self.assertIn(list(g.topo_sort(nodes[::-1], reverse=True))[::-1],
+                          expected)
+            self.random.shuffle(nodes)
+            self.assertIn(list(g.topo_sort(nodes)), expected)
+            self.assertIn(list(g.topo_sort(nodes, reverse=True))[::-1],
+                          expected)
+
+        g = self.loopless2()
+        check_topo_sort([21, 99, 12, 34], ([99, 12, 21, 34],))
+        # NOTE: topo_sort() is not stable
+        check_topo_sort([18, 12, 42, 99],
+                        ([99, 12, 18, 42], [99, 18, 12, 42]))
+        g = self.multiple_exits()
+        check_topo_sort([19, 10, 7, 36],
+                        ([7, 10, 19, 36], [7, 10, 36, 19], [7, 36, 10, 19]))
+
+    def check_dominators(self, got, expected):
+        self.assertEqual(sorted(got), sorted(expected))
+        for node in sorted(got):
+            self.assertEqual(sorted(got[node]), sorted(expected[node]),
+                             "mismatch for %r" % (node,))
+
+    def test_dominators_loopless(self):
+        def eq_(d, l):
+            self.assertEqual(sorted(doms[d]), l)
+        for g in [self.loopless1(), self.loopless1_dead_nodes()]:
+            doms = g.dominators()
+            eq_(0, [0])
+            eq_(12, [0, 12])
+            eq_(18, [0, 18])
+            eq_(21, [0, 21])
+        g = self.loopless2()
+        doms = g.dominators()
+        eq_(99, [99])
+        eq_(12, [12, 99])
+        eq_(18, [18, 99])
+        eq_(21, [21, 99])
+        eq_(34, [21, 34, 99])
+        eq_(42, [21, 42, 99])
+
+    def test_dominators_loops(self):
+        g = self.multiple_exits()
+        doms = g.dominators()
+        self.check_dominators(doms,
+                              {0: [0],
+                               7: [0, 7],
+                               10: [0, 7, 10],
+                               19: [0, 7, 10, 19],
+                               23: [0, 7, 10, 23],
+                               29: [0, 7, 10, 23, 29],
+                               36: [0, 7, 36],
+                               37: [0, 7, 37],
+                               })
+        g = self.multiple_loops()
+        doms = g.dominators()
+        self.check_dominators(doms,
+                              {0: [0],
+                               7: [0, 7],
+                               10: [0, 10, 7],
+                               13: [0, 10, 13, 7],
+                               20: [0, 10, 20, 13, 7],
+                               23: [0, 20, 23, 7, 10, 13],
+                               32: [32, 0, 20, 23, 7, 10, 13],
+                               44: [0, 20, 23, 7, 10, 44, 13],
+                               56: [0, 20, 7, 56, 10, 13],
+                               57: [0, 20, 7, 56, 57, 10, 13],
+                               60: [0, 60, 7],
+                               61: [0, 60, 61, 7],
+                               68: [0, 68, 60, 61, 7],
+                               71: [0, 68, 71, 7, 60, 61],
+                               80: [80, 0, 68, 71, 7, 60, 61],
+                               87: [0, 68, 87, 7, 60, 61],
+                               88: [0, 68, 87, 88, 7, 60, 61]
+                               })
+        g = self.infinite_loop1()
+        doms = g.dominators()
+        self.check_dominators(doms,
+                              {0: [0],
+                               6: [0, 6],
+                               10: [0, 10],
+                               13: [0, 10, 13],
+                               19: [0, 10, 19, 13],
+                               26: [0, 10, 13, 26],
+                               })
+
+    def test_post_dominators_loopless(self):
+        def eq_(d, l):
+            self.assertEqual(sorted(doms[d]), l)
+        for g in [self.loopless1(), self.loopless1_dead_nodes()]:
+            doms = g.post_dominators()
+            eq_(0, [0, 21])
+            eq_(12, [12, 21])
+            eq_(18, [18, 21])
+            eq_(21, [21])
+        g = self.loopless2()
+        doms = g.post_dominators()
+        eq_(34, [34])
+        eq_(42, [42])
+        eq_(21, [21])
+        eq_(18, [18, 21])
+        eq_(12, [12, 21])
+        eq_(99, [21, 99])
+
+    def test_post_dominators_loops(self):
+        g = self.multiple_exits()
+        doms = g.post_dominators()
+        self.check_dominators(doms,
+                              {0: [0, 7],
+                               7: [7],
+                               10: [10],
+                               19: [19],
+                               23: [23],
+                               29: [29, 37],
+                               36: [36, 37],
+                               37: [37],
+                               })
+        g = self.multiple_loops()
+        doms = g.post_dominators()
+        self.check_dominators(doms,
+                              {0: [0, 60, 68, 61, 7],
+                               7: [60, 68, 61, 7],
+                               10: [68, 7, 10, 13, 20, 56, 57, 60, 61],
+                               13: [68, 7, 13, 20, 56, 57, 60, 61],
+                               20: [20, 68, 7, 56, 57, 60, 61],
+                               23: [68, 7, 20, 23, 56, 57, 60, 61],
+                               32: [32, 68, 7, 20, 56, 57, 60, 61],
+                               44: [68, 7, 44, 20, 56, 57, 60, 61],
+                               56: [68, 7, 56, 57, 60, 61],
+                               57: [57, 60, 68, 61, 7],
+                               60: [60, 68, 61],
+                               61: [68, 61],
+                               68: [68],
+                               71: [71],
+                               80: [80],
+                               87: [88, 87],
+                               88: [88]
+                               })
+
+    def test_post_dominators_infinite_loops(self):
+        # Post-dominators with infinite loops need special care
+        # (the ordinary algorithm won't work).
+        g = self.infinite_loop1()
+        doms = g.post_dominators()
+        self.check_dominators(doms,
+                              {0: [0],
+                               6: [6],
+                               10: [10, 13],
+                               13: [13],
+                               19: [19],
+                               26: [26],
+                               })
+        g = self.infinite_loop2()
+        doms = g.post_dominators()
+        self.check_dominators(doms,
+                              {0: [0, 3],
+                               3: [3],
+                               9: [9],
+                               16: [16],
+                               })
+
+    def test_dominator_tree(self):
+        def check(graph, expected):
+            domtree = graph.dominator_tree()
+            self.assertEqual(domtree, expected)
+
+        check(self.loopless1(),
+              {0: {12, 18, 21}, 12: set(), 18: set(), 21: set()})
+        check(self.loopless2(),
+              {12: set(), 18: set(), 21: {34, 42}, 34: set(), 42: set(),
+               99: {18, 12, 21}})
+        check(self.loopless1_dead_nodes(),
+              {0: {12, 18, 21}, 12: set(), 18: set(), 21: set()})
+        check(self.multiple_loops(),
+              {0: {7}, 7: {10, 60}, 60: {61}, 61: {68}, 68: {71, 87},
+               87: {88}, 88: set(), 71: {80}, 80: set(), 10: {13},
+               13: {20}, 20: {56, 23}, 23: {32, 44}, 44: set(),
+               32: set(), 56: {57}, 57: set()})
+        check(self.multiple_exits(),
+              {0: {7}, 7: {10, 36, 37}, 36: set(), 10: {19, 23},
+               23: {29}, 29: set(), 37: set(), 19: set()})
+        check(self.infinite_loop1(),
+              {0: {10, 6}, 6: set(), 10: {13}, 13: {26, 19}, 19: set(),
+               26: set()})
+        check(self.infinite_loop2(),
+              {0: {3}, 3: {16, 9}, 9: set(), 16: set()})
+
+    def test_immediate_dominators(self):
+        def check(graph, expected):
+            idoms = graph.immediate_dominators()
+            self.assertEqual(idoms, expected)
+
+        check(self.loopless1(),
+              {0: 0, 12: 0, 18: 0, 21: 0})
+        check(self.loopless2(),
+              {18: 99, 12: 99, 21: 99, 42: 21, 34: 21, 99: 99})
+        check(self.loopless1_dead_nodes(),
+              {0: 0, 12: 0, 18: 0, 21: 0})
+        check(self.multiple_loops(),
+              {0: 0, 7: 0, 10: 7, 13: 10, 20: 13, 23: 20,
+               32: 23, 44: 23, 56: 20, 57: 56, 60: 7, 61: 60,
+               68: 61, 71: 68, 80: 71, 87: 68, 88: 87})
+        check(self.multiple_exits(),
+              {0:0, 7: 0, 10: 7, 19: 10, 23: 10, 29: 23, 36: 7, 37: 7})
+        check(self.infinite_loop1(),
+              {0: 0, 6: 0, 10: 0, 13: 10, 19: 13, 26: 13})
+        check(self.infinite_loop2(),
+              {0: 0, 3: 0, 9: 3, 16: 3})
+
+    def test_dominance_frontier(self):
+        def check(graph, expected):
+            df = graph.dominance_frontier()
+            self.assertEqual(df, expected)
+
+        check(self.loopless1(),
+              {0: set(), 12: {21}, 18: {21}, 21: set()})
+        check(self.loopless2(),
+              {18: {21}, 12: {21}, 21: set(), 42: set(), 34: set(), 99: set()})
+        check(self.loopless1_dead_nodes(),
+              {0: set(), 12: {21}, 18: {21}, 21: set()})
+        check(self.multiple_loops(),
+              {0: set(), 7: {7}, 10: {7}, 13: {7}, 20: {20, 7}, 23: {20},
+               32: {20}, 44: {20}, 56: {7}, 57: {7}, 60: set(), 61: set(),
+               68: {68}, 71: {68}, 80: set(), 87: set(), 88: set()})
+        check(self.multiple_exits(),
+              {0: set(), 7: {7}, 10: {37, 7}, 19: set(),
+               23: {37, 7}, 29: {37}, 36: {37}, 37: set()})
+        check(self.infinite_loop1(),
+              {0: set(), 6: set(), 10: set(), 13: {13}, 19: {13}, 26: {13}})
+        check(self.infinite_loop2(),
+              {0: set(), 3: {3}, 9: {3}, 16: {3}})
+
+    def test_backbone_loopless(self):
+        for g in [self.loopless1(), self.loopless1_dead_nodes()]:
+            self.assertEqual(sorted(g.backbone()), [0, 21])
+        g = self.loopless2()
+        self.assertEqual(sorted(g.backbone()), [21, 99])
+
+    def test_backbone_loops(self):
+        g = self.multiple_loops()
+        self.assertEqual(sorted(g.backbone()), [0, 7, 60, 61, 68])
+        g = self.infinite_loop1()
+        self.assertEqual(sorted(g.backbone()), [0])
+        g = self.infinite_loop2()
+        self.assertEqual(sorted(g.backbone()), [0, 3])
+
+    def test_loops(self):
+        for g in [self.loopless1(), self.loopless1_dead_nodes(),
+                  self.loopless2()]:
+            self.assertEqual(len(g.loops()), 0)
+
+        g = self.multiple_loops()
+        # Loop headers
+        self.assertEqual(sorted(g.loops()), [7, 20, 68])
+        outer1 = g.loops()[7]
+        inner1 = g.loops()[20]
+        outer2 = g.loops()[68]
+        self.assertEqual(outer1.header, 7)
+        self.assertEqual(sorted(outer1.entries), [0])
+        self.assertEqual(sorted(outer1.exits), [60])
+        self.assertEqual(sorted(outer1.body),
+                         [7, 10, 13, 20, 23, 32, 44, 56, 57])
+        self.assertEqual(inner1.header, 20)
+        self.assertEqual(sorted(inner1.entries), [13])
+        self.assertEqual(sorted(inner1.exits), [56])
+        self.assertEqual(sorted(inner1.body), [20, 23, 32, 44])
+        self.assertEqual(outer2.header, 68)
+        self.assertEqual(sorted(outer2.entries), [61])
+        self.assertEqual(sorted(outer2.exits), [80, 87])
+        self.assertEqual(sorted(outer2.body), [68, 71])
+        for node in [0, 60, 61, 80, 87, 88]:
+            self.assertEqual(g.in_loops(node), [])
+        for node in [7, 10, 13, 56, 57]:
+            self.assertEqual(g.in_loops(node), [outer1])
+        for node in [20, 23, 32, 44]:
+            self.assertEqual(g.in_loops(node), [inner1, outer1])
+        for node in [68, 71]:
+            self.assertEqual(g.in_loops(node), [outer2])
+
+        g = self.infinite_loop1()
+        # Loop headers
+        self.assertEqual(sorted(g.loops()), [13])
+        loop = g.loops()[13]
+        self.assertEqual(loop.header, 13)
+        self.assertEqual(sorted(loop.entries), [10])
+        self.assertEqual(sorted(loop.exits), [])
+        self.assertEqual(sorted(loop.body), [13, 19, 26])
+        for node in [0, 6, 10]:
+            self.assertEqual(g.in_loops(node), [])
+        for node in [13, 19, 26]:
+            self.assertEqual(g.in_loops(node), [loop])
+
+        g = self.infinite_loop2()
+        # Loop headers
+        self.assertEqual(sorted(g.loops()), [3])
+        loop = g.loops()[3]
+        self.assertEqual(loop.header, 3)
+        self.assertEqual(sorted(loop.entries), [0])
+        self.assertEqual(sorted(loop.exits), [])
+        self.assertEqual(sorted(loop.body), [3, 9, 16])
+        for node in [0]:
+            self.assertEqual(g.in_loops(node), [])
+        for node in [3, 9, 16]:
+            self.assertEqual(g.in_loops(node), [loop])
+
+        g = self.multiple_exits()
+        # Loop headers
+        self.assertEqual(sorted(g.loops()), [7])
+        loop = g.loops()[7]
+        self.assertEqual(loop.header, 7)
+        self.assertEqual(sorted(loop.entries), [0])
+        self.assertEqual(sorted(loop.exits), [19, 29, 36])
+        self.assertEqual(sorted(loop.body), [7, 10, 23])
+        for node in [0, 19, 29, 36]:
+            self.assertEqual(g.in_loops(node), [])
+        for node in [7, 10, 23]:
+            self.assertEqual(g.in_loops(node), [loop])
+
+    def test_loop_dfs_pathological(self):
+        # The follow adjlist is an export from the reproducer in #6186
+        g = self.from_adj_list({
+            0: {38, 14},
+            14: {38, 22},
+            22: {38, 30},
+            30: {42, 38},
+            38: {42},
+            42: {64, 50},
+            50: {64, 58},
+            58: {128},
+            64: {72, 86},
+            72: {80, 86},
+            80: {128},
+            86: {108, 94},
+            94: {108, 102},
+            102: {128},
+            108: {128, 116},
+            116: {128, 124},
+            124: {128},
+            128: {178, 174},
+            174: {178},
+            178: {210, 206},
+            206: {210},
+            210: {248, 252},
+            248: {252},
+            252: {282, 286},
+            282: {286},
+            286: {296, 326},
+            296: {330},
+            326: {330},
+            330: {370, 340},
+            340: {374},
+            370: {374},
+            374: {380, 382},
+            380: {382},
+            382: {818, 390},
+            390: {456, 458},
+            456: {458},
+            458: {538, 566},
+            538: {548, 566},
+            548: set(),
+            566: {586, 572},
+            572: {586},
+            586: {708, 596},
+            596: {608},
+            608: {610},
+            610: {704, 620},
+            620: {666, 630},
+            630: {636, 646},
+            636: {666, 646},
+            646: {666},
+            666: {610},
+            704: {706},
+            706: {818},
+            708: {720},
+            720: {722},
+            722: {816, 732},
+            732: {778, 742},
+            742: {748, 758},
+            748: {778, 758},
+            758: {778},
+            778: {722},
+            816: {818},
+            818: set(),
+        })
+        g.set_entry_point(0)
+        g.process()
+        stats = {}
+        # Compute backedges and store the iteration count for testing
+        back_edges = g._find_back_edges(stats=stats)
+        self.assertEqual(back_edges, {(666, 610), (778, 722)})
+        self.assertEqual(stats['iteration_count'], 155)
+
+    def test_equals(self):
+
+        def get_new():
+            g = self.from_adj_list({0: [18, 12], 12: [21], 18: [21], 21: []})
+            g.set_entry_point(0)
+            g.process()
+            return g
+
+        x = get_new()
+        y = get_new()
+
+        # identical
+        self.assertEqual(x, y)
+
+        # identical but defined in a different order
+        g = self.from_adj_list({0: [12, 18], 18: [21], 21: [], 12: [21]})
+        g.set_entry_point(0)
+        g.process()
+        self.assertEqual(x, g)
+
+        # different entry point
+        z = get_new()
+        z.set_entry_point(18)
+        z.process()
+        self.assertNotEqual(x, z)
+
+        # extra node/edge, same entry point
+        z = self.from_adj_list({0: [18, 12], 12: [21], 18: [21], 21: [22],
+                                22: []})
+        z.set_entry_point(0)
+        z.process()
+        self.assertNotEqual(x, z)
+
+        # same nodes, different edges
+        a = self.from_adj_list({0: [18, 12], 12: [0], 18: []})
+        a.set_entry_point(0)
+        a.process()
+        z = self.from_adj_list({0: [18, 12], 12: [18], 18: []})
+        z.set_entry_point(0)
+        z.process()
+        self.assertNotEqual(a, z)
+
+
+class TestRealCodeDomFront(TestCase):
+    """Test IDOM and DOMFRONT computation on real python bytecode.
+    Note: there will be less testing on IDOM (esp in loop) because of
+    the extra blocks inserted by the interpreter.  But, testing on DOMFRONT
+    (which depends on IDOM) is easier.
+
+    Testing is done by associating names to basicblock by using globals of
+    the pattern "SET_BLOCK_<name>", which are scanned by
+    `.get_cfa_and_namedblocks` into *namedblocks* dictionary.  That way, we
+    can check that a block of a certain name is a IDOM or DOMFRONT of another
+    named block.
+    """
+    def cfa(self, bc):
+        cfa = ControlFlowAnalysis(bc)
+        cfa.run()
+        return cfa
+
+    def get_cfa_and_namedblocks(self, fn):
+        fid = FunctionIdentity.from_function(fn)
+        bc = ByteCode(func_id=fid)
+        cfa = self.cfa(bc)
+        namedblocks = self._scan_namedblocks(bc, cfa)
+
+        #### To debug, uncomment below
+        # print(bc.dump())
+        # print("IDOMS")
+        # for k, v in sorted(cfa.graph.immediate_dominators().items()):
+        #     print('{} -> {}'.format(k, v))
+        # print("DOMFRONT")
+        # for k, vs in sorted(cfa.graph.dominance_frontier().items()):
+        #     print('{} -> {}'.format(k, vs))
+        # print(namedblocks)
+        # cfa.graph.render_dot().view()
+
+        return cfa, namedblocks
+
+    def _scan_namedblocks(self, bc, cfa):
+        """Scan namedblocks as denoted by a LOAD_GLOBAL bytecode referring
+        to global variables with the pattern "SET_BLOCK_<name>", where "<name>"
+        would be the name for the current block.
+        """
+        namedblocks = {}
+        blocks = sorted([x.offset for x in cfa.iterblocks()])
+        prefix = 'SET_BLOCK_'
+
+        for inst in bc:
+            # Find LOAD_GLOBAL that refers to "SET_BLOCK_<name>"
+            if inst.opname == 'LOAD_GLOBAL':
+                gv = bc.co_names[_fix_LOAD_GLOBAL_arg(inst.arg)]
+                if gv.startswith(prefix):
+                    name = gv[len(prefix):]
+                    # Find the block where this instruction resides
+                    for s, e in zip(blocks, blocks[1:] + [blocks[-1] + 1]):
+                        if s <= inst.offset < e:
+                            break
+                    else:
+                        raise AssertionError('unreachable loop')
+                    blkno = s
+                    namedblocks[name] = blkno
+        return namedblocks
+
+    def test_loop(self):
+        def foo(n):
+            c = 0
+            SET_BLOCK_A                     # noqa: F821
+            i = 0
+            while SET_BLOCK_B0:             # noqa: F821
+                SET_BLOCK_B1                # noqa: F821
+                c += 1
+                i += 1
+            SET_BLOCK_C                     # noqa: F821
+            return c
+
+        cfa, blkpts = self.get_cfa_and_namedblocks(foo)
+
+        # Py3.10 turns while loop into if(...) { do {...} while(...) }.
+        # Also, `SET_BLOCK_B0` is duplicated. As a result, the second B0
+        # is picked up by `blkpts`.
+        domfront = cfa.graph.dominance_frontier()
+        self.assertFalse(domfront[blkpts['A']])
+        self.assertFalse(domfront[blkpts['C']])
+
+    def test_loop_nested_and_break(self):
+        def foo(n):
+            SET_BLOCK_A                     # noqa: F821
+            while SET_BLOCK_B0:             # noqa: F821
+                SET_BLOCK_B1                # noqa: F821
+                while SET_BLOCK_C0:         # noqa: F821
+                    SET_BLOCK_C1            # noqa: F821
+                    if SET_BLOCK_D0:        # noqa: F821
+                        SET_BLOCK_D1        # noqa: F821
+                        break
+                    elif n:
+                        SET_BLOCK_D2        # noqa: F821
+                    SET_BLOCK_E             # noqa: F821
+                SET_BLOCK_F                 # noqa: F821
+            SET_BLOCK_G                     # noqa: F821
+
+        cfa, blkpts = self.get_cfa_and_namedblocks(foo)
+        self.assertEqual(blkpts['D0'], blkpts['C1'])
+
+        # Py3.10 changes while loop into if-do-while
+        domfront = cfa.graph.dominance_frontier()
+        self.assertFalse(domfront[blkpts['A']])
+        self.assertFalse(domfront[blkpts['G']])
+        # 2 domfront members for C1
+        # C0 because of the loop; F because of the break.
+        self.assertEqual({blkpts['F']}, domfront[blkpts['D1']])
+        self.assertEqual({blkpts['E']}, domfront[blkpts['D2']])
+
+    def test_if_else(self):
+        def foo(a, b):
+            c = 0
+            SET_BLOCK_A           # noqa: F821
+            if a < b:
+                SET_BLOCK_B       # noqa: F821
+                c = 1
+            elif SET_BLOCK_C0:    # noqa: F821
+                SET_BLOCK_C1      # noqa: F821
+                c = 2
+            else:
+                SET_BLOCK_D       # noqa: F821
+                c = 3
+
+            SET_BLOCK_E           # noqa: F821
+            if a % b == 0:
+                SET_BLOCK_F       # noqa: F821
+                c += 1
+            SET_BLOCK_G           # noqa: F821
+            return c
+
+        cfa, blkpts = self.get_cfa_and_namedblocks(foo)
+
+        idoms = cfa.graph.immediate_dominators()
+        self.assertEqual(blkpts['A'], idoms[blkpts['B']])
+        self.assertEqual(blkpts['A'], idoms[blkpts['C0']])
+        self.assertEqual(blkpts['C0'], idoms[blkpts['C1']])
+        self.assertEqual(blkpts['C0'], idoms[blkpts['D']])
+        self.assertEqual(blkpts['A'], idoms[blkpts['E']])
+        self.assertEqual(blkpts['E'], idoms[blkpts['F']])
+        self.assertEqual(blkpts['E'], idoms[blkpts['G']])
+
+        domfront = cfa.graph.dominance_frontier()
+        self.assertFalse(domfront[blkpts['A']])
+        self.assertFalse(domfront[blkpts['E']])
+        self.assertFalse(domfront[blkpts['G']])
+        self.assertEqual({blkpts['E']}, domfront[blkpts['B']])
+        self.assertEqual({blkpts['E']}, domfront[blkpts['C0']])
+        self.assertEqual({blkpts['E']}, domfront[blkpts['C1']])
+        self.assertEqual({blkpts['E']}, domfront[blkpts['D']])
+        self.assertEqual({blkpts['G']}, domfront[blkpts['F']])
+
+    def test_if_else_nested(self):
+        def foo():
+            if SET_BLOCK_A0:                # noqa: F821
+                SET_BLOCK_A1                # noqa: F821
+                if SET_BLOCK_B0:            # noqa: F821
+                    SET_BLOCK_B1            # noqa: F821
+                    a = 0
+                else:
+                    if SET_BLOCK_C0:        # noqa: F821
+                        SET_BLOCK_C1        # noqa: F821
+                        a = 1
+                    else:
+                        SET_BLOCK_C2        # noqa: F821
+                        a = 2
+                    SET_BLOCK_D             # noqa: F821
+                SET_BLOCK_E                 # noqa: F821
+            SET_BLOCK_F                     # noqa: F821
+            return a
+
+        cfa, blkpts = self.get_cfa_and_namedblocks(foo)
+
+        idoms = cfa.graph.immediate_dominators()
+        self.assertEqual(blkpts['A0'], idoms[blkpts['A1']])
+        self.assertEqual(blkpts['A1'], idoms[blkpts['B1']])
+        self.assertEqual(blkpts['A1'], idoms[blkpts['C0']])
+        self.assertEqual(blkpts['C0'], idoms[blkpts['D']])
+        self.assertEqual(blkpts['A1'], idoms[blkpts['E']])
+        self.assertEqual(blkpts['A0'], idoms[blkpts['F']])
+
+        domfront = cfa.graph.dominance_frontier()
+        self.assertFalse(domfront[blkpts['A0']])
+        self.assertFalse(domfront[blkpts['F']])
+        self.assertEqual({blkpts['E']}, domfront[blkpts['B1']])
+        self.assertEqual({blkpts['D']}, domfront[blkpts['C1']])
+        self.assertEqual({blkpts['E']}, domfront[blkpts['D']])
+        self.assertEqual({blkpts['F']}, domfront[blkpts['E']])
+
+    def test_infinite_loop(self):
+        def foo():
+            SET_BLOCK_A                     # noqa: F821
+            while True:  # infinite loop
+                if SET_BLOCK_B:             # noqa: F821
+                    SET_BLOCK_C             # noqa: F821
+                    return
+                SET_BLOCK_D                 # noqa: F821
+            SET_BLOCK_E                     # noqa: F821
+
+        cfa, blkpts = self.get_cfa_and_namedblocks(foo)
+
+        idoms = cfa.graph.immediate_dominators()
+        # Py3.10 optimizes away the infinite loop and removes SET_BLOCK_E from
+        # the bytecode.
+        self.assertNotIn('E', blkpts)
+        self.assertEqual(blkpts['B'], idoms[blkpts['C']])
+        self.assertEqual(blkpts['B'], idoms[blkpts['D']])
+
+        domfront = cfa.graph.dominance_frontier()
+        self.assertFalse(domfront[blkpts['A']])
+        self.assertFalse(domfront[blkpts['C']])
+        self.assertEqual({blkpts['B']}, domfront[blkpts['B']])
+        self.assertEqual({blkpts['B']}, domfront[blkpts['D']])
+
+
+if __name__ == '__main__':
+    unittest.main()

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

@@ -0,0 +1,43 @@
+import unittest
+from numba import jit
+
+
+class TestFuncInterface(unittest.TestCase):
+    def test_jit_function_docstring(self):
+
+        def add(x, y):
+            '''Return sum of two numbers'''
+            return x + y
+
+        c_add = jit(add)
+        self.assertEqual(c_add.__doc__, 'Return sum of two numbers')
+
+    def test_jit_function_name(self):
+
+        def add(x, y):
+            return x + y
+
+        c_add = jit(add)
+        self.assertEqual(c_add.__name__, 'add')
+
+    def test_jit_function_module(self):
+
+        def add(x, y):
+            return x + y
+
+        c_add = jit(add)
+        # Expected answer depends on how you run this test.
+        # Compare to python function instead.
+        self.assertEqual(c_add.__module__, add.__module__)
+
+    def test_jit_function_code_object(self):
+        def add(x, y):
+            return x + y
+
+        c_add = jit(add)
+        self.assertEqual(c_add.__code__, add.__code__)
+        self.assertEqual(c_add.func_code, add.__code__)
+
+
+if __name__ == '__main__':
+    unittest.main()

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

@@ -0,0 +1,164 @@
+import gc
+import weakref
+
+from numba import jit
+from numba.core import types
+from numba.tests.support import TestCase
+import unittest
+
+
+class Dummy(object):
+
+    def __add__(self, other):
+        return other + 5
+
+
+def global_usecase1(x):
+    return x + 1
+
+def global_usecase2():
+    return global_obj + 1
+
+
+class TestFuncLifetime(TestCase):
+    """
+    Test the lifetime of compiled function objects and their dependencies.
+    """
+
+    def get_impl(self, dispatcher):
+        """
+        Get the single implementation (a C function object) of a dispatcher.
+        """
+        self.assertEqual(len(dispatcher.overloads), 1)
+        cres = list(dispatcher.overloads.values())[0]
+        return cres.entry_point
+
+    def check_local_func_lifetime(self, **jitargs):
+        def f(x):
+            return x + 1
+
+        c_f = jit('int32(int32)', **jitargs)(f)
+        self.assertPreciseEqual(c_f(1), 2)
+
+        cfunc = self.get_impl(c_f)
+
+        # Since we can't take a weakref to a C function object
+        # (see http://bugs.python.org/issue22116), ensure it's
+        # collected by taking a weakref to its __self__ instead
+        # (a _dynfunc._Closure object).
+        refs = [weakref.ref(obj) for obj in (f, c_f, cfunc.__self__)]
+        obj = f = c_f = cfunc = None
+        gc.collect()
+        self.assertEqual([wr() for wr in refs], [None] * len(refs))
+
+    def test_local_func_lifetime(self):
+        self.check_local_func_lifetime(forceobj=True)
+
+    def test_local_func_lifetime_npm(self):
+        self.check_local_func_lifetime(nopython=True)
+
+    def check_global_func_lifetime(self, **jitargs):
+        c_f = jit(**jitargs)(global_usecase1)
+        self.assertPreciseEqual(c_f(1), 2)
+
+        cfunc = self.get_impl(c_f)
+
+        wr = weakref.ref(c_f)
+        refs = [weakref.ref(obj) for obj in (c_f, cfunc.__self__)]
+        obj = c_f = cfunc = None
+        gc.collect()
+        self.assertEqual([wr() for wr in refs], [None] * len(refs))
+
+    def test_global_func_lifetime(self):
+        self.check_global_func_lifetime(forceobj=True)
+
+    def test_global_func_lifetime_npm(self):
+        self.check_global_func_lifetime(nopython=True)
+
+    def check_global_obj_lifetime(self, **jitargs):
+        # Since global objects can be recorded for typing purposes,
+        # check that they are not kept around after they are removed
+        # from the globals.
+        global global_obj
+        global_obj = Dummy()
+
+        c_f = jit(**jitargs)(global_usecase2)
+        self.assertPreciseEqual(c_f(), 6)
+
+        refs = [weakref.ref(obj) for obj in (c_f, global_obj)]
+        obj = c_f = global_obj = None
+        gc.collect()
+        self.assertEqual([wr() for wr in refs], [None] * len(refs))
+
+    def test_global_obj_lifetime(self):
+        self.check_global_obj_lifetime(forceobj=True)
+
+    def check_inner_function_lifetime(self, **jitargs):
+        """
+        When a jitted function calls into another jitted function, check
+        that everything is collected as desired.
+        """
+        def mult_10(a):
+            return a * 10
+
+        c_mult_10 = jit('intp(intp)', **jitargs)(mult_10)
+        c_mult_10.disable_compile()
+
+        def do_math(x):
+            return c_mult_10(x + 4)
+
+        c_do_math = jit('intp(intp)', **jitargs)(do_math)
+        c_do_math.disable_compile()
+
+        self.assertEqual(c_do_math(1), 50)
+
+        wrs = [weakref.ref(obj) for obj in
+               (mult_10, c_mult_10, do_math, c_do_math,
+                self.get_impl(c_mult_10).__self__,
+                self.get_impl(c_do_math).__self__,
+                )]
+        obj = mult_10 = c_mult_10 = do_math = c_do_math = None
+        gc.collect()
+        self.assertEqual([w() for w in wrs], [None] * len(wrs))
+
+    def test_inner_function_lifetime(self):
+        self.check_inner_function_lifetime(forceobj=True)
+
+    def test_inner_function_lifetime_npm(self):
+        self.check_inner_function_lifetime(nopython=True)
+
+
+class TestLifeTimeIssue(TestCase):
+    def test_double_free(self):
+        from numba import njit
+        import numpy as np
+
+        # This is the function that causes the crash
+
+        @njit
+        def is_point_in_polygons(point, polygons):
+            num_polygons = polygons.shape[0]
+            if num_polygons != 0:
+                # An extra decref is inserted in this block
+                intentionally_unused_variable = polygons[0]
+            return 0
+
+        # This function creates some NRT objects for the previous function
+        # to corrupt.
+
+        @njit
+        def dummy():
+            return np.empty(10, dtype=np.int64)
+
+        polygons = np.array([[[0, 1]]])
+        points = np.array([[-1.5, 0.5]])
+        a = dummy()
+        is_point_in_polygons(points[0], polygons)
+        b = dummy()
+        # Crash happens at second call
+        is_point_in_polygons(points[0], polygons)
+        c = dummy()
+
+
+if __name__ == '__main__':
+    unittest.main()

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

@@ -0,0 +1,661 @@
+import numpy as np
+
+import unittest
+from numba import jit, njit
+from numba.core import types
+from numba.tests.support import TestCase, MemoryLeakMixin
+from numba.core.datamodel.testing import test_factory
+
+forceobj_flags = {'nopython': False, 'forceobj': True}
+nopython_flags = {'nopython': True}
+
+
+def make_consumer(gen_func):
+    def consumer(x):
+        res = 0.0
+        for y in gen_func(x):
+            res += y
+        return res
+
+    return consumer
+
+
+def gen1(x):
+    for i in range(x):
+        yield i
+
+
+def gen2(x):
+    for i in range(x):
+        yield i
+        for j in range(1, 3):
+            yield i + j
+
+
+def gen3(x):
+    # Polymorphic yield types must be unified
+    yield x
+    yield x + 1.5
+    yield x + 1j
+
+
+def gen4(x, y, z):
+    for i in range(3):
+        yield z
+        yield y + z
+    return
+    yield x
+
+
+def gen5():
+    # The bytecode for this generator doesn't contain any YIELD_VALUE
+    # (it's optimized away).  We fail typing it, since the yield type
+    # is entirely undefined.
+    if 0:
+        yield 1
+
+
+def gen6(a, b):
+    # Infinite loop: exercise computation of state variables
+    x = a + 1
+    while True:
+        y = b + 2
+        yield x + y
+
+
+def gen7(arr):
+    # Array variable in generator state
+    for i in range(arr.size):
+        yield arr[i]
+
+
+# Optional arguments and boolean state members
+def gen8(x=1, y=2, b=False):
+    bb = not b
+    yield x
+    if bb:
+        yield y
+    if b:
+        yield x + y
+
+
+def genobj(x):
+    object()
+    yield x
+
+
+def return_generator_expr(x):
+    return (i * 2 for i in x)
+
+
+def gen_ndindex(shape):
+    for ind in np.ndindex(shape):
+        yield ind
+
+
+def gen_flat(arr):
+    for val in arr.flat:
+        yield val
+
+
+def gen_ndenumerate(arr):
+    for tup in np.ndenumerate(arr):
+        yield tup
+
+
+def gen_bool():
+    yield True
+
+
+def gen_unification_error():
+    yield None
+    yield 1j
+
+
+def gen_optional_and_type_unification_error():
+    # yields complex and optional(literalint)
+    i = 0
+    yield 1j
+    while True:
+        i = yield i
+
+
+def gen_changing_tuple_type():
+    # https://github.com/numba/numba/issues/7295
+    yield 1, 2
+    yield 3, 4
+
+
+def gen_changing_number_type():
+    # additional test for https://github.com/numba/numba/issues/7295
+    yield 1
+    yield 3.5
+    yield 67.8j
+
+
+class TestGenerators(MemoryLeakMixin, TestCase):
+    def check_generator(self, pygen, cgen):
+        self.assertEqual(next(cgen), next(pygen))
+        # Use list comprehensions to make sure we trash the generator's
+        # former C stack.
+        expected = [x for x in pygen]
+        got = [x for x in cgen]
+        self.assertEqual(expected, got)
+        with self.assertRaises(StopIteration):
+            next(cgen)
+
+    def check_gen1(self, **kwargs):
+        pyfunc = gen1
+        cr = jit((types.int32,), **kwargs)(pyfunc)
+        pygen = pyfunc(8)
+        cgen = cr(8)
+        self.check_generator(pygen, cgen)
+
+    def test_gen1(self):
+        self.check_gen1(**nopython_flags)
+
+    def test_gen1_objmode(self):
+        self.check_gen1(**forceobj_flags)
+
+    def check_gen2(self, **kwargs):
+        pyfunc = gen2
+        cr = jit((types.int32,), **kwargs)(pyfunc)
+        pygen = pyfunc(8)
+        cgen = cr(8)
+        self.check_generator(pygen, cgen)
+
+    def test_gen2(self):
+        self.check_gen2(**nopython_flags)
+
+    def test_gen2_objmode(self):
+        self.check_gen2(**forceobj_flags)
+
+    def check_gen3(self, **kwargs):
+        pyfunc = gen3
+        cr = jit((types.int32,), **kwargs)(pyfunc)
+        pygen = pyfunc(8)
+        cgen = cr(8)
+        self.check_generator(pygen, cgen)
+
+    def test_gen3(self):
+        self.check_gen3(**nopython_flags)
+
+    def test_gen3_objmode(self):
+        self.check_gen3(**forceobj_flags)
+
+    def check_gen4(self, **kwargs):
+        pyfunc = gen4
+        cr = jit((types.int32,) * 3, **kwargs)(pyfunc)
+        pygen = pyfunc(5, 6, 7)
+        cgen = cr(5, 6, 7)
+        self.check_generator(pygen, cgen)
+
+    def test_gen4(self):
+        self.check_gen4(**nopython_flags)
+
+    def test_gen4_objmode(self):
+        self.check_gen4(**forceobj_flags)
+
+    def test_gen5(self):
+        with self.assertTypingError() as raises:
+            jit((), **nopython_flags)(gen5)
+        self.assertIn("Cannot type generator: it does not yield any value",
+                      str(raises.exception))
+
+    def test_gen5_objmode(self):
+        cgen = jit((), **forceobj_flags)(gen5)()
+        self.assertEqual(list(cgen), [])
+        with self.assertRaises(StopIteration):
+            next(cgen)
+
+    def check_gen6(self, **kwargs):
+        cr = jit((types.int32,) * 2, **kwargs)(gen6)
+        cgen = cr(5, 6)
+        l = []
+        for i in range(3):
+            l.append(next(cgen))
+        self.assertEqual(l, [14] * 3)
+
+    def test_gen6(self):
+        self.check_gen6(**nopython_flags)
+
+    def test_gen6_objmode(self):
+        self.check_gen6(**forceobj_flags)
+
+    def check_gen7(self, **kwargs):
+        pyfunc = gen7
+        cr = jit((types.Array(types.float64, 1, 'C'),), **kwargs)(pyfunc)
+        arr = np.linspace(1, 10, 7)
+        pygen = pyfunc(arr.copy())
+        cgen = cr(arr)
+        self.check_generator(pygen, cgen)
+
+    def test_gen7(self):
+        self.check_gen7(**nopython_flags)
+
+    def test_gen7_objmode(self):
+        self.check_gen7(**forceobj_flags)
+
+    def check_gen8(self, **jit_args):
+        pyfunc = gen8
+        cfunc = jit(**jit_args)(pyfunc)
+
+        def check(*args, **kwargs):
+            self.check_generator(pyfunc(*args, **kwargs),
+                                 cfunc(*args, **kwargs))
+
+        check(2, 3)
+        check(4)
+        check(y=5)
+        check(x=6, b=True)
+
+    def test_gen8(self):
+        self.check_gen8(nopython=True)
+
+    def test_gen8_objmode(self):
+        self.check_gen8(forceobj=True)
+
+    def check_gen9(self, **kwargs):
+        pyfunc = gen_bool
+        cr = jit((), **kwargs)(pyfunc)
+        pygen = pyfunc()
+        cgen = cr()
+        self.check_generator(pygen, cgen)
+
+    def test_gen9(self):
+        self.check_gen9(**nopython_flags)
+
+    def test_gen9_objmode(self):
+        self.check_gen9(**forceobj_flags)
+
+    def check_consume_generator(self, gen_func):
+        cgen = jit(nopython=True)(gen_func)
+        cfunc = jit(nopython=True)(make_consumer(cgen))
+        pyfunc = make_consumer(gen_func)
+        expected = pyfunc(5)
+        got = cfunc(5)
+        self.assertPreciseEqual(got, expected)
+
+    def test_consume_gen1(self):
+        self.check_consume_generator(gen1)
+
+    def test_consume_gen2(self):
+        self.check_consume_generator(gen2)
+
+    def test_consume_gen3(self):
+        self.check_consume_generator(gen3)
+
+    # Check generator storage of some types
+
+    def check_ndindex(self, **kwargs):
+        pyfunc = gen_ndindex
+        cr = jit((types.UniTuple(types.intp, 2),), **kwargs)(pyfunc)
+        shape = (2, 3)
+        pygen = pyfunc(shape)
+        cgen = cr(shape)
+        self.check_generator(pygen, cgen)
+
+    def test_ndindex(self):
+        self.check_ndindex(**nopython_flags)
+
+    def test_ndindex_objmode(self):
+        self.check_ndindex(**forceobj_flags)
+
+    def check_np_flat(self, pyfunc, **kwargs):
+        cr = jit((types.Array(types.int32, 2, "C"),), **kwargs)(pyfunc)
+        arr = np.arange(6, dtype=np.int32).reshape((2, 3))
+        self.check_generator(pyfunc(arr), cr(arr))
+        crA = jit((types.Array(types.int32, 2, "A"),), **kwargs)(pyfunc)
+        arr = arr.T
+        self.check_generator(pyfunc(arr), crA(arr))
+
+    def test_np_flat(self):
+        self.check_np_flat(gen_flat, **nopython_flags)
+
+    def test_np_flat_objmode(self):
+        self.check_np_flat(gen_flat, **forceobj_flags)
+
+    def test_ndenumerate(self):
+        self.check_np_flat(gen_ndenumerate, **nopython_flags)
+
+    def test_ndenumerate_objmode(self):
+        self.check_np_flat(gen_ndenumerate, **forceobj_flags)
+
+    def test_type_unification_error(self):
+        pyfunc = gen_unification_error
+        with self.assertTypingError() as raises:
+            jit((), **nopython_flags)(pyfunc)
+
+        msg = ("Can't unify yield type from the following types: complex128, "
+               "none")
+        self.assertIn(msg, str(raises.exception))
+
+    def test_optional_expansion_type_unification_error(self):
+        pyfunc = gen_optional_and_type_unification_error
+        with self.assertTypingError() as raises:
+            jit((), **nopython_flags)(pyfunc)
+
+        msg = ("Can't unify yield type from the following types: complex128, "
+               "int%s, none")
+        self.assertIn(msg % types.intp.bitwidth, str(raises.exception))
+
+    def test_changing_tuple_type(self):
+        # test https://github.com/numba/numba/issues/7295
+        pyfunc = gen_changing_tuple_type
+        expected = list(pyfunc())
+        got = list(njit(pyfunc)())
+        self.assertEqual(expected, got)
+
+    def test_changing_number_type(self):
+        # additional test for https://github.com/numba/numba/issues/7295
+        pyfunc = gen_changing_number_type
+        expected = list(pyfunc())
+        got = list(njit(pyfunc)())
+        self.assertEqual(expected, got)
+
+
+def nrt_gen0(ary):
+    for elem in ary:
+        yield elem
+
+
+def nrt_gen1(ary1, ary2):
+    for e1, e2 in zip(ary1, ary2):
+        yield e1
+        yield e2
+
+
+class TestNrtArrayGen(MemoryLeakMixin, TestCase):
+    def test_nrt_gen0(self):
+        pygen = nrt_gen0
+        cgen = jit(nopython=True)(pygen)
+
+        py_ary = np.arange(10)
+        c_ary = py_ary.copy()
+
+        py_res = list(pygen(py_ary))
+        c_res = list(cgen(c_ary))
+
+        np.testing.assert_equal(py_ary, c_ary)
+        self.assertEqual(py_res, c_res)
+        # Check reference count
+        self.assertRefCountEqual(py_ary, c_ary)
+
+    def test_nrt_gen1(self):
+        pygen = nrt_gen1
+        cgen = jit(nopython=True)(pygen)
+
+        py_ary1 = np.arange(10)
+        py_ary2 = py_ary1 + 100
+
+        c_ary1 = py_ary1.copy()
+        c_ary2 = py_ary2.copy()
+
+        py_res = list(pygen(py_ary1, py_ary2))
+        c_res = list(cgen(c_ary1, c_ary2))
+
+        np.testing.assert_equal(py_ary1, c_ary1)
+        np.testing.assert_equal(py_ary2, c_ary2)
+        self.assertEqual(py_res, c_res)
+        # Check reference count
+        self.assertRefCountEqual(py_ary1, c_ary1)
+        self.assertRefCountEqual(py_ary2, c_ary2)
+
+    def test_combine_gen0_gen1(self):
+        """
+        Issue #1163 is observed when two generator with NRT object arguments
+        is ran in sequence.  The first one does a invalid free and corrupts
+        the NRT memory subsystem.  The second generator is likely to segfault
+        due to corrupted NRT data structure (an invalid MemInfo).
+        """
+        self.test_nrt_gen0()
+        self.test_nrt_gen1()
+
+    def test_nrt_gen0_stop_iteration(self):
+        """
+        Test cleanup on StopIteration
+        """
+        pygen = nrt_gen0
+        cgen = jit(nopython=True)(pygen)
+
+        py_ary = np.arange(1)
+        c_ary = py_ary.copy()
+
+        py_iter = pygen(py_ary)
+        c_iter = cgen(c_ary)
+
+        py_res = next(py_iter)
+        c_res = next(c_iter)
+
+        with self.assertRaises(StopIteration):
+            py_res = next(py_iter)
+
+        with self.assertRaises(StopIteration):
+            c_res = next(c_iter)
+
+        del py_iter
+        del c_iter
+
+        np.testing.assert_equal(py_ary, c_ary)
+        self.assertEqual(py_res, c_res)
+        # Check reference count
+        self.assertRefCountEqual(py_ary, c_ary)
+
+    def test_nrt_gen0_no_iter(self):
+        """
+        Test cleanup for a initialized but never iterated (never call next())
+        generator.
+        """
+        pygen = nrt_gen0
+        cgen = jit(nopython=True)(pygen)
+
+        py_ary = np.arange(1)
+        c_ary = py_ary.copy()
+
+        py_iter = pygen(py_ary)
+        c_iter = cgen(c_ary)
+
+        del py_iter
+        del c_iter
+
+        np.testing.assert_equal(py_ary, c_ary)
+
+        # Check reference count
+        self.assertRefCountEqual(py_ary, c_ary)
+
+
+# TODO: fix nested generator and MemoryLeakMixin
+class TestNrtNestedGen(TestCase):
+    def test_nrt_nested_gen(self):
+
+        def gen0(arr):
+            for i in range(arr.size):
+                yield arr
+
+        def factory(gen0):
+            def gen1(arr):
+                out = np.zeros_like(arr)
+                for x in gen0(arr):
+                    out = out + x
+                return out, arr
+
+            return gen1
+
+        py_arr = np.arange(10)
+        c_arr = py_arr.copy()
+        py_res, py_old = factory(gen0)(py_arr)
+        c_gen = jit(nopython=True)(factory(jit(nopython=True)(gen0)))
+        c_res, c_old = c_gen(c_arr)
+
+        self.assertIsNot(py_arr, c_arr)
+        self.assertIs(py_old, py_arr)
+        self.assertIs(c_old, c_arr)
+
+        np.testing.assert_equal(py_res, c_res)
+
+        self.assertRefCountEqual(py_res, c_res)
+
+        # The below test will fail due to generator finalizer not invoked.
+        # This kept a reference of the c_old.
+        #
+        # self.assertEqual(sys.getrefcount(py_old),
+        #                  sys.getrefcount(c_old))
+
+    @unittest.expectedFailure
+    def test_nrt_nested_gen_refct(self):
+        def gen0(arr):
+            yield arr
+
+        def factory(gen0):
+            def gen1(arr):
+                for out in gen0(arr):
+                    return out
+
+            return gen1
+
+        py_arr = np.arange(10)
+        c_arr = py_arr.copy()
+        py_old = factory(gen0)(py_arr)
+        c_gen = jit(nopython=True)(factory(jit(nopython=True)(gen0)))
+        c_old = c_gen(c_arr)
+
+        self.assertIsNot(py_arr, c_arr)
+        self.assertIs(py_old, py_arr)
+        self.assertIs(c_old, c_arr)
+
+        self.assertRefCountEqual(py_old, c_old)
+
+    def test_nrt_nested_nopython_gen(self):
+        """
+        Test nesting three generators
+        """
+
+        def factory(decor=lambda x: x):
+            @decor
+            def foo(a, n):
+                for i in range(n):
+                    yield a[i]
+                    a[i] += i
+
+            @decor
+            def bar(n):
+                a = np.arange(n)
+                for i in foo(a, n):
+                    yield i * 2
+                for i in range(a.size):
+                    yield a[i]
+
+            @decor
+            def cat(n):
+                for i in bar(n):
+                    yield i + i
+
+            return cat
+
+        py_gen = factory()
+        c_gen = factory(jit(nopython=True))
+
+        py_res = list(py_gen(10))
+        c_res = list(c_gen(10))
+
+        self.assertEqual(py_res, c_res)
+
+
+class TestGeneratorWithNRT(MemoryLeakMixin, TestCase):
+    def test_issue_1254(self):
+        """
+        Missing environment for returning array
+        """
+
+        @jit(nopython=True)
+        def random_directions(n):
+            for i in range(n):
+                vec = np.empty(3)
+                vec[:] = 12
+                yield vec
+
+        outputs = list(random_directions(5))
+        self.assertEqual(len(outputs), 5)
+
+        expect = np.empty(3)
+        expect[:] = 12
+        for got in outputs:
+            np.testing.assert_equal(expect, got)
+
+    def test_issue_1265(self):
+        """
+        Double-free for locally allocated, non escaping NRT objects
+        """
+
+        def py_gen(rmin, rmax, nr):
+            a = np.linspace(rmin, rmax, nr)
+            yield a[0]
+            yield a[1]
+
+        c_gen = jit(nopython=True)(py_gen)
+
+        py_res = list(py_gen(-2, 2, 100))
+        c_res = list(c_gen(-2, 2, 100))
+
+        self.assertEqual(py_res, c_res)
+
+        def py_driver(args):
+            rmin, rmax, nr = args
+            points = np.empty(nr, dtype=np.complex128)
+            for i, c in enumerate(py_gen(rmin, rmax, nr)):
+                points[i] = c
+
+            return points
+
+        @jit(nopython=True)
+        def c_driver(args):
+            rmin, rmax, nr = args
+            points = np.empty(nr, dtype=np.complex128)
+            for i, c in enumerate(c_gen(rmin, rmax, nr)):
+                points[i] = c
+
+            return points
+
+        n = 2
+        patches = (-2, -1, n)
+
+        py_res = py_driver(patches)
+        # The error will cause a segfault here
+        c_res = c_driver(patches)
+
+        np.testing.assert_equal(py_res, c_res)
+
+    def test_issue_1808(self):
+        """
+        Incorrect return data model
+        """
+        magic = 0xdeadbeef
+
+        @njit
+        def generator():
+            yield magic
+
+        @njit
+        def get_generator():
+            return generator()
+
+        @njit
+        def main():
+            out = 0
+            for x in get_generator():
+                out += x
+
+            return out
+
+        self.assertEqual(main(), magic)
+
+
+class TestGeneratorModel(test_factory()):
+    fe_type = types.Generator(gen_func=None, yield_type=types.int32,
+                              arg_types=[types.int64, types.float32],
+                              state_types=[types.intp, types.intp[::1]],
+                              has_finalizer=False)
+
+
+if __name__ == '__main__':
+    unittest.main()

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

@@ -0,0 +1,92 @@
+import sys
+import subprocess
+import types as pytypes
+import os.path
+
+import numpy as np
+
+import builtins
+from numba.core import types
+from numba.tests.support import TestCase, temp_directory
+from numba.misc.help.inspector import inspect_function, inspect_module
+
+
+class TestInspector(TestCase):
+    def check_function_descriptor(self, info, must_be_defined=False):
+        self.assertIsInstance(info, dict)
+        self.assertIn('numba_type', info)
+        numba_type = info['numba_type']
+        if numba_type is None:
+            self.assertFalse(must_be_defined)
+        else:
+            self.assertIsInstance(numba_type, types.Type)
+            self.assertIn('explained', info)
+            self.assertIsInstance(info['explained'], str)
+            self.assertIn('source_infos', info)
+            self.assertIsInstance(info['source_infos'], dict)
+
+    def test_inspect_function_on_range(self):
+        info = inspect_function(range)
+        self.check_function_descriptor(info, must_be_defined=True)
+
+    def test_inspect_function_on_np_all(self):
+        info = inspect_function(np.all)
+        self.check_function_descriptor(info, must_be_defined=True)
+        source_infos = info['source_infos']
+        self.assertGreater(len(source_infos), 0)
+        c = 0
+        for srcinfo in source_infos.values():
+            self.assertIsInstance(srcinfo['kind'], str)
+            self.assertIsInstance(srcinfo['name'], str)
+            self.assertIsInstance(srcinfo['sig'], str)
+            self.assertIsInstance(srcinfo['filename'], str)
+            self.assertIsInstance(srcinfo['lines'], tuple)
+            self.assertIn('docstring', srcinfo)
+            c += 1
+        self.assertEqual(c, len(source_infos))
+
+    def test_inspect_module(self):
+        c = 0
+        for it in inspect_module(builtins):
+            self.assertIsInstance(it['module'], pytypes.ModuleType)
+            self.assertIsInstance(it['name'], str)
+            self.assertTrue(callable(it['obj']))
+            self.check_function_descriptor(it)
+            c += 1
+        self.assertGreater(c, 0)
+
+    def test_inspect_cli(self):
+        # Try CLI on math module
+        cmdbase = [sys.executable, '-m', 'numba.misc.help.inspector']
+
+        dirpath = temp_directory('{}.{}'.format(__name__,
+                                                self.__class__.__name__))
+        filename = os.path.join(dirpath, 'out')
+
+        # Try default format "html"
+        expected_file = filename + '.html'
+        cmds = cmdbase + ['--file', filename, 'math']
+        # File shouldn't exist yet
+        self.assertFalse(os.path.isfile(expected_file))
+        # Run CLI
+        subprocess.check_output(cmds)
+        # File should exist now
+        self.assertTrue(os.path.isfile(expected_file))
+
+        # Try changing the format to "rst"
+        cmds = cmdbase + ['--file', filename, '--format', 'rst', 'math']
+        expected_file = filename + '.rst'
+        # File shouldn't exist yet
+        self.assertFalse(os.path.isfile(expected_file))
+        # Run CLI
+        subprocess.check_output(cmds)
+        # File should exist now
+        self.assertTrue(os.path.isfile(expected_file))
+
+        # Try unsupported format
+        cmds = cmdbase + ['--file', filename, '--format', 'foo', 'math']
+        # Run CLI
+        with self.assertRaises(subprocess.CalledProcessError) as raises:
+            subprocess.check_output(cmds, stderr=subprocess.STDOUT)
+        self.assertIn("\'foo\' is not supported",
+                      raises.exception.stdout.decode())

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

@@ -0,0 +1,1154 @@
+"""
+Test bytecode fixes provided in interpreter.py
+"""
+import unittest
+from numba import jit, njit, objmode, typeof, literally
+from numba.extending import overload
+from numba.core import types
+from numba.core.errors import UnsupportedBytecodeError
+from numba.tests.support import (
+    TestCase,
+    MemoryLeakMixin,
+    skip_unless_py10_or_later,
+)
+
+
+@njit
+def sum_jit_func(
+    arg0=0,
+    arg1=0,
+    arg2=0,
+    arg3=0,
+    arg4=0,
+    arg5=0,
+    arg6=0,
+    arg7=0,
+    arg8=0,
+    arg9=0,
+    arg10=0,
+    arg11=0,
+    arg12=0,
+    arg13=0,
+    arg14=0,
+    arg15=0,
+    arg16=0,
+    arg17=0,
+    arg18=0,
+    arg19=0,
+    arg20=0,
+    arg21=0,
+    arg22=0,
+    arg23=0,
+    arg24=0,
+    arg25=0,
+    arg26=0,
+    arg27=0,
+    arg28=0,
+    arg29=0,
+    arg30=0,
+    arg31=0,
+    arg32=0,
+    arg33=0,
+    arg34=0,
+    arg35=0,
+    arg36=0,
+    arg37=0,
+    arg38=0,
+    arg39=0,
+    arg40=0,
+    arg41=0,
+    arg42=0,
+    arg43=0,
+    arg44=0,
+    arg45=0,
+    arg46=0,
+):
+    return (
+        arg0
+        + arg1
+        + arg2
+        + arg3
+        + arg4
+        + arg5
+        + arg6
+        + arg7
+        + arg8
+        + arg9
+        + arg10
+        + arg11
+        + arg12
+        + arg13
+        + arg14
+        + arg15
+        + arg16
+        + arg17
+        + arg18
+        + arg19
+        + arg20
+        + arg21
+        + arg22
+        + arg23
+        + arg24
+        + arg25
+        + arg26
+        + arg27
+        + arg28
+        + arg29
+        + arg30
+        + arg31
+        + arg32
+        + arg33
+        + arg34
+        + arg35
+        + arg36
+        + arg37
+        + arg38
+        + arg39
+        + arg40
+        + arg41
+        + arg42
+        + arg43
+        + arg44
+        + arg45
+        + arg46
+    )
+
+
+class TestCallFunctionExPeepHole(MemoryLeakMixin, TestCase):
+    """
+    gh #7812
+
+    Tests that check a peephole optimization for Function calls
+    in Python 3.10. The bytecode changes when
+    (n_args / 2) + n_kws > 15, which moves the arguments from
+    the stack into a tuple and dictionary.
+
+    This peephole optimization updates the IR to use the original format.
+    There are different paths when n_args > 30 and n_args <= 30 and when
+    n_kws > 15 and n_kws <= 15.
+    """
+    THRESHOLD_ARGS = 31
+    THRESHOLD_KWS = 16
+
+    def gen_func(self, n_args, n_kws):
+        """
+            Generates a function that calls sum_jit_func
+            with the desired number of args and kws.
+        """
+        param_list = [f"arg{i}" for i in range(n_args + n_kws)]
+        args_list = []
+        for i in range(n_args + n_kws):
+            # Call a function on every 5th argument to ensure
+            # we test function calls.
+            if i % 5 == 0:
+                arg_val = f"pow(arg{i}, 2)"
+            else:
+                arg_val = f"arg{i}"
+            args_list.append(arg_val)
+        total_params = ", ".join(param_list)
+        func_text = f"def impl({total_params}):\n"
+        func_text += "    return sum_jit_func(\n"
+        for i in range(n_args):
+            func_text += f"        {args_list[i]},\n"
+        for i in range(n_args, n_args + n_kws):
+            func_text += f"        {param_list[i]}={args_list[i]},\n"
+        func_text += "    )\n"
+        local_vars = {}
+        exec(func_text, {"sum_jit_func": sum_jit_func}, local_vars)
+        return local_vars["impl"]
+
+    @skip_unless_py10_or_later
+    def test_all_args(self):
+        """
+        Tests calling a function when n_args > 30 and
+        n_kws = 0. This shouldn't use the peephole, but
+        it should still succeed.
+        """
+        total_args = [i for i in range(self.THRESHOLD_ARGS)]
+        f = self.gen_func(self.THRESHOLD_ARGS, 0)
+        py_func = f
+        cfunc = njit()(f)
+        a = py_func(*total_args)
+        b = cfunc(*total_args)
+        self.assertEqual(a, b)
+
+    @skip_unless_py10_or_later
+    def test_all_kws(self):
+        """
+        Tests calling a function when n_kws > 15 and
+        n_args = 0.
+        """
+        total_args = [i for i in range(self.THRESHOLD_KWS)]
+        f = self.gen_func(0, self.THRESHOLD_KWS)
+        py_func = f
+        cfunc = njit()(f)
+        a = py_func(*total_args)
+        b = cfunc(*total_args)
+        self.assertEqual(a, b)
+
+    @skip_unless_py10_or_later
+    def test_small_args_small_kws(self):
+        """
+        Tests calling a function when (n_args / 2) + n_kws > 15,
+        but n_args <= 30 and n_kws <= 15
+        """
+        used_args = self.THRESHOLD_ARGS - 1
+        used_kws = self.THRESHOLD_KWS - 1
+        total_args = [i for i in range((used_args) + (used_kws))]
+        f = self.gen_func(used_args, used_kws)
+        py_func = f
+        cfunc = njit()(f)
+        a = py_func(*total_args)
+        b = cfunc(*total_args)
+        self.assertEqual(a, b)
+
+    @skip_unless_py10_or_later
+    def test_small_args_large_kws(self):
+        """
+        Tests calling a function when (n_args / 2) + n_kws > 15,
+        but n_args <= 30 and n_kws > 15
+        """
+        used_args = self.THRESHOLD_ARGS - 1
+        used_kws = self.THRESHOLD_KWS
+        total_args = [i for i in range((used_args) + (used_kws))]
+        f = self.gen_func(used_args, used_kws)
+        py_func = f
+        cfunc = njit()(f)
+        a = py_func(*total_args)
+        b = cfunc(*total_args)
+        self.assertEqual(a, b)
+
+    @skip_unless_py10_or_later
+    def test_large_args_small_kws(self):
+        """
+        Tests calling a function when (n_args / 2) + n_kws > 15,
+        but n_args > 30 and n_kws <= 15
+        """
+        used_args = self.THRESHOLD_ARGS
+        used_kws = self.THRESHOLD_KWS - 1
+        total_args = [i for i in range((used_args) + (used_kws))]
+        f = self.gen_func(used_args, used_kws)
+        py_func = f
+        cfunc = njit()(f)
+        a = py_func(*total_args)
+        b = cfunc(*total_args)
+        self.assertEqual(a, b)
+
+    @skip_unless_py10_or_later
+    def test_large_args_large_kws(self):
+        """
+        Tests calling a function when (n_args / 2) + n_kws > 15,
+        but n_args > 30 and n_kws > 15
+        """
+        used_args = self.THRESHOLD_ARGS
+        used_kws = self.THRESHOLD_KWS
+        total_args = [i for i in range((used_args) + (used_kws))]
+        f = self.gen_func(used_args, used_kws)
+        py_func = f
+        cfunc = njit()(f)
+        a = py_func(*total_args)
+        b = cfunc(*total_args)
+        self.assertEqual(a, b)
+
+    @skip_unless_py10_or_later
+    def test_large_kws_objmode(self):
+        """
+        Tests calling an objectmode function with > 15 return values.
+        """
+        def py_func():
+            return (
+                0,
+                1,
+                2,
+                3,
+                4,
+                5,
+                6,
+                7,
+                8,
+                9,
+                10,
+                11,
+                12,
+                13,
+                14,
+                15,
+            )
+
+        @njit
+        def objmode_func():
+            """
+            Wrapper to call py_func from objmode. This tests
+            large kws with objmode. If the definition for the
+            call is not properly updated this test will fail.
+            """
+            with objmode(
+                a='int64',
+                b='int64',
+                c='int64',
+                d='int64',
+                e='int64',
+                f='int64',
+                g='int64',
+                h='int64',
+                i='int64',
+                j='int64',
+                k='int64',
+                l='int64',
+                m='int64',
+                n='int64',
+                o='int64',
+                p='int64',
+            ):
+                (
+                    a,
+                    b,
+                    c,
+                    d,
+                    e,
+                    f,
+                    g,
+                    h,
+                    i,
+                    j,
+                    k,
+                    l,
+                    m,
+                    n,
+                    o,
+                    p
+                ) = py_func()
+            return (
+                a
+                + b
+                + c
+                + d
+                + e
+                + f
+                + g
+                + h
+                + i
+                + j
+                + k
+                + l
+                + m
+                + n
+                + o
+                + p
+            )
+
+        a = sum(list(py_func()))
+        b = objmode_func()
+        self.assertEqual(a, b)
+
+    @skip_unless_py10_or_later
+    def test_large_args_inline_controlflow(self):
+        """
+        Tests generating large args when one of the inputs
+        has inlined controlflow.
+        """
+        def inline_func(flag):
+            return sum_jit_func(
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1 if flag else 2,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                arg41=1,
+            )
+
+        with self.assertRaises(UnsupportedBytecodeError) as raises:
+            njit()(inline_func)(False)
+        self.assertIn(
+            'You can resolve this issue by moving the control flow out',
+            str(raises.exception)
+        )
+
+    @skip_unless_py10_or_later
+    def test_large_args_noninlined_controlflow(self):
+        """
+        Tests generating large args when one of the inputs
+        has the change suggested in the error message
+        for inlined control flow.
+        """
+        def inline_func(flag):
+            a_val = 1 if flag else 2
+            return sum_jit_func(
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                a_val,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                arg41=1,
+            )
+
+        py_func = inline_func
+        cfunc = njit()(inline_func)
+        a = py_func(False)
+        b = cfunc(False)
+        self.assertEqual(a, b)
+
+    @skip_unless_py10_or_later
+    def test_all_args_inline_controlflow(self):
+        """
+        Tests generating only large args when one of the inputs
+        has inlined controlflow. This requires a special check
+        inside peep_hole_call_function_ex_to_call_function_kw
+        because it usually only handles varkwargs.
+        """
+        def inline_func(flag):
+            return sum_jit_func(
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1 if flag else 2,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+            )
+
+        with self.assertRaises(UnsupportedBytecodeError) as raises:
+            njit()(inline_func)(False)
+        self.assertIn(
+            'You can resolve this issue by moving the control flow out',
+            str(raises.exception)
+        )
+
+    @skip_unless_py10_or_later
+    def test_all_args_noninlined_controlflow(self):
+        """
+        Tests generating large args when one of the inputs
+        has the change suggested in the error message
+        for inlined control flow.
+        """
+        def inline_func(flag):
+            a_val = 1 if flag else 2
+            return sum_jit_func(
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                a_val,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+            )
+
+        py_func = inline_func
+        cfunc = njit()(inline_func)
+        a = py_func(False)
+        b = cfunc(False)
+        self.assertEqual(a, b)
+
+    @skip_unless_py10_or_later
+    def test_large_kws_inline_controlflow(self):
+        """
+        Tests generating large kws when one of the inputs
+        has inlined controlflow.
+        """
+        def inline_func(flag):
+            return sum_jit_func(
+                arg0=1,
+                arg1=1,
+                arg2=1,
+                arg3=1,
+                arg4=1,
+                arg5=1,
+                arg6=1,
+                arg7=1,
+                arg8=1,
+                arg9=1,
+                arg10=1,
+                arg11=1,
+                arg12=1,
+                arg13=1,
+                arg14=1,
+                arg15=1 if flag else 2,
+            )
+
+        with self.assertRaises(UnsupportedBytecodeError) as raises:
+            njit()(inline_func)(False)
+        self.assertIn(
+            'You can resolve this issue by moving the control flow out',
+            str(raises.exception)
+        )
+
+    @skip_unless_py10_or_later
+    def test_large_kws_noninlined_controlflow(self):
+        """
+        Tests generating large kws when one of the inputs
+        has the change suggested in the error message
+        for inlined control flow.
+        """
+        def inline_func(flag):
+            a_val = 1 if flag else 2
+            return sum_jit_func(
+                arg0=1,
+                arg1=1,
+                arg2=1,
+                arg3=1,
+                arg4=1,
+                arg5=1,
+                arg6=1,
+                arg7=1,
+                arg8=1,
+                arg9=1,
+                arg10=1,
+                arg11=1,
+                arg12=1,
+                arg13=1,
+                arg14=1,
+                arg15=a_val,
+            )
+
+        py_func = inline_func
+        cfunc = njit()(inline_func)
+        a = py_func(False)
+        b = cfunc(False)
+        self.assertEqual(a, b)
+
+
+class TestLargeConstDict(TestCase, MemoryLeakMixin):
+    """
+    gh #7894
+
+    Tests that check a peephole optimization for constant
+    dictionaries in Python 3.10. The bytecode changes when
+    number of elements > 15, which splits the constant dictionary
+    into multiple dictionaries that are joined by a DICT_UPDATE
+    bytecode instruction.
+
+    This optimization modifies the IR to rejoin dictionaries
+    and remove the DICT_UPDATE generated code. This then allows
+    code that depends on literal dictionaries or literal keys
+    to succeed.
+    """
+
+    @skip_unless_py10_or_later
+    def test_large_heterogeneous_const_dict(self):
+        """
+        Tests that a function with a large heterogeneous constant
+        dictionary remains a constant.
+        """
+        def const_func():
+            # D is a heterogeneous dictionary
+            # so this code can only compile if
+            # d is constant.
+            d = {
+                "A": 1,
+                "B": 1,
+                "C": 1,
+                "D": 1,
+                "E": 1,
+                "F": 1,
+                "G": 1,
+                "H": 1,
+                "I": 1,
+                "J": 1,
+                "K": 1,
+                "L": 1,
+                "M": 1,
+                "N": 1,
+                "O": 1,
+                "P": 1,
+                "Q": 1,
+                "R": 1,
+                "S": 'a',
+            }
+            return d["S"]
+
+        py_func = const_func
+        cfunc = njit()(const_func)
+        a = py_func()
+        b = cfunc()
+        self.assertEqual(a, b)
+
+    @skip_unless_py10_or_later
+    def test_large_heterogeneous_LiteralStrKeyDict_literal_values(self):
+        """Check the literal values for a LiteralStrKeyDict requiring
+        optimizations because it is heterogeneous.
+        """
+
+        def bar(d):
+            ...
+
+        @overload(bar)
+        def ol_bar(d):
+            a = {
+                "A": 1,
+                "B": 1,
+                "C": 1,
+                "D": 1,
+                "E": 1,
+                "F": 1,
+                "G": 1,
+                "H": 1,
+                "I": 1,
+                "J": 1,
+                "K": 1,
+                "L": 1,
+                "M": 1,
+                "N": 1,
+                "O": 1,
+                "P": 1,
+                "Q": 1,
+                "R": 1,
+                "S": 'a',
+            }
+
+            def specific_ty(z):
+                return types.literal(z) if types.maybe_literal(z) else typeof(z)
+            expected = {types.literal(x): specific_ty(y) for x, y in a.items()}
+            self.assertTrue(isinstance(d, types.LiteralStrKeyDict))
+            self.assertEqual(d.literal_value, expected)
+            self.assertEqual(hasattr(d, 'initial_value'), False)
+            return lambda d: d
+
+        @njit
+        def foo():
+            # D is a heterogeneous dictionary
+            # so this code can only compile if
+            # d has the correct literal values.
+            d = {
+                "A": 1,
+                "B": 1,
+                "C": 1,
+                "D": 1,
+                "E": 1,
+                "F": 1,
+                "G": 1,
+                "H": 1,
+                "I": 1,
+                "J": 1,
+                "K": 1,
+                "L": 1,
+                "M": 1,
+                "N": 1,
+                "O": 1,
+                "P": 1,
+                "Q": 1,
+                "R": 1,
+                "S": 'a',
+            }
+            bar(d)
+
+        foo()
+
+    @skip_unless_py10_or_later
+    def test_large_heterogeneous_const_keys_dict(self):
+        """
+        Tests that a function with a large heterogeneous constant
+        dictionary remains a constant.
+        """
+        def const_keys_func(a):
+            # D is a heterogeneous dictionary
+            # so this code can only compile if
+            # d has constant keys.
+            d = {
+                "A": 1,
+                "B": 1,
+                "C": 1,
+                "D": 1,
+                "E": 1,
+                "F": 1,
+                "G": 1,
+                "H": 1,
+                "I": 1,
+                "J": 1,
+                "K": 1,
+                "L": 1,
+                "M": 1,
+                "N": 1,
+                "O": 1,
+                "P": 1,
+                "Q": 1,
+                "R": 1,
+                "S": a,
+            }
+            return d["S"]
+
+        py_func = const_keys_func
+        cfunc = njit()(const_keys_func)
+        # str to make the dictionary heterogeneous.
+        value = "a_string"
+        a = py_func(value)
+        b = cfunc(value)
+        self.assertEqual(a, b)
+
+    @skip_unless_py10_or_later
+    def test_large_dict_mutation_not_carried(self):
+        """Checks that the optimization for large dictionaries
+        do not incorrectly update initial values due to other
+        mutations.
+        """
+        def bar(d):
+            ...
+
+        @overload(bar)
+        def ol_bar(d):
+            a = {
+                "A": 1,
+                "B": 1,
+                "C": 1,
+                "D": 1,
+                "E": 1,
+                "F": 1,
+                "G": 1,
+                "H": 1,
+                "I": 1,
+                "J": 1,
+                "K": 1,
+                "L": 1,
+                "M": 1,
+                "N": 1,
+                "O": 1,
+                "P": 1,
+                "Q": 1,
+                "R": 1,
+                "S": 7,
+            }
+            if d.initial_value is None:
+                return lambda d: literally(d)
+            self.assertTrue(isinstance(d, types.DictType))
+            self.assertEqual(d.initial_value, a)
+            return lambda d: d
+
+        @njit
+        def foo():
+            # This dictionary is mutated, check the initial_value carries
+            # correctly and is not mutated
+            d = {
+                "A": 1,
+                "B": 1,
+                "C": 1,
+                "D": 1,
+                "E": 1,
+                "F": 1,
+                "G": 1,
+                "H": 1,
+                "I": 1,
+                "J": 1,
+                "K": 1,
+                "L": 1,
+                "M": 1,
+                "N": 1,
+                "O": 1,
+                "P": 1,
+                "Q": 1,
+                "R": 1,
+                "S": 7,
+            }
+            d['X'] = 4
+            bar(d)
+
+        foo()
+
+    @skip_unless_py10_or_later
+    def test_usercode_update_use_d2(self):
+        """
+        Tests an example using a regular update is
+        not modified by the optimization.
+        """
+
+        def check_before(x):
+            pass
+
+        def check_after(x):
+            pass
+
+        checked_before = False
+        checked_after = False
+
+        @overload(check_before, prefer_literal=True)
+        def ol_check_before(d):
+            nonlocal checked_before
+            # Typing iteration from d1.update(d2)
+            # may reset the initial values to None,
+            # so we only check on the first iteration.
+            if not checked_before:
+                checked_before = True
+                a = {
+                    "a": 1,
+                    "b": 2,
+                    "c": 3,
+                }
+                self.assertTrue(isinstance(d, types.DictType))
+                self.assertEqual(d.initial_value, a)
+
+            return lambda d: None
+
+        @overload(check_after, prefer_literal=True)
+        def ol_check_after(d):
+            nonlocal checked_after
+            # Typing iteration from d1.update(d2)
+            # may reset the initial values to None,
+            # so we only check on the first iteration.
+            if not checked_after:
+                checked_after = True
+                self.assertTrue(isinstance(d, types.DictType))
+                self.assertTrue(d.initial_value is None)
+
+            return lambda d: None
+
+        def const_dict_func():
+            """
+            Dictionary update between two constant
+            dictionaries. This verifies d2 doesn't
+            get incorrectly removed.
+            """
+            d1 = {
+                "a": 1,
+                "b": 2,
+                "c": 3,
+            }
+            d2 = {
+                "d": 4,
+                "e": 4
+            }
+            check_before(d1)
+            d1.update(d2)
+            check_after(d1)
+            # Create a use of d2 in a new block.
+            if len(d1) > 4:
+                return d2
+            return d1
+
+        py_func = const_dict_func
+        cfunc = njit()(const_dict_func)
+        a = py_func()
+        b = cfunc()
+        self.assertEqual(a, b)
+
+    @skip_unless_py10_or_later
+    def test_large_const_dict_inline_controlflow(self):
+        """
+        Tests generating a large dictionary when one of
+        the inputs requires inline control flow
+        has the change suggested in the error message
+        for inlined control flow.
+        """
+        def inline_func(a, flag):
+            # D is a heterogeneous dictionary
+            # so this code can only compile if
+            # d has constant keys.
+            d = {
+                "A": 1,
+                "B": 1,
+                "C": 1,
+                "D": 1,
+                "E": 1,
+                "F": 1,
+                "G": 1,
+                "H": 1 if flag else 2,
+                "I": 1,
+                "J": 1,
+                "K": 1,
+                "L": 1,
+                "M": 1,
+                "N": 1,
+                "O": 1,
+                "P": 1,
+                "Q": 1,
+                "R": 1,
+                "S": a,
+            }
+            return d["S"]
+
+        with self.assertRaises(UnsupportedBytecodeError) as raises:
+            njit()(inline_func)("a_string", False)
+        self.assertIn(
+            'You can resolve this issue by moving the control flow out',
+            str(raises.exception)
+        )
+
+    @skip_unless_py10_or_later
+    def test_large_const_dict_noninline_controlflow(self):
+        """
+        Tests generating large constant dict when one of the
+        inputs has the change suggested in the error message
+        for inlined control flow.
+        """
+        def non_inline_func(a, flag):
+            # D is a heterogeneous dictionary
+            # so this code can only compile if
+            # d has constant keys.
+            val = 1 if flag else 2
+            d = {
+                "A": 1,
+                "B": 1,
+                "C": 1,
+                "D": 1,
+                "E": 1,
+                "F": 1,
+                "G": 1,
+                "H": val,
+                "I": 1,
+                "J": 1,
+                "K": 1,
+                "L": 1,
+                "M": 1,
+                "N": 1,
+                "O": 1,
+                "P": 1,
+                "Q": 1,
+                "R": 1,
+                "S": a,
+            }
+            return d["S"]
+
+        py_func = non_inline_func
+        cfunc = njit()(non_inline_func)
+        value = "a_string"
+        a = py_func(value, False)
+        b = cfunc(value, False)
+        self.assertEqual(a, b)
+
+    @skip_unless_py10_or_later
+    def test_fuse_twice_literal_values(self):
+        """
+        Tests that the correct literal values are generated
+        for a dictionary that produces two DICT_UPDATE
+        bytecode entries for the same dictionary.
+        """
+        def bar(d):
+            ...
+
+        @overload(bar)
+        def ol_bar(d):
+            a = {
+                "a1" : 1,
+                "a2" : 2,
+                "a3" : 3,
+                "a4" : 4,
+                "a5" : 5,
+                "a6" : 6,
+                "a7" : 7,
+                "a8" : 8,
+                "a9" : 9,
+                "a10" : 10,
+                "a11" : 11,
+                "a12" : 12,
+                "a13" : 13,
+                "a14" : 14,
+                "a15" : 15,
+                "a16" : 16,
+                "a17" : 17,
+                "a18" : 18,
+                "a19" : 19,
+                "a20" : 20,
+                "a21" : 21,
+                "a22" : 22,
+                "a23" : 23,
+                "a24" : 24,
+                "a25" : 25,
+                "a26" : 26,
+                "a27" : 27,
+                "a28" : 28,
+                "a29" : 29,
+                "a30" : 30,
+                "a31" : 31,
+                "a32" : 32,
+                "a33" : 33,
+                "a34" : 34, # 34 items is the limit of
+                            # (LOAD_CONST + MAP_ADD)^n + DICT_UPDATE
+                "a35" : 35, # 35 Generates an additional BUILD_MAP + DICT_UPDATE
+            }
+            if d.initial_value is None:
+                return lambda d: literally(d)
+            self.assertTrue(isinstance(d, types.DictType))
+            self.assertEqual(d.initial_value, a)
+            return lambda d: d
+
+        @njit
+        def foo():
+            # This dictionary is mutated, check the initial_value carries
+            # correctly and is not mutated
+            d = {
+                "a1" : 1,
+                "a2" : 2,
+                "a3" : 3,
+                "a4" : 4,
+                "a5" : 5,
+                "a6" : 6,
+                "a7" : 7,
+                "a8" : 8,
+                "a9" : 9,
+                "a10" : 10,
+                "a11" : 11,
+                "a12" : 12,
+                "a13" : 13,
+                "a14" : 14,
+                "a15" : 15,
+                "a16" : 16,
+                "a17" : 17,
+                "a18" : 18,
+                "a19" : 19,
+                "a20" : 20,
+                "a21" : 21,
+                "a22" : 22,
+                "a23" : 23,
+                "a24" : 24,
+                "a25" : 25,
+                "a26" : 26,
+                "a27" : 27,
+                "a28" : 28,
+                "a29" : 29,
+                "a30" : 30,
+                "a31" : 31,
+                "a32" : 32,
+                "a33" : 33,
+                "a34" : 34, # 34 items is the limit of
+                            # (LOAD_CONST + MAP_ADD)^n + DICT_UPDATE
+                "a35" : 35, # 35 Generates an additional BUILD_MAP + DICT_UPDATE
+            }
+            bar(d)
+
+        foo()
+
+
+class TestListExtendInStarArgNonTupleIterable(MemoryLeakMixin, TestCase):
+    """Test `fn(pos_arg0, pos_arg1, *args)` where args is a non-tuple iterable.
+
+    Python 3.9+ will generate LIST_EXTEND bytecode to combine the positional
+    arguments with the `*args`.
+
+    See #8059
+
+    NOTE: At the moment, there are no meaningful tests for NoPython because the
+    lack of support for `tuple(iterable)` for most iterable types.
+    """
+    def test_list_extend_forceobj(self):
+        def consumer(*x):
+            return x
+
+        @jit(forceobj=True)
+        def foo(x):
+            return consumer(1, 2, *x)
+
+        got = foo("ijo")
+        expect = foo.py_func("ijo")
+        self.assertEqual(got, (1, 2, "i", "j", "o"))
+        self.assertEqual(got, expect)
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,560 @@
+import unittest
+from unittest.case import TestCase
+import warnings
+import numpy as np
+
+from numba import objmode
+from numba.core import ir, compiler
+from numba.core import errors
+from numba.core.compiler import (
+    CompilerBase,
+    ReconstructSSA,
+)
+from numba.core.compiler_machinery import (
+    FunctionPass,
+    PassManager,
+    register_pass,
+)
+from numba.core.untyped_passes import (
+    TranslateByteCode,
+    IRProcessing,
+)
+from numba import njit
+
+
+class TestIR(unittest.TestCase):
+
+    def test_IRScope(self):
+        filename = "<?>"
+        top = ir.Scope(parent=None, loc=ir.Loc(filename=filename, line=1))
+        local = ir.Scope(parent=top, loc=ir.Loc(filename=filename, line=2))
+
+        apple = local.define('apple', loc=ir.Loc(filename=filename, line=3))
+        self.assertIs(local.get('apple'), apple)
+        self.assertEqual(len(local.localvars), 1)
+
+        orange = top.define('orange', loc=ir.Loc(filename=filename, line=4))
+        self.assertEqual(len(local.localvars), 1)
+        self.assertEqual(len(top.localvars), 1)
+        self.assertIs(top.get('orange'), orange)
+        self.assertIs(local.get('orange'), orange)
+
+        more_orange = local.define('orange', loc=ir.Loc(filename=filename,
+                                                        line=5))
+        self.assertIs(top.get('orange'), orange)
+        self.assertIsNot(local.get('orange'), not orange)
+        self.assertIs(local.get('orange'), more_orange)
+
+        try:
+            local.define('orange', loc=ir.Loc(filename=filename, line=5))
+        except ir.RedefinedError:
+            pass
+        else:
+            self.fail("Expecting an %s" % ir.RedefinedError)
+
+
+class CheckEquality(unittest.TestCase):
+
+    var_a = ir.Var(None, 'a', ir.unknown_loc)
+    var_b = ir.Var(None, 'b', ir.unknown_loc)
+    var_c = ir.Var(None, 'c', ir.unknown_loc)
+    var_d = ir.Var(None, 'd', ir.unknown_loc)
+    var_e = ir.Var(None, 'e', ir.unknown_loc)
+    loc1 = ir.Loc('mock', 1, 0)
+    loc2 = ir.Loc('mock', 2, 0)
+    loc3 = ir.Loc('mock', 3, 0)
+
+    def check(self, base, same=[], different=[]):
+        for s in same:
+            self.assertTrue(base == s)
+        for d in different:
+            self.assertTrue(base != d)
+
+
+class TestIRMeta(CheckEquality):
+    """
+    Tests IR node meta, like Loc and Scope
+    """
+    def test_loc(self):
+        a = ir.Loc('file', 1, 0)
+        b = ir.Loc('file', 1, 0)
+        c = ir.Loc('pile', 1, 0)
+        d = ir.Loc('file', 2, 0)
+        e = ir.Loc('file', 1, 1)
+        self.check(a, same=[b,], different=[c, d, e])
+
+        f = ir.Loc('file', 1, 0, maybe_decorator=False)
+        g = ir.Loc('file', 1, 0, maybe_decorator=True)
+        self.check(a, same=[f, g])
+
+    def test_scope(self):
+        parent1 = ir.Scope(None, self.loc1)
+        parent2 = ir.Scope(None, self.loc1)
+        parent3 = ir.Scope(None, self.loc2)
+        self.check(parent1, same=[parent2, parent3,])
+
+        a = ir.Scope(parent1, self.loc1)
+        b = ir.Scope(parent1, self.loc1)
+        c = ir.Scope(parent1, self.loc2)
+        d = ir.Scope(parent3, self.loc1)
+        self.check(a, same=[b, c, d])
+
+        # parent1 and parent2 are equal, so children referring to either parent
+        # should be equal
+        e = ir.Scope(parent2, self.loc1)
+        self.check(a, same=[e,])
+
+
+class TestIRNodes(CheckEquality):
+    """
+    Tests IR nodes
+    """
+    def test_terminator(self):
+        # terminator base class inst should always be equal
+        t1 = ir.Terminator()
+        t2 = ir.Terminator()
+        self.check(t1, same=[t2])
+
+    def test_jump(self):
+        a = ir.Jump(1, self.loc1)
+        b = ir.Jump(1, self.loc1)
+        c = ir.Jump(1, self.loc2)
+        d = ir.Jump(2, self.loc1)
+        self.check(a, same=[b, c], different=[d])
+
+    def test_return(self):
+        a = ir.Return(self.var_a, self.loc1)
+        b = ir.Return(self.var_a, self.loc1)
+        c = ir.Return(self.var_a, self.loc2)
+        d = ir.Return(self.var_b, self.loc1)
+        self.check(a, same=[b, c], different=[d])
+
+    def test_raise(self):
+        a = ir.Raise(self.var_a, self.loc1)
+        b = ir.Raise(self.var_a, self.loc1)
+        c = ir.Raise(self.var_a, self.loc2)
+        d = ir.Raise(self.var_b, self.loc1)
+        self.check(a, same=[b, c], different=[d])
+
+    def test_staticraise(self):
+        a = ir.StaticRaise(AssertionError, None, self.loc1)
+        b = ir.StaticRaise(AssertionError, None, self.loc1)
+        c = ir.StaticRaise(AssertionError, None, self.loc2)
+        e = ir.StaticRaise(AssertionError, ("str",), self.loc1)
+        d = ir.StaticRaise(RuntimeError, None, self.loc1)
+        self.check(a, same=[b, c], different=[d, e])
+
+    def test_branch(self):
+        a = ir.Branch(self.var_a, 1, 2, self.loc1)
+        b = ir.Branch(self.var_a, 1, 2, self.loc1)
+        c = ir.Branch(self.var_a, 1, 2, self.loc2)
+        d = ir.Branch(self.var_b, 1, 2, self.loc1)
+        e = ir.Branch(self.var_a, 2, 2, self.loc1)
+        f = ir.Branch(self.var_a, 1, 3, self.loc1)
+        self.check(a, same=[b, c], different=[d, e, f])
+
+    def test_expr(self):
+        a = ir.Expr('some_op', self.loc1)
+        b = ir.Expr('some_op', self.loc1)
+        c = ir.Expr('some_op', self.loc2)
+        d = ir.Expr('some_other_op', self.loc1)
+        self.check(a, same=[b, c], different=[d])
+
+    def test_setitem(self):
+        a = ir.SetItem(self.var_a, self.var_b, self.var_c, self.loc1)
+        b = ir.SetItem(self.var_a, self.var_b, self.var_c, self.loc1)
+        c = ir.SetItem(self.var_a, self.var_b, self.var_c, self.loc2)
+        d = ir.SetItem(self.var_d, self.var_b, self.var_c, self.loc1)
+        e = ir.SetItem(self.var_a, self.var_d, self.var_c, self.loc1)
+        f = ir.SetItem(self.var_a, self.var_b, self.var_d, self.loc1)
+        self.check(a, same=[b, c], different=[d, e, f])
+
+    def test_staticsetitem(self):
+        a = ir.StaticSetItem(self.var_a, 1, self.var_b, self.var_c, self.loc1)
+        b = ir.StaticSetItem(self.var_a, 1, self.var_b, self.var_c, self.loc1)
+        c = ir.StaticSetItem(self.var_a, 1, self.var_b, self.var_c, self.loc2)
+        d = ir.StaticSetItem(self.var_d, 1, self.var_b, self.var_c, self.loc1)
+        e = ir.StaticSetItem(self.var_a, 2, self.var_b, self.var_c, self.loc1)
+        f = ir.StaticSetItem(self.var_a, 1, self.var_d, self.var_c, self.loc1)
+        g = ir.StaticSetItem(self.var_a, 1, self.var_b, self.var_d, self.loc1)
+        self.check(a, same=[b, c], different=[d, e, f, g])
+
+    def test_delitem(self):
+        a = ir.DelItem(self.var_a, self.var_b, self.loc1)
+        b = ir.DelItem(self.var_a, self.var_b, self.loc1)
+        c = ir.DelItem(self.var_a, self.var_b, self.loc2)
+        d = ir.DelItem(self.var_c, self.var_b, self.loc1)
+        e = ir.DelItem(self.var_a, self.var_c, self.loc1)
+        self.check(a, same=[b, c], different=[d, e])
+
+    def test_del(self):
+        a = ir.Del(self.var_a.name, self.loc1)
+        b = ir.Del(self.var_a.name, self.loc1)
+        c = ir.Del(self.var_a.name, self.loc2)
+        d = ir.Del(self.var_b.name, self.loc1)
+        self.check(a, same=[b, c], different=[d])
+
+    def test_setattr(self):
+        a = ir.SetAttr(self.var_a, 'foo', self.var_b, self.loc1)
+        b = ir.SetAttr(self.var_a, 'foo', self.var_b, self.loc1)
+        c = ir.SetAttr(self.var_a, 'foo', self.var_b, self.loc2)
+        d = ir.SetAttr(self.var_c, 'foo', self.var_b, self.loc1)
+        e = ir.SetAttr(self.var_a, 'bar', self.var_b, self.loc1)
+        f = ir.SetAttr(self.var_a, 'foo', self.var_c, self.loc1)
+        self.check(a, same=[b, c], different=[d, e, f])
+
+    def test_delattr(self):
+        a = ir.DelAttr(self.var_a, 'foo', self.loc1)
+        b = ir.DelAttr(self.var_a, 'foo', self.loc1)
+        c = ir.DelAttr(self.var_a, 'foo', self.loc2)
+        d = ir.DelAttr(self.var_c, 'foo', self.loc1)
+        e = ir.DelAttr(self.var_a, 'bar', self.loc1)
+        self.check(a, same=[b, c], different=[d, e])
+
+    def test_assign(self):
+        a = ir.Assign(self.var_a, self.var_b, self.loc1)
+        b = ir.Assign(self.var_a, self.var_b, self.loc1)
+        c = ir.Assign(self.var_a, self.var_b, self.loc2)
+        d = ir.Assign(self.var_c, self.var_b, self.loc1)
+        e = ir.Assign(self.var_a, self.var_c, self.loc1)
+        self.check(a, same=[b, c], different=[d, e])
+
+    def test_print(self):
+        a = ir.Print((self.var_a,), self.var_b, self.loc1)
+        b = ir.Print((self.var_a,), self.var_b, self.loc1)
+        c = ir.Print((self.var_a,), self.var_b, self.loc2)
+        d = ir.Print((self.var_c,), self.var_b, self.loc1)
+        e = ir.Print((self.var_a,), self.var_c, self.loc1)
+        self.check(a, same=[b, c], different=[d, e])
+
+    def test_storemap(self):
+        a = ir.StoreMap(self.var_a, self.var_b, self.var_c, self.loc1)
+        b = ir.StoreMap(self.var_a, self.var_b, self.var_c, self.loc1)
+        c = ir.StoreMap(self.var_a, self.var_b, self.var_c, self.loc2)
+        d = ir.StoreMap(self.var_d, self.var_b, self.var_c, self.loc1)
+        e = ir.StoreMap(self.var_a, self.var_d, self.var_c, self.loc1)
+        f = ir.StoreMap(self.var_a, self.var_b, self.var_d, self.loc1)
+        self.check(a, same=[b, c], different=[d, e, f])
+
+    def test_yield(self):
+        a = ir.Yield(self.var_a, self.loc1, 0)
+        b = ir.Yield(self.var_a, self.loc1, 0)
+        c = ir.Yield(self.var_a, self.loc2, 0)
+        d = ir.Yield(self.var_b, self.loc1, 0)
+        e = ir.Yield(self.var_a, self.loc1, 1)
+        self.check(a, same=[b, c], different=[d, e])
+
+    def test_enterwith(self):
+        a = ir.EnterWith(self.var_a, 0, 1, self.loc1)
+        b = ir.EnterWith(self.var_a, 0, 1, self.loc1)
+        c = ir.EnterWith(self.var_a, 0, 1, self.loc2)
+        d = ir.EnterWith(self.var_b, 0, 1, self.loc1)
+        e = ir.EnterWith(self.var_a, 1, 1, self.loc1)
+        f = ir.EnterWith(self.var_a, 0, 2, self.loc1)
+        self.check(a, same=[b, c], different=[d, e, f])
+
+    def test_arg(self):
+        a = ir.Arg('foo', 0, self.loc1)
+        b = ir.Arg('foo', 0, self.loc1)
+        c = ir.Arg('foo', 0, self.loc2)
+        d = ir.Arg('bar', 0, self.loc1)
+        e = ir.Arg('foo', 1, self.loc1)
+        self.check(a, same=[b, c], different=[d, e])
+
+    def test_const(self):
+        a = ir.Const(1, self.loc1)
+        b = ir.Const(1, self.loc1)
+        c = ir.Const(1, self.loc2)
+        d = ir.Const(2, self.loc1)
+        self.check(a, same=[b, c], different=[d])
+
+    def test_global(self):
+        a = ir.Global('foo', 0, self.loc1)
+        b = ir.Global('foo', 0, self.loc1)
+        c = ir.Global('foo', 0, self.loc2)
+        d = ir.Global('bar', 0, self.loc1)
+        e = ir.Global('foo', 1, self.loc1)
+        self.check(a, same=[b, c], different=[d, e])
+
+    def test_var(self):
+        a = ir.Var(None, 'foo', self.loc1)
+        b = ir.Var(None, 'foo', self.loc1)
+        c = ir.Var(None, 'foo', self.loc2)
+        d = ir.Var(ir.Scope(None, ir.unknown_loc), 'foo', self.loc1)
+        e = ir.Var(None, 'bar', self.loc1)
+        self.check(a, same=[b, c, d], different=[e])
+
+    def test_undefinedtype(self):
+        a = ir.UndefinedType()
+        b = ir.UndefinedType()
+        self.check(a, same=[b])
+
+    def test_loop(self):
+        a = ir.Loop(1, 3)
+        b = ir.Loop(1, 3)
+        c = ir.Loop(2, 3)
+        d = ir.Loop(1, 4)
+        self.check(a, same=[b], different=[c, d])
+
+    def test_with(self):
+        a = ir.With(1, 3)
+        b = ir.With(1, 3)
+        c = ir.With(2, 3)
+        d = ir.With(1, 4)
+        self.check(a, same=[b], different=[c, d])
+
+
+# used later
+_GLOBAL = 1234
+
+
+class TestIRCompounds(CheckEquality):
+    """
+    Tests IR concepts that have state
+    """
+    def test_varmap(self):
+        a = ir.VarMap()
+        a.define(self.var_a, 'foo')
+        a.define(self.var_b, 'bar')
+
+        b = ir.VarMap()
+        b.define(self.var_a, 'foo')
+        b.define(self.var_b, 'bar')
+
+        c = ir.VarMap()
+        c.define(self.var_a, 'foo')
+        c.define(self.var_c, 'bar')
+
+        self.check(a, same=[b], different=[c])
+
+    def test_block(self):
+        def gen_block():
+            parent = ir.Scope(None, self.loc1)
+            tmp = ir.Block(parent, self.loc2)
+            assign1 = ir.Assign(self.var_a, self.var_b, self.loc3)
+            assign2 = ir.Assign(self.var_a, self.var_c, self.loc3)
+            assign3 = ir.Assign(self.var_c, self.var_b, self.loc3)
+            tmp.append(assign1)
+            tmp.append(assign2)
+            tmp.append(assign3)
+            return tmp
+
+        a = gen_block()
+        b = gen_block()
+        c = gen_block().append(ir.Assign(self.var_a, self.var_b, self.loc3))
+
+        self.check(a, same=[b], different=[c])
+
+    def test_functionir(self):
+
+        def run_frontend(x):
+            return compiler.run_frontend(x, emit_dels=True)
+
+        # this creates a function full of all sorts of things to ensure the IR
+        # is pretty involved, it then compares two instances of the compiled
+        # function IR to check the IR is the same invariant of objects, and then
+        # a tiny mutation is made to the IR in the second function and detection
+        # of this change is checked.
+        def gen():
+            _FREEVAR = 0xCAFE
+
+            def foo(a, b, c=12, d=1j, e=None):
+                f = a + b
+                a += _FREEVAR
+                g = np.zeros(c, dtype=np.complex64)
+                h = f + g
+                i = 1j / d
+                if np.abs(i) > 0:
+                    k = h / i
+                    l = np.arange(1, c + 1)
+                    with objmode():
+                        print(e, k)
+                    m = np.sqrt(l - g)
+                    if np.abs(m[0]) < 1:
+                        n = 0
+                        for o in range(a):
+                            n += 0
+                            if np.abs(n) < 3:
+                                break
+                        n += m[2]
+                    p = g / l
+                    q = []
+                    for r in range(len(p)):
+                        q.append(p[r])
+                        if r > 4 + 1:
+                            with objmode(s='intp', t='complex128'):
+                                s = 123
+                                t = 5
+                            if s > 122:
+                                t += s
+                        t += q[0] + _GLOBAL
+
+                return f + o + r + t + r + a + n
+
+            return foo
+
+        x = gen()
+        y = gen()
+        x_ir = run_frontend(x)
+        y_ir = run_frontend(y)
+
+        self.assertTrue(x_ir.equal_ir(y_ir))
+
+        def check_diffstr(string, pointing_at=[]):
+            lines = string.splitlines()
+            for item in pointing_at:
+                for l in lines:
+                    if l.startswith('->'):
+                        if item in l:
+                            break
+                else:
+                    raise AssertionError("Could not find %s " % item)
+
+        self.assertIn("IR is considered equivalent", x_ir.diff_str(y_ir))
+
+        # minor mutation, simply switch branch targets on last branch
+        for label in reversed(list(y_ir.blocks.keys())):
+            blk = y_ir.blocks[label]
+            if isinstance(blk.body[-1], ir.Branch):
+                ref = blk.body[-1]
+                ref.truebr, ref.falsebr = ref.falsebr, ref.truebr
+                break
+
+        check_diffstr(x_ir.diff_str(y_ir), ['branch'])
+
+        z = gen()
+        self.assertFalse(x_ir.equal_ir(y_ir))
+
+        z_ir = run_frontend(z)
+
+        change_set = set()
+        for label in reversed(list(z_ir.blocks.keys())):
+            blk = z_ir.blocks[label]
+            ref = blk.body[:-1]
+            idx = None
+            for i in range(len(ref) - 1):
+                # look for two adjacent Del
+                if (isinstance(ref[i], ir.Del) and
+                        isinstance(ref[i + 1], ir.Del)):
+                    idx = i
+                    break
+            if idx is not None:
+                b = blk.body
+                change_set.add(str(b[idx + 1]))
+                change_set.add(str(b[idx]))
+                b[idx], b[idx + 1] = b[idx + 1], b[idx]
+                break
+
+        # ensure that a mutation occurred.
+        self.assertTrue(change_set)
+
+        self.assertFalse(x_ir.equal_ir(z_ir))
+        self.assertEqual(len(change_set), 2)
+        for item in change_set:
+            self.assertTrue(item.startswith('del '))
+        check_diffstr(x_ir.diff_str(z_ir), change_set)
+
+        def foo(a, b):
+            c = a * 2
+            d = c + b
+            e = np.sqrt(d)
+            return e
+
+        def bar(a, b): # same as foo
+            c = a * 2
+            d = c + b
+            e = np.sqrt(d)
+            return e
+
+        def baz(a, b):
+            c = a * 2
+            d = b + c
+            e = np.sqrt(d + 1)
+            return e
+
+        foo_ir = run_frontend(foo)
+        bar_ir = run_frontend(bar)
+        self.assertTrue(foo_ir.equal_ir(bar_ir))
+        self.assertIn("IR is considered equivalent", foo_ir.diff_str(bar_ir))
+
+        baz_ir = run_frontend(baz)
+        self.assertFalse(foo_ir.equal_ir(baz_ir))
+        tmp = foo_ir.diff_str(baz_ir)
+        self.assertIn("Other block contains more statements", tmp)
+        check_diffstr(tmp, ["c + b", "b + c"])
+
+
+class TestIRPedanticChecks(TestCase):
+    def test_var_in_scope_assumption(self):
+        # Create a pass that clears ir.Scope in ir.Block
+        @register_pass(mutates_CFG=False, analysis_only=False)
+        class RemoveVarInScope(FunctionPass):
+            _name = "_remove_var_in_scope"
+
+            def __init__(self):
+                FunctionPass.__init__(self)
+
+            # implement method to do the work, "state" is the internal compiler
+            # state from the CompilerBase instance.
+            def run_pass(self, state):
+                func_ir = state.func_ir
+                # walk the blocks
+                for blk in func_ir.blocks.values():
+                    oldscope = blk.scope
+                    # put in an empty Scope
+                    blk.scope = ir.Scope(parent=oldscope.parent,
+                                         loc=oldscope.loc)
+                return True
+
+        # Create a pass that always fails, to stop the compiler
+        @register_pass(mutates_CFG=False, analysis_only=False)
+        class FailPass(FunctionPass):
+            _name = "_fail"
+
+            def __init__(self, *args, **kwargs):
+                FunctionPass.__init__(self)
+
+            def run_pass(self, state):
+                # This is unreachable. SSA pass should have raised before this
+                # pass when run with `error.NumbaPedanticWarning`s raised as
+                # errors.
+                raise AssertionError("unreachable")
+
+        class MyCompiler(CompilerBase):
+            def define_pipelines(self):
+                pm = PassManager("testing pm")
+                pm.add_pass(TranslateByteCode, "analyzing bytecode")
+                pm.add_pass(IRProcessing, "processing IR")
+                pm.add_pass(RemoveVarInScope, "_remove_var_in_scope")
+                pm.add_pass(ReconstructSSA, "ssa")
+                pm.add_pass(FailPass, "_fail")
+                pm.finalize()
+                return [pm]
+
+        @njit(pipeline_class=MyCompiler)
+        def dummy(x):
+            # To trigger SSA and the pedantic check, this function must have
+            # multiple assignments to the same variable in different blocks.
+            a = 1
+            b = 2
+            if a < b:
+                a = 2
+            else:
+                b = 3
+            return a, b
+
+        with warnings.catch_warnings():
+            # Make NumbaPedanticWarning an error
+            warnings.simplefilter("error", errors.NumbaPedanticWarning)
+            # Catch NumbaIRAssumptionWarning
+            with self.assertRaises(errors.NumbaIRAssumptionWarning) as raises:
+                dummy(1)
+            # Verify the error message
+            self.assertRegex(
+                str(raises.exception),
+                r"variable '[a-z]' is not in scope",
+            )
+
+
+if __name__ == '__main__':
+    unittest.main()

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

@@ -0,0 +1,146 @@
+import os
+import sys
+import inspect
+import contextlib
+import numpy as np
+import logging
+from io import StringIO
+
+import unittest
+from numba.tests.support import SerialMixin, create_temp_module
+from numba.core import dispatcher
+
+
+@contextlib.contextmanager
+def captured_logs(l):
+    try:
+        buffer = StringIO()
+        handler = logging.StreamHandler(buffer)
+        l.addHandler(handler)
+        yield buffer
+    finally:
+        l.removeHandler(handler)
+
+
+class TestJitModule(SerialMixin, unittest.TestCase):
+
+    source_lines = """
+from numba import jit_module
+
+def inc(x):
+    return x + 1
+
+def add(x, y):
+    return x + y
+
+def inc_add(x):
+    y = inc(x)
+    return add(x, y)
+
+import numpy as np
+mean = np.mean
+
+class Foo(object):
+    pass
+
+jit_module({jit_options})
+"""
+
+    def test_create_temp_jitted_module(self):
+        sys_path_original = list(sys.path)
+        sys_modules_original = dict(sys.modules)
+        with create_temp_module(self.source_lines) as test_module:
+            temp_module_dir = os.path.dirname(test_module.__file__)
+            self.assertEqual(temp_module_dir, sys.path[0])
+            self.assertEqual(sys.path[1:], sys_path_original)
+            self.assertTrue(test_module.__name__ in sys.modules)
+        # Test that modifications to sys.path / sys.modules are reverted
+        self.assertEqual(sys.path, sys_path_original)
+        self.assertEqual(sys.modules, sys_modules_original)
+
+    def test_create_temp_jitted_module_with_exception(self):
+        try:
+            sys_path_original = list(sys.path)
+            sys_modules_original = dict(sys.modules)
+            with create_temp_module(self.source_lines):
+                raise ValueError("Something went wrong!")
+        except ValueError:
+            # Test that modifications to sys.path / sys.modules are reverted
+            self.assertEqual(sys.path, sys_path_original)
+            self.assertEqual(sys.modules, sys_modules_original)
+
+    def test_jit_module(self):
+        with create_temp_module(self.source_lines) as test_module:
+            self.assertIsInstance(test_module.inc, dispatcher.Dispatcher)
+            self.assertIsInstance(test_module.add, dispatcher.Dispatcher)
+            self.assertIsInstance(test_module.inc_add, dispatcher.Dispatcher)
+            self.assertTrue(test_module.mean is np.mean)
+            self.assertTrue(inspect.isclass(test_module.Foo))
+
+            # Test output of jitted functions is as expected
+            x, y = 1.7, 2.3
+            self.assertEqual(test_module.inc(x),
+                             test_module.inc.py_func(x))
+            self.assertEqual(test_module.add(x, y),
+                             test_module.add.py_func(x, y))
+            self.assertEqual(test_module.inc_add(x),
+                             test_module.inc_add.py_func(x))
+
+    def test_jit_module_jit_options(self):
+        jit_options = {"nopython": True,
+                       "nogil": False,
+                       "error_model": "numpy",
+                       "boundscheck": False,
+                       }
+        with create_temp_module(self.source_lines,
+                                **jit_options) as test_module:
+            self.assertEqual(test_module.inc.targetoptions, jit_options)
+
+    def test_jit_module_jit_options_override(self):
+        source_lines = """
+from numba import jit, jit_module
+
+@jit(nogil=True, forceobj=True)
+def inc(x):
+    return x + 1
+
+def add(x, y):
+    return x + y
+
+jit_module({jit_options})
+"""
+        jit_options = {"nopython": True,
+                       "error_model": "numpy",
+                       "boundscheck": False,
+                       }
+        with create_temp_module(source_lines=source_lines,
+                                **jit_options) as test_module:
+            self.assertEqual(test_module.add.targetoptions, jit_options)
+            # Test that manual jit-wrapping overrides jit_module options,
+            # `forceobj` will automatically apply `nopython=False`.
+            self.assertEqual(test_module.inc.targetoptions,
+                             {'nogil': True, 'forceobj': True,
+                              'boundscheck': None, 'nopython': False})
+
+    def test_jit_module_logging_output(self):
+        logger = logging.getLogger('numba.core.decorators')
+        logger.setLevel(logging.DEBUG)
+        jit_options = {"nopython": True,
+                       "error_model": "numpy",
+                       }
+        with captured_logs(logger) as logs:
+            with create_temp_module(self.source_lines,
+                                    **jit_options) as test_module:
+                logs = logs.getvalue()
+                expected = ["Auto decorating function",
+                            "from module {}".format(test_module.__name__),
+                            "with jit and options: {}".format(jit_options)]
+                self.assertTrue(all(i in logs for i in expected))
+
+    def test_jit_module_logging_level(self):
+        logger = logging.getLogger('numba.core.decorators')
+        # Test there's no logging for INFO level
+        logger.setLevel(logging.INFO)
+        with captured_logs(logger) as logs:
+            with create_temp_module(self.source_lines):
+                self.assertEqual(logs.getvalue(), '')

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

@@ -0,0 +1,1652 @@
+""" Tests for the compiler components of the Numba typed-list.
+
+The tests here should exercise everything within an `@njit` context.
+Importantly, the tests should not return a typed list from within such a
+context as this would require code from numba/typed/typedlist.py (this is
+tested separately).  Tests in this file build on each other in the order of
+writing. For example, the first test, tests the creation, append and len of the
+list. These are the barebones to do anything useful with a list. The subsequent
+test for getitem assumes makes use of these three operations and therefore
+assumes that they work.
+
+"""
+
+from textwrap import dedent
+
+from numba import njit
+from numba import int32
+from numba.extending import register_jitable
+from numba.core import types
+from numba.core.errors import TypingError
+from numba.tests.support import (TestCase, MemoryLeakMixin, override_config,
+                                 forbid_codegen)
+from numba.typed import listobject, List
+
+
+class TestCreateAppendLength(MemoryLeakMixin, TestCase):
+    """Test list creation, append and len. """
+
+    def test_list_create(self):
+        @njit
+        def foo(n):
+            l = listobject.new_list(int32)
+            for i in range(n):
+                l.append(i)
+            return len(l)
+
+        for i in (0, 1, 2, 100):
+            self.assertEqual(foo(i), i)
+
+    def test_list_create_no_jit(self):
+        with override_config('DISABLE_JIT', True):
+            with forbid_codegen():
+                l = listobject.new_list(int32)
+                self.assertEqual(type(l), list)
+
+    def test_nonempty_list_create_no_jit(self):
+        # See Issue #6001: https://github.com/numba/numba/issues/6001
+        with override_config('DISABLE_JIT', True):
+            with forbid_codegen():
+                l = List([1, 2, 3])
+                self.assertEqual(type(l), list)
+                self.assertEqual(l, [1, 2, 3])
+
+
+class TestBool(MemoryLeakMixin, TestCase):
+    """Test list bool."""
+
+    def test_list_bool(self):
+        @njit
+        def foo(n):
+            l = listobject.new_list(int32)
+            for i in range(n):
+                l.append(i)
+            return bool(l)
+
+        for i in (0, 1, 2, 100):
+            self.assertEqual(foo(i), i > 0)
+
+
+class TestAllocation(MemoryLeakMixin, TestCase):
+
+    def test_list_allocation(self):
+        @njit
+        def foo_kwarg(n):
+            l = listobject.new_list(int32, allocated=n)
+            return l._allocated()
+
+        for i in range(16):
+            self.assertEqual(foo_kwarg(i), i)
+
+        @njit
+        def foo_posarg(n):
+            l = listobject.new_list(int32, n)
+            return l._allocated()
+        for i in range(16):
+            self.assertEqual(foo_posarg(i), i)
+
+    def test_list_allocation_negative(self):
+        @njit
+        def foo():
+            l = listobject.new_list(int32, -1)
+            return l._allocated()
+
+        with self.assertRaises(RuntimeError) as raises:
+            self.assertEqual(foo(), -1)
+        self.assertIn(
+            "expecting *allocated* to be >= 0",
+            str(raises.exception),
+        )
+
+
+class TestToFromMeminfo(MemoryLeakMixin, TestCase):
+
+    def test_list_to_from_meminfo(self):
+        """
+        Exercise listobject.{_as_meminfo, _from_meminfo}
+        """
+
+        @njit
+        def boxer():
+            l = listobject.new_list(int32)
+            for i in range(10, 20):
+                l.append(i)
+            return listobject._as_meminfo(l)
+
+        lsttype = types.ListType(int32)
+
+        @njit
+        def unboxer(mi):
+            l = listobject._from_meminfo(mi, lsttype)
+            return l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7], l[8], l[9]
+
+        mi = boxer()
+        self.assertEqual(mi.refcount, 1)
+
+        received = list(unboxer(mi))
+        expected = list(range(10, 20))
+        self.assertEqual(received, expected)
+
+
+class TestGetitem(MemoryLeakMixin, TestCase):
+    """Test list getitem. """
+
+    def test_list_getitem_singleton(self):
+        @njit
+        def foo(n):
+            l = listobject.new_list(int32)
+            l.append(n)
+            return l[0]
+
+        self.assertEqual(foo(0), 0)
+
+    def test_list_getitem_singleton_negtive_index(self):
+        @njit
+        def foo(n):
+            l = listobject.new_list(int32)
+            l.append(n)
+            return l[-1]
+
+        self.assertEqual(foo(0), 0)
+
+    def test_list_getitem_multiple(self):
+        @njit
+        def foo(i):
+            l = listobject.new_list(int32)
+            for j in range(10, 20):
+                l.append(j)
+            return l[i]
+
+        for i,j in ((0, 10), (9, 19), (4, 14), (-5, 15), (-1, 19), (-10, 10)):
+            self.assertEqual(foo(i), j)
+
+    def test_list_getitem_empty_index_error(self):
+        self.disable_leak_check()
+
+        @njit
+        def foo(i):
+            l = listobject.new_list(int32)
+            return l[i]
+
+        for i in (1, 0, -1):
+            with self.assertRaises(IndexError) as raises:
+                foo(i)
+            self.assertIn(
+                "list index out of range",
+                str(raises.exception),
+            )
+
+    def test_list_getitem_multiple_index_error(self):
+        self.disable_leak_check()
+
+        @njit
+        def foo(i):
+            l = listobject.new_list(int32)
+            for j in range(10, 20):
+                l.append(j)
+            return l[i]
+
+        for i in (10, -11):
+            with self.assertRaises(IndexError) as raises:
+                foo(i)
+            self.assertIn(
+                "list index out of range",
+                str(raises.exception),
+            )
+
+    def test_list_getitem_empty_typing_error(self):
+        self.disable_leak_check()
+
+        @njit
+        def foo(i):
+            l = listobject.new_list(int32)
+            return l[i]
+
+        for i in "xyz", 1.0, 1j:
+            with self.assertRaises(TypingError) as raises:
+                foo(i)
+            self.assertIn(
+                "list indices must be integers or slices",
+                str(raises.exception),
+            )
+
+    def test_list_getitem_integer_types_as_index(self):
+
+        @njit
+        def foo(i):
+            l = listobject.new_list(int32)
+            l.append(0)
+            return l[i]
+
+        # try all signed integers and make sure they are cast
+        for t in (types.signed_domain
+                  ):
+            self.assertEqual(foo((t(0))), 0)
+
+    def test_list_getitem_different_sized_uint_index(self):
+        # Checks that the index type cast and ext/trunc to the
+        # type of the length is correct, both wraparound and
+        # direct index is tested via -1/0.
+
+        for ty in types.unsigned_domain:
+            @njit
+            def foo():
+                l = listobject.new_list(int32)
+                l.append(7)
+                return l[ty(0)]
+
+            self.assertEqual(foo(), 7)
+
+    def test_list_getitem_different_sized_int_index(self):
+        # Checks that the index type cast and ext/trunc to the
+        # type of the length is correct, both wraparound and
+        # direct index is tested via -1/0.
+
+        for ty in types.signed_domain:
+            @njit
+            def foo():
+                l = listobject.new_list(int32)
+                l.append(7)
+                return l[ty(0)], l[ty(-1)]
+
+            self.assertEqual(foo(), (7, 7))
+
+
+class TestGetitemSlice(MemoryLeakMixin, TestCase):
+    """Test list getitem when indexing with slices. """
+
+    def test_list_getitem_empty_slice_defaults(self):
+        @njit
+        def foo():
+            l = listobject.new_list(int32)
+            n = l[:]
+            return len(n)
+
+        self.assertEqual(foo(), 0)
+
+    def test_list_getitem_singleton_slice_defaults(self):
+        @njit
+        def foo():
+            l = listobject.new_list(int32)
+            l.append(0)
+            n = l[:]
+            return len(n)
+
+        self.assertEqual(foo(), 1)
+
+    def test_list_getitem_multiple_slice_defaults(self):
+        @njit
+        def foo(i):
+            l = listobject.new_list(int32)
+            for j in range(10, 20):
+                l.append(j)
+            n = l[:]
+            return n[i]
+
+        for i,j in ((0, 10), (9, 19), (4, 14), (-5, 15), (-1, 19), (-10, 10)):
+            self.assertEqual(foo(i), j)
+
+    def test_list_getitem_multiple_slice_pos_start(self):
+        @njit
+        def foo():
+            l = listobject.new_list(int32)
+            for j in range(10, 20):
+                l.append(j)
+            n = l[5:]
+            return len(n), (n[0], n[1], n[2], n[3], n[4])
+
+        length, items = foo()
+        self.assertEqual(length, 5)
+        self.assertEqual(items, (15, 16, 17, 18, 19))
+
+    def test_list_getitem_multiple_slice_pos_stop(self):
+        @njit
+        def foo():
+            l = listobject.new_list(int32)
+            for j in range(10, 20):
+                l.append(j)
+            n = l[:5]
+            return len(n), (n[0], n[1], n[2], n[3], n[4])
+
+        length, items = foo()
+        self.assertEqual(length, 5)
+        self.assertEqual(items, (10, 11, 12, 13, 14))
+
+    def test_list_getitem_multiple_slice_pos_start_pos_stop(self):
+        @njit
+        def foo():
+            l = listobject.new_list(int32)
+            for j in range(10, 20):
+                l.append(j)
+            n = l[2:7]
+            return len(n), (n[0], n[1], n[2], n[3], n[4])
+
+        length, items = foo()
+        self.assertEqual(length, 5)
+        self.assertEqual(items, (12, 13, 14, 15, 16))
+
+    def test_list_getitem_multiple_slice_pos_start_pos_stop_pos_step(self):
+        @njit
+        def foo():
+            l = listobject.new_list(int32)
+            for j in range(10, 20):
+                l.append(j)
+            n = l[1:9:2]
+            return len(n), (n[0], n[1], n[2], n[3])
+
+        length, items = foo()
+        self.assertEqual(length, 4)
+        self.assertEqual(items, (11, 13, 15, 17))
+
+    def test_list_getitem_multiple_slice_neg_start(self):
+        @njit
+        def foo():
+            l = listobject.new_list(int32)
+            for j in range(10, 20):
+                l.append(j)
+            n = l[-5:]
+            return len(n), (n[0], n[1], n[2], n[3], n[4])
+
+        length, items = foo()
+        self.assertEqual(length, 5)
+        self.assertEqual(items, (15, 16, 17, 18, 19))
+
+    def test_list_getitem_multiple_slice_neg_stop(self):
+        @njit
+        def foo():
+            l = listobject.new_list(int32)
+            for j in range(10, 20):
+                l.append(j)
+            n = l[:-5]
+            return len(n), (n[0], n[1], n[2], n[3], n[4])
+
+        length, items = foo()
+        self.assertEqual(length, 5)
+        self.assertEqual(items, (10, 11, 12, 13, 14))
+
+    def test_list_getitem_multiple_slice_neg_step(self):
+        @njit
+        def foo():
+            l = listobject.new_list(int32)
+            for j in range(10, 20):
+                l.append(j)
+            n = l[::-2]
+            return len(n), (n[0], n[1], n[2], n[3], n[4])
+
+        length, items = foo()
+        self.assertEqual(length, 5)
+        self.assertEqual(items, (19, 17, 15, 13, 11))
+
+    def test_list_getitem_multiple_slice_pos_start_neg_step(self):
+        @njit
+        def foo():
+            l = listobject.new_list(int32)
+            for j in range(10, 20):
+                l.append(j)
+            n = l[4::-1]
+            return len(n), (n[0], n[1], n[2], n[3], n[4])
+
+        length, items = foo()
+        self.assertEqual(length, 5)
+        self.assertEqual(items, (14, 13, 12, 11, 10))
+
+    def test_list_getitem_multiple_slice_neg_start_neg_step(self):
+        @njit
+        def foo():
+            l = listobject.new_list(int32)
+            for j in range(10, 20):
+                l.append(j)
+            n = l[-6::-1]
+            return len(n), (n[0], n[1], n[2], n[3], n[4])
+
+        length, items = foo()
+        self.assertEqual(length, 5)
+        self.assertEqual(items, (14, 13, 12, 11, 10))
+
+    def test_list_getitem_multiple_slice_pos_stop_neg_step(self):
+        @njit
+        def foo():
+            l = listobject.new_list(int32)
+            for j in range(10, 20):
+                l.append(j)
+            n = l[:4:-1]
+            return len(n), (n[0], n[1], n[2], n[3], n[4])
+
+        length, items = foo()
+        self.assertEqual(length, 5)
+        self.assertEqual(items, (19, 18, 17, 16, 15))
+
+    def test_list_getitem_multiple_slice_neg_stop_neg_step(self):
+        @njit
+        def foo():
+            l = listobject.new_list(int32)
+            for j in range(10, 20):
+                l.append(j)
+            n = l[:-6:-1]
+            return len(n), (n[0], n[1], n[2], n[3], n[4])
+
+        length, items = foo()
+        self.assertEqual(length, 5)
+        self.assertEqual(items, (19, 18, 17, 16, 15))
+
+    def test_list_getitem_multiple_slice_pos_start_pos_stop_neg_step(self):
+        @njit
+        def foo():
+            l = listobject.new_list(int32)
+            for j in range(10, 20):
+                l.append(j)
+            n = l[8:3:-1]
+            return len(n), (n[0], n[1], n[2], n[3], n[4])
+
+        length, items = foo()
+        self.assertEqual(length, 5)
+        self.assertEqual(items, (18, 17, 16, 15, 14))
+
+    def test_list_getitem_multiple_slice_neg_start_neg_stop_neg_step(self):
+        @njit
+        def foo():
+            l = listobject.new_list(int32)
+            for j in range(10, 20):
+                l.append(j)
+            n = l[-2:-7:-1]
+            return len(n), (n[0], n[1], n[2], n[3], n[4])
+
+        length, items = foo()
+        self.assertEqual(length, 5)
+        self.assertEqual(items, (18, 17, 16, 15, 14))
+
+    def test_list_getitem_multiple_slice_start_out_of_range(self):
+        @njit
+        def foo():
+            l = listobject.new_list(int32)
+            for j in range(10, 20):
+                l.append(j)
+            n = l[10:]
+            return len(n)
+
+        self.assertEqual(foo(), 0)
+
+    def test_list_getitem_multiple_slice_stop_zero(self):
+        @njit
+        def foo():
+            l = listobject.new_list(int32)
+            for j in range(10, 20):
+                l.append(j)
+            n = l[:0]
+            return len(n)
+
+        self.assertEqual(foo(), 0)
+
+    def test_list_getitem_multiple_slice_zero_step_index_error(self):
+        self.disable_leak_check()
+
+        @njit
+        def foo():
+            l = listobject.new_list(int32)
+            for j in range(10, 20):
+                l.append(j)
+            l[::0]
+
+        with self.assertRaises(ValueError) as raises:
+            foo()
+        self.assertIn(
+            "slice step cannot be zero",
+            str(raises.exception),
+        )
+
+
+class TestSetitem(MemoryLeakMixin, TestCase):
+    """Test list setitem. """
+
+    def test_list_setitem_singleton(self):
+        @njit
+        def foo(n):
+            l = listobject.new_list(int32)
+            l.append(0)
+            l[0] = n
+            return l[0]
+
+        for i in (0, 1, 2, 100):
+            self.assertEqual(foo(i), i)
+
+    def test_list_setitem_singleton_negative_index(self):
+        @njit
+        def foo(n):
+            l = listobject.new_list(int32)
+            l.append(0)
+            l[0] = n
+            return l[-1]
+
+        for i in (0, 1, 2, 100):
+            self.assertEqual(foo(i), i)
+
+    def test_list_setitem_singleton_index_error(self):
+        self.disable_leak_check()
+
+        @njit
+        def foo(i):
+            l = listobject.new_list(int32)
+            l.append(0)
+            l[i] = 1
+
+        with self.assertRaises(IndexError):
+            foo(1)
+
+        with self.assertRaises(IndexError):
+            foo(-2)
+
+    def test_list_setitem_multiple(self):
+
+        @njit
+        def foo(i, n):
+            l = listobject.new_list(int32)
+            for j in range(10, 20):
+                l.append(j)
+            l[i] = n
+            return l[i]
+
+        for i,n in zip(range(0,10), range(20,30)):
+            self.assertEqual(foo(i, n), n)
+
+    def test_list_setitem_multiple_index_error(self):
+        self.disable_leak_check()
+
+        @njit
+        def foo(i):
+            l = listobject.new_list(int32)
+            for j in range(10, 20):
+                l.append(j)
+            l[i] = 0
+
+        with self.assertRaises(IndexError):
+            foo(10)
+
+        with self.assertRaises(IndexError):
+            foo(-11)
+
+    def test_list_setitem_singleton_typing_error_on_index(self):
+        self.disable_leak_check()
+
+        @njit
+        def foo(i):
+            l = listobject.new_list(int32)
+            l.append(0)
+            # slice with a non-{integer,slice}
+            l[i] = 1
+
+        for i in "xyz", 1.0, 1j:
+            with self.assertRaises(TypingError) as raises:
+                foo(i)
+            self.assertIn(
+                "list indices must be integers or slices",
+                str(raises.exception),
+            )
+
+    def test_list_setitem_singleton_typing_error_on_item(self):
+        self.disable_leak_check()
+
+        @njit
+        def foo():
+            l = listobject.new_list(int32)
+            l.append(0)
+            # assign a non-iterable to a slice
+            l[:] = 1
+
+        with self.assertRaises(TypingError) as raises:
+            foo()
+        self.assertIn(
+            "can only assign an iterable when using a slice "
+            "with assignment/setitem",
+            str(raises.exception),
+        )
+
+    def test_list_setitem_integer_types_as_index(self):
+
+        @njit
+        def foo(i):
+            l = listobject.new_list(int32)
+            l.append(0)
+            l[i] = 1
+            return l[i]
+
+        # try all signed integers and make sure they are cast
+        for t in (types.signed_domain
+                  ):
+            self.assertEqual(foo((t(0))), 1)
+
+
+class TestPop(MemoryLeakMixin, TestCase):
+    """Test list pop. """
+
+    def test_list_pop_singleton(self):
+        @njit
+        def foo():
+            l = listobject.new_list(int32)
+            l.append(0)
+            return l.pop(), len(l)
+
+        self.assertEqual(foo(), (0, 0))
+
+    def test_list_pop_singleton_index(self):
+        @njit
+        def foo(i):
+            l = listobject.new_list(int32)
+            l.append(0)
+            return l.pop(i), len(l)
+
+        self.assertEqual(foo(0), (0, 0))
+        self.assertEqual(foo(-1), (0, 0))
+
+    def test_list_pop_multiple(self):
+        @njit
+        def foo():
+            l = listobject.new_list(int32)
+            for j in (10, 11, 12):
+                l.append(j)
+            return l.pop(), len(l)
+
+        self.assertEqual(foo(), (12, 2))
+
+    def test_list_pop_multiple_index(self):
+        @njit
+        def foo(i):
+            l = listobject.new_list(int32)
+            for j in (10, 11, 12):
+                l.append(j)
+            return l.pop(i), len(l)
+
+        for i, n in ((0, 10), (1, 11), (2, 12)):
+            self.assertEqual(foo(i), (n, 2))
+
+        for i, n in ((-3, 10), (-2, 11), (-1, 12)):
+            self.assertEqual(foo(i), (n, 2))
+
+    def test_list_pop_integer_types_as_index(self):
+
+        @njit
+        def foo(i):
+            l = listobject.new_list(int32)
+            l.append(0)
+            return l.pop(i)
+
+        # try all signed integers and make sure they are cast
+        for t in (types.signed_domain
+                  ):
+            self.assertEqual(foo((t(0))), 0)
+
+    def test_list_pop_empty_index_error_no_index(self):
+        self.disable_leak_check()
+
+        @njit
+        def foo():
+            l = listobject.new_list(int32)
+            l.pop()
+
+        with self.assertRaises(IndexError) as raises:
+            foo()
+        self.assertIn(
+            "pop from empty list",
+            str(raises.exception),
+        )
+
+    def test_list_pop_empty_index_error_with_index(self):
+        self.disable_leak_check()
+
+        @njit
+        def foo(i):
+            l = listobject.new_list(int32)
+            l.pop(i)
+
+        with self.assertRaises(IndexError) as raises:
+            foo(-1)
+        self.assertIn(
+            "pop from empty list",
+            str(raises.exception),
+        )
+
+        with self.assertRaises(IndexError) as raises:
+            foo(0)
+        self.assertIn(
+            "pop from empty list",
+            str(raises.exception),
+        )
+
+        with self.assertRaises(IndexError) as raises:
+            foo(1)
+        self.assertIn(
+            "pop from empty list",
+            str(raises.exception),
+        )
+
+    def test_list_pop_mutiple_index_error_with_index(self):
+        self.disable_leak_check()
+
+        @njit
+        def foo(i):
+            l = listobject.new_list(int32)
+            for j in (10, 11, 12):
+                l.append(j)
+            l.pop(i)
+
+        with self.assertRaises(IndexError) as raises:
+            foo(-4)
+        self.assertIn(
+            "list index out of range",
+            str(raises.exception),
+        )
+
+        with self.assertRaises(IndexError) as raises:
+            foo(3)
+        self.assertIn(
+            "list index out of range",
+            str(raises.exception),
+        )
+
+    def test_list_pop_singleton_typing_error_on_index(self):
+        self.disable_leak_check()
+
+        @njit
+        def foo(i):
+            l = listobject.new_list(int32)
+            l.append(0)
+            # slice with a non-{integer,slice}
+            return l.pop(i)
+
+        for i in "xyz", 1.0, 1j:
+            with self.assertRaises(TypingError) as raises:
+                foo(i)
+            self.assertIn(
+                "argument for pop must be an integer",
+                str(raises.exception),
+            )
+
+
+class TestListObjectDelitem(MemoryLeakMixin, TestCase):
+    """Test list delitem.
+    """
+
+    def test_list_singleton_delitem_index(self):
+
+        @njit
+        def foo():
+            l = listobject.new_list(int32)
+            l.append(0)
+            del l[0]
+            return len(l)
+        self.assertEqual(foo(), 0)
+
+    def test_list_singleton_delitem_slice_defaults(self):
+
+        @njit
+        def foo():
+            l = listobject.new_list(int32)
+            l.append(0)
+            del l[:]
+            return len(l)
+        self.assertEqual(foo(), 0)
+
+    def test_list_singleton_delitem_slice_start(self):
+
+        @njit
+        def foo():
+            l = listobject.new_list(int32)
+            l.append(0)
+            del l[0:]
+            return len(l)
+        self.assertEqual(foo(), 0)
+
+    def test_list_singleton_delitem_slice_stop(self):
+
+        @njit
+        def foo():
+            l = listobject.new_list(int32)
+            l.append(0)
+            del l[:1]
+            return len(l)
+        self.assertEqual(foo(), 0)
+
+    def test_list_singleton_delitem_slice_start_stop(self):
+
+        @njit
+        def foo():
+            l = listobject.new_list(int32)
+            l.append(0)
+            del l[0:1]
+            return len(l)
+        self.assertEqual(foo(), 0)
+
+    def test_list_singleton_delitem_slice_start_step(self):
+
+        @njit
+        def foo():
+            l = listobject.new_list(int32)
+            l.append(0)
+            del l[0::1]
+            return len(l)
+        self.assertEqual(foo(), 0)
+
+    def test_list_singleton_delitem_slice_start_stop_step(self):
+
+        @njit
+        def foo():
+            l = listobject.new_list(int32)
+            l.append(0)
+            del l[0:1:1]
+            return len(l)
+        self.assertEqual(foo(), 0)
+
+    def test_list_multiple_delitem(self):
+
+        @njit
+        def foo():
+            l = listobject.new_list(int32)
+            for j in (10, 11, 12):
+                l.append(j)
+            del l[0]
+            return len(l), l[0], l[1]
+        self.assertEqual(foo(), (2, 11, 12))
+
+    def test_list_multiple_delitem_slice(self):
+
+        @njit
+        def foo():
+            l = listobject.new_list(int32)
+            for j in (10, 11, 12):
+                l.append(j)
+            del l[:]
+            return len(l)
+        self.assertEqual(foo(), 0)
+
+    def test_list_multiple_delitem_off_by_one(self):
+        # this was exposing a nasty off-by-one error, leaving it in to detect
+        # and regressions
+        @njit
+        def foo():
+            l = listobject.new_list(int32)
+            for j in range(10, 20):
+                l.append(j)
+            k = listobject.new_list(int32)
+            for j in range(10, 20):
+                k.append(j)
+            # should be a no-op
+            del l[-9:-20]
+            return k == l
+        self.assertTrue(foo())
+
+
+class TestContains(MemoryLeakMixin, TestCase):
+    """Test list contains. """
+
+    def test_list_contains_empty(self):
+        @njit
+        def foo(i):
+            l = listobject.new_list(int32)
+            return i in l
+
+        self.assertFalse(foo(0))
+        self.assertFalse(foo(1))
+
+    def test_list_contains_singleton(self):
+        @njit
+        def foo(i):
+            l = listobject.new_list(int32)
+            l.append(0)
+            return i in l
+
+        self.assertTrue(foo(0))
+        self.assertFalse(foo(1))
+
+    def test_list_contains_multiple(self):
+        @njit
+        def foo(i):
+            l = listobject.new_list(int32)
+            for j in range(10, 20):
+                l.append(j)
+            return i in l
+
+        for i in range(10, 20):
+            self.assertTrue(foo(i))
+
+        for i in range(20, 30):
+            self.assertFalse(foo(i))
+
+
+class TestCount(MemoryLeakMixin, TestCase):
+    """Test list count. """
+
+    def test_list_count_empty(self):
+        @njit
+        def foo(i):
+            l = listobject.new_list(int32)
+            return l.count(i)
+
+        self.assertEqual(foo(10), 0)
+
+    def test_list_count_singleton(self):
+        @njit
+        def foo(i):
+            l = listobject.new_list(int32)
+            l.append(10)
+            return l.count(i)
+
+        self.assertEqual(foo(1), 0)
+        self.assertEqual(foo(10), 1)
+
+    def test_list_count_mutiple(self):
+        @njit
+        def foo(i):
+            l = listobject.new_list(int32)
+            for j in [11, 12, 12, 13, 13, 13]:
+                l.append(j)
+            return l.count(i)
+
+        self.assertEqual(foo(10), 0)
+        self.assertEqual(foo(11), 1)
+        self.assertEqual(foo(12), 2)
+        self.assertEqual(foo(13), 3)
+
+
+class TestExtend(MemoryLeakMixin, TestCase):
+    """Test list extend. """
+
+    def test_list_extend_empty(self):
+        @njit
+        def foo(items):
+            l = listobject.new_list(int32)
+            l.extend(items)
+            return len(l)
+
+        self.assertEqual(foo((1,)), 1)
+        self.assertEqual(foo((1,2)), 2)
+        self.assertEqual(foo((1,2,3)), 3)
+
+    def test_list_extend_typing_error_non_iterable(self):
+        self.disable_leak_check()
+
+        @njit
+        def foo():
+            l = listobject.new_list(int32)
+            l.extend(1)
+
+        with self.assertRaises(TypingError) as raises:
+            foo()
+        self.assertIn(
+            "extend argument must be iterable",
+            str(raises.exception),
+        )
+
+
+class TestInsert(MemoryLeakMixin, TestCase):
+    """Test list insert. """
+
+    def test_list_insert_empty(self):
+        @njit
+        def foo(i):
+            l = listobject.new_list(int32)
+            l.insert(i, 1)
+            return len(l), l[0]
+
+        for i in (-10, -5, -1, 0, 1, 4, 9):
+            self.assertEqual(foo(i), (1, 1))
+
+    def test_list_insert_singleton(self):
+        @njit
+        def foo(i):
+            l = listobject.new_list(int32)
+            l.append(0)
+            l.insert(i, 1)
+            return len(l), l[0], l[1]
+
+        # insert before
+        for i in (-10, -3, -2, -1, 0):
+            self.assertEqual(foo(i), (2, 1, 0))
+
+        # insert after
+        for i in (1, 2, 3, 10):
+            self.assertEqual(foo(i), (2, 0, 1))
+
+    def test_list_insert_multiple(self):
+        @njit
+        def foo(i):
+            l = listobject.new_list(int32)
+            for j in range(10):
+                l.append(0)
+            l.insert(i, 1)
+            return len(l), l[i]
+
+        for i in (0, 4, 9):
+            self.assertEqual(foo(i), (11, 1))
+
+    def test_list_insert_multiple_before(self):
+        @njit
+        def foo(i):
+            l = listobject.new_list(int32)
+            for j in range(10):
+                l.append(0)
+            l.insert(i, 1)
+            return len(l), l[0]
+
+        for i in (-12, -11, -10, 0):
+            self.assertEqual(foo(i), (11, 1))
+
+    def test_list_insert_multiple_after(self):
+        @njit
+        def foo(i):
+            l = listobject.new_list(int32)
+            for j in range(10):
+                l.append(0)
+            l.insert(i, 1)
+            return len(l), l[10]
+
+        for i in (10, 11, 12):
+            self.assertEqual(foo(i), (11, 1))
+
+    def test_list_insert_typing_error(self):
+        self.disable_leak_check()
+
+        @njit
+        def foo():
+            l = listobject.new_list(int32)
+            l.insert("a", 0)
+
+        with self.assertRaises(TypingError) as raises:
+            foo()
+        self.assertIn(
+            "list insert indices must be integers",
+            str(raises.exception),
+        )
+
+
+class TestRemove(MemoryLeakMixin, TestCase):
+    """Test list remove. """
+
+    def test_list_remove_empty(self):
+        self.disable_leak_check()
+
+        @njit
+        def foo():
+            l = listobject.new_list(int32)
+            l.remove(0)
+
+        with self.assertRaises(ValueError):
+            foo()
+
+    def test_list_remove_singleton(self):
+        @njit
+        def foo():
+            l = listobject.new_list(int32)
+            l.append(0)
+            l.remove(0)
+            return len(l)
+
+        self.assertEqual(foo(), 0)
+
+    def test_list_remove_singleton_value_error(self):
+        self.disable_leak_check()
+
+        @njit
+        def foo():
+            l = listobject.new_list(int32)
+            l.append(1)
+            l.remove(0)
+
+        with self.assertRaises(ValueError):
+            foo()
+
+    def test_list_remove_multiple(self):
+        @njit
+        def foo():
+            l = listobject.new_list(int32)
+            for j in range(10, 20):
+                l.append(j)
+            l.remove(13)
+            l.remove(19)
+            return len(l)
+
+        self.assertEqual(foo(), 8)
+
+    def test_list_remove_multiple_value_error(self):
+        self.disable_leak_check()
+
+        @njit
+        def foo():
+            l = listobject.new_list(int32)
+            for j in range(10, 20):
+                l.append(j)
+            l.remove(23)
+
+        with self.assertRaises(ValueError):
+            foo()
+
+
+class TestClear(MemoryLeakMixin, TestCase):
+    """Test list clear. """
+
+    def test_list_clear_empty(self):
+        @njit
+        def foo():
+            l = listobject.new_list(int32)
+            l.clear()
+            return len(l)
+
+        self.assertEqual(foo(), 0)
+
+    def test_list_clear_singleton(self):
+        @njit
+        def foo():
+            l = listobject.new_list(int32)
+            l.append(0)
+            l.clear()
+            return len(l)
+
+        self.assertEqual(foo(), 0)
+
+    def test_list_clear_multiple(self):
+        @njit
+        def foo():
+            l = listobject.new_list(int32)
+            for j in range(10):
+                l.append(0)
+            l.clear()
+            return len(l)
+        self.assertEqual(foo(), 0)
+
+
+class TestReverse(MemoryLeakMixin, TestCase):
+    """Test list reverse. """
+
+    def test_list_reverse_empty(self):
+        @njit
+        def foo():
+            l = listobject.new_list(int32)
+            l.reverse()
+            return len(l)
+
+        self.assertEqual(foo(), 0)
+
+    def test_list_reverse_singleton(self):
+        @njit
+        def foo():
+            l = listobject.new_list(int32)
+            l.append(0)
+            l.reverse()
+            return len(l), l[0]
+
+        self.assertEqual(foo(), (1, 0))
+
+    def test_list_reverse_multiple(self):
+        @njit
+        def foo():
+            l = listobject.new_list(int32)
+            for j in range(10, 13):
+                l.append(j)
+            l.reverse()
+            return len(l), l[0], l[1], l[2]
+        self.assertEqual(foo(), (3, 12, 11, 10))
+
+
+class TestCopy(MemoryLeakMixin, TestCase):
+    """Test list copy. """
+
+    def test_list_copy_empty(self):
+        @njit
+        def foo():
+            l = listobject.new_list(int32)
+            n = l.copy()
+            return len(l), len(n)
+
+        self.assertEqual(foo(), (0, 0))
+
+    def test_list_copy_singleton(self):
+        @njit
+        def foo():
+            l = listobject.new_list(int32)
+            l.append(0)
+            n = l.copy()
+            return len(l), len(n), l[0], n[0]
+
+        self.assertEqual(foo(), (1, 1, 0, 0))
+
+    def test_list_copy_multiple(self):
+        @njit
+        def foo():
+            l = listobject.new_list(int32)
+            for j in range(10, 13):
+                l.append(j)
+            n = l.copy()
+            return len(l), len(n), l[0], l[1], l[2], l[0], l[1], l[2]
+
+        self.assertEqual(foo(), (3, 3, 10, 11, 12, 10, 11, 12))
+
+
+class TestIndex(MemoryLeakMixin, TestCase):
+
+    def test_index_singleton(self):
+        @njit
+        def foo():
+            l = listobject.new_list(int32)
+            l.append(1)
+            return l.index(1)
+
+        self.assertEqual(foo(), 0)
+
+    def test_index_multiple(self):
+        @njit
+        def foo(i):
+            l = listobject.new_list(int32)
+            for j in range(10, 20):
+                l.append(j)
+            return l.index(i)
+
+        for i,v in zip(range(10), range(10,20)):
+            self.assertEqual(foo(v), i)
+
+    def test_index_duplicate(self):
+        @njit
+        def foo():
+            l = listobject.new_list(int32)
+            for _ in range(10, 20):
+                l.append(1)
+            return l.index(1)
+
+        self.assertEqual(foo(), 0)
+
+    def test_index_duplicate_with_start(self):
+        @njit
+        def foo(start):
+            l = listobject.new_list(int32)
+            for _ in range(10, 20):
+                l.append(1)
+            return l.index(1, start)
+
+        for i in range(10):
+            self.assertEqual(foo(i), i)
+
+    def test_index_singleton_value_error(self):
+        self.disable_leak_check()
+
+        @njit
+        def foo():
+            l = listobject.new_list(int32)
+            l.append(0)
+            return l.index(1)
+
+        with self.assertRaises(ValueError) as raises:
+            foo()
+        self.assertIn(
+            "item not in list",
+            str(raises.exception),
+        )
+
+    def test_index_multiple_value_error(self):
+        self.disable_leak_check()
+
+        @njit
+        def foo():
+            l = listobject.new_list(int32)
+            for j in range(10, 20):
+                l.append(j)
+            return l.index(23)
+
+        with self.assertRaises(ValueError) as raises:
+            foo()
+        self.assertIn(
+            "item not in list",
+            str(raises.exception),
+        )
+
+    def test_index_multiple_value_error_start(self):
+        self.disable_leak_check()
+
+        @njit
+        def foo(start):
+            l = listobject.new_list(int32)
+            for j in range(10, 20):
+                l.append(j)
+            return l.index(10, start)
+
+        self.assertEqual(foo(0), 0)
+        for i in range(1,10):
+            with self.assertRaises(ValueError) as raises:
+                foo(i)
+            self.assertIn(
+                "item not in list",
+                str(raises.exception),
+            )
+
+    def test_index_multiple_value_error_end(self):
+        self.disable_leak_check()
+
+        @njit
+        def foo(end):
+            l = listobject.new_list(int32)
+            for j in range(10, 20):
+                l.append(j)
+            return l.index(19, 0, end)
+
+        self.assertEqual(foo(10), 9)
+        for i in range(0,9):
+            with self.assertRaises(ValueError) as raises:
+                foo(i)
+            self.assertIn(
+                "item not in list",
+                str(raises.exception),
+            )
+
+    def test_index_typing_error_start(self):
+        self.disable_leak_check()
+
+        @njit
+        def foo():
+            l = listobject.new_list(int32)
+            l.append(0)
+            return l.index(0, start="a")
+
+        with self.assertRaises(TypingError) as raises:
+            foo()
+        self.assertIn(
+            "start argument for index must be an integer",
+            str(raises.exception),
+        )
+
+    def test_index_typing_error_end(self):
+        self.disable_leak_check()
+
+        @njit
+        def foo():
+            l = listobject.new_list(int32)
+            l.append(0)
+            return l.index(0, end="a")
+
+        with self.assertRaises(TypingError) as raises:
+            foo()
+        self.assertIn(
+            "end argument for index must be an integer",
+            str(raises.exception),
+        )
+
+
+class TestEqualNotEqual(MemoryLeakMixin, TestCase):
+    """Test list equal and not equal. """
+
+    def test_list_empty_equal(self):
+        @njit
+        def foo():
+            t = listobject.new_list(int32)
+            o = listobject.new_list(int32)
+            return t == o, t != o
+
+        self.assertEqual(foo(), (True, False))
+
+    def test_list_singleton_equal(self):
+        @njit
+        def foo():
+            t = listobject.new_list(int32)
+            t.append(0)
+            o = listobject.new_list(int32)
+            o.append(0)
+            return t == o, t != o
+
+        self.assertEqual(foo(), (True, False))
+
+    def test_list_singleton_not_equal(self):
+        @njit
+        def foo():
+            t = listobject.new_list(int32)
+            t.append(0)
+            o = listobject.new_list(int32)
+            o.append(1)
+            return t == o, t != o
+
+        self.assertEqual(foo(), (False, True))
+
+    def test_list_length_mismatch(self):
+        @njit
+        def foo():
+            t = listobject.new_list(int32)
+            t.append(0)
+            o = listobject.new_list(int32)
+            return t == o, t != o
+
+        self.assertEqual(foo(), (False, True))
+
+    def test_list_multiple_equal(self):
+        @njit
+        def foo():
+            t = listobject.new_list(int32)
+            o = listobject.new_list(int32)
+            for i in range(10):
+                t.append(i)
+                o.append(i)
+            return t == o, t != o
+
+        self.assertEqual(foo(), (True, False))
+
+    def test_list_multiple_not_equal(self):
+        @njit
+        def foo():
+            t = listobject.new_list(int32)
+            o = listobject.new_list(int32)
+            for i in range(10):
+                t.append(i)
+                o.append(i)
+            o[-1] = 42
+            return t == o, t != o
+
+        self.assertEqual(foo(), (False, True))
+
+
+class TestIter(MemoryLeakMixin, TestCase):
+    """Test list iter. """
+
+    def test_list_iter(self):
+        @njit
+        def foo(items):
+            l = listobject.new_list(int32)
+            l.extend(items)
+            # use a simple sum to check this w/o having to return a list
+            r = 0
+            for j in l:
+                r += j
+            return r
+
+        items = (1, 2, 3, 4)
+
+        self.assertEqual(
+            foo(items),
+            sum(items)
+        )
+
+    def test_list_iter_self_mutation(self):
+        self.disable_leak_check()
+
+        @njit
+        def foo():
+            l = listobject.new_list(int32)
+            l.extend((1, 2, 3, 4))
+            for i in l:
+                l.append(i)
+
+        with self.assertRaises(RuntimeError) as raises:
+            foo()
+        self.assertIn(
+            'list was mutated during iteration'.format(**locals()),
+            str(raises.exception),
+        )
+
+
+class TestStringItem(MemoryLeakMixin, TestCase):
+    """Test list can take strings as items. """
+
+    def test_string_item(self):
+        @njit
+        def foo():
+            l = listobject.new_list(types.unicode_type)
+            l.append('a')
+            l.append('b')
+            l.append('c')
+            l.append('d')
+            return l[0], l[1], l[2], l[3]
+
+        items = foo()
+        self.assertEqual(['a', 'b', 'c', 'd'], list(items))
+
+
+class TestItemCasting(TestCase):
+
+    @njit
+    def foo(fromty, toty):
+        l = listobject.new_list(toty)
+        l.append(fromty(0))
+
+    def check_good(self, fromty, toty):
+        TestItemCasting.foo(fromty, toty)
+
+    def check_bad(self, fromty, toty):
+        with self.assertRaises(TypingError) as raises:
+            TestItemCasting.foo(fromty, toty)
+        self.assertIn(
+            'cannot safely cast {fromty} to {toty}'.format(**locals()),
+            str(raises.exception),
+        )
+
+    def test_cast_int_to(self):
+        self.check_good(types.int32, types.float32)
+        self.check_good(types.int32, types.float64)
+        self.check_good(types.int32, types.complex128)
+        self.check_good(types.int64, types.complex128)
+        self.check_bad(types.int32, types.complex64)
+        self.check_good(types.int8, types.complex64)
+
+    def test_cast_float_to(self):
+        self.check_good(types.float32, types.float64)
+        self.check_good(types.float32, types.complex64)
+        self.check_good(types.float64, types.complex128)
+
+    def test_cast_bool_to(self):
+        self.check_good(types.boolean, types.int32)
+        self.check_good(types.boolean, types.float64)
+        self.check_good(types.boolean, types.complex128)
+
+    def test_cast_fail_unicode_int(self):
+
+        @njit
+        def foo():
+            l = listobject.new_list(int32)
+            l.append("xyz")
+
+        with self.assertRaises(TypingError) as raises:
+            foo()
+        self.assertIn(
+            'cannot safely cast unicode_type to int32',
+            str(raises.exception),
+        )
+
+    def test_cast_fail_int_unicode(self):
+
+        @njit
+        def foo():
+            l = listobject.new_list(types.unicode_type)
+            l.append(int32(0))
+
+        with self.assertRaises(TypingError) as raises:
+            foo()
+        self.assertIn(
+            'Cannot cast int32 to unicode_type',
+            str(raises.exception),
+        )
+
+
+@register_jitable
+def make_test_list():
+    l = listobject.new_list(int32)
+    l.append(int32(1))
+    return l
+
+
+class TestImmutable(MemoryLeakMixin, TestCase):
+
+    def test_is_immutable(self):
+        @njit
+        def foo():
+            l = make_test_list()
+            return l._is_mutable()
+        self.assertTrue(foo())
+
+    def test_make_immutable_is_immutable(self):
+        @njit
+        def foo():
+            l = make_test_list()
+            l._make_immutable()
+            return l._is_mutable()
+        self.assertFalse(foo())
+
+    def test_length_still_works_when_immutable(self):
+        @njit
+        def foo():
+            l = make_test_list()
+            l._make_immutable()
+            return len(l),l._is_mutable()
+        length, mutable = foo()
+        self.assertEqual(length, 1)
+        self.assertFalse(mutable)
+
+    def test_getitem_still_works_when_immutable(self):
+        @njit
+        def foo():
+            l = make_test_list()
+            l._make_immutable()
+            return l[0], l._is_mutable()
+        test_item, mutable = foo()
+        self.assertEqual(test_item, 1)
+        self.assertFalse(mutable)
+
+    def test_append_fails(self):
+        self.disable_leak_check()
+
+        @njit
+        def foo():
+            l = make_test_list()
+            l._make_immutable()
+            l.append(int32(1))
+        with self.assertRaises(ValueError) as raises:
+            foo()
+        self.assertIn(
+            'list is immutable',
+            str(raises.exception),
+        )
+
+    def test_mutation_fails(self):
+        """ Test that any attempt to mutate an immutable typed list fails. """
+        self.disable_leak_check()
+
+        def generate_function(line):
+            context = {}
+            exec(dedent("""
+                from numba.typed import listobject
+                from numba import int32
+                def bar():
+                    lst = listobject.new_list(int32)
+                    lst.append(int32(1))
+                    lst._make_immutable()
+                    zero = int32(0)
+                    {}
+                """.format(line)), context)
+            return njit(context["bar"])
+        for line in ("lst.append(zero)",
+                     "lst[0] = zero",
+                     "lst.pop()",
+                     "del lst[0]",
+                     "lst.extend((zero,))",
+                     "lst.insert(0, zero)",
+                     "lst.clear()",
+                     "lst.reverse()",
+                     "lst.sort()",
+                     ):
+            foo = generate_function(line)
+            with self.assertRaises(ValueError) as raises:
+                foo()
+            self.assertIn(
+                "list is immutable",
+                str(raises.exception),
+            )

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

@@ -0,0 +1,400 @@
+import numpy as np
+
+import numba
+import unittest
+from numba.tests.support import TestCase
+from numba import njit
+from numba.core import types, errors, cgutils
+from numba.core.typing import signature
+from numba.core.datamodel import models
+from numba.core.extending import (
+    overload, SentryLiteralArgs, overload_method, register_model, intrinsic,
+)
+from numba.misc.special import literally
+
+
+class TestLiteralDispatch(TestCase):
+    def check_literal_basic(self, literal_args):
+        @njit
+        def foo(x):
+            return literally(x)
+
+        # Test with int
+        for lit in literal_args:
+            self.assertEqual(foo(lit), lit)
+
+        for lit, sig in zip(literal_args, foo.signatures):
+            self.assertEqual(sig[0].literal_value, lit)
+
+    def test_literal_basic(self):
+        self.check_literal_basic([123, 321])
+        self.check_literal_basic(["abc", "cb123"])
+
+    def test_literal_nested(self):
+        @njit
+        def foo(x):
+            return literally(x) * 2
+
+        @njit
+        def bar(y, x):
+            return foo(y) + x
+
+        y, x = 3, 7
+        self.assertEqual(bar(y, x), y * 2 + x)
+        [foo_sig] = foo.signatures
+        self.assertEqual(foo_sig[0], types.literal(y))
+        [bar_sig] = bar.signatures
+        self.assertEqual(bar_sig[0], types.literal(y))
+        self.assertNotIsInstance(bar_sig[1], types.Literal)
+
+    def test_literally_freevar(self):
+        # Try referring to numba.literally not in the globals
+        import numba
+
+        @njit
+        def foo(x):
+            return numba.literally(x)
+
+        self.assertEqual(foo(123), 123)
+        self.assertEqual(foo.signatures[0][0], types.literal(123))
+
+    def test_mutual_recursion_literal(self):
+        def get_functions(decor):
+            @decor
+            def outer_fac(n, value):
+                if n < 1:
+                    return value
+                return n * inner_fac(n - 1, value)
+
+            @decor
+            def inner_fac(n, value):
+                if n < 1:
+                    return literally(value)
+                return n * outer_fac(n - 1, value)
+
+            return outer_fac, inner_fac
+
+        ref_outer_fac, ref_inner_fac = get_functions(lambda x: x)
+        outer_fac, inner_fac = get_functions(njit)
+
+        self.assertEqual(outer_fac(10, 12), ref_outer_fac(10, 12))
+        self.assertEqual(outer_fac.signatures[0][1].literal_value, 12)
+        self.assertEqual(inner_fac.signatures[0][1].literal_value, 12)
+
+        self.assertEqual(inner_fac(11, 13), ref_inner_fac(11, 13))
+        self.assertEqual(outer_fac.signatures[1][1].literal_value, 13)
+        self.assertEqual(inner_fac.signatures[1][1].literal_value, 13)
+
+    def test_literal_nested_multi_arg(self):
+        @njit
+        def foo(a, b, c):
+            return inner(a, c)
+
+        @njit
+        def inner(x, y):
+            return x + literally(y)
+
+        kwargs = dict(a=1, b=2, c=3)
+        got = foo(**kwargs)
+        expect = (lambda a, b, c: a + c)(**kwargs)
+        self.assertEqual(got, expect)
+        [foo_sig] = foo.signatures
+        self.assertEqual(foo_sig[2], types.literal(3))
+
+    def test_unsupported_literal_type(self):
+        @njit
+        def foo(a, b, c):
+            return inner(a, c)
+
+        @njit
+        def inner(x, y):
+            return x + literally(y)
+
+        arr = np.arange(10)
+        with self.assertRaises(errors.LiteralTypingError) as raises:
+            foo(a=1, b=2, c=arr)
+        self.assertIn("numpy.ndarray", str(raises.exception))
+
+    def test_biliteral(self):
+        # Test usecase with more than one literal call
+        @njit
+        def foo(a, b, c):
+            return inner(a, b) + inner(b, c)
+
+        @njit
+        def inner(x, y):
+            return x + literally(y)
+
+        kwargs = dict(a=1, b=2, c=3)
+        got = foo(**kwargs)
+        expect = (lambda a, b, c: a + b + b + c)(**kwargs)
+        self.assertEqual(got, expect)
+        [(type_a, type_b, type_c)] = foo.signatures
+        self.assertNotIsInstance(type_a, types.Literal)
+        self.assertIsInstance(type_b, types.Literal)
+        self.assertEqual(type_b.literal_value, 2)
+        self.assertIsInstance(type_c, types.Literal)
+        self.assertEqual(type_c.literal_value, 3)
+
+    def test_literally_varargs(self):
+        @njit
+        def foo(a, *args):
+            return literally(args)
+
+        with self.assertRaises(errors.LiteralTypingError):
+            foo(1, 2, 3)
+
+        @njit
+        def bar(a, b):
+            foo(a, b)
+
+        with self.assertRaises(errors.TypingError) as raises:
+            bar(1, 2)
+        self.assertIn(
+            "Cannot request literal type",
+            str(raises.exception),
+        )
+
+    @unittest.expectedFailure
+    def test_literally_defaults(self):
+        # Problem with OmittedArg
+        @njit
+        def foo(a, b=1):
+            return (a, literally(b))
+        foo(a=1)
+
+    @unittest.expectedFailure
+    def test_literally_defaults_inner(self):
+        # Problem with Omitted
+        @njit
+        def foo(a, b=1):
+            return (a, literally(b))
+
+        @njit
+        def bar(a):
+            return foo(a) + 1
+
+        bar(1)
+
+    def test_literally_from_module(self):
+        # Problem with Omitted
+        @njit
+        def foo(x):
+            return numba.literally(x)
+
+        got = foo(123)
+        self.assertEqual(got, foo.py_func(123))
+        self.assertIsInstance(foo.signatures[0][0], types.Literal)
+
+    def test_non_literal(self):
+        @njit
+        def foo(a, b):
+            return literally(1 + a)
+
+        with self.assertRaises(errors.TypingError) as raises:
+            foo(1, 2)
+        self.assertIn(
+            "Invalid use of non-Literal type",
+            str(raises.exception),
+        )
+
+    def test_inlined_literal(self):
+        # Check that literally accepts inlined literal
+        @njit
+        def foo(a, b):
+            v = 1000
+            return a + literally(v) + literally(b)
+
+        got = foo(1, 2)
+        self.assertEqual(got, foo.py_func(1, 2))
+
+        @njit
+        def bar():
+            a = 100
+            b = 9
+            return foo(a=b, b=a)
+
+        got = bar()
+        self.assertEqual(got, bar.py_func())
+
+    def test_aliased_variable(self):
+        @njit
+        def foo(a, b, c):
+            def closure(d):
+                return literally(d) + 10 * inner(a, b)
+            # The inlining of the closure will create an alias to c
+            return closure(c)
+
+        @njit
+        def inner(x, y):
+            return x + literally(y)
+
+        kwargs = dict(a=1, b=2, c=3)
+        got = foo(**kwargs)
+        expect = (lambda a, b, c: c + 10 * (a + b))(**kwargs)
+        self.assertEqual(got, expect)
+        [(type_a, type_b, type_c)] = foo.signatures
+        self.assertNotIsInstance(type_a, types.Literal)
+        self.assertIsInstance(type_b, types.Literal)
+        self.assertEqual(type_b.literal_value, 2)
+        self.assertIsInstance(type_c, types.Literal)
+        self.assertEqual(type_c.literal_value, 3)
+
+    def test_overload_explicit(self):
+        # This test represents a more controlled usage with ensuring literal
+        # typing for an argument.
+        def do_this(x, y):
+            return x + y
+
+        @overload(do_this)
+        def ov_do_this(x, y):
+            SentryLiteralArgs(['x']).for_function(ov_do_this).bind(x, y)
+            return lambda x, y: x + y
+
+        @njit
+        def foo(a, b):
+            return do_this(a, b)
+
+        a = 123
+        b = 321
+        r = foo(a, b)
+        self.assertEqual(r, a + b)
+        [type_a, type_b] = foo.signatures[0]
+        self.assertIsInstance(type_a, types.Literal)
+        self.assertEqual(type_a.literal_value, a)
+        self.assertNotIsInstance(type_b, types.Literal)
+
+    def test_overload_implicit(self):
+        # This test represents the preferred usage style for using literally
+        # in overload. Here, literally() is used inside the "implementation"
+        # function of the overload.
+        def do_this(x, y):
+            return x + y
+
+        @njit
+        def hidden(x, y):
+            return literally(x) + y
+
+        @overload(do_this)
+        def ov_do_this(x, y):
+            if isinstance(x, types.Integer):
+                # At this point, `x` can be a literal or not
+                return lambda x, y: hidden(x, y)
+
+        @njit
+        def foo(a, b):
+            return do_this(a, b)
+
+        a = 123
+        b = 321
+        r = foo(a, b)
+        self.assertEqual(r, a + b)
+        [type_a, type_b] = foo.signatures[0]
+        self.assertIsInstance(type_a, types.Literal)
+        self.assertEqual(type_a.literal_value, a)
+        self.assertNotIsInstance(type_b, types.Literal)
+
+    def test_overload_error_loop(self):
+        # Test a case where a infinite compiling loop is caused because a
+        # literal type is requested but an error would raise for the
+        # literal-ized code path. This causes the overload resolution to
+        # retry by "de-literal-izing" the values.
+        def do_this(x, y):
+            return x + y
+
+        @njit
+        def hidden(x, y):
+            return literally(x) + y
+
+        @overload(do_this)
+        def ov_do_this(x, y):
+            if isinstance(y, types.IntegerLiteral):
+                # This error is however suppressed because a non-literal
+                # version is valid.
+                raise errors.NumbaValueError("oops")
+            else:
+                def impl(x, y):
+                    return hidden(x, y)
+                return impl
+
+        @njit
+        def foo(a, b):
+            return do_this(a, literally(b))
+
+        # Expect raising CompilerError to stop re-compiling with duplicated
+        # literal typing request.
+        with self.assertRaises(errors.CompilerError) as raises:
+            foo(a=123, b=321)
+        self.assertIn("Repeated literal typing request",
+                      str(raises.exception))
+
+
+class TestLiteralDispatchWithCustomType(TestCase):
+    def make_dummy_type(self):
+        class Dummy(object):
+            def lit(self, a):
+                return a
+
+        class DummyType(types.Type):
+            def __init__(self):
+                super(DummyType, self).__init__(name="dummy")
+
+        @register_model(DummyType)
+        class DummyTypeModel(models.StructModel):
+            def __init__(self, dmm, fe_type):
+                members = []
+                super(DummyTypeModel, self).__init__(dmm, fe_type, members)
+
+        @intrinsic
+        def init_dummy(typingctx):
+            def codegen(context, builder, signature, args):
+                dummy = cgutils.create_struct_proxy(
+                    signature.return_type)(context, builder)
+
+                return dummy._getvalue()
+
+            sig = signature(DummyType())
+            return sig, codegen
+
+        @overload(Dummy)
+        def dummy_overload():
+            def ctor():
+                return init_dummy()
+
+            return ctor
+
+        return (DummyType, Dummy)
+
+    def test_overload_method(self):
+        # from issue #5011
+        DummyType, Dummy = self.make_dummy_type()
+
+        @overload_method(DummyType, 'lit')
+        def lit_overload(self, a):
+            def impl(self, a):
+                return literally(a)  # <-- using literally here
+
+            return impl
+
+        @njit
+        def test_impl(a):
+            d = Dummy()
+
+            return d.lit(a)
+
+        # Successful case
+        self.assertEqual(test_impl(5), 5)
+
+        # Failing case
+        @njit
+        def inside(a):
+            return test_impl(a + 1)
+
+        with self.assertRaises(errors.TypingError) as raises:
+            inside(4)
+
+        self.assertIn("Cannot request literal type.", str(raises.exception))
+
+
+if __name__ == '__main__':
+    unittest.main()

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

@@ -0,0 +1,560 @@
+from io import StringIO
+import numpy as np
+
+from numba.core import types
+from numba.core.compiler import compile_extra, Flags
+from numba.tests.support import TestCase, tag, MemoryLeakMixin
+import unittest
+
+
+looplift_flags = Flags()
+looplift_flags.force_pyobject = True
+looplift_flags.enable_looplift = True
+
+pyobject_looplift_flags = looplift_flags.copy()
+pyobject_looplift_flags.enable_pyobject_looplift = True
+
+
+def compile_isolated(pyfunc, argtypes, **kwargs):
+    from numba.core.registry import cpu_target
+
+    kwargs.setdefault('return_type', None)
+    kwargs.setdefault('locals', {})
+    return compile_extra(
+        cpu_target.typing_context,
+        cpu_target.target_context,
+        pyfunc,
+        argtypes,
+        **kwargs,
+    )
+
+
+def lift1(x):
+    # Outer needs object mode because of np.empty()
+    a = np.empty(3)
+    for i in range(a.size):
+        # Inner is nopython-compliant
+        a[i] = x
+    return a
+
+
+def lift2(x):
+    # Outer needs object mode because of np.empty()
+    a = np.empty((3, 4))
+    for i in range(a.shape[0]):
+        for j in range(a.shape[1]):
+            # Inner is nopython-compliant
+            a[i, j] = x
+    return a
+
+
+def lift3(x):
+    # Output variable from the loop
+    _ = object()
+    a = np.arange(5, dtype=np.int64)
+    c = 0
+    for i in range(a.shape[0]):
+        c += a[i] * x
+    return c
+
+def lift4(x):
+    # Output two variables from the loop
+    _ = object()
+    a = np.arange(5, dtype=np.int64)
+    c = 0
+    d = 0
+    for i in range(a.shape[0]):
+        c += a[i] * x
+        d += c
+    return c + d
+
+def lift5(x):
+    _ = object()
+    a = np.arange(4)
+    for i in range(a.shape[0]):
+        # Inner has a break statement
+        if i > 2:
+            break
+    return a
+
+def lift_gen1(x):
+    # Outer needs object mode because of np.empty()
+    a = np.empty(3)
+    yield 0
+    for i in range(a.size):
+        # Inner is nopython-compliant
+        a[i] = x
+    yield np.sum(a)
+
+def lift_issue2561():
+    np.empty(1)   # This forces objectmode because no nrt
+    for i in range(10):
+        for j in range(10):
+            return 1
+    return 2
+
+def reject1(x):
+    a = np.arange(4)
+    for i in range(a.shape[0]):
+        # Inner returns a variable from outer "scope" => cannot loop-lift
+        return a
+    return a
+
+
+def reject_gen1(x):
+    _ = object()
+    a = np.arange(4)
+    for i in range(a.shape[0]):
+        # Inner is a generator => cannot loop-lift
+        yield a[i]
+
+def reject_gen2(x):
+    _ = object()
+    a = np.arange(3)
+    for i in range(a.size):
+        # Middle has a yield => cannot loop-lift
+        res = a[i] + x
+        for j in range(i):
+            # Inner is nopython-compliant, but the current algorithm isn't
+            # able to separate it.
+            res = res ** 2
+        yield res
+
+def reject_npm1(x):
+    a = np.empty(3, dtype=np.int32)
+    for i in range(a.size):
+        # Inner uses object() => cannot loop-lift
+        _ = object()
+        a[i] = np.arange(i + 1)[i]
+
+    return a
+
+
+class TestLoopLifting(MemoryLeakMixin, TestCase):
+
+    def try_lift(self, pyfunc, argtypes):
+        from numba.core.registry import cpu_target
+
+        cres = compile_extra(
+            cpu_target.typing_context,
+            cpu_target.target_context,
+            pyfunc, argtypes,
+            return_type=None, flags=looplift_flags, locals={},
+        )
+        # One lifted loop
+        self.assertEqual(len(cres.lifted), 1)
+        return cres
+
+    def assert_lifted_native(self, cres):
+        # Check if we have lifted in nopython mode
+        jitloop = cres.lifted[0]
+        [loopcres] = jitloop.overloads.values()
+        self.assertTrue(loopcres.fndesc.native)  # Lifted function is native
+
+    def check_lift_ok(self, pyfunc, argtypes, args):
+        """
+        Check that pyfunc can loop-lift even in nopython mode.
+        """
+        cres = self.try_lift(pyfunc, argtypes)
+        expected = pyfunc(*args)
+        got = cres.entry_point(*args)
+        self.assert_lifted_native(cres)
+        # Check return values
+        self.assertPreciseEqual(expected, got)
+
+    def check_lift_generator_ok(self, pyfunc, argtypes, args):
+        """
+        Check that pyfunc (a generator function) can loop-lift even in
+        nopython mode.
+        """
+        cres = self.try_lift(pyfunc, argtypes)
+        expected = list(pyfunc(*args))
+        got = list(cres.entry_point(*args))
+        self.assert_lifted_native(cres)
+        # Check return values
+        self.assertPreciseEqual(expected, got)
+
+    def check_no_lift(self, pyfunc, argtypes, args):
+        """
+        Check that pyfunc can't loop-lift.
+        """
+        cres = compile_isolated(pyfunc, argtypes,
+                                flags=looplift_flags)
+        self.assertFalse(cres.lifted)
+        expected = pyfunc(*args)
+        got = cres.entry_point(*args)
+        # Check return values
+        self.assertPreciseEqual(expected, got)
+
+    def check_no_lift_generator(self, pyfunc, argtypes, args):
+        """
+        Check that pyfunc (a generator function) can't loop-lift.
+        """
+        cres = compile_isolated(pyfunc, argtypes,
+                                flags=looplift_flags)
+        self.assertFalse(cres.lifted)
+        expected = list(pyfunc(*args))
+        got = list(cres.entry_point(*args))
+        self.assertPreciseEqual(expected, got)
+
+    def test_lift1(self):
+        self.check_lift_ok(lift1, (types.intp,), (123,))
+
+    def test_lift2(self):
+        self.check_lift_ok(lift2, (types.intp,), (123,))
+
+    def test_lift3(self):
+        self.check_lift_ok(lift3, (types.intp,), (123,))
+
+    def test_lift4(self):
+        self.check_lift_ok(lift4, (types.intp,), (123,))
+
+    def test_lift5(self):
+        self.check_lift_ok(lift5, (types.intp,), (123,))
+
+    def test_lift_issue2561(self):
+        self.check_lift_ok(lift_issue2561, (), ())
+
+    def test_lift_gen1(self):
+        self.check_lift_generator_ok(lift_gen1, (types.intp,), (123,))
+
+    def test_reject1(self):
+        self.check_no_lift(reject1, (types.intp,), (123,))
+
+    def test_reject_gen1(self):
+        self.check_no_lift_generator(reject_gen1, (types.intp,), (123,))
+
+    def test_reject_gen2(self):
+        self.check_no_lift_generator(reject_gen2, (types.intp,), (123,))
+
+
+class TestLoopLiftingAnnotate(TestCase):
+    def test_annotate_1(self):
+        """
+        Verify that annotation works as expected with one lifted loop
+        """
+        from numba import jit
+
+        # dummy function to force objmode
+        def bar():
+            pass
+
+        def foo(x):
+            bar()  # force obj
+            for i in range(x.size):
+                x[i] += 1
+
+            return x
+
+        cfoo = jit(forceobj=True)(foo)
+
+        x = np.arange(10)
+        xcopy = x.copy()
+        r = cfoo(x)
+        np.testing.assert_equal(r, xcopy + 1)
+
+        buf = StringIO()
+        cfoo.inspect_types(file=buf)
+        annotation = buf.getvalue()
+        buf.close()
+
+        self.assertIn("The function contains lifted loops", annotation)
+        line = foo.__code__.co_firstlineno + 2  # 2 lines down from func head
+        self.assertIn("Loop at line {line}".format(line=line), annotation)
+        self.assertIn("Has 1 overloads", annotation)
+
+    def test_annotate_2(self):
+        """
+        Verify that annotation works as expected with two lifted loops
+        """
+        from numba import jit
+
+        # dummy function to force objmode
+        def bar():
+            pass
+
+        def foo(x):
+            bar()  # force obj
+            # first lifted loop
+            for i in range(x.size):
+                x[i] += 1
+            # second lifted loop
+            for j in range(x.size):
+                x[j] *= 2
+            return x
+
+        cfoo = jit(forceobj=True)(foo)
+
+        x = np.arange(10)
+        xcopy = x.copy()
+        r = cfoo(x)
+        np.testing.assert_equal(r, (xcopy + 1) * 2)
+
+        buf = StringIO()
+        cfoo.inspect_types(file=buf)
+        annotation = buf.getvalue()
+        buf.close()
+
+        self.assertIn("The function contains lifted loops", annotation)
+        line1 = foo.__code__.co_firstlineno + 3  # 3 lines down from func head
+        line2 = foo.__code__.co_firstlineno + 6  # 6 lines down from func head
+        self.assertIn("Loop at line {line}".format(line=line1), annotation)
+        self.assertIn("Loop at line {line}".format(line=line2), annotation)
+
+
+class TestLoopLiftingInAction(MemoryLeakMixin, TestCase):
+    def assert_has_lifted(self, jitted, loopcount):
+        lifted = jitted.overloads[jitted.signatures[0]].lifted
+        self.assertEqual(len(lifted), loopcount)
+
+    def test_issue_734(self):
+        from numba import jit, void, int32, double
+
+        @jit(void(int32, double[:]), forceobj=True)
+        def forloop_with_if(u, a):
+            if u == 0:
+                for i in range(a.shape[0]):
+                    a[i] = a[i] * 2.0
+            else:
+                for i in range(a.shape[0]):
+                    a[i] = a[i] + 1.0
+
+        for u in (0, 1):
+            nb_a = np.arange(10, dtype='int32')
+            np_a = np.arange(10, dtype='int32')
+            forloop_with_if(u, nb_a)
+            forloop_with_if.py_func(u, np_a)
+            self.assertPreciseEqual(nb_a, np_a)
+
+    def test_issue_812(self):
+        from numba import jit
+
+        @jit('f8[:](f8[:])', forceobj=True)
+        def test(x):
+            res = np.zeros(len(x))
+            ind = 0
+            for ii in range(len(x)):
+                ind += 1
+                res[ind] = x[ind]
+                if x[ind] >= 10:
+                    break
+
+            # Invalid loopjitting will miss the usage of `ind` in the
+            # following loop.
+            for ii in range(ind + 1, len(x)):
+                res[ii] = 0
+            return res
+
+        x = np.array([1., 4, 2, -3, 5, 2, 10, 5, 2, 6])
+        np.testing.assert_equal(test.py_func(x), test(x))
+
+    def test_issue_2368(self):
+        from numba import jit
+
+        def lift_issue2368(a, b):
+            s = 0
+            for e in a:
+                s += e
+            h = b.__hash__()
+            return s, h
+
+        a = np.ones(10)
+        b = object()
+        jitted = jit(forceobj=True)(lift_issue2368)
+
+        expected = lift_issue2368(a, b)
+        got = jitted(a, b)
+
+        self.assertEqual(expected[0], got[0])
+        self.assertEqual(expected[1], got[1])
+
+        jitloop = jitted.overloads[jitted.signatures[0]].lifted[0]
+        [loopcres] = jitloop.overloads.values()
+        # assert lifted function is native
+        self.assertTrue(loopcres.fndesc.native)
+
+    def test_no_iteration_w_redef(self):
+        # redefinition of res in the loop with no use of res should not
+        # prevent lifting
+        from numba import jit
+
+        @jit(forceobj=True)
+        def test(n):
+            res = 0
+            for i in range(n):
+                res = i
+            return res
+
+        # loop count = 1, loop lift but loop body not execute
+        self.assertEqual(test.py_func(-1), test(-1))
+        self.assert_has_lifted(test, loopcount=1)
+        # loop count = 1, loop will lift and will execute
+        self.assertEqual(test.py_func(1), test(1))
+        self.assert_has_lifted(test, loopcount=1)
+
+    def test_no_iteration(self):
+        from numba import jit
+
+        @jit(forceobj=True)
+        def test(n):
+            res = 0
+            for i in range(n):
+                res += i
+            return res
+
+        # loop count = 1
+        self.assertEqual(test.py_func(-1), test(-1))
+        self.assert_has_lifted(test, loopcount=1)
+        # loop count = 1
+        self.assertEqual(test.py_func(1), test(1))
+        self.assert_has_lifted(test, loopcount=1)
+
+    def test_define_in_loop_body(self):
+        # tests a definition in a loop that leaves the loop is liftable
+        from numba import jit
+
+        @jit(forceobj=True)
+        def test(n):
+            for i in range(n):
+                res = i
+            return res
+
+        # loop count = 1
+        self.assertEqual(test.py_func(1), test(1))
+        self.assert_has_lifted(test, loopcount=1)
+
+    def test_invalid_argument(self):
+        """Test a problem caused by invalid discovery of loop argument
+        when a variable is used afterwards but not before.
+
+        Before the fix, this will result in::
+
+        numba.ir.NotDefinedError: 'i' is not defined
+        """
+        from numba import jit
+
+        @jit(forceobj=True)
+        def test(arg):
+            if type(arg) == np.ndarray: # force object mode
+                if arg.ndim == 1:
+                    result = 0.0
+                    j = 0
+                    for i in range(arg.shape[0]):
+                        pass
+                else:
+                    raise Exception
+            else:
+                result = 0.0
+                i, j = 0, 0
+                return result
+
+        arg = np.arange(10)
+        self.assertEqual(test.py_func(arg), test(arg))
+
+    def test_conditionally_defined_in_loop(self):
+        from numba import jit
+        @jit(forceobj=True)
+        def test():
+            x = 5
+            y = 0
+            for i in range(2):
+                if i > 0:
+                   x = 6
+                y += x
+            return y, x
+
+        self.assertEqual(test.py_func(), test())
+        self.assert_has_lifted(test, loopcount=1)
+
+    def test_stack_offset_error_when_has_no_return(self):
+        from numba import jit
+        import warnings
+
+        def pyfunc(a):
+            if a:
+                for i in range(10):
+                    pass
+
+        with warnings.catch_warnings():
+            warnings.simplefilter("error")
+
+            cfunc = jit(forceobj=True)(pyfunc)
+            self.assertEqual(pyfunc(True), cfunc(True))
+
+    def test_variable_scope_bug(self):
+        """
+        https://github.com/numba/numba/issues/2179
+
+        Looplifting transformation is using the wrong version of variable `h`.
+        """
+        from numba import jit
+
+        def bar(x):
+            return x
+
+        def foo(x):
+            h = 0.
+            for k in range(x):
+                h = h + k
+            h = h - bar(x)
+            return h
+
+        cfoo = jit(forceobj=True)(foo)
+        self.assertEqual(foo(10), cfoo(10))
+
+    def test_recompilation_loop(self):
+        """
+        https://github.com/numba/numba/issues/2481
+        """
+        from numba import jit
+
+        def foo(x, y):
+            # slicing to make array `x` into different layout
+            # to cause a new compilation of the lifted loop
+            A = x[::y]
+            c = 1
+            for k in range(A.size):
+                object()  # to force objectmode and looplifting
+                c = c * A[::-1][k]   # the slice that is failing in static_getitem
+            return c
+
+        cfoo = jit(forceobj=True)(foo)
+        # First run just works
+        args = np.arange(10), 1
+        self.assertEqual(foo(*args), cfoo(*args))
+        # Exactly 1 lifted loop so far
+        self.assertEqual(len(cfoo.overloads[cfoo.signatures[0]].lifted), 1)
+        lifted = cfoo.overloads[cfoo.signatures[0]].lifted[0]
+        # The lifted loop has 1 signature
+        self.assertEqual(len(lifted.signatures), 1)
+        # Use different argument to trigger a new compilation of the lifted loop
+        args = np.arange(10), -1
+        self.assertEqual(foo(*args), cfoo(*args))
+        # Ensure that is really a new overload for the lifted loop
+        self.assertEqual(len(lifted.signatures), 2)
+
+
+    def test_lift_objectmode_issue_4223(self):
+        from numba import jit
+
+        @jit(forceobj=True)
+        def foo(a, b, c, d, x0, y0, n):
+            xs, ys = np.zeros(n), np.zeros(n)
+            xs[0], ys[0] = x0, y0
+            for i in np.arange(n-1):
+                xs[i+1] = np.sin(a * ys[i]) + c * np.cos(a * xs[i])
+                ys[i+1] = np.sin(b * xs[i]) + d * np.cos(b * ys[i])
+            object() # ensure object mode
+            return xs, ys
+
+        kwargs = dict(a=1.7, b=1.7, c=0.6, d=1.2, x0=0, y0=0, n=200)
+        got = foo(**kwargs)
+        expected = foo.py_func(**kwargs)
+        self.assertPreciseEqual(got[0], expected[0])
+        self .assertPreciseEqual(got[1], expected[1])
+        [lifted] = foo.overloads[foo.signatures[0]].lifted
+        self.assertEqual(len(lifted.nopython_signatures), 1)
+
+
+if __name__ == '__main__':
+    unittest.main()

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

@@ -0,0 +1,41 @@
+# -*- coding: utf-8 -*-
+"""
+Test function name mangling.
+The mangling affects the ABI of numba compiled binaries.
+"""
+from numba.core import types
+from numba.core.funcdesc import default_mangler
+from numba.tests.support import unittest, TestCase
+
+
+class TestMangling(TestCase):
+    def test_one_args(self):
+        fname = 'foo'
+        argtypes = types.int32,
+        name = default_mangler(fname, argtypes)
+        self.assertEqual(name, '_Z3fooi')
+
+    def test_two_args(self):
+        fname = 'foo'
+        argtypes = types.int32, types.float32
+        name = default_mangler(fname, argtypes)
+        self.assertEqual(name, '_Z3fooif')
+
+    def test_unicode_fname(self):
+        fname = u'foಠ'
+        argtypes = types.int32, types.float32
+        name = default_mangler(fname, argtypes)
+        self.assertIsInstance(name, str)
+        # manually encode it
+        unichar = fname[2]
+        enc = ''.join('_{:02x}'.format(c)
+                      for c in unichar.encode('utf8'))
+        text = 'fo' + enc
+        expect = '_Z{}{}if'.format(len(text), text)
+        self.assertEqual(name, expect)
+        # ensure result chars are in the right charset
+        self.assertRegex(name, r'^_Z[a-zA-Z0-9_\$]+$')
+
+
+if __name__ == '__main__':
+    unittest.main()

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

@@ -0,0 +1,30 @@
+"""Tests for moved modules and their redirection from old path
+"""
+from numba.tests.support import TestCase
+
+
+class TestMovedModule(TestCase):
+    """Testing moved modules in Q1 2020 but were decided to kept as public API
+    """
+    def tests_numba_types(self):
+        import numba.types
+        import numba.core.types as types
+        # The old module IS NOT the new module
+        self.assertIsNot(numba.types, types)
+        # Attribute access are there
+        self.assertIs(numba.types.intp, types.intp)
+        self.assertIs(numba.types.float64, types.float64)
+        self.assertIs(numba.types.Array, types.Array)
+        # Submodule access through old import path is possible
+        import numba.types.misc
+        self.assertIs(types.misc, numba.types.misc)
+        self.assertIs(types.misc.Optional, numba.types.misc.Optional)
+        # Import time code could be executed twice and causes the following to
+        # fail.
+        self.assertIs(types.StringLiteral, numba.types.misc.StringLiteral)
+        # Check numba.types.container
+        from numba.types import containers
+        self.assertIs(types.containers, containers)
+        self.assertIs(types.containers.Sequence, containers.Sequence)
+        from numba.types.containers import Sequence
+        self.assertIs(Sequence, containers.Sequence)

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

@@ -0,0 +1,43 @@
+import random
+
+import numpy as np
+
+from numba import njit
+from numba.core import types
+import unittest
+
+class TestMulti3(unittest.TestCase):
+    """
+    This test is only relevant for 32-bit architectures.
+
+    Test __multi3 implementation in _helperlib.c.
+    The symbol defines a i128 multiplication.
+    It is necessary for working around an issue in LLVM (see issue #969).
+    The symbol does not exist in 32-bit platform, and should not be used by
+    LLVM.  However, optimization passes will create i65 multiplication that
+    is then lowered to __multi3.
+    """
+    def test_multi3(self):
+        @njit("(int64,)")
+        def func(x):
+            res = 0
+            for i in range(x):
+                res += i
+            return res
+
+        x_cases = [-1, 0, 1, 3, 4, 8,
+                   0xffffffff - 1, 0xffffffff, 0xffffffff + 1,
+                   0x123456789abcdef, -0x123456789abcdef]
+        for _ in range(500):
+            x_cases.append(random.randint(0, 0xffffffff))
+
+        def expected(x):
+            if x <= 0: return 0
+            return ((x * (x - 1)) // 2) & (2**64 - 1)
+
+        for x in x_cases:
+            self.assertEqual(expected(x), func(x))
+
+
+if __name__ == '__main__':
+    unittest.main()

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

@@ -0,0 +1,37 @@
+import unittest
+from numba import jit
+from numba.core import types
+
+enable_pyobj_flags = {'forceobj': True}
+no_pyobj_flags = {'nopython': True}
+
+
+def isnan(x):
+    return x != x
+
+
+def isequal(x):
+    return x == x
+
+
+class TestNaN(unittest.TestCase):
+
+    def test_nans(self, flags=enable_pyobj_flags):
+        pyfunc = isnan
+        cfunc = jit((types.float64,), **flags)(pyfunc)
+
+        self.assertTrue(cfunc(float('nan')))
+        self.assertFalse(cfunc(1.0))
+
+        pyfunc = isequal
+        cfunc = jit((types.float64,), **flags)(pyfunc)
+
+        self.assertFalse(cfunc(float('nan')))
+        self.assertTrue(cfunc(1.0))
+
+    def test_nans_npm(self):
+        self.test_nans(flags=no_pyobj_flags)
+
+
+if __name__ == '__main__':
+    unittest.main()