ovld 0.4.2__py3-none-any.whl → 0.4.4__py3-none-any.whl

ovld/recode.py

@@ -1,14 +1,14 @@
 import ast
 import inspect
 import linecache
+import re
 import textwrap
 from ast import _splitlines_no_ff as splitlines
 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, Unusable, UsageError, subtler_type
 
 recurse = Unusable(
     "recurse() can only be used from inside an @ovld-registered function."
@@ -19,12 +19,8 @@ call_next = Unusable(
 
 
 dispatch_template = """
-from ovld.utils import MISSING
-
 def __DISPATCH__(self, {args}):
-    {inits}
     {body}
-    {call}
 """
 
 
@@ -55,6 +51,35 @@ def instantiate_code(symbol, code, inject={}):
 #     return rval
 
 
+class NameDatabase:
+    def __init__(self, default_name):
+        self.default_name = default_name
+        self.count = count()
+        self.variables = {}
+        self.names = {}
+        self.registered = set()
+
+    def register(self, name):
+        self.registered.add(name)
+
+    def __getitem__(self, value):
+        if isinstance(value, (int, float, str)):
+            return repr(value)
+        if id(value) in self.names:
+            return self.names[id(value)]
+        name = orig_name = getattr(value, "__name__", self.default_name)
+        if not re.match(string=name, pattern=r"[a-zA-Z_][a-zA-Z0-9_]+"):
+            name = self.default_name
+        i = 1
+        while name in self.registered:
+            name = f"{orig_name}{i}"
+            i += 1
+        self.variables[name] = value
+        self.names[id(value)] = name
+        self.registered.add(name)
+        return name
+
+
 def generate_dispatch(arganal):
     def join(li, sep=", ", trail=False):
         li = [x for x in li if x]
@@ -76,6 +101,13 @@ def generate_dispatch(arganal):
     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)
 
     for name in spr + spo:
         if name in spr:
@@ -83,7 +115,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:
@@ -99,7 +131,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 +141,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 +153,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)
@@ -150,30 +175,19 @@ def generate_dispatch(arganal):
             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, inject={"MISSING": MISSING, **ndb.variables}
     )
-    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
 
 
 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 +201,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 +241,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
@@ -243,7 +257,7 @@ def generate_dependent_dispatch(tup, handlers, next_call, slf, name, err, nerr):
 
     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 +277,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
 
@@ -400,18 +414,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],
@@ -579,6 +591,7 @@ 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__["__SUBTLER_TYPE"] = subtler_type
     new_fn.__globals__[ovld_mangled] = ovld
     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