Address review comments

Author: Duhemm

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

@@ -16,6 +16,8 @@ class SpecializeFunctions extends MiniPhase with InfoTransformer {
   val phaseName = "specializeFunctions"
   override def runsAfter = Set(classOf[ElimByName])
 
+  private val jFunction = "scala.compat.java8.JFunction".toTermName
+
   /** Transforms the type to include decls for specialized applys  */
   override def transformInfo(tp: Type, sym: Symbol)(implicit ctx: Context) = tp match {
     case tp: ClassInfo if !sym.is(Flags.Package) && (tp.decls ne EmptyScope) =>
@@ -26,9 +28,15 @@ class SpecializeFunctions extends MiniPhase with InfoTransformer {
           val func = defn.FunctionClass(arity)
           if (parent.derivesFrom(func)) {
             val typeParams = tp.cls.typeRef.baseType(func).argInfos
-            val interface  = specInterface(typeParams)
-
-            if (interface.exists && tp.decls.lookup(nme.apply).exists) {
+            val isSpecializable =
+              defn.isSpecializableFunction(
+                parent.classSymbol.asClass,
+                typeParams.init,
+                typeParams.last
+              )
+
+            if (isSpecializable && tp.decls.lookup(nme.apply).exists) {
+              val interface = specInterface(typeParams)
               val specializedMethodName = nme.apply.specializedFunction(typeParams.last, typeParams.init)
               newApplys += (specializedMethodName -> interface)
             }
@@ -63,13 +71,12 @@ class SpecializeFunctions extends MiniPhase with InfoTransformer {
     val applyBuf = new mutable.ListBuffer[Tree]
     val newBody = tree.body.mapConserve {
       case dt: DefDef if dt.name == nme.apply && dt.vparamss.length == 1 =>
-        val specName = nme.apply.specializedFunction(
-          dt.tpe.widen.finalResultType,
-          dt.vparamss.head.map(_.symbol.info)
-        )
-
-        val specializedApply = tree.symbol.enclosingClass.info.decls.lookup(specName)
+        val cls        = tree.symbol.enclosingClass.asClass
+        val typeParams = dt.vparamss.head.map(_.symbol.info)
+        val retType    = dt.tpe.widen.finalResultType
 
+        val specName = specializedName(nme.apply, typeParams :+ retType)
+        val specializedApply = cls.info.decls.lookup(specName)
         if (specializedApply.exists) {
           val apply = specializedApply.asTerm
           val specializedDecl =
@@ -104,9 +111,14 @@ class SpecializeFunctions extends MiniPhase with InfoTransformer {
         fun.symbol.owner.derivesFrom(defn.FunctionClass(args.length))
       =>
         val params = (fun.tpe.widen.firstParamTypes :+ tree.tpe).map(_.widenSingleton.dealias)
-        val specializedApply = specializedName(nme.apply, params)
-
-        if (!params.exists(_.isInstanceOf[ExprType]) && fun.symbol.owner.info.decls.lookup(specializedApply).exists) {
+        val isSpecializable =
+          defn.isSpecializableFunction(
+            fun.symbol.owner.asClass,
+            params.init,
+            params.last)
+
+        if (isSpecializable && !params.exists(_.isInstanceOf[ExprType])) {
+          val specializedApply = specializedName(nme.apply, params)
           val newSel = fun match {
             case Select(qual, _) =>
               qual.select(specializedApply)
@@ -126,14 +138,12 @@ class SpecializeFunctions extends MiniPhase with InfoTransformer {
       case _ => tree
     }
 
-  @inline private def specializedName(name: Name, args: List[Type])(implicit ctx: Context) =
-    name.specializedFor(args, args.map(_.typeSymbol.name), Nil, Nil)
+  private def specializedName(name: Name, args: List[Type])(implicit ctx: Context) =
+    name.specializedFunction(args.last, args.init)
 
-  @inline private def specInterface(typeParams: List[Type])(implicit ctx: Context) = {
-    val specName =
-      ("JFunction" + (typeParams.length - 1)).toTermName
-      .specializedFunction(typeParams.last, typeParams.init)
+  private def functionName(typeParams: List[Type])(implicit ctx: Context) =
+    jFunction ++ (typeParams.length - 1).toString
 
-    ctx.getClassIfDefined("scala.compat.java8.".toTermName ++ specName)
-  }
+  private def specInterface(typeParams: List[Type])(implicit ctx: Context) =
+    ctx.getClassIfDefined(functionName(typeParams).specializedFunction(typeParams.last, typeParams.init))
 }

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

@@ -19,9 +19,9 @@ class SpecializedApplyMethods extends MiniPhase with InfoTransformer {
 
   val phaseName = "specializedApplyMethods"
 
-  private[this] var func0Applys: List[Symbol] = _
-  private[this] var func1Applys: List[Symbol] = _
-  private[this] var func2Applys: List[Symbol] = _
+  private[this] var func0Applys: collection.Set[Symbol] = _
+  private[this] var func1Applys: collection.Set[Symbol] = _
+  private[this] var func2Applys: collection.Set[Symbol] = _
   private[this] var func0: Symbol = _
   private[this] var func1: Symbol = _
   private[this] var func2: Symbol = _
@@ -30,25 +30,25 @@ class SpecializedApplyMethods extends MiniPhase with InfoTransformer {
     val definitions = ctx.definitions
     import definitions._
 
-    def specApply(sym: Symbol, args: List[Type], ret: Type)(implicit ctx: Context) = {
+    def specApply(sym: Symbol, args: List[Type], ret: Type)(implicit ctx: Context): Symbol = {
       val name = nme.apply.specializedFunction(ret, args)
       ctx.newSymbol(sym, name, Flags.Method, MethodType(args, ret))
     }
 
     func0 = FunctionClass(0)
-    func0Applys = for (r <- ScalaValueTypes.toList) yield specApply(func0, Nil, r)
+    func0Applys = for (r <- defn.Function0SpecializedReturns) yield specApply(func0, Nil, r)
 
     func1 = FunctionClass(1)
     func1Applys = for {
-      r  <- List(UnitType, BooleanType, IntType, FloatType, LongType, DoubleType)
-      t1 <- List(IntType, LongType, FloatType, DoubleType)
+      r  <- defn.Function1SpecializedReturns
+      t1 <- defn.Function1SpecializedParams
     } yield specApply(func1, List(t1), r)
 
     func2 = FunctionClass(2)
     func2Applys = for {
-      r  <- List(UnitType, BooleanType, IntType, FloatType, LongType, DoubleType)
-      t1 <- List(IntType, LongType, DoubleType)
-      t2 <- List(IntType, LongType, DoubleType)
+      r  <- Function2SpecializedReturns
+      t1 <- Function2SpecializedParams
+      t2 <- Function2SpecializedReturns
     } yield specApply(func2, List(t1, t2), r)
   }