Specialize String ++ Name -> Name operation

Avoid doing the concatenation in a separate string

Author: odersky

compiler/src/dotty/tools/dotc/ast/tpd.scala

@@ -1172,8 +1172,8 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
 
   // convert a numeric with a toXXX method
   def primitiveConversion(tree: Tree, numericCls: Symbol)(using Context): Tree = {
-    val mname      = ("to" + numericCls.name).toTermName
-    val conversion = tree.tpe member mname
+    val mname      = "to".concat(numericCls.name)
+    val conversion = tree.tpe member(mname)
     if (conversion.symbol.exists)
       tree.select(conversion.symbol.termRef).ensureApplied
     else if (tree.tpe.widen isRef numericCls)

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

@@ -918,7 +918,12 @@ object Contexts {
     private[Contexts] val comparers = new mutable.ArrayBuffer[TypeComparer]
     private[Contexts] var comparersInUse: Int = 0
 
-    private[dotc] var nameCharBuffer = new Array[Char](256)
+    private var charArray = new Array[Char](256)
+
+    def sharedCharArray(len: Int): Array[Char] =
+      while len > charArray.length do
+        charArray = new Array[Char](charArray.length * 2)
+      charArray
 
     def reset(): Unit = {
       for ((_, set) <- uniqueSets) set.clear()

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

@@ -39,16 +39,25 @@ object Decorators {
      *  This avoids some allocation relative to `termName(s)`
      */
     def sliceToTermName(start: Int, end: Int)(using Context): SimpleName =
-      val base = ctx.base
       val len = end - start
-      while len > base.nameCharBuffer.length do
-        base.nameCharBuffer = new Array[Char](base.nameCharBuffer.length * 2)
-      s.getChars(start, end, base.nameCharBuffer, 0)
-      termName(base.nameCharBuffer, 0, len)
+      val chars = ctx.base.sharedCharArray(len)
+      s.getChars(start, end, chars, 0)
+      termName(chars, 0, len)
 
     def sliceToTypeName(start: Int, end: Int)(using Context): TypeName =
       sliceToTermName(start, end).toTypeName
 
+    def concat(name: Name)(using Context): SimpleName = name match
+      case name: SimpleName =>
+        val len = s.length + name.length
+        var chars = ctx.base.sharedCharArray(len)
+        s.getChars(0, s.length, chars, 0)
+        if name.length != 0 then name.getChars(0, name.length, chars, s.length)
+        termName(chars, 0, len)
+      case name: TypeName => s.concat(name.toTermName)
+      case _ => termName(s.concat(name.toString))
+  end extension
+
   /** Implements a findSymbol method on iterators of Symbols that
    *  works like find but avoids Option, replacing None with NoSymbol.
    */

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

@@ -8,6 +8,7 @@ import scala.internal.Chars
 import Chars.isOperatorPart
 import Definitions._
 import nme._
+import Decorators.concat
 
 object NameOps {
 
@@ -138,7 +139,7 @@ object NameOps {
       case _ => false
 
     /** Add an `extension_` in front of this name */
-    def toExtensionName = termName("extension_" ++ name.toString)
+    def toExtensionName(using Context): SimpleName = "extension_".concat(name)
 
     /** Drop `extension_` in front of this name, if it has this prefix */
     def dropExtension = name match

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

@@ -337,6 +337,13 @@ object Names {
     def head: Char = apply(0)
     def last: Char = apply(length - 1)
 
+    /** Copy character slice (from until end) to character array starting at `dstStart`.
+     *  @pre Destination must have enough space to hold all characters of this name.
+     */
+    def getChars(from: Int, end: Int, dst: Array[Char], dstStart: Int): Unit =
+      assert(0 <= from && from <= end && end <= length)
+      Array.copy(chrs, start + from, dst, dstStart, end - from)
+
     override def asSimpleName: SimpleName = this
     override def toSimpleName: SimpleName = this
     override final def mangle: SimpleName = encode

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

@@ -47,7 +47,7 @@ trait Deriving {
      *  @param  reportErrors  Report an error if an instance with the same name exists already
      */
     private def addDerivedInstance(clsName: Name, info: Type, pos: SrcPos): Unit = {
-      val instanceName = s"derived$$$clsName".toTermName
+      val instanceName = "derived$".concat(clsName)
       if (ctx.denotNamed(instanceName).exists)
         report.error(i"duplicate type class derivation for $clsName", pos)
       else

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

@@ -137,7 +137,7 @@ object ProtoTypes {
   extends CachedProxyType with ProtoType with ValueTypeOrProto {
 
     private var myExtensionName: TermName = null
-    def extensionName: TermName =
+    def extensionName(using Context): TermName =
       if myExtensionName == null then myExtensionName = name.toExtensionName
       myExtensionName