porting: remove make_isxpred, now obsolete

Technologicat · Technologicat · commit 0273c4b5ba15 · 2021-05-01T00:23:59.000+03:00
`mcpyrate` does not need to rename hygienically captured values, so the name
will always match exactly.

If the use site needs something more complex, `isx` already supports that:
just pass a predicate instead of a string as the name to be detected.
diff --git a/unpythonic/syntax/__init__.py b/unpythonic/syntax/__init__.py
@@ -89,7 +89,6 @@
 # However, 0.15.0 is the initial version that runs on `mcpyrate`, and the focus is to just get this running.
 # Cleanups can be done in a future release.
 
-# TODO: `make_isxpred` is now obsolete because `mcpyrate` does not rename hygienic captures of run-time values. Make it explicit at the use sites what they want, and remove `make_isxpred`. (E.g. `curry` wants to match both `curryf` and `currycall`, exactly. Some use sites want to match only a single thing.)
 
 # TODO: `let` constructs: document difference to Python 3.8 walrus operator (`let` creates a scope, `:=` doesn't)
 
diff --git a/unpythonic/syntax/lambdatools.py b/unpythonic/syntax/lambdatools.py
@@ -16,13 +16,12 @@
 
 from ..dynassign import dyn
 from ..misc import namelambda
-from ..fun import orf
 from ..env import env
 
 from .astcompat import getconstant, Str, NamedExpr
 from .letdo import do
 from .letdoutil import islet, isenvassign, UnexpandedLetView, UnexpandedEnvAssignView, ExpandedDoView
-from .util import (is_decorated_lambda, isx, make_isxpred, has_deco,
+from .util import (is_decorated_lambda, isx, has_deco,
                    destructure_decorated_lambda, detect_lambda)
 
 def multilambda(block_body):
@@ -53,18 +52,17 @@ def issingleassign(tree):
         return type(tree) is Assign and len(tree.targets) == 1 and type(tree.targets[0]) is Name
 
     # detect a manual curry
-    iscurry = make_isxpred("curry")
     def iscurrywithfinallambda(tree):
-        if not (type(tree) is Call and isx(tree.func, iscurry) and tree.args):
+        if not (type(tree) is Call and isx(tree.func, "curry") and tree.args):
             return False
         return type(tree.args[-1]) is Lambda
 
     # Detect an autocurry from an already expanded "with autocurry".
     # CAUTION: These must match what unpythonic.syntax.curry.autocurry uses in its output.
-    iscurrycall = make_isxpred("currycall")
-    iscurryf = orf(make_isxpred("curryf"), make_isxpred("curry"))  # auto or manual curry in a "with autocurry"
+    currycall_name = "currycall"
+    iscurryf = lambda name: name in ("curryf", "curry")  # auto or manual curry in a "with autocurry"
     def isautocurrywithfinallambda(tree):
-        if not (type(tree) is Call and isx(tree.func, iscurrycall) and tree.args and
+        if not (type(tree) is Call and isx(tree.func, currycall_name) and tree.args and
                 type(tree.args[-1]) is Call and isx(tree.args[-1].func, iscurryf)):
             return False
         return type(tree.args[-1].args[-1]) is Lambda
@@ -235,7 +233,6 @@ def isfunctionoruserlambda(tree):
 
     # Create a renamed reference to the env() constructor to be sure the Call
     # nodes added by us have a unique .func (not used by other macros or user code)
-    _ismakeenv = make_isxpred("_envify")
     _envify = env
 
     class EnvifyTransformer(ASTTransformer):
@@ -284,7 +281,7 @@ def isourupdate(thecall):
                     self.generic_withstate(tree, enames=(enames + [ename]), bindings=newbindings)
             else:
                 # leave alone the _envify() added by us
-                if type(tree) is Call and (isx(tree.func, _ismakeenv) or isourupdate(tree)):
+                if type(tree) is Call and (isx(tree.func, "_envify") or isourupdate(tree)):
                     # don't recurse
                     return tree
                 # transform env-assignments into our envs
diff --git a/unpythonic/syntax/lazify.py b/unpythonic/syntax/lazify.py
@@ -10,7 +10,7 @@
 from mcpyrate.walkers import ASTTransformer
 
 from .util import (suggest_decorator_index, sort_lambda_decorators, detect_lambda,
-                   isx, make_isxpred, getname, is_decorator, wrapwith)
+                   isx, getname, is_decorator, wrapwith)
 from .letdoutil import islet, isdo, ExpandedLetView
 from ..lazyutil import Lazy, passthrough_lazy_args, force, force1, maybe_force_args
 from ..dynassign import dyn
@@ -87,8 +87,8 @@ def lazy(tree):
 # variant `frozendict(mapping1, mapping2, ...)`.
 _ctorcalls_that_take_exactly_one_positional_arg = {"tuple", "list", "set", "dict", "frozenset", "llist"}
 
-islazy = make_isxpred("lazy")  # unexpanded
-isLazy = make_isxpred("Lazy")  # expanded
+unexpanded_lazy_name = "lazy"
+expanded_lazy_name = "Lazy"
 def lazyrec(tree):
     # This helper doesn't need to recurse, so we don't need `ASTTransformer` here.
     def transform(tree):
@@ -99,9 +99,9 @@ def transform(tree):
         elif type(tree) is Call and any(isx(tree.func, ctor) for ctor in _ctorcalls_all):
             p, k = _ctor_handling_modes[getname(tree.func)]
             lazify_ctorcall(tree, p, k)
-        elif type(tree) is Subscript and isx(tree.value, islazy):  # unexpanded
+        elif type(tree) is Subscript and isx(tree.value, unexpanded_lazy_name):
             pass
-        elif type(tree) is Call and isx(tree.func, isLazy):  # expanded
+        elif type(tree) is Call and isx(tree.func, expanded_lazy_name):
             pass
         else:
             # mcpyrate supports hygienic macro capture, so we can just splice unexpanded
@@ -293,7 +293,7 @@ def transform_starred(tree, dstarred=False):
                 # Lazy() is a strict function, takes a lambda, constructs a Lazy object
                 # _autoref_resolve doesn't need any special handling
                 elif (isdo(tree) or is_decorator(tree.func, "namelambda") or
-                      any(isx(tree.func, s) for s in _ctorcalls_all) or isx(tree.func, isLazy) or
+                      any(isx(tree.func, s) for s in _ctorcalls_all) or isx(tree.func, expanded_lazy_name) or
                       any(isx(tree.func, s) for s in ("_autoref_resolve", "AutorefMarker"))):
                     # here we know the operator (.func) to be one of specific names;
                     # don't transform it to avoid confusing lazyrec[] (important if this
diff --git a/unpythonic/syntax/letdoutil.py b/unpythonic/syntax/letdoutil.py
@@ -10,15 +10,15 @@
 import sys
 
 from .astcompat import getconstant, Str
-from .nameutil import isx, make_isxpred
+from .nameutil import isx
 
 def where(*bindings):
     """[syntax] Only meaningful in a let[body, where((k0, v0), ...)]."""
     raise RuntimeError("where() is only meaningful in a let[body, where((k0, v0), ...)]")  # pragma: no cover
 
-_isletf = make_isxpred("letter")  # name must match what ``unpythonic.syntax.letdo._letimpl`` uses in its output.
-_isdof = make_isxpred("dof")      # name must match what ``unpythonic.syntax.letdo.do`` uses in its output.
-_iscurrycall = make_isxpred("currycall")  # output of ``unpythonic.syntax.curry``
+letf_name = "letter"  # must match what ``unpythonic.syntax.letdo._letimpl`` uses in its output.
+dof_name = "dof"      # name must match what ``unpythonic.syntax.letdo.do`` uses in its output.
+currycall_name = "currycall"  # output of ``unpythonic.syntax.curry``
 
 # TODO: switch from call to subscript in name position for let_syntax templates.
 def canonize_bindings(elts, allow_call_in_name_position=False):  # public as of v0.14.3+
@@ -98,9 +98,9 @@ def islet(tree, expanded=True):
         if type(tree) is not Call:
             return False
         kind = "expanded"
-        if isx(tree.func, _iscurrycall) and isx(tree.args[0], _isletf):
+        if isx(tree.func, currycall_name) and isx(tree.args[0], letf_name):
             kind = "curried"
-        elif not isx(tree.func, _isletf):
+        elif not isx(tree.func, letf_name):
             return False
         mode = [kw.value for kw in tree.keywords if kw.arg == "mode"]
         assert len(mode) == 1 and type(mode[0]) in (Constant, Str)
@@ -203,9 +203,9 @@ def isdo(tree, expanded=True):
         if type(tree) is not Call:
             return False
         kind = "expanded"
-        if isx(tree.func, _iscurrycall) and isx(tree.args[0], _isdof):
+        if isx(tree.func, currycall_name) and isx(tree.args[0], dof_name):
             kind = "curried"
-        elif not isx(tree.func, _isdof):
+        elif not isx(tree.func, dof_name):
             return False
         return kind
 
diff --git a/unpythonic/syntax/nameutil.py b/unpythonic/syntax/nameutil.py
@@ -66,18 +66,6 @@ def isx(tree, x, accept_attr=True):
             (key and ismatch(name)) or
             (accept_attr and type(tree) is Attribute and ismatch(tree.attr)))
 
-# TODO: obsolete function, remove
-def make_isxpred(x):
-    """Make a predicate for isx.
-
-    Here ``x`` is an ``str``; the resulting function will match also
-    hygienically captured identifiers.
-    """
-    # `mcpyrate` only renames captured macros; the names of captured
-    # run-time values live in the keys in the `lookup_value` calls
-    # (where the original name is preserved, with no renaming needed).
-    return lambda name: name == x
-
 def getname(tree, accept_attr=True):
     """The cousin of ``isx``.
 
diff --git a/unpythonic/syntax/tailtools.py b/unpythonic/syntax/tailtools.py
@@ -23,7 +23,7 @@
 from mcpyrate.walkers import ASTTransformer, ASTVisitor
 
 from .astcompat import getconstant, NameConstant
-from .util import (isx, make_isxpred, isec,
+from .util import (isx, isec,
                    detect_callec, detect_lambda,
                    has_tco, sort_lambda_decorators,
                    suggest_decorator_index, ContinuationsMarker, wrapwith, isexpandedmacromarker)
@@ -601,7 +601,7 @@ def transform(self, tree):
 # Tail-position analysis for a return-value expression (also the body of a lambda).
 # Here we need to be very, very selective about where to recurse so this would not
 # benefit much from being made into an ASTTransformer. Just a function is fine.
-_isjump = orf(make_isxpred("jump"), make_isxpred("loop"))
+_isjump = lambda name: name in ("jump", "loop")
 def _transform_retexpr(tree, known_ecs, call_cb=None, data_cb=None):
     """Analyze and TCO a return-value expression or a lambda body.
 
diff --git a/unpythonic/syntax/tests/test_nameutil.py b/unpythonic/syntax/tests/test_nameutil.py
@@ -6,7 +6,7 @@
 
 from mcpyrate.quotes import macros, q, h  # noqa: F401, F811
 
-from ...syntax.nameutil import isx, make_isxpred, getname
+from ...syntax.nameutil import isx, getname
 
 from ast import Call
 
@@ -26,11 +26,6 @@ def runtests():
         test[isx(attribute, "ok")]
         test[not isx(attribute, "ok", accept_attr=False)]
 
-    with testset("make_isxpred"):
-        isfab = make_isxpred("fab")
-        test[isx(q[fab], isfab)]  # noqa: F821
-        test[isx(q[someobj.fab], isfab)]  # noqa: F821
-
     with testset("getname"):
         test[getname(barename) == "ok"]
         test[getname(captured.func) == "capture_this"]
diff --git a/unpythonic/syntax/util.py b/unpythonic/syntax/util.py
@@ -11,7 +11,7 @@
 
 from .astcompat import getconstant
 from .letdoutil import isdo, ExpandedDoView
-from .nameutil import isx, make_isxpred, getname
+from .nameutil import isx, getname
 
 from ..regutil import all_decorators, tco_decorators, decorator_registry
 
@@ -52,7 +52,7 @@ def g(ec):           # <-- should grab from here
     and `throw` covers the use of `unpythonic.ec.throw`.)
     """
     fallbacks = ["ec", "brk", "throw"]
-    iscallec = partial(isx, x=make_isxpred("call_ec"))
+    iscallec = partial(isx, x="call_ec")
     def detect(tree):
         class Detector(ASTVisitor):
             def examine(self, tree):
