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 symbol.id == 2765 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.toString.contains("compiletime2") then
+              report.echo(s"${classReps} class reps found in package $packageName")
             initializeFromClassPath(root.symbol, classRep)
         for (classRep <- classReps)
           if (maybeModuleClass(classRep) && hasFlatName(classRep) == flat &&

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

@@ -46,12 +46,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 id == 2760 /* myerror before */ || id == 2756 /* compiletime2.package$ before */ || id == 2765 /* myerror after */|| id == 2757 /* compiletime2.package before */|| id == 2753 /* compiletime2.package after */ then
+        val tracer = Thread.currentThread().getStackTrace().mkString("\n  ", "\n  ", "\n")
+        tracer
+      else
+        null
+
+    // assert(id != 723)
 
     def coord: Coord = myCoord
 
@@ -76,6 +83,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("scala.compiletime") && !fname.contains(".ops") 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 +379,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 +527,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 +545,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/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)
+          val trace = if cls.denot.fullName.toString.contains("scala.compiletime2.package$package") then cls.tracer else "no trace"
+          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/scala/compiletime2/Errors.scala

@@ -0,0 +1,8 @@
+package scala.compiletime2
+
+object Errors {
+  inline def myerror(inline msg: String): Nothing =
+    ???
+    ???
+}
+    // TODO try with https://github.com/lampepfl/dotty/pull/13973

library/src-bootstrapped/scala/compiletime2/Utils.scala

@@ -0,0 +1,8 @@
+package scala.compiletime2
+
+import scala.compiletime2.Errors.myerror
+
+object Utils:
+
+  def typeChecks2: Boolean =
+    myerror("foo")

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]
-

library/src/scala/compiletime3/package.scala

@@ -0,0 +1,4 @@
+package scala
+package compiletime3
+
+inline def myerror(inline msg: String): Nothing = { ??? ; ??? }

library/src/scala/compiletime3/testing3/package.scala

@@ -0,0 +1,17 @@
+package scala.compiletime3
+package testing3
+
+/** Whether the code type checks in the current context?
+ *
+ *  An inline definition with a call to `typeChecks` should be transparent.
+ *
+ *  @param code The code to be type checked
+ *
+ *  @return false if the code has syntax error or type error in the current context, otherwise returns true.
+ *
+ *  The code should be a sequence of expressions or statements that may appear in a block.
+ */
+transparent inline def typeChecks2(inline code: String): Boolean =
+  ???
+  // implemented in package dotty.tools.dotc.typer.Inliner.Intrinsics
+  // myerror("Compiler bug: `typeChecks` was not checked by the compiler")

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")
+}
+
+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 = ???