More relative path elimination.

Some names I missed in 55b609458fd .

How one might know when one is done:

  mkdir scratch && cd scratch
  mkdir annotation beans collection compat concurrent io \
    math parallel ref reflect runtime scala sys testing \
    text tools util xml
  scalac $(find ../src/library -name '*.scala')

Until recently that would fail with about a billion errors. When it
compiles, that's when you're done.  And that's where this commit
takes us, for src/library at least.

16 files changed, 43 insertions, 43 deletions

diff --git a/src/compiler/scala/tools/ant/sabbus/Compilers.scala b/src/compiler/scala/tools/ant/sabbus/Compilers.scala
index bb32149a75..7165474345 100644
--- a/src/compiler/scala/tools/ant/sabbus/Compilers.scala
+++ b/src/compiler/scala/tools/ant/sabbus/Compilers.scala
@@ -15,7 +15,7 @@ object Compilers extends scala.collection.DefaultMap[String, Compiler] {
 
   val debug = false
 
-  private val container = new collection.mutable.HashMap[String, Compiler]
+  private val container = new scala.collection.mutable.HashMap[String, Compiler]
 
   def iterator = container.iterator
 
diff --git a/src/compiler/scala/tools/cmd/package.scala b/src/compiler/scala/tools/cmd/package.scala
index 5be98a460a..8c6716be78 100644
--- a/src/compiler/scala/tools/cmd/package.scala
+++ b/src/compiler/scala/tools/cmd/package.scala
@@ -9,8 +9,8 @@ package object cmd {
   def returning[T](x: T)(f: T => Unit): T = { f(x) ; x }
 
   // make some language features in this package compile without warning
-  implicit def implicitConversions = language.implicitConversions
-  implicit def postfixOps = language.postfixOps
+  implicit def implicitConversions = scala.language.implicitConversions
+  implicit def postfixOps = scala.language.postfixOps
 
   private[cmd] def debug(msg: String) = println(msg)
 
diff --git a/src/compiler/scala/tools/nsc/ast/Trees.scala b/src/compiler/scala/tools/nsc/ast/Trees.scala
index ea1b26469b..dec7b648ee 100644
--- a/src/compiler/scala/tools/nsc/ast/Trees.scala
+++ b/src/compiler/scala/tools/nsc/ast/Trees.scala
@@ -281,7 +281,7 @@ trait Trees extends scala.reflect.internal.Trees { self: Global =>
     val trace = scala.tools.nsc.util.trace when debug
 
     val locals = util.HashSet[Symbol](8)
-    val orderedLocals = collection.mutable.ListBuffer[Symbol]()
+    val orderedLocals = scala.collection.mutable.ListBuffer[Symbol]()
     def registerLocal(sym: Symbol) {
       if (sym != null && sym != NoSymbol) {
         if (debug && !(locals contains sym)) orderedLocals append sym
diff --git a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala
index e3755b82d5..eaee39d7e6 100644
--- a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala
+++ b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala
@@ -468,7 +468,7 @@ self =>
 
 /* ------------- ERROR HANDLING ------------------------------------------- */
 
-    var assumedClosingParens = collection.mutable.Map(RPAREN -> 0, RBRACKET -> 0, RBRACE -> 0)
+    var assumedClosingParens = scala.collection.mutable.Map(RPAREN -> 0, RBRACKET -> 0, RBRACE -> 0)
 
     private var inFunReturnType = false
     @inline private def fromWithinReturnType[T](body: => T): T = {
diff --git a/src/compiler/scala/tools/nsc/ast/parser/Scanners.scala b/src/compiler/scala/tools/nsc/ast/parser/Scanners.scala
index dd0f8fdbe0..ba8da3b0ec 100644
--- a/src/compiler/scala/tools/nsc/ast/parser/Scanners.scala
+++ b/src/compiler/scala/tools/nsc/ast/parser/Scanners.scala
@@ -1302,7 +1302,7 @@ trait Scanners extends ScannersCommon {
   }
 
   class ParensAnalyzer(unit: CompilationUnit, patches: List[BracePatch]) extends UnitScanner(unit, patches) {
-    var balance = collection.mutable.Map(RPAREN -> 0, RBRACKET -> 0, RBRACE -> 0)
+    var balance = scala.collection.mutable.Map(RPAREN -> 0, RBRACKET -> 0, RBRACE -> 0)
 
     init()
 
@@ -1317,7 +1317,7 @@ trait Scanners extends ScannersCommon {
       var lineCount = 1
       var lastOffset = 0
       var indent = 0
-      val oldBalance = collection.mutable.Map[Int, Int]()
+      val oldBalance = scala.collection.mutable.Map[Int, Int]()
       def markBalance() = for ((k, v) <- balance) oldBalance(k) = v
       markBalance()
 
diff --git a/src/compiler/scala/tools/nsc/interactive/tests/core/PresentationCompilerRequestsWorkingMode.scala b/src/compiler/scala/tools/nsc/interactive/tests/core/PresentationCompilerRequestsWorkingMode.scala
index 18a8eb5fc3..b5ae5f2d75 100644
--- a/src/compiler/scala/tools/nsc/interactive/tests/core/PresentationCompilerRequestsWorkingMode.scala
+++ b/src/compiler/scala/tools/nsc/interactive/tests/core/PresentationCompilerRequestsWorkingMode.scala
@@ -36,7 +36,7 @@ trait PresentationCompilerRequestsWorkingMode extends TestResources {
 
   /** Return all positions of the given str in the given source file. */
   private def positionsOf(source: SourceFile, str: String): Seq[Position] = {
-    val buf = new collection.mutable.ListBuffer[Position]
+    val buf = new scala.collection.mutable.ListBuffer[Position]
     var pos = source.content.indexOfSlice(str)
     while (pos >= 0) {
       buf += source.position(pos - 1) // we need the position before the first character of this marker
@@ -44,7 +44,7 @@ trait PresentationCompilerRequestsWorkingMode extends TestResources {
     }
     buf.toList
   }
-    
+
   private def withResponse[T](pos: Position, response: Response[T])(f: (Position, T) => Unit) {
     /** Return the filename:line:col version of this position. */
     def showPos(pos: Position): String =
@@ -59,4 +59,4 @@ trait PresentationCompilerRequestsWorkingMode extends TestResources {
         println("ERROR: " + r)
     }
   }
-}
\ No newline at end of file
+}
diff --git a/src/compiler/scala/tools/nsc/interpreter/package.scala b/src/compiler/scala/tools/nsc/interpreter/package.scala
index 89006be8e2..6a3a2a38ae 100644
--- a/src/compiler/scala/tools/nsc/interpreter/package.scala
+++ b/src/compiler/scala/tools/nsc/interpreter/package.scala
@@ -35,7 +35,7 @@ package object interpreter extends ReplConfig with ReplStrings {
 
   val IR = Results
 
-  implicit def postfixOps = language.postfixOps // make all postfix ops in this package compile without warning
+  implicit def postfixOps = scala.language.postfixOps // make all postfix ops in this package compile without warning
 
   private[interpreter] implicit def javaCharSeqCollectionToScala(xs: JCollection[_ <: CharSequence]): List[String] = {
     import scala.collection.JavaConverters._
diff --git a/src/compiler/scala/tools/nsc/io/package.scala b/src/compiler/scala/tools/nsc/io/package.scala
index 6385706830..775ad6bde0 100644
--- a/src/compiler/scala/tools/nsc/io/package.scala
+++ b/src/compiler/scala/tools/nsc/io/package.scala
@@ -11,7 +11,7 @@ import java.util.jar.{ Attributes }
 import scala.language.implicitConversions
 
 package object io {
-  implicit def postfixOps = language.postfixOps // make all postfix ops in this package compile without warning
+  implicit def postfixOps = scala.language.postfixOps // make all postfix ops in this package compile without warning
 
   type JManifest = java.util.jar.Manifest
   type JFile = java.io.File
diff --git a/src/compiler/scala/tools/nsc/transform/TailCalls.scala b/src/compiler/scala/tools/nsc/transform/TailCalls.scala
index b1b930ca2d..0ad6d6c677 100644
--- a/src/compiler/scala/tools/nsc/transform/TailCalls.scala
+++ b/src/compiler/scala/tools/nsc/transform/TailCalls.scala
@@ -90,7 +90,7 @@ abstract class TailCalls extends Transform {
     private val defaultReason = "it contains a recursive call not in tail position"
 
     /** Has the label been accessed? Then its symbol is in this set. */
-    private val accessed = new collection.mutable.HashSet[Symbol]()
+    private val accessed = new scala.collection.mutable.HashSet[Symbol]()
     // `accessed` was stored as boolean in the current context -- this is no longer tenable
     // with jumps to labels in tailpositions now considered in tailposition,
     // a downstream context may access the label, and the upstream one will be none the wiser
@@ -373,7 +373,7 @@ abstract class TailCalls extends Transform {
   // the labels all look like: matchEnd(x) {x}
   // then, in a forward jump `matchEnd(expr)`, `expr` is considered in tail position (and the matchEnd jump is replaced by the jump generated by expr)
   class TailPosLabelsTraverser extends Traverser {
-    val tailLabels = new collection.mutable.HashSet[Symbol]()
+    val tailLabels = new scala.collection.mutable.HashSet[Symbol]()
 
     private var maybeTail: Boolean = true // since we start in the rhs of a DefDef
 
diff --git a/src/compiler/scala/tools/nsc/typechecker/DestructureTypes.scala b/src/compiler/scala/tools/nsc/typechecker/DestructureTypes.scala
index 6a21639391..e8865964b0 100644
--- a/src/compiler/scala/tools/nsc/typechecker/DestructureTypes.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/DestructureTypes.scala
@@ -39,7 +39,7 @@ trait DestructureTypes {
 
     private implicit def liftToTerm(name: String): TermName = newTermName(name)
 
-    private val openSymbols = collection.mutable.Set[Symbol]()
+    private val openSymbols = scala.collection.mutable.Set[Symbol]()
 
     private def nodeList[T](elems: List[T], mkNode: T => Node): Node =
       if (elems.isEmpty) wrapEmpty else list(elems map mkNode)
diff --git a/src/compiler/scala/tools/nsc/typechecker/Infer.scala b/src/compiler/scala/tools/nsc/typechecker/Infer.scala
index 803fb2857e..294470d40e 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Infer.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Infer.scala
@@ -526,8 +526,8 @@ trait Infer {
      *  and the code is not exactly readable.
      */
     object AdjustedTypeArgs {
-      val Result = collection.mutable.LinkedHashMap
-      type Result = collection.mutable.LinkedHashMap[Symbol, Option[Type]]
+      val Result = scala.collection.mutable.LinkedHashMap
+      type Result = scala.collection.mutable.LinkedHashMap[Symbol, Option[Type]]
 
       def unapply(m: Result): Some[(List[Symbol], List[Type])] = Some(toLists(
         (m collect {case (p, Some(a)) => (p, a)}).unzip  ))
diff --git a/src/compiler/scala/tools/nsc/typechecker/Macros.scala b/src/compiler/scala/tools/nsc/typechecker/Macros.scala
index d3580c19ef..9adf86e44b 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Macros.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Macros.scala
@@ -336,7 +336,7 @@ trait Macros extends scala.tools.reflect.FastTrack with Traces {
           val tsym = getMember(MacroContextClass, if (isType) tpnme.WeakTypeTag else tpnme.Expr)
           typeRef(singleType(NoPrefix, ctxParam), tsym, List(sigma(origTpe)))
         }
-      val paramCache = collection.mutable.Map[Symbol, Symbol]()
+      val paramCache = scala.collection.mutable.Map[Symbol, Symbol]()
       def param(tree: Tree): Symbol =
         paramCache.getOrElseUpdate(tree.symbol, {
           val sym = tree.symbol
@@ -827,11 +827,11 @@ trait Macros extends scala.tools.reflect.FastTrack with Traces {
    *    2) undetparams (sym.isTypeParameter && !sym.isSkolem)
    */
   var hasPendingMacroExpansions = false
-  private val delayed = perRunCaches.newWeakMap[Tree, collection.mutable.Set[Int]]
+  private val delayed = perRunCaches.newWeakMap[Tree, scala.collection.mutable.Set[Int]]
   private def isDelayed(expandee: Tree) = delayed contains expandee
   private def calculateUndetparams(expandee: Tree): scala.collection.mutable.Set[Int] =
     delayed.get(expandee).getOrElse {
-      val calculated = collection.mutable.Set[Symbol]()
+      val calculated = scala.collection.mutable.Set[Symbol]()
       expandee foreach (sub => {
         def traverse(sym: Symbol) = if (sym != null && (undetparams contains sym.id)) calculated += sym
         if (sub.symbol != null) traverse(sub.symbol)
diff --git a/src/compiler/scala/tools/nsc/typechecker/PatternMatching.scala b/src/compiler/scala/tools/nsc/typechecker/PatternMatching.scala
index 237d17887d..2dc3dc3dbd 100644
--- a/src/compiler/scala/tools/nsc/typechecker/PatternMatching.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/PatternMatching.scala
@@ -1558,7 +1558,7 @@ trait PatternMatching extends Transform with TypingTransformers with ast.TreeDSL
       var currId = 0
     }
     case class Test(cond: Cond, treeMaker: TreeMaker) {
-      // private val reusedBy = new collection.mutable.HashSet[Test]
+      // private val reusedBy = new scala.collection.mutable.HashSet[Test]
       var reuses: Option[Test] = None
       def registerReuseBy(later: Test): Unit = {
         assert(later.reuses.isEmpty, later.reuses)
@@ -1587,7 +1587,7 @@ trait PatternMatching extends Transform with TypingTransformers with ast.TreeDSL
     case class OrCond(a: Cond, b: Cond)  extends Cond {override def toString = "("+a+") \\/ ("+ b +")"}
 
     object EqualityCond {
-      private val uniques = new collection.mutable.HashMap[(Tree, Tree), EqualityCond]
+      private val uniques = new scala.collection.mutable.HashMap[(Tree, Tree), EqualityCond]
       def apply(testedPath: Tree, rhs: Tree): EqualityCond = uniques getOrElseUpdate((testedPath, rhs), new EqualityCond(testedPath, rhs))
       def unapply(c: EqualityCond) = Some(c.testedPath, c.rhs)
     }
@@ -1596,7 +1596,7 @@ trait PatternMatching extends Transform with TypingTransformers with ast.TreeDSL
     }
 
     object NonNullCond {
-      private val uniques = new collection.mutable.HashMap[Tree, NonNullCond]
+      private val uniques = new scala.collection.mutable.HashMap[Tree, NonNullCond]
       def apply(testedPath: Tree): NonNullCond = uniques getOrElseUpdate(testedPath, new NonNullCond(testedPath))
       def unapply(c: NonNullCond) = Some(c.testedPath)
     }
@@ -1605,7 +1605,7 @@ trait PatternMatching extends Transform with TypingTransformers with ast.TreeDSL
     }
 
     object TypeCond {
-      private val uniques = new collection.mutable.HashMap[(Tree, Type), TypeCond]
+      private val uniques = new scala.collection.mutable.HashMap[(Tree, Type), TypeCond]
       def apply(testedPath: Tree, pt: Type): TypeCond = uniques getOrElseUpdate((testedPath, pt), new TypeCond(testedPath, pt))
       def unapply(c: TypeCond) = Some(c.testedPath, c.pt)
     }
@@ -1654,8 +1654,8 @@ trait PatternMatching extends Transform with TypingTransformers with ast.TreeDSL
     // returns (tree, tests), where `tree` will be used to refer to `root` in `tests`
     class TreeMakersToConds(val root: Symbol) {
       // a variable in this set should never be replaced by a tree that "does not consist of a selection on a variable in this set" (intuitively)
-      private val pointsToBound = collection.mutable.HashSet(root)
-      private val trees         = collection.mutable.HashSet.empty[Tree]
+      private val pointsToBound = scala.collection.mutable.HashSet(root)
+      private val trees         = scala.collection.mutable.HashSet.empty[Tree]
 
       // the substitution that renames variables to variables in pointsToBound
       private var normalize: Substitution  = EmptySubstitution
@@ -1956,7 +1956,7 @@ trait PatternMatching extends Transform with TypingTransformers with ast.TreeDSL
     def removeVarEq(props: List[Prop], modelNull: Boolean = false): (Prop, List[Prop]) = {
       val start = if (Statistics.canEnable) Statistics.startTimer(patmatAnaVarEq) else null
 
-      val vars = new collection.mutable.HashSet[Var]
+      val vars = new scala.collection.mutable.HashSet[Var]
 
       object gatherEqualities extends PropTraverser {
         override def apply(p: Prop) = p match {
@@ -2261,7 +2261,7 @@ trait PatternMatching extends Transform with TypingTransformers with ast.TreeDSL
       def nextId = {_nextId += 1; _nextId}
 
       def resetUniques() = {_nextId = 0; uniques.clear()}
-      private val uniques = new collection.mutable.HashMap[Tree, Var]
+      private val uniques = new scala.collection.mutable.HashMap[Tree, Var]
       def apply(x: Tree): Var = uniques getOrElseUpdate(x, new Var(x, x.tpe))
     }
     class Var(val path: Tree, staticTp: Type) extends AbsVar {
@@ -2273,7 +2273,7 @@ trait PatternMatching extends Transform with TypingTransformers with ast.TreeDSL
       @inline private[this] def observed = {} //canModify = Some(Thread.currentThread.getStackTrace)
 
       // don't access until all potential equalities have been registered using registerEquality
-      private[this] val symForEqualsTo = new collection.mutable.HashMap[Const, Sym]
+      private[this] val symForEqualsTo = new scala.collection.mutable.HashMap[Const, Sym]
 
       // when looking at the domain, we only care about types we can check at run time
       val staticTpCheckable: Type = checkableType(staticTp)
@@ -2386,7 +2386,7 @@ trait PatternMatching extends Transform with TypingTransformers with ast.TreeDSL
  but we can safely pretend types are mutually exclusive as long as there are no counter-examples in the match we're analyzing}
 */
 
-        val excludedPair = new collection.mutable.HashSet[ExcludedPair]
+        val excludedPair = new scala.collection.mutable.HashSet[ExcludedPair]
 
         case class ExcludedPair(a: Const, b: Const) {
           override def equals(o: Any) = o match {
@@ -2440,7 +2440,7 @@ trait PatternMatching extends Transform with TypingTransformers with ast.TreeDSL
       private var _nextValueId = 0
       def nextValueId = {_nextValueId += 1; _nextValueId}
 
-      private val uniques = new collection.mutable.HashMap[Type, Const]
+      private val uniques = new scala.collection.mutable.HashMap[Type, Const]
       private[SymbolicMatchAnalysis] def unique(tp: Type, mkFresh: => Const): Const =
         uniques.get(tp).getOrElse(
           uniques.find {case (oldTp, oldC) => oldTp =:= tp} match {
@@ -2454,7 +2454,7 @@ trait PatternMatching extends Transform with TypingTransformers with ast.TreeDSL
               fresh
           })
 
-      private val trees = collection.mutable.HashSet.empty[Tree]
+      private val trees = scala.collection.mutable.HashSet.empty[Tree]
 
       // hashconsing trees (modulo value-equality)
       private[SymbolicMatchAnalysis] def uniqueTpForTree(t: Tree): Type =
@@ -2915,7 +2915,7 @@ trait PatternMatching extends Transform with TypingTransformers with ast.TreeDSL
           case _ => varAssignment.find{case (v, a) => chop(v.path) == path}.map(_._1)
         }
 
-        private val uniques = new collection.mutable.HashMap[Var, VariableAssignment]
+        private val uniques = new scala.collection.mutable.HashMap[Var, VariableAssignment]
         private def unique(variable: Var): VariableAssignment =
           uniques.getOrElseUpdate(variable, {
             val (eqTo, neqTo) = varAssignment.getOrElse(variable, (Nil, Nil)) // TODO
@@ -3034,8 +3034,8 @@ trait PatternMatching extends Transform with TypingTransformers with ast.TreeDSL
       val testss = approximateMatchConservative(prevBinder, cases)
 
       // interpret:
-      val dependencies = new collection.mutable.LinkedHashMap[Test, Set[Cond]]
-      val tested = new collection.mutable.HashSet[Cond]
+      val dependencies = new scala.collection.mutable.LinkedHashMap[Test, Set[Cond]]
+      val tested = new scala.collection.mutable.HashSet[Cond]
 
       def storeDependencies(test: Test) = {
         val cond = test.cond
@@ -3083,7 +3083,7 @@ trait PatternMatching extends Transform with TypingTransformers with ast.TreeDSL
       // then, collapse these contiguous sequences of reusing tests
       // store the result of the final test and the intermediate results in hoisted mutable variables (TODO: optimize: don't store intermediate results that aren't used)
       // replace each reference to a variable originally bound by a collapsed test by a reference to the hoisted variable
-      val reused = new collection.mutable.HashMap[TreeMaker, ReusedCondTreeMaker]
+      val reused = new scala.collection.mutable.HashMap[TreeMaker, ReusedCondTreeMaker]
       var okToCall = false
       val reusedOrOrig = (tm: TreeMaker) => {assert(okToCall); reused.getOrElse(tm, tm)}
 
@@ -3317,7 +3317,7 @@ trait PatternMatching extends Transform with TypingTransformers with ast.TreeDSL
 
         // requires cases.exists(isGuardedCase) (otherwise the rewrite is pointless)
         var remainingCases = cases
-        val collapsed      = collection.mutable.ListBuffer.empty[CaseDef]
+        val collapsed      = scala.collection.mutable.ListBuffer.empty[CaseDef]
 
         // when some of collapsed cases (except for the default case itself) did not include an un-guarded case
         // we'll need to emit a labeldef for the default case
diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
index 5200aae8d1..2926678281 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
@@ -3413,7 +3413,7 @@ trait Typers extends Modes with Adaptations with Tags {
               else argss.head
             val annScope = annType.decls
                 .filter(sym => sym.isMethod && !sym.isConstructor && sym.isJavaDefined)
-            val names = new collection.mutable.HashSet[Symbol]
+            val names = new scala.collection.mutable.HashSet[Symbol]
             names ++= (if (isJava) annScope.iterator
                        else typedFun.tpe.params.iterator)
             val nvPairs = args map {
@@ -3627,8 +3627,8 @@ trait Typers extends Modes with Adaptations with Tags {
           while (o != owner && o != NoSymbol && !o.hasPackageFlag) o = o.owner
           o == owner && !isVisibleParameter(sym)
         }
-      var localSyms = collection.immutable.Set[Symbol]()
-      var boundSyms = collection.immutable.Set[Symbol]()
+      var localSyms = scala.collection.immutable.Set[Symbol]()
+      var boundSyms = scala.collection.immutable.Set[Symbol]()
       def isLocal(sym: Symbol): Boolean =
         if (sym == NoSymbol || sym.isRefinementClass || sym.isLocalDummy) false
         else if (owner == NoSymbol) tree exists (defines(_, sym))
diff --git a/src/compiler/scala/tools/nsc/util/package.scala b/src/compiler/scala/tools/nsc/util/package.scala
index 876fb18578..780e3eab88 100644
--- a/src/compiler/scala/tools/nsc/util/package.scala
+++ b/src/compiler/scala/tools/nsc/util/package.scala
@@ -9,7 +9,7 @@ import java.io.{ OutputStream, PrintStream, ByteArrayOutputStream, PrintWriter,
 
 package object util {
 
-  implicit def postfixOps = language.postfixOps // make all postfix ops in this package compile without warning
+  implicit def postfixOps = scala.language.postfixOps // make all postfix ops in this package compile without warning
 
   // forwarder for old code that builds against 2.9 and 2.10
   val Chars = scala.reflect.internal.Chars
diff --git a/src/compiler/scala/tools/reflect/ToolBoxFactory.scala b/src/compiler/scala/tools/reflect/ToolBoxFactory.scala
index b671a2eb48..d941519958 100644
--- a/src/compiler/scala/tools/reflect/ToolBoxFactory.scala
+++ b/src/compiler/scala/tools/reflect/ToolBoxFactory.scala
@@ -70,9 +70,9 @@ abstract class ToolBoxFactory[U <: JavaUniverse](val u: U) { factorySelf =>
         }
       }
 
-      def extractFreeTerms(expr0: Tree, wrapFreeTermRefs: Boolean): (Tree, collection.mutable.LinkedHashMap[FreeTermSymbol, TermName]) = {
+      def extractFreeTerms(expr0: Tree, wrapFreeTermRefs: Boolean): (Tree, scala.collection.mutable.LinkedHashMap[FreeTermSymbol, TermName]) = {
         val freeTerms = expr0.freeTerms
-        val freeTermNames = collection.mutable.LinkedHashMap[FreeTermSymbol, TermName]()
+        val freeTermNames = scala.collection.mutable.LinkedHashMap[FreeTermSymbol, TermName]()
         freeTerms foreach (ft => {
           var name = ft.name.toString
           val namesakes = freeTerms takeWhile (_ != ft) filter (ft2 => ft != ft2 && ft.name == ft2.name)