Add inlay hints for showing omitted function return types (#1011)

Fixes #869. The attached text edits also suffer from #1001.

Author: timsueberkrueb

effekt/jvm/src/main/scala/effekt/Server.scala

@@ -8,7 +8,7 @@ import effekt.source.{Span, Tree}
 import effekt.symbols.Binder.{ValBinder, VarBinder}
 import effekt.symbols.BlockTypeConstructor.{ExternInterface, Interface}
 import effekt.symbols.TypeConstructor.{DataType, ExternType}
-import effekt.symbols.{Anon, Binder, Callable, Effects, Module, Param, Symbol, TypeAlias, TypePrinter, UserFunction, ValueType, isSynthetic}
+import effekt.symbols.{Anon, Binder, Callable, Effects, ErrorMessageInterpolator, Module, Param, Symbol, TypeAlias, TypePrinter, UserFunction, ValueType, isSynthetic}
 import effekt.util.messages.EffektError
 import effekt.util.{PlainMessaging, PrettyPrinter}
 import kiama.util.Collections.{mapToJavaMap, seqToJavaList}
@@ -373,7 +373,7 @@ class Server(config: EffektConfig, compileOnChange: Boolean=false) extends Langu
       source <- sources.get(params.getTextDocument.getUri)
       hints = {
         val range = fromLSPRange(params.getRange, source)
-        getInferredCaptures(range)(using context).map {
+        val captures = getInferredCaptures(range)(using context).map {
           case (p, c) =>
             val prettyCaptures = TypePrinter.show(c)
             val inlayHint = new InlayHint(convertPosition(p), messages.Either.forLeft(prettyCaptures))
@@ -386,6 +386,32 @@ class Server(config: EffektConfig, compileOnChange: Boolean=false) extends Langu
             inlayHint.setData("capture")
             inlayHint
         }.toVector
+
+        val unannotated = getTreesInRange(range)(using context).map { trees =>
+          trees.collect {
+            // Functions without an annotated type:
+            case fun: FunDef if fun.ret.isEmpty => for {
+              sym <- context.symbolOption(fun.id)
+              tpe <- context.functionTypeOption(sym)
+              pos = fun.ret.span.range.from
+            } yield {
+              val prettyType = pp": ${tpe.result} / ${tpe.effects}"
+              val inlayHint = new InlayHint(convertPosition(pos), messages.Either.forLeft(prettyType))
+              inlayHint.setKind(InlayHintKind.Type)
+              val markup = new MarkupContent()
+              markup.setValue(s"return type${prettyType}")
+              markup.setKind("markdown")
+              inlayHint.setTooltip(markup)
+              inlayHint.setPaddingLeft(true)
+              inlayHint.setData("return-type-annotation")
+              val textEdit = new TextEdit(convertRange(fun.ret.span.range), prettyType)
+              inlayHint.setTextEdits(Collections.seqToJavaList(List(textEdit)))
+              inlayHint
+            }
+          }.flatten
+        }.getOrElse(Vector())
+
+        captures ++ unannotated
       }
     } yield hints
 

effekt/jvm/src/test/scala/effekt/LSPTests.scala

@@ -572,11 +572,11 @@ class LSPTests extends FunSuite {
   //
   //
 
-  test("inlayHints should show the io effect") {
+  test("inlayHint should show the io effect") {
     withClientAndServer { (client, server) =>
       val (textDoc, positions) = raw"""
                                 |↑
-                                |def main() = {
+                                |def main(): Unit = {
                                 |↑
                                 |  println("Hello, world!")
                                 |}
@@ -609,12 +609,61 @@ class LSPTests extends FunSuite {
     }
   }
 
-  test("inlayHints work after editing") {
+  test("inlayHint shows omitted return type and effect") {
+    withClientAndServer { (client, server) =>
+      val (textDoc, positions) =
+        raw"""effect raise(): Unit
+             |
+             |↑
+             |def foo() = { do raise(); 5 }
+             |↑        ↑
+             |
+             |↑
+             |""".textDocumentAndPositions
+
+      val captureHint = new InlayHint()
+      captureHint.setKind(InlayHintKind.Type)
+      captureHint.setPosition(positions(1))
+      captureHint.setLabel("{}")
+      captureHint.setData("capture")
+      captureHint.setTooltip(new MarkupContent("markdown", "captures: `{}`"))
+      captureHint.setPaddingRight(true)
+
+      val omittedHint = new InlayHint()
+      omittedHint.setKind(InlayHintKind.Type)
+      omittedHint.setPosition(positions(2))
+      omittedHint.setLabel(": Int / { raise }")
+      omittedHint.setData("return-type-annotation")
+      omittedHint.setTextEdits(List(
+        new TextEdit(
+          new Range(positions(2), positions(2)),
+          ": Int / { raise }"
+        )
+      ).asJava)
+      omittedHint.setTooltip(new MarkupContent("markdown", "return type: Int / { raise }"))
+      omittedHint.setPaddingLeft(true)
+
+      val expectedInlayHints = List(captureHint, omittedHint)
+
+      val didOpenParams = new DidOpenTextDocumentParams()
+      didOpenParams.setTextDocument(textDoc)
+      server.getTextDocumentService().didOpen(didOpenParams)
+
+      val params = new InlayHintParams()
+      params.setTextDocument(textDoc.versionedTextDocumentIdentifier)
+      params.setRange(new Range(positions(0), positions(3)))
+
+      val inlayHints = server.getTextDocumentService().inlayHint(params).get()
+      assertEquals(expectedInlayHints.asJava, inlayHints)
+    }
+  }
+
+  test("inlayHint works after editing") {
     withClientAndServer { (client, server) =>
       val (textDoc, positions) =
         raw"""
              |↑
-             |def main() = {
+             |def main(): Unit = {
              |↑
              |  println("Hello, world!")
              |}
@@ -652,7 +701,7 @@ class LSPTests extends FunSuite {
       val (newTextDoc, changeEvent) = textDoc.changeTo(
         raw"""
              |
-             |def main() = {
+             |def main(): Unit = {
              |  println("Hello, world!")
              |}
              |""".stripMargin
@@ -694,12 +743,12 @@ class LSPTests extends FunSuite {
 
   }
 
-  test("inlayHints work after invalid edits") {
+  test("inlayHint works after invalid edits") {
     withClientAndServer(false) { (client, server) =>
       val (textDoc, positions) =
         raw"""
              |↑
-             |def main() = {
+             |def main(): Unit = {
              |↑
              |  println("Hello, world!")
              |}
@@ -736,7 +785,7 @@ class LSPTests extends FunSuite {
 
       val (newTextDoc, changeEvent) = textDoc.changeTo(
         raw"""
-             |def main() = {
+             |def main(): Unit = {
              |  println("Hello, world!")
              |}
              |invalid syntax

effekt/shared/src/main/scala/effekt/source/Tree.scala

@@ -298,7 +298,7 @@ case class Maybe[T](unspan: Option[T], span: Span) {
       case None => alternative
     }
 
-  export unspan.{foreach, get, getOrElse}
+  export unspan.{foreach, get, getOrElse, isEmpty}
 }
 
 object Maybe {