@elaraai/east 1.0.97 → 1.0.98

package/dist/src/compile/control.js

@@ -1,32 +1,66 @@
-import { compile_internal } from "./ir.js";
-import { BreakException, ContinueException, lazyReadErrorAt, lockForIteration, ReturnException, unlockForIteration } from "./runtime.js";
+import { compile_ir } from "./ir.js";
+import { asStatement, ControlSignal, escapesOf, loopReads, NO_ESCAPES } from "./flow.js";
+import { lazyReadErrorAt, lockForIteration, unlockForIteration } from "./runtime.js";
 import { variant } from "../containers/variant.js";
 import { EastError } from "../error.js";
 import { loopWalk } from "../serialization/beast2/v5/lazy.js";
 import { expandTypeValue } from "../type_of_type.js";
-/** Compiles the errors, try/catch, branches, loops, and early exits. */
+/** A child, compiled to run as a statement: a signal a node under it threw is given back. */
+function statement(child, child_ctx, fresh_ctx, platform, asyncPlatformFns, platformDef, compilingNodes) {
+    return asStatement(child, compile_ir(child, child_ctx, platform, asyncPlatformFns, platformDef, fresh_ctx, compilingNodes));
+}
+/**
+ * Compiles the errors, try/catch, branches, loops, and early exits.
+ *
+ * Each runs its children as statements, and gives back a `return`, `continue`
+ * or `break` one of them gives — a loop acting on those that name it — so
+ * control flow is never thrown here (`flow.ts`).
+ */
 export function compile_control(ir, ctx, platform, asyncPlatformFns, platformDef, compilingNodes, source_map) {
     if (ir.type === "Error") {
-        const message_compiled = compile_internal(ir.value.message, ctx, platform, asyncPlatformFns, platformDef, false, compilingNodes);
-        if (ir.value.isAsync) {
-            const err_location = source_map?.resolve(ir.value.loc_id) ?? [];
+        const message_compiled = statement(ir.value.message, ctx, false, platform, asyncPlatformFns, platformDef, compilingNodes);
+        const err_location = source_map?.resolve(ir.value.loc_id) ?? [];
+        if (escapesOf(ir.value.message) !== NO_ESCAPES) {
+            // A message a control statement leaves raises nothing: the signal leaves the error too.
+            if (ir.value.isAsync) {
+                return async (ctx) => {
+                    const message = await message_compiled(ctx);
+                    if (message instanceof ControlSignal)
+                        return message;
+                    throw new EastError(message, { location: err_location });
+                };
+            }
+            else {
+                return (ctx) => {
+                    const message = message_compiled(ctx);
+                    if (message instanceof ControlSignal)
+                        return message;
+                    throw new EastError(message, { location: err_location });
+                };
+            }
+        }
+        else if (ir.value.isAsync) {
             return async (ctx) => { throw new EastError(await message_compiled(ctx), { location: err_location }); };
         }
         else {
-            const err_location = source_map?.resolve(ir.value.loc_id) ?? [];
             return (ctx) => { throw new EastError(message_compiled(ctx), { location: err_location }); };
         }
     }
     else if (ir.type === "TryCatch") {
-        const try_body = compile_internal(ir.value.try_body, Object.create(ctx), platform, asyncPlatformFns, platformDef, true, compilingNodes);
+        const try_body = statement(ir.value.try_body, Object.create(ctx), true, platform, asyncPlatformFns, platformDef, compilingNodes);
         const new_ctx = Object.create(ctx);
         const message_name = ir.value.message.value.name;
         const stack_name = ir.value.stack.value.name;
         new_ctx[message_name] = ir.value.message.value.type;
         new_ctx[stack_name] = ir.value.stack.value.type;
-        const catch_body = compile_internal(ir.value.catch_body, new_ctx, platform, asyncPlatformFns, platformDef, true, compilingNodes);
+        const catch_body = statement(ir.value.catch_body, new_ctx, true, platform, asyncPlatformFns, platformDef, compilingNodes);
         // Don't include finally unless necessary (Value nodes are effect free)
-        const finally_body = ir.value.finally_body.type === "Value" ? undefined : compile_internal(ir.value.finally_body, Object.create(ctx), platform, asyncPlatformFns, platformDef, true, compilingNodes);
+        const finally_body = ir.value.finally_body.type === "Value" ? undefined : statement(ir.value.finally_body, Object.create(ctx), true, platform, asyncPlatformFns, platformDef, compilingNodes);
+        // A signal the finally gives leaves in place of what the try or the catch
+        // gave, or threw, as a control statement thrown from the finally did.
+        const finally_leaves = finally_body !== undefined && escapesOf(ir.value.finally_body) !== NO_ESCAPES;
+        // The try and the catch give back a signal as their value, so East's catch
+        // never sees one: it catches East's errors alone.
         if (ir.value.isAsync) {
             if (finally_body === undefined) {
                 return async (ctx) => {
@@ -63,7 +97,9 @@ export function compile_control(ir, ctx, platform, asyncPlatformFns, platformDef
                         }
                     }
                     finally {
-                        await finally_body(Object.create(ctx));
+                        const left = await finally_body(Object.create(ctx));
+                        if (finally_leaves && left instanceof ControlSignal)
+                            return left;
                     }
                 };
             }
@@ -104,7 +140,9 @@ export function compile_control(ir, ctx, platform, asyncPlatformFns, platformDef
                         }
                     }
                     finally {
-                        finally_body(Object.create(ctx));
+                        const left = finally_body(Object.create(ctx));
+                        if (finally_leaves && left instanceof ControlSignal)
+                            return left;
                     }
                 };
             }
@@ -113,17 +151,50 @@ export function compile_control(ir, ctx, platform, asyncPlatformFns, platformDef
     else if (ir.type === "IfElse") {
         const ifs = [];
         let asyncPredicate = false;
+        let predicateLeaves = false;
         for (const { predicate, body } of ir.value.ifs) {
             if (predicate.value.isAsync) {
                 asyncPredicate = true;
             }
+            if (escapesOf(predicate) !== NO_ESCAPES) {
+                predicateLeaves = true;
+            }
             ifs.push({
-                predicate: compile_internal(predicate, ctx, platform, asyncPlatformFns, platformDef, false, compilingNodes),
-                body: compile_internal(body, Object.create(ctx), platform, asyncPlatformFns, platformDef, true, compilingNodes),
+                predicate: statement(predicate, ctx, false, platform, asyncPlatformFns, platformDef, compilingNodes),
+                body: statement(body, Object.create(ctx), true, platform, asyncPlatformFns, platformDef, compilingNodes),
             });
         }
-        const else_body = compile_internal(ir.value.else_body, Object.create(ctx), platform, asyncPlatformFns, platformDef, true, compilingNodes);
-        if (ir.value.isAsync) {
+        const else_body = statement(ir.value.else_body, Object.create(ctx), true, platform, asyncPlatformFns, platformDef, compilingNodes);
+        if (predicateLeaves) {
+            // A predicate a control statement leaves gives its signal in place of a branch's value.
+            if (ir.value.isAsync) {
+                return async (ctx) => {
+                    for (const { predicate, body } of ifs) {
+                        const p = await predicate(ctx);
+                        if (p instanceof ControlSignal)
+                            return p;
+                        if (p) {
+                            return await body(Object.create(ctx));
+                        }
+                    }
+                    return await else_body(Object.create(ctx));
+                };
+            }
+            else {
+                return (ctx) => {
+                    for (const { predicate, body } of ifs) {
+                        const p = predicate(ctx);
+                        if (p instanceof ControlSignal)
+                            return p;
+                        if (p) {
+                            return body(Object.create(ctx));
+                        }
+                    }
+                    return else_body(Object.create(ctx));
+                };
+            }
+        }
+        else if (ir.value.isAsync) {
             if (asyncPredicate) {
                 return async (ctx) => {
                     for (const { predicate, body } of ifs) {
@@ -157,7 +228,7 @@ export function compile_control(ir, ctx, platform, asyncPlatformFns, platformDef
         }
     }
     else if (ir.type === "Match") {
-        const compiled_variant = compile_internal(ir.value.variant, ctx, platform, asyncPlatformFns, platformDef, false, compilingNodes);
+        const compiled_variant = statement(ir.value.variant, ctx, false, platform, asyncPlatformFns, platformDef, compilingNodes);
         const compiled_cases = {};
         const data_names = {};
         for (const { case: k, variable, body } of ir.value.cases) {
@@ -165,9 +236,32 @@ export function compile_control(ir, ctx, platform, asyncPlatformFns, platformDef
             const data_name = variable.value.name;
             data_names[k] = data_name;
             ctx2[data_name] = variable.value.type;
-            compiled_cases[k] = compile_internal(body, ctx2, platform, asyncPlatformFns, platformDef, true, compilingNodes);
+            compiled_cases[k] = statement(body, ctx2, true, platform, asyncPlatformFns, platformDef, compilingNodes);
         }
-        if (ir.value.isAsync) {
+        if (escapesOf(ir.value.variant) !== NO_ESCAPES) {
+            // A variant a control statement leaves gives its signal in place of a case's value.
+            if (ir.value.isAsync) {
+                return async (ctx) => {
+                    const v = await compiled_variant(ctx);
+                    if (v instanceof ControlSignal)
+                        return v;
+                    const ctx2 = Object.create(ctx);
+                    ctx2[data_names[v.type]] = variant("value", v.value);
+                    return await compiled_cases[v.type](ctx2);
+                };
+            }
+            else {
+                return (ctx) => {
+                    const v = compiled_variant(ctx);
+                    if (v instanceof ControlSignal)
+                        return v;
+                    const ctx2 = Object.create(ctx);
+                    ctx2[data_names[v.type]] = variant("value", v.value);
+                    return compiled_cases[v.type](ctx2);
+                };
+            }
+        }
+        else if (ir.value.isAsync) {
             if (ir.value.variant.value.isAsync) {
                 return async (ctx) => {
                     const v = await compiled_variant(ctx);
@@ -195,88 +289,85 @@ export function compile_control(ir, ctx, platform, asyncPlatformFns, platformDef
         }
     }
     else if (ir.type === "While") {
-        const compiled_predicate = compile_internal(ir.value.predicate, ctx, platform, asyncPlatformFns, platformDef, false, compilingNodes);
+        const compiled_predicate = statement(ir.value.predicate, ctx, false, platform, asyncPlatformFns, platformDef, compilingNodes);
         const ctx2 = Object.create(ctx);
-        const compiled_body = compile_internal(ir.value.body, ctx2, platform, asyncPlatformFns, platformDef, true, compilingNodes);
+        const compiled_body = statement(ir.value.body, ctx2, true, platform, asyncPlatformFns, platformDef, compilingNodes);
         const label = ir.value.label.name;
+        // Whether the predicate can give a signal, which leaves the loop; and
+        // whether the body can give one but its own `continue`, which the loop
+        // must act on: its own `break` stops it, and any other leaves it.
+        const predicate_leaves = escapesOf(ir.value.predicate) !== NO_ESCAPES;
+        const reads = loopReads(ir.value.body, label);
         if (ir.value.isAsync) {
             return async (ctx) => {
-                while (await compiled_predicate(ctx)) {
-                    try {
-                        const ctx2 = Object.create(ctx);
-                        await compiled_body(ctx2);
-                    }
-                    catch (e) {
-                        if (e instanceof ContinueException && e.label === label) {
-                            continue;
-                        }
-                        else if (e instanceof BreakException && e.label === label) {
-                            break;
-                        }
-                        else {
-                            throw e;
-                        }
+                for (;;) {
+                    const p = await compiled_predicate(ctx);
+                    if (predicate_leaves && p instanceof ControlSignal)
+                        return p;
+                    if (!p)
+                        return null;
+                    const ctx2 = Object.create(ctx);
+                    const r = await compiled_body(ctx2);
+                    if (reads && r instanceof ControlSignal) {
+                        if (r.kind === "return" || r.label !== label)
+                            return r;
+                        if (r.kind === "break")
+                            return null;
                     }
                 }
-                return null;
             };
         }
         else {
             return (ctx) => {
-                while (compiled_predicate(ctx)) {
-                    try {
-                        const ctx2 = Object.create(ctx);
-                        compiled_body(ctx2);
-                    }
-                    catch (e) {
-                        if (e instanceof ContinueException && e.label === label) {
-                            continue;
-                        }
-                        else if (e instanceof BreakException && e.label === label) {
-                            break;
-                        }
-                        else {
-                            throw e;
-                        }
+                for (;;) {
+                    const p = compiled_predicate(ctx);
+                    if (predicate_leaves && p instanceof ControlSignal)
+                        return p;
+                    if (!p)
+                        return null;
+                    const ctx2 = Object.create(ctx);
+                    const r = compiled_body(ctx2);
+                    if (reads && r instanceof ControlSignal) {
+                        if (r.kind === "return" || r.label !== label)
+                            return r;
+                        if (r.kind === "break")
+                            return null;
                     }
                 }
-                return null;
             };
         }
     }
     else if (ir.type === "ForArray") {
         const value_type = expandTypeValue(ir.value.array.value.type).value;
-        const compiled_array = compile_internal(ir.value.array, ctx, platform, asyncPlatformFns, platformDef, false, compilingNodes);
+        const compiled_array = statement(ir.value.array, ctx, false, platform, asyncPlatformFns, platformDef, compilingNodes);
         const ctx2 = Object.create(ctx);
         const key_name = ir.value.key.value.name;
         const value_name = ir.value.value.value.name;
         ctx2[key_name] = variant("Integer", null);
         ctx2[value_name] = value_type;
-        const compiled_body = compile_internal(ir.value.body, ctx2, platform, asyncPlatformFns, platformDef, true, compilingNodes);
+        const compiled_body = statement(ir.value.body, ctx2, true, platform, asyncPlatformFns, platformDef, compilingNodes);
         const label = ir.value.label.name;
         const loc_id = ir.value.loc_id;
+        // As a While's: whether the array can give a signal, and whether the loop must act on what its body gives.
+        const array_leaves = escapesOf(ir.value.array) !== NO_ESCAPES;
+        const reads = loopReads(ir.value.body, label);
         if (ir.value.isAsync) {
             return async (ctx) => {
                 const array = await compiled_array(ctx);
+                if (array_leaves && array instanceof ControlSignal)
+                    return array;
                 lockForIteration(array);
                 try {
                     for (const [key, value] of array.entries()) {
                         const ctx2 = Object.create(ctx);
                         ctx2[key_name] = variant("value", BigInt(key));
                         ctx2[value_name] = variant("value", value);
-                        try {
-                            await compiled_body(ctx2);
-                        }
-                        catch (e) {
-                            if (e instanceof ContinueException && e.label === label) {
-                                continue;
-                            }
-                            else if (e instanceof BreakException && e.label === label) {
+                        const r = await compiled_body(ctx2);
+                        if (reads && r instanceof ControlSignal) {
+                            if (r.kind === "return" || r.label !== label)
+                                return r;
+                            if (r.kind === "break")
                                 break;
-                            }
-                            else {
-                                throw e;
-                            }
                         }
                     }
                     return null;
@@ -292,25 +383,20 @@ export function compile_control(ir, ctx, platform, asyncPlatformFns, platformDef
         else {
             return (ctx) => {
                 const array = compiled_array(ctx);
+                if (array_leaves && array instanceof ControlSignal)
+                    return array;
                 lockForIteration(array);
                 try {
                     for (const [key, value] of array.entries()) {
                         const ctx2 = Object.create(ctx);
                         ctx2[key_name] = variant("value", BigInt(key));
                         ctx2[value_name] = variant("value", value);
-                        try {
-                            compiled_body(ctx2);
-                        }
-                        catch (e) {
-                            if (e instanceof ContinueException && e.label === label) {
-                                continue;
-                            }
-                            else if (e instanceof BreakException && e.label === label) {
+                        const r = compiled_body(ctx2);
+                        if (reads && r instanceof ControlSignal) {
+                            if (r.kind === "return" || r.label !== label)
+                                return r;
+                            if (r.kind === "break")
                                 break;
-                            }
-                            else {
-                                throw e;
-                            }
                         }
                     }
                     return null;
@@ -326,34 +412,32 @@ export function compile_control(ir, ctx, platform, asyncPlatformFns, platformDef
     }
     else if (ir.type === "ForSet") {
         const key_type = expandTypeValue(ir.value.set.value.type).value;
-        const compiled_set = compile_internal(ir.value.set, ctx, platform, asyncPlatformFns, platformDef, false, compilingNodes);
+        const compiled_set = statement(ir.value.set, ctx, false, platform, asyncPlatformFns, platformDef, compilingNodes);
         const ctx2 = Object.create(ctx);
         const key_name = ir.value.key.value.name;
         ctx2[key_name] = key_type;
-        const compiled_body = compile_internal(ir.value.body, ctx2, platform, asyncPlatformFns, platformDef, true, compilingNodes);
+        const compiled_body = statement(ir.value.body, ctx2, true, platform, asyncPlatformFns, platformDef, compilingNodes);
         const label = ir.value.label.name;
         const loc_id = ir.value.loc_id;
+        // As a While's: whether the set can give a signal, and whether the loop must act on what its body gives.
+        const set_leaves = escapesOf(ir.value.set) !== NO_ESCAPES;
+        const reads = loopReads(ir.value.body, label);
         if (ir.value.isAsync) {
             return async (ctx) => {
                 const set = await compiled_set(ctx);
+                if (set_leaves && set instanceof ControlSignal)
+                    return set;
                 lockForIteration(set);
                 try {
                     for (const key of loopWalk(set)) {
                         const ctx2 = Object.create(ctx);
                         ctx2[key_name] = variant("value", key);
-                        try {
-                            await compiled_body(ctx2);
-                        }
-                        catch (e) {
-                            if (e instanceof ContinueException && e.label === label) {
-                                continue;
-                            }
-                            else if (e instanceof BreakException && e.label === label) {
+                        const r = await compiled_body(ctx2);
+                        if (reads && r instanceof ControlSignal) {
+                            if (r.kind === "return" || r.label !== label)
+                                return r;
+                            if (r.kind === "break")
                                 break;
-                            }
-                            else {
-                                throw e;
-                            }
                         }
                     }
                     return null;
@@ -369,24 +453,19 @@ export function compile_control(ir, ctx, platform, asyncPlatformFns, platformDef
         else {
             return (ctx) => {
                 const set = compiled_set(ctx);
+                if (set_leaves && set instanceof ControlSignal)
+                    return set;
                 lockForIteration(set);
                 try {
                     for (const key of loopWalk(set)) {
                         const ctx2 = Object.create(ctx);
                         ctx2[key_name] = variant("value", key);
-                        try {
-                            compiled_body(ctx2);
-                        }
-                        catch (e) {
-                            if (e instanceof ContinueException && e.label === label) {
-                                continue;
-                            }
-                            else if (e instanceof BreakException && e.label === label) {
+                        const r = compiled_body(ctx2);
+                        if (reads && r instanceof ControlSignal) {
+                            if (r.kind === "return" || r.label !== label)
+                                return r;
+                            if (r.kind === "break")
                                 break;
-                            }
-                            else {
-                                throw e;
-                            }
                         }
                     }
                     return null;
@@ -403,37 +482,35 @@ export function compile_control(ir, ctx, platform, asyncPlatformFns, platformDef
     else if (ir.type === "ForDict") {
         const key_type = expandTypeValue(ir.value.dict.value.type).value.key;
         const value_type = expandTypeValue(ir.value.dict.value.type).value.value;
-        const compiled_dict = compile_internal(ir.value.dict, ctx, platform, asyncPlatformFns, platformDef, false, compilingNodes);
+        const compiled_dict = statement(ir.value.dict, ctx, false, platform, asyncPlatformFns, platformDef, compilingNodes);
         const ctx2 = Object.create(ctx);
         const key_name = ir.value.key.value.name;
         const value_name = ir.value.value.value.name;
         ctx2[key_name] = key_type;
         ctx2[value_name] = value_type;
-        const compiled_body = compile_internal(ir.value.body, ctx2, platform, asyncPlatformFns, platformDef, true, compilingNodes);
+        const compiled_body = statement(ir.value.body, ctx2, true, platform, asyncPlatformFns, platformDef, compilingNodes);
         const label = ir.value.label.name;
         const loc_id = ir.value.loc_id;
+        // As a While's: whether the dict can give a signal, and whether the loop must act on what its body gives.
+        const dict_leaves = escapesOf(ir.value.dict) !== NO_ESCAPES;
+        const reads = loopReads(ir.value.body, label);
         if (ir.value.isAsync) {
             return async (ctx) => {
                 const dict = await compiled_dict(ctx);
+                if (dict_leaves && dict instanceof ControlSignal)
+                    return dict;
                 lockForIteration(dict);
                 try {
                     for (const [key, value] of loopWalk(dict)) {
                         const ctx2 = Object.create(ctx);
                         ctx2[key_name] = variant("value", key);
                         ctx2[value_name] = variant("value", value);
-                        try {
-                            await compiled_body(ctx2);
-                        }
-                        catch (e) {
-                            if (e instanceof ContinueException && e.label === label) {
-                                continue;
-                            }
-                            else if (e instanceof BreakException && e.label === label) {
+                        const r = await compiled_body(ctx2);
+                        if (reads && r instanceof ControlSignal) {
+                            if (r.kind === "return" || r.label !== label)
+                                return r;
+                            if (r.kind === "break")
                                 break;
-                            }
-                            else {
-                                throw e;
-                            }
                         }
                     }
                     return null;
@@ -449,25 +526,20 @@ export function compile_control(ir, ctx, platform, asyncPlatformFns, platformDef
         else {
             return (ctx) => {
                 const dict = compiled_dict(ctx);
+                if (dict_leaves && dict instanceof ControlSignal)
+                    return dict;
                 lockForIteration(dict);
                 try {
                     for (const [key, value] of loopWalk(dict)) {
                         const ctx2 = Object.create(ctx);
                         ctx2[key_name] = variant("value", key);
                         ctx2[value_name] = variant("value", value);
-                        try {
-                            compiled_body(ctx2);
-                        }
-                        catch (e) {
-                            if (e instanceof ContinueException && e.label === label) {
-                                continue;
-                            }
-                            else if (e instanceof BreakException && e.label === label) {
+                        const r = compiled_body(ctx2);
+                        if (reads && r instanceof ControlSignal) {
+                            if (r.kind === "return" || r.label !== label)
+                                return r;
+                            if (r.kind === "break")
                                 break;
-                            }
-                            else {
-                                throw e;
-                            }
                         }
                     }
                     return null;
@@ -482,29 +554,39 @@ export function compile_control(ir, ctx, platform, asyncPlatformFns, platformDef
         }
     }
     else if (ir.type === "Return") {
-        const compiled_value = compile_internal(ir.value.value, ctx, platform, asyncPlatformFns, platformDef, false, compilingNodes);
+        const compiled_value = statement(ir.value.value, ctx, false, platform, asyncPlatformFns, platformDef, compilingNodes);
+        // A value a control statement leaves gives its signal in place of the return's.
+        const value_leaves = escapesOf(ir.value.value) !== NO_ESCAPES;
         if (ir.value.isAsync) {
-            return async (ctx) => {
-                throw new ReturnException(await compiled_value(ctx));
-            };
+            if (value_leaves) {
+                return async (ctx) => {
+                    const value = await compiled_value(ctx);
+                    return value instanceof ControlSignal ? value : new ControlSignal("return", "", value);
+                };
+            }
+            else {
+                return async (ctx) => new ControlSignal("return", "", await compiled_value(ctx));
+            }
         }
         else {
-            return (ctx) => {
-                throw new ReturnException(compiled_value(ctx));
-            };
+            if (value_leaves) {
+                return (ctx) => {
+                    const value = compiled_value(ctx);
+                    return value instanceof ControlSignal ? value : new ControlSignal("return", "", value);
+                };
+            }
+            else {
+                return (ctx) => new ControlSignal("return", "", compiled_value(ctx));
+            }
         }
     }
     else if (ir.type === "Continue") {
-        const label = ir.value.label;
-        return (_ctx) => {
-            throw new ContinueException(label.name);
-        };
+        const signal = new ControlSignal("continue", ir.value.label.name, null);
+        return (_ctx) => signal;
     }
     else if (ir.type === "Break") {
-        const label = ir.value.label;
-        return (_ctx) => {
-            throw new BreakException(label.name);
-        };
+        const signal = new ControlSignal("break", ir.value.label.name, null);
+        return (_ctx) => signal;
     }
     else {
         throw new Error(`Unhandled IR type ${ir.type} at loc_id ${ir.value.loc_id}`); // The `satisfies never` here ensures that this branch is unreachable if all IR types are handled