Can mill always show warnings on compile

[Arthurm1]

If I compile a codebase from scratch and get a number of Java/Scala warnings, Mill will output those warnings to the console which is correct.

If I run mill __.compile again then I get SUCCESS but no warnings.

To me it looks like I've fixed the warnings - when I haven't. This is especially true if there are many modules and I fixed one module and then it looks like the warnings have been fixed in all modules.

Can Mill replay any warnings from the original successful compile?

How does this work in BSP - do the warnings just disappear from VSCode problems list and then reappear if the code is changed and a proper compile is needed?

[lefou]

We have two different mechanisms at play here.

1. Task caching

Since tasks are cached, a compile task may not need to run at all, so there is also no way to output anything. This is an inherent Mill property and won't change.

2. Incremental compilation

Once, the compile task runs, it may still not need to re-compile the full code but only some selected files, which may lead to less reported issues that expected. We already have a mechanism to re-report cached warnings/errors, unless you changed the default for zincReportCachedProblems. This typically means, once you fixed a reported problem by changing the sources, the compile task is triggered and reports all remaining issues.

You probably need to provide more details about your project, so we can find out, why you didn't see all remaining warnings.

[Arthurm1]

Here's a contrived example...
I have 2 different unrelated modules in my project.
I have warnings in both.
I run mill __.compile.
Warnings for both appear.
I fix the warnings in the 1st project only.
I rerun mill __.compile
No warnings appear - even though I haven't fixed the 2nd project's warnings.

I assume that this is down to "1. Task caching" and the 2nd project is not being recompiled as it hasn't changed?

But task outputs are part of the caching aren't they? E.g. all the .class files generated on compile are part of the output and are still present on the filesystem even though the task doesn't run because it's cached. But the console output from the tasks is now missing and should be replayed to the output shouldn't it?

Can the console output not be logged to a file as part of caching and then copied to the console every time a task isn't run because it's cached? How do you replay diagnostics via BSP in the above case - if Metals sends a compile twice for the same module, do the warnings just disappear on the 2nd compile?

[lefou]

While technically possible, that's most likely not want users want and I don't know any tool that is doing what you propose. The point of not doing some work isn't faking it anyways.

Regarding Metals, IIRC, Metals is receiving compiler problems via events and persists them. Hence, as long an no new compilation sends a reset event, you will continue to see the previously detected problems.