diff --git a/compiler/src/dotty/tools/dotc/ast/Desugar.scala b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
index ef8226229a7e..c0508c81d168 100644
--- a/compiler/src/dotty/tools/dotc/ast/Desugar.scala
+++ b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
@@ -776,18 +776,16 @@ object desugar {
* ==> r.op(l) if op is right-associative
*/
def binop(left: Tree, op: Ident, right: Tree)(implicit ctx: Context): Apply = {
- def assignToNamedArg(arg: Tree) = arg match {
+
+ def assignToNamedArg(arg: Tree): Tree = arg match {
case Assign(Ident(name), rhs) => cpy.NamedArg(arg)(name, rhs)
+ case Parens(arg1) => untpd.cpy.Parens(arg)(assignToNamedArg(arg1))
+ case Tuple(args) => untpd.cpy.Tuple(arg)(args.mapConserve(assignToNamedArg))
case _ => arg
}
- def makeOp(fn: Tree, arg: Tree, selectPos: Position) = {
- val args: List[Tree] = arg match {
- case Parens(arg) => assignToNamedArg(arg) :: Nil
- case Tuple(args) => args.mapConserve(assignToNamedArg)
- case _ => arg :: Nil
- }
- Apply(Select(fn, op.name).withPos(selectPos), args)
- }
+
+ def makeOp(fn: Tree, arg: Tree, selectPos: Position) =
+ Apply(Select(fn, op.name).withPos(selectPos), assignToNamedArg(arg))
if (isLeftAssoc(op.name))
makeOp(left, right, Position(left.pos.start, op.pos.end, op.pos.start))
@@ -1216,7 +1214,7 @@ object desugar {
*/
private object IdPattern {
def unapply(tree: Tree)(implicit ctx: Context): Option[VarInfo] = tree match {
- case id: Ident => Some(id, TypeTree())
+ case id: Ident => Some((id, TypeTree()))
case Typed(id: Ident, tpt) => Some((id, tpt))
case _ => None
}
diff --git a/compiler/src/dotty/tools/dotc/ast/TreeInfo.scala b/compiler/src/dotty/tools/dotc/ast/TreeInfo.scala
index d1e91799f31a..c50d154f2827 100644
--- a/compiler/src/dotty/tools/dotc/ast/TreeInfo.scala
+++ b/compiler/src/dotty/tools/dotc/ast/TreeInfo.scala
@@ -537,7 +537,7 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
object closure {
def unapply(tree: Tree): Option[(List[Tree], Tree, Tree)] = tree match {
case Block(_, expr) => unapply(expr)
- case Closure(env, meth, tpt) => Some(env, meth, tpt)
+ case Closure(env, meth, tpt) => Some((env, meth, tpt))
case Typed(expr, _) => unapply(expr)
case _ => None
}
diff --git a/compiler/src/dotty/tools/dotc/ast/tpd.scala b/compiler/src/dotty/tools/dotc/ast/tpd.scala
index a3be000dbbc2..3fbb091bb702 100644
--- a/compiler/src/dotty/tools/dotc/ast/tpd.scala
+++ b/compiler/src/dotty/tools/dotc/ast/tpd.scala
@@ -1009,8 +1009,8 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
/** An extractor that pulls out type arguments */
object MaybePoly {
def unapply(tree: Tree): Option[(Tree, List[Tree])] = tree match {
- case TypeApply(tree, targs) => Some(tree, targs)
- case _ => Some(tree, Nil)
+ case TypeApply(tree, targs) => Some((tree, targs))
+ case _ => Some((tree, Nil))
}
}
diff --git a/compiler/src/dotty/tools/dotc/core/Definitions.scala b/compiler/src/dotty/tools/dotc/core/Definitions.scala
index 95c5aa94dd37..f5eefa75c57c 100644
--- a/compiler/src/dotty/tools/dotc/core/Definitions.scala
+++ b/compiler/src/dotty/tools/dotc/core/Definitions.scala
@@ -436,7 +436,6 @@ class Definitions {
lazy val ArrayModuleType = ctx.requiredModuleRef("scala.Array")
def ArrayModule(implicit ctx: Context) = ArrayModuleType.symbol.moduleClass.asClass
-
lazy val UnitType: TypeRef = valueTypeRef("scala.Unit", BoxedUnitType, java.lang.Void.TYPE, UnitEnc, nme.specializedTypeNames.Void)
def UnitClass(implicit ctx: Context) = UnitType.symbol.asClass
def UnitModuleClass(implicit ctx: Context) = UnitType.symbol.asClass.linkedClass
@@ -776,7 +775,7 @@ class Definitions {
if (isFunctionClass(tsym)) {
val targs = ft.dealias.argInfos
if (targs.isEmpty) None
- else Some(targs.init, targs.last, tsym.name.isImplicitFunction, tsym.name.isErasedFunction)
+ else Some((targs.init, targs.last, tsym.name.isImplicitFunction, tsym.name.isErasedFunction))
}
else None
}
@@ -821,8 +820,8 @@ class Definitions {
case ArrayOf(elemtp) =>
def recur(elemtp: Type): Option[(Type, Int)] = elemtp.dealias match {
case TypeBounds(lo, hi) => recur(hi)
- case MultiArrayOf(finalElemTp, n) => Some(finalElemTp, n + 1)
- case _ => Some(elemtp, 1)
+ case MultiArrayOf(finalElemTp, n) => Some((finalElemTp, n + 1))
+ case _ => Some((elemtp, 1))
}
recur(elemtp)
case _ =>
@@ -879,6 +878,22 @@ class Definitions {
name.length > prefix.length &&
name.drop(prefix.length).forall(_.isDigit))
+ // Currently unused:
+ /** If `cls` has name s"$prefix$digits" where $digits is a valid integer, that
+ * that integer, otherwise -1.
+ */
+ def arity(cls: Symbol, prefix: String): Int =
+ scalaClassName(cls).applySimple(-1) { name =>
+ if (name.startsWith(prefix)) {
+ val digits = name.drop(prefix.length)
+ if (!digits.isEmpty && digits.forall(_.isDigit))
+ try digits.toString.toInt
+ catch { case ex: NumberFormatException => -1 }
+ else -1
+ }
+ else -1
+ }
+
def isBottomClass(cls: Symbol) =
cls == NothingClass || cls == NullClass
def isBottomType(tp: Type) =
diff --git a/compiler/src/dotty/tools/dotc/core/Denotations.scala b/compiler/src/dotty/tools/dotc/core/Denotations.scala
index 0443f346476e..1e6b8bf155f4 100644
--- a/compiler/src/dotty/tools/dotc/core/Denotations.scala
+++ b/compiler/src/dotty/tools/dotc/core/Denotations.scala
@@ -553,7 +553,7 @@ object Denotations {
val r = mergeDenot(this, that)
if (r.exists) r else MultiDenotation(this, that)
case that @ MultiDenotation(denot1, denot2) =>
- this & (denot1, pre) & (denot2, pre)
+ this .& (denot1, pre) .& (denot2, pre)
}
}
@@ -634,11 +634,11 @@ object Denotations {
else if (!that.exists) that
else this match {
case denot1 @ MultiDenotation(denot11, denot12) =>
- denot1.derivedUnionDenotation(denot11 | (that, pre), denot12 | (that, pre))
+ denot1.derivedUnionDenotation(denot11 .| (that, pre), denot12 .| (that, pre))
case denot1: SingleDenotation =>
that match {
case denot2 @ MultiDenotation(denot21, denot22) =>
- denot2.derivedUnionDenotation(this | (denot21, pre), this | (denot22, pre))
+ denot2.derivedUnionDenotation(this .| (denot21, pre), this .| (denot22, pre))
case denot2: SingleDenotation =>
unionDenot(denot1, denot2)
}
@@ -1180,7 +1180,7 @@ object Denotations {
final case class DenotUnion(denot1: PreDenotation, denot2: PreDenotation) extends MultiPreDenotation {
def exists = true
def toDenot(pre: Type)(implicit ctx: Context) =
- (denot1 toDenot pre) & (denot2 toDenot pre, pre)
+ (denot1 toDenot pre) .& (denot2 toDenot pre, pre)
def containsSym(sym: Symbol) =
(denot1 containsSym sym) || (denot2 containsSym sym)
type AsSeenFromResult = PreDenotation
@@ -1218,8 +1218,8 @@ object Denotations {
def hasAltWith(p: SingleDenotation => Boolean): Boolean =
denot1.hasAltWith(p) || denot2.hasAltWith(p)
def accessibleFrom(pre: Type, superAccess: Boolean)(implicit ctx: Context): Denotation = {
- val d1 = denot1 accessibleFrom (pre, superAccess)
- val d2 = denot2 accessibleFrom (pre, superAccess)
+ val d1 = denot1.accessibleFrom(pre, superAccess)
+ val d2 = denot2.accessibleFrom(pre, superAccess)
if (!d1.exists) d2
else if (!d2.exists) d1
else derivedUnionDenotation(d1, d2)
diff --git a/compiler/src/dotty/tools/dotc/core/NameOps.scala b/compiler/src/dotty/tools/dotc/core/NameOps.scala
index 584139248959..7a99f20bb2c9 100644
--- a/compiler/src/dotty/tools/dotc/core/NameOps.scala
+++ b/compiler/src/dotty/tools/dotc/core/NameOps.scala
@@ -58,6 +58,12 @@ object NameOps {
case _ => false
}
+ def applySimple[T](default: T)(f: SimpleName => T): T = name match {
+ case name: SimpleName => f(name)
+ case name: TypeName => name.toTermName.applySimple(default)(f)
+ case _ => default
+ }
+
def likeSpaced(n: PreName): N =
(if (name.isTermName) n.toTermName else n.toTypeName).asInstanceOf[N]
@@ -81,6 +87,13 @@ object NameOps {
}
}
+ /** Is name an operator name that does not start with a letter or `_` or `$`? */
+ def isSymbolic = name match {
+ case name: SimpleName =>
+ !Chars.isIdentifierStart(name.head) && NameTransformer.encode(name) != name
+ case _ => false
+ }
+
def isOpAssignmentName: Boolean = name match {
case raw.NE | raw.LE | raw.GE | EMPTY =>
false
@@ -110,7 +123,7 @@ object NameOps {
/** If flags is a ModuleClass but not a Package, add module class suffix */
def adjustIfModuleClass(flags: Flags.FlagSet): N = likeSpaced {
- if (flags is (ModuleClass, butNot = Package)) name.asTypeName.moduleClassName
+ if (flags.is(ModuleClass, butNot = Package)) name.asTypeName.moduleClassName
else name.toTermName.exclude(AvoidClashName)
}
diff --git a/compiler/src/dotty/tools/dotc/core/SymDenotations.scala b/compiler/src/dotty/tools/dotc/core/SymDenotations.scala
index 3064078ed403..550cb47427d3 100644
--- a/compiler/src/dotty/tools/dotc/core/SymDenotations.scala
+++ b/compiler/src/dotty/tools/dotc/core/SymDenotations.scala
@@ -190,7 +190,7 @@ object SymDenotations {
* in `butNot` are set?
*/
final def is(fs: FlagSet, butNot: FlagSet)(implicit ctx: Context) =
- (if (isCurrent(fs) && isCurrent(butNot)) myFlags else flags) is (fs, butNot)
+ (if (isCurrent(fs) && isCurrent(butNot)) myFlags else flags).is(fs, butNot)
/** Has this denotation all of the flags in `fs` set? */
final def is(fs: FlagConjunction)(implicit ctx: Context) =
@@ -200,7 +200,7 @@ object SymDenotations {
* in `butNot` are set?
*/
final def is(fs: FlagConjunction, butNot: FlagSet)(implicit ctx: Context) =
- (if (isCurrent(fs) && isCurrent(butNot)) myFlags else flags) is (fs, butNot)
+ (if (isCurrent(fs) && isCurrent(butNot)) myFlags else flags).is(fs, butNot)
/** The type info.
* The info is an instance of TypeType iff this is a type denotation
@@ -457,13 +457,13 @@ object SymDenotations {
/** Is symbol known to not exist, or potentially not completed yet? */
final def unforcedIsAbsent(implicit ctx: Context): Boolean =
myInfo == NoType ||
- (this is (ModuleVal, butNot = Package)) && moduleClass.unforcedIsAbsent
+ (this.is(ModuleVal, butNot = Package)) && moduleClass.unforcedIsAbsent
/** Is symbol known to not exist? */
final def isAbsent(implicit ctx: Context): Boolean = {
ensureCompleted()
(myInfo `eq` NoType) ||
- (this is (ModuleVal, butNot = Package)) && moduleClass.isAbsent
+ (this.is(ModuleVal, butNot = Package)) && moduleClass.isAbsent
}
/** Is this symbol the root class or its companion object? */
@@ -921,7 +921,7 @@ object SymDenotations {
* A local dummy owner is mapped to the primary constructor of the class.
*/
final def enclosingMethod(implicit ctx: Context): Symbol =
- if (this is (Method, butNot = Label)) symbol
+ if (this.is(Method, butNot = Label)) symbol
else if (this.isClass) primaryConstructor
else if (this.exists) owner.enclosingMethod
else NoSymbol
@@ -1352,7 +1352,7 @@ object SymDenotations {
// ----- denotation fields and accessors ------------------------------
- if (initFlags is (Module, butNot = Package))
+ if (initFlags.is(Module, butNot = Package))
assert(name.is(ModuleClassName), s"module naming inconsistency: ${name.debugString}")
/** The symbol asserted to have type ClassSymbol */
diff --git a/compiler/src/dotty/tools/dotc/core/TypeOps.scala b/compiler/src/dotty/tools/dotc/core/TypeOps.scala
index 498660c9d82b..0ae384c500bc 100644
--- a/compiler/src/dotty/tools/dotc/core/TypeOps.scala
+++ b/compiler/src/dotty/tools/dotc/core/TypeOps.scala
@@ -17,7 +17,7 @@ import util.Property
import collection.mutable
import ast.tpd._
import reporting.trace
-import reporting.diagnostic.Message
+import reporting.diagnostic.{Message, NoExplanation}
trait TypeOps { this: Context => // TODO: Make standalone object.
@@ -313,10 +313,6 @@ trait TypeOps { this: Context => // TODO: Make standalone object.
hasImport(ctx.withPhase(ctx.typerPhase)) || hasOption
}
- /** Is auto-tupling enabled? */
- def canAutoTuple =
- !featureEnabled(defn.LanguageModuleClass, nme.noAutoTupling)
-
def scala2Mode =
featureEnabled(defn.LanguageModuleClass, nme.Scala2)
@@ -325,7 +321,8 @@ trait TypeOps { this: Context => // TODO: Make standalone object.
def testScala2Mode(msg: => Message, pos: Position, rewrite: => Unit = ()) = {
if (scala2Mode) {
- migrationWarning(msg, pos)
+ migrationWarning(
+ new NoExplanation(msg.msg ++ "\nThis can be fixed automatically using -rewrite"), pos)
rewrite
}
scala2Mode
diff --git a/compiler/src/dotty/tools/dotc/core/Types.scala b/compiler/src/dotty/tools/dotc/core/Types.scala
index 01144c3ddbfd..8cb791f066c8 100644
--- a/compiler/src/dotty/tools/dotc/core/Types.scala
+++ b/compiler/src/dotty/tools/dotc/core/Types.scala
@@ -598,7 +598,7 @@ object Types {
else pdenot.info recoverable_& rinfo
pdenot.asSingleDenotation.derivedSingleDenotation(pdenot.symbol, jointInfo)
} else {
- pdenot & (
+ pdenot .& (
new JointRefDenotation(NoSymbol, rinfo, Period.allInRun(ctx.runId)),
pre,
safeIntersection = ctx.pendingMemberSearches.contains(name))
@@ -643,7 +643,7 @@ object Types {
}
def goAnd(l: Type, r: Type) = {
- go(l) & (go(r), pre, safeIntersection = ctx.pendingMemberSearches.contains(name))
+ go(l) .& (go(r), pre, safeIntersection = ctx.pendingMemberSearches.contains(name))
}
val recCount = ctx.findMemberCount
@@ -980,7 +980,7 @@ object Types {
case res => res
}
case tp @ AndType(tp1, tp2) =>
- tp derived_& (tp1.widenUnion, tp2.widenUnion)
+ tp.derived_&(tp1.widenUnion, tp2.widenUnion)
case tp: RefinedType =>
tp.derivedRefinedType(tp.parent.widenUnion, tp.refinedName, tp.refinedInfo)
case tp: RecType =>
diff --git a/compiler/src/dotty/tools/dotc/reporting/UniqueMessagePositions.scala b/compiler/src/dotty/tools/dotc/reporting/UniqueMessagePositions.scala
index 6fd971c2a4c0..e63f685632ea 100644
--- a/compiler/src/dotty/tools/dotc/reporting/UniqueMessagePositions.scala
+++ b/compiler/src/dotty/tools/dotc/reporting/UniqueMessagePositions.scala
@@ -21,7 +21,7 @@ trait UniqueMessagePositions extends Reporter {
m.pos.exists && {
var shouldHide = false
for (pos <- m.pos.start to m.pos.end) {
- positions get (ctx.source, pos) match {
+ positions.get((ctx.source, pos)) match {
case Some(level) if level >= m.level => shouldHide = true
case _ => positions((ctx.source, pos)) = m.level
}
diff --git a/compiler/src/dotty/tools/dotc/transform/Constructors.scala b/compiler/src/dotty/tools/dotc/transform/Constructors.scala
index 89a3d16772a4..6f25948aadb6 100644
--- a/compiler/src/dotty/tools/dotc/transform/Constructors.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Constructors.scala
@@ -152,7 +152,7 @@ class Constructors extends MiniPhase with IdentityDenotTransformer { thisPhase =
override def transform(tree: Tree)(implicit ctx: Context): Tree = tree match {
case Ident(_) | Select(This(_), _) =>
var sym = tree.symbol
- if (sym is (ParamAccessor, butNot = Mutable)) sym = sym.subst(accessors, paramSyms)
+ if (sym.is(ParamAccessor, butNot = Mutable)) sym = sym.subst(accessors, paramSyms)
if (sym.owner.isConstructor) ref(sym).withPos(tree.pos) else tree
case Apply(fn, Nil) =>
val fn1 = transform(fn)
diff --git a/compiler/src/dotty/tools/dotc/transform/Erasure.scala b/compiler/src/dotty/tools/dotc/transform/Erasure.scala
index d0f7daa2cadc..fa3d10a645e1 100644
--- a/compiler/src/dotty/tools/dotc/transform/Erasure.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Erasure.scala
@@ -481,7 +481,7 @@ object Erasure {
/** Besides normal typing, this method collects all arguments
* to a compacted function into a single argument of array type.
*/
- override def typedApply(tree: untpd.Apply, pt: Type)(implicit ctx: Context): Tree = {
+ override def typedApply(tree: untpd.Apply, pt: Type, scala2InfixOp: Boolean)(implicit ctx: Context): Tree = {
val Apply(fun, args) = tree
if (fun.symbol == defn.cbnArg)
typedUnadapted(args.head, pt)
diff --git a/compiler/src/dotty/tools/dotc/transform/ParamForwarding.scala b/compiler/src/dotty/tools/dotc/transform/ParamForwarding.scala
index b876a3a9b47e..1e2824027f72 100644
--- a/compiler/src/dotty/tools/dotc/transform/ParamForwarding.scala
+++ b/compiler/src/dotty/tools/dotc/transform/ParamForwarding.scala
@@ -48,7 +48,7 @@ class ParamForwarding(thisPhase: DenotTransformer) {
* }
*/
val candidate = sym.owner.asClass.superClass
- .info.decl(sym.name).suchThat(_ is (ParamAccessor, butNot = Mutable)).symbol
+ .info.decl(sym.name).suchThat(_.is(ParamAccessor, butNot = Mutable)).symbol
if (candidate.isAccessibleFrom(currentClass.thisType, superAccess = true)) candidate
else if (candidate.exists) inheritedAccessor(candidate)
else NoSymbol
diff --git a/compiler/src/dotty/tools/dotc/transform/SuperAccessors.scala b/compiler/src/dotty/tools/dotc/transform/SuperAccessors.scala
index 1435a5aaf099..9d90683184f3 100644
--- a/compiler/src/dotty/tools/dotc/transform/SuperAccessors.scala
+++ b/compiler/src/dotty/tools/dotc/transform/SuperAccessors.scala
@@ -123,7 +123,7 @@ class SuperAccessors(thisPhase: DenotTransformer) {
// SI-4989 Check if an intermediate class between `clazz` and `sym.owner` redeclares the method as abstract.
for (intermediateClass <- clazz.info.baseClasses.tail.takeWhile(_ != sym.owner)) {
val overriding = sym.overridingSymbol(intermediateClass)
- if ((overriding is (Deferred, butNot = AbsOverride)) && !(overriding.owner is Trait))
+ if (overriding.is(Deferred, butNot = AbsOverride) && !overriding.owner.is(Trait))
ctx.error(
s"${sym.showLocated} cannot be directly accessed from ${clazz} because ${overriding.owner} redeclares it as abstract",
sel.pos)
diff --git a/compiler/src/dotty/tools/dotc/transform/TransformByNameApply.scala b/compiler/src/dotty/tools/dotc/transform/TransformByNameApply.scala
index c0825c7e8bea..e34ba59a7523 100644
--- a/compiler/src/dotty/tools/dotc/transform/TransformByNameApply.scala
+++ b/compiler/src/dotty/tools/dotc/transform/TransformByNameApply.scala
@@ -26,7 +26,7 @@ abstract class TransformByNameApply extends MiniPhase { thisPhase: DenotTransfor
/** If denotation had an ExprType before, it now gets a function type */
protected def exprBecomesFunction(symd: SymDenotation)(implicit ctx: Context) =
- (symd is Param) || (symd is (ParamAccessor, butNot = Method))
+ symd.is(Param) || symd.is(ParamAccessor, butNot = Method)
protected def isByNameRef(tree: Tree)(implicit ctx: Context) = {
val origDenot = originalDenotation(tree)
diff --git a/compiler/src/dotty/tools/dotc/typer/Applications.scala b/compiler/src/dotty/tools/dotc/typer/Applications.scala
index 7d77920e8741..5707f77ef20e 100644
--- a/compiler/src/dotty/tools/dotc/typer/Applications.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Applications.scala
@@ -23,6 +23,7 @@ import StdNames._
import NameKinds.DefaultGetterName
import ProtoTypes._
import Inferencing._
+import rewrite.Rewrites.patch
import collection.mutable
import config.Printers.{overload, typr, unapp}
@@ -242,7 +243,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
def success = ok
protected def methodType = methType.asInstanceOf[MethodType]
- private def methString: String = i"${methRef.symbol}: ${methType.show}"
+ private def methString: String = i"${methRef.symbol.showLocated}: ${methType.show}"
/** Re-order arguments to correctly align named arguments */
def reorder[T >: Untyped](args: List[Trees.Tree[T]]): List[Trees.Tree[T]] = {
@@ -669,10 +670,19 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
* or, if application is an operator assignment, also an `Assign` or
* Block node.
*/
- def typedApply(tree: untpd.Apply, pt: Type)(implicit ctx: Context): Tree = {
-
+ def typedApply(tree: untpd.Apply, pt: Type, scala2InfixOp: Boolean = false)(implicit ctx: Context): Tree = {
def realApply(implicit ctx: Context): Tree = track("realApply") {
- val originalProto = new FunProto(tree.args, IgnoredProto(pt), this)(argCtx(tree))
+ var originalProto = new FunProto(tree.args, IgnoredProto(pt), this)(argCtx(tree))
+
+ // In an infix operation `x op (y, z)` under Scala-2 mode, rewrite tuple on the
+ // right hand side to multi-parameters, i.e `x.op(y, z)`, relying on auto-tupling
+ // to revert this if `op` takes a single argument.
+ tree.args match {
+ case untpd.Tuple(elems) :: Nil if scala2InfixOp =>
+ originalProto = new FunProto(elems, IgnoredProto(pt), this)(argCtx(tree))
+ originalProto.scala2InfixOp = true
+ case _ =>
+ }
val fun1 = typedExpr(tree.fun, originalProto)
// Warning: The following lines are dirty and fragile. We record that auto-tupling was demanded as
@@ -682,7 +692,41 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
// otherwise we would get possible cross-talk between different `adapt` calls using the same
// prototype. A cleaner alternative would be to return a modified prototype from `adapt` together with
// a modified tree but this would be more convoluted and less efficient.
- val proto = if (originalProto.isTupled) originalProto.tupled else originalProto
+ // All of this is provisional in the long run, since it is only needed under Scala-2 mode.
+ val proto =
+ if (originalProto.isTupled) originalProto.tupled
+ else {
+ // If we see a multi-parameter infix operation `x op (y, z)` under Scala-2 mode,
+ // issue a migration warning and propose a rewrite to `x .op (y, z)` (or
+ // `(x) .op (y, z)` is `x` is itself an infix operation) where this is possible.
+ // Not possible are rewrites of operator assignments and right-associative operators.
+ tree.fun match {
+ case sel @ Select(qual, opName)
+ if originalProto.scala2InfixOp && !fun1.tpe.widen.isErroneous =>
+ val opEndOffset = sel.pos.point + opName.toString.length
+ val isOpAssign = ctx.source(opEndOffset) == '='
+ val isRightAssoc = !isLeftAssoc(opName)
+ val addendum =
+ if (isOpAssign) "\nThis requires a manual rewrite since it is part of an operator assignment."
+ else if (isRightAssoc) "\nThis requires a manual rewrite since the operator is right-associative."
+ else "\nThis can be fixed automatically using -rewrite."
+ ctx.migrationWarning(
+ em"""infix operator takes exactly one argument,
+ |use method call syntax with `.` instead.$addendum""", fun1.pos)
+ val Select(qual, _) = tree.fun
+ if (!isOpAssign && !isRightAssoc) {
+ patch(Position(sel.pos.point), ".")
+ qual match {
+ case qual: untpd.InfixOp =>
+ patch(qual.pos.startPos, "(")
+ patch(qual.pos.endPos, ")")
+ case _ =>
+ }
+ }
+ case _ =>
+ }
+ originalProto
+ }
// If some of the application's arguments are function literals without explicitly declared
// parameter types, relate the normalized result type of the application with the
@@ -750,12 +794,25 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
* { val xs = es; e' = e' + args }
*/
def typedOpAssign(implicit ctx: Context): Tree = track("typedOpAssign") {
- val Apply(Select(lhs, name), rhss) = tree
+ val Apply(sel @ Select(lhs, name), rhss) = tree
val lhs1 = typedExpr(lhs)
val liftedDefs = new mutable.ListBuffer[Tree]
val lhs2 = untpd.TypedSplice(LiftComplex.liftAssigned(liftedDefs, lhs1))
- val assign = untpd.Assign(lhs2,
- untpd.Apply(untpd.Select(lhs2, name.asSimpleName.dropRight(1)), rhss))
+ val opName = name.asSimpleName.dropRight(1)
+
+ // If original operation was an infix operation under Scala-2 mode, generate
+ // again an infix operation insteadof an application, so that the logic does
+ // the right thing for migrating from auto-tupling and multi-parameter infix ops.
+ val app = rhss match {
+ case (rhs: untpd.Tuple) :: Nil if scala2InfixOp =>
+ val opEndOffset = sel.pos.point + opName.length
+ assert(ctx.source(opEndOffset) == '=')
+ val op = untpd.Ident(opName).withPos(Position(sel.pos.point, opEndOffset))
+ untpd.InfixOp(lhs2, op, rhs)
+ case _ =>
+ untpd.Apply(untpd.Select(lhs2, opName), rhss)
+ }
+ val assign = untpd.Assign(lhs2, app)
wrapDefs(liftedDefs, typed(assign))
}
@@ -980,10 +1037,12 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
val (regularArgs, varArgs) = args.splitAt(argTypes.length - 1)
regularArgs :+ untpd.SeqLiteral(varArgs, untpd.TypeTree()).withPos(tree.pos)
}
- else if (argTypes.lengthCompare(1) == 0 && args.lengthCompare(1) > 0 && ctx.canAutoTuple)
- untpd.Tuple(args) :: Nil
- else
- args
+ else argTypes match {
+ case argType :: Nil if args.lengthCompare(1) > 0 && canAutoTuple(args) =>
+ untpd.Tuple(args) :: Nil
+ case _ =>
+ args
+ }
if (argTypes.length != bunchedArgs.length) {
ctx.error(UnapplyInvalidNumberOfArguments(qual, argTypes), tree.pos)
argTypes = argTypes.take(args.length) ++
diff --git a/compiler/src/dotty/tools/dotc/typer/Checking.scala b/compiler/src/dotty/tools/dotc/typer/Checking.scala
index 698fdaff0c15..13250d2b2c16 100644
--- a/compiler/src/dotty/tools/dotc/typer/Checking.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Checking.scala
@@ -850,6 +850,29 @@ trait Checking {
checkEnumCaseRefsLegal(stat, enumContext)
stats
}
+
+ /** `tp` refers to a method with exactly one parameter in its first parameter list.
+ * If `tp` is overloaded, all alternatives are unary in that sense.
+ */
+ def isUnary(tp: Type)(implicit ctx: Context): Boolean = tp match {
+ case tp: MethodicType =>
+ tp.firstParamTypes match {
+ case ptype :: Nil => !ptype.isRepeatedParam
+ case _ => false
+ }
+ case tp: TermRef =>
+ tp.denot.alternatives.forall(alt => isUnary(alt.info))
+ case _ =>
+ false
+ }
+
+ /** Under Scala-2 mode, issue a migration warning for a symbolic method that is
+ * not unary.
+ */
+ def checkSymbolicUnary(sym: Symbol)(implicit ctx: Context): Unit =
+ if (sym.name.isSymbolic && !isUnary(sym.info) && ctx.scala2Mode)
+ ctx.migrationWarning(i"""symbolic operator `${sym.name}` should take exactly one parameter,
+ |otherwise it cannot be used in infix position.""", sym.pos)
}
trait ReChecking extends Checking {
@@ -877,4 +900,5 @@ trait NoChecking extends ReChecking {
override def checkCaseInheritance(parentSym: Symbol, caseCls: ClassSymbol, pos: Position)(implicit ctx: Context) = ()
override def checkNoForwardDependencies(vparams: List[ValDef])(implicit ctx: Context): Unit = ()
override def checkMembersOK(tp: Type, pos: Position)(implicit ctx: Context): Type = tp
+ override def checkSymbolicUnary(sym: Symbol)(implicit ctx: Context): Unit = ()
}
diff --git a/compiler/src/dotty/tools/dotc/typer/Inliner.scala b/compiler/src/dotty/tools/dotc/typer/Inliner.scala
index 49a507e0994c..80aec515be66 100644
--- a/compiler/src/dotty/tools/dotc/typer/Inliner.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Inliner.scala
@@ -564,13 +564,13 @@ class Inliner(call: tpd.Tree, rhs: tpd.Tree)(implicit ctx: Context) {
}
}
- override def typedApply(tree: untpd.Apply, pt: Type)(implicit ctx: Context) =
+ override def typedApply(tree: untpd.Apply, pt: Type, scala2InfixOp: Boolean)(implicit ctx: Context) =
tree.asInstanceOf[tpd.Tree] match {
case Apply(Select(InlineableArg(closure(_, fn, _)), nme.apply), args) =>
inlining.println(i"reducing $tree with closure $fn")
typed(fn.appliedToArgs(args), pt)
case _ =>
- super.typedApply(tree, pt)
+ super.typedApply(tree, pt, scala2InfixOp)
}
}
}
diff --git a/compiler/src/dotty/tools/dotc/typer/Namer.scala b/compiler/src/dotty/tools/dotc/typer/Namer.scala
index 78c9d111cf9e..f1a5a089b258 100644
--- a/compiler/src/dotty/tools/dotc/typer/Namer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Namer.scala
@@ -1029,7 +1029,7 @@ class Namer { typer: Typer =>
def moduleValSig(sym: Symbol)(implicit ctx: Context): Type = {
val clsName = sym.name.moduleClassName
val cls = ctx.denotNamed(clsName) suchThat (_ is ModuleClass)
- ctx.owner.thisType select (clsName, cls)
+ ctx.owner.thisType.select(clsName, cls)
}
/** The type signature of a ValDef or DefDef
diff --git a/compiler/src/dotty/tools/dotc/typer/ProtoTypes.scala b/compiler/src/dotty/tools/dotc/typer/ProtoTypes.scala
index f06df5d03d74..9248edde5c4a 100644
--- a/compiler/src/dotty/tools/dotc/typer/ProtoTypes.scala
+++ b/compiler/src/dotty/tools/dotc/typer/ProtoTypes.scala
@@ -288,6 +288,11 @@ object ProtoTypes {
def typeOfArg(arg: untpd.Tree)(implicit ctx: Context): Type =
myTypedArg(arg).tpe
+ // `scala2InfixOp` and `tupled` only needed for Scala-2 compatibility and migration
+
+ /** FunProto applies to an infix operation under -language:Scala2 */
+ var scala2InfixOp = false
+
private[this] var myTupled: Type = NoType
/** The same proto-type but with all arguments combined in a single tuple */
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index 431721dc44e6..24eea10ef8cd 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -151,7 +151,7 @@ class Typer extends Namer
def qualifies(denot: Denotation): Boolean =
reallyExists(denot) &&
!(pt.isInstanceOf[UnapplySelectionProto] &&
- (denot.symbol is (Method, butNot = Accessor))) &&
+ (denot.symbol.is(Method, butNot = Accessor))) &&
!(denot.symbol is PackageClass)
/** Find the denotation of enclosing `name` in given context `ctx`.
@@ -1434,6 +1434,8 @@ class Typer extends Namer
for (param <- tparams1 ::: vparamss1.flatten)
checkRefsLegal(param, sym.owner, (name, sym) => sym.is(TypeParam), "secondary constructor")
+ checkSymbolicUnary(sym)
+
assignType(cpy.DefDef(ddef)(name, tparams1, vparamss1, tpt1, rhs1), sym)
//todo: make sure dependent method types do not depend on implicits or by-name params
}
@@ -1707,7 +1709,7 @@ class Typer extends Namer
*/
def typedInfixOp(tree: untpd.InfixOp, pt: Type)(implicit ctx: Context): Tree = {
val untpd.InfixOp(l, op, r) = tree
- val app = typedApply(desugar.binop(l, op, r), pt)
+ val app = typedApply(desugar.binop(l, op, r), pt, scala2InfixOp = ctx.scala2Mode)
if (untpd.isLeftAssoc(op.name)) app
else {
val defs = new mutable.ListBuffer[Tree]
@@ -2032,6 +2034,17 @@ class Typer extends Namer
}
}
+ def canAutoTuple(args: List[untpd.Tree])(implicit ctx: Context): Boolean = {
+ val pos = Position(args.map(_.pos.start).min, args.map(_.pos.end).max)
+ ctx.testScala2Mode(
+ i"""auto-tupling is no longer supported,
+ |arguments now need to be enclosed in parentheses (...).""",
+ pos, { patch(pos.startPos, "("); patch(pos.endPos, ")") })
+ }
+
+ def takesAutoTupledArgs(tp: Type, pt: FunProto)(implicit ctx: Context): Boolean =
+ pt.args.lengthCompare(1) > 0 && isUnary(tp) && (pt.scala2InfixOp || canAutoTuple(pt.args))
+
/** Perform the following adaptations of expression, pattern or type `tree` wrt to
* given prototype `pt`:
* (1) Resolve overloading
@@ -2119,24 +2132,10 @@ class Typer extends Namer
}
}
- def isUnary(tp: Type): Boolean = tp match {
- case tp: MethodicType =>
- tp.firstParamTypes match {
- case ptype :: Nil => !ptype.isRepeatedParam
- case _ => false
- }
- case tp: TermRef =>
- tp.denot.alternatives.forall(alt => isUnary(alt.info))
- case _ =>
- false
- }
-
def adaptToArgs(wtp: Type, pt: FunProto): Tree = wtp match {
case _: MethodOrPoly =>
- if (pt.args.lengthCompare(1) > 0 && isUnary(wtp) && ctx.canAutoTuple)
- adapt(tree, pt.tupled, locked)
- else
- tree
+ if (takesAutoTupledArgs(wtp, pt)) adapt(tree, pt.tupled, locked)
+ else tree
case _ => tryInsertApplyOrImplicit(tree, pt, locked) {
errorTree(tree, MethodDoesNotTakeParameters(tree, methPart(tree).tpe)(err))
}
@@ -2499,10 +2498,9 @@ class Typer extends Namer
case tp: FlexType =>
ensureReported(tp)
tree
- case ref: TermRef =>
+ case ref: TermRef => // this case can happen in case tree.tpe is overloaded
pt match {
- case pt: FunProto
- if pt.args.lengthCompare(1) > 0 && isUnary(ref) && ctx.canAutoTuple =>
+ case pt: FunProto if takesAutoTupledArgs(ref, pt) =>
adapt(tree, pt.tupled, locked)
case _ =>
adaptOverloaded(ref)
diff --git a/compiler/src/dotty/tools/dotc/util/SimpleIdentityMap.scala b/compiler/src/dotty/tools/dotc/util/SimpleIdentityMap.scala
index bdbba5605141..4606499fe211 100644
--- a/compiler/src/dotty/tools/dotc/util/SimpleIdentityMap.scala
+++ b/compiler/src/dotty/tools/dotc/util/SimpleIdentityMap.scala
@@ -22,7 +22,7 @@ abstract class SimpleIdentityMap[K <: AnyRef, +V >: Null <: AnyRef] extends (K =
def toList: List[(K, V)] = map2((k, v) => (k, v))
override def toString = {
def assocToString(key: K, value: V) = s"$key -> $value"
- map2(assocToString) mkString ("(", ", ", ")")
+ map2(assocToString).mkString("(", ", ", ")")
}
}
diff --git a/compiler/src/dotty/tools/repl/terminal/filters/ReadlineFilters.scala b/compiler/src/dotty/tools/repl/terminal/filters/ReadlineFilters.scala
index c619238de2d0..f106c9a19510 100644
--- a/compiler/src/dotty/tools/repl/terminal/filters/ReadlineFilters.scala
+++ b/compiler/src/dotty/tools/repl/terminal/filters/ReadlineFilters.scala
@@ -121,7 +121,7 @@ object ReadlineFilters {
}
def cutCharLeft(b: Vector[Char], c: Int) = {
/* Do not edit current cut. Zsh(zle) & Bash(readline) do not edit the yank ring for Ctrl-h */
- (b patch(from = c - 1, patch = Nil, replaced = 1), c - 1)
+ (b .patch(from = c - 1, patch = Nil, replaced = 1), c - 1)
}
def cutLineLeft(b: Vector[Char], c: Int) = {
diff --git a/compiler/test/dotty/tools/dotc/CompilationTests.scala b/compiler/test/dotty/tools/dotc/CompilationTests.scala
index d91b789b4f86..c0180adfcd28 100644
--- a/compiler/test/dotty/tools/dotc/CompilationTests.scala
+++ b/compiler/test/dotty/tools/dotc/CompilationTests.scala
@@ -180,7 +180,6 @@ class CompilationTests extends ParallelTesting {
compileFilesInDir("tests/neg-custom-args/allow-double-bindings", allowDoubleBindings) +
compileFile("tests/neg-custom-args/i3246.scala", scala2Mode) +
compileFile("tests/neg-custom-args/overrideClass.scala", scala2Mode) +
- compileFile("tests/neg-custom-args/autoTuplingTest.scala", defaultOptions.and("-language:noAutoTupling")) +
compileFile("tests/neg-custom-args/i1050.scala", defaultOptions.and("-strict")) +
compileFile("tests/neg-custom-args/nopredef.scala", defaultOptions.and("-Yno-predef")) +
compileFile("tests/neg-custom-args/noimports.scala", defaultOptions.and("-Yno-imports")) +
diff --git a/compiler/test/dotty/tools/vulpix/ParallelTesting.scala b/compiler/test/dotty/tools/vulpix/ParallelTesting.scala
index 945d5fa3efb4..829ca85d52cc 100644
--- a/compiler/test/dotty/tools/vulpix/ParallelTesting.scala
+++ b/compiler/test/dotty/tools/vulpix/ParallelTesting.scala
@@ -331,7 +331,7 @@ trait ParallelTesting extends RunnerOrchestration { self =>
protected def compile(files0: Array[JFile], flags0: TestFlags, suppressErrors: Boolean, targetDir: JFile): TestReporter = {
- val flags = flags0 and ("-d", targetDir.getAbsolutePath)
+ val flags = flags0.and("-d", targetDir.getAbsolutePath)
def flattenFiles(f: JFile): Array[JFile] =
if (f.isDirectory) f.listFiles.flatMap(flattenFiles)
@@ -400,7 +400,7 @@ trait ParallelTesting extends RunnerOrchestration { self =>
protected def compileFromTasty(flags0: TestFlags, suppressErrors: Boolean, targetDir: JFile): TestReporter = {
val tastyOutput = new JFile(targetDir.getPath + "_from-tasty")
tastyOutput.mkdir()
- val flags = flags0 and ("-d", tastyOutput.getAbsolutePath) and "-from-tasty"
+ val flags = flags0.and("-d", tastyOutput.getAbsolutePath).and("-from-tasty")
def hasTastyFileToClassName(f: JFile): String =
targetDir.toPath.relativize(f.toPath).toString.dropRight(".hasTasty".length).replace('/', '.')
@@ -427,8 +427,10 @@ trait ParallelTesting extends RunnerOrchestration { self =>
val decompilationOutput = new JFile(targetDir.getPath)
decompilationOutput.mkdir()
val flags =
- flags0 and ("-d", decompilationOutput.getAbsolutePath) and
- "-decompile" and "-pagewidth" and "80"
+ flags0
+ .and("-d", decompilationOutput.getAbsolutePath)
+ .and("-decompile")
+ .and("-pagewidth", "80")
def hasTastyFileToClassName(f: JFile): String =
targetDir.toPath.relativize(f.toPath).toString.dropRight(".hasTasty".length).replace('/', '.')
diff --git a/compiler/test/dotty/tools/vulpix/TestConfiguration.scala b/compiler/test/dotty/tools/vulpix/TestConfiguration.scala
index 845908be2e0f..0bd8d5469c58 100644
--- a/compiler/test/dotty/tools/vulpix/TestConfiguration.scala
+++ b/compiler/test/dotty/tools/vulpix/TestConfiguration.scala
@@ -49,18 +49,18 @@ object TestConfiguration {
val basicDefaultOptions = checkOptions ++ noCheckOptions ++ yCheckOptions
val defaultUnoptimised = TestFlags(classPath, runClassPath, basicDefaultOptions)
- val defaultOptimised = defaultUnoptimised and "-optimise"
+ val defaultOptimised = defaultUnoptimised.and("-optimise")
val defaultOptions = defaultUnoptimised
val defaultRunWithCompilerOptions = defaultOptions.withRunClasspath(Jars.dottyRunWithCompiler.mkString(":"))
val allowDeepSubtypes = defaultOptions without "-Yno-deep-subtypes"
val allowDoubleBindings = defaultOptions without "-Yno-double-bindings"
- val picklingOptions = defaultUnoptimised and (
+ val picklingOptions = defaultUnoptimised.and(
"-Xprint-types",
"-Ytest-pickler",
"-Yprint-pos",
"-Yprint-pos-syms"
)
- val scala2Mode = defaultOptions and "-language:Scala2"
- val explicitUTF8 = defaultOptions and ("-encoding", "UTF8")
- val explicitUTF16 = defaultOptions and ("-encoding", "UTF16")
+ val scala2Mode = defaultOptions.and("-language:Scala2")
+ val explicitUTF8 = defaultOptions.and("-encoding", "UTF8")
+ val explicitUTF16 = defaultOptions.and("-encoding", "UTF16")
}
diff --git a/library/src/scalaShadowing/language.scala b/library/src/scalaShadowing/language.scala
index 50d2bf069c04..d1d26f77af31 100644
--- a/library/src/scalaShadowing/language.scala
+++ b/library/src/scalaShadowing/language.scala
@@ -29,7 +29,6 @@ package scalaShadowing
* and, for dotty:
*
* - [[Scala2 `Scala2`] backwards compatibility mode for Scala2
- * - [[noAtoTupling `noAutoTupling`]] disable auto-tupling
*
* @groupname production Language Features
* @groupname experimental Experimental Language Features
@@ -193,9 +192,6 @@ object language {
/** Where imported, a backwards compatibility mode for Scala2 is enabled */
object Scala2
- /** Where imported, auto-tupling is disabled */
- object noAutoTupling
-
/* Where imported loose equality using eqAny is disabled */
object strictEquality
}
diff --git a/tests/neg-custom-args/autoTuplingTest.scala b/tests/neg-custom-args/autoTuplingTest.scala
deleted file mode 100644
index 7321a83827bb..000000000000
--- a/tests/neg-custom-args/autoTuplingTest.scala
+++ /dev/null
@@ -1,9 +0,0 @@
-object autoTupling {
-
- val x = Some(1, 2) // error when running with -language:noAutoTupling
-
- x match {
- case Some(a, b) => a + b // error // error when running with -language:noAutoTupling
- case None =>
- }
-}
diff --git a/tests/neg/autoTuplingTest.scala b/tests/neg/autoTuplingTest.scala
index 92126ab5dd60..c53ff99fc571 100644
--- a/tests/neg/autoTuplingTest.scala
+++ b/tests/neg/autoTuplingTest.scala
@@ -1,11 +1,9 @@
-import language.noAutoTupling
-
object autoTuplingNeg2 {
val x = Some(1, 2) // error: too many arguments for method apply: (x: A)Some[A]
x match {
- case Some(a, b) => a + b // error: wrong number of argument patterns for Some // error: not found: b
+ case Some(a, b) => a + b // error: wrong number of argument patterns for Some // error: not found: a
case None =>
}
}
diff --git a/tests/neg/i1286.scala b/tests/neg/i1286.scala
index 40db9ab1d46d..b2b74c41a63e 100644
--- a/tests/neg/i1286.scala
+++ b/tests/neg/i1286.scala
@@ -10,7 +10,6 @@ import scala.io.{ Idontexist4 => Foo } // error
import scala.io.{ Idontexist5 => _ } // error
import scala.language.dynamics
-import scala.language.noAutoTupling
import scala.language.idontexist // error
object Test
diff --git a/tests/neg/i2033.scala b/tests/neg/i2033.scala
index b28a0d99e5be..c717bc8679e6 100644
--- a/tests/neg/i2033.scala
+++ b/tests/neg/i2033.scala
@@ -4,10 +4,10 @@ object Test {
def check(obj: AnyRef): Unit = {
val bos = new ByteArrayOutputStream()
val out = new ObjectOutputStream(println) // error
- val arr = bos toByteArray ()
+ val arr = bos.toByteArray ()
val in = (())
val deser = ()
- val lhs = mutable LinkedHashSet ()
+ val lhs = mutable.LinkedHashSet ()
check(lhs)
}
}
diff --git a/tests/neg/t6920.scala b/tests/neg/t6920.scala
index 9601ed8d27e6..4a135f0d2d10 100644
--- a/tests/neg/t6920.scala
+++ b/tests/neg/t6920.scala
@@ -6,5 +6,5 @@ class DynTest extends Dynamic {
class CompilerError {
val test = new DynTest
- test.crushTheCompiler(a = 1, b = 2) // error
+ test.crushTheCompiler(a = 1, b = 2) // error // error
}
diff --git a/tests/pos-special/strawman-collections/CollectionStrawMan6.scala b/tests/pos-special/strawman-collections/CollectionStrawMan6.scala
index a2ff42ba783e..6c2a37adfda9 100644
--- a/tests/pos-special/strawman-collections/CollectionStrawMan6.scala
+++ b/tests/pos-special/strawman-collections/CollectionStrawMan6.scala
@@ -651,7 +651,7 @@ object CollectionStrawMan6 extends LowPriority {
}
def fromIterator[B](it: Iterator[B]): LazyList[B] =
- new LazyList(if (it.hasNext) Some(it.next(), fromIterator(it)) else None)
+ new LazyList(if (it.hasNext) Some((it.next(), fromIterator(it))) else None)
}
// ------------------ Decorators to add collection ops to existing types -----------------------
diff --git a/tests/pos/Map.scala b/tests/pos/Map.scala
index 5178d5a862cf..b5ba3b1627a6 100644
--- a/tests/pos/Map.scala
+++ b/tests/pos/Map.scala
@@ -176,7 +176,7 @@ object Map extends ImmutableMapFactory[Map] {
else if (key == key2) new Map4(key1, value1, key2, value, key3, value3, key4, value4)
else if (key == key3) new Map4(key1, value1, key2, value2, key3, value, key4, value4)
else if (key == key4) new Map4(key1, value1, key2, value2, key3, value3, key4, value)
- else new HashMap + ((key1, value1), (key2, value2), (key3, value3), (key4, value4), (key, value))
+ else HashMap((key1, value1), (key2, value2), (key3, value3), (key4, value4), (key, value))
def + [B1 >: B](kv: (A, B1)): Map[A, B1] = updated(kv._1, kv._2)
def - (key: A): Map[A, B] =
if (key == key1) new Map3(key2, value2, key3, value3, key4, value4)
diff --git a/tests/pos/autoTuplingTest.scala b/tests/pos/autoTuplingTest.scala
deleted file mode 100644
index 523411a1a410..000000000000
--- a/tests/pos/autoTuplingTest.scala
+++ /dev/null
@@ -1,9 +0,0 @@
-object autoTupling {
-
- val x = Some(1, 2)
-
- x match {
- case Some(a, b) => a + b
- case None =>
- }
-}
diff --git a/tests/pos/i1318.scala b/tests/pos/i1318.scala
index dfb882825166..6fb6357cbe88 100644
--- a/tests/pos/i1318.scala
+++ b/tests/pos/i1318.scala
@@ -3,7 +3,7 @@ object Foo {
case class T(i: Int) extends S(i)
object T {
- def unapply(s: S): Option[(Int, Int)] = Some(5, 6)
+ def unapply(s: S): Option[(Int, Int)] = Some((5, 6))
// def unapply(o: Object): Option[(Int, Int, Int)] = Some(5, 6, 7)
}
@@ -22,7 +22,7 @@ object Bar {
class S(i: Int) extends T(i)
object T {
- def unapply(s: S): Option[(Int, Int)] = Some(5, 6)
+ def unapply(s: S): Option[(Int, Int)] = Some((5, 6))
// def unapply(o: Object): Option[(Int, Int, Int)] = Some(5, 6, 7)
}
diff --git a/tests/pos/i903.scala b/tests/pos/i903.scala
index 5afb6e53010c..dc64d6d5fef3 100644
--- a/tests/pos/i903.scala
+++ b/tests/pos/i903.scala
@@ -17,7 +17,7 @@ object Test {
}
def test2 = {
- val f = "".contains("", (_: Int)) // dotc:
+ val f = (x: Int) => "".contains(("", x)) // dotc:
f.apply(0)
// sandbox/eta.scala:18: error: apply is not a member of Boolean(f)
// f.apply(0)
diff --git a/tests/pos/t1133.scala b/tests/pos/t1133.scala
index 2e4793e998f3..60c1751ad402 100644
--- a/tests/pos/t1133.scala
+++ b/tests/pos/t1133.scala
@@ -11,21 +11,21 @@ object Match
object Extractor1 {
def unapply(x: Any) = x match {
- case x: String => Some(x, x + x, x + x+x, x+x, x)
+ case x: String => Some((x, x + x, x + x+x, x+x, x))
case _ => None
}
}
object Extractor2 {
def unapply(x: Any) = x match {
- case x: String => Some(x, x + x, x + x+x)
+ case x: String => Some((x, x + x, x + x+x))
case _ => None
}
}
object Extractor3 {
def unapply(x: Any) = x match {
- case x: String => Some(x, x, x)
+ case x: String => Some((x, x, x))
case _ => None
}
}
diff --git a/tests/pos/t2913.scala b/tests/pos/t2913.scala
index f91ed7b51318..b599ca6a2924 100644
--- a/tests/pos/t2913.scala
+++ b/tests/pos/t2913.scala
@@ -10,8 +10,6 @@ class RichA {
}
object TestNoAutoTupling {
- import language.noAutoTupling // try with on and off
-
implicit def AToRichA(a: A): RichA = new RichA
val a = new A
@@ -52,25 +50,3 @@ object Main {
()
}
}
-
-object TestWithAutoTupling {
-
- implicit def AToRichA(a: A): RichA = new RichA
-
- val a = new A
- a.foo()
- a.foo(1)
-
- a.foo("") // Without implicits, a type error regarding invalid argument types is generated at `""`. This is
- // the same position as an argument, so the 'second try' typing with an Implicit View is tried,
- // and AToRichA(a).foo("") is found.
- //
- // My reading of the spec "7.3 Views" is that `a.foo` denotes a member of `a`, so the view should
- // not be triggered.
- //
- // But perhaps the implementation was changed to solve See https://lampsvn.epfl.ch/trac/scala/ticket/1756
-
- a.foo("a", "b") // Without implicits, a type error regarding invalid arity is generated at `foo(<error>"", "")`.
- // Typers#tryTypedApply:3274 only checks if the error is as the same position as `foo`, `"a"`, or `"b"`.
-}
-
diff --git a/tests/run/collections.scala b/tests/run/collections.scala
index acc2d93fff82..2b90655a1deb 100644
--- a/tests/run/collections.scala
+++ b/tests/run/collections.scala
@@ -18,7 +18,7 @@ object Test extends dotty.runtime.LegacyApp {
println("***** "+msg+":")
var s = s0
s = s + 2
- s = s + (3, 4000, 10000)
+ s = s.+(3, 4000, 10000)
println("test1: "+sum(s))
time {
s = s ++ (List.range(0, iters) map (2*))
@@ -36,7 +36,7 @@ object Test extends dotty.runtime.LegacyApp {
println("***** "+msg+":")
var s = s0
s = s + 2
- s = s + (3, 4000, 10000)
+ s = s.+(3, 4000, 10000)
println("test1: "+sum(s))
time {
s = s ++ (List.range(0, iters) map (2*))
@@ -54,7 +54,7 @@ object Test extends dotty.runtime.LegacyApp {
println("***** "+msg+":")
var s = s0
s = s + (2 -> 2)
- s = s + (3 -> 3, 4000 -> 4000, 10000 -> 10000)
+ s = s.+(3 -> 3, 4000 -> 4000, 10000 -> 10000)
println("test1: "+sum(s map (_._2)))
time {
s = s ++ (List.range(0, iters) map (x => x * 2 -> x * 2))
@@ -89,7 +89,7 @@ object Test extends dotty.runtime.LegacyApp {
println("***** "+msg+":")
var s = s0
s = s + (2 -> 2)
- s = s + (3 -> 3, 4000 -> 4000, 10000 -> 10000)
+ s = s.+(3 -> 3, 4000 -> 4000, 10000 -> 10000)
println("test1: "+sum(s map (_._2)))
time {
s = s ++ (List.range(0, iters) map (x => x * 2 -> x * 2))
diff --git a/tests/run/colltest1.scala b/tests/run/colltest1.scala
index ab519067b6f7..612b3e8c1c79 100644
--- a/tests/run/colltest1.scala
+++ b/tests/run/colltest1.scala
@@ -47,8 +47,8 @@ object Test extends dotty.runtime.LegacyApp {
assert(vs1 == ten)
assert((ten take 5) == firstFive)
assert((ten drop 5) == secondFive)
- assert(ten slice (3, 3) isEmpty)
- assert((ten slice (3, 6)) == List(4, 5, 6), ten slice (3, 6))
+ assert(ten.slice(3, 3) isEmpty)
+ assert((ten.slice(3, 6)) == List(4, 5, 6), ten .slice (3, 6))
assert((ten takeWhile (_ <= 5)) == firstFive)
assert((ten dropWhile (_ <= 5)) == secondFive)
assert((ten span (_ <= 5)) == (firstFive, secondFive))
@@ -139,7 +139,7 @@ object Test extends dotty.runtime.LegacyApp {
def setTest(empty: => Set[String]): Unit = {
var s = empty + "A" + "B" + "C"
- s += ("D", "E", "F")
+ s = s.+("D", "E", "F")
s ++= List("G", "H", "I")
s ++= ('J' to 'Z') map (_.toString)
assert(s forall (s contains))
@@ -156,8 +156,8 @@ object Test extends dotty.runtime.LegacyApp {
assert(!s.isEmpty)
val s1 = s intersect empty
assert(s1 == empty, s1)
- def abc = empty + ("a", "b", "c")
- def bc = empty + ("b", "c")
+ def abc = empty.+("a", "b", "c")
+ def bc = empty.+("b", "c")
assert(bc subsetOf abc)
}
@@ -173,7 +173,7 @@ object Test extends dotty.runtime.LegacyApp {
def mapTest(empty: => Map[String, String]) = {
var m = empty + ("A" -> "A") + ("B" -> "B") + ("C" -> "C")
- m += (("D" -> "D"), ("E" -> "E"), ("F" -> "F"))
+ m = m.+(("D" -> "D"), ("E" -> "E"), ("F" -> "F"))
m ++= List(("G" -> "G"), ("H" -> "H"), ("I" -> "I"))
m ++= ('J' to 'Z') map (x => (x.toString -> x.toString))
println(m.toList.sorted)
diff --git a/tests/run/colltest6/CollectionStrawMan6_1.scala b/tests/run/colltest6/CollectionStrawMan6_1.scala
index 4fad57154775..a380deb9d74c 100644
--- a/tests/run/colltest6/CollectionStrawMan6_1.scala
+++ b/tests/run/colltest6/CollectionStrawMan6_1.scala
@@ -652,7 +652,7 @@ object CollectionStrawMan6 extends LowPriority {
}
def fromIterator[B](it: Iterator[B]): LazyList[B] =
- new LazyList(if (it.hasNext) Some(it.next(), fromIterator(it)) else None)
+ new LazyList(if (it.hasNext) Some((it.next(), fromIterator(it))) else None)
}
// ------------------ Decorators to add collection ops to existing types -----------------------
diff --git a/tests/run/iterators.scala b/tests/run/iterators.scala
index 2f70abd52193..a0696eace072 100644
--- a/tests/run/iterators.scala
+++ b/tests/run/iterators.scala
@@ -57,8 +57,8 @@ object Test {
def check_drop: Int = {
val it1 = Iterator.from(0)
val it2 = it1 map { 2 * _ }
- val n1 = it1 drop 2 next()
- val n2 = it2 drop 2 next();
+ val n1 = (it1 drop 2) .next()
+ val n2 = (it2 drop 2) .next();
n1 + n2
}
diff --git a/tests/run/runtime.scala b/tests/run/runtime.scala
index 89348b294db8..3a55069c3f0c 100644
--- a/tests/run/runtime.scala
+++ b/tests/run/runtime.scala
@@ -65,7 +65,7 @@ object Test1Test {
// {System.out.print(12); java.lang}.System.out.println();
// {System.out.print(13); java.lang.System}.out.println();
{Console.print(14); Console}.println;
- {Console.print(15); (() => Console.println):(() => Unit)} apply ();
+ {Console.print(15); (() => Console.println):(() => Unit)} .apply ();
{Console.print(16); Console.println};
{Console.print(20)}; test1.bar.System.out.println();
@@ -73,7 +73,7 @@ object Test1Test {
// {System.out.print(22); test1.bar}.System.out.println();
{Console.print(23); test1.bar.System}.out.println();
{Console.print(24); test1.bar.System.out}.println();
- {Console.print(25); test1.bar.System.out.println:(() => Unit)} apply ();
+ {Console.print(25); test1.bar.System.out.println:(() => Unit)} .apply ();
{Console.print(26); test1.bar.System.out.println()};
}
diff --git a/tests/run/t2544.scala b/tests/run/t2544.scala
index 6bee2f108230..ff53cf4f18d7 100644
--- a/tests/run/t2544.scala
+++ b/tests/run/t2544.scala
@@ -11,10 +11,10 @@ object Test {
)
def main(args: Array[String]) = {
- println(Foo indexWhere(_ >= 2,1))
- println(Foo.toList indexWhere(_ >= 2,1))
- println(Foo segmentLength(_ <= 3,1))
- println(Foo.toList segmentLength(_ <= 3,1))
+ println(Foo .indexWhere(_ >= 2,1))
+ println(Foo.toList .indexWhere(_ >= 2,1))
+ println(Foo .segmentLength(_ <= 3,1))
+ println(Foo.toList .segmentLength(_ <= 3,1))
lengthEquiv(Foo lengthCompare 7)
lengthEquiv(Foo.toList lengthCompare 7)
lengthEquiv(Foo lengthCompare 2)
diff --git a/tests/run/t4813.scala b/tests/run/t4813.scala
index 1146bb16ec04..29fa71c5608f 100644
--- a/tests/run/t4813.scala
+++ b/tests/run/t4813.scala
@@ -31,7 +31,7 @@ object Test extends dotty.runtime.LegacyApp {
runTest(TreeSet(1,2,3))(_.clone) { buf => buf add 4 }
// Maps
- runTest(HashMap(1->1,2->2,3->3))(_.clone) { buf => buf put (4,4) }
- runTest(WeakHashMap(1->1,2->2,3->3))(_.clone) { buf => buf put (4,4) }
+ runTest(HashMap(1->1,2->2,3->3))(_.clone) { buf => buf.put(4,4) }
+ runTest(WeakHashMap(1->1,2->2,3->3))(_.clone) { buf => buf.put(4,4) }
}
diff --git a/tests/run/t5045.scala b/tests/run/t5045.scala
index 3778339aa4b1..ef992da813f5 100644
--- a/tests/run/t5045.scala
+++ b/tests/run/t5045.scala
@@ -6,7 +6,7 @@ object Test extends dotty.runtime.LegacyApp {
import scala.util.matching.{ Regex, UnanchoredRegex }
val dateP1 = """(\d\d\d\d)-(\d\d)-(\d\d)""".r.unanchored
- val dateP2 = """(\d\d\d\d)-(\d\d)-(\d\d)""" r ("year", "month", "day") unanchored
+ val dateP2 = """(\d\d\d\d)-(\d\d)-(\d\d)""" .r ("year", "month", "day") unanchored
val dateP3 = new Regex("""(\d\d\d\d)-(\d\d)-(\d\d)""", "year", "month", "day") with UnanchoredRegex
val yearStr = "2011"
diff --git a/tests/run/t6271.scala b/tests/run/t6271.scala
index e8047a9be7f2..a7b60b1df7ba 100644
--- a/tests/run/t6271.scala
+++ b/tests/run/t6271.scala
@@ -21,7 +21,7 @@ object Test extends dotty.runtime.LegacyApp {
}
def slicedIssue = {
val viewed : Iterable[Iterable[Int]] = List(List(0).view).view
- val filtered = viewed flatMap { x => List( x slice (2,3) ) }
+ val filtered = viewed flatMap { x => List( x.slice(2,3) ) }
filtered.iterator.toIterable.flatten
}
filterIssue
diff --git a/tests/run/t6827.scala b/tests/run/t6827.scala
index 43e01831c340..7c9c7057aa62 100644
--- a/tests/run/t6827.scala
+++ b/tests/run/t6827.scala
@@ -10,7 +10,7 @@ object Test extends App {
} catch {
case e: Exception => e.toString
}
- println("%s: %s" format (label, status))
+ println("%s: %s".format(label, status))
}
tryit("start at -5", -5, 10)
diff --git a/tests/run/t8610.scala b/tests/run/t8610.scala
index 978900d42d09..f0ffabd0db54 100644
--- a/tests/run/t8610.scala
+++ b/tests/run/t8610.scala
@@ -3,7 +3,7 @@
case class X(name: String) {
def x = "Hi, $name" // missing interp
def f(p: (Int, Int)): Int = p._1 * p._2
- def g = f(3, 4) // adapted
+ def g = f((3, 4)) // adapted
def u: Unit = () // unitarian universalist
}
diff --git a/tests/run/unapply.scala b/tests/run/unapply.scala
index 7b10030ba76d..db8823f00eef 100644
--- a/tests/run/unapply.scala
+++ b/tests/run/unapply.scala
@@ -33,7 +33,7 @@ object VarFoo {
object Foo {
def unapply(x: Any): Option[Product2[Int, String]] = x match {
- case y: Bar => Some(y.size, y.name)
+ case y: Bar => Some((y.size, y.name))
case _ => None
}
def doMatch1(b:Bar) = b match {
@@ -69,7 +69,7 @@ object Foo {
object Mas {
object Gaz {
def unapply(x: Any): Option[Product2[Int, String]] = x match {
- case y: Baz => Some(y.size, y.name)
+ case y: Baz => Some((y.size, y.name))
case _ => None
}
}
diff --git a/tests/run/virtpatmat_unapply.scala b/tests/run/virtpatmat_unapply.scala
index 9915b8d924e5..c52556ae0b69 100644
--- a/tests/run/virtpatmat_unapply.scala
+++ b/tests/run/virtpatmat_unapply.scala
@@ -1,7 +1,7 @@
class IntList(val hd: Int, val tl: IntList)
object NilIL extends IntList(0, null)
object IntList {
- def unapply(il: IntList): Option[(Int, IntList)] = if(il eq NilIL) None else Some(il.hd, il.tl)
+ def unapply(il: IntList): Option[(Int, IntList)] = if(il eq NilIL) None else Some((il.hd, il.tl))
def apply(x: Int, xs: IntList) = new IntList(x, xs)
}