Using upvalues of atoms in evaluations. (#1507)

In the `Expression.rewrite_apply_eval_step` method, in the upvalues
lookup, to reduce the cost of evaluating expressions with many numerical
elements, we use to skip atomic elements. This makes that upvalues of
atomic elements get never evaluated (see #1506). This PR fix by, instead
of skipping atoms, just check beforehand if all the elements are of the
same kind.

---------

Co-authored-by: R. Bernstein <[email protected]>

Author: mmatera

mathics/builtin/layout.py

@@ -60,7 +60,7 @@ class Format(Builtin):
 
     Raw objects cannot be formatted:
     >> Format[3] = "three";
-     : Cannot assign to raw object 3.
+     : Tag Integer in 3 is Protected.
 
     Format types must be symbols:
     >> Format[r, a + b] = "r";

mathics/core/assignment.py

@@ -102,10 +102,10 @@ def get_symbol_values(
         A list of rules. None if `symbol` is not a Symbol.
 
     """
-    name = symbol.get_name()
-    if not name:
+    if not isinstance(symbol, Symbol):
         evaluation.message(func_name, "sym", symbol, 1)
         return None
+    name = symbol.get_name()
     definitions = evaluation.definitions
     try:
         definition = (

mathics/core/element.py

@@ -77,6 +77,9 @@ class ElementsProperties:
     # this True elements are not sorted can cause evaluation differences.
     is_ordered: bool = False
 
+    # Uniform expressions have all their elements with the same Head.
+    is_uniform: bool = False
+
 
 class ImmutableValueMixin:
     @property

mathics/core/expression.py

@@ -355,15 +355,25 @@ def _build_elements_properties(self):
         """
 
         # All of the properties start out optimistic (True) and are reset when that proves wrong.
-        self.elements_properties = ElementsProperties(True, True, True)
+        self.elements_properties = ElementsProperties(True, True, True, True)
 
         last_element = None
         values = []
+        last_lookup_name = ""
+        uniform = True
         for element in self._elements:
             # Test for the literalness, and the three properties mentioned above
             if not element.is_literal:
                 self.elements_properties.elements_fully_evaluated = False
 
+            if uniform:
+                lookup_name = element.get_lookup_name()
+                if last_lookup_name:
+                    if lookup_name != last_lookup_name:
+                        uniform = self.elements_properties.is_uniform = False
+                else:
+                    last_lookup_name = lookup_name
+
             if isinstance(element, Expression):
                 # "self" can't be flat.
                 self.elements_properties.is_flat = False
@@ -1296,6 +1306,7 @@ def flatten_callback(new_elements, old):
                 else:
                     return threaded, True
 
+        elements_properties = new.elements_properties
         # Step 6:
         # Look at the rules associated with:
         #   1. the upvalues of each element
@@ -1335,15 +1346,17 @@ def flatten_callback(new_elements, old):
         def rules():
             rules_names = set()
             if not A_HOLD_ALL_COMPLETE & attributes:
-                for element in elements:
-                    if not isinstance(element, EvalMixin):
-                        continue
+                sample_elements = (
+                    (elements[0],)
+                    if elements and elements_properties.is_uniform
+                    else elements
+                )
+                for element in sample_elements:
                     name = element.get_lookup_name()
-                    if len(name) > 0:  # only lookup rules if this is a symbol
-                        if name not in rules_names:
-                            rules_names.add(name)
-                            for rule in evaluation.definitions.get_upvalues(name):
-                                yield rule
+                    if name and name not in rules_names:
+                        rules_names.add(name)
+                        for rule in evaluation.definitions.get_upvalues(name):
+                            yield rule
             lookup_name = new.get_lookup_name()
             if lookup_name == new.get_head_name():
                 for rule in evaluation.definitions.get_downvalues(lookup_name):

mathics/core/symbols.py

@@ -216,6 +216,13 @@ def get_head_name(self) -> "str":
     #        1/0
     #        return None if stop_on_error else {}
 
+    def get_lookup_name(self) -> str:
+        """
+        By default, atoms that are not symbols
+        have their class head_names as their lookup names.
+        """
+        return self.class_head_name
+
     @property
     def element_order(self) -> tuple:
         """
@@ -461,6 +468,12 @@ def get_head(self) -> "Symbol":
     def get_head_name(self) -> str:
         return "System`Symbol"
 
+    def get_lookup_name(self) -> str:
+        """
+        The lookup name of a Symbol is its name.
+        """
+        return self.get_name()
+
     def get_option_values(self, evaluation, allow_symbols=False, stop_on_error=True):
         """
         Build a dictionary of options from an expression.

mathics/eval/assignments/assignment.py

@@ -508,7 +508,7 @@ def eval_assign_format(
     lhs_reference = get_reference_expression(lhs)
     lhs_reference = (
         lhs_reference.get_head()
-        if isinstance(lhs_reference, Expression)
+        if not isinstance(lhs_reference, Symbol)
         else lhs_reference
     )
     tags = process_tags_and_upset_dont_allow_custom(

test/test_evaluation.py

@@ -289,6 +289,20 @@ def test_system_specific_long_integer():
 #             check_evaluation_with_err(str_expr, str_expected, message)
 
 
+def test_eval_atom_upvalues():
+    """Check that upvalues of atoms are taken into account in evaluations"""
+    # Clear definitions
+    check_evaluation(None, None, None)
+    check_evaluation(
+        "Unprotect[Real]; Real/:F[x_Real]:=x; DownValues[F]",
+        "{}",
+        "F does not have downvalues",
+    )
+    check_evaluation("F[3.]", "3.", "Upvalue of Real is taken into account.")
+    # Clear definitions again.
+    check_evaluation(None, None, None)
+
+
 def test_exit():
     global session
     try: