scala · adriaanm · Sep 27, 2017 · Sep 19, 2017
diff --git a/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala b/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala
@@ -1337,8 +1337,12 @@ trait ContextErrors {
       context.warning(arg.pos, note)
     }
 
-    def UnknownParameterNameNamesDefaultError(arg: Tree, name: Name)(implicit context: Context) = {
-      issueNormalTypeError(arg, "unknown parameter name: " + name)
+    def UnknownParameterNameNamesDefaultError(arg: Tree, name: Name, isVariableInScope: Boolean)(implicit context: Context) = {
+      val suffix =
+        if (isVariableInScope)
+          s"\nNote that assignments in argument position are no longer allowed since Scala 2.13.\nTo express the assignment expression, wrap it in brackets, e.g., `{ $name = ... }`."
+        else ""
+      issueNormalTypeError(arg, s"unknown parameter name: $name$suffix")
       setError(arg)
     }
 

diff --git a/src/compiler/scala/tools/nsc/typechecker/NamesDefaults.scala b/src/compiler/scala/tools/nsc/typechecker/NamesDefaults.scala
@@ -486,6 +486,10 @@ trait NamesDefaults { self: Analyzer =>
     } else NoSymbol
   }
 
+  def isVariableInScope(context: Context, name: Name): Boolean = {
+    context.lookupSymbol(name, _.isVariable).isSuccess
+  }
+
   /** A full type check is very expensive; let's make sure there's a name
    *  somewhere which could potentially be ambiguous before we go that route.
    */
@@ -593,19 +597,27 @@ trait NamesDefaults { self: Analyzer =>
       def stripNamedArg(arg: AssignOrNamedArg, argIndex: Int): Tree = {
         val AssignOrNamedArg(Ident(name), rhs) = arg
         params indexWhere (p => matchesName(p, name, argIndex)) match {
-          case -1 if positionalAllowed =>
+          case -1 if positionalAllowed && !settings.isScala213 =>
+            if (isVariableInScope(context0, name)) {
+              // only issue the deprecation warning if `name` is in scope, this avoids the warning when mis-spelling a parameter name.
+              context0.deprecationWarning(
+                arg.pos,
+                context0.owner,
+                s"assignments in argument position are deprecated in favor of named arguments. Wrap the assignment in brackets, e.g., `{ $name = ... }`.",
+                "2.12.4")
+            }
             // prevent isNamed from being true when calling doTypedApply recursively,
             // treat the arg as an assignment of type Unit
             Assign(arg.lhs, rhs) setPos arg.pos
           case -1 =>
-            UnknownParameterNameNamesDefaultError(arg, name)
+            UnknownParameterNameNamesDefaultError(arg, name, isVariableInScope(context0, name))
           case paramPos if argPos contains paramPos =>
             val existingArgIndex = argPos.indexWhere(_ == paramPos)
             val otherName = Some(args(paramPos)) collect {
               case AssignOrNamedArg(Ident(oName), _) if oName != name => oName
             }
             DoubleParamNamesDefaultError(arg, name, existingArgIndex+1, otherName)
-          case paramPos if isAmbiguousAssignment(typer, params(paramPos), arg) =>
+          case paramPos if !settings.isScala213 && isAmbiguousAssignment(typer, params(paramPos), arg) =>
             AmbiguousReferenceInNamesDefaultError(arg, name)
           case paramPos if paramPos != argIndex =>
             positionalAllowed = false    // named arg is not in original parameter order: require names after this

diff --git a/test/files/neg/checksensible.check b/test/files/neg/checksensible.check
@@ -1,3 +1,21 @@
+checksensible.scala:45: warning: Adaptation of argument list by inserting () is deprecated: this is unlikely to be what you want.
+        signature: Any.==(x$1: Any): Boolean
+  given arguments: <none>
+ after adaptation: Any.==((): Unit)
+  () == ()
+     ^
+checksensible.scala:48: warning: Adaptation of argument list by inserting () is deprecated: this is unlikely to be what you want.
+        signature: Object.!=(x$1: Any): Boolean
+  given arguments: <none>
+ after adaptation: Object.!=((): Unit)
+  scala.runtime.BoxedUnit.UNIT != ()
+                               ^
+checksensible.scala:49: warning: Adaptation of argument list by inserting () is deprecated: this is unlikely to be what you want.
+        signature: Any.!=(x$1: Any): Boolean
+  given arguments: <none>
+ after adaptation: Any.!=((): Unit)
+  (scala.runtime.BoxedUnit.UNIT: java.io.Serializable) != () // shouldn't warn
+                                                       ^
 checksensible.scala:13: warning: comparing a fresh object using `eq' will always yield false
   (new AnyRef) eq (new AnyRef)
                ^
@@ -97,7 +115,6 @@ checksensible.scala:84: warning: comparing values of types EqEqRefTest.this.C3 a
 checksensible.scala:95: warning: comparing values of types Unit and Int using `!=' will always yield true
     while ((c = in.read) != -1)
                          ^
-warning: there were three deprecation warnings (since 2.11.0); re-run with -deprecation for details
 error: No warnings can be incurred under -Xfatal-warnings.
-34 warnings found
+36 warnings found
 one error found
diff --git a/test/files/neg/checksensible.flags b/test/files/neg/checksensible.flags
@@ -1 +1 @@
--Xfatal-warnings
+-Xfatal-warnings -deprecation
diff --git a/test/files/neg/names-defaults-neg-213.check b/test/files/neg/names-defaults-neg-213.check
@@ -0,0 +1,16 @@
+names-defaults-neg-213.scala:7: warning: a pure expression does nothing in statement position
+    f1(x = 1) // named arg in 2.13 (value discard), not ambiguous
+           ^
+names-defaults-neg-213.scala:8: error: unknown parameter name: x
+Note that assignments in argument position are no longer allowed since Scala 2.13.
+To express the assignment expression, wrap it in brackets, e.g., `{ x = ... }`.
+    f2(x = 1) // error, no parameter named x. error message mentions change in 2.13
+         ^
+names-defaults-neg-213.scala:13: warning: a pure expression does nothing in statement position
+    f1(x = 1) // ok, named arg (value discard)
+           ^
+names-defaults-neg-213.scala:14: error: unknown parameter name: x
+    f2(x = 1) // error (no such parameter). no mention of new semantics in 2.13
+         ^
+two warnings found
+two errors found
diff --git a/test/files/neg/names-defaults-neg-213.flags b/test/files/neg/names-defaults-neg-213.flags
@@ -0,0 +1 @@
+-Xsource:2.13
diff --git a/test/files/neg/names-defaults-neg-213.scala b/test/files/neg/names-defaults-neg-213.scala
@@ -0,0 +1,16 @@
+class C {
+  def f1(x: Unit): Int = 0
+  def f2(y: Unit): Int = 0
+
+  def t1 = {
+    var x = 0
+    f1(x = 1) // named arg in 2.13 (value discard), not ambiguous
+    f2(x = 1) // error, no parameter named x. error message mentions change in 2.13
+  }
+
+  def t2 = {
+    val x = 0
+    f1(x = 1) // ok, named arg (value discard)
+    f2(x = 1) // error (no such parameter). no mention of new semantics in 2.13 
+  }
+}
diff --git a/test/files/neg/names-defaults-neg-warn.check b/test/files/neg/names-defaults-neg-warn.check
@@ -4,6 +4,20 @@ names-defaults-neg-warn.scala:11: warning: the parameter name s is deprecated: u
 names-defaults-neg-warn.scala:12: warning: the parameter name x is deprecated: use s instead
   deprNam2.g(x = "dlkjf")
                ^
-error: No warnings can be incurred under -Xfatal-warnings.
-two warnings found
-one error found
+names-defaults-neg-warn.scala:22: error: reference to x is ambiguous; it is both a method parameter and a variable in scope.
+    f1(x = 1) // 2.12: error, ambiguous (named arg or assign). 2.13: named arg
+         ^
+names-defaults-neg-warn.scala:23: warning: assignments in argument position are deprecated in favor of named arguments. Wrap the assignment in brackets, e.g., `{ x = ... }`.
+    f2(x = 1) // 2.12: deprecation warning, compiles. 2.13: error, no parameter named x
+         ^
+names-defaults-neg-warn.scala:34: warning: assignments in argument position are deprecated in favor of named arguments. Wrap the assignment in brackets, e.g., `{ x = ... }`.
+    synchronized(x = 1) // deprecation warning in 2.12, error in 2.13
+                   ^
+names-defaults-neg-warn.scala:42: warning: a pure expression does nothing in statement position
+    f1(x = 1) // 2.12, 2.13: ok, named arg (value discard)
+           ^
+names-defaults-neg-warn.scala:43: error: reassignment to val
+    f2(x = 1) // 2.12, 2.13: error (no such parameter). no deprecation warning in 2.12, x is not a variable.
+         ^
+5 warnings found
+two errors found
diff --git a/test/files/neg/names-defaults-neg-warn.scala b/test/files/neg/names-defaults-neg-warn.scala
@@ -12,3 +12,34 @@ object Test extends App {
   deprNam2.g(x = "dlkjf")
   deprNam2.g(s = new Object)
 }
+
+class C {
+  def f1(x: Unit): Unit = ()
+  def f2(y: Unit): Unit = ()
+
+  def t1 = {
+    var x = 0
+    f1(x = 1) // 2.12: error, ambiguous (named arg or assign). 2.13: named arg
+    f2(x = 1) // 2.12: deprecation warning, compiles. 2.13: error, no parameter named x
+
+    // all of the following are assignments to x
+
+    f1((x = 1))
+    f2((x = 1))
+    f1({ x = 1 })
+    f2({ x = 1 })
+    f1 { x = 1 }
+    f2 { x = 1 }
+
+    synchronized(x = 1) // deprecation warning in 2.12, error in 2.13
+    synchronized((x = 1))   // ok
+    synchronized({ x = 1 }) // ok
+    synchronized { x = 1 }  // ok
+  }
+
+  def t2 = {
+    val x = 0
+    f1(x = 1) // 2.12, 2.13: ok, named arg (value discard)
+    f2(x = 1) // 2.12, 2.13: error (no such parameter). no deprecation warning in 2.12, x is not a variable.
+  }
+}
diff --git a/test/files/run/names-defaults.check b/test/files/run/names-defaults.check
@@ -4,7 +4,9 @@ names-defaults.scala:269: warning: a pure expression does nothing in statement p
 names-defaults.scala:269: warning: multiline expressions might require enclosing parentheses; a value can be silently discarded when Unit is expected
     spawn(b = { val ttt = 1; ttt }, a = 0)
                              ^
-warning: there were four deprecation warnings; re-run with -deprecation for details
+warning: there were four deprecation warnings
+warning: there was one deprecation warning (since 2.12.4)
+warning: there were 5 deprecation warnings in total; re-run with -deprecation for details
 1: @
 get: $
 get: 2