Small optimization

Author: liufengyun

compiler/src/dotty/tools/dotc/Compiler.scala

@@ -69,7 +69,7 @@ class Compiler {
          new CacheAliasImplicits,    // Cache RHS of parameterless alias implicits
          new ByNameClosures,         // Expand arguments to by-name parameters to closures
          new HoistSuperArgs,         // Hoist complex arguments of supercalls to enclosing scope
-         new SpecializedApplyMethods,// Adds specialized methods to FunctionN
+         new SpecializeApplyMethods, // Adds specialized methods to FunctionN
          new RefChecks) ::           // Various checks mostly related to abstract members and overriding
     List(new ElimOpaque,             // Turn opaque into normal aliases
          new TryCatchPatterns,       // Compile cases in try/catch

compiler/src/dotty/tools/dotc/transform/SpecializedApplyMethods.scala renamed to compiler/src/dotty/tools/dotc/transform/SpecializeApplyMethods.scala

@@ -17,10 +17,10 @@ import scala.collection.mutable
  *  can hardcode them. This should, however be removed once we're using a
  *  different standard library.
  */
-class SpecializedApplyMethods extends MiniPhase with InfoTransformer {
+class SpecializeApplyMethods extends MiniPhase with InfoTransformer {
   import ast.tpd._
 
-  val phaseName = "specializedApplyMethods"
+  val phaseName = "specializeApplyMethods"
 
   override def isEnabled(using Context): Boolean =
     !ctx.settings.scalajs.value
@@ -56,6 +56,17 @@ class SpecializedApplyMethods extends MiniPhase with InfoTransformer {
       op(t1, t2, r)
   }
 
+  /** Whether the name is possibly specializable?
+   *
+   *  This is a micro-optimization, as name test is fast and most test would fail.
+   */
+  private def specializableName(name: Name): Boolean =
+    val arity = name.functionArity
+    arity >= 0 && arity < 3
+
+  override def infoMayChange(sym: Symbol)(using Context) =
+    specializableName(sym.name)
+
   /** Add symbols for specialized methods to FunctionN */
   override def transformInfo(tp: Type, sym: Symbol)(using Context) = tp match {
     case tp: ClassInfo if defn.isPlainFunctionClass(sym) =>
@@ -85,7 +96,7 @@ class SpecializedApplyMethods extends MiniPhase with InfoTransformer {
   override def transformTemplate(tree: Template)(using Context) = {
     val cls = tree.symbol.owner.asClass
 
-    if (!defn.isPlainFunctionClass(cls)) return tree
+    if (!specializableName(cls.name) || !defn.isPlainFunctionClass(cls)) return tree
 
     def synthesizeApply(names: collection.Set[TermName]): Tree = {
       val applyBuf = new mutable.ListBuffer[DefDef]