remove deprecations that can be resolved with 2.12 library

Author: bishabosha

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

@@ -394,11 +394,11 @@ class GenBCodePipeline(val entryPoints: List[Symbol], val int: DottyBackendInter
         }
         for ((label, i) <- initialLabels.iterator.zipWithIndex) {
           mv.visitLabel(label)
-          emitLambdaDeserializeIndy(groups(i))
+          emitLambdaDeserializeIndy(groups(i).toIndexedSeq)
           mv.visitInsn(ARETURN)
         }
         mv.visitLabel(terminalLabel)
-        emitLambdaDeserializeIndy(groups(numGroups - 1))
+        emitLambdaDeserializeIndy(groups(numGroups - 1).toIndexedSeq)
         mv.visitInsn(ARETURN)
       }
 

compiler/src/dotty/tools/backend/sjs/JSCodeGen.scala

@@ -194,7 +194,7 @@ class JSCodeGen()(implicit ctx: Context) {
       ctx.settings.outputDir.value
 
     val pathParts = sym.fullName.toString.split("[./]")
-    val dir = (outputDirectory /: pathParts.init)(_.subdirectoryNamed(_))
+    val dir = pathParts.init.foldLeft(outputDirectory)(_.subdirectoryNamed(_))
 
     var filename = pathParts.last
     if (sym.is(ModuleClass))

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -1278,7 +1278,7 @@ object desugar {
     val ttree = ctx.typerPhase match {
       case phase: FrontEnd if phase.stillToBeEntered(parts.last) =>
         val prefix =
-          parts.init.foldLeft((Ident(nme.ROOTPKG): Tree))((qual, name) =>
+          parts.init.foldLeft(Ident(nme.ROOTPKG): Tree)((qual, name) =>
             Select(qual, name.toTermName))
         Select(prefix, parts.last.toTypeName)
       case _ =>

compiler/src/dotty/tools/dotc/ast/tpd.scala

@@ -295,7 +295,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       for (tparam <- cls.typeParams if !(bodyTypeParams contains tparam))
       yield TypeDef(tparam)
     val findLocalDummy = FindLocalDummyAccumulator(cls)
-    val localDummy = ((NoSymbol: Symbol) /: body)(findLocalDummy.apply)
+    val localDummy = body.foldLeft(NoSymbol: Symbol)(findLocalDummy.apply)
       .orElse(ctx.newLocalDummy(cls))
     val impl = untpd.Template(constr, parents, Nil, selfType, newTypeParams ++ body)
       .withType(localDummy.termRef)
@@ -873,7 +873,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
      *  `tree (argss(0)) ... (argss(argss.length -1))`
      */
     def appliedToArgss(argss: List[List[Tree]])(implicit ctx: Context): Tree =
-      ((tree: Tree) /: argss)(Apply(_, _))
+      argss.foldLeft(tree: Tree)(Apply(_, _))
 
     /** The current tree applied to (): `tree()` */
     def appliedToNone(implicit ctx: Context): Apply = appliedToArgs(Nil)

compiler/src/dotty/tools/dotc/ast/untpd.scala

@@ -354,7 +354,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
    *  PrepareInlineable.
    */
   def New(tpt: Tree, argss: List[List[Tree]])(implicit ctx: Context): Tree =
-    ensureApplied((makeNew(tpt) /: argss)(Apply(_, _)))
+    ensureApplied(argss.foldLeft(makeNew(tpt))(Apply(_, _)))
 
   /** A new expression with constrictor and possibly type arguments. See
    *  `New(tpt, argss)` for details.

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

@@ -51,7 +51,7 @@ trait DirectoryLookup[FileEntryType <: ClassRepresentation] extends ClassPath {
       case Some(directory) => listChildren(directory, Some(isPackage))
     }
     val prefix = PackageNameUtils.packagePrefix(inPackage)
-    nestedDirs.map(f => PackageEntryImpl(prefix + getName(f)))
+    nestedDirs.toIndexedSeq.map(f => PackageEntryImpl(prefix + getName(f)))
   }
 
   protected def files(inPackage: String): Seq[FileEntryType] = {

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

@@ -13,7 +13,7 @@ case class VirtualDirectoryClassPath(dir: VirtualDirectory) extends ClassPath wi
   // From AbstractFileClassLoader
   private final def lookupPath(base: AbstractFile)(pathParts: Seq[String], directory: Boolean): AbstractFile = {
     var file: AbstractFile = base
-    val dirParts = pathParts.init.toIterator
+    val dirParts = pathParts.init.iterator
     while (dirParts.hasNext) {
       val dirPart = dirParts.next
       file = file.lookupName(dirPart, directory = true)
@@ -25,7 +25,7 @@ case class VirtualDirectoryClassPath(dir: VirtualDirectory) extends ClassPath wi
 
   protected def emptyFiles: Array[AbstractFile] = Array.empty
   protected def getSubDir(packageDirName: String): Option[AbstractFile] =
-    Option(lookupPath(dir)(packageDirName.split(java.io.File.separator), directory = true))
+    Option(lookupPath(dir)(packageDirName.split(java.io.File.separator).toIndexedSeq, directory = true))
   protected def listChildren(dir: AbstractFile, filter: Option[AbstractFile => Boolean] = None): Array[F] = filter match {
     case Some(f) => dir.iterator.filter(f).toArray
     case _ => dir.toArray
@@ -42,7 +42,7 @@ case class VirtualDirectoryClassPath(dir: VirtualDirectory) extends ClassPath wi
 
   def findClassFile(className: String): Option[AbstractFile] = {
     val relativePath = FileUtils.dirPath(className) + ".class"
-    Option(lookupPath(dir)(relativePath.split(java.io.File.separator), directory = false))
+    Option(lookupPath(dir)(relativePath.split(java.io.File.separator).toIndexedSeq, directory = false))
   }
 
   private[dotty] def classes(inPackage: String): Seq[ClassFileEntry] = files(inPackage)

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

@@ -94,7 +94,7 @@ object Settings {
     def legalChoices: String =
       if (choices.isEmpty) ""
       else choices match {
-        case r: Range => r.head + ".." + r.last
+        case r: Range => s"${r.head}..${r.last}"
         case xs: List[_] => xs.mkString(", ")
       }
 
@@ -205,10 +205,10 @@ object Settings {
       userSetSettings(state).mkString("(", " ", ")")
 
     private def checkDependencies(state: ArgsSummary): ArgsSummary =
-      (state /: userSetSettings(state.sstate))(checkDependenciesOfSetting)
+      userSetSettings(state.sstate).foldLeft(state)(checkDependenciesOfSetting)
 
     private def checkDependenciesOfSetting(state: ArgsSummary, setting: Setting[_]) =
-      (state /: setting.depends) { (s, dep) =>
+      setting.depends.foldLeft(state) { (s, dep) =>
         val (depSetting, reqValue) = dep
         if (depSetting.valueIn(state.sstate) == reqValue) s
         else s.fail(s"incomplete option ${setting.name} (requires ${depSetting.name})")

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

@@ -171,10 +171,10 @@ class CheckRealizable(implicit ctx: Context) {
     val baseProblems =
       tp.baseClasses.map(_.baseTypeOf(tp)).flatMap(baseTypeProblems)
 
-    ((((Realizable: Realizability)
-      /: memberProblems)(_ andAlso _)
-      /: refinementProblems)(_ andAlso _)
-      /: baseProblems)(_ andAlso _)
+    baseProblems.foldLeft(
+      refinementProblems.foldLeft(
+        memberProblems.foldLeft(
+          Realizable: Realizability)(_ andAlso _))(_ andAlso _))(_ andAlso _)
   }
 
   /** `Realizable` if all of `tp`'s non-strict fields have realizable types,
@@ -199,7 +199,7 @@ class CheckRealizable(implicit ctx: Context) {
       // Reason: An embedded field could well be nullable, which means it
       // should not be part of a path and need not be checked; but we cannot recognize
       // this situation until we have a typesystem that tracks nullability.
-      ((Realizable: Realizability) /: tp.fields)(checkField)
+      tp.fields.foldLeft(Realizable: Realizability)(checkField)
     else
       Realizable
   }

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

@@ -72,10 +72,10 @@ trait ConstraintHandling[AbstractContext] {
   def nonParamBounds(param: TypeParamRef)(implicit actx: AbstractContext): TypeBounds = constraint.nonParamBounds(param)
 
   def fullLowerBound(param: TypeParamRef)(implicit actx: AbstractContext): Type =
-    (nonParamBounds(param).lo /: constraint.minLower(param))(_ | _)
+    constraint.minLower(param).foldLeft(nonParamBounds(param).lo)(_ | _)
 
   def fullUpperBound(param: TypeParamRef)(implicit actx: AbstractContext): Type =
-    (nonParamBounds(param).hi /: constraint.minUpper(param))(_ & _)
+    constraint.minUpper(param).foldLeft(nonParamBounds(param).hi)(_ & _)
 
   /** Full bounds of `param`, including other lower/upper params.
     *