Add try..finally

Why:
    JavaScript code cleans up with finally blocks: after an await, around
    break and continue, and in generators, where cancellation is only seen
    by finally. ReScript had no way to express them.

`try` takes `finally { ... }` after its body or after its catch. `finally`
stays an identifier: after a catch it only starts a finally block when a
brace follows. The block is a statement and must not break or continue out
of it. Supersedes #7903.

AST modified (Pexp_try):
Example:
    let f = g =>
      try g() catch {
      | Not_found => 0
      } finally {
        Console.log("done")
      }
Before (diagnostic): `finally` was not valid after a catch.
After (parse):
    expression
      Pexp_try
      expression
        Pexp_apply
        expression
          Pexp_ident "g"
        …
      [
        <case>
          pattern
            Ppat_construct "Not_found"
          expression
            Pexp_constant PConst_int (0,None)
      ]
      Some
        expression
          Pexp_apply
          expression
            Pexp_ident "Console.log"
          …

Lambda added (Ltryfinally):
After (lambda):
    (try
      (try (apply g/1002 unit) with raw_exn/1062
        …)
     finally (seq (js_call[console.log] "done") unit))

JS added (try..catch..finally):
After (js):
    function f(g) {
      try {
        return g();
      } catch (raw_exn) {
        let exn = Primitive_exceptions.internalToException(raw_exn);
        if (exn.RE_EXN_ID === "Not_found") {
          return 0;
        }
        throw exn;
      } finally {
        console.log("done");
      }
    }

Diagnostic added (break out of finally):
Example:
    while true {
      try {
        ()
      } finally {
        break
      }
    }
After (diagnostic):
    `break` cannot leave a `finally` block. Only a loop inside the block can be broken out of.

Review: Why a separate Ltryfinally instead of an optional finally on
Ltrywith? Ltrywith keeps its meaning in every pass, a try without catch
needs no exception ident, and try..catch..finally is an Ltryfinally around
an Ltrywith that the JS backend prints as one statement.
Review: Why is the catch handler no longer in tail position? With a
finally, a self tail call in the handler would become a loop `continue`
that runs the finally before the recursive call instead of after it.
Review: Why reject break and continue in finally? JavaScript allows them,
but they silently drop a pending exception or return value.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Fc7LEuyEfynjaKCVEBPmTF
Signed-off-by: Christoph Knittel <ck@cca.io>

Author: cknitt

analysis/reanalyze/src/arnold.ml

@@ -996,11 +996,13 @@ module Compile = struct
           expression ~ctx e)
       |> Command.unordered_sequence
     | Texp_assert _ -> Command.nothing
-    | Texp_try (e, cases) ->
+    | Texp_try (e, cases, finally) -> (
       let c_e = e |> expression ~ctx in
       let c_cases = cases |> List.map (case ~ctx) |> Command.nondet in
       let open Command in
-      c_e +++ c_cases
+      match finally with
+      | None -> c_e +++ c_cases
+      | Some finally -> c_e +++ c_cases +++ expression ~ctx finally)
     | Texp_variant (_label, e_opt) -> e_opt |> expression_opt ~ctx
     | Texp_while _ ->
       not_implemented "Texp_while";

analysis/reanalyze/src/exception.ml

@@ -394,18 +394,23 @@ let traverse_ast ~file ~values_builder ~checks_builder () =
             kind = Throws;
           }
           :: !current_events
-    | Texp_try (e, cases) ->
-      let exceptions =
-        cases
-        |> List.map (fun case -> case.Typedtree.c_lhs.pat_desc)
-        |> exceptions_of_patterns
-      in
-      let old_events = !current_events in
-      current_events := [];
-      e |> iter_expr self;
-      current_events :=
-        {Event.exceptions; loc; kind = Catches !current_events} :: old_events;
-      cases |> iter_cases self
+    | Texp_try (e, cases, finally) ->
+      (* Catches with no exceptions means a catch-all, so a try without catch
+         cases must not record one. *)
+      if cases <> [] then (
+        let exceptions =
+          cases
+          |> List.map (fun case -> case.Typedtree.c_lhs.pat_desc)
+          |> exceptions_of_patterns
+        in
+        let old_events = !current_events in
+        current_events := [];
+        e |> iter_expr self;
+        current_events :=
+          {Event.exceptions; loc; kind = Catches !current_events} :: old_events)
+      else e |> iter_expr self;
+      cases |> iter_cases self;
+      finally |> iter_expr_opt self
     | _ -> super.expr self expr |> ignore);
     (if is_does_no_throw then
        let nested_events = !current_events in

analysis/reanalyze/src/side_effects.ml

@@ -49,8 +49,10 @@ let rec expr_no_side_effects (expr : Typedtree.expression) =
     partial = Total && e |> expr_no_side_effects
     && cases |> List.for_all case_no_side_effects
   | Texp_letmodule _ -> false
-  | Texp_try (e, cases) ->
-    e |> expr_no_side_effects && cases |> List.for_all case_no_side_effects
+  | Texp_try (e, cases, finally) ->
+    e |> expr_no_side_effects
+    && cases |> List.for_all case_no_side_effects
+    && finally |> expr_opt_no_side_effects
   | Texp_tuple el -> el |> List.for_all expr_no_side_effects
   | Texp_variant (_lbl, eo) -> eo |> expr_opt_no_side_effects
   | Texp_field (e, _lid, _ld) -> e |> expr_no_side_effects

changes/try-finally.feature.md

@@ -0,0 +1 @@
+- Add `try ... finally { ... }` and `try ... catch { ... } finally { ... }`, compiled to JavaScript `finally` blocks.

compiler/core/js_dump.ml

@@ -1564,10 +1564,10 @@ and statement_desc top cxt f (s : J.statement_desc) : cxt =
         match fin with
         | None -> cxt
         | Some b ->
-          P.group f 1 (fun _ ->
-              P.string f L.finally;
-              P.space f;
-              brace_block cxt f b))
+          P.space f;
+          P.string f L.finally;
+          P.space f;
+          brace_block cxt f b)
 
 and function_body ?directive (cxt : cxt) f ~return_unit (b : J.block) : unit =
   (match directive with

compiler/core/lam_analysis.ml

@@ -121,6 +121,8 @@ let rec no_side_effects (lam : Lambda.t) : bool =
   *)
   | Ltrywith (body, _exn, handler) ->
     no_side_effects body && no_side_effects handler
+  | Ltryfinally (body, finally) ->
+    no_side_effects body && no_side_effects finally
   | Lifthenelse (a, b, c) ->
     no_side_effects a && no_side_effects b && no_side_effects c
   | Lsequence (a, b) -> no_side_effects a && no_side_effects b
@@ -210,7 +212,7 @@ let size_upto ~limit (lam : Lambda.t) =
       add 1;
       List.iter size ls
     | Lstaticcatch _ -> add too_big
-    | Ltrywith _ -> add too_big
+    | Ltrywith _ | Ltryfinally _ -> add too_big
     | Lifthenelse (l1, l2, l3) ->
       add 1;
       size l1;

compiler/core/lam_arity_analysis.ml

@@ -120,6 +120,7 @@ let rec get_arity (meta : Lam_stats.t) (lam : Lambda.t) : Lam_arity.t =
     | Some v -> all_lambdas meta (v :: Ext_list.map sw snd))
   | Lstaticcatch (_, _, handler) -> get_arity meta handler
   | Ltrywith (l1, _, l2) -> all_lambdas meta [l1; l2]
+  | Ltryfinally (body, _) -> get_arity meta body
   | Lifthenelse (_, l2, l3) -> all_lambdas meta [l2; l3]
   | Lsequence (_, l2) -> get_arity meta l2
   | Lstaticraise _ (* since it will not be in tail position *) -> Lam_arity.na

compiler/core/lam_bounded_vars.ml

@@ -154,6 +154,10 @@ let rewrite (map : _ Hash_ident.t) (lam : Lambda.t) : Lambda.t =
       let v = rebind v in
       let l2 = aux l2 in
       Lambda.try_ l1 v l2
+    | Ltryfinally (l1, l2) ->
+      let l1 = aux l1 in
+      let l2 = aux l2 in
+      Lambda.try_finally l1 l2
     | Lifthenelse (l1, l2, l3) ->
       let l1 = aux l1 in
       let l2 = aux l2 in

compiler/core/lam_check.ml

@@ -92,7 +92,7 @@ let check ~file ~pass lam =
     | Lstaticcatch (e1, (j, _vars), e2) ->
       check_staticfails e1 (Set_int.add j cxt);
       check_staticfails e2 cxt
-    | Ltrywith (e1, _exn, e2) ->
+    | Ltrywith (e1, _, e2) | Ltryfinally (e1, e2) ->
       check_staticfails e1 cxt;
       check_staticfails e2 cxt
     | Lifthenelse (e1, e2, e3) -> check_list [e1; e2; e3] cxt
@@ -142,6 +142,9 @@ let check ~file ~pass lam =
       iter e1;
       def exn;
       iter e2
+    | Ltryfinally (e1, e2) ->
+      iter e1;
+      iter e2
     | Lifthenelse (e1, e2, e3) ->
       iter e1;
       iter e2;

compiler/core/lam_closure.ml

@@ -117,7 +117,7 @@ let free_variables (export_idents : Set_ident.t) (params : stats Map_ident.t)
       iter sink_pos e1;
       local_add_list vars;
       iter sink_pos e2
-    | Ltrywith (e1, _exn, e2) ->
+    | Ltrywith (e1, _, e2) | Ltryfinally (e1, e2) ->
       iter top e1;
       iter sink_pos e2
     | Lifthenelse (e1, e2, e3) ->