Fast specialization

We avoid going through InfoTransformer, which will cause all symbols to be checked.
The reason why it works is that the specialized base classes, i.e. Function0-2
already have all the relevant definitions.

Author: liufengyun

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

@@ -11,88 +11,41 @@ import scala.collection.mutable
 /** Specializes classes that inherit from `FunctionN` where there exists a
  *  specialized form.
  */
-class SpecializeFunctions extends MiniPhase with InfoTransformer {
+class SpecializeFunctions extends MiniPhase {
   import ast.tpd._
   val phaseName = "specializeFunctions"
   override def runsAfter = Set(ElimByName.name)
 
   override def isEnabled(using Context): Boolean =
     !ctx.settings.scalajs.value
 
-  override def infoMayChange(sym: Symbol)(using Context): Boolean =
-    !sym.is(Flags.Package) && sym.isClass && sym.isDefinedInCurrentRun
-
-  /** Transforms the type to include decls for specialized applys  */
-  override def transformInfo(tp: Type, sym: Symbol)(using Context) = tp match {
-    case tp: ClassInfo =>
-      val apply = tp.decls.lookup(nme.apply)
-      if (!apply.exists) return tp
-
-      var newApplys: List[Symbol] = Nil
-
-      var arity = 0
-      while (arity < 3) {
-        val func = defn.SpecializableFunctions(arity)
-        if (sym != func && sym.derivesFrom(func)) {
-          val baseType   = tp.cls.typeRef.baseType(func)
-          val paramTypes = baseType.argInfos
-          val argTypes   = paramTypes.init
-          val retType    = paramTypes.last
-
-          val isSpecializable = defn.isSpecializableFunction(sym.asClass, argTypes, retType)
-          if (!isSpecializable) return tp
-
-          val apply = baseType.member(nme.apply)
-          val overrideApply = tp.decls.find {  sym =>
-            sym.is(Flags.Method, butNot = Flags.Deferred) && sym.name == nme.apply && sym.info.matches(apply.info)
-          }
-
-          if (overrideApply.exists) {
-            val specializedMethodName: Name = nme.apply.specializedFunction(retType, argTypes)
-            val applySpecialized = newSymbol(
-              sym,
-              specializedMethodName,
-              overrideApply.flags | Flags.Synthetic,
-              overrideApply.info
-            )
-
-            newApplys ::= applySpecialized
-          }
-        }
-        arity += 1
-      }
-
-      if (newApplys.isEmpty) tp
-      else {
-        val scope = tp.decls.cloneScope
-        newApplys.toList.foreach { sym => scope.enter(sym) }
-        tp.derivedClassInfo(decls = scope)
-      }
-
-    case _ => tp
-  }
-
   /** Create forwarders from the generic applys to the specialized ones.
    */
   override def transformDefDef(ddef: DefDef)(using Context) = {
     val sym = ddef.symbol
 
     if ddef.name != nme.apply
+       || sym.is(Flags.Deferred)
        || ddef.vparamss.length != 1
        || ddef.vparamss.head.length > 2
        || !sym.owner.isClass
-       || !derivesFromFn012(sym.owner.asClass)
     then
       return ddef
 
     val cls = sym.owner.asClass
     val paramTypes = ddef.vparamss.head.map(_.symbol.info)
-    val retType = ddef.tpe.widen.finalResultType
-
+    val retType = sym.info.finalResultType
     val specName = nme.apply.specializedFunction(retType, paramTypes)
-    val specializedApply = cls.asClass.info.decls.lookup(specName)
 
-    if (!specializedApply.exists) return ddef
+    val isSpecializable = defn.isSpecializableFunction(cls, paramTypes, retType)
+    if (!isSpecializable || cls.info.decls.lookup(specName).exists) return ddef
+
+    val specializedApply = newSymbol(
+        cls,
+        specName,
+        sym.flags | Flags.Synthetic,
+        sym.info
+      ).entered
 
     val specializedDecl =
       DefDef(specializedApply.asTerm, vparamss => {