@scriptc/compiler 0.4.2 → 0.4.4

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

@@ -26,12 +26,45 @@ import { InternalCompilerError } from "../../../errors.js";
 import { tryLowerExpression } from "./try-lower-expression.js";
 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 { builtinGlobalHasKey } from "../builtins/global-namespace-keys.js";
 import { foldedStringKeyOf } from "./object-literals.js";
 import { NARROW_FIRST, sideEffectFreeOptionValue } from "../surfaces.js";
 import { isExecExceptionType, refuseExecExceptionCode } from "../builtins/errors.js";
 import { hasRuntimeStatics } from "../class-runtime-statics.js";
 import { nullProtoRecordShape, recordNullProtoTest } from "../null-prototype.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
+ * to the class value. Runtime-provided classes keep their own lowering. */
+function classValueOperand(lowerer, right, type) {
+    if (!isJsSourceFile(ts.getSourceFileOfNode(right)) ||
+        ts.isIdentifier(right) ||
+        lowerer.classes.get(type.className)?.def.runtime)
+        return lowerer.lowerExpr(right);
+    const value = lowerer.lowerExprExpecting(right, DYN);
+    if (value.type.kind !== "dyn")
+        return value;
+    return { kind: "dynCheck", value, type, loc: locOf(right) };
+}
+/** The value kinds that never hold an instance of a program class. */
+const NO_CLASS_INSTANCE_KINDS = new Set([
+    "f64",
+    "bigint",
+    "date",
+    "string",
+    "bool",
+    "array",
+    "map",
+    "set",
+    "regex",
+    "bytes",
+    "symbol",
+    "promise",
+    "undefinedT",
+    "nullT",
+]);
 /** `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).
@@ -124,6 +157,10 @@ export function lowerInstanceOf(lowerer, expr, loc) {
             loc,
         };
     }
+    if (lowerer.isStdlibGlobal(expr.right, "FinalizationRegistry")) {
+        const value = lowerer.coerceInto(expr.left, lowerer.lowerExpr(expr.left), DYN);
+        return { kind: "libCall", fn: "finalizationRegistry.is", args: [value], type: BOOL, loc };
+    }
     const rhsBuiltin = ts.isIdentifier(expr.right)
         ? lowerer.builtinImportOf(expr.right)
         : ts.isPropertyAccessExpression(expr.right)
@@ -272,6 +309,20 @@ export function lowerInstanceOf(lowerer, expr, loc) {
                 type: BOOL,
                 loc,
             };
+        // A codec in untyped storage is its record's handle box.
+        const codec = ["TextEncoder", "TextDecoder"].find((name) => lowerer.isStdlibGlobal(expr.right, name));
+        if (codec && lowerer.mapTypeOf(lowerer.typeOf(expr.left))?.kind === "dyn") {
+            return {
+                kind: "libCall",
+                fn: "text.codecIs",
+                args: [
+                    lowerer.lowerExprExpecting(expr.left, DYN),
+                    { kind: "boolLit", value: codec === "TextDecoder", type: BOOL, loc },
+                ],
+                type: BOOL,
+                loc,
+            };
+        }
         if (lowerer.isStdlibGlobal(expr.right, "ReadableStream")) {
             const value = lowerer.lowerExprExpecting(expr.left, DYN);
             return { kind: "libCall", fn: "fetch.streamIs", args: [value], type: BOOL, loc };
@@ -364,7 +415,57 @@ export function lowerInstanceOf(lowerer, expr, loc) {
         // (itself — no descendants can flow into the slot), so the answer
         // folds statically exactly like the named-target folds below.
         const rhsClassval = storedClassValueType(lowerer, expr.right);
-        if (rhsClassval?.kind === "classval" && !lowerer.caughtLocalOf(expr.left)) {
+        // A catch binding against a class held by a binding (`var E = class
+        // extends Error {}`). The binding holds the declared class or one of its
+        // subclasses. Without subclasses the test is the class's caught test,
+        // after the right operand's read; otherwise a payload of the declared
+        // class is tested against the class the binding holds.
+        const caught = lowerer.caughtLocalOf(expr.left);
+        const caughtTarget = rhsClassval?.kind === "classval" && caught
+            ? lowerer.classes.get(rhsClassval.className)
+            : undefined;
+        if (caught && caughtTarget && !caughtTarget.localClass && !caughtTarget.def.runtime) {
+            const classValue = lowerer.lowerExpr(expr.right);
+            if (caughtTarget.subclasses.length === 0) {
+                return {
+                    kind: "seqExpr",
+                    stmts: [{ kind: "exprStmt", expr: classValue, loc }],
+                    result: caughtClassInstanceOf(lowerer, caught.id, caughtTarget, loc),
+                    type: BOOL,
+                    loc,
+                };
+            }
+            if (classValue.type.kind !== "classval")
+                lowerer.badType(expr.right, lowerer.typeOf(expr.right));
+            const held = lowerer.declareHiddenLocal("%instanceofClass", classValue.type);
+            const instance = { kind: "object", className: caughtTarget.def.name };
+            return {
+                kind: "seqExpr",
+                stmts: [{ kind: "varDecl", localId: held.id, init: classValue, loc }],
+                result: {
+                    kind: "logical",
+                    op: "&&",
+                    left: caughtClassInstanceOf(lowerer, caught.id, caughtTarget, loc),
+                    right: {
+                        kind: "instanceOfValue",
+                        value: {
+                            kind: "caughtNarrow",
+                            value: varRef(caught.id, CAUGHT, loc),
+                            type: instance,
+                            loc,
+                        },
+                        classValue: varRef(held.id, classValue.type, loc),
+                        type: BOOL,
+                        loc,
+                    },
+                    type: BOOL,
+                    loc,
+                },
+                type: BOOL,
+                loc,
+            };
+        }
+        if (rhsClassval?.kind === "classval" && !caught) {
             const targetInfo = lowerer.classes.get(rhsClassval.className);
             if (!targetInfo) {
                 // The type world names a class the lowering never registered
@@ -388,7 +489,7 @@ export function lowerInstanceOf(lowerer, expr, loc) {
                 if (targetInfo.def.runtime) {
                     lowerer.unsupported("SC1090", expr, "'instanceof' through a runtime-provided class value on an untyped value (give the operand a class type first)");
                 }
-                const classValue = lowerer.lowerExpr(expr.right);
+                const classValue = classValueOperand(lowerer, expr.right, rhsClassval);
                 return classInstanceOf(lowerer, left, targetInfo, loc, classValue);
             }
             // A union of class instances against a runtime class value (`new K()`
@@ -398,6 +499,22 @@ export function lowerInstanceOf(lowerer, expr, loc) {
                 if (tested)
                     return tested;
             }
+            // A value whose type holds no class instance (a primitive, a native
+            // collection, a date, a regex, an array) is never an instance
+            // of a program class: false, after both operands evaluate.
+            if (!targetInfo.def.runtime && NO_CLASS_INSTANCE_KINDS.has(left.type.kind)) {
+                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: false, type: BOOL, loc },
+                    type: BOOL,
+                    loc,
+                };
+            }
             if (left.type.kind !== "object") {
                 lowerer.unsupported("SC1090", expr, "'instanceof' on values other than class instances (narrow union-typed values first)");
             }
@@ -406,7 +523,7 @@ export function lowerInstanceOf(lowerer, expr, loc) {
                 throw new InternalCompilerError(`lowerer bug: unknown class ${left.type.className}`);
             if ((lowerer.inHierarchy(targetInfo) && lowerer.inHierarchy(lhsInfo)) ||
                 (targetInfo.localClass !== undefined && lhsInfo.localClass !== undefined)) {
-                const classValue = lowerer.lowerExpr(expr.right);
+                const classValue = classValueOperand(lowerer, expr.right, rhsClassval);
                 if (classValue.type.kind !== "classval")
                     lowerer.badType(expr.right, lowerer.typeOf(expr.right));
                 const writableTest = writableClassValueTest(lowerer, left, classValue, targetInfo, lhsInfo, loc);
@@ -431,10 +548,13 @@ export function lowerInstanceOf(lowerer, expr, loc) {
             }
             lowerer.unsupported("SC1090", expr, "statically-decided 'instanceof' on computed operands (bind the values to variables first)");
         }
+        // A checked-dynamic right-hand side (a constructor read from a table, a
+        // structural constructor type, a builtin constructor held as `any`):
+        // the runtime's instanceof over the value, in both source languages.
         const constructor = tryLowerExpression(lowerer, expr.right);
-        if (constructor?.type.kind === "dyn" && isJsSourceFile(ts.getSourceFileOfNode(expr))) {
+        if (constructor?.type.kind === "dyn") {
             const value = lowerer.coerceInto(expr.left, lowerer.lowerExpr(expr.left), DYN);
-            return checkedClassInstanceOf(lowerer, value, constructor, loc);
+            return checkedClassInstanceOf(lowerer, value, constructor, dynInstanceOfRefusal(lowerer, expr), loc);
         }
         // `this instanceof Glob` in a JavaScript constructor function: the
         // function's prototype against the value's prototype chain.
@@ -476,34 +596,7 @@ export function lowerInstanceOf(lowerer, expr, loc) {
     // narrowing then types the branches; reads bridge through caughtRead.
     const caughtLocal = lowerer.caughtLocalOf(expr.left);
     if (caughtLocal) {
-        const caughtInstanceOf = (info) => {
-            if (!lowerer.inHierarchy(info)) {
-                const value = varRef(caughtLocal.id, CAUGHT, loc);
-                return {
-                    kind: "ternary",
-                    cond: {
-                        kind: "caughtTest",
-                        value,
-                        test: "instanceof",
-                        className: info.def.name,
-                        type: BOOL,
-                        loc,
-                    },
-                    then: { kind: "boolLit", value: true, type: BOOL, loc },
-                    else_: classInstanceOf(lowerer, { kind: "caughtToDyn", value, type: DYN, loc }, info, loc),
-                    type: BOOL,
-                    loc,
-                };
-            }
-            return {
-                kind: "caughtTest",
-                value: { kind: "varRef", localId: caughtLocal.id, type: CAUGHT, loc },
-                test: "instanceof",
-                className: info.def.name,
-                type: BOOL,
-                loc,
-            };
-        };
+        const caughtInstanceOf = (info) => caughtClassInstanceOf(lowerer, caughtLocal.id, info, loc);
         let test = caughtInstanceOf(target);
         // A thrown checked-dynamic object whose prototype chain reaches
         // Error.prototype (an ES5 constructor function inheriting from it).
@@ -854,6 +947,36 @@ function writableClassValueTest(lowerer, left, classValue, targetInfo, lhsInfo,
         loc,
     };
 }
+/** A catch binding tested against a program class: the runtime test against
+ * the class's preorder interval (false for non-hierarchy-object payloads). */
+function caughtClassInstanceOf(lowerer, caughtId, info, loc) {
+    if (!lowerer.inHierarchy(info)) {
+        const value = varRef(caughtId, CAUGHT, loc);
+        return {
+            kind: "ternary",
+            cond: {
+                kind: "caughtTest",
+                value,
+                test: "instanceof",
+                className: info.def.name,
+                type: BOOL,
+                loc,
+            },
+            then: { kind: "boolLit", value: true, type: BOOL, loc },
+            else_: classInstanceOf(lowerer, { kind: "caughtToDyn", value, type: DYN, loc }, info, loc),
+            type: BOOL,
+            loc,
+        };
+    }
+    return {
+        kind: "caughtTest",
+        value: { kind: "varRef", localId: caughtId, type: CAUGHT, loc },
+        test: "instanceof",
+        className: info.def.name,
+        type: BOOL,
+        loc,
+    };
+}
 /** A statically decided `instanceof` still reads its class after the left
  * operand: a class with an initialization flag throws there before its
  * declaration ran. */
@@ -1254,6 +1377,18 @@ export function lowerInExpression(lowerer, expr, loc) {
         }
         lowerer.unsupported("SC1090", expr.left, "'in' with computed (non-literal) keys (a const whose type is one string literal folds; a string-typed key answers over index-signature record receivers)");
     }
+    // A feature probe on a builtin constructor global (`"captureStackTrace"
+    // in Error`): the global is a fixed object, so the answer is static.
+    {
+        let recvNode = expr.right;
+        while (ts.isParenthesizedExpression(recvNode))
+            recvNode = recvNode.expression;
+        if (ts.isIdentifier(recvNode) && lowerer.isStdlibGlobal(recvNode, recvNode.text)) {
+            const has = builtinGlobalHasKey(recvNode.text, key);
+            if (has !== null)
+                return { kind: "boolLit", value: has, type: BOOL, loc };
+        }
+    }
     // A receiver re-read (the static folds below) is safe for plain reads
     // AND for side-effect-free expressions (an object literal of literals
     // — the `"a" in { a: true }` shape).
@@ -1316,6 +1451,32 @@ export function lowerInExpression(lowerer, expr, loc) {
         if (helper)
             recv = { kind: "call", callee: helper, args: [recv], type: siteType, loc };
     }
+    // A builtin class held as a brand record (TextEncoder, TextDecoder: only
+    // `%`-prefixed internal fields): its members are the class's prototype
+    // members, which the standard library declares, so `"encodeInto" in
+    // encoder` answers from the checker's type, plus Object.prototype's keys.
+    // The receiver evaluates for its effects.
+    if (recv.type.kind === "record") {
+        const shape = lowerer.shapes.get(recv.type.shapeId);
+        if (shape && shape.fields.length > 0 && shape.fields.every((f) => f.name.startsWith("%"))) {
+            const declared = lowerer.checker.getPropertyOfType(lowerer.typeOf(expr.right), key) !== undefined;
+            const answer = {
+                kind: "boolLit",
+                value: declared || OBJECT_PROTOTYPE_KEYS.has(key),
+                type: BOOL,
+                loc,
+            };
+            if (recv.kind === "varRef")
+                return answer;
+            return {
+                kind: "seqExpr",
+                stmts: [{ kind: "exprStmt", expr: recv, loc }],
+                result: answer,
+                type: BOOL,
+                loc,
+            };
+        }
+    }
     // Error-rooted receivers (builtin or user subclass — the isErrnoException
     // predicate's `err instanceof Error && "code" in err` shape): `code`
     // answers from the runtime error's code slot (stamped by fs/system/
@@ -1779,4 +1940,22 @@ function lowerRuntimeKeyIn(lowerer, expr, loc) {
     }
     return { kind: "call", callee: helper, args: [keyIr, recv], type: BOOL, loc };
 }
+/** Standard-library constructors the untyped instanceof helper has no
+ * instance test for: an untyped `x instanceof Object` always refuses. */
+const DYN_INSTANCEOF_REFUSED = new Set(["Object", "Function"]);
+/** The SC1090 message `x instanceof C` throws, with the site's position,
+ * when `C` is a runtime constructor with no instance test. A right-hand
+ * side that names one of DYN_INSTANCEOF_REFUSED always reaches that
+ * refusal, so the site is listed with the runtime fences. */
+function dynInstanceOfRefusal(lowerer, expr) {
+    const diag = unsupportedDiag("SC1090", locOf(expr), "instanceof against this native constructor");
+    const symbol = lowerer.checker.getSymbolAtLocation(expr.right);
+    if (symbol !== undefined &&
+        lowerer.isStdlibSymbol(symbol) &&
+        DYN_INSTANCEOF_REFUSED.has(ts.symbolName(symbol)))
+        lowerer.runtimeFences.push(diag);
+    const sf = ts.getSourceFileOfNode(expr);
+    const line = ts.getLineAndCharacterOfPosition(sf, diag.loc.start).line + 1;
+    return `${diag.message} [${diag.code} at ${diag.loc.file}:${line}]`;
+}
 //# sourceMappingURL=relational.js.map