Required changes to build with new collection library

- Source code changes in all modules required for publish-core

- Adapt all JUnit tests to the new library

- Use a scaladoc stub when building in publish-core so we can build a
  compiler that satisfies sbt’s compiler interface but doesn’t require
  scala-xml to bootstrap

project/ScriptCommands.scala

@@ -19,7 +19,10 @@ object ScriptCommands {
     * The optional argument is the Artifactory snapshot repository URL. */
   def setupPublishCore = setup("setupPublishCore") { args =>
     Seq(
-      baseVersionSuffix in Global := "SHA-SNAPSHOT"
+      baseVersionSuffix in Global := "SHA-SNAPSHOT",
+      // Don't build scaladoc before bootstrapping because it requires scala-xml
+      sourceDirectory in Compile in LocalProject("scaladoc") := (baseDirectory in LocalProject("scaladoc")).value / ".." / "scaladoc-stub",
+      unmanagedSourceDirectories in Compile in LocalProject("scaladoc") := Seq((sourceDirectory in Compile in LocalProject("scaladoc")).value)
     ) ++ (args match {
       case Seq(url) => publishTarget(url)
       case Nil => Nil

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

@@ -48,14 +48,14 @@ trait SymbolTables {
 
     def +(sym: Symbol, name: TermName, reification: Tree): SymbolTable = add(sym, name, reification)
     def +(symDef: Tree): SymbolTable = add(symDef)
-    def ++(symDefs: TraversableOnce[Tree]): SymbolTable = (this /: symDefs)((symtab, symDef) => symtab.add(symDef))
+    def ++(symDefs: IterableOnce[Tree]): SymbolTable = (this /: symDefs)((symtab, symDef) => symtab.add(symDef))
     def ++(symtab: SymbolTable): SymbolTable = { val updated = this ++ symtab.symtab.values; new SymbolTable(updated.symtab, updated.aliases ++ symtab.aliases) }
     def -(sym: Symbol): SymbolTable = remove(sym)
     def -(name: TermName): SymbolTable = remove(name)
     def -(symDef: Tree): SymbolTable = remove(reifyBinding(symDef).symbol)
-    def --(syms: GenTraversableOnce[Symbol]): SymbolTable = (this /: syms)((symtab, sym) => symtab.remove(sym))
-    def --(names: Iterable[TermName]): SymbolTable = (this /: names)((symtab, name) => symtab.remove(name))
-    def --(symDefs: TraversableOnce[Tree]): SymbolTable = this -- (symDefs map (reifyBinding(_)))
+    def --(syms: IterableOnce[Symbol]): SymbolTable = (this /: syms)((symtab, sym) => symtab.remove(sym))
+    def --(names: List[TermName]): SymbolTable = (this /: names)((symtab, name) => symtab.remove(name))
+    def --(symDefs: Iterable[Tree]): SymbolTable = this -- (symDefs map (reifyBinding(_)))
     def --(symtab: SymbolTable): SymbolTable = { val updated = this -- symtab.symtab.values; new SymbolTable(updated.symtab, updated.aliases diff symtab.aliases) }
     def filterSyms(p: Symbol => Boolean): SymbolTable = this -- (syms filterNot p)
     def filterAliases(p: (Symbol, TermName) => Boolean): SymbolTable = this -- (aliases filterNot (tuple => p(tuple._1, tuple._2)) map (_._2))

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

@@ -872,7 +872,7 @@ class Global(var currentSettings: Settings, reporter0: Reporter)
           invalidated, failed)
       }
     }
-    def show(msg: String, syms: scala.collection.Traversable[Symbol]) =
+    def show(msg: String, syms: scala.collection.Iterable[Symbol]) =
       if (syms.nonEmpty)
         informProgress(s"$msg: ${syms map (_.fullName) mkString ","}")
     show("invalidated packages", invalidated)
@@ -1197,7 +1197,7 @@ class Global(var currentSettings: Settings, reporter0: Reporter)
         def isRange(s: String) = s.forall(c => c.isDigit || c == '-')
         def isSpecial(s: String) = (s == "all" || isRange(s))
         val setting = new ss.PhasesSetting("fake","fake")
-        for (p <- specs.flatten.to[Set]) {
+        for (p <- specs.flatten.to(Set)) {
           setting.value = List(p)
           val count = (
             if (including) first.iterator count (setting containsPhase _)

src/compiler/scala/tools/nsc/ast/parser/SymbolicXMLBuilder.scala

@@ -100,7 +100,7 @@ abstract class SymbolicXMLBuilder(p: Parsers#Parser, preserveWS: Boolean) {
     attrs: Tree,
     scope: Tree,
     empty: Boolean,
-    children: Seq[Tree]): Tree =
+    children: scala.collection.Seq[Tree]): Tree =
   {
     def starArgs =
       if (children.isEmpty) Nil
@@ -138,7 +138,7 @@ abstract class SymbolicXMLBuilder(p: Parsers#Parser, preserveWS: Boolean) {
   protected def ProcInstr(target: Tree, txt: Tree)  = New(_scala_xml_ProcInstr, LL(target, txt))
 
   /** @todo: attributes */
-  def makeXMLpat(pos: Position, n: String, args: Seq[Tree]): Tree = {
+  def makeXMLpat(pos: Position, n: String, args: scala.collection.Seq[Tree]): Tree = {
     val (prepat, labpat) = splitPrefix(n) match {
       case (Some(pre), rest)  => (const(pre), const(rest))
       case _                  => (wild, const(n))
@@ -150,7 +150,7 @@ abstract class SymbolicXMLBuilder(p: Parsers#Parser, preserveWS: Boolean) {
     case _: Literal => makeTextPat(t)
     case _          => t
   }
-  protected def convertToTextPat(buf: Seq[Tree]): List[Tree] =
+  protected def convertToTextPat(buf: scala.collection.Seq[Tree]): List[Tree] =
     (buf map convertToTextPat).toList
 
   def parseAttribute(pos: Position, s: String): Tree = {
@@ -169,7 +169,7 @@ abstract class SymbolicXMLBuilder(p: Parsers#Parser, preserveWS: Boolean) {
   }
 
   /** could optimize if args.length == 0, args.length == 1 AND args(0) is <: Node. */
-  def makeXMLseq(pos: Position, args: Seq[Tree]) = {
+  def makeXMLseq(pos: Position, args: scala.collection.Seq[Tree]) = {
     val buffer = ValDef(NoMods, _buf, TypeTree(), New(_scala_xml_NodeBuffer, ListOfNil))
     val applies = args filterNot isEmptyText map (t => Apply(Select(Ident(_buf), _plus), List(t)))
 
@@ -183,13 +183,13 @@ abstract class SymbolicXMLBuilder(p: Parsers#Parser, preserveWS: Boolean) {
   }
 
   /** Various node constructions. */
-  def group(pos: Position, args: Seq[Tree]): Tree =
+  def group(pos: Position, args: scala.collection.Seq[Tree]): Tree =
     atPos(pos)( New(_scala_xml_Group, LL(makeXMLseq(pos, args))) )
 
   def unparsed(pos: Position, str: String): Tree =
     atPos(pos)( New(_scala_xml_Unparsed, LL(const(str))) )
 
-  def element(pos: Position, qname: String, attrMap: mutable.Map[String, Tree], empty: Boolean, args: Seq[Tree]): Tree = {
+  def element(pos: Position, qname: String, attrMap: mutable.Map[String, Tree], empty: Boolean, args: scala.collection.Seq[Tree]): Tree = {
     def handleNamespaceBinding(pre: String, z: String): Tree = {
       def mkAssign(t: Tree): Tree = Assign(
         Ident(_tmpscope),

src/compiler/scala/tools/nsc/ast/parser/xml/MarkupParserCommon.scala

@@ -149,7 +149,7 @@ private[scala] trait MarkupParserCommon {
     if (ch == that) nextch()
     else xHandleError(that, "'%s' expected instead of '%s'".format(that, ch))
   }
-  def xToken(that: Seq[Char]) { that foreach xToken }
+  def xToken(that: Iterable[Char]) { that foreach xToken }
 
   /** scan [S] '=' [S]*/
   def xEQ() = { xSpaceOpt(); xToken('='); xSpaceOpt() }

src/compiler/scala/tools/nsc/backend/jvm/BTypesFromClassfile.scala

@@ -97,9 +97,9 @@ abstract class BTypesFromClassfile {
       })
     }
 
-    def nestedClasses: List[ClassBType] = classNode.innerClasses.asScala.collect({
+    def nestedClasses: List[ClassBType] = classNode.innerClasses.asScala.iterator.collect({
       case i if nestedInCurrentClass(i) => classBTypeFromParsedClassfile(i.name)
-    })(collection.breakOut)
+    }).toList
 
     // if classNode is a nested class, it has an innerClass attribute for itself. in this
     // case we build the NestedInfo.
@@ -120,7 +120,7 @@ abstract class BTypesFromClassfile {
 
     val inlineInfo = inlineInfoFromClassfile(classNode)
 
-    val interfaces: List[ClassBType] = classNode.interfaces.asScala.map(classBTypeFromParsedClassfile)(collection.breakOut)
+    val interfaces: List[ClassBType] = classNode.interfaces.asScala.iterator.map(classBTypeFromParsedClassfile).toList
 
     Right(ClassInfo(superClass, interfaces, flags, Lazy.withoutLock(nestedClasses), Lazy.withoutLock(nestedInfo), inlineInfo))
   }
@@ -147,13 +147,13 @@ abstract class BTypesFromClassfile {
       // require special handling. Excluding is OK because they are never inlined.
       // Here we are parsing from a classfile and we don't need to do anything special. Many of these
       // primitives don't even exist, for example Any.isInstanceOf.
-      val methodInfos:Map[String,MethodInlineInfo] = classNode.methods.asScala.map(methodNode => {
+      val methodInfos:Map[String,MethodInlineInfo] = classNode.methods.asScala.iterator.map(methodNode => {
         val info = MethodInlineInfo(
           effectivelyFinal                    = BytecodeUtils.isFinalMethod(methodNode),
           annotatedInline                     = false,
           annotatedNoInline                   = false)
         (methodNode.name + methodNode.desc, info)
-      })(scala.collection.breakOut)
+      }).toMap
       InlineInfo(
         isEffectivelyFinal = BytecodeUtils.isFinalClass(classNode),
         sam = inlinerHeuristics.javaSam(classNode.name),

src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala

@@ -243,14 +243,14 @@ abstract class BTypesFromSymbols[G <: Global](val global: G) extends BTypes {
    *
    * Specialized classes are always considered top-level, see comment in BTypes.
    */
-  private def memberClassesForInnerClassTable(classSymbol: Symbol): List[Symbol] = classSymbol.info.decls.collect({
+  private def memberClassesForInnerClassTable(classSymbol: Symbol): List[Symbol] = List.from(classSymbol.info.decls.iterator.collect({
     case sym if sym.isClass && !considerAsTopLevelImplementationArtifact(sym) =>
       sym
     case sym if sym.isModule && !considerAsTopLevelImplementationArtifact(sym) =>
       val r = exitingPickler(sym.moduleClass)
       assert(r != NoSymbol, sym.fullLocationString)
       r
-  })(collection.breakOut)
+  }))
 
   private def computeClassInfo(classSym: Symbol, classBType: ClassBType): Right[Nothing, ClassInfo] = {
     /**
@@ -561,7 +561,7 @@ abstract class BTypesFromSymbols[G <: Global](val global: G) extends BTypes {
 
     // Primitive methods cannot be inlined, so there's no point in building a MethodInlineInfo. Also, some
     // primitive methods (e.g., `isInstanceOf`) have non-erased types, which confuses [[typeToBType]].
-    val methodInlineInfos = methods.flatMap({
+    val methodInlineInfos = Map.from(methods.iterator.flatMap({
       case methodSym =>
         if (completeSilentlyAndCheckErroneous(methodSym)) {
           // Happens due to scala/bug#9111. Just don't provide any MethodInlineInfo for that method, we don't need fail the compiler.
@@ -603,7 +603,7 @@ abstract class BTypesFromSymbols[G <: Global](val global: G) extends BTypes {
           } else
             (signature, info) :: Nil
         }
-    }).toMap
+    }))
 
     InlineInfo(isEffectivelyFinal, sam, methodInlineInfos, warning)
   }

src/compiler/scala/tools/nsc/backend/jvm/ClassfileWriters.scala

@@ -71,9 +71,9 @@ abstract class ClassfileWriters {
       val basicClassWriter = settings.outputDirs.getSingleOutput match {
         case Some(dest) => singleWriter(dest)
         case None =>
-          val distinctOutputs: Set[AbstractFile] = settings.outputDirs.outputs.map(_._2)(scala.collection.breakOut)
+          val distinctOutputs: Set[AbstractFile] = settings.outputDirs.outputs.iterator.map(_._2).toSet
           if (distinctOutputs.size == 1) singleWriter(distinctOutputs.head)
-          else new MultiClassWriter(distinctOutputs.map { output: AbstractFile => output -> singleWriter(output) }(scala.collection.breakOut))
+          else new MultiClassWriter(distinctOutputs.iterator.map { output: AbstractFile => output -> singleWriter(output) }.toMap)
       }
 
       val withAdditionalFormats = if (settings.Ygenasmp.valueSetByUser.isEmpty && settings.Ydumpclasses.valueSetByUser.isEmpty) basicClassWriter else {

src/compiler/scala/tools/nsc/backend/jvm/CoreBTypes.scala

@@ -221,11 +221,11 @@ abstract class CoreBTypesFromSymbols[G <: Global] extends CoreBTypes {
   }
 
   private def srBoxesRuntimeMethods(getName: (String, String) => String): Map[BType, MethodNameAndType] = {
-    ScalaValueClassesNoUnit.map(primitive => {
+    Map.from(ScalaValueClassesNoUnit.iterator.map(primitive => {
       val bType = primitiveTypeToBType(primitive)
       val name = newTermName(getName(primitive.name.toString, boxedClass(primitive).name.toString))
       (bType, methodNameAndType(BoxesRunTimeClass, name))
-    })(collection.breakOut)
+    }))
   }
 
   // Z -> MethodNameAndType(boxToBoolean,(Z)Ljava/lang/Boolean;)
@@ -244,29 +244,29 @@ abstract class CoreBTypesFromSymbols[G <: Global] extends CoreBTypes {
   // java/lang/Boolean -> MethodNameAndType(valueOf,(Z)Ljava/lang/Boolean;)
   def javaBoxMethods: Map[InternalName, MethodNameAndType] = _javaBoxMethods.get
   private[this] lazy val _javaBoxMethods: LazyVar[Map[InternalName, MethodNameAndType]] = runLazy {
-    ScalaValueClassesNoUnit.map(primitive => {
+    Map.from(ScalaValueClassesNoUnit.iterator.map(primitive => {
       val boxed = boxedClass(primitive)
       val method = methodNameAndType(boxed, newTermName("valueOf"), static = true, filterOverload = singleParamOfClass(primitive))
       (classBTypeFromSymbol(boxed).internalName, method)
-    })(collection.breakOut)
+    }))
   }
 
   // java/lang/Boolean -> MethodNameAndType(booleanValue,()Z)
   def javaUnboxMethods: Map[InternalName, MethodNameAndType] = _javaUnboxMethods.get
   private[this] lazy val _javaUnboxMethods: LazyVar[Map[InternalName, MethodNameAndType]] = runLazy {
-    ScalaValueClassesNoUnit.map(primitive => {
+    Map.from(ScalaValueClassesNoUnit.iterator.map(primitive => {
       val boxed = boxedClass(primitive)
       val name = primitive.name.toString.toLowerCase + "Value"
       (classBTypeFromSymbol(boxed).internalName, methodNameAndType(boxed, newTermName(name)))
-    })(collection.breakOut)
+    }))
   }
 
   private def predefBoxingMethods(getName: (String, String) => String): Map[String, MethodBType] = {
-    ScalaValueClassesNoUnit.map(primitive => {
+    Map.from(ScalaValueClassesNoUnit.iterator.map(primitive => {
       val boxed = boxedClass(primitive)
       val name = getName(primitive.name.toString, boxed.name.toString)
       (name, methodNameAndType(PredefModule.moduleClass, newTermName(name)).methodType)
-    })(collection.breakOut)
+    }))
   }
 
   // boolean2Boolean -> (Z)Ljava/lang/Boolean;
@@ -278,8 +278,8 @@ abstract class CoreBTypesFromSymbols[G <: Global] extends CoreBTypes {
   private[this] lazy val _predefAutoUnboxMethods: LazyVar[Map[String, MethodBType]] = runLazy(predefBoxingMethods((primitive, boxed) => boxed + "2" + primitive.toLowerCase))
 
   private def staticRefMethods(name: Name): Map[InternalName, MethodNameAndType] = {
-    allRefClasses.map(refClass =>
-      (classBTypeFromSymbol(refClass).internalName, methodNameAndType(refClass, name, static = true)))(collection.breakOut)
+    Map.from(allRefClasses.iterator.map(refClass =>
+      (classBTypeFromSymbol(refClass).internalName, methodNameAndType(refClass, name, static = true))))
   }
 
   // scala/runtime/BooleanRef -> MethodNameAndType(create,(Z)Lscala/runtime/BooleanRef;)
@@ -293,14 +293,14 @@ abstract class CoreBTypesFromSymbols[G <: Global] extends CoreBTypes {
   // java/lang/Boolean -> MethodNameAndType(<init>,(Z)V)
   def primitiveBoxConstructors: Map[InternalName, MethodNameAndType] = _primitiveBoxConstructors.get
   private[this] lazy val _primitiveBoxConstructors: LazyVar[Map[InternalName, MethodNameAndType]] = runLazy {
-    ScalaValueClassesNoUnit.map(primitive => {
+    Map.from(ScalaValueClassesNoUnit.iterator.map(primitive => {
       val boxed = boxedClass(primitive)
       (classBTypeFromSymbol(boxed).internalName, methodNameAndType(boxed, nme.CONSTRUCTOR, filterOverload = singleParamOfClass(primitive)))
-    })(collection.breakOut)
+    }))
   }
 
   private def nonOverloadedConstructors(classes: Iterable[Symbol]): Map[InternalName, MethodNameAndType] = {
-    classes.map(cls => (classBTypeFromSymbol(cls).internalName, methodNameAndType(cls, nme.CONSTRUCTOR)))(collection.breakOut)
+    Map.from(classes.iterator.map(cls => (classBTypeFromSymbol(cls).internalName, methodNameAndType(cls, nme.CONSTRUCTOR))))
   }
 
   // scala/runtime/BooleanRef -> MethodNameAndType(<init>,(Z)V)

src/compiler/scala/tools/nsc/backend/jvm/PostProcessorFrontendAccess.scala

@@ -250,9 +250,9 @@ object PostProcessorFrontendAccess {
     def getEntryPoints: List[String] = frontendSynch(cleanup.getEntryPoints)
 
     def javaDefinedClasses: Set[InternalName] = frontendSynch {
-      currentRun.symSource.keys.collect{
+      currentRun.symSource.keys.iterator.collect{
         case sym if sym.isJavaDefined => sym.javaBinaryNameString
-      }(scala.collection.breakOut)
+      }.toSet
     }
 
 

src/compiler/scala/tools/nsc/backend/jvm/analysis/ProdConsAnalyzerImpl.scala

@@ -78,7 +78,7 @@ trait ProdConsAnalyzerImpl {
    * This is the counterpart of `producersForValueAt`.
    */
   def consumersOfValueAt(insn: AbstractInsnNode, slot: Int): Set[AbstractInsnNode] = {
-    producersForValueAt(insn, slot).flatMap(prod => {
+    producersForValueAt(insn, slot).flatMap[AbstractInsnNode](prod => {
       val outputNumber = outputValueSlots(prod).indexOf(slot)
       _consumersOfOutputsFrom.get(prod).map(v => {
         v(outputNumber)
@@ -98,7 +98,7 @@ trait ProdConsAnalyzerImpl {
     case ParameterProducer(local)                      => consumersOfValueAt(methodNode.instructions.getFirst, local)
     case ExceptionProducer(handlerLabel, handlerFrame) => consumersOfValueAt(handlerLabel, handlerFrame.stackTop)
     case _ =>
-      _consumersOfOutputsFrom.get(insn).map(v => v.indices.flatMap(v.apply)(collection.breakOut): Set[AbstractInsnNode]).getOrElse(Set.empty)
+      _consumersOfOutputsFrom.get(insn).map(v => Set.from[AbstractInsnNode](v.indices.iterator.flatMap(v.apply))).getOrElse(Set.empty)
   }
 
   /**

src/compiler/scala/tools/nsc/backend/jvm/opt/BoxUnbox.scala

@@ -226,7 +226,7 @@ abstract class BoxUnbox {
         })
 
         if (canRewrite) {
-          val localSlots: Vector[(Int, Type)] = boxKind.boxedTypes.map(tp => (getLocal(tp.getSize), tp))(collection.breakOut)
+          val localSlots = Vector.from[(Int, Type)](boxKind.boxedTypes.iterator.map(tp => (getLocal(tp.getSize), tp)))
 
           // store boxed value(s) into localSlots
           val storeOps = localSlots.toList reverseMap { case (slot, tp) =>
@@ -237,9 +237,9 @@ abstract class BoxUnbox {
             case None => storeOps
           }
           if (keepBox) {
-            val loadOps: List[VarInsnNode] = localSlots.map({ case (slot, tp) =>
+            val loadOps = List.from[VarInsnNode](localSlots.iterator.map({ case (slot, tp) =>
               new VarInsnNode(tp.getOpcode(ILOAD), slot)
-            })(collection.breakOut)
+            }))
             toInsertBefore(creation.valuesConsumer) = storeInitialValues ::: loadOps
           } else {
             toReplace(creation.valuesConsumer) = storeInitialValues
@@ -530,7 +530,7 @@ abstract class BoxUnbox {
    * this iterator returns all copy operations (load, store, dup) that are in between.
    */
   class CopyOpsIterator(initialCreations: Set[BoxCreation], finalCons: Set[BoxConsumer], prodCons: ProdConsAnalyzer) extends Iterator[AbstractInsnNode] {
-    private var queue = mutable.Queue.empty[AbstractInsnNode] ++ initialCreations.iterator.flatMap(_.boxConsumers(prodCons, ultimate = false))
+    private var queue = mutable.Queue.empty[AbstractInsnNode] ++= initialCreations.iterator.flatMap(_.boxConsumers(prodCons, ultimate = false))
 
     // a single copy operation can consume multiple producers: val a = if (b) box(1) else box(2).
     // the `ASTORE a` has two producers (the two box operations). we need to handle it only once.

src/compiler/scala/tools/nsc/backend/jvm/opt/ClosureOptimizer.scala

@@ -476,13 +476,13 @@ abstract class ClosureOptimizer {
      */
     def fromTypes(firstLocal: Int, types: Array[Type]): LocalsList = {
       var sizeTwoOffset = 0
-      val locals: List[Local] = types.indices.map(i => {
+      val locals = List.from[Local](types.indices.iterator.map(i => {
         // The ASM method `type.getOpcode` returns the opcode for operating on a value of `type`.
         val offset = types(i).getOpcode(ILOAD) - ILOAD
         val local = Local(firstLocal + i + sizeTwoOffset, offset)
         if (local.size == 2) sizeTwoOffset += 1
         local
-      })(collection.breakOut)
+      }))
       LocalsList(locals)
     }
   }