Notify Zinc about non-local classes early

For pipelining Zinc needs to know about non-local classes early.
e.g. it enables Zinc to disable pipelining if a non-local class
contains macros.

The changes in this commit are based of changes made originally in Zinc:
sbt/zinc@856d416

Author: bishabosha

Diff for: compiler/src/dotty/tools/backend/jvm/CodeGen.scala

@@ -125,17 +125,16 @@ class CodeGen(val int: DottyBackendInterface, val primitives: DottyPrimitives)(
 
   // Creates a callback that will be evaluated in PostProcessor after creating a file
   private def onFileCreated(cls: ClassNode, claszSymbol: Symbol, sourceFile: util.SourceFile)(using Context): AbstractFile => Unit = {
-    val (fullClassName, isLocal) = atPhase(sbtExtractDependenciesPhase) {
-      (ExtractDependencies.classNameAsString(claszSymbol), claszSymbol.isLocal)
+    val isLocal = atPhase(sbtExtractDependenciesPhase) {
+      claszSymbol.isLocal
     }
     clsFile => {
       val className = cls.name.replace('/', '.')
       if (ctx.compilerCallback != null)
         ctx.compilerCallback.onClassGenerated(sourceFile, convertAbstractFile(clsFile), className)
 
-      ctx.withIncCallback: cb =>
-        if (isLocal) cb.generatedLocalClass(sourceFile, clsFile.jpath)
-        else cb.generatedNonLocalClass(sourceFile, clsFile.jpath, className, fullClassName)
+      if isLocal then
+        ctx.withIncCallback(_.generatedLocalClass(sourceFile, clsFile.jpath))
     }
   }
 

Diff for: compiler/src/dotty/tools/dotc/sbt/ExtractAPI.scala

@@ -15,12 +15,15 @@ import Trees.*
 import Types.*
 import Symbols.*
 import Names.*
+import StdNames.str
 import NameOps.*
 import inlines.Inlines
 import transform.ValueClasses
-import dotty.tools.io.{File, FileExtension}
+import dotty.tools.io.{File, FileExtension, JarArchive}
+import util.{Property, SourceFile}
 import java.io.PrintWriter
 
+import ExtractAPI.NonLocalClassSymbolsInCurrentUnits
 
 import scala.collection.mutable
 import scala.util.hashing.MurmurHash3
@@ -64,13 +67,59 @@ class ExtractAPI extends Phase {
   // definitions, and `PostTyper` does not change definitions).
   override def runsAfter: Set[String] = Set(transform.PostTyper.name)
 
+  override def runOn(units: List[CompilationUnit])(using Context): List[CompilationUnit] =
+    val nonLocalClassSymbols = new mutable.HashSet[Symbol]
+    val ctx0 = ctx.withProperty(NonLocalClassSymbolsInCurrentUnits, Some(nonLocalClassSymbols))
+    val units0 = super.runOn(units)(using ctx0)
+    ctx.withIncCallback(recordNonLocalClasses(nonLocalClassSymbols, _))
+    units0
+  end runOn
+
+  private def recordNonLocalClasses(nonLocalClassSymbols: mutable.HashSet[Symbol], cb: interfaces.IncrementalCallback)(using Context): Unit =
+    for cls <- nonLocalClassSymbols do
+      val sourceFile = cls.source
+      if sourceFile.exists && cls.isDefinedInCurrentRun then
+        recordNonLocalClass(cls, sourceFile, cb)
+    cb.apiPhaseCompleted()
+    cb.dependencyPhaseCompleted()
+
+  private def recordNonLocalClass(cls: Symbol, sourceFile: SourceFile, cb: interfaces.IncrementalCallback)(using Context): Unit =
+    def registerProductNames(fullClassName: String, binaryClassName: String) =
+      val pathToClassFile = s"${binaryClassName.replace('.', java.io.File.separatorChar)}.class"
+
+      val classFile = {
+        ctx.settings.outputDir.value match {
+          case jar: JarArchive =>
+            new java.io.File(s"$jar!$pathToClassFile")
+          case outputDir =>
+            new java.io.File(outputDir.file, pathToClassFile)
+        }
+      }
+
+      cb.generatedNonLocalClass(sourceFile, classFile.toPath(), binaryClassName, fullClassName)
+    end registerProductNames
+
+    val fullClassName = atPhase(sbtExtractDependenciesPhase) {
+      ExtractDependencies.classNameAsString(cls)
+    }
+    val binaryClassName = cls.binaryClassName
+    registerProductNames(fullClassName, binaryClassName)
+
+    // Register the names of top-level module symbols that emit two class files
+    val isTopLevelUniqueModule =
+      cls.owner.is(PackageClass) && cls.is(ModuleClass) && cls.companionClass == NoSymbol
+    if isTopLevelUniqueModule then
+      registerProductNames(fullClassName, binaryClassName.stripSuffix(str.MODULE_SUFFIX))
+  end recordNonLocalClass
+
   override def run(using Context): Unit = {
     val unit = ctx.compilationUnit
     val sourceFile = unit.source
     ctx.withIncCallback: cb =>
       cb.startSource(sourceFile)
 
-    val apiTraverser = new ExtractAPICollector
+    val nonLocalClassSymbols = ctx.property(NonLocalClassSymbolsInCurrentUnits).get
+    val apiTraverser = ExtractAPICollector(nonLocalClassSymbols)
     val classes = apiTraverser.apiSource(unit.tpdTree)
     val mainClasses = apiTraverser.mainClasses
 
@@ -94,6 +143,8 @@ object ExtractAPI:
   val name: String = "sbt-api"
   val description: String = "sends a representation of the API of classes to sbt"
 
+  private val NonLocalClassSymbolsInCurrentUnits: Property.Key[mutable.HashSet[Symbol]] = Property.Key()
+
 /** Extracts full (including private members) API representation out of Symbols and Types.
  *
  *  The exact representation used for each type is not important: the only thing
@@ -136,7 +187,7 @@ object ExtractAPI:
  *  without going through an intermediate representation, see
  *  http://www.scala-sbt.org/0.13/docs/Understanding-Recompilation.html#Hashing+an+API+representation
  */
-private class ExtractAPICollector(using Context) extends ThunkHolder {
+private class ExtractAPICollector(nonLocalClassSymbols: mutable.HashSet[Symbol])(using Context) extends ThunkHolder {
   import tpd.*
   import xsbti.api
 
@@ -254,6 +305,8 @@ private class ExtractAPICollector(using Context) extends ThunkHolder {
       childrenOfSealedClass, topLevel, tparams)
 
     allNonLocalClassesInSrc += cl
+    if !sym.isLocal then
+      nonLocalClassSymbols += sym
 
     if (sym.isStatic && !sym.is(Trait) && ctx.platform.hasMainMethod(sym)) {
        // If sym is an object, all main methods count, otherwise only @static ones count.

Diff for: compiler/src/dotty/tools/dotc/sbt/interfaces/IncrementalCallback.java

@@ -7,6 +7,7 @@
 
 /* User code should not implement this interface, it is intended to be a wrapper around xsbti.AnalysisCallback. */
 public interface IncrementalCallback {
+
   default void api(SourceFile sourceFile, xsbti.api.ClassLike classApi) {
   }
 
@@ -36,4 +37,10 @@ default void generatedLocalClass(SourceFile source, Path classFile) {
   default void generatedNonLocalClass(SourceFile source, Path classFile, String binaryClassName,
       String srcClassName) {
   }
+
+  default void apiPhaseCompleted() {
+  }
+
+  default void dependencyPhaseCompleted() {
+  }
 }

Diff for: sbt-bridge/src/dotty/tools/xsbt/IncrementalCallback.java

@@ -57,4 +57,14 @@ public void generatedLocalClass(SourceFile source, java.nio.file.Path classFile)
   public void generatedNonLocalClass(SourceFile source, java.nio.file.Path classFile, String binaryClassName, String srcClassName) {
     delegate.generatedNonLocalClass(asVirtualFile.apply(source), classFile, binaryClassName, srcClassName);
   }
+
+  @Override
+  public void apiPhaseCompleted() {
+    delegate.apiPhaseCompleted();
+  }
+
+  @Override
+  public void dependencyPhaseCompleted() {
+    delegate.dependencyPhaseCompleted();
+  }
 }

Diff for: sbt-bridge/src/dotty/tools/xsbt/OldIncrementalCallback.java

@@ -71,4 +71,14 @@ public void generatedLocalClass(SourceFile source, java.nio.file.Path classFile)
   public void generatedNonLocalClass(SourceFile source, java.nio.file.Path classFile, String binaryClassName, String srcClassName) {
     delegate.generatedNonLocalClass(asJavaFile(source), classFile.toFile(), binaryClassName, srcClassName);
   }
+
+  @Override
+  public void apiPhaseCompleted() {
+    delegate.apiPhaseCompleted();
+  }
+
+  @Override
+  public void dependencyPhaseCompleted() {
+    delegate.dependencyPhaseCompleted();
+  }
 }

Diff for: sbt-test/source-dependencies/compactify/src/main/scala/Nested.scala

@@ -2,35 +2,35 @@ package test
 
 object TopLevelModule1
 {
-	object InnerModule1
-	{
-		object InnerModule2
-		{
-			trait Z { def q = 3 }
-			def x = 3
-		}
-	}
-	class InnerClass1
-	{
-		class InnerClass2
-		{
-			val z = new TopLevelModule1.InnerClass2
-		}
-		object InnerModule3
-		{
-			val y = new TopLevel1 with InnerModule1.InnerModule2.Z { val x = 4 }
-		}
-	}
-	class InnerClass2
+  object InnerModule1
+  {
+    object InnerModule2
+    {
+      trait Z { def q = 3 }
+      def x = 3
+    }
+  }
+  class InnerClass1
+  {
+    class InnerClass2
+    {
+      val z = new TopLevelModule1.InnerClass2
+    }
+    object InnerModule3
+    {
+      val y = new TopLevel1 with InnerModule1.InnerModule2.Z { val x = 4 }
+    }
+  }
+  class InnerClass2
 }
 class TopLevel1
 {
-	object Inner1_1
+  object Inner1_1
 }
 object TopLevel1
 {
-	class Inner1_2
-	object Inner1_2
+  class Inner1_2
+  object Inner1_2
 }
 
 object TopLevel2
@@ -41,3 +41,11 @@ object TopLevel3
 class TopLevel4
 
 object TopLevelModuleSuffix$
+
+// will generate a package object wrapper
+val topLevelVal = 23
+
+// explicit package object
+package object inner {
+  val innerVal = 23
+}