Refactor closure adaptation

As described in details in `Erasure#adaptClosure`, in some situation we
need to perform some transformation to make the closure implementation
method type match the type of the single abstract method of the
functional interface this closure implements, previously the
responsability for doing this was split in three places:
- The FunctionalInterfaces phase was setting the functional
  interface of specializable FunctionN instances to the corresponding
  specialized JFunction*mc* interface
- The backend set the functional interface of a Unit-returning FunctionN
  to JProcedureN
- And `adaptClosure` generated a bridge method in all other
  situations where some adaptation was needed.

This commit centralizes all of this logic in `adaptClosure` which allows
us to remove one phase, and in general makes it easier to follow what's
going on.

Author: smarter

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

@@ -318,19 +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 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/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/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/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/StdNames.scala

@@ -830,6 +830,10 @@ object StdNames {
     final val Conforms: TypeName = encode("<:<")
 
     final val Uninstantiated: TypeName = "?$"
+
+    val Function: Seq[TypeName] = (0 to 22).map(i => s"scala.Function${i}")
+    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/transform/Erasure.scala

@@ -376,99 +376,131 @@ object Erasure {
      *
      *      val f: Function1[Int, Any] = x => ...
      *
-     *  results in the creation of a closure and a method in the typer:
+     *  results in the creation of a closure and an implementation method in the typer:
      *
      *      def $anonfun(x: Int): Any = ...
      *      val f: Function1[Int, Any] = closure($anonfun)
      *
-     *  Notice that `$anonfun` takes a primitive as argument, but the single abstract method
+     *  Notice that `$anonfun` takes a primitive as argument, but the SAM (Single Abstract Method)
      *  of `Function1` after erasure is:
      *
      *      def apply(x: Object): Object
      *
-     *  which takes a reference as argument. Hence, some form of adaptation is required.
+     *  which takes a reference as argument. Hence, some form of adaptation is
+     *  required. The most reliable way to do this adaptation is to replace the
+     *  closure implementation method by a bridge method that forwards to the
+     *  original method with appropriate boxing/unboxing. For our example above,
+     *  this would be:
      *
-     *  If we do nothing, the LambdaMetaFactory bootstrap method will
-     *  automatically do the adaptation. Unfortunately, the result does not
-     *  implement the expected Scala semantics: null should be "unboxed" to
-     *  the default value of the value class, but LMF will throw a
-     *  NullPointerException instead. LMF is also not capable of doing
-     *  adaptation for derived value classes.
+     *      def $anonfun$adapted(x: Object): Object = $anonfun(BoxesRunTime.unboxToInt(x))
+     *      val f: Function1 = closure($anonfun$adapted)
      *
-     *  Thus, we need to replace the closure method by a bridge method that
-     *  forwards to the original closure method with appropriate
-     *  boxing/unboxing. For our example above, this would be:
-     *
-     *      def $anonfun1(x: Object): Object = $anonfun(BoxesRunTime.unboxToInt(x))
-     *      val f: Function1 = closure($anonfun1)
-     *
-     *  In general a bridge is needed when, after Erasure, one of the
-     *  parameter type or the result type of the closure method has a
-     *  different type, and we cannot rely on auto-adaptation.
-     *
-     *  Auto-adaptation works in the following cases:
-     *  - If the SAM is replaced by JFunction*mc* in
-     *    [[FunctionalInterfaces]], no bridge is needed: the SAM contains
-     *    default methods to handle adaptation.
-     *  - If a result type of the closure method is a primitive value type
-     *    different from Unit, we can rely on the auto-adaptation done by
-     *    LMF (because it only needs to box, not unbox, so no special
-     *    handling of null is required).
-     *  - If the SAM is replaced by JProcedure* in
-     *    [[DottyBackendInterface]] (this only happens when no explicit SAM
-     *    type is given), no bridge is needed to box a Unit result type:
-     *    the SAM contains a default method to handle that.
+     *  But in some situations we can avoid generating this bridge, either
+     *  because the runtime can perform auto-adaptation, or because we can
+     *  replace the closure functional interface by a specialized sub-interface,
+     *  see comments in this method for details.
      *
      *  See test cases lambda-*.scala and t8017/ for concrete examples.
      */
-    def adaptClosure(tree: tpd.Closure)(using Context): Tree = {
-      val implClosure @ Closure(_, meth, _) = tree
-
-      implClosure.tpe match {
-        case SAMType(sam) =>
-          val implType = meth.tpe.widen.asInstanceOf[MethodType]
-
-          val implParamTypes = implType.paramInfos
-          val List(samParamTypes) = sam.paramInfoss
-          val implResultType = implType.resultType
-          val samResultType = sam.resultType
-
-          if (!defn.isSpecializableFunction(implClosure.tpe.classSymbol.asClass, implParamTypes, implResultType)) {
-            def autoAdaptedParam(tp: Type) = !tp.isErasedValueType && !tp.isPrimitiveValueType
-            val explicitSAMType = implClosure.tpt.tpe.exists
-            def autoAdaptedResult(tp: Type) = !tp.isErasedValueType &&
-              (!explicitSAMType || tp.typeSymbol != defn.UnitClass)
-            def sameSymbol(tp1: Type, tp2: Type) = tp1.typeSymbol == tp2.typeSymbol
-
-            val paramAdaptationNeeded =
-              implParamTypes.lazyZip(samParamTypes).exists((implType, samType) =>
-                !sameSymbol(implType, samType) && !autoAdaptedParam(implType))
-            val resultAdaptationNeeded =
-              !sameSymbol(implResultType, samResultType) && !autoAdaptedResult(implResultType)
-
-            if (paramAdaptationNeeded || resultAdaptationNeeded) {
-              val bridgeType =
-                if (paramAdaptationNeeded)
-                  if (resultAdaptationNeeded) sam
-                  else implType.derivedLambdaType(paramInfos = samParamTypes)
-                else implType.derivedLambdaType(resType = samResultType)
-              val bridge = newSymbol(ctx.owner, AdaptedClosureName(meth.symbol.name.asTermName), Flags.Synthetic | Flags.Method, bridgeType)
-              Closure(bridge, bridgeParamss =>
-                inContext(ctx.withOwner(bridge)) {
-                  val List(bridgeParams) = bridgeParamss
-                  assert(ctx.typer.isInstanceOf[Erasure.Typer])
-                  val rhs = Apply(meth, bridgeParams.lazyZip(implParamTypes).map(ctx.typer.adapt(_, _)))
-                  ctx.typer.adapt(rhs, bridgeType.resultType)
-                },
-                targetType = implClosure.tpt.tpe)
-            }
-            else implClosure
-          }
-          else implClosure
-        case _ =>
-          implClosure
-      }
-    }
+    def adaptClosure(tree: tpd.Closure)(using Context): Tree =
+      val Closure(env, meth, tpt) = tree
+      assert(env.isEmpty, tree)
+
+      // The type of the lambda expression
+      val lambdaType = tree.tpe
+      // The interface containing the SAM that this closure should implement
+      val functionalInterface = tpt.tpe
+      // A lack of an explicit functional interface means we're implementing a scala.FunctionN
+      val isFunction = !functionalInterface.exists
+      // The actual type of the implementation method
+      val implType = meth.tpe.widen.asInstanceOf[MethodType]
+      val implParamTypes = implType.paramInfos
+      val implResultType = implType.resultType
+      val implReturnsUnit = implResultType.classSymbol eq defn.UnitClass
+      // The SAM that this closure should implement
+      val SAMType(sam) = lambdaType: @unchecked
+      val samParamTypes = sam.paramInfos
+      val samResultType = sam.resultType
+
+      /** Can the implementation parameter type `tp` be auto-adapted to a different
+       *  parameter type in the SAM?
+       *
+       *  For derived value classes, we always need to do the bridging manually.
+       *  For primitives, we cannot rely on auto-adaptation on the JVM because
+       *  the Scala spec requires null to be "unboxed" to the default value of
+       *  the value class, but the adaptation performed by LambdaMetaFactory
+       *  will throw a `NullPointerException` instead. See `lambda-null.scala`
+       *  for test cases.
+       *
+       *  @see [LambdaMetaFactory](https://docs.oracle.com/javase/8/docs/api/java/lang/invoke/LambdaMetafactory.html)
+       */
+      def autoAdaptedParam(tp: Type) =
+        !tp.isErasedValueType && !tp.isPrimitiveValueType
+
+      /** Can the implementation result type be auto-adapted to a different result
+       *  type in the SAM?
+       *
+       *  For derived value classes, it's the same story as for parameters.
+       *  For non-Unit primitives, we can actually rely on the `LambdaMetaFactory`
+       *  adaptation, because it only needs to box, not unbox, so no special
+       *  handling of null is required.
+       */
+      def autoAdaptedResult =
+        !implResultType.isErasedValueType && !implReturnsUnit
+
+      def sameClass(tp1: Type, tp2: Type) = tp1.classSymbol == tp2.classSymbol
+
+      val paramAdaptationNeeded =
+        implParamTypes.lazyZip(samParamTypes).exists((implType, samType) =>
+          !sameClass(implType, samType) && !autoAdaptedParam(implType))
+      val resultAdaptationNeeded =
+        !sameClass(implResultType, samResultType) && !autoAdaptedResult
+
+      if paramAdaptationNeeded || resultAdaptationNeeded then
+        // Instead of instantiating `scala.FunctionN`, see if we can instantiate
+        // a specialized sub-interface where the SAM type matches the
+        // implementation method type, thus avoiding the need for bridging.
+        // This optimization is skipped when using Scala.js because its backend
+        // does not support closures using custom functional interfaces.
+        if isFunction && !ctx.settings.scalajs.value then
+          val arity = implParamTypes.length
+          val specializedFunctionalInterface =
+            if defn.isSpecializableFunctionSAM(implParamTypes, implResultType) then
+              // Using these subclasses is critical to avoid boxing since their
+              // SAM is a specialized method `apply$mc*$sp` whose default
+              // implementation in FunctionN boxes.
+              tpnme.JFunctionPrefix(arity).specializedFunction(implResultType, implParamTypes)
+            else if !paramAdaptationNeeded && implReturnsUnit then
+              // Here, there is no actual boxing to avoid so we could get by
+              // without JProcedureN, but Unit-returning functions are very
+              // common so it seems worth it to not generate bridges for them.
+              tpnme.JProcedure(arity)
+            else
+              EmptyTypeName
+          if !specializedFunctionalInterface.isEmpty then
+            return cpy.Closure(tree)(tpt = TypeTree(requiredClass(specializedFunctionalInterface).typeRef))
+
+        // Otherwise, generate a new closure implemented with a bridge.
+        val bridgeType =
+          if paramAdaptationNeeded then
+            if resultAdaptationNeeded then
+              sam
+            else
+              implType.derivedLambdaType(paramInfos = samParamTypes)
+          else
+            implType.derivedLambdaType(resType = samResultType)
+        val bridge = newSymbol(ctx.owner, AdaptedClosureName(meth.symbol.name.asTermName), Flags.Synthetic | Flags.Method, bridgeType)
+        Closure(bridge, bridgeParamss =>
+          inContext(ctx.withOwner(bridge)) {
+            val List(bridgeParams) = bridgeParamss
+            assert(ctx.typer.isInstanceOf[Erasure.Typer])
+            val rhs = Apply(meth, bridgeParams.lazyZip(implParamTypes).map(ctx.typer.adapt(_, _)))
+            ctx.typer.adapt(rhs, bridgeType.resultType)
+          },
+          targetType = functionalInterface).withSpan(tree.span)
+      else
+        tree
+    end adaptClosure
 
     /** Eta expand given `tree` that has the given method type `mt`, so that
      *  it conforms to erased result type `pt`.