@scriptc/compiler 0.3.1 → 0.3.2

package/dist/frontend/lowering/lower-exprs.js

@@ -1,8 +1,10 @@
 import { generatorDrain } from "./iterator-adapters.js";
+import { lowerEventStaticProperty } from "./builtins/numbers.js";
 import { lowerUnionEquality, tagEqualityMayMissAlias } from "./strict-equality.js";
 import { isOptionalProcessStreamProperty } from "./builtins/process.js";
 import { lowerWorkerMetadata } from "./builtins/workers.js";
 import { threadsImportOf } from "../threads-import.js";
+import { experimentalImportOf, lifetimeRegionMemberOf } from "../experimental-import.js";
 import { dynUndefinedExpr, nodeThrowExpr, numLit, strLit, varRef } from "../../ir/build.js";
 import { InternalCompilerError } from "../../errors.js";
 import { SYMBOL_T } from "../../ir/ir.js";
@@ -48,8 +50,8 @@ import { funcTypeFromParamShapes } from "./call-signatures.js";
 import { implicitMonoFile, objLitGenericFnInfoOf, objLitGenericFnNodeOf, requireObjLitGenericReceiver, } from "./generic-functions.js";
 import { lowerTaggedTemplate } from "./lower-calls.js";
 import { mixinFnOfCallee } from "./lower-mixins.js";
-import { isConstAssertionTypeNode, isGenericCallableMemberType, isParseArgsDynTypeName, underConstAssertion, unitOnlyUnion, withUnitArm, } from "../type-mapper.js";
-import { lowerYield } from "./lower-generators.js";
+import { isConstAssertionTypeNode, isGenericCallableMemberType, isOsConstantsType, isParseArgsDynTypeName, underConstAssertion, unitOnlyUnion, withUnitArm, } from "../type-mapper.js";
+import { iteratorResultValueRead, lowerYield } from "./lower-generators.js";
 import { errorPropertyRead, errorPropertyWrite, errorToStringCall } from "./error-methods.js";
 import { lowerStreamProperty, lowerStreamStateProperty, streamSidesOf } from "./lower-stream.js";
 import { unionWideningTags } from "../../ir/analysis.js";
@@ -731,7 +733,9 @@ function lowerExprInner(lowerer, expr) {
                     lowerer.unions.get(g.type.unionId)?.arms.length === 2 &&
                     lowerer.unions.get(g.type.unionId).arms.some((a) => a.kind === "f64") &&
                     lowerer.unions.get(g.type.unionId).arms.some((a) => a.kind === "string");
+                const symbol = lowerer.resolveValueSymbol(expr);
                 if (!arithmeticUnion &&
+                    !(symbol !== null && lowerer.earlyReadVars.has(symbol)) &&
                     g.type.kind === "union" &&
                     narrowed &&
                     narrowed.kind !== "union" &&
@@ -849,6 +853,8 @@ function lowerExprInner(lowerer, expr) {
                 return { kind: "boolLit", value: true, type: BOOL, loc };
             if (member === "publish")
                 lowerer.noLowering("publish (@scriptc/threads) as a value", expr, "call publish(value) directly");
+            if (experimentalImportOf(lowerer.program, expr) === "LifetimeRegion")
+                lowerer.noLowering("LifetimeRegion (@scriptc/experimental) as a value", expr, "construct regions with new LifetimeRegion()");
         }
         {
             const bi = lowerer.builtinImportOf(expr);
@@ -872,6 +878,9 @@ function lowerExprInner(lowerer, expr) {
                 if (bi.module === "http" && bi.member === "STATUS_CODES") {
                     return { kind: "libCall", fn: "http.statusCodes", args: [], type: DYN, loc };
                 }
+                if (bi.module === "os" && bi.member === "constants") {
+                    return { kind: "libCall", fn: "os.constants", args: [], type: DYN, loc };
+                }
                 // tls.rootCertificates: a runtime-valued module constant (the
                 // cached bundled-CA array) — the one member read that lowers
                 // to a libCall instead of a baked literal.
@@ -1413,6 +1422,11 @@ function lowerExprInner(lowerer, expr) {
     if (ts.isConditionalExpression(expr))
         return lowerTernary(lowerer, expr);
     if (ts.isPropertyAccessExpression(expr)) {
+        {
+            const member = lifetimeRegionMemberOf(lowerer.program, expr, lowerer.experimentalFiles);
+            if (member !== null)
+                lowerer.noLowering(`LifetimeRegion.${member} (@scriptc/experimental) as a value`, expr, `call region.${member}(${member === "run" ? "fn" : ""}) directly`);
+        }
         // Expando statics may still be absent even when JS inference sees
         // the eventual assignment's scalar type. Preserve the checked value.
         const staticField = lowerStaticFieldRead(lowerer, expr);
@@ -1809,6 +1823,7 @@ function lowerExprInner(lowerer, expr) {
             lowerer.lowerJsonProperty(expr) ??
             lowerer.lowerErrorCodeProperty(expr) ??
             lowerer.lowerNumberStaticProperty(expr) ??
+            lowerEventStaticProperty(lowerer, expr) ??
             lowerer.lowerMathProperty(expr) ??
             lowerer.lowerIntrinsicProperty(expr) ??
             // The _readableState/_writableState scalar READS (the suite's
@@ -1831,7 +1846,7 @@ function lowerExprInner(lowerer, expr) {
             // arm is real (`obj.n = bytes[i]; obj.n` is undefined in Node).
             if (runtimeOptionalClassField(lowerer, handled, expr))
                 return handled;
-            return lowerer.maybeNarrow(handled, expr);
+            return iteratorResultValueRead(lowerer, handled, expr) ?? lowerer.maybeNarrow(handled, expr);
         }
         // `globalThis.<name>` that no lowering above claimed
         // (globalThis.crypto, globalThis.SubtleCrypto, globalThis.localStorage
@@ -2021,14 +2036,15 @@ function lowerExprInner(lowerer, expr) {
                     const shape = lowerer.shapes.get(recv.type.shapeId);
                     const field = shape?.fields.find((f) => f.name === expr.name.text);
                     if (field) {
-                        return lowerer.maybeNarrow({
+                        const read = {
                             kind: "recordGet",
                             obj: recv,
                             shapeId: recv.type.shapeId,
                             field: field.name,
                             type: field.type,
                             loc,
-                        }, expr);
+                        };
+                        return iteratorResultValueRead(lowerer, read, expr) ?? lowerer.maybeNarrow(read, expr);
                     }
                 }
             }
@@ -2055,9 +2071,14 @@ function lowerExprInner(lowerer, expr) {
         const segmentDataProperty = segmentDataSymbol?.name === "SegmentData" &&
             lowerer.isStdlibSymbol(segmentDataSymbol) &&
             ["segment", "index", "input", "isWordLike"].includes(expr.name.text);
+        // os.constants members vary by platform (the declared groups list
+        // every platform's names): a number member reads as `number |
+        // undefined`, like an array element, and a group stays checked.
+        const osConstants = isOsConstantsType(lowerer.typeOf(expr.expression), lowerer);
         if (isParseArgsDynProperty(lowerer, expr) ||
             isStatFsDynProperty(lowerer, expr) ||
-            segmentDataProperty) {
+            segmentDataProperty ||
+            osConstants) {
             const recv = lowerer.lowerExpr(expr.expression);
             if (recv.type.kind === "dyn") {
                 const key = {
@@ -2067,14 +2088,20 @@ function lowerExprInner(lowerer, expr) {
                     loc: locOf(expr.name),
                 };
                 const opt = hasOptionalChainGuard(expr.expression);
-                return lowerer.maybeNarrow({
+                const read = {
                     kind: "dynKeyGet",
                     key,
                     ...(opt ? { optional: true } : {}),
                     value: recv,
                     type: DYN,
                     loc,
-                }, expr);
+                };
+                if (osConstants) {
+                    return lowerer.mapTypeOf(lowerer.typeOf(expr))?.kind === "f64"
+                        ? lowerer.coerceToExpected(read, lowerer.withUndefinedArm(F64))
+                        : read;
+                }
+                return lowerer.maybeNarrow(read, expr);
             }
         }
         // A member read through a NULLISH generic binding (`const i: I<A &
@@ -10140,6 +10167,14 @@ export function lowerInstanceOf(lowerer, expr, loc) {
         const value = lowerer.coerceInto(expr.left, lowerer.lowerExpr(expr.left), DYN);
         return { kind: "libCall", fn: "dyn.dataViewIs", args: [value], type: BOOL, loc };
     }
+    {
+        const eventKind = ["Event", "CustomEvent", "EventTarget"].findIndex((name) => lowerer.isStdlibGlobal(expr.right, name));
+        if (eventKind >= 0) {
+            const value = lowerer.coerceInto(expr.left, lowerer.lowerExpr(expr.left), DYN);
+            const kind = { kind: "numLit", value: eventKind, type: F64, loc };
+            return { kind: "libCall", fn: "event.is", args: [value, kind], type: BOOL, loc };
+        }
+    }
     if (lowerer.isStdlibGlobal(expr.right, "SharedArrayBuffer")) {
         const value = lowerer.coerceInto(expr.left, lowerer.lowerExpr(expr.left), DYN);
         return { kind: "libCall", fn: "sharedArrayBuffer.is", args: [value], type: BOOL, loc };
@@ -10339,7 +10374,12 @@ export function lowerInstanceOf(lowerer, expr, loc) {
                 lowerer.isSubclassOf(left.type.className, targetInfo.def.name);
             if (left.kind === "varRef" &&
                 (ts.isIdentifier(expr.right) || expr.right.kind === ts.SyntaxKind.ThisKeyword)) {
-                return { kind: "boolLit", value, type: BOOL, loc };
+                return readsClassAfter(lowerer, targetInfo, expr.right, [], {
+                    kind: "boolLit",
+                    value,
+                    type: BOOL,
+                    loc,
+                });
             }
             lowerer.unsupported("SC1090", expr, "statically-decided 'instanceof' on computed operands (bind the values to variables first)");
         }
@@ -10489,13 +10529,12 @@ export function lowerInstanceOf(lowerer, expr, loc) {
         }
     }
     if (left.type.kind !== "object") {
-        return {
-            kind: "seqExpr",
-            stmts: [{ kind: "exprStmt", expr: left, loc }],
-            result: { kind: "boolLit", value: false, type: BOOL, loc },
+        return readsClassAfter(lowerer, target, expr.right, [{ kind: "exprStmt", expr: left, loc }], {
+            kind: "boolLit",
+            value: false,
             type: BOOL,
             loc,
-        };
+        });
     }
     const lhsInfo = lowerer.classes.get(left.type.className);
     if (!lhsInfo)
@@ -10506,10 +10545,33 @@ export function lowerInstanceOf(lowerer, expr, loc) {
     const value = left.type.className === target.def.name ||
         lowerer.isSubclassOf(left.type.className, target.def.name);
     if (left.kind === "varRef") {
-        return { kind: "boolLit", value, type: BOOL, loc };
+        return readsClassAfter(lowerer, target, expr.right, [], {
+            kind: "boolLit",
+            value,
+            type: BOOL,
+            loc,
+        });
     }
     lowerer.unsupported("SC1090", expr, "statically-decided 'instanceof' on computed operands (bind the value to a variable first)");
 }
+/** A statically decided `instanceof` still reads its class after the left
+ * operand: a class with an initialization flag throws there before its
+ * declaration ran. */
+function readsClassAfter(lowerer, target, right, stmts, result) {
+    if (!lowerer.classInitFlags.has(target.def.name)) {
+        if (stmts.length === 0)
+            return result;
+        return { kind: "seqExpr", stmts, result, type: result.type, loc: result.loc };
+    }
+    const read = lowerer.lowerExpr(right);
+    return {
+        kind: "seqExpr",
+        stmts: [...stmts, { kind: "exprStmt", expr: read, loc: locOf(right) }],
+        result,
+        type: result.type,
+        loc: result.loc,
+    };
+}
 /** `#name in obj` — the ergonomic brand check. In this closed world a
  * brand is held by exactly the instances of the declaring class
  * (subclasses included — construction always runs the declaring class's
@@ -10663,11 +10725,27 @@ function lowerPrivateIn(lowerer, expr, priv, loc) {
         return { kind: "boolLit", value, type: BOOL, loc };
     lowerer.unsupported("SC1090", expr, `statically-decided '${pname} in …' on computed operands (bind the value to a variable first)`);
 }
+/** The string keys every record inherits from Object.prototype. */
+const OBJECT_PROTOTYPE_KEYS = new Set([
+    "constructor",
+    "__defineGetter__",
+    "__defineSetter__",
+    "hasOwnProperty",
+    "__lookupGetter__",
+    "__lookupSetter__",
+    "isPrototypeOf",
+    "propertyIsEnumerable",
+    "toString",
+    "valueOf",
+    "__proto__",
+    "toLocaleString",
+]);
 /** `"key" in v` — the key-presence test. Three lowered receivers:
  * process.env (getenv(3) presence — Node-exact, an empty value still
  * counts as present), and monomorphic record shapes, where the answer is
  * type-directed: a declared non-optional field is a compile-time `true`,
- * a missing field (no index signature) a compile-time `false` — both
+ * a missing field (no index signature) a compile-time `false` unless
+ * Object.prototype has it — both
  * folds limited to side-effect-free receivers, the lowerInstanceOf rule —
  * and an OPTIONAL field (undefined-armed union) is a runtime presence
  * test on the slot: an omitted or deleted property is absent, while a
@@ -10917,7 +10995,11 @@ function lowerInExpression(lowerer, expr, loc) {
                 break;
             }
             const f = shape.fields.find((x) => x.name === key);
-            if (f && f.type.kind === "union" && lowerer.armTag(f.type.unionId, UNDEFINED_T) >= 0) {
+            const inherited = OBJECT_PROTOTYPE_KEYS.has(key);
+            if (f &&
+                !inherited &&
+                f.type.kind === "union" &&
+                lowerer.armTag(f.type.unionId, UNDEFINED_T) >= 0) {
                 staticAnswers = false; // an optional slot: presence is per-value
                 break;
             }
@@ -10925,7 +11007,7 @@ 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 });
+            answers.push({ tag, has: f !== undefined || acc || inherited });
         }
         if (staticAnswers) {
             const pureRecv = recv.kind === "varRef" ||
@@ -10993,7 +11075,9 @@ 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) {
-        if (field.type.kind === "union" && lowerer.armTag(field.type.unionId, UNDEFINED_T) >= 0) {
+        if (!OBJECT_PROTOTYPE_KEYS.has(key) &&
+            field.type.kind === "union" &&
+            lowerer.armTag(field.type.unionId, UNDEFINED_T) >= 0) {
             // Optional slot: the key is present unless the field is absent
             // (omitted or deleted); an explicit undefined is present.
             return lowerer.recordFieldPresent(recv, recv.type.shapeId, key, loc);
@@ -11021,14 +11105,16 @@ function lowerInExpression(lowerer, expr, loc) {
         }
         lowerer.unsupported("SC1090", expr, "statically-decided 'in' on computed receivers (bind the value to a variable first)");
     }
-    if (shape.indexValue) {
+    // 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) {
-        return { kind: "boolLit", value: false, type: BOOL, loc };
+        return { kind: "boolLit", value: inherited, type: BOOL, loc };
     }
     lowerer.unsupported("SC1090", expr, "statically-decided 'in' on computed receivers (bind the value to a variable first)");
 }
@@ -11081,7 +11167,36 @@ function lowerRuntimeKeyIn(lowerer, expr, loc) {
         // Overflow keys answer through the map's hashed presence probe (a
         // stored undefined value is still present), not a scan over a fresh
         // key snapshot, which made `k in dict` loops quadratic.
-        body.push(ret({ kind: "recordOvfHas", obj: r, shapeId: recvT.shapeId, key: k, type: BOOL, loc }));
+        const ovfHas = {
+            kind: "recordOvfHas",
+            obj: r,
+            shapeId: recvT.shapeId,
+            key: k,
+            type: BOOL,
+            loc,
+        };
+        // A miss in the record's own keys still finds Object.prototype's.
+        let inherited = ovfHas;
+        for (const name of OBJECT_PROTOTYPE_KEYS) {
+            if (shape.fields.some((f) => f.name === name))
+                continue;
+            inherited = {
+                kind: "logical",
+                op: "||",
+                left: inherited,
+                right: {
+                    kind: "strEq",
+                    negated: false,
+                    left: k,
+                    right: { kind: "strLit", value: name, type: STRING, loc },
+                    type: BOOL,
+                    loc,
+                },
+                type: BOOL,
+                loc,
+            };
+        }
+        body.push(ret(inherited));
         lowerer.liftedFns.push({
             name: helper,
             params: [