Rename AsyncHelper to ThreadPoolFactory, remove unused implicits

Author: WojciechMazur

compiler/src/dotty/tools/dotc/profile/AsyncHelper.scala renamed to compiler/src/dotty/tools/dotc/profile/ThreadPoolFactory.scala

@@ -9,38 +9,49 @@ import java.util.concurrent.atomic.AtomicInteger
 import dotty.tools.dotc.core.Phases.Phase
 import dotty.tools.dotc.core.Contexts._
 
-sealed trait AsyncHelper {
-
-  def newUnboundedQueueFixedThreadPool
-  (nThreads: Int,
-   shortId: String, priority : Int = Thread.NORM_PRIORITY) : ThreadPoolExecutor
-  def newBoundedQueueFixedThreadPool
-  (nThreads: Int, maxQueueSize: Int, rejectHandler: RejectedExecutionHandler,
-   shortId: String, priority : Int = Thread.NORM_PRIORITY) : ThreadPoolExecutor
+sealed trait ThreadPoolFactory {
+
+  def newUnboundedQueueFixedThreadPool(
+    nThreads: Int,
+    shortId: String,
+    priority : Int = Thread.NORM_PRIORITY) : ThreadPoolExecutor
+
+  def newBoundedQueueFixedThreadPool(
+    nThreads: Int,
+    maxQueueSize: Int,
+    rejectHandler: RejectedExecutionHandler,
+    shortId: String,
+    priority : Int = Thread.NORM_PRIORITY) : ThreadPoolExecutor
 }
 
 
-object AsyncHelper {
-  def apply(phase: Phase)(using Context): AsyncHelper = ctx.profiler match {
-    case NoOpProfiler => new BasicAsyncHelper(phase)
-    case r: RealProfiler => new ProfilingAsyncHelper(phase, r)
+object ThreadPoolFactory {
+  def apply(phase: Phase)(using Context): ThreadPoolFactory = ctx.profiler match {
+    case NoOpProfiler => new BasicThreadPoolFactory(phase)
+    case r: RealProfiler => new ProfilingThreadPoolFactory(phase, r)
   }
 
-  private abstract class BaseAsyncHelper(phase: Phase)(using Context) extends AsyncHelper {
+  private abstract class BaseThreadPoolFactory(phase: Phase) extends ThreadPoolFactory {
     val baseGroup = new ThreadGroup(s"dotc-${phase.phaseName}")
+
     private def childGroup(name: String) = new ThreadGroup(baseGroup, name)
 
-    protected def wrapRunnable(r: Runnable, shortId:String): Runnable
+    // Invoked when a new `Worker` is created, see `CommonThreadFactory.newThread`
+    protected def wrapWorker(worker: Runnable, shortId:String): Runnable = worker
 
-    protected class CommonThreadFactory(shortId: String,
-                                        daemon: Boolean = true,
-                                        priority: Int) extends ThreadFactory {
+    protected final class CommonThreadFactory(
+        shortId: String,
+        daemon: Boolean = true,
+        priority: Int) extends ThreadFactory {
       private val group: ThreadGroup = childGroup(shortId)
       private val threadNumber: AtomicInteger = new AtomicInteger(1)
       private val namePrefix = s"${baseGroup.getName}-$shortId-"
 
-      override def newThread(r: Runnable): Thread = {
-        val wrapped = wrapRunnable(r, shortId)
+      // Invoked by the `ThreadPoolExecutor` when creating a new worker thread. The argument
+      // runnable is the `Worker` (which extends `Runnable`). Its `run` method gets tasks from
+      // the thread pool and executes them (on the thread created here).
+      override def newThread(worker: Runnable): Thread = {
+        val wrapped = wrapWorker(worker, shortId)
         val t: Thread = new Thread(group, wrapped, namePrefix + threadNumber.getAndIncrement, 0)
         if (t.isDaemon != daemon) t.setDaemon(daemon)
         if (t.getPriority != priority) t.setPriority(priority)
@@ -49,7 +60,7 @@ object AsyncHelper {
     }
   }
 
-  private final class BasicAsyncHelper(phase: Phase)(using Context) extends BaseAsyncHelper(phase) {
+  private final class BasicThreadPoolFactory(phase: Phase) extends BaseThreadPoolFactory(phase) {
 
     override def newUnboundedQueueFixedThreadPool(nThreads: Int, shortId: String, priority: Int): ThreadPoolExecutor = {
       val threadFactory = new CommonThreadFactory(shortId, priority = priority)
@@ -62,11 +73,9 @@ object AsyncHelper {
       //like Executors.newFixedThreadPool
       new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new ArrayBlockingQueue[Runnable](maxQueueSize), threadFactory, rejectHandler)
     }
-
-    override protected def wrapRunnable(r: Runnable, shortId:String): Runnable = r
   }
 
-  private class ProfilingAsyncHelper(phase: Phase, private val profiler: RealProfiler)(using Context) extends BaseAsyncHelper(phase) {
+  private class ProfilingThreadPoolFactory(phase: Phase, private val profiler: RealProfiler) extends BaseThreadPoolFactory(phase) {
 
     override def newUnboundedQueueFixedThreadPool(nThreads: Int, shortId: String, priority: Int): ThreadPoolExecutor = {
       val threadFactory = new CommonThreadFactory(shortId, priority = priority)
@@ -80,13 +89,13 @@ object AsyncHelper {
       new SinglePhaseInstrumentedThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new ArrayBlockingQueue[Runnable](maxQueueSize), threadFactory, rejectHandler)
     }
 
-    override protected def wrapRunnable(r: Runnable, shortId:String): Runnable = {
+    override protected def wrapWorker(worker: Runnable, shortId: String): Runnable = {
       () =>
       val data = new ThreadProfileData
       localData.set(data)
 
       val profileStart = profiler.snapThread(0)
-      try r.run finally {
+      try worker.run finally {
         val snap = profiler.snapThread(data.idleNs)
         val threadRange = ProfileRange(profileStart, snap, phase, shortId, data.taskCount, Thread.currentThread())
         profiler.completeBackground(threadRange)