ovld 0.4.3__py3-none-any.whl → 0.4.5__py3-none-any.whl

ovld/core.py

@@ -5,36 +5,24 @@ import itertools
 import sys
 import textwrap
 import typing
-from collections import defaultdict
+from collections import OrderedDict, defaultdict
 from dataclasses import dataclass, field, replace
 from functools import cached_property, partial
-from types import GenericAlias
+from types import FunctionType, GenericAlias
 
 from .recode import (
     Conformer,
     adapt_function,
     generate_dispatch,
-    rename_function,
+    rename_code,
 )
-from .typemap import MultiTypeMap, is_type_of_type
-from .types import normalize_type
-from .utils import UsageError, keyword_decorator
+from .typemap import MultiTypeMap
+from .types import clsstring, normalize_type
+from .utils import MISSING, UsageError, keyword_decorator, subtler_type
 
 _current_id = itertools.count()
 
 
-def _fresh(t):
-    """Returns a new subclass of type t.
-
-    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)
-
-
 @keyword_decorator
 def _setattrs(fn, **kwargs):
     for k, v in kwargs.items():
@@ -42,23 +30,107 @@ def _setattrs(fn, **kwargs):
     return fn
 
 
-@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)
+class LazySignature(inspect.Signature):
+    def __init__(self, ovld):
+        super().__init__([])
+        self.ovld = ovld
 
-    first_entry._replace_by = fn
-    first_entry._rename = rename
-    return first_entry
+    def replace(
+        self, *, parameters=inspect._void, return_annotation=inspect._void
+    ):  # pragma: no cover
+        if parameters is inspect._void:
+            parameters = self.parameters.values()
 
+        if return_annotation is inspect._void:
+            return_annotation = self._return_annotation
 
-def arg0_is_self(fn):
-    sgn = inspect.signature(fn)
-    params = list(sgn.parameters.values())
-    return params and params[0].name == "self"
+        return inspect.Signature(
+            parameters, return_annotation=return_annotation
+        )
+
+    @property
+    def parameters(self):
+        anal = self.ovld.analyze_arguments()
+        parameters = []
+        if anal.is_method:
+            parameters.append(
+                inspect.Parameter(
+                    name="self",
+                    kind=inspect._POSITIONAL_ONLY,
+                )
+            )
+        parameters += [
+            inspect.Parameter(
+                name=p,
+                kind=inspect._POSITIONAL_ONLY,
+            )
+            for p in anal.strict_positional_required
+        ]
+        parameters += [
+            inspect.Parameter(
+                name=p,
+                kind=inspect._POSITIONAL_ONLY,
+                default=MISSING,
+            )
+            for p in anal.strict_positional_optional
+        ]
+        parameters += [
+            inspect.Parameter(
+                name=p,
+                kind=inspect._POSITIONAL_OR_KEYWORD,
+            )
+            for p in anal.positional_required
+        ]
+        parameters += [
+            inspect.Parameter(
+                name=p,
+                kind=inspect._POSITIONAL_OR_KEYWORD,
+                default=MISSING,
+            )
+            for p in anal.positional_optional
+        ]
+        parameters += [
+            inspect.Parameter(
+                name=p,
+                kind=inspect._KEYWORD_ONLY,
+            )
+            for p in anal.keyword_required
+        ]
+        parameters += [
+            inspect.Parameter(
+                name=p,
+                kind=inspect._KEYWORD_ONLY,
+                default=MISSING,
+            )
+            for p in anal.keyword_optional
+        ]
+        return OrderedDict({p.name: p for p in parameters})
+
+
+def bootstrap_dispatch(ov, name):
+    def first_entry(*args, **kwargs):
+        ov.compile()
+        return ov.dispatch(*args, **kwargs)
+
+    dispatch = FunctionType(
+        rename_code(first_entry.__code__, name),
+        {},
+        name,
+        (),
+        first_entry.__closure__,
+    )
+    dispatch.__signature__ = LazySignature(ov)
+    dispatch.__ovld__ = ov
+    dispatch.register = ov.register
+    dispatch.resolve = ov.resolve
+    dispatch.copy = ov.copy
+    dispatch.variant = ov.variant
+    dispatch.display_methods = ov.display_methods
+    dispatch.display_resolution = ov.display_resolution
+    dispatch.add_mixins = ov.add_mixins
+    dispatch.unregister = ov.unregister
+    dispatch.next = ov.next
+    return dispatch
 
 
 @dataclass(frozen=True)
@@ -80,6 +152,7 @@ class Arginfo:
 @dataclass(frozen=True)
 class Signature:
     types: tuple
+    return_type: type
     req_pos: int
     max_pos: int
     req_names: frozenset
@@ -139,6 +212,7 @@ class Signature:
 
         return cls(
             types=tuple(typelist),
+            return_type=normalize_type(sig.return_annotation, fn),
             req_pos=req_pos,
             max_pos=max_pos,
             req_names=frozenset(req_names),
@@ -149,28 +223,16 @@ class Signature:
         )
 
 
-def clsstring(cls):
-    if cls is object:
-        return "*"
-    elif isinstance(cls, tuple):
+def typemap_entry_string(cls):
+    if 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 repr(cls)
-    elif hasattr(cls, "__name__"):
-        return cls.__name__
     else:
-        return repr(cls)
+        return clsstring(cls)
 
 
 def sigstring(types):
-    return ", ".join(map(clsstring, types))
+    return ", ".join(map(typemap_entry_string, types))
 
 
 class ArgumentAnalyzer:
@@ -181,8 +243,10 @@ class ArgumentAnalyzer:
         self.complex_transforms = set()
         self.total = 0
         self.is_method = None
+        self.done = False
 
     def add(self, fn):
+        self.done = False
         sig = Signature.extract(fn)
         self.complex_transforms.update(
             arg.canonical for arg in sig.arginfo if arg.is_complex
@@ -207,6 +271,8 @@ class ArgumentAnalyzer:
             )
 
     def compile(self):
+        if self.done:
+            return
         for name, pos in self.name_to_positions.items():
             if len(pos) != 1:
                 if all(isinstance(p, int) for p in pos):
@@ -233,23 +299,23 @@ class ArgumentAnalyzer:
 
         assert strict_positional + positional == p_to_n
 
-        strict_positional_required = [
+        self.strict_positional_required = [
             f"ARG{pos + 1}"
             for pos, _ in enumerate(strict_positional)
             if self.counts[pos][0] == self.total
         ]
-        strict_positional_optional = [
+        self.strict_positional_optional = [
             f"ARG{pos + 1}"
             for pos, _ in enumerate(strict_positional)
             if self.counts[pos][0] != self.total
         ]
 
-        positional_required = [
+        self.positional_required = [
             names[0]
             for pos, names in enumerate(positional)
             if self.counts[pos + len(strict_positional)][0] == self.total
         ]
-        positional_optional = [
+        self.positional_optional = [
             names[0]
             for pos, names in enumerate(positional)
             if self.counts[pos + len(strict_positional)][0] != self.total
@@ -260,29 +326,19 @@ class ArgumentAnalyzer:
             for _, (name,) in self.name_to_positions.items()
             if not isinstance(name, int)
         ]
-        keyword_required = [
+        self.keyword_required = [
             name for name in keywords if self.counts[name][0] == self.total
         ]
-        keyword_optional = [
+        self.keyword_optional = [
             name for name in keywords if self.counts[name][0] != self.total
         ]
-
-        return (
-            strict_positional_required,
-            strict_positional_optional,
-            positional_required,
-            positional_optional,
-            keyword_required,
-            keyword_optional,
-        )
+        self.done = True
 
     def lookup_for(self, key):
-        return (
-            "self.map.transform" if key in self.complex_transforms else "type"
-        )
+        return subtler_type if key in self.complex_transforms else type
 
 
-class _Ovld:
+class Ovld:
     """Overloaded function.
 
     A function can be added with the `register` method. One of its parameters
@@ -305,7 +361,6 @@ class _Ovld:
         self,
         *,
         mixins=[],
-        bootstrap=None,
         name=None,
         linkback=False,
         allow_replacement=True,
@@ -316,15 +371,14 @@ class _Ovld:
         self.linkback = linkback
         self.children = []
         self.allow_replacement = allow_replacement
-        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.argument_analysis = ArgumentAnalyzer()
         self.add_mixins(*mixins)
-        self.ocls = _fresh(OvldCall)
 
     @property
     def defns(self):
@@ -334,11 +388,14 @@ class _Ovld:
         defns.update(self._defns)
         return defns
 
-    @property
-    def __doc__(self):
-        if not self._compiled:
-            self.compile()
+    def analyze_arguments(self):
+        self.argument_analysis = ArgumentAnalyzer()
+        for key, fn in list(self.defns.items()):
+            self.argument_analysis.add(fn)
+        self.argument_analysis.compile()
+        return self.argument_analysis
 
+    def mkdoc(self):
         docs = [fn.__doc__ for fn in self.defns.values() if fn.__doc__]
         if len(docs) == 1:
             maindoc = docs[0]
@@ -359,16 +416,13 @@ class _Ovld:
         return doc
 
     @property
-    def __signature__(self):
-        if not self._compiled:
-            self.compile()
+    def __doc__(self):
+        self.ensure_compiled()
+        return self.mkdoc()
 
-        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
+    @property
+    def __signature__(self):
+        return self.dispatch.__signature__
 
     def lock(self):
         self._locked = True
@@ -379,11 +433,10 @@ class _Ovld:
 
     def add_mixins(self, *mixins):
         self._attempt_modify()
+        mixins = [o for m in mixins if (o := to_ovld(m)) is not self]
         for mixin in mixins:
             if self.linkback:
                 mixin.children.append(self)
-            if mixin._defns and self.bootstrap is None:
-                self.bootstrap = mixin.bootstrap
         self.mixins += mixins
 
     def _key_error(self, key, possibilities=None):
@@ -403,28 +456,23 @@ class _Ovld:
                 "Note: you can use @ovld(priority=X) to give higher priority to an overload."
             )
 
-    def rename(self, name):
+    def rename(self, name, shortname=None):
         """Rename this Ovld."""
         self.name = name
-        self.__name__ = name
+        self.shortname = shortname or name
+        self.__name__ = shortname
+        self.dispatch = bootstrap_dispatch(self, name=self.shortname)
 
     def _set_attrs_from(self, fn):
         """Inherit relevant attributes from the function."""
-        if self.bootstrap is None:
-            self.bootstrap = arg0_is_self(fn)
-
         if self.name is None:
-            self.name = f"{fn.__module__}.{fn.__qualname__}"
-            self.shortname = fn.__name__
-            self.__name__ = fn.__name__
             self.__qualname__ = fn.__qualname__
             self.__module__ = fn.__module__
+            self.rename(f"{fn.__module__}.{fn.__qualname__}", fn.__name__)
 
-    def _maybe_rename(self, fn):
-        if hasattr(fn, "rename"):
-            return rename_function(fn, f"{self.__name__}.{fn.rename}")
-        else:
-            return fn
+    def ensure_compiled(self):
+        if not self._compiled:
+            self.compile()
 
     def compile(self):
         """Finalize this overload.
@@ -440,40 +488,33 @@ class _Ovld:
             if self not in mixin.children:
                 mixin.lock()
 
-        cls = type(self)
         if self.name is None:
             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:
-                repl = self._maybe_rename(repl)
-                setattr(cls, method, repl)
-
-        target = self.ocls if self.bootstrap else cls
-
-        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")
+        self.analyze_arguments()
+        dispatch = generate_dispatch(self, self.argument_analysis)
+        if not hasattr(self, "dispatch"):
+            self.dispatch = bootstrap_dispatch(self, name=self.shortname)
+        self.dispatch.__code__ = rename_code(dispatch.__code__, self.shortname)
+        self.dispatch.__kwdefaults__ = dispatch.__kwdefaults__
+        self.dispatch.__annotations__ = dispatch.__annotations__
+        self.dispatch.__defaults__ = dispatch.__defaults__
+        self.dispatch.__globals__.update(dispatch.__globals__)
+        self.dispatch.map = self.map
+        self.dispatch.__doc__ = self.mkdoc()
 
         for key, fn in list(self.defns.items()):
             self.register_signature(key, fn)
 
         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))]
+        self.ensure_compiled()
+        return self.map[tuple(map(subtler_type, args))]
 
     def register_signature(self, sig, orig_fn):
         """Register a function for the given signature."""
@@ -528,6 +569,8 @@ class _Ovld:
             self.compile()
         for child in self.children:
             child._update()
+        if hasattr(self, "dispatch"):
+            self.dispatch.__doc__ = self.mkdoc()
 
     def copy(self, mixins=[], linkback=False):
         """Create a copy of this Ovld.
@@ -535,11 +578,7 @@ class _Ovld:
         New functions can be registered to the copy without affecting the
         original.
         """
-        return _fresh(_Ovld)(
-            bootstrap=self.bootstrap,
-            mixins=[self, *mixins],
-            linkback=linkback,
-        )
+        return Ovld(mixins=[self, *mixins], linkback=linkback)
 
     def variant(self, fn=None, priority=0, **kwargs):
         """Decorator to create a variant of this Ovld.
@@ -554,104 +593,55 @@ class _Ovld:
             ov.register(fn, priority=priority)
             return ov
 
-    @_compile_first
     def __get__(self, obj, cls):
-        if obj is None:
-            return self
-        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,)
-        return self.map[t]
-
-    @_compile_first
+        if not self._compiled:
+            self.compile()
+        return self.dispatch.__get__(obj, cls)
+
     @_setattrs(rename="dispatch")
-    def __call__(self, *args):  # pragma: no cover
+    def __call__(self, *args, **kwargs):  # pragma: no cover
         """Call the overloaded function.
 
         This should be replaced by an auto-generated function.
         """
-        key = tuple(map(self.map.transform, args))
-        method = self.map[key]
-        return method(*args)
+        if not self._compiled:
+            self.compile()
+        return self.dispatch(*args, **kwargs)
 
-    @_compile_first
     @_setattrs(rename="next")
     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))
+        key = (fr.f_code, *map(subtler_type, args))
         method = self.map[key]
         return method(*args)
 
     def __repr__(self):
         return f"<Ovld {self.name or hex(id(self))}>"
 
-    @_compile_first
     def display_methods(self):
+        self.ensure_compiled()
         self.map.display_methods()
 
-    @_compile_first
     def display_resolution(self, *args, **kwargs):
+        self.ensure_compiled()
         self.map.display_resolution(*args, **kwargs)
 
 
 def is_ovld(x):
     """Return whether the argument is an ovld function/method."""
-    return isinstance(x, _Ovld)
-
-
-class OvldCall:
-    """Context for an Ovld call."""
-
-    def __init__(self, ovld, bind_to):
-        """Initialize an OvldCall."""
-        self.ovld = ovld
-        self.map = ovld.map
-        self.obj = bind_to
-
-    @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):
-        """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)
-
-    def resolve(self, *args):
-        """Find the right method to call for the given arguments."""
-        return self.map[tuple(map(self.map.transform, args))].__get__(self.obj)
-
-    def __call__(self, *args):  # pragma: no cover
-        """Call this overloaded 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)
+    return isinstance(x, Ovld) or isinstance(
+        getattr(x, "__ovld__", False), Ovld
+    )
 
 
-def Ovld(*args, **kwargs):
-    """Returns an instance of a fresh Ovld class."""
-    return _fresh(_Ovld)(*args, **kwargs)
+def to_ovld(x):
+    """Return whether the argument is an ovld function/method."""
+    x = getattr(x, "__ovld__", x)
+    if inspect.isfunction(x):
+        return ovld(x, fresh=True)
+    else:
+        return x if isinstance(x, Ovld) else None
 
 
 def extend_super(fn):
@@ -678,33 +668,24 @@ class ovld_cls_dict(dict):
     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
+            prev = to_ovld(self[attr])
         elif is_ovld(value) and getattr(value, "_extend_super", False):
             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 mixin := to_ovld(candidate):
+                        mixins.append(mixin)
             if mixins:
                 prev, *others = mixins
-                if is_ovld(prev):
-                    prev = prev.copy()
-                else:
-                    prev = ovld(prev, fresh=True)
+                prev = prev.copy()
                 for other in others:
-                    if is_ovld(other):
-                        prev.add_mixins(other)
-                    else:
-                        prev.register(other)
+                    prev.add_mixins(other)
         else:
             prev = None
 
         if prev is not None:
             if is_ovld(value) and prev is not value:
+                value = getattr(value, "__ovld__", value)
                 if prev.name is None:
                     prev.rename(value.name)
                 prev.add_mixins(value)
@@ -713,7 +694,9 @@ class ovld_cls_dict(dict):
                 prev.register(value)
                 value = prev
 
-        super().__setitem__(attr, value)
+        super().__setitem__(
+            attr, value.dispatch if isinstance(value, Ovld) else value
+        )
 
 
 class OvldMC(type):
@@ -774,12 +757,12 @@ def _find_overload(fn, **kwargs):
     dispatch = fr.f_locals.get(fn.__name__, None)
 
     if dispatch is None:
-        dispatch = _fresh(_Ovld)(**kwargs)
+        dispatch = 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")
-    return dispatch
+    return getattr(dispatch, "__ovld__", dispatch)
 
 
 @keyword_decorator
@@ -808,16 +791,16 @@ def ovld(fn, priority=0, fresh=False, **kwargs):
             ovld so that updates can be propagated. (default: False)
     """
     if fresh:
-        dispatch = _fresh(_Ovld)(**kwargs)
+        dispatch = Ovld(**kwargs)
     else:
         dispatch = _find_overload(fn, **kwargs)
-    return dispatch.register(fn, priority=priority)
+    dispatch.register(fn, priority=priority)
+    return dispatch.dispatch
 
 
 __all__ = [
     "Ovld",
     "OvldBase",
-    "OvldCall",
     "OvldMC",
     "extend_super",
     "is_ovld",