@scriptc/compiler 0.4.6 → 0.4.8

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

@@ -1,4 +1,6 @@
 /* instanceof and in, including private-name and runtime-key in. */
+import { lowerIteratorInstanceOf } from "../iterator-prototype.js";
+import { programCreatesWrappers, WRAPPER_KIND_NUMBER } from "../primitive-wrappers.js";
 import { lowerArrayClassInstanceOf } from "../builtins/array-classes.js";
 import { dateRootOf } from "../builtins/date-classes.js";
 import { keyedHelperName } from "../stable-names.js";
@@ -22,8 +24,11 @@ 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";
+import { lowerGlobalObjectValue } from "../lower-global-value.js";
 import { isSafeToDiscard, isSafeToRepeat } from "./evaluation-safety.js";
-import { storedClassValueType } from "../lower-classes.js";
+import { inOperatorTypeError, isBuiltinIdentityToken, isPrimitiveValueType, throwAfterEach, } from "../primitive-throws.js";
+import { partialFieldPresence } from "../partial-assertions.js";
+import { classDeclaresHasInstanceHook, storedClassValueType, } from "../lower-classes.js";
 import { classInstanceOf } from "../class-dynamic-dispatch.js";
 import { InternalCompilerError } from "../../../errors.js";
 import { tryLowerExpression } from "./try-lower-expression.js";
@@ -32,12 +37,17 @@ import { isJsSourceFile, locOf } from "../../program.js";
 import { checkedClassInstanceOf } from "../class-construction.js";
 import { unsupportedDiag } from "../../../diagnostics/diagnostic.js";
 import { globalSymbolKey } from "./global-symbols.js";
+import { hostAbsentInstall, isGlobalObjectRead, NODE_GLOBALS_WITHOUT_NATIVE, } from "../host-globals.js";
+import { hasGlobalFunctionValue } from "../global-function-values.js";
 import { builtinGlobalHasKey } from "../builtins/global-namespace-keys.js";
 import { foldedStringKeyOf } from "./object-literals.js";
-import { NARROW_FIRST, sideEffectFreeOptionValue } from "../surfaces.js";
+import { NARROW_FIRST, sideEffectFreeOptionValue, stdlibGlobalNameOf } from "../surfaces.js";
 import { isExecExceptionType, refuseExecExceptionCode } from "../builtins/errors.js";
 import { hasRuntimeStatics } from "../class-runtime-statics.js";
 import { nullProtoRecordShape, recordNullProtoTest } from "../null-prototype.js";
+import { recordMayKeepSource } from "../record-sources.js";
+import { recordHasOwnHelper } from "../lower-calls.js";
+import { hostGlobalConstructorOfPrototype, hostGlobalNameOfRead } from "../host-globals.js";
 /** The class value an `instanceof` right-hand side holds. A JavaScript
  * object's property holding a program class (`holder.type`) reads as a
  * checked-dynamic value that the checker types as the class: it converts
@@ -70,6 +80,19 @@ const NO_CLASS_INSTANCE_KINDS = new Set([
     "nullT",
 ]);
 const PRIMITIVE_WRAPPERS = ["Boolean", "Number", "String", "BigInt", "Symbol"];
+/** The known answer of an `instanceof` test on a listed Node global's value,
+ * after the left operand's evaluation (kept for its effects, as Node runs
+ * it before the test). */
+function hostGlobalInstanceOfAnswer(lowerer, expr, answer, loc) {
+    const value = lowerer.coerceInto(expr.left, lowerer.lowerExpr(expr.left), DYN);
+    return {
+        kind: "seqExpr",
+        stmts: [{ kind: "exprStmt", expr: value, loc }],
+        result: { kind: "boolLit", value: answer, type: BOOL, loc },
+        type: BOOL,
+        loc,
+    };
+}
 /** `x instanceof C` for a program-declared class C. When x's static
  * class and C are both in extends-hierarchies the test is dynamic — the
  * O(1) preorder-interval check against the vtable (`instanceOf` node).
@@ -80,6 +103,25 @@ 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 iteratorTest = lowerIteratorInstanceOf(lowerer, expr, loc);
+    if (iteratorTest !== null)
+        return iteratorTest;
+    // A listed Node global's value is a constructor native code never created
+    // an instance from, so `x instanceof X` is false for every value — an
+    // ordinary function's [[Prototype]] included, which the generic walk
+    // cannot read and would throw its unsupported-getPrototypeOf error for.
+    // The value is itself a Function instance, as Node's class is; the
+    // runtime's generic walk stops at the object that terminates the value's
+    // prototype chain, so that one answer is folded here too. The operand
+    // still runs, as Node evaluates it before the test.
+    if (hostGlobalNameOfRead(lowerer, expr.right) !== null)
+        return hostGlobalInstanceOfAnswer(lowerer, expr, false, loc);
+    if (lowerer.isStdlibGlobal(expr.right, "Function")) {
+        const value = hostGlobalNameOfRead(lowerer, expr.left) ??
+            hostGlobalConstructorOfPrototype(lowerer, expr.left);
+        if (value !== null)
+            return hostGlobalInstanceOfAnswer(lowerer, expr, true, loc);
+    }
     const arrayClassTest = lowerArrayClassInstanceOf(lowerer, expr, loc);
     if (arrayClassTest !== null)
         return arrayClassTest;
@@ -171,6 +213,19 @@ export function lowerInstanceOf(lowerer, expr, loc) {
     // (typebox's IsBoolean/IsNumber/IsString guards). The operand still runs.
     if (PRIMITIVE_WRAPPERS.some((name) => lowerer.isStdlibGlobal(expr.right, name))) {
         const value = lowerer.lowerExpr(expr.left);
+        // In a program that creates wrappers, a checked-dynamic value may be
+        // one: the kind's prototype on its chain decides.
+        const wrapperKind = ["String", "Number", "Boolean"].find((name) => lowerer.isStdlibGlobal(expr.right, name));
+        if (wrapperKind &&
+            value.type.kind === "dyn" &&
+            (lowerer.createsWrappers ??= programCreatesWrappers(lowerer)))
+            return {
+                kind: "libCall",
+                fn: "wrapper.instanceOf",
+                args: [value, { kind: "numLit", value: WRAPPER_KIND_NUMBER[wrapperKind], type: F64, loc }],
+                type: BOOL,
+                loc,
+            };
         return {
             kind: "seqExpr",
             stmts: [{ kind: "exprStmt", expr: value, loc }],
@@ -480,6 +535,12 @@ export function lowerInstanceOf(lowerer, expr, loc) {
             : undefined;
         if (caught && caughtTarget && !caughtTarget.localClass && !caughtTarget.def.runtime) {
             const classValue = lowerer.lowerExpr(expr.right);
+            // A class that declares a static `Symbol.hasInstance` hook answers
+            // through the hook: the caught payload reaches it as a checked-dynamic
+            // value, exactly as a thrown value reaches Node's hook.
+            if (classDeclaresHasInstanceHook(caughtTarget)) {
+                return checkedClassInstanceOf(lowerer, { kind: "caughtToDyn", value: varRef(caught.id, CAUGHT, loc), type: DYN, loc }, lowerer.coerceToExpected(classValue, DYN), dynInstanceOfRefusal(lowerer, expr), loc);
+            }
             if (caughtTarget.subclasses.length === 0) {
                 return {
                     kind: "seqExpr",
@@ -529,6 +590,14 @@ export function lowerInstanceOf(lowerer, expr, loc) {
                 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);
+            // The class declares a static `Symbol.hasInstance` hook (its bases
+            // included, through the static prototype chain): Node asks the hook
+            // first and uses OrdinaryHasInstance only when it is absent, so the
+            // test runs the checked-dynamic class test against the class value.
+            if (!targetInfo.def.runtime && classDeclaresHasInstanceHook(targetInfo)) {
+                const classValue = classValueOperand(lowerer, expr.right, rhsClassval);
+                return checkedClassInstanceOf(lowerer, lowerer.coerceInto(expr.left, left, DYN), lowerer.coerceToExpected(classValue, DYN), dynInstanceOfRefusal(lowerer, expr), loc);
+            }
             if (left.type.kind === "dyn") {
                 // An untyped binding the checker narrowed to EventEmitter or a
                 // stream class (`ReleaseEmitter = EventEmitter` in JavaScript):
@@ -544,6 +613,13 @@ export function lowerInstanceOf(lowerer, expr, loc) {
                     lowerer.unsupported("SC1090", expr, "'instanceof' through a runtime-provided class value on an untyped value (give the operand a class type first)");
                 }
                 const classValue = classValueOperand(lowerer, expr.right, rhsClassval);
+                // A checked-dynamic class value (`for (const C of [A, B])`: tsc's
+                // common supertype names the first class, but the slot holds either
+                // class at run time): the test dispatches on the class the value IS,
+                // like any other untyped right-hand side. Using the statically named
+                // class's prototype here answered false for every other class.
+                if (classValue.type.kind === "dyn")
+                    return checkedClassInstanceOf(lowerer, left, classValue, dynInstanceOfRefusal(lowerer, expr), loc);
                 return classInstanceOf(lowerer, left, targetInfo, loc, classValue);
             }
             // A union of class instances against a runtime class value (`new K()`
@@ -600,7 +676,28 @@ export function lowerInstanceOf(lowerer, expr, loc) {
                     loc,
                 });
             }
-            lowerer.unsupported("SC1090", expr, "statically-decided 'instanceof' on computed operands (bind the values to variables first)");
+            // The answer is static (a standalone operand's runtime class IS its
+            // static class), but the operands are computed: Node evaluates both,
+            // so evaluate them and return the known answer.
+            const classValue = classValueOperand(lowerer, expr.right, rhsClassval);
+            return {
+                kind: "seqExpr",
+                stmts: [
+                    { kind: "exprStmt", expr: left, loc },
+                    { kind: "exprStmt", expr: classValue, loc },
+                ],
+                result: { kind: "boolLit", value, type: BOOL, loc },
+                type: BOOL,
+                loc,
+            };
+        }
+        // A builtin global function value read off the global (`parseInt`,
+        // `Symbol`, `WeakRef`, ...) is not a class value: the boxed value has
+        // no prototype to test against, so the test keeps the refusal the
+        // global's identity token answered.
+        if (isJsSourceFile(ts.getSourceFileOfNode(expr)) &&
+            hasGlobalFunctionValue(stdlibGlobalNameOf(lowerer, expr.right) ?? "")) {
+            lowerer.unsupported("SC1090", expr.right, "'instanceof' right-hand sides other than classes declared in the program");
         }
         // A checked-dynamic right-hand side (a constructor read from a table, a
         // structural constructor type, a builtin constructor held as `any`):
@@ -650,6 +747,17 @@ export function lowerInstanceOf(lowerer, expr, loc) {
     // narrowing then types the branches; reads bridge through caughtRead.
     const caughtLocal = lowerer.caughtLocalOf(expr.left);
     if (caughtLocal) {
+        // A class that declares a static `Symbol.hasInstance` hook answers
+        // through the hook whatever the operand's static type: the caught
+        // payload reaches it as a checked-dynamic value, exactly as a thrown
+        // value reaches Node's hook.
+        if (!target.def.runtime && classDeclaresHasInstanceHook(target)) {
+            const classValue = classValueOperand(lowerer, expr.right, {
+                kind: "classval",
+                className: target.def.name,
+            });
+            return checkedClassInstanceOf(lowerer, { kind: "caughtToDyn", value: varRef(caughtLocal.id, CAUGHT, loc), type: DYN, loc }, lowerer.coerceToExpected(classValue, DYN), dynInstanceOfRefusal(lowerer, expr), loc);
+        }
         const caughtInstanceOf = (info) => caughtClassInstanceOf(lowerer, caughtLocal.id, info, loc);
         let test = caughtInstanceOf(target);
         // A thrown checked-dynamic object whose prototype chain reaches
@@ -683,6 +791,18 @@ export function lowerInstanceOf(lowerer, expr, loc) {
             : test;
     }
     const left = lowerer.lowerExpr(expr.left);
+    // A program class that declares a static `Symbol.hasInstance` hook (its
+    // bases included, through the static prototype chain): Node asks the
+    // hook first and uses OrdinaryHasInstance only when it is absent, so the
+    // test runs the checked-dynamic class test against the class value,
+    // whatever the operand's static type is.
+    if (!target.def.runtime && classDeclaresHasInstanceHook(target)) {
+        const classValue = classValueOperand(lowerer, expr.right, {
+            kind: "classval",
+            className: target.def.name,
+        });
+        return checkedClassInstanceOf(lowerer, lowerer.coerceInto(expr.left, left, DYN), lowerer.coerceToExpected(classValue, DYN), dynInstanceOfRefusal(lowerer, expr), loc);
+    }
     // `u instanceof Error` on an `unknown` value: the checked-dynamic tree's error encoding
     // (the shape caughtToDyn builds for Error payloads — the reserved
     // "%error" marker) answers the test, so a caught Error passed through
@@ -890,6 +1010,25 @@ export function lowerInstanceOf(lowerer, expr, loc) {
             loc,
         });
     }
+    // A program class target: the answer is static (the operand's runtime
+    // class IS its static class), but the operands are computed. Node
+    // evaluates both, so evaluate them and return the known answer.
+    if (target.decl !== null && !target.def.runtime) {
+        const classValue = classValueOperand(lowerer, expr.right, {
+            kind: "classval",
+            className: target.def.name,
+        });
+        return {
+            kind: "seqExpr",
+            stmts: [
+                { kind: "exprStmt", expr: left, loc },
+                { kind: "exprStmt", expr: classValue, loc },
+            ],
+            result: { kind: "boolLit", value, type: BOOL, loc },
+            type: BOOL,
+            loc,
+        };
+    }
     lowerer.unsupported("SC1090", expr, "statically-decided 'instanceof' on computed operands (bind the value to a variable first)");
 }
 /** `x instanceof K` for a union-typed operand whose arms are class
@@ -1331,6 +1470,84 @@ export function lowerInExpression(lowerer, expr, loc) {
     if (ts.isPrivateIdentifier(expr.left)) {
         return lowerPrivateIn(lowerer, expr, expr.left, loc);
     }
+    // `… in <global object>`: presence on the runtime's global object. Node HAS
+    // the globals the native runtime does not implement, so the answer must not
+    // be a silent false — arming the compiler's derived set makes the runtime
+    // throw for them (host-globals.ts) and answer the global object's own
+    // presence otherwise. A symbol key keeps its checked-dynamic path below;
+    // this answer is keyed by a string.
+    const inGlobalKey = foldedStringKeyOf(lowerer, expr.left);
+    if (isGlobalObjectRead(lowerer, expr.right) &&
+        lowerer.mapTypeOf(lowerer.typeOf(expr.left))?.kind !== "symbol" &&
+        // A static key the runtime already answers correctly (a name Node does
+        // not define) keeps its existing lowering, byte for byte.
+        (inGlobalKey === null || NODE_GLOBALS_WITHOUT_NATIVE.has(inGlobalKey))) {
+        const installedHas = (key) => ({
+            kind: "seqExpr",
+            stmts: [{ kind: "exprStmt", expr: hostAbsentInstall(loc), loc }],
+            result: { kind: "libCall", fn: "dyn.globalHas", args: [key], type: BOOL, loc },
+            type: BOOL,
+            loc,
+        });
+        if (inGlobalKey !== null)
+            return installedHas({ kind: "strLit", value: inGlobalKey, type: STRING, loc });
+        // JS evaluates the key before the receiver; the receiver is the global
+        // object, whose evaluation has no effects, so lowering the key first is
+        // the whole evaluation order.
+        const lowered = lowerer.lowerExpr(expr.left);
+        if (lowered.type.kind === "string")
+            return installedHas(lowered);
+        // A key the type cannot prove to be a string may hold a symbol at
+        // runtime, and a symbol is an identity, not a name: it must reach the
+        // global object's symbol store rather than the string conversion (which
+        // throws for a symbol). The boxed key is stabilized first; the answer is
+        // the same presence query the dynamic path gives.
+        const keyLocal = lowerer.declareHiddenLocal("%inKey", DYN);
+        const boxedKey = varRef(keyLocal.id, DYN, loc);
+        return {
+            kind: "seqExpr",
+            stmts: [
+                { kind: "exprStmt", expr: hostAbsentInstall(loc), loc },
+                {
+                    kind: "varDecl",
+                    localId: keyLocal.id,
+                    init: lowerer.coerceInto(expr.left, lowered, DYN),
+                    loc,
+                },
+            ],
+            result: {
+                kind: "ternary",
+                cond: {
+                    kind: "strEq",
+                    negated: false,
+                    left: { kind: "libCall", fn: "dyn.typeof", args: [boxedKey], type: STRING, loc },
+                    right: { kind: "strLit", value: "symbol", type: STRING, loc },
+                    type: BOOL,
+                    loc,
+                },
+                then: {
+                    kind: "libCall",
+                    fn: "dyn.hasKeyComputed",
+                    args: [lowerGlobalObjectValue(lowerer, expr.right, locOf(expr.right)), boxedKey],
+                    type: BOOL,
+                    loc,
+                },
+                else_: {
+                    kind: "libCall",
+                    fn: "dyn.globalHas",
+                    args: [
+                        { kind: "libCall", fn: "dyn.toStringCoerce", args: [boxedKey], type: STRING, loc },
+                    ],
+                    type: BOOL,
+                    loc,
+                },
+                type: BOOL,
+                loc,
+            },
+            type: BOOL,
+            loc,
+        };
+    }
     // Compile-time-known STRING keys fold — literals, and the same
     // const/enum-literal and template folding computed property keys get
     // (foldedStringKeyOf); runtime-valued keys keep the fence.
@@ -1495,6 +1712,25 @@ export function lowerInExpression(lowerer, expr, loc) {
     // 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);
+    // A PRIMITIVE receiver: JavaScript's ToObject step throws Node's TypeError
+    // for every primitive (`'x' in 5` included), and the throw precedes the
+    // key's ToPropertyKey — the key is a compile-time literal on every path
+    // that reaches here, so only the receiver's own evaluation remains. The
+    // message spells the receiver's value, so a receiver the IR cannot
+    // re-evaluate (`receiver()`) evaluates once into a hidden local.
+    if (isPrimitiveValueType(recv.type) && !isBuiltinIdentityToken(lowerer, expr.right, recv)) {
+        if (isUnitType(recv.type) || isSafeToRepeat(recv)) {
+            return throwAfterEach([recv], inOperatorTypeError(lowerer, key, recv, BOOL, loc), loc);
+        }
+        const slot = lowerer.declareHiddenLocal("%inReceiver", recv.type);
+        return {
+            kind: "seqExpr",
+            stmts: [{ kind: "varDecl", localId: slot.id, init: recv, loc }],
+            result: inOperatorTypeError(lowerer, key, varRef(slot.id, recv.type, loc), BOOL, loc),
+            type: BOOL,
+            loc,
+        };
+    }
     const classInfo = recv.type.kind === "classval" ? lowerer.classes.get(recv.type.className) : undefined;
     if ((classInfo && (classInfo.callableBase || hasRuntimeStatics(classInfo))) ||
         (isJsSourceFile(ts.getSourceFileOfNode(expr)) &&
@@ -1818,6 +2054,14 @@ export function lowerInExpression(lowerer, expr, loc) {
         throw new InternalCompilerError(`lowerer bug: unknown shape ${recv.type.shapeId}`);
     const field = shape.fields.find((f) => f.name === key);
     if (field) {
+        // A field some partial record assertion leaves unwritten (a partial
+        // record view, partial-assertions.ts): the answer is the view's, not
+        // the declared type's.
+        {
+            const viewPresence = partialFieldPresence(lowerer, recv, recv.type.shapeId, key, loc);
+            if (viewPresence)
+                return viewPresence;
+        }
         if (!OBJECT_PROTOTYPE_KEYS.has(key) &&
             field.type.kind === "union" &&
             lowerer.armTag(field.type.unionId, UNDEFINED_T) >= 0) {
@@ -1854,7 +2098,21 @@ export function lowerInExpression(lowerer, expr, loc) {
             loc,
         };
     }
-    return staticAnswerAfter(recv, inherited, loc);
+    // A key the type does not declare is an own key of a linked copy's
+    // source or of a kept source (record-links.ts, and the hasOwn helper's
+    // kept width spread answer); the helper call evaluates the receiver once.
+    if (!inherited && recordMayKeepSource(lowerer, recv.type))
+        return {
+            kind: "call",
+            callee: recordHasOwnHelper(lowerer, recv.type.shapeId, loc),
+            args: [recv, { kind: "strLit", value: key, type: STRING, loc }],
+            type: BOOL,
+            loc,
+        };
+    // Otherwise the answer is static; the key-order pass still reads the
+    // site as a presence test of the receiver's keys.
+    const answer = staticAnswerAfter(recv, inherited, loc);
+    return inherited ? answer : lowerer.keyOrder.sourceProbe(answer, recv, key);
 }
 /** A statically-decided `in` answer: a side-effect-free receiver folds away,
  * while any other receiver (a call result, an effectful read) is still