Reduce required stack frames

It was easier to hit the recursion limit with long chains of if-elif. This makes that less of an issue.

Author: dflook

src/python_minifier/transforms/remove_dead_branches.py

@@ -186,44 +186,62 @@ def changes_semantics(self, namespace, candidate_suite):
         else:
             return properties != candidate_properties
 
+    def constant_test(self, node):
+        """
+        The constant truth value of an if statement's test, or None
+
+        RemoveDebug marks if statements whose __debug__ test it has resolved
+        with a resolved_test attribute. Otherwise only the True and False
+        constants are recognised - before python 3.4 they are reassignable
+        names, so nothing is recognised.
+
+        :param node: The statement to examine
+        :type node: ast.AST
+        :rtype: bool or None
+        """
+        if not isinstance(node, ast.If):
+            return None
+
+        if hasattr(node, 'resolved_test'):
+            if node.resolved_test is True or node.resolved_test is False:
+                return node.resolved_test
+            return None
+
+        if is_constant_node(node.test, ast.NameConstant) and isinstance(node.test.value, bool):
+            return node.test.value
+
+        return None
+
     def remove_false_branches(self, node_list):
         suite = []
 
         for node in node_list:
-            if not isinstance(node, ast.If):
-                suite.append(self.visit(node))
-                continue
+            condition = self.constant_test(node)
 
-            # This is an If statement
+            # A branch of a constant test can be removed, if that doesn't change
+            # the semantics of the program
 
-            if hasattr(node, 'resolved_test'):
-                condition = node.resolved_test
-            elif is_constant_node(node.test, ast.NameConstant) and isinstance(node.test.value, bool):
-                condition = node.test.value
-            else:
-                # The test is not a constant, so we can't remove this branch
-                suite.append(self.visit(node))
+            if condition is True and not self.changes_semantics(node.namespace, node.orelse):
+                # The else branch is dead, keep only the body
+                self._removed_suites.append(node.orelse)
+                suite.extend(self.remove_false_branches(node.body))
                 continue
 
-            # We can possibly remove one of the branches, but we need to check if it changes the semantics of the program
-
-            if condition is True:
-                if self.changes_semantics(node.namespace, node.orelse):
-                    # Removing the else branch changes the semantics of the program, so we can't remove it
-                    suite.append(self.visit(node))
-                else:
-                    # The else branch is dead, keep only the body
-                    self._removed_suites.append(node.orelse)
-                    suite.extend(self.remove_false_branches(node.body))
-
-            elif condition is False:
-                if self.changes_semantics(node.namespace, node.body):
-                    # Removing the body branch changes the semantics of the program, so we can't remove it
-                    suite.append(self.visit(node))
-                else:
-                    # The body is dead, keep only the else branch
-                    self._removed_suites.append(node.body)
-                    suite.extend(self.remove_false_branches(node.orelse))
+            if condition is False and not self.changes_semantics(node.namespace, node.body):
+                # The body is dead, keep only the else branch
+                self._removed_suites.append(node.body)
+                suite.extend(self.remove_false_branches(node.orelse))
+                continue
+
+            node = self.visit(node)
+
+            # An else suite that dead branch removal (or another transform) emptied
+            # or reduced to the 0 padding can be omitted.
+            orelse = getattr(node, 'orelse', None)
+            if orelse and self._is_empty_suite(orelse):
+                node.orelse = []
+
+            suite.append(node)
 
         return suite
 
@@ -253,39 +271,3 @@ def _is_empty_suite(self, suite):
         if len(suite) == 0:
             return True
         return len(suite) == 1 and isinstance(suite[0], ast.Expr) and is_constant_node(suite[0].value, ast.Num) and suite[0].value.n == 0
-
-    def visit_If(self, node):
-        node = super(RemoveDeadBranches, self).visit_If(node)
-
-        # Empty orelse suite can be omitted
-        if self._is_empty_suite(node.orelse):
-            node.orelse = []
-
-        return node
-
-    def visit_While(self, node):
-        node = super(RemoveDeadBranches, self).visit_While(node)
-
-        # Empty orelse suite can be omitted
-        if self._is_empty_suite(node.orelse):
-            node.orelse = []
-
-        return node
-
-    def visit_For(self, node):
-        node = super(RemoveDeadBranches, self).visit_For(node)
-
-        # Empty orelse suite can be omitted
-        if self._is_empty_suite(node.orelse):
-            node.orelse = []
-
-        return node
-
-    def visit_Try(self, node):
-        node = super(RemoveDeadBranches, self).visit_Try(node)
-
-        # Empty orelse suite can be omitted
-        if self._is_empty_suite(node.orelse):
-            node.orelse = []
-
-        return node

test/test_remove_dead_branches.py

@@ -531,6 +531,43 @@ def test_removes_from_match_case():
 
 # endregion
 
+# region deep nesting
+
+def stack_depth():
+    depth = 0
+    frame = sys._getframe()
+    while frame is not None:
+        depth += 1
+        frame = frame.f_back
+    return depth
+
+
+def test_deep_elif_chain():
+    # Machine generated dispatch code can contain elif chains hundreds of levels
+    # deep. elif chains nest through the orelse suite without any indentation, so
+    # they are not capped by the tokenizer's 100 level indentation limit and the
+    # transform must not use more stack frames per level than other transforms.
+    # The transform gets a fixed stack budget so the test doesn't depend on how
+    # deep the test runner's own stack already is.
+    source = 'if x0:\n a()\n' + ''.join('elif x%d:\n a()\n' % i for i in range(1, 150))
+
+    limit = sys.getrecursionlimit()
+    try:
+        sys.setrecursionlimit(stack_depth() + 700)
+        run_test(source, source)
+    finally:
+        sys.setrecursionlimit(limit)
+
+
+def test_deep_constant_elif_chain():
+    # A chain of dead elif branches is spliced level by level, which must not
+    # exhaust the stack either
+    skip_if_no_nameconstant()
+    source = 'if False:\n a()\n' + ''.join('elif False:\n a()\n' for _ in range(1, 150))
+    run_test(source, '')
+
+# endregion
+
 # region orelse cleanup
 
 def test_drops_emptied_if_else():