@scriptc/compiler 0.4.6 → 0.4.8

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

@@ -5,16 +5,20 @@ import { constituentTypes } from "../../ts7/checker.js";
 import * as ts from "../../ts7/adapter.js";
 import { lowerOptionalIndex, splitUndefinedIndex, undefinedTypedArrayKeyFence, } from "../undefined-index.js";
 import { jsFuncNameOf, neverTaintedJsType } from "../lowerer.js";
-import { BOOL, DYN, F64, NULL_T, STRING, UNDEFINED_T, VOID, canBoxFuncIntoDyn, canDynCheckTo, isDynTypedRefType, isUnitType, shapeHasAccessorSlots, typeEquals, typeKey, unionContainerArmsOk, } from "../../../ir/ir.js";
+import { BOOL, DYN, F64, NULL_T, STRING, UNDEFINED_T, VOID, canBoxFuncIntoDyn, canDynCheckTo, isDynTypedRefType, isUnitType, recordTextCodecClass, shapeHasAccessorSlots, typeEquals, typeKey, unionContainerArmsOk, } from "../../../ir/ir.js";
 import { importMetaField, isImportMeta } from "../import-meta.js";
+import { heldEnvValueType } from "../builtins/environment.js";
 import { hasOptionalChainGuard, isOptionalChainTail } from "./optional-chains.js";
 import { lowerEnumAccess } from "../lower-enums.js";
 import { fenceNodeModuleMutation, lowerRequireCacheElement } from "../lower-node-module.js";
 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";
@@ -30,11 +34,12 @@ import { isSafeToDiscard, isSafeToRepeat } from "./evaluation-safety.js";
 import { withInheritedMethods } from "../record-inherited.js";
 import { lowerClassPrototypeComputedAssignment } from "../class-prototypes.js";
 import { isClassCallback } from "../class-callbacks.js";
-import { isKeyedFieldAccess } from "./keyed-field-targets.js";
+import { isKeyedFieldAccess, keyedFieldRead, keyedFieldWrite, sameTypedFieldKeys, } from "./keyed-field-targets.js";
 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
@@ -64,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)
@@ -119,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 {
@@ -139,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`
@@ -171,6 +257,25 @@ export function lowerElementAccess(lowerer, expr) {
         };
         return lowerer.maybeNarrow(get, expr);
     }
+    // `held[expr]` for a value HELD from process.env (`const env =
+    // process.env`): the hold aliases the live table, so the read is the same
+    // getenv the direct spelling uses.
+    {
+        const live = heldEnvValueType(lowerer, expr.expression);
+        if (live !== null) {
+            const key = lowerEnvironmentKey(lowerer, expr.argumentExpression);
+            if (key.type.kind === "string") {
+                const get = {
+                    kind: "libCall",
+                    fn: "process.envGet",
+                    args: [key],
+                    type: live,
+                    loc: locOf(expr),
+                };
+                return lowerer.maybeNarrow(get, expr);
+            }
+        }
+    }
     // Expando function members in element clothing (`foo[strMem]`,
     // `foo[_private]` where foo is a module-level function/callable const
     // and the key folds or is a unique-symbol const): the member's module
@@ -192,6 +297,25 @@ export function lowerElementAccess(lowerer, expr) {
         if (target)
             return lowerer.maybeNarrow(lowerer.fieldGetExpr(target, locOf(expr), expr), expr);
         let receiver = lowerer.lowerExpr(expr.expression);
+        // TextEncoder and TextDecoder define Symbol.toStringTag on their
+        // prototypes as the class name.
+        const codec = receiver.type.kind === "record"
+            ? recordTextCodecClass(lowerer.shapes.get(receiver.type.shapeId))
+            : null;
+        const key = expr.argumentExpression;
+        if (codec !== null &&
+            ts.isPropertyAccessExpression(key) &&
+            key.name.text === "toStringTag" &&
+            lowerer.isStdlibGlobal(key.expression, "Symbol")) {
+            const loc = locOf(expr);
+            return {
+                kind: "seqExpr",
+                stmts: [{ kind: "exprStmt", expr: receiver, loc }],
+                result: { kind: "strLit", value: codec, type: STRING, loc },
+                type: STRING,
+                loc,
+            };
+        }
         const classInfo = receiver.type.kind === "classval" ? lowerer.classes.get(receiver.type.className) : undefined;
         if (receiver.type.kind === "func" ||
             receiver.type.kind === "generator" ||
@@ -253,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") {
@@ -324,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),
             };
@@ -641,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);
@@ -740,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),
         };
@@ -1245,6 +1417,58 @@ export function lowerRecordKeyRead(lowerer, expr, shapeId, shape, includeUndefin
             (lowerer.typeOf(expr).flags & ts.TypeFlags.Any) !== 0) &&
         recordKeyResultOk(lowerer, shape, DYN))
         declared = DYN;
+    // A `keyof` read over a record that holds an 'unknown' member: the
+    // checker's answer collapses to 'unknown' (the union of every field
+    // type absorbs into it), so there is no typed join to dispatch into.
+    // Each declared field still reads through its checked-dynamic slot —
+    // the very value the checker's 'unknown' can hold — so dispatch per
+    // declared key and answer a checked-dynamic read. The key type is the
+    // record's own `keyof`, so the answer is present whenever the read is.
+    if (!declared &&
+        (lowerer.typeOf(expr).flags & ts.TypeFlags.Unknown) !== 0 &&
+        !shape.indexValue &&
+        recordKeyResultOk(lowerer, shape, DYN))
+        declared = DYN;
+    // A key whose literal type names only declared fields of one type, on a
+    // record whose other fields have other types, reads the field it names.
+    // A called access (`r[key]()`) keeps the refusal.
+    const named = !declared && litKey === null && !isCalledAccess(expr)
+        ? sameTypedFieldKeys(lowerer, shape, keyNode)
+        : null;
+    if (named) {
+        const stmts = [];
+        const settle = (value, name, force = false) => {
+            if (!force && isSafeToRepeat(value))
+                return value;
+            const temp = lowerer.declareHiddenLocal(name, value.type);
+            stmts.push({ kind: "varDecl", localId: temp.id, init: value, loc });
+            return varRef(temp.id, temp.type, loc);
+        };
+        const receiver = settle(obj, "%keyedReceiver", !isSafeToDiscard(key));
+        const target = {
+            container: "recordKeyed",
+            obj: receiver,
+            shapeId,
+            field: named.keys[0],
+            keys: named.keys,
+            key: settle(key, "%keyedKey"),
+            fieldType: named.fieldType,
+        };
+        const get = keyedFieldRead(lowerer, target, loc, true);
+        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)`);
     }
@@ -1844,8 +2068,12 @@ export function lowerElementWrite(lowerer, expr) {
         };
     }
     // `process.env[key] = v` — the computed twin of the dotted env write:
-    // setenv(3), string keys and string values only.
-    if (lowerer.isProcessEnv(target.expression) && !target.questionDotToken) {
+    // setenv(3), string keys and string values only. A key write through a
+    // value HELD from process.env takes the same path: the hold aliases the
+    // live table.
+    if (!target.questionDotToken &&
+        (lowerer.isProcessEnv(target.expression) ||
+            heldEnvValueType(lowerer, target.expression) !== null)) {
         const loc = locOf(expr);
         const key = lowerEnvironmentKey(lowerer, target.argumentExpression);
         if (key.type.kind !== "string") {
@@ -2117,6 +2345,39 @@ export function lowerElementWrite(lowerer, expr) {
                     };
                 }
             }
+            // A key whose literal type names only declared fields of one type
+            // writes the field it names. JavaScript evaluates the receiver, then
+            // the key, then the value; the dispatch reads the saved receiver and
+            // key once per named field. Locals are saved too, because the key or
+            // the value can reassign them.
+            const named = litKey === null ? sameTypedFieldKeys(lowerer, shape, target.argumentExpression) : null;
+            if (named && !shape.fields.every((f) => typeEquals(f.type, named.fieldType))) {
+                const loc = locOf(expr);
+                const body = [];
+                const save = (value, name) => {
+                    const temp = lowerer.declareHiddenLocal(name, value.type);
+                    body.push({ kind: "varDecl", localId: temp.id, init: value, loc });
+                    return varRef(temp.id, temp.type, loc);
+                };
+                const obj = save(lowerer.lowerExpr(target.expression), "%keyedReceiver");
+                const rawKey = lowerRecordPropertyKey(lowerer, lowerer.lowerExpr(target.argumentExpression), target.argumentExpression);
+                if (rawKey.type.kind !== "string") {
+                    lowerer.unsupported("SC1090", target.argumentExpression, "indexing records with non-string or non-number keys");
+                }
+                const key = save(rawKey, "%keyedKey");
+                const value = lowerer.lowerExprExpecting(expr.right, named.fieldType);
+                const keyed = {
+                    container: "recordKeyed",
+                    obj,
+                    shapeId: receiverIr.shapeId,
+                    field: named.keys[0],
+                    keys: named.keys,
+                    key,
+                    fieldType: named.fieldType,
+                };
+                body.push(keyedFieldWrite(lowerer, keyed, value, loc));
+                return { kind: "block", body, loc };
+            }
             if (!shape.indexValue) {
                 // A SIGNATURE-FREE shape whose declared fields share ONE type
                 // writes through the same per-shape dispatch (the mockable-clock