Improve performance by avoiding needless Name => String => Name conversion

Author: retronym

src/main/scala/scala/async/internal/AnfTransform.scala

@@ -163,13 +163,13 @@ private[async] trait AnfTransform {
           }
         }
 
-        def defineVar(prefix: String, tp: Type, pos: Position): ValDef = {
+        def defineVar(prefix: TermName, tp: Type, pos: Position): ValDef = {
           val sym = api.currentOwner.newTermSymbol(name.fresh(prefix), pos, MUTABLE | SYNTHETIC).setInfo(uncheckedBounds(tp))
           valDef(sym, mkZero(uncheckedBounds(tp))).setType(NoType).setPos(pos)
         }
       }
 
-      def defineVal(prefix: String, lhs: Tree, pos: Position): ValDef = {
+      def defineVal(prefix: TermName, lhs: Tree, pos: Position): ValDef = {
         val sym = api.currentOwner.newTermSymbol(name.fresh(prefix), pos, SYNTHETIC).setInfo(uncheckedBounds(lhs.tpe))
         internal.valDef(sym, internal.changeOwner(lhs, api.currentOwner, sym)).setType(NoType).setPos(pos)
       }

src/main/scala/scala/async/internal/TransformUtils.scala

@@ -32,18 +32,18 @@ private[async] trait TransformUtils {
   }
 
   object name {
-    def matchRes      = maybeFresh(baseNames.matchRes)
-    def ifRes         = maybeFresh(baseNames.ifRes) 
-    def bindSuffix    = maybeFresh(baseNames.bindSuffix)
-    def completed     = maybeFresh(baseNames.completed) 
+    val matchRes      = newTermName(baseNames.matchRes)
+    val ifRes         = newTermName(baseNames.ifRes)
+    def bindSuffix    = baseNames.bindSuffix
+    def completed     = baseNames.completed
 
     val state         = maybeFresh(baseNames.state)
     val result        = baseNames.result
     val execContext   = maybeFresh(baseNames.execContext)
     val tr            = maybeFresh(baseNames.tr)
     val t             = maybeFresh(baseNames.t)
 
-    val await = "await"
+    val await = newTermName("await")
     val resume = newTermName("resume")
     val apply = newTermName("apply")
     val stateMachine  = newTermName(fresh("stateMachine"))
@@ -162,10 +162,10 @@ private[async] trait TransformUtils {
       (i, j) => util.Try(byNamess(i)(j)).getOrElse(false)
     }
   }
-  private def argName(fun: Tree): ((Int, Int) => String) = {
+  private def argName(fun: Tree): ((Int, Int) => TermName) = {
     val paramss = fun.tpe.paramss
-    val namess = paramss.map(_.map(_.name.toString))
-    (i, j) => util.Try(namess(i)(j)).getOrElse(s"arg_${i}_${j}")
+    val namess = paramss.map(_.map(_.name.toTermName))
+    (i, j) => util.Try(namess(i)(j)).getOrElse(TermName(s"arg_${i}_${j}"))
   }
 
   object defn {
@@ -246,7 +246,7 @@ private[async] trait TransformUtils {
     }
   }
 
-  case class Arg(expr: Tree, isByName: Boolean, argName: String)
+  case class Arg(expr: Tree, isByName: Boolean, argName: TermName)
 
   /**
    * Transform a list of argument lists, producing the transformed lists, and lists of auxillary
@@ -261,7 +261,7 @@ private[async] trait TransformUtils {
    */
   def mapArgumentss[A](fun: Tree, argss: List[List[Tree]])(f: Arg => (A, Tree)): (List[List[A]], List[List[Tree]]) = {
     val isByNamess: (Int, Int) => Boolean = isByName(fun)
-    val argNamess: (Int, Int) => String = argName(fun)
+    val argNamess: (Int, Int) => TermName = argName(fun)
     argss.zipWithIndex.map { case (args, i) =>
       mapArguments[A](args) {
         (tree, j) => f(Arg(tree, isByNamess(i, j), argNamess(i, j)))