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

ovld/recode.py

@@ -7,8 +7,7 @@ from functools import reduce
 from itertools import count
 from types import CodeType, FunctionType
 
-from .dependent import DependentType
-from .utils import Unusable, UsageError
+from .utils import MISSING, NameDatabase, Unusable, UsageError, subtler_type
 
 recurse = Unusable(
     "recurse() can only be used from inside an @ovld-registered function."
@@ -18,24 +17,8 @@ call_next = Unusable(
 )
 
 
-dispatch_template = """
-from ovld.utils import MISSING
-
-def __DISPATCH__(self, {args}):
-    {inits}
-    {body}
-    {call}
-"""
-
-
-call_template = """
-method = self.map[({lookup})]
-return method({posargs})
-"""
-
-
 def instantiate_code(symbol, code, inject={}):
-    virtual_file = f"<ovld{hash(code)}>"
+    virtual_file = f"<ovld:{abs(hash(code)):x}>"
     linecache.cache[virtual_file] = (None, None, splitlines(code), virtual_file)
     code = compile(source=code, filename=virtual_file, mode="exec")
     glb = {**inject}
@@ -55,7 +38,22 @@ def instantiate_code(symbol, code, inject={}):
 #     return rval
 
 
-def generate_dispatch(arganal):
+dispatch_template = """
+def __WRAP_DISPATCH__(OVLD):
+    def __DISPATCH__({args}):
+        {body}
+
+    return __DISPATCH__
+"""
+
+
+call_template = """
+{mvar} = OVLD.map[({lookup})]
+return {mvar}({posargs})
+"""
+
+
+def generate_dispatch(ov, arganal):
     def join(li, sep=", ", trail=False):
         li = [x for x in li if x]
         rval = sep.join(li)
@@ -63,19 +61,35 @@ def generate_dispatch(arganal):
             rval += ","
         return rval
 
-    spr, spo, pr, po, kr, ko = arganal.compile()
+    arganal.compile()
+
+    spr = arganal.strict_positional_required
+    spo = arganal.strict_positional_optional
+    pr = arganal.positional_required
+    po = arganal.positional_optional
+    kr = arganal.keyword_required
+    ko = arganal.keyword_optional
 
     inits = set()
 
     kwargsstar = ""
     targsstar = ""
 
-    args = []
+    args = ["self" if arganal.is_method else ""]
     body = [""]
-    posargs = ["self.obj" if arganal.is_method else ""]
+    posargs = ["self" if arganal.is_method else ""]
     lookup = []
 
     i = 0
+    ndb = NameDatabase(default_name="INJECT")
+
+    def lookup_for(x):
+        return ndb[arganal.lookup_for(x)]
+
+    for name in spr + spo + pr + po + kr:
+        ndb.register(name)
+
+    mv = ndb.gensym(desired_name="method")
 
     for name in spr + spo:
         if name in spr:
@@ -83,10 +97,10 @@ def generate_dispatch(arganal):
         else:
             args.append(f"{name}=MISSING")
         posargs.append(name)
-        lookup.append(f"{arganal.lookup_for(i)}({name})")
+        lookup.append(f"{lookup_for(i)}({name})")
         i += 1
 
-    if len(po) <= 1:
+    if len(po) <= 1 and (spr or spo):
         # If there are more than one non-strictly positional optional arguments,
         # then all positional arguments are strictly positional, because if e.g.
         # x and y are optional we want x==MISSING to imply that y==MISSING, but
@@ -99,7 +113,7 @@ def generate_dispatch(arganal):
         else:
             args.append(f"{name}=MISSING")
         posargs.append(name)
-        lookup.append(f"{arganal.lookup_for(i)}({name})")
+        lookup.append(f"{lookup_for(i)}({name})")
         i += 1
 
     if len(po) > 1:
@@ -109,14 +123,9 @@ def generate_dispatch(arganal):
         args.append("*")
 
     for name in kr:
-        lookup_fn = (
-            "self.map.transform"
-            if name in arganal.complex_transforms
-            else "type"
-        )
         args.append(f"{name}")
         posargs.append(f"{name}={name}")
-        lookup.append(f"({name!r}, {lookup_fn}({name}))")
+        lookup.append(f"({name!r}, {lookup_for(name)}({name}))")
 
     for name in ko:
         args.append(f"{name}=MISSING")
@@ -126,9 +135,7 @@ def generate_dispatch(arganal):
         inits.add("TARGS = []")
         body.append(f"if {name} is not MISSING:")
         body.append(f"    KWARGS[{name!r}] = {name}")
-        body.append(
-            f"    TARGS.append(({name!r}, {arganal.lookup_for(name)}({name})))"
-        )
+        body.append(f"    TARGS.append(({name!r}, {lookup_for(name)}({name})))")
 
     posargs.append(kwargsstar)
     lookup.append(targsstar)
@@ -136,6 +143,7 @@ def generate_dispatch(arganal):
     fullcall = call_template.format(
         lookup=join(lookup, trail=True),
         posargs=join(posargs),
+        mvar=mv,
     )
 
     calls = []
@@ -145,35 +153,26 @@ def generate_dispatch(arganal):
             call = call_template.format(
                 lookup=join(lookup[: req + i], trail=True),
                 posargs=join(posargs[: req + i + 1]),
+                mvar=mv,
             )
-            call = textwrap.indent(call, "    ")
+            call = textwrap.indent(call, "        ")
             calls.append(f"\nif {arg} is MISSING:{call}")
     calls.append(fullcall)
 
+    lines = [*inits, *body, textwrap.indent("".join(calls), "        ")]
     code = dispatch_template.format(
-        inits=join(inits, sep="\n    "),
         args=join(args),
-        body=join(body, sep="\n    "),
-        call=textwrap.indent("".join(calls), "    "),
+        body=join(lines, sep="\n        ").lstrip(),
     )
-    return instantiate_code("__DISPATCH__", code)
-
-
-class GenSym:
-    def __init__(self, prefix):
-        self.prefix = prefix
-        self.count = count()
-        self.variables = {}
-
-    def add(self, value):
-        if isinstance(value, (int, float, str)):
-            return repr(value)
-        id = f"{self.prefix}{next(self.count)}"
-        self.variables[id] = value
-        return id
+    wr = instantiate_code(
+        "__WRAP_DISPATCH__", code, inject={"MISSING": MISSING, **ndb.variables}
+    )
+    return wr(ov)
 
 
 def generate_dependent_dispatch(tup, handlers, next_call, slf, name, err, nerr):
+    from .dependent import generate_checking_code, is_dependent
+
     def to_dict(tup):
         return dict(
             entry if isinstance(entry, tuple) else (i, entry)
@@ -187,14 +186,14 @@ def generate_dependent_dispatch(tup, handlers, next_call, slf, name, err, nerr):
         return f"ARG{x}" if isinstance(x, int) else f"{x}={x}"
 
     def codegen(typ, arg):
-        cg = typ.codegen()
+        cg = generate_checking_code(typ)
         return cg.template.format(
-            arg=arg, **{k: gen.add(v) for k, v in cg.substitutions.items()}
+            arg=arg, **{k: ndb[v] for k, v in cg.substitutions.items()}
         )
 
     tup = to_dict(tup)
     handlers = [(h, to_dict(types)) for h, types in handlers]
-    gen = GenSym(prefix="INJECT")
+    ndb = NameDatabase(default_name="INJECT")
     conjs = []
 
     exclusive = False
@@ -227,7 +226,7 @@ def generate_dependent_dispatch(tup, handlers, next_call, slf, name, err, nerr):
                     exclusive = getattr(focus, "exclusive_type", False)
 
     for i, (h, types) in enumerate(handlers):
-        relevant = [k for k in tup if isinstance(types[k], DependentType)]
+        relevant = [k for k in tup if is_dependent(types[k])]
         if len(relevant) > 1:
             # The keyexpr method only works if there is only one condition to check.
             keyexpr = keyed = None
@@ -238,12 +237,15 @@ def generate_dependent_dispatch(tup, handlers, next_call, slf, name, err, nerr):
             conj = "True"
         conjs.append(conj)
 
+    if len(handlers) == 1:
+        exclusive = True
+
     argspec = ", ".join(argname(x) for x in tup)
     argcall = ", ".join(argprovide(x) for x in tup)
 
     body = []
     if keyexpr:
-        body.append(f"HANDLER = {gen.add(keyed)}.get({keyexpr}, FALLTHROUGH)")
+        body.append(f"HANDLER = {ndb[keyed]}.get({keyexpr}, FALLTHROUGH)")
         body.append(f"return HANDLER({slf}{argcall})")
 
     elif exclusive:
@@ -263,12 +265,12 @@ def generate_dependent_dispatch(tup, handlers, next_call, slf, name, err, nerr):
         body.append("elif SUMMATION == 0:")
         body.append(f"    return FALLTHROUGH({slf}{argcall})")
         body.append("else:")
-        body.append(f"    raise {gen.add(err)}")
+        body.append(f"    raise {ndb[err]}")
 
     body_text = textwrap.indent("\n".join(body), "    ")
     code = f"def __DEPENDENT_DISPATCH__({slf}{argspec}):\n{body_text}"
 
-    inject = gen.variables
+    inject = ndb.variables
     for i, (h, types) in enumerate(handlers):
         inject[f"HANDLER{i}"] = h
 
@@ -366,12 +368,19 @@ def rename_function(fn, newname):
 
 class NameConverter(ast.NodeTransformer):
     def __init__(
-        self, anal, recurse_sym, call_next_sym, ovld_mangled, code_mangled
+        self,
+        anal,
+        recurse_sym,
+        call_next_sym,
+        ovld_mangled,
+        map_mangled,
+        code_mangled,
     ):
         self.analysis = anal
         self.recurse_sym = recurse_sym
         self.call_next_sym = call_next_sym
         self.ovld_mangled = ovld_mangled
+        self.map_mangled = map_mangled
         self.code_mangled = code_mangled
         self.count = count()
 
@@ -400,18 +409,16 @@ class NameConverter(ast.NodeTransformer):
         tmp = f"__TMP{next(self.count)}_"
 
         def _make_lookup_call(key, arg):
+            name = (
+                "__SUBTLER_TYPE"
+                if self.analysis.lookup_for(key) is subtler_type
+                else "type"
+            )
             value = ast.NamedExpr(
                 target=ast.Name(id=f"{tmp}{key}", ctx=ast.Store()),
                 value=self.visit(arg),
             )
-            if self.analysis.lookup_for(key) == "self.map.transform":
-                func = ast.Attribute(
-                    value=ast.Name(id=f"{tmp}M", ctx=ast.Load()),
-                    attr="transform",
-                    ctx=ast.Load(),
-                )
-            else:
-                func = ast.Name(id="type", ctx=ast.Load())
+            func = ast.Name(id=name, ctx=ast.Load())
             return ast.Call(
                 func=func,
                 args=[value],
@@ -438,14 +445,7 @@ class NameConverter(ast.NodeTransformer):
         if cn:
             type_parts.insert(0, ast.Name(id=self.code_mangled, ctx=ast.Load()))
         method = ast.Subscript(
-            value=ast.NamedExpr(
-                target=ast.Name(id=f"{tmp}M", ctx=ast.Store()),
-                value=ast.Attribute(
-                    value=ast.Name(id=self.ovld_mangled, ctx=ast.Load()),
-                    attr="map",
-                    ctx=ast.Load(),
-                ),
-            ),
+            value=ast.Name(id=self.map_mangled, ctx=ast.Load()),
             slice=ast.Tuple(
                 elts=type_parts,
                 ctx=ast.Load(),
@@ -453,19 +453,14 @@ class NameConverter(ast.NodeTransformer):
             ctx=ast.Load(),
         )
         if self.analysis.is_method:
-            method = ast.Call(
-                func=ast.Attribute(
-                    value=method,
-                    attr="__get__",
-                    ctx=ast.Load(),
-                ),
-                args=[ast.Name(id="self", ctx=ast.Load())],
-                keywords=[],
-            )
+            selfarg = [ast.Name(id="self", ctx=ast.Load())]
+        else:
+            selfarg = []
 
         new_node = ast.Call(
             func=method,
-            args=[
+            args=selfarg
+            + [
                 ast.Name(id=f"{tmp}{i}", ctx=ast.Load())
                 for i, arg in enumerate(node.args)
             ],
@@ -498,7 +493,10 @@ def adapt_function(fn, ovld, newname):
     """Create a copy of the function with a different name."""
     rec_syms = list(
         _search_names(
-            fn.__code__, (recurse, ovld), fn.__globals__, fn.__closure__
+            fn.__code__,
+            (recurse, ovld, ovld.dispatch),
+            fn.__globals__,
+            fn.__closure__,
         )
     )
     cn_syms = list(
@@ -540,6 +538,7 @@ def closure_wrap(tree, fname, names):
 
 def recode(fn, ovld, recurse_sym, call_next_sym, newname):
     ovld_mangled = f"___OVLD{ovld.id}"
+    map_mangled = f"___MAP{ovld.id}"
     code_mangled = f"___CODE{next(_current)}"
     try:
         src = inspect.getsource(fn)
@@ -556,6 +555,7 @@ def recode(fn, ovld, recurse_sym, call_next_sym, newname):
         recurse_sym=recurse_sym,
         call_next_sym=call_next_sym,
         ovld_mangled=ovld_mangled,
+        map_mangled=map_mangled,
         code_mangled=code_mangled,
     ).visit(tree)
     new.body[0].decorator_list = []
@@ -579,6 +579,8 @@ def recode(fn, ovld, recurse_sym, call_next_sym, newname):
     new_fn.__kwdefaults__ = fn.__kwdefaults__
     new_fn.__annotations__ = fn.__annotations__
     new_fn = rename_function(new_fn, newname)
-    new_fn.__globals__[ovld_mangled] = ovld
+    new_fn.__globals__["__SUBTLER_TYPE"] = subtler_type
+    new_fn.__globals__[ovld_mangled] = ovld.dispatch
+    new_fn.__globals__[map_mangled] = ovld.map
     new_fn.__globals__[code_mangled] = new_fn.__code__
     return new_fn

ovld/typemap.py

@@ -1,27 +1,12 @@
 import inspect
 import math
-import typing
 from dataclasses import dataclass
 from itertools import count
 from types import CodeType
 
-from .dependent import DependentType
 from .mro import sort_types
 from .recode import generate_dependent_dispatch
-from .utils import MISSING
-
-
-class GenericAliasMC(type):
-    def __instancecheck__(cls, obj):
-        return hasattr(obj, "__origin__")
-
-
-class GenericAlias(metaclass=GenericAliasMC):
-    pass
-
-
-def is_type_of_type(t):
-    return getattr(t, "__origin__", None) is type
+from .utils import MISSING, subtler_type
 
 
 class TypeMap(dict):
@@ -123,16 +108,6 @@ class MultiTypeMap(dict):
         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]
-        else:
-            return type(obj)
-
     def mro(self, obj_t_tup):
         specificities = {}
         candidates = None
@@ -229,6 +204,8 @@ class MultiTypeMap(dict):
             sig: A Signature object.
             handler: A function to handle the tuple.
         """
+        from .dependent import is_dependent
+
         self.clear()
 
         obj_t_tup = sig.types
@@ -240,8 +217,7 @@ class MultiTypeMap(dict):
         self.tiebreaks[handler] = sig.tiebreak
         self.type_tuples[handler] = obj_t_tup
         self.dependent[handler] = any(
-            isinstance(t[1] if isinstance(t, tuple) else t, DependentType)
-            for t in obj_t_tup
+            is_dependent(t[1] if isinstance(t, tuple) else t) for t in obj_t_tup
         )
 
         for i, cls in enumerate(obj_t_tup):
@@ -266,19 +242,21 @@ class MultiTypeMap(dict):
             print(f"{'':{width-2}} @ {co.co_filename}:{co.co_firstlineno}")
 
     def display_resolution(self, *args, **kwargs):
+        from .dependent import is_dependent
+
         def dependent_match(tup, args):
             for t, a in zip(tup, args):
                 if isinstance(t, tuple):
                     t = t[1]
                     a = a[1]
-                if isinstance(t, DependentType) and not t.check(a):
+                if is_dependent(t) and not isinstance(a, t):
                     return False
             return True
 
         message = "No method will be called."
         argt = [
-            *map(self.transform, args),
-            *[(k, self.transform(v)) for k, v in kwargs.items()],
+            *map(subtler_type, args),
+            *[(k, subtler_type(v)) for k, v in kwargs.items()],
         ]
         finished = False
         rank = 1