@scriptc/compiler 0.4.5 → 0.4.6

package/dist/frontend/lowering/expressions/relational.js

@@ -1,6 +1,8 @@
 /* instanceof and in, including private-name and runtime-key in. */
+import { lowerArrayClassInstanceOf } from "../builtins/array-classes.js";
 import { dateRootOf } from "../builtins/date-classes.js";
 import { keyedHelperName } from "../stable-names.js";
+import { lowerWebStreamInstanceof } from "../builtins/web-streams-dyn.js";
 import * as ts from "../../ts7/adapter.js";
 import { builtinClassInstanceOfAny, builtinClassKind } from "../builtins/builtin-class-dyn.js";
 import { checkedPrivateIn, localPrivateBrandClass, primitiveOperand, privateInMessage, } from "../private-brands.js";
@@ -9,13 +11,14 @@ import { lowerWebAssemblyInstanceof, refuseWebAssemblyUse } from "../builtins/we
 import { lowerSocketInstanceOf } from "../lower-server.js";
 import { builtinClassRefOf } from "../builtins/class-values.js";
 import { lowerZlibInstanceOf } from "../builtins/compression.js";
-import { numLit, strLit, varRef } from "../../../ir/build.js";
+import { nodeThrowExpr, numLit, strLit, varRef } from "../../../ir/build.js";
 import { lowerDisposableStackInstanceOf } from "../builtins/disposable-stack.js";
 import { lowerBlobInstanceof } from "../builtins/blob.js";
 import { lowerReadlineInstanceof } from "../builtins/readline.js";
 import { lowerKeyObjectInstanceof } from "../builtins/key-object.js";
 import { lowerCryptoKeyInstanceof } from "../builtins/webcrypto.js";
 import { lowerNetAddressInstanceof } from "../builtins/net-address.js";
+import { lowerMimeInstanceof } from "../builtins/mime.js";
 import { typedArrayHasMember } from "../builtins/typed-array-members.js";
 import { fenceEarlyNsMemberRef, nsMemberIdentOf } from "../lower-namespaces.js";
 import { maybePromiseInstanceOf } from "../maybe-promise.js";
@@ -24,6 +27,7 @@ import { storedClassValueType } from "../lower-classes.js";
 import { classInstanceOf } from "../class-dynamic-dispatch.js";
 import { InternalCompilerError } from "../../../errors.js";
 import { tryLowerExpression } from "./try-lower-expression.js";
+import { assertedInOperand } from "./asserted-receiver.js";
 import { isJsSourceFile, locOf } from "../../program.js";
 import { checkedClassInstanceOf } from "../class-construction.js";
 import { unsupportedDiag } from "../../../diagnostics/diagnostic.js";
@@ -76,6 +80,9 @@ const PRIMITIVE_WRAPPERS = ["Boolean", "Number", "String", "BigInt", "Symbol"];
  * Folding is limited to side-effect-free operands — dropping a computed
  * operand would skip its effects, so those are rejected instead. */
 export function lowerInstanceOf(lowerer, expr, loc) {
+    const arrayClassTest = lowerArrayClassInstanceOf(lowerer, expr, loc);
+    if (arrayClassTest !== null)
+        return arrayClassTest;
     const webAssembly = lowerWebAssemblyInstanceof(lowerer, expr);
     if (webAssembly !== null)
         return webAssembly;
@@ -216,6 +223,9 @@ export function lowerInstanceOf(lowerer, expr, loc) {
         const netAddress = lowerNetAddressInstanceof(lowerer, expr);
         if (netAddress)
             return netAddress;
+        const mime = lowerMimeInstanceof(lowerer, expr);
+        if (mime)
+            return mime;
         const readlineInterface = lowerReadlineInstanceof(lowerer, expr);
         if (readlineInterface)
             return readlineInterface;
@@ -348,6 +358,9 @@ export function lowerInstanceOf(lowerer, expr, loc) {
                 loc,
             };
         }
+        const webStream = lowerWebStreamInstanceof(lowerer, expr);
+        if (webStream)
+            return webStream;
         if (lowerer.isStdlibGlobal(expr.right, "ReadableStream")) {
             const value = lowerer.lowerExprExpecting(expr.left, DYN);
             return { kind: "libCall", fn: "fetch.streamIs", args: [value], type: BOOL, loc };
@@ -396,6 +409,22 @@ export function lowerInstanceOf(lowerer, expr, loc) {
                     loc,
                 };
             }
+            // Plain data (records, arrays, strings, numbers, booleans, and unions
+            // of them) is never a promise: false after the operand's evaluation.
+            const neverPromise = (t) => NEVER_PROMISE_KINDS.has(t.kind) ||
+                (t.kind === "union" && (lowerer.unions.get(t.unionId)?.arms ?? [t]).every(neverPromise));
+            if (neverPromise(left.type)) {
+                const no = { kind: "boolLit", value: false, type: BOOL, loc };
+                if (isSafeToDiscard(left))
+                    return no;
+                return {
+                    kind: "seqExpr",
+                    stmts: [{ kind: "exprStmt", expr: left, loc }],
+                    result: no,
+                    type: BOOL,
+                    loc,
+                };
+            }
             lowerer.unsupported("SC1090", expr, `'instanceof Promise' on '${lowerer.fmt(left.type)}' values (only promises, promise-armed unions, and checked-dynamic values have a lowering)`);
         }
         // `x instanceof RegExp` over a union with a regex arm (the
@@ -491,12 +520,12 @@ export function lowerInstanceOf(lowerer, expr, loc) {
             };
         }
         if (rhsClassval?.kind === "classval" && !caught) {
-            const targetInfo = lowerer.classes.get(rhsClassval.className);
+            const targetInfo = lowerer.classes.get(rhsClassval.className) ??
+                lowerer.flushDeferredClass(rhsClassval.className);
             if (!targetInfo) {
                 // The type world names a class the lowering never registered
-                // (a fenced class expression, a deferred declaration): flush
-                // its diagnostics and poison the test site, never an ICE.
-                lowerer.flushDeferredClass(rhsClassval.className);
+                // (a fenced class expression, a deferred declaration): its
+                // diagnostics flushed above; poison the test site, never an ICE.
                 lowerer.unsupported("SC1090", expr, "'instanceof' against a class value whose class has no lowering (the class declaration itself was rejected — see its own diagnostic)");
             }
             const left = lowerer.lowerExpr(expr.left);
@@ -730,9 +759,10 @@ export function lowerInstanceOf(lowerer, expr, loc) {
     if (left.type.kind === "union") {
         const unionId = left.type.unionId;
         const arms = lowerer.unions.get(unionId)?.arms;
-        // Ordinary records, arrays and scalar values do not carry a class
-        // prototype (no program class extends Array). Dynamic/opaque runtime
-        // objects keep their existing instanceof fences.
+        // Records, arrays and scalar values are no instances of a class that
+        // does not extend Array (lowerArrayClassInstanceOf tests the classes
+        // that do). Dynamic/opaque runtime objects keep their existing
+        // instanceof fences.
         if (arms?.every((arm) => arm.kind === "object" ||
             arm.kind === "record" ||
             arm.kind === "array" ||
@@ -1460,7 +1490,11 @@ export function lowerInExpression(lowerer, expr, loc) {
                 return probed;
         }
     }
-    let recv = lowerer.lowerExpr(expr.right);
+    // `"stream" in (stored as R)` probes the value actually stored (Node
+    // erases the assertion): a union of fixed record shapes answers per arm
+    // below, so the assertion's checked extraction must not run first (it
+    // would trap on the very arm the probe exists to detect).
+    let recv = assertedInOperand(lowerer, expr.right) ?? lowerer.lowerExpr(expr.right);
     const classInfo = recv.type.kind === "classval" ? lowerer.classes.get(recv.type.className) : undefined;
     if ((classInfo && (classInfo.callableBase || hasRuntimeStatics(classInfo))) ||
         (isJsSourceFile(ts.getSourceFileOfNode(expr)) &&
@@ -1628,8 +1662,18 @@ export function lowerInExpression(lowerer, expr, loc) {
         let staticAnswers = arms.length > 0;
         for (const arm of arms) {
             const tag = lowerer.armTag(unionId, arm);
+            if (tag < 0) {
+                staticAnswers = false;
+                break;
+            }
+            // A unit arm answers Node's TypeError (`'k' in undefined`): only an
+            // erased assertion over an optional value still carries one.
+            if (isUnitType(arm)) {
+                answers.push({ tag, has: "unit", arm });
+                continue;
+            }
             const shape = arm.kind === "record" ? lowerer.shapes.get(arm.shapeId) : undefined;
-            if (tag < 0 || !shape || shape.tuple || shape.indexValue) {
+            if (!shape || shape.tuple) {
                 staticAnswers = false;
                 break;
             }
@@ -1646,22 +1690,30 @@ export function lowerInExpression(lowerer, expr, loc) {
             // true without invoking the getter) — either slot present makes
             // the name a member.
             const acc = shape.fields.some((x) => x.name === `%get:${key}` || x.name === `%set:${key}`);
-            answers.push({ tag, has: f !== undefined || acc || inherited, arm });
+            if (f !== undefined || acc || !shape.indexValue) {
+                answers.push({ tag, has: f !== undefined || acc || inherited, arm });
+                continue;
+            }
+            // An index-signature arm answers the overflow map's own key (a
+            // stored undefined is present), or the prototype's name.
+            answers.push({ tag, has: "keyed", arm });
         }
-        if (staticAnswers && answers.some((a) => a.has === "slot")) {
+        if (staticAnswers &&
+            answers.some((a) => a.has === "slot" || a.has === "unit" || a.has === "keyed")) {
             return perValueUnionIn(lowerer, recv, unionId, key, answers, loc);
         }
         if (staticAnswers) {
-            const pureRecv = recv.kind === "varRef" ||
-                recv.kind === "recordGet" ||
-                recv.kind === "fieldGet" ||
-                pureRecvNode;
+            // A field read is pure only over a pure object: the stored value of
+            // an asserted receiver (`"k" in (make().stored as R)`) still
+            // evaluates its call.
+            const pureRecv = isSafeToRepeat(recv) || pureRecvNode;
+            let value = recv;
             const isTag = (tag, negated) => ({
                 kind: "unionIsTag",
                 unionId,
                 tag,
                 negated,
-                value: recv,
+                value,
                 type: BOOL,
                 loc,
             });
@@ -1690,23 +1742,31 @@ export function lowerInExpression(lowerer, expr, loc) {
             const falses = answers.filter((a) => !a.has);
             if (falses.length === 1)
                 return isTag(falses[0].tag, true);
-            // Several arms on each side: the OR chain re-reads the receiver,
-            // so only side-effect-free reads qualify.
-            if (pureRecv) {
-                let out = isTag(trues[0].tag, false);
-                for (const t of trues.slice(1)) {
-                    out = {
-                        kind: "logical",
-                        op: "||",
-                        left: out,
-                        right: isTag(t.tag, false),
-                        type: BOOL,
-                        loc,
-                    };
-                }
-                return out;
+            // Several arms on each side: the OR chain re-reads the receiver, so
+            // anything but a pure read is evaluated once into a hidden local.
+            const stable = pureRecv ? null : lowerer.declareHiddenLocal("%inRecv", recv.type);
+            if (stable)
+                value = varRef(stable.id, recv.type, loc);
+            let out = isTag(trues[0].tag, false);
+            for (const t of trues.slice(1)) {
+                out = {
+                    kind: "logical",
+                    op: "||",
+                    left: out,
+                    right: isTag(t.tag, false),
+                    type: BOOL,
+                    loc,
+                };
             }
-            lowerer.unsupported("SC1090", expr, "statically-decided 'in' on computed receivers (bind the value to a variable first)");
+            if (!stable)
+                return out;
+            return {
+                kind: "seqExpr",
+                stmts: [{ kind: "varDecl", localId: stable.id, init: recv, loc }],
+                result: out,
+                type: BOOL,
+                loc,
+            };
         }
     }
     // A literal member name over a typed array (`"BYTES_PER_ELEMENT" in a`):
@@ -1766,51 +1826,52 @@ export function lowerInExpression(lowerer, expr, loc) {
             return lowerer.recordFieldPresent(recv, recv.type.shapeId, key, loc);
         }
         // A declared non-optional field always exists on every value of the
-        // shape — statically true, but folding may only drop a
-        // side-effect-free receiver read.
-        if (recv.kind === "varRef" ||
-            recv.kind === "recordGet" ||
-            recv.kind === "fieldGet" ||
-            pureRecvNode) {
-            return { kind: "boolLit", value: true, type: BOOL, loc };
-        }
-        lowerer.unsupported("SC1090", expr, "statically-decided 'in' on computed receivers (bind the value to a variable first)");
+        // shape — statically true, but a calling receiver (`"k" in make().api`)
+        // must still run exactly once.
+        return staticAnswerAfter(recv, true, loc);
     }
     // Accessor properties answer `in` as own members (Node: true, getter
-    // NOT invoked) — statically true under the same purity discipline as
-    // declared non-optional fields.
+    // NOT invoked) — statically true, with the receiver evaluated once.
     if (shape.fields.some((f) => f.name === `%get:${key}` || f.name === `%set:${key}`)) {
-        if (recv.kind === "varRef" ||
-            recv.kind === "recordGet" ||
-            recv.kind === "fieldGet" ||
-            pureRecvNode) {
-            return { kind: "boolLit", value: true, type: BOOL, loc };
-        }
-        lowerer.unsupported("SC1090", expr, "statically-decided 'in' on computed receivers (bind the value to a variable first)");
+        return staticAnswerAfter(recv, true, loc);
     }
     // Records are ordinary objects: Object.prototype's members are in them.
     const inherited = OBJECT_PROTOTYPE_KEYS.has(key);
     if (shape.indexValue && !inherited) {
         lowerer.unsupported("SC1090", expr, "'in' over index-signature keys (read the key and test '!== undefined' instead)");
     }
-    if (recv.kind === "varRef" ||
-        recv.kind === "recordGet" ||
-        recv.kind === "fieldGet" ||
-        pureRecvNode) {
-        // A null-prototype record (Object.groupBy) has no inherited names.
-        const nullProtoT = inherited ? nullProtoRecordShape(lowerer, recv.type) : null;
-        if (nullProtoT) {
-            return {
-                kind: "unary",
-                op: "!",
-                operand: recordNullProtoTest(recv, nullProtoT.shapeId, loc),
-                type: BOOL,
-                loc,
-            };
-        }
-        return { kind: "boolLit", value: inherited, type: BOOL, loc };
+    // A null-prototype record (Object.groupBy) has no inherited names.
+    const nullProtoT = inherited ? nullProtoRecordShape(lowerer, recv.type) : null;
+    if (nullProtoT) {
+        // The answer reads the receiver itself, so it already evaluates it
+        // exactly once; wrapping it in a discard statement would run an
+        // effectful receiver (a call result) twice.
+        return {
+            kind: "unary",
+            op: "!",
+            operand: recordNullProtoTest(recv, nullProtoT.shapeId, loc),
+            type: BOOL,
+            loc,
+        };
     }
-    lowerer.unsupported("SC1090", expr, "statically-decided 'in' on computed receivers (bind the value to a variable first)");
+    return staticAnswerAfter(recv, inherited, loc);
+}
+/** A statically-decided `in` answer: a side-effect-free receiver folds away,
+ * while any other receiver (a call result, an effectful read) is still
+ * evaluated exactly once for its effects. */
+function staticAnswerAfter(recv, answer, loc) {
+    return staticAnswerAfterWith(recv, { kind: "boolLit", value: answer, type: BOOL, loc }, loc);
+}
+function staticAnswerAfterWith(recv, result, loc) {
+    if (isSafeToDiscard(recv))
+        return result;
+    return {
+        kind: "seqExpr",
+        stmts: [{ kind: "exprStmt", expr: recv, loc }],
+        result,
+        type: BOOL,
+        loc,
+    };
 }
 /** `"k" in u` over a union of fixed record shapes where some arm declares
  * `k` as an optional slot. Arms without the name answer false and arms
@@ -1834,8 +1895,9 @@ function perValueUnionIn(lowerer, recv, unionId, key, answers, loc) {
         loc,
     });
     let out = null;
+    const inherited = OBJECT_PROTOTYPE_KEYS.has(key);
     for (const a of answers) {
-        if (a.has === false)
+        if (a.has === false || a.has === "unit")
             continue;
         let test = isTag(a.tag);
         if (a.has === "slot" && a.arm.kind === "record") {
@@ -1862,9 +1924,63 @@ function perValueUnionIn(lowerer, recv, unionId, key, answers, loc) {
                 loc,
             };
         }
+        if (a.has === "keyed" && a.arm.kind === "record") {
+            const narrowed = {
+                kind: "unionNarrow",
+                unionId,
+                tag: a.tag,
+                value: ref(),
+                type: a.arm,
+                loc,
+            };
+            // An inherited name answers the prototype (a null-prototype record
+            // has none); any other key is an own key of the overflow map.
+            const nullProtoT = inherited ? nullProtoRecordShape(lowerer, a.arm) : null;
+            const presence = nullProtoT
+                ? {
+                    kind: "unary",
+                    op: "!",
+                    operand: recordNullProtoTest(narrowed, a.arm.shapeId, loc),
+                    type: BOOL,
+                    loc,
+                }
+                : inherited
+                    ? { kind: "boolLit", value: true, type: BOOL, loc }
+                    : {
+                        kind: "recordOvfHas",
+                        obj: narrowed,
+                        shapeId: a.arm.shapeId,
+                        key: { kind: "strLit", value: key, type: STRING, loc },
+                        type: BOOL,
+                        loc,
+                    };
+            test = {
+                kind: "logical",
+                op: "&&",
+                left: test,
+                right: presence,
+                type: BOOL,
+                loc,
+            };
+        }
         out = out ? { kind: "logical", op: "||", left: out, right: test, type: BOOL, loc } : test;
     }
-    const result = out ?? { kind: "boolLit", value: false, type: BOOL, loc };
+    let result = out ?? { kind: "boolLit", value: false, type: BOOL, loc };
+    // A unit arm throws Node's TypeError (`'k' in undefined`); the tests are
+    // disjoint by tag, so the order among them does not matter.
+    for (const a of answers) {
+        if (a.has !== "unit")
+            continue;
+        const unit = a.arm.kind === "nullT" ? "null" : "undefined";
+        result = {
+            kind: "ternary",
+            cond: isTag(a.tag),
+            then: nodeThrowExpr(1, "", `Cannot use 'in' operator to search for '${key}' in ${unit}`, BOOL, loc),
+            else_: result,
+            type: BOOL,
+            loc,
+        };
+    }
     if (!stable)
         return result;
     return {
@@ -2023,4 +2139,20 @@ function nodeDeclaredMember(lowerer, t, key) {
             prop.declarations.every((d) => ts.getSourceFileOfNode(d).isDeclarationFile));
     });
 }
+const NEVER_PROMISE_KINDS = new Set([
+    "record",
+    "array",
+    "string",
+    "f64",
+    "bool",
+    "bigint",
+    "date",
+    "map",
+    "set",
+    "regex",
+    "bytes",
+    "symbol",
+    "nullT",
+    "undefinedT",
+]);
 //# sourceMappingURL=relational.js.map