local classes early

Author: bishabosha

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

@@ -126,17 +126,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): 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))
     }
   }
 

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

@@ -15,13 +15,16 @@ import Trees.*
 import Types.*
 import Symbols.*
 import Names.*
+import StdNames.str
 import NameOps.*
 import inlines.Inlines
 import transform.ValueClasses
 import transform.SymUtils.*
-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
@@ -62,13 +65,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 if !cls.isLocal 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 || cls.isPackageObject 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
 
@@ -92,6 +141,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
@@ -134,7 +185,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
 
@@ -252,6 +303,7 @@ private class ExtractAPICollector(using Context) extends ThunkHolder {
       childrenOfSealedClass, topLevel, tparams)
 
     allNonLocalClassesInSrc += cl
+    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.

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() {
+  }
 }

sbt-bridge/src/dotty/tools/xsbt/IncrementalCallback.java

@@ -2,6 +2,7 @@
 
 import dotty.tools.dotc.util.SourceFile;
 import java.util.function.Function;
+import java.util.function.Predicate;
 
 public final class IncrementalCallback implements dotty.tools.dotc.sbt.interfaces.IncrementalCallback {
 
@@ -57,4 +58,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();
+  }
 }

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();
+  }
 }

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

@@ -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
+}