@scriptc/compiler 0.0.36 → 0.1.2

package/dist/ir/validate.js

@@ -1,4 +1,4 @@
-import { arrayOf, BOOL, BYTES_U8, bytesOf, canAdaptDynFuncTo, canConvertToDyn, canExitIslandToType, canMarshalIntoIsland, canMarshalTypedFuncIntoIsland, CHILD_T, CHILDSTREAM_T, DATE_T, DGRAMSOCK_T, DYN, DYN_HANDLE_KINDS, F64, ffiClassType, ffiSourceParamTypes, FILEHANDLE_T, FSWATCHER_T, HTTP2SESSION_T, HTTP2STREAM_T, HTTPCLIENTREQ_T, HTTPREQ_T, HTTPRES_T, islandPromisePayloadTag, isFfiCallbackParam, isFfiContextParam, isFfiReleaseParam, isJsonSafeType, isRefCounted, isSupportedArrayElem, isSupportedIndexValue, isSupportedMapKey, isSupportedMapValue, isSupportedSetElem, isUnitType, jsOpResultKind, JSVAL, NETSERVER_T, NETSOCKET_T, PROCSTREAM_T, REF_TRUTHY_KINDS, REGEX, RUNTIME_EMITTER_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, SEARCH_PARAMS_T, SECURECTX_T, shapeHasAccessorSlots, SPAWNRES_T, STATS_T, STRING, SYMBOL_T, TESTCTX_T, typeEquals, typeKey, unionFuncSetArmsOk, URL_T, VOID } from "./ir.js";
+import { arrayOf, BOOL, BYTES_U8, bytesOf, canAdaptDynFuncTo, canConvertToDyn, canExitIslandToType, canMarshalIntoIsland, canMarshalTypedFuncIntoIsland, CHILD_T, CHILDSTREAM_T, DATE_T, DGRAMSOCK_T, DYN, DYN_HANDLE_KINDS, F64, ffiClassType, ffiSourceParamTypes, FILEHANDLE_T, FSWATCHER_T, HTTP2SESSION_T, HTTP2STREAM_T, HTTPCLIENTREQ_T, HTTPREQ_T, HTTPRES_T, islandPromisePayloadTag, isDynTypedRefType, isFfiCallbackParam, isFfiContextParam, isFfiReleaseParam, isJsonSafeType, isJsonStringifySafeType, isRefCounted, isSupportedArrayElem, isSupportedIndexValue, isSupportedMapKey, isSupportedMapValue, isSupportedSetElem, isUnitType, jsOpResultKind, JSVAL, NETSERVER_T, NETSOCKET_T, PROCSTREAM_T, REF_TRUTHY_KINDS, REGEX, RUNTIME_EMITTER_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, SEARCH_PARAMS_T, SECURECTX_T, shapeHasAccessorSlots, SPAWNRES_T, STATS_T, STRING, SYMBOL_T, TESTCTX_T, typeEquals, typeKey, unionFuncSetArmsOk, URL_T, VOID } from "./ir.js";
 /** Per-method signature for strIntrinsic: `argTypes` lists every argument
  * position (optional ones included); `minArgs` is how many may be omitted
  * from the end (backends fill the documented defaults). Exported for the
@@ -85,6 +85,22 @@ export const LIB_FN_SIGS = {
     "dyn.toString": { argTypes: [DYN, STRING, STRING], result: STRING },
     "dyn.defineProps": { argTypes: [DYN, DYN], result: DYN },
     "dyn.typeof": { argTypes: [DYN], result: STRING },
+    "module.registryInit": { argTypes: [F64], result: VOID },
+    "module.define": { argTypes: [F64, STRING, STRING, STRING, arrayOf(STRING), BOOL], result: VOID },
+    "module.enter": { argTypes: [F64], result: VOID },
+    "module.link": { argTypes: [F64, F64], result: VOID },
+    "module.finish": { argTypes: [F64], result: VOID },
+    "module.fail": { argTypes: [F64], result: VOID },
+    "module.filename": { argTypes: [F64], result: STRING },
+    "module.id": { argTypes: [F64], result: STRING },
+    "module.path": { argTypes: [F64], result: STRING },
+    "module.paths": { argTypes: [F64], result: arrayOf(STRING) },
+    "module.children": { argTypes: [F64], result: arrayOf(F64) },
+    "module.parent": { argTypes: [F64], result: F64 },
+    "module.loaded": { argTypes: [F64], result: BOOL },
+    "module.cacheGet": { argTypes: [STRING], result: F64 },
+    "module.cacheHas": { argTypes: [STRING], result: BOOL },
+    "module.cacheKeys": { argTypes: [], result: arrayOf(STRING) },
     "timers.setTimeout": { argTypes: [{ kind: "func", params: [], ret: VOID }, F64], result: VOID },
     "timers.setInterval": { argTypes: [{ kind: "func", params: [], ret: VOID }, F64], result: F64 },
     "timers.clearInterval": { argTypes: [F64], result: VOID },
@@ -937,6 +953,7 @@ export const LIB_FN_SIGS = {
     "writable.uncork": { argTypes: [null], result: VOID },
     "stream.destroy": { argTypes: [null], result: VOID },
     "stream.destroyErr": { argTypes: [null, null], result: VOID },
+    "stream.iteratorClose": { argTypes: [null], result: VOID },
     "stream.prop": { argTypes: [null, STRING], result: VOID },
     "stream.errored": { argTypes: [null], result: VOID },
     // node:assert: pass/negated/deep/hasMsg are frontend-computed bools; the
@@ -1118,6 +1135,9 @@ function isBuiltinErrorObject(t) {
  * TReturn channel, so call sites see the generator type. The one place
  * the body/call-site split is spelled out in the validator. */
 function callSiteReturnType(fn) {
+    if (fn.async && fn.generator !== undefined) {
+        return { kind: "generator", async: true, yieldT: fn.generator.yieldT, retT: fn.returnType, nextT: fn.generator.nextT };
+    }
     if (fn.async)
         return { kind: "promise", inner: fn.returnType };
     if (fn.generator !== undefined) {
@@ -1132,9 +1152,6 @@ export function validateModule(mod) {
         if (functionsByName.has(fn.name)) {
             errors.push({ message: `duplicate function "${fn.name}"`, loc: fn.loc });
         }
-        if (fn.async && fn.generator !== undefined) {
-            errors.push({ message: `function "${fn.name}" is both async and a generator (async generators are fenced)`, loc: fn.loc });
-        }
         functionsByName.set(fn.name, fn);
     }
     const ffiByName = new Map();
@@ -1716,7 +1733,8 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
     const liveDynRefEligible = (type, seen = new Set()) => {
         if (type.kind === "record" ||
             type.kind === "array" ||
-            type.kind === "bytes") {
+            type.kind === "bytes" ||
+            isDynTypedRefType(type)) {
             return true;
         }
         if (type.kind !== "union" || seen.has(type.unionId))
@@ -1883,9 +1901,11 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                 break;
             }
             case "seqExpr": {
-                // Statements in an expression: straight-line writes only — no
-                // control flow, no jumps (the C emission point is mid-expression).
-                const allowed = new Set(["varDecl", "assign", "exprStmt", "fieldSet", "recordSet", "recordKeySet", "arraySet", "bytesSet", "block"]);
+                // Statements in an expression cannot jump out of the expression,
+                // but a local state branch is valid: optional array stores must
+                // choose ARRAY_VALUE versus ARRAY_UNDEFINED before the final result
+                // is evaluated. Nested blocks/ifs are checked recursively below.
+                const allowed = new Set(["varDecl", "assign", "exprStmt", "fieldSet", "recordSet", "recordKeySet", "arraySet", "arraySetLength", "arraySetUndefined", "arrayDelete", "bytesSet", "block", "if"]);
                 const flat = (ss) => {
                     for (const s of ss) {
                         if (!allowed.has(s.kind)) {
@@ -1896,6 +1916,13 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                             flat(s.body);
                             continue;
                         }
+                        if (s.kind === "if") {
+                            flat(s.then);
+                            if (s.else_)
+                                flat(s.else_);
+                            checkExpr(s.cond);
+                            continue;
+                        }
                         checkStmt(s);
                     }
                 };
@@ -2320,6 +2347,27 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                 }
                 break;
             }
+            case "arrayHas": {
+                checkExpr(e.arr);
+                checkExpr(e.index);
+                expectType(e.index, F64, "arrayHas index");
+                if (!typeEquals(e.type, BOOL))
+                    err(`arrayHas result ${e.type.kind} != bool`, e.loc);
+                if (e.arr.type.kind !== "array") {
+                    err(`arrayHas on non-array ${e.arr.type.kind}`, e.loc);
+                }
+                break;
+            }
+            case "arrayState": {
+                checkExpr(e.arr);
+                checkExpr(e.index);
+                expectType(e.index, F64, "arrayState index");
+                if (!typeEquals(e.type, F64))
+                    err(`arrayState result ${e.type.kind} != f64`, e.loc);
+                if (e.arr.type.kind !== "array")
+                    err(`arrayState on non-array ${e.arr.type.kind}`, e.loc);
+                break;
+            }
             case "bytesNew": {
                 if (e.type.kind !== "bytes") {
                     err(`bytesNew of non-bytes type ${e.type.kind}`, e.loc);
@@ -2468,31 +2516,35 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                 const elem = e.receiver.type.elem;
                 const sig = e.method === "push" || e.method === "unshift"
                     ? { argTypes: e.args.map(() => elem), result: F64 }
-                    : e.method === "pushSpread" || e.method === "unshiftSpread"
+                    : e.method === "pushSpread" || e.method === "concatSpread" || e.method === "unshiftSpread"
                         ? { argTypes: [e.receiver.type], result: F64 }
-                        : e.method === "pop"
-                            ? { argTypes: [], result: elem }
-                            : e.method === "indexOf"
-                                ? { argTypes: [elem], result: F64 }
-                                : e.method === "includes"
-                                    ? { argTypes: [elem], result: BOOL }
-                                    : e.method === "join"
-                                        ? { argTypes: [STRING], result: STRING }
-                                        : e.method === "slice"
-                                            ? { argTypes: [F64, F64], result: e.receiver.type }
-                                            : e.method === "toReversed"
-                                                ? { argTypes: [], result: e.receiver.type }
-                                                : e.method === "reverse"
+                        : e.method === "nextPresent"
+                            ? { argTypes: [F64], result: F64 }
+                            : e.method === "pop"
+                                ? { argTypes: [], result: e.type } // union-checked below
+                                : e.method === "indexOf"
+                                    ? { argTypes: [elem], result: F64 }
+                                    : e.method === "includes"
+                                        ? { argTypes: [elem], result: BOOL }
+                                        : e.method === "join"
+                                            ? { argTypes: [STRING], result: STRING }
+                                            : e.method === "slice"
+                                                ? { argTypes: [F64, F64], result: e.receiver.type }
+                                                : e.method === "toReversed"
                                                     ? { argTypes: [], result: e.receiver.type }
-                                                    : e.method === "toSpliced"
-                                                        ? { argTypes: [F64, F64, e.receiver.type], result: e.receiver.type }
-                                                        : e.method === "with"
-                                                            ? { argTypes: [F64, elem], result: e.receiver.type }
-                                                            : e.method === "splice"
-                                                                ? { argTypes: [F64, F64], result: e.receiver.type }
-                                                                : e.method === "shift"
-                                                                    ? { argTypes: [], result: e.type } // union-checked below
-                                                                    : { argTypes: [], result: F64 }; // length
+                                                    : e.method === "reverse"
+                                                        ? { argTypes: [], result: e.receiver.type }
+                                                        : e.method === "toSpliced"
+                                                            ? { argTypes: [F64, F64, e.receiver.type], result: e.receiver.type }
+                                                            : e.method === "with"
+                                                                ? { argTypes: [F64, elem], result: e.receiver.type }
+                                                                : e.method === "withUndefined"
+                                                                    ? { argTypes: [F64], result: e.receiver.type }
+                                                                    : e.method === "splice"
+                                                                        ? { argTypes: [F64, F64], result: e.receiver.type }
+                                                                        : e.method === "shift"
+                                                                            ? { argTypes: [], result: e.type } // union-checked below
+                                                                            : { argTypes: [], result: F64 }; // length
                 if (e.method === "join" &&
                     elem.kind !== "f64" && elem.kind !== "string" && elem.kind !== "bool" &&
                     !(elem.kind === "union" &&
@@ -2507,17 +2559,12 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                     // misjudge JS ===; the frontend fences these.
                     err(`arrIntrinsic ${e.method} on union elements (frontend must reject)`, e.loc);
                 }
-                if (e.method === "shift") {
-                    // The result is the interned `elem | undefined` union (union
-                    // elements are frontend-fenced, so the arms never collide).
-                    if (elem.kind === "union") {
-                        err("arrIntrinsic shift on union elements (frontend must reject)", e.loc);
-                    }
+                if (e.method === "shift" || e.method === "pop") {
                     const rdef = e.type.kind === "union" ? unions.get(e.type.unionId) : undefined;
                     if (!rdef ||
-                        !rdef.arms.some((a) => a.kind === "undefinedT") ||
-                        !rdef.arms.some((a) => typeEquals(a, elem))) {
-                        err("arrIntrinsic shift result must be the elem|undefined union", e.loc);
+                        !rdef.arms.some((arm) => arm.kind === "undefinedT") ||
+                        !(elem.kind === "union" ? typeEquals(elem, e.type) : rdef.arms.some((arm) => typeEquals(arm, elem)))) {
+                        err(`arrIntrinsic ${e.method} result must be the elem|undefined union`, e.loc);
                     }
                 }
                 // slice's indices and splice's count are optional (omitted args
@@ -4498,7 +4545,7 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                 if (e.fn.startsWith("readable.") || e.fn.startsWith("writable.") ||
                     e.fn.startsWith("duplex.") || e.fn.startsWith("transform.") ||
                     e.fn.startsWith("passthrough.") || e.fn === "stream.destroy" ||
-                    e.fn === "stream.destroyErr" || e.fn === "stream.prop" ||
+                    e.fn === "stream.destroyErr" || e.fn === "stream.iteratorClose" || e.fn === "stream.prop" ||
                     e.fn === "stream.errored" || e.fn === "stream.finished" ||
                     e.fn === "stream.finishedDyn" || e.fn === "stream.pipeline" ||
                     e.fn === "stream.pipelineDyn") {
@@ -4606,7 +4653,8 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                     if (e.fn === "readable.pause" || e.fn === "readable.resume" ||
                         e.fn === "readable.unpipe" || e.fn === "writable.end" ||
                         e.fn === "readable.setEncoding" || e.fn === "readable.pushEncoding" ||
-                        e.fn === "stream.destroy" || e.fn === "stream.destroyErr") {
+                        e.fn === "stream.destroy" || e.fn === "stream.destroyErr" ||
+                        e.fn === "stream.iteratorClose") {
                         if (!typeEquals(e.type, e.args[0].type)) {
                             err(`libCall ${e.fn} must return its receiver's type (the chaining 'this')`, e.loc);
                         }
@@ -4750,7 +4798,7 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                 // A dyn ROOT is the one non-static shape allowed: the runtime's dyn
                 // walker serializes it (scr_dyn_format_j), no emitted serializer.
                 if (e.value.type.kind !== "dyn" &&
-                    !isJsonSafeType(e.value.type, (id) => records.get(id), (id) => unions.get(id))) {
+                    !isJsonStringifySafeType(e.value.type, (id) => records.get(id), (id) => unions.get(id))) {
                     err(`jsonStringify of non-JSON-safe type ${e.value.type.kind}`, e.loc);
                 }
                 break;
@@ -4766,13 +4814,17 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                 // reads), which matches exactly the undefined arm.
                 const jsonOk = (t) => isJsonSafeType(t, (id) => records.get(id), (id) => unions.get(id));
                 const undefArmedOk = e.type.kind === "union" &&
-                    (unions.get(e.type.unionId)?.arms.every((a) => a.kind === "undefinedT" || jsonOk(a)) ??
+                    (unions.get(e.type.unionId)?.arms.every((a) => a.kind === "undefinedT" ||
+                        jsonOk(a) ||
+                        isDynTypedRefType(a) ||
+                        DYN_HANDLE_KINDS.has(a.kind)) ??
                         false);
                 // bytes<u8> targets extract the checked-dynamic tree's bytes kind (a copy).
                 const bytesOk = e.type.kind === "bytes" && e.type.elem === "u8";
                 // The %Error root extracts the checked-dynamic tree's error encoding (the "%error"
                 // marker object caughtToDyn builds) as a fresh runtime error.
                 const errorOk = e.type.kind === "object" && e.type.className === "%Error";
+                const classOk = isDynTypedRefType(e.type);
                 // ADAPTABLE function targets unwrap or wrap the checked-dynamic tree's function
                 // kind (the checked-dynamic function boundary, ir.ts).
                 const funcOk = e.type.kind === "func" &&
@@ -4780,7 +4832,7 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                 // Runtime HANDLE targets unwrap the checked-dynamic tree's handle kind by tag (a
                 // retained reference, no copy — DYN_HANDLE_KINDS).
                 const handleOk = DYN_HANDLE_KINDS.has(e.type.kind);
-                if (!jsonOk(e.type) && !undefArmedOk && !bytesOk && !errorOk && !funcOk && !handleOk) {
+                if (!jsonOk(e.type) && !undefArmedOk && !bytesOk && !errorOk && !classOk && !funcOk && !handleOk) {
                     err(`dynCheck against non-JSON-representable type ${e.type.kind}`, e.loc);
                 }
                 break;
@@ -4859,17 +4911,19 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                         err(`genResume throw of a ${e.arg.type.kind} value`, e.loc);
                     }
                 }
-                // The result is the IteratorResult record { done: bool, value: V }
+                // Sync resumes return IteratorResult directly; async resumes return
+                // Promise<IteratorResult>. The record is { done: bool, value: V }
                 // with V dyn (the any/unknown channel) or an undefined-armed union.
-                if (e.type.kind !== "record") {
-                    err(`genResume result is ${e.type.kind}, not a record`, e.loc);
+                const resultT = genT.async ? (e.type.kind === "promise" ? e.type.inner : null) : e.type;
+                if (resultT?.kind !== "record") {
+                    err(`genResume result is ${typeKey(e.type)}, not ${genT.async ? "a promise of " : ""}a record`, e.loc);
                     break;
                 }
-                const rec = records.get(e.type.shapeId);
+                const rec = records.get(resultT.shapeId);
                 const doneF = rec?.fields.find((f) => f.name === "done");
                 const valueF = rec?.fields.find((f) => f.name === "value");
                 if (!rec || rec.fields.length !== 2 || doneF?.type.kind !== "bool" || valueF === undefined) {
-                    err(`genResume result record ${e.type.shapeId} is not { done: bool, value: V }`, e.loc);
+                    err(`genResume result record ${resultT.shapeId} is not { done: bool, value: V }`, e.loc);
                     break;
                 }
                 if (valueF.type.kind === "dyn")
@@ -5093,19 +5147,8 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
     let breakableDepth = 0;
     // Labeled jump targets, innermost last: every loop/switch/labeled-block
     // enters with its labels (possibly none) so `break lbl`/`continue lbl`
-    // can resolve to an enclosing entry — and so the finally backstop can
-    // compare the TARGET's position, not just the innermost depth.
+    // can resolve to an enclosing entry.
     const labelTargets = [];
-    // Active try-with-finally regions: break/continue may not cross one, and
-    // NO jump may leave a finally BODY (the frontend fences both; this is the
-    // backstop). `return` crossing a region is modeled now (the backend's
-    // pending-return path), so returns are legal in tryBody/catchBody but
-    // still rejected inside finallyBody (they would replace a pending
-    // completion). Each entry records the loop/switch depths (and the label
-    // stack length) at region entry: a break whose target is at or below
-    // them would cross the finally.
-    const finallyRegions = [];
-    let finallyBlockDepth = 0;
     function checkStmts(stmts) {
         for (const s of stmts)
             checkStmt(s);
@@ -5119,12 +5162,11 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
         breakableDepth--;
         loopDepth--;
     }
-    /** The innermost enclosing target carrying `label`, or null — plus its
-     * index for the finally-region crossing check. */
+    /** The innermost enclosing target carrying `label`, or null. */
     function labelTargetOf(label) {
         for (let i = labelTargets.length - 1; i >= 0; i--) {
             if (labelTargets[i].labels.includes(label))
-                return { entry: labelTargets[i], index: i };
+                return labelTargets[i];
         }
         return null;
     }
@@ -5243,6 +5285,24 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                 }
                 break;
             }
+            case "arraySetLength": {
+                checkExpr(s.arr);
+                checkExpr(s.length);
+                expectType(s.length, F64, "arraySetLength length");
+                if (s.arr.type.kind !== "array") {
+                    err(`arraySetLength on non-array ${s.arr.type.kind}`, s.loc);
+                }
+                break;
+            }
+            case "arraySetUndefined":
+            case "arrayDelete": {
+                checkExpr(s.arr);
+                checkExpr(s.index);
+                expectType(s.index, F64, `${s.kind} index`);
+                if (s.arr.type.kind !== "array")
+                    err(`${s.kind} on non-array ${s.arr.type.kind}`, s.loc);
+                break;
+            }
             case "bytesSet": {
                 checkExpr(s.arr);
                 checkExpr(s.index);
@@ -5403,67 +5463,39 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                         err(`tryCatch catch binding without a catch body`, s.loc);
                     }
                 }
-                const guarded = s.finallyBody !== null;
-                if (guarded)
-                    finallyRegions.push({ loopDepth, breakableDepth, labelLen: labelTargets.length });
                 checkStmts(s.tryBody);
                 if (s.catchBody)
                     checkStmts(s.catchBody);
-                if (s.finallyBody) {
-                    finallyBlockDepth++;
+                if (s.finallyBody)
                     checkStmts(s.finallyBody);
-                    finallyBlockDepth--;
-                }
-                if (guarded)
-                    finallyRegions.pop();
                 break;
             }
             case "break": {
-                const region = finallyRegions[finallyRegions.length - 1];
                 if (s.label !== undefined) {
                     const target = labelTargetOf(s.label);
                     if (!target)
                         err(`break to unknown label "${s.label}"`, s.loc);
-                    else if (region && target.index < region.labelLen) {
-                        err(`labeled break crossing a finally block (frontend must reject)`, s.loc);
-                    }
                     break;
                 }
                 if (breakableDepth === 0)
                     err(`break outside a loop or switch`, s.loc);
-                if (region && breakableDepth <= region.breakableDepth) {
-                    err(`break crossing a finally block (frontend must reject)`, s.loc);
-                }
                 break;
             }
             case "continue": {
-                const region = finallyRegions[finallyRegions.length - 1];
                 if (s.label !== undefined) {
                     const target = labelTargetOf(s.label);
                     if (!target)
                         err(`continue to unknown label "${s.label}"`, s.loc);
-                    else if (target.entry.kind !== "loop") {
+                    else if (target.kind !== "loop") {
                         err(`continue to non-loop label "${s.label}"`, s.loc);
                     }
-                    else if (region && target.index < region.labelLen) {
-                        err(`labeled continue crossing a finally block (frontend must reject)`, s.loc);
-                    }
                     break;
                 }
                 if (loopDepth === 0)
                     err(`continue outside a loop`, s.loc);
-                if (region && loopDepth <= region.loopDepth) {
-                    err(`continue crossing a finally block (frontend must reject)`, s.loc);
-                }
                 break;
             }
             case "return":
-                // Crossing OUT of a try/catch body guarded by a finally is modeled
-                // (the backend's pending-return path); a return inside the finally
-                // BODY itself is not (it would replace a pending completion).
-                if (finallyBlockDepth > 0) {
-                    err(`return inside a finally body (frontend must reject)`, s.loc);
-                }
                 if (s.value) {
                     checkExpr(s.value);
                     expectType(s.value, fn.returnType, "return value");