Add files using upload-large-folder tool

.gitattributes

@@ -97,3 +97,5 @@ lib/python3.10/site-packages/av/video/frame.cpython-310-x86_64-linux-gnu.so filt
 lib/python3.10/site-packages/av/sidedata/sidedata.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 lib/python3.10/site-packages/av/video/format.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 lib/python3.10/site-packages/av/sidedata/motionvectors.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+lib/python3.10/site-packages/av/audio/layout.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+lib/python3.10/site-packages/av/audio/plane.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text

lib/python3.10/site-packages/av/audio/layout.cpython-310-x86_64-linux-gnu.so

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

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

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

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

@@ -0,0 +1,18 @@
+from . import cloudpickle
+from .cloudpickle import *  # noqa
+
+__doc__ = cloudpickle.__doc__
+
+__version__ = "3.0.0"
+
+__all__ = [  # noqa
+    "__version__",
+    "Pickler",
+    "CloudPickler",
+    "dumps",
+    "loads",
+    "dump",
+    "load",
+    "register_pickle_by_value",
+    "unregister_pickle_by_value",
+]

lib/python3.10/site-packages/numba/cloudpickle/cloudpickle.py

@@ -0,0 +1,1504 @@
+"""
+This is a modified version of the cloudpickle module.
+Patches:
+- https://github.com/numba/numba/pull/7388
+  Avoid resetting class state of dynamic classes.
+
+Original module docstring:
+
+Pickler class to extend the standard pickle.Pickler functionality
+
+The main objective is to make it natural to perform distributed computing on
+clusters (such as PySpark, Dask, Ray...) with interactively defined code
+(functions, classes, ...) written in notebooks or console.
+
+In particular this pickler adds the following features:
+- serialize interactively-defined or locally-defined functions, classes,
+  enums, typevars, lambdas and nested functions to compiled byte code;
+- deal with some other non-serializable objects in an ad-hoc manner where
+  applicable.
+
+This pickler is therefore meant to be used for the communication between short
+lived Python processes running the same version of Python and libraries. In
+particular, it is not meant to be used for long term storage of Python objects.
+
+It does not include an unpickler, as standard Python unpickling suffices.
+
+This module was extracted from the `cloud` package, developed by `PiCloud, Inc.
+<https://web.archive.org/web/20140626004012/http://www.picloud.com/>`_.
+
+Copyright (c) 2012-now, CloudPickle developers and contributors.
+Copyright (c) 2012, Regents of the University of California.
+Copyright (c) 2009 `PiCloud, Inc. <https://web.archive.org/web/20140626004012/http://www.picloud.com/>`_.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the University of California, Berkeley nor the
+      names of its contributors may be used to endorse or promote
+      products derived from this software without specific prior written
+      permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
+TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+"""
+
+import _collections_abc
+from collections import ChainMap, OrderedDict
+import abc
+import builtins
+import copyreg
+import dataclasses
+import dis
+from enum import Enum
+import io
+import itertools
+import logging
+import opcode
+import pickle
+from pickle import _getattribute
+import platform
+import struct
+import sys
+import threading
+import types
+import typing
+import uuid
+import warnings
+import weakref
+
+# The following import is required to be imported in the cloudpickle
+# namespace to be able to load pickle files generated with older versions of
+# cloudpickle. See: tests/test_backward_compat.py
+from types import CellType  # noqa: F401
+
+
+# cloudpickle is meant for inter process communication: we expect all
+# communicating processes to run the same Python version hence we favor
+# communication speed over compatibility:
+DEFAULT_PROTOCOL = pickle.HIGHEST_PROTOCOL
+
+# Names of modules whose resources should be treated as dynamic.
+_PICKLE_BY_VALUE_MODULES = set()
+
+# Track the provenance of reconstructed dynamic classes to make it possible to
+# reconstruct instances from the matching singleton class definition when
+# appropriate and preserve the usual "isinstance" semantics of Python objects.
+_DYNAMIC_CLASS_TRACKER_BY_CLASS = weakref.WeakKeyDictionary()
+_DYNAMIC_CLASS_TRACKER_BY_ID = weakref.WeakValueDictionary()
+_DYNAMIC_CLASS_TRACKER_LOCK = threading.Lock()
+_DYNAMIC_CLASS_TRACKER_REUSING = weakref.WeakSet()
+
+PYPY = platform.python_implementation() == "PyPy"
+
+builtin_code_type = None
+if PYPY:
+    # builtin-code objects only exist in pypy
+    builtin_code_type = type(float.__new__.__code__)
+
+_extract_code_globals_cache = weakref.WeakKeyDictionary()
+
+
+def _get_or_create_tracker_id(class_def):
+    with _DYNAMIC_CLASS_TRACKER_LOCK:
+        class_tracker_id = _DYNAMIC_CLASS_TRACKER_BY_CLASS.get(class_def)
+        if class_tracker_id is None:
+            class_tracker_id = uuid.uuid4().hex
+            _DYNAMIC_CLASS_TRACKER_BY_CLASS[class_def] = class_tracker_id
+            _DYNAMIC_CLASS_TRACKER_BY_ID[class_tracker_id] = class_def
+    return class_tracker_id
+
+
+def _lookup_class_or_track(class_tracker_id, class_def):
+    if class_tracker_id is not None:
+        with _DYNAMIC_CLASS_TRACKER_LOCK:
+            orig_class_def = class_def
+            class_def = _DYNAMIC_CLASS_TRACKER_BY_ID.setdefault(
+                class_tracker_id, class_def
+            )
+            _DYNAMIC_CLASS_TRACKER_BY_CLASS[class_def] = class_tracker_id
+            # Check if we are reusing a previous class_def
+            if orig_class_def is not class_def:
+                # Remember the class_def is being reused
+                _DYNAMIC_CLASS_TRACKER_REUSING.add(class_def)
+    return class_def
+
+
+def register_pickle_by_value(module):
+    """Register a module to make it functions and classes picklable by value.
+
+    By default, functions and classes that are attributes of an importable
+    module are to be pickled by reference, that is relying on re-importing
+    the attribute from the module at load time.
+
+    If `register_pickle_by_value(module)` is called, all its functions and
+    classes are subsequently to be pickled by value, meaning that they can
+    be loaded in Python processes where the module is not importable.
+
+    This is especially useful when developing a module in a distributed
+    execution environment: restarting the client Python process with the new
+    source code is enough: there is no need to re-install the new version
+    of the module on all the worker nodes nor to restart the workers.
+
+    Note: this feature is considered experimental. See the cloudpickle
+    README.md file for more details and limitations.
+    """
+    if not isinstance(module, types.ModuleType):
+        raise ValueError(f"Input should be a module object, got {str(module)} instead")
+    # In the future, cloudpickle may need a way to access any module registered
+    # for pickling by value in order to introspect relative imports inside
+    # functions pickled by value. (see
+    # https://github.com/cloudpipe/cloudpickle/pull/417#issuecomment-873684633).
+    # This access can be ensured by checking that module is present in
+    # sys.modules at registering time and assuming that it will still be in
+    # there when accessed during pickling. Another alternative would be to
+    # store a weakref to the module. Even though cloudpickle does not implement
+    # this introspection yet, in order to avoid a possible breaking change
+    # later, we still enforce the presence of module inside sys.modules.
+    if module.__name__ not in sys.modules:
+        raise ValueError(
+            f"{module} was not imported correctly, have you used an "
+            "`import` statement to access it?"
+        )
+    _PICKLE_BY_VALUE_MODULES.add(module.__name__)
+
+
+def unregister_pickle_by_value(module):
+    """Unregister that the input module should be pickled by value."""
+    if not isinstance(module, types.ModuleType):
+        raise ValueError(f"Input should be a module object, got {str(module)} instead")
+    if module.__name__ not in _PICKLE_BY_VALUE_MODULES:
+        raise ValueError(f"{module} is not registered for pickle by value")
+    else:
+        _PICKLE_BY_VALUE_MODULES.remove(module.__name__)
+
+
+def list_registry_pickle_by_value():
+    return _PICKLE_BY_VALUE_MODULES.copy()
+
+
+def _is_registered_pickle_by_value(module):
+    module_name = module.__name__
+    if module_name in _PICKLE_BY_VALUE_MODULES:
+        return True
+    while True:
+        parent_name = module_name.rsplit(".", 1)[0]
+        if parent_name == module_name:
+            break
+        if parent_name in _PICKLE_BY_VALUE_MODULES:
+            return True
+        module_name = parent_name
+    return False
+
+
+def _whichmodule(obj, name):
+    """Find the module an object belongs to.
+
+    This function differs from ``pickle.whichmodule`` in two ways:
+    - it does not mangle the cases where obj's module is __main__ and obj was
+      not found in any module.
+    - Errors arising during module introspection are ignored, as those errors
+      are considered unwanted side effects.
+    """
+    module_name = getattr(obj, "__module__", None)
+
+    if module_name is not None:
+        return module_name
+    # Protect the iteration by using a copy of sys.modules against dynamic
+    # modules that trigger imports of other modules upon calls to getattr or
+    # other threads importing at the same time.
+    for module_name, module in sys.modules.copy().items():
+        # Some modules such as coverage can inject non-module objects inside
+        # sys.modules
+        if (
+            module_name == "__main__"
+            or module is None
+            or not isinstance(module, types.ModuleType)
+        ):
+            continue
+        try:
+            if _getattribute(module, name)[0] is obj:
+                return module_name
+        except Exception:
+            pass
+    return None
+
+
+def _should_pickle_by_reference(obj, name=None):
+    """Test whether an function or a class should be pickled by reference
+
+    Pickling by reference means by that the object (typically a function or a
+    class) is an attribute of a module that is assumed to be importable in the
+    target Python environment. Loading will therefore rely on importing the
+    module and then calling `getattr` on it to access the function or class.
+
+    Pickling by reference is the only option to pickle functions and classes
+    in the standard library. In cloudpickle the alternative option is to
+    pickle by value (for instance for interactively or locally defined
+    functions and classes or for attributes of modules that have been
+    explicitly registered to be pickled by value.
+    """
+    if isinstance(obj, types.FunctionType) or issubclass(type(obj), type):
+        module_and_name = _lookup_module_and_qualname(obj, name=name)
+        if module_and_name is None:
+            return False
+        module, name = module_and_name
+        return not _is_registered_pickle_by_value(module)
+
+    elif isinstance(obj, types.ModuleType):
+        # We assume that sys.modules is primarily used as a cache mechanism for
+        # the Python import machinery. Checking if a module has been added in
+        # is sys.modules therefore a cheap and simple heuristic to tell us
+        # whether we can assume that a given module could be imported by name
+        # in another Python process.
+        if _is_registered_pickle_by_value(obj):
+            return False
+        return obj.__name__ in sys.modules
+    else:
+        raise TypeError(
+            "cannot check importability of {} instances".format(type(obj).__name__)
+        )
+
+
+def _lookup_module_and_qualname(obj, name=None):
+    if name is None:
+        name = getattr(obj, "__qualname__", None)
+    if name is None:  # pragma: no cover
+        # This used to be needed for Python 2.7 support but is probably not
+        # needed anymore. However we keep the __name__ introspection in case
+        # users of cloudpickle rely on this old behavior for unknown reasons.
+        name = getattr(obj, "__name__", None)
+
+    module_name = _whichmodule(obj, name)
+
+    if module_name is None:
+        # In this case, obj.__module__ is None AND obj was not found in any
+        # imported module. obj is thus treated as dynamic.
+        return None
+
+    if module_name == "__main__":
+        return None
+
+    # Note: if module_name is in sys.modules, the corresponding module is
+    # assumed importable at unpickling time. See #357
+    module = sys.modules.get(module_name, None)
+    if module is None:
+        # The main reason why obj's module would not be imported is that this
+        # module has been dynamically created, using for example
+        # types.ModuleType. The other possibility is that module was removed
+        # from sys.modules after obj was created/imported. But this case is not
+        # supported, as the standard pickle does not support it either.
+        return None
+
+    try:
+        obj2, parent = _getattribute(module, name)
+    except AttributeError:
+        # obj was not found inside the module it points to
+        return None
+    if obj2 is not obj:
+        return None
+    return module, name
+
+
+def _extract_code_globals(co):
+    """Find all globals names read or written to by codeblock co."""
+    out_names = _extract_code_globals_cache.get(co)
+    if out_names is None:
+        # We use a dict with None values instead of a set to get a
+        # deterministic order and avoid introducing non-deterministic pickle
+        # bytes as a results.
+        out_names = {name: None for name in _walk_global_ops(co)}
+
+        # Declaring a function inside another one using the "def ..." syntax
+        # generates a constant code object corresponding to the one of the
+        # nested function's As the nested function may itself need global
+        # variables, we need to introspect its code, extract its globals, (look
+        # for code object in it's co_consts attribute..) and add the result to
+        # code_globals
+        if co.co_consts:
+            for const in co.co_consts:
+                if isinstance(const, types.CodeType):
+                    out_names.update(_extract_code_globals(const))
+
+        _extract_code_globals_cache[co] = out_names
+
+    return out_names
+
+
+def _find_imported_submodules(code, top_level_dependencies):
+    """Find currently imported submodules used by a function.
+
+    Submodules used by a function need to be detected and referenced for the
+    function to work correctly at depickling time. Because submodules can be
+    referenced as attribute of their parent package (``package.submodule``), we
+    need a special introspection technique that does not rely on GLOBAL-related
+    opcodes to find references of them in a code object.
+
+    Example:
+    ```
+    import concurrent.futures
+    import cloudpickle
+    def func():
+        x = concurrent.futures.ThreadPoolExecutor
+    if __name__ == '__main__':
+        cloudpickle.dumps(func)
+    ```
+    The globals extracted by cloudpickle in the function's state include the
+    concurrent package, but not its submodule (here, concurrent.futures), which
+    is the module used by func. Find_imported_submodules will detect the usage
+    of concurrent.futures. Saving this module alongside with func will ensure
+    that calling func once depickled does not fail due to concurrent.futures
+    not being imported
+    """
+
+    subimports = []
+    # check if any known dependency is an imported package
+    for x in top_level_dependencies:
+        if (
+            isinstance(x, types.ModuleType)
+            and hasattr(x, "__package__")
+            and x.__package__
+        ):
+            # check if the package has any currently loaded sub-imports
+            prefix = x.__name__ + "."
+            # A concurrent thread could mutate sys.modules,
+            # make sure we iterate over a copy to avoid exceptions
+            for name in list(sys.modules):
+                # Older versions of pytest will add a "None" module to
+                # sys.modules.
+                if name is not None and name.startswith(prefix):
+                    # check whether the function can address the sub-module
+                    tokens = set(name[len(prefix) :].split("."))
+                    if not tokens - set(code.co_names):
+                        subimports.append(sys.modules[name])
+    return subimports
+
+
+# relevant opcodes
+STORE_GLOBAL = opcode.opmap["STORE_GLOBAL"]
+DELETE_GLOBAL = opcode.opmap["DELETE_GLOBAL"]
+LOAD_GLOBAL = opcode.opmap["LOAD_GLOBAL"]
+GLOBAL_OPS = (STORE_GLOBAL, DELETE_GLOBAL, LOAD_GLOBAL)
+HAVE_ARGUMENT = dis.HAVE_ARGUMENT
+EXTENDED_ARG = dis.EXTENDED_ARG
+
+
+_BUILTIN_TYPE_NAMES = {}
+for k, v in types.__dict__.items():
+    if type(v) is type:
+        _BUILTIN_TYPE_NAMES[v] = k
+
+
+def _builtin_type(name):
+    if name == "ClassType":  # pragma: no cover
+        # Backward compat to load pickle files generated with cloudpickle
+        # < 1.3 even if loading pickle files from older versions is not
+        # officially supported.
+        return type
+    return getattr(types, name)
+
+
+def _walk_global_ops(code):
+    """Yield referenced name for global-referencing instructions in code."""
+    for instr in dis.get_instructions(code):
+        op = instr.opcode
+        if op in GLOBAL_OPS:
+            yield instr.argval
+
+
+def _extract_class_dict(cls):
+    """Retrieve a copy of the dict of a class without the inherited method."""
+    clsdict = dict(cls.__dict__)  # copy dict proxy to a dict
+    if len(cls.__bases__) == 1:
+        inherited_dict = cls.__bases__[0].__dict__
+    else:
+        inherited_dict = {}
+        for base in reversed(cls.__bases__):
+            inherited_dict.update(base.__dict__)
+    to_remove = []
+    for name, value in clsdict.items():
+        try:
+            base_value = inherited_dict[name]
+            if value is base_value:
+                to_remove.append(name)
+        except KeyError:
+            pass
+    for name in to_remove:
+        clsdict.pop(name)
+    return clsdict
+
+
+def is_tornado_coroutine(func):
+    """Return whether `func` is a Tornado coroutine function.
+
+    Running coroutines are not supported.
+    """
+    warnings.warn(
+        "is_tornado_coroutine is deprecated in cloudpickle 3.0 and will be "
+        "removed in cloudpickle 4.0. Use tornado.gen.is_coroutine_function "
+        "directly instead.",
+        category=DeprecationWarning,
+    )
+    if "tornado.gen" not in sys.modules:
+        return False
+    gen = sys.modules["tornado.gen"]
+    if not hasattr(gen, "is_coroutine_function"):
+        # Tornado version is too old
+        return False
+    return gen.is_coroutine_function(func)
+
+
+def subimport(name):
+    # We cannot do simply: `return __import__(name)`: Indeed, if ``name`` is
+    # the name of a submodule, __import__ will return the top-level root module
+    # of this submodule. For instance, __import__('os.path') returns the `os`
+    # module.
+    __import__(name)
+    return sys.modules[name]
+
+
+def dynamic_subimport(name, vars):
+    mod = types.ModuleType(name)
+    mod.__dict__.update(vars)
+    mod.__dict__["__builtins__"] = builtins.__dict__
+    return mod
+
+
+def _get_cell_contents(cell):
+    try:
+        return cell.cell_contents
+    except ValueError:
+        # Handle empty cells explicitly with a sentinel value.
+        return _empty_cell_value
+
+
+def instance(cls):
+    """Create a new instance of a class.
+
+    Parameters
+    ----------
+    cls : type
+        The class to create an instance of.
+
+    Returns
+    -------
+    instance : cls
+        A new instance of ``cls``.
+    """
+    return cls()
+
+
+@instance
+class _empty_cell_value:
+    """Sentinel for empty closures."""
+
+    @classmethod
+    def __reduce__(cls):
+        return cls.__name__
+
+
+def _make_function(code, globals, name, argdefs, closure):
+    # Setting __builtins__ in globals is needed for nogil CPython.
+    globals["__builtins__"] = __builtins__
+    return types.FunctionType(code, globals, name, argdefs, closure)
+
+
+def _make_empty_cell():
+    if False:
+        # trick the compiler into creating an empty cell in our lambda
+        cell = None
+        raise AssertionError("this route should not be executed")
+
+    return (lambda: cell).__closure__[0]
+
+
+def _make_cell(value=_empty_cell_value):
+    cell = _make_empty_cell()
+    if value is not _empty_cell_value:
+        cell.cell_contents = value
+    return cell
+
+
+def _make_skeleton_class(
+    type_constructor, name, bases, type_kwargs, class_tracker_id, extra
+):
+    """Build dynamic class with an empty __dict__ to be filled once memoized
+
+    If class_tracker_id is not None, try to lookup an existing class definition
+    matching that id. If none is found, track a newly reconstructed class
+    definition under that id so that other instances stemming from the same
+    class id will also reuse this class definition.
+
+    The "extra" variable is meant to be a dict (or None) that can be used for
+    forward compatibility shall the need arise.
+    """
+    skeleton_class = types.new_class(
+        name, bases, {"metaclass": type_constructor}, lambda ns: ns.update(type_kwargs)
+    )
+    return _lookup_class_or_track(class_tracker_id, skeleton_class)
+
+
+def _make_skeleton_enum(
+    bases, name, qualname, members, module, class_tracker_id, extra
+):
+    """Build dynamic enum with an empty __dict__ to be filled once memoized
+
+    The creation of the enum class is inspired by the code of
+    EnumMeta._create_.
+
+    If class_tracker_id is not None, try to lookup an existing enum definition
+    matching that id. If none is found, track a newly reconstructed enum
+    definition under that id so that other instances stemming from the same
+    class id will also reuse this enum definition.
+
+    The "extra" variable is meant to be a dict (or None) that can be used for
+    forward compatibility shall the need arise.
+    """
+    # enums always inherit from their base Enum class at the last position in
+    # the list of base classes:
+    enum_base = bases[-1]
+    metacls = enum_base.__class__
+    classdict = metacls.__prepare__(name, bases)
+
+    for member_name, member_value in members.items():
+        classdict[member_name] = member_value
+    enum_class = metacls.__new__(metacls, name, bases, classdict)
+    enum_class.__module__ = module
+    enum_class.__qualname__ = qualname
+
+    return _lookup_class_or_track(class_tracker_id, enum_class)
+
+
+def _make_typevar(name, bound, constraints, covariant, contravariant, class_tracker_id):
+    tv = typing.TypeVar(
+        name,
+        *constraints,
+        bound=bound,
+        covariant=covariant,
+        contravariant=contravariant,
+    )
+    return _lookup_class_or_track(class_tracker_id, tv)
+
+
+def _decompose_typevar(obj):
+    return (
+        obj.__name__,
+        obj.__bound__,
+        obj.__constraints__,
+        obj.__covariant__,
+        obj.__contravariant__,
+        _get_or_create_tracker_id(obj),
+    )
+
+
+def _typevar_reduce(obj):
+    # TypeVar instances require the module information hence why we
+    # are not using the _should_pickle_by_reference directly
+    module_and_name = _lookup_module_and_qualname(obj, name=obj.__name__)
+
+    if module_and_name is None:
+        return (_make_typevar, _decompose_typevar(obj))
+    elif _is_registered_pickle_by_value(module_and_name[0]):
+        return (_make_typevar, _decompose_typevar(obj))
+
+    return (getattr, module_and_name)
+
+
+def _get_bases(typ):
+    if "__orig_bases__" in getattr(typ, "__dict__", {}):
+        # For generic types (see PEP 560)
+        # Note that simply checking `hasattr(typ, '__orig_bases__')` is not
+        # correct.  Subclasses of a fully-parameterized generic class does not
+        # have `__orig_bases__` defined, but `hasattr(typ, '__orig_bases__')`
+        # will return True because it's defined in the base class.
+        bases_attr = "__orig_bases__"
+    else:
+        # For regular class objects
+        bases_attr = "__bases__"
+    return getattr(typ, bases_attr)
+
+
+def _make_dict_keys(obj, is_ordered=False):
+    if is_ordered:
+        return OrderedDict.fromkeys(obj).keys()
+    else:
+        return dict.fromkeys(obj).keys()
+
+
+def _make_dict_values(obj, is_ordered=False):
+    if is_ordered:
+        return OrderedDict((i, _) for i, _ in enumerate(obj)).values()
+    else:
+        return {i: _ for i, _ in enumerate(obj)}.values()
+
+
+def _make_dict_items(obj, is_ordered=False):
+    if is_ordered:
+        return OrderedDict(obj).items()
+    else:
+        return obj.items()
+
+
+# COLLECTION OF OBJECTS __getnewargs__-LIKE METHODS
+# -------------------------------------------------
+
+
+def _class_getnewargs(obj):
+    type_kwargs = {}
+    if "__module__" in obj.__dict__:
+        type_kwargs["__module__"] = obj.__module__
+
+    __dict__ = obj.__dict__.get("__dict__", None)
+    if isinstance(__dict__, property):
+        type_kwargs["__dict__"] = __dict__
+
+    return (
+        type(obj),
+        obj.__name__,
+        _get_bases(obj),
+        type_kwargs,
+        _get_or_create_tracker_id(obj),
+        None,
+    )
+
+
+def _enum_getnewargs(obj):
+    members = {e.name: e.value for e in obj}
+    return (
+        obj.__bases__,
+        obj.__name__,
+        obj.__qualname__,
+        members,
+        obj.__module__,
+        _get_or_create_tracker_id(obj),
+        None,
+    )
+
+
+# COLLECTION OF OBJECTS RECONSTRUCTORS
+# ------------------------------------
+def _file_reconstructor(retval):
+    return retval
+
+
+# COLLECTION OF OBJECTS STATE GETTERS
+# -----------------------------------
+
+
+def _function_getstate(func):
+    # - Put func's dynamic attributes (stored in func.__dict__) in state. These
+    #   attributes will be restored at unpickling time using
+    #   f.__dict__.update(state)
+    # - Put func's members into slotstate. Such attributes will be restored at
+    #   unpickling time by iterating over slotstate and calling setattr(func,
+    #   slotname, slotvalue)
+    slotstate = {
+        "__name__": func.__name__,
+        "__qualname__": func.__qualname__,
+        "__annotations__": func.__annotations__,
+        "__kwdefaults__": func.__kwdefaults__,
+        "__defaults__": func.__defaults__,
+        "__module__": func.__module__,
+        "__doc__": func.__doc__,
+        "__closure__": func.__closure__,
+    }
+
+    f_globals_ref = _extract_code_globals(func.__code__)
+    f_globals = {k: func.__globals__[k] for k in f_globals_ref if k in func.__globals__}
+
+    if func.__closure__ is not None:
+        closure_values = list(map(_get_cell_contents, func.__closure__))
+    else:
+        closure_values = ()
+
+    # Extract currently-imported submodules used by func. Storing these modules
+    # in a smoke _cloudpickle_subimports attribute of the object's state will
+    # trigger the side effect of importing these modules at unpickling time
+    # (which is necessary for func to work correctly once depickled)
+    slotstate["_cloudpickle_submodules"] = _find_imported_submodules(
+        func.__code__, itertools.chain(f_globals.values(), closure_values)
+    )
+    slotstate["__globals__"] = f_globals
+
+    state = func.__dict__
+    return state, slotstate
+
+
+def _class_getstate(obj):
+    clsdict = _extract_class_dict(obj)
+    clsdict.pop("__weakref__", None)
+
+    if issubclass(type(obj), abc.ABCMeta):
+        # If obj is an instance of an ABCMeta subclass, don't pickle the
+        # cache/negative caches populated during isinstance/issubclass
+        # checks, but pickle the list of registered subclasses of obj.
+        clsdict.pop("_abc_cache", None)
+        clsdict.pop("_abc_negative_cache", None)
+        clsdict.pop("_abc_negative_cache_version", None)
+        registry = clsdict.pop("_abc_registry", None)
+        if registry is None:
+            # The abc caches and registered subclasses of a
+            # class are bundled into the single _abc_impl attribute
+            clsdict.pop("_abc_impl", None)
+            (registry, _, _, _) = abc._get_dump(obj)
+
+            clsdict["_abc_impl"] = [subclass_weakref() for subclass_weakref in registry]
+        else:
+            # In the above if clause, registry is a set of weakrefs -- in
+            # this case, registry is a WeakSet
+            clsdict["_abc_impl"] = [type_ for type_ in registry]
+
+    if "__slots__" in clsdict:
+        # pickle string length optimization: member descriptors of obj are
+        # created automatically from obj's __slots__ attribute, no need to
+        # save them in obj's state
+        if isinstance(obj.__slots__, str):
+            clsdict.pop(obj.__slots__)
+        else:
+            for k in obj.__slots__:
+                clsdict.pop(k, None)
+
+    clsdict.pop("__dict__", None)  # unpicklable property object
+
+    return (clsdict, {})
+
+
+def _enum_getstate(obj):
+    clsdict, slotstate = _class_getstate(obj)
+
+    members = {e.name: e.value for e in obj}
+    # Cleanup the clsdict that will be passed to _make_skeleton_enum:
+    # Those attributes are already handled by the metaclass.
+    for attrname in [
+        "_generate_next_value_",
+        "_member_names_",
+        "_member_map_",
+        "_member_type_",
+        "_value2member_map_",
+    ]:
+        clsdict.pop(attrname, None)
+    for member in members:
+        clsdict.pop(member)
+        # Special handling of Enum subclasses
+    return clsdict, slotstate
+
+
+# COLLECTIONS OF OBJECTS REDUCERS
+# -------------------------------
+# A reducer is a function taking a single argument (obj), and that returns a
+# tuple with all the necessary data to re-construct obj. Apart from a few
+# exceptions (list, dict, bytes, int, etc.), a reducer is necessary to
+# correctly pickle an object.
+# While many built-in objects (Exceptions objects, instances of the "object"
+# class, etc), are shipped with their own built-in reducer (invoked using
+# obj.__reduce__), some do not. The following methods were created to "fill
+# these holes".
+
+
+def _code_reduce(obj):
+    """code object reducer."""
+    # If you are not sure about the order of arguments, take a look at help
+    # of the specific type from types, for example:
+    # >>> from types import CodeType
+    # >>> help(CodeType)
+    if hasattr(obj, "co_exceptiontable"):
+        # Python 3.11 and later: there are some new attributes
+        # related to the enhanced exceptions.
+        args = (
+            obj.co_argcount,
+            obj.co_posonlyargcount,
+            obj.co_kwonlyargcount,
+            obj.co_nlocals,
+            obj.co_stacksize,
+            obj.co_flags,
+            obj.co_code,
+            obj.co_consts,
+            obj.co_names,
+            obj.co_varnames,
+            obj.co_filename,
+            obj.co_name,
+            obj.co_qualname,
+            obj.co_firstlineno,
+            obj.co_linetable,
+            obj.co_exceptiontable,
+            obj.co_freevars,
+            obj.co_cellvars,
+        )
+    elif hasattr(obj, "co_linetable"):
+        # Python 3.10 and later: obj.co_lnotab is deprecated and constructor
+        # expects obj.co_linetable instead.
+        args = (
+            obj.co_argcount,
+            obj.co_posonlyargcount,
+            obj.co_kwonlyargcount,
+            obj.co_nlocals,
+            obj.co_stacksize,
+            obj.co_flags,
+            obj.co_code,
+            obj.co_consts,
+            obj.co_names,
+            obj.co_varnames,
+            obj.co_filename,
+            obj.co_name,
+            obj.co_firstlineno,
+            obj.co_linetable,
+            obj.co_freevars,
+            obj.co_cellvars,
+        )
+    elif hasattr(obj, "co_nmeta"):  # pragma: no cover
+        # "nogil" Python: modified attributes from 3.9
+        args = (
+            obj.co_argcount,
+            obj.co_posonlyargcount,
+            obj.co_kwonlyargcount,
+            obj.co_nlocals,
+            obj.co_framesize,
+            obj.co_ndefaultargs,
+            obj.co_nmeta,
+            obj.co_flags,
+            obj.co_code,
+            obj.co_consts,
+            obj.co_varnames,
+            obj.co_filename,
+            obj.co_name,
+            obj.co_firstlineno,
+            obj.co_lnotab,
+            obj.co_exc_handlers,
+            obj.co_jump_table,
+            obj.co_freevars,
+            obj.co_cellvars,
+            obj.co_free2reg,
+            obj.co_cell2reg,
+        )
+    else:
+        # Backward compat for 3.8 and 3.9
+        args = (
+            obj.co_argcount,
+            obj.co_posonlyargcount,
+            obj.co_kwonlyargcount,
+            obj.co_nlocals,
+            obj.co_stacksize,
+            obj.co_flags,
+            obj.co_code,
+            obj.co_consts,
+            obj.co_names,
+            obj.co_varnames,
+            obj.co_filename,
+            obj.co_name,
+            obj.co_firstlineno,
+            obj.co_lnotab,
+            obj.co_freevars,
+            obj.co_cellvars,
+        )
+    return types.CodeType, args
+
+
+def _cell_reduce(obj):
+    """Cell (containing values of a function's free variables) reducer."""
+    try:
+        obj.cell_contents
+    except ValueError:  # cell is empty
+        return _make_empty_cell, ()
+    else:
+        return _make_cell, (obj.cell_contents,)
+
+
+def _classmethod_reduce(obj):
+    orig_func = obj.__func__
+    return type(obj), (orig_func,)
+
+
+def _file_reduce(obj):
+    """Save a file."""
+    import io
+
+    if not hasattr(obj, "name") or not hasattr(obj, "mode"):
+        raise pickle.PicklingError(
+            "Cannot pickle files that do not map to an actual file"
+        )
+    if obj is sys.stdout:
+        return getattr, (sys, "stdout")
+    if obj is sys.stderr:
+        return getattr, (sys, "stderr")
+    if obj is sys.stdin:
+        raise pickle.PicklingError("Cannot pickle standard input")
+    if obj.closed:
+        raise pickle.PicklingError("Cannot pickle closed files")
+    if hasattr(obj, "isatty") and obj.isatty():
+        raise pickle.PicklingError("Cannot pickle files that map to tty objects")
+    if "r" not in obj.mode and "+" not in obj.mode:
+        raise pickle.PicklingError(
+            "Cannot pickle files that are not opened for reading: %s" % obj.mode
+        )
+
+    name = obj.name
+
+    retval = io.StringIO()
+
+    try:
+        # Read the whole file
+        curloc = obj.tell()
+        obj.seek(0)
+        contents = obj.read()
+        obj.seek(curloc)
+    except OSError as e:
+        raise pickle.PicklingError(
+            "Cannot pickle file %s as it cannot be read" % name
+        ) from e
+    retval.write(contents)
+    retval.seek(curloc)
+
+    retval.name = name
+    return _file_reconstructor, (retval,)
+
+
+def _getset_descriptor_reduce(obj):
+    return getattr, (obj.__objclass__, obj.__name__)
+
+
+def _mappingproxy_reduce(obj):
+    return types.MappingProxyType, (dict(obj),)
+
+
+def _memoryview_reduce(obj):
+    return bytes, (obj.tobytes(),)
+
+
+def _module_reduce(obj):
+    if _should_pickle_by_reference(obj):
+        return subimport, (obj.__name__,)
+    else:
+        # Some external libraries can populate the "__builtins__" entry of a
+        # module's `__dict__` with unpicklable objects (see #316). For that
+        # reason, we do not attempt to pickle the "__builtins__" entry, and
+        # restore a default value for it at unpickling time.
+        state = obj.__dict__.copy()
+        state.pop("__builtins__", None)
+        return dynamic_subimport, (obj.__name__, state)
+
+
+def _method_reduce(obj):
+    return (types.MethodType, (obj.__func__, obj.__self__))
+
+
+def _logger_reduce(obj):
+    return logging.getLogger, (obj.name,)
+
+
+def _root_logger_reduce(obj):
+    return logging.getLogger, ()
+
+
+def _property_reduce(obj):
+    return property, (obj.fget, obj.fset, obj.fdel, obj.__doc__)
+
+
+def _weakset_reduce(obj):
+    return weakref.WeakSet, (list(obj),)
+
+
+def _dynamic_class_reduce(obj):
+    """Save a class that can't be referenced as a module attribute.
+
+    This method is used to serialize classes that are defined inside
+    functions, or that otherwise can't be serialized as attribute lookups
+    from importable modules.
+    """
+    if Enum is not None and issubclass(obj, Enum):
+        return (
+            _make_skeleton_enum,
+            _enum_getnewargs(obj),
+            _enum_getstate(obj),
+            None,
+            None,
+            _class_setstate,
+        )
+    else:
+        return (
+            _make_skeleton_class,
+            _class_getnewargs(obj),
+            _class_getstate(obj),
+            None,
+            None,
+            _class_setstate,
+        )
+
+
+def _class_reduce(obj):
+    """Select the reducer depending on the dynamic nature of the class obj."""
+    if obj is type(None):  # noqa
+        return type, (None,)
+    elif obj is type(Ellipsis):
+        return type, (Ellipsis,)
+    elif obj is type(NotImplemented):
+        return type, (NotImplemented,)
+    elif obj in _BUILTIN_TYPE_NAMES:
+        return _builtin_type, (_BUILTIN_TYPE_NAMES[obj],)
+    elif not _should_pickle_by_reference(obj):
+        return _dynamic_class_reduce(obj)
+    return NotImplemented
+
+
+def _dict_keys_reduce(obj):
+    # Safer not to ship the full dict as sending the rest might
+    # be unintended and could potentially cause leaking of
+    # sensitive information
+    return _make_dict_keys, (list(obj),)
+
+
+def _dict_values_reduce(obj):
+    # Safer not to ship the full dict as sending the rest might
+    # be unintended and could potentially cause leaking of
+    # sensitive information
+    return _make_dict_values, (list(obj),)
+
+
+def _dict_items_reduce(obj):
+    return _make_dict_items, (dict(obj),)
+
+
+def _odict_keys_reduce(obj):
+    # Safer not to ship the full dict as sending the rest might
+    # be unintended and could potentially cause leaking of
+    # sensitive information
+    return _make_dict_keys, (list(obj), True)
+
+
+def _odict_values_reduce(obj):
+    # Safer not to ship the full dict as sending the rest might
+    # be unintended and could potentially cause leaking of
+    # sensitive information
+    return _make_dict_values, (list(obj), True)
+
+
+def _odict_items_reduce(obj):
+    return _make_dict_items, (dict(obj), True)
+
+
+def _dataclass_field_base_reduce(obj):
+    return _get_dataclass_field_type_sentinel, (obj.name,)
+
+
+# COLLECTIONS OF OBJECTS STATE SETTERS
+# ------------------------------------
+# state setters are called at unpickling time, once the object is created and
+# it has to be updated to how it was at unpickling time.
+
+
+def _function_setstate(obj, state):
+    """Update the state of a dynamic function.
+
+    As __closure__ and __globals__ are readonly attributes of a function, we
+    cannot rely on the native setstate routine of pickle.load_build, that calls
+    setattr on items of the slotstate. Instead, we have to modify them inplace.
+    """
+    state, slotstate = state
+    obj.__dict__.update(state)
+
+    obj_globals = slotstate.pop("__globals__")
+    obj_closure = slotstate.pop("__closure__")
+    # _cloudpickle_subimports is a set of submodules that must be loaded for
+    # the pickled function to work correctly at unpickling time. Now that these
+    # submodules are depickled (hence imported), they can be removed from the
+    # object's state (the object state only served as a reference holder to
+    # these submodules)
+    slotstate.pop("_cloudpickle_submodules")
+
+    obj.__globals__.update(obj_globals)
+    obj.__globals__["__builtins__"] = __builtins__
+
+    if obj_closure is not None:
+        for i, cell in enumerate(obj_closure):
+            try:
+                value = cell.cell_contents
+            except ValueError:  # cell is empty
+                continue
+            obj.__closure__[i].cell_contents = value
+
+    for k, v in slotstate.items():
+        setattr(obj, k, v)
+
+
+def _class_setstate(obj, state):
+    # Check if class is being reused and needs bypass setstate logic.
+    if obj in _DYNAMIC_CLASS_TRACKER_REUSING:
+        return obj
+    state, slotstate = state
+    registry = None
+    for attrname, attr in state.items():
+        if attrname == "_abc_impl":
+            registry = attr
+        else:
+            setattr(obj, attrname, attr)
+    if registry is not None:
+        for subclass in registry:
+            obj.register(subclass)
+
+    return obj
+
+
+# COLLECTION OF DATACLASS UTILITIES
+# ---------------------------------
+# There are some internal sentinel values whose identity must be preserved when
+# unpickling dataclass fields. Each sentinel value has a unique name that we can
+# use to retrieve its identity at unpickling time.
+
+
+_DATACLASSE_FIELD_TYPE_SENTINELS = {
+    dataclasses._FIELD.name: dataclasses._FIELD,
+    dataclasses._FIELD_CLASSVAR.name: dataclasses._FIELD_CLASSVAR,
+    dataclasses._FIELD_INITVAR.name: dataclasses._FIELD_INITVAR,
+}
+
+
+def _get_dataclass_field_type_sentinel(name):
+    return _DATACLASSE_FIELD_TYPE_SENTINELS[name]
+
+
+class Pickler(pickle.Pickler):
+    # set of reducers defined and used by cloudpickle (private)
+    _dispatch_table = {}
+    _dispatch_table[classmethod] = _classmethod_reduce
+    _dispatch_table[io.TextIOWrapper] = _file_reduce
+    _dispatch_table[logging.Logger] = _logger_reduce
+    _dispatch_table[logging.RootLogger] = _root_logger_reduce
+    _dispatch_table[memoryview] = _memoryview_reduce
+    _dispatch_table[property] = _property_reduce
+    _dispatch_table[staticmethod] = _classmethod_reduce
+    _dispatch_table[CellType] = _cell_reduce
+    _dispatch_table[types.CodeType] = _code_reduce
+    _dispatch_table[types.GetSetDescriptorType] = _getset_descriptor_reduce
+    _dispatch_table[types.ModuleType] = _module_reduce
+    _dispatch_table[types.MethodType] = _method_reduce
+    _dispatch_table[types.MappingProxyType] = _mappingproxy_reduce
+    _dispatch_table[weakref.WeakSet] = _weakset_reduce
+    _dispatch_table[typing.TypeVar] = _typevar_reduce
+    _dispatch_table[_collections_abc.dict_keys] = _dict_keys_reduce
+    _dispatch_table[_collections_abc.dict_values] = _dict_values_reduce
+    _dispatch_table[_collections_abc.dict_items] = _dict_items_reduce
+    _dispatch_table[type(OrderedDict().keys())] = _odict_keys_reduce
+    _dispatch_table[type(OrderedDict().values())] = _odict_values_reduce
+    _dispatch_table[type(OrderedDict().items())] = _odict_items_reduce
+    _dispatch_table[abc.abstractmethod] = _classmethod_reduce
+    _dispatch_table[abc.abstractclassmethod] = _classmethod_reduce
+    _dispatch_table[abc.abstractstaticmethod] = _classmethod_reduce
+    _dispatch_table[abc.abstractproperty] = _property_reduce
+    _dispatch_table[dataclasses._FIELD_BASE] = _dataclass_field_base_reduce
+
+    dispatch_table = ChainMap(_dispatch_table, copyreg.dispatch_table)
+
+    # function reducers are defined as instance methods of cloudpickle.Pickler
+    # objects, as they rely on a cloudpickle.Pickler attribute (globals_ref)
+    def _dynamic_function_reduce(self, func):
+        """Reduce a function that is not pickleable via attribute lookup."""
+        newargs = self._function_getnewargs(func)
+        state = _function_getstate(func)
+        return (_make_function, newargs, state, None, None, _function_setstate)
+
+    def _function_reduce(self, obj):
+        """Reducer for function objects.
+
+        If obj is a top-level attribute of a file-backed module, this reducer
+        returns NotImplemented, making the cloudpickle.Pickler fall back to
+        traditional pickle.Pickler routines to save obj. Otherwise, it reduces
+        obj using a custom cloudpickle reducer designed specifically to handle
+        dynamic functions.
+        """
+        if _should_pickle_by_reference(obj):
+            return NotImplemented
+        else:
+            return self._dynamic_function_reduce(obj)
+
+    def _function_getnewargs(self, func):
+        code = func.__code__
+
+        # base_globals represents the future global namespace of func at
+        # unpickling time. Looking it up and storing it in
+        # cloudpickle.Pickler.globals_ref allow functions sharing the same
+        # globals at pickling time to also share them once unpickled, at one
+        # condition: since globals_ref is an attribute of a cloudpickle.Pickler
+        # instance, and that a new cloudpickle.Pickler is created each time
+        # cloudpickle.dump or cloudpickle.dumps is called, functions also need
+        # to be saved within the same invocation of
+        # cloudpickle.dump/cloudpickle.dumps (for example:
+        # cloudpickle.dumps([f1, f2])). There is no such limitation when using
+        # cloudpickle.Pickler.dump, as long as the multiple invocations are
+        # bound to the same cloudpickle.Pickler instance.
+        base_globals = self.globals_ref.setdefault(id(func.__globals__), {})
+
+        if base_globals == {}:
+            # Add module attributes used to resolve relative imports
+            # instructions inside func.
+            for k in ["__package__", "__name__", "__path__", "__file__"]:
+                if k in func.__globals__:
+                    base_globals[k] = func.__globals__[k]
+
+        # Do not bind the free variables before the function is created to
+        # avoid infinite recursion.
+        if func.__closure__ is None:
+            closure = None
+        else:
+            closure = tuple(_make_empty_cell() for _ in range(len(code.co_freevars)))
+
+        return code, base_globals, None, None, closure
+
+    def dump(self, obj):
+        try:
+            return super().dump(obj)
+        except RuntimeError as e:
+            if len(e.args) > 0 and "recursion" in e.args[0]:
+                msg = "Could not pickle object as excessively deep recursion required."
+                raise pickle.PicklingError(msg) from e
+            else:
+                raise
+
+    def __init__(self, file, protocol=None, buffer_callback=None):
+        if protocol is None:
+            protocol = DEFAULT_PROTOCOL
+        super().__init__(file, protocol=protocol, buffer_callback=buffer_callback)
+        # map functions __globals__ attribute ids, to ensure that functions
+        # sharing the same global namespace at pickling time also share
+        # their global namespace at unpickling time.
+        self.globals_ref = {}
+        self.proto = int(protocol)
+
+    if not PYPY:
+        # pickle.Pickler is the C implementation of the CPython pickler and
+        # therefore we rely on reduce_override method to customize the pickler
+        # behavior.
+
+        # `cloudpickle.Pickler.dispatch` is only left for backward
+        # compatibility - note that when using protocol 5,
+        # `cloudpickle.Pickler.dispatch` is not an extension of
+        # `pickle._Pickler.dispatch` dictionary, because `cloudpickle.Pickler`
+        # subclasses the C-implemented `pickle.Pickler`, which does not expose
+        # a `dispatch` attribute.  Earlier versions of `cloudpickle.Pickler`
+        # used `cloudpickle.Pickler.dispatch` as a class-level attribute
+        # storing all reducers implemented by cloudpickle, but the attribute
+        # name was not a great choice given because it would collide with a
+        # similarly named attribute in the pure-Python `pickle._Pickler`
+        # implementation in the standard library.
+        dispatch = dispatch_table
+
+        # Implementation of the reducer_override callback, in order to
+        # efficiently serialize dynamic functions and classes by subclassing
+        # the C-implemented `pickle.Pickler`.
+        # TODO: decorrelate reducer_override (which is tied to CPython's
+        # implementation - would it make sense to backport it to pypy? - and
+        # pickle's protocol 5 which is implementation agnostic. Currently, the
+        # availability of both notions coincide on CPython's pickle, but it may
+        # not be the case anymore when pypy implements protocol 5.
+
+        def reducer_override(self, obj):
+            """Type-agnostic reducing callback for function and classes.
+
+            For performance reasons, subclasses of the C `pickle.Pickler` class
+            cannot register custom reducers for functions and classes in the
+            dispatch_table attribute. Reducers for such types must instead
+            implemented via the special `reducer_override` method.
+
+            Note that this method will be called for any object except a few
+            builtin-types (int, lists, dicts etc.), which differs from reducers
+            in the Pickler's dispatch_table, each of them being invoked for
+            objects of a specific type only.
+
+            This property comes in handy for classes: although most classes are
+            instances of the ``type`` metaclass, some of them can be instances
+            of other custom metaclasses (such as enum.EnumMeta for example). In
+            particular, the metaclass will likely not be known in advance, and
+            thus cannot be special-cased using an entry in the dispatch_table.
+            reducer_override, among other things, allows us to register a
+            reducer that will be called for any class, independently of its
+            type.
+
+            Notes:
+
+            * reducer_override has the priority over dispatch_table-registered
+            reducers.
+            * reducer_override can be used to fix other limitations of
+              cloudpickle for other types that suffered from type-specific
+              reducers, such as Exceptions. See
+              https://github.com/cloudpipe/cloudpickle/issues/248
+            """
+            t = type(obj)
+            try:
+                is_anyclass = issubclass(t, type)
+            except TypeError:  # t is not a class (old Boost; see SF #502085)
+                is_anyclass = False
+
+            if is_anyclass:
+                return _class_reduce(obj)
+            elif isinstance(obj, types.FunctionType):
+                return self._function_reduce(obj)
+            else:
+                # fallback to save_global, including the Pickler's
+                # dispatch_table
+                return NotImplemented
+
+    else:
+        # When reducer_override is not available, hack the pure-Python
+        # Pickler's types.FunctionType and type savers. Note: the type saver
+        # must override Pickler.save_global, because pickle.py contains a
+        # hard-coded call to save_global when pickling meta-classes.
+        dispatch = pickle.Pickler.dispatch.copy()
+
+        def _save_reduce_pickle5(
+            self,
+            func,
+            args,
+            state=None,
+            listitems=None,
+            dictitems=None,
+            state_setter=None,
+            obj=None,
+        ):
+            save = self.save
+            write = self.write
+            self.save_reduce(
+                func,
+                args,
+                state=None,
+                listitems=listitems,
+                dictitems=dictitems,
+                obj=obj,
+            )
+            # backport of the Python 3.8 state_setter pickle operations
+            save(state_setter)
+            save(obj)  # simple BINGET opcode as obj is already memoized.
+            save(state)
+            write(pickle.TUPLE2)
+            # Trigger a state_setter(obj, state) function call.
+            write(pickle.REDUCE)
+            # The purpose of state_setter is to carry-out an
+            # inplace modification of obj. We do not care about what the
+            # method might return, so its output is eventually removed from
+            # the stack.
+            write(pickle.POP)
+
+        def save_global(self, obj, name=None, pack=struct.pack):
+            """Main dispatch method.
+
+            The name of this method is somewhat misleading: all types get
+            dispatched here.
+            """
+            if obj is type(None):  # noqa
+                return self.save_reduce(type, (None,), obj=obj)
+            elif obj is type(Ellipsis):
+                return self.save_reduce(type, (Ellipsis,), obj=obj)
+            elif obj is type(NotImplemented):
+                return self.save_reduce(type, (NotImplemented,), obj=obj)
+            elif obj in _BUILTIN_TYPE_NAMES:
+                return self.save_reduce(
+                    _builtin_type, (_BUILTIN_TYPE_NAMES[obj],), obj=obj
+                )
+
+            if name is not None:
+                super().save_global(obj, name=name)
+            elif not _should_pickle_by_reference(obj, name=name):
+                self._save_reduce_pickle5(*_dynamic_class_reduce(obj), obj=obj)
+            else:
+                super().save_global(obj, name=name)
+
+        dispatch[type] = save_global
+
+        def save_function(self, obj, name=None):
+            """Registered with the dispatch to handle all function types.
+
+            Determines what kind of function obj is (e.g. lambda, defined at
+            interactive prompt, etc) and handles the pickling appropriately.
+            """
+            if _should_pickle_by_reference(obj, name=name):
+                return super().save_global(obj, name=name)
+            elif PYPY and isinstance(obj.__code__, builtin_code_type):
+                return self.save_pypy_builtin_func(obj)
+            else:
+                return self._save_reduce_pickle5(
+                    *self._dynamic_function_reduce(obj), obj=obj
+                )
+
+        def save_pypy_builtin_func(self, obj):
+            """Save pypy equivalent of builtin functions.
+
+            PyPy does not have the concept of builtin-functions. Instead,
+            builtin-functions are simple function instances, but with a
+            builtin-code attribute.
+            Most of the time, builtin functions should be pickled by attribute.
+            But PyPy has flaky support for __qualname__, so some builtin
+            functions such as float.__new__ will be classified as dynamic. For
+            this reason only, we created this special routine. Because
+            builtin-functions are not expected to have closure or globals,
+            there is no additional hack (compared the one already implemented
+            in pickle) to protect ourselves from reference cycles. A simple
+            (reconstructor, newargs, obj.__dict__) tuple is save_reduced.  Note
+            also that PyPy improved their support for __qualname__ in v3.6, so
+            this routing should be removed when cloudpickle supports only PyPy
+            3.6 and later.
+            """
+            rv = (
+                types.FunctionType,
+                (obj.__code__, {}, obj.__name__, obj.__defaults__, obj.__closure__),
+                obj.__dict__,
+            )
+            self.save_reduce(*rv, obj=obj)
+
+        dispatch[types.FunctionType] = save_function
+
+
+# Shorthands similar to pickle.dump/pickle.dumps
+
+
+def dump(obj, file, protocol=None, buffer_callback=None):
+    """Serialize obj as bytes streamed into file
+
+    protocol defaults to cloudpickle.DEFAULT_PROTOCOL which is an alias to
+    pickle.HIGHEST_PROTOCOL. This setting favors maximum communication
+    speed between processes running the same Python version.
+
+    Set protocol=pickle.DEFAULT_PROTOCOL instead if you need to ensure
+    compatibility with older versions of Python (although this is not always
+    guaranteed to work because cloudpickle relies on some internal
+    implementation details that can change from one Python version to the
+    next).
+    """
+    Pickler(file, protocol=protocol, buffer_callback=buffer_callback).dump(obj)
+
+
+def dumps(obj, protocol=None, buffer_callback=None):
+    """Serialize obj as a string of bytes allocated in memory
+
+    protocol defaults to cloudpickle.DEFAULT_PROTOCOL which is an alias to
+    pickle.HIGHEST_PROTOCOL. This setting favors maximum communication
+    speed between processes running the same Python version.
+
+    Set protocol=pickle.DEFAULT_PROTOCOL instead if you need to ensure
+    compatibility with older versions of Python (although this is not always
+    guaranteed to work because cloudpickle relies on some internal
+    implementation details that can change from one Python version to the
+    next).
+    """
+    with io.BytesIO() as file:
+        cp = Pickler(file, protocol=protocol, buffer_callback=buffer_callback)
+        cp.dump(obj)
+        return file.getvalue()
+
+
+# Include pickles unloading functions in this namespace for convenience.
+load, loads = pickle.load, pickle.loads
+
+# Backward compat alias.
+CloudPickler = Pickler

lib/python3.10/site-packages/numba/cloudpickle/cloudpickle_fast.py

@@ -0,0 +1,13 @@
+"""Compatibility module.
+
+It can be necessary to load files generated by previous versions of cloudpickle
+that rely on symbols being defined under the `cloudpickle.cloudpickle_fast`
+namespace.
+
+See: tests/test_backward_compat.py
+"""
+from . import cloudpickle
+
+
+def __getattr__(name):
+    return getattr(cloudpickle, name)

lib/python3.10/site-packages/numba/core/annotations/pretty_annotate.py

@@ -0,0 +1,283 @@
+"""
+This module implements code highlighting of numba function annotations.
+"""
+
+from warnings import warn
+
+warn("The pretty_annotate functionality is experimental and might change API",
+         FutureWarning)
+
+def hllines(code, style):
+    try:
+        from pygments import highlight
+        from pygments.lexers import PythonLexer
+        from pygments.formatters import HtmlFormatter
+    except ImportError:
+        raise ImportError("please install the 'pygments' package")
+    pylex = PythonLexer()
+    "Given a code string, return a list of html-highlighted lines"
+    hf = HtmlFormatter(noclasses=True, style=style, nowrap=True)
+    res = highlight(code, pylex, hf)
+    return res.splitlines()
+
+
+def htlines(code, style):
+    try:
+        from pygments import highlight
+        from pygments.lexers import PythonLexer
+        # TerminalFormatter does not support themes, Terminal256 should,
+        # but seem to not work.
+        from pygments.formatters import TerminalFormatter
+    except ImportError:
+        raise ImportError("please install the 'pygments' package")
+    pylex = PythonLexer()
+    "Given a code string, return a list of ANSI-highlighted lines"
+    hf = TerminalFormatter(style=style)
+    res = highlight(code, pylex, hf)
+    return res.splitlines()
+
+def get_ansi_template():
+    try:
+        from jinja2 import Template
+    except ImportError:
+        raise ImportError("please install the 'jinja2' package")
+    return Template("""
+    {%- for func_key in func_data.keys() -%}
+        Function name: \x1b[34m{{func_data[func_key]['funcname']}}\x1b[39;49;00m
+        {%- if func_data[func_key]['filename'] -%}
+        {{'\n'}}In file: \x1b[34m{{func_data[func_key]['filename'] -}}\x1b[39;49;00m
+        {%- endif -%}
+        {{'\n'}}With signature: \x1b[34m{{func_key[1]}}\x1b[39;49;00m
+        {{- "\n" -}}
+        {%- for num, line, hl, hc in func_data[func_key]['pygments_lines'] -%}
+                {{-'\n'}}{{ num}}: {{hc-}}
+                {%- if func_data[func_key]['ir_lines'][num] -%}
+                    {%- for ir_line, ir_line_type in func_data[func_key]['ir_lines'][num] %}
+                        {{-'\n'}}--{{- ' '*func_data[func_key]['python_indent'][num]}}
+                        {{- ' '*(func_data[func_key]['ir_indent'][num][loop.index0]+4)
+                        }}{{ir_line }}\x1b[41m{{ir_line_type-}}\x1b[39;49;00m
+                    {%- endfor -%}
+                {%- endif -%}
+            {%- endfor -%}
+    {%- endfor -%}
+    """)
+    return ansi_template
+
+def get_html_template():
+    try:
+        from jinja2 import Template
+    except ImportError:
+        raise ImportError("please install the 'jinja2' package")
+    return Template("""
+    <html>
+    <head>
+        <style>
+
+            .annotation_table {
+                color: #000000;
+                font-family: monospace;
+                margin: 5px;
+                width: 100%;
+            }
+
+            /* override JupyterLab style */
+            .annotation_table td {
+                text-align: left;
+                background-color: transparent; 
+                padding: 1px;
+            }
+
+            .annotation_table tbody tr:nth-child(even) {
+                background: white;
+            }
+
+            .annotation_table code
+            {
+                background-color: transparent; 
+                white-space: normal;
+            }
+
+            /* End override JupyterLab style */
+
+            tr:hover {
+                background-color: rgba(92, 200, 249, 0.25);
+            }
+
+            td.object_tag summary ,
+            td.lifted_tag summary{
+                font-weight: bold;
+                display: list-item;
+            }
+
+            span.lifted_tag {
+                color: #00cc33;
+            }
+
+            span.object_tag {
+                color: #cc3300;
+            }
+
+
+            td.lifted_tag {
+                background-color: #cdf7d8;
+            }
+
+            td.object_tag {
+                background-color: #fef5c8;
+            }
+
+            code.ir_code {
+                color: grey;
+                font-style: italic;
+            }
+
+            .metadata {
+                border-bottom: medium solid black;
+                display: inline-block;
+                padding: 5px;
+                width: 100%;
+            }
+
+            .annotations {
+                padding: 5px;
+            }
+
+            .hidden {
+                display: none;
+            }
+
+            .buttons {
+                padding: 10px;
+                cursor: pointer;
+            }
+        </style>
+    </head>
+
+    <body>
+        {% for func_key in func_data.keys() %}
+            <div class="metadata">
+            Function name: {{func_data[func_key]['funcname']}}<br />
+            {% if func_data[func_key]['filename'] %}
+                in file: {{func_data[func_key]['filename']|escape}}<br />
+            {% endif %}
+            with signature: {{func_key[1]|e}}
+            </div>
+            <div class="annotations">
+            <table class="annotation_table tex2jax_ignore">
+                {%- for num, line, hl, hc in func_data[func_key]['pygments_lines'] -%}
+                    {%- if func_data[func_key]['ir_lines'][num] %}
+                        <tr><td style="text-align:left;" class="{{func_data[func_key]['python_tags'][num]}}">
+                            <details>
+                                <summary>
+                                    <code>
+                                    {{num}}:
+                                    {{'&nbsp;'*func_data[func_key]['python_indent'][num]}}{{hl}}
+                                    </code>
+                                </summary>
+                                <table class="annotation_table">
+                                    <tbody>
+                                        {%- for ir_line, ir_line_type in func_data[func_key]['ir_lines'][num] %}
+                                            <tr class="ir_code">
+                                                <td style="text-align: left;"><code>
+                                                &nbsp;
+                                                {{- '&nbsp;'*func_data[func_key]['python_indent'][num]}}
+                                                {{ '&nbsp;'*func_data[func_key]['ir_indent'][num][loop.index0]}}{{ir_line|e -}}
+                                                <span class="object_tag">{{ir_line_type}}</span>
+                                                </code>
+                                                </td>
+                                            </tr>
+                                        {%- endfor -%}
+                                    </tbody>
+                                </table>
+                                </details>
+                        </td></tr>
+                    {% else -%}
+                        <tr><td style="text-align:left; padding-left: 22px;" class="{{func_data[func_key]['python_tags'][num]}}">
+                            <code>
+                                {{num}}:
+                                {{'&nbsp;'*func_data[func_key]['python_indent'][num]}}{{hl}}
+                            </code>
+                        </td></tr>
+                    {%- endif -%}
+                {%- endfor -%}
+            </table>
+            </div>
+        {% endfor %}
+    </body>
+    </html>
+    """)
+
+
+def reform_code(annotation):
+    """
+    Extract the code from the Numba annotation datastructure. 
+
+    Pygments can only highlight full multi-line strings, the Numba
+    annotation is list of single lines, with indentation removed.
+    """
+    ident_dict = annotation['python_indent']
+    s= ''
+    for n,l in annotation['python_lines']:
+        s = s+' '*ident_dict[n]+l+'\n'
+    return s
+
+
+class Annotate:
+    """
+    Construct syntax highlighted annotation for a given jitted function:
+
+    Example:
+
+    >>> import numba
+    >>> from numba.pretty_annotate import Annotate
+    >>> @numba.jit
+    ... def test(q):
+    ...     res = 0
+    ...     for i in range(q):
+    ...         res += i
+    ...     return res
+    ...
+    >>> test(10)
+    45
+    >>> Annotate(test)
+
+    The last line will return an HTML and/or ANSI representation that will be
+    displayed accordingly in Jupyter/IPython.
+
+    Function annotations persist across compilation for newly encountered
+    type signatures and as a result annotations are shown for all signatures
+    by default.
+
+    Annotations for a specific signature can be shown by using the
+    ``signature`` parameter.
+
+    >>> @numba.jit
+    ... def add(x, y):
+    ...     return x + y
+    ...
+    >>> add(1, 2)
+    3
+    >>> add(1.3, 5.7)
+    7.0
+    >>> add.signatures
+    [(int64, int64), (float64, float64)]
+    >>> Annotate(add, signature=add.signatures[1])  # annotation for (float64, float64)
+    """
+    def __init__(self, function, signature=None, **kwargs):
+
+        style = kwargs.get('style', 'default')
+        if not function.signatures:
+            raise ValueError('function need to be jitted for at least one signature')
+        ann = function.get_annotation_info(signature=signature)
+        self.ann = ann
+
+        for k,v in ann.items():
+            res = hllines(reform_code(v), style)
+            rest = htlines(reform_code(v), style)
+            v['pygments_lines'] = [(a,b,c, d) for (a,b),c, d in zip(v['python_lines'], res, rest)]
+
+    def _repr_html_(self):
+        return get_html_template().render(func_data=self.ann)
+
+    def __repr__(self):
+        return get_ansi_template().render(func_data=self.ann)

lib/python3.10/site-packages/numba/core/annotations/template.html

@@ -0,0 +1,144 @@
+<html>
+
+<head>
+
+<style>
+
+.annotation_table {
+    color: #000000;
+    font-family: monospace;
+    margin: 5px;
+    width: 100%;
+}
+
+/* override JupyterLab style */
+.annotation_table td {
+    text-align: left;
+    background-color: transparent; 
+    padding: 1px;
+}
+
+.annotation_table code
+{
+    background-color: transparent; 
+    white-space: normal;
+}
+
+/* End override JupyterLab style */
+
+tr:hover {
+    background-color: rgba(92, 200, 249, 0.25);
+}
+
+td.object_tag summary ,
+td.lifted_tag summary{
+    font-weight: bold;
+    display: list-item;
+}
+
+span.lifted_tag {
+    color: #00cc33;
+}
+
+span.object_tag {
+    color: #cc3300;
+}
+
+
+td.lifted_tag {
+    background-color: #cdf7d8;
+}
+
+td.object_tag {
+    background-color: #ffd3d3;
+}
+
+code.ir_code {
+    color: grey;
+    font-style: italic;
+}
+
+.metadata {
+    border-bottom: medium solid black;
+    display: inline-block;
+    padding: 5px;
+    width: 100%;
+}
+
+.annotations {
+padding: 5px;
+}
+
+.hidden {
+display: none;
+}
+
+.buttons {
+padding: 10px;
+cursor: pointer;
+}
+
+</style>
+
+</head>
+
+<body>
+
+    {% for func_key in func_data.keys() %}
+
+        {% set loop1 = loop %}
+
+        <div class="metadata">
+        Function name: {{func_data[func_key]['funcname']}}<br />
+        in file: {{func_data[func_key]['filename']}}<br />
+        with signature: {{func_key[1]|e}}
+        </div>
+
+        <div class="annotations">
+
+        <table class="annotation_table tex2jax_ignore">
+            {%- for num, line in func_data[func_key]['python_lines'] -%}
+                {%- if func_data[func_key]['ir_lines'][num] %}
+                    <tr><td class="{{func_data[func_key]['python_tags'][num]}}">
+                        <details>
+                            <summary>
+                                <code>
+                                {{num}}:
+                                {{func_data[func_key]['python_indent'][num]}}{{line|e}}
+                                </code>
+                            </summary>
+                            <table class="annotation_table">
+                                <tbody>
+                                    {%- for ir_line, ir_line_type in func_data[func_key]['ir_lines'][num] %}
+                                        <tr class="ir_code func{{loop1.index0}}_ir">
+                                            <td><code>&nbsp;
+                                            {{- func_data[func_key]['python_indent'][num]}}
+                                            {{func_data[func_key]['ir_indent'][num][loop.index0]}}{{ir_line|e -}}
+                                            <span class="object_tag">{{ir_line_type}}</span>
+                                            </code>
+                                            </td>
+                                        </tr>
+                                    {%- endfor -%}
+                                </tbody>
+                            </table>
+                            </details>
+                    </td></tr>
+                {% else -%}
+                    <tr><td style=" padding-left: 22px;" class="{{func_data[func_key]['python_tags'][num]}}">
+                        <code>
+                            {{num}}:
+                            {{func_data[func_key]['python_indent'][num]}}{{line|e}}
+                        </code>
+                    </td></tr>
+                {%- endif -%}
+            {%- endfor -%}
+        </table>
+        </div>
+
+        <br /><br /><br />
+
+    {% endfor %}
+
+</body>
+
+</html>

lib/python3.10/site-packages/numba/core/annotations/type_annotations.py

@@ -0,0 +1,283 @@
+from collections import defaultdict, OrderedDict
+from collections.abc import Mapping
+from contextlib import closing
+import copy
+import inspect
+import os
+import re
+import sys
+import textwrap
+from io import StringIO
+
+import numba.core.dispatcher
+from numba.core import ir
+
+
+class SourceLines(Mapping):
+    def __init__(self, func):
+
+        try:
+            lines, startno = inspect.getsourcelines(func)
+        except OSError:
+            self.lines = ()
+            self.startno = 0
+        else:
+            self.lines = textwrap.dedent(''.join(lines)).splitlines()
+            self.startno = startno
+
+    def __getitem__(self, lineno):
+        try:
+            return self.lines[lineno - self.startno].rstrip()
+        except IndexError:
+            return ''
+
+    def __iter__(self):
+        return iter((self.startno + i) for i in range(len(self.lines)))
+
+    def __len__(self):
+        return len(self.lines)
+
+    @property
+    def avail(self):
+        return bool(self.lines)
+
+
+class TypeAnnotation(object):
+
+    # func_data dict stores annotation data for all functions that are
+    # compiled. We store the data in the TypeAnnotation class since a new
+    # TypeAnnotation instance is created for each function that is compiled.
+    # For every function that is compiled, we add the type annotation data to
+    # this dict and write the html annotation file to disk (rewrite the html
+    # file for every function since we don't know if this is the last function
+    # to be compiled).
+    func_data = OrderedDict()
+
+    def __init__(self, func_ir, typemap, calltypes, lifted, lifted_from,
+                 args, return_type, html_output=None):
+        self.func_id = func_ir.func_id
+        self.blocks = func_ir.blocks
+        self.typemap = typemap
+        self.calltypes = calltypes
+        self.filename = func_ir.loc.filename
+        self.linenum = str(func_ir.loc.line)
+        self.signature = str(args) + ' -> ' + str(return_type)
+
+        # lifted loop information
+        self.lifted = lifted
+        self.num_lifted_loops = len(lifted)
+
+        # If this is a lifted loop function that is being compiled, lifted_from
+        # points to annotation data from function that this loop lifted function
+        # was lifted from. This is used to stick lifted loop annotations back
+        # into original function.
+        self.lifted_from = lifted_from
+
+    def prepare_annotations(self):
+        # Prepare annotations
+        groupedinst = defaultdict(list)
+        found_lifted_loop = False
+        #for blkid, blk in self.blocks.items():
+        for blkid in sorted(self.blocks.keys()):
+            blk = self.blocks[blkid]
+            groupedinst[blk.loc.line].append("label %s" % blkid)
+            for inst in blk.body:
+                lineno = inst.loc.line
+
+                if isinstance(inst, ir.Assign):
+                    if found_lifted_loop:
+                        atype = 'XXX Lifted Loop XXX'
+                        found_lifted_loop = False
+                    elif (isinstance(inst.value, ir.Expr) and
+                            inst.value.op ==  'call'):
+                        atype = self.calltypes[inst.value]
+                    elif (isinstance(inst.value, ir.Const) and
+                            isinstance(inst.value.value, numba.core.dispatcher.LiftedLoop)):
+                        atype = 'XXX Lifted Loop XXX'
+                        found_lifted_loop = True
+                    else:
+                        # TODO: fix parfor lowering so that typemap is valid.
+                        atype = self.typemap.get(inst.target.name, "<missing>")
+
+                    aline = "%s = %s  :: %s" % (inst.target, inst.value, atype)
+                elif isinstance(inst, ir.SetItem):
+                    atype = self.calltypes[inst]
+                    aline = "%s  :: %s" % (inst, atype)
+                else:
+                    aline = "%s" % inst
+                groupedinst[lineno].append("  %s" % aline)
+        return groupedinst
+
+    def annotate(self):
+        source = SourceLines(self.func_id.func)
+        # if not source.avail:
+        #     return "Source code unavailable"
+
+        groupedinst = self.prepare_annotations()
+
+        # Format annotations
+        io = StringIO()
+        with closing(io):
+            if source.avail:
+                print("# File: %s" % self.filename, file=io)
+                for num in source:
+                    srcline = source[num]
+                    ind = _getindent(srcline)
+                    print("%s# --- LINE %d --- " % (ind, num), file=io)
+                    for inst in groupedinst[num]:
+                        print('%s# %s' % (ind, inst), file=io)
+                    print(file=io)
+                    print(srcline, file=io)
+                    print(file=io)
+                if self.lifted:
+                    print("# The function contains lifted loops", file=io)
+                    for loop in self.lifted:
+                        print("# Loop at line %d" % loop.get_source_location(),
+                              file=io)
+                        print("# Has %d overloads" % len(loop.overloads),
+                              file=io)
+                        for cres in loop.overloads.values():
+                            print(cres.type_annotation, file=io)
+            else:
+                print("# Source code unavailable", file=io)
+                for num in groupedinst:
+                    for inst in groupedinst[num]:
+                        print('%s' % (inst,), file=io)
+                    print(file=io)
+
+            return io.getvalue()
+
+    def html_annotate(self, outfile):
+        # ensure that annotation information is assembled
+        self.annotate_raw()
+        # make a deep copy ahead of the pending mutations
+        func_data = copy.deepcopy(self.func_data)
+
+        key = 'python_indent'
+        for this_func in func_data.values():
+            if key in this_func:
+                idents = {}
+                for line, amount in this_func[key].items():
+                    idents[line] = '&nbsp;' * amount
+                this_func[key] = idents
+
+        key = 'ir_indent'
+        for this_func in func_data.values():
+            if key in this_func:
+                idents = {}
+                for line, ir_id in this_func[key].items():
+                    idents[line] = ['&nbsp;' * amount for amount in ir_id]
+                this_func[key] = idents
+
+
+
+        try:
+            from jinja2 import Template
+        except ImportError:
+            raise ImportError("please install the 'jinja2' package")
+
+        root = os.path.join(os.path.dirname(__file__))
+        template_filename = os.path.join(root, 'template.html')
+        with open(template_filename, 'r') as template:
+            html = template.read()
+
+        template = Template(html)
+        rendered = template.render(func_data=func_data)
+        outfile.write(rendered)
+
+    def annotate_raw(self):
+        """
+        This returns "raw" annotation information i.e. it has no output format
+        specific markup included.
+        """
+        python_source = SourceLines(self.func_id.func)
+        ir_lines = self.prepare_annotations()
+        line_nums = [num for num in python_source]
+        lifted_lines = [l.get_source_location() for l in self.lifted]
+
+        def add_ir_line(func_data, line):
+            line_str = line.strip()
+            line_type = ''
+            if line_str.endswith('pyobject'):
+                line_str = line_str.replace('pyobject', '')
+                line_type = 'pyobject'
+            func_data['ir_lines'][num].append((line_str, line_type))
+            indent_len = len(_getindent(line))
+            func_data['ir_indent'][num].append(indent_len)
+
+        func_key = (self.func_id.filename + ':' + str(self.func_id.firstlineno + 1),
+                    self.signature)
+        if self.lifted_from is not None and self.lifted_from[1]['num_lifted_loops'] > 0:
+            # This is a lifted loop function that is being compiled. Get the
+            # numba ir for lines in loop function to use for annotating
+            # original python function that the loop was lifted from.
+            func_data = self.lifted_from[1]
+            for num in line_nums:
+                if num not in ir_lines.keys():
+                    continue
+                func_data['ir_lines'][num] = []
+                func_data['ir_indent'][num] = []
+                for line in ir_lines[num]:
+                    add_ir_line(func_data, line)
+                    if line.strip().endswith('pyobject'):
+                        func_data['python_tags'][num] = 'object_tag'
+                        # If any pyobject line is found, make sure original python
+                        # line that was marked as a lifted loop start line is tagged
+                        # as an object line instead. Lifted loop start lines should
+                        # only be marked as lifted loop lines if the lifted loop
+                        # was successfully compiled in nopython mode.
+                        func_data['python_tags'][self.lifted_from[0]] = 'object_tag'
+
+            # We're done with this lifted loop, so decrement lifted loop counter.
+            # When lifted loop counter hits zero, that means we're ready to write
+            # out annotations to html file.
+            self.lifted_from[1]['num_lifted_loops'] -= 1
+
+        elif func_key not in TypeAnnotation.func_data.keys():
+            TypeAnnotation.func_data[func_key] = {}
+            func_data = TypeAnnotation.func_data[func_key]
+
+            for i, loop in enumerate(self.lifted):
+                # Make sure that when we process each lifted loop function later,
+                # we'll know where it originally came from.
+                loop.lifted_from = (lifted_lines[i], func_data)
+            func_data['num_lifted_loops'] = self.num_lifted_loops
+
+            func_data['filename'] = self.filename
+            func_data['funcname'] = self.func_id.func_name
+            func_data['python_lines'] = []
+            func_data['python_indent'] = {}
+            func_data['python_tags'] = {}
+            func_data['ir_lines'] = {}
+            func_data['ir_indent'] = {}
+
+            for num in line_nums:
+                func_data['python_lines'].append((num, python_source[num].strip()))
+                indent_len = len(_getindent(python_source[num]))
+                func_data['python_indent'][num] = indent_len
+                func_data['python_tags'][num] = ''
+                func_data['ir_lines'][num] = []
+                func_data['ir_indent'][num] = []
+
+                for line in ir_lines[num]:
+                    add_ir_line(func_data, line)
+                    if num in lifted_lines:
+                        func_data['python_tags'][num] = 'lifted_tag'
+                    elif line.strip().endswith('pyobject'):
+                        func_data['python_tags'][num] = 'object_tag'
+        return self.func_data
+
+
+    def __str__(self):
+        return self.annotate()
+
+
+re_longest_white_prefix = re.compile(r'^\s*')
+
+
+def _getindent(text):
+    m = re_longest_white_prefix.match(text)
+    if not m:
+        return ''
+    else:
+        return ' ' * len(m.group(0))

lib/python3.10/site-packages/numba/core/datamodel/__init__.py

@@ -0,0 +1,4 @@
+from .manager import DataModelManager
+from .packer import ArgPacker, DataPacker
+from .registry import register_default, default_manager, register
+from .models import PrimitiveModel, CompositeModel, StructModel # type: ignore

lib/python3.10/site-packages/numba/core/datamodel/manager.py

@@ -0,0 +1,68 @@
+import weakref
+from collections import ChainMap
+
+from numba.core import types
+
+
+class DataModelManager(object):
+    """Manages mapping of FE types to their corresponding data model
+    """
+
+    def __init__(self, handlers=None):
+        """
+        Parameters
+        -----------
+        handlers: Mapping[Type, DataModel] or None
+            Optionally provide the initial handlers mapping.
+        """
+        # { numba type class -> model factory }
+        self._handlers = handlers or {}
+        # { numba type instance -> model instance }
+        self._cache = weakref.WeakKeyDictionary()
+
+    def register(self, fetypecls, handler):
+        """Register the datamodel factory corresponding to a frontend-type class
+        """
+        assert issubclass(fetypecls, types.Type)
+        self._handlers[fetypecls] = handler
+
+    def lookup(self, fetype):
+        """Returns the corresponding datamodel given the frontend-type instance
+        """
+        try:
+            return self._cache[fetype]
+        except KeyError:
+            pass
+        handler = self._handlers[type(fetype)]
+        model = self._cache[fetype] = handler(self, fetype)
+        return model
+
+    def __getitem__(self, fetype):
+        """Shorthand for lookup()
+        """
+        return self.lookup(fetype)
+
+    def copy(self):
+        """
+        Make a copy of the manager.
+        Use this to inherit from the default data model and specialize it
+        for custom target.
+        """
+        return DataModelManager(self._handlers.copy())
+
+    def chain(self, other_manager):
+        """Create a new DataModelManager by chaining the handlers mapping of
+        `other_manager` with a fresh handlers mapping.
+
+        Any existing and new handlers inserted to `other_manager` will be
+        visible to the new manager. Any handlers inserted to the new manager
+        can override existing handlers in `other_manager` without actually
+        mutating `other_manager`.
+
+        Parameters
+        ----------
+        other_manager: DataModelManager
+        """
+        chained = ChainMap(self._handlers, other_manager._handlers)
+        return DataModelManager(chained)
+

lib/python3.10/site-packages/numba/core/datamodel/models.py

@@ -0,0 +1,12 @@
+import sys
+from numba.core.utils import _RedirectSubpackage
+from numba.core import config
+
+if config.USE_LEGACY_TYPE_SYSTEM: # type: ignore
+    sys.modules[__name__] = _RedirectSubpackage(
+        locals(), "numba.core.datamodel.old_models"
+    )
+else:
+    sys.modules[__name__] = _RedirectSubpackage(
+        locals(), "numba.core.datamodel.new_models"
+    )

lib/python3.10/site-packages/numba/core/datamodel/new_models.py

@@ -0,0 +1,1390 @@
+from functools import partial
+from collections import deque
+
+from llvmlite import ir
+
+from numba.core.datamodel.registry import register_default
+from numba.core import types, cgutils
+from numba.np import numpy_support
+
+
+class DataModel(object):
+    """
+    DataModel describe how a FE type is represented in the LLVM IR at
+    different contexts.
+
+    Contexts are:
+
+    - value: representation inside function body.  Maybe stored in stack.
+    The representation here are flexible.
+
+    - data: representation used when storing into containers (e.g. arrays).
+
+    - argument: representation used for function argument.  All composite
+    types are unflattened into multiple primitive types.
+
+    - return: representation used for return argument.
+
+    Throughput the compiler pipeline, a LLVM value is usually passed around
+    in the "value" representation.  All "as_" prefix function converts from
+    "value" representation.  All "from_" prefix function converts to the
+    "value"  representation.
+
+    """
+    def __init__(self, dmm, fe_type):
+        self._dmm = dmm
+        self._fe_type = fe_type
+
+    @property
+    def fe_type(self):
+        return self._fe_type
+
+    def get_value_type(self):
+        raise NotImplementedError(self)
+
+    def get_data_type(self):
+        return self.get_value_type()
+
+    def get_argument_type(self):
+        """Return a LLVM type or nested tuple of LLVM type
+        """
+        return self.get_value_type()
+
+    def get_return_type(self):
+        return self.get_value_type()
+
+    def as_data(self, builder, value):
+        raise NotImplementedError(self)
+
+    def as_argument(self, builder, value):
+        """
+        Takes one LLVM value
+        Return a LLVM value or nested tuple of LLVM value
+        """
+        raise NotImplementedError(self)
+
+    def as_return(self, builder, value):
+        raise NotImplementedError(self)
+
+    def from_data(self, builder, value):
+        raise NotImplementedError(self)
+
+    def from_argument(self, builder, value):
+        """
+        Takes a LLVM value or nested tuple of LLVM value
+        Returns one LLVM value
+        """
+        raise NotImplementedError(self)
+
+    def from_return(self, builder, value):
+        raise NotImplementedError(self)
+
+    def load_from_data_pointer(self, builder, ptr, align=None):
+        """
+        Load value from a pointer to data.
+        This is the default implementation, sufficient for most purposes.
+        """
+        return self.from_data(builder, builder.load(ptr, align=align))
+
+    def traverse(self, builder):
+        """
+        Traverse contained members.
+        Returns a iterable of contained (types, getters).
+        Each getter is a one-argument function accepting a LLVM value.
+        """
+        return []
+
+    def traverse_models(self):
+        """
+        Recursively list all models involved in this model.
+        """
+        return [self._dmm[t] for t in self.traverse_types()]
+
+    def traverse_types(self):
+        """
+        Recursively list all frontend types involved in this model.
+        """
+        types = [self._fe_type]
+        queue = deque([self])
+        while len(queue) > 0:
+            dm = queue.popleft()
+
+            for i_dm in dm.inner_models():
+                if i_dm._fe_type not in types:
+                    queue.append(i_dm)
+                    types.append(i_dm._fe_type)
+
+        return types
+
+    def inner_models(self):
+        """
+        List all *inner* models.
+        """
+        return []
+
+    def get_nrt_meminfo(self, builder, value):
+        """
+        Returns the MemInfo object or None if it is not tracked.
+        It is only defined for types.meminfo_pointer
+        """
+        return None
+
+    def has_nrt_meminfo(self):
+        return False
+
+    def contains_nrt_meminfo(self):
+        """
+        Recursively check all contained types for need for NRT meminfo.
+        """
+        return any(model.has_nrt_meminfo() for model in self.traverse_models())
+
+    def _compared_fields(self):
+        return (type(self), self._fe_type)
+
+    def __hash__(self):
+        return hash(tuple(self._compared_fields()))
+
+    def __eq__(self, other):
+        if type(self) is type(other):
+            return self._compared_fields() == other._compared_fields()
+        else:
+            return False
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+
+@register_default(types.Omitted)
+class OmittedArgDataModel(DataModel):
+    """
+    A data model for omitted arguments.  Only the "argument" representation
+    is defined, other representations raise a NotImplementedError.
+    """
+    # Omitted arguments are using a dummy value type
+    def get_value_type(self):
+        return ir.LiteralStructType([])
+
+    # Omitted arguments don't produce any LLVM function argument.
+    def get_argument_type(self):
+        return ()
+
+    def as_argument(self, builder, val):
+        return ()
+
+    def from_argument(self, builder, val):
+        assert val == (), val
+        return None
+
+class PrimitiveModel(DataModel):
+    """A primitive type can be represented natively in the target in all
+    usage contexts.
+    """
+
+    def __init__(self, dmm, fe_type, be_type):
+        super(PrimitiveModel, self).__init__(dmm, fe_type)
+        self.be_type = be_type
+
+    def get_value_type(self):
+        return self.be_type
+
+    def as_data(self, builder, value):
+        return value
+
+    def as_argument(self, builder, value):
+        return value
+
+    def as_return(self, builder, value):
+        return value
+
+    def from_data(self, builder, value):
+        return value
+
+    def from_argument(self, builder, value):
+        return value
+
+    def from_return(self, builder, value):
+        return value
+
+
+class ProxyModel(DataModel):
+    """
+    Helper class for models which delegate to another model.
+    """
+
+    def get_value_type(self):
+        return self._proxied_model.get_value_type()
+
+    def get_data_type(self):
+        return self._proxied_model.get_data_type()
+
+    def get_return_type(self):
+        return self._proxied_model.get_return_type()
+
+    def get_argument_type(self):
+        return self._proxied_model.get_argument_type()
+
+    def as_data(self, builder, value):
+        return self._proxied_model.as_data(builder, value)
+
+    def as_argument(self, builder, value):
+        return self._proxied_model.as_argument(builder, value)
+
+    def as_return(self, builder, value):
+        return self._proxied_model.as_return(builder, value)
+
+    def from_data(self, builder, value):
+        return self._proxied_model.from_data(builder, value)
+
+    def from_argument(self, builder, value):
+        return self._proxied_model.from_argument(builder, value)
+
+    def from_return(self, builder, value):
+        return self._proxied_model.from_return(builder, value)
+
+
+@register_default(types.EnumMember)
+@register_default(types.IntEnumMember)
+class EnumModel(ProxyModel):
+    """
+    Enum members are represented exactly like their values.
+    """
+    def __init__(self, dmm, fe_type):
+        super(EnumModel, self).__init__(dmm, fe_type)
+        self._proxied_model = dmm.lookup(fe_type.dtype)
+
+
+@register_default(types.Opaque)
+@register_default(types.PyObject)
+@register_default(types.RawPointer)
+@register_default(types.NoneType)
+@register_default(types.StringLiteral)
+@register_default(types.EllipsisType)
+@register_default(types.Function)
+@register_default(types.Type)
+@register_default(types.Object)
+@register_default(types.Module)
+@register_default(types.Phantom)
+@register_default(types.UndefVar)
+@register_default(types.ContextManager)
+@register_default(types.Dispatcher)
+@register_default(types.ObjModeDispatcher)
+@register_default(types.ExceptionClass)
+@register_default(types.Dummy)
+@register_default(types.ExceptionInstance)
+@register_default(types.ExternalFunction)
+@register_default(types.EnumClass)
+@register_default(types.IntEnumClass)
+@register_default(types.NumberClass)
+@register_default(types.TypeRef)
+@register_default(types.NamedTupleClass)
+@register_default(types.DType)
+@register_default(types.RecursiveCall)
+@register_default(types.MakeFunctionLiteral)
+@register_default(types.Poison)
+class OpaqueModel(PrimitiveModel):
+    """
+    Passed as opaque pointers
+    """
+    _ptr_type = ir.IntType(8).as_pointer()
+
+    def __init__(self, dmm, fe_type):
+        be_type = self._ptr_type
+        super(OpaqueModel, self).__init__(dmm, fe_type, be_type)
+
+
+@register_default(types.MemInfoPointer)
+class MemInfoModel(OpaqueModel):
+
+    def inner_models(self):
+        return [self._dmm.lookup(self._fe_type.dtype)]
+
+    def has_nrt_meminfo(self):
+        return True
+
+    def get_nrt_meminfo(self, builder, value):
+        return value
+
+
+@register_default(types.CPointer)
+class PointerModel(PrimitiveModel):
+    def __init__(self, dmm, fe_type):
+        self._pointee_model = dmm.lookup(fe_type.dtype)
+        self._pointee_be_type = self._pointee_model.get_data_type()
+        be_type = self._pointee_be_type.as_pointer()
+        super(PointerModel, self).__init__(dmm, fe_type, be_type)
+
+
+@register_default(types.EphemeralPointer)
+class EphemeralPointerModel(PointerModel):
+
+    def get_data_type(self):
+        return self._pointee_be_type
+
+    def as_data(self, builder, value):
+        value = builder.load(value)
+        return self._pointee_model.as_data(builder, value)
+
+    def from_data(self, builder, value):
+        raise NotImplementedError("use load_from_data_pointer() instead")
+
+    def load_from_data_pointer(self, builder, ptr, align=None):
+        return builder.bitcast(ptr, self.get_value_type())
+
+
+@register_default(types.EphemeralArray)
+class EphemeralArrayModel(PointerModel):
+
+    def __init__(self, dmm, fe_type):
+        super(EphemeralArrayModel, self).__init__(dmm, fe_type)
+        self._data_type = ir.ArrayType(self._pointee_be_type,
+                                       self._fe_type.count)
+
+    def get_data_type(self):
+        return self._data_type
+
+    def as_data(self, builder, value):
+        values = [builder.load(cgutils.gep_inbounds(builder, value, i))
+                  for i in range(self._fe_type.count)]
+        return cgutils.pack_array(builder, values)
+
+    def from_data(self, builder, value):
+        raise NotImplementedError("use load_from_data_pointer() instead")
+
+    def load_from_data_pointer(self, builder, ptr, align=None):
+        return builder.bitcast(ptr, self.get_value_type())
+
+
+@register_default(types.ExternalFunctionPointer)
+class ExternalFuncPointerModel(PrimitiveModel):
+    def __init__(self, dmm, fe_type):
+        sig = fe_type.sig
+        # Since the function is non-Numba, there is no adaptation
+        # of arguments and return value, hence get_value_type().
+        retty = dmm.lookup(sig.return_type).get_value_type()
+        args = [dmm.lookup(t).get_value_type() for t in sig.args]
+        be_type = ir.PointerType(ir.FunctionType(retty, args))
+        super(ExternalFuncPointerModel, self).__init__(dmm, fe_type, be_type)
+
+
+@register_default(types.UniTuple)
+@register_default(types.NamedUniTuple)
+@register_default(types.StarArgUniTuple)
+class UniTupleModel(DataModel):
+    def __init__(self, dmm, fe_type):
+        super(UniTupleModel, self).__init__(dmm, fe_type)
+        self._elem_model = dmm.lookup(fe_type.dtype)
+        self._count = len(fe_type)
+        self._value_type = ir.ArrayType(self._elem_model.get_value_type(),
+                                        self._count)
+        self._data_type = ir.ArrayType(self._elem_model.get_data_type(),
+                                       self._count)
+
+    def get_value_type(self):
+        return self._value_type
+
+    def get_data_type(self):
+        return self._data_type
+
+    def get_return_type(self):
+        return self.get_value_type()
+
+    def get_argument_type(self):
+        return (self._elem_model.get_argument_type(),) * self._count
+
+    def as_argument(self, builder, value):
+        out = []
+        for i in range(self._count):
+            v = builder.extract_value(value, [i])
+            v = self._elem_model.as_argument(builder, v)
+            out.append(v)
+        return out
+
+    def from_argument(self, builder, value):
+        out = ir.Constant(self.get_value_type(), ir.Undefined)
+        for i, v in enumerate(value):
+            v = self._elem_model.from_argument(builder, v)
+            out = builder.insert_value(out, v, [i])
+        return out
+
+    def as_data(self, builder, value):
+        out = ir.Constant(self.get_data_type(), ir.Undefined)
+        for i in range(self._count):
+            val = builder.extract_value(value, [i])
+            dval = self._elem_model.as_data(builder, val)
+            out = builder.insert_value(out, dval, [i])
+        return out
+
+    def from_data(self, builder, value):
+        out = ir.Constant(self.get_value_type(), ir.Undefined)
+        for i in range(self._count):
+            val = builder.extract_value(value, [i])
+            dval = self._elem_model.from_data(builder, val)
+            out = builder.insert_value(out, dval, [i])
+        return out
+
+    def as_return(self, builder, value):
+        return value
+
+    def from_return(self, builder, value):
+        return value
+
+    def traverse(self, builder):
+        def getter(i, value):
+            return builder.extract_value(value, i)
+        return [(self._fe_type.dtype, partial(getter, i))
+                for i in range(self._count)]
+
+    def inner_models(self):
+        return [self._elem_model]
+
+
+class CompositeModel(DataModel):
+    """Any model that is composed of multiple other models should subclass from
+    this.
+    """
+    pass
+
+
+class StructModel(CompositeModel):
+    _value_type = None
+    _data_type = None
+
+    def __init__(self, dmm, fe_type, members):
+        super(StructModel, self).__init__(dmm, fe_type)
+        if members:
+            self._fields, self._members = zip(*members)
+        else:
+            self._fields = self._members = ()
+        self._models = tuple([self._dmm.lookup(t) for t in self._members])
+
+    def get_member_fe_type(self, name):
+        """
+        StructModel-specific: get the Numba type of the field named *name*.
+        """
+        pos = self.get_field_position(name)
+        return self._members[pos]
+
+    def get_value_type(self):
+        if self._value_type is None:
+            self._value_type = ir.LiteralStructType([t.get_value_type()
+                                                    for t in self._models])
+        return self._value_type
+
+    def get_data_type(self):
+        if self._data_type is None:
+            self._data_type = ir.LiteralStructType([t.get_data_type()
+                                                    for t in self._models])
+        return self._data_type
+
+    def get_argument_type(self):
+        return tuple([t.get_argument_type() for t in self._models])
+
+    def get_return_type(self):
+        return self.get_data_type()
+
+    def _as(self, methname, builder, value):
+        extracted = []
+        for i, dm in enumerate(self._models):
+            extracted.append(getattr(dm, methname)(builder,
+                                                   self.get(builder, value, i)))
+        return tuple(extracted)
+
+    def _from(self, methname, builder, value):
+        struct = ir.Constant(self.get_value_type(), ir.Undefined)
+
+        for i, (dm, val) in enumerate(zip(self._models, value)):
+            v = getattr(dm, methname)(builder, val)
+            struct = self.set(builder, struct, v, i)
+
+        return struct
+
+    def as_data(self, builder, value):
+        """
+        Converts the LLVM struct in `value` into a representation suited for
+        storing into arrays.
+
+        Note
+        ----
+        Current implementation rarely changes how types are represented for
+        "value" and "data".  This is usually a pointless rebuild of the
+        immutable LLVM struct value.  Luckily, LLVM optimization removes all
+        redundancy.
+
+        Sample usecase: Structures nested with pointers to other structures
+        that can be serialized into  a flat representation when storing into
+        array.
+        """
+        elems = self._as("as_data", builder, value)
+        struct = ir.Constant(self.get_data_type(), ir.Undefined)
+        for i, el in enumerate(elems):
+            struct = builder.insert_value(struct, el, [i])
+        return struct
+
+    def from_data(self, builder, value):
+        """
+        Convert from "data" representation back into "value" representation.
+        Usually invoked when loading from array.
+
+        See notes in `as_data()`
+        """
+        vals = [builder.extract_value(value, [i])
+                for i in range(len(self._members))]
+        return self._from("from_data", builder, vals)
+
+    def load_from_data_pointer(self, builder, ptr, align=None):
+        values = []
+        for i, model in enumerate(self._models):
+            elem_ptr = cgutils.gep_inbounds(builder, ptr, 0, i)
+            val = model.load_from_data_pointer(builder, elem_ptr, align)
+            values.append(val)
+
+        struct = ir.Constant(self.get_value_type(), ir.Undefined)
+        for i, val in enumerate(values):
+            struct = self.set(builder, struct, val, i)
+        return struct
+
+    def as_argument(self, builder, value):
+        return self._as("as_argument", builder, value)
+
+    def from_argument(self, builder, value):
+        return self._from("from_argument", builder, value)
+
+    def as_return(self, builder, value):
+        elems = self._as("as_data", builder, value)
+        struct = ir.Constant(self.get_data_type(), ir.Undefined)
+        for i, el in enumerate(elems):
+            struct = builder.insert_value(struct, el, [i])
+        return struct
+
+    def from_return(self, builder, value):
+        vals = [builder.extract_value(value, [i])
+                for i in range(len(self._members))]
+        return self._from("from_data", builder, vals)
+
+    def get(self, builder, val, pos):
+        """Get a field at the given position or the fieldname
+
+        Args
+        ----
+        builder:
+            LLVM IRBuilder
+        val:
+            value to be inserted
+        pos: int or str
+            field index or field name
+
+        Returns
+        -------
+        Extracted value
+        """
+        if isinstance(pos, str):
+            pos = self.get_field_position(pos)
+        return builder.extract_value(val, [pos],
+                                     name="extracted." + self._fields[pos])
+
+    def set(self, builder, stval, val, pos):
+        """Set a field at the given position or the fieldname
+
+        Args
+        ----
+        builder:
+            LLVM IRBuilder
+        stval:
+            LLVM struct value
+        val:
+            value to be inserted
+        pos: int or str
+            field index or field name
+
+        Returns
+        -------
+        A new LLVM struct with the value inserted
+        """
+        if isinstance(pos, str):
+            pos = self.get_field_position(pos)
+        return builder.insert_value(stval, val, [pos],
+                                    name="inserted." + self._fields[pos])
+
+    def get_field_position(self, field):
+        try:
+            return self._fields.index(field)
+        except ValueError:
+            raise KeyError("%s does not have a field named %r"
+                           % (self.__class__.__name__, field))
+
+    @property
+    def field_count(self):
+        return len(self._fields)
+
+    def get_type(self, pos):
+        """Get the frontend type (numba type) of a field given the position
+         or the fieldname
+
+        Args
+        ----
+        pos: int or str
+            field index or field name
+        """
+        if isinstance(pos, str):
+            pos = self.get_field_position(pos)
+        return self._members[pos]
+
+    def get_model(self, pos):
+        """
+        Get the datamodel of a field given the position or the fieldname.
+
+        Args
+        ----
+        pos: int or str
+            field index or field name
+        """
+        return self._models[pos]
+
+    def traverse(self, builder):
+        def getter(k, value):
+            if value.type != self.get_value_type():
+                args = self.get_value_type(), value.type
+                raise TypeError("expecting {0} but got {1}".format(*args))
+            return self.get(builder, value, k)
+
+        return [(self.get_type(k), partial(getter, k)) for k in self._fields]
+
+    def inner_models(self):
+        return self._models
+
+
+@register_default(types.PythonBoolean)
+@register_default(types.PythonBooleanLiteral)
+@register_default(types.NumPyBoolean)
+@register_default(types.NumPyBooleanLiteral)
+@register_default(types.MachineBoolean)
+@register_default(types.MachineBooleanLiteral)
+class BooleanModel(DataModel):
+    _bit_type = ir.IntType(1)
+    _byte_type = ir.IntType(8)
+
+    def get_value_type(self):
+        return self._bit_type
+
+    def get_data_type(self):
+        return self._byte_type
+
+    def get_return_type(self):
+        return self.get_data_type()
+
+    def get_argument_type(self):
+        return self.get_data_type()
+
+    def as_data(self, builder, value):
+        return builder.zext(value, self.get_data_type())
+
+    def as_argument(self, builder, value):
+        return self.as_data(builder, value)
+
+    def as_return(self, builder, value):
+        return self.as_data(builder, value)
+
+    def from_data(self, builder, value):
+        ty = self.get_value_type()
+        resalloca = cgutils.alloca_once(builder, ty)
+        cond = builder.icmp_unsigned('==', value, value.type(0))
+        with builder.if_else(cond) as (then, otherwise):
+            with then:
+                builder.store(ty(0), resalloca)
+            with otherwise:
+                builder.store(ty(1), resalloca)
+        return builder.load(resalloca)
+
+    def from_argument(self, builder, value):
+        return self.from_data(builder, value)
+
+    def from_return(self, builder, value):
+        return self.from_data(builder, value)
+
+
+@register_default(types.PythonInteger)
+@register_default(types.PythonIntegerLiteral)
+@register_default(types.NumPyInteger)
+@register_default(types.NumPyIntegerLiteral)
+@register_default(types.MachineInteger)
+@register_default(types.MachineIntegerLiteral)
+class IntegerModel(PrimitiveModel):
+    def __init__(self, dmm, fe_type):
+        be_type = ir.IntType(fe_type.bitwidth)
+        super(IntegerModel, self).__init__(dmm, fe_type, be_type)
+
+
+@register_default(types.PythonFloat)
+@register_default(types.NumPyFloat)
+@register_default(types.MachineFloat)
+class FloatModel(PrimitiveModel):
+    def __init__(self, dmm, fe_type):
+        be_type = ir.DoubleType()
+        super(FloatModel, self).__init__(dmm, fe_type, be_type)
+
+
+@register_default(types.PythonComplex)
+@register_default(types.NumPyComplex)
+@register_default(types.MachineComplex)
+class ComplexModel(StructModel):
+    _element_type = NotImplemented
+
+    def __init__(self, dmm, fe_type):
+        members = [
+            ('real', fe_type.underlying_float),
+            ('imag', fe_type.underlying_float),
+        ]
+        super(ComplexModel, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.LiteralList)
+@register_default(types.LiteralStrKeyDict)
+@register_default(types.Tuple)
+@register_default(types.NamedTuple)
+@register_default(types.StarArgTuple)
+class TupleModel(StructModel):
+    def __init__(self, dmm, fe_type):
+        members = [('f' + str(i), t) for i, t in enumerate(fe_type)]
+        super(TupleModel, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.UnionType)
+class UnionModel(StructModel):
+    def __init__(self, dmm, fe_type):
+        members = [
+            ('tag', types.uintp),
+            # XXX: it should really be a MemInfoPointer(types.voidptr)
+            ('payload', types.Tuple.from_types(fe_type.types)),
+        ]
+        super(UnionModel, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.Pair)
+class PairModel(StructModel):
+    def __init__(self, dmm, fe_type):
+        members = [('first', fe_type.first_type),
+                   ('second', fe_type.second_type)]
+        super(PairModel, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.ListPayload)
+class ListPayloadModel(StructModel):
+    def __init__(self, dmm, fe_type):
+        # The fields are mutable but the payload is always manipulated
+        # by reference.  This scheme allows mutations of an array to
+        # be seen by its iterators.
+        members = [
+            ('size', types.intp),
+            ('allocated', types.intp),
+            # This member is only used only for reflected lists
+            ('dirty', types.boolean),
+            # Actually an inlined var-sized array
+            ('data', fe_type.container.dtype),
+        ]
+        super(ListPayloadModel, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.List)
+class ListModel(StructModel):
+    def __init__(self, dmm, fe_type):
+        payload_type = types.ListPayload(fe_type)
+        members = [
+            # The meminfo data points to a ListPayload
+            ('meminfo', types.MemInfoPointer(payload_type)),
+            # This member is only used only for reflected lists
+            ('parent', types.pyobject),
+        ]
+        super(ListModel, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.ListIter)
+class ListIterModel(StructModel):
+    def __init__(self, dmm, fe_type):
+        payload_type = types.ListPayload(fe_type.container)
+        members = [
+            # The meminfo data points to a ListPayload (shared with the
+            # original list object)
+            ('meminfo', types.MemInfoPointer(payload_type)),
+            ('index', types.EphemeralPointer(types.intp)),
+            ]
+        super(ListIterModel, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.SetEntry)
+class SetEntryModel(StructModel):
+    def __init__(self, dmm, fe_type):
+        dtype = fe_type.set_type.dtype
+        members = [
+            # -1 = empty, -2 = deleted
+            ('hash', types.intp),
+            ('key', dtype),
+        ]
+        super(SetEntryModel, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.SetPayload)
+class SetPayloadModel(StructModel):
+    def __init__(self, dmm, fe_type):
+        entry_type = types.SetEntry(fe_type.container)
+        members = [
+            # Number of active + deleted entries
+            ('fill', types.intp),
+            # Number of active entries
+            ('used', types.intp),
+            # Allocated size - 1 (size being a power of 2)
+            ('mask', types.intp),
+            # Search finger
+            ('finger', types.intp),
+            # This member is only used only for reflected sets
+            ('dirty', types.boolean),
+            # Actually an inlined var-sized array
+            ('entries', entry_type),
+        ]
+        super(SetPayloadModel, self).__init__(dmm, fe_type, members)
+
+@register_default(types.Set)
+class SetModel(StructModel):
+    def __init__(self, dmm, fe_type):
+        payload_type = types.SetPayload(fe_type)
+        members = [
+            # The meminfo data points to a SetPayload
+            ('meminfo', types.MemInfoPointer(payload_type)),
+            # This member is only used only for reflected sets
+            ('parent', types.pyobject),
+        ]
+        super(SetModel, self).__init__(dmm, fe_type, members)
+
+@register_default(types.SetIter)
+class SetIterModel(StructModel):
+    def __init__(self, dmm, fe_type):
+        payload_type = types.SetPayload(fe_type.container)
+        members = [
+            # The meminfo data points to a SetPayload (shared with the
+            # original set object)
+            ('meminfo', types.MemInfoPointer(payload_type)),
+            # The index into the entries table
+            ('index', types.EphemeralPointer(types.intp)),
+            ]
+        super(SetIterModel, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.Array)
+@register_default(types.Buffer)
+@register_default(types.ByteArray)
+@register_default(types.Bytes)
+@register_default(types.MemoryView)
+@register_default(types.PyArray)
+class ArrayModel(StructModel):
+    def __init__(self, dmm, fe_type):
+        ndim = fe_type.ndim
+        members = [
+            ('meminfo', types.MemInfoPointer(fe_type.dtype)),
+            ('parent', types.pyobject),
+            ('nitems', types.intp),
+            ('itemsize', types.intp),
+            ('data', types.CPointer(fe_type.dtype)),
+            ('shape', types.UniTuple(types.intp, ndim)),
+            ('strides', types.UniTuple(types.intp, ndim)),
+
+        ]
+        super(ArrayModel, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.ArrayFlags)
+class ArrayFlagsModel(StructModel):
+    def __init__(self, dmm, fe_type):
+        members = [
+            ('parent', fe_type.array_type),
+        ]
+        super(ArrayFlagsModel, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.NestedArray)
+class NestedArrayModel(ArrayModel):
+    def __init__(self, dmm, fe_type):
+        self._be_type = dmm.lookup(fe_type.dtype).get_data_type()
+        super(NestedArrayModel, self).__init__(dmm, fe_type)
+
+    def as_storage_type(self):
+        """Return the LLVM type representation for the storage of
+        the nestedarray.
+        """
+        ret = ir.ArrayType(self._be_type, self._fe_type.nitems)
+        return ret
+
+
+@register_default(types.Optional)
+class OptionalModel(StructModel):
+    def __init__(self, dmm, fe_type):
+        members = [
+            ('data', fe_type.type),
+            ('valid', types.boolean),
+        ]
+        self._value_model = dmm.lookup(fe_type.type)
+        super(OptionalModel, self).__init__(dmm, fe_type, members)
+
+    def get_return_type(self):
+        return self._value_model.get_return_type()
+
+    def as_return(self, builder, value):
+        raise NotImplementedError
+
+    def from_return(self, builder, value):
+        return self._value_model.from_return(builder, value)
+
+    def traverse(self, builder):
+        def get_data(value):
+            valid = get_valid(value)
+            data = self.get(builder, value, "data")
+            return builder.select(valid, data, ir.Constant(data.type, None))
+        def get_valid(value):
+            return self.get(builder, value, "valid")
+
+        return [(self.get_type("data"), get_data),
+                (self.get_type("valid"), get_valid)]
+
+
+@register_default(types.Record)
+class RecordModel(CompositeModel):
+    def __init__(self, dmm, fe_type):
+        super(RecordModel, self).__init__(dmm, fe_type)
+        self._models = [self._dmm.lookup(t) for _, t in fe_type.members]
+        self._be_type = ir.ArrayType(ir.IntType(8), fe_type.size)
+        self._be_ptr_type = self._be_type.as_pointer()
+
+    def get_value_type(self):
+        """Passed around as reference to underlying data
+        """
+        return self._be_ptr_type
+
+    def get_argument_type(self):
+        return self._be_ptr_type
+
+    def get_return_type(self):
+        return self._be_ptr_type
+
+    def get_data_type(self):
+        return self._be_type
+
+    def as_data(self, builder, value):
+        return builder.load(value)
+
+    def from_data(self, builder, value):
+        raise NotImplementedError("use load_from_data_pointer() instead")
+
+    def as_argument(self, builder, value):
+        return value
+
+    def from_argument(self, builder, value):
+        return value
+
+    def as_return(self, builder, value):
+        return value
+
+    def from_return(self, builder, value):
+        return value
+
+    def load_from_data_pointer(self, builder, ptr, align=None):
+        return builder.bitcast(ptr, self.get_value_type())
+
+
+@register_default(types.UnicodeCharSeq)
+class UnicodeCharSeq(DataModel):
+    def __init__(self, dmm, fe_type):
+        super(UnicodeCharSeq, self).__init__(dmm, fe_type)
+        charty = ir.IntType(numpy_support.sizeof_unicode_char * 8)
+        self._be_type = ir.ArrayType(charty, fe_type.count)
+
+    def get_value_type(self):
+        return self._be_type
+
+    def get_data_type(self):
+        return self._be_type
+
+    def as_data(self, builder, value):
+        return value
+
+    def from_data(self, builder, value):
+        return value
+
+    def as_return(self, builder, value):
+        return value
+
+    def from_return(self, builder, value):
+        return value
+
+    def as_argument(self, builder, value):
+        return value
+
+    def from_argument(self, builder, value):
+        return value
+
+
+@register_default(types.CharSeq)
+class CharSeq(DataModel):
+    def __init__(self, dmm, fe_type):
+        super(CharSeq, self).__init__(dmm, fe_type)
+        charty = ir.IntType(8)
+        self._be_type = ir.ArrayType(charty, fe_type.count)
+
+    def get_value_type(self):
+        return self._be_type
+
+    def get_data_type(self):
+        return self._be_type
+
+    def as_data(self, builder, value):
+        return value
+
+    def from_data(self, builder, value):
+        return value
+
+    def as_return(self, builder, value):
+        return value
+
+    def from_return(self, builder, value):
+        return value
+
+    def as_argument(self, builder, value):
+        return value
+
+    def from_argument(self, builder, value):
+        return value
+
+
+class CContiguousFlatIter(StructModel):
+    def __init__(self, dmm, fe_type, need_indices):
+        assert fe_type.array_type.layout == 'C'
+        array_type = fe_type.array_type
+        dtype = array_type.dtype
+        ndim = array_type.ndim
+        members = [('array', array_type),
+                   ('stride', types.intp),
+                   ('index', types.EphemeralPointer(types.intp)),
+                   ]
+        if need_indices:
+            # For ndenumerate()
+            members.append(('indices', types.EphemeralArray(types.intp, ndim)))
+        super(CContiguousFlatIter, self).__init__(dmm, fe_type, members)
+
+
+class FlatIter(StructModel):
+    def __init__(self, dmm, fe_type):
+        array_type = fe_type.array_type
+        dtype = array_type.dtype
+        ndim = array_type.ndim
+        members = [('array', array_type),
+                   ('pointers', types.EphemeralArray(types.CPointer(dtype), ndim)),
+                   ('indices', types.EphemeralArray(types.intp, ndim)),
+                   ('exhausted', types.EphemeralPointer(types.boolean)),
+        ]
+        super(FlatIter, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.UniTupleIter)
+class UniTupleIter(StructModel):
+    def __init__(self, dmm, fe_type):
+        members = [('index', types.EphemeralPointer(types.intp)),
+                   ('tuple', fe_type.container,)]
+        super(UniTupleIter, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.misc.SliceLiteral)
+@register_default(types.SliceType)
+class SliceModel(StructModel):
+    def __init__(self, dmm, fe_type):
+        members = [('start', types.intp),
+                   ('stop', types.intp),
+                   ('step', types.intp),
+                   ]
+        super(SliceModel, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.NPDatetime)
+@register_default(types.NPTimedelta)
+class NPDatetimeModel(PrimitiveModel):
+    def __init__(self, dmm, fe_type):
+        be_type = ir.IntType(64)
+        super(NPDatetimeModel, self).__init__(dmm, fe_type, be_type)
+
+
+@register_default(types.ArrayIterator)
+class ArrayIterator(StructModel):
+    def __init__(self, dmm, fe_type):
+        # We use an unsigned index to avoid the cost of negative index tests.
+        members = [('index', types.EphemeralPointer(types.uintp)),
+                   ('array', fe_type.array_type)]
+        super(ArrayIterator, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.EnumerateType)
+class EnumerateType(StructModel):
+    def __init__(self, dmm, fe_type):
+        members = [('count', types.EphemeralPointer(types.intp)),
+                   ('iter', fe_type.source_type)]
+
+        super(EnumerateType, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.ZipType)
+class ZipType(StructModel):
+    def __init__(self, dmm, fe_type):
+        members = [('iter%d' % i, source_type.iterator_type)
+                   for i, source_type in enumerate(fe_type.source_types)]
+        super(ZipType, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.RangeIteratorType)
+class RangeIteratorType(StructModel):
+    def __init__(self, dmm, fe_type):
+        int_type = fe_type.yield_type
+        members = [('iter', types.EphemeralPointer(int_type)),
+                   ('stop', int_type),
+                   ('step', int_type),
+                   ('count', types.EphemeralPointer(int_type))]
+        super(RangeIteratorType, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.Generator)
+class GeneratorModel(CompositeModel):
+    def __init__(self, dmm, fe_type):
+        super(GeneratorModel, self).__init__(dmm, fe_type)
+        # XXX Fold this in DataPacker?
+        self._arg_models = [self._dmm.lookup(t) for t in fe_type.arg_types
+                            if not isinstance(t, types.Omitted)]
+        self._state_models = [self._dmm.lookup(t) for t in fe_type.state_types]
+
+        self._args_be_type = ir.LiteralStructType(
+            [t.get_data_type() for t in self._arg_models])
+        self._state_be_type = ir.LiteralStructType(
+            [t.get_data_type() for t in self._state_models])
+        # The whole generator closure
+        self._be_type = ir.LiteralStructType(
+            [self._dmm.lookup(types.int32).get_value_type(),
+             self._args_be_type, self._state_be_type])
+        self._be_ptr_type = self._be_type.as_pointer()
+
+    def get_value_type(self):
+        """
+        The generator closure is passed around as a reference.
+        """
+        return self._be_ptr_type
+
+    def get_argument_type(self):
+        return self._be_ptr_type
+
+    def get_return_type(self):
+        return self._be_type
+
+    def get_data_type(self):
+        return self._be_type
+
+    def as_argument(self, builder, value):
+        return value
+
+    def from_argument(self, builder, value):
+        return value
+
+    def as_return(self, builder, value):
+        return self.as_data(builder, value)
+
+    def from_return(self, builder, value):
+        return self.from_data(builder, value)
+
+    def as_data(self, builder, value):
+        return builder.load(value)
+
+    def from_data(self, builder, value):
+        stack = cgutils.alloca_once(builder, value.type)
+        builder.store(value, stack)
+        return stack
+
+
+@register_default(types.ArrayCTypes)
+class ArrayCTypesModel(StructModel):
+    def __init__(self, dmm, fe_type):
+        # ndim = fe_type.ndim
+        members = [('data', types.CPointer(fe_type.dtype)),
+                   ('meminfo', types.MemInfoPointer(fe_type.dtype))]
+        super(ArrayCTypesModel, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.RangeType)
+class RangeModel(StructModel):
+    def __init__(self, dmm, fe_type):
+        int_type = fe_type.iterator_type.yield_type
+        members = [('start', int_type),
+                   ('stop', int_type),
+                   ('step', int_type)]
+        super(RangeModel, self).__init__(dmm, fe_type, members)
+
+
+# =============================================================================
+
+@register_default(types.NumpyNdIndexType)
+class NdIndexModel(StructModel):
+    def __init__(self, dmm, fe_type):
+        ndim = fe_type.ndim
+        members = [('shape', types.UniTuple(types.intp, ndim)),
+                   ('indices', types.EphemeralArray(types.intp, ndim)),
+                   ('exhausted', types.EphemeralPointer(types.boolean)),
+                   ]
+        super(NdIndexModel, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.NumpyFlatType)
+def handle_numpy_flat_type(dmm, ty):
+    if ty.array_type.layout == 'C':
+        return CContiguousFlatIter(dmm, ty, need_indices=False)
+    else:
+        return FlatIter(dmm, ty)
+
+@register_default(types.NumpyNdEnumerateType)
+def handle_numpy_ndenumerate_type(dmm, ty):
+    if ty.array_type.layout == 'C':
+        return CContiguousFlatIter(dmm, ty, need_indices=True)
+    else:
+        return FlatIter(dmm, ty)
+
+@register_default(types.BoundFunction)
+def handle_bound_function(dmm, ty):
+    # The same as the underlying type
+    return dmm[ty.this]
+
+
+@register_default(types.NumpyNdIterType)
+class NdIter(StructModel):
+    def __init__(self, dmm, fe_type):
+        array_types = fe_type.arrays
+        ndim = fe_type.ndim
+        shape_len = ndim if fe_type.need_shaped_indexing else 1
+        members = [('exhausted', types.EphemeralPointer(types.boolean)),
+                   ('arrays', types.Tuple(array_types)),
+                   # The iterator's main shape and indices
+                   ('shape', types.UniTuple(types.intp, shape_len)),
+                   ('indices', types.EphemeralArray(types.intp, shape_len)),
+                   ]
+        # Indexing state for the various sub-iterators
+        # XXX use a tuple instead?
+        for i, sub in enumerate(fe_type.indexers):
+            kind, start_dim, end_dim, _ = sub
+            member_name = 'index%d' % i
+            if kind == 'flat':
+                # A single index into the flattened array
+                members.append((member_name, types.EphemeralPointer(types.intp)))
+            elif kind in ('scalar', 'indexed', '0d'):
+                # Nothing required
+                pass
+            else:
+                assert 0
+        # Slots holding values of the scalar args
+        # XXX use a tuple instead?
+        for i, ty in enumerate(fe_type.arrays):
+            if not isinstance(ty, types.Array):
+                member_name = 'scalar%d' % i
+                members.append((member_name, types.EphemeralPointer(ty)))
+
+        super(NdIter, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.DeferredType)
+class DeferredStructModel(CompositeModel):
+    def __init__(self, dmm, fe_type):
+        super(DeferredStructModel, self).__init__(dmm, fe_type)
+        self.typename = "deferred.{0}".format(id(fe_type))
+        self.actual_fe_type = fe_type.get()
+
+    def get_value_type(self):
+        return ir.global_context.get_identified_type(self.typename + '.value')
+
+    def get_data_type(self):
+        return ir.global_context.get_identified_type(self.typename + '.data')
+
+    def get_argument_type(self):
+        return self._actual_model.get_argument_type()
+
+    def as_argument(self, builder, value):
+        inner = self.get(builder, value)
+        return self._actual_model.as_argument(builder, inner)
+
+    def from_argument(self, builder, value):
+        res = self._actual_model.from_argument(builder, value)
+        return self.set(builder, self.make_uninitialized(), res)
+
+    def from_data(self, builder, value):
+        self._define()
+        elem = self.get(builder, value)
+        value = self._actual_model.from_data(builder, elem)
+        out = self.make_uninitialized()
+        return self.set(builder, out, value)
+
+    def as_data(self, builder, value):
+        self._define()
+        elem = self.get(builder, value)
+        value = self._actual_model.as_data(builder, elem)
+        out = self.make_uninitialized(kind='data')
+        return self.set(builder, out, value)
+
+    def from_return(self, builder, value):
+        return value
+
+    def as_return(self, builder, value):
+        return value
+
+    def get(self, builder, value):
+        return builder.extract_value(value, [0])
+
+    def set(self, builder, value, content):
+        return builder.insert_value(value, content, [0])
+
+    def make_uninitialized(self, kind='value'):
+        self._define()
+        if kind == 'value':
+            ty = self.get_value_type()
+        else:
+            ty = self.get_data_type()
+        return ir.Constant(ty, ir.Undefined)
+
+    def _define(self):
+        valty = self.get_value_type()
+        self._define_value_type(valty)
+        datty = self.get_data_type()
+        self._define_data_type(datty)
+
+    def _define_value_type(self, value_type):
+        if value_type.is_opaque:
+            value_type.set_body(self._actual_model.get_value_type())
+
+    def _define_data_type(self, data_type):
+        if data_type.is_opaque:
+            data_type.set_body(self._actual_model.get_data_type())
+
+    @property
+    def _actual_model(self):
+        return self._dmm.lookup(self.actual_fe_type)
+
+    def traverse(self, builder):
+        return [(self.actual_fe_type,
+                 lambda value: builder.extract_value(value, [0]))]
+
+
+@register_default(types.StructRefPayload)
+class StructPayloadModel(StructModel):
+    """Model for the payload of a mutable struct
+    """
+    def __init__(self, dmm, fe_typ):
+        members = tuple(fe_typ.field_dict.items())
+        super().__init__(dmm, fe_typ, members)
+
+
+class StructRefModel(StructModel):
+    """Model for a mutable struct.
+    A reference to the payload
+    """
+    def __init__(self, dmm, fe_typ):
+        dtype = fe_typ.get_data_type()
+        members = [
+            ("meminfo", types.MemInfoPointer(dtype)),
+        ]
+        super().__init__(dmm, fe_typ, members)
+

lib/python3.10/site-packages/numba/core/datamodel/old_models.py

@@ -0,0 +1,1385 @@
+from functools import partial
+from collections import deque
+
+from llvmlite import ir
+
+from numba.core.datamodel.registry import register_default
+from numba.core import types, cgutils
+from numba.np import numpy_support
+
+
+class DataModel(object):
+    """
+    DataModel describe how a FE type is represented in the LLVM IR at
+    different contexts.
+
+    Contexts are:
+
+    - value: representation inside function body.  Maybe stored in stack.
+    The representation here are flexible.
+
+    - data: representation used when storing into containers (e.g. arrays).
+
+    - argument: representation used for function argument.  All composite
+    types are unflattened into multiple primitive types.
+
+    - return: representation used for return argument.
+
+    Throughput the compiler pipeline, a LLVM value is usually passed around
+    in the "value" representation.  All "as_" prefix function converts from
+    "value" representation.  All "from_" prefix function converts to the
+    "value"  representation.
+
+    """
+    def __init__(self, dmm, fe_type):
+        self._dmm = dmm
+        self._fe_type = fe_type
+
+    @property
+    def fe_type(self):
+        return self._fe_type
+
+    def get_value_type(self):
+        raise NotImplementedError(self)
+
+    def get_data_type(self):
+        return self.get_value_type()
+
+    def get_argument_type(self):
+        """Return a LLVM type or nested tuple of LLVM type
+        """
+        return self.get_value_type()
+
+    def get_return_type(self):
+        return self.get_value_type()
+
+    def as_data(self, builder, value):
+        raise NotImplementedError(self)
+
+    def as_argument(self, builder, value):
+        """
+        Takes one LLVM value
+        Return a LLVM value or nested tuple of LLVM value
+        """
+        raise NotImplementedError(self)
+
+    def as_return(self, builder, value):
+        raise NotImplementedError(self)
+
+    def from_data(self, builder, value):
+        raise NotImplementedError(self)
+
+    def from_argument(self, builder, value):
+        """
+        Takes a LLVM value or nested tuple of LLVM value
+        Returns one LLVM value
+        """
+        raise NotImplementedError(self)
+
+    def from_return(self, builder, value):
+        raise NotImplementedError(self)
+
+    def load_from_data_pointer(self, builder, ptr, align=None):
+        """
+        Load value from a pointer to data.
+        This is the default implementation, sufficient for most purposes.
+        """
+        return self.from_data(builder, builder.load(ptr, align=align))
+
+    def traverse(self, builder):
+        """
+        Traverse contained members.
+        Returns a iterable of contained (types, getters).
+        Each getter is a one-argument function accepting a LLVM value.
+        """
+        return []
+
+    def traverse_models(self):
+        """
+        Recursively list all models involved in this model.
+        """
+        return [self._dmm[t] for t in self.traverse_types()]
+
+    def traverse_types(self):
+        """
+        Recursively list all frontend types involved in this model.
+        """
+        types = [self._fe_type]
+        queue = deque([self])
+        while len(queue) > 0:
+            dm = queue.popleft()
+
+            for i_dm in dm.inner_models():
+                if i_dm._fe_type not in types:
+                    queue.append(i_dm)
+                    types.append(i_dm._fe_type)
+
+        return types
+
+    def inner_models(self):
+        """
+        List all *inner* models.
+        """
+        return []
+
+    def get_nrt_meminfo(self, builder, value):
+        """
+        Returns the MemInfo object or None if it is not tracked.
+        It is only defined for types.meminfo_pointer
+        """
+        return None
+
+    def has_nrt_meminfo(self):
+        return False
+
+    def contains_nrt_meminfo(self):
+        """
+        Recursively check all contained types for need for NRT meminfo.
+        """
+        return any(model.has_nrt_meminfo() for model in self.traverse_models())
+
+    def _compared_fields(self):
+        return (type(self), self._fe_type)
+
+    def __hash__(self):
+        return hash(tuple(self._compared_fields()))
+
+    def __eq__(self, other):
+        if type(self) is type(other):
+            return self._compared_fields() == other._compared_fields()
+        else:
+            return False
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+
+@register_default(types.Omitted)
+class OmittedArgDataModel(DataModel):
+    """
+    A data model for omitted arguments.  Only the "argument" representation
+    is defined, other representations raise a NotImplementedError.
+    """
+    # Omitted arguments are using a dummy value type
+    def get_value_type(self):
+        return ir.LiteralStructType([])
+
+    # Omitted arguments don't produce any LLVM function argument.
+    def get_argument_type(self):
+        return ()
+
+    def as_argument(self, builder, val):
+        return ()
+
+    def from_argument(self, builder, val):
+        assert val == (), val
+        return None
+
+
+@register_default(types.Boolean)
+@register_default(types.BooleanLiteral)
+class BooleanModel(DataModel):
+    _bit_type = ir.IntType(1)
+    _byte_type = ir.IntType(8)
+
+    def get_value_type(self):
+        return self._bit_type
+
+    def get_data_type(self):
+        return self._byte_type
+
+    def get_return_type(self):
+        return self.get_data_type()
+
+    def get_argument_type(self):
+        return self.get_data_type()
+
+    def as_data(self, builder, value):
+        return builder.zext(value, self.get_data_type())
+
+    def as_argument(self, builder, value):
+        return self.as_data(builder, value)
+
+    def as_return(self, builder, value):
+        return self.as_data(builder, value)
+
+    def from_data(self, builder, value):
+        ty = self.get_value_type()
+        resalloca = cgutils.alloca_once(builder, ty)
+        cond = builder.icmp_unsigned('==', value, value.type(0))
+        with builder.if_else(cond) as (then, otherwise):
+            with then:
+                builder.store(ty(0), resalloca)
+            with otherwise:
+                builder.store(ty(1), resalloca)
+        return builder.load(resalloca)
+
+    def from_argument(self, builder, value):
+        return self.from_data(builder, value)
+
+    def from_return(self, builder, value):
+        return self.from_data(builder, value)
+
+
+class PrimitiveModel(DataModel):
+    """A primitive type can be represented natively in the target in all
+    usage contexts.
+    """
+
+    def __init__(self, dmm, fe_type, be_type):
+        super(PrimitiveModel, self).__init__(dmm, fe_type)
+        self.be_type = be_type
+
+    def get_value_type(self):
+        return self.be_type
+
+    def as_data(self, builder, value):
+        return value
+
+    def as_argument(self, builder, value):
+        return value
+
+    def as_return(self, builder, value):
+        return value
+
+    def from_data(self, builder, value):
+        return value
+
+    def from_argument(self, builder, value):
+        return value
+
+    def from_return(self, builder, value):
+        return value
+
+
+class ProxyModel(DataModel):
+    """
+    Helper class for models which delegate to another model.
+    """
+
+    def get_value_type(self):
+        return self._proxied_model.get_value_type()
+
+    def get_data_type(self):
+        return self._proxied_model.get_data_type()
+
+    def get_return_type(self):
+        return self._proxied_model.get_return_type()
+
+    def get_argument_type(self):
+        return self._proxied_model.get_argument_type()
+
+    def as_data(self, builder, value):
+        return self._proxied_model.as_data(builder, value)
+
+    def as_argument(self, builder, value):
+        return self._proxied_model.as_argument(builder, value)
+
+    def as_return(self, builder, value):
+        return self._proxied_model.as_return(builder, value)
+
+    def from_data(self, builder, value):
+        return self._proxied_model.from_data(builder, value)
+
+    def from_argument(self, builder, value):
+        return self._proxied_model.from_argument(builder, value)
+
+    def from_return(self, builder, value):
+        return self._proxied_model.from_return(builder, value)
+
+
+@register_default(types.EnumMember)
+@register_default(types.IntEnumMember)
+class EnumModel(ProxyModel):
+    """
+    Enum members are represented exactly like their values.
+    """
+    def __init__(self, dmm, fe_type):
+        super(EnumModel, self).__init__(dmm, fe_type)
+        self._proxied_model = dmm.lookup(fe_type.dtype)
+
+
+@register_default(types.Opaque)
+@register_default(types.PyObject)
+@register_default(types.RawPointer)
+@register_default(types.NoneType)
+@register_default(types.StringLiteral)
+@register_default(types.EllipsisType)
+@register_default(types.Function)
+@register_default(types.Type)
+@register_default(types.Object)
+@register_default(types.Module)
+@register_default(types.Phantom)
+@register_default(types.UndefVar)
+@register_default(types.ContextManager)
+@register_default(types.Dispatcher)
+@register_default(types.ObjModeDispatcher)
+@register_default(types.ExceptionClass)
+@register_default(types.Dummy)
+@register_default(types.ExceptionInstance)
+@register_default(types.ExternalFunction)
+@register_default(types.EnumClass)
+@register_default(types.IntEnumClass)
+@register_default(types.NumberClass)
+@register_default(types.TypeRef)
+@register_default(types.NamedTupleClass)
+@register_default(types.DType)
+@register_default(types.RecursiveCall)
+@register_default(types.MakeFunctionLiteral)
+@register_default(types.Poison)
+class OpaqueModel(PrimitiveModel):
+    """
+    Passed as opaque pointers
+    """
+    _ptr_type = ir.IntType(8).as_pointer()
+
+    def __init__(self, dmm, fe_type):
+        be_type = self._ptr_type
+        super(OpaqueModel, self).__init__(dmm, fe_type, be_type)
+
+
+@register_default(types.MemInfoPointer)
+class MemInfoModel(OpaqueModel):
+
+    def inner_models(self):
+        return [self._dmm.lookup(self._fe_type.dtype)]
+
+    def has_nrt_meminfo(self):
+        return True
+
+    def get_nrt_meminfo(self, builder, value):
+        return value
+
+
+@register_default(types.Integer)
+@register_default(types.IntegerLiteral)
+class IntegerModel(PrimitiveModel):
+    def __init__(self, dmm, fe_type):
+        be_type = ir.IntType(fe_type.bitwidth)
+        super(IntegerModel, self).__init__(dmm, fe_type, be_type)
+
+
+@register_default(types.Float)
+class FloatModel(PrimitiveModel):
+    def __init__(self, dmm, fe_type):
+        if fe_type == types.float32:
+            be_type = ir.FloatType()
+        elif fe_type == types.float64:
+            be_type = ir.DoubleType()
+        else:
+            raise NotImplementedError(fe_type)
+        super(FloatModel, self).__init__(dmm, fe_type, be_type)
+
+
+@register_default(types.CPointer)
+class PointerModel(PrimitiveModel):
+    def __init__(self, dmm, fe_type):
+        self._pointee_model = dmm.lookup(fe_type.dtype)
+        self._pointee_be_type = self._pointee_model.get_data_type()
+        be_type = self._pointee_be_type.as_pointer()
+        super(PointerModel, self).__init__(dmm, fe_type, be_type)
+
+
+@register_default(types.EphemeralPointer)
+class EphemeralPointerModel(PointerModel):
+
+    def get_data_type(self):
+        return self._pointee_be_type
+
+    def as_data(self, builder, value):
+        value = builder.load(value)
+        return self._pointee_model.as_data(builder, value)
+
+    def from_data(self, builder, value):
+        raise NotImplementedError("use load_from_data_pointer() instead")
+
+    def load_from_data_pointer(self, builder, ptr, align=None):
+        return builder.bitcast(ptr, self.get_value_type())
+
+
+@register_default(types.EphemeralArray)
+class EphemeralArrayModel(PointerModel):
+
+    def __init__(self, dmm, fe_type):
+        super(EphemeralArrayModel, self).__init__(dmm, fe_type)
+        self._data_type = ir.ArrayType(self._pointee_be_type,
+                                       self._fe_type.count)
+
+    def get_data_type(self):
+        return self._data_type
+
+    def as_data(self, builder, value):
+        values = [builder.load(cgutils.gep_inbounds(builder, value, i))
+                  for i in range(self._fe_type.count)]
+        return cgutils.pack_array(builder, values)
+
+    def from_data(self, builder, value):
+        raise NotImplementedError("use load_from_data_pointer() instead")
+
+    def load_from_data_pointer(self, builder, ptr, align=None):
+        return builder.bitcast(ptr, self.get_value_type())
+
+
+@register_default(types.ExternalFunctionPointer)
+class ExternalFuncPointerModel(PrimitiveModel):
+    def __init__(self, dmm, fe_type):
+        sig = fe_type.sig
+        # Since the function is non-Numba, there is no adaptation
+        # of arguments and return value, hence get_value_type().
+        retty = dmm.lookup(sig.return_type).get_value_type()
+        args = [dmm.lookup(t).get_value_type() for t in sig.args]
+        be_type = ir.PointerType(ir.FunctionType(retty, args))
+        super(ExternalFuncPointerModel, self).__init__(dmm, fe_type, be_type)
+
+
+@register_default(types.UniTuple)
+@register_default(types.NamedUniTuple)
+@register_default(types.StarArgUniTuple)
+class UniTupleModel(DataModel):
+    def __init__(self, dmm, fe_type):
+        super(UniTupleModel, self).__init__(dmm, fe_type)
+        self._elem_model = dmm.lookup(fe_type.dtype)
+        self._count = len(fe_type)
+        self._value_type = ir.ArrayType(self._elem_model.get_value_type(),
+                                        self._count)
+        self._data_type = ir.ArrayType(self._elem_model.get_data_type(),
+                                       self._count)
+
+    def get_value_type(self):
+        return self._value_type
+
+    def get_data_type(self):
+        return self._data_type
+
+    def get_return_type(self):
+        return self.get_value_type()
+
+    def get_argument_type(self):
+        return (self._elem_model.get_argument_type(),) * self._count
+
+    def as_argument(self, builder, value):
+        out = []
+        for i in range(self._count):
+            v = builder.extract_value(value, [i])
+            v = self._elem_model.as_argument(builder, v)
+            out.append(v)
+        return out
+
+    def from_argument(self, builder, value):
+        out = ir.Constant(self.get_value_type(), ir.Undefined)
+        for i, v in enumerate(value):
+            v = self._elem_model.from_argument(builder, v)
+            out = builder.insert_value(out, v, [i])
+        return out
+
+    def as_data(self, builder, value):
+        out = ir.Constant(self.get_data_type(), ir.Undefined)
+        for i in range(self._count):
+            val = builder.extract_value(value, [i])
+            dval = self._elem_model.as_data(builder, val)
+            out = builder.insert_value(out, dval, [i])
+        return out
+
+    def from_data(self, builder, value):
+        out = ir.Constant(self.get_value_type(), ir.Undefined)
+        for i in range(self._count):
+            val = builder.extract_value(value, [i])
+            dval = self._elem_model.from_data(builder, val)
+            out = builder.insert_value(out, dval, [i])
+        return out
+
+    def as_return(self, builder, value):
+        return value
+
+    def from_return(self, builder, value):
+        return value
+
+    def traverse(self, builder):
+        def getter(i, value):
+            return builder.extract_value(value, i)
+        return [(self._fe_type.dtype, partial(getter, i))
+                for i in range(self._count)]
+
+    def inner_models(self):
+        return [self._elem_model]
+
+
+class CompositeModel(DataModel):
+    """Any model that is composed of multiple other models should subclass from
+    this.
+    """
+    pass
+
+
+class StructModel(CompositeModel):
+    _value_type = None
+    _data_type = None
+
+    def __init__(self, dmm, fe_type, members):
+        super(StructModel, self).__init__(dmm, fe_type)
+        if members:
+            self._fields, self._members = zip(*members)
+        else:
+            self._fields = self._members = ()
+        self._models = tuple([self._dmm.lookup(t) for t in self._members])
+
+    def get_member_fe_type(self, name):
+        """
+        StructModel-specific: get the Numba type of the field named *name*.
+        """
+        pos = self.get_field_position(name)
+        return self._members[pos]
+
+    def get_value_type(self):
+        if self._value_type is None:
+            self._value_type = ir.LiteralStructType([t.get_value_type()
+                                                    for t in self._models])
+        return self._value_type
+
+    def get_data_type(self):
+        if self._data_type is None:
+            self._data_type = ir.LiteralStructType([t.get_data_type()
+                                                    for t in self._models])
+        return self._data_type
+
+    def get_argument_type(self):
+        return tuple([t.get_argument_type() for t in self._models])
+
+    def get_return_type(self):
+        return self.get_data_type()
+
+    def _as(self, methname, builder, value):
+        extracted = []
+        for i, dm in enumerate(self._models):
+            extracted.append(getattr(dm, methname)(builder,
+                                                   self.get(builder, value, i)))
+        return tuple(extracted)
+
+    def _from(self, methname, builder, value):
+        struct = ir.Constant(self.get_value_type(), ir.Undefined)
+
+        for i, (dm, val) in enumerate(zip(self._models, value)):
+            v = getattr(dm, methname)(builder, val)
+            struct = self.set(builder, struct, v, i)
+
+        return struct
+
+    def as_data(self, builder, value):
+        """
+        Converts the LLVM struct in `value` into a representation suited for
+        storing into arrays.
+
+        Note
+        ----
+        Current implementation rarely changes how types are represented for
+        "value" and "data".  This is usually a pointless rebuild of the
+        immutable LLVM struct value.  Luckily, LLVM optimization removes all
+        redundancy.
+
+        Sample usecase: Structures nested with pointers to other structures
+        that can be serialized into  a flat representation when storing into
+        array.
+        """
+        elems = self._as("as_data", builder, value)
+        struct = ir.Constant(self.get_data_type(), ir.Undefined)
+        for i, el in enumerate(elems):
+            struct = builder.insert_value(struct, el, [i])
+        return struct
+
+    def from_data(self, builder, value):
+        """
+        Convert from "data" representation back into "value" representation.
+        Usually invoked when loading from array.
+
+        See notes in `as_data()`
+        """
+        vals = [builder.extract_value(value, [i])
+                for i in range(len(self._members))]
+        return self._from("from_data", builder, vals)
+
+    def load_from_data_pointer(self, builder, ptr, align=None):
+        values = []
+        for i, model in enumerate(self._models):
+            elem_ptr = cgutils.gep_inbounds(builder, ptr, 0, i)
+            val = model.load_from_data_pointer(builder, elem_ptr, align)
+            values.append(val)
+
+        struct = ir.Constant(self.get_value_type(), ir.Undefined)
+        for i, val in enumerate(values):
+            struct = self.set(builder, struct, val, i)
+        return struct
+
+    def as_argument(self, builder, value):
+        return self._as("as_argument", builder, value)
+
+    def from_argument(self, builder, value):
+        return self._from("from_argument", builder, value)
+
+    def as_return(self, builder, value):
+        elems = self._as("as_data", builder, value)
+        struct = ir.Constant(self.get_data_type(), ir.Undefined)
+        for i, el in enumerate(elems):
+            struct = builder.insert_value(struct, el, [i])
+        return struct
+
+    def from_return(self, builder, value):
+        vals = [builder.extract_value(value, [i])
+                for i in range(len(self._members))]
+        return self._from("from_data", builder, vals)
+
+    def get(self, builder, val, pos):
+        """Get a field at the given position or the fieldname
+
+        Args
+        ----
+        builder:
+            LLVM IRBuilder
+        val:
+            value to be inserted
+        pos: int or str
+            field index or field name
+
+        Returns
+        -------
+        Extracted value
+        """
+        if isinstance(pos, str):
+            pos = self.get_field_position(pos)
+        return builder.extract_value(val, [pos],
+                                     name="extracted." + self._fields[pos])
+
+    def set(self, builder, stval, val, pos):
+        """Set a field at the given position or the fieldname
+
+        Args
+        ----
+        builder:
+            LLVM IRBuilder
+        stval:
+            LLVM struct value
+        val:
+            value to be inserted
+        pos: int or str
+            field index or field name
+
+        Returns
+        -------
+        A new LLVM struct with the value inserted
+        """
+        if isinstance(pos, str):
+            pos = self.get_field_position(pos)
+        return builder.insert_value(stval, val, [pos],
+                                    name="inserted." + self._fields[pos])
+
+    def get_field_position(self, field):
+        try:
+            return self._fields.index(field)
+        except ValueError:
+            raise KeyError("%s does not have a field named %r"
+                           % (self.__class__.__name__, field))
+
+    @property
+    def field_count(self):
+        return len(self._fields)
+
+    def get_type(self, pos):
+        """Get the frontend type (numba type) of a field given the position
+         or the fieldname
+
+        Args
+        ----
+        pos: int or str
+            field index or field name
+        """
+        if isinstance(pos, str):
+            pos = self.get_field_position(pos)
+        return self._members[pos]
+
+    def get_model(self, pos):
+        """
+        Get the datamodel of a field given the position or the fieldname.
+
+        Args
+        ----
+        pos: int or str
+            field index or field name
+        """
+        return self._models[pos]
+
+    def traverse(self, builder):
+        def getter(k, value):
+            if value.type != self.get_value_type():
+                args = self.get_value_type(), value.type
+                raise TypeError("expecting {0} but got {1}".format(*args))
+            return self.get(builder, value, k)
+
+        return [(self.get_type(k), partial(getter, k)) for k in self._fields]
+
+    def inner_models(self):
+        return self._models
+
+
+@register_default(types.Complex)
+class ComplexModel(StructModel):
+    _element_type = NotImplemented
+
+    def __init__(self, dmm, fe_type):
+        members = [
+            ('real', fe_type.underlying_float),
+            ('imag', fe_type.underlying_float),
+        ]
+        super(ComplexModel, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.LiteralList)
+@register_default(types.LiteralStrKeyDict)
+@register_default(types.Tuple)
+@register_default(types.NamedTuple)
+@register_default(types.StarArgTuple)
+class TupleModel(StructModel):
+    def __init__(self, dmm, fe_type):
+        members = [('f' + str(i), t) for i, t in enumerate(fe_type)]
+        super(TupleModel, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.UnionType)
+class UnionModel(StructModel):
+    def __init__(self, dmm, fe_type):
+        members = [
+            ('tag', types.uintp),
+            # XXX: it should really be a MemInfoPointer(types.voidptr)
+            ('payload', types.Tuple.from_types(fe_type.types)),
+        ]
+        super(UnionModel, self).__init__(dmm, fe_type, members)
+
+
+
+@register_default(types.Pair)
+class PairModel(StructModel):
+    def __init__(self, dmm, fe_type):
+        members = [('first', fe_type.first_type),
+                   ('second', fe_type.second_type)]
+        super(PairModel, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.ListPayload)
+class ListPayloadModel(StructModel):
+    def __init__(self, dmm, fe_type):
+        # The fields are mutable but the payload is always manipulated
+        # by reference.  This scheme allows mutations of an array to
+        # be seen by its iterators.
+        members = [
+            ('size', types.intp),
+            ('allocated', types.intp),
+            # This member is only used only for reflected lists
+            ('dirty', types.boolean),
+            # Actually an inlined var-sized array
+            ('data', fe_type.container.dtype),
+        ]
+        super(ListPayloadModel, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.List)
+class ListModel(StructModel):
+    def __init__(self, dmm, fe_type):
+        payload_type = types.ListPayload(fe_type)
+        members = [
+            # The meminfo data points to a ListPayload
+            ('meminfo', types.MemInfoPointer(payload_type)),
+            # This member is only used only for reflected lists
+            ('parent', types.pyobject),
+        ]
+        super(ListModel, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.ListIter)
+class ListIterModel(StructModel):
+    def __init__(self, dmm, fe_type):
+        payload_type = types.ListPayload(fe_type.container)
+        members = [
+            # The meminfo data points to a ListPayload (shared with the
+            # original list object)
+            ('meminfo', types.MemInfoPointer(payload_type)),
+            ('index', types.EphemeralPointer(types.intp)),
+            ]
+        super(ListIterModel, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.SetEntry)
+class SetEntryModel(StructModel):
+    def __init__(self, dmm, fe_type):
+        dtype = fe_type.set_type.dtype
+        members = [
+            # -1 = empty, -2 = deleted
+            ('hash', types.intp),
+            ('key', dtype),
+        ]
+        super(SetEntryModel, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.SetPayload)
+class SetPayloadModel(StructModel):
+    def __init__(self, dmm, fe_type):
+        entry_type = types.SetEntry(fe_type.container)
+        members = [
+            # Number of active + deleted entries
+            ('fill', types.intp),
+            # Number of active entries
+            ('used', types.intp),
+            # Allocated size - 1 (size being a power of 2)
+            ('mask', types.intp),
+            # Search finger
+            ('finger', types.intp),
+            # This member is only used only for reflected sets
+            ('dirty', types.boolean),
+            # Actually an inlined var-sized array
+            ('entries', entry_type),
+        ]
+        super(SetPayloadModel, self).__init__(dmm, fe_type, members)
+
+@register_default(types.Set)
+class SetModel(StructModel):
+    def __init__(self, dmm, fe_type):
+        payload_type = types.SetPayload(fe_type)
+        members = [
+            # The meminfo data points to a SetPayload
+            ('meminfo', types.MemInfoPointer(payload_type)),
+            # This member is only used only for reflected sets
+            ('parent', types.pyobject),
+        ]
+        super(SetModel, self).__init__(dmm, fe_type, members)
+
+@register_default(types.SetIter)
+class SetIterModel(StructModel):
+    def __init__(self, dmm, fe_type):
+        payload_type = types.SetPayload(fe_type.container)
+        members = [
+            # The meminfo data points to a SetPayload (shared with the
+            # original set object)
+            ('meminfo', types.MemInfoPointer(payload_type)),
+            # The index into the entries table
+            ('index', types.EphemeralPointer(types.intp)),
+            ]
+        super(SetIterModel, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.Array)
+@register_default(types.Buffer)
+@register_default(types.ByteArray)
+@register_default(types.Bytes)
+@register_default(types.MemoryView)
+@register_default(types.PyArray)
+class ArrayModel(StructModel):
+    def __init__(self, dmm, fe_type):
+        ndim = fe_type.ndim
+        members = [
+            ('meminfo', types.MemInfoPointer(fe_type.dtype)),
+            ('parent', types.pyobject),
+            ('nitems', types.intp),
+            ('itemsize', types.intp),
+            ('data', types.CPointer(fe_type.dtype)),
+            ('shape', types.UniTuple(types.intp, ndim)),
+            ('strides', types.UniTuple(types.intp, ndim)),
+
+        ]
+        super(ArrayModel, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.ArrayFlags)
+class ArrayFlagsModel(StructModel):
+    def __init__(self, dmm, fe_type):
+        members = [
+            ('parent', fe_type.array_type),
+        ]
+        super(ArrayFlagsModel, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.NestedArray)
+class NestedArrayModel(ArrayModel):
+    def __init__(self, dmm, fe_type):
+        self._be_type = dmm.lookup(fe_type.dtype).get_data_type()
+        super(NestedArrayModel, self).__init__(dmm, fe_type)
+
+    def as_storage_type(self):
+        """Return the LLVM type representation for the storage of
+        the nestedarray.
+        """
+        ret = ir.ArrayType(self._be_type, self._fe_type.nitems)
+        return ret
+
+
+@register_default(types.Optional)
+class OptionalModel(StructModel):
+    def __init__(self, dmm, fe_type):
+        members = [
+            ('data', fe_type.type),
+            ('valid', types.boolean),
+        ]
+        self._value_model = dmm.lookup(fe_type.type)
+        super(OptionalModel, self).__init__(dmm, fe_type, members)
+
+    def get_return_type(self):
+        return self._value_model.get_return_type()
+
+    def as_return(self, builder, value):
+        raise NotImplementedError
+
+    def from_return(self, builder, value):
+        return self._value_model.from_return(builder, value)
+
+    def traverse(self, builder):
+        def get_data(value):
+            valid = get_valid(value)
+            data = self.get(builder, value, "data")
+            return builder.select(valid, data, ir.Constant(data.type, None))
+        def get_valid(value):
+            return self.get(builder, value, "valid")
+
+        return [(self.get_type("data"), get_data),
+                (self.get_type("valid"), get_valid)]
+
+
+@register_default(types.Record)
+class RecordModel(CompositeModel):
+    def __init__(self, dmm, fe_type):
+        super(RecordModel, self).__init__(dmm, fe_type)
+        self._models = [self._dmm.lookup(t) for _, t in fe_type.members]
+        self._be_type = ir.ArrayType(ir.IntType(8), fe_type.size)
+        self._be_ptr_type = self._be_type.as_pointer()
+
+    def get_value_type(self):
+        """Passed around as reference to underlying data
+        """
+        return self._be_ptr_type
+
+    def get_argument_type(self):
+        return self._be_ptr_type
+
+    def get_return_type(self):
+        return self._be_ptr_type
+
+    def get_data_type(self):
+        return self._be_type
+
+    def as_data(self, builder, value):
+        return builder.load(value)
+
+    def from_data(self, builder, value):
+        raise NotImplementedError("use load_from_data_pointer() instead")
+
+    def as_argument(self, builder, value):
+        return value
+
+    def from_argument(self, builder, value):
+        return value
+
+    def as_return(self, builder, value):
+        return value
+
+    def from_return(self, builder, value):
+        return value
+
+    def load_from_data_pointer(self, builder, ptr, align=None):
+        return builder.bitcast(ptr, self.get_value_type())
+
+
+@register_default(types.UnicodeCharSeq)
+class UnicodeCharSeq(DataModel):
+    def __init__(self, dmm, fe_type):
+        super(UnicodeCharSeq, self).__init__(dmm, fe_type)
+        charty = ir.IntType(numpy_support.sizeof_unicode_char * 8)
+        self._be_type = ir.ArrayType(charty, fe_type.count)
+
+    def get_value_type(self):
+        return self._be_type
+
+    def get_data_type(self):
+        return self._be_type
+
+    def as_data(self, builder, value):
+        return value
+
+    def from_data(self, builder, value):
+        return value
+
+    def as_return(self, builder, value):
+        return value
+
+    def from_return(self, builder, value):
+        return value
+
+    def as_argument(self, builder, value):
+        return value
+
+    def from_argument(self, builder, value):
+        return value
+
+
+@register_default(types.CharSeq)
+class CharSeq(DataModel):
+    def __init__(self, dmm, fe_type):
+        super(CharSeq, self).__init__(dmm, fe_type)
+        charty = ir.IntType(8)
+        self._be_type = ir.ArrayType(charty, fe_type.count)
+
+    def get_value_type(self):
+        return self._be_type
+
+    def get_data_type(self):
+        return self._be_type
+
+    def as_data(self, builder, value):
+        return value
+
+    def from_data(self, builder, value):
+        return value
+
+    def as_return(self, builder, value):
+        return value
+
+    def from_return(self, builder, value):
+        return value
+
+    def as_argument(self, builder, value):
+        return value
+
+    def from_argument(self, builder, value):
+        return value
+
+
+class CContiguousFlatIter(StructModel):
+    def __init__(self, dmm, fe_type, need_indices):
+        assert fe_type.array_type.layout == 'C'
+        array_type = fe_type.array_type
+        dtype = array_type.dtype
+        ndim = array_type.ndim
+        members = [('array', array_type),
+                   ('stride', types.intp),
+                   ('index', types.EphemeralPointer(types.intp)),
+                   ]
+        if need_indices:
+            # For ndenumerate()
+            members.append(('indices', types.EphemeralArray(types.intp, ndim)))
+        super(CContiguousFlatIter, self).__init__(dmm, fe_type, members)
+
+
+class FlatIter(StructModel):
+    def __init__(self, dmm, fe_type):
+        array_type = fe_type.array_type
+        dtype = array_type.dtype
+        ndim = array_type.ndim
+        members = [('array', array_type),
+                   ('pointers', types.EphemeralArray(types.CPointer(dtype), ndim)),
+                   ('indices', types.EphemeralArray(types.intp, ndim)),
+                   ('exhausted', types.EphemeralPointer(types.boolean)),
+        ]
+        super(FlatIter, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.UniTupleIter)
+class UniTupleIter(StructModel):
+    def __init__(self, dmm, fe_type):
+        members = [('index', types.EphemeralPointer(types.intp)),
+                   ('tuple', fe_type.container,)]
+        super(UniTupleIter, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.misc.SliceLiteral)
+@register_default(types.SliceType)
+class SliceModel(StructModel):
+    def __init__(self, dmm, fe_type):
+        members = [('start', types.intp),
+                   ('stop', types.intp),
+                   ('step', types.intp),
+                   ]
+        super(SliceModel, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.NPDatetime)
+@register_default(types.NPTimedelta)
+class NPDatetimeModel(PrimitiveModel):
+    def __init__(self, dmm, fe_type):
+        be_type = ir.IntType(64)
+        super(NPDatetimeModel, self).__init__(dmm, fe_type, be_type)
+
+
+@register_default(types.ArrayIterator)
+class ArrayIterator(StructModel):
+    def __init__(self, dmm, fe_type):
+        # We use an unsigned index to avoid the cost of negative index tests.
+        members = [('index', types.EphemeralPointer(types.uintp)),
+                   ('array', fe_type.array_type)]
+        super(ArrayIterator, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.EnumerateType)
+class EnumerateType(StructModel):
+    def __init__(self, dmm, fe_type):
+        members = [('count', types.EphemeralPointer(types.intp)),
+                   ('iter', fe_type.source_type)]
+
+        super(EnumerateType, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.ZipType)
+class ZipType(StructModel):
+    def __init__(self, dmm, fe_type):
+        members = [('iter%d' % i, source_type.iterator_type)
+                   for i, source_type in enumerate(fe_type.source_types)]
+        super(ZipType, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.RangeIteratorType)
+class RangeIteratorType(StructModel):
+    def __init__(self, dmm, fe_type):
+        int_type = fe_type.yield_type
+        members = [('iter', types.EphemeralPointer(int_type)),
+                   ('stop', int_type),
+                   ('step', int_type),
+                   ('count', types.EphemeralPointer(int_type))]
+        super(RangeIteratorType, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.Generator)
+class GeneratorModel(CompositeModel):
+    def __init__(self, dmm, fe_type):
+        super(GeneratorModel, self).__init__(dmm, fe_type)
+        # XXX Fold this in DataPacker?
+        self._arg_models = [self._dmm.lookup(t) for t in fe_type.arg_types
+                            if not isinstance(t, types.Omitted)]
+        self._state_models = [self._dmm.lookup(t) for t in fe_type.state_types]
+
+        self._args_be_type = ir.LiteralStructType(
+            [t.get_data_type() for t in self._arg_models])
+        self._state_be_type = ir.LiteralStructType(
+            [t.get_data_type() for t in self._state_models])
+        # The whole generator closure
+        self._be_type = ir.LiteralStructType(
+            [self._dmm.lookup(types.int32).get_value_type(),
+             self._args_be_type, self._state_be_type])
+        self._be_ptr_type = self._be_type.as_pointer()
+
+    def get_value_type(self):
+        """
+        The generator closure is passed around as a reference.
+        """
+        return self._be_ptr_type
+
+    def get_argument_type(self):
+        return self._be_ptr_type
+
+    def get_return_type(self):
+        return self._be_type
+
+    def get_data_type(self):
+        return self._be_type
+
+    def as_argument(self, builder, value):
+        return value
+
+    def from_argument(self, builder, value):
+        return value
+
+    def as_return(self, builder, value):
+        return self.as_data(builder, value)
+
+    def from_return(self, builder, value):
+        return self.from_data(builder, value)
+
+    def as_data(self, builder, value):
+        return builder.load(value)
+
+    def from_data(self, builder, value):
+        stack = cgutils.alloca_once(builder, value.type)
+        builder.store(value, stack)
+        return stack
+
+
+@register_default(types.ArrayCTypes)
+class ArrayCTypesModel(StructModel):
+    def __init__(self, dmm, fe_type):
+        # ndim = fe_type.ndim
+        members = [('data', types.CPointer(fe_type.dtype)),
+                   ('meminfo', types.MemInfoPointer(fe_type.dtype))]
+        super(ArrayCTypesModel, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.RangeType)
+class RangeModel(StructModel):
+    def __init__(self, dmm, fe_type):
+        int_type = fe_type.iterator_type.yield_type
+        members = [('start', int_type),
+                   ('stop', int_type),
+                   ('step', int_type)]
+        super(RangeModel, self).__init__(dmm, fe_type, members)
+
+
+# =============================================================================
+
+@register_default(types.NumpyNdIndexType)
+class NdIndexModel(StructModel):
+    def __init__(self, dmm, fe_type):
+        ndim = fe_type.ndim
+        members = [('shape', types.UniTuple(types.intp, ndim)),
+                   ('indices', types.EphemeralArray(types.intp, ndim)),
+                   ('exhausted', types.EphemeralPointer(types.boolean)),
+                   ]
+        super(NdIndexModel, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.NumpyFlatType)
+def handle_numpy_flat_type(dmm, ty):
+    if ty.array_type.layout == 'C':
+        return CContiguousFlatIter(dmm, ty, need_indices=False)
+    else:
+        return FlatIter(dmm, ty)
+
+@register_default(types.NumpyNdEnumerateType)
+def handle_numpy_ndenumerate_type(dmm, ty):
+    if ty.array_type.layout == 'C':
+        return CContiguousFlatIter(dmm, ty, need_indices=True)
+    else:
+        return FlatIter(dmm, ty)
+
+@register_default(types.BoundFunction)
+def handle_bound_function(dmm, ty):
+    # The same as the underlying type
+    return dmm[ty.this]
+
+
+@register_default(types.NumpyNdIterType)
+class NdIter(StructModel):
+    def __init__(self, dmm, fe_type):
+        array_types = fe_type.arrays
+        ndim = fe_type.ndim
+        shape_len = ndim if fe_type.need_shaped_indexing else 1
+        members = [('exhausted', types.EphemeralPointer(types.boolean)),
+                   ('arrays', types.Tuple(array_types)),
+                   # The iterator's main shape and indices
+                   ('shape', types.UniTuple(types.intp, shape_len)),
+                   ('indices', types.EphemeralArray(types.intp, shape_len)),
+                   ]
+        # Indexing state for the various sub-iterators
+        # XXX use a tuple instead?
+        for i, sub in enumerate(fe_type.indexers):
+            kind, start_dim, end_dim, _ = sub
+            member_name = 'index%d' % i
+            if kind == 'flat':
+                # A single index into the flattened array
+                members.append((member_name, types.EphemeralPointer(types.intp)))
+            elif kind in ('scalar', 'indexed', '0d'):
+                # Nothing required
+                pass
+            else:
+                assert 0
+        # Slots holding values of the scalar args
+        # XXX use a tuple instead?
+        for i, ty in enumerate(fe_type.arrays):
+            if not isinstance(ty, types.Array):
+                member_name = 'scalar%d' % i
+                members.append((member_name, types.EphemeralPointer(ty)))
+
+        super(NdIter, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.DeferredType)
+class DeferredStructModel(CompositeModel):
+    def __init__(self, dmm, fe_type):
+        super(DeferredStructModel, self).__init__(dmm, fe_type)
+        self.typename = "deferred.{0}".format(id(fe_type))
+        self.actual_fe_type = fe_type.get()
+
+    def get_value_type(self):
+        return ir.global_context.get_identified_type(self.typename + '.value')
+
+    def get_data_type(self):
+        return ir.global_context.get_identified_type(self.typename + '.data')
+
+    def get_argument_type(self):
+        return self._actual_model.get_argument_type()
+
+    def as_argument(self, builder, value):
+        inner = self.get(builder, value)
+        return self._actual_model.as_argument(builder, inner)
+
+    def from_argument(self, builder, value):
+        res = self._actual_model.from_argument(builder, value)
+        return self.set(builder, self.make_uninitialized(), res)
+
+    def from_data(self, builder, value):
+        self._define()
+        elem = self.get(builder, value)
+        value = self._actual_model.from_data(builder, elem)
+        out = self.make_uninitialized()
+        return self.set(builder, out, value)
+
+    def as_data(self, builder, value):
+        self._define()
+        elem = self.get(builder, value)
+        value = self._actual_model.as_data(builder, elem)
+        out = self.make_uninitialized(kind='data')
+        return self.set(builder, out, value)
+
+    def from_return(self, builder, value):
+        return value
+
+    def as_return(self, builder, value):
+        return value
+
+    def get(self, builder, value):
+        return builder.extract_value(value, [0])
+
+    def set(self, builder, value, content):
+        return builder.insert_value(value, content, [0])
+
+    def make_uninitialized(self, kind='value'):
+        self._define()
+        if kind == 'value':
+            ty = self.get_value_type()
+        else:
+            ty = self.get_data_type()
+        return ir.Constant(ty, ir.Undefined)
+
+    def _define(self):
+        valty = self.get_value_type()
+        self._define_value_type(valty)
+        datty = self.get_data_type()
+        self._define_data_type(datty)
+
+    def _define_value_type(self, value_type):
+        if value_type.is_opaque:
+            value_type.set_body(self._actual_model.get_value_type())
+
+    def _define_data_type(self, data_type):
+        if data_type.is_opaque:
+            data_type.set_body(self._actual_model.get_data_type())
+
+    @property
+    def _actual_model(self):
+        return self._dmm.lookup(self.actual_fe_type)
+
+    def traverse(self, builder):
+        return [(self.actual_fe_type,
+                 lambda value: builder.extract_value(value, [0]))]
+
+
+@register_default(types.StructRefPayload)
+class StructPayloadModel(StructModel):
+    """Model for the payload of a mutable struct
+    """
+    def __init__(self, dmm, fe_typ):
+        members = tuple(fe_typ.field_dict.items())
+        super().__init__(dmm, fe_typ, members)
+
+
+class StructRefModel(StructModel):
+    """Model for a mutable struct.
+    A reference to the payload
+    """
+    def __init__(self, dmm, fe_typ):
+        dtype = fe_typ.get_data_type()
+        members = [
+            ("meminfo", types.MemInfoPointer(dtype)),
+        ]
+        super().__init__(dmm, fe_typ, members)
+

lib/python3.10/site-packages/numba/core/datamodel/packer.py

@@ -0,0 +1,213 @@
+from collections import deque
+
+from numba.core import types, cgutils
+
+
+
+class DataPacker(object):
+    """
+    A helper to pack a number of typed arguments into a data structure.
+    Omitted arguments (i.e. values with the type `Omitted`) are automatically
+    skipped.
+    """
+    # XXX should DataPacker be a model for a dedicated type?
+
+    def __init__(self, dmm, fe_types):
+        self._dmm = dmm
+        self._fe_types = fe_types
+        self._models = [dmm.lookup(ty) for ty in fe_types]
+
+        self._pack_map = []
+        self._be_types = []
+        for i, ty in enumerate(fe_types):
+            if not isinstance(ty, types.Omitted):
+                self._pack_map.append(i)
+                self._be_types.append(self._models[i].get_data_type())
+
+    def as_data(self, builder, values):
+        """
+        Return the given values packed as a data structure.
+        """
+        elems = [self._models[i].as_data(builder, values[i])
+                 for i in self._pack_map]
+        return cgutils.make_anonymous_struct(builder, elems)
+
+    def _do_load(self, builder, ptr, formal_list=None):
+        res = []
+        for i, i_formal in enumerate(self._pack_map):
+            elem_ptr = cgutils.gep_inbounds(builder, ptr, 0, i)
+            val = self._models[i_formal].load_from_data_pointer(builder, elem_ptr)
+            if formal_list is None:
+                res.append((self._fe_types[i_formal], val))
+            else:
+                formal_list[i_formal] = val
+        return res
+
+    def load(self, builder, ptr):
+        """
+        Load the packed values and return a (type, value) tuples.
+        """
+        return self._do_load(builder, ptr)
+
+    def load_into(self, builder, ptr, formal_list):
+        """
+        Load the packed values into a sequence indexed by formal
+        argument number (skipping any Omitted position).
+        """
+        self._do_load(builder, ptr, formal_list)
+
+
+class ArgPacker(object):
+    """
+    Compute the position for each high-level typed argument.
+    It flattens every composite argument into primitive types.
+    It maintains a position map for unflattening the arguments.
+
+    Since struct (esp. nested struct) have specific ABI requirements (e.g.
+    alignment, pointer address-space, ...) in different architecture (e.g.
+    OpenCL, CUDA), flattening composite argument types simplifes the call
+    setup from the Python side.  Functions are receiving simple primitive
+    types and there are only a handful of these.
+    """
+
+    def __init__(self, dmm, fe_args):
+        self._dmm = dmm
+        self._fe_args = fe_args
+        self._nargs = len(fe_args)
+
+        self._dm_args = []
+        argtys = []
+        for ty in fe_args:
+            dm = self._dmm.lookup(ty)
+            self._dm_args.append(dm)
+            argtys.append(dm.get_argument_type())
+        self._unflattener = _Unflattener(argtys)
+        self._be_args = list(_flatten(argtys))
+
+    def as_arguments(self, builder, values):
+        """Flatten all argument values
+        """
+        if len(values) != self._nargs:
+            raise TypeError("invalid number of args: expected %d, got %d"
+                            % (self._nargs, len(values)))
+
+        if not values:
+            return ()
+
+        args = [dm.as_argument(builder, val)
+                for dm, val in zip(self._dm_args, values)
+                ]
+
+        args = tuple(_flatten(args))
+        return args
+
+    def from_arguments(self, builder, args):
+        """Unflatten all argument values
+        """
+
+        valtree = self._unflattener.unflatten(args)
+        values = [dm.from_argument(builder, val)
+                  for dm, val in zip(self._dm_args, valtree)
+                  ]
+
+        return values
+
+    def assign_names(self, args, names):
+        """Assign names for each flattened argument values.
+        """
+
+        valtree = self._unflattener.unflatten(args)
+        for aval, aname in zip(valtree, names):
+            self._assign_names(aval, aname)
+
+    def _assign_names(self, val_or_nested, name, depth=()):
+        if isinstance(val_or_nested, (tuple, list)):
+            for pos, aval in enumerate(val_or_nested):
+                self._assign_names(aval, name, depth=depth + (pos,))
+        else:
+            postfix = '.'.join(map(str, depth))
+            parts = [name, postfix]
+            val_or_nested.name = '.'.join(filter(bool, parts))
+
+    @property
+    def argument_types(self):
+        """Return a list of LLVM types that are results of flattening
+        composite types.
+        """
+        return tuple(ty for ty in self._be_args if ty != ())
+
+
+def _flatten(iterable):
+    """
+    Flatten nested iterable of (tuple, list).
+    """
+    def rec(iterable):
+        for i in iterable:
+            if isinstance(i, (tuple, list)):
+                for j in rec(i):
+                    yield j
+            else:
+                yield i
+    return rec(iterable)
+
+
+_PUSH_LIST = 1
+_APPEND_NEXT_VALUE = 2
+_APPEND_EMPTY_TUPLE = 3
+_POP = 4
+
+class _Unflattener(object):
+    """
+    An object used to unflatten nested sequences after a given pattern
+    (an arbitrarily nested sequence).
+    The pattern shows the nested sequence shape desired when unflattening;
+    the values it contains are irrelevant.
+    """
+
+    def __init__(self, pattern):
+        self._code = self._build_unflatten_code(pattern)
+
+    def _build_unflatten_code(self, iterable):
+        """Build the unflatten opcode sequence for the given *iterable* structure
+        (an iterable of nested sequences).
+        """
+        code = []
+        def rec(iterable):
+            for i in iterable:
+                if isinstance(i, (tuple, list)):
+                    if len(i) > 0:
+                        code.append(_PUSH_LIST)
+                        rec(i)
+                        code.append(_POP)
+                    else:
+                        code.append(_APPEND_EMPTY_TUPLE)
+                else:
+                    code.append(_APPEND_NEXT_VALUE)
+
+        rec(iterable)
+        return code
+
+    def unflatten(self, flatiter):
+        """Rebuild a nested tuple structure.
+        """
+        vals = deque(flatiter)
+
+        res = []
+        cur = res
+        stack = []
+        for op in self._code:
+            if op is _PUSH_LIST:
+                stack.append(cur)
+                cur.append([])
+                cur = cur[-1]
+            elif op is _APPEND_NEXT_VALUE:
+                cur.append(vals.popleft())
+            elif op is _APPEND_EMPTY_TUPLE:
+                cur.append(())
+            elif op is _POP:
+                cur = stack.pop()
+
+        assert not stack, stack
+        assert not vals, vals
+
+        return res

lib/python3.10/site-packages/numba/core/datamodel/registry.py

@@ -0,0 +1,18 @@
+import functools
+from .manager import DataModelManager
+
+
+def register(dmm, typecls):
+    """Used as decorator to simplify datamodel registration.
+    Returns the object being decorated so that chaining is possible.
+    """
+    def wraps(fn):
+        dmm.register(typecls, fn)
+        return fn
+
+    return wraps
+
+
+default_manager = DataModelManager()
+
+register_default = functools.partial(register, default_manager)

lib/python3.10/site-packages/numba/core/datamodel/testing.py

@@ -0,0 +1,150 @@
+from llvmlite import ir
+from llvmlite import binding as ll
+
+from numba.core import datamodel
+import unittest
+
+
+class DataModelTester(unittest.TestCase):
+    """
+    Test the implementation of a DataModel for a frontend type.
+    """
+    fe_type = NotImplemented
+
+    def setUp(self):
+        self.module = ir.Module()
+        self.datamodel = datamodel.default_manager[self.fe_type]
+
+    def test_as_arg(self):
+        """
+        - Is as_arg() and from_arg() implemented?
+        - Are they the inverse of each other?
+        """
+        fnty = ir.FunctionType(ir.VoidType(), [])
+        function = ir.Function(self.module, fnty, name="test_as_arg")
+        builder = ir.IRBuilder()
+        builder.position_at_end(function.append_basic_block())
+
+        undef_value = ir.Constant(self.datamodel.get_value_type(), None)
+        args = self.datamodel.as_argument(builder, undef_value)
+        self.assertIsNot(args, NotImplemented, "as_argument returned "
+                                               "NotImplementedError")
+
+        if isinstance(args, (tuple, list)):
+            def recur_tuplize(args, func=None):
+                for arg in args:
+                    if isinstance(arg, (tuple, list)):
+                        yield tuple(recur_tuplize(arg, func=func))
+                    else:
+                        if func is None:
+                            yield arg
+                        else:
+                            yield func(arg)
+
+            argtypes = tuple(recur_tuplize(args, func=lambda x: x.type))
+            exptypes = tuple(recur_tuplize(
+                self.datamodel.get_argument_type()))
+            self.assertEqual(exptypes, argtypes)
+        else:
+            self.assertEqual(args.type,
+                             self.datamodel.get_argument_type())
+
+        rev_value = self.datamodel.from_argument(builder, args)
+        self.assertEqual(rev_value.type, self.datamodel.get_value_type())
+
+        builder.ret_void()  # end function
+
+        # Ensure valid LLVM generation
+        materialized = ll.parse_assembly(str(self.module))
+        str(materialized)
+
+    def test_as_return(self):
+        """
+        - Is as_return() and from_return() implemented?
+        - Are they the inverse of each other?
+        """
+        fnty = ir.FunctionType(ir.VoidType(), [])
+        function = ir.Function(self.module, fnty, name="test_as_return")
+        builder = ir.IRBuilder()
+        builder.position_at_end(function.append_basic_block())
+
+        undef_value = ir.Constant(self.datamodel.get_value_type(), None)
+        ret = self.datamodel.as_return(builder, undef_value)
+        self.assertIsNot(ret, NotImplemented, "as_return returned "
+                                              "NotImplementedError")
+
+        self.assertEqual(ret.type, self.datamodel.get_return_type())
+
+        rev_value = self.datamodel.from_return(builder, ret)
+        self.assertEqual(rev_value.type, self.datamodel.get_value_type())
+
+        builder.ret_void()  # end function
+
+        # Ensure valid LLVM generation
+        materialized = ll.parse_assembly(str(self.module))
+        str(materialized)
+
+
+class SupportAsDataMixin(object):
+    """Test as_data() and from_data()
+    """
+    # XXX test load_from_data_pointer() as well
+
+    def test_as_data(self):
+        fnty = ir.FunctionType(ir.VoidType(), [])
+        function = ir.Function(self.module, fnty, name="test_as_data")
+        builder = ir.IRBuilder()
+        builder.position_at_end(function.append_basic_block())
+
+        undef_value = ir.Constant(self.datamodel.get_value_type(), None)
+        data = self.datamodel.as_data(builder, undef_value)
+        self.assertIsNot(data, NotImplemented,
+                         "as_data returned NotImplemented")
+
+        self.assertEqual(data.type, self.datamodel.get_data_type())
+
+        rev_value = self.datamodel.from_data(builder, data)
+        self.assertEqual(rev_value.type,
+                         self.datamodel.get_value_type())
+
+        builder.ret_void()  # end function
+
+        # Ensure valid LLVM generation
+        materialized = ll.parse_assembly(str(self.module))
+        str(materialized)
+
+
+class NotSupportAsDataMixin(object):
+    """Ensure as_data() and from_data() raise NotImplementedError.
+    """
+
+    def test_as_data_not_supported(self):
+        fnty = ir.FunctionType(ir.VoidType(), [])
+        function = ir.Function(self.module, fnty, name="test_as_data")
+        builder = ir.IRBuilder()
+        builder.position_at_end(function.append_basic_block())
+
+        undef_value = ir.Constant(self.datamodel.get_value_type(), None)
+        with self.assertRaises(NotImplementedError):
+            data = self.datamodel.as_data(builder, undef_value)
+        with self.assertRaises(NotImplementedError):
+            rev_data = self.datamodel.from_data(builder, undef_value)
+
+
+class DataModelTester_SupportAsDataMixin(DataModelTester,
+                                         SupportAsDataMixin):
+    pass
+
+
+class DataModelTester_NotSupportAsDataMixin(DataModelTester,
+                                            NotSupportAsDataMixin):
+    pass
+
+
+def test_factory(support_as_data=True):
+    """A helper for returning a unittest TestCase for testing
+    """
+    if support_as_data:
+        return DataModelTester_SupportAsDataMixin
+    else:
+        return DataModelTester_NotSupportAsDataMixin

lib/python3.10/site-packages/numba/core/rewrites/__init__.py

@@ -0,0 +1,8 @@
+"""
+A subpackage hosting Numba IR rewrite passes.
+"""
+
+from .registry import register_rewrite, rewrite_registry, Rewrite
+# Register various built-in rewrite passes
+from numba.core.rewrites import (static_getitem, static_raise, static_binop,
+                                 ir_print)

lib/python3.10/site-packages/numba/core/rewrites/ir_print.py

@@ -0,0 +1,82 @@
+from numba.core import errors, ir
+from numba.core.rewrites import register_rewrite, Rewrite
+
+
+@register_rewrite('before-inference')
+class RewritePrintCalls(Rewrite):
+    """
+    Rewrite calls to the print() global function to dedicated IR print() nodes.
+    """
+
+    def match(self, func_ir, block, typemap, calltypes):
+        self.prints = prints = {}
+        self.block = block
+        # Find all assignments with a right-hand print() call
+        for inst in block.find_insts(ir.Assign):
+            if isinstance(inst.value, ir.Expr) and inst.value.op == 'call':
+                expr = inst.value
+                try:
+                    callee = func_ir.infer_constant(expr.func)
+                except errors.ConstantInferenceError:
+                    continue
+                if callee is print:
+                    if expr.kws:
+                        # Only positional args are supported
+                        msg = ("Numba's print() function implementation does not "
+                            "support keyword arguments.")
+                        raise errors.UnsupportedError(msg, inst.loc)
+                    prints[inst] = expr
+        return len(prints) > 0
+
+    def apply(self):
+        """
+        Rewrite `var = call <print function>(...)` as a sequence of
+        `print(...)` and `var = const(None)`.
+        """
+        new_block = self.block.copy()
+        new_block.clear()
+        for inst in self.block.body:
+            if inst in self.prints:
+                expr = self.prints[inst]
+                print_node = ir.Print(args=expr.args, vararg=expr.vararg,
+                                      loc=expr.loc)
+                new_block.append(print_node)
+                assign_node = ir.Assign(value=ir.Const(None, loc=expr.loc),
+                                        target=inst.target,
+                                        loc=inst.loc)
+                new_block.append(assign_node)
+            else:
+                new_block.append(inst)
+        return new_block
+
+
+@register_rewrite('before-inference')
+class DetectConstPrintArguments(Rewrite):
+    """
+    Detect and store constant arguments to print() nodes.
+    """
+
+    def match(self, func_ir, block, typemap, calltypes):
+        self.consts = consts = {}
+        self.block = block
+        for inst in block.find_insts(ir.Print):
+            if inst.consts:
+                # Already rewritten
+                continue
+            for idx, var in enumerate(inst.args):
+                try:
+                    const = func_ir.infer_constant(var)
+                except errors.ConstantInferenceError:
+                    continue
+                consts.setdefault(inst, {})[idx] = const
+
+        return len(consts) > 0
+
+    def apply(self):
+        """
+        Store detected constant arguments on their nodes.
+        """
+        for inst in self.block.body:
+            if inst in self.consts:
+                inst.consts = self.consts[inst]
+        return self.block

lib/python3.10/site-packages/numba/core/rewrites/registry.py

@@ -0,0 +1,98 @@
+from collections import defaultdict
+
+from numba.core import config
+
+
+class Rewrite(object):
+    '''Defines the abstract base class for Numba rewrites.
+    '''
+
+    def __init__(self, state=None):
+        '''Constructor for the Rewrite class.
+        '''
+        pass
+
+    def match(self, func_ir, block, typemap, calltypes):
+        '''Overload this method to check an IR block for matching terms in the
+        rewrite.
+        '''
+        return False
+
+    def apply(self):
+        '''Overload this method to return a rewritten IR basic block when a
+        match has been found.
+        '''
+        raise NotImplementedError("Abstract Rewrite.apply() called!")
+
+
+class RewriteRegistry(object):
+    '''Defines a registry for Numba rewrites.
+    '''
+    _kinds = frozenset(['before-inference', 'after-inference'])
+
+    def __init__(self):
+        '''Constructor for the rewrite registry.  Initializes the rewrites
+        member to an empty list.
+        '''
+        self.rewrites = defaultdict(list)
+
+    def register(self, kind):
+        """
+        Decorator adding a subclass of Rewrite to the registry for
+        the given *kind*.
+        """
+        if kind not in self._kinds:
+            raise KeyError("invalid kind %r" % (kind,))
+        def do_register(rewrite_cls):
+            if not issubclass(rewrite_cls, Rewrite):
+                raise TypeError('{0} is not a subclass of Rewrite'.format(
+                    rewrite_cls))
+            self.rewrites[kind].append(rewrite_cls)
+            return rewrite_cls
+        return do_register
+
+    def apply(self, kind, state):
+        '''Given a pipeline and a dictionary of basic blocks, exhaustively
+        attempt to apply all registered rewrites to all basic blocks.
+        '''
+        assert kind in self._kinds
+        blocks = state.func_ir.blocks
+        old_blocks = blocks.copy()
+        for rewrite_cls in self.rewrites[kind]:
+            # Exhaustively apply a rewrite until it stops matching.
+            rewrite = rewrite_cls(state)
+            work_list = list(blocks.items())
+            while work_list:
+                key, block = work_list.pop()
+                matches = rewrite.match(state.func_ir, block, state.typemap,
+                                        state.calltypes)
+                if matches:
+                    if config.DEBUG or config.DUMP_IR:
+                        print("_" * 70)
+                        print("REWRITING (%s):" % rewrite_cls.__name__)
+                        block.dump()
+                        print("_" * 60)
+                    new_block = rewrite.apply()
+                    blocks[key] = new_block
+                    work_list.append((key, new_block))
+                    if config.DEBUG or config.DUMP_IR:
+                        new_block.dump()
+                        print("_" * 70)
+        # If any blocks were changed, perform a sanity check.
+        for key, block in blocks.items():
+            if block != old_blocks[key]:
+                block.verify()
+
+        # Some passes, e.g. _inline_const_arraycall are known to occasionally
+        # do invalid things WRT ir.Del, others, e.g. RewriteArrayExprs do valid
+        # things with ir.Del, but the placement is not optimal. The lines below
+        # fix-up the IR so that ref counts are valid and optimally placed,
+        # see #4093 for context. This has to be run here opposed to in
+        # apply() as the CFG needs computing so full IR is needed.
+        from numba.core import postproc
+        post_proc = postproc.PostProcessor(state.func_ir)
+        post_proc.run()
+
+
+rewrite_registry = RewriteRegistry()
+register_rewrite = rewrite_registry.register

lib/python3.10/site-packages/numba/core/rewrites/static_binop.py

@@ -0,0 +1,35 @@
+from numba.core import errors, ir
+from numba.core.rewrites import register_rewrite, Rewrite
+
+
+@register_rewrite('before-inference')
+class DetectStaticBinops(Rewrite):
+    """
+    Detect constant arguments to select binops.
+    """
+
+    # Those operators can benefit from a constant-inferred argument
+    rhs_operators = {'**'}
+
+    def match(self, func_ir, block, typemap, calltypes):
+        self.static_lhs = {}
+        self.static_rhs = {}
+        self.block = block
+        # Find binop expressions with a constant lhs or rhs
+        for expr in block.find_exprs(op='binop'):
+            try:
+                if (expr.fn in self.rhs_operators
+                    and expr.static_rhs is ir.UNDEFINED):
+                    self.static_rhs[expr] = func_ir.infer_constant(expr.rhs)
+            except errors.ConstantInferenceError:
+                continue
+
+        return len(self.static_lhs) > 0 or len(self.static_rhs) > 0
+
+    def apply(self):
+        """
+        Store constant arguments that were detected in match().
+        """
+        for expr, rhs in self.static_rhs.items():
+            expr.static_rhs = rhs
+        return self.block

lib/python3.10/site-packages/numba/core/rewrites/static_getitem.py

@@ -0,0 +1,175 @@
+from numba.core import errors, ir, types
+from numba.core.rewrites import register_rewrite, Rewrite
+
+
+@register_rewrite('before-inference')
+class RewriteConstGetitems(Rewrite):
+    """
+    Rewrite IR expressions of the kind `getitem(value=arr, index=$constXX)`
+    where `$constXX` is a known constant as
+    `static_getitem(value=arr, index=<constant value>)`.
+    """
+
+    def match(self, func_ir, block, typemap, calltypes):
+        self.getitems = getitems = {}
+        self.block = block
+        # Detect all getitem expressions and find which ones can be
+        # rewritten
+        for expr in block.find_exprs(op='getitem'):
+            if expr.op == 'getitem':
+                try:
+                    const = func_ir.infer_constant(expr.index)
+                except errors.ConstantInferenceError:
+                    continue
+                getitems[expr] = const
+
+        return len(getitems) > 0
+
+    def apply(self):
+        """
+        Rewrite all matching getitems as static_getitems.
+        """
+        new_block = self.block.copy()
+        new_block.clear()
+        for inst in self.block.body:
+            if isinstance(inst, ir.Assign):
+                expr = inst.value
+                if expr in self.getitems:
+                    const = self.getitems[expr]
+                    new_expr = ir.Expr.static_getitem(value=expr.value,
+                                                      index=const,
+                                                      index_var=expr.index,
+                                                      loc=expr.loc)
+                    inst = ir.Assign(value=new_expr, target=inst.target,
+                                     loc=inst.loc)
+            new_block.append(inst)
+        return new_block
+
+
+@register_rewrite('after-inference')
+class RewriteStringLiteralGetitems(Rewrite):
+    """
+    Rewrite IR expressions of the kind `getitem(value=arr, index=$XX)`
+    where `$XX` is a StringLiteral value as
+    `static_getitem(value=arr, index=<literal value>)`.
+    """
+
+    def match(self, func_ir, block, typemap, calltypes):
+        """
+        Detect all getitem expressions and find which ones have
+        string literal indexes
+        """
+        self.getitems = getitems = {}
+        self.block = block
+        self.calltypes = calltypes
+        for expr in block.find_exprs(op='getitem'):
+            if expr.op == 'getitem':
+                index_ty = typemap[expr.index.name]
+                if isinstance(index_ty, types.StringLiteral):
+                    getitems[expr] = (expr.index, index_ty.literal_value)
+
+        return len(getitems) > 0
+
+    def apply(self):
+        """
+        Rewrite all matching getitems as static_getitems where the index
+        is the literal value of the string.
+        """
+        new_block = ir.Block(self.block.scope, self.block.loc)
+        for inst in self.block.body:
+            if isinstance(inst, ir.Assign):
+                expr = inst.value
+                if expr in self.getitems:
+                    const, lit_val = self.getitems[expr]
+                    new_expr = ir.Expr.static_getitem(value=expr.value,
+                                                      index=lit_val,
+                                                      index_var=expr.index,
+                                                      loc=expr.loc)
+                    self.calltypes[new_expr] = self.calltypes[expr]
+                    inst = ir.Assign(value=new_expr, target=inst.target,
+                                     loc=inst.loc)
+            new_block.append(inst)
+        return new_block
+
+
+@register_rewrite('after-inference')
+class RewriteStringLiteralSetitems(Rewrite):
+    """
+    Rewrite IR expressions of the kind `setitem(value=arr, index=$XX, value=)`
+    where `$XX` is a StringLiteral value as
+    `static_setitem(value=arr, index=<literal value>, value=)`.
+    """
+
+    def match(self, func_ir, block, typemap, calltypes):
+        """
+        Detect all setitem expressions and find which ones have
+        string literal indexes
+        """
+        self.setitems = setitems = {}
+        self.block = block
+        self.calltypes = calltypes
+        for inst in block.find_insts(ir.SetItem):
+            index_ty = typemap[inst.index.name]
+            if isinstance(index_ty, types.StringLiteral):
+                setitems[inst] = (inst.index, index_ty.literal_value)
+
+        return len(setitems) > 0
+
+    def apply(self):
+        """
+        Rewrite all matching setitems as static_setitems where the index
+        is the literal value of the string.
+        """
+        new_block = ir.Block(self.block.scope, self.block.loc)
+        for inst in self.block.body:
+            if isinstance(inst, ir.SetItem):
+                if inst in self.setitems:
+                    const, lit_val = self.setitems[inst]
+                    new_inst = ir.StaticSetItem(target=inst.target,
+                                                index=lit_val,
+                                                index_var=inst.index,
+                                                value=inst.value,
+                                                loc=inst.loc)
+                    self.calltypes[new_inst] = self.calltypes[inst]
+                    inst = new_inst
+            new_block.append(inst)
+        return new_block
+
+
+@register_rewrite('before-inference')
+class RewriteConstSetitems(Rewrite):
+    """
+    Rewrite IR statements of the kind `setitem(target=arr, index=$constXX, ...)`
+    where `$constXX` is a known constant as
+    `static_setitem(target=arr, index=<constant value>, ...)`.
+    """
+
+    def match(self, func_ir, block, typemap, calltypes):
+        self.setitems = setitems = {}
+        self.block = block
+        # Detect all setitem statements and find which ones can be
+        # rewritten
+        for inst in block.find_insts(ir.SetItem):
+            try:
+                const = func_ir.infer_constant(inst.index)
+            except errors.ConstantInferenceError:
+                continue
+            setitems[inst] = const
+
+        return len(setitems) > 0
+
+    def apply(self):
+        """
+        Rewrite all matching setitems as static_setitems.
+        """
+        new_block = self.block.copy()
+        new_block.clear()
+        for inst in self.block.body:
+            if inst in self.setitems:
+                const = self.setitems[inst]
+                new_inst = ir.StaticSetItem(inst.target, const,
+                                            inst.index, inst.value, inst.loc)
+                new_block.append(new_inst)
+            else:
+                new_block.append(inst)
+        return new_block

lib/python3.10/site-packages/numba/core/rewrites/static_raise.py

@@ -0,0 +1,93 @@
+from numba.core import errors, ir, consts
+from numba.core.rewrites import register_rewrite, Rewrite
+
+
+@register_rewrite('before-inference')
+class RewriteConstRaises(Rewrite):
+    """
+    Rewrite IR statements of the kind `raise(value)`
+    where `value` is the result of instantiating an exception with
+    constant arguments
+    into `static_raise(exception_type, constant args)`.
+
+    This allows lowering in nopython mode, where one can't instantiate
+    exception instances from runtime data.
+    """
+
+    def _is_exception_type(self, const):
+        return isinstance(const, type) and issubclass(const, Exception)
+
+    def _break_constant(self, const, loc):
+        """
+        Break down constant exception.
+        """
+        if isinstance(const, tuple): # it's a tuple(exception class, args)
+            if not self._is_exception_type(const[0]):
+                msg = "Encountered unsupported exception constant %r"
+                raise errors.UnsupportedError(msg % (const[0],), loc)
+            return const[0], tuple(const[1])
+        elif self._is_exception_type(const):
+            return const, None
+        else:
+            if isinstance(const, str):
+                msg = ("Directly raising a string constant as an exception is "
+                       "not supported.")
+            else:
+                msg = "Encountered unsupported constant type used for exception"
+            raise errors.UnsupportedError(msg, loc)
+
+    def _try_infer_constant(self, func_ir, inst):
+        try:
+            return func_ir.infer_constant(inst.exception)
+        except consts.ConstantInferenceError:
+            # not a static exception
+            return None
+
+    def match(self, func_ir, block, typemap, calltypes):
+        self.raises = raises = {}
+        self.tryraises = tryraises = {}
+        self.block = block
+        # Detect all raise statements and find which ones can be
+        # rewritten
+        for inst in block.find_insts((ir.Raise, ir.TryRaise)):
+            if inst.exception is None:
+                # re-reraise
+                exc_type, exc_args = None, None
+            else:
+                # raise <something> => find the definition site for <something>
+                const = self._try_infer_constant(func_ir, inst)
+
+                # failure to infer constant indicates this isn't a static
+                # exception
+                if const is None:
+                    continue
+
+                loc = inst.exception.loc
+                exc_type, exc_args = self._break_constant(const, loc)
+
+            if isinstance(inst, ir.Raise):
+                raises[inst] = exc_type, exc_args
+            elif isinstance(inst, ir.TryRaise):
+                tryraises[inst] = exc_type, exc_args
+            else:
+                raise ValueError('unexpected: {}'.format(type(inst)))
+        return (len(raises) + len(tryraises)) > 0
+
+    def apply(self):
+        """
+        Rewrite all matching setitems as static_setitems.
+        """
+        new_block = self.block.copy()
+        new_block.clear()
+        for inst in self.block.body:
+            if inst in self.raises:
+                exc_type, exc_args = self.raises[inst]
+                new_inst = ir.StaticRaise(exc_type, exc_args, inst.loc)
+                new_block.append(new_inst)
+            elif inst in self.tryraises:
+                exc_type, exc_args = self.tryraises[inst]
+                new_inst = ir.StaticTryRaise(exc_type, exc_args, inst.loc)
+                new_block.append(new_inst)
+            else:
+                new_block.append(inst)
+        return new_block

lib/python3.10/site-packages/numba/core/types/__init__.py

@@ -0,0 +1,386 @@
+import struct
+
+import numpy as np
+from numba.core import utils
+
+from .abstract import *
+from .containers import *
+from .functions import *
+from .iterators import *
+from .misc import *
+from .npytypes import *
+from .scalars import *
+from .function_type import *
+
+numpy_version = tuple(map(int, np.__version__.split('.')[:2]))
+
+# Short names
+
+pyobject = PyObject('pyobject')
+ffi_forced_object = Opaque('ffi_forced_object')
+ffi = Opaque('ffi')
+none = NoneType('none')
+ellipsis = EllipsisType('...')
+Any = Phantom('any')
+undefined = Undefined('undefined')
+py2_string_type = Opaque('str')
+unicode_type = UnicodeType('unicode_type')
+string = unicode_type
+unknown = Dummy('unknown')
+npy_rng = NumPyRandomGeneratorType('rng')
+npy_bitgen = NumPyRandomBitGeneratorType('bitgen')
+
+# _undef_var is used to represent undefined variables in the type system.
+_undef_var = UndefVar('_undef_var')
+
+code_type = Opaque('code')
+pyfunc_type = Opaque('pyfunc')
+
+# No operation is defined on voidptr
+# Can only pass it around
+voidptr = RawPointer('void*')
+
+# optional types
+optional = Optional
+deferred_type = DeferredType
+slice2_type = SliceType('slice<a:b>', 2)
+slice3_type = SliceType('slice<a:b:c>', 3)
+void = none
+
+# Need to ignore mypy errors because mypy cannot unify types for both
+# the type systems even if they're logically mutually exclusive.
+# mypy: ignore-errors
+
+if config.USE_LEGACY_TYPE_SYSTEM: # type: ignore
+    boolean = bool_ = Boolean('bool')
+    if numpy_version >= (2, 0):
+        bool = bool_
+
+    byte = uint8 = Integer('uint8')
+    uint16 = Integer('uint16')
+    uint32 = Integer('uint32')
+    uint64 = Integer('uint64')
+
+    int8 = Integer('int8')
+    int16 = Integer('int16')
+    int32 = Integer('int32')
+    int64 = Integer('int64')
+    intp = int32 if utils.MACHINE_BITS == 32 else int64
+    uintp = uint32 if utils.MACHINE_BITS == 32 else uint64
+    intc = int32 if struct.calcsize('i') == 4 else int64
+    uintc = uint32 if struct.calcsize('I') == 4 else uint64
+    ssize_t = int32 if struct.calcsize('n') == 4 else int64
+    size_t = uint32 if struct.calcsize('N') == 4 else uint64
+
+    float32 = Float('float32')
+    float64 = Float('float64')
+    float16 = Float('float16')
+
+    complex64 = Complex('complex64', float32)
+    complex128 = Complex('complex128', float64)
+
+    range_iter32_type = RangeIteratorType(int32)
+    range_iter64_type = RangeIteratorType(int64)
+    unsigned_range_iter64_type = RangeIteratorType(uint64)
+    range_state32_type = RangeType(int32)
+    range_state64_type = RangeType(int64)
+    unsigned_range_state64_type = RangeType(uint64)
+
+    signed_domain = frozenset([int8, int16, int32, int64])
+    unsigned_domain = frozenset([uint8, uint16, uint32, uint64])
+    integer_domain = signed_domain | unsigned_domain
+    real_domain = frozenset([float32, float64])
+    complex_domain = frozenset([complex64, complex128])
+    number_domain = real_domain | integer_domain | complex_domain
+
+    # Integer Aliases
+    c_bool = py_bool = np_bool_ = boolean
+
+    c_uint8 = np_uint8 = uint8
+    c_uint16 = np_uint16 = uint16
+    c_uint32 = np_uint32 = uint32
+    c_uint64 = np_uint64 = uint64
+    c_uintp = np_uintp = uintp
+
+    c_int8 = np_int8 = int8
+    c_int16 = np_int16 = int16
+    c_int32 = np_int32 = int32
+    c_int64 = np_int64 = int64
+    c_intp = py_int = np_intp = intp
+
+    c_float16 = np_float16 = float16
+    c_float32 = np_float32 = float32
+    c_float64 = py_float = np_float64 = float64
+
+    np_complex64 = complex64
+    py_complex = np_complex128 = complex128
+
+    # Domain Aliases
+    py_signed_domain = np_signed_domain = signed_domain
+    np_unsigned_domain = unsigned_domain
+    py_integer_domain = np_integer_domain = integer_domain
+    py_real_domain = np_real_domain = real_domain
+    py_complex_domain = np_complex_domain = complex_domain
+    py_number_domain = np_number_domain = number_domain
+
+    # Aliases to NumPy type names
+
+    b1 = bool_
+    i1 = int8
+    i2 = int16
+    i4 = int32
+    i8 = int64
+    u1 = uint8
+    u2 = uint16
+    u4 = uint32
+    u8 = uint64
+
+    f2 = float16
+    f4 = float32
+    f8 = float64
+
+    c8 = complex64
+    c16 = complex128
+
+    np_float_ = float32
+    np_double = double = float64
+    if numpy_version < (2, 0):
+        float_ = float32
+
+    _make_signed = lambda x: globals()["int%d" % (np.dtype(x).itemsize * 8)]
+    _make_unsigned = lambda x: globals()["uint%d" % (np.dtype(x).itemsize * 8)]
+
+    char = np_char = _make_signed(np.byte)
+    uchar = np_uchar = byte = _make_unsigned(np.byte)
+    short = np_short = _make_signed(np.short)
+    ushort = np_ushort = _make_unsigned(np.short)
+    int_ = np_int_ = _make_signed(np.int_)
+    uint = np_uint = _make_unsigned(np.int_)
+    intc = np_intc = _make_signed(np.intc) # C-compat int
+    uintc = np_uintc = _make_unsigned(np.uintc) # C-compat uint
+    long_ = np_long = _make_signed(np.int_)  # C-compat long
+    ulong = np_ulong = _make_unsigned(np.int_)  # C-compat ulong
+    longlong = np_longlong = _make_signed(np.longlong)
+    ulonglong = np_ulonglong = _make_unsigned(np.longlong)
+
+    all_str = '''
+    int8
+    int16
+    int32
+    int64
+    uint8
+    uint16
+    uint32
+    uint64
+    intp
+    uintp
+    intc
+    uintc
+    ssize_t
+    size_t
+    boolean
+    float32
+    float64
+    complex64
+    complex128
+    bool_
+    byte
+    char
+    uchar
+    short
+    ushort
+    int_
+    uint
+    long_
+    ulong
+    longlong
+    ulonglong
+    float_
+    double
+    void
+    none
+    b1
+    i1
+    i2
+    i4
+    i8
+    u1
+    u2
+    u4
+    u8
+    f4
+    f8
+    c8
+    c16
+    optional
+    ffi_forced_object
+    ffi
+    deferred_type
+    '''
+else:
+    from .new_scalars import *
+    ### Machine Datatypes ###
+    c_bool = MachineBoolean('c_bool')
+    c_byte = c_int8 = MachineInteger('c_int8')
+    c_int16 = MachineInteger('c_int16')
+    c_int32 = MachineInteger('c_int32')
+    c_int64 = MachineInteger('c_int64')
+    c_uint8 = MachineInteger('c_uint8')
+    c_uint16 = MachineInteger('c_uint16')
+    c_uint32 = MachineInteger('c_uint32')
+    c_uint64 = MachineInteger('c_uint64')
+
+    c_intp = c_int32 if utils.MACHINE_BITS == 32 else c_int64
+    c_uintp = c_uint32 if utils.MACHINE_BITS == 32 else c_uint64
+
+    # Machine Floats
+    c_float16 = MachineFloat('c_float16')
+    c_float32 = MachineFloat('c_float32')
+    c_float64 = MachineFloat('c_float64')
+
+    # Machine Complex
+    c_complex64 = MachineComplex('c_complex64', c_float32)
+    c_complex128 = MachineComplex('c_complex128', c_float64)
+
+    c_signed_domain = frozenset([c_int8, c_int16, c_int32, c_int64])
+    c_unsigned_domain = frozenset([c_uint8, c_uint16, c_uint32, c_uint64])
+    c_integer_domain = c_signed_domain | c_unsigned_domain
+    c_real_domain = frozenset([c_float32, c_float64])
+    c_complex_domain = frozenset([c_complex64, c_complex128])
+    c_number_domain = c_real_domain | c_integer_domain | c_complex_domain
+
+    ### Python Datatypes ###
+    # Python Integers
+    py_bool = PythonBoolean('py_bool')
+    py_int = PythonInteger('py_int')
+
+    # Python Float
+    py_float = PythonFloat('py_float')
+
+    # Python Complex
+    py_complex = PythonComplex('py_complex', py_float)
+
+    py_signed_domain = frozenset([py_int])
+    py_integer_domain = py_signed_domain
+    py_real_domain = frozenset([py_float])
+    py_complex_domain = frozenset([py_complex])
+    py_number_domain = py_real_domain | py_integer_domain | py_complex_domain
+
+    range_iter_type = RangeIteratorType(py_int)
+    range_state_type = RangeType(py_int)
+
+    ### NumPy Datatypes ###
+    # Numpy Integers
+    np_bool_ = np_bool = NumPyBoolean('np_bool_')
+    np_byte = np_int8 = NumPyInteger('np_int8')
+    np_int16 = NumPyInteger('np_int16')
+    np_int32 = NumPyInteger('np_int32')
+    np_int64 = NumPyInteger('np_int64')
+    np_uint8 = NumPyInteger('np_uint8')
+    np_uint16 = NumPyInteger('np_uint16')
+    np_uint32 = NumPyInteger('np_uint32')
+    np_uint64 = NumPyInteger('np_uint64')
+
+    np_intp = np_int32 if utils.MACHINE_BITS == 32 else np_int64
+    np_uintp = np_uint32 if utils.MACHINE_BITS == 32 else np_uint64
+
+    # NumPy Floats
+    np_float16 = NumPyFloat('np_float16')
+    np_float32 = NumPyFloat('np_float32')
+    np_float64 = NumPyFloat('np_float64')
+
+    # NumPy Complex
+    np_complex64 = NumPyComplex('np_complex64', np_float32)
+    np_complex128 = NumPyComplex('np_complex128', np_float64)
+
+    np_signed_domain = frozenset([np_int8, np_int16, np_int32, np_int64])
+    np_unsigned_domain = frozenset([np_uint8, np_uint16, np_uint32, np_uint64])
+    np_integer_domain = np_signed_domain | np_unsigned_domain
+    np_real_domain = frozenset([np_float32, np_float64])
+    np_complex_domain = frozenset([np_complex64, np_complex128])
+    np_number_domain = np_real_domain | np_integer_domain | np_complex_domain
+
+    # NumPy globals
+    np_double = np_float64
+    _make_signed = lambda x: globals()["np_int%d" % (np.dtype(x).itemsize * 8)]
+    _make_unsigned = lambda x: globals()["np_uint%d" % (np.dtype(x).itemsize * 8)]
+
+    np_char = _make_signed(np.byte)
+    np_uchar = byte = _make_unsigned(np.byte)
+    np_short = _make_signed(np.short)
+    np_ushort = _make_unsigned(np.short)
+    np_int_ = _make_signed(np.int_)
+    np_uint = _make_unsigned(np.int_)
+    np_intc = _make_signed(np.intc) # C-compat int
+    np_uintc = _make_unsigned(np.uintc) # C-compat uint
+    np_long_ = _make_signed(np.int_)  # C-compat long
+    np_ulong = _make_unsigned(np.int_)  # C-compat ulong
+    np_longlong = _make_signed(np.longlong)
+    np_ulonglong = _make_unsigned(np.longlong)
+
+    all_str = '''
+    c_bool
+    c_byte
+    c_int8
+    c_int16
+    c_int32
+    c_int64
+    c_uint8
+    c_uint16
+    c_uint32
+    c_uint64
+    c_intp
+    c_uintp
+    c_float16
+    c_float32
+    c_float64
+    c_complex64
+    c_complex128
+    py_bool
+    py_int
+    py_float
+    py_complex
+    np_bool_
+    np_bool
+    np_byte
+    np_int8
+    np_int16
+    np_int32
+    np_int64
+    np_uint8
+    np_uint16
+    np_uint32
+    np_uint64
+    np_intp
+    np_uintp
+    np_float16
+    np_float32
+    np_float64
+    np_complex64
+    np_complex128
+    np_double
+    np_char
+    np_uchar
+    np_short
+    np_ushort
+    np_int_
+    np_uint
+    np_intc
+    np_uintc
+    np_long_
+    np_ulong
+    np_longlong
+    np_ulonglong
+    ffi_forced_object
+    ffi
+    none
+    optional
+    deferred_type
+    void
+    '''
+
+
+__all__ = all_str.split()
+if numpy_version >= (2, 0) and config.USE_LEGACY_TYPE_SYSTEM:
+    __all__.remove('float_')
+    __all__.append('bool')

lib/python3.10/site-packages/numba/core/types/abstract.py

@@ -0,0 +1,512 @@
+from abc import ABCMeta, abstractmethod, abstractproperty
+from typing import Dict as ptDict, Type as ptType
+import itertools
+import weakref
+from functools import cached_property
+
+import numpy as np
+
+from numba.core.utils import get_hashable_key
+
+# Types are added to a global registry (_typecache) in order to assign
+# them unique integer codes for fast matching in _dispatcher.c.
+# However, we also want types to be disposable, therefore we ensure
+# each type is interned as a weak reference, so that it lives only as
+# long as necessary to keep a stable type code.
+# NOTE: some types can still be made immortal elsewhere (for example
+# in _dispatcher.c's internal caches).
+_typecodes = itertools.count()
+
+def _autoincr():
+    n = next(_typecodes)
+    # 4 billion types should be enough, right?
+    assert n < 2 ** 32, "Limited to 4 billion types"
+    return n
+
+_typecache: ptDict[weakref.ref, weakref.ref] = {}
+
+def _on_type_disposal(wr, _pop=_typecache.pop):
+    _pop(wr, None)
+
+
+class _TypeMetaclass(ABCMeta):
+    """
+    A metaclass that will intern instances after they are created.
+    This is done by first creating a new instance (including calling
+    __init__, which sets up the required attributes for equality
+    and hashing), then looking it up in the _typecache registry.
+    """
+
+    def __init__(cls, name, bases, orig_vars):
+        # __init__ is hooked to mark whether a Type class being defined is a
+        # Numba internal type (one which is defined somewhere under the `numba`
+        # module) or an external type (one which is defined elsewhere, for
+        # example a user defined type).
+        super(_TypeMetaclass, cls).__init__(name, bases, orig_vars)
+        root = (cls.__module__.split('.'))[0]
+        cls._is_internal = root == "numba"
+
+    def _intern(cls, inst):
+        # Try to intern the created instance
+        wr = weakref.ref(inst, _on_type_disposal)
+        orig = _typecache.get(wr)
+        orig = orig and orig()
+        if orig is not None:
+            return orig
+        else:
+            inst._code = _autoincr()
+            _typecache[wr] = wr
+            return inst
+
+    def __call__(cls, *args, **kwargs):
+        """
+        Instantiate *cls* (a Type subclass, presumably) and intern it.
+        If an interned instance already exists, it is returned, otherwise
+        the new instance is returned.
+        """
+        inst = type.__call__(cls, *args, **kwargs)
+        return cls._intern(inst)
+
+
+def _type_reconstructor(reconstructor, reconstructor_args, state):
+    """
+    Rebuild function for unpickling types.
+    """
+    obj = reconstructor(*reconstructor_args)
+    if state:
+        obj.__dict__.update(state)
+    return type(obj)._intern(obj)
+
+
+class Type(metaclass=_TypeMetaclass):
+    """
+    The base class for all Numba types.
+    It is essential that proper equality comparison is implemented.  The
+    default implementation uses the "key" property (overridable in subclasses)
+    for both comparison and hashing, to ensure sane behaviour.
+    """
+
+    mutable = False
+    # Rather the type is reflected at the python<->nopython boundary
+    reflected = False
+
+    def __init__(self, name):
+        self.name = name
+
+    @property
+    def key(self):
+        """
+        A property used for __eq__, __ne__ and __hash__.  Can be overridden
+        in subclasses.
+        """
+        return self.name
+
+    @property
+    def mangling_args(self):
+        """
+        Returns `(basename, args)` where `basename` is the name of the type
+        and `args` is a sequence of parameters of the type.
+
+        Subclass should override to specialize the behavior.
+        By default, this returns `(self.name, ())`.
+        """
+        return self.name, ()
+
+    def __repr__(self):
+        return self.name
+
+    def __str__(self):
+        return self.name
+
+    def __hash__(self):
+        return hash(self.key)
+
+    def __eq__(self, other):
+        return self.__class__ is other.__class__ and self.key == other.key
+
+    def __ne__(self, other):
+        return not (self == other)
+
+    def __reduce__(self):
+        reconstructor, args, state = super(Type, self).__reduce__()
+        return (_type_reconstructor, (reconstructor, args, state))
+
+    def unify(self, typingctx, other):
+        """
+        Try to unify this type with the *other*.  A third type must
+        be returned, or None if unification is not possible.
+        Only override this if the coercion logic cannot be expressed
+        as simple casting rules.
+        """
+        return None
+
+    def can_convert_to(self, typingctx, other):
+        """
+        Check whether this type can be converted to the *other*.
+        If successful, must return a string describing the conversion, e.g.
+        "exact", "promote", "unsafe", "safe"; otherwise None is returned.
+        """
+        return None
+
+    def can_convert_from(self, typingctx, other):
+        """
+        Similar to *can_convert_to*, but in reverse.  Only needed if
+        the type provides conversion from other types.
+        """
+        return None
+
+    def is_precise(self):
+        """
+        Whether this type is precise, i.e. can be part of a successful
+        type inference.  Default implementation returns True.
+        """
+        return True
+
+    def augment(self, other):
+        """
+        Augment this type with the *other*.  Return the augmented type,
+        or None if not supported.
+        """
+        return None
+
+    # User-facing helpers.  These are not part of the core Type API but
+    # are provided so that users can write e.g. `numba.boolean(1.5)`
+    # (returns True) or `types.int32(types.int32[:])` (returns something
+    # usable as a function signature).
+
+    def __call__(self, *args):
+        from numba.core.typing import signature
+        if len(args) == 1 and not isinstance(args[0], Type):
+            return self.cast_python_value(args[0])
+        return signature(self, # return_type
+                         *args)
+
+    def __getitem__(self, args):
+        """
+        Return an array of this type.
+        """
+        from numba.core.types import Array
+        ndim, layout = self._determine_array_spec(args)
+        return Array(dtype=self, ndim=ndim, layout=layout)
+
+    def _determine_array_spec(self, args):
+        # XXX non-contiguous by default, even for 1d arrays,
+        # doesn't sound very intuitive
+        def validate_slice(s):
+            return isinstance(s, slice) and s.start is None and s.stop is None
+
+        if isinstance(args, (tuple, list)) and all(map(validate_slice, args)):
+            ndim = len(args)
+            if args[0].step == 1:
+                layout = 'F'
+            elif args[-1].step == 1:
+                layout = 'C'
+            else:
+                layout = 'A'
+        elif validate_slice(args):
+            ndim = 1
+            if args.step == 1:
+                layout = 'C'
+            else:
+                layout = 'A'
+        else:
+            # Raise a KeyError to not be handled by collection constructors (e.g. list).
+            raise KeyError(f"Can only index numba types with slices with no start or stop, got {args}.")
+
+        return ndim, layout
+
+    def cast_python_value(self, args):
+        raise NotImplementedError
+
+
+    @property
+    def is_internal(self):
+        """ Returns True if this class is an internally defined Numba type by
+        virtue of the module in which it is instantiated, False else."""
+        return self._is_internal
+
+    def dump(self, tab=''):
+        print(f'{tab}DUMP {type(self).__name__}[code={self._code}, name={self.name}]')
+
+# XXX we should distinguish between Dummy (no meaningful
+# representation, e.g. None or a builtin function) and Opaque (has a
+# meaningful representation, e.g. ExternalFunctionPointer)
+
+class Dummy(Type):
+    """
+    Base class for types that do not really have a representation and are
+    compatible with a void*.
+    """
+
+
+class Hashable(Type):
+    """
+    Base class for hashable types.
+    """
+
+
+class Number(Hashable):
+    """
+    Base class for number types.
+    """
+
+    def unify(self, typingctx, other):
+        """
+        Unify the two number types using Numpy's rules.
+        """
+        from numba.np import numpy_support
+        if isinstance(other, Number):
+            # XXX: this can produce unsafe conversions,
+            # e.g. would unify {int64, uint64} to float64
+            a = numpy_support.as_dtype(self)
+            b = numpy_support.as_dtype(other)
+            sel = np.promote_types(a, b)
+            return numpy_support.from_dtype(sel)
+
+
+class Callable(Type):
+    """
+    Base class for callables.
+    """
+
+    @abstractmethod
+    def get_call_type(self, context, args, kws):
+        """
+        Using the typing *context*, resolve the callable's signature for
+        the given arguments.  A signature object is returned, or None.
+        """
+
+    @abstractmethod
+    def get_call_signatures(self):
+        """
+        Returns a tuple of (list of signatures, parameterized)
+        """
+
+    @abstractmethod
+    def get_impl_key(self, sig):
+        """
+        Returns the impl key for the given signature
+        """
+
+
+class DTypeSpec(Type):
+    """
+    Base class for types usable as "dtype" arguments to various Numpy APIs
+    (e.g. np.empty()).
+    """
+
+    @abstractproperty
+    def dtype(self):
+        """
+        The actual dtype denoted by this dtype spec (a Type instance).
+        """
+
+
+class IterableType(Type):
+    """
+    Base class for iterable types.
+    """
+
+    @abstractproperty
+    def iterator_type(self):
+        """
+        The iterator type obtained when calling iter() (explicitly or implicitly).
+        """
+
+
+class Sized(Type):
+    """
+    Base class for objects that support len()
+    """
+
+
+class ConstSized(Sized):
+    """
+    For types that have a constant size
+    """
+    @abstractmethod
+    def __len__(self):
+        pass
+
+
+class IteratorType(IterableType):
+    """
+    Base class for all iterator types.
+    Derived classes should implement the *yield_type* attribute.
+    """
+
+    def __init__(self, name, **kwargs):
+        super(IteratorType, self).__init__(name, **kwargs)
+
+    @abstractproperty
+    def yield_type(self):
+        """
+        The type of values yielded by the iterator.
+        """
+
+    # This is a property to avoid recursivity (for pickling)
+
+    @property
+    def iterator_type(self):
+        return self
+
+
+class Container(Sized, IterableType):
+    """
+    Base class for container types.
+    """
+
+
+class Sequence(Container):
+    """
+    Base class for 1d sequence types.  Instances should have the *dtype*
+    attribute.
+    """
+
+
+class MutableSequence(Sequence):
+    """
+    Base class for 1d mutable sequence types.  Instances should have the
+    *dtype* attribute.
+    """
+
+    mutable = True
+
+class ArrayCompatible(Type):
+    """
+    Type class for Numpy array-compatible objects (typically, objects
+    exposing an __array__ method).
+    Derived classes should implement the *as_array* attribute.
+    """
+    # If overridden by a subclass, it should also implement typing
+    # for '__array_wrap__' with arguments (input, formal result).
+    array_priority = 0.0
+
+    @abstractproperty
+    def as_array(self):
+        """
+        The equivalent array type, for operations supporting array-compatible
+        objects (such as ufuncs).
+        """
+
+    # For compatibility with types.Array
+
+    @cached_property
+    def ndim(self):
+        return self.as_array.ndim
+
+    @cached_property
+    def layout(self):
+        return self.as_array.layout
+
+    @cached_property
+    def dtype(self):
+        return self.as_array.dtype
+
+
+class Literal(Type):
+    """Base class for Literal types.
+    Literal types contain the original Python value in the type.
+
+    A literal type should always be constructed from the `literal(val)`
+    function.
+    """
+
+    # *ctor_map* is a dictionary mapping Python types to Literal subclasses
+    # for constructing a numba type for a given Python type.
+    # It is used in `literal(val)` function.
+    # To add new Literal subclass, register a new mapping to this dict.
+    ctor_map: ptDict[type, ptType['Literal']] = {}
+
+    # *_literal_type_cache* is used to cache the numba type of the given value.
+    _literal_type_cache = None
+
+    def __init__(self, value):
+        if type(self) is Literal:
+            raise TypeError(
+                "Cannot be constructed directly. "
+                "Use `numba.types.literal(value)` instead",
+            )
+        self._literal_init(value)
+        fmt = "Literal[{}]({})"
+        super(Literal, self).__init__(fmt.format(type(value).__name__, value))
+
+    def _literal_init(self, value):
+        self._literal_value = value
+        # We want to support constants of non-hashable values, therefore
+        # fall back on the value's id() if necessary.
+        self._key = get_hashable_key(value)
+
+    @property
+    def literal_value(self):
+        return self._literal_value
+
+    @property
+    def literal_type(self):
+        if self._literal_type_cache is None:
+            from numba.core import typing
+            ctx = typing.Context()
+            try:
+                res = ctx.resolve_value_type(self.literal_value)
+            except ValueError as e:
+
+                if "Int value is too large" in str(e):
+                    # If a string literal cannot create an IntegerLiteral
+                    # because of overflow we generate this message.
+                    msg = f"Cannot create literal type. {str(e)}"
+                    raise TypeError(msg)
+                # Not all literal types have a literal_value that can be
+                # resolved to a type, for example, LiteralStrKeyDict has a
+                # literal_value that is a python dict for which there's no
+                # `typeof` support.
+                msg = "{} has no attribute 'literal_type'".format(self)
+                raise AttributeError(msg)
+            self._literal_type_cache = res
+
+        return self._literal_type_cache
+
+
+
+class TypeRef(Dummy):
+    """Reference to a type.
+
+    Used when a type is passed as a value.
+    """
+    def __init__(self, instance_type):
+        self.instance_type = instance_type
+        super(TypeRef, self).__init__('typeref[{}]'.format(self.instance_type))
+
+    @property
+    def key(self):
+        return self.instance_type
+
+
+class InitialValue(object):
+    """
+    Used as a mixin for a type will potentially have an initial value that will
+    be carried in the .initial_value attribute.
+    """
+    def __init__(self, initial_value):
+        self._initial_value = initial_value
+
+    @property
+    def initial_value(self):
+        return self._initial_value
+
+
+class Poison(Type):
+    """
+    This is the "bottom" type in the type system. It won't unify and it's
+    unliteral version is Poison of itself. It's advisable for debugging purposes
+    to call the constructor with the type that's being poisoned (for whatever
+    reason) but this isn't strictly required.
+    """
+    def __init__(self, ty):
+        self.ty = ty
+        super(Poison, self).__init__(name="Poison<%s>" % ty)
+
+    def __unliteral__(self):
+        return Poison(self)
+
+    def unify(self, typingctx, other):
+        return None

lib/python3.10/site-packages/numba/core/types/common.py

@@ -0,0 +1,104 @@
+"""
+Helper classes / mixins for defining types.
+"""
+
+from .abstract import ArrayCompatible, Dummy, IterableType, IteratorType
+from numba.core.errors import NumbaTypeError, NumbaValueError
+
+
+class Opaque(Dummy):
+    """
+    A type that is a opaque pointer.
+    """
+
+
+class SimpleIterableType(IterableType):
+
+    def __init__(self, name, iterator_type):
+        self._iterator_type = iterator_type
+        super(SimpleIterableType, self).__init__(name)
+
+    @property
+    def iterator_type(self):
+        return self._iterator_type
+
+
+class SimpleIteratorType(IteratorType):
+
+    def __init__(self, name, yield_type):
+        self._yield_type = yield_type
+        super(SimpleIteratorType, self).__init__(name)
+
+    @property
+    def yield_type(self):
+        return self._yield_type
+
+
+class Buffer(IterableType, ArrayCompatible):
+    """
+    Type class for objects providing the buffer protocol.
+    Derived classes exist for more specific cases.
+    """
+    mutable = True
+    slice_is_copy = False
+    aligned = True
+
+    # CS and FS are not reserved for inner contig but strided
+    LAYOUTS = frozenset(['C', 'F', 'CS', 'FS', 'A'])
+
+    def __init__(self, dtype, ndim, layout, readonly=False, name=None):
+        from .misc import unliteral
+
+        if isinstance(dtype, Buffer):
+            msg = ("The dtype of a Buffer type cannot itself be a Buffer type, "
+                   "this is unsupported behaviour."
+                   "\nThe dtype requested for the unsupported Buffer was: {}.")
+            raise NumbaTypeError(msg.format(dtype))
+        if layout not in self.LAYOUTS:
+            raise NumbaValueError("Invalid layout '%s'" % layout)
+        self.dtype = unliteral(dtype)
+        self.ndim = ndim
+        self.layout = layout
+        if readonly:
+            self.mutable = False
+        if name is None:
+            type_name = self.__class__.__name__.lower()
+            if readonly:
+                type_name = "readonly %s" % type_name
+            name = "%s(%s, %sd, %s)" % (type_name, dtype, ndim, layout)
+        super(Buffer, self).__init__(name)
+
+    @property
+    def iterator_type(self):
+        from .iterators import ArrayIterator
+        return ArrayIterator(self)
+
+    @property
+    def as_array(self):
+        return self
+
+    def copy(self, dtype=None, ndim=None, layout=None):
+        if dtype is None:
+            dtype = self.dtype
+        if ndim is None:
+            ndim = self.ndim
+        if layout is None:
+            layout = self.layout
+        return self.__class__(dtype=dtype, ndim=ndim, layout=layout,
+                              readonly=not self.mutable)
+
+    @property
+    def key(self):
+        return self.dtype, self.ndim, self.layout, self.mutable
+
+    @property
+    def is_c_contig(self):
+        return self.layout == 'C' or (self.ndim <= 1 and self.layout in 'CF')
+
+    @property
+    def is_f_contig(self):
+        return self.layout == 'F' or (self.ndim <= 1 and self.layout in 'CF')
+
+    @property
+    def is_contig(self):
+        return self.layout in 'CF'

lib/python3.10/site-packages/numba/core/types/containers.py

@@ -0,0 +1,974 @@
+from collections.abc import Iterable
+from collections.abc import Sequence as pySequence
+from types import MappingProxyType
+
+from .abstract import (
+    ConstSized,
+    Container,
+    Hashable,
+    MutableSequence,
+    Sequence,
+    Type,
+    TypeRef,
+    Literal,
+    InitialValue,
+    Poison,
+)
+from .common import (
+    Buffer,
+    IterableType,
+    SimpleIterableType,
+    SimpleIteratorType,
+)
+from .misc import Undefined, unliteral, Optional, NoneType
+from ..typeconv import Conversion
+from ..errors import TypingError
+from .. import utils
+
+
+class Pair(Type):
+    """
+    A heterogeneous pair.
+    """
+
+    def __init__(self, first_type, second_type):
+        self.first_type = first_type
+        self.second_type = second_type
+        name = "pair<%s, %s>" % (first_type, second_type)
+        super(Pair, self).__init__(name=name)
+
+    @property
+    def key(self):
+        return self.first_type, self.second_type
+
+    def unify(self, typingctx, other):
+        if isinstance(other, Pair):
+            first = typingctx.unify_pairs(self.first_type, other.first_type)
+            second = typingctx.unify_pairs(self.second_type, other.second_type)
+            if first is not None and second is not None:
+                return Pair(first, second)
+
+
+class BaseContainerIterator(SimpleIteratorType):
+    """
+    Convenience base class for some container iterators.
+
+    Derived classes must implement the *container_class* attribute.
+    """
+
+    def __init__(self, container):
+        assert isinstance(container, self.container_class), container
+        self.container = container
+        yield_type = container.dtype
+        name = "iter(%s)" % container
+        super(BaseContainerIterator, self).__init__(name, yield_type)
+
+    def unify(self, typingctx, other):
+        cls = type(self)
+        if isinstance(other, cls):
+            container = typingctx.unify_pairs(self.container, other.container)
+            if container is not None:
+                return cls(container)
+
+    @property
+    def key(self):
+        return self.container
+
+
+class BaseContainerPayload(Type):
+    """
+    Convenience base class for some container payloads.
+
+    Derived classes must implement the *container_class* attribute.
+    """
+
+    def __init__(self, container):
+        assert isinstance(container, self.container_class)
+        self.container = container
+        name = "payload(%s)" % container
+        super(BaseContainerPayload, self).__init__(name)
+
+    @property
+    def key(self):
+        return self.container
+
+
+class Bytes(Buffer):
+    """
+    Type class for Python 3.x bytes objects.
+    """
+
+    mutable = False
+    # Actually true but doesn't matter since bytes is immutable
+    slice_is_copy = False
+
+
+class ByteArray(Buffer):
+    """
+    Type class for bytearray objects.
+    """
+
+    slice_is_copy = True
+
+
+class PyArray(Buffer):
+    """
+    Type class for array.array objects.
+    """
+
+    slice_is_copy = True
+
+
+class MemoryView(Buffer):
+    """
+    Type class for memoryview objects.
+    """
+
+
+def is_homogeneous(*tys):
+    """Are the types homogeneous?
+    """
+    if tys:
+        first, tys = tys[0], tys[1:]
+        return not any(t != first for t in tys)
+    else:
+        # *tys* is empty.
+        return False
+
+
+class BaseTuple(ConstSized, Hashable):
+    """
+    The base class for all tuple types (with a known size).
+    """
+
+    @classmethod
+    def from_types(cls, tys, pyclass=None):
+        """
+        Instantiate the right tuple type for the given element types.
+        """
+        if pyclass is not None and pyclass is not tuple:
+            # A subclass => is it a namedtuple?
+            assert issubclass(pyclass, tuple)
+            if hasattr(pyclass, "_asdict"):
+                tys = tuple(map(unliteral, tys))
+                homogeneous = is_homogeneous(*tys)
+                if homogeneous:
+                    return NamedUniTuple(tys[0], len(tys), pyclass)
+                else:
+                    return NamedTuple(tys, pyclass)
+        else:
+            dtype = utils.unified_function_type(tys)
+            if dtype is not None:
+                return UniTuple(dtype, len(tys))
+            # non-named tuple
+            homogeneous = is_homogeneous(*tys)
+            if homogeneous:
+                return cls._make_homogeneous_tuple(tys[0], len(tys))
+            else:
+                return cls._make_heterogeneous_tuple(tys)
+
+    @classmethod
+    def _make_homogeneous_tuple(cls, dtype, count):
+        return UniTuple(dtype, count)
+
+    @classmethod
+    def _make_heterogeneous_tuple(cls, tys):
+        return Tuple(tys)
+
+
+class BaseAnonymousTuple(BaseTuple):
+    """
+    Mixin for non-named tuples.
+    """
+
+    def can_convert_to(self, typingctx, other):
+        """
+        Convert this tuple to another one.  Note named tuples are rejected.
+        """
+        if not isinstance(other, BaseAnonymousTuple):
+            return
+        if len(self) != len(other):
+            return
+        if len(self) == 0:
+            return Conversion.safe
+        if isinstance(other, BaseTuple):
+            kinds = [
+                typingctx.can_convert(ta, tb) for ta, tb in zip(self, other)
+            ]
+            if any(kind is None for kind in kinds):
+                return
+            return max(kinds)
+
+    def __unliteral__(self):
+        return type(self).from_types([unliteral(t) for t in self])
+
+
+class _HomogeneousTuple(Sequence, BaseTuple):
+    @property
+    def iterator_type(self):
+        return UniTupleIter(self)
+
+    def __getitem__(self, i):
+        """
+        Return element at position i
+        """
+        return self.dtype
+
+    def __iter__(self):
+        return iter([self.dtype] * self.count)
+
+    def __len__(self):
+        return self.count
+
+    @property
+    def types(self):
+        return (self.dtype,) * self.count
+
+
+class UniTuple(BaseAnonymousTuple, _HomogeneousTuple, Sequence):
+    """
+    Type class for homogeneous tuples.
+    """
+
+    def __init__(self, dtype, count):
+        self.dtype = dtype
+        self.count = count
+        name = "%s(%s x %d)" % (self.__class__.__name__, dtype, count,)
+        super(UniTuple, self).__init__(name)
+
+    @property
+    def mangling_args(self):
+        return self.__class__.__name__, (self.dtype, self.count)
+
+    @property
+    def key(self):
+        return self.dtype, self.count
+
+    def unify(self, typingctx, other):
+        """
+        Unify UniTuples with their dtype
+        """
+        if isinstance(other, UniTuple) and len(self) == len(other):
+            dtype = typingctx.unify_pairs(self.dtype, other.dtype)
+            if dtype is not None:
+                return UniTuple(dtype=dtype, count=self.count)
+
+    def __unliteral__(self):
+        return type(self)(dtype=unliteral(self.dtype), count=self.count)
+
+    def __repr__(self):
+        return f"UniTuple({repr(self.dtype)}, {self.count})"
+
+
+class UniTupleIter(BaseContainerIterator):
+    """
+    Type class for homogeneous tuple iterators.
+    """
+
+    container_class = _HomogeneousTuple
+
+
+class _HeterogeneousTuple(BaseTuple):
+    def __getitem__(self, i):
+        """
+        Return element at position i
+        """
+        return self.types[i]
+
+    def __len__(self):
+        # Beware: this makes Tuple(()) false-ish
+        return len(self.types)
+
+    def __iter__(self):
+        return iter(self.types)
+
+    @staticmethod
+    def is_types_iterable(types):
+        # issue 4463 - check if argument 'types' is iterable
+        if not isinstance(types, Iterable):
+            raise TypingError("Argument 'types' is not iterable")
+
+
+class UnionType(Type):
+    def __init__(self, types):
+        self.types = tuple(sorted(set(types), key=lambda x: x.name))
+        name = "Union[{}]".format(",".join(map(str, self.types)))
+        super(UnionType, self).__init__(name=name)
+
+    def get_type_tag(self, typ):
+        return self.types.index(typ)
+
+
+class Tuple(BaseAnonymousTuple, _HeterogeneousTuple):
+    def __new__(cls, types):
+
+        t = utils.unified_function_type(types, require_precise=True)
+        if t is not None:
+            return UniTuple(dtype=t, count=len(types))
+
+        _HeterogeneousTuple.is_types_iterable(types)
+
+        if types and all(t == types[0] for t in types[1:]):
+            return UniTuple(dtype=types[0], count=len(types))
+        else:
+            return object.__new__(Tuple)
+
+    def __init__(self, types):
+        self.types = tuple(types)
+        self.count = len(self.types)
+        self.dtype = UnionType(types)
+        name = "%s(%s)" % (
+            self.__class__.__name__,
+            ", ".join(str(i) for i in self.types),
+        )
+        super(Tuple, self).__init__(name)
+
+    @property
+    def mangling_args(self):
+        return self.__class__.__name__, tuple(t for t in self.types)
+
+    @property
+    def key(self):
+        return self.types
+
+    def unify(self, typingctx, other):
+        """
+        Unify elements of Tuples/UniTuples
+        """
+        # Other is UniTuple or Tuple
+        if isinstance(other, BaseTuple) and len(self) == len(other):
+            unified = [
+                typingctx.unify_pairs(ta, tb) for ta, tb in zip(self, other)
+            ]
+
+            if all(t is not None for t in unified):
+                return Tuple(unified)
+
+    def __repr__(self):
+        return f"Tuple({tuple(ty for ty in self.types)})"
+
+
+class _StarArgTupleMixin:
+    @classmethod
+    def _make_homogeneous_tuple(cls, dtype, count):
+        return StarArgUniTuple(dtype, count)
+
+    @classmethod
+    def _make_heterogeneous_tuple(cls, tys):
+        return StarArgTuple(tys)
+
+
+class StarArgTuple(_StarArgTupleMixin, Tuple):
+    """To distinguish from Tuple() used as argument to a `*args`.
+    """
+
+    def __new__(cls, types):
+        _HeterogeneousTuple.is_types_iterable(types)
+
+        if types and all(t == types[0] for t in types[1:]):
+            return StarArgUniTuple(dtype=types[0], count=len(types))
+        else:
+            return object.__new__(StarArgTuple)
+
+
+class StarArgUniTuple(_StarArgTupleMixin, UniTuple):
+    """To distinguish from UniTuple() used as argument to a `*args`.
+    """
+
+
+class BaseNamedTuple(BaseTuple):
+    pass
+
+
+class NamedUniTuple(_HomogeneousTuple, BaseNamedTuple):
+    def __init__(self, dtype, count, cls):
+        self.dtype = dtype
+        self.count = count
+        self.fields = tuple(cls._fields)
+        self.instance_class = cls
+        name = "%s(%s x %d)" % (cls.__name__, dtype, count)
+        super(NamedUniTuple, self).__init__(name)
+
+    @property
+    def iterator_type(self):
+        return UniTupleIter(self)
+
+    @property
+    def key(self):
+        return self.instance_class, self.dtype, self.count
+
+
+class NamedTuple(_HeterogeneousTuple, BaseNamedTuple):
+    def __init__(self, types, cls):
+        _HeterogeneousTuple.is_types_iterable(types)
+
+        self.types = tuple(types)
+        self.count = len(self.types)
+        self.fields = tuple(cls._fields)
+        self.instance_class = cls
+        name = "%s(%s)" % (cls.__name__, ", ".join(str(i) for i in self.types))
+        super(NamedTuple, self).__init__(name)
+
+    @property
+    def key(self):
+        return self.instance_class, self.types
+
+
+class List(MutableSequence, InitialValue):
+    """
+    Type class for (arbitrary-sized) homogeneous lists.
+    """
+
+    def __init__(self, dtype, reflected=False, initial_value=None):
+        dtype = unliteral(dtype)
+        self.dtype = dtype
+        self.reflected = reflected
+        cls_name = "reflected list" if reflected else "list"
+        name = "%s(%s)<iv=%s>" % (cls_name, self.dtype, initial_value)
+        super(List, self).__init__(name=name)
+        InitialValue.__init__(self, initial_value)
+
+    def copy(self, dtype=None, reflected=None):
+        if dtype is None:
+            dtype = self.dtype
+        if reflected is None:
+            reflected = self.reflected
+        return List(dtype, reflected, self.initial_value)
+
+    def unify(self, typingctx, other):
+        if isinstance(other, List):
+            dtype = typingctx.unify_pairs(self.dtype, other.dtype)
+            reflected = self.reflected or other.reflected
+            if dtype is not None:
+                siv = self.initial_value
+                oiv = other.initial_value
+                if siv is not None and oiv is not None:
+                    use = siv
+                    if siv is None:
+                        use = oiv
+                    return List(dtype, reflected, use)
+                else:
+                    return List(dtype, reflected)
+
+    @property
+    def key(self):
+        return self.dtype, self.reflected, str(self.initial_value)
+
+    @property
+    def iterator_type(self):
+        return ListIter(self)
+
+    def is_precise(self):
+        return self.dtype.is_precise()
+
+    def __getitem__(self, args):
+        """
+        Overrides the default __getitem__ from Type.
+        """
+        return self.dtype
+
+    def __unliteral__(self):
+        return List(self.dtype, reflected=self.reflected,
+                    initial_value=None)
+
+    def __repr__(self):
+        return f"List({self.dtype}, {self.reflected})"
+
+
+class LiteralList(Literal, ConstSized, Hashable):
+    """A heterogeneous immutable list (basically a tuple with list semantics).
+    """
+
+    mutable = False
+
+    def __init__(self, literal_value):
+        self.is_types_iterable(literal_value)
+        self._literal_init(list(literal_value))
+        self.types = tuple(literal_value)
+        self.count = len(self.types)
+        self.name = "LiteralList({})".format(literal_value)
+
+    def __getitem__(self, i):
+        """
+        Return element at position i
+        """
+        return self.types[i]
+
+    def __len__(self):
+        return len(self.types)
+
+    def __iter__(self):
+        return iter(self.types)
+
+    @classmethod
+    def from_types(cls, tys):
+        return LiteralList(tys)
+
+    @staticmethod
+    def is_types_iterable(types):
+        if not isinstance(types, Iterable):
+            raise TypingError("Argument 'types' is not iterable")
+
+    @property
+    def iterator_type(self):
+        return ListIter(self)
+
+    def __unliteral__(self):
+        return Poison(self)
+
+    def unify(self, typingctx, other):
+        """
+        Unify this with the *other* one.
+        """
+        if isinstance(other, LiteralList) and self.count == other.count:
+            tys = []
+            for i1, i2 in zip(self.types, other.types):
+                tys.append(typingctx.unify_pairs(i1, i2))
+            if all(tys):
+                return LiteralList(tys)
+
+
+class ListIter(BaseContainerIterator):
+    """
+    Type class for list iterators.
+    """
+
+    container_class = List
+
+
+class ListPayload(BaseContainerPayload):
+    """
+    Internal type class for the dynamically-allocated payload of a list.
+    """
+
+    container_class = List
+
+
+class Set(Container):
+    """
+    Type class for homogeneous sets.
+    """
+
+    mutable = True
+
+    def __init__(self, dtype, reflected=False):
+        assert isinstance(dtype, (Hashable, Undefined))
+        self.dtype = dtype
+        self.reflected = reflected
+        cls_name = "reflected set" if reflected else "set"
+        name = "%s(%s)" % (cls_name, self.dtype)
+        super(Set, self).__init__(name=name)
+
+    @property
+    def key(self):
+        return self.dtype, self.reflected
+
+    @property
+    def iterator_type(self):
+        return SetIter(self)
+
+    def is_precise(self):
+        return self.dtype.is_precise()
+
+    def copy(self, dtype=None, reflected=None):
+        if dtype is None:
+            dtype = self.dtype
+        if reflected is None:
+            reflected = self.reflected
+        return Set(dtype, reflected)
+
+    def unify(self, typingctx, other):
+        if isinstance(other, Set):
+            dtype = typingctx.unify_pairs(self.dtype, other.dtype)
+            reflected = self.reflected or other.reflected
+            if dtype is not None:
+                return Set(dtype, reflected)
+
+    def __repr__(self):
+        return f"Set({self.dtype}, {self.reflected})"
+
+
+class SetIter(BaseContainerIterator):
+    """
+    Type class for set iterators.
+    """
+
+    container_class = Set
+
+
+class SetPayload(BaseContainerPayload):
+    """
+    Internal type class for the dynamically-allocated payload of a set.
+    """
+
+    container_class = Set
+
+
+class SetEntry(Type):
+    """
+    Internal type class for the entries of a Set's hash table.
+    """
+
+    def __init__(self, set_type):
+        self.set_type = set_type
+        name = "entry(%s)" % set_type
+        super(SetEntry, self).__init__(name)
+
+    @property
+    def key(self):
+        return self.set_type
+
+
+class ListType(IterableType):
+    """List type
+    """
+
+    mutable = True
+
+    def __init__(self, itemty):
+        assert not isinstance(itemty, TypeRef)
+        itemty = unliteral(itemty)
+        if isinstance(itemty, Optional):
+            fmt = "List.item_type cannot be of type {}"
+            raise TypingError(fmt.format(itemty))
+        # FIXME: _sentry_forbidden_types(itemty)
+        self.item_type = itemty
+        self.dtype = itemty
+        name = "{}[{}]".format(self.__class__.__name__, itemty,)
+        super(ListType, self).__init__(name)
+
+    @property
+    def key(self):
+        return self.item_type
+
+    def is_precise(self):
+        return not isinstance(self.item_type, Undefined)
+
+    @property
+    def iterator_type(self):
+        return ListTypeIterableType(self).iterator_type
+
+    @classmethod
+    def refine(cls, itemty):
+        """Refine to a precise list type
+        """
+        res = cls(itemty)
+        assert res.is_precise()
+        return res
+
+    def unify(self, typingctx, other):
+        """
+        Unify this with the *other* list.
+        """
+        # If other is list
+        if isinstance(other, ListType):
+            if not other.is_precise():
+                return self
+
+    def __repr__(self):
+        return f"ListType({self.item_type})"
+
+
+class ListTypeIterableType(SimpleIterableType):
+    """List iterable type
+    """
+
+    def __init__(self, parent):
+        assert isinstance(parent, ListType)
+        self.parent = parent
+        self.yield_type = self.parent.item_type
+        name = "list[{}]".format(self.parent.name)
+        iterator_type = ListTypeIteratorType(self)
+        super(ListTypeIterableType, self).__init__(name, iterator_type)
+
+
+class ListTypeIteratorType(SimpleIteratorType):
+    def __init__(self, iterable):
+        self.parent = iterable.parent
+        self.iterable = iterable
+        yield_type = iterable.yield_type
+        name = "iter[{}->{}]".format(iterable.parent, yield_type)
+        super(ListTypeIteratorType, self).__init__(name, yield_type)
+
+
+def _sentry_forbidden_types(key, value):
+    # Forbids List and Set for now
+    if isinstance(key, (Set, List)):
+        raise TypingError("{} as key is forbidden".format(key))
+    if isinstance(value, (Set, List)):
+        raise TypingError("{} as value is forbidden".format(value))
+
+
+class DictType(IterableType, InitialValue):
+    """Dictionary type
+    """
+
+    def __init__(self, keyty, valty, initial_value=None):
+        assert not isinstance(keyty, TypeRef)
+        assert not isinstance(valty, TypeRef)
+        keyty = unliteral(keyty)
+        valty = unliteral(valty)
+        if isinstance(keyty, (Optional, NoneType)):
+            fmt = "Dict.key_type cannot be of type {}"
+            raise TypingError(fmt.format(keyty))
+        if isinstance(valty, (Optional, NoneType)):
+            fmt = "Dict.value_type cannot be of type {}"
+            raise TypingError(fmt.format(valty))
+        _sentry_forbidden_types(keyty, valty)
+        self.key_type = keyty
+        self.value_type = valty
+        self.keyvalue_type = Tuple([keyty, valty])
+        name = "{}[{},{}]<iv={}>".format(
+            self.__class__.__name__, keyty, valty, initial_value
+        )
+        super(DictType, self).__init__(name)
+        InitialValue.__init__(self, initial_value)
+
+    def is_precise(self):
+        return not any(
+            (
+                isinstance(self.key_type, Undefined),
+                isinstance(self.value_type, Undefined),
+            )
+        )
+
+    @property
+    def iterator_type(self):
+        return DictKeysIterableType(self).iterator_type
+
+    @classmethod
+    def refine(cls, keyty, valty):
+        """Refine to a precise dictionary type
+        """
+        res = cls(keyty, valty)
+        assert res.is_precise()
+        return res
+
+    def unify(self, typingctx, other):
+        """
+        Unify this with the *other* dictionary.
+        """
+        # If other is dict
+        if isinstance(other, DictType):
+            if not other.is_precise():
+                return self
+            else:
+                ukey_type = self.key_type == other.key_type
+                uvalue_type = self.value_type == other.value_type
+                if ukey_type and uvalue_type:
+                    siv = self.initial_value
+                    oiv = other.initial_value
+                    siv_none = siv is None
+                    oiv_none = oiv is None
+                    if not siv_none and not oiv_none:
+                        if siv == oiv:
+                            return DictType(self.key_type, other.value_type,
+                                            siv)
+                    return DictType(self.key_type, other.value_type)
+
+    @property
+    def key(self):
+        return self.key_type, self.value_type, str(self.initial_value)
+
+    def __unliteral__(self):
+        return DictType(self.key_type, self.value_type)
+
+    def __repr__(self):
+        return f"DictType({self.key_type}, {self.value_type})"
+
+
+class LiteralStrKeyDict(Literal, ConstSized, Hashable):
+    """A Dictionary of string keys to heterogeneous values (basically a
+    namedtuple with dict semantics).
+    """
+
+    class FakeNamedTuple(pySequence):
+        # This is namedtuple-like and is a workaround for #6518 and #7416.
+        # This has the couple of namedtuple properties that are used by Numba's
+        # internals but avoids use of an actual namedtuple as it cannot have
+        # numeric field names, i.e. `namedtuple('foo', '0 1')` is invalid.
+        def __init__(self, name, keys):
+            self.__name__ = name
+            self._fields = tuple(keys)
+            super(LiteralStrKeyDict.FakeNamedTuple, self).__init__()
+
+        def __len__(self):
+            return len(self._fields)
+
+        def __getitem__(self, key):
+            return self._fields[key]
+
+    mutable = False
+
+    def __init__(self, literal_value, value_index=None):
+        self._literal_init(literal_value)
+        self.value_index = value_index
+        strkeys = [x.literal_value for x in literal_value.keys()]
+        self.tuple_ty = self.FakeNamedTuple("_ntclazz", strkeys)
+        tys = [x for x in literal_value.values()]
+        self.types = tuple(tys)
+        self.count = len(self.types)
+        self.fields = tuple(self.tuple_ty._fields)
+        self.instance_class = self.tuple_ty
+        self.name = "LiteralStrKey[Dict]({})".format(literal_value)
+
+    def __unliteral__(self):
+        return Poison(self)
+
+    def unify(self, typingctx, other):
+        """
+        Unify this with the *other* one.
+        """
+        if isinstance(other, LiteralStrKeyDict):
+            tys = []
+            for (k1, v1), (k2, v2) in zip(
+                self.literal_value.items(), other.literal_value.items()
+            ):
+                if k1 != k2:  # keys must be same
+                    break
+                tys.append(typingctx.unify_pairs(v1, v2))
+            else:
+                if all(tys):
+                    d = {k: v for k, v in zip(self.literal_value.keys(), tys)}
+                    return LiteralStrKeyDict(d)
+
+    def __len__(self):
+        return len(self.types)
+
+    def __iter__(self):
+        return iter(self.types)
+
+    @property
+    def key(self):
+        # use the namedtuple fields not the namedtuple itself as it's created
+        # locally in the ctor and comparison would always be False.
+        return self.tuple_ty._fields, self.types, str(self.literal_value)
+
+
+class DictItemsIterableType(SimpleIterableType):
+    """Dictionary iterable type for .items()
+    """
+
+    def __init__(self, parent):
+        assert isinstance(parent, DictType)
+        self.parent = parent
+        self.yield_type = self.parent.keyvalue_type
+        name = "items[{}]".format(self.parent.name)
+        self.name = name
+        iterator_type = DictIteratorType(self)
+        super(DictItemsIterableType, self).__init__(name, iterator_type)
+
+
+class DictKeysIterableType(SimpleIterableType):
+    """Dictionary iterable type for .keys()
+    """
+
+    def __init__(self, parent):
+        assert isinstance(parent, DictType)
+        self.parent = parent
+        self.yield_type = self.parent.key_type
+        name = "keys[{}]".format(self.parent.name)
+        self.name = name
+        iterator_type = DictIteratorType(self)
+        super(DictKeysIterableType, self).__init__(name, iterator_type)
+
+
+class DictValuesIterableType(SimpleIterableType):
+    """Dictionary iterable type for .values()
+    """
+
+    def __init__(self, parent):
+        assert isinstance(parent, DictType)
+        self.parent = parent
+        self.yield_type = self.parent.value_type
+        name = "values[{}]".format(self.parent.name)
+        self.name = name
+        iterator_type = DictIteratorType(self)
+        super(DictValuesIterableType, self).__init__(name, iterator_type)
+
+
+class DictIteratorType(SimpleIteratorType):
+    def __init__(self, iterable):
+        self.parent = iterable.parent
+        self.iterable = iterable
+        yield_type = iterable.yield_type
+        name = "iter[{}->{}],{}".format(
+            iterable.parent, yield_type, iterable.name
+        )
+        super(DictIteratorType, self).__init__(name, yield_type)
+
+
+class StructRef(Type):
+    """A mutable struct.
+    """
+
+    def __init__(self, fields):
+        """
+        Parameters
+        ----------
+        fields : Sequence
+            A sequence of field descriptions, which is a 2-tuple-like object
+            containing `(name, type)`, where `name` is a `str` for the field
+            name, and `type` is a numba type for the field type.
+        """
+
+        def check_field_pair(fieldpair):
+            name, typ = fieldpair
+            if not isinstance(name, str):
+                msg = "expecting a str for field name"
+                raise ValueError(msg)
+            if not isinstance(typ, Type):
+                msg = "expecting a Numba Type for field type"
+                raise ValueError(msg)
+            return name, typ
+
+        fields = tuple(map(check_field_pair, fields))
+        self._fields = tuple(map(check_field_pair,
+                                 self.preprocess_fields(fields)))
+        self._typename = self.__class__.__qualname__
+        name = f"numba.{self._typename}{self._fields}"
+        super().__init__(name=name)
+
+    def preprocess_fields(self, fields):
+        """Subclasses can override this to do additional clean up on fields.
+
+        The default is an identity function.
+
+        Parameters:
+        -----------
+        fields : Sequence[Tuple[str, Type]]
+        """
+        return fields
+
+    @property
+    def field_dict(self):
+        """Return an immutable mapping for the field names and their
+        corresponding types.
+        """
+        return MappingProxyType(dict(self._fields))
+
+    def get_data_type(self):
+        """Get the payload type for the actual underlying structure referred
+        to by this struct reference.
+
+        See also: `ClassInstanceType.get_data_type`
+        """
+        return StructRefPayload(
+            typename=self.__class__.__name__, fields=self._fields,
+        )
+
+
+class StructRefPayload(Type):
+    """The type of the payload of a mutable struct.
+    """
+
+    mutable = True
+
+    def __init__(self, typename, fields):
+        self._typename = typename
+        self._fields = tuple(fields)
+        super().__init__(name=f"numba.{typename}{self._fields}.payload")
+
+    @property
+    def field_dict(self):
+        return MappingProxyType(dict(self._fields))

lib/python3.10/site-packages/numba/core/types/function_type.py

@@ -0,0 +1,211 @@
+
+__all__ = ['FunctionType', 'UndefinedFunctionType', 'FunctionPrototype',
+           'WrapperAddressProtocol', 'CompileResultWAP']
+
+from abc import ABC, abstractmethod
+from .abstract import Type
+from .. import types, errors
+
+
+class FunctionType(Type):
+    """
+    First-class function type.
+    """
+
+    cconv = None
+
+    def __init__(self, signature):
+        sig = types.unliteral(signature)
+        self.nargs = len(sig.args)
+        self.signature = sig
+        self.ftype = FunctionPrototype(sig.return_type, sig.args)
+        self._key = self.ftype.key
+
+    @property
+    def key(self):
+        return self._key
+
+    @property
+    def name(self):
+        return f'{type(self).__name__}[{self.key}]'
+
+    def is_precise(self):
+        return self.signature.is_precise()
+
+    def get_precise(self):
+        return self
+
+    def dump(self, tab=''):
+        print(f'{tab}DUMP {type(self).__name__}[code={self._code}]')
+        self.signature.dump(tab=tab + '  ')
+        print(f'{tab}END DUMP {type(self).__name__}')
+
+    def get_call_type(self, context, args, kws):
+        from numba.core import typing
+
+        if kws:
+            # First-class functions carry only the type signature
+            # information and function address value. So, it is not
+            # possible to determine the positional arguments
+            # corresponding to the keyword arguments in the call
+            # expression. For instance, the definition of the
+            # first-class function may not use the same argument names
+            # that the caller assumes. [numba/issues/5540].
+            raise errors.UnsupportedError(
+                'first-class function call cannot use keyword arguments')
+
+        if len(args) != self.nargs:
+            raise ValueError(
+                f'mismatch of arguments number: {len(args)} vs {self.nargs}')
+
+        sig = self.signature
+
+        # check that arguments types match with the signature types exactly
+        for atype, sig_atype in zip(args, sig.args):
+            atype = types.unliteral(atype)
+            if sig_atype.is_precise():
+                conv_score = context.context.can_convert(
+                    fromty=atype, toty=sig_atype
+                )
+                if conv_score is None \
+                   or conv_score > typing.context.Conversion.safe:
+                    raise ValueError(
+                        f'mismatch of argument types: {atype} vs {sig_atype}')
+
+        if not sig.is_precise():
+            for dispatcher in self.dispatchers:
+                template, pysig, args, kws \
+                    = dispatcher.get_call_template(args, kws)
+                new_sig = template(context.context).apply(args, kws)
+                return types.unliteral(new_sig)
+
+        return sig
+
+    def check_signature(self, other_sig):
+        """Return True if signatures match (up to being precise).
+        """
+        sig = self.signature
+        return (self.nargs == len(other_sig.args)
+                and (sig == other_sig or not sig.is_precise()))
+
+    def unify(self, context, other):
+        if isinstance(other, types.UndefinedFunctionType) \
+           and self.nargs == other.nargs:
+            return self
+
+
+class UndefinedFunctionType(FunctionType):
+
+    _counter = 0
+
+    def __init__(self, nargs, dispatchers):
+        from numba.core.typing.templates import Signature
+        signature = Signature(types.undefined,
+                              (types.undefined,) * nargs, recvr=None)
+
+        super(UndefinedFunctionType, self).__init__(signature)
+
+        self.dispatchers = dispatchers
+
+        # make the undefined function type instance unique
+        type(self)._counter += 1
+        self._key += str(type(self)._counter)
+
+    def get_precise(self):
+        """
+        Return precise function type if possible.
+        """
+        for dispatcher in self.dispatchers:
+            for cres in dispatcher.overloads.values():
+                sig = types.unliteral(cres.signature)
+                return FunctionType(sig)
+        return self
+
+
+class FunctionPrototype(Type):
+    """
+    Represents the prototype of a first-class function type.
+    Used internally.
+    """
+    cconv = None
+
+    def __init__(self, rtype, atypes):
+        self.rtype = rtype
+        self.atypes = tuple(atypes)
+
+        assert isinstance(rtype, Type), (rtype)
+        lst = []
+        for atype in self.atypes:
+            assert isinstance(atype, Type), (atype)
+            lst.append(atype.name)
+        name = '%s(%s)' % (rtype, ', '.join(lst))
+
+        super(FunctionPrototype, self).__init__(name)
+
+    @property
+    def key(self):
+        return self.name
+
+
+class WrapperAddressProtocol(ABC):
+    """Base class for Wrapper Address Protocol.
+
+    Objects that inherit from the WrapperAddressProtocol can be passed
+    as arguments to Numba jit compiled functions where it can be used
+    as first-class functions. As a minimum, the derived types must
+    implement two methods ``__wrapper_address__`` and ``signature``.
+    """
+
+    @abstractmethod
+    def __wrapper_address__(self):
+        """Return the address of a first-class function.
+
+        Returns
+        -------
+        addr : int
+        """
+
+    @abstractmethod
+    def signature(self):
+        """Return the signature of a first-class function.
+
+        Returns
+        -------
+        sig : Signature
+          The returned Signature instance represents the type of a
+          first-class function that the given WrapperAddressProtocol
+          instance represents.
+        """
+
+
+class CompileResultWAP(WrapperAddressProtocol):
+    """Wrapper of dispatcher instance compilation result to turn it a
+    first-class function.
+    """
+
+    def __init__(self, cres):
+        """
+        Parameters
+        ----------
+        cres : CompileResult
+          Specify compilation result of a Numba jit-decorated function
+          (that is a value of dispatcher instance ``overloads``
+          attribute)
+        """
+        self.cres = cres
+        name = getattr(cres.fndesc, 'llvm_cfunc_wrapper_name')
+        self.address = cres.library.get_pointer_to_function(name)
+
+    def dump(self, tab=''):
+        print(f'{tab}DUMP {type(self).__name__} [addr={self.address}]')
+        self.cres.signature.dump(tab=tab + '  ')
+        print(f'{tab}END DUMP {type(self).__name__}')
+
+    def __wrapper_address__(self):
+        return self.address
+
+    def signature(self):
+        return self.cres.signature
+
+    def __call__(self, *args, **kwargs):  # used in object-mode
+        return self.cres.entry_point(*args, **kwargs)

lib/python3.10/site-packages/numba/core/types/functions.py

@@ -0,0 +1,743 @@
+import traceback
+from collections import namedtuple, defaultdict
+import itertools
+import logging
+import textwrap
+from shutil import get_terminal_size
+
+from .abstract import Callable, DTypeSpec, Dummy, Literal, Type, weakref
+from .common import Opaque
+from .misc import unliteral
+from numba.core import errors, utils, types, config
+from numba.core.typeconv import Conversion
+
+_logger = logging.getLogger(__name__)
+
+
+# terminal color markup
+_termcolor = errors.termcolor()
+
+_FAILURE = namedtuple('_FAILURE', 'template matched error literal')
+
+_termwidth = get_terminal_size().columns
+
+
+# pull out the lead line as unit tests often use this
+_header_lead = "No implementation of function"
+_header_template = (_header_lead + " {the_function} found for signature:\n \n "
+                    ">>> {fname}({signature})\n \nThere are {ncandidates} "
+                    "candidate implementations:")
+
+_reason_template = """
+" - Of which {nmatches} did not match due to:\n
+"""
+
+
+def _wrapper(tmp, indent=0):
+    return textwrap.indent(tmp, ' ' * indent, lambda line: True)
+
+
+_overload_template = ("- Of which {nduplicates} did not match due to:\n"
+                      "{kind} {inof} function '{function}': File: {file}: "
+                      "Line {line}.\n  With argument(s): '({args})':")
+
+
+_err_reasons = {'specific_error': "Rejected as the implementation raised a "
+                                  "specific error:\n{}"}
+
+
+def _bt_as_lines(bt):
+    """
+    Converts a backtrace into a list of lines, squashes it a bit on the way.
+    """
+    return [y for y in itertools.chain(*[x.split('\n') for x in bt]) if y]
+
+
+def argsnkwargs_to_str(args, kwargs):
+    buf = [str(a) for a in tuple(args)]
+    buf.extend(["{}={}".format(k, v) for k, v in kwargs.items()])
+    return ', '.join(buf)
+
+
+class _ResolutionFailures(object):
+    """Collect and format function resolution failures.
+    """
+    def __init__(self, context, function_type, args, kwargs, depth=0):
+        self._context = context
+        self._function_type = function_type
+        self._args = args
+        self._kwargs = kwargs
+        self._failures = defaultdict(list)
+        self._depth = depth
+        self._max_depth = 5
+        self._scale = 2
+
+    def __len__(self):
+        return len(self._failures)
+
+    def add_error(self, calltemplate, matched, error, literal):
+        """
+        Args
+        ----
+        calltemplate : CallTemplate
+        error : Exception or str
+            Error message
+        """
+        isexc = isinstance(error, Exception)
+        errclazz = '%s: ' % type(error).__name__ if isexc else ''
+
+        key = "{}{}".format(errclazz, str(error))
+        self._failures[key].append(_FAILURE(calltemplate, matched, error,
+                                            literal))
+
+    def format(self):
+        """Return a formatted error message from all the gathered errors.
+        """
+        indent = ' ' * self._scale
+        argstr = argsnkwargs_to_str(self._args, self._kwargs)
+        ncandidates = sum([len(x) for x in self._failures.values()])
+
+        # sort out a display name for the function
+        tykey = self._function_type.typing_key
+        # most things have __name__
+        fname = getattr(tykey, '__name__', None)
+        is_external_fn_ptr = isinstance(self._function_type,
+                                        ExternalFunctionPointer)
+
+        if fname is None:
+            if is_external_fn_ptr:
+                fname = "ExternalFunctionPointer"
+            else:
+                fname = "<unknown function>"
+
+        msgbuf = [_header_template.format(the_function=self._function_type,
+                                          fname=fname,
+                                          signature=argstr,
+                                          ncandidates=ncandidates)]
+        nolitargs = tuple([unliteral(a) for a in self._args])
+        nolitkwargs = {k: unliteral(v) for k, v in self._kwargs.items()}
+        nolitargstr = argsnkwargs_to_str(nolitargs, nolitkwargs)
+
+        # depth could potentially get massive, so limit it.
+        ldepth = min(max(self._depth, 0), self._max_depth)
+
+        def template_info(tp):
+            src_info = tp.get_template_info()
+            unknown = "unknown"
+            source_name = src_info.get('name', unknown)
+            source_file = src_info.get('filename', unknown)
+            source_lines = src_info.get('lines', unknown)
+            source_kind = src_info.get('kind', 'Unknown template')
+            return source_name, source_file, source_lines, source_kind
+
+        for i, (k, err_list) in enumerate(self._failures.items()):
+            err = err_list[0]
+            nduplicates = len(err_list)
+            template, error = err.template, err.error
+            ifo = template_info(template)
+            source_name, source_file, source_lines, source_kind = ifo
+            largstr = argstr if err.literal else nolitargstr
+
+            if err.error == "No match.":
+                err_dict = defaultdict(set)
+                for errs in err_list:
+                    err_dict[errs.template].add(errs.literal)
+                # if there's just one template, and it's erroring on
+                # literal/nonliteral be specific
+                if len(err_dict) == 1:
+                    template = [_ for _ in err_dict.keys()][0]
+                    source_name, source_file, source_lines, source_kind = \
+                        template_info(template)
+                    source_lines = source_lines[0]
+                else:
+                    source_file = "<numerous>"
+                    source_lines = "N/A"
+
+                msgbuf.append(_termcolor.errmsg(
+                    _wrapper(_overload_template.format(nduplicates=nduplicates,
+                                                       kind=source_kind.title(),
+                                                       function=fname,
+                                                       inof='of',
+                                                       file=source_file,
+                                                       line=source_lines,
+                                                       args=largstr),
+                             ldepth + 1)))
+                msgbuf.append(_termcolor.highlight(_wrapper(err.error,
+                                                            ldepth + 2)))
+            else:
+                # There was at least one match in this failure class, but it
+                # failed for a specific reason try and report this.
+                msgbuf.append(_termcolor.errmsg(
+                    _wrapper(_overload_template.format(nduplicates=nduplicates,
+                                                       kind=source_kind.title(),
+                                                       function=source_name,
+                                                       inof='in',
+                                                       file=source_file,
+                                                       line=source_lines[0],
+                                                       args=largstr),
+                             ldepth + 1)))
+
+                if isinstance(error, BaseException):
+                    reason = indent + self.format_error(error)
+                    errstr = _err_reasons['specific_error'].format(reason)
+                else:
+                    errstr = error
+                # if you are a developer, show the back traces
+                if config.DEVELOPER_MODE:
+                    if isinstance(error, BaseException):
+                        # if the error is an actual exception instance, trace it
+                        bt = traceback.format_exception(type(error), error,
+                                                        error.__traceback__)
+                    else:
+                        bt = [""]
+                    bt_as_lines = _bt_as_lines(bt)
+                    nd2indent = '\n{}'.format(2 * indent)
+                    errstr += _termcolor.reset(nd2indent +
+                                               nd2indent.join(bt_as_lines))
+                msgbuf.append(_termcolor.highlight(_wrapper(errstr,
+                                                            ldepth + 2)))
+                loc = self.get_loc(template, error)
+                if loc:
+                    msgbuf.append('{}raised from {}'.format(indent, loc))
+
+        # the commented bit rewraps each block, may not be helpful?!
+        return _wrapper('\n'.join(msgbuf) + '\n') # , self._scale * ldepth)
+
+    def format_error(self, error):
+        """Format error message or exception
+        """
+        if isinstance(error, Exception):
+            return '{}: {}'.format(type(error).__name__, error)
+        else:
+            return '{}'.format(error)
+
+    def get_loc(self, classtemplate, error):
+        """Get source location information from the error message.
+        """
+        if isinstance(error, Exception) and hasattr(error, '__traceback__'):
+            # traceback is unavailable in py2
+            frame = traceback.extract_tb(error.__traceback__)[-1]
+            return "{}:{}".format(frame[0], frame[1])
+
+    def raise_error(self):
+        for faillist in self._failures.values():
+            for fail in faillist:
+                if isinstance(fail.error, errors.ForceLiteralArg):
+                    raise fail.error
+        raise errors.TypingError(self.format())
+
+
+def _unlit_non_poison(ty):
+    """Apply unliteral(ty) and raise a TypingError if type is Poison.
+    """
+    out = unliteral(ty)
+    if isinstance(out, types.Poison):
+        m = f"Poison type used in arguments; got {out}"
+        raise errors.TypingError(m)
+    return out
+
+
+class BaseFunction(Callable):
+    """
+    Base type class for some function types.
+    """
+
+    def __init__(self, template):
+
+        if isinstance(template, (list, tuple)):
+            self.templates = tuple(template)
+            keys = set(temp.key for temp in self.templates)
+            if len(keys) != 1:
+                raise ValueError("incompatible templates: keys = %s"
+                                 % (keys,))
+            self.typing_key, = keys
+        else:
+            self.templates = (template,)
+            self.typing_key = template.key
+        self._impl_keys = {}
+        name = "%s(%s)" % (self.__class__.__name__, self.typing_key)
+        self._depth = 0
+        super(BaseFunction, self).__init__(name)
+
+    @property
+    def key(self):
+        return self.typing_key, self.templates
+
+    def augment(self, other):
+        """
+        Augment this function type with the other function types' templates,
+        so as to support more input types.
+        """
+        if type(other) is type(self) and other.typing_key == self.typing_key:
+            return type(self)(self.templates + other.templates)
+
+    def get_impl_key(self, sig):
+        """
+        Get the implementation key (used by the target context) for the
+        given signature.
+        """
+        return self._impl_keys[sig.args]
+
+    def get_call_type(self, context, args, kws):
+
+        prefer_lit = [True, False]    # old behavior preferring literal
+        prefer_not = [False, True]    # new behavior preferring non-literal
+        failures = _ResolutionFailures(context, self, args, kws,
+                                       depth=self._depth)
+
+        # get the order in which to try templates
+        from numba.core.target_extension import get_local_target # circular
+        target_hw = get_local_target(context)
+        order = utils.order_by_target_specificity(target_hw, self.templates,
+                                                  fnkey=self.key[0])
+
+        self._depth += 1
+
+        for temp_cls in order:
+            temp = temp_cls(context)
+            # The template can override the default and prefer literal args
+            choice = prefer_lit if temp.prefer_literal else prefer_not
+            for uselit in choice:
+                try:
+                    if uselit:
+                        sig = temp.apply(args, kws)
+                    else:
+                        nolitargs = tuple([_unlit_non_poison(a) for a in args])
+                        nolitkws = {k: _unlit_non_poison(v)
+                                    for k, v in kws.items()}
+                        sig = temp.apply(nolitargs, nolitkws)
+                except Exception as e:
+                    if not isinstance(e, errors.NumbaError):
+                        raise e
+                    sig = None
+                    failures.add_error(temp, False, e, uselit)
+                else:
+                    if sig is not None:
+                        self._impl_keys[sig.args] = temp.get_impl_key(sig)
+                        self._depth -= 1
+                        return sig
+                    else:
+                        registered_sigs = getattr(temp, 'cases', None)
+                        if registered_sigs is not None:
+                            msg = "No match for registered cases:\n%s"
+                            msg = msg % '\n'.join(" * {}".format(x) for x in
+                                                  registered_sigs)
+                        else:
+                            msg = 'No match.'
+                        failures.add_error(temp, True, msg, uselit)
+
+        failures.raise_error()
+
+    def get_call_signatures(self):
+        sigs = []
+        is_param = False
+        for temp in self.templates:
+            sigs += getattr(temp, 'cases', [])
+            is_param = is_param or hasattr(temp, 'generic')
+        return sigs, is_param
+
+
+class Function(BaseFunction, Opaque):
+    """
+    Type class for builtin functions implemented by Numba.
+    """
+
+
+class BoundFunction(Callable, Opaque):
+    """
+    A function with an implicit first argument (denoted as *this* below).
+    """
+
+    def __init__(self, template, this):
+        # Create a derived template with an attribute *this*
+        newcls = type(template.__name__ + '.' + str(this), (template,),
+                      dict(this=this))
+        self.template = newcls
+        self.typing_key = self.template.key
+        self.this = this
+        name = "%s(%s for %s)" % (self.__class__.__name__,
+                                  self.typing_key, self.this)
+        super(BoundFunction, self).__init__(name)
+
+    def unify(self, typingctx, other):
+        if (isinstance(other, BoundFunction) and
+                self.typing_key == other.typing_key):
+            this = typingctx.unify_pairs(self.this, other.this)
+            if this is not None:
+                # XXX is it right that both template instances are distinct?
+                return self.copy(this=this)
+
+    def copy(self, this):
+        return type(self)(self.template, this)
+
+    @property
+    def key(self):
+        # FIXME: With target-overload, the MethodTemplate can change depending
+        #        on the target.
+        unique_impl = getattr(self.template, "_overload_func", None)
+        return self.typing_key, self.this, unique_impl
+
+    def get_impl_key(self, sig):
+        """
+        Get the implementation key (used by the target context) for the
+        given signature.
+        """
+        return self.typing_key
+
+    def get_call_type(self, context, args, kws):
+        template = self.template(context)
+        literal_e = None
+        nonliteral_e = None
+        out = None
+
+        choice = [True, False] if template.prefer_literal else [False, True]
+        for uselit in choice:
+            if uselit:
+                # Try with Literal
+                try:
+                    out = template.apply(args, kws)
+                except Exception as exc:
+                    if not isinstance(exc, errors.NumbaError):
+                        raise exc
+                    if isinstance(exc, errors.ForceLiteralArg):
+                        raise exc
+                    literal_e = exc
+                    out = None
+                else:
+                    break
+            else:
+                # if the unliteral_args and unliteral_kws are the same as the
+                # literal ones, set up to not bother retrying
+                unliteral_args = tuple([_unlit_non_poison(a) for a in args])
+                unliteral_kws = {k: _unlit_non_poison(v)
+                                 for k, v in kws.items()}
+                skip = unliteral_args == args and kws == unliteral_kws
+
+                # If the above template application failed and the non-literal
+                # args are different to the literal ones, try again with
+                # literals rewritten as non-literals
+                if not skip and out is None:
+                    try:
+                        out = template.apply(unliteral_args, unliteral_kws)
+                    except Exception as exc:
+                        if isinstance(exc, errors.ForceLiteralArg):
+                            if template.prefer_literal:
+                                # For template that prefers literal types,
+                                # reaching here means that the literal types
+                                # have failed typing as well.
+                                raise exc
+                        nonliteral_e = exc
+                    else:
+                        break
+
+        if out is None and (nonliteral_e is not None or literal_e is not None):
+            header = "- Resolution failure for {} arguments:\n{}\n"
+            tmplt = _termcolor.highlight(header)
+            if config.DEVELOPER_MODE:
+                indent = ' ' * 4
+
+                def add_bt(error):
+                    if isinstance(error, BaseException):
+                        # if the error is an actual exception instance, trace it
+                        bt = traceback.format_exception(type(error), error,
+                                                        error.__traceback__)
+                    else:
+                        bt = [""]
+                    nd2indent = '\n{}'.format(2 * indent)
+                    errstr = _termcolor.reset(nd2indent +
+                                              nd2indent.join(_bt_as_lines(bt)))
+                    return _termcolor.reset(errstr)
+            else:
+                add_bt = lambda X: ''
+
+            def nested_msg(literalness, e):
+                estr = str(e)
+                estr = estr if estr else (str(repr(e)) + add_bt(e))
+                new_e = errors.TypingError(textwrap.dedent(estr))
+                return tmplt.format(literalness, str(new_e))
+
+            raise errors.TypingError(nested_msg('literal', literal_e) +
+                                     nested_msg('non-literal', nonliteral_e))
+        return out
+
+    def get_call_signatures(self):
+        sigs = getattr(self.template, 'cases', [])
+        is_param = hasattr(self.template, 'generic')
+        return sigs, is_param
+
+
+class MakeFunctionLiteral(Literal, Opaque):
+    pass
+
+
+class _PickleableWeakRef(weakref.ref):
+    """
+    Allow a weakref to be pickled.
+
+    Note that if the object referred to is not kept alive elsewhere in the
+    pickle, the weakref will immediately expire after being constructed.
+    """
+    def __getnewargs__(self):
+        obj = self()
+        if obj is None:
+            raise ReferenceError("underlying object has vanished")
+        return (obj,)
+
+
+class WeakType(Type):
+    """
+    Base class for types parametered by a mortal object, to which only
+    a weak reference is kept.
+    """
+
+    def _store_object(self, obj):
+        self._wr = _PickleableWeakRef(obj)
+
+    def _get_object(self):
+        obj = self._wr()
+        if obj is None:
+            raise ReferenceError("underlying object has vanished")
+        return obj
+
+    @property
+    def key(self):
+        return self._wr
+
+    def __eq__(self, other):
+        if type(self) is type(other):
+            obj = self._wr()
+            return obj is not None and obj is other._wr()
+        return NotImplemented
+
+    def __hash__(self):
+        return Type.__hash__(self)
+
+
+class Dispatcher(WeakType, Callable, Dummy):
+    """
+    Type class for @jit-compiled functions.
+    """
+
+    def __init__(self, dispatcher):
+        self._store_object(dispatcher)
+        super(Dispatcher, self).__init__("type(%s)" % dispatcher)
+
+    def dump(self, tab=''):
+        print((f'{tab}DUMP {type(self).__name__}[code={self._code}, '
+               f'name={self.name}]'))
+        self.dispatcher.dump(tab=tab + '  ')
+        print(f'{tab}END DUMP')
+
+    def get_call_type(self, context, args, kws):
+        """
+        Resolve a call to this dispatcher using the given argument types.
+        A signature returned and it is ensured that a compiled specialization
+        is available for it.
+        """
+        template, pysig, args, kws = \
+            self.dispatcher.get_call_template(args, kws)
+        sig = template(context).apply(args, kws)
+        if sig:
+            sig = sig.replace(pysig=pysig)
+            return sig
+
+    def get_call_signatures(self):
+        sigs = self.dispatcher.nopython_signatures
+        return sigs, True
+
+    @property
+    def dispatcher(self):
+        """
+        A strong reference to the underlying numba.dispatcher.Dispatcher
+        instance.
+        """
+        return self._get_object()
+
+    def get_overload(self, sig):
+        """
+        Get the compiled overload for the given signature.
+        """
+        return self.dispatcher.get_overload(sig.args)
+
+    def get_impl_key(self, sig):
+        """
+        Get the implementation key for the given signature.
+        """
+        return self.get_overload(sig)
+
+    def unify(self, context, other):
+        return utils.unified_function_type((self, other), require_precise=False)
+
+    def can_convert_to(self, typingctx, other):
+        if isinstance(other, types.FunctionType):
+            try:
+                self.dispatcher.get_compile_result(other.signature)
+            except errors.NumbaError:
+                return None
+            else:
+                return Conversion.safe
+
+
+class ObjModeDispatcher(Dispatcher):
+    """Dispatcher subclass that enters objectmode function.
+    """
+    pass
+
+
+class ExternalFunctionPointer(BaseFunction):
+    """
+    A pointer to a native function (e.g. exported via ctypes or cffi).
+    *get_pointer* is a Python function taking an object
+    and returning the raw pointer value as an int.
+    """
+    def __init__(self, sig, get_pointer, cconv=None):
+        from numba.core.typing.templates import (AbstractTemplate,
+                                                 make_concrete_template,
+                                                 signature)
+        from numba.core.types import ffi_forced_object
+        if sig.return_type == ffi_forced_object:
+            msg = "Cannot return a pyobject from an external function"
+            raise errors.TypingError(msg)
+        self.sig = sig
+        self.requires_gil = any(a == ffi_forced_object for a in self.sig.args)
+        self.get_pointer = get_pointer
+        self.cconv = cconv
+        if self.requires_gil:
+            class GilRequiringDefn(AbstractTemplate):
+                key = self.sig
+
+                def generic(self, args, kws):
+                    if kws:
+                        msg = "does not support keyword arguments"
+                        raise errors.TypingError(msg)
+                    # Make ffi_forced_object a bottom type to allow any type to
+                    # be casted to it. This is the only place that support
+                    # ffi_forced_object.
+                    coerced = [actual if formal == ffi_forced_object else formal
+                               for actual, formal
+                               in zip(args, self.key.args)]
+                    return signature(self.key.return_type, *coerced)
+            template = GilRequiringDefn
+        else:
+            template = make_concrete_template("CFuncPtr", sig, [sig])
+        super(ExternalFunctionPointer, self).__init__(template)
+
+    @property
+    def key(self):
+        return self.sig, self.cconv, self.get_pointer
+
+
+class ExternalFunction(Function):
+    """
+    A named native function (resolvable by LLVM) accepting an explicit
+    signature. For internal use only.
+    """
+
+    def __init__(self, symbol, sig):
+        from numba.core import typing
+        self.symbol = symbol
+        self.sig = sig
+        template = typing.make_concrete_template(symbol, symbol, [sig])
+        super(ExternalFunction, self).__init__(template)
+
+    @property
+    def key(self):
+        return self.symbol, self.sig
+
+
+class NamedTupleClass(Callable, Opaque):
+    """
+    Type class for namedtuple classes.
+    """
+
+    def __init__(self, instance_class):
+        self.instance_class = instance_class
+        name = "class(%s)" % (instance_class)
+        super(NamedTupleClass, self).__init__(name)
+
+    def get_call_type(self, context, args, kws):
+        # Overridden by the __call__ constructor resolution in
+        # typing.collections
+        return None
+
+    def get_call_signatures(self):
+        return (), True
+
+    def get_impl_key(self, sig):
+        return type(self)
+
+    @property
+    def key(self):
+        return self.instance_class
+
+
+class NumberClass(Callable, DTypeSpec, Opaque):
+    """
+    Type class for number classes (e.g. "np.float64").
+    """
+
+    def __init__(self, instance_type):
+        self.instance_type = instance_type
+        name = "class(%s)" % (instance_type,)
+        super(NumberClass, self).__init__(name)
+
+    def get_call_type(self, context, args, kws):
+        # Overridden by the __call__ constructor resolution in typing.builtins
+        return None
+
+    def get_call_signatures(self):
+        return (), True
+
+    def get_impl_key(self, sig):
+        return type(self)
+
+    @property
+    def key(self):
+        return self.instance_type
+
+    @property
+    def dtype(self):
+        return self.instance_type
+
+
+_RecursiveCallOverloads = namedtuple("_RecursiveCallOverloads", "qualname,uid")
+
+
+class RecursiveCall(Opaque):
+    """
+    Recursive call to a Dispatcher.
+    """
+    _overloads = None
+
+    def __init__(self, dispatcher_type):
+        assert isinstance(dispatcher_type, Dispatcher)
+        self.dispatcher_type = dispatcher_type
+        name = "recursive(%s)" % (dispatcher_type,)
+        super(RecursiveCall, self).__init__(name)
+        # Initializing for the first time
+        if self._overloads is None:
+            self._overloads = {}
+
+    def add_overloads(self, args, qualname, uid):
+        """Add an overload of the function.
+
+        Parameters
+        ----------
+        args :
+            argument types
+        qualname :
+            function qualifying name
+        uid :
+            unique id
+        """
+        self._overloads[args] = _RecursiveCallOverloads(qualname, uid)
+
+    def get_overloads(self, args):
+        """Get the qualifying name and unique id for the overload given the
+        argument types.
+        """
+        return self._overloads[args]
+
+    @property
+    def key(self):
+        return self.dispatcher_type

lib/python3.10/site-packages/numba/core/types/iterators.py

@@ -0,0 +1,108 @@
+from .common import SimpleIterableType, SimpleIteratorType
+from ..errors import TypingError
+
+
+class RangeType(SimpleIterableType):
+
+    def __init__(self, dtype):
+        self.dtype = dtype
+        name = "range_state_%s" % (dtype,)
+        super(SimpleIterableType, self).__init__(name)
+        self._iterator_type = RangeIteratorType(self.dtype)
+
+    def unify(self, typingctx, other):
+        if isinstance(other, RangeType):
+            dtype = typingctx.unify_pairs(self.dtype, other.dtype)
+            if dtype is not None:
+                return RangeType(dtype)
+
+
+class RangeIteratorType(SimpleIteratorType):
+
+    def __init__(self, dtype):
+        name = "range_iter_%s" % (dtype,)
+        super(SimpleIteratorType, self).__init__(name)
+        self._yield_type = dtype
+
+    def unify(self, typingctx, other):
+        if isinstance(other, RangeIteratorType):
+            dtype = typingctx.unify_pairs(self.yield_type, other.yield_type)
+            if dtype is not None:
+                return RangeIteratorType(dtype)
+
+
+class Generator(SimpleIteratorType):
+    """
+    Type class for Numba-compiled generator objects.
+    """
+
+    def __init__(self, gen_func, yield_type, arg_types, state_types,
+                 has_finalizer):
+        self.gen_func = gen_func
+        self.arg_types = tuple(arg_types)
+        self.state_types = tuple(state_types)
+        self.has_finalizer = has_finalizer
+        name = "%s generator(func=%s, args=%s, has_finalizer=%s)" % (
+            yield_type, self.gen_func, self.arg_types,
+            self.has_finalizer)
+        super(Generator, self).__init__(name, yield_type)
+
+    @property
+    def key(self):
+        return (self.gen_func, self.arg_types, self.yield_type,
+                self.has_finalizer, self.state_types)
+
+
+class EnumerateType(SimpleIteratorType):
+    """
+    Type class for `enumerate` objects.
+    Type instances are parametered with the underlying source type.
+    """
+
+    def __init__(self, iterable_type):
+        from numba.core.types import Tuple, intp
+        self.source_type = iterable_type.iterator_type
+        yield_type = Tuple([intp, self.source_type.yield_type])
+        name = 'enumerate(%s)' % (self.source_type)
+        super(EnumerateType, self).__init__(name, yield_type)
+
+    @property
+    def key(self):
+        return self.source_type
+
+
+class ZipType(SimpleIteratorType):
+    """
+    Type class for `zip` objects.
+    Type instances are parametered with the underlying source types.
+    """
+
+    def __init__(self, iterable_types):
+        from numba.core.types import Tuple
+        self.source_types = tuple(tp.iterator_type for tp in iterable_types)
+        yield_type = Tuple([tp.yield_type for tp in self.source_types])
+        name = 'zip(%s)' % ', '.join(str(tp) for tp in self.source_types)
+        super(ZipType, self).__init__(name, yield_type)
+
+    @property
+    def key(self):
+        return self.source_types
+
+
+class ArrayIterator(SimpleIteratorType):
+    """
+    Type class for iterators of array and buffer objects.
+    """
+
+    def __init__(self, array_type):
+        self.array_type = array_type
+        name = "iter(%s)" % (self.array_type,)
+        nd = array_type.ndim
+        if nd == 0:
+            raise TypingError("iteration over a 0-d array")
+        elif nd == 1:
+            yield_type = array_type.dtype
+        else:
+            # iteration semantics leads to A order layout
+            yield_type = array_type.copy(ndim=array_type.ndim - 1, layout='A')
+        super(ArrayIterator, self).__init__(name, yield_type)

lib/python3.10/site-packages/numba/core/types/misc.py

@@ -0,0 +1,556 @@
+from numba.core.types.abstract import Callable, Literal, Type, Hashable
+from numba.core.types.common import (Dummy, IterableType, Opaque,
+                                     SimpleIteratorType)
+from numba.core.typeconv import Conversion
+from numba.core.errors import TypingError, LiteralTypingError
+from numba.core.ir import UndefinedType
+from numba.core.utils import get_hashable_key
+
+
+class PyObject(Dummy):
+    """
+    A generic CPython object.
+    """
+
+    def is_precise(self):
+        return False
+
+
+class Phantom(Dummy):
+    """
+    A type that cannot be materialized.  A Phantom cannot be used as
+    argument or return type.
+    """
+
+
+class Undefined(Dummy):
+    """
+    A type that is left imprecise.  This is used as a temporaray placeholder
+    during type inference in the hope that the type can be later refined.
+    """
+
+    def is_precise(self):
+        return False
+
+
+class UndefVar(Dummy):
+    """
+    A type that is created by Expr.undef to represent an undefined variable.
+    This type can be promoted to any other type.
+    This is introduced to handle Python 3.12 LOAD_FAST_AND_CLEAR.
+    """
+
+    def can_convert_to(self, typingctx, other):
+        return Conversion.promote
+
+
+class RawPointer(Opaque):
+    """
+    A raw pointer without any specific meaning.
+    """
+
+
+class StringLiteral(Literal, Dummy):
+
+    def can_convert_to(self, typingctx, other):
+        if isinstance(other, UnicodeType):
+            return Conversion.safe
+
+
+Literal.ctor_map[str] = StringLiteral
+
+
+def unliteral(lit_type):
+    """
+    Get base type from Literal type.
+    """
+    if hasattr(lit_type, '__unliteral__'):
+        return lit_type.__unliteral__()
+    return getattr(lit_type, 'literal_type', lit_type)
+
+
+def literal(value):
+    """Returns a Literal instance or raise LiteralTypingError
+    """
+    ty = type(value)
+    if isinstance(value, Literal):
+        msg = "the function does not accept a Literal type; got {} ({})"
+        raise ValueError(msg.format(value, ty))
+    try:
+        ctor = Literal.ctor_map[ty]
+    except KeyError:
+        raise LiteralTypingError("{} cannot be used as a literal".format(ty))
+    else:
+        return ctor(value)
+
+
+def maybe_literal(value):
+    """Get a Literal type for the value or None.
+    """
+    try:
+        return literal(value)
+    except LiteralTypingError:
+        return
+
+
+class Omitted(Opaque):
+    """
+    An omitted function argument with a default value.
+    """
+
+    def __init__(self, value):
+        self._value = value
+        # Use helper function to support both hashable and non-hashable
+        # values. See discussion in gh #6957.
+        self._value_key = get_hashable_key(value)
+        super(Omitted, self).__init__("omitted(default=%r)" % (value,))
+
+    @property
+    def key(self):
+        return type(self._value), self._value_key
+
+    @property
+    def value(self):
+        return self._value
+
+
+class VarArg(Type):
+    """
+    Special type representing a variable number of arguments at the
+    end of a function's signature.  Only used for signature matching,
+    not for actual values.
+    """
+
+    def __init__(self, dtype):
+        self.dtype = dtype
+        super(VarArg, self).__init__("*%s" % dtype)
+
+    @property
+    def key(self):
+        return self.dtype
+
+
+class Module(Dummy):
+    def __init__(self, pymod):
+        self.pymod = pymod
+        super(Module, self).__init__("Module(%s)" % pymod)
+
+    @property
+    def key(self):
+        return self.pymod
+
+
+class MemInfoPointer(Type):
+    """
+    Pointer to a Numba "meminfo" (i.e. the information for a managed
+    piece of memory).
+    """
+    mutable = True
+
+    def __init__(self, dtype):
+        self.dtype = dtype
+        name = "memory-managed *%s" % dtype
+        super(MemInfoPointer, self).__init__(name)
+
+    @property
+    def key(self):
+        return self.dtype
+
+
+class CPointer(Type):
+    """
+    Type class for pointers to other types.
+
+    Attributes
+    ----------
+        dtype : The pointee type
+        addrspace : int
+            The address space pointee belongs to.
+    """
+    mutable = True
+
+    def __init__(self, dtype, addrspace=None):
+        self.dtype = dtype
+        self.addrspace = addrspace
+        if addrspace is not None:
+            name = "%s_%s*" % (dtype, addrspace)
+        else:
+            name = "%s*" % dtype
+        super(CPointer, self).__init__(name)
+
+    @property
+    def key(self):
+        return self.dtype, self.addrspace
+
+
+class EphemeralPointer(CPointer):
+    """
+    Type class for pointers which aren't guaranteed to last long - e.g.
+    stack-allocated slots.  The data model serializes such pointers
+    by copying the data pointed to.
+    """
+
+
+class EphemeralArray(Type):
+    """
+    Similar to EphemeralPointer, but pointing to an array of elements,
+    rather than a single one.  The array size must be known at compile-time.
+    """
+
+    def __init__(self, dtype, count):
+        self.dtype = dtype
+        self.count = count
+        name = "*%s[%d]" % (dtype, count)
+        super(EphemeralArray, self).__init__(name)
+
+    @property
+    def key(self):
+        return self.dtype, self.count
+
+
+class Object(Type):
+    # XXX unused?
+    mutable = True
+
+    def __init__(self, clsobj):
+        self.cls = clsobj
+        name = "Object(%s)" % clsobj.__name__
+        super(Object, self).__init__(name)
+
+    @property
+    def key(self):
+        return self.cls
+
+
+class Optional(Type):
+    """
+    Type class for optional types, i.e. union { some type, None }
+    """
+
+    def __init__(self, typ):
+        assert not isinstance(typ, (Optional, NoneType))
+        typ = unliteral(typ)
+        self.type = typ
+        name = "OptionalType(%s)" % self.type
+        super(Optional, self).__init__(name)
+
+    @property
+    def key(self):
+        return self.type
+
+    def can_convert_to(self, typingctx, other):
+        if isinstance(other, Optional):
+            return typingctx.can_convert(self.type, other.type)
+        else:
+            conv = typingctx.can_convert(self.type, other)
+            if conv is not None:
+                return max(conv, Conversion.safe)
+
+    def can_convert_from(self, typingctx, other):
+        if isinstance(other, NoneType):
+            return Conversion.promote
+        elif isinstance(other, Optional):
+            return typingctx.can_convert(other.type, self.type)
+        else:
+            conv = typingctx.can_convert(other, self.type)
+            if conv is not None:
+                return max(conv, Conversion.promote)
+
+    def unify(self, typingctx, other):
+        if isinstance(other, Optional):
+            unified = typingctx.unify_pairs(self.type, other.type)
+        else:
+            unified = typingctx.unify_pairs(self.type, other)
+
+        if unified is not None:
+            if isinstance(unified, Optional):
+                return unified
+            else:
+                return Optional(unified)
+
+
+class NoneType(Opaque):
+    """
+    The type for None.
+    """
+
+    def unify(self, typingctx, other):
+        """
+        Turn anything to a Optional type;
+        """
+        if isinstance(other, (Optional, NoneType)):
+            return other
+        return Optional(other)
+
+
+class EllipsisType(Opaque):
+    """
+    The type for the Ellipsis singleton.
+    """
+
+
+class ExceptionClass(Callable, Phantom):
+    """
+    The type of exception classes (not instances).
+    """
+
+    def __init__(self, exc_class):
+        assert issubclass(exc_class, BaseException)
+        name = "%s" % (exc_class.__name__)
+        self.exc_class = exc_class
+        super(ExceptionClass, self).__init__(name)
+
+    def get_call_type(self, context, args, kws):
+        return self.get_call_signatures()[0][0]
+
+    def get_call_signatures(self):
+        from numba.core import typing
+        return_type = ExceptionInstance(self.exc_class)
+        return [typing.signature(return_type)], False
+
+    def get_impl_key(self, sig):
+        return type(self)
+
+    @property
+    def key(self):
+        return self.exc_class
+
+
+class ExceptionInstance(Phantom):
+    """
+    The type of exception instances.  *exc_class* should be the
+    exception class.
+    """
+
+    def __init__(self, exc_class):
+        assert issubclass(exc_class, BaseException)
+        name = "%s(...)" % (exc_class.__name__,)
+        self.exc_class = exc_class
+        super(ExceptionInstance, self).__init__(name)
+
+    @property
+    def key(self):
+        return self.exc_class
+
+
+class SliceType(Type):
+
+    def __init__(self, name, members):
+        assert members in (2, 3)
+        self.members = members
+        self.has_step = members >= 3
+        super(SliceType, self).__init__(name)
+
+    @property
+    def key(self):
+        return self.members
+
+
+class SliceLiteral(Literal, SliceType):
+    def __init__(self, value):
+        self._literal_init(value)
+        name = 'Literal[slice]({})'.format(value)
+        members = 2 if value.step is None else 3
+        SliceType.__init__(self, name=name, members=members)
+
+    @property
+    def key(self):
+        sl = self.literal_value
+        return sl.start, sl.stop, sl.step
+
+
+Literal.ctor_map[slice] = SliceLiteral
+
+
+class ClassInstanceType(Type):
+    """
+    The type of a jitted class *instance*.  It will be the return-type
+    of the constructor of the class.
+    """
+    mutable = True
+    name_prefix = "instance"
+
+    def __init__(self, class_type):
+        self.class_type = class_type
+        name = "{0}.{1}".format(self.name_prefix, self.class_type.name)
+        super(ClassInstanceType, self).__init__(name)
+
+    def get_data_type(self):
+        return ClassDataType(self)
+
+    def get_reference_type(self):
+        return self
+
+    @property
+    def key(self):
+        return self.class_type.key
+
+    @property
+    def classname(self):
+        return self.class_type.class_name
+
+    @property
+    def jit_props(self):
+        return self.class_type.jit_props
+
+    @property
+    def jit_static_methods(self):
+        return self.class_type.jit_static_methods
+
+    @property
+    def jit_methods(self):
+        return self.class_type.jit_methods
+
+    @property
+    def struct(self):
+        return self.class_type.struct
+
+    @property
+    def methods(self):
+        return self.class_type.methods
+
+    @property
+    def static_methods(self):
+        return self.class_type.static_methods
+
+
+class ClassType(Callable, Opaque):
+    """
+    The type of the jitted class (not instance).  When the type of a class
+    is called, its constructor is invoked.
+    """
+    mutable = True
+    name_prefix = "jitclass"
+    instance_type_class = ClassInstanceType
+
+    def __init__(self, class_def, ctor_template_cls, struct, jit_methods,
+                 jit_props, jit_static_methods):
+        self.class_name = class_def.__name__
+        self.class_doc = class_def.__doc__
+        self._ctor_template_class = ctor_template_cls
+        self.jit_methods = jit_methods
+        self.jit_props = jit_props
+        self.jit_static_methods = jit_static_methods
+        self.struct = struct
+        fielddesc = ','.join("{0}:{1}".format(k, v) for k, v in struct.items())
+        name = "{0}.{1}#{2:x}<{3}>".format(self.name_prefix, self.class_name,
+                                           id(self), fielddesc)
+        super(ClassType, self).__init__(name)
+
+    def get_call_type(self, context, args, kws):
+        return self.ctor_template(context).apply(args, kws)
+
+    def get_call_signatures(self):
+        return (), True
+
+    def get_impl_key(self, sig):
+        return type(self)
+
+    @property
+    def methods(self):
+        return {k: v.py_func for k, v in self.jit_methods.items()}
+
+    @property
+    def static_methods(self):
+        return {k: v.py_func for k, v in self.jit_static_methods.items()}
+
+    @property
+    def instance_type(self):
+        return ClassInstanceType(self)
+
+    @property
+    def ctor_template(self):
+        return self._specialize_template(self._ctor_template_class)
+
+    def _specialize_template(self, basecls):
+        return type(basecls.__name__, (basecls,), dict(key=self))
+
+
+class DeferredType(Type):
+    """
+    Represents a type that will be defined later.  It must be defined
+    before it is materialized (used in the compiler).  Once defined, it
+    behaves exactly as the type it is defining.
+    """
+
+    def __init__(self):
+        self._define = None
+        name = "{0}#{1}".format(type(self).__name__, id(self))
+        super(DeferredType, self).__init__(name)
+
+    def get(self):
+        if self._define is None:
+            raise RuntimeError("deferred type not defined")
+        return self._define
+
+    def define(self, typ):
+        if self._define is not None:
+            raise TypeError("deferred type already defined")
+        if not isinstance(typ, Type):
+            raise TypeError("arg is not a Type; got: {0}".format(type(typ)))
+        self._define = typ
+
+    def unify(self, typingctx, other):
+        return typingctx.unify_pairs(self.get(), other)
+
+
+class ClassDataType(Type):
+    """
+    Internal only.
+    Represents the data of the instance.  The representation of
+    ClassInstanceType contains a pointer to a ClassDataType which represents
+    a C structure that contains all the data fields of the class instance.
+    """
+
+    def __init__(self, classtyp):
+        self.class_type = classtyp
+        name = "data.{0}".format(self.class_type.name)
+        super(ClassDataType, self).__init__(name)
+
+
+class ContextManager(Callable, Phantom):
+    """
+    An overly-simple ContextManager type that cannot be materialized.
+    """
+
+    def __init__(self, cm):
+        self.cm = cm
+        super(ContextManager, self).__init__("ContextManager({})".format(cm))
+
+    def get_call_signatures(self):
+        if not self.cm.is_callable:
+            msg = "contextmanager {} is not callable".format(self.cm)
+            raise TypingError(msg)
+
+        return (), False
+
+    def get_call_type(self, context, args, kws):
+        from numba.core import typing
+
+        if not self.cm.is_callable:
+            msg = "contextmanager {} is not callable".format(self.cm)
+            raise TypingError(msg)
+
+        posargs = list(args) + [v for k, v in sorted(kws.items())]
+        return typing.signature(self, *posargs)
+
+    def get_impl_key(self, sig):
+        return type(self)
+
+
+class UnicodeType(IterableType, Hashable):
+
+    def __init__(self, name):
+        super(UnicodeType, self).__init__(name)
+
+    @property
+    def iterator_type(self):
+        return UnicodeIteratorType(self)
+
+
+class UnicodeIteratorType(SimpleIteratorType):
+
+    def __init__(self, dtype):
+        name = "iter_unicode"
+        self.data = dtype
+        super(UnicodeIteratorType, self).__init__(name, dtype)

lib/python3.10/site-packages/numba/core/types/new_scalars/__init__.py

@@ -0,0 +1,18 @@
+from numba.core.types.new_scalars.scalars import (
+    Integer, IntegerLiteral, Boolean, BooleanLiteral, Float, Complex,
+    parse_integer_bitwidth, parse_integer_signed,
+    _NPDatetimeBase, NPTimedelta, NPDatetime, EnumClass, IntEnumClass,
+    EnumMember, IntEnumMember
+)
+from numba.core.types.new_scalars.python_types import (
+    PythonBoolean, PythonInteger, PythonFloat, PythonComplex,
+    PythonBooleanLiteral, PythonIntegerLiteral
+)
+from numba.core.types.new_scalars.machine_types import (
+    MachineBoolean, MachineInteger, MachineFloat, MachineComplex,
+    MachineBooleanLiteral, MachineIntegerLiteral
+)
+from numba.core.types.new_scalars.numpy_types import (
+    NumPyBoolean, NumPyInteger, NumPyFloat, NumPyComplex,
+    NumPyBooleanLiteral, NumPyIntegerLiteral
+)

lib/python3.10/site-packages/numba/core/types/new_scalars/machine_types.py

@@ -0,0 +1,119 @@
+"""
+    Type definitions for machine types.
+"""
+
+from numba.core.types.new_scalars.scalars \
+    import (Integer, IntegerLiteral, Boolean,
+            BooleanLiteral, Float, Complex,
+            parse_integer_bitwidth, parse_integer_signed)
+from functools import total_ordering
+from numba.core.typeconv import Conversion
+
+
+@total_ordering
+class MachineInteger(Integer):
+    def __init__(self, name, bitwidth=None, signed=None):
+        super(MachineInteger, self).__init__(name)
+        if bitwidth is None:
+            bitwidth = parse_integer_bitwidth(name)
+        if signed is None:
+            signed = parse_integer_signed(name)
+        self.bitwidth = bitwidth
+        self.signed = signed
+
+    @classmethod
+    def from_bitwidth(cls, bitwidth, signed=True):
+        name = ('int%d' if signed else 'uint%d') % bitwidth
+        return cls(name)
+
+    def __lt__(self, other):
+        if self.__class__ is not other.__class__:
+            return NotImplemented
+        if self.signed != other.signed:
+            return NotImplemented
+        return self.bitwidth < other.bitwidth
+
+    @property
+    def maxval(self):
+        """
+        The maximum value representable by this type.
+        """
+        if self.signed:
+            return (1 << (self.bitwidth - 1)) - 1
+        else:
+            return (1 << self.bitwidth) - 1
+
+    @property
+    def minval(self):
+        """
+        The minimal value representable by this type.
+        """
+        if self.signed:
+            return -(1 << (self.bitwidth - 1))
+        else:
+            return 0
+
+
+class MachineIntegerLiteral(IntegerLiteral, MachineInteger):
+    def __init__(self, value):
+        self._literal_init(value)
+        name = 'Literal[machine_int]({})'.format(value)
+        basetype = self.literal_type
+        MachineInteger.__init__(self,
+                                name=name,
+                                bitwidth=basetype.bitwidth,
+                                signed=basetype.signed,)
+
+    def can_convert_to(self, typingctx, other):
+        conv = typingctx.can_convert(self.literal_type, other)
+        if conv is not None:
+            return max(conv, Conversion.promote)
+
+
+class MachineBoolean(Boolean):
+    pass
+
+
+class MachineBooleanLiteral(BooleanLiteral, MachineBoolean):
+
+    def __init__(self, value):
+        self._literal_init(value)
+        name = 'Literal[machine_bool]({})'.format(value)
+        MachineBoolean.__init__(self,
+                                name=name)
+
+    def can_convert_to(self, typingctx, other):
+        conv = typingctx.can_convert(self.literal_type, other)
+        if conv is not None:
+            return max(conv, Conversion.promote)
+
+
+@total_ordering
+class MachineFloat(Float):
+    def __init__(self, *args, **kws):
+        super(MachineFloat, self).__init__(*args, **kws)
+        # Determine bitwidth
+        assert self.name.startswith('c_float')
+        bitwidth = int(self.name[8:])
+        self.bitwidth = bitwidth
+
+    def __lt__(self, other):
+        if self.__class__ is not other.__class__:
+            return NotImplemented
+        return self.bitwidth < other.bitwidth
+
+
+@total_ordering
+class MachineComplex(Complex):
+    def __init__(self, name, underlying_float, **kwargs):
+        super(MachineComplex, self).__init__(name, **kwargs)
+        self.underlying_float = underlying_float
+        # Determine bitwidth
+        assert self.name.startswith('c_complex')
+        bitwidth = int(self.name[10:])
+        self.bitwidth = bitwidth
+
+    def __lt__(self, other):
+        if self.__class__ is not other.__class__:
+            return NotImplemented
+        return self.bitwidth < other.bitwidth

lib/python3.10/site-packages/numba/core/types/new_scalars/numpy_types.py

@@ -0,0 +1,142 @@
+"""
+    Type definitions for NumPy types.
+"""
+
+import numpy as np
+
+from numba.core.types.abstract import Literal
+from numba.core.types.new_scalars.scalars \
+    import (Integer, IntegerLiteral, Boolean,
+            BooleanLiteral, Float, Complex,
+            parse_integer_bitwidth, parse_integer_signed)
+from functools import total_ordering
+from numba.core.typeconv import Conversion
+
+
+@total_ordering
+class NumPyInteger(Integer):
+    def __init__(self, name, bitwidth=None, signed=None):
+        super(NumPyInteger, self).__init__(name)
+        if bitwidth is None:
+            bitwidth = parse_integer_bitwidth(name)
+        if signed is None:
+            signed = parse_integer_signed(name)
+        self.bitwidth = bitwidth
+        self.signed = signed
+
+    @classmethod
+    def from_bitwidth(cls, bitwidth, signed=True):
+        name = ('np_int%d' if signed else 'np_uint%d') % bitwidth
+        return cls(name)
+
+    def cast_python_value(self, value):
+        sign_char = "" if self.signed else "u"
+        return getattr(
+            np,
+            sign_char + "int" + str(self.bitwidth)
+        )(value)
+
+    def __lt__(self, other):
+        if self.__class__ is not other.__class__:
+            return NotImplemented
+        if self.signed != other.signed:
+            return NotImplemented
+        return self.bitwidth < other.bitwidth
+
+    @property
+    def maxval(self):
+        """
+        The maximum value representable by this type.
+        """
+        if self.signed:
+            return (1 << (self.bitwidth - 1)) - 1
+        else:
+            return (1 << self.bitwidth) - 1
+
+    @property
+    def minval(self):
+        """
+        The minimal value representable by this type.
+        """
+        if self.signed:
+            return -(1 << (self.bitwidth - 1))
+        else:
+            return 0
+
+
+class NumPyIntegerLiteral(IntegerLiteral):
+    def __init__(self, value):
+        self._literal_init(value)
+        name = 'Literal[int]({})'.format(value)
+        basetype = self.literal_type
+        NumPyInteger.__init__(self,
+                              name=name,
+                              bitwidth=basetype.bitwidth,
+                              signed=basetype.signed,)
+
+    def can_convert_to(self, typingctx, other):
+        conv = typingctx.can_convert(self.literal_type, other)
+        if conv is not None:
+            return max(conv, Conversion.promote)
+
+
+Literal.ctor_map[np.integer] = NumPyIntegerLiteral
+
+
+class NumPyBoolean(Boolean):
+    def cast_python_value(self, value):
+        return np.bool_(value)
+
+
+class NumPyBooleanLiteral(BooleanLiteral, NumPyBoolean):
+
+    def __init__(self, value):
+        self._literal_init(value)
+        name = 'Literal[np.bool_]({})'.format(value)
+        NumPyBoolean.__init__(self,
+                              name=name)
+
+    def can_convert_to(self, typingctx, other):
+        conv = typingctx.can_convert(self.literal_type, other)
+        if conv is not None:
+            return max(conv, Conversion.promote)
+
+
+Literal.ctor_map[np.bool_] = NumPyBooleanLiteral
+
+
+@total_ordering
+class NumPyFloat(Float):
+    def __init__(self, *args, **kws):
+        super(NumPyFloat, self).__init__(*args, **kws)
+        # Determine bitwidth
+        assert self.name.startswith('np_float')
+        bitwidth = int(self.name[8:])
+        self.bitwidth = bitwidth
+
+    def cast_python_value(self, value):
+        return getattr(np, "float" + str(self.bitwidth))(value)
+
+    def __lt__(self, other):
+        if self.__class__ is not other.__class__:
+            return NotImplemented
+        return self.bitwidth < other.bitwidth
+
+
+@total_ordering
+class NumPyComplex(Complex):
+    def __init__(self, name, underlying_float, **kwargs):
+        super(NumPyComplex, self).__init__(name, **kwargs)
+        self.underlying_float = underlying_float
+        # Determine bitwidth
+        assert self.name.startswith('np_complex')
+        bitwidth = int(self.name[10:])
+        self.bitwidth = bitwidth
+
+    def cast_python_value(self, value):
+        return getattr(np, "complex" + str(self.bitwidth))(value)
+
+    def __lt__(self, other):
+        if self.__class__ is not other.__class__:
+            return NotImplemented
+        return self.bitwidth < other.bitwidth

lib/python3.10/site-packages/numba/core/types/new_scalars/python_types.py

@@ -0,0 +1,130 @@
+"""
+    Type definitions for Python types.
+"""
+
+from numba.core.types.abstract import Literal
+from numba.core.types.new_scalars.scalars \
+    import (Integer, IntegerLiteral, Boolean,
+            BooleanLiteral, Float, Complex,
+            parse_integer_signed)
+from functools import total_ordering
+from numba.core.typeconv import Conversion
+
+
+@total_ordering
+class PythonInteger(Integer):
+    def __init__(self, name, bitwidth=None, signed=None):
+        super(PythonInteger, self).__init__(name)
+        if bitwidth is None:
+            bitwidth = 64
+        if signed is None:
+            signed = parse_integer_signed(name)
+        self.bitwidth = bitwidth
+        self.signed = signed
+
+    def cast_python_value(self, value):
+        return int(value)
+
+    def __lt__(self, other):
+        if self.__class__ is not other.__class__:
+            return NotImplemented
+        if self.signed != other.signed:
+            return NotImplemented
+        return self.bitwidth < other.bitwidth
+
+    @property
+    def maxval(self):
+        """
+        The maximum value representable by this type.
+        """
+        if self.signed:
+            return (1 << (self.bitwidth - 1)) - 1
+        else:
+            return (1 << self.bitwidth) - 1
+
+    @property
+    def minval(self):
+        """
+        The minimal value representable by this type.
+        """
+        if self.signed:
+            return -(1 << (self.bitwidth - 1))
+        else:
+            return 0
+
+
+class PythonIntegerLiteral(IntegerLiteral, PythonInteger):
+    def __init__(self, value):
+        self._literal_init(value)
+        name = 'Literal[int]({})'.format(value)
+        basetype = self.literal_type
+        PythonInteger.__init__(self,
+                               name=name,
+                               bitwidth=basetype.bitwidth,
+                               signed=basetype.signed,)
+
+    def can_convert_to(self, typingctx, other):
+        conv = typingctx.can_convert(self.literal_type, other)
+        if conv is not None:
+            return max(conv, Conversion.promote)
+
+
+Literal.ctor_map[int] = PythonIntegerLiteral
+
+
+class PythonBoolean(Boolean):
+    def cast_python_value(self, value):
+        return bool(value)
+
+
+class PythonBooleanLiteral(BooleanLiteral, PythonBoolean):
+
+    def __init__(self, value):
+        self._literal_init(value)
+        name = 'Literal[bool]({})'.format(value)
+        PythonBoolean.__init__(self, name=name)
+
+    def can_convert_to(self, typingctx, other):
+        conv = typingctx.can_convert(self.literal_type, other)
+        if conv is not None:
+            return max(conv, Conversion.promote)
+
+
+Literal.ctor_map[bool] = PythonBooleanLiteral
+
+
+@total_ordering
+class PythonFloat(Float):
+    def __init__(self, *args, **kws):
+        super(PythonFloat, self).__init__(*args, **kws)
+        # Determine bitwidth
+        assert self.name.startswith('py_float')
+        bitwidth = 64
+        self.bitwidth = bitwidth
+
+    def cast_python_value(self, value):
+        return float(value)
+
+    def __lt__(self, other):
+        if self.__class__ is not other.__class__:
+            return NotImplemented
+        return self.bitwidth < other.bitwidth
+
+
+@total_ordering
+class PythonComplex(Complex):
+    def __init__(self, name, underlying_float, **kwargs):
+        super(PythonComplex, self).__init__(name, **kwargs)
+        self.underlying_float = underlying_float
+        # Determine bitwidth
+        assert self.name.startswith('py_complex')
+        bitwidth = 128
+        self.bitwidth = bitwidth
+
+    def cast_python_value(self, value):
+        return complex(value)
+
+    def __lt__(self, other):
+        if self.__class__ is not other.__class__:
+            return NotImplemented
+        return self.bitwidth < other.bitwidth

lib/python3.10/site-packages/numba/core/types/new_scalars/scalars.py

@@ -0,0 +1,161 @@
+import enum
+import re
+import numpy as np
+
+from numba.core.types.abstract import Dummy, Hashable, Literal, Number, Type
+from functools import total_ordering, cached_property
+from numba.core import utils
+from numba.core.typeconv import Conversion
+from numba.np import npdatetime_helpers
+
+
+class Boolean(Hashable):
+    pass
+
+def parse_integer_bitwidth(name):
+    bitwidth = int(re.findall(r'\d+', name)[-1])
+    return bitwidth
+
+
+def parse_integer_signed(name):
+    signed = name.startswith('int')
+    return signed
+
+
+class Integer(Number):
+    pass
+
+
+class IntegerLiteral(Literal, Integer):
+    pass
+
+
+class BooleanLiteral(Literal, Boolean):
+    pass
+
+
+class Float(Number):
+    pass
+
+
+class Complex(Number):
+    pass
+
+
+class _NPDatetimeBase(Type):
+    """
+    Common base class for np.datetime64 and np.timedelta64.
+    """
+
+    def __init__(self, unit, *args, **kws):
+        name = '%s[%s]' % (self.type_name, unit)
+        self.unit = unit
+        self.unit_code = npdatetime_helpers.DATETIME_UNITS[self.unit]
+        super(_NPDatetimeBase, self).__init__(name, *args, **kws)
+
+    def __lt__(self, other):
+        if self.__class__ is not other.__class__:
+            return NotImplemented
+        # A coarser-grained unit is "smaller", i.e. less precise values
+        # can be represented (but the magnitude of representable values is
+        # also greater...).
+        return self.unit_code < other.unit_code
+
+    def cast_python_value(self, value):
+        cls = getattr(np, self.type_name)
+        if self.unit:
+            return cls(value, self.unit)
+        else:
+            return cls(value)
+
+
+@total_ordering
+class NPTimedelta(_NPDatetimeBase):
+    type_name = 'timedelta64'
+
+@total_ordering
+class NPDatetime(_NPDatetimeBase):
+    type_name = 'datetime64'
+
+
+class EnumClass(Dummy):
+    """
+    Type class for Enum classes.
+    """
+    basename = "Enum class"
+
+    def __init__(self, cls, dtype):
+        assert isinstance(cls, type)
+        assert isinstance(dtype, Type)
+        self.instance_class = cls
+        self.dtype = dtype
+        name = "%s<%s>(%s)" % (self.basename, self.dtype, self.instance_class.__name__)
+        super(EnumClass, self).__init__(name)
+
+    @property
+    def key(self):
+        return self.instance_class, self.dtype
+
+    @cached_property
+    def member_type(self):
+        """
+        The type of this class' members.
+        """
+        return EnumMember(self.instance_class, self.dtype)
+
+
+class IntEnumClass(EnumClass):
+    """
+    Type class for IntEnum classes.
+    """
+    basename = "IntEnum class"
+
+    @cached_property
+    def member_type(self):
+        """
+        The type of this class' members.
+        """
+        return IntEnumMember(self.instance_class, self.dtype)
+
+
+class EnumMember(Type):
+    """
+    Type class for Enum members.
+    """
+    basename = "Enum"
+    class_type_class = EnumClass
+
+    def __init__(self, cls, dtype):
+        assert isinstance(cls, type)
+        assert isinstance(dtype, Type)
+        self.instance_class = cls
+        self.dtype = dtype
+        name = "%s<%s>(%s)" % (self.basename, self.dtype, self.instance_class.__name__)
+        super(EnumMember, self).__init__(name)
+
+    @property
+    def key(self):
+        return self.instance_class, self.dtype
+
+    @property
+    def class_type(self):
+        """
+        The type of this member's class.
+        """
+        return self.class_type_class(self.instance_class, self.dtype)
+
+
+class IntEnumMember(EnumMember):
+    """
+    Type class for IntEnum members.
+    """
+    basename = "IntEnum"
+    class_type_class = IntEnumClass
+
+    def can_convert_to(self, typingctx, other):
+        """
+        Convert IntEnum members to plain integers.
+        """
+        if issubclass(self.instance_class, enum.IntEnum):
+            conv = typingctx.can_convert(self.dtype, other)
+            return max(conv, Conversion.safe)

lib/python3.10/site-packages/numba/core/types/npytypes.py

@@ -0,0 +1,649 @@
+import collections
+import warnings
+from functools import cached_property
+
+from llvmlite import ir
+
+from .abstract import DTypeSpec, IteratorType, MutableSequence, Number, Type
+from .common import Buffer, Opaque, SimpleIteratorType
+from numba.core.typeconv import Conversion
+from numba.core import utils
+from .misc import UnicodeType
+from .containers import Bytes
+import numpy as np
+
+class CharSeq(Type):
+    """
+    A fixed-length 8-bit character sequence.
+    """
+    mutable = True
+
+    def __init__(self, count):
+        self.count = count
+        name = "[char x %d]" % count
+        super(CharSeq, self).__init__(name)
+
+    @property
+    def key(self):
+        return self.count
+
+    def can_convert_from(self, typingctx, other):
+        if isinstance(other, Bytes):
+            return Conversion.safe
+
+
+class UnicodeCharSeq(Type):
+    """
+    A fixed-length unicode character sequence.
+    """
+    mutable = True
+
+    def __init__(self, count):
+        self.count = count
+        name = "[unichr x %d]" % count
+        super(UnicodeCharSeq, self).__init__(name)
+
+    @property
+    def key(self):
+        return self.count
+
+    def can_convert_to(self, typingctx, other):
+        if isinstance(other, UnicodeCharSeq):
+            return Conversion.safe
+
+    def can_convert_from(self, typingctx, other):
+        if isinstance(other, UnicodeType):
+            # Assuming that unicode_type itemsize is not greater than
+            # numpy.dtype('U1').itemsize that UnicodeCharSeq is based
+            # on.
+            return Conversion.safe
+
+    def __repr__(self):
+        return f"UnicodeCharSeq({self.count})"
+
+
+_RecordField = collections.namedtuple(
+    '_RecordField',
+    'type,offset,alignment,title',
+)
+
+
+class Record(Type):
+    """
+    A Record datatype can be mapped to a NumPy structured dtype.
+    A record is very flexible since it is laid out as a list of bytes.
+    Fields can be mapped to arbitrary points inside it, even if they overlap.
+
+    *fields* is a list of `(name:str, data:dict)`.
+        Where `data` is `{ type: Type, offset: int }`
+    *size* is an int; the record size
+    *aligned* is a boolean; whether the record is ABI aligned.
+    """
+    mutable = True
+
+    @classmethod
+    def make_c_struct(cls, name_types):
+        """Construct a Record type from a list of (name:str, type:Types).
+        The layout of the structure will follow C.
+
+        Note: only scalar types are supported currently.
+        """
+        from numba.core.registry import cpu_target
+
+        ctx = cpu_target.target_context
+        offset = 0
+        fields = []
+        lltypes = []
+        for k, ty in name_types:
+            if not isinstance(ty, (Number, NestedArray)):
+                msg = "Only Number and NestedArray types are supported, found: {}. "
+                raise TypeError(msg.format(ty))
+            if isinstance(ty, NestedArray):
+                datatype = ctx.data_model_manager[ty].as_storage_type()
+            else:
+                datatype = ctx.get_data_type(ty)
+            lltypes.append(datatype)
+            size = ctx.get_abi_sizeof(datatype)
+            align = ctx.get_abi_alignment(datatype)
+            # align
+            misaligned = offset % align
+            if misaligned:
+                offset += align - misaligned
+            fields.append((k, {
+                'type': ty, 'offset': offset, 'alignment': align,
+            }))
+            offset += size
+        # Adjust sizeof structure
+        abi_size = ctx.get_abi_sizeof(ir.LiteralStructType(lltypes))
+        return Record(fields, size=abi_size, aligned=True)
+
+    def __init__(self, fields, size, aligned):
+        fields = self._normalize_fields(fields)
+        self.fields = dict(fields)
+        self.size = size
+        self.aligned = aligned
+
+        # Create description
+        descbuf = []
+        fmt = "{}[type={};offset={}{}]"
+        for k, infos in fields:
+            extra = ""
+            if infos.alignment is not None:
+                extra += ';alignment={}'.format(infos.alignment)
+            elif infos.title is not None:
+                extra += ';title={}'.format(infos.title)
+            descbuf.append(fmt.format(k, infos.type, infos.offset, extra))
+
+        desc = ','.join(descbuf)
+        name = 'Record({};{};{})'.format(desc, self.size, self.aligned)
+        super(Record, self).__init__(name)
+
+        self.bitwidth = self.dtype.itemsize * 8
+
+    @classmethod
+    def _normalize_fields(cls, fields):
+        """
+        fields:
+            [name: str,
+             value: {
+                 type: Type,
+                 offset: int,
+                 [ alignment: int ],
+                 [ title : str],
+             }]
+        """
+        res = []
+        for name, infos in sorted(fields, key=lambda x: (x[1]['offset'], x[0])):
+            fd = _RecordField(
+                type=infos['type'],
+                offset=infos['offset'],
+                alignment=infos.get('alignment'),
+                title=infos.get('title'),
+            )
+            res.append((name, fd))
+        return res
+
+    @property
+    def key(self):
+        # Numpy dtype equality doesn't always succeed, use the name instead
+        # (https://github.com/numpy/numpy/issues/5715)
+        return self.name
+
+    @property
+    def mangling_args(self):
+        return self.__class__.__name__, (self._code,)
+
+    def __len__(self):
+        """Returns the number of fields
+        """
+        return len(self.fields)
+
+    def offset(self, key):
+        """Get the byte offset of a field from the start of the structure.
+        """
+        return self.fields[key].offset
+
+    def typeof(self, key):
+        """Get the type of a field.
+        """
+        return self.fields[key].type
+
+    def alignof(self, key):
+        """Get the specified alignment of the field.
+
+        Since field alignment is optional, this may return None.
+        """
+        return self.fields[key].alignment
+
+    def has_titles(self):
+        """Returns True the record uses titles.
+        """
+        return any(fd.title is not None for fd in self.fields.values())
+
+    def is_title(self, key):
+        """Returns True if the field named *key* is a title.
+        """
+        return self.fields[key].title == key
+
+    @property
+    def members(self):
+        """An ordered list of (name, type) for the fields.
+        """
+        ordered = sorted(self.fields.items(), key=lambda x: x[1].offset)
+        return [(k, v.type) for k, v in ordered]
+
+    @property
+    def dtype(self):
+        from numba.np.numpy_support import as_struct_dtype
+
+        return as_struct_dtype(self)
+
+    def can_convert_to(self, typingctx, other):
+        """
+        Convert this Record to the *other*.
+
+        This method only implements width subtyping for records.
+        """
+        from numba.core.errors import NumbaExperimentalFeatureWarning
+
+        if isinstance(other, Record):
+            if len(other.fields) > len(self.fields):
+                return
+            for other_fd, self_fd in zip(other.fields.items(),
+                                         self.fields.items()):
+                if not other_fd == self_fd:
+                    return
+            warnings.warn(f"{self} has been considered a subtype of {other} "
+                          f" This is an experimental feature.",
+                          category=NumbaExperimentalFeatureWarning)
+            return Conversion.safe
+
+    def __repr__(self):
+        fields = [f"('{f_name}', " +
+                  f"{{'type': {repr(f_info.type)}, " +
+                  f"'offset': {f_info.offset}, " +
+                  f"'alignment': {f_info.alignment}, " +
+                  f"'title': {f_info.title}, " +
+                  f"}}" +
+                  ")"
+                  for f_name, f_info in self.fields.items()
+                  ]
+        fields = "[" + ", ".join(fields) + "]"
+        return f"Record({fields}, {self.size}, {self.aligned})"
+
+class DType(DTypeSpec, Opaque):
+    """
+    Type class associated with the `np.dtype`.
+
+    i.e. :code:`assert type(np.dtype('int32')) == np.dtype`
+
+    np.dtype('int32')
+    """
+
+    def __init__(self, dtype):
+        assert isinstance(dtype, Type)
+        self._dtype = dtype
+        name = "dtype(%s)" % (dtype,)
+        super(DTypeSpec, self).__init__(name)
+
+    @property
+    def key(self):
+        return self.dtype
+
+    @property
+    def dtype(self):
+        return self._dtype
+
+    def __getitem__(self, arg):
+        res = super(DType, self).__getitem__(arg)
+        return res.copy(dtype=self.dtype)
+
+
+class NumpyFlatType(SimpleIteratorType, MutableSequence):
+    """
+    Type class for `ndarray.flat()` objects.
+    """
+
+    def __init__(self, arrty):
+        self.array_type = arrty
+        yield_type = arrty.dtype
+        self.dtype = yield_type
+        name = "array.flat({arrayty})".format(arrayty=arrty)
+        super(NumpyFlatType, self).__init__(name, yield_type)
+
+    @property
+    def key(self):
+        return self.array_type
+
+
+class NumpyNdEnumerateType(SimpleIteratorType):
+    """
+    Type class for `np.ndenumerate()` objects.
+    """
+
+    def __init__(self, arrty):
+        from . import Tuple, UniTuple, intp
+        self.array_type = arrty
+        yield_type = Tuple((UniTuple(intp, arrty.ndim), arrty.dtype))
+        name = "ndenumerate({arrayty})".format(arrayty=arrty)
+        super(NumpyNdEnumerateType, self).__init__(name, yield_type)
+
+    @property
+    def key(self):
+        return self.array_type
+
+
+class NumpyNdIterType(IteratorType):
+    """
+    Type class for `np.nditer()` objects.
+
+    The layout denotes in which order the logical shape is iterated on.
+    "C" means logical order (corresponding to in-memory order in C arrays),
+    "F" means reverse logical order (corresponding to in-memory order in
+    F arrays).
+    """
+
+    def __init__(self, arrays):
+        # Note inputs arrays can also be scalars, in which case they are
+        # broadcast.
+        self.arrays = tuple(arrays)
+        self.layout = self._compute_layout(self.arrays)
+        self.dtypes = tuple(getattr(a, 'dtype', a) for a in self.arrays)
+        self.ndim = max(getattr(a, 'ndim', 0) for a in self.arrays)
+        name = "nditer(ndim={ndim}, layout={layout}, inputs={arrays})".format(
+            ndim=self.ndim, layout=self.layout, arrays=self.arrays)
+        super(NumpyNdIterType, self).__init__(name)
+
+    @classmethod
+    def _compute_layout(cls, arrays):
+        c = collections.Counter()
+        for a in arrays:
+            if not isinstance(a, Array):
+                continue
+            if a.layout in 'CF' and a.ndim == 1:
+                c['C'] += 1
+                c['F'] += 1
+            elif a.ndim >= 1:
+                c[a.layout] += 1
+        return 'F' if c['F'] > c['C'] else 'C'
+
+    @property
+    def key(self):
+        return self.arrays
+
+    @property
+    def views(self):
+        """
+        The views yielded by the iterator.
+        """
+        return [Array(dtype, 0, 'C') for dtype in self.dtypes]
+
+    @property
+    def yield_type(self):
+        from . import BaseTuple
+        views = self.views
+        if len(views) > 1:
+            return BaseTuple.from_types(views)
+        else:
+            return views[0]
+
+    @cached_property
+    def indexers(self):
+        """
+        A list of (kind, start_dim, end_dim, indices) where:
+        - `kind` is either "flat", "indexed", "0d" or "scalar"
+        - `start_dim` and `end_dim` are the dimension numbers at which
+          this indexing takes place
+        - `indices` is the indices of the indexed arrays in self.arrays
+        """
+        d = collections.OrderedDict()
+        layout = self.layout
+        ndim = self.ndim
+        assert layout in 'CF'
+        for i, a in enumerate(self.arrays):
+            if not isinstance(a, Array):
+                indexer = ('scalar', 0, 0)
+            elif a.ndim == 0:
+                indexer = ('0d', 0, 0)
+            else:
+                if a.layout == layout or (a.ndim == 1 and a.layout in 'CF'):
+                    kind = 'flat'
+                else:
+                    kind = 'indexed'
+                if layout == 'C':
+                    # If iterating in C order, broadcasting is done on the outer indices
+                    indexer = (kind, ndim - a.ndim, ndim)
+                else:
+                    indexer = (kind, 0, a.ndim)
+            d.setdefault(indexer, []).append(i)
+        return list(k + (v,) for k, v in d.items())
+
+    @cached_property
+    def need_shaped_indexing(self):
+        """
+        Whether iterating on this iterator requires keeping track of
+        individual indices inside the shape.  If False, only a single index
+        over the equivalent flat shape is required, which can make the
+        iterator more efficient.
+        """
+        for kind, start_dim, end_dim, _ in self.indexers:
+            if kind in ('0d', 'scalar'):
+                pass
+            elif kind == 'flat':
+                if (start_dim, end_dim) != (0, self.ndim):
+                    # Broadcast flat iteration needs shaped indexing
+                    # to know when to restart iteration.
+                    return True
+            else:
+                return True
+        return False
+
+
+class NumpyNdIndexType(SimpleIteratorType):
+    """
+    Type class for `np.ndindex()` objects.
+    """
+
+    def __init__(self, ndim):
+        from . import UniTuple, intp
+        self.ndim = ndim
+        yield_type = UniTuple(intp, self.ndim)
+        name = "ndindex(ndim={ndim})".format(ndim=ndim)
+        super(NumpyNdIndexType, self).__init__(name, yield_type)
+
+    @property
+    def key(self):
+        return self.ndim
+
+
+class Array(Buffer):
+    """
+    Type class for Numpy arrays.
+    """
+
+    def __init__(self, dtype, ndim, layout, readonly=False, name=None,
+                 aligned=True):
+        if readonly:
+            self.mutable = False
+        if (not aligned or
+            (isinstance(dtype, Record) and not dtype.aligned)):
+            self.aligned = False
+        if isinstance(dtype, NestedArray):
+            ndim += dtype.ndim
+            dtype = dtype.dtype
+        if name is None:
+            type_name = "array"
+            if not self.mutable:
+                type_name = "readonly " + type_name
+            if not self.aligned:
+                type_name = "unaligned " + type_name
+            name = "%s(%s, %sd, %s)" % (type_name, dtype, ndim, layout)
+        super(Array, self).__init__(dtype, ndim, layout, name=name)
+
+    @property
+    def mangling_args(self):
+        args = [self.dtype, self.ndim, self.layout,
+                'mutable' if self.mutable else 'readonly',
+                'aligned' if self.aligned else 'unaligned']
+        return self.__class__.__name__, args
+
+    def copy(self, dtype=None, ndim=None, layout=None, readonly=None):
+        if dtype is None:
+            dtype = self.dtype
+        if ndim is None:
+            ndim = self.ndim
+        if layout is None:
+            layout = self.layout
+        if readonly is None:
+            readonly = not self.mutable
+        return Array(dtype=dtype, ndim=ndim, layout=layout, readonly=readonly,
+                     aligned=self.aligned)
+
+    @property
+    def key(self):
+        return self.dtype, self.ndim, self.layout, self.mutable, self.aligned
+
+    def unify(self, typingctx, other):
+        """
+        Unify this with the *other* Array.
+        """
+        # If other is array and the ndim matches
+        if isinstance(other, Array) and other.ndim == self.ndim:
+            # If dtype matches or other.dtype is undefined (inferred)
+            if other.dtype == self.dtype or not other.dtype.is_precise():
+                if self.layout == other.layout:
+                    layout = self.layout
+                else:
+                    layout = 'A'
+                readonly = not (self.mutable and other.mutable)
+                aligned = self.aligned and other.aligned
+                return Array(dtype=self.dtype, ndim=self.ndim, layout=layout,
+                             readonly=readonly, aligned=aligned)
+
+    def can_convert_to(self, typingctx, other):
+        """
+        Convert this Array to the *other*.
+        """
+        if (isinstance(other, Array) and other.ndim == self.ndim
+            and other.dtype == self.dtype):
+            if (other.layout in ('A', self.layout)
+                and (self.mutable or not other.mutable)
+                and (self.aligned or not other.aligned)):
+                return Conversion.safe
+
+    def is_precise(self):
+        return self.dtype.is_precise()
+
+    @property
+    def box_type(self):
+        """Returns the Python type to box to.
+        """
+        return np.ndarray
+
+    def __repr__(self):
+        return (
+            f"Array({repr(self.dtype)}, {self.ndim}, '{self.layout}', "
+            f"{not self.mutable}, aligned={self.aligned})"
+                )
+
+class ArrayCTypes(Type):
+    """
+    This is the type for `np.ndarray.ctypes`.
+    """
+    def __init__(self, arytype):
+        # This depends on the ndim for the shape and strides attributes,
+        # even though they are not implemented, yet.
+        self.dtype = arytype.dtype
+        self.ndim = arytype.ndim
+        name = "ArrayCTypes(dtype={0}, ndim={1})".format(self.dtype, self.ndim)
+        super(ArrayCTypes, self).__init__(name)
+
+    @property
+    def key(self):
+        return self.dtype, self.ndim
+
+    def can_convert_to(self, typingctx, other):
+        """
+        Convert this type to the corresponding pointer type.
+        This allows passing a array.ctypes object to a C function taking
+        a raw pointer.
+
+        Note that in pure Python, the array.ctypes object can only be
+        passed to a ctypes function accepting a c_void_p, not a typed
+        pointer.
+        """
+        from . import CPointer, voidptr
+        # XXX what about readonly
+        if isinstance(other, CPointer) and other.dtype == self.dtype:
+            return Conversion.safe
+        elif other == voidptr:
+            return Conversion.safe
+
+
+class ArrayFlags(Type):
+    """
+    This is the type for `np.ndarray.flags`.
+    """
+    def __init__(self, arytype):
+        self.array_type = arytype
+        name = "ArrayFlags({0})".format(self.array_type)
+        super(ArrayFlags, self).__init__(name)
+
+    @property
+    def key(self):
+        return self.array_type
+
+
+class NestedArray(Array):
+    """
+    A NestedArray is an array nested within a structured type (which are "void"
+    type in NumPy parlance). Unlike an Array, the shape, and not just the number
+    of dimensions is part of the type of a NestedArray.
+    """
+
+    def __init__(self, dtype, shape):
+        if isinstance(dtype, NestedArray):
+            tmp = Array(dtype.dtype, dtype.ndim, 'C')
+            shape += dtype.shape
+            dtype = tmp.dtype
+        assert dtype.bitwidth % 8 == 0, \
+            "Dtype bitwidth must be a multiple of bytes"
+        self._shape = shape
+        name = "nestedarray(%s, %s)" % (dtype, shape)
+        ndim = len(shape)
+        super(NestedArray, self).__init__(dtype, ndim, 'C', name=name)
+
+    @property
+    def shape(self):
+        return self._shape
+
+    @property
+    def nitems(self):
+        l = 1
+        for s in self.shape:
+            l = l * s
+        return l
+
+    @property
+    def size(self):
+        return self.dtype.bitwidth // 8
+
+    @property
+    def strides(self):
+        stride = self.size
+        strides = []
+        for i in reversed(self._shape):
+             strides.append(stride)
+             stride *= i
+        return tuple(reversed(strides))
+
+    @property
+    def key(self):
+        return self.dtype, self.shape
+
+    def __repr__(self):
+        return f"NestedArray({repr(self.dtype)}, {self.shape})"
+
+
+class NumPyRandomBitGeneratorType(Type):
+    def __init__(self, *args, **kwargs):
+        super(NumPyRandomBitGeneratorType, self).__init__(*args, **kwargs)
+        self.name = 'NumPyRandomBitGeneratorType'
+
+
+class NumPyRandomGeneratorType(Type):
+    def __init__(self, *args, **kwargs):
+        super(NumPyRandomGeneratorType, self).__init__(*args, **kwargs)
+        self.name = 'NumPyRandomGeneratorType'
+
+
+class PolynomialType(Type):
+    def __init__(self, coef, domain=None, window=None, n_args=1):
+        super(PolynomialType, self).__init__(name=f'PolynomialType({coef}, {domain}, {domain}, {n_args})')
+        self.coef = coef
+        self.domain = domain
+        self.window = window
+        # We use n_args to keep track of the number of arguments in the
+        # constructor, since the types of domain and window arguments depend on
+        # that and we need that information when boxing
+        self.n_args = n_args

lib/python3.10/site-packages/numba/core/types/old_scalars.py

@@ -0,0 +1,270 @@
+import enum
+
+import numpy as np
+
+from .abstract import Dummy, Hashable, Literal, Number, Type
+from functools import total_ordering, cached_property
+from numba.core import utils
+from numba.core.typeconv import Conversion
+from numba.np import npdatetime_helpers
+
+
+class Boolean(Hashable):
+
+    def cast_python_value(self, value):
+        return bool(value)
+
+
+def parse_integer_bitwidth(name):
+    for prefix in ('int', 'uint'):
+        if name.startswith(prefix):
+            bitwidth = int(name[len(prefix):])
+    return bitwidth
+
+
+def parse_integer_signed(name):
+    signed = name.startswith('int')
+    return signed
+
+
+@total_ordering
+class Integer(Number):
+    def __init__(self, name, bitwidth=None, signed=None):
+        super(Integer, self).__init__(name)
+        if bitwidth is None:
+            bitwidth = parse_integer_bitwidth(name)
+        if signed is None:
+            signed = parse_integer_signed(name)
+        self.bitwidth = bitwidth
+        self.signed = signed
+
+    @classmethod
+    def from_bitwidth(cls, bitwidth, signed=True):
+        name = ('int%d' if signed else 'uint%d') % bitwidth
+        return cls(name)
+
+    def cast_python_value(self, value):
+        return getattr(np, self.name)(value)
+
+    def __lt__(self, other):
+        if self.__class__ is not other.__class__:
+            return NotImplemented
+        if self.signed != other.signed:
+            return NotImplemented
+        return self.bitwidth < other.bitwidth
+
+    @property
+    def maxval(self):
+        """
+        The maximum value representable by this type.
+        """
+        if self.signed:
+            return (1 << (self.bitwidth - 1)) - 1
+        else:
+            return (1 << self.bitwidth) - 1
+
+    @property
+    def minval(self):
+        """
+        The minimal value representable by this type.
+        """
+        if self.signed:
+            return -(1 << (self.bitwidth - 1))
+        else:
+            return 0
+
+
+class IntegerLiteral(Literal, Integer):
+    def __init__(self, value):
+        self._literal_init(value)
+        name = 'Literal[int]({})'.format(value)
+        basetype = self.literal_type
+        Integer.__init__(
+            self,
+            name=name,
+            bitwidth=basetype.bitwidth,
+            signed=basetype.signed,
+            )
+
+    def can_convert_to(self, typingctx, other):
+        conv = typingctx.can_convert(self.literal_type, other)
+        if conv is not None:
+            return max(conv, Conversion.promote)
+
+
+Literal.ctor_map[int] = IntegerLiteral
+
+
+class BooleanLiteral(Literal, Boolean):
+
+    def __init__(self, value):
+        self._literal_init(value)
+        name = 'Literal[bool]({})'.format(value)
+        Boolean.__init__(
+            self,
+            name=name
+            )
+
+    def can_convert_to(self, typingctx, other):
+        conv = typingctx.can_convert(self.literal_type, other)
+        if conv is not None:
+            return max(conv, Conversion.promote)
+
+
+Literal.ctor_map[bool] = BooleanLiteral
+
+
+@total_ordering
+class Float(Number):
+    def __init__(self, *args, **kws):
+        super(Float, self).__init__(*args, **kws)
+        # Determine bitwidth
+        assert self.name.startswith('float')
+        bitwidth = int(self.name[5:])
+        self.bitwidth = bitwidth
+
+    def cast_python_value(self, value):
+        return getattr(np, self.name)(value)
+
+    def __lt__(self, other):
+        if self.__class__ is not other.__class__:
+            return NotImplemented
+        return self.bitwidth < other.bitwidth
+
+
+@total_ordering
+class Complex(Number):
+    def __init__(self, name, underlying_float, **kwargs):
+        super(Complex, self).__init__(name, **kwargs)
+        self.underlying_float = underlying_float
+        # Determine bitwidth
+        assert self.name.startswith('complex')
+        bitwidth = int(self.name[7:])
+        self.bitwidth = bitwidth
+
+    def cast_python_value(self, value):
+        return getattr(np, self.name)(value)
+
+    def __lt__(self, other):
+        if self.__class__ is not other.__class__:
+            return NotImplemented
+        return self.bitwidth < other.bitwidth
+
+
+class _NPDatetimeBase(Type):
+    """
+    Common base class for np.datetime64 and np.timedelta64.
+    """
+
+    def __init__(self, unit, *args, **kws):
+        name = '%s[%s]' % (self.type_name, unit)
+        self.unit = unit
+        self.unit_code = npdatetime_helpers.DATETIME_UNITS[self.unit]
+        super(_NPDatetimeBase, self).__init__(name, *args, **kws)
+
+    def __lt__(self, other):
+        if self.__class__ is not other.__class__:
+            return NotImplemented
+        # A coarser-grained unit is "smaller", i.e. less precise values
+        # can be represented (but the magnitude of representable values is
+        # also greater...).
+        return self.unit_code < other.unit_code
+
+    def cast_python_value(self, value):
+        cls = getattr(np, self.type_name)
+        if self.unit:
+            return cls(value, self.unit)
+        else:
+            return cls(value)
+
+
+@total_ordering
+class NPTimedelta(_NPDatetimeBase):
+    type_name = 'timedelta64'
+
+@total_ordering
+class NPDatetime(_NPDatetimeBase):
+    type_name = 'datetime64'
+
+
+class EnumClass(Dummy):
+    """
+    Type class for Enum classes.
+    """
+    basename = "Enum class"
+
+    def __init__(self, cls, dtype):
+        assert isinstance(cls, type)
+        assert isinstance(dtype, Type)
+        self.instance_class = cls
+        self.dtype = dtype
+        name = "%s<%s>(%s)" % (self.basename, self.dtype, self.instance_class.__name__)
+        super(EnumClass, self).__init__(name)
+
+    @property
+    def key(self):
+        return self.instance_class, self.dtype
+
+    @cached_property
+    def member_type(self):
+        """
+        The type of this class' members.
+        """
+        return EnumMember(self.instance_class, self.dtype)
+
+
+class IntEnumClass(EnumClass):
+    """
+    Type class for IntEnum classes.
+    """
+    basename = "IntEnum class"
+
+    @cached_property
+    def member_type(self):
+        """
+        The type of this class' members.
+        """
+        return IntEnumMember(self.instance_class, self.dtype)
+
+
+class EnumMember(Type):
+    """
+    Type class for Enum members.
+    """
+    basename = "Enum"
+    class_type_class = EnumClass
+
+    def __init__(self, cls, dtype):
+        assert isinstance(cls, type)
+        assert isinstance(dtype, Type)
+        self.instance_class = cls
+        self.dtype = dtype
+        name = "%s<%s>(%s)" % (self.basename, self.dtype, self.instance_class.__name__)
+        super(EnumMember, self).__init__(name)
+
+    @property
+    def key(self):
+        return self.instance_class, self.dtype
+
+    @property
+    def class_type(self):
+        """
+        The type of this member's class.
+        """
+        return self.class_type_class(self.instance_class, self.dtype)
+
+
+class IntEnumMember(EnumMember):
+    """
+    Type class for IntEnum members.
+    """
+    basename = "IntEnum"
+    class_type_class = IntEnumClass
+
+    def can_convert_to(self, typingctx, other):
+        """
+        Convert IntEnum members to plain integers.
+        """
+        if issubclass(self.instance_class, enum.IntEnum):
+            conv = typingctx.can_convert(self.dtype, other)
+            return max(conv, Conversion.safe)

lib/python3.10/site-packages/numba/core/types/scalars.py

@@ -0,0 +1,12 @@
+import sys
+from numba.core.utils import _RedirectSubpackage
+from numba.core import config
+
+if config.USE_LEGACY_TYPE_SYSTEM: # type: ignore
+    sys.modules[__name__] = _RedirectSubpackage(
+        locals(), "numba.core.types.old_scalars"
+    )
+else:
+    sys.modules[__name__] = _RedirectSubpackage(
+        locals(), "numba.core.types.new_scalars"
+    )

lib/python3.10/site-packages/numba/core/typing/__init__.py

@@ -0,0 +1,3 @@
+from .context import BaseContext, Context
+from .templates import (signature, make_concrete_template, Signature,
+                        fold_arguments)

lib/python3.10/site-packages/numba/core/typing/arraydecl.py

@@ -0,0 +1,880 @@
+import numpy as np
+import operator
+from collections import namedtuple
+
+from numba.core import types, utils
+from numba.core.typing.templates import (AttributeTemplate, AbstractTemplate,
+                                         infer, infer_global, infer_getattr,
+                                         signature, bound_function)
+# import time side effect: array operations requires typing support of sequence
+# defined in collections: e.g. array.shape[i]
+from numba.core.typing import collections
+from numba.core.errors import (TypingError, RequireLiteralValue, NumbaTypeError,
+                               NumbaNotImplementedError, NumbaAssertionError,
+                               NumbaKeyError, NumbaIndexError, NumbaValueError)
+from numba.core.cgutils import is_nonelike
+
+numpy_version = tuple(map(int, np.__version__.split('.')[:2]))
+
+
+Indexing = namedtuple("Indexing", ("index", "result", "advanced"))
+
+
+def get_array_index_type(ary, idx):
+    """
+    Returns None or a tuple-3 for the types of the input array, index, and
+    resulting type of ``array[index]``.
+
+    Note: This is shared logic for ndarray getitem and setitem.
+    """
+    if not isinstance(ary, types.Buffer):
+        return
+
+    ndim = ary.ndim
+
+    left_indices = []
+    right_indices = []
+    ellipsis_met = False
+    advanced = False
+    num_newaxis = 0
+
+    if not isinstance(idx, types.BaseTuple):
+        idx = [idx]
+
+    # Here, a subspace is considered as a contiguous group of advanced indices.
+    # num_subspaces keeps track of the number of such
+    # contiguous groups.
+    in_subspace = False
+    num_subspaces = 0
+    array_indices = 0
+
+    # Walk indices
+    for ty in idx:
+        if ty is types.ellipsis:
+            if ellipsis_met:
+                raise NumbaTypeError(
+                    "Only one ellipsis allowed in array indices "
+                    "(got %s)" % (idx,))
+            ellipsis_met = True
+            in_subspace = False
+        elif isinstance(ty, types.SliceType):
+            # If we encounter a non-advanced index while in a
+            # subspace then that subspace ends.
+            in_subspace = False
+        # In advanced indexing, any index broadcastable to an
+        # array is considered an advanced index. Hence all the
+        # branches below are considered as advanced indices.
+        elif isinstance(ty, types.Integer):
+            # Normalize integer index
+            ty = types.intp if ty.signed else types.uintp
+            # Integer indexing removes the given dimension
+            ndim -= 1
+            # If we're within a subspace/contiguous group of
+            # advanced indices then no action is necessary
+            # since we've already counted that subspace once.
+            if not in_subspace:
+                # If we're not within a subspace and we encounter
+                # this branch then we have a new subspace/group.
+                num_subspaces += 1
+                in_subspace = True
+        elif (isinstance(ty, types.Array) and ty.ndim == 0
+              and isinstance(ty.dtype, types.Integer)):
+            # 0-d array used as integer index
+            ndim -= 1
+            if not in_subspace:
+                num_subspaces += 1
+                in_subspace = True
+        elif (isinstance(ty, types.Array)
+              and isinstance(ty.dtype, (types.Integer, types.Boolean))):
+            if ty.ndim > 1:
+                # Advanced indexing limitation # 1
+                raise NumbaTypeError(
+                    "Multi-dimensional indices are not supported.")
+            array_indices += 1
+            # The condition for activating advanced indexing is simply
+            # having at least one array with size > 1.
+            advanced = True
+            if not in_subspace:
+                num_subspaces += 1
+                in_subspace = True
+        elif (is_nonelike(ty)):
+            ndim += 1
+            num_newaxis += 1
+        else:
+            raise NumbaTypeError("Unsupported array index type %s in %s"
+                                 % (ty, idx))
+        (right_indices if ellipsis_met else left_indices).append(ty)
+
+    if advanced:
+        if array_indices > 1:
+            # Advanced indexing limitation # 2
+            msg = "Using more than one non-scalar array index is unsupported."
+            raise NumbaTypeError(msg)
+
+        if num_subspaces > 1:
+            # Advanced indexing limitation # 3
+            msg = ("Using more than one indexing subspace is unsupported."
+                   " An indexing subspace is a group of one or more"
+                   " consecutive indices comprising integer or array types.")
+            raise NumbaTypeError(msg)
+
+    # Only Numpy arrays support advanced indexing
+    if advanced and not isinstance(ary, types.Array):
+        return
+
+    # Check indices and result dimensionality
+    all_indices = left_indices + right_indices
+    if ellipsis_met:
+        assert right_indices[0] is types.ellipsis
+        del right_indices[0]
+
+    n_indices = len(all_indices) - ellipsis_met - num_newaxis
+    if n_indices > ary.ndim:
+        raise NumbaTypeError("cannot index %s with %d indices: %s"
+                             % (ary, n_indices, idx))
+    if n_indices == ary.ndim and ndim == 0 and not ellipsis_met:
+        # Full integer indexing => scalar result
+        # (note if ellipsis is present, a 0-d view is returned instead)
+        res = ary.dtype
+
+    elif advanced:
+        # Result is a copy
+        res = ary.copy(ndim=ndim, layout='C', readonly=False)
+
+    else:
+        # Result is a view
+        if ary.slice_is_copy:
+            # Avoid view semantics when the original type creates a copy
+            # when slicing.
+            return
+
+        # Infer layout
+        layout = ary.layout
+
+        def keeps_contiguity(ty, is_innermost):
+            # A slice can only keep an array contiguous if it is the
+            # innermost index and it is not strided
+            return (ty is types.ellipsis or isinstance(ty, types.Integer)
+                    or (is_innermost and isinstance(ty, types.SliceType)
+                        and not ty.has_step))
+
+        def check_contiguity(outer_indices):
+            """
+            Whether indexing with the given indices (from outer to inner in
+            physical layout order) can keep an array contiguous.
+            """
+            for ty in outer_indices[:-1]:
+                if not keeps_contiguity(ty, False):
+                    return False
+            if outer_indices and not keeps_contiguity(outer_indices[-1], True):
+                return False
+            return True
+
+        if layout == 'C':
+            # Integer indexing on the left keeps the array C-contiguous
+            if n_indices == ary.ndim:
+                # If all indices are there, ellipsis's place is indifferent
+                left_indices = left_indices + right_indices
+                right_indices = []
+            if right_indices:
+                layout = 'A'
+            elif not check_contiguity(left_indices):
+                layout = 'A'
+        elif layout == 'F':
+            # Integer indexing on the right keeps the array F-contiguous
+            if n_indices == ary.ndim:
+                # If all indices are there, ellipsis's place is indifferent
+                right_indices = left_indices + right_indices
+                left_indices = []
+            if left_indices:
+                layout = 'A'
+            elif not check_contiguity(right_indices[::-1]):
+                layout = 'A'
+
+        if ndim == 0:
+            # Implicitly convert to a scalar if the output ndim==0
+            res = ary.dtype
+        else:
+            res = ary.copy(ndim=ndim, layout=layout)
+
+    # Re-wrap indices
+    if isinstance(idx, types.BaseTuple):
+        idx = types.BaseTuple.from_types(all_indices)
+    else:
+        idx, = all_indices
+
+    return Indexing(idx, res, advanced)
+
+
+@infer_global(operator.getitem)
+class GetItemBuffer(AbstractTemplate):
+    def generic(self, args, kws):
+        assert not kws
+        [ary, idx] = args
+        out = get_array_index_type(ary, idx)
+        if out is not None:
+            return signature(out.result, ary, out.index)
+
+
+@infer_global(operator.setitem)
+class SetItemBuffer(AbstractTemplate):
+    def generic(self, args, kws):
+        assert not kws
+        ary, idx, val = args
+        if not isinstance(ary, types.Buffer):
+            return
+        if not ary.mutable:
+            msg = f"Cannot modify readonly array of type: {ary}"
+            raise NumbaTypeError(msg)
+        out = get_array_index_type(ary, idx)
+        if out is None:
+            return
+
+        idx = out.index
+        res = out.result  # res is the result type of the access ary[idx]
+        if isinstance(res, types.Array):
+            # Indexing produces an array
+            if isinstance(val, types.Array):
+                if not self.context.can_convert(val.dtype, res.dtype):
+                    # DType conversion not possible
+                    return
+                else:
+                    res = val
+            elif isinstance(val, types.Sequence):
+                if (res.ndim == 1 and
+                    self.context.can_convert(val.dtype, res.dtype)):
+                    # Allow assignment of sequence to 1d array
+                    res = val
+                else:
+                    # NOTE: sequence-to-array broadcasting is unsupported
+                    return
+            else:
+                # Allow scalar broadcasting
+                if self.context.can_convert(val, res.dtype):
+                    res = res.dtype
+                else:
+                    # Incompatible scalar type
+                    return
+        elif not isinstance(val, types.Array):
+            # Single item assignment
+            if not self.context.can_convert(val, res):
+                # if the array dtype is not yet defined
+                if not res.is_precise():
+                    # set the array type to use the dtype of value (RHS)
+                    newary = ary.copy(dtype=val)
+                    return signature(types.none, newary, idx, res)
+                else:
+                    return
+            res = val
+        elif (isinstance(val, types.Array) and val.ndim == 0
+              and self.context.can_convert(val.dtype, res)):
+            # val is an array(T, 0d, O), where T is the type of res, O is order
+            res = val
+        else:
+            return
+        return signature(types.none, ary, idx, res)
+
+
+def normalize_shape(shape):
+    if isinstance(shape, types.UniTuple):
+        if isinstance(shape.dtype, types.Integer):
+            dimtype = types.intp if shape.dtype.signed else types.uintp
+            return types.UniTuple(dimtype, len(shape))
+
+    elif isinstance(shape, types.Tuple) and shape.count == 0:
+        # Force (0 x intp) for consistency with other shapes
+        return types.UniTuple(types.intp, 0)
+
+
+@infer_getattr
+class ArrayAttribute(AttributeTemplate):
+    key = types.Array
+
+    def resolve_dtype(self, ary):
+        return types.DType(ary.dtype)
+
+    def resolve_nbytes(self, ary):
+        return types.intp
+
+    def resolve_itemsize(self, ary):
+        return types.intp
+
+    def resolve_shape(self, ary):
+        return types.UniTuple(types.intp, ary.ndim)
+
+    def resolve_strides(self, ary):
+        return types.UniTuple(types.intp, ary.ndim)
+
+    def resolve_ndim(self, ary):
+        return types.intp
+
+    def resolve_size(self, ary):
+        return types.intp
+
+    def resolve_flat(self, ary):
+        return types.NumpyFlatType(ary)
+
+    def resolve_ctypes(self, ary):
+        return types.ArrayCTypes(ary)
+
+    def resolve_flags(self, ary):
+        return types.ArrayFlags(ary)
+
+    def resolve_T(self, ary):
+        if ary.ndim <= 1:
+            retty = ary
+        else:
+            layout = {"C": "F", "F": "C"}.get(ary.layout, "A")
+            retty = ary.copy(layout=layout)
+        return retty
+
+    def resolve_real(self, ary):
+        return self._resolve_real_imag(ary, attr='real')
+
+    def resolve_imag(self, ary):
+        return self._resolve_real_imag(ary, attr='imag')
+
+    def _resolve_real_imag(self, ary, attr):
+        if ary.dtype in types.complex_domain:
+            return ary.copy(dtype=ary.dtype.underlying_float, layout='A')
+        elif ary.dtype in types.number_domain:
+            res = ary.copy(dtype=ary.dtype)
+            if attr == 'imag':
+                res = res.copy(readonly=True)
+            return res
+        else:
+            msg = "cannot access .{} of array of {}"
+            raise TypingError(msg.format(attr, ary.dtype))
+
+    @bound_function("array.transpose")
+    def resolve_transpose(self, ary, args, kws):
+        def sentry_shape_scalar(ty):
+            if ty in types.number_domain:
+                # Guard against non integer type
+                if not isinstance(ty, types.Integer):
+                    msg = "transpose() arg cannot be {0}".format(ty)
+                    raise TypingError(msg)
+                return True
+            else:
+                return False
+
+        assert not kws
+        if len(args) == 0:
+            return signature(self.resolve_T(ary))
+
+        if len(args) == 1:
+            shape, = args
+
+            if sentry_shape_scalar(shape):
+                assert ary.ndim == 1
+                return signature(ary, *args)
+
+            if isinstance(shape, types.NoneType):
+                return signature(self.resolve_T(ary))
+
+            shape = normalize_shape(shape)
+            if shape is None:
+                return
+
+            assert ary.ndim == shape.count
+            return signature(self.resolve_T(ary).copy(layout="A"), shape)
+
+        else:
+            if any(not sentry_shape_scalar(a) for a in args):
+                msg = "transpose({0}) is not supported".format(
+                    ', '.join(args))
+                raise TypingError(msg)
+            assert ary.ndim == len(args)
+            return signature(self.resolve_T(ary).copy(layout="A"), *args)
+
+    @bound_function("array.copy")
+    def resolve_copy(self, ary, args, kws):
+        assert not args
+        assert not kws
+        retty = ary.copy(layout="C", readonly=False)
+        return signature(retty)
+
+    @bound_function("array.item")
+    def resolve_item(self, ary, args, kws):
+        assert not kws
+        # We don't support explicit arguments as that's exactly equivalent
+        # to regular indexing.  The no-argument form is interesting to
+        # allow some degree of genericity when writing functions.
+        if not args:
+            return signature(ary.dtype)
+
+    if numpy_version < (2, 0):
+        @bound_function("array.itemset")
+        def resolve_itemset(self, ary, args, kws):
+            assert not kws
+            # We don't support explicit arguments as that's exactly equivalent
+            # to regular indexing.  The no-argument form is interesting to
+            # allow some degree of genericity when writing functions.
+            if len(args) == 1:
+                return signature(types.none, ary.dtype)
+
+    @bound_function("array.nonzero")
+    def resolve_nonzero(self, ary, args, kws):
+        assert not args
+        assert not kws
+        if ary.ndim == 0 and numpy_version >= (2, 1):
+            raise NumbaValueError(
+                "Calling nonzero on 0d arrays is not allowed."
+                " Use np.atleast_1d(scalar).nonzero() instead."
+            )
+        # 0-dim arrays return one result array
+        ndim = max(ary.ndim, 1)
+        retty = types.UniTuple(types.Array(types.intp, 1, 'C'), ndim)
+        return signature(retty)
+
+    @bound_function("array.reshape")
+    def resolve_reshape(self, ary, args, kws):
+        def sentry_shape_scalar(ty):
+            if ty in types.number_domain:
+                # Guard against non integer type
+                if not isinstance(ty, types.Integer):
+                    raise TypingError("reshape() arg cannot be {0}".format(ty))
+                return True
+            else:
+                return False
+
+        assert not kws
+        if ary.layout not in 'CF':
+            # only work for contiguous array
+            raise TypingError("reshape() supports contiguous array only")
+
+        if len(args) == 1:
+            # single arg
+            shape, = args
+
+            if sentry_shape_scalar(shape):
+                ndim = 1
+            else:
+                shape = normalize_shape(shape)
+                if shape is None:
+                    return
+                ndim = shape.count
+            retty = ary.copy(ndim=ndim)
+            return signature(retty, shape)
+
+        elif len(args) == 0:
+            # no arg
+            raise TypingError("reshape() take at least one arg")
+
+        else:
+            # vararg case
+            if any(not sentry_shape_scalar(a) for a in args):
+                raise TypingError("reshape({0}) is not supported".format(
+                    ', '.join(map(str, args))))
+
+            retty = ary.copy(ndim=len(args))
+            return signature(retty, *args)
+
+    @bound_function("array.sort")
+    def resolve_sort(self, ary, args, kws):
+        assert not args
+        assert not kws
+        return signature(types.none)
+
+    @bound_function("array.argsort")
+    def resolve_argsort(self, ary, args, kws):
+        assert not args
+        kwargs = dict(kws)
+        kind = kwargs.pop('kind', types.StringLiteral('quicksort'))
+        if not isinstance(kind, types.StringLiteral):
+            raise TypingError('"kind" must be a string literal')
+        if kwargs:
+            msg = "Unsupported keywords: {!r}"
+            raise TypingError(msg.format([k for k in kwargs.keys()]))
+        if ary.ndim == 1:
+            def argsort_stub(kind='quicksort'):
+                pass
+            pysig = utils.pysignature(argsort_stub)
+            sig = signature(types.Array(types.intp, 1, 'C'), kind).replace(pysig=pysig)
+            return sig
+
+    @bound_function("array.view")
+    def resolve_view(self, ary, args, kws):
+        from .npydecl import parse_dtype
+        assert not kws
+        dtype, = args
+        dtype = parse_dtype(dtype)
+        if dtype is None:
+            return
+        retty = ary.copy(dtype=dtype)
+        return signature(retty, *args)
+
+    @bound_function("array.astype")
+    def resolve_astype(self, ary, args, kws):
+        from .npydecl import parse_dtype
+        assert not kws
+        dtype, = args
+        if isinstance(dtype, types.UnicodeType):
+            raise RequireLiteralValue(("array.astype if dtype is a string it "
+                                       "must be constant"))
+        dtype = parse_dtype(dtype)
+        if dtype is None:
+            return
+        if not self.context.can_convert(ary.dtype, dtype):
+            raise TypingError("astype(%s) not supported on %s: "
+                              "cannot convert from %s to %s"
+                              % (dtype, ary, ary.dtype, dtype))
+        layout = ary.layout if ary.layout in 'CF' else 'C'
+        # reset the write bit irrespective of whether the cast type is the same
+        # as the current dtype, this replicates numpy
+        retty = ary.copy(dtype=dtype, layout=layout, readonly=False)
+        return signature(retty, *args)
+
+    @bound_function("array.ravel")
+    def resolve_ravel(self, ary, args, kws):
+        # Only support no argument version (default order='C')
+        assert not kws
+        assert not args
+        copy_will_be_made = ary.layout != 'C'
+        readonly = not (copy_will_be_made or ary.mutable)
+        return signature(ary.copy(ndim=1, layout='C', readonly=readonly))
+
+    @bound_function("array.flatten")
+    def resolve_flatten(self, ary, args, kws):
+        # Only support no argument version (default order='C')
+        assert not kws
+        assert not args
+        # To ensure that Numba behaves exactly like NumPy,
+        # we also clear the read-only flag when doing a "flatten"
+        # Why? Two reasons:
+        # Because flatten always returns a copy. (see NumPy docs for "flatten")
+        # And because a copy always returns a writeable array.
+        # ref: https://numpy.org/doc/stable/reference/generated/numpy.copy.html
+        return signature(ary.copy(ndim=1, layout='C', readonly=False))
+
+    def generic_resolve(self, ary, attr):
+        # Resolution of other attributes, for record arrays
+        if isinstance(ary.dtype, types.Record):
+            if attr in ary.dtype.fields:
+                attr_dtype = ary.dtype.typeof(attr)
+                if isinstance(attr_dtype, types.NestedArray):
+                    return ary.copy(
+                        dtype=attr_dtype.dtype,
+                        ndim=ary.ndim + attr_dtype.ndim,
+                        layout='A'
+                    )
+                else:
+                    return ary.copy(dtype=attr_dtype, layout='A')
+
+
+@infer_getattr
+class DTypeAttr(AttributeTemplate):
+    key = types.DType
+
+    def resolve_type(self, ary):
+        # Wrap the numeric type in NumberClass
+        return types.NumberClass(ary.dtype)
+
+    def resolve_kind(self, ary):
+        if isinstance(ary.key, types.scalars.Float):
+            val = 'f'
+        elif isinstance(ary.key, types.scalars.Integer):
+            val = 'i'
+        else:
+            return None  # other types not supported yet
+        return types.StringLiteral(val)
+
+
+@infer
+class StaticGetItemArray(AbstractTemplate):
+    key = "static_getitem"
+
+    def generic(self, args, kws):
+        # Resolution of members for record and structured arrays
+        ary, idx = args
+        if (isinstance(ary, types.Array) and isinstance(idx, str) and
+                isinstance(ary.dtype, types.Record)):
+            if idx in ary.dtype.fields:
+                attr_dtype = ary.dtype.typeof(idx)
+                if isinstance(attr_dtype, types.NestedArray):
+                    ret = ary.copy(
+                        dtype=attr_dtype.dtype,
+                        ndim=ary.ndim + attr_dtype.ndim,
+                        layout='A'
+                    )
+                    return signature(ret, *args)
+                else:
+                    ret = ary.copy(dtype=attr_dtype, layout='A')
+                    return signature(ret, *args)
+
+
+@infer_getattr
+class RecordAttribute(AttributeTemplate):
+    key = types.Record
+
+    def generic_resolve(self, record, attr):
+        ret = record.typeof(attr)
+        assert ret
+        return ret
+
+
+@infer
+class StaticGetItemRecord(AbstractTemplate):
+    key = "static_getitem"
+
+    def generic(self, args, kws):
+        # Resolution of members for records
+        record, idx = args
+        if isinstance(record, types.Record) and isinstance(idx, str):
+            if idx not in record.fields:
+                raise NumbaKeyError(f"Field '{idx}' was not found in record "
+                                    "with fields "
+                                    f"{tuple(record.fields.keys())}")
+            ret = record.typeof(idx)
+            assert ret
+            return signature(ret, *args)
+
+
+@infer_global(operator.getitem)
+class StaticGetItemLiteralRecord(AbstractTemplate):
+    def generic(self, args, kws):
+        # Resolution of members for records
+        record, idx = args
+        if isinstance(record, types.Record):
+            if isinstance(idx, types.StringLiteral):
+                if idx.literal_value not in record.fields:
+                    msg = (f"Field '{idx.literal_value}' was not found in "
+                           f"record with fields {tuple(record.fields.keys())}")
+                    raise NumbaKeyError(msg)
+                ret = record.typeof(idx.literal_value)
+                assert ret
+                return signature(ret, *args)
+            elif isinstance(idx, types.IntegerLiteral):
+                if idx.literal_value >= len(record.fields):
+                    msg = f"Requested index {idx.literal_value} is out of range"
+                    raise NumbaIndexError(msg)
+                field_names = list(record.fields)
+                ret = record.typeof(field_names[idx.literal_value])
+                assert ret
+                return signature(ret, *args)
+
+
+@infer
+class StaticSetItemRecord(AbstractTemplate):
+    key = "static_setitem"
+
+    def generic(self, args, kws):
+        # Resolution of members for record and structured arrays
+        record, idx, value = args
+        if isinstance(record, types.Record):
+            if isinstance(idx, str):
+                expectedty = record.typeof(idx)
+                if self.context.can_convert(value, expectedty) is not None:
+                    return signature(types.void, record, types.literal(idx),
+                                     value)
+            elif isinstance(idx, int):
+                if idx >= len(record.fields):
+                    msg = f"Requested index {idx} is out of range"
+                    raise NumbaIndexError(msg)
+                str_field = list(record.fields)[idx]
+                expectedty = record.typeof(str_field)
+                if self.context.can_convert(value, expectedty) is not None:
+                    return signature(types.void, record, types.literal(idx),
+                                     value)
+
+
+@infer_global(operator.setitem)
+class StaticSetItemLiteralRecord(AbstractTemplate):
+    def generic(self, args, kws):
+        # Resolution of members for records
+        target, idx, value = args
+        if isinstance(target, types.Record) and isinstance(idx, types.StringLiteral):
+            if idx.literal_value not in target.fields:
+                msg = (f"Field '{idx.literal_value}' was not found in record "
+                       f"with fields {tuple(target.fields.keys())}")
+                raise NumbaKeyError(msg)
+            expectedty = target.typeof(idx.literal_value)
+            if self.context.can_convert(value, expectedty) is not None:
+                return signature(types.void, target, idx, value)
+
+
+@infer_getattr
+class ArrayCTypesAttribute(AttributeTemplate):
+    key = types.ArrayCTypes
+
+    def resolve_data(self, ctinfo):
+        return types.uintp
+
+
+@infer_getattr
+class ArrayFlagsAttribute(AttributeTemplate):
+    key = types.ArrayFlags
+
+    def resolve_contiguous(self, ctflags):
+        return types.boolean
+
+    def resolve_c_contiguous(self, ctflags):
+        return types.boolean
+
+    def resolve_f_contiguous(self, ctflags):
+        return types.boolean
+
+
+@infer_getattr
+class NestedArrayAttribute(ArrayAttribute):
+    key = types.NestedArray
+
+
+def _expand_integer(ty):
+    """
+    If *ty* is an integer, expand it to a machine int (like Numpy).
+    """
+    if isinstance(ty, types.Integer):
+        if ty.signed:
+            return max(types.intp, ty)
+        else:
+            return max(types.uintp, ty)
+    elif isinstance(ty, types.Boolean):
+        return types.intp
+    else:
+        return ty
+
+
+def generic_homog(self, args, kws):
+    if args:
+        raise NumbaAssertionError("args not supported")
+    if kws:
+        raise NumbaAssertionError("kws not supported")
+
+    return signature(self.this.dtype, recvr=self.this)
+
+
+def generic_expand(self, args, kws):
+    assert not args
+    assert not kws
+    return signature(_expand_integer(self.this.dtype), recvr=self.this)
+
+
+def sum_expand(self, args, kws):
+    """
+    sum can be called with or without an axis parameter, and with or without
+    a dtype parameter
+    """
+    pysig = None
+    if 'axis' in kws and 'dtype' not in kws:
+        def sum_stub(axis):
+            pass
+        pysig = utils.pysignature(sum_stub)
+        # rewrite args
+        args = list(args) + [kws['axis']]
+    elif 'dtype' in kws and 'axis' not in kws:
+        def sum_stub(dtype):
+            pass
+        pysig = utils.pysignature(sum_stub)
+        # rewrite args
+        args = list(args) + [kws['dtype']]
+    elif 'dtype' in kws and 'axis' in kws:
+        def sum_stub(axis, dtype):
+            pass
+        pysig = utils.pysignature(sum_stub)
+        # rewrite args
+        args = list(args) + [kws['axis'], kws['dtype']]
+
+    args_len = len(args)
+    assert args_len <= 2
+    if args_len == 0:
+        # No axis or dtype parameter so the return type of the summation is a scalar
+        # of the type of the array.
+        out = signature(_expand_integer(self.this.dtype), *args,
+                        recvr=self.this)
+    elif args_len == 1 and 'dtype' not in kws:
+        # There is an axis parameter, either arg or kwarg
+        if self.this.ndim == 1:
+            # 1d reduces to a scalar
+            return_type = _expand_integer(self.this.dtype)
+        else:
+            # the return type of this summation is  an array of dimension one
+            # less than the input array.
+            return_type = types.Array(dtype=_expand_integer(self.this.dtype),
+                                    ndim=self.this.ndim-1, layout='C')
+        out = signature(return_type, *args, recvr=self.this)
+
+    elif args_len == 1 and 'dtype' in kws:
+        # No axis parameter so the return type of the summation is a scalar
+        # of the dtype parameter.
+        from .npydecl import parse_dtype
+        dtype, = args
+        dtype = parse_dtype(dtype)
+        out = signature(dtype, *args, recvr=self.this)
+
+    elif args_len == 2:
+        # There is an axis and dtype parameter, either arg or kwarg
+        from .npydecl import parse_dtype
+        dtype = parse_dtype(args[1])
+        return_type = dtype
+        if self.this.ndim != 1:
+            # 1d reduces to a scalar, 2d and above reduce dim by 1
+            # the return type of this summation is  an array of dimension one
+            # less than the input array.
+            return_type = types.Array(dtype=return_type,
+                                    ndim=self.this.ndim-1, layout='C')
+        out = signature(return_type, *args, recvr=self.this)
+    else:
+        pass
+    return out.replace(pysig=pysig)
+
+
+def generic_expand_cumulative(self, args, kws):
+    if args:
+        raise NumbaAssertionError("args unsupported")
+    if kws:
+        raise NumbaAssertionError("kwargs unsupported")
+    assert isinstance(self.this, types.Array)
+    return_type = types.Array(dtype=_expand_integer(self.this.dtype),
+                              ndim=1, layout='C')
+    return signature(return_type, recvr=self.this)
+
+
+def generic_hetero_real(self, args, kws):
+    assert not args
+    assert not kws
+    if isinstance(self.this.dtype, (types.Integer, types.Boolean)):
+        return signature(types.float64, recvr=self.this)
+    return signature(self.this.dtype, recvr=self.this)
+
+
+def generic_hetero_always_real(self, args, kws):
+    assert not args
+    assert not kws
+    if isinstance(self.this.dtype, (types.Integer, types.Boolean)):
+        return signature(types.float64, recvr=self.this)
+    if isinstance(self.this.dtype, types.Complex):
+        return signature(self.this.dtype.underlying_float, recvr=self.this)
+    return signature(self.this.dtype, recvr=self.this)
+
+
+def generic_index(self, args, kws):
+    assert not args
+    assert not kws
+    return signature(types.intp, recvr=self.this)
+
+
+def install_array_method(name, generic, prefer_literal=True):
+    my_attr = {"key": "array." + name, "generic": generic,
+               "prefer_literal": prefer_literal}
+    temp_class = type("Array_" + name, (AbstractTemplate,), my_attr)
+
+    def array_attribute_attachment(self, ary):
+        return types.BoundFunction(temp_class, ary)
+
+    setattr(ArrayAttribute, "resolve_" + name, array_attribute_attachment)
+
+
+# Functions that return a machine-width type, to avoid overflows
+install_array_method("sum", sum_expand, prefer_literal=True)
+
+
+@infer_global(operator.eq)
+class CmpOpEqArray(AbstractTemplate):
+    #key = operator.eq
+
+    def generic(self, args, kws):
+        assert not kws
+        [va, vb] = args
+        if isinstance(va, types.Array) and va == vb:
+            return signature(va.copy(dtype=types.boolean), va, vb)

lib/python3.10/site-packages/numba/core/typing/bufproto.py

@@ -0,0 +1,79 @@
+"""
+Typing support for the buffer protocol (PEP 3118).
+"""
+
+import array
+
+from numba.core import types, config
+from numba.core.errors import NumbaValueError
+
+
+_pep3118_int_types = set('bBhHiIlLqQnN')
+
+if config.USE_LEGACY_TYPE_SYSTEM: # Old type system
+    _pep3118_scalar_map = {
+        'f': types.float32,
+        'd': types.float64,
+        'Zf': types.complex64,
+        'Zd': types.complex128,
+        }
+else: # New type system
+    _pep3118_scalar_map = {
+        # TODO: FIXME We need to modify the following Map to use Python Types.
+        # However currently here's nothing in Python types that maps
+        # to a float32 or a complex64
+        # 'f': types.np_float32,
+        'd': types.py_float, # 64-bit float
+        # 'Zf': types.np_complex64,
+        'Zd': types.py_complex, # 128-bit complex
+        }
+
+_type_map = {
+    bytearray: types.ByteArray,
+    array.array: types.PyArray,
+    }
+
+_type_map[memoryview] = types.MemoryView
+_type_map[bytes] = types.Bytes
+
+
+def decode_pep3118_format(fmt, itemsize):
+    """
+    Return the Numba type for an item with format string *fmt* and size
+    *itemsize* (in bytes).
+    """
+    # XXX reuse _dtype_from_pep3118() from np.core._internal?
+    if fmt in _pep3118_int_types:
+        # Determine int width and signedness
+        name = 'int%d' % (itemsize * 8,)
+        if fmt.isupper():
+            name = 'u' + name
+        return types.Integer(name)
+    try:
+        # For the hard-coded types above, consider "=" the same as "@"
+        # (the default).  This is because Numpy sometimes adds "="
+        # in front of the PEP 3118 format string.
+        return _pep3118_scalar_map[fmt.lstrip('=')]
+    except KeyError:
+        raise NumbaValueError("unsupported PEP 3118 format %r" % (fmt,))
+
+
+def get_type_class(typ):
+    """
+    Get the Numba type class for buffer-compatible Python *typ*.
+    """
+    try:
+        # Look up special case.
+        return _type_map[typ]
+    except KeyError:
+        # Fall back on generic one.
+        return types.Buffer
+
+
+def infer_layout(val):
+    """
+    Infer layout of the given memoryview *val*.
+    """
+    return ('C' if val.c_contiguous else
+            'F' if val.f_contiguous else
+            'A')

lib/python3.10/site-packages/numba/core/typing/context.py

@@ -0,0 +1,741 @@
+from collections import defaultdict
+from collections.abc import Sequence
+import types as pytypes
+import weakref
+import threading
+import contextlib
+import operator
+
+from numba.core import types, errors
+from numba.core.typeconv import Conversion, rules
+from numba.core.typing import templates
+from numba.core.utils import order_by_target_specificity
+from .typeof import typeof, Purpose
+
+from numba.core import utils
+
+
+class Rating(object):
+    __slots__ = 'promote', 'safe_convert', "unsafe_convert"
+
+    def __init__(self):
+        self.promote = 0
+        self.safe_convert = 0
+        self.unsafe_convert = 0
+
+    def astuple(self):
+        """Returns a tuple suitable for comparing with the worse situation
+        start first.
+        """
+        return (self.unsafe_convert, self.safe_convert, self.promote)
+
+    def __add__(self, other):
+        if type(self) is not type(other):
+            return NotImplemented
+        rsum = Rating()
+        rsum.promote = self.promote + other.promote
+        rsum.safe_convert = self.safe_convert + other.safe_convert
+        rsum.unsafe_convert = self.unsafe_convert + other.unsafe_convert
+        return rsum
+
+
+class CallStack(Sequence):
+    """
+    A compile-time call stack
+    """
+
+    def __init__(self):
+        self._stack = []
+        self._lock = threading.RLock()
+
+    def __getitem__(self, index):
+        """
+        Returns item in the stack where index=0 is the top and index=1 is
+        the second item from the top.
+        """
+        return self._stack[len(self) - index - 1]
+
+    def __len__(self):
+        return len(self._stack)
+
+    @contextlib.contextmanager
+    def register(self, target, typeinfer, func_id, args):
+        # guard compiling the same function with the same signature
+        if self.match(func_id.func, args):
+            msg = "compiler re-entrant to the same function signature"
+            raise errors.NumbaRuntimeError(msg)
+        self._lock.acquire()
+        self._stack.append(CallFrame(target, typeinfer, func_id, args))
+        try:
+            yield
+        finally:
+            self._stack.pop()
+            self._lock.release()
+
+    def finditer(self, py_func):
+        """
+        Yields frame that matches the function object starting from the top
+        of stack.
+        """
+        for frame in self:
+            if frame.func_id.func is py_func:
+                yield frame
+
+    def findfirst(self, py_func):
+        """
+        Returns the first result from `.finditer(py_func)`; or None if no match.
+        """
+        try:
+            return next(self.finditer(py_func))
+        except StopIteration:
+            return
+
+    def match(self, py_func, args):
+        """
+        Returns first function that matches *py_func* and the arguments types in
+        *args*; or, None if no match.
+        """
+        for frame in self.finditer(py_func):
+            if frame.args == args:
+                return frame
+
+
+class CallFrame(object):
+    """
+    A compile-time call frame
+    """
+    def __init__(self, target, typeinfer, func_id, args):
+        self.typeinfer = typeinfer
+        self.func_id = func_id
+        self.args = args
+        self.target = target
+        self._inferred_retty = set()
+
+    def __repr__(self):
+        return "CallFrame({}, {})".format(self.func_id, self.args)
+
+    def add_return_type(self, return_type):
+        """Add *return_type* to the list of inferred return-types.
+        If there are too many, raise `TypingError`.
+        """
+        # The maximum limit is picked arbitrarily.
+        # Don't think that this needs to be user configurable.
+        RETTY_LIMIT = 16
+        self._inferred_retty.add(return_type)
+        if len(self._inferred_retty) >= RETTY_LIMIT:
+            m = "Return type of recursive function does not converge"
+            raise errors.TypingError(m)
+
+
+class BaseContext(object):
+    """A typing context for storing function typing constrain template.
+    """
+
+    def __init__(self):
+        # A list of installed registries
+        self._registries = {}
+        # Typing declarations extracted from the registries or other sources
+        self._functions = defaultdict(list)
+        self._attributes = defaultdict(list)
+        self._globals = utils.UniqueDict()
+        self.tm = rules.default_type_manager
+        self.callstack = CallStack()
+
+        # Initialize
+        self.init()
+
+    def init(self):
+        """
+        Initialize the typing context.  Can be overridden by subclasses.
+        """
+
+    def refresh(self):
+        """
+        Refresh context with new declarations from known registries.
+        Useful for third-party extensions.
+        """
+        self.load_additional_registries()
+        # Some extensions may have augmented the builtin registry
+        self._load_builtins()
+
+    def explain_function_type(self, func):
+        """
+        Returns a string description of the type of a function
+        """
+        desc = []
+        defns = []
+        param = False
+        if isinstance(func, types.Callable):
+            sigs, param = func.get_call_signatures()
+            defns.extend(sigs)
+
+        elif func in self._functions:
+            for tpl in self._functions[func]:
+                param = param or hasattr(tpl, 'generic')
+                defns.extend(getattr(tpl, 'cases', []))
+
+        else:
+            msg = "No type info available for {func!r} as a callable."
+            desc.append(msg.format(func=func))
+
+        if defns:
+            desc = ['Known signatures:']
+            for sig in defns:
+                desc.append(' * {0}'.format(sig))
+
+        return '\n'.join(desc)
+
+    def resolve_function_type(self, func, args, kws):
+        """
+        Resolve function type *func* for argument types *args* and *kws*.
+        A signature is returned.
+        """
+        # Prefer user definition first
+        try:
+            res = self._resolve_user_function_type(func, args, kws)
+        except errors.TypingError as e:
+            # Capture any typing error
+            last_exception = e
+            res = None
+        else:
+            last_exception = None
+
+        # Return early we know there's a working user function
+        if res is not None:
+            return res
+
+        # Check builtin functions
+        res = self._resolve_builtin_function_type(func, args, kws)
+
+        # Re-raise last_exception if no function type has been found
+        if res is None and last_exception is not None:
+            raise last_exception
+
+        return res
+
+    def _resolve_builtin_function_type(self, func, args, kws):
+        # NOTE: we should reduce usage of this
+        if func in self._functions:
+            # Note: Duplicating code with types.Function.get_call_type().
+            #       *defns* are CallTemplates.
+            defns = self._functions[func]
+            for defn in defns:
+                for support_literals in [True, False]:
+                    if support_literals:
+                        res = defn.apply(args, kws)
+                    else:
+                        fixedargs = [types.unliteral(a) for a in args]
+                        res = defn.apply(fixedargs, kws)
+                    if res is not None:
+                        return res
+
+    def _resolve_user_function_type(self, func, args, kws, literals=None):
+        # It's not a known function type, perhaps it's a global?
+        functy = self._lookup_global(func)
+        if functy is not None:
+            func = functy
+
+        if isinstance(func, types.Type):
+            # If it's a type, it may support a __call__ method
+            func_type = self.resolve_getattr(func, "__call__")
+            if func_type is not None:
+                # The function has a __call__ method, type its call.
+                return self.resolve_function_type(func_type, args, kws)
+
+        if isinstance(func, types.Callable):
+            # XXX fold this into the __call__ attribute logic?
+            return func.get_call_type(self, args, kws)
+
+    def _get_attribute_templates(self, typ):
+        """
+        Get matching AttributeTemplates for the Numba type.
+        """
+        if typ in self._attributes:
+            for attrinfo in self._attributes[typ]:
+                yield attrinfo
+        else:
+            for cls in type(typ).__mro__:
+                if cls in self._attributes:
+                    for attrinfo in self._attributes[cls]:
+                        yield attrinfo
+
+    def resolve_getattr(self, typ, attr):
+        """
+        Resolve getting the attribute *attr* (a string) on the Numba type.
+        The attribute's type is returned, or None if resolution failed.
+        """
+        def core(typ):
+            out = self.find_matching_getattr_template(typ, attr)
+            if out:
+                return out['return_type']
+
+        out = core(typ)
+        if out is not None:
+            return out
+
+        # Try again without literals
+        out = core(types.unliteral(typ))
+        if out is not None:
+            return out
+
+        if isinstance(typ, types.Module):
+            attrty = self.resolve_module_constants(typ, attr)
+            if attrty is not None:
+                return attrty
+
+    def find_matching_getattr_template(self, typ, attr):
+
+        templates = list(self._get_attribute_templates(typ))
+
+        # get the order in which to try templates
+        from numba.core.target_extension import get_local_target # circular
+        target_hw = get_local_target(self)
+        order = order_by_target_specificity(target_hw, templates, fnkey=attr)
+
+        for template in order:
+            return_type = template.resolve(typ, attr)
+            if return_type is not None:
+                return {
+                    'template': template,
+                    'return_type': return_type,
+                }
+
+    def resolve_setattr(self, target, attr, value):
+        """
+        Resolve setting the attribute *attr* (a string) on the *target* type
+        to the given *value* type.
+        A function signature is returned, or None if resolution failed.
+        """
+        for attrinfo in self._get_attribute_templates(target):
+            expectedty = attrinfo.resolve(target, attr)
+            # NOTE: convertibility from *value* to *expectedty* is left to
+            # the caller.
+            if expectedty is not None:
+                return templates.signature(types.void, target, expectedty)
+
+    def resolve_static_getitem(self, value, index):
+        assert not isinstance(index, types.Type), index
+        args = value, index
+        kws = ()
+        return self.resolve_function_type("static_getitem", args, kws)
+
+    def resolve_static_setitem(self, target, index, value):
+        assert not isinstance(index, types.Type), index
+        args = target, index, value
+        kws = {}
+        return self.resolve_function_type("static_setitem", args, kws)
+
+    def resolve_setitem(self, target, index, value):
+        assert isinstance(index, types.Type), index
+        fnty = self.resolve_value_type(operator.setitem)
+        sig = fnty.get_call_type(self, (target, index, value), {})
+        return sig
+
+    def resolve_delitem(self, target, index):
+        args = target, index
+        kws = {}
+        fnty = self.resolve_value_type(operator.delitem)
+        sig = fnty.get_call_type(self, args, kws)
+        return sig
+
+    def resolve_module_constants(self, typ, attr):
+        """
+        Resolve module-level global constants.
+        Return None or the attribute type
+        """
+        assert isinstance(typ, types.Module)
+        attrval = getattr(typ.pymod, attr)
+        try:
+            return self.resolve_value_type(attrval)
+        except ValueError:
+            pass
+
+    def resolve_value_type(self, val):
+        """
+        Return the numba type of a Python value that is being used
+        as a runtime constant.
+        ValueError is raised for unsupported types.
+        """
+        try:
+            ty = typeof(val, Purpose.constant)
+        except ValueError as e:
+            # Make sure the exception doesn't hold a reference to the user
+            # value.
+            typeof_exc = utils.erase_traceback(e)
+        else:
+            return ty
+
+        if isinstance(val, types.ExternalFunction):
+            return val
+
+        # Try to look up target specific typing information
+        ty = self._get_global_type(val)
+        if ty is not None:
+            return ty
+
+        raise typeof_exc
+
+    def resolve_value_type_prefer_literal(self, value):
+        """Resolve value type and prefer Literal types whenever possible.
+        """
+        lit = types.maybe_literal(value)
+        if lit is None:
+            return self.resolve_value_type(value)
+        else:
+            return lit
+
+    def _get_global_type(self, gv):
+        ty = self._lookup_global(gv)
+        if ty is not None:
+            return ty
+        if isinstance(gv, pytypes.ModuleType):
+            return types.Module(gv)
+
+    def _load_builtins(self):
+        # Initialize declarations
+        from numba.core.typing import builtins, arraydecl, npdatetime  # noqa: F401, E501
+        from numba.core.typing import ctypes_utils, bufproto           # noqa: F401, E501
+        from numba.core.unsafe import eh                    # noqa: F401
+
+        self.install_registry(templates.builtin_registry)
+
+    def load_additional_registries(self):
+        """
+        Load target-specific registries.  Can be overridden by subclasses.
+        """
+
+    def install_registry(self, registry):
+        """
+        Install a *registry* (a templates.Registry instance) of function,
+        attribute and global declarations.
+        """
+        try:
+            loader = self._registries[registry]
+        except KeyError:
+            loader = templates.RegistryLoader(registry)
+            self._registries[registry] = loader
+
+        from numba.core.target_extension import (get_local_target,
+                                                 resolve_target_str)
+        current_target = get_local_target(self)
+
+        def is_for_this_target(ftcls):
+            metadata = getattr(ftcls, 'metadata', None)
+            if metadata is None:
+                return True
+
+            target_str = metadata.get('target')
+            if target_str is None:
+                return True
+
+            # There may be pending registrations for nonexistent targets.
+            # Ideally it would be impossible to leave a registration pending
+            # for an invalid target, but in practice this is exceedingly
+            # difficult to guard against - many things are registered at import
+            # time, and eagerly reporting an error when registering for invalid
+            # targets would require that all target registration code is
+            # executed prior to all typing registrations during the import
+            # process; attempting to enforce this would impose constraints on
+            # execution order during import that would be very difficult to
+            # resolve and maintain in the presence of typical code maintenance.
+            # Furthermore, these constraints would be imposed not only on
+            # Numba internals, but also on its dependents.
+            #
+            # Instead of that enforcement, we simply catch any occurrences of
+            # registrations for targets that don't exist, and report that
+            # they're not for this target. They will then not be encountered
+            # again during future typing context refreshes (because the
+            # loader's new registrations are a stream_list that doesn't yield
+            # previously-yielded items).
+            try:
+                ft_target = resolve_target_str(target_str)
+            except errors.NonexistentTargetError:
+                return False
+
+            return current_target.inherits_from(ft_target)
+
+        for ftcls in loader.new_registrations('functions'):
+            if not is_for_this_target(ftcls):
+                continue
+            self.insert_function(ftcls(self))
+        for ftcls in loader.new_registrations('attributes'):
+            if not is_for_this_target(ftcls):
+                continue
+            self.insert_attributes(ftcls(self))
+        for gv, gty in loader.new_registrations('globals'):
+            existing = self._lookup_global(gv)
+            if existing is None:
+                self.insert_global(gv, gty)
+            else:
+                # A type was already inserted, see if we can add to it
+                newty = existing.augment(gty)
+                if newty is None:
+                    raise TypeError("cannot augment %s with %s"
+                                    % (existing, gty))
+                self._remove_global(gv)
+                self._insert_global(gv, newty)
+
+    def _lookup_global(self, gv):
+        """
+        Look up the registered type for global value *gv*.
+        """
+        try:
+            gv = weakref.ref(gv)
+        except TypeError:
+            pass
+        try:
+            return self._globals.get(gv, None)
+        except TypeError:
+            # Unhashable type
+            return None
+
+    def _insert_global(self, gv, gty):
+        """
+        Register type *gty* for value *gv*.  Only a weak reference
+        to *gv* is kept, if possible.
+        """
+        def on_disposal(wr, pop=self._globals.pop):
+            # pop() is pre-looked up to avoid a crash late at shutdown on 3.5
+            # (https://bugs.python.org/issue25217)
+            pop(wr)
+        try:
+            gv = weakref.ref(gv, on_disposal)
+        except TypeError:
+            pass
+        self._globals[gv] = gty
+
+    def _remove_global(self, gv):
+        """
+        Remove the registered type for global value *gv*.
+        """
+        try:
+            gv = weakref.ref(gv)
+        except TypeError:
+            pass
+        del self._globals[gv]
+
+    def insert_global(self, gv, gty):
+        self._insert_global(gv, gty)
+
+    def insert_attributes(self, at):
+        key = at.key
+        self._attributes[key].append(at)
+
+    def insert_function(self, ft):
+        key = ft.key
+        self._functions[key].append(ft)
+
+    def insert_user_function(self, fn, ft):
+        """Insert a user function.
+
+        Args
+        ----
+        - fn:
+            object used as callee
+        - ft:
+            function template
+        """
+        self._insert_global(fn, types.Function(ft))
+
+    def can_convert(self, fromty, toty):
+        """
+        Check whether conversion is possible from *fromty* to *toty*.
+        If successful, return a numba.typeconv.Conversion instance;
+        otherwise None is returned.
+        """
+        if fromty == toty:
+            return Conversion.exact
+        else:
+            # First check with the type manager (some rules are registered
+            # at startup there, see numba.typeconv.rules)
+            conv = self.tm.check_compatible(fromty, toty)
+            if conv is not None:
+                return conv
+
+            # Fall back on type-specific rules
+            forward = fromty.can_convert_to(self, toty)
+            backward = toty.can_convert_from(self, fromty)
+            if backward is None:
+                return forward
+            elif forward is None:
+                return backward
+            else:
+                return min(forward, backward)
+
+    def _rate_arguments(self, actualargs, formalargs, unsafe_casting=True,
+                        exact_match_required=False):
+        """
+        Rate the actual arguments for compatibility against the formal
+        arguments.  A Rating instance is returned, or None if incompatible.
+        """
+        if len(actualargs) != len(formalargs):
+            return None
+        rate = Rating()
+        for actual, formal in zip(actualargs, formalargs):
+            conv = self.can_convert(actual, formal)
+            if conv is None:
+                return None
+            elif not unsafe_casting and conv >= Conversion.unsafe:
+                return None
+            elif exact_match_required and conv != Conversion.exact:
+                return None
+
+            if conv == Conversion.promote:
+                rate.promote += 1
+            elif conv == Conversion.safe:
+                rate.safe_convert += 1
+            elif conv == Conversion.unsafe:
+                rate.unsafe_convert += 1
+            elif conv == Conversion.exact:
+                pass
+            else:
+                raise AssertionError("unreachable", conv)
+
+        return rate
+
+    def install_possible_conversions(self, actualargs, formalargs):
+        """
+        Install possible conversions from the actual argument types to
+        the formal argument types in the C++ type manager.
+        Return True if all arguments can be converted.
+        """
+        if len(actualargs) != len(formalargs):
+            return False
+        for actual, formal in zip(actualargs, formalargs):
+            if self.tm.check_compatible(actual, formal) is not None:
+                # This conversion is already known
+                continue
+            conv = self.can_convert(actual, formal)
+            if conv is None:
+                return False
+            assert conv is not Conversion.exact
+            self.tm.set_compatible(actual, formal, conv)
+        return True
+
+    def resolve_overload(self, key, cases, args, kws,
+                         allow_ambiguous=True, unsafe_casting=True,
+                         exact_match_required=False):
+        """
+        Given actual *args* and *kws*, find the best matching
+        signature in *cases*, or None if none matches.
+        *key* is used for error reporting purposes.
+        If *allow_ambiguous* is False, a tie in the best matches
+        will raise an error.
+        If *unsafe_casting* is False, unsafe casting is forbidden.
+        """
+        assert not kws, "Keyword arguments are not supported, yet"
+        options = {
+            'unsafe_casting': unsafe_casting,
+            'exact_match_required': exact_match_required,
+        }
+        # Rate each case
+        candidates = []
+        for case in cases:
+            if len(args) == len(case.args):
+                rating = self._rate_arguments(args, case.args, **options)
+                if rating is not None:
+                    candidates.append((rating.astuple(), case))
+
+        # Find the best case
+        candidates.sort(key=lambda i: i[0])
+        if candidates:
+            best_rate, best = candidates[0]
+            if not allow_ambiguous:
+                # Find whether there is a tie and if so, raise an error
+                tied = []
+                for rate, case in candidates:
+                    if rate != best_rate:
+                        break
+                    tied.append(case)
+                if len(tied) > 1:
+                    args = (key, args, '\n'.join(map(str, tied)))
+                    msg = "Ambiguous overloading for %s %s:\n%s" % args
+                    raise TypeError(msg)
+            # Simply return the best matching candidate in order.
+            # If there is a tie, since list.sort() is stable, the first case
+            # in the original order is returned.
+            # (this can happen if e.g. a function template exposes
+            #  (int32, int32) -> int32 and (int64, int64) -> int64,
+            #  and you call it with (int16, int16) arguments)
+            return best
+
+    def unify_types(self, *typelist):
+        # Sort the type list according to bit width before doing
+        # pairwise unification (with thanks to aterrel).
+        def keyfunc(obj):
+            """Uses bitwidth to order numeric-types.
+            Fallback to stable, deterministic sort.
+            """
+            return getattr(obj, 'bitwidth', 0)
+        typelist = sorted(typelist, key=keyfunc)
+        unified = typelist[0]
+        for tp in typelist[1:]:
+            unified = self.unify_pairs(unified, tp)
+            if unified is None:
+                break
+        return unified
+
+    def unify_pairs(self, first, second):
+        """
+        Try to unify the two given types.  A third type is returned,
+        or None in case of failure.
+        """
+        if first == second:
+            return first
+
+        if first is types.undefined:
+            return second
+        elif second is types.undefined:
+            return first
+
+        # Types with special unification rules
+        unified = first.unify(self, second)
+        if unified is not None:
+            return unified
+
+        unified = second.unify(self, first)
+        if unified is not None:
+            return unified
+
+        # Other types with simple conversion rules
+        conv = self.can_convert(fromty=first, toty=second)
+        if conv is not None and conv <= Conversion.safe:
+            # Can convert from first to second
+            return second
+
+        conv = self.can_convert(fromty=second, toty=first)
+        if conv is not None and conv <= Conversion.safe:
+            # Can convert from second to first
+            return first
+
+        if isinstance(first, types.Literal) or \
+           isinstance(second, types.Literal):
+            first = types.unliteral(first)
+            second = types.unliteral(second)
+            return self.unify_pairs(first, second)
+
+        # Cannot unify
+        return None
+
+
+class Context(BaseContext):
+
+    def load_additional_registries(self):
+        from . import (
+            cffi_utils,
+            cmathdecl,
+            enumdecl,
+            listdecl,
+            mathdecl,
+            npydecl,
+            setdecl,
+            dictdecl,
+        )
+        self.install_registry(cffi_utils.registry)
+        self.install_registry(cmathdecl.registry)
+        self.install_registry(enumdecl.registry)
+        self.install_registry(listdecl.registry)
+        self.install_registry(mathdecl.registry)
+        self.install_registry(npydecl.registry)
+        self.install_registry(setdecl.registry)
+        self.install_registry(dictdecl.registry)

lib/python3.10/site-packages/numba/core/typing/mathdecl.py

@@ -0,0 +1,14 @@
+import sys
+from numba.core.utils import _RedirectSubpackage
+from numba.core import config
+
+if config.USE_LEGACY_TYPE_SYSTEM:
+    sys.modules[__name__] = _RedirectSubpackage(
+        locals(),
+        "numba.core.typing.old_mathdecl"
+    )
+else:
+    sys.modules[__name__] = _RedirectSubpackage(
+        locals(),
+        "numba.core.typing.new_mathdecl"
+    )

lib/python3.10/site-packages/numba/core/typing/new_cmathdecl.py

@@ -0,0 +1,50 @@
+import cmath
+
+from numba.core import types, utils
+from numba.core.typing.templates import (AbstractTemplate, ConcreteTemplate,
+                                    signature, Registry)
+
+registry = Registry()
+infer_global = registry.register_global
+
+# TODO: support non-complex arguments (floats and ints)
+
+# TODO: New Type System
+# These functions are part of the Python standard library
+#  and (without checking) probably accept anything which
+#  is "number"-like i.e. has a __float__, __int__, or
+#  __index__
+# This needs fixing in the new type system
+
+
+@infer_global(cmath.acos)
+@infer_global(cmath.asin)
+@infer_global(cmath.asinh)
+@infer_global(cmath.atan)
+@infer_global(cmath.atanh)
+@infer_global(cmath.cos)
+@infer_global(cmath.exp)
+@infer_global(cmath.sin)
+@infer_global(cmath.sqrt)
+@infer_global(cmath.tan)
+class CMath_unary(ConcreteTemplate):
+    cases = []
+
+
+@infer_global(cmath.isinf)
+@infer_global(cmath.isnan)
+class CMath_predicate(ConcreteTemplate):
+    cases = []
+
+
+@infer_global(cmath.isfinite)
+class CMath_isfinite(CMath_predicate):
+    pass
+
+
+@infer_global(cmath.log)
+class Cmath_log(ConcreteTemplate):
+    # unary cmath.log()
+    cases = []
+    # binary cmath.log()
+    cases += []

lib/python3.10/site-packages/numba/core/typing/new_mathdecl.py

@@ -0,0 +1,107 @@
+import math
+from numba.core import types, utils
+from numba.core.typing.templates import (AttributeTemplate, ConcreteTemplate,
+                                         signature, Registry)
+
+# TODO: New Type System
+# These functions are part of the Python standard library
+#  and (without checking) probably accept anything which
+#  is "number"-like i.e. has a __float__, __int__, or
+#  __index__
+# This needs fixing in the new type system
+
+
+registry = Registry()
+infer_global = registry.register_global
+
+
+@infer_global(math.exp)
+@infer_global(math.expm1)
+@infer_global(math.fabs)
+@infer_global(math.sqrt)
+@infer_global(math.log)
+@infer_global(math.log1p)
+@infer_global(math.log10)
+@infer_global(math.log2)
+@infer_global(math.sin)
+@infer_global(math.cos)
+@infer_global(math.tan)
+@infer_global(math.sinh)
+@infer_global(math.cosh)
+@infer_global(math.tanh)
+@infer_global(math.asin)
+@infer_global(math.acos)
+@infer_global(math.atan)
+@infer_global(math.asinh)
+@infer_global(math.acosh)
+@infer_global(math.atanh)
+@infer_global(math.degrees)
+@infer_global(math.radians)
+@infer_global(math.erf)
+@infer_global(math.erfc)
+@infer_global(math.gamma)
+@infer_global(math.lgamma)
+class Math_unary(ConcreteTemplate):
+    cases = []
+
+
+@infer_global(math.atan2)
+class Math_atan2(ConcreteTemplate):
+    cases = []
+
+
+@infer_global(math.trunc)
+class Math_converter(ConcreteTemplate):
+    cases = []
+
+
+@infer_global(math.floor)
+@infer_global(math.ceil)
+class Math_floor_ceil(Math_converter):
+    pass
+
+
+@infer_global(math.copysign)
+class Math_copysign(ConcreteTemplate):
+    cases = []
+
+
+@infer_global(math.hypot)
+class Math_hypot(ConcreteTemplate):
+    cases = []
+
+
+@infer_global(math.nextafter)
+class Math_nextafter(ConcreteTemplate):
+    cases = []
+
+
+@infer_global(math.isinf)
+@infer_global(math.isnan)
+class Math_predicate(ConcreteTemplate):
+    cases = []
+
+
+@infer_global(math.isfinite)
+class Math_isfinite(Math_predicate):
+    pass
+
+
+@infer_global(math.pow)
+class Math_pow(ConcreteTemplate):
+    cases = []
+
+
+@infer_global(math.gcd)
+class Math_gcd(ConcreteTemplate):
+    cases = []
+
+
+@infer_global(math.frexp)
+class Math_frexp(ConcreteTemplate):
+    cases = []
+
+
+@infer_global(math.ldexp)
+class Math_ldexp(ConcreteTemplate):
+    cases = []

lib/python3.10/site-packages/numba/core/typing/templates.py

@@ -0,0 +1,1337 @@
+"""
+Define typing templates
+"""
+
+from abc import ABC, abstractmethod
+import functools
+import sys
+import inspect
+import os.path
+from collections import namedtuple
+from collections.abc import Sequence
+from types import MethodType, FunctionType, MappingProxyType
+
+import numba
+from numba.core import types, utils, targetconfig
+from numba.core.errors import (
+    TypingError,
+    InternalError,
+)
+from numba.core.cpu_options import InlineOptions
+
+# info store for inliner callback functions e.g. cost model
+_inline_info = namedtuple('inline_info',
+                          'func_ir typemap calltypes signature')
+
+
+class Signature(object):
+    """
+    The signature of a function call or operation, i.e. its argument types
+    and return type.
+    """
+
+    # XXX Perhaps the signature should be a BoundArguments, instead
+    # of separate args and pysig...
+    __slots__ = '_return_type', '_args', '_recvr', '_pysig'
+
+    def __init__(self, return_type, args, recvr, pysig=None):
+        if isinstance(args, list):
+            args = tuple(args)
+        self._return_type = return_type
+        self._args = args
+        self._recvr = recvr
+        self._pysig = pysig
+
+    @property
+    def return_type(self):
+        return self._return_type
+
+    @property
+    def args(self):
+        return self._args
+
+    @property
+    def recvr(self):
+        return self._recvr
+
+    @property
+    def pysig(self):
+        return self._pysig
+
+    def replace(self, **kwargs):
+        """Copy and replace the given attributes provided as keyword arguments.
+        Returns an updated copy.
+        """
+        curstate = dict(return_type=self.return_type,
+                        args=self.args,
+                        recvr=self.recvr,
+                        pysig=self.pysig)
+        curstate.update(kwargs)
+        return Signature(**curstate)
+
+    def __getstate__(self):
+        """
+        Needed because of __slots__.
+        """
+        return self._return_type, self._args, self._recvr, self._pysig
+
+    def __setstate__(self, state):
+        """
+        Needed because of __slots__.
+        """
+        self._return_type, self._args, self._recvr, self._pysig = state
+
+    def __hash__(self):
+        return hash((self.args, self.return_type))
+
+    def __eq__(self, other):
+        if isinstance(other, Signature):
+            return (self.args == other.args and
+                    self.return_type == other.return_type and
+                    self.recvr == other.recvr and
+                    self.pysig == other.pysig)
+
+    def __ne__(self, other):
+        return not (self == other)
+
+    def __repr__(self):
+        return "%s -> %s" % (self.args, self.return_type)
+
+    @property
+    def is_method(self):
+        """
+        Whether this signature represents a bound method or a regular
+        function.
+        """
+        return self.recvr is not None
+
+    def as_method(self):
+        """
+        Convert this signature to a bound method signature.
+        """
+        if self.recvr is not None:
+            return self
+        sig = signature(self.return_type, *self.args[1:],
+                        recvr=self.args[0])
+
+        # Adjust the python signature
+        params = list(self.pysig.parameters.values())[1:]
+        sig = sig.replace(
+            pysig=utils.pySignature(
+                parameters=params,
+                return_annotation=self.pysig.return_annotation,
+            ),
+        )
+        return sig
+
+    def as_function(self):
+        """
+        Convert this signature to a regular function signature.
+        """
+        if self.recvr is None:
+            return self
+        sig = signature(self.return_type, *((self.recvr,) + self.args))
+        return sig
+
+    def as_type(self):
+        """
+        Convert this signature to a first-class function type.
+        """
+        return types.FunctionType(self)
+
+    def __unliteral__(self):
+        return signature(types.unliteral(self.return_type),
+                         *map(types.unliteral, self.args))
+
+    def dump(self, tab=''):
+        c = self.as_type()._code
+        print(f'{tab}DUMP {type(self).__name__} [type code: {c}]')
+        print(f'{tab}  Argument types:')
+        for a in self.args:
+            a.dump(tab=tab + '  | ')
+        print(f'{tab}  Return type:')
+        self.return_type.dump(tab=tab + '  | ')
+        print(f'{tab}END DUMP')
+
+    def is_precise(self):
+        for atype in self.args:
+            if not atype.is_precise():
+                return False
+        return self.return_type.is_precise()
+
+
+def make_concrete_template(name, key, signatures):
+    baseclasses = (ConcreteTemplate,)
+    gvars = dict(key=key, cases=list(signatures))
+    return type(name, baseclasses, gvars)
+
+
+def make_callable_template(key, typer, recvr=None):
+    """
+    Create a callable template with the given key and typer function.
+    """
+    def generic(self):
+        return typer
+
+    name = "%s_CallableTemplate" % (key,)
+    bases = (CallableTemplate,)
+    class_dict = dict(key=key, generic=generic, recvr=recvr)
+    return type(name, bases, class_dict)
+
+
+def signature(return_type, *args, **kws):
+    recvr = kws.pop('recvr', None)
+    assert not kws
+    return Signature(return_type, args, recvr=recvr)
+
+
+def fold_arguments(pysig, args, kws, normal_handler, default_handler,
+                   stararg_handler):
+    """
+    Given the signature *pysig*, explicit *args* and *kws*, resolve
+    omitted arguments and keyword arguments. A tuple of positional
+    arguments is returned.
+    Various handlers allow to process arguments:
+    - normal_handler(index, param, value) is called for normal arguments
+    - default_handler(index, param, default) is called for omitted arguments
+    - stararg_handler(index, param, values) is called for a "*args" argument
+    """
+    if isinstance(kws, Sequence):
+        # Normalize dict kws
+        kws = dict(kws)
+
+    # deal with kwonly args
+    params = pysig.parameters
+    kwonly = []
+    for name, p in params.items():
+        if p.kind == p.KEYWORD_ONLY:
+            kwonly.append(name)
+
+    if kwonly:
+        bind_args = args[:-len(kwonly)]
+    else:
+        bind_args = args
+    bind_kws = kws.copy()
+    if kwonly:
+        for idx, n in enumerate(kwonly):
+            bind_kws[n] = args[len(kwonly) + idx]
+
+    # now bind
+    try:
+        ba = pysig.bind(*bind_args, **bind_kws)
+    except TypeError as e:
+        # The binding attempt can raise if the args don't match up, this needs
+        # to be converted to a TypingError so that e.g. partial type inference
+        # doesn't just halt.
+        msg = (f"Cannot bind 'args={bind_args} kws={bind_kws}' to "
+               f"signature '{pysig}' due to \"{type(e).__name__}: {e}\".")
+        raise TypingError(msg)
+    for i, param in enumerate(pysig.parameters.values()):
+        name = param.name
+        default = param.default
+        if param.kind == param.VAR_POSITIONAL:
+            # stararg may be omitted, in which case its "default" value
+            # is simply the empty tuple
+            if name in ba.arguments:
+                argval = ba.arguments[name]
+                # NOTE: avoid wrapping the tuple type for stararg in another
+                #       tuple.
+                if (len(argval) == 1 and
+                        isinstance(argval[0], (types.StarArgTuple,
+                                               types.StarArgUniTuple))):
+                    argval = tuple(argval[0])
+            else:
+                argval = ()
+            out = stararg_handler(i, param, argval)
+
+            ba.arguments[name] = out
+        elif name in ba.arguments:
+            # Non-stararg, present
+            ba.arguments[name] = normal_handler(i, param, ba.arguments[name])
+        else:
+            # Non-stararg, omitted
+            assert default is not param.empty
+            ba.arguments[name] = default_handler(i, param, default)
+    # Collect args in the right order
+    args = tuple(ba.arguments[param.name]
+                 for param in pysig.parameters.values())
+    return args
+
+
+class FunctionTemplate(ABC):
+    # Set to true to disable unsafe cast.
+    # subclass overide-able
+    unsafe_casting = True
+    # Set to true to require exact match without casting.
+    # subclass overide-able
+    exact_match_required = False
+    # Set to true to prefer literal arguments.
+    # Useful for definitions that specialize on literal but also support
+    # non-literals.
+    # subclass overide-able
+    prefer_literal = False
+    # metadata
+    metadata = {}
+
+    def __init__(self, context):
+        self.context = context
+
+    def _select(self, cases, args, kws):
+        options = {
+            'unsafe_casting': self.unsafe_casting,
+            'exact_match_required': self.exact_match_required,
+        }
+        selected = self.context.resolve_overload(self.key, cases, args, kws,
+                                                 **options)
+        return selected
+
+    def get_impl_key(self, sig):
+        """
+        Return the key for looking up the implementation for the given
+        signature on the target context.
+        """
+        # Lookup the key on the class, to avoid binding it with `self`.
+        key = type(self).key
+        # On Python 2, we must also take care about unbound methods
+        if isinstance(key, MethodType):
+            assert key.im_self is None
+            key = key.im_func
+        return key
+
+    @classmethod
+    def get_source_code_info(cls, impl):
+        """
+        Gets the source information about function impl.
+        Returns:
+
+        code - str: source code as a string
+        firstlineno - int: the first line number of the function impl
+        path - str: the path to file containing impl
+
+        if any of the above are not available something generic is returned
+        """
+        try:
+            code, firstlineno = inspect.getsourcelines(impl)
+        except OSError: # missing source, probably a string
+            code = "None available (built from string?)"
+            firstlineno = 0
+        path = inspect.getsourcefile(impl)
+        if path is None:
+            path = "<unknown> (built from string?)"
+        return code, firstlineno, path
+
+    @abstractmethod
+    def get_template_info(self):
+        """
+        Returns a dictionary with information specific to the template that will
+        govern how error messages are displayed to users. The dictionary must
+        be of the form:
+        info = {
+            'kind': "unknown", # str: The kind of template, e.g. "Overload"
+            'name': "unknown", # str: The name of the source function
+            'sig': "unknown",  # str: The signature(s) of the source function
+            'filename': "unknown", # str: The filename of the source function
+            'lines': ("start", "end"), # tuple(int, int): The start and
+                                         end line of the source function.
+            'docstring': "unknown" # str: The docstring of the source function
+        }
+        """
+        pass
+
+    def __str__(self):
+        info = self.get_template_info()
+        srcinfo = f"{info['filename']}:{info['lines'][0]}"
+        return f"<{self.__class__.__name__} {srcinfo}>"
+
+    __repr__ = __str__
+
+
+class AbstractTemplate(FunctionTemplate):
+    """
+    Defines method ``generic(self, args, kws)`` which compute a possible
+    signature base on input types.  The signature does not have to match the
+    input types. It is compared against the input types afterwards.
+    """
+
+    def apply(self, args, kws):
+        generic = getattr(self, "generic")
+        sig = generic(args, kws)
+        # Enforce that *generic()* must return None or Signature
+        if sig is not None:
+            if not isinstance(sig, Signature):
+                raise AssertionError(
+                    "generic() must return a Signature or None. "
+                    "{} returned {}".format(generic, type(sig)),
+                )
+
+        # Unpack optional type if no matching signature
+        if not sig and any(isinstance(x, types.Optional) for x in args):
+            def unpack_opt(x):
+                if isinstance(x, types.Optional):
+                    return x.type
+                else:
+                    return x
+
+            args = list(map(unpack_opt, args))
+            assert not kws  # Not supported yet
+            sig = generic(args, kws)
+
+        return sig
+
+    def get_template_info(self):
+        impl = getattr(self, "generic")
+        basepath = os.path.dirname(os.path.dirname(numba.__file__))
+
+        code, firstlineno, path = self.get_source_code_info(impl)
+        sig = str(utils.pysignature(impl))
+        info = {
+            'kind': "overload",
+            'name': getattr(impl, '__qualname__', impl.__name__),
+            'sig': sig,
+            'filename': utils.safe_relpath(path, start=basepath),
+            'lines': (firstlineno, firstlineno + len(code) - 1),
+            'docstring': impl.__doc__
+        }
+        return info
+
+
+class CallableTemplate(FunctionTemplate):
+    """
+    Base class for a template defining a ``generic(self)`` method
+    returning a callable to be called with the actual ``*args`` and
+    ``**kwargs`` representing the call signature.  The callable has
+    to return a return type, a full signature, or None.  The signature
+    does not have to match the input types. It is compared against the
+    input types afterwards.
+    """
+    recvr = None
+
+    def apply(self, args, kws):
+        generic = getattr(self, "generic")
+        typer = generic()
+        match_sig = inspect.signature(typer)
+        try:
+            match_sig.bind(*args, **kws)
+        except TypeError as e:
+            # bind failed, raise, if there's a
+            # ValueError then there's likely unrecoverable
+            # problems
+            raise TypingError(str(e)) from e
+
+        sig = typer(*args, **kws)
+
+        # Unpack optional type if no matching signature
+        if sig is None:
+            if any(isinstance(x, types.Optional) for x in args):
+                def unpack_opt(x):
+                    if isinstance(x, types.Optional):
+                        return x.type
+                    else:
+                        return x
+
+                args = list(map(unpack_opt, args))
+                sig = typer(*args, **kws)
+            if sig is None:
+                return
+
+        # Get the pysig
+        try:
+            pysig = typer.pysig
+        except AttributeError:
+            pysig = utils.pysignature(typer)
+
+        # Fold any keyword arguments
+        bound = pysig.bind(*args, **kws)
+        if bound.kwargs:
+            raise TypingError("unsupported call signature")
+        if not isinstance(sig, Signature):
+            # If not a signature, `sig` is assumed to be the return type
+            if not isinstance(sig, types.Type):
+                raise TypeError("invalid return type for callable template: "
+                                "got %r" % (sig,))
+            sig = signature(sig, *bound.args)
+        if self.recvr is not None:
+            sig = sig.replace(recvr=self.recvr)
+        # Hack any omitted parameters out of the typer's pysig,
+        # as lowering expects an exact match between formal signature
+        # and actual args.
+        if len(bound.args) < len(pysig.parameters):
+            parameters = list(pysig.parameters.values())[:len(bound.args)]
+            pysig = pysig.replace(parameters=parameters)
+        sig = sig.replace(pysig=pysig)
+        cases = [sig]
+        return self._select(cases, bound.args, bound.kwargs)
+
+    def get_template_info(self):
+        impl = getattr(self, "generic")
+        basepath = os.path.dirname(os.path.dirname(numba.__file__))
+        code, firstlineno, path = self.get_source_code_info(impl)
+        sig = str(utils.pysignature(impl))
+        info = {
+            'kind': "overload",
+            'name': getattr(self.key, '__name__',
+                            getattr(impl, '__qualname__', impl.__name__),),
+            'sig': sig,
+            'filename': utils.safe_relpath(path, start=basepath),
+            'lines': (firstlineno, firstlineno + len(code) - 1),
+            'docstring': impl.__doc__
+        }
+        return info
+
+
+class ConcreteTemplate(FunctionTemplate):
+    """
+    Defines attributes "cases" as a list of signature to match against the
+    given input types.
+    """
+
+    def apply(self, args, kws):
+        cases = getattr(self, 'cases')
+        return self._select(cases, args, kws)
+
+    def get_template_info(self):
+        import operator
+        name = getattr(self.key, '__name__', "unknown")
+        op_func = getattr(operator, name, None)
+
+        kind = "Type restricted function"
+        if op_func is not None:
+            if self.key is op_func:
+                kind = "operator overload"
+        info = {
+            'kind': kind,
+            'name': name,
+            'sig': "unknown",
+            'filename': "unknown",
+            'lines': ("unknown", "unknown"),
+            'docstring': "unknown"
+        }
+        return info
+
+
+class _EmptyImplementationEntry(InternalError):
+    def __init__(self, reason):
+        super(_EmptyImplementationEntry, self).__init__(
+            "_EmptyImplementationEntry({!r})".format(reason),
+        )
+
+
+class _OverloadFunctionTemplate(AbstractTemplate):
+    """
+    A base class of templates for overload functions.
+    """
+
+    def _validate_sigs(self, typing_func, impl_func):
+        # check that the impl func and the typing func have the same signature!
+        typing_sig = utils.pysignature(typing_func)
+        impl_sig = utils.pysignature(impl_func)
+        # the typing signature is considered golden and must be adhered to by
+        # the implementation...
+        # Things that are valid:
+        # 1. args match exactly
+        # 2. kwargs match exactly in name and default value
+        # 3. Use of *args in the same location by the same name in both typing
+        #    and implementation signature
+        # 4. Use of *args in the implementation signature to consume any number
+        #    of arguments in the typing signature.
+        # Things that are invalid:
+        # 5. Use of *args in the typing signature that is not replicated
+        #    in the implementing signature
+        # 6. Use of **kwargs
+
+        def get_args_kwargs(sig):
+            kws = []
+            args = []
+            pos_arg = None
+            for x in sig.parameters.values():
+                if x.default == utils.pyParameter.empty:
+                    args.append(x)
+                    if x.kind == utils.pyParameter.VAR_POSITIONAL:
+                        pos_arg = x
+                    elif x.kind == utils.pyParameter.VAR_KEYWORD:
+                        msg = ("The use of VAR_KEYWORD (e.g. **kwargs) is "
+                               "unsupported. (offending argument name is '%s')")
+                        raise InternalError(msg % x)
+                else:
+                    kws.append(x)
+            return args, kws, pos_arg
+
+        ty_args, ty_kws, ty_pos = get_args_kwargs(typing_sig)
+        im_args, im_kws, im_pos = get_args_kwargs(impl_sig)
+
+        sig_fmt = ("Typing signature:         %s\n"
+                   "Implementation signature: %s")
+        sig_str = sig_fmt % (typing_sig, impl_sig)
+
+        err_prefix = "Typing and implementation arguments differ in "
+
+        a = ty_args
+        b = im_args
+        if ty_pos:
+            if not im_pos:
+                # case 5. described above
+                msg = ("VAR_POSITIONAL (e.g. *args) argument kind (offending "
+                       "argument name is '%s') found in the typing function "
+                       "signature, but is not in the implementing function "
+                       "signature.\n%s") % (ty_pos, sig_str)
+                raise InternalError(msg)
+        else:
+            if im_pos:
+                # no *args in typing but there's a *args in the implementation
+                # this is case 4. described above
+                b = im_args[:im_args.index(im_pos)]
+                try:
+                    a = ty_args[:ty_args.index(b[-1]) + 1]
+                except ValueError:
+                    # there's no b[-1] arg name in the ty_args, something is
+                    # very wrong, we can't work out a diff (*args consumes
+                    # unknown quantity of args) so just report first error
+                    specialized = "argument names.\n%s\nFirst difference: '%s'"
+                    msg = err_prefix + specialized % (sig_str, b[-1])
+                    raise InternalError(msg)
+
+        def gen_diff(typing, implementing):
+            diff = set(typing) ^ set(implementing)
+            return "Difference: %s" % diff
+
+        if a != b:
+            specialized = "argument names.\n%s\n%s" % (sig_str, gen_diff(a, b))
+            raise InternalError(err_prefix + specialized)
+
+        # ensure kwargs are the same
+        ty = [x.name for x in ty_kws]
+        im = [x.name for x in im_kws]
+        if ty != im:
+            specialized = "keyword argument names.\n%s\n%s"
+            msg = err_prefix + specialized % (sig_str, gen_diff(ty_kws, im_kws))
+            raise InternalError(msg)
+        same = [x.default for x in ty_kws] == [x.default for x in im_kws]
+        if not same:
+            specialized = "keyword argument default values.\n%s\n%s"
+            msg = err_prefix + specialized % (sig_str, gen_diff(ty_kws, im_kws))
+            raise InternalError(msg)
+
+    def generic(self, args, kws):
+        """
+        Type the overloaded function by compiling the appropriate
+        implementation for the given args.
+        """
+        from numba.core.typed_passes import PreLowerStripPhis
+
+        disp, new_args = self._get_impl(args, kws)
+        if disp is None:
+            return
+        # Compile and type it for the given types
+        disp_type = types.Dispatcher(disp)
+        # Store the compiled overload for use in the lowering phase if there's
+        # no inlining required (else functions are being compiled which will
+        # never be used as they are inlined)
+        if not self._inline.is_never_inline:
+            # need to run the compiler front end up to type inference to compute
+            # a signature
+            from numba.core import typed_passes, compiler
+            from numba.core.inline_closurecall import InlineWorker
+            fcomp = disp._compiler
+            flags = compiler.Flags()
+
+            # Updating these causes problems?!
+            #fcomp.targetdescr.options.parse_as_flags(flags,
+            #                                         fcomp.targetoptions)
+            #flags = fcomp._customize_flags(flags)
+
+            # spoof a compiler pipline like the one that will be in use
+            tyctx = fcomp.targetdescr.typing_context
+            tgctx = fcomp.targetdescr.target_context
+            compiler_inst = fcomp.pipeline_class(tyctx, tgctx, None, None, None,
+                                                 flags, None, )
+            inline_worker = InlineWorker(tyctx, tgctx, fcomp.locals,
+                                         compiler_inst, flags, None,)
+
+            # If the inlinee contains something to trigger literal arg dispatch
+            # then the pipeline call will unconditionally fail due to a raised
+            # ForceLiteralArg exception. Therefore `resolve` is run first, as
+            # type resolution must occur at some point, this will hit any
+            # `literally` calls and because it's going via the dispatcher will
+            # handle them correctly i.e. ForceLiteralArg propagates. This having
+            # the desired effect of ensuring the pipeline call is only made in
+            # situations that will succeed. For context see #5887.
+            resolve = disp_type.dispatcher.get_call_template
+            template, pysig, folded_args, kws = resolve(new_args, kws)
+            ir = inline_worker.run_untyped_passes(
+                disp_type.dispatcher.py_func, enable_ssa=True
+            )
+
+            (
+                typemap,
+                return_type,
+                calltypes,
+                _
+            ) = typed_passes.type_inference_stage(
+                self.context, tgctx, ir, folded_args, None)
+            ir = PreLowerStripPhis()._strip_phi_nodes(ir)
+            ir._definitions = numba.core.ir_utils.build_definitions(ir.blocks)
+
+            sig = Signature(return_type, folded_args, None)
+            # this stores a load of info for the cost model function if supplied
+            # it by default is None
+            self._inline_overloads[sig.args] = {'folded_args': folded_args}
+            # this stores the compiled overloads, if there's no compiled
+            # overload available i.e. function is always inlined, the key still
+            # needs to exist for type resolution
+
+            # NOTE: If lowering is failing on a `_EmptyImplementationEntry`,
+            #       the inliner has failed to inline this entry correctly.
+            impl_init = _EmptyImplementationEntry('always inlined')
+            self._compiled_overloads[sig.args] = impl_init
+            if not self._inline.is_always_inline:
+                # this branch is here because a user has supplied a function to
+                # determine whether to inline or not. As a result both compiled
+                # function and inliner info needed, delaying the computation of
+                # this leads to an internal state mess at present. TODO: Fix!
+                sig = disp_type.get_call_type(self.context, new_args, kws)
+                self._compiled_overloads[sig.args] = disp_type.get_overload(sig)
+                # store the inliner information, it's used later in the cost
+                # model function call
+            iinfo = _inline_info(ir, typemap, calltypes, sig)
+            self._inline_overloads[sig.args] = {'folded_args': folded_args,
+                                                'iinfo': iinfo}
+        else:
+            sig = disp_type.get_call_type(self.context, new_args, kws)
+            if sig is None: # can't resolve for this target
+                return None
+            self._compiled_overloads[sig.args] = disp_type.get_overload(sig)
+        return sig
+
+    def _get_impl(self, args, kws):
+        """Get implementation given the argument types.
+
+        Returning a Dispatcher object.  The Dispatcher object is cached
+        internally in `self._impl_cache`.
+        """
+        flags = targetconfig.ConfigStack.top_or_none()
+        cache_key = self.context, tuple(args), tuple(kws.items()), flags
+        try:
+            impl, args = self._impl_cache[cache_key]
+            return impl, args
+        except KeyError:
+            # pass and try outside the scope so as to not have KeyError with a
+            # nested addition error in the case the _build_impl fails
+            pass
+        impl, args = self._build_impl(cache_key, args, kws)
+        return impl, args
+
+    def _get_jit_decorator(self):
+        """Gets a jit decorator suitable for the current target"""
+
+        from numba.core.target_extension import (target_registry,
+                                                 get_local_target,
+                                                 jit_registry)
+
+        jitter_str = self.metadata.get('target', 'generic')
+        jitter = jit_registry.get(jitter_str, None)
+
+        if jitter is None:
+            # No JIT known for target string, see if something is
+            # registered for the string and report if not.
+            target_class = target_registry.get(jitter_str, None)
+            if target_class is None:
+                msg = ("Unknown target '{}', has it been ",
+                       "registered?")
+                raise ValueError(msg.format(jitter_str))
+
+            target_hw = get_local_target(self.context)
+
+            # check that the requested target is in the hierarchy for the
+            # current frame's target.
+            if not issubclass(target_hw, target_class):
+                msg = "No overloads exist for the requested target: {}."
+
+            jitter = jit_registry[target_hw]
+
+        if jitter is None:
+            raise ValueError("Cannot find a suitable jit decorator")
+
+        return jitter
+
+    def _build_impl(self, cache_key, args, kws):
+        """Build and cache the implementation.
+
+        Given the positional (`args`) and keyword arguments (`kws`), obtains
+        the `overload` implementation and wrap it in a Dispatcher object.
+        The expected argument types are returned for use by type-inference.
+        The expected argument types are only different from the given argument
+        types if there is an imprecise type in the given argument types.
+
+        Parameters
+        ----------
+        cache_key : hashable
+            The key used for caching the implementation.
+        args : Tuple[Type]
+            Types of positional argument.
+        kws : Dict[Type]
+            Types of keyword argument.
+
+        Returns
+        -------
+        disp, args :
+            On success, returns `(Dispatcher, Tuple[Type])`.
+            On failure, returns `(None, None)`.
+
+        """
+        jitter = self._get_jit_decorator()
+
+        # Get the overload implementation for the given types
+        ov_sig = inspect.signature(self._overload_func)
+        try:
+            ov_sig.bind(*args, **kws)
+        except TypeError as e:
+            # bind failed, raise, if there's a
+            # ValueError then there's likely unrecoverable
+            # problems
+            raise TypingError(str(e)) from e
+        else:
+            ovf_result = self._overload_func(*args, **kws)
+
+        if ovf_result is None:
+            # No implementation => fail typing
+            self._impl_cache[cache_key] = None, None
+            return None, None
+        elif isinstance(ovf_result, tuple):
+            # The implementation returned a signature that the type-inferencer
+            # should be using.
+            sig, pyfunc = ovf_result
+            args = sig.args
+            kws = {}
+            cache_key = None            # don't cache
+        else:
+            # Regular case
+            pyfunc = ovf_result
+
+        # Check type of pyfunc
+        if not isinstance(pyfunc, FunctionType):
+            msg = ("Implementation function returned by `@overload` "
+                   "has an unexpected type.  Got {}")
+            raise AssertionError(msg.format(pyfunc))
+
+        # check that the typing and impl sigs match up
+        if self._strict:
+            self._validate_sigs(self._overload_func, pyfunc)
+        # Make dispatcher
+        jitdecor = jitter(**self._jit_options)
+        disp = jitdecor(pyfunc)
+        # Make sure that the implementation can be fully compiled
+        disp_type = types.Dispatcher(disp)
+        disp_type.get_call_type(self.context, args, kws)
+        if cache_key is not None:
+            self._impl_cache[cache_key] = disp, args
+        return disp, args
+
+    def get_impl_key(self, sig):
+        """
+        Return the key for looking up the implementation for the given
+        signature on the target context.
+        """
+        return self._compiled_overloads[sig.args]
+
+    @classmethod
+    def get_source_info(cls):
+        """Return a dictionary with information about the source code of the
+        implementation.
+
+        Returns
+        -------
+        info : dict
+            - "kind" : str
+                The implementation kind.
+            - "name" : str
+                The name of the function that provided the definition.
+            - "sig" : str
+                The formatted signature of the function.
+            - "filename" : str
+                The name of the source file.
+            - "lines": tuple (int, int)
+                First and list line number.
+            - "docstring": str
+                The docstring of the definition.
+        """
+        basepath = os.path.dirname(os.path.dirname(numba.__file__))
+        impl = cls._overload_func
+        code, firstlineno, path = cls.get_source_code_info(impl)
+        sig = str(utils.pysignature(impl))
+        info = {
+            'kind': "overload",
+            'name': getattr(impl, '__qualname__', impl.__name__),
+            'sig': sig,
+            'filename': utils.safe_relpath(path, start=basepath),
+            'lines': (firstlineno, firstlineno + len(code) - 1),
+            'docstring': impl.__doc__
+        }
+        return info
+
+    def get_template_info(self):
+        basepath = os.path.dirname(os.path.dirname(numba.__file__))
+        impl = self._overload_func
+        code, firstlineno, path = self.get_source_code_info(impl)
+        sig = str(utils.pysignature(impl))
+        info = {
+            'kind': "overload",
+            'name': getattr(impl, '__qualname__', impl.__name__),
+            'sig': sig,
+            'filename': utils.safe_relpath(path, start=basepath),
+            'lines': (firstlineno, firstlineno + len(code) - 1),
+            'docstring': impl.__doc__
+        }
+        return info
+
+
+def make_overload_template(func, overload_func, jit_options, strict,
+                           inline, prefer_literal=False, **kwargs):
+    """
+    Make a template class for function *func* overloaded by *overload_func*.
+    Compiler options are passed as a dictionary to *jit_options*.
+    """
+    func_name = getattr(func, '__name__', str(func))
+    name = "OverloadTemplate_%s" % (func_name,)
+    base = _OverloadFunctionTemplate
+    dct = dict(key=func, _overload_func=staticmethod(overload_func),
+               _impl_cache={}, _compiled_overloads={}, _jit_options=jit_options,
+               _strict=strict, _inline=staticmethod(InlineOptions(inline)),
+               _inline_overloads={}, prefer_literal=prefer_literal,
+               metadata=kwargs)
+    return type(base)(name, (base,), dct)
+
+
+class _TemplateTargetHelperMixin(object):
+    """Mixin for helper methods that assist with target/registry resolution"""
+
+    def _get_target_registry(self, reason):
+        """Returns the registry for the current target.
+
+        Parameters
+        ----------
+        reason: str
+            Reason for the resolution. Expects a noun.
+        Returns
+        -------
+        reg : a registry suitable for the current target.
+        """
+        from numba.core.target_extension import (_get_local_target_checked,
+                                                 dispatcher_registry)
+        hwstr = self.metadata.get('target', 'generic')
+        target_hw = _get_local_target_checked(self.context, hwstr, reason)
+        # Get registry for the current hardware
+        disp = dispatcher_registry[target_hw]
+        tgtctx = disp.targetdescr.target_context
+        # This is all workarounds...
+        # The issue is that whilst targets shouldn't care about which registry
+        # in which to register lowering implementations, the CUDA target
+        # "borrows" implementations from the CPU from specific registries. This
+        # means that if some impl is defined via @intrinsic, e.g. numba.*unsafe
+        # modules, _AND_ CUDA also makes use of the same impl, then it's
+        # required that the registry in use is one that CUDA borrows from. This
+        # leads to the following expression where by the CPU builtin_registry is
+        # used if it is in the target context as a known registry (i.e. the
+        # target installed it) and if it is not then it is assumed that the
+        # registries for the target are unbound to any other target and so it's
+        # fine to use any of them as a place to put lowering impls.
+        #
+        # NOTE: This will need subsequently fixing again when targets use solely
+        # the extension APIs to describe their implementation. The issue will be
+        # that the builtin_registry should contain _just_ the stack allocated
+        # implementations and low level target invariant things and should not
+        # be modified further. It should be acceptable to remove the `then`
+        # branch and just keep the `else`.
+
+        # In case the target has swapped, e.g. cuda borrowing cpu, refresh to
+        # populate.
+        tgtctx.refresh()
+        if builtin_registry in tgtctx._registries:
+            reg = builtin_registry
+        else:
+            # Pick a registry in which to install intrinsics
+            registries = iter(tgtctx._registries)
+            reg = next(registries)
+        return reg
+
+
+class _IntrinsicTemplate(_TemplateTargetHelperMixin, AbstractTemplate):
+    """
+    A base class of templates for intrinsic definition
+    """
+
+    def generic(self, args, kws):
+        """
+        Type the intrinsic by the arguments.
+        """
+        lower_builtin = self._get_target_registry('intrinsic').lower
+        cache_key = self.context, args, tuple(kws.items())
+        try:
+            return self._impl_cache[cache_key]
+        except KeyError:
+            pass
+        result = self._definition_func(self.context, *args, **kws)
+        if result is None:
+            return
+        [sig, imp] = result
+        pysig = utils.pysignature(self._definition_func)
+        # omit context argument from user function
+        parameters = list(pysig.parameters.values())[1:]
+        sig = sig.replace(pysig=pysig.replace(parameters=parameters))
+        self._impl_cache[cache_key] = sig
+        self._overload_cache[sig.args] = imp
+        # register the lowering
+        lower_builtin(imp, *sig.args)(imp)
+        return sig
+
+    def get_impl_key(self, sig):
+        """
+        Return the key for looking up the implementation for the given
+        signature on the target context.
+        """
+        return self._overload_cache[sig.args]
+
+    def get_template_info(self):
+        basepath = os.path.dirname(os.path.dirname(numba.__file__))
+        impl = self._definition_func
+        code, firstlineno, path = self.get_source_code_info(impl)
+        sig = str(utils.pysignature(impl))
+        info = {
+            'kind': "intrinsic",
+            'name': getattr(impl, '__qualname__', impl.__name__),
+            'sig': sig,
+            'filename': utils.safe_relpath(path, start=basepath),
+            'lines': (firstlineno, firstlineno + len(code) - 1),
+            'docstring': impl.__doc__
+        }
+        return info
+
+
+def make_intrinsic_template(handle, defn, name, *, prefer_literal=False,
+                            kwargs=None):
+    """
+    Make a template class for a intrinsic handle *handle* defined by the
+    function *defn*.  The *name* is used for naming the new template class.
+    """
+    kwargs = MappingProxyType({} if kwargs is None else kwargs)
+    base = _IntrinsicTemplate
+    name = "_IntrinsicTemplate_%s" % (name)
+    dct = dict(key=handle, _definition_func=staticmethod(defn),
+               _impl_cache={}, _overload_cache={},
+               prefer_literal=prefer_literal, metadata=kwargs)
+    return type(base)(name, (base,), dct)
+
+
+class AttributeTemplate(object):
+    def __init__(self, context):
+        self.context = context
+
+    def resolve(self, value, attr):
+        return self._resolve(value, attr)
+
+    def _resolve(self, value, attr):
+        fn = getattr(self, "resolve_%s" % attr, None)
+        if fn is None:
+            fn = self.generic_resolve
+            if fn is NotImplemented:
+                if isinstance(value, types.Module):
+                    return self.context.resolve_module_constants(value, attr)
+                else:
+                    return None
+            else:
+                return fn(value, attr)
+        else:
+            return fn(value)
+
+    generic_resolve = NotImplemented
+
+
+class _OverloadAttributeTemplate(_TemplateTargetHelperMixin, AttributeTemplate):
+    """
+    A base class of templates for @overload_attribute functions.
+    """
+    is_method = False
+
+    def __init__(self, context):
+        super(_OverloadAttributeTemplate, self).__init__(context)
+        self.context = context
+        self._init_once()
+
+    def _init_once(self):
+        cls = type(self)
+        attr = cls._attr
+
+        lower_getattr = self._get_target_registry('attribute').lower_getattr
+
+        @lower_getattr(cls.key, attr)
+        def getattr_impl(context, builder, typ, value):
+            typingctx = context.typing_context
+            fnty = cls._get_function_type(typingctx, typ)
+            sig = cls._get_signature(typingctx, fnty, (typ,), {})
+            call = context.get_function(fnty, sig)
+            return call(builder, (value,))
+
+    def _resolve(self, typ, attr):
+        if self._attr != attr:
+            return None
+        fnty = self._get_function_type(self.context, typ)
+        sig = self._get_signature(self.context, fnty, (typ,), {})
+        # There should only be one template
+        for template in fnty.templates:
+            self._inline_overloads.update(template._inline_overloads)
+        return sig.return_type
+
+    @classmethod
+    def _get_signature(cls, typingctx, fnty, args, kws):
+        sig = fnty.get_call_type(typingctx, args, kws)
+        sig = sig.replace(pysig=utils.pysignature(cls._overload_func))
+        return sig
+
+    @classmethod
+    def _get_function_type(cls, typingctx, typ):
+        return typingctx.resolve_value_type(cls._overload_func)
+
+
+class _OverloadMethodTemplate(_OverloadAttributeTemplate):
+    """
+    A base class of templates for @overload_method functions.
+    """
+    is_method = True
+
+    def _init_once(self):
+        """
+        Overriding parent definition
+        """
+        attr = self._attr
+
+        registry = self._get_target_registry('method')
+
+        @registry.lower((self.key, attr), self.key, types.VarArg(types.Any))
+        def method_impl(context, builder, sig, args):
+            typ = sig.args[0]
+            typing_context = context.typing_context
+            fnty = self._get_function_type(typing_context, typ)
+            sig = self._get_signature(typing_context, fnty, sig.args, {})
+            call = context.get_function(fnty, sig)
+            # Link dependent library
+            context.add_linking_libs(getattr(call, 'libs', ()))
+            return call(builder, args)
+
+    def _resolve(self, typ, attr):
+        if self._attr != attr:
+            return None
+
+        if isinstance(typ, types.TypeRef):
+            assert typ == self.key
+        elif isinstance(typ, types.Callable):
+            assert typ == self.key
+        else:
+            assert isinstance(typ, self.key)
+
+        class MethodTemplate(AbstractTemplate):
+            key = (self.key, attr)
+            _inline = self._inline
+            _overload_func = staticmethod(self._overload_func)
+            _inline_overloads = self._inline_overloads
+            prefer_literal = self.prefer_literal
+
+            def generic(_, args, kws):
+                args = (typ,) + tuple(args)
+                fnty = self._get_function_type(self.context, typ)
+                sig = self._get_signature(self.context, fnty, args, kws)
+                sig = sig.replace(pysig=utils.pysignature(self._overload_func))
+                for template in fnty.templates:
+                    self._inline_overloads.update(template._inline_overloads)
+                if sig is not None:
+                    return sig.as_method()
+
+            def get_template_info(self):
+                basepath = os.path.dirname(os.path.dirname(numba.__file__))
+                impl = self._overload_func
+                code, firstlineno, path = self.get_source_code_info(impl)
+                sig = str(utils.pysignature(impl))
+                info = {
+                    'kind': "overload_method",
+                    'name': getattr(impl, '__qualname__', impl.__name__),
+                    'sig': sig,
+                    'filename': utils.safe_relpath(path, start=basepath),
+                    'lines': (firstlineno, firstlineno + len(code) - 1),
+                    'docstring': impl.__doc__
+                }
+
+                return info
+
+        return types.BoundFunction(MethodTemplate, typ)
+
+
+def make_overload_attribute_template(typ, attr, overload_func, inline='never',
+                                     prefer_literal=False,
+                                     base=_OverloadAttributeTemplate,
+                                     **kwargs):
+    """
+    Make a template class for attribute *attr* of *typ* overloaded by
+    *overload_func*.
+    """
+    assert isinstance(typ, types.Type) or issubclass(typ, types.Type)
+    name = "OverloadAttributeTemplate_%s_%s" % (typ, attr)
+    # Note the implementation cache is subclass-specific
+    dct = dict(key=typ, _attr=attr, _impl_cache={},
+               _inline=staticmethod(InlineOptions(inline)),
+               _inline_overloads={},
+               _overload_func=staticmethod(overload_func),
+               prefer_literal=prefer_literal,
+               metadata=kwargs,
+               )
+    obj = type(base)(name, (base,), dct)
+    return obj
+
+
+def make_overload_method_template(typ, attr, overload_func, inline,
+                                  prefer_literal=False, **kwargs):
+    """
+    Make a template class for method *attr* of *typ* overloaded by
+    *overload_func*.
+    """
+    return make_overload_attribute_template(
+        typ, attr, overload_func, inline=inline,
+        base=_OverloadMethodTemplate, prefer_literal=prefer_literal,
+        **kwargs,
+    )
+
+
+def bound_function(template_key):
+    """
+    Wrap an AttributeTemplate resolve_* method to allow it to
+    resolve an instance method's signature rather than a instance attribute.
+    The wrapped method must return the resolved method's signature
+    according to the given self type, args, and keywords.
+
+    It is used thusly:
+
+        class ComplexAttributes(AttributeTemplate):
+            @bound_function("complex.conjugate")
+            def resolve_conjugate(self, ty, args, kwds):
+                return ty
+
+    *template_key* (e.g. "complex.conjugate" above) will be used by the
+    target to look up the method's implementation, as a regular function.
+    """
+    def wrapper(method_resolver):
+        @functools.wraps(method_resolver)
+        def attribute_resolver(self, ty):
+            class MethodTemplate(AbstractTemplate):
+                key = template_key
+
+                def generic(_, args, kws):
+                    sig = method_resolver(self, ty, args, kws)
+                    if sig is not None and sig.recvr is None:
+                        sig = sig.replace(recvr=ty)
+                    return sig
+
+            return types.BoundFunction(MethodTemplate, ty)
+        return attribute_resolver
+    return wrapper
+
+
+# -----------------------------
+
+class Registry(object):
+    """
+    A registry of typing declarations.  The registry stores such declarations
+    for functions, attributes and globals.
+    """
+
+    def __init__(self):
+        self.functions = []
+        self.attributes = []
+        self.globals = []
+
+    def register(self, item):
+        assert issubclass(item, FunctionTemplate)
+        self.functions.append(item)
+        return item
+
+    def register_attr(self, item):
+        assert issubclass(item, AttributeTemplate)
+        self.attributes.append(item)
+        return item
+
+    def register_global(self, val=None, typ=None, **kwargs):
+        """
+        Register the typing of a global value.
+        Functional usage with a Numba type::
+            register_global(value, typ)
+
+        Decorator usage with a template class::
+            @register_global(value, typing_key=None)
+            class Template:
+                ...
+        """
+        if typ is not None:
+            # register_global(val, typ)
+            assert val is not None
+            assert not kwargs
+            self.globals.append((val, typ))
+        else:
+            def decorate(cls, typing_key):
+                class Template(cls):
+                    key = typing_key
+                if callable(val):
+                    typ = types.Function(Template)
+                else:
+                    raise TypeError("cannot infer type for global value %r")
+                self.globals.append((val, typ))
+                return cls
+
+            # register_global(val, typing_key=None)(<template class>)
+            assert val is not None
+            typing_key = kwargs.pop('typing_key', val)
+            assert not kwargs
+            if typing_key is val:
+                # Check the value is globally reachable, as it is going
+                # to be used as the key.
+                mod = sys.modules[val.__module__]
+                if getattr(mod, val.__name__) is not val:
+                    raise ValueError("%r is not globally reachable as '%s.%s'"
+                                     % (mod, val.__module__, val.__name__))
+
+            def decorator(cls):
+                return decorate(cls, typing_key)
+            return decorator
+
+
+class BaseRegistryLoader(object):
+    """
+    An incremental loader for a registry.  Each new call to
+    new_registrations() will iterate over the not yet seen registrations.
+
+    The reason for this object is multiple:
+    - there can be several contexts
+    - each context wants to install all registrations
+    - registrations can be added after the first installation, so contexts
+      must be able to get the "new" installations
+
+    Therefore each context maintains its own loaders for each existing
+    registry, without duplicating the registries themselves.
+    """
+
+    def __init__(self, registry):
+        self._registrations = dict(
+            (name, utils.stream_list(getattr(registry, name)))
+            for name in self.registry_items)
+
+    def new_registrations(self, name):
+        for item in next(self._registrations[name]):
+            yield item
+
+
+class RegistryLoader(BaseRegistryLoader):
+    """
+    An incremental loader for a typing registry.
+    """
+    registry_items = ('functions', 'attributes', 'globals')
+
+
+builtin_registry = Registry()
+infer = builtin_registry.register
+infer_getattr = builtin_registry.register_attr
+infer_global = builtin_registry.register_global

lib/python3.10/site-packages/numba/core/unsafe/bytes.py

@@ -0,0 +1,49 @@
+"""
+This file provides internal compiler utilities that support certain special
+operations with bytes and workarounds for limitations enforced in userland.
+"""
+
+from numba.core.extending import intrinsic
+from llvmlite import ir
+from numba.core import types, cgutils
+
+
+@intrinsic
+def grab_byte(typingctx, data, offset):
+    # returns a byte at a given offset in data
+    def impl(context, builder, signature, args):
+        data, idx = args
+        ptr = builder.bitcast(data, ir.IntType(8).as_pointer())
+        ch = builder.load(builder.gep(ptr, [idx]))
+        return ch
+
+    sig = types.uint8(types.voidptr, types.intp)
+    return sig, impl
+
+
+@intrinsic
+def grab_uint64_t(typingctx, data, offset):
+    # returns a uint64_t at a given offset in data
+    def impl(context, builder, signature, args):
+        data, idx = args
+        ptr = builder.bitcast(data, ir.IntType(64).as_pointer())
+        ch = builder.load(builder.gep(ptr, [idx]))
+        return ch
+    sig = types.uint64(types.voidptr, types.intp)
+    return sig, impl
+
+
+@intrinsic
+def memcpy_region(typingctx, dst, dst_offset, src, src_offset, nbytes, align):
+    '''Copy nbytes from *(src + src_offset) to *(dst + dst_offset)'''
+    def codegen(context, builder, signature, args):
+        [dst_val, dst_offset_val, src_val, src_offset_val, nbytes_val,
+         align_val] = args
+        src_ptr = builder.gep(src_val, [src_offset_val])
+        dst_ptr = builder.gep(dst_val, [dst_offset_val])
+        cgutils.raw_memcpy(builder, dst_ptr, src_ptr, nbytes_val, align_val)
+        return context.get_dummy_value()
+
+    sig = types.void(types.voidptr, types.intp, types.voidptr, types.intp,
+                     types.intp, types.intp)
+    return sig, codegen