* Fix Pattern.create in a way that handles input expr that are not Atom or Expression, but have a to_expression method.

* Fix BoxExpression.sameQ to avoid infinite loops.
* adds the pattern_sort parameter to the ``BuiltinExpression.get_sort_key`` method.

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.
-
+#. ``mathics.core.Pattern.create`` now catches the case when the input parameter is not an `Atom` or an `Expression`.
 
 Enhancements
 ++++++++++++

mathics/builtin/base.py

@@ -818,15 +818,20 @@ def get_head_name(self):
     def get_lookup_name(self):
         return self.get_name()
 
-    def get_sort_key(self) -> tuple:
+    def get_sort_key(self, pattern_sort=False) -> tuple:
         return self.to_expression().get_sort_key()
 
     def get_string_value(self):
         return "-@" + self.get_head_name() + "@-"
 
     def sameQ(self, expr) -> bool:
         """Mathics SameQ"""
-        return expr.sameQ(self)
+        if expr is self:
+            return True
+        # Otherwise, we need to convert
+        # self into an to expression
+        # to avoid an infinite loop...
+        return self.to_expression().sameQ(expr)
 
     def do_format(self, evaluation, format):
         return self

mathics/core/pattern.py

@@ -80,18 +80,25 @@ class Pattern:
     def create(expr: BaseElement) -> "Pattern":
         """
         If ``expr`` is listed in ``pattern_object``  return the pattern found there.
-        Otherwise, if ``expr`` is an ``Atom``, create and return  ``AtomPattern`` for ``expr``.
-        Otherwise, create and return and ``ExpressionPattern`` for ``expr``.
+        Otherwise, if ``expr`` is an ``Atom``, create and return  ``AtomPattern`` for ``expr``;
+        if it is an ``Expression`` create and return and ``ExpressionPattern`` for ``expr``.
+        Finally, it tries to get one object of one of these classes
+        by calling the method ``to_expression``, and then call the function
+        again with this new object as input.
         """
-
         name = expr.get_head_name()
         pattern_object = pattern_objects.get(name)
         if pattern_object is not None:
             return pattern_object(expr)
         if isinstance(expr, Atom):
             return AtomPattern(expr)
-        else:
+        elif isinstance(expr, Expression):
             return ExpressionPattern(expr)
+        # To handle Boxes and other possible objects that
+        # can be converted into expressions, convert expr to
+        # expression and call this function
+        # again:
+        return Pattern.create(expr.to_expression())
 
     def match(
         self,