Nanopass AST-with-holes for testing

typhon/nano/scopes.py

@@ -438,8 +438,10 @@ def visitIfExpr(self, test, consq, alt):
         origLayout = self.layout
         self.layout = layout1 = ScopeBox(origLayout)
         origLayout.addChild(layout1)
+        # The test and if-branch go in the same scope box.
         t = self.visitExpr(test)
         c = self.visitExpr(consq)
+        # The else-branch does not get access to names bound in the test.
         self.layout = layout2 = ScopeBox(origLayout)
         origLayout.addChild(layout2)
         e = self.visitExpr(alt)

typhon/nanopass.py

@@ -238,3 +238,98 @@ def selfPass(self):
     irAttrs["selfPass"] = selfPass
 
     return type(name + "IR", (object,), irAttrs)()
+
+def withHoles(irClass):
+    """
+    Create an object similar to the IR class but for building an AST
+    pattern-matching template rather than building an AST. Designed for use in
+    unit tests.
+
+    Note that this currently doesn't check the schema when constructing a
+    quasi-AST so it's possible to construct a template that will not match any
+    valid AST.
+    """
+    class IRMatcherInstance(object):
+        def __init__(self, quasi, name, args, cls):
+            self.quasi = quasi
+            self.name = name
+            self.args = args
+            self.cls = cls
+
+        def match(self, specimen):
+            if not isinstance(specimen, self.cls):
+                raise ValueError("Expected %s, got %s" % (
+                    self.cls.__name__, type(specimen).__name__))
+            for p, (argname, argtype) in zip(self.args,
+                                             self.quasi.schema[self.name]):
+                val = getattr(specimen, argname)
+                if argtype is None or argtype in irClass.terminals:
+                    if isinstance(p, IRHole):
+                        p.match(val)
+                        continue
+                    elif val != p:
+                        raise ValueError("Expected %r, got %r" % (p, val))
+                    else:
+                        continue
+                if (argtype.endswith('*') and isinstance(p, list)):
+                    for subp, item in zip(p, val):
+                        subp.match(item)
+                else:
+                    p.match(val)
+            return self.quasi.holeMatches
+
+    class IRMatcher(object):
+        def __init__(self, name, quasi, original):
+            self.quasi = quasi
+            self.name = name
+            self.original = original
+
+        def __call__(self, *a):
+            if len(a) != len(self.quasi.schema[self.name]):
+                raise ValueError("Expected %d arguments, got %d" % (
+                    len(a), len(self.quasi.schema[self.name])))
+            return IRMatcherInstance(self.quasi, self.name, a, self.original)
+
+    class IRHole(object):
+        def __init__(self, name, quasi, typeConstructor):
+            self.name = name
+            self.quasi = quasi
+            self.typeConstructor = typeConstructor
+
+        def match(self, specimen):
+            if (self.typeConstructor is not None and
+                not isinstance(specimen, self.typeConstructor)):
+                raise ValueError("Expected %s, got %s" % (
+                    self.typeConstructor.__name__, type(specimen).__name__))
+            self.quasi.holeMatches[self.name] = specimen
+
+
+    class QuasiIR(object):
+        def __init__(self):
+            self.holes = []
+            self.holeMatches = {}
+
+            self.schema = {}
+            for nonterm, constructors in irClass.nonterms.iteritems():
+                for constructor, pieces in constructors.iteritems():
+                    self.schema[constructor] = pieces
+
+        def __getattr__(self, name):
+            return IRMatcher(name, self, getattr(irClass, name))
+
+        def HOLE(self, name, typeConstructor=None):
+            if typeConstructor is not None:
+                if isinstance(typeConstructor, IRMatcher):
+                    tycon = typeConstructor.original
+                elif isinstance(typeConstructor, irClass._NonTerminal):
+                    tycon = typeConstructor
+                else:
+                    raise ValueError("%s is not a type constructor for "
+                                     "either %s or %s" % (typeConstructor, irClass, self))
+            else:
+                tycon = None
+            h = IRHole(name, self, tycon)
+            self.holes.append(h)
+            return h
+
+    return QuasiIR()

typhon/test/test_mast.py

@@ -0,0 +1,127 @@
+from unittest import TestCase
+
+from typhon.nanopass import CompilerFailed, withHoles
+from typhon.nano.mast import MastIR, SanityCheck, SaveScriptIR as ssi
+from typhon.nano.slots import NoAssignIR as nai, RemoveAssign
+from typhon.nano.scopes import LayoutIR as li, LayOutScopes, ScopeBox, ScopeItem
+
+def assertAstSame(left, right):
+    if left == right:
+        return
+    if isinstance(left, list):
+        if not isinstance(right, list):
+            raise AssertionError("%r != %r" % (left, right))
+        for l, r in zip(left, right):
+            assertAstSame(l, r)
+        return
+
+    if type(left) != type(right):
+        raise AssertionError("%r instance expected, %s found" %
+                             (type(left), type(right)))
+    if left._immutable_fields_ and right._immutable_fields_:
+        leftR, rightR = left.__reduce__()[2], right.__reduce__()[2]
+        for k, v in leftR.iteritems():
+            assertAstSame(v, rightR[k])
+
+
+class SanityCheckTests(TestCase):
+    def test_viaPattObjects(self):
+        oAst = MastIR.ObjectExpr(
+            None,
+            MastIR.ViaPatt(MastIR.CallExpr(
+                MastIR.NounExpr(u"foo"),
+                u"run",
+                [MastIR.NounExpr(u"x")], []),
+                           MastIR.FinalPatt(u"x", None), None),
+            [], [], [])
+
+        self.assertRaises(CompilerFailed, SanityCheck().visitExpr, oAst)
+
+
+class RemoveAssignTests(TestCase):
+    def test_rewriteAssign(self):
+        ast1 = ssi.SeqExpr([
+            ssi.AssignExpr(u"blee", ssi.IntExpr(1)),
+            ssi.NounExpr(u"blee")
+            ])
+        ast2 = nai.SeqExpr([
+            nai.HideExpr(nai.SeqExpr([
+                nai.DefExpr(nai.TempPatt(u"_tempAssign"), nai.NullExpr(),
+                            nai.IntExpr(1)),
+                nai.CallExpr(nai.SlotExpr(u"blee"), u"put",
+                             [nai.TempNounExpr(u"_tempAssign")], []),
+                nai.TempNounExpr(u"_tempAssign")])),
+            nai.NounExpr(u"blee")
+            ])
+
+        assertAstSame(ast2, RemoveAssign().visitExpr(ast1))
+
+
+class LayoutScopesTests(TestCase):
+    def test_ifExprSeparateBoxes(self):
+        """
+        The branches of an 'if' expression create their own scope boxes.
+        """
+        layouter = LayOutScopes([], "test", False)
+        qli = withHoles(li)
+        top = layouter.top
+        ast1 = nai.IfExpr(
+            nai.DefExpr(nai.FinalPatt(u"a", nai.NullExpr()), nai.NullExpr(),
+                        nai.IntExpr(1)),
+            nai.SeqExpr([nai.DefExpr(nai.FinalPatt(u"b", nai.NullExpr()),
+                                     nai.NullExpr(), nai.IntExpr(2)),
+                         nai.CallExpr(nai.NounExpr(u"a"), u"add",
+                                      [nai.NounExpr("b")], [])]),
+            nai.SeqExpr([nai.DefExpr(nai.FinalPatt(u"b", nai.NullExpr()),
+                                     nai.NullExpr(), nai.IntExpr(3)),
+                         nai.CallExpr(nai.NounExpr(u"a"), u"add",
+                                      [nai.NounExpr("b")], [])]))
+        qast2 = qli.IfExpr(
+            qli.DefExpr(
+                qli.FinalPatt(u"a", qli.NullExpr(), qli.HOLE("APattern")),
+                qli.NullExpr(), qli.IntExpr(1)),
+            qli.SeqExpr([
+                qli.DefExpr(
+                    qli.FinalPatt(u"b", qli.NullExpr(),
+                                  qli.HOLE("leftBPattern")),
+                    qli.NullExpr(), qli.IntExpr(2)),
+                qli.CallExpr(qli.NounExpr(u"a", qli.HOLE("leftANoun")),
+                             "add", [qli.NounExpr("b", qli.HOLE("leftBNoun"))],
+                             [])]),
+            qli.SeqExpr([qli.DefExpr(qli.FinalPatt(u"b", qli.NullExpr(),
+                                                   qli.HOLE("rightBPattern")),
+                                     qli.NullExpr(), qli.IntExpr(3)),
+                         qli.CallExpr(
+                             qli.NounExpr(u"a", qli.HOLE("rightANoun")),
+                             "add", [qli.NounExpr("b",
+                                                  qli.HOLE("rightBNoun"))],
+                             [])]))
+        scopes = qast2.match(layouter.visitExpr(ast1))
+        self.assertIsInstance(scopes["APattern"], ScopeBox)
+        self.assertIsInstance(scopes["leftBPattern"], ScopeItem)
+        self.assertIsInstance(scopes["leftANoun"], ScopeItem)
+
+        self.assertIs(scopes["APattern"].next, top)
+        self.assertIs(scopes["leftBPattern"].next, scopes["APattern"])
+        self.assertIs(scopes["leftANoun"].next, scopes["leftBPattern"])
+
+        self.assertIsInstance(scopes["rightBPattern"], ScopeBox)
+        self.assertIsInstance(scopes["rightANoun"], ScopeItem)
+
+        self.assertIs(scopes["rightBPattern"].next, top)
+        self.assertIs(scopes["rightANoun"].next, scopes["rightBPattern"])
+
+    def test_escapeExpr(self):
+        """
+        Escape exprs create scope boxes for their expr and catcher, and
+        include the ejector and caught value in them, respectively.
+        """
+
+class InterpTests(TestCase):
+
+    def test_disabledEjector(self):
+        """
+        Ejectors that escape their dynamic context throw when invoked.
+        """
+        # 
+

typhon/test/test_nanopass.py

@@ -0,0 +1,62 @@
+from unittest import TestCase
+
+from typhon.nanopass import makeIR, withHoles
+
+ir = makeIR(
+    "Test",
+    ["Noun", "Literal"],
+    {
+        "Expr": {
+            "DefExpr": [("patt", "Patt"), ("rvalue", "Expr")],
+            "NounExpr": [("name", "Noun")],
+            "LiteralExpr": [("val", "Literal")],
+            "SeqExpr": [("exprs", "Expr*")]
+            },
+        "Patt": {
+            "FinalPatt": [("name", "Noun")],
+            "VarPatt": [("name", "Noun")],
+        }
+    })
+
+class IRDestructuringTests(TestCase):
+    def test_terminalHole(self):
+        qir = withHoles(ir)
+        ast1 = ir.NounExpr("blee")
+        qast = qir.NounExpr(qir.HOLE("name"))
+
+        self.assertEqual(qast.match(ast1), {"name": "blee"})
+
+    def test_nontermHole(self):
+        qir = withHoles(ir)
+        p = ir.FinalPatt("foo")
+        ast1 = ir.DefExpr(p, ir.NounExpr("blee"))
+        qast = qir.DefExpr(qir.HOLE("patt"), qir.NounExpr("blee"))
+
+        self.assertEqual(qast.match(ast1), {"patt": p})
+
+    def test_nonmatchTerminal(self):
+        qir = withHoles(ir)
+        p = ir.FinalPatt("foo")
+        ast1 = ir.DefExpr(p, ir.NounExpr("baz"))
+        qast = qir.DefExpr(qir.HOLE("patt"), qir.NounExpr("blee"))
+        with self.assertRaises(ValueError) as ve:
+            qast.match(ast1)
+        self.assertEqual(ve.exception.message, "Expected 'blee', got 'baz'")
+
+    def test_nonmatchNonterm(self):
+        qir = withHoles(ir)
+        p = ir.FinalPatt("foo")
+        ast1 = ir.DefExpr(p, ir.LiteralExpr(1))
+        qast = qir.DefExpr(qir.HOLE("patt"), qir.NounExpr("blee"))
+        with self.assertRaises(ValueError) as ve:
+            qast.match(ast1)
+        self.assertEqual(ve.exception.message, "Expected NounExpr3, got LiteralExpr5")
+
+    def test_nonmatchNontermType(self):
+        qir = withHoles(ir)
+        p = ir.FinalPatt("foo")
+        ast1 = ir.DefExpr(p, ir.LiteralExpr(1))
+        qast = qir.DefExpr(qir.HOLE("patt", qir.VarPatt), ir.LiteralExpr(1))
+        with self.assertRaises(ValueError) as ve:
+            qast.match(ast1)
+        self.assertEqual(ve.exception.message, "Expected VarPatt8, got FinalPatt7")