Make an attempt to inline recursive functions if some arguments literal

Now attempt recursive inlining if the arguments aren't all dynamic. 
Monitor inlining depth and raise a recursion error if it's getting out 
of hand. This also requires fixing all simplifier name binding to unwind 
the bindings if an exception is raised. New tests of this functionality 
and generally tidying-up of simplifier call tests.

Fixes #69

Author: jonathanhogg

src/flitter/language/tree.pyx

@@ -20,6 +20,7 @@ from .vm cimport Program, Instruction, InstructionInt, InstructionVector, OpCode
 logger = name_patch(logger, __name__)
 
 cdef Literal NoOp = Literal(null_)
+cdef int64_t MAX_RECURSIVE_CALL_DEPTH = 500
 
 
 cdef bint sequence_pack(list expressions):
@@ -231,8 +232,10 @@ cdef class Import(Expression):
         cdef Expression expr = self.expr
         if let_names:
             expr = Let(tuple(PolyBinding((name,), value if isinstance(value, Function) else Literal(value)) for name, value in let_names.items()), expr)
-        expr = expr._simplify(context)
-        context.names = saved
+        try:
+            expr = expr._simplify(context)
+        finally:
+            context.names = saved
         if not remaining:
             return expr
         if filename is self.filename and expr is self.expr:
@@ -992,29 +995,33 @@ cdef class Call(Expression):
         cdef bint literal_func = isinstance(function, Literal)
         if literal_func and not (<Literal>function).value.objects:
             return NoOp
-        cdef bint literal_args = True
+        cdef bint all_literal_args=True, all_dynamic_args=True
         cdef Expression arg, sarg, expr
         cdef list args = []
         if self.args:
             for arg in self.args:
                 sarg = arg._simplify(context)
                 touched |= sarg is not arg
                 args.append(sarg)
-                if not isinstance(sarg, Literal):
-                    literal_args = False
+                if isinstance(sarg, Literal):
+                    all_dynamic_args = False
+                else:
+                    all_literal_args = False
         cdef list keyword_args = []
         cdef Binding binding
         if self.keyword_args:
             for binding in self.keyword_args:
                 arg = binding.expr._simplify(context)
                 touched |= arg is not binding.expr
                 keyword_args.append(Binding(binding.name, arg))
-                if not isinstance(arg, Literal):
-                    literal_args = False
+                if isinstance(arg, Literal):
+                    all_dynamic_args = False
+                else:
+                    all_literal_args = False
         cdef list bindings
         cdef dict kwargs
         cdef int64_t i
-        if func_expr is not None and not func_expr.captures and (not func_expr.recursive or literal_args):
+        if func_expr is not None and not func_expr.captures and not (func_expr.recursive and all_dynamic_args):
             kwargs = {binding.name: binding.expr for binding in keyword_args}
             bindings = []
             for i, binding in enumerate(func_expr.parameters):
@@ -1026,11 +1033,26 @@ cdef class Call(Expression):
                     bindings.append(PolyBinding((binding.name,), binding.expr))
                 else:
                     bindings.append(PolyBinding((binding.name,), Literal(null_)))
-            expr = Let(tuple(bindings), func_expr.body)._simplify(context)
-            return expr
+            if func_expr.recursive:
+                if context.call_depth == 0:
+                    context.call_depth = 1
+                    try:
+                        return Let(tuple(bindings), func_expr.body)._simplify(context)
+                    except RecursionError:
+                        pass
+                    context.call_depth = 0
+                elif context.call_depth == MAX_RECURSIVE_CALL_DEPTH:
+                    raise RecursionError()
+                else:
+                    context.call_depth += 1
+                    expr = Let(tuple(bindings), func_expr.body)._simplify(context)
+                    context.call_depth -= 1
+                    return expr
+            else:
+                return Let(tuple(bindings), func_expr.body)._simplify(context)
         cdef list vector_args, results
         cdef Literal literal_arg
-        if literal_func and literal_args:
+        if literal_func and all_literal_args:
             vector_args = [literal_arg.value for literal_arg in args]
             kwargs = {binding.name: (<Literal>binding.expr).value for binding in keyword_args}
             results = []
@@ -1364,9 +1386,12 @@ cdef class Let(Expression):
                 context.names[name] = None
             remaining.append(PolyBinding(binding.names, expr))
         cdef bint resimplify = shadowed and shadowed & discarded
-        cdef Expression sbody = body._simplify(context)
-        touched |= sbody is not body
-        context.names = saved
+        cdef Expression sbody
+        try:
+            sbody = body._simplify(context)
+            touched |= sbody is not body
+        finally:
+            context.names = saved
         if isinstance(sbody, Literal):
             return sbody
         if isinstance(sbody, Let):
@@ -1432,19 +1457,23 @@ cdef class For(Expression):
         if not isinstance(source, Literal):
             for name in self.names:
                 context.names[name] = None
-            body = self.body._simplify(context)
-            context.names = saved
+            try:
+                body = self.body._simplify(context)
+            finally:
+                context.names = saved
             if source is self.source and body is self.body:
                 return self
             return For(self.names, source, body)
         values = (<Literal>source).value
         cdef int64_t i=0, n=values.length
-        while i < n:
-            for name in self.names:
-                context.names[name] = values.item(i) if i < n else null_
-                i += 1
-            remaining.append(self.body._simplify(context))
-        context.names = saved
+        try:
+            while i < n:
+                for name in self.names:
+                    context.names[name] = values.item(i) if i < n else null_
+                    i += 1
+                remaining.append(self.body._simplify(context))
+        finally:
+            context.names = saved
         sequence_pack(remaining)
         if not remaining:
             return NoOp
@@ -1611,7 +1640,10 @@ cdef class Function(Expression):
         for parameter in parameters:
             context.names[parameter.name] = None
             bound_names.add(parameter.name)
-        body = self.body._simplify(context)
+        try:
+            body = self.body._simplify(context)
+        finally:
+            context.names = saved
         cdef set captures = body._unbound_names(bound_names)
         touched |= body is not self.body
         cdef recursive = self.name in captures
@@ -1621,7 +1653,6 @@ cdef class Function(Expression):
         cdef tuple captures_t = tuple(captures)
         cdef bint inlineable = literal and not captures_t
         touched |= inlineable != self.inlineable
-        context.names = saved
         touched |= captures_t != self.captures
         if not touched:
             return self

src/flitter/model.pxd

@@ -245,3 +245,4 @@ cdef class Context:
     cdef readonly object stack
     cdef readonly object lnames
     cdef readonly set dependencies
+    cdef readonly int64_t call_depth

tests/test_simplifier.py

@@ -7,6 +7,7 @@
 import unittest
 import unittest.mock
 
+from flitter import configure_logger
 from flitter.model import Vector, Node, StateDict, null, true, false
 from flitter.language import functions
 from flitter.language.tree import (Literal, Name, Sequence,
@@ -20,6 +21,9 @@
                                    Binding, PolyBinding, IfCondition)
 
 
+configure_logger('ERROR')
+
+
 class SimplifierTestCase(unittest.TestCase):
     def assertSimplifiesTo(self, x, y, state=None, dynamic=None, static=None, with_errors=None, with_dependencies=None, unbound=None):
         aliases = set()
@@ -1036,58 +1040,76 @@ def test_non_callable_literal(self):
 
     def test_simple_named_inlining(self):
         """Calls to names that resolve to Function objects are inlined as let expressions"""
-        func = Function('func', (Binding('x', Literal(null)),), Add(Name('x'), Literal(5)), captures=(), inlineable=True)
-        self.assertSimplifiesTo(Call(Name('func'), (Add(Literal(1), Name('y')),), ()),
+        f = Function('f', (Binding('x', Literal(null)),), Add(Name('x'), Literal(5)), captures=(), inlineable=True)
+        self.assertSimplifiesTo(Call(Name('f'), (Add(Literal(1), Name('y')),), ()),
                                 Let((PolyBinding(('x',), Add(Literal(1), Name('y'))),), Add(Name('x'), Literal(5))),
-                                static={'func': func}, dynamic={'y'})
+                                static={'f': f}, dynamic={'y'})
 
     def test_simple_anonymous_inlining(self):
         """Direct calls to anonymous functions are inlined as let expressions"""
-        func = Function('<anon>', (Binding('x', Literal(null)),), Add(Name('x'), Literal(5)), captures=(), inlineable=True)
-        self.assertSimplifiesTo(Call(func, (Add(Literal(1), Name('y')),), ()),
+        f = Function('<anon>', (Binding('x', Literal(null)),), Add(Name('x'), Literal(5)), captures=(), inlineable=True)
+        self.assertSimplifiesTo(Call(f, (Add(Literal(1), Name('y')),), ()),
                                 Let((PolyBinding(('x',), Add(Literal(1), Name('y'))),), Add(Name('x'), Literal(5))),
                                 dynamic={'y'})
 
     def test_simple_inlined_missing_parameter_default(self):
         """An inlined function with a default parameter value used"""
-        func = Function('func', (Binding('x', None), Binding('y', Literal(1))), Add(Name('x'), Name('y')), captures=(), inlineable=True)
-        self.assertSimplifiesTo(Call(Name('func'), (Literal(5),), ()),
+        f = Function('f', (Binding('x', None), Binding('y', Literal(1))), Add(Name('x'), Name('y')), captures=(), inlineable=True)
+        self.assertSimplifiesTo(Call(Name('f'), (Literal(5),), ()),
                                 Literal(6),
-                                static={'func': func})
+                                static={'f': f})
 
     def test_simple_inlined_keyword_argument(self):
         """An inlined function with a keyword argument given"""
-        func = Function('func', (Binding('x', None), Binding('y', Literal(1))), Add(Name('x'), Name('y')), captures=(), inlineable=True)
-        self.assertSimplifiesTo(Call(Name('func'), (Literal(1),), (Binding('y', Literal(2)),)),
+        f = Function('f', (Binding('x', None), Binding('y', Literal(1))), Add(Name('x'), Name('y')), captures=(), inlineable=True)
+        self.assertSimplifiesTo(Call(Name('f'), (Literal(1),), (Binding('y', Literal(2)),)),
                                 Literal(3),
-                                static={'func': func})
+                                static={'f': f})
 
     def test_simple_inlined_missing_default_parameter_used(self):
         """An inlined function with a keyword argument given"""
-        func = Function('func', (Binding('x', None), Binding('y', Literal(1))), Add(Name('x'), Name('y')), captures=(), inlineable=True)
-        self.assertSimplifiesTo(Call(Name('func'), (), ()),
+        f = Function('f', (Binding('x', None), Binding('y', Literal(1))), Add(Name('x'), Name('y')), captures=(), inlineable=True)
+        self.assertSimplifiesTo(Call(Name('f'), (), ()),
                                 Literal(null),
-                                static={'func': func})
-
-    def test_inlineable_recursive_non_literal(self):
-        """Calls to inlineable, recursive functions are *not* inlined if arguments are not all literal"""
-        func = Function(
-            'func',
-            (Binding('x', Literal(null)),),
-            IfElse((IfCondition(GreaterThan(Name('x'), Literal(0)), Add(Name('x'), Call(Name('func'), (Subtract(Name('x'), Literal(1)),)))),), Literal(0)),
-            captures=(), inlineable=True, recursive=True
-        )
-        self.assertSimplifiesTo(Call(Name('func'), (Name('y'),)), Call(Name('func'), (Name('y'),)), static={'func': func}, dynamic={'y'})
-
-    def test_inlineable_recursive_literal(self):
-        """Calls to inlineable, recursive functions *are* inlined if arguments are all literal"""
-        func = Function(
-            'func',
-            (Binding('x', Literal(null)),),
-            IfElse((IfCondition(GreaterThan(Name('x'), Literal(0)), Add(Name('x'), Call(Name('func'), (Subtract(Name('x'), Literal(1)),)))),), Literal(0)),
+                                static={'f': f})
+
+
+class TestRecursiveCall(SimplifierTestCase):
+    def setUp(self):
+        self.f = Function(
+            'f',
+            (Binding('x', Literal(null)), Binding('y', Literal(null))),
+            IfElse((IfCondition(GreaterThan(Name('x'), Literal(0)),
+                                Add(Name('y'), Call(Name('f'), (Subtract(Name('x'), Literal(1)), Divide(Name('y'), Literal(2)))))),),
+                   Literal(0)),
             captures=(), inlineable=True, recursive=True
         )
-        self.assertSimplifiesTo(Call(Name('func'), (Literal(5),)), Literal(15), static={'func': func})
+
+    def test_inlineable_recursive_all_non_literal(self):
+        """A call to a recursive function with no literal arguments will not be inlined"""
+        self.assertSimplifiesTo(Call(Name('f'), (Name('z'), Name('w'))),
+                                Call(Name('f'), (Name('z'), Name('w'))),
+                                static={'f': self.f}, dynamic={'z', 'w'})
+
+    def test_inlineable_recursive_literal_bound(self):
+        """A call to a recursive function with at least literal arguments will cause an inline attempt.
+           In this case the literal argument determines the bounds and so recursive inlining will succeed."""
+        self.assertSimplifiesTo(Call(Name('f'), (Literal(2), Name('w'))),
+                                Add(Name('w'), Let((PolyBinding(('y',), Multiply(Literal(0.5), Name('w'))),), Positive(Name('y')))),
+                                static={'f': self.f}, dynamic={'w'})
+
+    def test_inlineable_recursive_dynamic_bound(self):
+        """A call to a recursive function with at least literal arguments will cause an inline attempt.
+           In this case the literal argument does not determine the bounds and so recursive inlining will fail."""
+        self.assertSimplifiesTo(Call(Name('f'), (Name('z'), Literal(1))),
+                                Call(Name('f'), (Name('z'), Literal(1))),
+                                static={'f': self.f}, dynamic={'z'})
+
+    def test_inlineable_recursive_all_literal(self):
+        """A call to a recursive function with all literal arguments should be fully simplified"""
+        self.assertSimplifiesTo(Call(Name('f'), (Literal(4), Literal(32))),
+                                Literal(32+16+8+4+0),
+                                static={'f': self.f})
 
 
 class TestFastFunctions(SimplifierTestCase):