decrease duplication of fresh* function definitions

This commit extracts out freshTermName and freshTypeName to the top-level
with implicit fresh name creator argument. This will let to refactor out
more methods out of tree builder into treegen that are dependent on fresh
name generator. We also save quite a bit of boilerplate by not having to
redefined fresh functions all over the place.

9 files changed, 44 insertions, 67 deletions

diff --git a/src/compiler/scala/tools/nsc/CompilationUnits.scala b/src/compiler/scala/tools/nsc/CompilationUnits.scala
index 59ac123fe6..df5952a4cf 100644
--- a/src/compiler/scala/tools/nsc/CompilationUnits.scala
+++ b/src/compiler/scala/tools/nsc/CompilationUnits.scala
@@ -26,10 +26,9 @@ trait CompilationUnits { global: Global =>
   class CompilationUnit(val source: SourceFile) extends CompilationUnitContextApi { self =>
 
     /** the fresh name creator */
-    val fresh: FreshNameCreator = new FreshNameCreator
-
-    def freshTermName(prefix: String): TermName = newTermName(fresh.newName(prefix))
-    def freshTypeName(prefix: String): TypeName = newTypeName(fresh.newName(prefix))
+    implicit val fresh: FreshNameCreator     = new FreshNameCreator
+    def freshTermName(prefix: String = "x$") = global.freshTermName(prefix)
+    def freshTypeName(prefix: String)        = global.freshTypeName(prefix)
 
     /** the content of the compilation unit in tree form */
     var body: Tree = EmptyTree
diff --git a/src/compiler/scala/tools/nsc/Global.scala b/src/compiler/scala/tools/nsc/Global.scala
index 1cd3e0ec4b..46456093eb 100644
--- a/src/compiler/scala/tools/nsc/Global.scala
+++ b/src/compiler/scala/tools/nsc/Global.scala
@@ -110,9 +110,10 @@ class Global(var currentSettings: Settings, var reporter: Reporter)
   }
 
   /** A spare instance of TreeBuilder left for backwards compatibility. */
-  lazy val treeBuilder: TreeBuilder { val global: Global.this.type } = new UnitTreeBuilder {
+  lazy val treeBuilder: TreeBuilder { val global: Global.this.type } = new TreeBuilder {
     val global: Global.this.type = Global.this;
-    val unit = currentUnit
+    def unit = currentUnit
+    def source = currentUnit.source
   }
 
   /** Fold constants */
diff --git a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala
index 6f5d9f289b..2b6bf657b3 100644
--- a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala
+++ b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala
@@ -40,9 +40,6 @@ trait ParsersCommon extends ScannersCommon { self =>
    */
   abstract class ParserCommon {
     val in: ScannerCommon
-    def freshName(prefix: String): Name
-    def freshTermName(prefix: String): TermName
-    def freshTypeName(prefix: String): TypeName
     def deprecationWarning(off: Int, msg: String): Unit
     def accept(token: Int): Int
 
@@ -163,15 +160,7 @@ self =>
     val in = newScanner()
     in.init()
 
-    private val globalFresh = new FreshNameCreator
-
     def unit = global.currentUnit
-    def freshName(prefix: String): Name = freshTermName(prefix)
-    def freshTermName(prefix: String): TermName = newTermName(globalFresh.newName(prefix))
-    def freshTypeName(prefix: String): TypeName = newTypeName(globalFresh.newName(prefix))
-
-    def o2p(offset: Int): Position = Position.offset(source, offset)
-    def r2p(start: Int, mid: Int, end: Int): Position = rangePos(source, start, mid, end)
 
     // suppress warnings; silent abort on errors
     def warning(offset: Int, msg: String) {}
@@ -224,9 +213,6 @@ self =>
 
     override def newScanner() = new UnitScanner(unit, patches)
 
-    override def freshTermName(prefix: String): TermName = unit.freshTermName(prefix)
-    override def freshTypeName(prefix: String): TypeName = unit.freshTypeName(prefix)
-
     override def warning(offset: Int, msg: String) {
       unit.warning(o2p(offset), msg)
     }
@@ -294,25 +280,26 @@ self =>
 
   abstract class Parser extends ParserCommon { parser =>
     val in: Scanner
-
     def unit: CompilationUnit
-    def freshName(prefix: String): Name
-    def freshTermName(prefix: String): TermName
-    def freshTypeName(prefix: String): TypeName
-    def o2p(offset: Int): Position
-    def r2p(start: Int, mid: Int, end: Int): Position
-    def r2p(start: Int, mid: Int): Position = r2p(start, mid, in.lastOffset max start)
-    def r2p(offset: Int): Position = r2p(offset, offset)
-
-    /** whether a non-continuable syntax error has been seen */
-    private var lastErrorOffset : Int = -1
+    def source: SourceFile
 
-    class ParserTreeBuilder extends UnitTreeBuilder {
+    class ParserTreeBuilder extends TreeBuilder {
       val global: self.global.type = self.global
       def unit = parser.unit
+      def source = parser.source
     }
     val treeBuilder = new ParserTreeBuilder
-    import treeBuilder.{global => _, unit => _, _}
+    import treeBuilder.{global => _, unit => _, source => _, fresh => _, _}
+
+    implicit def fresh: FreshNameCreator = unit.fresh
+
+    def o2p(offset: Int): Position                    = Position.offset(source, offset)
+    def r2p(start: Int, mid: Int, end: Int): Position = rangePos(source, start, mid, end)
+    def r2p(start: Int, mid: Int): Position           = r2p(start, mid, in.lastOffset max start)
+    def r2p(offset: Int): Position                    = r2p(offset, offset)
+
+    /** whether a non-continuable syntax error has been seen */
+    private var lastErrorOffset : Int = -1
 
     /** The types of the context bounds of type parameters of the surrounding class
      */
@@ -1162,7 +1149,7 @@ self =>
     /** Consume a USCORE and create a fresh synthetic placeholder param. */
     private def freshPlaceholder(): Tree = {
       val start = in.offset
-      val pname = freshName("x$")
+      val pname = freshTermName()
       in.nextToken()
       val id = atPos(start)(Ident(pname))
       val param = atPos(id.pos.focus)(gen.mkSyntheticParam(pname.toTermName))
@@ -2247,7 +2234,7 @@ self =>
           }
         }
         val nameOffset = in.offset
-        // TODO AM: freshName(o2p(in.skipToken()), "_$$"), will need to update test suite
+        // TODO AM: freshTermName(o2p(in.skipToken()), "_$$"), will need to update test suite
         val pname: TypeName = wildcardOrIdent().toTypeName
         val param = atPos(start, nameOffset) {
           val tparams = typeParamClauseOpt(pname, null) // @M TODO null --> no higher-order context bounds for now
@@ -2459,7 +2446,6 @@ self =>
           EmptyTree
         }
       def mkDefs(p: Tree, tp: Tree, rhs: Tree): List[Tree] = {
-        //Console.println("DEBUG: p = "+p.toString()); // DEBUG
         val trees =
           makePatDef(newmods,
                      if (tp.isEmpty) p
diff --git a/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala b/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala
index 59abf99844..28d5aefc2b 100644
--- a/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala
+++ b/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala
@@ -8,24 +8,21 @@ package ast.parser
 
 import symtab.Flags._
 import scala.collection.mutable.ListBuffer
-import scala.reflect.internal.util.Position
+import scala.reflect.internal.util.{Position, SourceFile, FreshNameCreator}
 
 /** Methods for building trees, used in the parser.  All the trees
  *  returned by this class must be untyped.
  */
 abstract class TreeBuilder {
-
   val global: Global
   import global._
 
-  def freshName(): Name = freshName("x$")
-  def freshTermName(): TermName = freshTermName("x$")
+  def unit: CompilationUnit
+  def source: SourceFile
 
-  def freshName(prefix: String): Name
-  def freshTermName(prefix: String): TermName
-  def freshTypeName(prefix: String): TypeName
-  def o2p(offset: Int): Position
-  def r2p(start: Int, point: Int, end: Int): Position
+  implicit def fresh: FreshNameCreator              = unit.fresh
+  def o2p(offset: Int): Position                    = Position.offset(source, offset)
+  def r2p(start: Int, mid: Int, end: Int): Position = rangePos(source, start, mid, end)
 
   def rootScalaDot(name: Name) = gen.rootScalaDot(name)
   def scalaDot(name: Name)     = gen.scalaDot(name)
@@ -325,7 +322,7 @@ abstract class TreeBuilder {
     /* If `pat` is not yet a `Bind` wrap it in one with a fresh name */
     def makeBind(pat: Tree): Tree = pat match {
       case Bind(_, _) => pat
-      case _ => Bind(freshName(), pat) setPos pat.pos
+      case _ => Bind(freshTermName(), pat) setPos pat.pos
     }
 
     /* A reference to the name bound in Bind `pat`. */
@@ -416,7 +413,7 @@ abstract class TreeBuilder {
    *    }
    */
   def makeCatchFromExpr(catchExpr: Tree): CaseDef = {
-    val binder   = freshTermName("x")
+    val binder   = freshTermName()
     val pat      = Bind(binder, Typed(Ident(nme.WILDCARD), Ident(tpnme.Throwable)))
     val catchDef = ValDef(Modifiers(ARTIFACT), freshTermName("catchExpr"), TypeTree(), catchExpr)
     val catchFn  = Ident(catchDef.name)
@@ -520,13 +517,3 @@ abstract class TreeBuilder {
     }
   }
 }
-
-abstract class UnitTreeBuilder extends TreeBuilder {
-  import global._
-  def unit: CompilationUnit
-  def freshName(prefix: String): Name               = freshTermName(prefix)
-  def freshTermName(prefix: String): TermName       = unit.freshTermName(prefix)
-  def freshTypeName(prefix: String): TypeName       = unit.freshTypeName(prefix)
-  def o2p(offset: Int): Position                    = Position.offset(unit.source, offset)
-  def r2p(start: Int, mid: Int, end: Int): Position = rangePos(unit.source, start, mid, end)
-}
diff --git a/src/compiler/scala/tools/nsc/typechecker/NamesDefaults.scala b/src/compiler/scala/tools/nsc/typechecker/NamesDefaults.scala
index dea4c46e79..03aad71165 100644
--- a/src/compiler/scala/tools/nsc/typechecker/NamesDefaults.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/NamesDefaults.scala
@@ -289,7 +289,7 @@ trait NamesDefaults { self: Analyzer =>
               arg.tpe
             }
           ).widen // have to widen or types inferred from literal defaults will be singletons
-          val s = context.owner.newValue(unit.freshTermName("x$"), arg.pos, newFlags = ARTIFACT) setInfo {
+          val s = context.owner.newValue(unit.freshTermName(), arg.pos, newFlags = ARTIFACT) setInfo {
             val tp = if (byName) functionType(Nil, argTpe) else argTpe
             uncheckedBounds(tp)
           }
diff --git a/src/compiler/scala/tools/nsc/typechecker/PatternTypers.scala b/src/compiler/scala/tools/nsc/typechecker/PatternTypers.scala
index f3e8ac64f4..f69b8a9697 100644
--- a/src/compiler/scala/tools/nsc/typechecker/PatternTypers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/PatternTypers.scala
@@ -281,7 +281,7 @@ trait PatternTypers {
             else TypeBounds.lower(tpSym.tpeHK)
           )
           // origin must be the type param so we can deskolemize
-          val skolem = context.owner.newGADTSkolem(unit.freshTypeName("?"+tpSym.name), tpSym, bounds)
+          val skolem = context.owner.newGADTSkolem(unit.freshTypeName("?" + tpSym.name), tpSym, bounds)
           skolemBuffer += skolem
           logResult(s"Created gadt skolem $skolem: ${skolem.tpe_*} to stand in for $tpSym")(skolem.tpe_*)
         case tp1 => tp1
diff --git a/src/compiler/scala/tools/reflect/quasiquotes/Parsers.scala b/src/compiler/scala/tools/reflect/quasiquotes/Parsers.scala
index bd85aa9cdc..983978db7e 100644
--- a/src/compiler/scala/tools/reflect/quasiquotes/Parsers.scala
+++ b/src/compiler/scala/tools/reflect/quasiquotes/Parsers.scala
@@ -4,7 +4,7 @@ package quasiquotes
 import scala.tools.nsc.ast.parser.{Parsers => ScalaParser}
 import scala.tools.nsc.ast.parser.Tokens._
 import scala.compat.Platform.EOL
-import scala.reflect.internal.util.{BatchSourceFile, SourceFile}
+import scala.reflect.internal.util.{BatchSourceFile, SourceFile, FreshNameCreator}
 import scala.collection.mutable.ListBuffer
 import scala.util.Try
 
@@ -55,12 +55,12 @@ trait Parsers { self: Quasiquotes =>
 
       def isHole(name: Name): Boolean = holeMap.contains(name)
 
-      override def freshTermName(prefix: String): TermName = unit.freshTermName(nme.QUASIQUOTE_PREFIX + prefix)
-      override def freshTypeName(prefix: String): TypeName = unit.freshTypeName(nme.QUASIQUOTE_PREFIX + prefix)
+      override implicit def fresh = new FreshNameCreator {
+        override def newName(prefix: String) = super.newName(nme.QUASIQUOTE_PREFIX + prefix)
+      }
 
       override val treeBuilder = new ParserTreeBuilder {
-        override def freshTermName(prefix: String): TermName = parser.freshTermName(prefix)
-        override def freshTypeName(prefix: String): TypeName = parser.freshTypeName(prefix)
+        override implicit def fresh = parser.fresh
 
         // q"(..$xs)"
         override def makeTupleTerm(trees: List[Tree], flattenUnary: Boolean): Tree =
diff --git a/src/reflect/scala/reflect/internal/BuildUtils.scala b/src/reflect/scala/reflect/internal/BuildUtils.scala
index 39dfe60ecf..46119ae802 100644
--- a/src/reflect/scala/reflect/internal/BuildUtils.scala
+++ b/src/reflect/scala/reflect/internal/BuildUtils.scala
@@ -131,11 +131,11 @@ trait BuildUtils { self: SymbolTable =>
 
     def RefTree(qual: Tree, sym: Symbol) = self.RefTree(qual, sym.name) setSymbol sym
 
-    def withFreshTermName[T](prefix: String)(f: TermName => T): T = f(TermName(freshNameCreator.newName(prefix)))
+    def withFreshTermName[T](prefix: String)(f: TermName => T): T = f(freshTermName(prefix))
 
-    def withFreshTypeName[T](prefix: String)(f: TypeName => T): T = f(TypeName(freshNameCreator.newName(prefix)))
+    def withFreshTypeName[T](prefix: String)(f: TypeName => T): T = f(freshTypeName(prefix))
 
-    private val freshNameCreator = new util.FreshNameCreator
+    private implicit val fresh = new FreshNameCreator
 
     object FlagsRepr extends FlagsReprExtractor {
       def apply(bits: Long): FlagSet = bits
diff --git a/src/reflect/scala/reflect/internal/SymbolTable.scala b/src/reflect/scala/reflect/internal/SymbolTable.scala
index a6f9dfc164..0e9c866ace 100644
--- a/src/reflect/scala/reflect/internal/SymbolTable.scala
+++ b/src/reflect/scala/reflect/internal/SymbolTable.scala
@@ -370,6 +370,10 @@ abstract class SymbolTable extends macros.Universe
    * Adds the `sm` String interpolator to a [[scala.StringContext]].
    */
   implicit val StringContextStripMarginOps: StringContext => StringContextStripMarginOps = util.StringContextStripMarginOps
+
+  // fresh name creation
+  def freshTermName(prefix: String = "x$")(implicit creator: FreshNameCreator): TermName = newTermName(creator.newName(prefix))
+  def freshTypeName(prefix: String)(implicit creator: FreshNameCreator): TypeName        = newTypeName(creator.newName(prefix))
 }
 
 object SymbolTableStats {