macro code: convert prefix tests to unpythonic.test.fixtures

Technologicat · Technologicat · commit b497021c5c1d · 2020-08-19T20:24:31.000+03:00
This required changes to the block macro `prefix`, which usually rewrites tuples
as function calls. It needed a new special case to leave alone the tuple that
forms the arguments for the test macro. (It now leaves the tuple itself alone,
but recurses into its elements.)
diff --git a/unpythonic/syntax/prefix.py b/unpythonic/syntax/prefix.py
@@ -4,12 +4,13 @@
 Experimental, not for use in production code.
 """
 
-from ast import Name, Call, Tuple, Load
+from ast import Name, Call, Tuple, Load, Index
 
 from macropy.core.quotes import macros, q, u, ast_literal  # noqa: F811, F401
 from macropy.core.walkers import Walker
 
 from .letdoutil import islet, isdo, UnexpandedLetView, UnexpandedDoView
+from .testutil import isunexpandedtestmacro
 
 from ..it import flatmap, rev, uniqify
 
@@ -42,6 +43,20 @@ def transform(tree, *, quotelevel, set_ctx, stop, **kw):
             view = UnexpandedDoView(tree)
             view.body = [transform.recurse(expr, quotelevel=quotelevel) for expr in view.body]
             return tree
+
+        # integration with testing framework
+        if isunexpandedtestmacro(tree):
+            stop()
+            if type(tree.slice) is not Index:
+                assert False, "prefix: Slice and ExtSlice not implemented in analysis of testing macro arguments"
+            body = tree.slice.value
+            if type(body) is Tuple:
+                # skip the transformation of the argument tuple itself, but transform its elements
+                body.elts = [transform.recurse(expr, quotelevel=quotelevel) for expr in body.elts]
+            else:
+                tree.slice.value = transform.recurse(tree.slice.value, quotelevel=quotelevel)
+            return tree
+
         # general case
         # macro-created nodes might not have a ctx, but we run in the first pass.
         if not (type(tree) is Tuple and type(tree.ctx) is Load):
diff --git a/unpythonic/syntax/test/test_prefix.py b/unpythonic/syntax/test/test_prefix.py
@@ -3,102 +3,108 @@
 
 **CAUTION**: Experimental, **not** recommended for use in production code."""
 
-# Use "with show_expanded:" to see what it did.
-#from macropy.tracing import macros, show_expanded
+from ...syntax import macros, test, test_raises  # noqa: F401
+from ...test.fixtures import testset, returns_normally
 
-from ...syntax import macros, prefix, q, u, kw, curry, let, do  # noqa: F401
+from ...syntax import macros, prefix, q, u, kw, curry, let, do  # noqa: F401, F811
 
 from ...fold import foldr
 from ...fun import composerc as compose, apply
 from ...llist import cons, nil, ll
 
+# Use "with show_expanded:" to see what it did.
+#from macropy.tracing import macros, show_expanded
+
 def runtests():
-    with prefix:
-        (print, "hello world")
-        x = 42  # can write any regular Python, too
-
-        # quote operator q locally turns off the function-call transformation:
-        t1 = (q, 1, 2, (3, 4), 5)  # q takes effect recursively
-        t2 = (q, 17, 23, x)  # unlike in Lisps, x refers to its value even in a quote
-        (print, t1, t2)
-
-        # unquote operator u locally turns the transformation back on:
-        t3 = (q, (u, print, 42), (print, 42), "foo", "bar")
-        assert t3 == (q, None, (print, 42), "foo", "bar")
-
-        # quotes nest; call transformation made when quote level == 0
-        t4 = (q, (print, 42), (q, (u, u, print, 42)), "foo", "bar")
-        assert t4 == (q, (print, 42), (None,), "foo", "bar")
-
-        # Be careful:
-        try:
-            (x,)  # in a prefix block, this means "call the 0-arg function x"
-        except TypeError:
-            pass  # 'int' object is not callable
-        else:
-            assert False, "should have attempted to call x"
-        (q, x)  # OK!
-
-        # give named args with kw(...) [it's syntax, not really a function!]:
-        def f(*, a, b):
-            return (q, a, b)
-        # in one kw(...), or...
-        assert (f, kw(a="hi there", b="foo")) == (q, "hi there", "foo")
-        # in several kw(...), doesn't matter
-        assert (f, kw(a="hi there"), kw(b="foo")) == (q, "hi there", "foo")
-        # in case of duplicate name across kws, rightmost wins
-        assert (f, kw(a="hi there"), kw(b="foo"), kw(b="bar")) == (q, "hi there", "bar")
-
-        # give *args with unpythonic.fun.apply, like in Lisps:
-        lst = [1, 2, 3]
-        def g(*args, **kwargs):
-            return args + tuple(sorted(kwargs.items()))
-        assert (apply, g, lst) == (q, 1, 2, 3)
-        # lst goes last; may have other args first
-        assert (apply, g, "hi", "ho", lst) == (q, "hi", "ho", 1, 2, 3)
-        # named args in apply are also fine
-        assert (apply, g, "hi", "ho", lst, kw(myarg=4)) == (q, "hi", "ho", 1, 2, 3, ('myarg', 4))
-
-        # Function call transformation only applies to tuples in load context
-        # (i.e. NOT on the LHS of an assignment)
-        a, b = (q, 100, 200)
-        assert a == 100 and b == 200
-        a, b = (q, b, a)  # pythonic swap in prefix syntax; must quote RHS
-        assert a == 200 and b == 100
-
-        # prefix leaves alone the let binding syntax ((name0, value0), ...)
-        a = let((x, 42))[x << x + 1]
-        assert a == 43
-
-        # but the RHSs of the bindings are transformed normally:
-        def double(x):
-            return 2 * x
-        a = let((x, (double, 21)))[x << x + 1]
-        assert a == 43
-
-        # similarly, prefix leaves the "body tuple" of a do alone
-        # (syntax, not semantically a tuple), but recurses into it:
-        a = do[1, 2, 3]
-        assert a == 3
-        a = do[1, 2, (double, 3)]
-        assert a == 6
-
-        # the extra bracket syntax has no danger of confusion, as it's a list, not tuple
-        a = let((x, 3))[[
-                  1,
-                  2,
-                  (double, x)]]
-        assert a == 6
-
-    # Introducing the LisThEll programming language: an all-in-one solution with
-    # the prefix syntax of Lisp, the speed of Python, and the readability of Haskell!
-    with prefix, curry:
-        mymap = lambda f: (foldr, (compose, cons, f), nil)
-        double = lambda x: 2 * x
-        (print, (mymap, double, (q, 1, 2, 3)))
-        assert (mymap, double, (q, 1, 2, 3)) == ll(2, 4, 6)
-
-    print("All tests PASSED")
+    with testset("unpythonic.syntax.prefix"):
+        with prefix:
+            (print, "hello world")
+            x = 42  # can write any regular Python, too
+
+            with testset("quote operator"):
+                # quote operator q locally turns off the function-call transformation:
+                t1 = (q, 1, 2, (3, 4), 5)  # q takes effect recursively
+                t2 = (q, 17, 23, x)  # unlike in Lisps, x refers to its value even in a quote
+                (print, t1, t2)
+
+                # unquote operator u locally turns the transformation back on:
+                t3 = (q, (u, print, 42), (print, 42), "foo", "bar")
+                test[t3 == (q, None, (print, 42), "foo", "bar")]
+
+                # quotes nest; call transformation made when quote level == 0
+                t4 = (q, (print, 42), (q, (u, u, print, 42)), "foo", "bar")
+                test[t4 == (q, (print, 42), (None,), "foo", "bar")]
+
+            with testset("tuple in load context denotes a call"):
+                # Be careful:
+                test_raises[TypeError,
+                            (x,),  # in a prefix block, this 1-element tuple means "call the 0-arg function x"
+                            "should have attempted to call x"]
+
+                test[returns_normally((q, x))]  # quoted, OK!
+
+                # Function call transformation only applies to tuples in load context
+                # (i.e. NOT on the LHS of an assignment)
+                a, b = (q, 100, 200)
+                test[a == 100 and b == 200]
+                a, b = (q, b, a)  # pythonic swap in prefix syntax; must quote RHS
+                test[a == 200 and b == 100]
+
+            with testset("kwargs"):
+                # give named args with kw(...) [it's syntax, not really a function!]:
+                def f(*, a, b):
+                    return (q, a, b)
+                # in one kw(...), or...
+                test[(f, kw(a="hi there", b="foo")) == (q, "hi there", "foo")]
+                # in several kw(...), doesn't matter
+                test[(f, kw(a="hi there"), kw(b="foo")) == (q, "hi there", "foo")]
+                # in case of duplicate name across kws, rightmost wins
+                test[(f, kw(a="hi there"), kw(b="foo"), kw(b="bar")) == (q, "hi there", "bar")]
+
+            with testset("starargs"):
+                # give *args with unpythonic.fun.apply, like in Lisps:
+                lst = [1, 2, 3]
+                def g(*args, **kwargs):
+                    return args + tuple(sorted(kwargs.items()))
+                test[(apply, g, lst) == (q, 1, 2, 3)]
+                # lst goes last; may have other args first
+                test[(apply, g, "hi", "ho", lst) == (q, "hi", "ho", 1, 2, 3)]
+                # named args in apply are also fine
+                test[(apply, g, "hi", "ho", lst, kw(myarg=4)) == (q, "hi", "ho", 1, 2, 3, ('myarg', 4))]
+
+            with testset("integration with let and do"):
+                # prefix leaves alone the let binding syntax ((name0, value0), ...)
+                a = let((x, 42))[x << x + 1]
+                test[a == 43]
+
+                # but the RHSs of the bindings are transformed normally:
+                def double(x):
+                    return 2 * x
+                a = let((x, (double, 21)))[x << x + 1]
+                test[a == 43]
+
+                # similarly, prefix leaves the "body tuple" of a do alone
+                # (syntax, not semantically a tuple), but recurses into it:
+                a = do[1, 2, 3]
+                test[a == 3]
+                a = do[1, 2, (double, 3)]
+                test[a == 6]
+
+                # the extra bracket syntax has no danger of confusion, as it's a list, not tuple
+                a = let((x, 3))[[
+                          1,
+                          2,
+                          (double, x)]]
+                test[a == 6]
+
+        # Introducing the LisThEll programming language: an all-in-one solution with
+        # the prefix syntax of Lisp, the speed of Python, and the readability of Haskell!
+        with testset("LisThEll"):
+            with prefix, curry:
+                mymap = lambda f: (foldr, (compose, cons, f), nil)
+                double = lambda x: 2 * x
+                (print, (mymap, double, (q, 1, 2, 3)))
+                test[(mymap, double, (q, 1, 2, 3)) == ll(2, 4, 6)]
 
 if __name__ == '__main__':
     runtests()
diff --git a/unpythonic/syntax/testutil.py b/unpythonic/syntax/testutil.py
@@ -30,20 +30,21 @@
 _test_function_names = ["unpythonic_assert",
                         "unpythonic_assert_signals",
                         "unpythonic_assert_raises"]
+def isunexpandedtestmacro(tree):
+    """Return whether `tree` is an invocation of a testing macro, unexpanded."""
+    return (type(tree) is Subscript and
+            type(tree.value) is Name and
+            tree.value.id in _test_macro_names)
+def isexpandedtestmacro(tree):
+    """Return whether `tree` is an invocation of a testing macro, expanded."""
+    return (type(tree) is Call and
+            any(isx(tree.func, fname, accept_attr=False)
+                for fname in _test_function_names))
 def istestmacro(tree):
     """Return whether `tree` is an invocation of a testing macro.
 
-    Expanded or unexpanded doesn't matter; this is currently provided
-    so that other macros can detect and skip subtrees that invoke a test.
+    Expanded or unexpanded doesn't matter.
     """
-    def isunexpandedtestmacro(tree):
-        return (type(tree) is Subscript and
-                type(tree.value) is Name and
-                tree.value.id in _test_macro_names)
-    def isexpandedtestmacro(tree):
-        return (type(tree) is Call and
-                any(isx(tree.func, fname, accept_attr=False)
-                    for fname in _test_function_names))
     return isunexpandedtestmacro(tree) or isexpandedtestmacro(tree)
 
 # -----------------------------------------------------------------------------
