fix do_replace in rules where the replacement expression consists on a (nested) Condition[expr, pat] expression

Author: mmatera

CHANGES.rst

@@ -50,7 +50,7 @@ Bugs
 
 # ``0`` with a given precision (like in ```0`3```) is now parsed as ``0``, an integer number.
 #. ``RandomSample`` with one list argument now returns a random ordering of the list items. Previously it would return just one item.
-
+#. Rules of the form ``pat->Condition[expr, cond]`` are handled as in WL. The same works for nested `Condition` expressions.
 
 Enhancements
 ++++++++++++

mathics/core/rules.py

@@ -5,7 +5,7 @@
 
 from mathics.core.element import KeyComparable
 from mathics.core.expression import Expression
-from mathics.core.symbols import strip_context
+from mathics.core.symbols import strip_context, SymbolTrue
 from mathics.core.pattern import Pattern, StopGenerator
 
 from itertools import chain
@@ -136,7 +136,15 @@ def __init__(self, pattern, replace, system=False) -> None:
         self.replace = replace
 
     def do_replace(self, expression, vars, options, evaluation):
-        new = self.replace.replace_vars(vars)
+        replace = self.replace
+        while replace.has_form("System`Condition", 2):
+            replace, cond = replace.elements
+            cond = cond.replace_vars(vars)
+            cond = cond.evaluate(evaluation)
+            if cond is not SymbolTrue:
+                return None
+
+        new = replace.replace_vars(vars)
         new.options = options
 
         # if options is a non-empty dict, we need to ensure reevaluation of the whole expression, since 'new' will

test/builtin/test_patterns.py

@@ -26,3 +26,17 @@ def test_replace_all():
         ),
     ):
         check_evaluation(str_expr, str_expected, message)
+
+
+def test_rule_repl_cond():
+    for str_expr, str_expected, message in (
+        ("f[x]/.(f[u_]->u^2/; u>3/; u>2)", "f[x]", "conditions are not evaluated"),
+        ("f[4]/.(f[u_]->u^2/; u>3/; u>2)", "16", "both conditions are True"),
+        (
+            "f[2.5]/.(f[u_]->u^2/; u>3/; u>2)",
+            "f[2.5]",
+            "just the first condition is True",
+        ),
+        ("f[1.]/.(f[u_]->u^2/; u>3/; u>2)", "f[1.]", "Both conditions are False"),
+    ):
+        check_evaluation(str_expr, str_expected, message)