Stable names for lambda lifted method and fresh names

Fresh names are created using a FreshNameCreator, which appends
an increasing number to the given prefix.

```
scala> val fresh = new scala.reflect.internal.util.FreshNameCreator()
fresh: scala.reflect.internal.util.FreshNameCreator = scala.reflect.internal.util.FreshNameCreator@42b84286

scala> List("foo$", "bar$", "foo$").map(fresh.newName(_))
res1: List[String] = List(foo$1, bar$1, foo$2)
```

Each compilation unit had its own fresh name creator, which is used
in the regular compiler. Macros and quasiquotes make use of a global
creator (at least, as of #3401).

Both of these are too broadly scoped to help achieve deterministic
fresh names: if sources are recompiled in a different order or separately
recompiled, the fresh name counters can be different. Methods in a given
compilation unit are not necessarily typechecked in a linear fashion;
they might be typechecked ahead of time to provide an inferred type
to a caller.

This commit:

  - Changes all known fresh name creations within the typer phase (in which
    out-of-order typechecking is a factor) to use a fineer grained fresh
    name creator. How fine grained? A fresh name generated as some position
    `p` shares the fresh name generator scoped at the closest method or
    class that encloses that the outermost enclosing tree at the same
    position. This definition is designed to give a shared fresh name
    creator for all fresh names generated in `macro1(macro2())`, even if
    the fresh names are requiested from with a Typer in the macro enclosed
    by a synthetic method.
  - Changes macro fresh names to use the same fresh naming scheme as the regular
    typechecker. An opt-out compiler option allows the old behaviour, but I'm
    interested to find real-world cases where the new scheme actually causes
    a problem

In addition, a small change is made to lambda lift to lift local methods in the
order that they are encountered during traversal, rather than sorting them
based on `Symbol.isLess` (which include `Symbol.id`, an order-of-typechecking
dependent value).

Author: retronym

src/compiler/scala/reflect/macros/contexts/Names.scala

@@ -6,7 +6,7 @@ trait Names {
 
   import global._
 
-  def freshNameCreator = globalFreshNameCreator
+  def freshNameCreator = self.callsiteTyper.fresh
 
   def fresh(): String =
     freshName()

src/compiler/scala/reflect/macros/contexts/Parsers.scala

@@ -1,6 +1,7 @@
 package scala.reflect.macros
 package contexts
 
+import scala.reflect.internal.util.FreshNameCreator
 import scala.tools.nsc.reporters.StoreReporter
 
 trait Parsers {
@@ -12,7 +13,9 @@ trait Parsers {
     val oldReporter = global.reporter
     try {
       global.reporter = sreporter
-      val parser = newUnitParser(new CompilationUnit(newSourceFile(code, "<macro>")))
+      val parser = newUnitParser(new CompilationUnit(newSourceFile(code, "<macro>")) {
+        override implicit val fresh: FreshNameCreator = currentFreshNameCreator
+      })
       val tree = gen.mkTreeOrBlock(parser.parseStatsOrPackages())
       sreporter.infos.foreach {
         case sreporter.Info(pos, msg, sreporter.ERROR) => throw ParseException(pos, msg)

src/compiler/scala/reflect/reify/utils/Extractors.scala

@@ -72,7 +72,7 @@ trait Extractors {
     }
     val tpec = ClassDef(
       Modifiers(FINAL),
-      newTypeName(global.currentUnit.fresh.newName(flavor.toString)),
+      newTypeName(currentFreshNameCreator.newName(flavor.toString)),
       List(),
       Template(List(Ident(reifierBase)),
       noSelfType,

src/compiler/scala/reflect/reify/utils/SymbolTables.scala

@@ -77,7 +77,7 @@ trait SymbolTables {
         var name = name0.toString
         name = name.replace(".type", "$type")
         name = name.replace(" ", "$")
-        val fresh = typer.context.unit.fresh
+        val fresh = typer.fresh
         newTermName(fresh.newName(name))
       }
       val bindingAttachment = reification.attachments.get[ReifyBindingAttachment].get

src/compiler/scala/tools/nsc/Global.scala

@@ -10,12 +10,13 @@ package nsc
 import java.io.{File, FileNotFoundException, IOException}
 import java.net.URL
 import java.nio.charset.{Charset, CharsetDecoder, IllegalCharsetNameException, UnsupportedCharsetException}
+
 import scala.collection.{immutable, mutable}
 import io.{AbstractFile, Path, SourceReader}
 import reporters.Reporter
 import util.{ClassPath, returning}
 import scala.reflect.ClassTag
-import scala.reflect.internal.util.{BatchSourceFile, NoSourceFile, ScalaClassLoader, ScriptSourceFile, SourceFile, StatisticsStatics}
+import scala.reflect.internal.util.{BatchSourceFile, FreshNameCreator, NoSourceFile, ScalaClassLoader, ScriptSourceFile, SourceFile, StatisticsStatics}
 import scala.reflect.internal.pickling.PickleBuffer
 import symtab.{Flags, SymbolTable, SymbolTrackers}
 import symtab.classfile.Pickler
@@ -26,7 +27,7 @@ import typechecker._
 import transform.patmat.PatternMatching
 import transform._
 import backend.{JavaPlatform, ScalaPrimitives}
-import backend.jvm.{GenBCode, BackendStats}
+import backend.jvm.{BackendStats, GenBCode}
 import scala.concurrent.Future
 import scala.language.postfixOps
 import scala.tools.nsc.ast.{TreeGen => AstTreeGen}
@@ -965,7 +966,9 @@ class Global(var currentSettings: Settings, reporter0: Reporter)
   def currentRun: Run              = curRun
   def currentUnit: CompilationUnit = if (currentRun eq null) NoCompilationUnit else currentRun.currentUnit
   def currentSource: SourceFile    = if (currentUnit.exists) currentUnit.source else lastSeenSourceFile
-  def currentFreshNameCreator      = currentUnit.fresh
+  def currentFreshNameCreator      = if (curFreshNameCreator == null) currentUnit.fresh else curFreshNameCreator
+  private[this] var curFreshNameCreator: FreshNameCreator = null
+  private[scala] def currentFreshNameCreator_=(fresh: FreshNameCreator): Unit = curFreshNameCreator = fresh
 
   def isGlobalInitialized = (
        definitions.isDefinitionsInitialized

src/compiler/scala/tools/nsc/ast/TreeGen.scala

@@ -9,6 +9,7 @@ package ast
 import scala.collection.mutable.ListBuffer
 import symtab.Flags._
 import scala.language.postfixOps
+import scala.reflect.internal.util.FreshNameCreator
 
 /** XXX to resolve: TreeGen only assumes global is a SymbolTable, but
  *  TreeDSL at the moment expects a Global.  Can we get by with SymbolTable?
@@ -191,20 +192,24 @@ abstract class TreeGen extends scala.reflect.internal.TreeGen with TreeDSL {
 
   /** Used in situations where you need to access value of an expression several times
    */
-  def evalOnce(expr: Tree, owner: Symbol, unit: CompilationUnit)(within: (() => Tree) => Tree): Tree = {
+  def evalOnce(expr: Tree, owner: Symbol, unit: CompilationUnit)(within: (() => Tree) => Tree): Tree = evalOnce(expr, owner, unit.fresh)(within)
+  def evalOnce(expr: Tree, owner: Symbol, fresh: FreshNameCreator)(within: (() => Tree) => Tree): Tree = {
     var used = false
     if (treeInfo.isExprSafeToInline(expr)) {
       within(() => if (used) expr.duplicate else { used = true; expr })
     }
     else {
-      val (valDef, identFn) = mkPackedValDef(expr, owner, unit.freshTermName("ev$"))
+      val (valDef, identFn) = mkPackedValDef(expr, owner, freshTermName("ev$")(fresh))
       val containing = within(identFn)
       ensureNonOverlapping(containing, List(expr))
       Block(List(valDef), containing) setPos (containing.pos union expr.pos)
     }
   }
 
-  def evalOnceAll(exprs: List[Tree], owner: Symbol, unit: CompilationUnit)(within: (List[() => Tree]) => Tree): Tree = {
+  def evalOnceAll(exprs: List[Tree], owner: Symbol, unit: CompilationUnit)(within: (List[() => Tree]) => Tree): Tree =
+    evalOnceAll(exprs, owner, unit.fresh)(within)
+
+  def evalOnceAll(exprs: List[Tree], owner: Symbol, fresh: FreshNameCreator)(within: (List[() => Tree]) => Tree): Tree = {
     val vdefs = new ListBuffer[ValDef]
     val exprs1 = new ListBuffer[() => Tree]
     val used = new Array[Boolean](exprs.length)
@@ -217,7 +222,7 @@ abstract class TreeGen extends scala.reflect.internal.TreeGen with TreeDSL {
         }
       }
       else {
-        val (valDef, identFn) = mkPackedValDef(expr, owner, unit.freshTermName("ev$"))
+        val (valDef, identFn) = mkPackedValDef(expr, owner, freshTermName("ev$")(fresh))
         vdefs += valDef
         exprs1 += identFn
       }

src/compiler/scala/tools/nsc/settings/ScalaSettings.scala

@@ -218,6 +218,7 @@ trait ScalaSettings extends AbsScalaSettings
   val Yreifycopypaste = BooleanSetting    ("-Yreify-copypaste", "Dump the reified trees in copypasteable representation.")
   val Ymacroexpand    = ChoiceSetting     ("-Ymacro-expand", "policy", "Control expansion of macros, useful for scaladoc and presentation compiler.", List(MacroExpand.Normal, MacroExpand.None, MacroExpand.Discard), MacroExpand.Normal)
   val Ymacronoexpand  = BooleanSetting    ("-Ymacro-no-expand", "Don't expand macros. Might be useful for scaladoc and presentation compiler, but will crash anything which uses macros and gets past typer.") withDeprecationMessage(s"Use ${Ymacroexpand.name}:${MacroExpand.None}") withPostSetHook(_ => Ymacroexpand.value = MacroExpand.None)
+  val YmacroFresh     = BooleanSetting    ("-Ymacro-global-fresh-names", "Should fresh names in macros be unique across all compilation units")
   val YmacroAnnotations = BooleanSetting  ("-Ymacro-annotations", "Enable support for macro annotations, formerly in macro paradise.")
   val Yreplclassbased = BooleanSetting    ("-Yrepl-class-based", "Use classes to wrap REPL snippets instead of objects")
   val Yreploutdir     = StringSetting     ("-Yrepl-outdir", "path", "Write repl-generated classfiles to given output directory (use \"\" to generate a temporary dir)" , "")

src/compiler/scala/tools/nsc/transform/CleanUp.scala

@@ -186,7 +186,7 @@ abstract class CleanUp extends Statics with Transform with ast.TreeDSL {
           val runDefinitions = currentRun.runDefinitions
           import runDefinitions._
 
-          gen.evalOnce(qual, currentOwner, unit) { qual1 =>
+          gen.evalOnce(qual, currentOwner, localTyper.fresh) { qual1 =>
             /* Some info about the type of the method being called. */
             val methSym       = ad.symbol
             val boxedResType  = toBoxedType(resType)      // Int -> Integer

src/compiler/scala/tools/nsc/transform/Erasure.scala

@@ -682,7 +682,7 @@ abstract class Erasure extends InfoTransform
             else {
               val untyped =
 //                util.trace("new asinstanceof test") {
-                  gen.evalOnce(qual1, context.owner, context.unit) { qual =>
+                  gen.evalOnce(qual1, context.owner, fresh) { qual =>
                     If(Apply(Select(qual(), nme.eq), List(Literal(Constant(null)) setType NullTpe)),
                        Literal(Constant(null)) setType targ.tpe,
                        unbox(qual(), targ.tpe))
@@ -1044,7 +1044,7 @@ abstract class Erasure extends InfoTransform
                 case SingletonInstanceCheck(cmpOp, cmpArg) =>
                   atPos(tree.pos) { Apply(Select(cmpArg, cmpOp), List(qual)) }
                 case RefinedType(parents, decls) if (parents.length >= 2) =>
-                  gen.evalOnce(qual, currentOwner, unit) { q =>
+                  gen.evalOnce(qual, currentOwner, localTyper.fresh) { q =>
                     // Optimization: don't generate isInstanceOf tests if the static type
                     // conforms, because it always succeeds.  (Or at least it had better.)
                     // At this writing the pattern matcher generates some instance tests
@@ -1097,7 +1097,7 @@ abstract class Erasure extends InfoTransform
 
             global.typer.typedPos(tree.pos) {
               if (level == 1) isArrayTest(qual)
-              else gen.evalOnce(qual, currentOwner, unit) { qual1 =>
+              else gen.evalOnce(qual, currentOwner, localTyper.fresh) { qual1 =>
                 gen.mkAnd(
                   gen.mkMethodCall(
                     qual1(),

src/compiler/scala/tools/nsc/transform/LambdaLift.scala

@@ -9,7 +9,7 @@ package transform
 import symtab._
 import Flags._
 import scala.collection.mutable
-import scala.collection.mutable.{ LinkedHashMap, LinkedHashSet, TreeSet }
+import scala.collection.mutable.{ LinkedHashMap, LinkedHashSet }
 
 abstract class LambdaLift extends InfoTransform {
   import global._
@@ -50,7 +50,7 @@ abstract class LambdaLift extends InfoTransform {
 
   class LambdaLifter(unit: CompilationUnit) extends explicitOuter.OuterPathTransformer(unit) {
 
-    private type SymSet = TreeSet[Symbol]
+    private type SymSet = LinkedHashSet[Symbol]
 
     /** A map storing free variables of functions and classes */
     private val free = new LinkedHashMap[Symbol, SymSet]
@@ -64,8 +64,7 @@ abstract class LambdaLift extends InfoTransform {
     /** Symbols that are called from an inner class. */
     private val calledFromInner = new LinkedHashSet[Symbol]
 
-    private val ord = Ordering.fromLessThan[Symbol](_ isLess _)
-    private def newSymSet = TreeSet.empty[Symbol](ord)
+    private def newSymSet: LinkedHashSet[Symbol] = new LinkedHashSet[Symbol]
 
     private def symSet(f: LinkedHashMap[Symbol, SymSet], sym: Symbol): SymSet =
       f.getOrElseUpdate(sym, newSymSet)