Stop using scala.runtime.function.JFunction*mc*

Instead, use the equivalent classes in the Scala 2 standard library in
scala.runtime.java8.

The only difference is that these classes are written in Scala instead
of Java, which exposed a bug in the Scala2Unpickler: we were calling
`atPhaseNoLater(picklerPhase)`, but this doesn't actually do anything in
situation where the Pickler phase is not used (for example, when using
the `QuoteCompiler`), this is fixed by introducing a new
`atPhaseBeforeTransforms` which does the right thing.

Because the `FirstTransform` phase itself might not be present, this
also required fixing `Phase#next` and `Phase#prev` to work on `NoPhase`:
the issue was that `myBase.NoPhase` failed with an NPE which we fix by
making `NoPhase` a static object instead of a member of `PhasesBase`.
Since an instace of `Phase` contains mutable state this requires making
it `@sharable` to pass our tests, this is safe since we never mutate
anything in `NoPhase` (this also matches what we do for `NoSymbol` and
`NoDenotation`).

Author: smarter

compiler/src/dotty/tools/backend/sjs/JSCodeGen.scala

@@ -4135,7 +4135,7 @@ class JSCodeGen()(using genCtx: Context) {
   }
 
   private def computeJSNativeLoadSpecOfValDef(sym: Symbol): js.JSNativeLoadSpec = {
-    atPhase(picklerPhase.next) {
+    atPhaseBeforeTransforms {
       computeJSNativeLoadSpecOfInPhase(sym)
     }
   }
@@ -4144,7 +4144,7 @@ class JSCodeGen()(using genCtx: Context) {
     if (sym.is(Trait) || sym.hasAnnotation(jsdefn.JSGlobalScopeAnnot)) {
       None
     } else {
-      atPhase(picklerPhase.next) {
+      atPhaseBeforeTransforms {
         if (sym.owner.isStaticOwner)
           Some(computeJSNativeLoadSpecOfInPhase(sym))
         else

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

@@ -61,7 +61,7 @@ object Annotations {
       mySym match {
         case symFn: (Context ?=> Symbol) @unchecked =>
           mySym = null
-          mySym = atPhaseNoLater(picklerPhase)(symFn)
+          mySym = atPhaseBeforeTransforms(symFn)
             // We should always produce the same annotation tree, no matter when the
             // annotation is evaluated. Setting the phase to a pre-transformation phase
             // seems to be enough to ensure this (note that after erasure, `ctx.typer`
@@ -79,7 +79,7 @@ object Annotations {
       myTree match {
         case treeFn: (Context ?=> Tree) @unchecked =>
           myTree = null
-          myTree = atPhaseNoLater(picklerPhase)(treeFn)
+          myTree = atPhaseBeforeTransforms(treeFn)
         case _ =>
       }
       myTree.asInstanceOf[Tree]
@@ -112,7 +112,7 @@ object Annotations {
       myTree match {
         case treeFn: (Context ?=> Tree) @unchecked =>
           myTree = null
-          myTree = atPhaseNoLater(picklerPhase)(treeFn)
+          myTree = atPhaseBeforeTransforms(treeFn)
         case _ =>
       }
       myTree.asInstanceOf[Tree]

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

@@ -76,6 +76,16 @@ object Contexts {
   inline def atNextPhase[T](inline op: Context ?=> T)(using Context): T =
     atPhase(ctx.phase.next)(op)
 
+  /** Execute `op` at the current phase if it's before the first transform phase,
+   *  otherwise at the last phase before the first transform phase.
+   *
+   *  Note: this should be used instead of `atPhaseNoLater(ctx.picklerPhase)`
+   *  because the later won't work if the `Pickler` phase is not present (for example,
+   *  when using `QuoteCompiler`).
+   */
+  inline def atPhaseBeforeTransforms[T](inline op: Context ?=> T)(using Context): T =
+    atPhaseNoLater(firstTransformPhase.prev)(op)
+
   inline def atPhaseNoLater[T](limit: Phase)(inline op: Context ?=> T)(using Context): T =
     op(using if !limit.exists || ctx.phase <= limit then ctx else ctx.withPhase(limit))
 

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

@@ -16,25 +16,26 @@ import Periods._
 import typer.{FrontEnd, RefChecks}
 import typer.ImportInfo.withRootImports
 import ast.tpd
+import scala.annotation.internal.sharable
 
 object Phases {
 
   inline def phaseOf(id: PhaseId)(using Context): Phase =
     ctx.base.phases(id)
 
+  @sharable object NoPhase extends Phase {
+    override def exists: Boolean = false
+    def phaseName: String = "<no phase>"
+    def run(using Context): Unit = unsupported("run")
+    def transform(ref: SingleDenotation)(using Context): SingleDenotation = unsupported("transform")
+  }
+
   trait PhasesBase {
     this: ContextBase =>
 
     // drop NoPhase at beginning
     def allPhases: Array[Phase] = (if (fusedPhases.nonEmpty) fusedPhases else phases).tail
 
-    object NoPhase extends Phase {
-      override def exists: Boolean = false
-      def phaseName: String = "<no phase>"
-      def run(using Context): Unit = unsupported("run")
-      def transform(ref: SingleDenotation)(using Context): SingleDenotation = unsupported("transform")
-    }
-
     object SomePhase extends Phase {
       def phaseName: String = "<some phase>"
       def run(using Context): Unit = unsupported("run")
@@ -198,6 +199,7 @@ object Phases {
     private var mySbtExtractDependenciesPhase: Phase = _
     private var myPicklerPhase: Phase = _
     private var myPickleQuotesPhase: Phase = _
+    private var myFirstTransformPhase: Phase = _
     private var myCollectNullableFieldsPhase: Phase = _
     private var myRefChecksPhase: Phase = _
     private var myPatmatPhase: Phase = _
@@ -217,6 +219,7 @@ object Phases {
     final def sbtExtractDependenciesPhase: Phase = mySbtExtractDependenciesPhase
     final def picklerPhase: Phase = myPicklerPhase
     final def pickleQuotesPhase: Phase = myPickleQuotesPhase
+    final def firstTransformPhase: Phase = myFirstTransformPhase
     final def collectNullableFieldsPhase: Phase = myCollectNullableFieldsPhase
     final def refchecksPhase: Phase = myRefChecksPhase
     final def patmatPhase: Phase = myPatmatPhase
@@ -239,6 +242,7 @@ object Phases {
       mySbtExtractDependenciesPhase = phaseOfClass(classOf[sbt.ExtractDependencies])
       myPicklerPhase = phaseOfClass(classOf[Pickler])
       myPickleQuotesPhase = phaseOfClass(classOf[PickleQuotes])
+      myFirstTransformPhase = phaseOfClass(classOf[FirstTransform])
       myCollectNullableFieldsPhase = phaseOfClass(classOf[CollectNullableFields])
       myRefChecksPhase = phaseOfClass(classOf[RefChecks])
       myElimRepeatedPhase = phaseOfClass(classOf[ElimRepeated])
@@ -385,10 +389,10 @@ object Phases {
       exists && id <= that.id
 
     final def prev: Phase =
-      if (id > FirstPhaseId) myBase.phases(start - 1) else myBase.NoPhase
+      if (id > FirstPhaseId) myBase.phases(start - 1) else NoPhase
 
     final def next: Phase =
-      if (hasNext) myBase.phases(end + 1) else myBase.NoPhase
+      if (hasNext) myBase.phases(end + 1) else NoPhase
 
     final def hasNext: Boolean = start >= FirstPhaseId && end + 1 < myBase.phases.length
 
@@ -403,6 +407,7 @@ object Phases {
   def sbtExtractDependenciesPhase(using Context): Phase = ctx.base.sbtExtractDependenciesPhase
   def picklerPhase(using Context): Phase                = ctx.base.picklerPhase
   def pickleQuotesPhase(using Context): Phase           = ctx.base.pickleQuotesPhase
+  def firstTransformPhase(using Context): Phase         = ctx.base.firstTransformPhase
   def refchecksPhase(using Context): Phase              = ctx.base.refchecksPhase
   def elimRepeatedPhase(using Context): Phase           = ctx.base.elimRepeatedPhase
   def extensionMethodsPhase(using Context): Phase       = ctx.base.extensionMethodsPhase

compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala

@@ -116,7 +116,7 @@ class TreeUnpickler(reader: TastyReader,
     val owner = ctx.owner
     val source = ctx.source
     def complete(denot: SymDenotation)(using Context): Unit =
-      treeAtAddr(currentAddr) = atPhaseNoLater(picklerPhase) {
+      treeAtAddr(currentAddr) = atPhaseBeforeTransforms {
         new TreeReader(reader).readIndexedDef()(
           using ctx.withOwner(owner).withSource(source))
       }
@@ -1392,7 +1392,7 @@ class TreeUnpickler(reader: TastyReader,
       op: TreeReader => Context ?=> T) extends Trees.Lazy[T] {
     def complete(using Context): T = {
       pickling.println(i"starting to read at ${reader.reader.currentAddr} with owner $owner")
-      atPhaseNoLater(picklerPhase) {
+      atPhaseBeforeTransforms {
         op(reader)(using ctx
           .withOwner(owner)
           .withModeBits(mode)

compiler/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala

@@ -608,7 +608,7 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas
       }
       atReadPos(startCoord(denot).toIndex,
           () => withMode(Mode.Scala2Unpickling) {
-            atPhaseNoLater(picklerPhase) {
+            atPhaseBeforeTransforms {
               parseToCompletion(denot)
             }
           })

compiler/src/dotty/tools/dotc/transform/FunctionalInterfaces.scala

@@ -25,7 +25,7 @@ class FunctionalInterfaces extends MiniPhase {
   def phaseName: String = FunctionalInterfaces.name
 
   private val functionName = "JFunction".toTermName
-  private val functionPackage = "scala.runtime.function.".toTermName
+  private val functionPackage = "scala.runtime.java8.".toTermName
 
   override def transformClosure(tree: Closure)(using Context): Tree = {
     val cls = tree.tpe.classSymbol.asClass