respect $IterationLimit more places (#1477)

Respect $IterationLimit more places. Fixes #1476

There are probably more places where we need to do something similar, but this is a start.

---------

Co-authored-by: Juan Mauricio Matera <[email protected]>

Author: rocky

mathics/builtin/evaluation.py

@@ -84,11 +84,18 @@ class IterationLimit(Predefined):
     Calculations terminated by '\$IterationLimit' return '\$Aborted':
 
     >> $IterationLimit
-     = 1000
+     = 4096
+
+    The iteration limit protects against runaway definitions:
+
+    >> Block[{$IterationLimit = 20}, yin := yang; yang := yin; yin]
+     : Iteration limit of 20 exceeded.
+     = $Aborted
+
     """
 
     name = "$IterationLimit"
-    value = 1000
+    value = 4096
 
     rules = {
         "$IterationLimit": str(value),
@@ -186,7 +193,7 @@ class Evaluate(Builtin):
     >> f[1 + 2]
      = f[1 + 2]
 
-    'Evaluate' forces evaluation of the argument, even though $f$ has
+    'Evaluate' forces evaluation of the argument, even though $f$ has \
     the 'HoldAll' attribute:
     >> f[Evaluate[1 + 2]]
      = f[3]
@@ -211,9 +218,9 @@ class Unevaluated(Builtin):
     <url>:WMA link:https://reference.wolfram.com/language/ref/Unevaluated.html</url>
 
     <dl>
-    <dt>'Unevaluated'[$expr$]
-        <dd>temporarily leaves $expr$ in an unevaluated form when it
-        appears as a function argument.
+      <dt>'Unevaluated'[$expr$]
+      <dd>temporarily leaves $expr$ in an unevaluated form when it \
+          appears as a function argument.
     </dl>
 
     'Unevaluated' is automatically removed when function arguments are

mathics/core/evaluation.py

@@ -144,6 +144,10 @@ def __init__(
         self.quiet_all = False
         self.recursion_depth = 0
 
+        # iteration is used to keep track of evaluation chains and is
+        # compared against $IterationLimit.
+        self.iteration_count = 0
+
         # Interrupt handlers may need access to the shell
         # that invoked the evaluation.
         self.shell = None

mathics/core/symbols.py

@@ -1,6 +1,7 @@
 # cython: language_level=3
 # -*- coding: utf-8 -*-
 
+import sys
 from typing import TYPE_CHECKING, Any, Dict, FrozenSet, List, Optional, Sequence, Union
 
 from mathics.core.element import (
@@ -434,6 +435,23 @@ def evaluate(self, evaluation):
             if result is not None and not result.sameQ(self):
                 if result.is_literal:
                     return result
+
+                # We will be using $IterationLimit, not $RecursionLimit below
+                # to catch symbolic looping rewrite expansions.
+                # We do this to model Mathematica behavior more closely.
+                limit = (
+                    evaluation.definitions.get_config_value("$IterationLimit")
+                    or sys.maxsize
+                )
+                if limit is None:
+                    limit = sys.maxsize
+                if limit != sys.maxsize and evaluation.iteration_count > limit:
+                    evaluation.error("$IterationLimit", "itlim", limit)
+                    from mathics.core.systemsymbols import SymbolAborted
+
+                    return SymbolAborted
+                evaluation.iteration_count += 1
+
                 return result.evaluate(evaluation)
         return self
 

mathics/session.py

@@ -143,6 +143,7 @@ def reset(self, add_builtin=True, catch_interrupt=False):
     def evaluate(self, str_expression, timeout=None, form=None):
         """Parse str_expression and evaluate using the `evaluate` method of the Expression"""
         self.evaluation.out.clear()
+        self.evaluation.iteration_count = 0
         expr = parse(
             self.definitions,
             MathicsSingleLineFeeder(str_expression, ContainerKind.STREAM),
@@ -155,6 +156,7 @@ def evaluate(self, str_expression, timeout=None, form=None):
     def evaluate_as_in_cli(self, str_expression, timeout=None, form=None, src_name=""):
         """This method parse and evaluate the expression using the session.evaluation.evaluate method"""
         self.evaluation.out = []
+        self.evaluation.iteration_count = 0
         query = self.evaluation.parse(str_expression, src_name)
         if query is not None:
             res = self.evaluation.evaluate(query, timeout=timeout, format=form)

test/builtin/test_attributes.py

@@ -4,7 +4,7 @@
 """
 
 import os
-from test.helper import check_evaluation, check_evaluation_as_in_cli, session
+from test.helper import check_evaluation, check_evaluation_as_in_cli
 
 import pytest
 
@@ -229,57 +229,60 @@ def test_Attributes_wrong_args(str_expr, arg_count):
 
 
 @pytest.mark.parametrize(
-    ("str_expr", "msgs", "str_expected", "fail_msg"),
+    ("str_expr", "msgs", "str_expected", "assert_failure_msg"),
     [
         ("CleanAll[u];CleanAll[v];", None, None, None),
         ("SetAttributes[{u, v}, Flat];u[x_] := {x};u[]", None, "u[]", None),
         ("u[a]", None, "{a}", None),
         ("v[x_] := x;v[]", None, "v[]", None),
         ("v[a]", None, "a", None),
         (
-            "v[a, b]",
+            "Block[{$IterationLimit = 40}, v[a, b]]",
             None,
             "v[a, b]",
-            "in Mathematica: Iteration limit of 4096 exceeded.",
+            "Test $IterationLimit catches unbounded expansion",
         ),
         ("CleanAll[u];CleanAll[v];", None, None, None),
     ],
 )
-def test_private_doctests_attributes(str_expr, msgs, str_expected, fail_msg):
+def test_private_doctests_attributes(str_expr, msgs, str_expected, assert_failure_msg):
     """ """
     check_evaluation(
         str_expr,
         str_expected,
         to_string_expr=True,
         to_string_expected=True,
         hold_expected=True,
-        failure_message=fail_msg,
+        failure_message=assert_failure_msg,
         expected_messages=msgs,
     )
 
 
 @pytest.mark.parametrize(
-    ("str_expr", "msgs", "str_expected", "fail_msg"),
+    ("str_expr", "msgs", "str_expected", "assert_failure_msg"),
     [
         ("CleanAll[u];CleanAll[v];", None, None, None),
         (
-            "SetAttributes[{u, v}, Flat];u[x_] := {x};u[a, b]",
-            ("Iteration limit of 1000 exceeded.",),
+            "Block[{$IterationLimit=30}, SetAttributes[{u, v}, Flat];u[x_] := {x};u[a, b]]",
+            ("Iteration limit of 30 exceeded.",),
             "$Aborted",
-            None,
+            "Test $IterationLimit catches unbounded expansion using SetDelayed, test 1.",
+        ),
+        (
+            "Block[{$IterationLimit=20}, u[a, b, c]]",
+            ("Iteration limit of 20 exceeded.",),
+            "$Aborted",
+            "Test $IterationLimit catches unbounded expansion in function call.",
         ),
-        ("u[a, b, c]", ("Iteration limit of 1000 exceeded.",), "$Aborted", None),
         (
-            "v[x_] := x;v[a,b,c]",
-            ("Iteration limit of 1000 exceeded.",),
+            "Block[{$IterationLimit=20}, v[x_] := x;v[a,b,c]]",
+            ("Iteration limit of 20 exceeded.",),
             "$Aborted",
-            "in Mathematica: Iteration limit of 4096 exceeded.",
+            "Test $IterationLimit catches unbounded expansion using SetDelayed, test 2.",
         ),
         ("CleanAll[u];CleanAll[v];", None, None, None),
     ],
 )
-def test_private_doctests_attributes_with_exceptions(
-    str_expr, msgs, str_expected, fail_msg
-):
-    """These tests check the behavior of $RecursionLimit and $IterationLimit"""
-    check_evaluation_as_in_cli(str_expr, str_expected, fail_msg, msgs)
+def test_IterationLimit(str_expr, msgs, str_expected, assert_failure_msg):
+    """Check the behavior of $RecursionLimit and $IterationLimit"""
+    check_evaluation_as_in_cli(str_expr, str_expected, assert_failure_msg, msgs)

test/builtin/test_evaluation.py

@@ -36,7 +36,7 @@
         ),
         (
             "ClearAll[f]; f[x_] := f[x + 1];f[x]",
-            ("Iteration limit of 1000 exceeded.",),
+            ("Iteration limit of 4096 exceeded.",),
             "$Aborted",
             None,
         ),