WIP: broken

Author: bishabosha

compiler/src/dotty/tools/dotc/Run.scala

@@ -39,6 +39,8 @@ import scala.io.Codec
 /** A compiler run. Exports various methods to compile source files */
 class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with ConstraintRunInfo {
 
+  val uuid = java.util.UUID.randomUUID.toString
+
   /** Default timeout to stop looking for further implicit suggestions, in ms.
    *  This is usually for the first import suggestion; subsequent suggestions
    *  may get smaller timeouts. @see ImportSuggestions.reduceTimeBudget
@@ -202,6 +204,7 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
 
   def compile(files: List[AbstractFile]): Unit =
     try
+      report.echo(s"!!! BEGIN RUN $uuid on ${files.mkString(", ")}")
       val sources = files.map(runContext.getSource(_))
       compileSources(sources)
     catch

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

@@ -168,6 +168,8 @@ object SymDenotations {
           atPhase(validFor.firstPhaseId)(completer.complete(this))
         }
 
+    protected[dotc] var infoTracer: String | Null = null
+
     protected[dotc] def info_=(tp: Type): Unit = {
       /* // DEBUG
        def illegal: String = s"illegal type for $this: $tp"
@@ -180,6 +182,8 @@ object SymDenotations {
         }
         */
       if (Config.checkNoSkolemsInInfo) assertNoSkolems(tp)
+      if SymbolCapturing.doCapture(symbol) then
+        infoTracer = Thread.currentThread().getStackTrace().mkString("\n  ", "\n  ", "")
       myInfo = tp
     }
 

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

@@ -271,6 +271,8 @@ object SymbolLoaders {
         for (classRep <- classReps)
           if (!maybeModuleClass(classRep) && hasFlatName(classRep) == flat &&
             (!flat || isAbsent(classRep))) // on 2nd enter of flat names, check that the name has not been entered before
+            if packageName == "a" then
+              report.echo(s"initialising ${classRep} for ${root.symbol} in package $packageName")
             initializeFromClassPath(root.symbol, classRep)
         for (classRep <- classReps)
           if (maybeModuleClass(classRep) && hasFlatName(classRep) == flat &&

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

@@ -35,6 +35,16 @@ import scala.collection.JavaConverters._
 import scala.annotation.internal.sharable
 import config.Printers.typr
 
+object SymbolCapturing {
+  def ids = Set(
+    2844, // a.Foo$.foo (before)
+    2756, // a.Foo (before)
+    4949, // a.Foo$.foo (after)
+    2756, // a.Foo (after)
+  )
+  def doCapture(sym: Symbol): Boolean = ids.contains(sym.id)
+}
+
 object Symbols {
 
   implicit def eqSymbol: CanEqual[Symbol, Symbol] = CanEqual.derived
@@ -46,12 +56,19 @@ object Symbols {
    *  @param coord  The coordinates of the symbol (a position or an index)
    *  @param id     A unique identifier of the symbol (unique per ContextBase)
    */
-  class Symbol private[Symbols] (private var myCoord: Coord, val id: Int)
+  class Symbol private[Symbols] (private var myCoord: Coord, val id: Int, val runUUID: String = "<no uuid>")
     extends Designator, ParamInfo, SrcPos, printing.Showable {
 
     type ThisName <: Name
 
-    //assert(id != 723)
+    val tracer: String | Null =
+      if SymbolCapturing.doCapture(this) then
+        val tracer = Thread.currentThread().getStackTrace().mkString("\n  ", "\n  ", "\n")
+        tracer
+      else
+        null
+
+    // assert(id != 723)
 
     def coord: Coord = myCoord
 
@@ -76,6 +93,10 @@ object Symbols {
 
     /** Set defining tree if this symbol retains its definition tree */
     def defTree_=(tree: Tree)(using Context): Unit =
+      val fname = denot.fullName.toString
+      if fname.contains("a.Foo") || fname.contains("a.Bar") then
+        if tracer != null then
+          report.echo(i"`${denot.fullName}.defTree = $tree` [did assign? $retainsDefTree, id? ${id}, phase? ${ctx.phase.phaseName}, run? $runUUID]")//, $tracer]")
       if (retainsDefTree) myDefTree = tree
 
     /** Does this symbol retain its definition tree?
@@ -368,8 +389,8 @@ object Symbols {
   type TermSymbol = Symbol { type ThisName = TermName }
   type TypeSymbol = Symbol { type ThisName = TypeName }
 
-  class ClassSymbol private[Symbols] (coord: Coord, val assocFile: AbstractFile, id: Int)
-    extends Symbol(coord, id) {
+  class ClassSymbol private[Symbols] (coord: Coord, val assocFile: AbstractFile, id: Int, runUUID: String)
+    extends Symbol(coord, id, runUUID) {
 
     type ThisName = TypeName
 
@@ -516,7 +537,7 @@ object Symbols {
       info: Type,
       privateWithin: Symbol = NoSymbol,
       coord: Coord = NoCoord)(using Context): Symbol { type ThisName = N } = {
-    val sym = new Symbol(coord, ctx.base.nextSymId).asInstanceOf[Symbol { type ThisName = N }]
+    val sym = new Symbol(coord, ctx.base.nextSymId, Option(ctx.run).map(_.uuid).getOrElse("<no run>")).asInstanceOf[Symbol { type ThisName = N }]
     val denot = SymDenotation(sym, owner, name, flags, info, privateWithin)
     sym.denot = denot
     sym
@@ -534,7 +555,7 @@ object Symbols {
       coord: Coord = NoCoord,
       assocFile: AbstractFile = null)(using Context): ClassSymbol
   = {
-    val cls = new ClassSymbol(coord, assocFile, ctx.base.nextSymId)
+    val cls = new ClassSymbol(coord, assocFile, ctx.base.nextSymId, Option(ctx.run).map(_.uuid).getOrElse("<no uuid>"))
     val denot = SymDenotation(cls, owner, name, flags, infoFn(cls), privateWithin)
     cls.denot = denot
     cls

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

@@ -720,8 +720,10 @@ private class ExtractAPICollector(using Context) extends ThunkHolder {
             sym.defTree match
               case defTree: ValOrDefDef =>
                 h = inlineReferenceHash(sym, defTree.rhs, h)
-              case _ =>
-                h = err(i"inline method reference `${ref.name}`", ref.name, ref, h)
+              case tree =>
+                val trace = if sym.tracer != null then s"created at: ${sym.tracer}" else "no tracer"
+                val infoTrace = if sym.denot.infoTracer != null then s"info assigned at: ${sym.denot.infoTracer}" else "no info tracer"
+                h = err(i"inline method reference `${ref.name}` [tree? ${tree.show}, symId? ${sym.id}, run? ${sym.runUUID}, $trace, $infoTrace]", ref.name, ref, h)
         case _ =>
 
       // FIXME: If `p` is a tree we should probably take its type into account

compiler/src/dotty/tools/dotc/typer/Namer.scala

@@ -1255,6 +1255,9 @@ class Namer { typer: Typer =>
 
     /** The type signature of a ClassDef with given symbol */
     override def completeInCreationContext(denot: SymDenotation): Unit = {
+      if SymbolCapturing.doCapture(cls) then
+        val trace = if cls.tracer != null then s"created: ${cls.tracer}" else "no trace"
+        report.echo(i"forcing class ${cls.denot.fullName} [id? ${cls.id}, trace? $trace]")
       val parents = impl.parents
 
       /* The type of a parent constructor. Types constructor arguments

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -2552,7 +2552,10 @@ class Typer extends Namer
           // If it exists, complete the class containing the top-level definitions
           // before typing any statement in the package to avoid cycles as in i13669.scala
           val topLevelClassName = desugar.packageObjectName(ctx.source).moduleClassName
-          pkg.moduleClass.info.decls.lookup(topLevelClassName).ensureCompleted()
+          val cls = pkg.moduleClass.info.decls.lookup(topLevelClassName)
+          // if SymbolCapturing.doCapture(cls.id) then
+          //   report.echo(i"forcing top level class ${cls.denot.fullName} [id? ${cls.id}, run? ${cls.runUUID}, from? ${String.valueOf(trace)}]")
+          cls.ensureCompleted()
           var stats1 = typedStats(tree.stats, pkg.moduleClass)._1
           if (!ctx.isAfterTyper)
             stats1 = stats1 ++ typedBlockStats(MainProxies.mainProxies(stats1))._1

library/src-bootstrapped/a/b/Bar.scala

@@ -0,0 +1,5 @@
+package a
+package b
+
+object Bar:
+  inline def Bar = Foo.foo

library/src-bootstrapped/a/zz.scala

@@ -0,0 +1,7 @@
+package a
+
+object Foo:
+  inline def foo: Nothing =
+    ???
+    ???
+    ???

library/src/scala/compiletime/package.scala

@@ -188,4 +188,3 @@ def byName[T](x: => T): T = x
   */
 extension [T](x: T)
   transparent inline def asMatchable: x.type & Matchable = x.asInstanceOf[x.type & Matchable]
-

project/Build.scala

@@ -257,6 +257,8 @@ object Build {
     (Compile / resourceDirectory)    := baseDirectory.value / "resources",
     (Test / resourceDirectory)       := baseDirectory.value / "test-resources",
 
+    disableDocSetting,
+
     // Prevent sbt from rewriting our dependencies
     scalaModuleInfo ~= (_.map(_.withOverrideScalaVersion(false))),
 

sandbox/scalajs/src/hello.scala

@@ -8,8 +8,10 @@ trait MyTrait {
 }
 
 object HelloWorld extends MyTrait {
+
   def main(args: Array[String]): Unit = {
     println("hello dotty.js!")
     println(foo(4))
+    // println(compiletime.foo)
   }
 }

sbt-test/source-dependencies/inline-rec-package-obj/Utils.scala

@@ -0,0 +1,8 @@
+package a
+
+import a.Errors.myerror
+
+object Utils:
+
+  inline def testTypeChecks: Nothing =
+    myerror("foo...")

sbt-test/source-dependencies/inline-rec-package-obj/build.sbt

@@ -0,0 +1,27 @@
+import sbt.internal.inc.Analysis
+import complete.DefaultParsers._
+
+// Reset compiler iterations, necessary because tests run in batch mode
+val recordPreviousIterations = taskKey[Unit]("Record previous iterations.")
+recordPreviousIterations := {
+  val log = streams.value.log
+  CompileState.previousIterations = {
+    val previousAnalysis = (previousCompile in Compile).value.analysis.asScala
+    previousAnalysis match {
+      case None =>
+        log.info("No previous analysis detected")
+        0
+      case Some(a: Analysis) => a.compilations.allCompilations.size
+    }
+  }
+}
+
+val checkIterations = inputKey[Unit]("Verifies the accumulated number of iterations of incremental compilation.")
+
+checkIterations := {
+  val expected: Int = (Space ~> NatBasic).parsed
+  val actual: Int = ((compile in Compile).value match { case a: Analysis => a.compilations.allCompilations.size }) - CompileState.previousIterations
+  assert(expected == actual, s"Expected $expected compilations, got $actual")
+}
+
+Compile/scalacOptions ++= Seq("-sourcepath", (Compile / sourceDirectories).value.map(_.getAbsolutePath).distinct.mkString(java.io.File.pathSeparator))

sbt-test/source-dependencies/inline-rec-package-obj/changes/zz1.scala

@@ -0,0 +1,7 @@
+package a
+
+object Errors:
+
+  inline def myerror(inline msg: String): Nothing =
+    ???
+    ???

sbt-test/source-dependencies/inline-rec-package-obj/project/CompileState.scala

@@ -0,0 +1,4 @@
+// This is necessary because tests are run in batch mode
+object CompileState {
+  @volatile var previousIterations: Int = -1
+}

sbt-test/source-dependencies/inline-rec-package-obj/project/DottyInjectedPlugin.scala

@@ -0,0 +1,11 @@
+import sbt._
+import Keys._
+
+object DottyInjectedPlugin extends AutoPlugin {
+  override def requires = plugins.JvmPlugin
+  override def trigger = allRequirements
+
+  override val projectSettings = Seq(
+    scalaVersion := sys.props("plugin.scalaVersion")
+  )
+}

sbt-test/source-dependencies/inline-rec-package-obj/test

@@ -0,0 +1,7 @@
+> compile
+> recordPreviousIterations
+# Force recompilation of a-testing-package because a.myerror, called by a.testing.myTypeChecks, has changed
+$ copy-file changes/zz1.scala zz.scala
+> compile
+# 1 to recompile a-package, then 1 more to recompile a-testing-package due to a.myerror change
+> checkIterations 2

sbt-test/source-dependencies/inline-rec-package-obj/zz.scala

@@ -0,0 +1,5 @@
+package a
+
+object Errors:
+
+  inline def myerror(inline msg: String): Nothing = ???