Change explicit box capture syntax (#1017)

Closes #965.

Author: timsueberkrueb

effekt/js/src/main/scala/effekt/LanguageServer.scala

@@ -1,12 +1,12 @@
 package effekt
 
-import effekt.context.{ Context, VirtualFileSource, VirtualModuleDB }
-
-import effekt.util.{ PlainMessaging, getOrElseAborting }
-import effekt.util.messages.{ BufferedMessaging, EffektError, EffektMessaging, FatalPhaseError }
+import effekt.Intelligence.CaptureInfo
+import effekt.context.{Context, VirtualFileSource, VirtualModuleDB}
+import effekt.util.{PlainMessaging, getOrElseAborting}
+import effekt.util.messages.{BufferedMessaging, EffektError, EffektMessaging, FatalPhaseError}
 import effekt.util.paths.*
 import effekt.generator.js.JavaScriptWeb
-import kiama.util.{ Messaging, Position, Positions, Severities, Source, StringSource }
+import kiama.util.{Messaging, Position, Positions, Severities, Source, StringSource}
 
 import scala.scalajs.js
 import scala.scalajs.js.JSConverters.*
@@ -117,7 +117,7 @@ class LanguageServer extends Intelligence {
     val source = VirtualFileSource(path)
     val range = kiama.util.Range(source.offsetToPosition(0), source.offsetToPosition(source.charCount))
     getInferredCaptures(range).map {
-      case (p, c) => new lsp.CaptureInfo(toLSPPosition(p), c.toString)
+      case CaptureInfo(p, c, _) => new lsp.CaptureInfo(toLSPPosition(p), c.toString)
     }.toJSArray
   }
 

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

@@ -1,6 +1,7 @@
 package effekt
 
 import com.google.gson.JsonElement
+import effekt.Intelligence.CaptureInfo
 import effekt.context.Context
 import effekt.source.Def.FunDef
 import effekt.source.Term.Hole
@@ -374,15 +375,19 @@ class Server(config: EffektConfig, compileOnChange: Boolean=false) extends Langu
       hints = {
         val range = fromLSPRange(params.getRange, source)
         val captures = getInferredCaptures(range)(using context).map {
-          case (p, c) =>
+          case CaptureInfo(p, c, atSyntax) =>
             val prettyCaptures = TypePrinter.show(c)
-            val inlayHint = new InlayHint(convertPosition(p), messages.Either.forLeft(prettyCaptures))
+            val codeEdit = if atSyntax then s"at ${prettyCaptures}" else prettyCaptures
+            val inlayHint = new InlayHint(convertPosition(p), messages.Either.forLeft(codeEdit))
             inlayHint.setKind(InlayHintKind.Type)
             val markup = new MarkupContent()
             markup.setValue(s"captures: `${prettyCaptures}`")
             markup.setKind("markdown")
             inlayHint.setTooltip(markup)
-            inlayHint.setPaddingRight(true)
+            if (atSyntax) then
+              inlayHint.setPaddingLeft(true)
+            else
+              inlayHint.setPaddingRight(true)
             inlayHint.setData("capture")
             inlayHint
         }.toVector

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

@@ -572,7 +572,7 @@ class LSPTests extends FunSuite {
   //
   //
 
-  test("inlayHint should show the io effect") {
+  test("inlayHint shows the io capture on a def") {
     withClientAndServer { (client, server) =>
       val (textDoc, positions) = raw"""
                                 |↑
@@ -609,6 +609,43 @@ class LSPTests extends FunSuite {
     }
   }
 
+  test("inlayHint shows the io capture in explicit box syntax") {
+    withClientAndServer { (client, server) =>
+      val (textDoc, positions) = raw"""def foo(): Unit = { println("foo") }
+                                |
+                                |↑
+                                |val bar = box { () => foo() }
+                                |                             ↑
+                                |
+                                |↑
+                                |""".textDocumentAndPositions
+
+      val inlayHint = new InlayHint()
+      inlayHint.setKind(InlayHintKind.Type)
+      inlayHint.setPosition(positions(1))
+      inlayHint.setLabel("at {io}")
+      val markup = new MarkupContent()
+      markup.setKind("markdown")
+      markup.setValue("captures: `{io}`")
+      inlayHint.setTooltip(markup)
+      inlayHint.setPaddingLeft(true)
+      inlayHint.setData("capture")
+
+      val expectedInlayHints = List(inlayHint)
+
+      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(2)))
+
+      val inlayHints = server.getTextDocumentService().inlayHint(params).get()
+      assertEquals(inlayHints, expectedInlayHints.asJava)
+    }
+  }
+
   test("inlayHint shows omitted return type and effect") {
     withClientAndServer { (client, server) =>
       val (textDoc, positions) =

effekt/jvm/src/test/scala/effekt/RecursiveDescentTests.scala

@@ -255,6 +255,10 @@ class RecursiveDescentTests extends munit.FunSuite {
     assertEquals(peek(tokens, 3).kind, EOF)
   }
 
+  // Parsing tests
+  //
+  //
+
   test("Simple expressions") {
     parseExpr("42")
     parseExpr("f")
@@ -316,13 +320,27 @@ class RecursiveDescentTests extends munit.FunSuite {
     )
     assertNotEqualModuloSpans(
       parseExpr("box { 42 }"),
-      parseExpr("box {} { 42 }")
+      parseExpr("box { 42 } at {}")
     )
     parseExpr("box { (x: Int) => x }")
     parseExpr("box new Fresh { def fresh() = \"42\" }")
     parseExpr("box foo()")
     parseExpr("box bar(1)")
     parseExpr("box baz(quux)")
+    parseExpr("box { (x, y) => compareByteString(x, y) } at {io, global}")
+
+    {
+      val (source, pos) =
+        raw"""box { (x, y) => compareByteString(x, y) }
+             |                                         ↑
+             |""".sourceAndPosition
+      val b = parseExpr(source.content)
+      b match {
+        case Term.Box(c, _) => assertEquals(c.span, Span(source, pos, pos, Synthesized))
+        case other =>
+          throw new IllegalArgumentException(s"Expected Box but got ${other.getClass.getSimpleName}")
+      }
+    }
 
     // { f } is parsed as a capture set and not backtracked.
     intercept[Throwable] { parseExpr("box { f }") }

effekt/shared/src/main/scala/effekt/Intelligence.scala

@@ -1,8 +1,8 @@
 package effekt
 
 import effekt.context.{Annotations, Context}
-import effekt.source.{FunDef, Include, ModuleDecl, Span, Tree}
-import effekt.symbols.Hole
+import effekt.source.{FunDef, Include, Maybe, ModuleDecl, Span, Tree}
+import effekt.symbols.{CaptureSet, Hole}
 import kiama.util.{Position, Source}
 import effekt.symbols.scopes.Scope
 
@@ -182,7 +182,7 @@ trait Intelligence {
     C.annotationOption(Annotations.CaptureForFile, src).getOrElse(Nil)
 
   // For now, we only show captures of function definitions and calls to box
-  def getInferredCaptures(range: kiama.util.Range)(using C: Context): List[(Position, CaptureSet)] =
+  def getInferredCaptures(range: kiama.util.Range)(using C: Context): List[CaptureInfo] =
     val src = range.from.source
     allCaptures(src).filter {
       // keep only captures in the current range
@@ -192,14 +192,13 @@ trait Intelligence {
     }.collect {
       case (t: source.FunDef, c) => for {
         pos <- C.positions.getStart(t)
-      } yield (pos, c)
+      } yield CaptureInfo(pos, c)
       case (t: source.DefDef, c) => for {
         pos <- C.positions.getStart(t)
-      } yield (pos, c)
-      case (source.Box(None, block), _) if C.inferredCaptureOption(block).isDefined => for {
-        pos <- C.positions.getStart(block)
+      } yield CaptureInfo(pos, c)
+      case (source.Box(Maybe(None, span), block), _) if C.inferredCaptureOption(block).isDefined => for {
         capt <- C.inferredCaptureOption(block)
-      } yield (pos, capt)
+      } yield CaptureInfo(span.range.from, capt, true)
     }.flatten
 
   def getInfoOf(sym: Symbol)(using C: Context): Option[SymbolInfo] = PartialFunction.condOpt(resolveCallTarget(sym)) {
@@ -354,4 +353,13 @@ object Intelligence {
         terms ++ other.terms,
         types ++ other.types)
   }
+
+  case class CaptureInfo(
+    position: Position,
+    captures: CaptureSet,
+    /**
+     * Whether this capture set could be written into the source code at `position` using the `at { captures }` syntax
+     */
+    atSyntax: Boolean = false,
+  )
 }

effekt/shared/src/main/scala/effekt/RecursiveDescent.scala

@@ -674,20 +674,22 @@ class RecursiveDescent(positions: Positions, tokens: Seq[Token], source: Source)
     nonterminal:
       Region(`region` ~> idDef(), stmt())
 
-  def boxExpr(): Term =
+  def boxExpr(): Term = {
     nonterminal:
-      val captures = `box` ~> backtrack(captureSet())
+      consume(`box`)
       val expr = if (peek(`{`)) functionArg()
-        else if (peek(`new`)) newExpr()
-        else callExpr()
-      Box(captures.unspan, expr)
-
+      else callExpr()
+      val captures = backtrack {
+        `at` ~> captureSet()
+      }
+      Box(captures, expr)
+  }
 
   // TODO deprecate
   def funExpr(): Term =
     nonterminal:
-      `fun` ~> Box(None, BlockLiteral(Nil, valueParams().unspan, Nil, braces { stmts() }))
-    // TODO positions
+      val blockLiteral = `fun` ~> BlockLiteral(Nil, valueParams().unspan, Nil, braces { stmts() })
+      Box(Maybe.None(Span(source, pos(), pos(), Synthesized)), blockLiteral)
 
   def unboxExpr(): Term =
     nonterminal:
@@ -1347,8 +1349,13 @@ class RecursiveDescent(positions: Positions, tokens: Seq[Token], source: Source)
 
   inline def backtrack[T](inline p: => T): Maybe[T] =
     val before = position
-    try { Maybe.Some(p, span(before)) } catch {
-      case Fail(_, _) => position = before; Maybe.None(span(before))
+    val beforePrevious = previous
+    try { Maybe.Some(p, span(tokens(before).end)) } catch {
+      case Fail(_, _) => {
+        position = before
+        previous = beforePrevious
+        Maybe.None(Span(source, previous.end + 1, previous.end + 1, Synthesized))
+      }
     }
 
   def interleave[A](xs: List[A], ys: List[A]): List[A] = (xs, ys) match {

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

@@ -456,7 +456,7 @@ enum Term extends Tree {
   case Hole(id: IdDef, stmts: Stmt, override val span: Span)
 
   // Boxing and unboxing to represent first-class values
-  case Box(capt: Option[CaptureSet], block: Term)
+  case Box(capt: Maybe[CaptureSet], block: Term)
   case Unbox(term: Term)
 
   /**

effekt/shared/src/main/scala/effekt/typer/BoxUnboxInference.scala

@@ -50,12 +50,12 @@ object BoxUnboxInference extends Phase[NameResolved, NameResolved] {
     case v: Var => v.definition match {
       // TODO maybe we should synthesize a call to get here already?
       case sym: (ValueSymbol | symbols.RefBinder) => v
-      case sym: BlockSymbol => Box(None, v).inheritPosition(v)
+      case sym: BlockSymbol => Box(Maybe.None(v.span.emptyAfter), v).inheritPosition(v)
     }
 
-    case n: New => Box(None, rewriteAsBlock(n)).inheritPosition(n)
+    case n: New => Box(Maybe.None(n.span.emptyAfter), rewriteAsBlock(n)).inheritPosition(n)
 
-    case b: BlockLiteral => Box(None, rewriteAsBlock(b)).inheritPosition(b)
+    case b: BlockLiteral => Box(Maybe.None(b.span.emptyAfter), rewriteAsBlock(b)).inheritPosition(b)
 
     case l: Literal => l
 

examples/neg/issue362.check

@@ -1,3 +1,3 @@
-[error] examples/neg/issue362.effekt:4:31: Not allowed {arr}
-def foo() {arr: Exc} = box {} { read {arr} }
-                              ^^^^^^^^^^^^^^
+[error] examples/neg/issue362.effekt:4:28: Not allowed {arr}
+def foo() {arr: Exc} = box { read {arr} } at {}
+                           ^^^^^^^^^^^^^^

examples/neg/issue362.effekt

@@ -1,7 +1,7 @@
 interface Exc { def op(): Unit }
 def read {t: Exc}: Unit = t.op()
 
-def foo() {arr: Exc} = box {} { read {arr} }
+def foo() {arr: Exc} = box { read {arr} } at {}
 
 def main() = {
   val cap = try {