diff --git a/src/compiler/scala/reflect/macros/compiler/Errors.scala b/src/compiler/scala/reflect/macros/compiler/Errors.scala index afbf2f2bb680..301d90ddec18 100644 --- a/src/compiler/scala/reflect/macros/compiler/Errors.scala +++ b/src/compiler/scala/reflect/macros/compiler/Errors.scala @@ -100,7 +100,7 @@ trait Errors extends Traces { private def showMeth(pss: List[List[Symbol]], restpe: Type, abbreviate: Boolean, untype: Boolean) = { def preprocess(tpe: Type) = if (untype) untypeMetalevel(tpe) else tpe - var pssPart = (pss map (ps => ps map (p => p.defStringSeenAs(preprocess(p.info))) mkString ("(", ", ", ")"))).mkString + var pssPart = pss.map(_.map(p => p.defStringSeenAs(preprocess(p.info))).mkString("(", ", ", ")")).mkString if (abbreviate) pssPart = abbreviateCoreAliases(pssPart) var retPart = preprocess(restpe).toString if (abbreviate || macroDdef.tpt.tpe == null) retPart = abbreviateCoreAliases(retPart) diff --git a/src/compiler/scala/reflect/reify/utils/SymbolTables.scala b/src/compiler/scala/reflect/reify/utils/SymbolTables.scala index 034b2b89f1d7..372474a5768a 100644 --- a/src/compiler/scala/reflect/reify/utils/SymbolTables.scala +++ b/src/compiler/scala/reflect/reify/utils/SymbolTables.scala @@ -58,6 +58,7 @@ trait SymbolTables { case None => EmptyTree } + @deprecated("use add instead", since="2.13.3") def +(sym: Symbol, name: TermName, reification: Tree): SymbolTable = add(sym, name, reification) def +(symDef: Tree): SymbolTable = add(symDef) def ++(symDefs: IterableOnce[Tree]): SymbolTable = symDefs.iterator.foldLeft(this)((symtab, symDef) => symtab.add(symDef)) diff --git a/src/compiler/scala/tools/nsc/Reporting.scala b/src/compiler/scala/tools/nsc/Reporting.scala index 49a58244ff8d..ec76ed5c0d5e 100644 --- a/src/compiler/scala/tools/nsc/Reporting.scala +++ b/src/compiler/scala/tools/nsc/Reporting.scala @@ -229,7 +229,7 @@ trait Reporting extends internal.Reporting { self: ast.Positions with Compilatio ) reportedFeature += featureTrait - val msg = s"$featureDesc $req be enabled\nby making the implicit value $fqname visible.$explain" replace ("#", construct) + val msg = s"$featureDesc $req be enabled\nby making the implicit value $fqname visible.$explain".replace("#", construct) // maybe pos.source.file.file.getParentFile.getName or Path(source.file.file).parent.name def parentFileName(source: internal.util.SourceFile) = Option(java.nio.file.Paths.get(source.path).getParent).map(_.getFileName.toString) diff --git a/src/compiler/scala/tools/nsc/ast/TreeGen.scala b/src/compiler/scala/tools/nsc/ast/TreeGen.scala index 64430eacd2e0..5e72cc1cbec6 100644 --- a/src/compiler/scala/tools/nsc/ast/TreeGen.scala +++ b/src/compiler/scala/tools/nsc/ast/TreeGen.scala @@ -364,7 +364,7 @@ abstract class TreeGen extends scala.reflect.internal.TreeGen with TreeDSL { } def expandFunction(localTyper: analyzer.Typer)(fun: Function, inConstructorFlag: Long): Tree = { - val anonClass = fun.symbol.owner newAnonymousFunctionClass(fun.pos, inConstructorFlag) + val anonClass = fun.symbol.owner.newAnonymousFunctionClass(fun.pos, inConstructorFlag) val parents = if (isFunctionType(fun.tpe)) { anonClass addAnnotation SerialVersionUIDAnnotation addSerializable(abstractFunctionType(fun.vparams.map(_.symbol.tpe), fun.body.tpe.deconst)) diff --git a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala index c95d29f1aa7f..a04bb85bdb5d 100644 --- a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala +++ b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala @@ -2187,7 +2187,7 @@ self => private def addMod(mods: Modifiers, mod: Long, pos: Position): Modifiers = { if (mods hasFlag mod) syntaxError(in.offset, "repeated modifier", skipIt = false) in.nextToken() - (mods | mod) withPosition (mod, pos) + (mods | mod).withPosition(mod, pos) } private def tokenRange(token: TokenData) = @@ -2397,7 +2397,7 @@ self => if (mods.isLazy) syntaxError("lazy modifier not allowed here. Use call-by-name parameters instead", skipIt = false) in.token match { case v @ (VAL | VAR) => - mods = mods withPosition (in.token.toLong, tokenRange(in)) + mods = mods.withPosition(in.token.toLong, tokenRange(in)) if (v == VAR) mods |= Flags.MUTABLE in.nextToken() case _ => @@ -2632,13 +2632,13 @@ self => syntaxError("lazy not allowed here. Only vals can be lazy", skipIt = false) in.token match { case VAL => - patDefOrDcl(pos, mods withPosition(VAL, tokenRange(in))) + patDefOrDcl(pos, mods.withPosition(VAL, tokenRange(in))) case VAR => - patDefOrDcl(pos, (mods | Flags.MUTABLE) withPosition (VAR, tokenRange(in))) + patDefOrDcl(pos, (mods | Flags.MUTABLE).withPosition(VAR, tokenRange(in))) case DEF => - List(funDefOrDcl(pos, mods withPosition(DEF, tokenRange(in)))) + List(funDefOrDcl(pos, mods.withPosition(DEF, tokenRange(in)))) case TYPE => - List(typeDefOrDcl(pos, mods withPosition(TYPE, tokenRange(in)))) + List(typeDefOrDcl(pos, mods.withPosition(TYPE, tokenRange(in)))) case _ => List(tmplDef(pos, mods)) } @@ -2897,15 +2897,15 @@ self => if (mods.isLazy) syntaxError("classes cannot be lazy", skipIt = false) in.token match { case TRAIT => - classDef(pos, (mods | Flags.TRAIT | Flags.ABSTRACT) withPosition (Flags.TRAIT, tokenRange(in))) + classDef(pos, (mods | Flags.TRAIT | Flags.ABSTRACT).withPosition(Flags.TRAIT, tokenRange(in))) case CLASS => classDef(pos, mods) case CASECLASS => - classDef(pos, (mods | Flags.CASE) withPosition (Flags.CASE, tokenRange(in.prev /*scanner skips on 'case' to 'class', thus take prev*/))) + classDef(pos, (mods | Flags.CASE).withPosition(Flags.CASE, tokenRange(in.prev /*scanner skips on 'case' to 'class', thus take prev*/))) case OBJECT => objectDef(pos, mods) case CASEOBJECT => - objectDef(pos, (mods | Flags.CASE) withPosition (Flags.CASE, tokenRange(in.prev /*scanner skips on 'case' to 'object', thus take prev*/))) + objectDef(pos, (mods | Flags.CASE).withPosition(Flags.CASE, tokenRange(in.prev /*scanner skips on 'case' to 'object', thus take prev*/))) case _ => syntaxErrorOrIncompleteAnd("expected start of definition", skipIt = true)( // assume a class definition so as to have somewhere to stash the annotations diff --git a/src/compiler/scala/tools/nsc/symtab/SymbolTrackers.scala b/src/compiler/scala/tools/nsc/symtab/SymbolTrackers.scala index ae4d0d2f1b8e..6c7db1dd5448 100644 --- a/src/compiler/scala/tools/nsc/symtab/SymbolTrackers.scala +++ b/src/compiler/scala/tools/nsc/symtab/SymbolTrackers.scala @@ -147,7 +147,7 @@ trait SymbolTrackers { else { indicatorString + indent + symString(root) + ( if (children.isEmpty) "" - else children map (c => c.indentString(indent + " ")) mkString ("\n", "\n", "") + else children.map(_.indentString(indent + " ")).mkString("\n", "\n", "") ) } } diff --git a/src/compiler/scala/tools/nsc/transform/Constructors.scala b/src/compiler/scala/tools/nsc/transform/Constructors.scala index 1ba9390ddc08..8c3f9e28dd3e 100644 --- a/src/compiler/scala/tools/nsc/transform/Constructors.scala +++ b/src/compiler/scala/tools/nsc/transform/Constructors.scala @@ -272,16 +272,10 @@ abstract class Constructors extends Statics with Transform with TypingTransforme closureClass setInfoAndEnter new ClassInfoType(closureParents, newScope, closureClass) - val outerField: TermSymbol = ( - closureClass - newValue(nme.OUTER, impl.pos, PrivateLocal | PARAMACCESSOR) - setInfoAndEnter clazz.tpe - ) - val applyMethod: MethodSymbol = ( - closureClass - newMethod(nme.apply, impl.pos, FINAL) - setInfoAndEnter MethodType(Nil, ObjectTpe) - ) + val outerField: TermSymbol = + closureClass.newValue(nme.OUTER, impl.pos, PrivateLocal | PARAMACCESSOR) setInfoAndEnter clazz.tpe + val applyMethod: MethodSymbol = + closureClass.newMethod(nme.apply, impl.pos, FINAL) setInfoAndEnter MethodType(Nil, ObjectTpe) val outerFieldDef = ValDef(outerField) val closureClassTyper = localTyper.atOwner(closureClass) val applyMethodTyper = closureClassTyper.atOwner(applyMethod) diff --git a/src/compiler/scala/tools/nsc/transform/ExtensionMethods.scala b/src/compiler/scala/tools/nsc/transform/ExtensionMethods.scala index 55b8cfbb92ca..e0d2541f4c45 100644 --- a/src/compiler/scala/tools/nsc/transform/ExtensionMethods.scala +++ b/src/compiler/scala/tools/nsc/transform/ExtensionMethods.scala @@ -138,14 +138,14 @@ abstract class ExtensionMethods extends Transform with TypingTransformers { val resultType = MethodType(List(thisParam), dropNullaryMethod(methodResult)) val selfParamType = singleType(currentOwner.companionModule.thisType, thisParam) - def fixres(tp: Type) = tp substThisAndSym (clazz, selfParamType, clazz.typeParams, tparamsFromClass) - def fixtparam(tp: Type) = tp substSym (clazz.typeParams, tparamsFromClass) + def fixres(tp: Type) = tp.substThisAndSym(clazz, selfParamType, clazz.typeParams, tparamsFromClass) + def fixtparam(tp: Type) = tp.substSym(clazz.typeParams, tparamsFromClass) // We can't substitute symbols on the entire polytype because we // need to modify the bounds of the cloned type parameters, but we // don't want to substitute for the cloned type parameters themselves. val tparams = tparamsFromMethod ::: tparamsFromClass - tparams foreach (_ modifyInfo fixtparam) + tparams.foreach(_ modifyInfo fixtparam) GenPolyType(tparams, fixres(resultType)) // For reference, calling fix on the GenPolyType plays out like this: diff --git a/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala b/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala index 974f19a4a397..2c6bcd925d78 100644 --- a/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala +++ b/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala @@ -804,7 +804,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers { def overrideIn(clazz: Symbol, sym: Symbol) = { val newFlags = (sym.flags | OVERRIDE | SPECIALIZED) & ~(DEFERRED | CASEACCESSOR | PARAMACCESSOR) val sym1 = sym.cloneSymbol(clazz, newFlags) - sym1 modifyInfo (_ asSeenFrom (clazz.tpe, sym1.owner)) + sym1.modifyInfo(_.asSeenFrom(clazz.tpe, sym1.owner)) } val specVal = specializedOverload(sClass, m, env) diff --git a/src/compiler/scala/tools/nsc/transform/TailCalls.scala b/src/compiler/scala/tools/nsc/transform/TailCalls.scala index 88928219dd2d..7e3799da1675 100644 --- a/src/compiler/scala/tools/nsc/transform/TailCalls.scala +++ b/src/compiler/scala/tools/nsc/transform/TailCalls.scala @@ -174,7 +174,7 @@ abstract class TailCalls extends Transform { val thisParam = method.newSyntheticValueParam(currentClass.typeOfThis) label setInfo MethodType(thisParam :: method.tpe.params, method.tpe_*.finalResultType) if (isEligible) - label substInfo (method.tpe.typeParams, tparams) + label.substInfo(method.tpe.typeParams, tparams) label } diff --git a/src/compiler/scala/tools/nsc/transform/patmat/Logic.scala b/src/compiler/scala/tools/nsc/transform/patmat/Logic.scala index 8c27cd7ce921..843a2ca20e97 100644 --- a/src/compiler/scala/tools/nsc/transform/patmat/Logic.scala +++ b/src/compiler/scala/tools/nsc/transform/patmat/Logic.scala @@ -517,7 +517,7 @@ trait ScalaLogic extends Interface with Logic with TreeAndTypeAnalysis { def resetUniques() = {_nextId = 0; uniques.clear()} private val uniques = new mutable.HashMap[Tree, Var] - def apply(x: Tree): Var = uniques getOrElseUpdate(x, new Var(x, x.tpe)) + def apply(x: Tree): Var = uniques.getOrElseUpdate(x, new Var(x, x.tpe)) def unapply(v: Var) = Some(v.path) } class Var(val path: Tree, staticTp: Type) extends AbsVar { @@ -575,11 +575,11 @@ trait ScalaLogic extends Interface with Logic with TreeAndTypeAnalysis { // populate equalitySyms // don't care about the result, but want only one fresh symbol per distinct constant c - def registerEquality(c: Const): Unit = {ensureCanModify(); symForEqualsTo getOrElseUpdate(c, Sym(this, c))} + def registerEquality(c: Const): Unit = { ensureCanModify() ; symForEqualsTo.getOrElseUpdate(c, Sym(this, c)) } // return the symbol that represents this variable being equal to the constant `c`, if it exists, otherwise False (for robustness) // (registerEquality(c) must have been called prior, either when constructing the domain or from outside) - def propForEqualsTo(c: Const): Prop = {observed(); symForEqualsTo.getOrElse(c, False)} + def propForEqualsTo(c: Const): Prop = { observed() ; symForEqualsTo.getOrElse(c, False) } // [implementation NOTE: don't access until all potential equalities have been registered using registerEquality]p /** the information needed to construct the boolean proposition that encodes the equality proposition (V = C) @@ -709,8 +709,8 @@ trait ScalaLogic extends Interface with Logic with TreeAndTypeAnalysis { // don't call until all equalities have been registered and registerNull has been called (if needed) def describe = { def domain_s = domain match { - case Some(d) => d mkString (" ::= ", " | ", "// "+ symForEqualsTo.keys) - case _ => symForEqualsTo.keys mkString (" ::= ", " | ", " | ...") + case Some(d) => d.mkString(" ::= ", " | ", "// "+ symForEqualsTo.keys) + case _ => symForEqualsTo.keys.mkString(" ::= ", " | ", " | ...") } s"$this: ${staticTp}${domain_s} // = $path" } diff --git a/src/compiler/scala/tools/nsc/transform/patmat/MatchAnalysis.scala b/src/compiler/scala/tools/nsc/transform/patmat/MatchAnalysis.scala index c26fc1138ae1..cf168c5bc2d9 100644 --- a/src/compiler/scala/tools/nsc/transform/patmat/MatchAnalysis.scala +++ b/src/compiler/scala/tools/nsc/transform/patmat/MatchAnalysis.scala @@ -234,14 +234,14 @@ trait MatchApproximation extends TreeAndTypeAnalysis with ScalaLogic with MatchT private[this] val uniqueTypeProps = new mutable.HashMap[(Tree, Type), Eq] def uniqueEqualityProp(testedPath: Tree, rhs: Tree): Prop = - uniqueEqualityProps getOrElseUpdate((testedPath, rhs), Eq(Var(testedPath), ValueConst(rhs))) + uniqueEqualityProps.getOrElseUpdate((testedPath, rhs), Eq(Var(testedPath), ValueConst(rhs))) // overridden in TreeMakersToPropsIgnoreNullChecks def uniqueNonNullProp (testedPath: Tree): Prop = - uniqueNonNullProps getOrElseUpdate(testedPath, Not(Eq(Var(testedPath), NullConst))) + uniqueNonNullProps.getOrElseUpdate(testedPath, Not(Eq(Var(testedPath), NullConst))) def uniqueTypeProp(testedPath: Tree, pt: Type): Prop = - uniqueTypeProps getOrElseUpdate((testedPath, pt), Eq(Var(testedPath), TypeConst(checkableType(pt)))) + uniqueTypeProps.getOrElseUpdate((testedPath, pt), Eq(Var(testedPath), TypeConst(checkableType(pt)))) // a variable in this set should never be replaced by a tree that "does not consist of a selection on a variable in this set" (intuitively) private val pointsToBound = mutable.HashSet(root) @@ -646,7 +646,7 @@ trait MatchAnalysis extends MatchApproximation { def varAssignmentString(varAssignment: Map[Var, (Seq[Const], Seq[Const])]) = varAssignment.toSeq.sortBy(_._1.toString).map { case (v, (trues, falses)) => - val assignment = "== "+ (trues mkString("(", ", ", ")")) +" != ("+ (falses mkString(", ")) +")" + val assignment = "== "+ trues.mkString("(", ", ", ")") +" != ("+ falses.mkString(", ") +")" v +"(="+ v.path +": "+ v.staticTpCheckable +") "+ assignment }.mkString("\n") diff --git a/src/compiler/scala/tools/nsc/transform/patmat/PatternMatching.scala b/src/compiler/scala/tools/nsc/transform/patmat/PatternMatching.scala index b1a9229eea21..6cc5da6cfbf0 100644 --- a/src/compiler/scala/tools/nsc/transform/patmat/PatternMatching.scala +++ b/src/compiler/scala/tools/nsc/transform/patmat/PatternMatching.scala @@ -294,7 +294,7 @@ trait Interface extends ast.TreeDSL { } new Substitution(newFrom.prependToList(other.from), newTo.prependToList(other.to.mapConserve(apply))) } - override def toString = (from.map(_.name) zip to) mkString("Substitution(", ", ", ")") + override def toString = from.map(_.name).zip(to).mkString("Substitution(", ", ", ")") } object EmptySubstitution extends Substitution(Nil, Nil) { diff --git a/src/compiler/scala/tools/nsc/typechecker/NamesDefaults.scala b/src/compiler/scala/tools/nsc/typechecker/NamesDefaults.scala index 1f7216210080..18a6002a809e 100644 --- a/src/compiler/scala/tools/nsc/typechecker/NamesDefaults.scala +++ b/src/compiler/scala/tools/nsc/typechecker/NamesDefaults.scala @@ -188,7 +188,7 @@ trait NamesDefaults { self: Analyzer => blockTyper.context.scope enter sym val vd = atPos(sym.pos)(ValDef(sym, qual) setType NoType) // it stays in Vegas: scala/bug#5720, scala/bug#5727 - qual changeOwner (blockTyper.context.owner, sym) + qual.changeOwner(blockTyper.context.owner, sym) val newQual = atPos(qual.pos.focus)(blockTyper.typedQualifier(Ident(sym.name))) val baseFunTransformed = atPos(baseFun.pos.makeTransparent) { diff --git a/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala b/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala index cfdc48639999..d875f4530e3e 100644 --- a/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala +++ b/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala @@ -434,7 +434,7 @@ abstract class SuperAccessors extends transform.Transform with transform.TypingT if (owner.isClass) validCurrentOwner = true val savedLocalTyper = localTyper localTyper = localTyper.atOwner(tree, if (owner.isModuleNotMethod) owner.moduleClass else owner) - typers = typers updated (owner, localTyper) + typers = typers.updated(owner, localTyper) val result = super.atOwner(tree, owner)(trans) localTyper = savedLocalTyper validCurrentOwner = savedValid diff --git a/src/compiler/scala/tools/nsc/typechecker/TypeDiagnostics.scala b/src/compiler/scala/tools/nsc/typechecker/TypeDiagnostics.scala index 930ca4f74acb..28e8e2aca414 100644 --- a/src/compiler/scala/tools/nsc/typechecker/TypeDiagnostics.scala +++ b/src/compiler/scala/tools/nsc/typechecker/TypeDiagnostics.scala @@ -145,7 +145,7 @@ trait TypeDiagnostics { case _ => Nil } def alternativesString(tree: Tree) = - alternatives(tree) map (x => " " + methodTypeErrorString(x)) mkString ("", " \n", "\n") + alternatives(tree).map(x => " " + methodTypeErrorString(x)).mkString("", " \n", "\n") /** The symbol which the given accessor represents (possibly in part). * This is used for error messages, where we want to speak in terms @@ -278,7 +278,7 @@ trait TypeDiagnostics { val messages = relationships.flatten // the condition verifies no type argument came back None if (messages.size == foundArgs.size) - return messages filterNot (_ == "") mkString ("\n", "\n", "") + return messages.filterNot(_ == "").mkString("\n", "\n", "") } } } @@ -344,13 +344,13 @@ trait TypeDiagnostics { val caseString = if (clazz.isCaseClass && (clazz isSubClass ptSym)) ( clazz.caseFieldAccessors - map (_ => "_") // could use the actual param names here - mkString (s"`case ${clazz.name}(", ",", ")`") + .map(_ => "_") // could use the actual param names here + .mkString(s"`case ${clazz.name}(", ",", ")`") ) else "`case _: " + (clazz.typeParams match { case Nil => "" + clazz.name - case xs => xs map (_ => "_") mkString (clazz.name + "[", ",", "]") + case xs => xs.map(_ => "_").mkString(clazz.name + "[", ",", "]") })+ "`" if (!clazz.exists) "" diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala index 07d1ffbc757a..48cbabe0cfca 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala @@ -2775,7 +2775,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper // applyOrElse's default parameter: val B1 = methodSym newTypeParameter (newTypeName("B1")) setInfo TypeBounds.empty - val default = methodSym newValueParameter (newTermName("default"), tree.pos.focus, SYNTHETIC) setInfo functionType(List(A1.tpe), B1.tpe) + val default = methodSym.newValueParameter(newTermName("default"), tree.pos.focus, SYNTHETIC) setInfo functionType(List(A1.tpe), B1.tpe) val paramSyms = List(x, default) methodSym setInfo genPolyType(List(A1, B1), MethodType(paramSyms, B1.tpe)) diff --git a/src/compiler/scala/tools/reflect/ToolBoxFactory.scala b/src/compiler/scala/tools/reflect/ToolBoxFactory.scala index 1024507b8b53..78157272ce83 100644 --- a/src/compiler/scala/tools/reflect/ToolBoxFactory.scala +++ b/src/compiler/scala/tools/reflect/ToolBoxFactory.scala @@ -246,7 +246,7 @@ abstract class ToolBoxFactory[U <: JavaUniverse](val u: U) { factorySelf => case _ => NoSymbol } trace("wrapping ")(defOwner(expr) -> meth) - val methdef = DefDef(meth, expr changeOwner (defOwner(expr), meth)) + val methdef = DefDef(meth, expr.changeOwner(defOwner(expr), meth)) val moduledef = ModuleDef( obj, diff --git a/src/interactive/scala/tools/nsc/interactive/Global.scala b/src/interactive/scala/tools/nsc/interactive/Global.scala index 3ed06f8a7aab..157683206cd5 100644 --- a/src/interactive/scala/tools/nsc/interactive/Global.scala +++ b/src/interactive/scala/tools/nsc/interactive/Global.scala @@ -876,10 +876,10 @@ class Global(settings: Settings, _reporter: Reporter, projectName: String = "") sym.isType || { try { val tp1 = pre.memberType(alt) onTypeError NoType - val tp2 = adaptToNewRunMap(sym.tpe) substSym (originalTypeParams, sym.owner.typeParams) + val tp2 = adaptToNewRunMap(sym.tpe).substSym(originalTypeParams, sym.owner.typeParams) matchesType(tp1, tp2, alwaysMatchSimple = false) || { debugLog(s"findMirrorSymbol matchesType($tp1, $tp2) failed") - val tp3 = adaptToNewRunMap(sym.tpe) substSym (originalTypeParams, alt.owner.typeParams) + val tp3 = adaptToNewRunMap(sym.tpe).substSym(originalTypeParams, alt.owner.typeParams) matchesType(tp1, tp3, alwaysMatchSimple = false) || { debugLog(s"findMirrorSymbol fallback matchesType($tp1, $tp3) failed") false diff --git a/src/library/scala/runtime/ScalaRunTime.scala b/src/library/scala/runtime/ScalaRunTime.scala index 2ee3891b3c8b..578ae7e29017 100644 --- a/src/library/scala/runtime/ScalaRunTime.scala +++ b/src/library/scala/runtime/ScalaRunTime.scala @@ -14,14 +14,14 @@ package scala package runtime import scala.collection.{AbstractIterator, AnyConstr, SortedOps, StrictOptimizedIterableOps, StringOps, StringView, View} +import scala.collection.generic.IsIterable import scala.collection.immutable.{ArraySeq, NumericRange} import scala.collection.mutable.StringBuilder +import scala.math.min import scala.reflect.{ClassTag, classTag} import java.lang.{Class => jClass} import java.lang.reflect.{Method => JMethod} -import scala.collection.generic.IsIterable - /** The object ScalaRunTime provides support methods required by * the scala runtime. All these methods should be considered * outside the API and subject to change or removal without notice. @@ -239,7 +239,7 @@ object ScalaRunTime { // Special casing Unit arrays, the value class which uses a reference array type. def arrayToString(x: AnyRef) = { if (x.getClass.getComponentType == classOf[BoxedUnit]) - 0 until (array_length(x) min maxElements) map (_ => "()") mkString ("Array(", ", ", ")") + (0 until min(array_length(x), maxElements)).map(_ => "()").mkString("Array(", ", ", ")") else x.asInstanceOf[Array[_]].iterator.take(maxElements).map(inner).mkString("Array(", ", ", ")") } @@ -254,10 +254,10 @@ object ScalaRunTime { case x: String => if (x.head.isWhitespace || x.last.isWhitespace) "\"" + x + "\"" else x case x if useOwnToString(x) => x.toString case x: AnyRef if isArray(x) => arrayToString(x) - case x: scala.collection.Map[_, _] => x.iterator take maxElements map mapInner mkString (x.collectionClassName + "(", ", ", ")") - case x: Iterable[_] => x.iterator take maxElements map inner mkString (x.collectionClassName + "(", ", ", ")") + case x: scala.collection.Map[_, _] => x.iterator.take(maxElements).map(mapInner).mkString(x.collectionClassName + "(", ", ", ")") + case x: Iterable[_] => x.iterator.take(maxElements).map(inner).mkString(x.collectionClassName + "(", ", ", ")") case x: Product1[_] if isTuple(x) => "(" + inner(x._1) + ",)" // that special trailing comma - case x: Product if isTuple(x) => x.productIterator map inner mkString ("(", ",", ")") + case x: Product if isTuple(x) => x.productIterator.map(inner).mkString("(", ",", ")") case x => x.toString } diff --git a/src/partest/scala/tools/partest/DirectTest.scala b/src/partest/scala/tools/partest/DirectTest.scala index c4c30ae12cc0..ee7c16cb2f8d 100644 --- a/src/partest/scala/tools/partest/DirectTest.scala +++ b/src/partest/scala/tools/partest/DirectTest.scala @@ -17,6 +17,7 @@ import scala.tools.cmd.CommandLineParser import scala.tools.nsc._ import scala.tools.nsc.reporters.{ConsoleReporter, Reporter} import scala.tools.nsc.settings.ScalaVersion +import scala.util.chaining._ /** Test with code which is embedded as a string. * @@ -46,12 +47,10 @@ abstract class DirectTest { // a default Settings object def settings: Settings = newSettings(CommandLineParser tokenize extraSettings) // a custom Settings object - def newSettings(args: List[String]) = { - val s = new Settings + def newSettings(args: List[String]) = (new Settings).tap { s => val allArgs = args ++ (CommandLineParser tokenize debugSettings) log("newSettings: allArgs = " + allArgs) - s processArguments (allArgs, true) - s + s.processArguments(allArgs, true) } // new compiler def newCompiler(args: String*): Global = { diff --git a/src/partest/scala/tools/partest/nest/Runner.scala b/src/partest/scala/tools/partest/nest/Runner.scala index b4a276e381ac..78885b196013 100644 --- a/src/partest/scala/tools/partest/nest/Runner.scala +++ b/src/partest/scala/tools/partest/nest/Runner.scala @@ -364,7 +364,7 @@ class Runner(val testInfo: TestInfo, val suiteRunner: AbstractRunner) { // Apply judiciously; there are line comments in the "stub implementations" error output. val slashes = """[/\\]+""".r - def squashSlashes(s: String) = slashes replaceAllIn (s, "/") + def squashSlashes(s: String) = slashes.replaceAllIn(s, "/") // this string identifies a path and is also snipped from log output. val elided = parentFile.getAbsolutePath @@ -374,14 +374,12 @@ class Runner(val testInfo: TestInfo, val suiteRunner: AbstractRunner) { // no spaces in test file paths below root, because otherwise how to detect end of path string? val pathFinder = raw"""(?i)\Q${elided}${File.separator}\E([\${File.separator}\S]*)""".r - def canonicalize(s: String): String = ( - pathFinder replaceAllIn (s, m => - Regex.quoteReplacement(ellipsis + squashSlashes(m group 1))) - ) + def canonicalize(s: String): String = + pathFinder.replaceAllIn(s, m => Regex.quoteReplacement(ellipsis + squashSlashes(m group 1))) def masters = { val files = List(new File(parentFile, "filters"), new File(suiteRunner.pathSettings.srcDir.path, "filters")) - files filter (_.exists) flatMap (_.fileLines) map (_.trim) filter (s => !(s startsWith "#")) + files.filter(_.exists).flatMap(_.fileLines).map(_.trim).filter(s => !(s startsWith "#")) } val filters = toolArgs("filter", split = false) ++ masters val elisions = ListBuffer[String]() @@ -398,7 +396,7 @@ class Runner(val testInfo: TestInfo, val suiteRunner: AbstractRunner) { if (suiteRunner.verbose && elisions.nonEmpty) { import suiteRunner.log._ val emdash = bold(yellow("--")) - pushTranscript(s"filtering ${logFile.getName}$EOL${elisions mkString (emdash, EOL + emdash, EOL)}") + pushTranscript(s"filtering ${logFile.getName}$EOL${elisions.mkString(emdash, EOL + emdash, EOL)}") } } diff --git a/src/partest/scala/tools/partest/package.scala b/src/partest/scala/tools/partest/package.scala index 4a53355a2078..45205a93f1f7 100644 --- a/src/partest/scala/tools/partest/package.scala +++ b/src/partest/scala/tools/partest/package.scala @@ -115,10 +115,9 @@ package object partest { } implicit class ExecutorOps(val executor: ExecutorService) { - def awaitTermination[A](wait: Duration)(failing: => A = ()): Option[A] = ( - if (executor awaitTermination (wait.length, wait.unit)) None + def awaitTermination[A](wait: Duration)(failing: => A = ()): Option[A] = + if (executor.awaitTermination(wait.length, wait.unit)) None else Some(failing) - ) } implicit def temporaryPath2File(x: Path): File = x.jfile diff --git a/src/reflect/scala/reflect/internal/AnnotationInfos.scala b/src/reflect/scala/reflect/internal/AnnotationInfos.scala index 40f90f133b67..ba89438fb650 100644 --- a/src/reflect/scala/reflect/internal/AnnotationInfos.scala +++ b/src/reflect/scala/reflect/internal/AnnotationInfos.scala @@ -146,7 +146,7 @@ trait AnnotationInfos extends api.Annotations { self: SymbolTable => private[scala] def completeAnnotationToString(annInfo: AnnotationInfo) = { import annInfo._ val s_args = if (!args.isEmpty) args.mkString("(", ", ", ")") else "" - val s_assocs = if (!assocs.isEmpty) (assocs map { case (x, y) => s"$x = $y" } mkString ("(", ", ", ")")) else "" + val s_assocs = if (!assocs.isEmpty) assocs.map { case (x, y) => s"$x = $y" }.mkString("(", ", ", ")") else "" s"${atp}${s_args}${s_assocs}" } diff --git a/src/reflect/scala/reflect/internal/Definitions.scala b/src/reflect/scala/reflect/internal/Definitions.scala index e3ce59e7cd8b..c7e78e0f6d27 100644 --- a/src/reflect/scala/reflect/internal/Definitions.scala +++ b/src/reflect/scala/reflect/internal/Definitions.scala @@ -1203,7 +1203,7 @@ trait Definitions extends api.StandardDefinitions { normalizedParents(parents) mkString " with " def valueParamsString(tp: Type) = tp match { - case MethodType(params, _) => params map (_.defString) mkString ("(", ", ", ")") + case MethodType(params, _) => params.map(_.defString).mkString("(", ", ", ")") case _ => "" } diff --git a/src/reflect/scala/reflect/internal/Kinds.scala b/src/reflect/scala/reflect/internal/Kinds.scala index 81d07d972199..51bcf98ec74f 100644 --- a/src/reflect/scala/reflect/internal/Kinds.scala +++ b/src/reflect/scala/reflect/internal/Kinds.scala @@ -77,7 +77,7 @@ trait Kinds { private def buildMessage(xs: List[SymPair], f: (Symbol, Symbol) => String) = ( if (xs.isEmpty) "" - else xs map f.tupled mkString ("\n", ", ", "") + else xs.map(f.tupled).mkString("\n", ", ", "") ) def errorMessage(targ: Type, tparam: Symbol): String = ( diff --git a/src/reflect/scala/reflect/internal/Mirrors.scala b/src/reflect/scala/reflect/internal/Mirrors.scala index 56c6ec8a2e82..e7d434ca3a95 100644 --- a/src/reflect/scala/reflect/internal/Mirrors.scala +++ b/src/reflect/scala/reflect/internal/Mirrors.scala @@ -51,7 +51,7 @@ trait Mirrors extends api.Mirrors { getModuleOrClass(path.toString, len, path.newName(_)) private def getModuleOrClass(path: String, len: Int, toName: String => Name): Symbol = { - val point = path lastIndexOf ('.', len - 1) + val point = path.lastIndexOf('.', len - 1) val owner = if (point > 0) getModuleOrClass(path, point, newTermName(_)) else RootClass diff --git a/src/reflect/scala/reflect/internal/Symbols.scala b/src/reflect/scala/reflect/internal/Symbols.scala index 29d648439332..2cedfc5478be 100644 --- a/src/reflect/scala/reflect/internal/Symbols.scala +++ b/src/reflect/scala/reflect/internal/Symbols.scala @@ -1819,9 +1819,8 @@ trait Symbols extends api.Symbols { self: SymbolTable => } val oldsyms = oldsymbuf.toList val newsyms = newsymbuf.toList - for (sym <- newsyms) { - addMember(thistp, tp, sym modifyInfo (_ substThisAndSym(this, thistp, oldsyms, newsyms))) - } + for (sym <- newsyms) + addMember(thistp, tp, sym.modifyInfo(_.substThisAndSym(this, thistp, oldsyms, newsyms))) } tp } diff --git a/src/reflect/scala/reflect/internal/TypeDebugging.scala b/src/reflect/scala/reflect/internal/TypeDebugging.scala index ebb8c16b4f5b..98e686b61010 100644 --- a/src/reflect/scala/reflect/internal/TypeDebugging.scala +++ b/src/reflect/scala/reflect/internal/TypeDebugging.scala @@ -85,7 +85,7 @@ trait TypeDebugging { // otherwise case classes are caught looking like products case _: Tree | _: Type => "" + x case x: IterableOnce[_] => x.iterator mkString ", " - case x: Product => x.productIterator mkString ("(", ", ", ")") + case x: Product => x.productIterator.mkString("(", ", ", ")") case _ => "" + x } def ptBlock(label: String, pairs: (String, Any)*): String = { diff --git a/src/reflect/scala/reflect/internal/Types.scala b/src/reflect/scala/reflect/internal/Types.scala index 47d08b8de35a..df504a1b6266 100644 --- a/src/reflect/scala/reflect/internal/Types.scala +++ b/src/reflect/scala/reflect/internal/Types.scala @@ -1567,8 +1567,8 @@ trait Types */ private[internal] def starNotation(typeString: Type => String): String = { if (emptyLowerBound && emptyUpperBound) "" - else if (emptyLowerBound) "(" + typeString(hi) + ")" - else "(%s, %s)" format (typeString(lo), typeString(hi)) + else if (emptyLowerBound) s"(${typeString(hi)})" + else s"(${typeString(lo)}, ${typeString(hi)})" } override def kind = "TypeBoundsType" override def mapOver(map: TypeMap): Type = { @@ -2640,7 +2640,7 @@ trait Types private def refinementDecls = fullyInitializeScope(decls) filter (sym => sym.isPossibleInRefinement && sym.isPublic) private def refinementString = ( if (sym.isStructuralRefinement) - refinementDecls map (_.defString) mkString("{", "; ", "}") + refinementDecls.map(_.defString).mkString("{", "; ", "}") else "" ) protected def finishPrefix(rest: String) = ( @@ -3146,7 +3146,7 @@ trait Types } private def existentialClauses = { - val str = quantified map (_.existentialToString) mkString (" forSome { ", "; ", " }") + val str = quantified.map(_.existentialToString).mkString(" forSome { ", "; ", " }") if (settings.explaintypes) "(" + str + ")" else str } @@ -3747,7 +3747,7 @@ trait Types private def tparamsOfSym(sym: Symbol) = sym.info match { case PolyType(tparams, _) if !tparams.isEmpty => - tparams map (_.defString) mkString("[", ",", "]") + tparams.map(_.defString).mkString("[", ",", "]") case _ => "" } def originName = origin.typeSymbolDirect.decodedName @@ -4426,7 +4426,7 @@ trait Types case _: ConstantType => tp // Java enum constants: don't widen to the enum type! case _ => tp.widen // C.X.type widens to C.this.X.type, otherwise `tp asSeenFrom (pre, C)` has no effect. } - val memType = widened asSeenFrom (pre, tp.typeSymbol.owner) + val memType = widened.asSeenFrom(pre, tp.typeSymbol.owner) if (tp eq widened) memType else memType.narrow } else loop(tp.prefix) memberType tp.typeSymbol diff --git a/src/reflect/scala/reflect/internal/transform/Erasure.scala b/src/reflect/scala/reflect/internal/transform/Erasure.scala index e6d3496e4662..977dc10f4268 100644 --- a/src/reflect/scala/reflect/internal/transform/Erasure.scala +++ b/src/reflect/scala/reflect/internal/transform/Erasure.scala @@ -144,7 +144,7 @@ trait Erasure { else if (sym.isRefinementClass) apply(mergeParents(tp.parents)) else if (sym.isDerivedValueClass) eraseDerivedValueClassRef(tref) else if (sym.isClass) eraseNormalClassRef(tref) - else apply(sym.info asSeenFrom (pre, sym.owner)) // alias type or abstract type + else apply(sym.info.asSeenFrom(pre, sym.owner)) // alias type or abstract type case PolyType(tparams, restpe) => apply(restpe) case ExistentialType(tparams, restpe) => diff --git a/src/reflect/scala/reflect/runtime/JavaMirrors.scala b/src/reflect/scala/reflect/runtime/JavaMirrors.scala index 7b1bfab2d2c6..f68959a2382e 100644 --- a/src/reflect/scala/reflect/runtime/JavaMirrors.scala +++ b/src/reflect/scala/reflect/runtime/JavaMirrors.scala @@ -693,7 +693,7 @@ private[scala] trait JavaMirrors extends internal.SymbolTable with api.JavaUnive val tparam = sOwner(jtvar).newTypeParameter(newTypeName(jtvar.getName)) .setInfo(new TypeParamCompleter(jtvar)) markFlagsCompleted(tparam)(mask = AllFlags) - tparamCache enter (jtvar, tparam) + tparamCache.enter(jtvar, tparam) tparam } @@ -1206,7 +1206,7 @@ private[scala] trait JavaMirrors extends internal.SymbolTable with api.JavaUnive private def jmethodAsScala1(jmeth: jMethod): MethodSymbol = { val clazz = sOwner(jmeth) val meth = clazz.newMethod(newTermName(jmeth.getName), NoPosition, jmeth.scalaFlags) - methodCache enter (jmeth, meth) + methodCache.enter(jmeth, meth) val tparams = jmeth.getTypeParameters.toList map createTypeParameter val params = jparamsAsScala(meth, jmeth.getParameters.toList) val resulttpe = typeToScala(jmeth.getGenericReturnType) @@ -1232,7 +1232,7 @@ private[scala] trait JavaMirrors extends internal.SymbolTable with api.JavaUnive // [Martin] Note: I know there's a lot of duplication wrt jmethodAsScala, but don't think it's worth it to factor this out. val clazz = sOwner(jconstr) val constr = clazz.newConstructor(NoPosition, jconstr.scalaFlags) - constructorCache enter (jconstr, constr) + constructorCache.enter(jconstr, constr) val tparams = jconstr.getTypeParameters.toList map createTypeParameter val params = jparamsAsScala(constr, jconstr.getParameters.toList) setMethType(constr, tparams, params, clazz.tpe) @@ -1337,10 +1337,10 @@ private[scala] trait JavaMirrors extends internal.SymbolTable with api.JavaUnive val jclazz = classToJava(meth.owner.asClass) val paramClasses = transformedType(meth).paramTypes map typeToJavaClass val jname = meth.name.dropLocal.toString - try jclazz getDeclaredMethod (jname, paramClasses: _*) + try jclazz.getDeclaredMethod(jname, paramClasses: _*) catch { case ex: NoSuchMethodException => - jclazz getDeclaredMethod (expandedName(meth), paramClasses: _*) + jclazz.getDeclaredMethod(expandedName(meth), paramClasses: _*) } } diff --git a/src/repl-frontend/scala/tools/nsc/interpreter/shell/JavapClass.scala b/src/repl-frontend/scala/tools/nsc/interpreter/shell/JavapClass.scala index 34a76e721c41..4b96dd731d6c 100644 --- a/src/repl-frontend/scala/tools/nsc/interpreter/shell/JavapClass.scala +++ b/src/repl-frontend/scala/tools/nsc/interpreter/shell/JavapClass.scala @@ -491,11 +491,11 @@ class JavapTask(val loader: ScalaClassLoader, intp: Repl) extends JavapTool { // DisassemblerTool.getStandardFileManager(reporter,locale,charset) val defaultFileManager: JavaFileManager = - (loader.tryToLoadClass[JavaFileManager]("com.sun.tools.javap.JavapFileManager").get getMethod ( + (loader.tryToLoadClass[JavaFileManager]("com.sun.tools.javap.JavapFileManager").get.getMethod( "create", classOf[DiagnosticListener[_]], classOf[PrintWriter] - ) invoke (null, reporter, new PrintWriter(System.err, true))).asInstanceOf[JavaFileManager] + ).invoke(null, reporter, new PrintWriter(System.err, true))).asInstanceOf[JavaFileManager] // manages named arrays of bytes, which might have failed to load class JavapFileManager(val managed: Seq[Input])(delegate: JavaFileManager = defaultFileManager) diff --git a/src/repl-frontend/scala/tools/nsc/interpreter/shell/Scripted.scala b/src/repl-frontend/scala/tools/nsc/interpreter/shell/Scripted.scala index b1348adb38da..5587c8333c9c 100644 --- a/src/repl-frontend/scala/tools/nsc/interpreter/shell/Scripted.scala +++ b/src/repl-frontend/scala/tools/nsc/interpreter/shell/Scripted.scala @@ -214,7 +214,7 @@ class Scripted(@BeanProperty val factory: ScriptEngineFactory, settings: Setting override def eval(context: ScriptContext) = withScriptContext(context) { if (!first) - intp.addBackReferences(req) fold ( + intp.addBackReferences(req).fold( { line => Scripted.this.eval(line); null }, // we're evaluating after recording the request instead of other way around, but that should be ok, right? evalAndRecord(context, _)) else try evalAndRecord(context, req) finally first = false diff --git a/src/repl/scala/tools/nsc/interpreter/IMain.scala b/src/repl/scala/tools/nsc/interpreter/IMain.scala index 959cd2e6fdc3..7d93e8e5acad 100644 --- a/src/repl/scala/tools/nsc/interpreter/IMain.scala +++ b/src/repl/scala/tools/nsc/interpreter/IMain.scala @@ -1324,7 +1324,7 @@ class IMain(val settings: Settings, parentClassLoaderOverride: Option[ClassLoade val termMsg = if (terms.isEmpty) "" else s"${terms.size} terms" val implicitMsg = if (imps.isEmpty) "" else s"${imps.size} are implicit" val foundMsg = if (found.isEmpty) "" else found.mkString(" // imports: ", ", ", "") - val statsMsg = List(typeMsg, termMsg, implicitMsg) filterNot (_ == "") mkString ("(", ", ", ")") + val statsMsg = List(typeMsg, termMsg, implicitMsg).filterNot(_ == "").mkString("(", ", ", ")") f"${idx + 1}%2d) ${handler.importString}%-30s $statsMsg$foundMsg" } diff --git a/src/scaladoc/scala/tools/nsc/doc/model/ModelFactory.scala b/src/scaladoc/scala/tools/nsc/doc/model/ModelFactory.scala index dfbbb0d9af78..04a83d795213 100644 --- a/src/scaladoc/scala/tools/nsc/doc/model/ModelFactory.scala +++ b/src/scaladoc/scala/tools/nsc/doc/model/ModelFactory.scala @@ -209,7 +209,7 @@ class ModelFactory(val global: Global, val settings: doc.Settings) { case d: MemberEntity with Def => val paramLists: List[String] = if (d.valueParams.isEmpty) Nil - else d.valueParams map (ps => ps map (_.resultType.name) mkString ("(",",",")")) + else d.valueParams.map(ps => ps.map(_.resultType.name).mkString("(",",",")")) paramLists.mkString case _ => "" } diff --git a/test/benchmarks/src/main/scala/scala/collection/immutable/HashMapBulkBenchmark.scala b/test/benchmarks/src/main/scala/scala/collection/immutable/HashMapBulkBenchmark.scala index 9411681ad96a..9c653f359046 100644 --- a/test/benchmarks/src/main/scala/scala/collection/immutable/HashMapBulkBenchmark.scala +++ b/test/benchmarks/src/main/scala/scala/collection/immutable/HashMapBulkBenchmark.scala @@ -187,7 +187,7 @@ abstract class HashMapBaseBulkBenchmark { def base (i:Int) = { baseData(if (i < 0) baseData.length+i else i) } - shared(0) = (-10 to (0, 1)).foldLeft (base(-10)) {case (a, b) => a ++ base(b)} + shared(0) = (-10.to(0, 1)).foldLeft(base(-10)) { case (a, b) => a ++ base(b) } for (i <- 1 until baseData.length - 10) { shared(i) = shared(i - 1) -- base(i - 10).keys ++ base(i) } diff --git a/test/benchmarks/src/main/scala/scala/collection/immutable/MapAppendBenchmark.scala b/test/benchmarks/src/main/scala/scala/collection/immutable/MapAppendBenchmark.scala index a6aaf1a664a1..f7669233646a 100644 --- a/test/benchmarks/src/main/scala/scala/collection/immutable/MapAppendBenchmark.scala +++ b/test/benchmarks/src/main/scala/scala/collection/immutable/MapAppendBenchmark.scala @@ -43,7 +43,7 @@ class MapAppendBenchmark { var m = Map.empty[Int, Unit] var i = 0 while(i < size) { - m = m + ((i -> ()), ((i+size) -> ())) + m = m.+((i -> ()), ((i+size) -> ())) i += 1 } bh.consume(m) @@ -54,7 +54,7 @@ class MapAppendBenchmark { var m = Map.empty[Int, Unit] var i = 0 while(i < size) { - m = m + ((i -> ()), ((i+size) -> ()), empty: _*) + m = m.+((i -> ()), ((i+size) -> ()), empty: _*) i += 1 } bh.consume(m) diff --git a/test/junit/scala/collection/IteratorTest.scala b/test/junit/scala/collection/IteratorTest.scala index 23ce1a97b24e..4f9c9cef57af 100644 --- a/test/junit/scala/collection/IteratorTest.scala +++ b/test/junit/scala/collection/IteratorTest.scala @@ -12,6 +12,8 @@ import Seq.empty @RunWith(classOf[JUnit4]) class IteratorTest { + private def from0 = Iterator.from(0) + @Test def groupedIteratorShouldNotAskForUnneededElement(): Unit = { var counter = 0 val it = new Iterator[Int] { var i = 0 ; def hasNext = { counter = i; true } ; def next() = { i += 1; i } } @@ -48,16 +50,16 @@ class IteratorTest { } @Test def sliceIsChainable(): Unit = { - assertSameElements(3 to 6, Iterator from 0 slice (3, 7)) - assertSameElements(empty, Iterator from 0 slice (3, 3)) - assertSameElements(0 to 2, Iterator from 0 slice (-1, 3)) - assertSameElements(empty, Iterator from 0 slice (3, -1)) - assertSameElements(6 to 12 by 2, Iterator from 0 slice (3, 7) map (2 * _)) - assertSameElements(6 to 12 by 2, Iterator from 0 map (2 * _) slice (3, 7)) - assertSameElements(4 to 6, Iterator from 0 slice (3, 7) drop 1) - assertSameElements(4 to 7, Iterator from 0 drop 1 slice (3, 7)) - assertSameElements(4 to 5, Iterator from 0 slice (3, 7) slice (1, 3)) - assertSameElements(4 to 6, Iterator from 0 slice (3, 7) slice (1, 10)) + assertSameElements(3 to 6, from0.slice(3, 7)) + assertSameElements(empty, from0.slice(3, 3)) + assertSameElements(0 to 2, from0.slice(-1, 3)) + assertSameElements(empty, from0.slice(3, -1)) + assertSameElements(6 to 12 by 2, from0.slice(3, 7).map(2 * _)) + assertSameElements(6 to 12 by 2, from0.map(2 * _).slice(3, 7)) + assertSameElements(4 to 6, from0.slice(3, 7).drop(1)) + assertSameElements(4 to 7, from0.drop(1).slice(3, 7)) + assertSameElements(4 to 5, from0.slice(3, 7).slice(1, 3)) + assertSameElements(4 to 6, from0.slice(3, 7).slice(1, 10)) } // test/files/run/iterator-concat.scala diff --git a/test/junit/scala/collection/SetMapConsistencyTest.scala b/test/junit/scala/collection/SetMapConsistencyTest.scala index afd80aabf804..5718d1acfb63 100644 --- a/test/junit/scala/collection/SetMapConsistencyTest.scala +++ b/test/junit/scala/collection/SetMapConsistencyTest.scala @@ -396,7 +396,7 @@ class SetMapConsistencyTest { assert { val lm2 = new LongMap[String](_.toString) - lm2 += (5L -> "fish", 0L -> "unicorn") + lm2.+=(5L -> "fish", 0L -> "unicorn") val hm2 = (new HashMap[Long,String]) ++= lm2 List(Long.MinValue, 0L, 1L, 5L).forall(i => lm2.get(i) == hm2.get(i) && @@ -443,7 +443,7 @@ class SetMapConsistencyTest { assert { val arm2 = new AnyRefMap[String, String](x => if (x==null) "null" else x) - arm2 += ("cod" -> "fish", "Rarity" -> "unicorn") + arm2.+=("cod" -> "fish", "Rarity" -> "unicorn") val hm2 = (new HashMap[String,String]) ++= arm2 List(null, "cod", "sparrow", "Rarity").forall { i => //println((arm2.get(i), hm2.get(i))) @@ -519,10 +519,10 @@ class SetMapConsistencyTest { @Test def testSI8815(): Unit = { val lm = new scala.collection.mutable.LongMap[String] - lm += (Long.MinValue, "min") - lm += (-1, "neg-one") - lm += (0, "zero") - lm += (Long.MaxValue, "max") + lm.+=(Long.MinValue, "min") + lm.+=(-1, "neg-one") + lm.+=(0, "zero") + lm.+=(Long.MaxValue, "max") var nit = 0 lm.iterator.foreach(_ => nit += 1) var nfe = 0 diff --git a/test/junit/scala/collection/immutable/IndexedSeqTest.scala b/test/junit/scala/collection/immutable/IndexedSeqTest.scala index 65284eb98d79..27e64fcf4e24 100644 --- a/test/junit/scala/collection/immutable/IndexedSeqTest.scala +++ b/test/junit/scala/collection/immutable/IndexedSeqTest.scala @@ -4,7 +4,6 @@ import org.junit._ import Assert._ import scala.collection.Seq.empty -import scala.language.postfixOps import scala.tools.testkit.AssertUtil._ import scala.tools.testkit.AllocationTest @@ -102,40 +101,40 @@ class IndexedSeqTest extends AllocationTest { def generateTestIter = (0 to 10).view iterator - assertSameElements(empty toList, generateTestIter slice (3, -1)) - assertSameElements(empty toList, generateTestIter slice (0, 0)) - assertSameElements(empty, generateTestIter slice (3, 3)) - assertSameElements(List(0) , generateTestIter slice (0, 1)) - assertSameElements(0 to 1 , generateTestIter slice (0, 2)) - assertSameElements(3 to 6 toList, generateTestIter slice(3,7)) - assertSameElements(0 to 2 toList, generateTestIter slice (-1, 3)) - assertSameElements(0 to 10 toList, generateTestIter slice (0, 11)) - assertSameElements(6 to 12 by 2 toList, generateTestIter slice (3, 7) map (2 * _)) - assertSameElements(6 to 12 by 2 toList, generateTestIter map (2 * _) slice (3, 7)) - assertSameElements(4 to 6 toList, generateTestIter slice (3, 7) drop 1) - assertSameElements(4 to 7 toList, generateTestIter drop 1 slice (3, 7)) - assertSameElements(4 to 5 toList, generateTestIter slice (3, 7) slice (1, 3)) - assertSameElements(4 to 6 toList, generateTestIter slice (3, 7) slice (1, 10)) + assertSameElements(empty.toList, generateTestIter.slice(3, -1)) + assertSameElements(empty.toList, generateTestIter.slice(0, 0)) + assertSameElements(empty, generateTestIter.slice(3, 3)) + assertSameElements(List(0), generateTestIter.slice(0, 1)) + assertSameElements(0 to 1, generateTestIter.slice(0, 2)) + assertSameElements((3 to 6).toList, generateTestIter.slice(3,7)) + assertSameElements((0 to 2).toList, generateTestIter.slice(-1, 3)) + assertSameElements((0 to 10).toList, generateTestIter.slice(0, 11)) + assertSameElements((6 to 12 by 2).toList, generateTestIter.slice(3, 7).map(2 * _)) + assertSameElements((6 to 12 by 2).toList, generateTestIter.map(2 * _).slice(3, 7)) + assertSameElements((4 to 6).toList, generateTestIter.slice(3, 7).drop(1)) + assertSameElements((4 to 7).toList, generateTestIter.drop(1).slice(3, 7)) + assertSameElements((4 to 5).toList, generateTestIter.slice(3, 7).slice(1, 3)) + assertSameElements((4 to 6).toList, generateTestIter.slice(3, 7).slice(1, 10)) } @Test def testbackwardSliceEquals(): Unit = { def generateTestIter = (0 to 10).view reverseIterator - assertSameElements(empty toList, generateTestIter slice (3, -1)) - assertSameElements(empty toList, generateTestIter slice (3, 2)) - assertSameElements(empty, generateTestIter slice (0, 0)) - assertSameElements(empty, generateTestIter slice (3, 3)) - assertSameElements(List(10) , generateTestIter slice (0, 1)) - assertSameElements(10 to 9 by -1 , generateTestIter slice (0, 2)) - assertSameElements(7 to 4 by -1 toList, generateTestIter slice(3,7)) - assertSameElements(10 to 8 by -1 toList, generateTestIter slice (-1, 3)) - assertSameElements(14 to 8 by -2 toList, generateTestIter slice (3, 7) map (2 * _)) - assertSameElements(14 to 8 by -2 toList, generateTestIter map (2 * _) slice (3, 7)) - assertSameElements(6 to 4 by -1 toList, generateTestIter slice (3, 7) drop 1) - assertSameElements(6 to 3 by -1 toList, generateTestIter drop 1 slice (3, 7)) - assertSameElements(6 to 5 by -1 toList, generateTestIter slice (3, 7) slice (1, 3)) - assertSameElements(6 to 4 by -1 toList, generateTestIter slice (3, 7) slice (1, 10)) + assertSameElements(empty.toList, generateTestIter.slice(3, -1)) + assertSameElements(empty.toList, generateTestIter.slice(3, 2)) + assertSameElements(empty, generateTestIter.slice(0, 0)) + assertSameElements(empty, generateTestIter.slice(3, 3)) + assertSameElements(List(10), generateTestIter.slice(0, 1)) + assertSameElements(10 to 9 by -1, generateTestIter.slice(0, 2)) + assertSameElements((7 to 4 by -1).toList, generateTestIter.slice(3,7)) + assertSameElements((10 to 8 by -1).toList, generateTestIter.slice(-1, 3)) + assertSameElements((14 to 8 by -2).toList, generateTestIter.slice(3, 7).map(2 * _)) + assertSameElements((14 to 8 by -2).toList, generateTestIter.map(2 * _).slice(3, 7)) + assertSameElements((6 to 4 by -1).toList, generateTestIter.slice(3, 7).drop(1)) + assertSameElements((6 to 3 by -1).toList, generateTestIter.drop(1).slice(3, 7)) + assertSameElements((6 to 5 by -1).toList, generateTestIter.slice(3, 7).slice(1, 3)) + assertSameElements((6 to 4 by -1).toList, generateTestIter.slice(3, 7).slice(1, 10)) } } diff --git a/test/junit/scala/collection/mutable/ArrayDequeTest.scala b/test/junit/scala/collection/mutable/ArrayDequeTest.scala index 9fc5b07ee149..c5e353ddb1ca 100644 --- a/test/junit/scala/collection/mutable/ArrayDequeTest.scala +++ b/test/junit/scala/collection/mutable/ArrayDequeTest.scala @@ -21,7 +21,7 @@ class ArrayDequeTest { assertEquals(buffer.reverse, buffer2.reverse) } - apply(_ += (1, 2, 3, 4, 5)) + apply(_.+=(1, 2, 3, 4, 5)) apply(_.prepend(6).prepend(7).prepend(8)) apply(_.trimStart(2)) apply(_.trimEnd(3)) diff --git a/test/junit/scala/collection/mutable/CollisionProofHashMapTest.scala b/test/junit/scala/collection/mutable/CollisionProofHashMapTest.scala index 8089d61ae2a9..135f9ebbef6b 100644 --- a/test/junit/scala/collection/mutable/CollisionProofHashMapTest.scala +++ b/test/junit/scala/collection/mutable/CollisionProofHashMapTest.scala @@ -125,7 +125,7 @@ class CollisionProofHashMapTest { assertEquals(m7(3), "c") // deprecated - val m8 = (m1 + (4 -> "d", 5 -> "e")).addOne(3 -> "c") + val m8 = m1.+(4 -> "d", 5 -> "e").addOne(3 -> "c") assertEquals(m8(3), "c") // deprecated diff --git a/test/scalacheck/range.scala b/test/scalacheck/range.scala index d3d5f794195e..3344d3be6315 100644 --- a/test/scalacheck/range.scala +++ b/test/scalacheck/range.scala @@ -10,15 +10,15 @@ class Counter(r: Range) { def apply(x: Int) = { cnt += 1L if (cnt % 500000000L == 0L) { - println("Working: %s %d %d" format (str, cnt, x)) + println(f"Working: $str $cnt%d $x%d") } if (cnt > (Int.MaxValue.toLong + 1) * 2) { - val msg = "Count exceeds maximum possible for an Int Range: %s" format str + val msg = s"Count exceeds maximum possible for an Int Range: $str" println(msg) // exception is likely to be eaten by an out of memory error sys error msg } if ((r.step > 0 && last.exists(_ > x)) || (r.step < 0 && last.exists(_ < x))) { - val msg = "Range %s wrapped: %d %s" format (str, x, last.toString) + val msg = f"Range $str wrapped: $x%d ${last.toString}" println(msg) // exception is likely to be eaten by an out of memory error sys error msg }