Optimize access of function symbols

Author: liufengyun

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

@@ -1149,7 +1149,13 @@ class Definitions {
       else funType(n)
     ).symbol.asClass
 
-  @tu lazy val Function0_apply: Symbol = FunctionClass(0).requiredMethod(nme.apply)
+  @tu lazy val Function0_apply: Symbol = Function0.requiredMethod(nme.apply)
+
+  @tu lazy val Function0: Symbol = FunctionClass(0)
+  @tu lazy val Function1: Symbol = FunctionClass(1)
+  @tu lazy val Function2: Symbol = FunctionClass(2)
+
+  @tu lazy val SpecializableFunctions: IArray[Symbol] = IArray(Function0, Function1, Function2)
 
   def FunctionType(n: Int, isContextual: Boolean = false, isErased: Boolean = false)(using Context): TypeRef =
     FunctionClass(n, isContextual && !ctx.erasedTypes, isErased).typeRef

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

@@ -162,7 +162,7 @@ class ExpandSAMs extends MiniPhase {
         cpy.Block(tree)(pfDef :: Nil, New(pfSym.typeRef, Nil))
 
       case _ =>
-        val found = tpe.baseType(defn.FunctionClass(1))
+        val found = tpe.baseType(defn.Function1)
         report.error(TypeMismatch(found, tpe), tree.srcPos)
         tree
     }

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

@@ -32,7 +32,7 @@ class SpecializeFunctions extends MiniPhase with InfoTransformer {
 
       var arity = 0
       while (arity < 3) {
-        val func = defn.FunctionClass(arity)
+        val func = defn.SpecializableFunctions(arity)
         if (sym != func && sym.derivesFrom(func)) {
           val baseType   = tp.cls.typeRef.baseType(func)
           val paramTypes = baseType.argInfos
@@ -149,8 +149,8 @@ class SpecializeFunctions extends MiniPhase with InfoTransformer {
       case _ => tree
     }
 
-  private def derivesFromFn012(sym: Symbol)(using Context): Boolean =
-    sym.derivesFrom(defn.FunctionClass(0)) ||
-      sym.derivesFrom(defn.FunctionClass(1)) ||
-      sym.derivesFrom(defn.FunctionClass(2))
+  private def derivesFromFn012(cls: ClassSymbol)(using Context): Boolean =
+    cls.baseClasses.exists { p =>
+      p == defn.Function0 || p == defn.Function1 || p == defn.Function2
+    }
 }

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

@@ -47,7 +47,7 @@ abstract class TransformByNameApply extends MiniPhase { thisPhase: DenotTransfor
             ref(defn.cbnArg).appliedToType(argType).appliedTo(arg).withSpan(arg.span)
           arg match {
             case Apply(Select(qual, nme.apply), Nil)
-            if qual.tpe.derivesFrom(defn.FunctionClass(0)) && (isPureExpr(qual) || qual.symbol.isAllOf(Inline | Param)) =>
+            if qual.tpe.derivesFrom(defn.Function0) && (isPureExpr(qual) || qual.symbol.isAllOf(Inline | Param)) =>
               wrap(qual)
             case _ =>
               if (isByNameRef(arg) || arg.symbol == defn.cbnArg) arg

compiler/src/dotty/tools/dotc/typer/Implicits.scala

@@ -172,7 +172,7 @@ object Implicits:
               // We keep the old behavior under -source 3.0-migration.
               val isFunctionInS2 =
                 migrateTo3
-                && tpw.derivesFrom(defn.FunctionClass(1))
+                && tpw.derivesFrom(defn.Function1)
                 && ref.symbol != defn.Predef_conforms
               val isImplicitConversion = tpw.derivesFrom(defn.ConversionClass)
               // An implementation of <:< counts as a view