fix some deprecations

Author: bishabosha

compiler/src/dotty/tools/dotc/Bench.scala

@@ -15,7 +15,7 @@ object Bench extends Driver {
   @sharable private[this] var numRuns = 1
 
   private def ntimes(n: Int)(op: => Reporter): Reporter =
-    (emptyReporter /: (0 until n)) ((_, _) => op)
+    (0 until n).foldLeft(emptyReporter)((_, _) => op)
 
   override def doCompile(compiler: Compiler, fileNames: List[String])(implicit ctx: Context): Reporter =
     ntimes(numRuns) {

compiler/src/dotty/tools/dotc/Run.scala

@@ -56,7 +56,7 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
     ctx.initialize()(start) // re-initialize the base context with start
     def addImport(ctx: Context, refFn: () => TermRef) =
       ctx.fresh.setImportInfo(ImportInfo.rootImport(refFn)(ctx))
-    (start.setRun(this) /: defn.RootImportFns)(addImport)
+    defn.RootImportFns.foldLeft(start.setRun(this))(addImport)
   }
 
   private[this] var compiling = false

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

@@ -491,12 +491,12 @@ object desugar {
     // Annotations are dropped from the constructor parameters but should be
     // preserved in all derived parameters.
     val derivedTparams = {
-      val impliedTparamsIt = impliedTparams.toIterator
+      val impliedTparamsIt = impliedTparams.iterator
       constrTparams.map(tparam => derivedTypeParam(tparam)
         .withAnnotations(impliedTparamsIt.next().mods.annotations))
     }
     val derivedVparamss = {
-      val constrVparamsIt = constrVparamss.toIterator.flatten
+      val constrVparamsIt = constrVparamss.iterator.flatten
       constrVparamss.nestedMap(vparam => derivedTermParam(vparam)
         .withAnnotations(constrVparamsIt.next().mods.annotations))
     }
@@ -560,7 +560,7 @@ object desugar {
         case _ =>
           constrVparamss
       }
-      val nu = (makeNew(classTypeRef) /: vparamss) { (nu, vparams) =>
+      val nu = vparamss.foldLeft(makeNew(classTypeRef)) { (nu, vparams) =>
         val app = Apply(nu, vparams.map(refOfDef))
         vparams match {
           case vparam :: _ if vparam.mods.is(Given) => app.setGivenApply()
@@ -700,10 +700,9 @@ object desugar {
               isEnumCase) anyRef
           else
             // todo: also use anyRef if constructor has a dependent method type (or rule that out)!
-            (constrVparamss :\ classTypeRef) (
-              (vparams, restpe) => Function(vparams map (_.tpt), restpe))
+            constrVparamss.foldRight(classTypeRef)((vparams, restpe) => Function(vparams map (_.tpt), restpe))
         def widenedCreatorExpr =
-          (creatorExpr /: widenDefs)((rhs, meth) => Apply(Ident(meth.name), rhs :: Nil))
+          widenDefs.foldLeft(creatorExpr)((rhs, meth) => Apply(Ident(meth.name), rhs :: Nil))
         val applyMeths =
           if (mods.is(Abstract)) Nil
           else {
@@ -790,12 +789,12 @@ object desugar {
 
     val cdef1 = addEnumFlags {
       val tparamAccessors = {
-        val impliedTparamsIt = impliedTparams.toIterator
+        val impliedTparamsIt = impliedTparams.iterator
         derivedTparams.map(_.withMods(impliedTparamsIt.next().mods))
       }
       val caseAccessor = if (isCaseClass) CaseAccessor else EmptyFlags
       val vparamAccessors = {
-        val originalVparamsIt = originalVparamss.toIterator.flatten
+        val originalVparamsIt = originalVparamss.iterator.flatten
         derivedVparamss match {
           case first :: rest =>
             first.map(_.withMods(originalVparamsIt.next().mods | caseAccessor)) ++
@@ -1279,7 +1278,7 @@ object desugar {
     val ttree = ctx.typerPhase match {
       case phase: FrontEnd if phase.stillToBeEntered(parts.last) =>
         val prefix =
-          ((Ident(nme.ROOTPKG): Tree) /: parts.init)((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/DesugarEnums.scala

@@ -177,7 +177,7 @@ object DesugarEnums {
     parentTypes.head match {
       case parent: RefTree if parent.name == enumClass.name =>
         // need a widen method to compute correct type parameters for enum base class
-        val widenParamType = (appliedEnumRef /: parentTypes.tail)(makeAndType)
+        val widenParamType = parentTypes.tail.foldLeft(appliedEnumRef)(makeAndType)
         val widenParam = makeSyntheticParameter(tpt = widenParamType)
         val widenDef = DefDef(
           name = s"${cdef.name}$$to$$${enumClass.name}".toTermName,

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

@@ -270,7 +270,7 @@ trait TreeInfo[T >: Untyped <: Type] { self: Trees.Instance[T] =>
    *   trait or class with this body can have as flags.
    */
   def bodyKind(body: List[Tree])(implicit ctx: Context): FlagSet =
-    (NoInitsInterface /: body)((fs, stat) => fs & defKind(stat))
+    body.foldLeft(NoInitsInterface)((fs, stat) => fs & defKind(stat))
 
   /** Checks whether predicate `p` is true for all result parts of this expression,
    *  where we zoom into Ifs, Matches, and Blocks.
@@ -414,7 +414,7 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
       Impure
   }
 
-  private def minOf(l0: PurityLevel, ls: List[PurityLevel]) = (l0 /: ls)(_ `min` _)
+  private def minOf(l0: PurityLevel, ls: List[PurityLevel]) = ls.foldLeft(l0)(_ `min` _)
 
   def isPurePath(tree: Tree)(implicit ctx: Context): Boolean = tree.tpe match {
     case tpe: ConstantType => exprPurity(tree) >= Pure
@@ -825,8 +825,8 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
           case t1: Ident => t1.symbol.hashCode
           case t1 @ Select(q1, _) => t1.symbol.hashCode * 41 + q1.hash
           case Literal(c1) => c1.hashCode
-          case Apply(f1, as1) => (f1.hash /: as1)((h, arg) => h * 41 + arg.hash)
-          case TypeApply(f1, ts1) => (f1.hash /: ts1)((h, arg) => h * 41 + arg.tpe.hash)
+          case Apply(f1, as1) => as1.foldLeft(f1.hash)((h, arg) => h * 41 + arg.hash)
+          case TypeApply(f1, ts1) => ts1.foldLeft(f1.hash)((h, arg) => h * 41 + arg.tpe.hash)
           case _ => t1.hashCode
         }
       }

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

@@ -185,11 +185,13 @@ class TreeTypeMap(
   def withMappedSyms(syms: List[Symbol], mapped: List[Symbol]): TreeTypeMap = {
     val symsChanged = syms ne mapped
     val substMap = withSubstitution(syms, mapped)
-    val fullMap = (substMap /: mapped.filter(_.isClass)) { (tmap, cls) =>
+    val fullMap = mapped.filter(_.isClass).foldLeft(substMap) { (tmap, cls) =>
       val origDcls = cls.info.decls.toList
       val mappedDcls = ctx.mapSymbols(origDcls, tmap)
       val tmap1 = tmap.withMappedSyms(origDcls, mappedDcls)
-      if (symsChanged) (origDcls, mappedDcls).zipped.foreach(cls.asClass.replace)
+      if (symsChanged) {
+        (origDcls, mappedDcls).zipped.foreach(cls.asClass.replace)
+      }
       tmap1
     }
     if (symsChanged || (fullMap eq substMap)) fullMap

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

@@ -851,7 +851,7 @@ object Trees {
     override def isEmpty: Boolean = trees.isEmpty
     override def toList: List[Tree[T]] = flatten(trees)
     override def toString: String = if (isEmpty) "EmptyTree" else "Thicket(" + trees.mkString(", ") + ")"
-    override def span: Span = (NoSpan /: trees) ((span, t) => span union t.span)
+    override def span: Span = trees.foldLeft(NoSpan) ((span, t) => span union t.span)
 
     override def withSpan(span: Span): this.type =
       mapElems(_.withSpan(span)).asInstanceOf[this.type]
@@ -1364,7 +1364,7 @@ object Trees {
       // Ties the knot of the traversal: call `foldOver(x, tree))` to dive in the `tree` node.
       def apply(x: X, tree: Tree)(implicit ctx: Context): X
 
-      def apply(x: X, trees: Traversable[Tree])(implicit ctx: Context): X = (x /: trees)(apply)
+      def apply(x: X, trees: Traversable[Tree])(implicit ctx: Context): X = trees.foldLeft(x)(apply)
       def foldOver(x: X, tree: Tree)(implicit ctx: Context): X =
         if (tree.source != ctx.source && tree.source.exists)
           foldOver(x, tree)(ctx.withSource(tree.source))
@@ -1445,7 +1445,7 @@ object Trees {
               this(this(x, tpt), tree.rhs)
             case tree @ DefDef(name, tparams, vparamss, tpt, _) =>
               implicit val ctx = localCtx
-              this(this((this(x, tparams) /: vparamss)(apply), tpt), tree.rhs)
+              this(this(vparamss.foldLeft(this(x, tparams))(apply), tpt), tree.rhs)
             case TypeDef(name, rhs) =>
               implicit val ctx = localCtx
               this(x, rhs)

compiler/src/dotty/tools/dotc/typer/Namer.scala

@@ -133,7 +133,7 @@ trait NamerContextOps { this: Context =>
   /** The method type corresponding to given parameters and result type */
   def methodType(typeParams: List[Symbol], valueParamss: List[List[Symbol]], resultType: Type, isJava: Boolean = false)(implicit ctx: Context): Type = {
     val monotpe =
-      (valueParamss :\ resultType) { (params, resultType) =>
+      valueParamss.foldRight(resultType) { (params, resultType) =>
         val (isContextual, isImplicit, isErased) =
           if (params.isEmpty) (false, false, false)
           else (params.head.is(Given), params.head.is(Implicit), params.head.is(Erased))
@@ -720,7 +720,7 @@ class Namer { typer: Typer =>
 
     stats.foreach(expand)
     mergeCompanionDefs()
-    val ctxWithStats = (ctx /: stats) ((ctx, stat) => indexExpanded(stat)(ctx))
+    val ctxWithStats = stats.foldLeft(ctx)((ctx, stat) => indexExpanded(stat)(ctx))
     createCompanionLinks(ctxWithStats)
     ctxWithStats
   }
@@ -1248,7 +1248,7 @@ class Namer { typer: Typer =>
           // TODO: Look only at member of supertype instead?
           lazy val schema = paramFn(WildcardType)
           val site = sym.owner.thisType
-          ((NoType: Type) /: sym.owner.info.baseClasses.tail) { (tp, cls) =>
+          sym.owner.info.baseClasses.tail.foldLeft(NoType: Type) { (tp, cls) =>
             def instantiatedResType(info: Type, tparams: List[Symbol], paramss: List[List[Symbol]]): Type = info match {
               case info: PolyType =>
                 if (info.paramNames.length == typeParams.length)

library/src-bootstrapped/scala/tasty/reflect/TreeUtils.scala

@@ -14,8 +14,8 @@ trait TreeUtils
     def foldTree(x: X, tree: Tree) given (ctx: Context): X
     def foldPattern(x: X, tree: Pattern) given (ctx: Context): X
 
-    def foldTrees(x: X, trees: Iterable[Tree]) given (ctx: Context): X = (x /: trees)(foldTree)
-    def foldPatterns(x: X, trees: Iterable[Pattern]) given (ctx: Context): X = (x /: trees)(foldPattern)
+    def foldTrees(x: X, trees: Iterable[Tree]) given (ctx: Context): X = trees.foldLeft(x)(foldTree)
+    def foldPatterns(x: X, trees: Iterable[Pattern]) given (ctx: Context): X = trees.foldLeft(x)(foldPattern)
 
     def foldOverTree(x: X, tree: Tree) given (ctx: Context): X = {
       def localCtx(definition: Definition): Context = definition.symbol.localContext
@@ -65,7 +65,7 @@ trait TreeUtils
           foldTrees(foldTree(x, tpt), rhs)
         case IsDefinition(ddef @ DefDef(_, tparams, vparamss, tpt, rhs)) =>
           implicit val ctx = localCtx(ddef)
-          foldTrees(foldTree((foldTrees(x, tparams) /: vparamss)(foldTrees), tpt), rhs)
+          foldTrees(foldTree(vparamss.foldLeft(foldTrees(x, tparams))(foldTrees), tpt), rhs)
         case IsDefinition(tdef @ TypeDef(_, rhs)) =>
           implicit val ctx = localCtx(tdef)
           foldTree(x, rhs)

library/src/scala/tasty/reflect/Printers.scala

@@ -1371,6 +1371,9 @@ trait Printers
 
       }
 
+      inline private val qc  = '\''
+      inline private val qSc = '"'
+
       def printConstant(const: Constant): Buffer = const match {
         case Constant(()) => this += highlightLiteral("()")
         case Constant(null) => this += highlightLiteral("null")
@@ -1381,8 +1384,8 @@ trait Printers
         case Constant(v: Long) => this += highlightLiteral(v.toString + "L")
         case Constant(v: Float) => this += highlightLiteral(v.toString + "f")
         case Constant(v: Double) => this += highlightLiteral(v.toString)
-        case Constant(v: Char) => this += highlightString('\'' + escapedChar(v) + '\'')
-        case Constant(v: String) => this += highlightString('"' + escapedString(v) + '"')
+        case Constant(v: Char) => this += highlightString(s"${qc}${escapedChar(v)}${qc}")
+        case Constant(v: String) => this += highlightString(s"${qSc}${escapedString(v)}${qSc}")
         case Constant.ClassTag(v) =>
           this += "classOf"
           inSquare(printType(v))