Eclipse JDT incremental compiler cancellation in 2024‑Eclipse‑2024‑12

Short answer

Based on available knowledge of the 2024-12 release train, there is no confirmed change to the frequency of IProgressMonitor checks in the JDT incremental compiler. Cancellation is still evaluated at major phase boundaries (parsing, binding/type resolution, code generation), enabling fast incremental compilation can widen the gap between a cancel request and the next check, and the proposed fine-grained cancelable flag has not been merged into public JDT API. Treat these points as knowledge-based expectations, not verified release facts — the verification steps below matter because this behavior is version-sensitive.

Likely explanation vs. confirmed facts

Well-established behavior: the incremental compiler is not preemptively cancelable. It polls the monitor between coarse-grained phases, so a cancel request issued mid-phase waits until the current phase finishes. There is no built-in timeout, and worst-case latency is unbounded if a single phase (for example, resolution of a large compilation unit) runs long.

Likely, but unverified for 2024-12 specifically: that no additional monitor checkpoints were added in this release, and that the fast incremental compilation path still skips some checks. The interaction between the fast flag and cancellation is not documented as changed in 2024-12, but release-note silence is not proof of unchanged internals.

Answers to the three questions

1. Monitor check frequency in 2024-12: no known change; checks remain at major phases. Verify against the JDT section of the official 2024-12 release notes before relying on this.
2. Fast incremental compilation and cancellation: yes, it can affect responsiveness. By skipping certain checks to reduce overhead, it may delay the next monitor evaluation. If prompt cancellation matters, test with the fast path disabled.
3. Fine-grained cancelable API: proposed by the JDT team but, as of this release train, not released in public API. Do not design against it yet.

How to verify on your installation

The most reliable check is empirical, since milestone and service releases can carry different compiler revisions:

1. Install a custom IProgressMonitor wrapper that logs isCanceled() calls and phase entry/exit with timestamps.
2. Trigger a build of a large project, cancel mid-compile, and measure the interval between the cancel request and the next monitor call.
3. Repeat with fast incremental compilation toggled off (the org.eclipse.jdt.core.compiler.incremental-related preference) and compare latencies.
4. Cross-check the Eclipse bug tracker and JDT mailing lists for any resolved fine-grained cancellation work tagged to 2024-12 or later.

Practical mitigation

If cancellation latency is unacceptable, the realistic options today are a custom monitor that you control, disabling fast incremental compilation where responsiveness matters more than throughput, or external process management (running compilation in a separate process you can terminate). None of these give true mid-phase cancellation; they bound the damage.

Uncertainty

This assessment is based on model knowledge, not fetched release artifacts. Confirm against the 2024-12 JDT release notes and your exact service release before making tooling decisions that depend on cancellation timing.