Fix insertion of using in applications with trailing lambda syntax

Co-Authored-By: Abdullah Arif Jafri <[email protected]>

Author: mbovel

Diff for: compiler/src/dotty/tools/dotc/typer/Migrations.scala

@@ -138,7 +138,19 @@ trait Migrations:
             |""", 
         pt.args.head.srcPos, mversion)
       if mversion.needsPatch then
-        patch(Span(pt.args.head.span.start), "using ")
+        // In order to insert a `using`, the application needs to be done with
+        // parentheses syntax. See issue #22927 and related tests.
+        patch(Span(tree.span.end, pt.args.head.span.start), "(using ")
+        // Tentative heuristic: the application was done with parentheses syntax
+        // if there is a `(` between the function and the first argument.
+        val hasParentheses =
+          ctx.source.content
+            .slice(tree.span.end, pt.args.head.span.start)
+            .exists(_ == '(')
+        if !hasParentheses then
+          // If the application wasn't done with the parentheses syntax, we need
+          // to add a trailing closing parenthesis.
+          patch(Span(pt.args.head.span.end), ")")
   end implicitParams
 
 end Migrations

Diff for: compiler/test/dotty/tools/dotc/CompilationTests.scala

@@ -88,7 +88,10 @@ class CompilationTests {
       compileFile("tests/rewrites/ambiguous-named-tuple-assignment.scala", defaultOptions.and("-rewrite", "-source:3.6-migration")),
       compileFile("tests/rewrites/i21382.scala", defaultOptions.and("-indent", "-rewrite")),
       compileFile("tests/rewrites/unused.scala", defaultOptions.and("-rewrite", "-Wunused:all")),
-      compileFile("tests/rewrites/i22440.scala", defaultOptions.and("-rewrite"))
+      compileFile("tests/rewrites/i22440.scala", defaultOptions.and("-rewrite")),
+      compileFile("tests/rewrites/i22440.scala", defaultOptions.and("-rewrite")),
+      compileFile("tests/rewrites/i22731.scala", defaultOptions.and("-rewrite", "-source:3.7-migration")),
+      compileFile("tests/rewrites/i22731b.scala", defaultOptions.and("-rewrite", "-source:3.7-migration")),
     ).checkRewrites()
   }
 

Diff for: tests/rewrites/i22731.check

@@ -0,0 +1,11 @@
+class Input(x: String)
+
+trait Decoder[T]
+
+object Decoder:
+  inline def apply[T](implicit f: () => Unit): Decoder[T] = ???
+
+object Input:
+  given Decoder[Input] = Decoder(using { () =>
+    Input("")
+  })

Diff for: tests/rewrites/i22731.scala

@@ -0,0 +1,13 @@
+class Input(x: String)
+
+trait Decoder[T]
+
+object Decoder {
+  inline def apply[T](implicit f: () => Unit): Decoder[T] = ???
+}
+
+object Input {
+  given Decoder[Input] = Decoder { () =>
+    Input("")
+  }
+}

Diff for: tests/rewrites/i22731b.check

@@ -0,0 +1,49 @@
+def foo(implicit f: () => Unit): Unit = ???
+def bar(a: Int)(implicit f: () => Unit): Unit = ???
+
+@main def main =
+  // Trailing lambdas with braces:
+  foo(using { () => 43 })
+  foo(using { () => val x = 42; 43 })
+  foo(using { () => val x = 42; 43 })
+  foo(using {() => val x = 42; 43})
+  bar(1)(using { () =>
+    val x = 42
+    43 })
+
+  // Parentheses:
+  foo(using () => 43 )
+  foo(using () =>
+    val x = 42
+    43
+  )
+  foo(using () =>
+    val x = 42
+    43
+  )
+  foo(using () =>
+    val x = 42
+    43
+  )
+  bar(1)(using () =>
+    val x = 42
+    43 )
+
+  // Trailing lambdas with column and indentation:
+  foo(using () =>
+    43)
+  foo(using () =>
+    val x = 42
+    43)
+  foo(using () =>
+    val x = 42
+    43)
+  foo(using () =>
+    val x = 42
+    43)
+  foo(using () =>
+      val x = 42
+      43)
+  bar(1)(using () =>
+    val x = 42
+    43)

Diff for: tests/rewrites/i22731b.scala

@@ -0,0 +1,52 @@
+def foo(implicit f: () => Unit): Unit = ???
+def bar(a: Int)(implicit f: () => Unit): Unit = ???
+
+@main def main =
+  // Trailing lambdas with braces:
+  foo { () => 43 }
+  foo { () => val x = 42; 43 }
+  foo{ () => val x = 42; 43 }
+  foo {() => val x = 42; 43}
+  bar(1) { () =>
+    val x = 42
+    43 }
+
+  // Parentheses:
+  foo ( () => 43 )
+  foo ( () =>
+    val x = 42
+    43
+  )
+  foo( () =>
+    val x = 42
+    43
+  )
+  foo (() =>
+    val x = 42
+    43
+  )
+  bar(1) ( () =>
+    val x = 42
+    43 )
+
+  // Trailing lambdas with column and indentation:
+  foo: () =>
+    43
+  foo : () =>
+    val x = 42
+    43
+  foo :() =>
+    val x = 42
+    43
+  foo
+  : () =>
+    val x = 42
+    43
+  foo
+  :
+    () =>
+      val x = 42
+      43
+  bar(1) : () =>
+    val x = 42
+    43