@scriptc/compiler 0.2.0 → 0.2.1

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

@@ -1,3 +1,4 @@
+import { lowerDynObjectLiteral } from "./expressions/object-literals.js";
 import { InternalCompilerError } from "../../errors.js";
 /* Statement lowering: the statement dispatch (lowerStmt), variable
  * declarations including destructuring patterns, scoped blocks, control
@@ -10,7 +11,7 @@ import { lowerForAwaitGenerator, lowerForOfGenerator, lowerYieldStarStatement }
 import { lowerForAwaitBuiltin } from "./lower-async-iteration.js";
 import { BOOL, BYTES_U8, CAUGHT, DYN, F64, JSVAL, STRING, UNDEFINED_T, VOID, arrayOf, isDynTypedRefType, isUnitType, shapeHasAccessorSlots, typeEquals } from "../../ir/ir.js";
 import { PoisonError, boundIdentifiersOf, dynFallbackType, dynUndefinedExpr, importCallHandleType, neverTaintedJsType, staticImportNamespaceType, stmtUsesIsland, uncheckedOverloadHandleCall } from "./lowerer.js";
-import { enforceLibBoundary } from "./lib-boundary.js";
+import { enforceLibBoundary, lowerSurplusCalls } from "./lib-boundary.js";
 import { cjsExportAssignmentOf, cjsExportDiscardReason, cjsExportTargetLiteral, isCjsJsFile, isEsModuleStamp, isJsSourceFile, isNodeEsmFile, locOf, requireSpecOf } from "../program.js";
 import { COMPOUND_ASSIGN_OPS, STR_METHODS, UNSUPPORTED_STMT, isStdlibMember, sideEffectFreeOptionValue, stdlibGlobalAliasDecl, stdlibGlobalAliasNameOf, stdlibGlobalNameOf } from "./surfaces.js";
 import { isNativeBuiltinValueInitializer } from "./lower-builtin-values.js";
@@ -23,7 +24,8 @@ import { isMixinFnBinding, mixinResultBindingClassOf } from "./lower-mixins.js";
 import { isCompiledPrototypeMember } from "./class-prototypes.js";
 import { classStaticDataFor } from "./class-static-data.js";
 import { objectFactorySignature } from "./object-factory-new.js";
-import { lowerClassCallbackAssign } from "./class-callbacks.js";
+import { isClassCallback, lowerClassCallbackAssign } from "./class-callbacks.js";
+import { classPropertiesHelper } from "./class-dynamic-dispatch.js";
 import { genericIfaceBindingKeepsClass, staticFieldWriteTarget } from "./lower-classes.js";
 import { lowerStreamUnderscoreAssign, streamClassAliasDecl } from "./lower-stream.js";
 import { lowerHttpResPropertyAssignment, lowerHttpServerTimeoutAssignment, lowerServerCloseOverrideAssignment } from "./lower-server.js";
@@ -424,13 +426,16 @@ export function lowerStmts(lowerer, stmts) {
                 // fence — inside this statement's poison window, so a JS fence
                 // becomes the statement's runtimeFence exactly like every other
                 // deferred rejection.
-                if (lowered)
-                    enforceLibBoundary(lowerer, lowered);
-                if (!appended) {
+                if (lowered) {
+                    const body = [];
                     if (Array.isArray(lowered))
-                        out.push(...lowered);
-                    else if (lowered)
-                        out.push(lowered);
+                        body.push(...lowered);
+                    else
+                        body.push(lowered);
+                    const rewritten = lowerSurplusCalls(lowerer, body);
+                    enforceLibBoundary(lowerer, rewritten);
+                    if (!appended)
+                        out.push(...rewritten);
                 }
                 // Island accounting (--dynamic coverage): a statement that lowered
                 // but carries island constructs compiles DYNAMICALLY — its work
@@ -1562,8 +1567,11 @@ export function lowerDestructuringDecl(lowerer, decl, isLet) {
    * bound name, recursing through hidden temps for nested patterns. */
 export function lowerBindingPattern(lowerer, pattern, srcRef, srcType, isLet, out, dynSpell, allowDynObject = false) {
     if (ts.isObjectBindingPattern(pattern)) {
-        const patternSymbol = lowerer.typeOf(pattern).getSymbol();
+        const patternType = lowerer.typeOf(pattern);
+        const patternSymbol = patternType.getSymbol();
         allowDynObject ||= patternSymbol?.name === "SegmentData" && lowerer.isStdlibSymbol(patternSymbol);
+        allowDynObject ||= (patternType.flags & ts.TypeFlags.Object) !== 0 && lowerer.mapTypeOf(patternType)?.kind === "dyn";
+        allowDynObject ||= (patternType.flags & ts.TypeFlags.Any) !== 0;
     }
     const present = patternSourceValue(lowerer, srcRef(), ts.isArrayBindingPattern(pattern), out, locOf(pattern), dynSpell);
     if (!typeEquals(present.type, srcType)) {
@@ -1724,13 +1732,13 @@ export function lowerBindingPattern(lowerer, pattern, srcRef, srcType, isLet, ou
             out.push({
                 kind: "varDecl",
                 localId: pack.id,
-                init: {
+                init: pattern.elements.some((element) => ts.isBindingElement(element) && element.dotDotDotToken) ? {
                     kind: "libCall",
                     fn: "dyn.iterPack",
                     args: [srcRef(), { kind: "strLit", value: dynSpell ?? "", type: STRING, loc }],
                     type: DYN,
                     loc,
-                },
+                } : { kind: "dynIterN", value: srcRef(), count: pattern.elements.length, ...(dynSpell ? { notIterableMessage: dynSpell } : {}), type: DYN, loc },
                 loc,
             });
             pattern.elements.forEach((el, i) => {
@@ -1738,7 +1746,9 @@ export function lowerBindingPattern(lowerer, pattern, srcRef, srcType, isLet, ou
                     return; // hole: the position skips
                 const elLoc = locOf(el);
                 if (el.dotDotDotToken) {
-                    lowerer.unsupported("SC1031", el, "rest elements over checked-dynamic sources");
+                    lowerer.bindPatternTarget(el.name, { kind: "dynInvoke", recv: varRef(pack.id, DYN, elLoc),
+                        method: "slice", calleeName: "Array.prototype.slice", args: [lowerer.coerceToExpected(numLit(i, elLoc), DYN)], type: DYN, loc: elLoc }, isLet, out);
+                    return;
                 }
                 let value = {
                     kind: "dynKeyGet",
@@ -1752,7 +1762,7 @@ export function lowerBindingPattern(lowerer, pattern, srcRef, srcType, isLet, ou
                     // its value converting into the checked-dynamic tree like any dyn-slot value.
                     const rl = lowerer.declareHiddenLocal("%delem", DYN);
                     out.push({ kind: "varDecl", localId: rl.id, init: value, loc: elLoc });
-                    const dflt = lowerer.coerceToExpected(lowerer.lowerExpr(el.initializer), DYN);
+                    const dflt = lowerer.coerceInto(el.initializer, lowerer.lowerExpr(el.initializer), DYN);
                     if (dflt.type.kind !== "dyn") {
                         lowerer.unsupported("SC1031", el.initializer, `defaults of '${lowerer.fmt(dflt.type)}' type over checked-dynamic sources (the value cannot convert into the checked-dynamic tree)`);
                     }
@@ -1875,14 +1885,26 @@ export function lowerBindingPattern(lowerer, pattern, srcRef, srcType, isLet, ou
     // scoped TypeScript exception: its declared result/token types are
     // deliberately carried by the checked-dynamic tree, so their ordinary
     // object patterns use the same exact keyed-read desugar.
-    if (srcType.kind === "dyn" &&
-        (isJsSourceFile(pattern.getSourceFile()) || allowDynObject)) {
+    if (srcType.kind === "dyn") {
         for (const el of pattern.elements) {
             if (el.name === undefined)
                 continue;
             const loc = locOf(el);
             if (el.dotDotDotToken) {
-                lowerer.unsupported("SC1031", el, "rest elements over checked-dynamic sources (the remaining-fields object has no lowering yet)");
+                const keys = [];
+                for (const sibling of pattern.elements) {
+                    if (sibling === el || sibling.dotDotDotToken)
+                        continue;
+                    const key = sibling.propertyName ?? sibling.name;
+                    const name = ts.isIdentifier(key) || ts.isStringLiteralLike(key) || ts.isNumericLiteral(key) || ts.isComputedPropertyName(key)
+                        ? patternKeyNameOf(lowerer, key) : null;
+                    if (name === null)
+                        lowerer.unsupported("SC1031", sibling, "rest bindings beside runtime computed keys");
+                    keys.push({ kind: "dynFrom", value: { kind: "strLit", value: name, type: STRING, loc }, type: DYN, loc });
+                }
+                lowerer.bindPatternTarget(el.name, { kind: "libCall", fn: "dyn.objectRest", args: [srcRef(),
+                        { kind: "dynArrLit", elems: keys, type: DYN, loc }], type: DYN, loc }, isLet, out, allowDynObject);
+                continue;
             }
             const prop = el.propertyName ?? el.name;
             const propName = ts.isIdentifier(prop) || ts.isComputedPropertyName(prop) || ts.isStringLiteralLike(prop) || ts.isNumericLiteral(prop)
@@ -2117,6 +2139,17 @@ export function lowerBindingPattern(lowerer, pattern, srcRef, srcType, isLet, ou
             lowerer.bindPatternTarget(el.name, value, isLet, out);
             continue;
         }
+        if (!fieldType && isJsSourceFile(el.getSourceFile())) {
+            // Inferred JavaScript shapes can omit optional own properties and
+            // inherit values from their prototype. Read the live checked view.
+            const loc = locOf(el);
+            let value = { kind: "dynKeyGet", value: lowerer.coerceToExpected(srcRef(), DYN),
+                key: { kind: "strLit", value: propName, type: STRING, loc }, type: DYN, loc };
+            if (el.initializer)
+                value = applyBindingDefault(lowerer, el, value);
+            lowerer.bindPatternTarget(el.name, value, isLet, out);
+            continue;
+        }
         if (!fieldType) {
             // The pattern names a field the source SHAPE does not carry —
             // `for (let {x = 1} of [{}])` (signature 08): tsc types the binding
@@ -2437,6 +2470,14 @@ function stdlibGlobalTokenDestructure(lowerer, decl, isLet) {
    * alike (the caller's bindPatternTarget recurses through the latter). */
 function applyBindingDefault(lowerer, el, value) {
     const name = el.name; // callers skip nameless elisions
+    if (value.type.kind === "dyn") {
+        const loc = value.loc;
+        const local = lowerer.declareHiddenLocal("%bindingDefault", DYN);
+        const ref = varRef(local.id, DYN, loc);
+        const result = { kind: "ternary", cond: { kind: "dynTest", test: "undefined", value: ref, type: BOOL, loc },
+            then: lowerer.lowerExprExpecting(el.initializer, DYN), else_: ref, type: DYN, loc };
+        return { kind: "seqExpr", stmts: [{ kind: "varDecl", localId: local.id, init: value, loc }], result, type: DYN, loc };
+    }
     if (value.type.kind !== "union")
         return value; // no undefined arm: dead default
     if (lowerer.armTag(value.type.unionId, UNDEFINED_T) < 0)
@@ -3537,7 +3578,7 @@ export function lowerVarDecl(lowerer, decl, isLet) {
             return null;
         }
         const raw = lowerVariableInitializer(lowerer, decl.initializer, g.type.kind === "dyn" && (isNativeBuiltinValueInitializer(lowerer, decl.initializer) ||
-            ts.isArrayLiteralExpression(decl.initializer)) ? DYN : undefined);
+            ts.isArrayLiteralExpression(decl.initializer) || ts.isObjectLiteralExpression(decl.initializer)) ? DYN : undefined);
         const arithmetic = raw.type.kind === "union"
             ? lowerer.unions.get(raw.type.unionId)?.arms
             : undefined;
@@ -3606,7 +3647,11 @@ export function lowerVarDecl(lowerer, decl, isLet) {
     // poisons, still declare the local when its type is representable, so
     // later references to this name don't produce cascading errors.
     const inferredObjectType = isJsSourceFile(decl.getSourceFile()) ? lowerer.mapTypeOf(lowerer.typeOf(decl.name)) : null;
-    const expandsObject = inferredObjectType?.kind === "record" && jsObjectBindingExpands(lowerer, decl, inferredObjectType);
+    const inferredObjectArms = inferredObjectType?.kind === "union"
+        ? lowerer.unions.get(inferredObjectType.unionId)?.arms ?? [] : inferredObjectType ? [inferredObjectType] : [];
+    const expandsObject = !decl.type && !hasJsTypeAnnotation(decl) && inferredObjectType !== null &&
+        jsOpenObjectType(decl, inferredObjectType, lowerer.shapes, lowerer.unions).kind === "dyn" ||
+        inferredObjectArms.some((arm) => arm.kind === "record" && jsObjectBindingExpands(lowerer, decl, arm));
     let init;
     try {
         init = expandsObject || (isJsSourceFile(decl.getSourceFile()) && !decl.type &&
@@ -3661,6 +3706,8 @@ export function lowerVarDecl(lowerer, decl, isLet) {
         staticImportNamespaceType(lowerer, decl.initializer) ??
         (init.type.kind === "moduleNs" ? init.type : null) ??
         (init.type.kind === "dyn" ? DYN : null);
+    if (isJsSourceFile(decl.getSourceFile()) && !decl.type && !hasJsTypeAnnotation(decl) && init.type.kind === "func")
+        type = init.type;
     if (lowerer.implicitParamTypes !== null &&
         init.type.kind === "dyn" &&
         isJsSourceFile(decl.getSourceFile()) &&
@@ -3669,10 +3716,12 @@ export function lowerVarDecl(lowerer, decl, isLet) {
     }
     const preservesObjectIdentity = init.type.kind === "dyn" &&
         (inferredObjectType?.kind === "record" || inferredObjectType?.kind === "array" ||
+            (isJsSourceFile(decl.getSourceFile()) && inferredObjectArms.some((arm) => arm.kind === "record") &&
+                inferredObjectArms.every((arm) => isUnitType(arm) || arm.kind === "record")) ||
             (isJsSourceFile(decl.getSourceFile()) && inferredObjectType !== null &&
-                (inferredObjectType.kind === "date" || inferredObjectType.kind === "func" || jsOpenObjectType(decl, inferredObjectType, lowerer.shapes, lowerer.unions).kind === "dyn")) ||
+                (inferredObjectType.kind === "date" || inferredObjectType.kind === "func" || inferredObjectType.kind === "object" || jsOpenObjectType(decl, inferredObjectType, lowerer.shapes, lowerer.unions).kind === "dyn")) ||
             (isJsSourceFile(decl.getSourceFile()) && inferredObjectType !== null &&
-                (isUnitType(inferredObjectType) || inferredObjectType.kind === "union" && lowerer.unions.get(inferredObjectType.unionId)?.arms.every(isUnitType)))) &&
+                (inferredObjectType.kind === "void" || isUnitType(inferredObjectType) || inferredObjectType.kind === "union" && lowerer.unions.get(inferredObjectType.unionId)?.arms.every(isUnitType)))) &&
         !decl.type && !hasJsTypeAnnotation(decl);
     if (expandsObject || preservesObjectIdentity || (isJsSourceFile(decl.getSourceFile()) &&
         !decl.type && isNativeBuiltinValueInitializer(lowerer, decl.initializer))) {
@@ -3694,6 +3743,10 @@ export function lowerVarDecl(lowerer, decl, isLet) {
         if (shape && shape.fields.length === 0 && !shape.indexValue && !shape.tuple)
             type = DYN;
     }
+    if (isLet && type !== null && isJsSourceFile(decl.getSourceFile()) && !decl.type && !hasJsTypeAnnotation(decl) &&
+        (type.kind === "object" || type.kind === "symbol" || jsBindingHasOpenWrites(lowerer, decl))) {
+        type = DYN;
+    }
     const returnedEmptyArrayType = npmStaticReturnedEmptyArrayType(lowerer, decl);
     if (returnedEmptyArrayType !== null) {
         type = returnedEmptyArrayType;
@@ -3799,7 +3852,7 @@ export function lowerVarDecl(lowerer, decl, isLet) {
         lowerer.badType(decl.name, lowerer.typeOf(decl.name));
     let settledType = type;
     if (!isLet && isJsSourceFile(decl.getSourceFile()) && !hasJsTypeAnnotation(decl) && decl.initializer && ts.isNewExpression(decl.initializer)) {
-        settledType = objectFactorySignature(lowerer, decl.initializer)?.returnType ?? settledType;
+        settledType = init.type.kind === "dyn" ? DYN : objectFactorySignature(lowerer, decl.initializer)?.returnType ?? settledType;
     }
     const arithmeticType = decl.initializer ? lowerer.runtimeOptionalArithmeticTypes.get(decl.initializer) : undefined;
     const isStringArithmeticUnion = (t) => {
@@ -3954,6 +4007,8 @@ function lowerVariableInitializer(lowerer, node, expected) {
         return ts.isArrayLiteralExpression(value) || ts.isConditionalExpression(value)
             ? lowerer.lowerExprExpecting(node, expected) : lowerer.lowerExpr(node);
     }
+    if (expected?.kind === "dyn")
+        return lowerDynObjectLiteral(lowerer, value);
     const previous = new Map();
     for (const property of value.properties) {
         if (!ts.isPropertyAssignment(property) || !ts.isComputedPropertyName(property.name))
@@ -3987,7 +4042,7 @@ function jsObjectBindingExpands(lowerer, decl, type) {
     let initializer = decl.initializer;
     while (ts.isParenthesizedExpression(initializer))
         initializer = initializer.expression;
-    if (!ts.isObjectLiteralExpression(initializer))
+    if (!ts.isObjectLiteralExpression(initializer) && !ts.isCallExpression(initializer))
         return false;
     if (hasJsTypeAnnotation(decl))
         return false;
@@ -4050,6 +4105,13 @@ function jsObjectBindingExpands(lowerer, decl, type) {
         }
         if (ts.isDeleteExpression(node) && property(node.expression) !== undefined)
             expands = true;
+        if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && node.expression.name.text === "setPrototypeOf" &&
+            lowerer.isStdlibGlobal(node.expression.expression, "Object")) {
+            const target = node.arguments[0];
+            const sym = target && ts.isIdentifier(target) ? lowerer.resolveValueSymbol(target) : undefined;
+            if (sym && aliases.has(sym))
+                expands = true;
+        }
         ts.forEachChild(node, visit);
     };
     visit(scope);
@@ -4059,6 +4121,30 @@ export function hasJsTypeAnnotation(decl) {
     const statement = decl.parent?.parent;
     return !!statement && /@type\b/.test(decl.getSourceFile().text.slice(statement.pos, decl.getStart()));
 }
+/** Inferred JS scalar initializers do not constrain later writes through
+ * an any-valued callback. Keep those bindings open, including captured writes. */
+export function jsBindingHasOpenWrites(lowerer, decl) {
+    if (!isJsSourceFile(decl.getSourceFile()) || decl.type || hasJsTypeAnnotation(decl) || !ts.isIdentifier(decl.name))
+        return false;
+    const symbol = lowerer.resolveValueSymbol(decl.name);
+    if (!symbol)
+        return false;
+    let owner = decl;
+    while (owner.parent && !ts.isFunctionLike(owner) && !ts.isSourceFile(owner))
+        owner = owner.parent;
+    let open = false;
+    ts.walkPreorder(owner, (node) => {
+        if (ts.isBinaryExpression(node) && node.operatorToken.kind >= ts.SyntaxKind.FirstAssignment &&
+            node.operatorToken.kind <= ts.SyntaxKind.LastAssignment && ts.isIdentifier(node.left) &&
+            lowerer.resolveValueSymbol(node.left) === symbol &&
+            (lowerer.typeOf(node.right).flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) !== 0) {
+            open = true;
+            return "stop";
+        }
+        return undefined;
+    });
+    return open;
+}
 function immediatelyGuardedAbsenceProbe(lowerer, decl) {
     if (decl.type || !ts.isIdentifier(decl.name) || !decl.initializer)
         return false;
@@ -4228,9 +4314,10 @@ function lowerBranchSwitch(lowerer, stmt, disc, labels, compare) {
    *   narrowing tests (`e instanceof C` over hierarchy classes, `typeof e
    *   === "string"/"number"/"boolean"`), reads under a proven narrow
    *   (caughtRead bridges them with caughtNarrow, trust-the-checker like
-   *   unionNarrow), and rethrow (`throw e`). Raw uses, captures, and
-   *   assignment are fenced (SC1063 and friends); destructuring patterns
-   *   are SC1062. The `: any` / `: unknown` annotations tsc admits both
+   *   unionNarrow), and rethrow (`throw e`). Unsupported raw uses and
+   *   assignments are fenced (SC1063 and friends); destructuring patterns
+   *   are SC1062. Captures retain the snapshot beyond the catch scope.
+   *   The `: any` / `: unknown` annotations tsc admits both
    *   lower the same way (tsc narrows either through the tests).
    * - `finally` runs on normal completion, exception paths, and every
    *   abrupt completion that crosses it. Return values are snapshotted
@@ -4343,6 +4430,16 @@ function lowerDeleteStatement(lowerer, expr) {
         };
     }
     let obj = lowerer.lowerExpr(target.expression);
+    if (isJsSourceFile(expr.getSourceFile()) && obj.type.kind === "object") {
+        const info = lowerer.classes.get(obj.type.className);
+        const keyType = ts.isElementAccessExpression(target) ? lowerer.typeOf(target.argumentExpression) : null;
+        const name = ts.isPropertyAccessExpression(target) ? target.name.text
+            : keyType?.isStringLiteralType() ? keyType.value : null;
+        if (info && name !== null && isClassCallback(lowerer, info, name)) {
+            obj = { kind: "call", callee: classPropertiesHelper(lowerer, loc).name,
+                args: [lowerer.coerceToExpected(obj, DYN)], type: DYN, loc };
+        }
+    }
     if (isJsSourceFile(expr.getSourceFile()) && obj.type.kind === "func" && lowerer.dynConvertible(obj.type)) {
         obj = lowerer.coerceToExpected(obj, DYN);
     }
@@ -4650,7 +4747,7 @@ function lowerCjsSingleValueExport(lowerer, expr, loc) {
         const exportSym = lowerer.checker.getSymbolAtLocation(expr.left);
         if (exportSym && !lowerer.classBySymbol.has(exportSym))
             lowerer.classBySymbol.set(exportSym, info);
-        return { kind: "block", body: [], loc };
+        return { kind: "exprStmt", expr: lowerer.lowerClassExpression(rhs), loc };
     }
     const g = lowerer.globalsByDeclNode.get(expr);
     if (!g)
@@ -5092,6 +5189,11 @@ export function lowerExprStatement(lowerer, expr) {
                     if (viaStream)
                         return viaStream;
                 }
+                if (expr.left.name.text === "lastIndex" && lowerer.mapTypeOf(lowerer.typeOf(expr.left.expression))?.kind === "regex") {
+                    const loc = locOf(expr);
+                    return { kind: "exprStmt", expr: { kind: "libCall", fn: "regex.resetLastIndex",
+                            args: [lowerer.lowerExpr(expr.left.expression), lowerer.lowerExprExpecting(expr.right, F64)], type: VOID, loc }, loc };
+                }
                 const unionWrite = lowerUnionFieldWrite(lowerer, expr.left, expr.right);
                 if (unionWrite)
                     return unionWrite;
@@ -5111,6 +5213,13 @@ export function lowerExprStatement(lowerer, expr) {
                 }
                 if (!expr.left.questionDotToken) {
                     const recv = tryLowerExpression(lowerer, expr.left.expression);
+                    if (recv?.type.kind === "object" && recv.type.className === "%Error") {
+                        const loc = locOf(expr);
+                        return { kind: "exprStmt", expr: { kind: "libCall", fn: "dyn.keySet", args: [
+                                    lowerer.coerceToExpected(recv, DYN), { kind: "strLit", value: expr.left.name.text, type: STRING, loc },
+                                    lowerer.lowerExprExpecting(expr.right, DYN),
+                                ], type: VOID, loc }, loc };
+                    }
                     if (recv && isDynTypedRefType(recv.type)) {
                         const info = lowerer.classes.get(recv.type.className);
                         if (info && !info.def.runtime && !info.builtinError && !info.builtinEmitter && !info.builtinStream &&