Cross-compile the compiler with the 2.13 stdlib

We still need to support compiling it against the 2.12 stdlib until we
release a new reference compiler because the current reference compiler
cannot use the 2.13 stdlib. This is mostly not a problem, except that
this forces us to keep two versions of WeakHashSet, the same source file
cannot be used for both the 2.12 and 2.13 stdlib since `-=` and `+=` are
final in 2.13.

Author: smarter

compiler/src-bootstrapped/dotty/tools/dotc/util/WeakHashSet.scala

@@ -131,14 +131,6 @@ class CoreBTypes[BTFS <: BTypesFromSymbols[_ <: BackendInterface]](val bTypes: B
   lazy val srFloatRef   : ClassBType = classBTypeFromSymbol(requiredClass[scala.runtime.FloatRef])
   lazy val srDoubleRef  : ClassBType = classBTypeFromSymbol(requiredClass[scala.runtime.DoubleRef])
 
-  // scala.FunctionX and scala.runtim.AbstractFunctionX
-  lazy val FunctionReference         : Vector[ClassBType]   = (0 to MaxFunctionArity).map(i => classBTypeFromSymbol(FunctionClass(i)))(collection.breakOut)
-  lazy val AbstractFunctionReference : Vector[ClassBType]   = (0 to MaxFunctionArity).map(i => classBTypeFromSymbol(AbstractFunctionClass(i)))(collection.breakOut)
-  lazy val AbstractFunctionArityMap  : Map[ClassBType, Int] = AbstractFunctionReference.zipWithIndex.toMap
-
-  lazy val PartialFunctionReference         : ClassBType = classBTypeFromSymbol(PartialFunctionClass)
-  lazy val AbstractPartialFunctionReference : ClassBType = classBTypeFromSymbol(AbstractPartialFunctionClass)
-
   lazy val BoxesRunTime: ClassBType = classBTypeFromSymbol(requiredClass[scala.runtime.BoxesRunTime])
 
   /**
@@ -263,13 +255,6 @@ final class CoreBTypesProxy[BTFS <: BTypesFromSymbols[_ <: BackendInterface]](va
   def srFloatRef   : ClassBType = _coreBTypes.srFloatRef
   def srDoubleRef  : ClassBType = _coreBTypes.srDoubleRef
 
-  def FunctionReference         : Vector[ClassBType]   = _coreBTypes.FunctionReference
-  def AbstractFunctionReference : Vector[ClassBType]   = _coreBTypes.AbstractFunctionReference
-  def AbstractFunctionArityMap  : Map[ClassBType, Int] = _coreBTypes.AbstractFunctionArityMap
-
-  def PartialFunctionReference         : ClassBType = _coreBTypes.PartialFunctionReference
-  def AbstractPartialFunctionReference : ClassBType = _coreBTypes.AbstractPartialFunctionReference
-
   def BoxesRunTime: ClassBType = _coreBTypes.BoxesRunTime
 
   def asmBoxTo  : Map[BType, MethodNameAndType] = _coreBTypes.asmBoxTo

compiler/src/dotty/tools/dotc/util/WeakHashSet.scala renamed to compiler/src-non-bootstrapped/dotty/tools/dotc/util/WeakHashSet.scala

@@ -87,7 +87,7 @@ case class AggregateClassPath(aggregates: Seq[ClassPath]) extends ClassPath {
    * creates an entry containing both of them. If there would be more than one class or source
    * entries for the same class it always would use the first entry of each type found on a classpath.
    */
-  private def mergeClassesAndSources(entries: Seq[ClassRepresentation]*): Seq[ClassRepresentation] = {
+  private def mergeClassesAndSources(entries: scala.collection.Seq[ClassRepresentation]*): Seq[ClassRepresentation] = {
     // based on the implementation from MergedClassPath
     var count = 0
     val indices = collection.mutable.HashMap[String, Int]()

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

@@ -6,8 +6,8 @@ package dotty.tools.dotc.classpath
 import dotty.tools.io.AbstractFile
 import dotty.tools.io.ClassRepresentation
 
-case class ClassPathEntries(packages: Seq[PackageEntry], classesAndSources: Seq[ClassRepresentation]) {
-  def toTuple: (Seq[PackageEntry], Seq[ClassRepresentation]) = (packages, classesAndSources)
+case class ClassPathEntries(packages: scala.collection.Seq[PackageEntry], classesAndSources: scala.collection.Seq[ClassRepresentation]) {
+  def toTuple: (scala.collection.Seq[PackageEntry], scala.collection.Seq[ClassRepresentation]) = (packages, classesAndSources)
 }
 
 trait ClassFileEntry extends ClassRepresentation {

compiler/src/dotty/tools/dotc/classpath/AggregateClassPath.scala

@@ -60,7 +60,7 @@ trait DirectoryLookup[FileEntryType <: ClassRepresentation] extends ClassPath {
       case None => emptyFiles
       case Some(directory) => listChildren(directory, Some(isMatchingFile))
     }
-    files.map(f => createFileEntry(toAbstractFile(f)))
+    files.iterator.map(f => createFileEntry(toAbstractFile(f))).toSeq
   }
 
   private[dotty] def list(inPackage: String): ClassPathEntries = {

compiler/src/dotty/tools/dotc/classpath/ClassPath.scala

@@ -94,7 +94,7 @@ object ZipAndJarClassPathFactory extends ZipAndJarFileLookupFactory {
       val packages = collection.mutable.HashMap[String, PackageFileInfo]()
 
       def getSubpackages(dir: AbstractFile): List[AbstractFile] =
-        (for (file <- dir if file.isPackage) yield file)(collection.breakOut)
+        (for (file <- dir if file.isPackage) yield file).toList
 
       @tailrec
       def traverse(packagePrefix: String,
@@ -129,7 +129,7 @@ object ZipAndJarClassPathFactory extends ZipAndJarFileLookupFactory {
     override private[dotty] def classes(inPackage: String): Seq[ClassFileEntry] = cachedPackages.get(inPackage) match {
       case None => Seq.empty
       case Some(PackageFileInfo(pkg, _)) =>
-        (for (file <- pkg if file.isClass) yield ClassFileEntryImpl(file))(collection.breakOut)
+        (for (file <- pkg if file.isClass) yield ClassFileEntryImpl(file)).toSeq
     }
 
     override private[dotty] def hasPackage(pkg: String) = cachedPackages.contains(pkg)

compiler/src/dotty/tools/dotc/classpath/DirectoryClassPath.scala

@@ -5,7 +5,7 @@ package dotty.tools.dotc.classpath
 
 import java.io.File
 import java.net.URL
-import scala.collection.Seq
+
 import dotty.tools.io.{ AbstractFile, FileZipArchive }
 import FileUtils.AbstractFileOps
 import dotty.tools.io.{ClassPath, ClassRepresentation}

compiler/src/dotty/tools/dotc/classpath/ZipAndJarFileLookupFactory.scala

@@ -37,7 +37,7 @@ object Settings {
 
     def update(idx: Int, x: Any): SettingsState =
       if (_wasRead)
-        new SettingsState(values).update(idx, x)
+        new SettingsState(values.toSeq).update(idx, x)
       else {
         values(idx) = x
         this
@@ -194,7 +194,7 @@ object Settings {
   class SettingGroup {
 
     private[this] val _allSettings = new ArrayBuffer[Setting[_]]
-    def allSettings: Seq[Setting[_]] = _allSettings
+    def allSettings: Seq[Setting[_]] = _allSettings.toSeq
 
     def defaultState: SettingsState = new SettingsState(allSettings map (_.default))
 

compiler/src/dotty/tools/dotc/classpath/ZipArchiveFileLookup.scala

@@ -708,7 +708,7 @@ object Contexts {
 
     /** A map that associates label and size of all uniques sets */
     def uniquesSizes: Map[String, (Int, Int, Int)] =
-      uniqueSets.mapValues(s => (s.size, s.accesses, s.misses))
+      uniqueSets.transform((_, s) => (s.size, s.accesses, s.misses))
 
     /** Number of findMember calls on stack */
     private[core] var findMemberCount: Int = 0

compiler/src/dotty/tools/dotc/config/Settings.scala

@@ -212,8 +212,8 @@ object Phases {
         this.squashedPhases = this.phases
       }
 
-      config.println(s"Phases = ${phases.deep}")
-      config.println(s"nextDenotTransformerId = ${nextDenotTransformerId.deep}")
+      config.println(s"Phases = ${phases.toList}")
+      config.println(s"nextDenotTransformerId = ${nextDenotTransformerId.toList}")
     }
 
     private[this] var myTyperPhase: Phase = _

compiler/src/dotty/tools/dotc/core/Contexts.scala

@@ -77,7 +77,7 @@ class TyperState(private val previous: TyperState /* | Null */) {
     new TyperState(this).setReporter(new StoreReporter(reporter)).setCommittable(isCommittable)
 
   /** The uninstantiated variables */
-  def uninstVars: Seq[TypeVar] = constraint.uninstVars
+  def uninstVars: collection.Seq[TypeVar] = constraint.uninstVars
 
   /** The set of uninstantiated type variables which have this state as their owning state */
   private[this] var myOwnedVars: TypeVars = SimpleIdentitySet.empty

compiler/src/dotty/tools/dotc/core/Phases.scala

@@ -25,7 +25,7 @@ import printing.Texts._
 import printing.Printer
 import Hashable._
 import Uniques._
-import collection.{mutable, Seq}
+import collection.mutable
 import config.Config
 import annotation.tailrec
 import language.implicitConversions
@@ -757,9 +757,9 @@ object Types {
     }
 
     def memberDenots(keepOnly: NameFilter, f: (Name, mutable.Buffer[SingleDenotation]) => Unit)(implicit ctx: Context): Seq[SingleDenotation] = {
-      val buf = mutable.ArrayBuffer[SingleDenotation]()
+      val buf = mutable.ListBuffer[SingleDenotation]()
       for (name <- memberNames(keepOnly)) f(name, buf)
-      buf
+      buf.toList
     }
 
     /** The set of abstract term members of this type. */

compiler/src/dotty/tools/dotc/core/TyperState.scala

@@ -1164,7 +1164,7 @@ class ClassfileParser(
           val start = starts(index)
           if (in.buf(start).toInt != CONSTANT_UTF8) errorBadTag(start)
           val len = in.getChar(start + 1)
-          bytesBuffer ++= in.buf.view(start + 3, start + 3 + len)
+          bytesBuffer ++= in.buf.view.slice(start + 3, start + 3 + len)
         }
         value = getSubArray(bytesBuffer.toArray)
         values(indices.head) = value

compiler/src/dotty/tools/dotc/core/Types.scala

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

compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala

@@ -191,8 +191,8 @@ class Mixin extends MiniPhase with SymTransformer { thisPhase =>
       for (p <- impl.parents; constr = stripBlock(p).symbol if constr.isConstructor)
       yield constr.owner -> transformConstructor(p)
     ).toMap
-    val superCalls = superCallsAndArgs.mapValues(_._1)
-    val initArgs = superCallsAndArgs.mapValues(_._2)
+    val superCalls = superCallsAndArgs.transform((_, v) => v._1)
+    val initArgs = superCallsAndArgs.transform((_, v) => v._2)
 
     def superCallOpt(baseCls: Symbol): List[Tree] = superCalls.get(baseCls) match {
       case Some(call) =>

compiler/src/dotty/tools/dotc/parsing/xml/SymbolicXMLBuilder.scala

@@ -77,7 +77,7 @@ object Gen {
       }
     }
 
-    Program(breaks, cmds)
+    Program(breaks.toList, cmds.toList)
   }
 
   def generate(program: Program, source: String = "tests/debug/"): String = {

compiler/src/dotty/tools/dotc/transform/Mixin.scala

@@ -35,7 +35,7 @@ object ASMConverters {
 
     def dropStaleLabels = {
       val definedLabels: Set[Instruction] = self.filter(_.isInstanceOf[Label]).toSet
-      val usedLabels: Set[Instruction] = self.flatMap(referencedLabels)(collection.breakOut)
+      val usedLabels: Set[Instruction] = self.iterator.flatMap(referencedLabels).toSet
       self.filterNot(definedLabels diff usedLabels)
     }
 
@@ -144,19 +144,19 @@ object ASMConverters {
       case i: t.LineNumberNode         => LineNumber   (i.line, applyLabel(i.start))
     }
 
-    private def convertBsmArgs(a: Array[Object]): List[Object] = a.map({
+    private def convertBsmArgs(a: Array[Object]): List[Object] = a.iterator.map({
       case h: asm.Handle => convertMethodHandle(h)
       case _ => a // can be: Class, method Type, primitive constant
-    })(collection.breakOut)
+    }).toList
 
     private def convertMethodHandle(h: asm.Handle): MethodHandle = MethodHandle(h.getTag, h.getOwner, h.getName, h.getDesc, h.isInterface)
 
     private def convertHandlers(method: t.MethodNode): List[ExceptionHandler] = {
-      method.tryCatchBlocks.asScala.map(h => ExceptionHandler(applyLabel(h.start), applyLabel(h.end), applyLabel(h.handler), Option(h.`type`)))(collection.breakOut)
+      method.tryCatchBlocks.asScala.map(h => ExceptionHandler(applyLabel(h.start), applyLabel(h.end), applyLabel(h.handler), Option(h.`type`))).toList
     }
 
     private def convertLocalVars(method: t.MethodNode): List[LocalVariable] = {
-      method.localVariables.asScala.map(v => LocalVariable(v.name, v.desc, Option(v.signature), applyLabel(v.start), applyLabel(v.end), v.index))(collection.breakOut)
+      method.localVariables.asScala.map(v => LocalVariable(v.name, v.desc, Option(v.signature), applyLabel(v.start), applyLabel(v.end), v.index)).toList
     }
   }
 
@@ -233,7 +233,7 @@ object ASMConverters {
   def unconvertBsmArgs(a: List[Object]): Array[Object] = a.map({
     case h: MethodHandle => unconvertMethodHandle(h)
     case o => o
-  })(collection.breakOut)
+  }).toArray
 
   private def visitMethod(method: t.MethodNode, instruction: Instruction, asmLabel: Map[Label, asm.Label]): Unit = instruction match {
     case Field(op, owner, name, desc)                => method.visitFieldInsn(op, owner, name, desc)

compiler/test/debug/Gen.scala

@@ -246,13 +246,17 @@ object Build {
 
   // Settings used when compiling dotty with the reference compiler
   lazy val commonNonBootstrappedSettings = commonDottySettings ++ Seq(
+    unmanagedSourceDirectories in Compile += baseDirectory.value / "src-non-bootstrapped",
+
     version := dottyNonBootstrappedVersion,
     scalaVersion := referenceVersion,
-    excludeFromIDE := true
+    excludeFromIDE := true,
   )
 
   // Settings used when compiling dotty with a non-bootstrapped dotty
   lazy val commonBootstrappedSettings = commonDottySettings ++ Seq(
+    unmanagedSourceDirectories in Compile += baseDirectory.value / "src-bootstrapped",
+
     version := dottyVersion,
     scalaVersion := dottyNonBootstrappedVersion,
 
@@ -716,17 +720,6 @@ object Build {
   lazy val dottyLibrarySettings = Seq(
     // Needed so that the library sources are visible when `dotty.tools.dotc.core.Definitions#init` is called
     scalacOptions in Compile ++= Seq("-sourcepath", (scalaSource in Compile).value.getAbsolutePath),
-
-    // Add version-specific source directories:
-    // - files in src-non-bootstrapped will only be compiled by the reference compiler
-    // - files in src-bootstrapped will only be compiled by the current dotty compiler (non-bootstrapped and bootstrapped)
-    unmanagedSourceDirectories in Compile ++= {
-      val baseDir = baseDirectory.value
-      if (scalaVersion.value == referenceVersion)
-        Seq(baseDir / "src-non-bootstrapped")
-      else
-        Seq(baseDir / "src-bootstrapped")
-    }
   )
 
   lazy val `dotty-library` = project.in(file("library")).asDottyLibrary(NonBootstrapped)