Clean up scala.runtime.function, refactor closure adaptation

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

@@ -318,20 +318,10 @@ trait BCodeBodyBuilder extends BCodeSkelBuilder {
           abort(s"Unexpected New(${tpt.tpe.showSummary()}/$tpt) reached GenBCode.\n" +
                 "  Call was genLoad" + ((tree, expectedType)))
 
-        case app: Closure =>
-          val env: List[Tree] = app.env
-          val call: Tree = app.meth
-          val functionalInterface: Symbol = {
-            val t = app.tpt.tpe.typeSymbol
-            if (t.exists) t
-            else {
-              val arity = app.meth.tpe.widenDealias.firstParamTypes.size - env.size
-              val returnsUnit = app.meth.tpe.widenDealias.resultType.classSymbol == defn.UnitClass
-              if (returnsUnit) requiredClass(("scala.runtime.function.JProcedure" + arity))
-              else if (arity <= 2) requiredClass(("scala.runtime.function.JFunction" + arity))
-              else requiredClass(("scala.Function" + arity))
-            }
-          }
+        case t @ Closure(env, call, tpt) =>
+          val functionalInterface: Symbol =
+            if !tpt.isEmpty then tpt.tpe.classSymbol
+            else t.tpe.classSymbol
           val (fun, args) = call match {
             case Apply(fun, args) => (fun, args)
             case t @ DesugaredSelect(_, _) => (t, Nil) // TODO: use Select

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/Compiler.scala

@@ -111,7 +111,6 @@ class Compiler {
          new CapturedVars) ::        // Represent vars captured by closures as heap objects
     List(new Constructors,           // Collect initialization code in primary constructors
                                         // Note: constructors changes decls in transformTemplate, no InfoTransformers should be added after it
-         new FunctionalInterfaces,   // Rewrites closures to implement @specialized types of Functions.
          new Instrumentation) ::     // Count calls and allocations under -Yinstrument
     List(new LambdaLift,             // Lifts out nested functions to class scope, storing free variables in environments
                                      // Note: in this mini-phase block scopes are incorrect. No phases that rely on scopes should be here

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/Definitions.scala

@@ -1464,7 +1464,12 @@ class Definitions {
     new PerRun(Function2SpecializedReturnTypes.map(_.symbol))
 
   def isSpecializableFunction(cls: ClassSymbol, paramTypes: List[Type], retType: Type)(using Context): Boolean =
-    paramTypes.length <= 2 && cls.derivesFrom(FunctionClass(paramTypes.length)) && (paramTypes match {
+    paramTypes.length <= 2 && cls.derivesFrom(FunctionClass(paramTypes.length))
+    && isSpecializableFunctionSAM(paramTypes, retType)
+
+  /** If the Single Abstract Method of a Function class has this type, is it specializable? */
+  def isSpecializableFunctionSAM(paramTypes: List[Type], retType: Type)(using Context): Boolean =
+    paramTypes.length <= 2 && (paramTypes match {
       case Nil =>
         Function0SpecializedReturnClasses().contains(retType.typeSymbol)
       case List(paramType0) =>

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

@@ -585,7 +585,7 @@ object Denotations {
           try info.signature
           catch { // !!! DEBUG
             case scala.util.control.NonFatal(ex) =>
-              report.echo(s"cannot take signature of ${info.show}")
+              report.echo(s"cannot take signature of $info")
               throw ex
           }
         case _ => Signature.NotAMethod

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

@@ -300,15 +300,15 @@ object NameOps {
      *
      *  `<return type><first type><second type><...>`
      */
-    def specializedFunction(ret: Type, args: List[Type])(using Context): Name =
+    def specializedFunction(ret: Type, args: List[Type])(using Context): N =
       val sb = new StringBuilder
       sb.append(name.toString)
       sb.append(nme.specializedTypeNames.prefix.toString)
       sb.append(nme.specializedTypeNames.separator)
       sb.append(defn.typeTag(ret).toString)
       args.foreach { arg => sb.append(defn.typeTag(arg)) }
       sb.append(nme.specializedTypeNames.suffix)
-      termName(sb.toString)
+      likeSpacedN(termName(sb.toString))
 
     /** If name length exceeds allowable limit, replace part of it by hash */
     def compactified(using Context): TermName = termName(compactify(name.toString))

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/StdNames.scala

@@ -830,6 +830,9 @@ object StdNames {
     final val Conforms: TypeName = encode("<:<")
 
     final val Uninstantiated: TypeName = "?$"
+
+    val JFunctionPrefix: Seq[TypeName] = (0 to 2).map(i => s"scala.runtime.java8.JFunction${i}")
+    val JProcedure: Seq[TypeName] = (0 to 22).map(i => s"scala.runtime.function.JProcedure${i}")
   }
 
   abstract class JavaNames[N <: Name] extends DefinedNames[N] {

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)
             }
           })