Refactor FunctionalInterfaces

This commit does not change the end result of FunctionalInterfaces but
makes the code easier to read, and add a
`Definitions#isSpecializableFunction` method used in the next commit.

Author: smarter

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

@@ -911,6 +911,34 @@ class Definitions {
     arity >= 0 && isFunctionClass(sym) && tp.isRef(FunctionType(arity, sym.name.isImplicitFunction).typeSymbol)
   }
 
+  // Specialized type parameters defined for scala.Function{0,1,2}.
+  private lazy val Function1SpecializedParams: collection.Set[Type] =
+    Set(IntType, LongType, FloatType, DoubleType)
+  private lazy val Function2SpecializedParams: collection.Set[Type] =
+    Set(IntType, LongType, DoubleType)
+  private lazy val Function0SpecializedReturns: collection.Set[Type] =
+    ScalaNumericValueTypeList.toSet[Type] + UnitType + BooleanType
+  private lazy val Function1SpecializedReturns: collection.Set[Type] =
+    Set(UnitType, BooleanType, IntType, FloatType, LongType, DoubleType)
+  private lazy val Function2SpecializedReturns: collection.Set[Type] =
+    Function1SpecializedReturns
+
+  def isSpecializableFunction(cls: ClassSymbol, paramTypes: List[Type], retType: Type)(implicit ctx: Context) =
+    isFunctionClass(cls) && (paramTypes match {
+      case Nil =>
+        Function0SpecializedReturns.contains(retType)
+      case List(paramType0) =>
+        Function1SpecializedParams.contains(paramType0) &&
+        Function1SpecializedReturns.contains(retType)
+      case List(paramType0, paramType1) =>
+        Function2SpecializedParams.contains(paramType0) &&
+        Function2SpecializedParams.contains(paramType1) &&
+        Function2SpecializedReturns.contains(retType)
+      case _ =>
+        false
+    })
+
+
   def functionArity(tp: Type)(implicit ctx: Context) = tp.dealias.argInfos.length - 1
 
   def isImplicitFunctionType(tp: Type)(implicit ctx: Context) =

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

@@ -26,58 +26,26 @@ class FunctionalInterfaces extends MiniPhaseTransform {
 
   def phaseName: String = "functionalInterfaces"
 
-  private var allowedReturnTypes: Set[Symbol] = _ // moved here to make it explicit what specializations are generated
-  private var allowedArgumentTypes: Set[Symbol] = _
-  val maxArgsCount = 2
-
-  def shouldSpecialize(m: MethodType)(implicit ctx: Context) =
-    (m.paramInfos.size <= maxArgsCount) &&
-      m.paramInfos.forall(x => allowedArgumentTypes.contains(x.typeSymbol)) &&
-      allowedReturnTypes.contains(m.resultType.typeSymbol)
-
   val functionName = "JFunction".toTermName
   val functionPackage = "scala.compat.java8.".toTermName
 
-  override def prepareForUnit(tree: tpd.Tree)(implicit ctx: Context): TreeTransform = {
-    allowedReturnTypes   = Set(defn.UnitClass,
-                               defn.BooleanClass,
-                               defn.IntClass,
-                               defn.FloatClass,
-                               defn.LongClass,
-                               defn.DoubleClass,
-     /* only for Function0: */ defn.ByteClass,
-                               defn.ShortClass,
-                               defn.CharClass)
-
-    allowedArgumentTypes = Set(defn.IntClass,
-                               defn.LongClass,
-                               defn.DoubleClass,
-     /* only for Function1: */ defn.FloatClass)
-
-    this
-  }
-
   override def transformClosure(tree: Closure)(implicit ctx: Context, info: TransformerInfo): Tree = {
-    tree.tpt match {
-      case EmptyTree =>
-        val m = tree.meth.tpe.widen.asInstanceOf[MethodType]
-
-        if (shouldSpecialize(m)) {
-          val functionSymbol = tree.tpe.widenDealias.classSymbol
-          val names = ctx.atPhase(ctx.erasurePhase) {
-            implicit ctx => functionSymbol.typeParams.map(_.name)
-          }
-          val interfaceName = (functionName ++ m.paramInfos.length.toString).specializedFor(m.paramInfos ::: m.resultType :: Nil, names, Nil, Nil)
-
-          // symbols loaded from classpath aren't defined in periods earlier than when they where loaded
-          val interface = ctx.withPhase(ctx.typerPhase).getClassIfDefined(functionPackage ++ interfaceName)
-          if (interface.exists) {
-            val tpt = tpd.TypeTree(interface.asType.appliedRef)
-            tpd.Closure(tree.env, tree.meth, tpt)
-          } else tree
-        } else tree
-      case _ =>
-        tree
-    }
+    val cls = tree.tpe.widen.classSymbol.asClass
+
+    val implType = tree.meth.tpe.widen
+    val List(implParamTypes) = implType.paramInfoss
+    val implResultType = implType.resultType
+
+    if (defn.isSpecializableFunction(cls, implParamTypes, implResultType)) {
+      val names = ctx.atPhase(ctx.erasurePhase) {
+        implicit ctx => cls.typeParams.map(_.name)
+      }
+      val interfaceName = (functionName ++ implParamTypes.length.toString).specializedFor(implParamTypes ::: implResultType :: Nil, names, Nil, Nil)
+
+      // symbols loaded from classpath aren't defined in periods earlier than when they where loaded
+      val interface = ctx.withPhase(ctx.typerPhase).requiredClass(functionPackage ++ interfaceName)
+      val tpt = tpd.TypeTree(interface.asType.appliedRef)
+      tpd.Closure(tree.env, tree.meth, tpt)
+    } else tree
   }
 }