@scriptc/compiler 0.0.21 → 0.0.23

package/dist/frontend/lowering/lower-exprs.d.ts

@@ -232,9 +232,9 @@ export declare function foldedStringKeyOf(L: Lowerer, expr: ts.Expression): stri
    * dyn's String() for dyn operands — `{ [field]: v }` where field is a
    * checked-dynamic param). Values convert through the usual dyn boundary
    * (dynFrom's domain, functions box); a value with no dyn representation
-   * fences per property. Spreads, accessors, and methods stay fenced —
-   * none co-occur with the computed-key idiom in the wild. */
-export declare function lowerDynObjectLiteral(L: Lowerer, expr: ts.ObjectLiteralExpression): IrExpr;
+   * fences per property. Spreads copy through dyn.assign in source order;
+   * accessors stay fenced. */
+export declare function lowerDynObjectLiteral(L: Lowerer, expr: ts.ObjectLiteralExpression, boxValue?: (node: ts.Expression, value: IrExpr) => IrExpr): IrExpr;
 export declare function lowerObjectLiteral(L: Lowerer, expr: ts.ObjectLiteralExpression): IrExpr;
 /** A conditional spread's carrier property: `name: value` or shorthand,
    * with an identifier/string-literal name. */

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

@@ -82,6 +82,15 @@ function lowerExprInner(L, expr) {
     const chainRecv = L.chainRecvByNode.get(expr);
     if (chainRecv)
         return { ...chainRecv, loc };
+    // --external-types supplies CHECKER truth only. A value rooted in one
+    // of those declarations has no runtime implementation in scriptc, so
+    // every use fences at its expression instead of accidentally lowering
+    // as an ambient ReferenceError or a structural value. This keeps the
+    // rest of coverage measurable without overstating the host boundary.
+    const externalTypeSpecifier = L.externalTypeSpecifierOf(expr);
+    if (externalTypeSpecifier !== null) {
+        L.externalHostFence(externalTypeSpecifier, expr);
+    }
     if (ts.isNumericLiteral(expr)) {
         const value = Number(expr.text.replace(/_/g, ""));
         // Ask 4's representability input: a DECIMAL INTEGER source spelling
@@ -1605,6 +1614,10 @@ function lowerExprInner(L, expr) {
         // The lib fence's PROPERTY chokepoint: a stdlib-declared member that
         // no lowering above claimed ([1,2].entries, Math.SQRT2, Promise.all,
         // re.exec as a value, ...) reports SC2020 here.
+        L.fenceStaticAbortControllerMemberRead(expr);
+        L.fenceStaticResponseMember(expr, "read");
+        L.fenceStaticHeadersMember(expr, "read");
+        L.fenceStaticReadableStreamMember(expr, "read");
         L.stdlibMemberFence(expr);
         // The npm chokepoint: a member on a package-typed receiver in a
         // static build — attributed to the package, like every other site.
@@ -2899,7 +2912,7 @@ export function lowerIntrinsicProperty(L, expr) {
         if (probe.type.kind === "array")
             kind = "array";
     }
-    if (kind !== "string" && kind !== "array" && kind !== "map" && kind !== "set" && kind !== "f64" && kind !== "regex" && kind !== "url" && kind !== "searchParams" && kind !== "stats" && kind !== "spawnRes" && kind !== "child" && kind !== "bytes" && kind !== "symbol") {
+    if (kind !== "string" && kind !== "array" && kind !== "map" && kind !== "set" && kind !== "f64" && kind !== "date" && kind !== "regex" && kind !== "url" && kind !== "searchParams" && kind !== "stats" && kind !== "spawnRes" && kind !== "child" && kind !== "bytes" && kind !== "symbol") {
         return null;
     }
     // child receivers also admit the user's own child-shaped interface
@@ -2994,6 +3007,20 @@ export function lowerIntrinsicProperty(L, expr) {
         }
         L.noLowering(`Stats.${name}`, expr, "isFile(), isDirectory(), and size are the supported Stats members", L.checker.getSymbolAtLocation(expr.name));
     }
+    if (kind === "date") {
+        const methods = new Set([
+            "getTime", "valueOf", "toISOString",
+            "getFullYear", "getUTCFullYear", "getMonth", "getUTCMonth",
+            "getDate", "getUTCDate", "getDay", "getUTCDay", "getHours",
+            "getUTCHours", "getMinutes", "getUTCMinutes", "getSeconds",
+            "getUTCSeconds", "getMilliseconds", "getUTCMilliseconds",
+            "getTimezoneOffset",
+        ]);
+        if (methods.has(name)) {
+            L.unsupported("SC1090", expr, `Date methods as values (call '${name}' directly)`);
+        }
+        L.noLowering(`Date.prototype.${name}`, expr, "getTime(), valueOf(), toISOString(), the local/UTC calendar getters, and getTimezoneOffset() are supported; Date setters and locale/string formatters have no lowering", L.checker.getSymbolAtLocation(expr.name));
+    }
     if (kind === "symbol") {
         const loc = locOf(expr);
         // `.description`: the checker's `string | undefined` — undefined
@@ -3360,9 +3387,11 @@ export function lowerArrayLiteral(L, expr, expected) {
             let srcNode = el.expression;
             while (ts.isParenthesizedExpression(srcNode))
                 srcNode = srcNode.expression;
-            let src = ts.isConditionalExpression(srcNode)
-                ? lowerTernary(L, srcNode, type)
-                : L.lowerExpr(el.expression);
+            L.fenceStaticHeadersIteration(el.expression);
+            let src = L.lowerDynamicHeadersSpread(el.expression, type) ??
+                (ts.isConditionalExpression(srcNode)
+                    ? lowerTernary(L, srcNode, type)
+                    : L.lowerExpr(el.expression));
             // `[...someSet]`: a same-element Set drains into a fresh array in
             // insertion order (setIntrinsic toArray); the spread machinery
             // then copies like any array source.
@@ -3639,14 +3668,39 @@ function propNameText(L, name) {
    * dyn's String() for dyn operands — `{ [field]: v }` where field is a
    * checked-dynamic param). Values convert through the usual dyn boundary
    * (dynFrom's domain, functions box); a value with no dyn representation
-   * fences per property. Spreads, accessors, and methods stay fenced —
-   * none co-occur with the computed-key idiom in the wild. */
-export function lowerDynObjectLiteral(L, expr) {
+   * fences per property. Spreads copy through dyn.assign in source order;
+   * accessors stay fenced. */
+export function lowerDynObjectLiteral(L, expr, boxValue) {
     const loc = locOf(expr);
-    const fields = [];
+    let fields = [];
+    let acc = null;
+    const flushFields = () => {
+        if (fields.length === 0)
+            return;
+        const chunk = { kind: "dynObjLit", fields, type: DYN, loc };
+        acc = acc === null
+            ? chunk
+            : { kind: "libCall", fn: "dyn.assign", args: [acc, chunk], type: DYN, loc };
+        fields = [];
+    };
     for (const prop of expr.properties) {
-        if (!ts.isPropertyAssignment(prop) && !ts.isShorthandPropertyAssignment(prop)) {
-            L.unsupported("SC1090", prop, "spreads, accessors, and methods in a runtime-keyed (computed-key) object literal");
+        if (ts.isSpreadAssignment(prop)) {
+            flushFields();
+            const raw = L.lowerExpr(prop.expression);
+            const source = boxValue
+                ? boxValue(prop.expression, raw)
+                : L.coerceToExpected(raw, DYN);
+            if (source.type.kind !== "dyn") {
+                L.unsupported("SC1101", prop.expression, `spreading '${L.fmt(source.type)}' into a checked-dynamic object literal`);
+            }
+            acc ??= { kind: "dynObjLit", fields: [], type: DYN, loc };
+            acc = { kind: "libCall", fn: "dyn.assign", args: [acc, source], type: DYN, loc: locOf(prop) };
+            continue;
+        }
+        if (!ts.isPropertyAssignment(prop) &&
+            !ts.isShorthandPropertyAssignment(prop) &&
+            !ts.isMethodDeclaration(prop)) {
+            L.unsupported("SC1090", prop, "accessors in a runtime-keyed (computed-key) object literal");
         }
         const name = prop.name;
         let key;
@@ -3675,16 +3729,23 @@ export function lowerDynObjectLiteral(L, expr) {
         else {
             L.unsupported("SC1090", prop, "non-identifier property names");
         }
-        const valueExpr = ts.isShorthandPropertyAssignment(prop) ? prop.name : prop.initializer;
+        const valueExpr = ts.isMethodDeclaration(prop)
+            ? prop
+            : ts.isShorthandPropertyAssignment(prop)
+                ? prop.name
+                : prop.initializer;
         // Lambda values that fail to lower become trap closures (the
         // per-call fence granularity — fenceClosureProbe) so the object
         // still builds; everything else keeps the per-property fence below.
         let raw;
         const propDiagsBefore = L.diags.length;
         try {
+            const lowerValue = () => ts.isMethodDeclaration(prop)
+                ? (L.rejectThisInObjectMethod(prop.body ?? prop), L.lowerLambda(prop))
+                : L.lowerExpr(valueExpr);
             raw =
-                fenceClosureProbe(L, valueExpr, undefined, () => L.lowerExpr(valueExpr)) ??
-                    L.lowerExpr(valueExpr);
+                fenceClosureProbe(L, valueExpr, undefined, lowerValue) ??
+                    lowerValue();
         }
         catch (err) {
             // A PURE member read a JS file cannot lower (a namespace object
@@ -3722,7 +3783,9 @@ export function lowerDynObjectLiteral(L, expr) {
             });
             raw = { kind: "closure", fnName, captures: [], type: funcOf([], VOID), loc: locOf(prop) };
         }
-        let v = L.coerceToExpected(raw, DYN);
+        let v = boxValue
+            ? boxValue(valueExpr, raw)
+            : L.coerceToExpected(raw, DYN);
         if (v.type.kind !== "dyn") {
             const convDiagsBefore = L.diags.length;
             try {
@@ -3768,7 +3831,8 @@ export function lowerDynObjectLiteral(L, expr) {
         }
         fields.push({ key, value: v });
     }
-    return { kind: "dynObjLit", fields, type: DYN, loc };
+    flushFields();
+    return acc ?? { kind: "dynObjLit", fields: [], type: DYN, loc };
 }
 /** Spreading a source whose shape carries accessor slots: Node's copy
  * invokes each getter exactly once in insertion order — even for keys a
@@ -5185,6 +5249,14 @@ export function lowerElementAccess(L, expr) {
         if (en)
             return en;
     }
+    // Native Web handles use the same supported surface for bracket and dot
+    // spellings. Fence a statically-known unsupported key before the generic
+    // checked-dynamic element-read path can turn it into a runtime missing
+    // member.
+    L.fenceStaticAbortControllerMemberRead(expr);
+    L.fenceStaticResponseMember(expr, "read");
+    L.fenceStaticHeadersMember(expr, "read");
+    L.fenceStaticReadableStreamMember(expr, "read");
     // `globalThis[<expr>]` — the dynamic global probe (the harness's
     // conditional-globals sweep): a compiled binary's globals are
     // compile-time bindings, not runtime properties, and none of the