@scriptc/compiler 0.0.29 → 0.0.31

package/dist/frontend/lowering/lower-stmts.js

@@ -20,7 +20,7 @@ import { lowerStreamUnderscoreAssign, streamClassAliasDecl, streamSidesOf } from
 import { lowerHttpResPropertyAssignment, lowerHttpServerTimeoutAssignment, lowerServerCloseOverrideAssignment } from "./lower-server.js";
 import { builtinMemberRequireDecl, builtinNamespaceDestructureModuleOf, createRequireBindingDecl, createRequireCalleeFileOf, createRequireNamespaceDecl, textCodecBindingDecl } from "./lower-builtins.js";
 import { lowerEnumDeclaration } from "./lower-enums.js";
-import { abstractPropertyDeclOf, aliasTypeofNarrows, isMatchSliceType, lowerGroupsProjection, matchResultNamedGroupsOf, probeLower, pureReemittable, symbolFieldInfo } from "./lower-exprs.js";
+import { abstractPropertyDeclOf, aliasTypeofNarrows, isMatchSliceType, lowerAbsenceProbe, lowerGroupsProjection, matchResultNamedGroupsOf, probeLower, pureReemittable, runtimeOptionalTrueIds, symbolFieldInfo, withRuntimeOptionalNarrowed } from "./lower-exprs.js";
 import { checkerPanicDiag, isCheckerPanic, requiresDynamicDiag } from "../../diagnostics/diagnostic.js";
 import { isParseArgsDynTypeName, isUnitOnlyTsType, unitOnlyUnion } from "../types.js";
 import { canonicalBuiltinModule, isRelativeSpecifier } from "../shared.js";
@@ -704,16 +704,19 @@ export function lowerStmt(L, stmt) {
         // then-branch lowers under what a TRUE condition proves, the
         // else-branch under a FALSE one — the var/let alias narrowing the
         // checker only performs for consts (aliasTypeofNarrows).
-        const then = L.narrowingAliases(aliasTypeofNarrows(L, stmt.expression, true), () => L.lowerScopedBlock(stmt.thenStatement));
+        const then = L.narrowingAliases(aliasTypeofNarrows(L, stmt.expression, true), () => withRuntimeOptionalNarrowed(L, runtimeOptionalTrueIds(L, stmt.expression), () => L.lowerScopedBlock(stmt.thenStatement)));
         const else_ = stmt.elseStatement
             ? L.narrowingAliases(aliasTypeofNarrows(L, stmt.expression, false), () => L.lowerScopedBlock(stmt.elseStatement))
             : null;
+        const narrowedAfter = falsyExitRuntimeOptionalLocal(L, stmt);
+        if (narrowedAfter !== null)
+            L.runtimeOptionalLocals.delete(L.runtimeOptionalRootOf(narrowedAfter));
         return { kind: "if", cond, then, else_, loc: locOf(stmt) };
     }
     if (ts.isWhileStatement(stmt)) {
         const labels = L.takeLabels();
         const cond = L.lowerCondition(stmt.expression);
-        const body = L.inCtl("loop", () => L.lowerScopedBlock(stmt.statement), labels);
+        const body = L.inCtl("loop", () => withRuntimeOptionalNarrowed(L, runtimeOptionalTrueIds(L, stmt.expression), () => L.lowerScopedBlock(stmt.statement)), labels);
         return { kind: "while", cond, body, ...(labels && { labels }), loc: locOf(stmt) };
     }
     if (ts.isDoStatement(stmt)) {
@@ -3054,7 +3057,9 @@ export function lowerVarDecl(L, decl, isLet) {
     // later references to this name don't produce cascading errors.
     let init;
     try {
-        init = L.lowerExpr(decl.initializer);
+        init = immediatelyGuardedAbsenceProbe(L, decl)
+            ? (lowerAbsenceProbe(L, decl.initializer) ?? L.lowerExpr(decl.initializer))
+            : L.lowerExpr(decl.initializer);
     }
     catch (e) {
         if (e instanceof PoisonError) {
@@ -3134,14 +3139,17 @@ export function lowerVarDecl(L, decl, isLet) {
             }
         }
     }
-    // A JS binding holding an OOB-SAFE indexed read (`elem | undefined` —
-    // the --npm-static last-element probe) where the checker spells the
-    // bare element: the binding adopts the union — the idiom's next line
-    // is the truthiness guard, which narrows it right back.
-    if (type !== null && init.type.kind === "union" && isJsSourceFile(decl.getSourceFile()) &&
+    // An unannotated binding holding an OOB-SAFE indexed read (`elem |
+    // undefined`) where the checker spells the bare element: the binding
+    // adopts the runtime-honest union. This covers both inferred package JS
+    // and TypeScript's fresh-array probe idioms; an explicit annotation keeps
+    // the caller's checked slot contract.
+    let runtimeOptional = false;
+    if (!decl.type && type !== null && init.type.kind === "union" &&
         L.armTag(init.type.unionId, UNDEFINED_T) >= 0 &&
         typeEquals(L.stripUndefinedArm(init.type), type)) {
         type = init.type;
+        runtimeOptional = true;
     }
     // A JS binding whose checker type spells a FUNCTION but whose VALUE is
     // already checked-dynamic (`const cb = mustCall(fn)` — the helper's
@@ -3158,12 +3166,13 @@ export function lowerVarDecl(L, decl, isLet) {
     // adopt the initializer's type. Checker-`any[]` decls take the same
     // rule (`const tlds = Array.isArray(u) ? u : [u]` — tsc's readonly
     // Array.isArray quirk types the ternary any[], while the arms lower
-    // to the union's real array arm). Const only — an evolving-`any`
+    // to the union's real array arm; readonly fixed-tuple narrows adopt
+    // their tuple record likewise). Const only — an evolving-`any`
     // `let` may be reassigned a different shape later; genuine `any`
     // only — every other unmappable keeps its own diagnostic.
     if (type === null && !isLet &&
         ((L.typeOf(decl.name).flags & ts.TypeFlags.Any) !== 0 ||
-            (L.checkerAnyArray(decl.name) && init.type.kind === "array") ||
+            (L.checkerAnyArray(decl.name) && L.isArrayValueType(init.type)) ||
             // JS declarations carry no annotations: an unmappable inferred
             // type (a union with a fence-folded arm — the typeof-'bigint'
             // dual-mode ternary) adopts the initializer's static type, the
@@ -3275,8 +3284,59 @@ export function lowerVarDecl(L, decl, isLet) {
     // subtyping (`const p: {a: number} = wider;`) is rejected, not coerced.
     init = L.coerceInto(decl.initializer, init, type);
     const local = L.declareLocal(decl.name, decl.name.text, type, isLet);
+    if (runtimeOptional) {
+        const runtimeOptionalRoot = L.runtimeOptionalRootOf(local);
+        L.runtimeOptionalLocals.add(runtimeOptionalRoot);
+        L.runtimeOptionalStorageLocals.add(runtimeOptionalRoot);
+    }
     return { kind: "varDecl", localId: local.id, init, loc: locOf(decl) };
 }
+function immediatelyGuardedAbsenceProbe(L, decl) {
+    if (decl.type || !ts.isIdentifier(decl.name) || !decl.initializer)
+        return false;
+    const statement = decl.parent?.parent;
+    if (!statement || !ts.isVariableStatement(statement))
+        return false;
+    const container = statement.parent;
+    const statements = ts.isBlock(container) || ts.isSourceFile(container) ? container.statements : null;
+    if (!statements)
+        return false;
+    const index = statements.indexOf(statement);
+    const next = index >= 0 ? statements[index + 1] : undefined;
+    if (!next || !ts.isIfStatement(next))
+        return false;
+    let condition = next.expression;
+    while (ts.isParenthesizedExpression(condition))
+        condition = condition.expression;
+    if (!ts.isPrefixUnaryExpression(condition) || condition.operator !== ts.SyntaxKind.ExclamationToken)
+        return false;
+    let operand = condition.operand;
+    while (ts.isParenthesizedExpression(operand))
+        operand = operand.expression;
+    return ts.isIdentifier(operand) && L.resolveValueSymbol(operand) === L.resolveValueSymbol(decl.name);
+}
+function falsyExitRuntimeOptionalLocal(L, stmt) {
+    if (stmt.elseStatement)
+        return null;
+    let condition = stmt.expression;
+    while (ts.isParenthesizedExpression(condition))
+        condition = condition.expression;
+    if (!ts.isPrefixUnaryExpression(condition) || condition.operator !== ts.SyntaxKind.ExclamationToken)
+        return null;
+    let operand = condition.operand;
+    while (ts.isParenthesizedExpression(operand))
+        operand = operand.expression;
+    if (!ts.isIdentifier(operand))
+        return null;
+    const local = L.resolveLocal(operand);
+    if (!local || !L.runtimeOptionalLocals.has(L.runtimeOptionalRootOf(local)))
+        return null;
+    const exits = ts.isReturnStatement(stmt.thenStatement) || ts.isThrowStatement(stmt.thenStatement) ||
+        (ts.isBlock(stmt.thenStatement) && stmt.thenStatement.statements.length > 0 &&
+            (ts.isReturnStatement(stmt.thenStatement.statements[stmt.thenStatement.statements.length - 1]) ||
+                ts.isThrowStatement(stmt.thenStatement.statements[stmt.thenStatement.statements.length - 1])));
+    return exits ? local : null;
+}
 /** JS-exact switch (see docs/ir.md): one shared lexical scope for all case
    * bodies, lazy source-order test evaluation, fall-through. tsc has already
    * checked case-test comparability (TS2678) — the kind check below is the
@@ -4261,6 +4321,9 @@ export function lowerExprStatement(L, expr) {
             if (!target)
                 L.rejectUnresolved(expr.left, `assignment to '${expr.left.text}' (not a writable local or module global)`);
             const value = L.lowerExprExpecting(expr.right, target.type);
+            const runtimeOptionalRoot = L.runtimeOptionalRootOf(target);
+            if (L.runtimeOptionalStorageLocals.has(runtimeOptionalRoot))
+                L.runtimeOptionalLocals.add(runtimeOptionalRoot);
             return { kind: "assign", localId: target.id, value, loc: locOf(expr) };
         }
         if (opKind === ts.SyntaxKind.QuestionQuestionEqualsToken) {