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.
     *

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

@@ -382,7 +382,7 @@ class Definitions {
 
   // The set of all wrap{X, Ref}Array methods, where X is a value type
   val WrapArrayMethods: PerRun[collection.Set[Symbol]] = new PerRun({ implicit ctx =>
-    val methodNames = ScalaValueTypes.map(ast.tpd.wrapArrayMethodName) + nme.wrapRefArray
+    val methodNames = ScalaValueTypes.map(ast.tpd.wrapArrayMethodName) `union` Set(nme.wrapRefArray)
     methodNames.map(getWrapVarargsArrayModule.requiredMethod(_))
   })
 
@@ -1192,7 +1192,7 @@ class Definitions {
     ByteType, ShortType, CharType, IntType, LongType, FloatType, DoubleType)
 
   @tu private lazy val ScalaNumericValueTypes: collection.Set[TypeRef] = ScalaNumericValueTypeList.toSet
-  @tu private lazy val ScalaValueTypes: collection.Set[TypeRef] = ScalaNumericValueTypes + UnitType + BooleanType
+  @tu private lazy val ScalaValueTypes: collection.Set[TypeRef] = ScalaNumericValueTypes `union` Set(UnitType, BooleanType)
 
   val ScalaNumericValueClasses: PerRun[collection.Set[Symbol]] = new PerRun(implicit ctx => ScalaNumericValueTypes.map(_.symbol))
   val ScalaValueClasses: PerRun[collection.Set[Symbol]]        = new PerRun(implicit ctx => ScalaValueTypes.map(_.symbol))

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

@@ -173,7 +173,7 @@ object Flags {
    *  lie in the given range
    */
   private def flagRange(start: Int, end: Int) =
-    FlagSet((KINDFLAGS.toLong /: (start until end)) ((bits, idx) =>
+    FlagSet((start until end).foldLeft(KINDFLAGS.toLong) ((bits, idx) =>
       if (isDefinedAsFlag(idx)) bits | (1L << idx) else bits))
 
   /** The union of all flags in given flag set */

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

@@ -251,12 +251,12 @@ final class ProperGadtConstraint private(
      }
 
    override def fullLowerBound(param: TypeParamRef)(implicit ctx: Context): Type =
-     (nonParamBounds(param).lo /: constraint.minLower(param)) {
+     constraint.minLower(param).foldLeft(nonParamBounds(param).lo) {
        (t, u) => t | externalize(u)
      }
 
    override def fullUpperBound(param: TypeParamRef)(implicit ctx: Context): Type =
-     (nonParamBounds(param).hi /: constraint.minUpper(param)) {
+     constraint.minUpper(param).foldLeft(nonParamBounds(param).hi) {
        (t, u) => t & externalize(u)
      }
 

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

@@ -349,7 +349,7 @@ object NameKinds {
   val OuterSelectName: NumberedNameKind = new NumberedNameKind(OUTERSELECT, "OuterSelect") {
     def mkString(underlying: TermName, info: ThisInfo) = {
       assert(underlying.isEmpty)
-      info.num + "_<outer>"
+      s"${info.num}_<outer>"
     }
   }
 

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

@@ -271,7 +271,7 @@ object NameOps {
     }
 
     def unmangle(kinds: List[NameKind]): N = {
-      val unmangled = (name /: kinds)(_.unmangle(_))
+      val unmangled = kinds.foldLeft(name)(_.unmangle(_))
       if (unmangled eq name) name else unmangled.unmangle(kinds)
     }
   }

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

@@ -164,7 +164,7 @@ object Names {
     override def isTypeName: Boolean = false
     override def isTermName: Boolean = true
     override def toTermName: TermName = this
-    override def asTypeName: Nothing = throw new ClassCastException(this + " is not a type name")
+    override def asTypeName: Nothing = throw new ClassCastException(s"$this is not a type name")
     override def asTermName: TermName = this
 
     @sharable // because it is only modified in the synchronized block of toTypeName.
@@ -436,7 +436,7 @@ object Names {
     override def isTermName: Boolean = false
     override def toTypeName: TypeName = this
     override def asTypeName: TypeName = this
-    override def asTermName: Nothing = throw new ClassCastException(this + " is not a term name")
+    override def asTermName: Nothing = throw new ClassCastException(s"$this is not a term name")
 
     override def asSimpleName: SimpleName = toTermName.asSimpleName
     override def toSimpleName: SimpleName = toTermName.toSimpleName

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

@@ -301,8 +301,8 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
       val lo = normalizedType(bounds.lo, loBuf, isUpper = false)
       val hi = normalizedType(bounds.hi, hiBuf, isUpper = true)
       current = updateEntry(current, param, bounds.derivedTypeBounds(lo, hi))
-      current = (current /: loBuf)(order(_, _, param))
-      current = (current /: hiBuf)(order(_, param, _))
+      current = loBuf.foldLeft(current)(order(_, _, param))
+      current = hiBuf.foldLeft(current)(order(_, param, _))
       loBuf.clear()
       hiBuf.clear()
       i += 1
@@ -323,8 +323,8 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
       assert(contains(param2), i"$param2")
       val newUpper = param2 :: exclusiveUpper(param2, param1)
       val newLower = param1 :: exclusiveLower(param1, param2)
-      val current1 = (current /: newLower)(upperLens.map(this, _, _, newUpper ::: _))
-      val current2 = (current1 /: newUpper)(lowerLens.map(this, _, _, newLower ::: _))
+      val current1 = newLower.foldLeft(current)(upperLens.map(this, _, _, newUpper ::: _))
+      val current2 = newUpper.foldLeft(current1)(lowerLens.map(this, _, _, newLower ::: _))
       current2
     }
 
@@ -508,7 +508,7 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
     }
 
     def mergeParams(ps1: List[TypeParamRef], ps2: List[TypeParamRef]) =
-      (ps1 /: ps2)((ps1, p2) => if (ps1.contains(p2)) ps1 else p2 :: ps1)
+      ps2.foldLeft(ps1)((ps1, p2) => if (ps1.contains(p2)) ps1 else p2 :: ps1)
 
     // Must be symmetric
     def mergeEntries(e1: Type, e2: Type): Type =
@@ -679,7 +679,7 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
         val assocs =
           for (param <- domainParams)
           yield
-            param.binder.paramNames(param.paramNum) + ": " + entryText(entry(param))
+            s"${param.binder.paramNames(param.paramNum)}: ${entryText(entry(param))}"
         assocs.mkString("\n")
     }
     constrainedText + "\n" + boundsText

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

@@ -116,9 +116,9 @@ object StdNames {
     val ANON_FUN: N                   = str.ANON_FUN
     val BITMAP_PREFIX: N              = "bitmap$"  // @darkdimius: $bitmap? Also, the next 4 names are unused.
     val BITMAP_NORMAL: N              = BITMAP_PREFIX         // initialization bitmap for public/protected lazy vals
-    val BITMAP_TRANSIENT: N           = BITMAP_PREFIX + "trans$"    // initialization bitmap for transient lazy vals
-    val BITMAP_CHECKINIT: N           = BITMAP_PREFIX + "init$"      // initialization bitmap for checkinit values
-    val BITMAP_CHECKINIT_TRANSIENT: N = BITMAP_PREFIX + "inittrans$" // initialization bitmap for transient checkinit values
+    val BITMAP_TRANSIENT: N           = s"${BITMAP_PREFIX}trans$$"    // initialization bitmap for transient lazy vals
+    val BITMAP_CHECKINIT: N           = s"${BITMAP_PREFIX}init$$"      // initialization bitmap for checkinit values
+    val BITMAP_CHECKINIT_TRANSIENT: N = s"${BITMAP_PREFIX}inittrans$$" // initialization bitmap for transient checkinit values
     val DEFAULT_GETTER: N             = str.DEFAULT_GETTER
     val DEFAULT_GETTER_INIT: N        = "$lessinit$greater"
     val DO_WHILE_PREFIX: N            = "doWhile$"

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

@@ -331,7 +331,7 @@ abstract class SymbolLoader extends LazyType { self =>
         else "error while loading " + root.name + ",\n" + msg)
     }
     try {
-      val start = currentTime
+      val start = System.currentTimeMillis
       if (Config.tracingEnabled && ctx.settings.YdebugTrace.value)
         trace(s">>>> loading ${root.debugString}", _ => s"<<<< loaded ${root.debugString}") {
           doComplete(root)

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

@@ -1724,7 +1724,7 @@ class TypeComparer(initctx: Context) extends ConstraintHandling[AbsentContext] w
   }
 
   /** The greatest lower bound of a list types */
-  final def glb(tps: List[Type]): Type = ((AnyType: Type) /: tps)(glb)
+  final def glb(tps: List[Type]): Type = tps.foldLeft(AnyType: Type)(glb)
 
   def widenInUnions(implicit ctx: Context): Boolean = ctx.scala2Mode || ctx.erasedTypes
 
@@ -1767,7 +1767,7 @@ class TypeComparer(initctx: Context) extends ConstraintHandling[AbsentContext] w
 
   /** The least upper bound of a list of types */
   final def lub(tps: List[Type]): Type =
-    ((NothingType: Type) /: tps)(lub(_,_, canConstrain = false))
+    tps.foldLeft(NothingType: Type)(lub(_,_, canConstrain = false))
 
   /** Try to produce joint arguments for a lub `A[T_1, ..., T_n] | A[T_1', ..., T_n']` using
    *  the following strategies:

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

@@ -673,5 +673,5 @@ object TypeOps {
   // TODO: Move other typeops here. It's a bit weird that they are a part of `ctx`
 
   def nestedPairs(ts: List[Type])(implicit ctx: Context): Type =
-    (ts :\ (defn.UnitType: Type))(defn.PairClass.typeRef.appliedTo(_, _))
+    ts.foldRight(defn.UnitType: Type)(defn.PairClass.typeRef.appliedTo(_, _))
 }

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

@@ -3154,7 +3154,7 @@ object Types {
       else {
         val result =
           if (paramInfos.isEmpty) NoDeps
-          else (NoDeps /: paramInfos.tail)(depStatus(_, _))
+          else paramInfos.tail.foldLeft(NoDeps)(depStatus(_, _))
         if ((result & Provisional) == 0) myParamDependencyStatus = result
         (result & StatusMask).toByte
       }
@@ -4235,7 +4235,7 @@ object Types {
 
   object AnnotatedType {
     def make(underlying: Type, annots: List[Annotation]): Type =
-      (underlying /: annots)(AnnotatedType(_, _))
+      annots.foldLeft(underlying)(AnnotatedType(_, _))
   }
 
   // Special type objects and classes -----------------------------------------------------

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

@@ -421,7 +421,7 @@ class ClassfileParser(
         if (sig(index) != ':') // guard against empty class bound
           ts += objToAny(sig2type(tparams, skiptvs))
       }
-      TypeBounds.upper(((NoType: Type) /: ts)(_ & _) orElse defn.AnyType)
+      TypeBounds.upper(ts.foldLeft(NoType: Type)(_ & _) orElse defn.AnyType)
     }
 
     var tparams = classTParams
@@ -878,7 +878,7 @@ class ClassfileParser(
     def originalName: SimpleName = pool.getName(name)
 
     override def toString: String =
-      originalName + " in " + outerName + "(" + externalName + ")"
+      s"$originalName in $outerName($externalName)"
   }
 
   object innerClasses extends scala.collection.mutable.HashMap[Name, InnerClassEntry] {

compiler/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala

@@ -355,9 +355,9 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas
         val denot1 = denot.disambiguate(p)
         val sym = denot1.symbol
         if (denot.exists && !denot1.exists) { // !!!DEBUG
-          val alts = denot.alternatives map (d => d + ":" + d.info + "/" + d.signature)
+          val alts = denot.alternatives map (d => s"$d:${d.info}/${d.signature}")
           System.err.println(s"!!! disambiguation failure: $alts")
-          val members = denot.alternatives.head.symbol.owner.info.decls.toList map (d => d + ":" + d.info + "/" + d.signature)
+          val members = denot.alternatives.head.symbol.owner.info.decls.toList map (d => s"$d:${d.info}/${d.signature}")
           System.err.println(s"!!! all members: $members")
         }
         if (tag == EXTref) sym else sym.moduleClass
@@ -773,7 +773,7 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas
             if (clazz.isClass) info.substThis(clazz.asClass, rt.recThis)
             else info // turns out some symbols read into `clazz` are not classes, not sure why this is the case.
           def addRefinement(tp: Type, sym: Symbol) = RefinedType(tp, sym.name, sym.info)
-          val refined = (parent /: decls.toList)(addRefinement)
+          val refined = decls.toList.foldLeft(parent)(addRefinement)
           RecType.closeOver(rt => subst(refined, rt))
         }
       case CLASSINFOtpe =>

compiler/src/dotty/tools/dotc/parsing/JavaParsers.scala

@@ -656,7 +656,7 @@ object JavaParsers {
         syntaxError(start, "illegal import", skipIt = false)
         List()
       } else {
-        val qual = ((Ident(names.head): Tree) /: names.tail.init) (Select(_, _))
+        val qual = names.tail.init.foldLeft(Ident(names.head): Tree)(Select(_, _))
         val lastname = names.last
         val ident = Ident(lastname).withSpan(Span(lastnameOffset))
 //        val selector = lastname match {

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -1455,7 +1455,7 @@ object Parsers {
             t
           }
         case AT if location != Location.InPattern =>
-          (t /: annotations())(Annotated)
+          annotations().foldLeft(t)(Annotated)
         case _ =>
           val tpt = typeDependingOn(location)
           if (isWildcard(t) && location != Location.InPattern) {