Fix race condition in AbstractReconciler.reset() event ordering

In BackgroundWorker.reset(), reconcilerReset() was called after
fIsDirty was set to true and after fDirtyRegionQueue.notifyAll() and
informNotFinished(). This created two race windows:

1. aboutToBeReconciledInternal() (called before reset() in both
   documentChanged and inputDocumentChanged) triggers
   signalWaitForFinish() which wakes the background thread via
   notifyAll(). The background thread could then see fIsDirty=true
   (set at the start of reset()), consume the fReset flag, loop back,
   skip delay (waitFinish=true), and reach process() — all before the
   main thread reached reconcilerReset().

2. Within reset() itself, notifyAll() and informNotFinished() (which
   also triggers signalWaitForFinish → notifyAll) were called before
   reconcilerReset(), providing additional wake-up points for the
   background thread.

The fix moves reconcilerReset() to the very beginning of reset(),
before fIsDirty is set to true. This way, even if the background
thread is already awake from an earlier notification, it cannot find
work to do (isDirty() returns false) and blocks in delay() until after
reconcilerReset() completes and the state flags are set.

The reordered reset() is now:
1. reconcilerReset() — hook runs while isDirty is still false
2. Set state flags (fIsDirty, fReset) in synchronized block
3. informNotFinished() — may wake background thread
4. fDirtyRegionQueue.notifyAll() — wakes background thread

This guarantees the reconcilerReset hook completes before the
background thread can proceed to process().

User-visible impact: The AbstractReconciler drives background
processing in text editors (syntax validation, spell checking,
error/warning markers, code analysis). The race condition occurs when
the document changes or is replaced (e.g., switching files, reverting).
Without the reset happening first, process() can run with stale state,
causing brief flickers of incorrect error markers or squiggles from
the previous document on the new content. Being a race condition, this
is intermittent and self-corrects on the next reconciling pass.

Test coverage: Added ReconcilerResetOrderingTest which extends
FastAbstractReconcilerTest with a 50ms delay before logging
reconcilerReset. This widens the race window so that without the fix,
the background thread deterministically reaches process() before the
reset hook logs — causing testReplacingDocumentWhenClean and
testDirtyingWhenClean to always fail. With the fix, all tests pass
because the background thread cannot find work (isDirty=false) during
the delay. The full reconciler test suite (AbstractReconcilerTest +
FastAbstractReconcilerTest + ReconcilerResetOrderingTest, 21 tests)
covers reset() through all code paths.

See #2708

Author: vogella

bundles/org.eclipse.jface.text/src/org/eclipse/jface/text/reconciler/AbstractReconciler.java

@@ -140,29 +140,27 @@ public void suspendCallerWhileDirty() {
 		 */
 		public void reset() {
 
+			reconcilerReset();
+
 			if (fDelay > 0) {
 
 				synchronized (this) {
 					fIsDirty= true;
 					fReset= true;
 				}
-				synchronized (fDirtyRegionQueue) {
-					fDirtyRegionQueue.notifyAll(); // wake up wait(fDelay);
-				}
 
 			} else {
 
 				synchronized (this) {
 					fIsDirty= true;
 				}
-
-				synchronized (fDirtyRegionQueue) {
-					fDirtyRegionQueue.notifyAll();
-				}
 			}
 
 			informNotFinished();
-			reconcilerReset();
+
+			synchronized (fDirtyRegionQueue) {
+				fDirtyRegionQueue.notifyAll();
+			}
 		}
 
 		/**

tests/org.eclipse.jface.text.tests/src/org/eclipse/jface/text/tests/JFaceTextTestSuite.java

@@ -26,6 +26,7 @@
 import org.eclipse.jface.text.tests.contentassist.IncrementalAsyncContentAssistTests;
 import org.eclipse.jface.text.tests.reconciler.AbstractReconcilerTest;
 import org.eclipse.jface.text.tests.reconciler.FastAbstractReconcilerTest;
+import org.eclipse.jface.text.tests.reconciler.ReconcilerResetOrderingTest;
 import org.eclipse.jface.text.tests.rules.FastPartitionerTest;
 import org.eclipse.jface.text.tests.rules.FastPartitionerZeroLengthTest;
 import org.eclipse.jface.text.tests.rules.ScannerColumnTest;
@@ -61,6 +62,7 @@
 
 		AbstractReconcilerTest.class,
 		FastAbstractReconcilerTest.class,
+		ReconcilerResetOrderingTest.class,
 
 		FastPartitionerZeroLengthTest.class,
 		FastPartitionerTest.class,

tests/org.eclipse.jface.text.tests/src/org/eclipse/jface/text/tests/reconciler/AbstractReconcilerTest.java

@@ -173,6 +173,7 @@ protected void aboutToBeReconciled() {
 					}
 					@Override
 					protected void reconcilerReset() {
+						AbstractReconcilerTest.this.beforeReconcilerResetLogged();
 						fCallLog.add("reconcilerReset");
 					}
 					@Override
@@ -202,6 +203,10 @@ void aboutToWork(@SuppressWarnings("unused") AbstractReconciler reconciler) {
 		// nothing
 	}
 
+	void beforeReconcilerResetLogged() {
+		// hook for subclasses to widen race window
+	}
+
 	@AfterEach
 	public void tearDown() throws Exception {
 		fBarrier.shutdown();

tests/org.eclipse.jface.text.tests/src/org/eclipse/jface/text/tests/reconciler/ReconcilerResetOrderingTest.java

@@ -0,0 +1,40 @@
+/*******************************************************************************
+ * Copyright (c) 2025 Contributors to the Eclipse Foundation.
+ *
+ * This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License 2.0
+ * which accompanies this distribution, and is available at
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.jface.text.tests.reconciler;
+
+import org.eclipse.jface.text.reconciler.AbstractReconciler;
+
+/**
+ * Regression test for the race condition in
+ * {@link AbstractReconciler#install BackgroundWorker.reset()} where
+ * {@code reconcilerReset()} could be called after the background thread was
+ * already notified, allowing {@code process()} to run before the reset hook.
+ * <p>
+ * This test widens the race window by introducing a 50ms delay before logging
+ * {@code reconcilerReset}. Without the fix (reconcilerReset called before queue
+ * notification), the background thread is already awake during the delay and
+ * reaches {@code process()} first, causing {@code testReplacingDocumentWhenClean}
+ * to deterministically fail.
+ * </p>
+ *
+ * @see <a href="https://github.com/eclipse-platform/eclipse.platform.ui/issues/2708">Issue 2708</a>
+ */
+public class ReconcilerResetOrderingTest extends FastAbstractReconcilerTest {
+
+	@Override
+	void beforeReconcilerResetLogged() {
+		try {
+			Thread.sleep(50);
+		} catch (InterruptedException e) {
+			Thread.currentThread().interrupt();
+		}
+	}
+}