Refactor collecting entry points. Remove them from context and pass them via GenBCode callback

Author: BarkingBad

compiler/src/dotty/tools/backend/jvm/GenBCode.scala

@@ -42,6 +42,9 @@ class GenBCode extends Phase {
     superCallsMap.update(sym, old + calls)
   }
 
+  private val entryPoints = new mutable.HashSet[String]()
+  def registerEntryPoint(s: String): Unit = entryPoints += s
+
   private var myOutput: AbstractFile = _
 
   private def outputDir(using Context): AbstractFile = {
@@ -63,7 +66,7 @@ class GenBCode extends Phase {
   override def runOn(units: List[CompilationUnit])(using Context): List[CompilationUnit] = {
     outputDir match
       case jar: JarArchive =>
-        updateJarManifestWithMainClass(jar)
+        updateJarManifestWithMainClass(jar, entryPoints.toList)
       case _ =>
     try super.runOn(units)
     finally outputDir match {
@@ -78,9 +81,9 @@ class GenBCode extends Phase {
     }
   }
 
-  private def updateJarManifestWithMainClass(jarArchive: JarArchive)(using Context): Unit =
+  private def updateJarManifestWithMainClass(jarArchive: JarArchive, entryPoints: List[String])(using Context): Unit =
     val mainClass = Option.when(!ctx.settings.XmainClass.isDefault)(ctx.settings.XmainClass.value).orElse {
-      ctx.entryPoints.toList.match
+      entryPoints match
         case List(mainClass) =>
           Some(mainClass)
         case Nil =>

compiler/src/dotty/tools/dotc/core/Contexts.scala

@@ -52,9 +52,8 @@ object Contexts {
   private val (notNullInfosLoc,     store8) = store7.newLocation[List[NotNullInfo]]()
   private val (importInfoLoc,       store9) = store8.newLocation[ImportInfo]()
   private val (typeAssignerLoc,    store10) = store9.newLocation[TypeAssigner](TypeAssigner)
-  private val (entryPointsLoc,     store11) = store10.newLocation[EntryPoints](new EntryPoints)
 
-  private val initialStore = store11
+  private val initialStore = store10
 
   /** The current context */
   inline def ctx(using ctx: Context): Context = ctx
@@ -240,9 +239,6 @@ object Contexts {
     /** The current type assigner or typer */
     def typeAssigner: TypeAssigner = store(typeAssignerLoc)
 
-    /** The current entry points */
-    def entryPoints: EntryPoints = store(entryPointsLoc)
-
     /** The new implicit references that are introduced by this scope */
     protected var implicitsCache: ContextualImplicits = null
     def implicits: ContextualImplicits = {

compiler/src/dotty/tools/dotc/core/EntryPoints.scala

@@ -4,18 +4,19 @@ import dotty.tools.dotc.ast.tpd
 import dotty.tools.dotc.core.Contexts.Context
 import dotty.tools.dotc.core.Types
 import dotty.tools.dotc.transform.MegaPhase._
-import dotty.tools.dotc.ast.tpd
 import java.io.{File => _}
 
 import dotty.tools.dotc.core._
 import SymDenotations._
 import Contexts._
 import Types._
 import Symbols._
+import Phases._
 import dotty.tools.dotc.util.SourcePosition
 import Decorators._
 import StdNames.nme
 import dotty.tools.io.JarArchive
+import dotty.tools.backend.jvm.GenBCode
 
 /**
  * Small phase to be run to collect main classes and store them in the context.
@@ -40,11 +41,19 @@ class CollectEntryPoints extends MiniPhase:
 
 
   override def transformTypeDef(tree: tpd.TypeDef)(using Context): tpd.Tree =
-    ctx.entryPoints ++= getEntryPoint(tree)
+    getEntryPoint(tree).map(registerEntryPoint)
     tree
 
   private def getEntryPoint(tree: tpd.TypeDef)(using Context): Option[String] =
     val sym = tree.symbol
     import dotty.tools.dotc.core.NameOps.stripModuleClassSuffix
     val name = sym.fullName.stripModuleClassSuffix.toString
     Option.when(sym.isStatic && !sym.is(Flags.Trait) && ctx.platform.hasMainMethod(sym))(name)
+
+  private def registerEntryPoint(s: String)(using Context) = {
+    genBCodePhase match {
+      case genBCodePhase: GenBCode =>
+        genBCodePhase.registerEntryPoint(s)
+      case _ =>
+    }
+  }