Hi, we currently are fuzzing Python programs to find valid code that fails to compile. We found this program never finishes its compilation.

$ echo "raise ValueError ; 2 ** 12345678912345" > inf.py
$ python -m py_compile inf.py

We realize the computation is a large one and takes a very long time, in this case the compiler consumes more and more memory over time. Perhaps the compiler shouldn't try to calculate this indefinitely and just return an error.

Regards

On 3.6 it takes a very long time, but it does finish.

time ./python -c "raise ValueError ; 2 ** 12345678912345"
Traceback (most recent call last):
  File "<string>", line 1, in <module>
ValueError

real    1m35.673s
user    1m18.952s
sys     0m16.644s

Just in case anyone is wondering why this happens. The compiler's peephole optimizer will fold constant expressions like 

x = 5 + 5

into

x = 10

More specifically, this bit here: https://github.com/python/cpython/blob/0f21fe6155227d11dc02bd3ef3b061de4ecea445/Python/peephole.c#L240


I'd say the current behavior of the compilation taking a long time is fine since at runtime it would run the exact same "2 ** 12345678912345" expression and spend a long time/run out of memory.

However I'd say the fact that this happens so silently can be a "gotcha" in some very rare cases.

FYI my Python reimplementation of the bytecode peephole optimizer doesn't
have this issue. It estimates the size of a**b using exp() and ln()
functions.
http://bytecode.readthedocs.io/en/latest/

See also issue21074.