@scriptc/compiler 0.4.7 → 0.4.8

package/dist/frontend/lowering/expressions/element-access.js

@@ -14,8 +14,11 @@ import { fenceNodeModuleMutation, lowerRequireCacheElement } from "../lower-node
 import { lowerModuleNamespaceElement } from "../module-namespace-elements.js";
 import { stdlibGlobalNameOf } from "../surfaces.js";
 import { globalSymbolKey } from "./global-symbols.js";
+import { HOST_GLOBAL_PROTOTYPE_MEMBERS, HOST_GLOBAL_VALUE_MEMBERS, NODE_GLOBALS_WITHOUT_NATIVE, hostAbsentInstall, hostGlobalCallTarget, hostGlobalNameOfElement, hostGlobalNameOfRead, hostGlobalPrototypeOf, isGlobalObjectRead, } from "../host-globals.js";
+import { hostGlobalValue } from "../host-global-values.js";
 import { isJsSourceFile, locOf } from "../../program.js";
-import { lowerGlobalValue } from "../lower-global-value.js";
+import { MUTABLE_BUFFER_MEMBERS } from "../buffers.js";
+import { lowerGlobalObjectValue } from "../lower-global-value.js";
 import { expandoMemberRead } from "../lower-expando.js";
 import { assertedElementKeepsUndefined, compoundUnsupported, concatOperand, dynCompoundValue, hasClassPayload, lowerDynMemberAssignment, lowerOptionalArrayIndexRead, lowerOptionalNumber, assertedReadObservesUndefined, recordKeyResultOk, representedClassFieldTarget, runtimeOptionalElementKey, symbolFieldTarget, } from "../lower-exprs.js";
 import { hasRuntimeStatics } from "../class-runtime-statics.js";
@@ -36,6 +39,7 @@ import { lowerFieldCompoundValue } from "./updates.js";
 import { readsHeldEvolvingArray } from "../lower-stmts.js";
 import { indexedUnionArms, lowerIndexedUnionNumberRead, lowerIndexedUnionRead, lowerIndexedUnionWrite, } from "../indexed-unions.js";
 import { lowerBufferPrototypeMember } from "../containers/bytes.js";
+import { nullishReadTypeError, throwAfterEach } from "../primitive-throws.js";
 /** The per-arm answer for a presence probe of an element read through an
  * erased assertion (`typeof (u as R)["member"]`), or null when the read is
  * a real use or has no per-arm answer (the assertion then extracts as
@@ -65,6 +69,13 @@ function assertedProbeElementRead(lowerer, expr) {
  * string-key element access (`a["length"]`) and string indexing (`s[0]`
  * typechecks against the lib's index signature; use .charAt) stay out. */
 export function lowerElementAccess(lowerer, expr) {
+    // The bracket spelling of the mutableBuffers fact (`b["transfer"]()`,
+    // buffers.ts, t262-dc §2.4).
+    if (isJsSourceFile(ts.getSourceFileOfNode(expr))) {
+        const key = lowerer.foldedStringKeyOf(expr.argumentExpression);
+        if (key !== null && MUTABLE_BUFFER_MEMBERS.has(key))
+            lowerer.buffersMutable = true;
+    }
     if (isImportMeta(expr.expression)) {
         const name = lowerer.foldedStringKeyOf(expr.argumentExpression);
         if (name === null)
@@ -120,7 +131,66 @@ export function lowerElementAccess(lowerer, expr) {
     lowerer.fenceStaticReadableStreamMember(expr, "read");
     // Computed global reads share the stored global object's custom
     // properties. Symbol keys retain their identity-indexed store.
-    if (!expr.questionDotToken && stdlibGlobalNameOf(lowerer, expr.expression) === "globalThis") {
+    // `globalThis["WebSocket"]` is the same read as `globalThis.WebSocket`
+    // and answers the constructor Node has (host-global-values.ts); the
+    // dynamic path below answers undefined for names it does not know.
+    // Checked before the receiver test because a cast receiver
+    // (`(globalThis as T)["X"]`) is not the bare global spelling that test
+    // resolves.
+    {
+        const hostGlobal = hostGlobalNameOfElement(lowerer, expr);
+        if (hostGlobal !== null) {
+            if (hostGlobalCallTarget(expr))
+                lowerer.hostGlobalFence(hostGlobal, expr);
+            return hostGlobalValue(lowerer, hostGlobal, expr);
+        }
+    }
+    // `globalThis.WebSocket["OPEN"]`, `globalThis.FormData["prototype"]["append"]`:
+    // a member read off the value, which carries the function intrinsics only,
+    // or off its prototype, which carries the constructor link (see
+    // HOST_GLOBAL_VALUE_MEMBERS and HOST_GLOBAL_PROTOTYPE_MEMBERS).
+    {
+        const hostGlobal = hostGlobalNameOfRead(lowerer, expr.expression);
+        const key = expr.argumentExpression;
+        if (hostGlobal !== null) {
+            if (ts.isStringLiteralLike(key) && !HOST_GLOBAL_VALUE_MEMBERS.has(key.text))
+                lowerer.hostGlobalFence(hostGlobal, expr);
+        }
+        else {
+            const prototypeOf = hostGlobalPrototypeOf(lowerer, expr.expression);
+            if (prototypeOf !== null &&
+                ts.isStringLiteralLike(key) &&
+                !HOST_GLOBAL_PROTOTYPE_MEMBERS.has(key.text))
+                lowerer.hostGlobalFence(prototypeOf, expr);
+        }
+    }
+    // A computed key over the global object: the runtime answers from its own
+    // table, which cannot tell that a name is Node's. Reading a Node global the
+    // native runtime does not implement must not answer undefined, so the
+    // derived host-global set is armed before the read (host-globals.ts). A
+    // static string key never needs it (the fence above decides those), and a
+    // symbol key keeps its identity-indexed store.
+    const globalName = expr.questionDotToken ? null : stdlibGlobalNameOf(lowerer, expr.expression);
+    const plainGlobalRead = globalName === "globalThis";
+    // The alias/cast spellings (`const scope = globalThis as T`) resolve to no
+    // global name at all, which is what keeps them out of the check above.
+    const aliasGlobalRead = !plainGlobalRead &&
+        globalName === null &&
+        !expr.questionDotToken &&
+        isGlobalObjectRead(lowerer, expr.expression, undefined, globalName);
+    // A key the checker spells as one literal (a literal, an enum member, a
+    // `const` of one, a template of those — the same fold property keys take)
+    // is decided here rather than at run time, so a static key arms nothing
+    // unless it IS one of the derived globals: the fence above cannot see that
+    // one, because the key is not a string literal (`const key: "FormData" =
+    // "FormData"; globalThis[key]`). Every other static key keeps its read.
+    const foldedKey = expr.questionDotToken
+        ? null
+        : lowerer.foldedStringKeyOf(expr.argumentExpression);
+    const foldedHostGlobal = foldedKey !== null && NODE_GLOBALS_WITHOUT_NATIVE.has(foldedKey);
+    const dynamicKey = foldedKey === null &&
+        lowerer.mapTypeOf(lowerer.typeOf(expr.argumentExpression))?.kind !== "symbol";
+    if (plainGlobalRead || (aliasGlobalRead && (dynamicKey || foldedHostGlobal))) {
         const symbol = globalSymbolKey(lowerer, expr.expression, expr.argumentExpression);
         if (symbol)
             return {
@@ -140,12 +210,27 @@ export function lowerElementAccess(lowerer, expr) {
                 type: STRING,
                 loc: locOf(expr),
             };
-        return {
+        const loc = locOf(expr);
+        const read = {
             kind: "dynKeyGet",
-            value: lowerGlobalValue(lowerer, expr.expression),
+            // The receiver is the global object however this spelling reached it,
+            // so its name table is the `globalThis` one, not the read's own type.
+            value: lowerGlobalObjectValue(lowerer, expr.expression, locOf(expr.expression)),
             key: name,
             type: DYN,
-            loc: locOf(expr),
+            loc,
+        };
+        // Only a key the compiler cannot resolve, or a folded one that names a
+        // derived global, needs the runtime's set; the other static keys keep the
+        // read exactly as they had it.
+        if (!dynamicKey && !foldedHostGlobal)
+            return read;
+        return {
+            kind: "seqExpr",
+            stmts: [{ kind: "exprStmt", expr: hostAbsentInstall(loc), loc }],
+            result: read,
+            type: DYN,
+            loc,
         };
     }
     // `req.headers["x-name"]` — the computed twin of `req.headers.host`
@@ -292,6 +377,38 @@ export function lowerElementAccess(lowerer, expr) {
             const key = lowerer.lowerExprExpecting(expr.argumentExpression, DYN);
             return lowerer.maybeNarrow({ kind: "dynKeyGet", key, value: boxed, type: DYN, loc }, expr);
         }
+        if (receiver &&
+            (receiver.type.kind === "set" || receiver.type.kind === "map") &&
+            lowerer.dynConvertible(receiver.type)) {
+            // `new Set()[name]` / `m[k]` on a Set or Map instance: JavaScript
+            // reads the property the key names (size, a method object, or
+            // undefined) — never a collection entry. The checker's Set/Map type
+            // describes no such result, so the read stays checked-dynamic: the
+            // native collection boxes into the checked-dynamic tree as a handle
+            // that answers member reads (and fences a method value that has no
+            // lowering).
+            //
+            // The key keeps its VALUE for a dynamic, symbol or dyn-convertible
+            // union key: the checked-dynamic computed-key read applies
+            // ToPropertyKey itself (a symbol reads its symbol property, the
+            // well-known symbols answer as the collection's prototype does), so
+            // stringifying the key here would make `s[key]` throw on a symbol
+            // instead of reading the property JavaScript names.
+            const loc = locOf(expr);
+            const rawKey = lowerer.lowerExpr(expr.argumentExpression);
+            const key = rawKey.type.kind === "dyn" ||
+                rawKey.type.kind === "symbol" ||
+                (rawKey.type.kind === "union" && lowerer.dynConvertible(rawKey.type))
+                ? lowerer.coerceToExpected(rawKey, DYN)
+                : lowerRecordPropertyKey(lowerer, rawKey, expr.argumentExpression);
+            return lowerer.maybeNarrow({
+                kind: "dynKeyGet",
+                value: lowerer.coerceInto(expr.expression, receiver, DYN),
+                key,
+                type: DYN,
+                loc,
+            }, expr);
+        }
         if (receiver?.type.kind === "array" || receiver?.type.kind === "bytes")
             receiverIr = receiver.type;
         if (receiver?.type.kind === "union") {
@@ -363,7 +480,7 @@ export function lowerElementAccess(lowerer, expr) {
                 value: lowerer.coerceInto(expr.expression, recv, DYN),
                 key: index.type.kind === "f64"
                     ? { kind: "toString", operand: index, type: STRING, loc: locOf(expr) }
-                    : index,
+                    : lowerer.coerceToExpected(index, DYN),
                 type: DYN,
                 loc: locOf(expr),
             };
@@ -680,6 +797,18 @@ export function lowerElementAccess(lowerer, expr) {
             }
             lowerer.unsupported("SC1090", expr, "string indexing with this index/result shape (expected a number index and a string or string | undefined result)");
         }
+        // A NULLISH receiver (`(null)["k"]`): Node's RequireObjectCoercible
+        // TypeError at the read, after the key's own expression. The message
+        // needs only the key's spelling, which a runtime key cannot supply
+        // without V8's no-side-effect renderer, so that form keeps a written
+        // refusal instead of a runtime fence.
+        if (receiver && isUnitType(receiver.type)) {
+            const key = lowerer.foldedStringKeyOf(expr.argumentExpression);
+            if (key === null)
+                lowerer.unsupported("SC1090", expr, "reading a member of a nullish value with a runtime key (Node throws before it converts the key)");
+            const unit = receiver.type.kind === "nullT" ? "null" : "undefined";
+            return throwAfterEach([receiver], nullishReadTypeError(unit, key, lowerer.mapTypeOf(lowerer.typeOf(expr)) ?? F64, locOf(expr)), locOf(expr));
+        }
         lowerer.unsupported("SC1090", expr, "element access on non-array values");
     }
     let arr = lowerer.lowerExpr(expr.expression);
@@ -779,7 +908,11 @@ export function lowerElementAccess(lowerer, expr) {
         return {
             kind: "dynKeyGet",
             value: lowerer.coerceToExpected(arr, DYN),
-            key: index,
+            // A non-f64 key (a JavaScript file's `arr[true]`, an `any` index) is a
+            // dynamic key: the property read below the IR is dynamic, and the
+            // class member dispatch helpers take a dynamic key — never the bool or
+            // record value the checker typed here.
+            key: lowerer.coerceToExpected(index, DYN),
             type: DYN,
             loc: locOf(expr),
         };
@@ -1325,6 +1458,17 @@ export function lowerRecordKeyRead(lowerer, expr, shapeId, shape, includeUndefin
         const read = stmts.length === 0 ? get : { kind: "seqExpr", stmts, result: get, type: get.type, loc };
         return includeUndefined ? read : lowerer.maybeNarrow(read, expr);
     }
+    // A `keyof` read whose checker answer COLLAPSES to the checked-dynamic
+    // representation (the union of the field types carries an
+    // 'object'/'unknown'-flavored arm, so the union rule maps it to dyn):
+    // there is no typed join to dispatch into, exactly like the 'unknown'
+    // answer above, and each declared field still reads through its
+    // checked-dynamic slot. Dispatch per declared key and answer dyn.
+    if (!declared) {
+        const answer = lowerer.mapTypeOf(lowerer.typeOf(expr));
+        if (answer?.kind === "dyn" && !shape.indexValue && recordKeyResultOk(lowerer, shape, DYN))
+            declared = DYN;
+    }
     if (!declared) {
         lowerer.unsupported("SC1090", expr, `dynamic keyed reads of '${lowerer.fmt({ kind: "record", shapeId })}' (the declared fields have no one common type)`);
     }