Create AnalyzerRun for easier state management

gzm0 · gzm0 · commit 01f2e96e9358 · 2023-09-23T12:36:45.000+02:00
- resetState becomes unncessary - Using the ExecutionContext is less boilerplate - Factor out logging. This partially reverts 9302a39.
diff --git a/linker/shared/src/main/scala/org/scalajs/linker/analyzer/Analyzer.scala b/linker/shared/src/main/scala/org/scalajs/linker/analyzer/Analyzer.scala
@@ -45,11 +45,6 @@ import Infos.{NamespacedMethodName, ReachabilityInfo, ReachabilityInfoInClass}
 final class Analyzer(config: CommonPhaseConfig, initial: Boolean,
     checkIR: Boolean, failOnError: Boolean, irLoader: IRLoader) {
 
-  import Analyzer._
-
-  private val allowAddingSyntheticMethods = initial
-  private val checkAbstractReachability = initial
-
   private val infoLoader: InfoLoader = {
     new InfoLoader(irLoader,
         if (!checkIR) InfoLoader.NoIRCheck
@@ -58,51 +53,87 @@ final class Analyzer(config: CommonPhaseConfig, initial: Boolean,
     )
   }
 
-  private val isNoModule = config.coreSpec.moduleKind == ModuleKind.NoModule
+  def computeReachability(moduleInitializers: Seq[ModuleInitializer],
+      symbolRequirements: SymbolRequirement, logger: Logger)(implicit ec: ExecutionContext): Future[Analysis] = {
 
-  private var objectClassInfo: ClassInfo = _
-  private[this] var classLoader: ClassLoader = _
+    infoLoader.update(logger)
 
-  private[this] val _errors = new GrowingList[Error]
+    val run = new AnalyzerRun(config, initial, infoLoader)(
+        adjustExecutionContextForParallelism(ec, config.parallel))
 
-  private var workTracker: WorkTracker = _
+    run
+      .computeReachability(moduleInitializers, symbolRequirements)
+      .map { _ =>
+        if (failOnError && run.errors.nonEmpty)
+          reportErrors(run.errors, logger)
 
-  private val fromAnalyzer = FromCore("analyzer")
+        run
+      }
+      .andThen { case _ => infoLoader.cleanAfterRun() }
+  }
 
-  private[this] val _topLevelExportInfos: mutable.Map[(ModuleID, String), TopLevelExportInfo] = emptyThreadSafeMap
+  private def reportErrors(errors: List[Error], logger: Logger): Unit = {
+    require(errors.nonEmpty)
 
-  def computeReachability(moduleInitializers: Seq[ModuleInitializer],
-      symbolRequirements: SymbolRequirement, logger: Logger)(implicit ec: ExecutionContext): Future[Analysis] = {
+    val maxDisplayErrors = {
+      val propName = "org.scalajs.linker.maxlinkingerrors"
+      Try(System.getProperty(propName, "20").toInt).getOrElse(20).max(1)
+    }
 
-    computeInternal(moduleInitializers, symbolRequirements, logger)(
-        adjustExecutionContextForParallelism(ec, config.parallel))
+    errors
+      .take(maxDisplayErrors)
+      .foreach(logError(_, logger, Level.Error))
+
+    val skipped = errors.size - maxDisplayErrors
+    if (skipped > 0)
+      logger.log(Level.Error, s"Not showing $skipped more linking errors")
+
+    if (initial) {
+      throw new LinkingException("There were linking errors")
+    } else {
+      throw new AssertionError(
+          "There were linking errors after the optimizer has run. " +
+          "This is a bug, please report it. " +
+          "You can work around the bug by disabling the optimizer. " +
+          "In the sbt plugin, this can be done with " +
+          "`scalaJSLinkerConfig ~= { _.withOptimizer(false) }`.")
+    }
   }
+}
 
-  /** Internal helper to isolate the execution context. */
-  private def computeInternal(moduleInitializers: Seq[ModuleInitializer],
-      symbolRequirements: SymbolRequirement, logger: Logger)(implicit ec: ExecutionContext): Future[Analysis] = {
+private class AnalyzerRun(config: CommonPhaseConfig, initial: Boolean,
+    infoLoader: InfoLoader)(implicit ec: ExecutionContext) extends Analysis {
+  import AnalyzerRun._
 
-    resetState()
+  private val allowAddingSyntheticMethods = initial
+  private val checkAbstractReachability = initial
 
-    infoLoader.update(logger)
+  private val isNoModule = config.coreSpec.moduleKind == ModuleKind.NoModule
+
+  private val workTracker: WorkTracker = new WorkTracker
+  private[this] val classLoader: ClassLoader = new ClassLoader
 
-    workTracker = new WorkTracker
-    classLoader = new ClassLoader
+  private var objectClassInfo: ClassInfo = _
+  private var _classInfos: scala.collection.Map[ClassName, ClassInfo] = _
 
+  def classInfos: scala.collection.Map[ClassName, Analysis.ClassInfo] = _classInfos
+
+  private[this] val _errors = new GrowingList[Error]
+
+  override def errors: List[Error] = _errors.get()
+
+  private val fromAnalyzer = FromCore("analyzer")
+
+  private[this] val _topLevelExportInfos: mutable.Map[(ModuleID, String), TopLevelExportInfo] = emptyThreadSafeMap
+  def topLevelExportInfos: scala.collection.Map[(ModuleID, String), Analysis.TopLevelExportInfo] = _topLevelExportInfos
+
+  def computeReachability(moduleInitializers: Seq[ModuleInitializer],
+      symbolRequirements: SymbolRequirement): Future[Unit] = {
     loadObjectClass(() => loadEverything(moduleInitializers, symbolRequirements))
 
     workTracker
       .allowComplete()
-      .map(_ => postLoad(moduleInitializers, logger))
-      .andThen { case _ => infoLoader.cleanAfterRun() }
-  }
-
-  private def resetState(): Unit = {
-    objectClassInfo = null
-    workTracker = null
-    _errors.clear()
-    classLoader = null
-    _topLevelExportInfos.clear()
+      .map(_ => postLoad(moduleInitializers))
   }
 
   private def loadObjectClass(onSuccess: () => Unit): Unit = {
@@ -154,8 +185,9 @@ final class Analyzer(config: CommonPhaseConfig, initial: Boolean,
     reachInitializers(moduleInitializers)
   }
 
-  private def postLoad(moduleInitializers: Seq[ModuleInitializer],
-      logger: Logger): Analysis = {
+  private def postLoad(moduleInitializers: Seq[ModuleInitializer]): Unit = {
+    _classInfos = classLoader.loadedInfos()
+
     if (isNoModule) {
       // Check there is only a single module.
       val publicModuleIDs = (
@@ -167,51 +199,8 @@ final class Analyzer(config: CommonPhaseConfig, initial: Boolean,
         _errors ::= MultiplePublicModulesWithoutModuleSupport(publicModuleIDs)
     }
 
-    val infos = classLoader.loadedInfos()
-
     // Reach additional data, based on reflection methods used
-    reachDataThroughReflection(infos)
-
-    val errs = _errors.get()
-
-    if (failOnError && errs.nonEmpty)
-      reportErrors(logger)
-
-    new Analysis {
-      val classInfos = infos
-      val topLevelExportInfos = _topLevelExportInfos
-      val errors = errs
-    }
-  }
-
-  private def reportErrors(logger: Logger): Unit = {
-    val errors = _errors.get()
-
-    require(errors.nonEmpty)
-
-    val maxDisplayErrors = {
-      val propName = "org.scalajs.linker.maxlinkingerrors"
-      Try(System.getProperty(propName, "20").toInt).getOrElse(20).max(1)
-    }
-
-    errors
-      .take(maxDisplayErrors)
-      .foreach(logError(_, logger, Level.Error))
-
-    val skipped = errors.size - maxDisplayErrors
-    if (skipped > 0)
-      logger.log(Level.Error, s"Not showing $skipped more linking errors")
-
-    if (initial) {
-      throw new LinkingException("There were linking errors")
-    } else {
-      throw new AssertionError(
-          "There were linking errors after the optimizer has run. " +
-          "This is a bug, please report it. " +
-          "You can work around the bug by disabling the optimizer. " +
-          "In the sbt plugin, this can be done with " +
-          "`scalaJSLinkerConfig ~= { _.withOptimizer(false) }`.")
-    }
+    reachDataThroughReflection()
   }
 
   private def reachSymbolRequirement(requirement: SymbolRequirement): Unit = {
@@ -304,10 +293,9 @@ final class Analyzer(config: CommonPhaseConfig, initial: Boolean,
   }
 
   /** Reach additional class data based on reflection methods being used. */
-  private def reachDataThroughReflection(
-      classInfos: scala.collection.Map[ClassName, ClassInfo]): Unit = {
+  private def reachDataThroughReflection(): Unit = {
 
-    val classClassInfo = classInfos.get(ClassClass)
+    val classClassInfo = _classInfos.get(ClassClass)
 
     /* If Class.getSuperclass() is reachable, we can reach the data of all
      * superclasses of classes whose data we can already reach.
@@ -320,7 +308,7 @@ final class Analyzer(config: CommonPhaseConfig, initial: Boolean,
       // calledFrom should always be nonEmpty if isReachable, but let's be robust
       implicit val from =
         getSuperclassMethodInfo.calledFrom.headOption.getOrElse(fromAnalyzer)
-      for (classInfo <- classInfos.values.filter(_.isDataAccessed).toList) {
+      for (classInfo <- _classInfos.values.filter(_.isDataAccessed).toList) {
         @tailrec
         def loop(classInfo: ClassInfo): Unit = {
           classInfo.accessData()
@@ -339,8 +327,6 @@ final class Analyzer(config: CommonPhaseConfig, initial: Boolean,
 
   private def lookupClass(className: ClassName)(
       onSuccess: ClassInfo => Unit)(implicit from: From): Unit = {
-    implicit val ec = workTracker.ec
-
     workTracker.track {
       classLoader.lookupClass(className).map {
         case info: ClassInfo =>
@@ -887,8 +873,6 @@ final class Analyzer(config: CommonPhaseConfig, initial: Boolean,
           createReflProxy(proxyName, onlyCandidate.methodName).reach(this)
 
         case _ =>
-          implicit val ec = workTracker.ec
-
           val future = for {
             reflectiveTarget <- computeMostSpecificProxyMatch(candidates)
           } yield {
@@ -939,8 +923,6 @@ final class Analyzer(config: CommonPhaseConfig, initial: Boolean,
     private def computeMostSpecificProxyMatch(candidates: List[MethodInfo])(
         implicit from: From): Future[MethodInfo] = {
 
-      implicit val ec = workTracker.ec
-
       /* From the JavaDoc of java.lang.Class.getMethod:
        *
        *   If more than one [candidate] method is found in C, and one of these
@@ -1584,11 +1566,11 @@ final class Analyzer(config: CommonPhaseConfig, initial: Boolean,
 
 }
 
-object Analyzer {
+private object AnalyzerRun {
   private val getSuperclassMethodName =
     MethodName("getSuperclass", Nil, ClassRef(ClassClass))
 
-  private class WorkTracker(implicit val ec: ExecutionContext) {
+  private class WorkTracker(implicit ec: ExecutionContext) {
     private val pending = new AtomicInteger(0)
     @volatile private var _allowComplete = false
     private val promise = Promise[Unit]()
