Add resource finalization to handlers

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

@@ -448,6 +448,37 @@ class RecursiveDescentTests extends munit.FunSuite {
       with Eff3 { def op(x, y) = { x } def op2() = { () }}
       """
     )
+    parseTry(
+      """try { 42 }
+      with Empty {}
+      suspend { println("hello") }
+      resume { x => println("resuming...") }
+      return { x => x}
+      """
+    )
+    parseTry(
+      """try 42 with Empty {}
+      return { (x: Int) => x }
+      """
+    )
+    parseTry(
+      """try 42
+      return { (x: Int) => x }
+      """
+    )
+    parseTry(
+      """try "a"
+      with Empty {}
+      finally { _ => println("done") }
+      """
+    )
+    intercept[Throwable] {
+      parseTry(
+        """try { 42 }
+        resume { println("resuming") }
+        """
+      )
+    }
   }
 
   test("Type definition") {

effekt/shared/src/main/scala/effekt/Lexer.scala

@@ -108,6 +108,9 @@ enum TokenKind {
   case `is`
   case `namespace`
   case `pure`
+  // case `on`
+  case `suspend`
+  case `finally`
 }
 object TokenKind {
   // "Soft" keywords
@@ -135,7 +138,8 @@ object TokenKind {
     `let`, `true`, `false`, `val`, `var`, `if`, `else`, `while`, `type`, `effect`, `interface`,
     `try`, `with`, `case`, `do`, `fun`, `match`, `def`, `module`, `import`, `export`, `extern`,
     `include`, `record`, `box`, `unbox`, `return`, `region`, `resource`, `new`, `and`, `is`,
-    `namespace`, `pure`)
+    `namespace`, `pure`, `suspend`, `resume`, `finally`
+  )
 
 }
 

effekt/shared/src/main/scala/effekt/Namer.scala

@@ -397,7 +397,7 @@ object Namer extends Phase[Parsed, NameResolved] {
     case source.BlockStmt(block) =>
       Context scoped { resolveGeneric(block) }
 
-    case tree @ source.TryHandle(body, handlers) =>
+    case tree @ source.TryHandle(body, handlers, suspend, resume, ret) =>
       resolveAll(handlers)
 
       Context scoped {
@@ -411,6 +411,9 @@ object Namer extends Phase[Parsed, NameResolved] {
 
         resolveGeneric(body)
       }
+      Context scoped { suspend foreach { resolveGeneric } }
+      Context scoped { resume foreach { resolveGeneric } }
+      Context scoped { ret foreach { resolveGeneric } }
 
     case tree @ source.Region(name, body) =>
       val reg = BlockParam(Name.local(name.name), Some(builtins.TRegion))
@@ -586,6 +589,14 @@ object Namer extends Phase[Parsed, NameResolved] {
     case leaf           => ()
   }
 
+  def resolve(c: source.FinalizerClause)(using Context): Unit = {
+    val source.FinalizerClause(vp, body) = c
+    Context.scoped {
+      vp foreach { case v => Context.bind(resolve(v)) }
+      resolveGeneric(body)
+    }
+  }
+
   /**
    * Resolve Parameters as part of resolving function signatures
    *

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

@@ -659,8 +659,17 @@ class RecursiveDescent(positions: Positions, tokens: Seq[Token], source: Source)
   */
   def tryExpr(): Term =
     nonterminal:
-      `try` ~> stmt() ~ someWhile(handler(), `with`) match {
-        case s ~ hs => TryHandle(s, hs)
+      `try` ~> stmt() ~ manyWhile(handler(), `with`) ~ finalizerClause(`suspend`, false) ~ finalizerClause(`resume`, true) ~ finalizerClause(`return`, true) ~ finalizerClause(`finally`, true) match {
+        case _ ~ _ ~ None ~ Some(_) ~ _ ~ _ =>
+          fail("Got `resume` clause but no `suspend` clause.")
+        case _ ~ _ ~ _ ~ Some(_) ~ _ ~ Some(_) =>
+          fail("Got both an `resume` and `finally` clause.")
+        case _ ~ _ ~ _ ~ _ ~ Some(_) ~ Some(_) =>
+          fail("got both an `return` and `finally` clause.")
+        case s ~ hs ~ susp ~ None ~ None ~ Some(prog) =>
+          TryHandle(s, hs, susp, Some(prog), Some(prog))
+        case s ~ hs ~ susp ~ res ~ retrn ~ fin => 
+          TryHandle(s, hs, susp, res, retrn)
       }
 
   def regionExpr(): Term =
@@ -698,6 +707,25 @@ class RecursiveDescent(positions: Positions, tokens: Seq[Token], source: Source)
           Handler(capability, impl)
       }
 
+  def finalizerClause(clause: TokenKind, vparam: Boolean): Option[FinalizerClause] =
+    nonterminal:
+      backtrack { consume(clause) }
+      .map { _ =>
+        braces {
+          backtrack { lambdaParams() <~ `=>` } ~ stmts() match {
+            // TODO better erros
+            case Some(Nil, vps, Nil) ~ body =>
+              if (!vps.isEmpty != vparam) fail(s"$clause value parameter mismatch")
+              else FinalizerClause(vps.headOption, body)
+            case Some(_, _, _) ~ _ =>
+              fail(s"$clause only expects value parameters")
+            case None ~ body =>
+              if (vparam) fail(s"$clause expects one value parameter but none were found")
+              else FinalizerClause(None, body)
+          }
+        }
+      }
+
   // This nonterminal uses limited backtracking: It parses the interface type multiple times.
   def implementation(): Implementation =
     nonterminal:

effekt/shared/src/main/scala/effekt/Typer.scala

@@ -210,7 +210,14 @@ object Typer extends Phase[NameResolved, Typechecked] {
           checkStmt(body, expected)
         }
 
-      case tree @ source.TryHandle(prog, handlers) =>
+      case tree @ source.TryHandle(prog, handlers, suspend, resume, retrn) =>
+        /*
+        try { _: A }
+        with Eff { (x: B, resume: C => D) => _: D }
+        suspend { _: E }
+        resume { (x: E) => _: Unit }
+        return { (x: A) => _: D }
+        */
 
         // (1) extract all handled effects and capabilities
         val providedCapabilities: List[symbols.BlockParam] = handlers map Context.withFocus { h =>
@@ -226,13 +233,57 @@ object Typer extends Phase[NameResolved, Typechecked] {
 
         // All used captures flow into the continuation capture, except the ones handled by this handler.
         val continuationCaptHandled = Context.without(continuationCapt, providedCapabilities.map(_.capture))
+
+        val Result(res, _) = Context.bindingCapabilities(tree, providedCapabilities) {
+          flowingInto(continuationCaptHandled) {
+            checkStmt(prog, expected)
+          }
+        }
+
+        val Result(suspendType, suspendEffs) = suspend.map {
+          case source.FinalizerClause(None, body) =>
+            checkStmt(body, None)
+          case source.FinalizerClause(Some(_), _) =>
+            INTERNAL_ERROR("Parser should ensure that the suspend clause has no value parameter")
+        }.getOrElse { Result(TUnit, Pure) }
+
+        val Result(resumeType, resumeEffs) = resume.map {
+          case source.FinalizerClause(Some(vp), body) =>
+            // check potentially annotated parameter type matches type of suspend clause
+            vp.symbol.tpe.foreach { matchExpected(_, suspendType) }
+            Context.bind(vp.symbol, suspendType)
+            // ensure that the body returns a result of type Unit
+            checkStmt(body, Some(TUnit))
+          case source.FinalizerClause(None, _) =>
+            INTERNAL_ERROR("Parser should ensure that the resume clause has a value parameter")
+        }.getOrElse { Result(TUnit, Pure) }
+
+        val Result(ret, retEffs) = retrn.map {
+          case source.FinalizerClause(Some(vp), body) =>
+            // check potentially annotated parameter type matches type of try body
+            vp.symbol.tpe.foreach { matchExpected(_, res) }
+            Context.bind(vp.symbol, res)
+            checkStmt(body, expected)
+          case source.FinalizerClause(None, _) =>
+            INTERNAL_ERROR("Parser should ensure that the return clause has a value parameter")
+        }.getOrElse {
+          // (2) Check the handled program
+          val Result(ret, effs) = Context.bindingCapabilities(tree, providedCapabilities) {
+            flowingInto(continuationCaptHandled) {
+              checkStmt(prog, expected)
+            }
+          }
+          Result(ret, Pure)
+        }
+
+        val finalizerEffs = suspendEffs ++ resumeEffs ++ retEffs
 
         // (2) Check the handled program
-        val Result(ret, effs) = Context.bindingCapabilities(tree, providedCapabilities) {
+         val Result(_, effs) = Context.bindingCapabilities(tree, providedCapabilities) {
           flowingInto(continuationCaptHandled) {
             checkStmt(prog, expected)
           }
-        }
+        } 
 
         // (3) Check the handlers
         // Also all capabilities used by the handler flow into the capture of the continuation

effekt/shared/src/main/scala/effekt/core/Transformer.scala

@@ -425,9 +425,13 @@ object Transformer extends Phase[Typechecked, CoreTransformed] {
       val compiledMatch = PatternMatchingCompiler.compile(clauses ++ defaultClause)
       Context.bind(compiledMatch)
 
-    case source.TryHandle(prog, handlers) =>
+    case source.TryHandle(prog, handlers, suspend, resume, retrn) =>
 
       val transformedProg = transform(prog)
+      // TODO
+      val transformedSuspend = suspend map { transform }
+      val transformedResume = resume map { transform }
+      val transformedReturn = retrn map { transform }
 
       val answerType = transformedProg.tpe
 
@@ -445,7 +449,7 @@ object Transformer extends Phase[Typechecked, CoreTransformed] {
       }
 
       val body: BlockLit = BlockLit(Nil, List(promptCapt), Nil, List(promptParam),
-        Scope(transformedHandlers, transform(prog)))
+        Scope(transformedHandlers, transformedProg))
 
       Context.bind(Reset(body))
 
@@ -641,6 +645,11 @@ object Transformer extends Phase[Typechecked, CoreTransformed] {
     })
   }
 
+  def transform(clause: source.FinalizerClause)(using Context): FinalizerClause = {
+    val source.FinalizerClause(vp, prog) = clause
+    FinalizerClause(vp map transform, transform(prog))
+  }
+
   def preprocess(sc: ValueVar, clause: source.MatchClause)(using Context): Clause =
     preprocess(List((sc, clause.pattern)), clause.guards, transform(clause.body))
 

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

@@ -497,6 +497,8 @@ case class Operation(name: Id, tparams: List[Id], cparams: List[Id], vparams: Li
   val capt = body.capt -- cparams.toSet
 }
 
+case class FinalizerClause(vp: Option[ValueParam], body: Stmt) extends Tree
+
 
 object Tree {
 

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

@@ -55,11 +55,15 @@ object AnnotateCaptures extends Phase[Typechecked, Typechecked], Query[Unit, Cap
       val cap = Context.annotation(Annotations.CapabilityReceiver, t)
       combineAll(vargs.map(query)) ++ combineAll(bargs.map(query)) ++ CaptureSet(cap.capture)
 
-    case t @ source.TryHandle(prog, handlers) =>
+    case t @ source.TryHandle(prog, handlers, suspend, resume, retrn) =>
       val progCapture = query(prog)
+      val suspCapture = suspend map { query } getOrElse CaptureSet()
+      val resCapture = resume map { query } getOrElse CaptureSet()
+      val retCapture = retrn map { query } getOrElse CaptureSet()
+
       val boundCapture = boundCapabilities(t)
       val usedCapture = combineAll(handlers.map(query))
-      (progCapture -- boundCapture) ++ usedCapture
+      (progCapture -- boundCapture) ++ usedCapture ++ suspCapture ++ resCapture ++ retCapture
 
     case t @ source.Region(id, body) =>
       query(body) -- captureOf(id.symbol.asBlockSymbol)

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

@@ -91,8 +91,11 @@ object ExplicitCapabilities extends Phase[Typechecked, Typechecked], Rewrite {
 
       Call(receiver, typeArgs, valueArgs, blockArgs ++ capabilityArgs)
 
-    case h @ TryHandle(prog, handlers) =>
+    case h @ TryHandle(prog, handlers, suspend, resume, retrn) =>
       val body = rewrite(prog)
+      val susp = suspend map { rewrite }
+      val res = resume map { rewrite }
+      val ret = retrn map { rewrite }
 
       val capabilities = Context.annotation(Annotations.BoundCapabilities, h)
 
@@ -107,7 +110,7 @@ object ExplicitCapabilities extends Phase[Typechecked, Typechecked], Rewrite {
         }
       }
 
-      TryHandle(body, hs)
+      TryHandle(body, hs, susp, res, ret)
 
     case n @ source.New(impl @ Implementation(interface, clauses)) => {
       val cs = clauses map {
@@ -129,6 +132,11 @@ object ExplicitCapabilities extends Phase[Typechecked, Typechecked], Rewrite {
       source.BlockLiteral(tps, vps, bps ++ capParams, rewrite(body))
   }
 
+  def rewrite(c: FinalizerClause)(using Context): FinalizerClause = {
+    val FinalizerClause(vp, body) = c
+    FinalizerClause(vp, rewrite(body))
+  }
+
   override def rewrite(body: ExternBody)(using context.Context): ExternBody = 
     body match {
       case b @ source.ExternBody.StringExternBody(ff, body) =>

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

@@ -393,7 +393,8 @@ enum Term extends Tree {
    *
    * Each with-clause is modeled as an instance of type [[Handler]].
    */
-  case TryHandle(prog: Stmt, handlers: List[Handler])
+  case TryHandle(prog: Stmt, handlers: List[Handler], suspend: Option[FinalizerClause], resume: Option[FinalizerClause], retrn: Option[FinalizerClause])
+
   case Region(id: IdDef, body: Stmt) extends Term, Definition
 
   /**
@@ -461,6 +462,8 @@ case class Handler(capability: Option[BlockParam] = None, impl: Implementation)
 // currently the annotation is rejected by [[Typer]] -- after that phase, `ret` should always be `None`
 case class OpClause(id: IdRef,  tparams: List[Id], vparams: List[ValueParam], bparams: List[BlockParam], ret: Option[Effectful], body: Stmt, resume: IdDef) extends Reference
 
+case class FinalizerClause(vparam: Option[ValueParam], body: Stmt) extends Tree
+
 // Pattern Matching
 // ----------------
 
@@ -787,6 +790,7 @@ object Tree {
     def query(h: Handler)(using Context, Ctx): Res = structuralQuery(h)
     def query(h: Implementation)(using Context, Ctx): Res = structuralQuery(h)
     def query(h: OpClause)(using Context, Ctx): Res = structuralQuery(h)
+    def query(c: FinalizerClause)(using Context, Ctx): Res = structuralQuery(c)
     def query(c: MatchClause)(using Context, Ctx): Res = structuralQuery(c)
     def query(c: MatchGuard)(using Context, Ctx): Res = structuralQuery(c)
     def query(b: ExternBody)(using Context, Ctx): Res = structuralQuery(b)

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

@@ -106,8 +106,12 @@ object BoxUnboxInference extends Phase[NameResolved, NameResolved] {
         Call(IdTarget(id).inheritPosition(id), targs, rewriteAsExpr(receiver) :: vargsTransformed, bargsTransformed)
       }
 
-    case TryHandle(prog, handlers) =>
-      TryHandle(rewrite(prog), handlers.map(rewrite))
+    case TryHandle(prog, handlers, suspend, resume, retrn) =>
+      val rewrittenSusp = suspend.map { rewrite }
+      val rewrittenRes = resume.map { rewrite }
+      val rewrittenRet = retrn.map { rewrite }
+
+      TryHandle(rewrite(prog), handlers.map(rewrite), rewrittenSusp, rewrittenRes, rewrittenRet)
 
     case Region(name, body) =>
       Region(name, rewrite(body))
@@ -204,6 +208,11 @@ object BoxUnboxInference extends Phase[NameResolved, NameResolved] {
       OpClause(id, tparams, vparams, bparams, ret, rewrite(body), resume)
   }
 
+  def rewrite(c: FinalizerClause)(using Context): FinalizerClause = visit(c) {
+    case FinalizerClause(vp, body) =>
+      FinalizerClause(vp, rewrite(body))
+  }
+
   def rewrite(c: MatchClause)(using Context): MatchClause = visit(c) {
     case MatchClause(pattern, guards, body) =>
       MatchClause(pattern, guards.map(rewrite), rewrite(body))

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

@@ -125,7 +125,7 @@ object Wellformedness extends Phase[Typechecked, Typechecked], Visit[WFContext]
     /**
      * For handlers we check that the return type does not mention any bound capabilities
      */
-    case tree @ source.TryHandle(prog, handlers) =>
+    case tree @ source.TryHandle(prog, handlers, suspend, resume, retrn) =>
       val bound = Context.annotation(Annotations.BoundCapabilities, tree).map(_.capture).toSet
       val usedEffects = Context.annotation(Annotations.InferredEffect, tree)
       val tpe = Context.inferredTypeOf(prog)
@@ -136,6 +136,9 @@ object Wellformedness extends Phase[Typechecked, Typechecked], Visit[WFContext]
       binding(captures = bound) { query(prog) }
 
       handlers foreach { query }
+      suspend foreach { query }
+      resume foreach { query }
+      retrn foreach { query }
 
       // Now check the return type ...
       wellformed(tpe, prog, " inferred as return type of the handled statement",