Subject: bug#18109: 24.4.50; `compilation-error-regexp-alist-alist': wrong regexp for Maven

From: Filipp Gunbin <[email-masked]>
Date: Mon, 07 Dec 2020 23:07:44 +0300

On 07/12/2020 14:49 +0100, Mattias Engdegård wrote:

> However, experience tells us that this intuition is wrong. Output
> formats do in fact tend to remain unchanged: Emacs and other editors,
> IDEs and other code are parsing them, and they are not all equally
> tolerant or in the same way. There is thus a self-reinforcing effect:
> the tool keeps output stable because we expect it to. (When output
> formats do change, it tends to be for good reasons and regexp
> tolerance is then rarely useful.)

I would be very much happy if this was true (I don't say it's the
opposite, but I have a feeling that few in Java world care about how the
error parses in Emacs).

>> But, we just need to be aware that Java tools usually don't expect the
>> output to be parsed.
>
> Yes they do! The very composition of something like the gradle-kotlin output
>
> e: FILENAME: (LINE, COL): MESSAGE
>
> is so strict and formalised that it was definitely made with
> machine-readability in mind.

I doubt that any modern-or-so Java IDE will parse any error messages,
given that build tools and compilers have APIs.  At the level of build
tools, I can tell only for Gradle, and (to the best of my knowledge) it
doesn't - when invoking either compilers or other tools, like checkstyle
plugins.

>>  That is why I'm more inclined to
>> making regexps more _lax_, not the other way around (and fix the
>> problems with them once they appear).
>
> As we have found out the hard way, the cost of lax patterns is
> insidious and diffuse until the mess really has to be sorted out --
> and by then it's hard to get hold of the various people involved who
> have since long disappeared or forgot all about what they wrote years
> ago. Patterns are added independently of one another but interact in
> unexpected ways.
>
> Thus, better to keep patterns strict, and only alter them when and if
> tool output changes; it is then clear exactly what needs to be done
> and why. For most rules this never becomes necessary.

Just wondering - did we have really that much problems caused by bad
performance of compilation regexps?  Because if we did, then maybe we
should look at other approaches, like trying to detect the compiler
used, and narrow the set of regexps based on it.  It's natural to expect
that many different people would edit these regexps when something
doesn't work for them, and expecting that you will always come and fix
the things up would not be very fair to you :-)

Filipp