Cleanup parser (#428)

Remove post_parse

.pep8

@@ -1,3 +1,3 @@
 [pep8]
 ignore = E501,W291
-exclude = parsetab.py,magic.py,build/,.tox/
+exclude = magic.py,build/,.tox/

mathics/builtin/arithmetic.py

@@ -344,41 +344,6 @@ def apply_int(self, x, evaluation):
 
         return Integer(-x.to_sympy())
 
-    def post_parse(self, expression):
-        if (expression.get_head().get_name() == 'System`Minus' and
-            len(expression.leaves) == 1 and
-            isinstance(expression.leaves[0], Number)):  # nopep8
-
-            return Number.from_mp(-expression.leaves[0].to_sympy())
-        else:
-            return super(Minus, self).post_parse(expression)
-
-
-class PrePlus(PrefixOperator):
-    """
-    Hack to help the parser distinguish between binary and unary Plus.
-
-    >> +a //FullForm
-     = a
-
-    #> +(x - 2/3 + y)
-     = -2 / 3 + x + y
-
-    #> +Infinity
-     = Infinity
-    """
-
-    operator = '+'
-    precedence = 480
-    attributes = ('Listable', 'NumericFunction')
-
-    def apply_int(self, x, evaluation):
-        'PrePlus[x_]'
-        return x
-
-    def post_parse(self, expression):
-        return expression.leaves[0]
-
 
 def create_infix(items, operator, prec, grouping):
     if len(items) == 1:
@@ -664,31 +629,6 @@ class Divide(BinaryOperator):
             'Infix[{HoldForm[x], HoldForm[y]}, "/", 400, Left]'),
     }
 
-    def post_parse(self, expression):
-        if len(expression.leaves) == 2:
-            if (isinstance(expression.leaves[0], Integer) and   # noqa
-                isinstance(expression.leaves[1], Integer) and
-                expression.leaves[1].to_sympy() != 0):
-
-                return Number.from_mp(Rational(
-                    expression.leaves[0].to_sympy(),
-                    expression.leaves[1].to_sympy()).to_sympy())
-            else:
-                if (isinstance(expression.leaves[0], Integer) and   # noqa
-                    expression.leaves[0].to_sympy() == 1):
-
-                    return Expression('Power',
-                                      expression.leaves[1].post_parse(),
-                                      Integer(-1))
-                else:
-                    return Expression(
-                        'Times', expression.leaves[0].post_parse(),
-                        Expression('Power', expression.leaves[1].post_parse(),
-                                   Integer(-1)))
-        else:
-            return super(Divide, self).post_parse(expression)
-
-
 class Power(BinaryOperator, SympyFunction):
     """
     <dl>

mathics/builtin/base.py

@@ -242,10 +242,6 @@ def is_prefix(self):
     def is_postfix(self):
         return False
 
-    def post_parse(self, expression):
-        return Expression(expression.head.post_parse(), *[
-            leaf.post_parse() for leaf in expression.leaves])
-
 
 class Predefined(Builtin):
     def get_functions(self, prefix='apply'):

mathics/builtin/calculus.py

@@ -298,14 +298,6 @@ class Derivative(PostfixOperator, SympyFunction):
     def __init__(self, *args, **kwargs):
         super(Derivative, self).__init__(*args, **kwargs)
 
-    def post_parse(self, expression):
-        count = 0
-        inner = expression
-        while inner.has_form('Derivative', 1):
-            inner = inner.leaves[0]
-            count += 1
-        return Expression(Expression('Derivative', Integer(count)), inner)
-
     def to_sympy(self, expr, **kwargs):
         inner = expr
         exprs = [inner]

mathics/builtin/comparison.py

@@ -83,40 +83,6 @@ class _InequalityOperator(BinaryOperator):
     precedence = 290
     grouping = 'NonAssociative'
 
-    def parse(self, args):
-        # Parse multiple inequalities.
-        # "a op b op c" -> op[a, b, c]
-        # "a op1 b op2 c" -> Inequality[a, op1, b, op2, c]
-
-        def inequality_leaves(expression):
-            if expression.parenthesized:
-                return [expression]
-            name = expression.get_head().get_name()
-            leaves = expression.get_leaves()
-            if name == 'System`Inequality':
-                return leaves
-            elif name in operators:
-                result = []
-                for leaf in leaves[:-1]:
-                    result.extend([leaf, Symbol(name)])
-                result.extend(leaves[-1:])
-                return result
-            else:
-                return [expression]
-
-        left = args[0]
-        right = args[2]
-        name = self.get_name()
-
-        left_leaves = inequality_leaves(left)
-        right_leaves = inequality_leaves(right)
-        leaves = left_leaves + [Symbol(name)] + right_leaves
-        ops = set(leaves[1::2])
-        if len(ops) == 1:
-            return Expression(ops.pop(), *leaves[0::2])
-        else:
-            return Expression('Inequality', *leaves)
-
     def apply(self, items, evaluation):
         '%(name)s[items__]'
 

mathics/builtin/inout.py

@@ -813,10 +813,6 @@ class Postfix(BinaryOperator):
     precedence = 70
     grouping = 'Left'
 
-    def post_parse(self, expression):
-        return Expression(expression.leaves[1].post_parse(),
-                          expression.leaves[0].post_parse())
-
 
 class Prefix(BinaryOperator):
     """
@@ -850,10 +846,6 @@ class Prefix(BinaryOperator):
     precedence = 640
     grouping = 'Right'
 
-    def post_parse(self, expression):
-        return Expression(expression.leaves[0].post_parse(),
-                          expression.leaves[1].post_parse())
-
 
 class Infix(Builtin):
     """
@@ -1161,13 +1153,6 @@ def apply(self, symbol, tag, evaluation):
         return evaluation.definitions.get_value(
             symbol.get_name(), 'System`Messages', pattern, evaluation)
 
-    def post_parse(self, expr):
-        if len(expr.leaves) == 2 and expr.leaves[1].is_symbol():
-            msg = expr.leaves[1].get_name()
-            return Expression('MessageName', expr.leaves[0], String(msg))
-        else:
-            return expr
-
 
 class Syntax(Builtin):
     r"""

mathics/builtin/patterns.py

@@ -717,23 +717,6 @@ class Optional(BinaryOperator, PatternObject):
 
     default_formats = False
 
-    def post_parse(self, expression):
-        leaves = [leaf.post_parse() for leaf in expression.leaves]
-        expression = Expression(expression.head.post_parse(), *leaves)
-        if (expression.has_form('Optional', 2) and expression.leaves[0].get_name()):
-            sub = expression.leaves[1]
-            if sub.has_form(('Pattern', 'Optional'), 2):
-                return Expression(
-                    'Optional',
-                    Expression('Pattern', expression.leaves[0], sub.leaves[0]),
-                    sub.leaves[1])
-            else:
-                return Expression(
-                    'Pattern',
-                    *[leaf.post_parse() for leaf in expression.leaves])
-        else:
-            return expression
-
     rules = {
         'MakeBoxes[Verbatim[Optional][Verbatim[Pattern][symbol_Symbol, Verbatim[_]]], f:StandardForm|TraditionalForm|InputForm|OutputForm]': 'MakeBoxes[symbol, f] <> "_."',
         'MakeBoxes[Verbatim[Optional][Verbatim[_]], f:StandardForm|TraditionalForm|InputForm|OutputForm]': '"_."',

mathics/core/expression.py

@@ -320,9 +320,6 @@ def yield_match(vars, rest):
             return self.head.is_free(form, evaluation) and all(
                 leaf.is_free(form, evaluation) for leaf in self.leaves)
 
-    def post_parse(self):
-        return self
-
     def is_inexact(self):
         return self.get_precision() is not None
 
@@ -869,13 +866,6 @@ def rules():
             evaluation.options = old_options
             evaluation.dec_recursion_depth()
 
-    def post_parse(self):
-        if self.parse_operator is not None:
-            return self.parse_operator.post_parse(self)
-        else:
-            return Expression(self.head.post_parse(),
-                              *[leaf.post_parse() for leaf in self.leaves])
-
     def evaluate_leaves(self, evaluation):
         leaves = [leaf.evaluate(evaluation) for leaf in self.leaves]
         head = self.head.evaluate_leaves(evaluation)