ovld 0.3.9__py3-none-any.whl → 0.4.1__py3-none-any.whl

ovld/core.py

@@ -2,328 +2,283 @@
 
 import inspect
 import itertools
-import math
 import sys
 import textwrap
 import typing
-from functools import partial
-from types import CodeType
+from collections import defaultdict
+from dataclasses import dataclass, field, replace
+from functools import cached_property, partial
+from types import GenericAlias
 
-from .mro import compose_mro
-from .recode import Conformer, rename_function
-from .utils import BOOTSTRAP, MISSING, keyword_decorator
+from .recode import (
+    Conformer,
+    adapt_function,
+    generate_dispatch,
+    rename_function,
+)
+from .typemap import MultiTypeMap, is_type_of_type
+from .types import normalize_type
+from .utils import UsageError, keyword_decorator
 
-try:
-    from types import UnionType
-except ImportError:  # pragma: no cover
-    UnionType = None
+_current_id = itertools.count()
 
 
-class GenericAliasMC(type):
-    def __instancecheck__(cls, obj):
-        return hasattr(obj, "__origin__")
-
+def _fresh(t):
+    """Returns a new subclass of type t.
 
-class GenericAlias(metaclass=GenericAliasMC):
-    pass
+    Each Ovld corresponds to its own class, which allows for specialization of
+    methods.
+    """
+    methods = {}
+    if not isinstance(getattr(t, "__doc__", None), str):
+        methods["__doc__"] = t.__doc__
+    return type(t.__name__, (t,), methods)
 
 
-def is_type_of_type(t):
-    return getattr(t, "__origin__", None) is type
+@keyword_decorator
+def _setattrs(fn, **kwargs):
+    for k, v in kwargs.items():
+        setattr(fn, k, v)
+    return fn
 
 
-class TypeMap(dict):
-    """Represents a mapping from types to handlers.
+@keyword_decorator
+def _compile_first(fn, rename=None):
+    def first_entry(self, *args, **kwargs):
+        self.compile()
+        method = getattr(self, fn.__name__)
+        assert method is not first_entry
+        return method(*args, **kwargs)
 
-    The mro of a type is considered when getting the handler, so setting the
-    [object] key creates a default for all objects.
+    first_entry._replace_by = fn
+    first_entry._rename = rename
+    return first_entry
 
-    typemap[some_type] returns a tuple of a handler and a "level" that
-    represents the distance from the handler to the type `object`. Essentially,
-    the level is the index of the type for which the handler was registered
-    in the mro of `some_type`. So for example, `object` has level 0, a class
-    that inherits directly from `object` has level 1, and so on.
-    """
 
-    def __init__(self):
-        self.entries = {}
-        self.types = set()
+def arg0_is_self(fn):
+    sgn = inspect.signature(fn)
+    params = list(sgn.parameters.values())
+    return params and params[0].name == "self"
 
-    def register(self, obj_t, handler):
-        """Register a handler for the given object type."""
-        if isinstance(obj_t, str):
-            obj_t = eval(obj_t, getattr(handler[0], "__globals__", {}))
 
-        self.clear()
-        if is_type_of_type(obj_t):
-            self.types.add(obj_t.__args__[0])
-        else:
-            self.types.add(obj_t)
-        s = self.entries.setdefault(obj_t, set())
-        s.add(handler)
+@dataclass(frozen=True)
+class Arginfo:
+    position: typing.Optional[int]
+    name: typing.Optional[str]
+    required: bool
+    ann: type
 
-    def __missing__(self, obj_t):
-        """Get the handler for the given type.
+    @cached_property
+    def is_complex(self):
+        return isinstance(self.ann, GenericAlias)
 
-        The result is cached so that the normal dict getitem will find it
-        the next time getitem is called.
-        """
-        results = {}
-        abscollect = set()
-        if is_type_of_type(obj_t):
-            mro = [
-                type[t]
-                for t in compose_mro(obj_t.__args__[0], self.types, abscollect)
-            ]
-            mro.append(type)
-            mro.append(object)
-        else:
-            mro = compose_mro(obj_t, self.types, abscollect)
-
-        lvl = -1
-        prev_is_abstract = False
-        for cls in reversed(mro):
-            if cls not in abscollect or not prev_is_abstract:
-                lvl += 1
-            prev_is_abstract = cls in abscollect
-            handlers = self.entries.get(cls, None)
-            if handlers:
-                results.update({h: lvl for h in handlers})
-
-        if results:
-            self[obj_t] = results
-            return results
-        else:
-            raise KeyError(obj_t)
+    @cached_property
+    def canonical(self):
+        return self.name if self.position is None else self.position
 
 
-class MultiTypeMap(dict):
-    """Represents a mapping from tuples of types to handlers.
+@dataclass(frozen=True)
+class Signature:
+    types: tuple
+    req_pos: int
+    max_pos: int
+    req_names: frozenset
+    vararg: bool
+    priority: float
+    is_method: bool = False
+    arginfo: list[Arginfo] = field(
+        default_factory=list, hash=False, compare=False
+    )
 
-    The mro is taken into account to find a match. If multiple registered
-    handlers match the tuple of types that's given, if one of the handlers is
-    more specific than every other handler, that handler is returned.
-    Otherwise, the resolution is considered ambiguous and an error is raised.
+    @classmethod
+    def extract(cls, fn):
+        typelist = []
+        sig = inspect.signature(fn)
+        max_pos = 0
+        req_pos = 0
+        req_names = set()
+        is_method = False
+
+        arginfo = []
+        for i, (name, param) in enumerate(sig.parameters.items()):
+            if name == "self":
+                assert i == 0
+                is_method = True
+                continue
+            pos = nm = None
+            ann = normalize_type(param.annotation, fn)
+            if param.kind is inspect._POSITIONAL_ONLY:
+                pos = i - is_method
+                typelist.append(ann)
+                req_pos += param.default is inspect._empty
+                max_pos += 1
+            elif param.kind is inspect._POSITIONAL_OR_KEYWORD:
+                pos = i - is_method
+                nm = param.name
+                typelist.append(ann)
+                req_pos += param.default is inspect._empty
+                max_pos += 1
+            elif param.kind is inspect._KEYWORD_ONLY:
+                nm = param.name
+                typelist.append((param.name, ann))
+                if param.default is inspect._empty:
+                    req_names.add(param.name)
+            elif param.kind is inspect._VAR_POSITIONAL:
+                raise TypeError("ovld does not support *args")
+            elif param.kind is inspect._VAR_KEYWORD:
+                raise TypeError("ovld does not support **kwargs")
+            arginfo.append(
+                Arginfo(
+                    position=pos,
+                    name=nm,
+                    required=param.default is inspect._empty,
+                    ann=normalize_type(param.annotation, fn),
+                )
+            )
 
-    Handler A, registered for types (A1, A2, ..., An), is more specific than
-    handler B, registered for types (B1, B2, ..., Bn), if there exists n such
-    that An is more specific than Bn, and for all n, either An == Bn or An is
-    more specific than Bn. An is more specific than Bn if An is a direct or
-    indirect subclass of Bn.
+        return cls(
+            types=tuple(typelist),
+            req_pos=req_pos,
+            max_pos=max_pos,
+            req_names=frozenset(req_names),
+            vararg=False,
+            is_method=is_method,
+            priority=None,
+            arginfo=arginfo,
+        )
 
-    In other words, [int, object] is more specific than [object, object] and
-    less specific than [int, int], but it is neither less specific nor more
-    specific than [object, int] (which means there is an ambiguity).
-    """
 
-    def __init__(self, key_error=KeyError):
-        self.maps = {}
-        self.priorities = {}
-        self.empty = MISSING
-        self.key_error = key_error
-        self.transform = type
-        self.all = {}
-        self.errors = {}
-
-    def _transform(self, obj):
-        if isinstance(obj, GenericAlias):
-            return type[obj]
-        elif obj is typing.Any:
-            return type[object]
-        elif isinstance(obj, type):
-            return type[obj]
+def clsstring(cls):
+    if cls is object:
+        return "*"
+    elif isinstance(cls, tuple):
+        key, typ = cls
+        return f"{key}: {clsstring(typ)}"
+    elif is_type_of_type(cls):
+        arg = clsstring(cls.__args__[0])
+        return f"type[{arg}]"
+    elif hasattr(cls, "__origin__"):
+        if cls.__origin__ is typing.Union:
+            return "|".join(map(clsstring, cls.__args__))
         else:
-            return type(obj)
-
-    def register(self, obj_t_tup, nargs, handler):
-        """Register a handler for a tuple of argument types.
-
-        Arguments:
-            obj_t_tup: A tuple of argument types.
-            nargs: A (amin, amax, varargs) tuple where amin is the minimum
-                number of arguments needed to match this tuple (if there are
-                default arguments, it is possible that amin < len(obj_t_tup)),
-                amax is the maximum number of arguments, and varargs is a
-                boolean indicating whether there can be an arbitrary number
-                of arguments.
-            handler: A function to handle the tuple.
-        """
-        self.clear()
-
-        if any(isinstance(x, GenericAlias) for x in obj_t_tup):
-            self.transform = self._transform
-
-        amin, amax, vararg, priority = nargs
-
-        entry = (handler, amin, amax, vararg)
-        if not obj_t_tup:
-            self.empty = entry
-
-        self.priorities[handler] = priority
-
-        for i, cls in enumerate(obj_t_tup):
-            if i not in self.maps:
-                self.maps[i] = TypeMap()
-            self.maps[i].register(cls, entry)
-        if vararg:
-            if -1 not in self.maps:
-                self.maps[-1] = TypeMap()
-            self.maps[-1].register(object, entry)
-
-    def resolve(self, obj_t_tup):
-        specificities = {}
-        candidates = None
-        nargs = len(obj_t_tup)
-
-        for i, cls in enumerate(obj_t_tup):
-            try:
-                results = self.maps[i][cls]
-            except KeyError:
-                results = {}
-
-            results = {
-                handler: spc
-                for (handler, min, max, va), spc in results.items()
-                if min <= nargs <= (math.inf if va else max)
-            }
-
-            try:
-                vararg_results = self.maps[-1][cls]
-            except KeyError:
-                vararg_results = {}
-
-            vararg_results = {
-                handler: spc
-                for (handler, min, max, va), spc in vararg_results.items()
-                if min <= nargs and i >= max
-            }
-
-            results.update(vararg_results)
-
-            if candidates is None:
-                candidates = set(results.keys())
-            else:
-                candidates &= results.keys()
-            for c in candidates:
-                specificities.setdefault(c, []).append(results[c])
+            return repr(cls)
+    elif hasattr(cls, "__name__"):
+        return cls.__name__
+    else:
+        return repr(cls)
 
-        if not candidates:
-            raise self.key_error(obj_t_tup, ())
 
-        candidates = [
-            (c, self.priorities.get(c, 0), tuple(specificities[c]))
-            for c in candidates
-        ]
+def sigstring(types):
+    return ", ".join(map(clsstring, types))
 
-        # The sort ensures that if candidate A dominates candidate B, A will
-        # appear before B in the list. That's because it must dominate all
-        # other possibilities on all arguments, so the sum of all specificities
-        # has to be greater.
-        # Note: priority is always more important than specificity
-        candidates.sort(key=lambda cspc: (cspc[1], sum(cspc[2])), reverse=True)
-
-        self.all[obj_t_tup] = {
-            getattr(c[0], "__code__", None) for c in candidates
-        }
-
-        def _pull(candidates):
-            if not candidates:
-                return
-            rval = [candidates[0]]
-            c1, p1, spc1 = candidates[0]
-            for c2, p2, spc2 in candidates[1:]:
-                if p1 > p2 or (
-                    spc1 != spc2 and all(s1 >= s2 for s1, s2 in zip(spc1, spc2))
-                ):
-                    # Candidate 1 dominates candidate 2
-                    continue
-                else:
-                    # Candidate 1 does not dominate candidate 2, so we add it
-                    # to the list.
-                    rval.append((c2, p2, spc2))
-            yield rval
-            if len(rval) == 1:
-                # Only groups of length 1 are correct and reachable, so we don't
-                # care about the rest.
-                yield from _pull(candidates[1:])
-
-        results = list(_pull(candidates))
-        parent = None
-        for group in results:
-            tup = obj_t_tup if parent is None else (parent, *obj_t_tup)
-            if len(group) != 1:
-                self.errors[tup] = self.key_error(obj_t_tup, group)
-                break
-            else:
-                ((fn, _, _),) = group
-                self[tup] = fn
-                if hasattr(fn, "__code__"):
-                    parent = fn.__code__
-                else:
-                    break
-
-        return True
-
-    def __missing__(self, obj_t_tup):
-        if obj_t_tup and isinstance(obj_t_tup[0], CodeType):
-            real_tup = obj_t_tup[1:]
-            self[real_tup]
-            if obj_t_tup[0] not in self.all[real_tup]:
-                return self[real_tup]
-            elif obj_t_tup in self.errors:
-                raise self.errors[obj_t_tup]
-            elif obj_t_tup in self:  # pragma: no cover
-                # PROBABLY not reachable
-                return self[obj_t_tup]
-            else:
-                raise self.key_error(real_tup, ())
-
-        if not obj_t_tup:
-            if self.empty is MISSING:
-                raise self.key_error(obj_t_tup, ())
-            else:
-                return self.empty[0]
 
-        self.resolve(obj_t_tup)
-        if obj_t_tup in self.errors:
-            raise self.errors[obj_t_tup]
-        else:
-            return self[obj_t_tup]
+class ArgumentAnalyzer:
+    def __init__(self):
+        self.name_to_positions = defaultdict(set)
+        self.position_to_names = defaultdict(set)
+        self.counts = defaultdict(lambda: [0, 0])
+        self.complex_transforms = set()
+        self.total = 0
+        self.is_method = None
+
+    def add(self, fn):
+        sig = Signature.extract(fn)
+        self.complex_transforms.update(
+            arg.canonical for arg in sig.arginfo if arg.is_complex
+        )
+        for arg in sig.arginfo:
+            if arg.position is not None:
+                self.position_to_names[arg.position].add(arg.name)
+            if arg.name is not None:
+                self.name_to_positions[arg.name].add(arg.canonical)
+
+            cnt = self.counts[arg.canonical]
+            cnt[0] += arg.required
+            cnt[1] += 1
+
+        self.total += 1
+
+        if self.is_method is None:
+            self.is_method = sig.is_method
+        elif self.is_method != sig.is_method:  # pragma: no cover
+            raise TypeError(
+                "Some, but not all registered methods define `self`. It should be all or none."
+            )
 
+    def compile(self):
+        for name, pos in self.name_to_positions.items():
+            if len(pos) != 1:
+                if all(isinstance(p, int) for p in pos):
+                    raise TypeError(
+                        f"Argument '{name}' is declared in different positions by different methods. The same argument name should always be in the same position unless it is strictly positional."
+                    )
+                else:
+                    raise TypeError(
+                        f"Argument '{name}' is declared in a positional and keyword setting by different methods. It should be either."
+                    )
 
-def _fresh(t):
-    """Returns a new subclass of type t.
+        p_to_n = [
+            list(names) for _, names in sorted(self.position_to_names.items())
+        ]
 
-    Each Ovld corresponds to its own class, which allows for specialization of
-    methods.
-    """
-    return type(t.__name__, (t,), {})
+        positional = list(
+            itertools.takewhile(
+                lambda names: len(names) == 1 and isinstance(names[0], str),
+                reversed(p_to_n),
+            )
+        )
+        positional.reverse()
+        strict_positional = p_to_n[: len(p_to_n) - len(positional)]
 
+        assert strict_positional + positional == p_to_n
 
-@keyword_decorator
-def _setattrs(fn, **kwargs):
-    for k, v in kwargs.items():
-        setattr(fn, k, v)
-    return fn
+        strict_positional_required = [
+            f"ARG{pos + 1}"
+            for pos, _ in enumerate(strict_positional)
+            if self.counts[pos][0] == self.total
+        ]
+        strict_positional_optional = [
+            f"ARG{pos + 1}"
+            for pos, _ in enumerate(strict_positional)
+            if self.counts[pos][0] != self.total
+        ]
 
+        positional_required = [
+            names[0]
+            for pos, names in enumerate(positional)
+            if self.counts[pos + len(strict_positional)][0] == self.total
+        ]
+        positional_optional = [
+            names[0]
+            for pos, names in enumerate(positional)
+            if self.counts[pos + len(strict_positional)][0] != self.total
+        ]
 
-@keyword_decorator
-def _compile_first(fn, rename=None):
-    def deco(self, *args, **kwargs):
-        self.compile()
-        method = getattr(self, fn.__name__)
-        assert method is not deco
-        return method(*args, **kwargs)
+        keywords = [
+            name
+            for _, (name,) in self.name_to_positions.items()
+            if not isinstance(name, int)
+        ]
+        keyword_required = [
+            name for name in keywords if self.counts[name][0] == self.total
+        ]
+        keyword_optional = [
+            name for name in keywords if self.counts[name][0] != self.total
+        ]
 
-    def setalt(alt):
-        deco._alt = alt
-        return None
+        return (
+            strict_positional_required,
+            strict_positional_optional,
+            positional_required,
+            positional_optional,
+            keyword_required,
+            keyword_optional,
+        )
 
-    deco.setalt = setalt
-    deco._replace_by = fn
-    deco._alt = None
-    deco._rename = rename
-    return deco
+    def lookup_for(self, key):
+        return (
+            "self.map.transform" if key in self.complex_transforms else "type"
+        )
 
 
 class _Ovld:
@@ -334,19 +289,11 @@ class _Ovld:
     function should annotate the same parameter.
 
     Arguments:
-        dispatch: A function to use as the entry point. It must find the
-            function to dispatch to and call it.
-        postprocess: A function to call on the return value. It is not called
-            after recursive calls.
         mixins: A list of Ovld instances that contribute functions to this
             Ovld.
-        type_error: The error type to raise when no function can be found to
-            dispatch to (default: TypeError).
         name: Optional name for the Ovld. If not provided, it will be
             gotten automatically from the first registered function or
             dispatch.
-        mapper: Class implementing a mapping interface from a tuple of
-            types to a handler (default: MultiTypeMap).
         linkback: Whether to keep a pointer in the parent mixins to this
             ovld so that updates can be propagated. (default: False)
         allow_replacement: Allow replacing a method by another with the
@@ -356,43 +303,27 @@ class _Ovld:
     def __init__(
         self,
         *,
-        dispatch=None,
-        postprocess=None,
-        type_error=TypeError,
         mixins=[],
         bootstrap=None,
         name=None,
-        mapper=MultiTypeMap,
         linkback=False,
         allow_replacement=True,
     ):
         """Initialize an Ovld."""
+        self.id = next(_current_id)
         self._compiled = False
-        self._dispatch = dispatch
-        self.maindoc = None
-        self.mapper = mapper
         self.linkback = linkback
         self.children = []
-        self.type_error = type_error
-        self.postprocess = postprocess
         self.allow_replacement = allow_replacement
-        self.bootstrap_class = OvldCall
-        if self.postprocess:
-            assert bootstrap is not False
-            self.bootstrap = True
-        elif isinstance(bootstrap, type):
-            self.bootstrap_class = bootstrap
-            self.bootstrap = True
-        else:
-            self.bootstrap = bootstrap
+        self.bootstrap = bootstrap
         self.name = name
+        self.shortname = name or f"__OVLD{self.id}"
         self.__name__ = name
         self._defns = {}
         self._locked = False
         self.mixins = []
         self.add_mixins(*mixins)
-        self.ocls = _fresh(self.bootstrap_class)
-        self._make_signature()
+        self.ocls = _fresh(OvldCall)
 
     @property
     def defns(self):
@@ -402,6 +333,42 @@ class _Ovld:
         defns.update(self._defns)
         return defns
 
+    @property
+    def __doc__(self):
+        if not self._compiled:
+            self.compile()
+
+        docs = [fn.__doc__ for fn in self.defns.values() if fn.__doc__]
+        if len(docs) == 1:
+            maindoc = docs[0]
+        else:
+            maindoc = f"Ovld with {len(self.defns)} methods."
+
+        doc = f"{maindoc}\n\n"
+        for fn in self.defns.values():
+            fndef = inspect.signature(fn)
+            fdoc = fn.__doc__
+            if not fdoc or fdoc == maindoc:
+                doc += f"{self.__name__}{fndef}\n\n"
+            else:
+                if not fdoc.strip(" ").endswith("\n"):
+                    fdoc += "\n"
+                fdoc = textwrap.indent(fdoc, " " * 4)
+                doc += f"{self.__name__}{fndef}\n{fdoc}\n"
+        return doc
+
+    @property
+    def __signature__(self):
+        if not self._compiled:
+            self.compile()
+
+        sig = inspect.signature(self._dispatch)
+        if not self.argument_analysis.is_method:
+            sig = inspect.Signature(
+                [v for k, v in sig.parameters.items() if k != "self"]
+            )
+        return sig
+
     def lock(self):
         self._locked = True
 
@@ -414,40 +381,21 @@ class _Ovld:
         for mixin in mixins:
             if self.linkback:
                 mixin.children.append(self)
-            if mixin._defns:
-                assert mixin.bootstrap is not None
-                if self.bootstrap is None:
-                    self.bootstrap = mixin.bootstrap
-                assert mixin.bootstrap is self.bootstrap
-            if mixin._dispatch:
-                self._dispatch = mixin._dispatch
+            if mixin._defns and self.bootstrap is None:
+                self.bootstrap = mixin.bootstrap
         self.mixins += mixins
 
-    def _sig_string(self, type_tuple):
-        def clsname(cls):
-            if cls is object:
-                return "*"
-            elif is_type_of_type(cls):
-                arg = clsname(cls.__args__[0])
-                return f"type[{arg}]"
-            elif hasattr(cls, "__name__"):
-                return cls.__name__
-            else:
-                return repr(cls)
-
-        return ", ".join(map(clsname, type_tuple))
-
     def _key_error(self, key, possibilities=None):
-        typenames = self._sig_string(key)
+        typenames = sigstring(key)
         if not possibilities:
-            return self.type_error(
+            return TypeError(
                 f"No method in {self} for argument types [{typenames}]"
             )
         else:
             hlp = ""
             for p, prio, spc in possibilities:
                 hlp += f"* {p.__name__}  (priority: {prio}, specificity: {list(spc)})\n"
-            return self.type_error(
+            return TypeError(
                 f"Ambiguous resolution in {self} for"
                 f" argument types [{typenames}]\n"
                 f"Candidates are:\n{hlp}"
@@ -458,58 +406,15 @@ class _Ovld:
         """Rename this Ovld."""
         self.name = name
         self.__name__ = name
-        self._make_signature()
-
-    def _make_signature(self):
-        """Make the __doc__ and __signature__."""
-
-        def modelA(*args, **kwargs):  # pragma: no cover
-            pass
 
-        def modelB(self, *args, **kwargs):  # pragma: no cover
-            pass
-
-        seen = set()
-        doc = (
-            f"{self.maindoc}\n"
-            if self.maindoc
-            else f"Ovld with {len(self.defns)} methods.\n\n"
-        )
-        for key, fn in self.defns.items():
-            if fn in seen:
-                continue
-            seen.add(fn)
-            fndef = inspect.signature(fn)
-            fdoc = fn.__doc__
-            if not fdoc or fdoc == self.maindoc:
-                doc += f"    ``{self.__name__}{fndef}``\n\n"
-            else:
-                if not fdoc.strip(" ").endswith("\n"):
-                    fdoc += "\n"
-                fdoc = textwrap.indent(fdoc, " " * 8)
-                doc += f"    ``{self.__name__}{fndef}``\n{fdoc}\n"
-        self.__doc__ = doc
-        if self.bootstrap:
-            self.__signature__ = inspect.signature(modelB)
-        else:
-            self.__signature__ = inspect.signature(modelA)
-
-    def _set_attrs_from(self, fn, dispatch=False):
+    def _set_attrs_from(self, fn):
         """Inherit relevant attributes from the function."""
         if self.bootstrap is None:
-            sign = inspect.signature(fn)
-            params = list(sign.parameters.values())
-            if not dispatch:
-                if params and params[0].name == "self":
-                    self.bootstrap = True
-                else:
-                    self.bootstrap = False
+            self.bootstrap = arg0_is_self(fn)
 
         if self.name is None:
             self.name = f"{fn.__module__}.{fn.__qualname__}"
-            self.maindoc = fn.__doc__
-            if self.maindoc and not self.maindoc.strip(" ").endswith("\n"):
-                self.maindoc += "\n"
+            self.shortname = fn.__name__
             self.__name__ = fn.__name__
             self.__qualname__ = fn.__qualname__
             self.__module__ = fn.__module__
@@ -533,57 +438,51 @@ class _Ovld:
         for mixin in self.mixins:
             if self not in mixin.children:
                 mixin.lock()
-        self._compiled = True
-        self.map = self.mapper(key_error=self._key_error)
 
         cls = type(self)
         if self.name is None:
-            self.name = self.__name__ = f"ovld{id(self)}"
+            self.name = self.__name__ = f"ovld{self.id}"
 
         name = self.__name__
+        self.map = MultiTypeMap(name=name, key_error=self._key_error)
 
         # Replace the appropriate functions by their final behavior
         for method in dir(cls):
             value = getattr(cls, method)
             repl = getattr(value, "_replace_by", None)
             if repl:
-                if self.bootstrap and value._alt:
-                    repl = value._alt
                 repl = self._maybe_rename(repl)
                 setattr(cls, method, repl)
 
         target = self.ocls if self.bootstrap else cls
-        if self._dispatch:
-            target.__call__ = self._dispatch
 
-        # Rename the dispatch
-        target.__call__ = rename_function(target.__call__, f"{name}.dispatch")
+        anal = ArgumentAnalyzer()
+        for key, fn in list(self.defns.items()):
+            anal.add(fn)
+        self.argument_analysis = anal
+        dispatch = generate_dispatch(anal)
+        self._dispatch = dispatch
+        target.__call__ = rename_function(dispatch, f"{name}.dispatch")
 
         for key, fn in list(self.defns.items()):
             self.register_signature(key, fn)
 
-    def dispatch(self, dispatch):
-        """Set a dispatch function."""
-        if self._dispatch is not None:
-            raise TypeError(f"dispatch for {self} is already set")
-        self._dispatch = dispatch
-        self._set_attrs_from(dispatch, dispatch=True)
-        return self
+        self._compiled = True
 
+    @_compile_first
     def resolve(self, *args):
         """Find the correct method to call for the given arguments."""
         return self.map[tuple(map(self.map.transform, args))]
 
-    def register_signature(self, key, orig_fn):
+    def register_signature(self, sig, orig_fn):
         """Register a function for the given signature."""
-        sig, min, max, vararg, priority = key
-        fn = rename_function(
-            orig_fn, f"{self.__name__}[{self._sig_string(sig)}]"
+        fn = adapt_function(
+            orig_fn, self, f"{self.__name__}[{sigstring(sig.types)}]"
         )
         # We just need to keep the Conformer pointer alive for jurigged
         # to find it, if jurigged is used with ovld
         fn._conformer = Conformer(self, orig_fn, fn)
-        self.map.register(sig, (min, max, vararg, priority), fn)
+        self.map.register(sig, fn)
         return self
 
     def register(self, fn=None, priority=0):
@@ -595,60 +494,17 @@ class _Ovld:
     def _register(self, fn, priority):
         """Register a function."""
 
-        def _normalize_type(t, force_tuple=False):
-            origin = getattr(t, "__origin__", None)
-            if UnionType and isinstance(t, UnionType):
-                return _normalize_type(t.__args__)
-            elif origin is type:
-                return (t,) if force_tuple else t
-            elif origin is typing.Union:
-                return _normalize_type(t.__args__)
-            elif origin is not None:
-                raise TypeError(
-                    f"ovld does not accept generic types except type, Union or Optional, not {t}"
-                )
-            elif isinstance(t, tuple):
-                return tuple(_normalize_type(t2) for t2 in t)
-            elif force_tuple:
-                return (t,)
-            else:
-                return t
-
         self._attempt_modify()
 
         self._set_attrs_from(fn)
 
-        ann = fn.__annotations__
-        argspec = inspect.getfullargspec(fn)
-        argnames = argspec.args
-        if self.bootstrap:
-            if argnames[0] != "self":
-                raise TypeError(
-                    "The first argument of the function must be named `self`"
-                )
-            argnames = argnames[1:]
-
-        typelist = []
-        for i, name in enumerate(argnames):
-            t = ann.get(name, None)
-            if t is None:
-                typelist.append(object)
-            else:
-                typelist.append(t)
-
-        max_pos = len(argnames)
-        req_pos = max_pos - len(argspec.defaults or ())
-
-        typelist_tups = tuple(
-            _normalize_type(t, force_tuple=True) for t in typelist
-        )
-        for tl in itertools.product(*typelist_tups):
-            sig = (tuple(tl), req_pos, max_pos, bool(argspec.varargs), priority)
-            if not self.allow_replacement and sig in self._defns:
-                raise TypeError(f"There is already a method for {tl}")
-            self._defns[(*sig,)] = fn
+        sig = replace(Signature.extract(fn), priority=priority)
+        if not self.allow_replacement and sig in self._defns:
+            raise TypeError(
+                f"There is already a method for {sigstring(sig.types)}"
+            )
+        self._defns[sig] = fn
 
-        self._make_signature()
         self._update()
         return self
 
@@ -664,13 +520,7 @@ class _Ovld:
         for child in self.children:
             child._update()
 
-    def copy(
-        self,
-        dispatch=MISSING,
-        postprocess=None,
-        mixins=[],
-        linkback=False,
-    ):
+    def copy(self, mixins=[], linkback=False):
         """Create a copy of this Ovld.
 
         New functions can be registered to the copy without affecting the
@@ -678,13 +528,11 @@ class _Ovld:
         """
         return _fresh(_Ovld)(
             bootstrap=self.bootstrap,
-            dispatch=self._dispatch if dispatch is MISSING else dispatch,
             mixins=[self, *mixins],
-            postprocess=postprocess or self.postprocess,
             linkback=linkback,
         )
 
-    def variant(self, fn=None, **kwargs):
+    def variant(self, fn=None, priority=0, **kwargs):
         """Decorator to create a variant of this Ovld.
 
         New functions can be registered to the variant without affecting the
@@ -692,73 +540,58 @@ class _Ovld:
         """
         ov = self.copy(**kwargs)
         if fn is None:
-            return ov.register
+            return partial(ov.register, priority=priority)
         else:
-            ov.register(fn)
+            ov.register(fn, priority=priority)
             return ov
 
-    @_compile_first
-    def get_map(self):
-        return self.map
-
     @_compile_first
     def __get__(self, obj, cls):
         if obj is None:
             return self
-        return self.ocls(
-            map=self.map,
-            bind_to=obj,
-            super=self.mixins[0] if len(self.mixins) == 1 else None,
-        )
+        key = self.shortname
+        rval = obj.__dict__.get(key, None)
+        if rval is None:
+            obj.__dict__[key] = rval = self.ocls(self, obj)
+        return rval
 
     @_compile_first
     def __getitem__(self, t):
         if not isinstance(t, tuple):
             t = (t,)
-        assert not self.bootstrap
         return self.map[t]
 
     @_compile_first
     @_setattrs(rename="dispatch")
-    def __call__(self, *args, **kwargs):
+    def __call__(self, *args):  # pragma: no cover
         """Call the overloaded function.
 
-        This version of __call__ is used when bootstrap is False.
-
-        If bootstrap is False and a dispatch function is provided, it
-        replaces this function.
+        This should be replaced by an auto-generated function.
         """
         key = tuple(map(self.map.transform, args))
         method = self.map[key]
-        return method(*args, **kwargs)
+        return method(*args)
 
     @_compile_first
     @_setattrs(rename="next")
-    def next(self, *args, **kwargs):
+    def next(self, *args):
         """Call the next matching method after the caller, in terms of priority or specificity."""
         fr = sys._getframe(1)
         key = (fr.f_code, *map(self.map.transform, args))
         method = self.map[key]
-        return method(*args, **kwargs)
-
-    @__call__.setalt
-    @_setattrs(rename="entry")
-    def __ovldcall__(self, *args, **kwargs):
-        """Call the overloaded function.
-
-        This version of __call__ is used when bootstrap is True. This function is
-        only called once at the entry point: recursive calls will will be to
-        OvldCall.__call__.
-        """
-        ovc = self.__get__(BOOTSTRAP, None)
-        res = ovc(*args, **kwargs)
-        if self.postprocess:
-            res = self.postprocess(self, res)
-        return res
+        return method(*args)
 
     def __repr__(self):
         return f"<Ovld {self.name or hex(id(self))}>"
 
+    @_compile_first
+    def display_methods(self):
+        self.map.display_methods()
+
+    @_compile_first
+    def display_resolution(self, *args, **kwargs):
+        self.map.display_resolution(*args, **kwargs)
+
 
 def is_ovld(x):
     """Return whether the argument is an ovld function/method."""
@@ -768,47 +601,43 @@ def is_ovld(x):
 class OvldCall:
     """Context for an Ovld call."""
 
-    def __init__(self, map, bind_to, super=None):
+    def __init__(self, ovld, bind_to):
         """Initialize an OvldCall."""
-        self.map = map
-        self._parent = super
-        self.obj = self if bind_to is BOOTSTRAP else bind_to
+        self.ovld = ovld
+        self.map = ovld.map
+        self.obj = bind_to
 
-    def __getitem__(self, t):
-        """Find the right method to call given a tuple of types."""
-        if not isinstance(t, tuple):
-            t = (t,)
-        return self.map[t].__get__(self.obj)
+    @property
+    def __name__(self):
+        return self.ovld.__name__
+
+    @property
+    def __doc__(self):
+        return self.ovld.__doc__
+
+    @property
+    def __signature__(self):
+        return self.ovld.__signature__
 
-    def next(self, *args, **kwargs):
+    def next(self, *args):
         """Call the next matching method after the caller, in terms of priority or specificity."""
         fr = sys._getframe(1)
         key = (fr.f_code, *map(self.map.transform, args))
         method = self.map[key]
-        return method(self.obj, *args, **kwargs)
-
-    def super(self, *args, **kwargs):
-        """Use the parent ovld's method for this call."""
-        pmap = self._parent.get_map()
-        method = pmap[tuple(map(pmap.transform, args))]
-        return method.__get__(self.obj)(*args, **kwargs)
+        return method(self.obj, *args)
 
     def resolve(self, *args):
         """Find the right method to call for the given arguments."""
-        return self[tuple(map(self.map.transform, args))]
-
-    def call(self, *args):
-        """Call the right method for the given arguments."""
-        return self[tuple(map(self.map.transform, args))](*args)
+        return self.map[tuple(map(self.map.transform, args))].__get__(self.obj)
 
-    def __call__(self, *args, **kwargs):
+    def __call__(self, *args):  # pragma: no cover
         """Call this overloaded function.
 
-        If a dispatch function is provided, it replaces this function.
+        This should be replaced by an auto-generated function.
         """
         key = tuple(map(self.map.transform, args))
         method = self.map[key]
-        return method(self.obj, *args, **kwargs)
+        return method(self.obj, *args)
 
 
 def Ovld(*args, **kwargs):
@@ -823,7 +652,7 @@ def extend_super(fn):
     plus this definition and others with the same name.
     """
     if not is_ovld(fn):
-        fn = ovld(fn)
+        fn = ovld(fn, fresh=True)
     fn._extend_super = True
     return fn
 
@@ -835,29 +664,45 @@ class ovld_cls_dict(dict):
     """
 
     def __init__(self, bases):
-        self._mock = type("MockSuper", bases, {})
+        self._bases = bases
 
     def __setitem__(self, attr, value):
+        prev = None
         if attr in self:
             prev = self[attr]
+            if inspect.isfunction(prev):
+                prev = ovld(prev, fresh=True)
+            elif not is_ovld(prev):  # pragma: no cover
+                prev = None
         elif is_ovld(value) and getattr(value, "_extend_super", False):
-            prev = getattr(self._mock, attr, None)
-            if is_ovld(prev):
-                prev = prev.copy()
+            mixins = []
+            for base in self._bases:
+                if (candidate := getattr(base, attr, None)) is not None:
+                    if is_ovld(candidate) or inspect.isfunction(candidate):
+                        mixins.append(candidate)
+            if mixins:
+                prev, *others = mixins
+                if is_ovld(prev):
+                    prev = prev.copy()
+                else:
+                    prev = ovld(prev, fresh=True)
+                for other in others:
+                    if is_ovld(other):
+                        prev.add_mixins(other)
+                    else:
+                        prev.register(other)
         else:
             prev = None
 
         if prev is not None:
-            if inspect.isfunction(prev):
-                prev = ovld(prev)
-
-            if is_ovld(prev):
-                if is_ovld(value):
-                    prev.add_mixins(value)
-                    value = prev
-                elif inspect.isfunction(value):
-                    prev.register(value)
-                    value = prev
+            if is_ovld(value) and prev is not value:
+                if prev.name is None:
+                    prev.rename(value.name)
+                prev.add_mixins(value)
+                value = prev
+            elif inspect.isfunction(value):
+                prev.register(value)
+                value = prev
 
         super().__setitem__(attr, value)
 
@@ -905,19 +750,31 @@ class OvldBase(metaclass=OvldMC):
 
 
 def _find_overload(fn, **kwargs):
-    mod = __import__(fn.__module__, fromlist="_")
-    dispatch = getattr(mod, fn.__qualname__, None)
+    fr = sys._getframe(1)  # We typically expect to get to frame 3.
+    while fr and fn.__code__ not in fr.f_code.co_consts:
+        # We are basically searching for the function's code object in the stack.
+        # When a class/function A is nested in a class/function B, the former's
+        # code object is in the latter's co_consts. If ovld is used as a decorator,
+        # on A, then necessarily we are inside the execution of B, so B should be
+        # on the stack and we should be able to find A's code object in there.
+        fr = fr.f_back
+
+    if not fr:
+        raise UsageError("@ovld only works as a decorator.")
+
+    dispatch = fr.f_locals.get(fn.__name__, None)
+
     if dispatch is None:
         dispatch = _fresh(_Ovld)(**kwargs)
+    elif not is_ovld(dispatch):  # pragma: no cover
+        raise TypeError("@ovld requires Ovld instance")
     elif kwargs:  # pragma: no cover
         raise TypeError("Cannot configure an overload that already exists")
-    if not is_ovld(dispatch):  # pragma: no cover
-        raise TypeError("@ovld requires Ovld instance")
     return dispatch
 
 
 @keyword_decorator
-def ovld(fn, priority=0, **kwargs):
+def ovld(fn, priority=0, fresh=False, **kwargs):
     """Overload a function.
 
     Overloading is based on the function name.
@@ -931,71 +788,29 @@ def ovld(fn, priority=0, **kwargs):
 
     Arguments:
         fn: The function to register.
-        dispatch: A function to use as the entry point. It must find the
-            function to dispatch to and call it.
-        postprocess: A function to call on the return value. It is not called
-            after recursive calls.
+        priority: The priority of the function in the resolution order.
+        fresh: Whether to create a new ovld or try to reuse an existing one.
         mixins: A list of Ovld instances that contribute functions to this
             Ovld.
-        type_error: The error type to raise when no function can be found to
-            dispatch to (default: TypeError).
         name: Optional name for the Ovld. If not provided, it will be
             gotten automatically from the first registered function or
             dispatch.
-        mapper: Class implementing a mapping interface from a tuple of
-            types to a handler (default: MultiTypeMap).
         linkback: Whether to keep a pointer in the parent mixins to this
             ovld so that updates can be propagated. (default: False)
     """
-    dispatch = _find_overload(fn, **kwargs)
+    if fresh:
+        dispatch = _fresh(_Ovld)(**kwargs)
+    else:
+        dispatch = _find_overload(fn, **kwargs)
     return dispatch.register(fn, priority=priority)
 
 
-@keyword_decorator
-def ovld_dispatch(dispatch, **kwargs):
-    """Overload a function using the decorated function as a dispatcher.
-
-    The dispatch is the entry point for the function and receives a `self`
-    which is an Ovld or OvldCall instance, and the rest of the arguments.
-    It may call `self.resolve(arg1, arg2, ...)` to get the right method to
-    call.
-
-    The decorator optionally takes keyword arguments, *only* on the first
-    use.
-
-    Arguments:
-        dispatch: The function to use as the entry point. It must find the
-            function to dispatch to and call it.
-        postprocess: A function to call on the return value. It is not called
-            after recursive calls.
-        mixins: A list of Ovld instances that contribute functions to this
-            Ovld.
-        type_error: The error type to raise when no function can be found to
-            dispatch to (default: TypeError).
-        name: Optional name for the Ovld. If not provided, it will be
-            gotten automatically from the first registered function or
-            dispatch.
-        mapper: Class implementing a mapping interface from a tuple of
-            types to a handler (default: MultiTypeMap).
-        linkback: Whether to keep a pointer in the parent mixins to this
-            ovld so that updates can be propagated. (default: False)
-    """
-    ov = _find_overload(dispatch, **kwargs)
-    return ov.dispatch(dispatch)
-
-
-ovld.dispatch = ovld_dispatch
-
-
 __all__ = [
-    "MultiTypeMap",
     "Ovld",
     "OvldBase",
     "OvldCall",
     "OvldMC",
-    "TypeMap",
     "extend_super",
     "is_ovld",
     "ovld",
-    "ovld_dispatch",
 ]