feat: add in an action for missing empty argument list

Author: ckipp01

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

@@ -32,6 +32,7 @@ import cc.CaptureSet.IdentityCaptRefMap
 import dotty.tools.dotc.rewrites.Rewrites.ActionPatch
 import dotty.tools.dotc.util.Spans.Span
 import dotty.tools.dotc.util.SourcePosition
+import scala.jdk.CollectionConverters.*
 
 /**  Messages
   *  ========
@@ -1858,8 +1859,6 @@ class OnlyFunctionsCanBeFollowedByUnderscore(tp: Type, tree: untpd.PostfixOp)(us
 
   override def actions(using Context) =
     val untpd.PostfixOp(qual, Ident(nme.WILDCARD)) = tree: @unchecked
-    import scala.language.unsafeNulls
-    import scala.jdk.CollectionConverters.*
     List(
       CodeAction(title = "Rewrite to function value",
         description =  java.util.Optional.empty(),
@@ -1871,7 +1870,7 @@ class OnlyFunctionsCanBeFollowedByUnderscore(tp: Type, tree: untpd.PostfixOp)(us
     ).asJava
 }
 
-class MissingEmptyArgumentList(method: String)(using Context)
+class MissingEmptyArgumentList(method: String, tree: tpd.Tree)(using Context)
   extends SyntaxMsg(MissingEmptyArgumentListID) {
   def msg(using Context) = i"$method must be called with ${hl("()")} argument"
   def explain(using Context) = {
@@ -1886,6 +1885,16 @@ class MissingEmptyArgumentList(method: String)(using Context)
         |In Dotty, this idiom is an error. The application syntax has to follow exactly the parameter syntax.
         |Excluded from this rule are methods that are defined in Java or that override methods defined in Java."""
   }
+
+  override def actions(using Context) =
+    List(
+      CodeAction(title = "Insert ()",
+        description =  java.util.Optional.empty(),
+        patches = List(
+          ActionPatch(SourcePosition(tree.source, tree.span.endPos), "()"),
+        ).asJava
+      )
+    ).asJava
 }
 
 class DuplicateNamedTypeParameter(name: Name)(using Context)

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

@@ -55,7 +55,7 @@ object ErrorReporting {
     val meth = err.exprStr(methPart(tree))
     val info = if tree.symbol.exists then tree.symbol.info else mt
     if isCallableWithSingleEmptyArgumentList(info) then
-      report.error(MissingEmptyArgumentList(meth), tree.srcPos)
+      report.error(MissingEmptyArgumentList(meth, tree), tree.srcPos)
     else
       report.error(MissingArgumentList(meth, tree.symbol), tree.srcPos)
 

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

@@ -3953,7 +3953,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
       def isAutoApplied(sym: Symbol): Boolean =
         sym.isConstructor
         || sym.matchNullaryLoosely
-        || Feature.warnOnMigration(MissingEmptyArgumentList(sym.show), tree.srcPos, version = `3.0`)
+        || Feature.warnOnMigration(MissingEmptyArgumentList(sym.show, tree), tree.srcPos, version = `3.0`)
            && { patch(tree.span.endPos, "()"); true }
 
       /** If this is a selection prototype of the form `.apply(...): R`, return the nested

compiler/test/dotty/tools/dotc/reporting/CodeActionTest.scala

@@ -30,6 +30,20 @@ class CodeActionTest extends DottyTest:
          |""".stripMargin
       )
 
+  @Test def insertBracesForEmptyArgument =
+    checkCodeAction(
+      """|object Test:
+         |  def foo(): Unit = ()
+         |  val x = foo
+         |""".stripMargin,
+      "Insert ()",
+      """|object Test:
+         |  def foo(): Unit = ()
+         |  val x = foo()
+         |""".stripMargin
+
+      )
+
   // Make sure we're not using the default reporter, which is the ConsoleReporter,
   // meaning they will get reported in the test run and that's it.
   private def newContext =
@@ -41,11 +55,11 @@ class CodeActionTest extends DottyTest:
     val source = SourceFile.virtual("test", code).content
     val runCtx = checkCompile("typer", code) { (_, _) => () }
     val diagnostics = runCtx.reporter.removeBufferedMessages
-    assertEquals(diagnostics.size, 1)
+    assertEquals(1, diagnostics.size)
 
     val diagnostic = diagnostics.head
     val actions = diagnostic.msg.actions.asScala.toList
-    assertEquals(actions.size, 1)
+    assertEquals(1, actions.size)
 
     // TODO account for more than 1 action
     val action = actions.head
@@ -80,4 +94,4 @@ class CodeActionTest extends DottyTest:
           assert(outNew == result.length, s"$outNew != ${result.length}")
 
     loop(patches, 0, 0)
-    assertEquals(result.mkString, expected)
+    assertEquals(expected, result.mkString)