Performance tweeak

- Fix typo

- Use StringBuilder instead of StringBuffer (thanks @smarter)

StringBuffer is synchronized thus is slower.

Author: liufengyun

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

@@ -85,7 +85,7 @@ class Compiler {
          new SeqLiterals,            // Express vararg arguments as arrays
          new InterceptedMethods,     // Special handling of `==`, `|=`, `getClass` methods
          new Getters,                // Replace non-private vals and vars with getter defs (fields are added later)
-        //  new SpecializeFunctions,    // Specialized Function{0,1,2} by replacing super with specialized super
+         new SpecializeFunctions,    // Specialized Function{0,1,2} by replacing super with specialized super
          new LiftTry,                // Put try expressions that might execute on non-empty stacks into their own methods
          new CollectNullableFields,  // Collect fields that can be nulled out after use in lazy initialization
          new ElimOuterSelect,        // Expand outer selections

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

@@ -1184,13 +1184,6 @@ class Definitions {
 
   def isBottomClassAfterErasure(cls: Symbol): Boolean = cls == NothingClass || cls == NullClass
 
-  def isBottomType(tp: Type): Boolean =
-    if (ctx.explicitNulls && !ctx.phase.erasedTypes) tp.derivesFrom(NothingClass)
-    else isBottomTypeAfterErasure(tp)
-
-  def isBottomTypeAfterErasure(tp: Type): Boolean =
-    tp.derivesFrom(NothingClass) || tp.derivesFrom(NullClass)
-
   /** Is any function class where
    *   - FunctionXXL
    *   - FunctionN for N >= 0
@@ -1455,7 +1448,7 @@ class Definitions {
     for
       r  <- Function2SpecializedReturnTypes
       t1 <- Function2SpecializedParamTypes
-      t2 <- Function2SpecializedReturnTypes
+      t2 <- Function2SpecializedParamTypes
     yield
       nme.apply.specializedFunction(r, List(t1, t2)).asTermName
 

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

@@ -298,9 +298,14 @@ object NameOps {
      *  `<return type><first type><second type><...>`
      */
     def specializedFunction(ret: Type, args: List[Type])(using Context): Name =
-      name ++ nme.specializedTypeNames.prefix ++
-      nme.specializedTypeNames.separator ++ defn.typeTag(ret) ++
-      args.map(defn.typeTag).fold(nme.EMPTY)(_ ++ _) ++ nme.specializedTypeNames.suffix
+      val sb = new StringBuilder
+      sb.append(name.toString)
+      sb.append(nme.specializedTypeNames.prefix.toString)
+      sb.append(nme.specializedTypeNames.separator)
+      sb.append(defn.typeTag(ret).toString)
+      args.foreach { arg => sb.append(defn.typeTag(arg)) }
+      sb.append(nme.specializedTypeNames.suffix)
+      termName(sb.toString)
 
     /** If name length exceeds allowable limit, replace part of it by hash */
     def compactified(using Context): TermName = termName(compactify(name.toString))

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

@@ -34,24 +34,24 @@ class SpecializeApplyMethods extends MiniPhase with InfoTransformer {
     atNextPhase(newSymbol(sym, name, Flags.Method, MethodType(args, ret)))
   }
 
-  private def specFun0(op: Type => Unit)(using Context): Unit = {
+  private inline def specFun0(inline op: Type => Unit)(using Context): Unit = {
     for (r <- defn.Function0SpecializedReturnTypes) do
       op(r)
   }
 
-  private def specFun1(op: (Type, Type) => Unit)(using Context): Unit = {
+  private inline def specFun1(inline op: (Type, Type) => Unit)(using Context): Unit = {
     for
       r  <- defn.Function1SpecializedReturnTypes
       t1 <- defn.Function1SpecializedParamTypes
     do
       op(t1, r)
   }
 
-  private def specFun2(op: (Type, Type, Type) => Unit)(using Context): Unit = {
+  private inline def specFun2(inline op: (Type, Type, Type) => Unit)(using Context): Unit = {
     for
       r  <- defn.Function2SpecializedReturnTypes
       t1 <- defn.Function2SpecializedParamTypes
-      t2 <- defn.Function2SpecializedReturnTypes
+      t2 <- defn.Function2SpecializedParamTypes
     do
       op(t1, t2, r)
   }
@@ -63,30 +63,29 @@ class SpecializeApplyMethods extends MiniPhase with InfoTransformer {
 
   /** Add symbols for specialized methods to FunctionN */
   override def transformInfo(tp: Type, sym: Symbol)(using Context) = tp match {
-    // case tp: ClassInfo =>
-    //   if sym == defn.SpecializableFunctions(0) then
-    //       val scope = tp.decls.cloneScope
-    //       specFun0 { r => scope.enter(specApplySymbol(sym, Nil, r)) }
-    //       tp.derivedClassInfo(decls = scope)
+    case tp: ClassInfo =>
+      if sym == defn.SpecializableFunctions(0) then
+          val scope = tp.decls.cloneScope
+          specFun0 { r => scope.enter(specApplySymbol(sym, Nil, r)) }
+          tp.derivedClassInfo(decls = scope)
 
-    //   else if sym == defn.SpecializableFunctions(1) then
-    //       val scope = tp.decls.cloneScope
-    //       specFun1 { (t1, r) => scope.enter(specApplySymbol(sym, List(t1), r)) }
-    //       tp.derivedClassInfo(decls = scope)
+      else if sym == defn.SpecializableFunctions(1) then
+          val scope = tp.decls.cloneScope
+          specFun1 { (t1, r) => scope.enter(specApplySymbol(sym, t1 :: Nil, r)) }
+          tp.derivedClassInfo(decls = scope)
 
-    //   else if sym == defn.SpecializableFunctions(2) then
-    //       val scope = tp.decls.cloneScope
-    //       specFun2 { (t1, t2, r) => scope.enter(specApplySymbol(sym, List(t1, t2), r)) }
-    //       tp.derivedClassInfo(decls = scope)
+      else if sym == defn.SpecializableFunctions(2) then
+          val scope = tp.decls.cloneScope
+          specFun2 { (t1, t2, r) => scope.enter(specApplySymbol(sym, t1 :: t2 :: Nil, r)) }
+          tp.derivedClassInfo(decls = scope)
 
-    //   else tp
+      else tp
 
     case _ => tp
   }
 
   /** Create bridge methods for FunctionN with specialized applys */
-  // override def transformTemplate(tree: Template)(using Context) = {
-  def transformTemplate1(tree: Template)(using Context) = {
+  override def transformTemplate(tree: Template)(using Context) = {
     val cls = tree.symbol.owner.asClass
 
     def synthesizeApply(names: collection.Set[TermName]): Tree = {