Redundant jumps due to asserts

[iritkatriel]

I came across this in real code. When an assert is under an if, the assert disappears and leave a redundant conditional jump to the next block.

% cat assert.py 

def f():
    x = 42
    if x:
        assert x > 12
    y = 53

import dis
dis.dis(f)

% ./python.exe -O assert.py
  2           0 RESUME                   0

  3           2 LOAD_CONST               1 (42)
              4 COPY                     1
              6 STORE_FAST               0 (x)

  4           8 POP_JUMP_FORWARD_IF_FALSE     0 (to 10).    <-- redundant

  6     >>   10 LOAD_CONST               2 (53)
             12 STORE_FAST               1 (y)
             14 LOAD_CONST               0 (None)
             16 RETURN_VALUE

We have an optimisation the removes unconditional jumps to the next block. We can apply it to conditional jump like this one as well.

[sweeneyde]

Does it matter whether x.__bool__ is called? This issue seems to suggest "yes".

[iritkatriel]

Ah I see, we keep these jumps for their (potential) side effects.

If we had a pedantic compilation mode we could warn about this, and when someone does things like

    if x is not None:
         assert x.something

suggest instead

assert x is None or x.something

[gvanrossum]

That's for linters.

I think we should be allowed to optimize away if x is [not] None: pass completely (but not if [not] x: pass) but only if we have proof that x is always defined. If it could raise NameError we shouldn't optimize that away. The jump could become a POP_TOP though.

[iritkatriel]

At the moment I think we can't optimise away 'pass' because its line number needs to be in the trace. But assert disappears without a trace (pun intended) with -O.

[gvanrossum]

Isn't there a trick possible to generate lineno events without instructions?

[iritkatriel]

Not yet. Exceptions also leave behind NOPs for line number. See python/cpython#86885