Some identical expressions are different when parsed from a string or created from Python

[pombredanne]

Three tests are failing and maked with @expectedfailure for now. See here, here and there

The essence of these bugs is that parsing the same fairly complex expression with or without simplify=True and building the same expression in Python then invoking .simplify() creates different expressions. Somehow the results of parsing and building the expression in code is not the same.
I cannot pinpoint exactly where this comes from. The bug exists in the no-new-stamement branch but also in master. And was there in master before we started the recent improvements.
I added the .pretty() method with a debug flag to try to digg more into the problem but I did find anything fishy yet.
Ideally we would need a test on a smaller expression that exhibit the same buggy behaviour.

[pombredanne]

I wonder if this stems from different precedence between boolean.py and Python
In https://docs.python.org/2/reference/expressions.html Python goes and, or, not, bitwise OR |, bitwise AND &, + (aka OR), * (aka AND), bitwise NOT ~ ? Or rather from the _start_operation methods

[pombredanne]

This is the output of running the test above:

parsed
OR(
  NOT(Symbol('a')),
  NOT(Symbol('b')),
  NOT(Symbol('c'))
)
python
OR(
  OR(
    NOT(Symbol('a')),
    NOT(Symbol('b'))
  ),
  NOT(Symbol('c'))
)
FAILED

=========================================================================== FAILURES ===========================================================================
____________________________________ DualBaseTestCase.test_parse_complex_expression_should_create_same_expression_as_python ____________________________________

self = <boolean.test_boolean.DualBaseTestCase testMethod=test_parse_complex_expression_should_create_same_expression_as_python>

    def test_parse_complex_expression_should_create_same_expression_as_python(self):
        algebra = BooleanAlgebra()
        a, b, c = algebra.symbols(*'abc')

        test_expression_str = '''(~a | ~b | ~c)'''
        parsed = algebra.parse(test_expression_str, simplify=False)
        test_expression =  (~a | ~b | ~c )  #* ~d
        print()
        print('parsed')
        print(parsed.pretty())
        print('python')
        print(test_expression.pretty())
        # we have a different behavior for expressions built from python expressions
        # vs. expression built from an object tree vs. expression built from a parse
>       self.assertEqual(parsed.pretty(), test_expression.pretty())
E       AssertionError: u"OR(\n  NOT(Symbol('a')),\n  NOT(Symbol('b')),\n  NOT(Symbol('c'))\n)" != u"OR(\n  OR(\n    NOT(Symbol('a')),\n    NOT(Symbol('b'))\n  ),\n  NOT(Symbol('c [truncated]...
E         OR(
E       +   OR(
E       -   NOT(Symbol('a')),
E       +     NOT(Symbol('a')),
E       ? ++
E       -   NOT(Symbol('b')),
E       ?                   -
E       +     NOT(Symbol('b'))
E       ? ++
E       +   ),
E           NOT(Symbol('c'))
E         )

[pombredanne]

I guess there is really no easy around that. The semantics of parsing are IMHO correct and sound and some flattening of the expression takes place . The way the same Python expression is interpreted is also correct Python-wise, but it does not apply the same flattening. I guess the only way to get the same result is to use a different Python expression grouped correctly with parenthesis.

[pombredanne]

I guess the only way to get the same result is to use a different Python expression grouped correctly with parenthesis.

Or we could use the Python semantics in the parser... but this would become awkward.