Warn when named tuples resemble assignments (#21823)

This PR adds a warning for named tuples that look like assignment, such
as `(x = 1)`.

This is the first half to implement #21681. The second will be to add
warnings for named arguments to infix method calls (as a separate PR?).

Started during the Spree of October 21st.

Closes #21770.

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

@@ -1605,9 +1605,10 @@ object desugar {
 
  /** Translate tuple expressions
  *
- * () ==> ()
- * (t) ==> t
- * (t1, ..., tN) ==> TupleN(t1, ..., tN)
+ * () ==> ()
+ * (t) ==> t
+ * (t1, ..., tN) ==> TupleN(t1, ..., tN)
+ * (n1 = t1, ..., nN = tN) ==> NamedTuple.build[(n1, ..., nN)]()(TupleN(t1, ..., tN))
  */
  def tuple(tree: Tuple, pt: Type)(using Context): Tree =
  var elems = checkWellFormedTupleElems(tree.trees)

compiler/src/dotty/tools/dotc/reporting/ErrorMessageID.scala

@@ -216,6 +216,7 @@ enum ErrorMessageID(val isActive: Boolean = true) extends java.lang.Enum[ErrorMe
  case FinalLocalDefID // errorNumber: 200
  case NonNamedArgumentInJavaAnnotationID // errorNumber: 201
  case QuotedTypeMissingID // errorNumber: 202
+ case AmbiguousNamedTupleAssignmentID // errorNumber: 203
 
  def errorNumber = ordinal - 1
 

compiler/src/dotty/tools/dotc/reporting/messages.scala

@@ -3343,3 +3343,12 @@ final class QuotedTypeMissing(tpe: Type)(using Context) extends StagingMessage(Q
  |"""
 
 end QuotedTypeMissing
+
+final class AmbiguousNamedTupleAssignment(key: Name, value: untpd.Tree)(using Context) extends SyntaxMsg(AmbiguousNamedTupleAssignmentID):
+ override protected def msg(using Context): String =
+ i"""Ambiguous syntax: this is interpreted as a named tuple with one element,
+ |not as an assignment.
+ |
+ |To assign a value, use curly braces: `{${key} = ${value}}`."""
+
+ override protected def explain(using Context): String = ""

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

@@ -3398,6 +3398,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
  /** Translate tuples of all arities */
  def typedTuple(tree: untpd.Tuple, pt: Type)(using Context): Tree =
  val tree1 = desugar.tuple(tree, pt)
+ checkAmbiguousNamedTupleAssignment(tree)
  if tree1 ne tree then typed(tree1, pt)
  else
  val arity = tree.trees.length
@@ -3423,6 +3424,20 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
  val resTpe = TypeOps.nestedPairs(elemTpes)
  app1.cast(resTpe)
 
+ /** Checks if `tree` is a named tuple with one element that could be
+ * interpreted as an assignment, such as `(x = 1)`. If so, issues a warning.
+ */
+ def checkAmbiguousNamedTupleAssignment(tree: untpd.Tuple)(using Context): Unit =
+ tree.trees match
+ case List(NamedArg(name, value)) =>
+ val tmpCtx = ctx.fresh.setNewTyperState()
+ typedAssign(untpd.Assign(untpd.Ident(name), value), WildcardType)(using tmpCtx)
+ if !tmpCtx.reporter.hasErrors then
+ // If there are no errors typing the above, then the named tuple is
+ // ambiguous and we issue a warning.
+ report.migrationWarning(AmbiguousNamedTupleAssignment(name, value), tree.srcPos)
+ case _ => ()
+
  /** Retrieve symbol attached to given tree */
  protected def retrieveSym(tree: untpd.Tree)(using Context): Symbol = tree.removeAttachment(SymOfTree) match {
  case Some(sym) =>

tests/pos/21681d.scala

@@ -0,0 +1,16 @@
+def test1() =
+ class Person:
+ def age: Int = ???
+ def age_=(x: Int): Unit = ???
+
+ val person = Person()
+
+ (person.age = 29) // no warn (interpreted as `person.age_=(29)`)
+
+def test2() =
+ class Person:
+ var age: Int = 28
+
+ val person = Person()
+
+ (person.age = 29) // no warn (interpreted as `person.age_=(29)`)

tests/warn/21681.check

@@ -0,0 +1,7 @@
+-- [E203] Syntax Migration Warning: tests/warn/21681.scala:3:2 ---------------------------------------------------------
+3 | (age = 29) // warn
+ | ^^^^^^^^^^
+ | Ambiguous syntax: this is interpreted as a named tuple with one element,
+ | not as an assignment.
+ |
+ | To assign a value, use curly braces: `{age = 29}`.

tests/warn/21681.scala

@@ -0,0 +1,3 @@
+def main() =
+ var age: Int = 28
+ (age = 29) // warn

tests/warn/21681b.check

@@ -0,0 +1,7 @@
+-- [E203] Syntax Migration Warning: tests/warn/21681b.scala:3:2 --------------------------------------------------------
+3 | (age = 29) // warn
+ | ^^^^^^^^^^
+ | Ambiguous syntax: this is interpreted as a named tuple with one element,
+ | not as an assignment.
+ |
+ | To assign a value, use curly braces: `{age = 29}`.

tests/warn/21681b.scala

@@ -0,0 +1,3 @@
+object Test:
+ var age: Int = 28
+ (age = 29) // warn

tests/warn/21681c.check

@@ -0,0 +1,7 @@
+-- [E203] Syntax Migration Warning: tests/warn/21681c.scala:5:2 --------------------------------------------------------
+5 | (age = 29) // warn
+ | ^^^^^^^^^^
+ | Ambiguous syntax: this is interpreted as a named tuple with one element,
+ | not as an assignment.
+ |
+ | To assign a value, use curly braces: `{age = 29}`.

tests/warn/21681c.scala

@@ -0,0 +1,5 @@
+object Test:
+ def age: Int = ???
+ def age_=(x: Int): Unit = ()
+ age = 29
+ (age = 29) // warn

tests/warn/21770.check

@@ -0,0 +1,7 @@
+-- [E203] Syntax Migration Warning: tests/warn/21770.scala:5:9 ---------------------------------------------------------
+5 | f(i => (cache = Some(i))) // warn
+ | ^^^^^^^^^^^^^^^^^
+ | Ambiguous syntax: this is interpreted as a named tuple with one element,
+ | not as an assignment.
+ |
+ | To assign a value, use curly braces: `{cache = Some(i)}`.

tests/warn/21770.scala

@@ -0,0 +1,5 @@
+def f(g: Int => Unit) = g(0)
+
+def test = 
+ var cache: Option[Int] = None
+ f(i => (cache = Some(i))) // warn