whatever m/ 25 ; # / ; die "this dies!";
...or the use of parentheses for division:
(whatever / 25) ; # / ; die "this dies!";
...would be a helpful suggestion a syntax parser could give. Also, in either event the code is syntactically valid.
I feel like the type of work that's done by browsers on JIT compiling Javascript would be really hard if you can't 100% reliably parse the language.
You can, if you can detect (a superset of) the cases when it is invalid.
So even an "unreliable" syntax wouldn't matter much since the jitter kicks in after the parser had delivered its results.
BUT - you can't really draw the link between a language that is turing-complete to parse, and one that is difficult to parse. An example of this would be to take the most simple, basic language you can think of, and add a backtick-like operation. As in, you can put `echo hello` into the source and the string will get replaced by the output of the enclosed command. The source language instantly becomes turing complete (you're having to execute code, after all), but your one-off parser hasn't become much more difficult (you just call exec() and wait for the output)
That's irrelevant in this case, because a hypothetical Perl 5 JIT wouldn't do much until the Perl 5 parser finished parsing its code. Remember, all this proof proves is that you cannot produce a single, unambiguous parse tree from every Perl 5 source file because of the syntactic construct that lets you change how the parser works for specific symbols.
At least the article doesn't jump to big conclusions and make stupid declarations based on this result.
Unfortunately the commentators do: "This means that things like static code analysis, code transformation and syntax hilighting will never be reliable." So? Almost all code is still easily analysed, syntax highlighting works, etc. It's like stating that you can't do this stuff with C/C++, because the code depends upon #defines (whose values could be variable, or sourced from external processes)