frontend: eliminate `hs` as an error handling primitive. by mikesamuel · Pull Request #474 · temperlang/temper

mikesamuel · 2026-08-12T21:04:28Z

This commit is a work in progress.

Goal

Simplify frontend representation by eliminating hs (handler scope) which were previously inserted to make it clear which instructions could fail so that control-flow sensitive analyses were precise.

Unfotunately, many instructions were inserted pre-typing leading to imprecise assumptions that many non-failing operations could fail, and requiring expensive CleanupTemporaries passes to reduce the IR to something small enough to debug.

Now, we can eliminate it because failure is based on whether a callee has a declared Result return type.

Changes done

Passes that unify and manipulate control flow were largely rewritten:

MakeResultsExplicit now works based on the nesting structure of control flow block elements to capture function body and module results in return__123 variables.
Weaver now uses the same block structure instead of working on a CFG it builds using the block structure.

Both of these have been tested thoroughly.

Our MaximalPaths representation of a basic block control flow graph has been adapted to work with bubbly branches since we can no longer rely on fail#123 expressions as conditions for transitions to error handling blocks, but it needs more debugging, and passes that rely on it are probably buggy.

The staging of some of these μpasses has changed:

MakeResultsExplicit now runs first. It allocates return variables early.
Weaver now calls MagicSecurityDust.sprinkle internally, and has been rewritten and is probably quite a bit faster and simpler. It allocates far fewer temporaries.

Typer can no longer rely on hs(...) calls at places where a failing result can reach a call as an argument or be assigned to a variable. It used to serve as a typing helper by converting Foo | Bubble to Foo. Now the Typer explicitly excludes bubbles coming out of calls, and when propagating type information from a typed, bubbly return__123 variable to a temporary, for example.

Still to do

Most of the staging tests pass, but some that interpret or...elses or that deal with RTTI checks fail.
Need to debug these.

MaximalPaths is probably buggy. Need more testing.

Some static error checks like "function body bubbles but does not declare throws" might depend on information that now needs to be found by analysis of bubbly calles and CF block structure.

Also

I used the AssertModuleAtStage regenerate test outputs trick. I tweaked some of it to preserve comments inside test golden files.

This commit is a work in progress. Goal ==== Simplify frontend representation by eliminating `hs` (handler scope) which were previously inserted to make it clear which instructions could fail so that control-flow sensitive analyses were precise. Unfotunately, many instructions were inserted pre-typing leading to imprecise assumptions that many non-failing operations could fail, and requiring expensive *CleanupTemporaries* passes to reduce the IR to something small enough to debug. Now, we can eliminate it because failure is based on whether a callee has a declared *Result* return type. Changes done ============ Passes that unify and manipulate control flow were largely rewritten: - *MakeResultsExplicit* now works based on the nesting structure of control flow block elements to capture function body and module results in `return__123` variables. - *Weaver* now uses the same block structure instead of working on a CFG it builds using the block structure. Both of these have been tested thoroughly. Our *MaximalPaths* representation of a basic block control flow graph has been adapted to work with *bubbly* branches since we can no longer rely on `fail#123` expressions as conditions for transitions to error handling blocks, but it needs more debugging, and passes that rely on it are probably buggy. The staging of some of these μpasses has changed: 1. *MakeResultsExplicit* now runs first. It allocates return variables early. 2. *Weaver* now calls *MagicSecurityDust.sprinkle* internally, and has been rewritten and is probably quite a bit faster and simpler. It allocates far fewer temporaries. *Typer* can no longer rely on `hs(...)` calls at places where a failing result can reach a call as an argument or be assigned to a variable. It used to serve as a typing helper by converting `Foo | Bubble` to `Foo`. Now the *Typer* explicitly excludes bubbles coming out of calls, and when propagating type information from a typed, bubbly `return__123` variable to a temporary, for example. Still to do =========== Most of the staging tests pass, but some that interpret `or...else`s or that deal with RTTI checks fail. Need to debug these. *MaximalPaths* is probably buggy. Need more testing. Some static error checks like "function body bubbles but does not declare `throws`" might depend on information that now needs to be found by analysis of bubbly calles and CF block structure. Also ==== I used the *AssertModuleAtStage* regenerate test outputs trick. I tweaked some of it to preserve comments inside test golden files. Signed-off-by: Mike Samuel <mikesamuel@gmail.com>

mikesamuel · 2026-08-12T21:05:18Z

- *
- * See also [lang.temper.frontend.MagicSecurityDust].
- */
-private object HandlerScopeFn : SpecialFunction, NamedBuiltinFun {


I'm not out of scope; it's the scopes that are out.

mikesamuel · 2026-08-12T21:05:46Z

-        .also {
-            helpSnippet(it, "Boolean inverse", "builtin/!")
-        }
+    val notFn: CallableValue = NotFn


control flow stuff becomes easier if we can refer to ! from fundamentals.

mikesamuel · 2026-08-12T21:06:48Z

-                { Rn(name) },
-            )
+            Block {
+                If(


This commit adds machinery to TreeFarm to allow building control-flow block structures directly.

That's really helpful for testing, but one nice side effect is you can just use it in frontend code too.

mikesamuel · 2026-08-12T21:07:47Z

        internal.insert(internal.size) {
            V(vInitSymbol)
            // TODO Could implement a coalesce macro with this content.
-            Call {


This was kind of gnarly: building a call to the if macro. Now it just uses the tree farm.

mikesamuel · 2026-08-12T21:09:39Z

        for (typeFormal in typeFormals) {
            if (typeFormal.needsAdapting) {
-                val newName = p.nameMaker.unusedSourceNameWithPrefix(prefix = "adapterFor", typeFormal.name)
+                val newName = p.resolvedNameMaker.unusedSourceNameWithPrefix(prefix = "adapterFor", typeFormal.name)


nameMaker is now available from Planting, so I just renamed nameMaker to avoid collisions.

mikesamuel · 2026-08-12T21:46:53Z

+    pos: Position,
+    treeInnards: List<TreeInnard>,
+    flowMaker: FlowMaker?,
+): Pair<List<Tree>, FlowMaker?> {


Reusing the same infer-position from minimal position info tricks for control flow boundaries.

mikesamuel · 2026-08-12T21:48:16Z

+                    flowStack.last().add(BlockChildReference(children.lastIndex, innardPos))
+                }
+                is FlowMark -> when (innard.flowMarkKind) {
+                    FlowMarkKind.StartBlock -> flowStack.add(BlockInProgress(innardPos))


The idea is similar to AST lifting.

We build a list of marks: start-block a-tree end-block

Then we walk it matching starts and ends, and it all works out because the only way to edit the list is via the capitalized methods that pair marks up.

mikesamuel · 2026-08-12T21:49:14Z

 }

 private class UnpositionedBlockTemplate(
-    val flowMaker: FlowMaker = linearFlowMaker,


TODO: maybe get rid of this flowMaker. I think I might've already whacked them all, possibly outside UnsetTerminalExpressionsTest.

mikesamuel · 2026-08-12T21:49:54Z

This one still needs debugging.

mikesamuel · 2026-08-12T21:51:33Z

+        val oldContent = (oldValue as? JsonString)?.s
+        var adjustedString: String? = null
+
+        // If we have any `##` lines, then try to reinsert them in sensible places by diffing.


The above part of this file was extracted with some refactoring from AssertModuleAtStage but all the content adjustment tricks are new.

Tests for it in next added file.

mikesamuel

GH is demanding:

You need to leave a comment indicating the requested changes.

But I am me.

I also rewrote some test harness code to use the new way of specifying control flow, and MaximalPaths does a better job eliminating useless transitions. Signed-off-by: Mike Samuel <mikesamuel@gmail.com>

mikesamuel · 2026-08-14T19:08:02Z

mikesamuel · 2026-08-14T19:09:20Z

-                Stmt("foo"),
-                Stmt("bar"),
-            )
+            Do {


Converted all of these to use the new treeFarm equivalents.

mikesamuel · 2026-08-14T19:10:13Z

@@ -23,9 +25,8 @@ class MaximalPathTest {
                |
                |Path#0
            """.trimMargin(),
-            expectedTerminalExpressions = "Sometimes",


No longer testing the terminal expressions stuff since it's now based on the CF block structure.

mikesamuel · 2026-08-14T19:10:54Z

@@ -330,40 +297,36 @@ class MaximalPathTest {
        assertMaximalPaths(
            want = """
                |Entry Path#0
-                |Exits Path#5
+                |Exits Path#3


Checked these loop test changes by dumping to mermaid.

mikesamuel · 2026-08-14T19:11:56Z

-            |-> Path#1
-            |
-            |Path#1
+            |- ref#1: `body()`


Quite a few changes like this since I fixed some bugs in eliminateEmptyTransitions.