Best-effort compilation is a compilation mode introduced with the aim of improving IDE integration. It allows to generate tasty-like artifacts and semanticdb files in erroring programs.

It is composed of two experimental compiler options:

• -Ybest-effort produces Best Effort TASTy (.betasty) files to the META-INF/best-effort directory
• -Ywith-best-effort-tasty allows to read Best Effort TASTy files, and if such file is read from the classpath then limits compilation to the frontend phases

This feature aims to force through to the typer phase regardless of errors, and then serialize tasty-like files obtained from the error trees into the best effort directory (META-INF/best-effort) and also serialize semanticdb as normal.

The exact execution pattern is as follows:

Parser
    │
    │ regardless of errors
    ˅
TyperPhase ────────────────────────────────────┐
    │                                          │
    │                                          │
    │ with errors                              │ no errors
    │                                          │
    │                                          ˅
    │         Every following frontend pass until semanticdb.ExtractSemanticDB (interrupted in the case of errors)
    │                                          │
    │                                          │ regardless of errors
    ˅                                          ˅
semanticdb.ExtractSemanticDB ──────────────────┐
    │                                          │
    │ with errors                              │ no errors
    │                                          │
    │                                          ˅
    │         Every following frontend pass until Pickler (interrupted in the case of errors)
    │                                          │
    │                                          │ regardless of errors
    ˅                                          ˅
Pickler (with added printing of best effort tasty to the best effort target directory)
    │                                          │
    │ with errors                              │ no errors
    ˅                                          ˅
End compilation                      Execute latter passes

This is because the IDE is able to retrieve useful info even when skipping phases like PostTyper.

This execution structure where we skip phases depending on the errors found is motivated by the desire to avoid additionally handling errored trees in as many phases as possible, therefore also decreasing maintenance load. This way phases like PostTyper do not have to be continually adjusted to handle trees with errors from typer and usually the IDE is able to retrieve enough information with just the typer phase.

An unfortunate consequence of this structure is the fact that we lose access to phases allowing for incremental compilation, which is something that could be adressed in the future.

-Ywith-best-effort-tasty option allows reading Best Effort TASTy files from classpath. If such file is read, then the compiler is disallowed from proceeding to any non-frontend phase. This is to be used either in combination with -Ybest-effort option to produce Best Effort TASTy using failing dependencies, or in the Presentation Compiler to access symbols derived from failing projects.