Implement automatic rewrites for named infix arguments interpreted as named tuples

Author: WojciechMazur

compiler/src/dotty/tools/dotc/config/MigrationVersion.scala

@@ -26,6 +26,7 @@ enum MigrationVersion(val warnFrom: SourceVersion, val errorFrom: SourceVersion)
   case WithOperator extends MigrationVersion(`3.4`, future)
   case FunctionUnderscore extends MigrationVersion(`3.4`, future)
   case NonNamedArgumentInJavaAnnotation extends MigrationVersion(`3.6`, `3.6`)
+  case AmbiguousNamedTupleInfixApply extends MigrationVersion(`3.6`, never)
   case ImportWildcard extends MigrationVersion(future, future)
   case ImportRename extends MigrationVersion(future, future)
   case ParameterEnclosedByParenthesis extends MigrationVersion(future, future)

compiler/src/dotty/tools/dotc/core/StdNames.scala

@@ -668,6 +668,7 @@ object StdNames {
     val readResolve: N          = "readResolve"
     val zero: N                 = "zero"
     val zip: N                  = "zip"
+    val `++` : N                = "++"
     val nothingRuntimeClass: N  = "scala.runtime.Nothing$"
     val nullRuntimeClass: N     = "scala.runtime.Null$"
 

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -1120,21 +1120,32 @@ object Parsers {
           if (prec < opPrec || leftAssoc && prec == opPrec) {
             opStack = opStack.tail
             recur {
-              atSpan(opInfo.operator.span union opInfo.operand.span union top.span):
-                def deprecateInfixNamedArg(t: Tree): Unit = t match
-                  case Tuple(ts) => ts.foreach(deprecateInfixNamedArg)
-                  case Parens(t) => deprecateInfixNamedArg(t)
-                  case t: NamedArg => report.deprecationWarning(InfixNamedArgDeprecation(), t.srcPos)
-                  case _ =>
-                deprecateInfixNamedArg(top)
-                InfixOp(opInfo.operand, opInfo.operator, top)
+              migrateInfixOp(opInfo, isType):
+                atSpan(opInfo.operator.span union opInfo.operand.span union top.span):
+                  InfixOp(opInfo.operand, opInfo.operator, top)
             }
           }
           else top
         }
       recur(top)
     }
 
+    private def migrateInfixOp(opInfo: OpInfo, isType: Boolean)(infixOp: InfixOp): Tree = {
+      def isNamedTupleOperator = opInfo.operator.name match
+        case nme.EQ | nme.NE |  nme.eq | nme.ne | nme.`++` | nme.zip => true
+        case _ => false
+      if isType then infixOp
+      else infixOp.right match
+        case Tuple(args) if args.exists(_.isInstanceOf[NamedArg]) && !isNamedTupleOperator =>
+          report.errorOrMigrationWarning(AmbiguousNamedTupleInfixApply(), infixOp.right.srcPos, MigrationVersion.AmbiguousNamedTupleInfixApply)
+          if MigrationVersion.AmbiguousNamedTupleInfixApply.needsPatch then
+            val asApply = cpy.Apply(infixOp)(Select(opInfo.operand, opInfo.operator.name), args)
+            patch(source, infixOp.span, asApply.show)
+            asApply // allow to use pre-3.6 syntax in migration mode
+          else infixOp
+        case _ => infixOp
+    }
+
     /** True if we are seeing a lambda argument after a colon of the form:
      *    : (params) =>
      *      body

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

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

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

@@ -3353,9 +3353,12 @@ final class AmbiguousNamedTupleAssignment(key: Name, value: untpd.Tree)(using Co
 
   override protected def explain(using Context): String = ""
 
-class InfixNamedArgDeprecation()(using Context) extends SyntaxMsg(DeprecatedNamedInfixArgID):
-  def msg(using Context) = "Named argument syntax is deprecated for infix application"
+class AmbiguousNamedTupleInfixApply()(using Context) extends SyntaxMsg(AmbiguousNamedTupleInfixApplyID):
+  def msg(using Context) =
+    "Ambigious syntax: this infix call argument list is interpreted as single named tuple argument, not as an named arguments list."
+    + Message.rewriteNotice("This", version = SourceVersion.`3.6-migration`)
+
   def explain(using Context) =
-    i"""The argument will be parsed as a named tuple in future.
+    i"""Starting with Scala 3.6 infix named arguments are interpretted as Named Tuple.
         |
         |To avoid this warning, either remove the argument names or use dotted selection."""

compiler/test/dotty/tools/dotc/CompilationTests.scala

@@ -79,6 +79,7 @@ class CompilationTests {
       compileFile("tests/rewrites/i20002.scala", defaultOptions.and("-indent", "-rewrite")),
       compileDir("tests/rewrites/annotation-named-pararamters", defaultOptions.and("-rewrite", "-source:3.6-migration")),
       compileFile("tests/rewrites/i21418.scala", unindentOptions.and("-rewrite", "-source:3.5-migration")),
+      compileFile("tests/rewrites/infix-named-args.scala", defaultOptions.and("-rewrite", "-source:3.6-migration")),
     ).checkRewrites()
   }
 

tests/neg/infix-named-args.check

@@ -1,5 +1,5 @@
 -- [E134] Type Error: tests/neg/infix-named-args.scala:2:13 ------------------------------------------------------------
-2 |  def f = 42 + (x = 1) // error // a named tuple!
+2 |  def f = 42 + (x = 1) // error // werror
   |          ^^^^
   |          None of the overloaded alternatives of method + in class Int with types
   |           (x: Double): Double
@@ -11,11 +11,31 @@
   |           (x: Byte): Int
   |           (x: String): String
   |          match arguments ((x : Int)) (a named tuple)
--- [E007] Type Mismatch Error: tests/neg/infix-named-args.scala:13:18 --------------------------------------------------
-13 |  def g = this ** 2 // error
-   |                  ^
-   |                  Found:    (2 : Int)
-   |                  Required: X
+-- [E204] Syntax Warning: tests/neg/infix-named-args.scala:2:15 --------------------------------------------------------
+2 |  def f = 42 + (x = 1) // error // werror
+  |               ^^^^^^^
+  |Ambigious syntax: this infix call argument list is interpreted as single named tuple argument, not as an named arguments list.
+  |This can be rewritten automatically under -rewrite -source 3.6-migration.
+  |
+  | longer explanation available when compiling with `-explain`
+-- [E204] Syntax Warning: tests/neg/infix-named-args.scala:5:26 --------------------------------------------------------
+5 |  def g = new C() `multi` (x = 42, y = 27) // werror
+  |                          ^^^^^^^^^^^^^^^^
+  |Ambigious syntax: this infix call argument list is interpreted as single named tuple argument, not as an named arguments list.
+  |This can be rewritten automatically under -rewrite -source 3.6-migration.
+  |
+  | longer explanation available when compiling with `-explain`
+-- [E204] Syntax Warning: tests/neg/infix-named-args.scala:6:21 --------------------------------------------------------
+6 |  def h = new C() ** (x = 42, y = 27) // werror
+  |                     ^^^^^^^^^^^^^^^^
+  |Ambigious syntax: this infix call argument list is interpreted as single named tuple argument, not as an named arguments list.
+  |This can be rewritten automatically under -rewrite -source 3.6-migration.
+  |
+  | longer explanation available when compiling with `-explain`
+-- [E204] Syntax Warning: tests/neg/infix-named-args.scala:13:18 -------------------------------------------------------
+13 |  def f = this ** (x = 2) // werror
+   |                  ^^^^^^^
+   |Ambigious syntax: this infix call argument list is interpreted as single named tuple argument, not as an named arguments list.
+   |This can be rewritten automatically under -rewrite -source 3.6-migration.
    |
    | longer explanation available when compiling with `-explain`
-there were 6 deprecation warnings; re-run with -deprecation for details

tests/neg/infix-named-args.scala

@@ -1,13 +1,14 @@
 class C:
-  def f = 42 + (x = 1) // error // a named tuple!
+  def f = 42 + (x = 1) // error // werror
   def multi(x: Int, y: Int): Int = x + y
   def **(x: Int, y: Int): Int = x + y
-  def g = new C() `multi` (x = 42, y = 27) // werror // werror // not actually a tuple! appearances to the contrary
-  def h = new C() ** (x = 42, y = 27) // werror // werror
+  def g = new C() `multi` (x = 42, y = 27) // werror
+  def h = new C() ** (x = 42, y = 27) // werror
 
 type X = (x: Int)
 
 class D(d: Int):
+  def **(x: Int): Int = d * x
   def **(x: X): Int = d * x.x
-  def f = this ** (x = 2)
-  def g = this ** 2 // error
+  def f = this ** (x = 2) // werror
+  def g = this ** 2

tests/neg/named-tuples.check

@@ -101,4 +101,3 @@
    |                                Required: (name : ?, age : ?)
    |
    | longer explanation available when compiling with `-explain`
-there were 2 deprecation warnings; re-run with -deprecation for details

tests/rewrites/infix-named-args.check

@@ -0,0 +1,15 @@
+class C:
+  def multi(x: Int, y: Int): Int = x + y
+  def **(x: Int, y: Int): Int = x + y
+  def g = new C().multi(x = 42, y = 27)
+  def h = new C().**(x = 42, y = 27)
+
+type X = (x: Int)
+
+class D(d: Int):
+  def **(x: Int): Int = d * x
+  def **(x: X): Int = d * x.x
+  def f = this.**(x = 2)
+  def g = this ** 2
+  def h = this ** ((x = 2))
+  def i = this.**(x = (1 + 1))