adjust cancellation

Author: bishabosha

compiler/src/dotty/tools/dotc/sbt/package.scala

@@ -17,7 +17,7 @@ inline val TermNameHash = 1987 // 300th prime
 inline val TypeNameHash = 1993 // 301st prime
 inline val InlineParamHash = 1997 // 302nd prime
 
-def asyncZincPhasesCompleted(cb: IncrementalCallback, pending: Option[BufferingReporter]): Option[BufferingReporter] =
+def asyncZincPhasesCompleted(cb: IncrementalCallback, pending: Option[BufferingReporter]): BufferingReporter =
   val zincReporter = pending match
     case Some(buffered) => buffered
     case None => BufferingReporter()
@@ -27,7 +27,7 @@ def asyncZincPhasesCompleted(cb: IncrementalCallback, pending: Option[BufferingR
   catch
     case NonFatal(t) =>
       zincReporter.exception(em"signaling API and Dependencies phases completion", t)
-  if zincReporter.hasErrors then Some(zincReporter) else None
+  zincReporter
 
 extension (sym: Symbol)
 

compiler/src/dotty/tools/dotc/transform/Pickler.scala

@@ -53,22 +53,21 @@ object Pickler {
     import scala.concurrent.duration.Duration
     import AsyncTastyHolder.Signal
 
-    private val _cancel = AtomicBoolean(false)
+    private val _cancelled = AtomicBoolean(false)
 
     /**Cancel any outstanding work.
-     * This should be done at the end of a run, e.g. if there were errors that prevented reaching the backend. */
+     * This should be done at the end of a run, e.g. background work may be running even though
+     * errors in main thread will prevent reaching the backend. */
     def cancel(): Unit =
-      while
-        val cancelled = _cancel.get()
-        !cancelled && !_cancel.compareAndSet(false, true)
-      do ()
-      if incCallback != null then
+      if _cancelled.compareAndSet(false, true) then
         asyncTastyWritten.trySuccess(None) // cancel the wait for TASTy writing
-      if incCallback != null then
-        asyncAPIComplete.trySuccess(Signal.Cancelled) // cancel the wait for API completion
+        if incCallback != null then
+          asyncAPIComplete.trySuccess(Signal.Cancelled) // cancel the wait for API completion
+      else
+        () // nothing else to do
 
     /** check if the work has been cancelled. */
-    def cancelled: Boolean = _cancel.get()
+    def cancelled: Boolean = _cancelled.get()
 
     private val asyncTastyWritten = Promise[Option[AsyncTastyHolder.State]]()
     private val asyncAPIComplete =
@@ -81,7 +80,7 @@ object Pickler {
       asyncState.map: optState =>
         optState.flatMap: state =>
           if incCallback != null && state.done && !state.hasErrors then
-            asyncZincPhasesCompleted(incCallback, state.pending)
+            asyncZincPhasesCompleted(incCallback, state.pending).toBuffered
           else state.pending
 
     /** awaits the state of async TASTy operations indefinitely, returns optionally any buffered reports. */
@@ -112,11 +111,7 @@ object Pickler {
           AsyncTastyHolder.State(
             hasErrors = ctx.reporter.hasErrors,
             done = done,
-            pending = (
-              ctx.reporter match
-                case buffered: BufferingReporter => Some(buffered)
-                case _: EagerReporter => None // already reported
-            )
+            pending = ctx.reporter.toBuffered
           )
         )
     end signalAsyncTastyWritten

compiler/src/dotty/tools/io/FileWriters.scala

@@ -38,6 +38,7 @@ import dotty.tools.backend.jvm.PostProcessorFrontendAccess.BackendReporting
 import scala.annotation.constructorOnly
 import java.util.concurrent.atomic.AtomicReference
 import java.util.concurrent.atomic.AtomicBoolean
+import java.util.ConcurrentModificationException
 
 /** !!!Copied from `dotty.tools.backend.jvm.ClassfileWriters` but no `PostProcessorFrontendAccess` needed.
  * this should probably be changed to wrap that class instead.
@@ -56,6 +57,11 @@ object FileWriters {
     def warning(message: Context ?=> Message, position: SourcePosition): Unit
     def log(message: String): Unit
 
+    final def toBuffered: Option[BufferingReporter] = this match
+      case buffered: BufferingReporter =>
+        if buffered.hasReports then Some(buffered) else None
+      case _: EagerReporter => None
+
     def error(message: Context ?=> Message): Unit = error(message, NoSourcePosition)
     def warning(message: Context ?=> Message): Unit = warning(message, NoSourcePosition)
     final def exception(reason: Context ?=> Message, throwable: Throwable): Unit =
@@ -94,28 +100,18 @@ object FileWriters {
 
     /** Atomically record that an error occurred */
     private def recordError(): Unit =
-      while
-        val old = _hasErrors.get
-        !old && !_hasErrors.compareAndSet(old, true)
-      do ()
+      _hasErrors.set(true)
 
     /** Atomically add a report to the log */
     private def recordReport(report: Report): Unit =
-      while
-        val old = _bufferedReports.get
-        !_bufferedReports.compareAndSet(old, report :: old)
-      do ()
+      _bufferedReports.getAndUpdate(report :: _)
 
-    /** atomically extract and clear the buffered reports */
+    /** atomically extract and clear the buffered reports, must only be called at a synchonization point. */
     private def resetReports(): List[Report] =
-      while
-        val old = _bufferedReports.get
-        if _bufferedReports.compareAndSet(old, Nil) then
-          return old
-        else
-          true
-      do ()
-      throw new AssertionError("Unreachable")
+      val curr = _bufferedReports.get()
+      if curr.nonEmpty && !_bufferedReports.compareAndSet(curr, Nil) then
+        throw ConcurrentModificationException("concurrent modification of buffered reports")
+      else curr
 
     def hasErrors: Boolean = _hasErrors.get()
     def hasReports: Boolean = _bufferedReports.get().nonEmpty