@scriptc/compiler 0.4.3 → 0.4.4

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

@@ -1,4 +1,5 @@
 import { lowerTupleAliasDecl, stripTypeWrappers } from "./typed-arguments.js";
+import { allBytesArms, indexedUnionArms, lowerIndexedUnionMember, lowerIndexedUnionNumberRead, lowerIndexedUnionRead, } from "./indexed-unions.js";
 import { declaredMemberOf, isPromisePrototypeRead } from "./expressions/property-access.js";
 import { hostsAll } from "./expressions/hosted-narrowing.js";
 import { requestGeneralStreamSurface } from "./general-streams.js";
@@ -26,15 +27,16 @@ import { lowerOptionalIndex } from "./undefined-index.js";
 import { processDataMemberValue, programReadsExitCode } from "./builtins/process.js";
 import { requireInitFlagStmt } from "./require-initialization.js";
 import { isJsonRequireDecl } from "./json-require.js";
+import { isTimeValueDateDeclaration } from "./date-values.js";
 import { bindingSource } from "../binding-source.js";
 import { lowerConstructorReturn } from "./constructor-returns.js";
-import { cjsExportValueByName, cjsNamespaceDestructureOf, cjsTableMethodEntry, inlineProgramRequireOf, requireNestedPatternsOf, } from "./cjs-inline-require.js";
+import { cjsExportValueByName, cjsNamespaceDestructureOf, cjsTableMethodEntry, inlineProgramRequireOf, requireNestedPatternsOf, splitRequireAssignmentOf, splitRequireBindingOf, splitRequireBindingOfIdent, splitRequireEarlyReadOf, wholeExportSymbolOfModule, } from "./cjs-inline-require.js";
 import { cjsExportMemberWriteGlobalOf, isCjsExportsIdentifier, isCjsModuleExports, isFreshExportsReset, } from "./cjs-exports-object.js";
 import { isDeadTscHelperDecl, tscInteropBindingOfDecl } from "./cjs-tsc-interop.js";
 import { arrayValueRead, arrayValueStore, arrayValueType, unionArrayValueRead, lowerSafeIndexRead, } from "./array-values.js";
 import { lowerForAwaitGenerator, lowerForOfGenerator, lowerYieldStarStatement, } from "./lower-generators.js";
 import { classAsyncGeneratorIterator, lowerForAwaitBuiltin } from "./lower-async-iteration.js";
-import { BOOL, BYTES_U8, CAUGHT, DYN, F64, SEARCH_PARAMS_T, STRING, UNDEFINED_T, VOID, arrayOf, isDynTypedRefType, isUnitType, shapeHasAccessorSlots, typeEquals, } from "../../ir/ir.js";
+import { BOOL, BYTES_U8, CAUGHT, DATE_T, DYN, F64, SEARCH_PARAMS_T, STRING, UNDEFINED_T, VOID, arrayOf, isDynTypedRefType, isUnitType, shapeHasAccessorSlots, typeEquals, } from "../../ir/ir.js";
 import { PoisonError, boundIdentifiersOf, dynFallbackType, neverTaintedJsType, staticImportNamespaceType, } from "./lowerer.js";
 import { enforceLibBoundary, lowerSurplusCalls } from "./lib-boundary.js";
 import { cjsExportAssignmentOf, cjsExportChainOf, cjsVoidInitPreambleReals, cjsExportDiscardReason, cjsExportTargetLiteral, isCjsJsFile, isEsModuleStamp, isJsSourceFile, locOf, requireEarlyReference, requireSpecOf, } from "../program.js";
@@ -1662,6 +1664,19 @@ export function lowerVarStatement(lowerer, stmt) {
     });
 }
 function lowerVarDeclarator(lowerer, stmt, decl, isConst, isLet) {
+    // `var m; m = require("./x")`: the declaration is alias plumbing; the
+    // assignment owns the module's run-once %init (cjs-inline-require.ts).
+    // A read that code before the assignment can reach keeps Node's hoisted
+    // `undefined` divergence visible at build time, like a var require
+    // declaration below runnable code.
+    const split = splitRequireBindingOf(lowerer, decl);
+    if (split !== null) {
+        const early = splitRequireEarlyReadOf(lowerer, split);
+        if (early !== null) {
+            lowerer.unsupported("SC1013", early, `var require() binding '${decl.name.text}' below code that can reach it (Node reads undefined before the require runs, which is not modeled — assign the require above the code that can run first)`);
+        }
+        return [];
+    }
     // The canonical ESM bridge to a compiled program module. Like a
     // top-level CommonJS require declaration, the binding is alias
     // plumbing while the dependency evaluates at this statement's
@@ -4535,6 +4550,15 @@ export function lowerVarDecl(lowerer, decl, isLet) {
         if (alias)
             return alias;
     }
+    // A Date local whose identity no use observes stores its time value.
+    if (isTimeValueDateDeclaration(lowerer, decl)) {
+        const loc = locOf(decl);
+        const date = lowerer.lowerExprExpecting(decl.initializer, DATE_T);
+        const local = lowerer.declareLocal(decl.name, decl.name.text, F64, isLet);
+        lowerer.timeValueDateLocals.add(local);
+        const init = { kind: "libCall", fn: "date.getTime", args: [date], type: F64, loc };
+        return { kind: "varDecl", localId: local.id, init, loc };
+    }
     // A NULLISH generic binding (`const i: I<A & B> = null as any` — the
     // declared type has no mapping, the value is provably null/undefined
     // forever): no storage exists; reads know the value (member reads and
@@ -5833,7 +5857,7 @@ function lowerDynSwitch(lowerer, stmt, disc, labels) {
                 loc: locOf(expression),
             };
         }
-        if (test.type.kind === "date" || !lowerer.dynConvertible(test.type)) {
+        if (!lowerer.dynConvertible(test.type)) {
             lowerer.unsupported("SC1100", expression, "switch case values that cannot compare strictly with 'unknown'");
         }
         return {
@@ -6411,6 +6435,22 @@ function lowerCjsSingleValueExport(lowerer, expr, loc) {
             return lowerer.requireInitStmt(req.spec, req.call) ?? { kind: "block", body: [], loc };
     }
     if (ts.isIdentifier(rhs)) {
+        const split = splitRequireBindingOfIdent(lowerer, rhs);
+        if (split !== null) {
+            if (wholeExportSymbolOfModule(lowerer, split.dep) === null) {
+                lowerer.unsupported("SC1090", rhs, `the exports object of '${split.spec}' as a value (its exports compile to a static table: read require(${JSON.stringify(split.spec)}).member directly)`);
+            }
+            const root = lowerer.globalsByDeclNode.get(expr);
+            if (root !== undefined) {
+                return {
+                    kind: "assign",
+                    localId: root.id,
+                    value: lowerer.lowerExprExpecting(rhs, root.type),
+                    loc: locOf(rhs),
+                };
+            }
+            return { kind: "block", body: [], loc };
+        }
         const sym = lowerer.resolveValueSymbol(rhs);
         if (!sym)
             return null;
@@ -7213,6 +7253,14 @@ export function lowerExprStatement(lowerer, expr) {
             if (!ts.isIdentifier(expr.left)) {
                 lowerer.unsupported("SC1090", expr.left, "assignment to non-variables");
             }
+            const splitAssign = splitRequireAssignmentOf(lowerer, expr);
+            if (splitAssign !== null) {
+                return (lowerer.requireInitStmt(splitAssign.spec, splitAssign.call) ?? {
+                    kind: "block",
+                    body: [],
+                    loc: locOf(expr),
+                });
+            }
             const target = lowerer.resolveWritable(expr.left);
             if (!target)
                 lowerer.rejectUnresolved(expr.left, `assignment to '${expr.left.text}' (not a writable local or module global)`);
@@ -7498,7 +7546,9 @@ function destrSpellingOf(rhs) {
         return base === null ? null : `${base}.${e.name.text}`;
     }
     // `table[key]` and `list[0]`; V8 prints a numeric key in its canonical
-    // number form (`o[1.50]` reads "o[1.5]").
+    // number form (`o[1.50]` reads "o[1.5]"), and a string key as a property
+    // name with its text decoded (`o["a.b"]` and `o[\`a.b\`]` read "o.a.b").
+    // The message is a C string, so a key holding NUL keeps the refusal.
     if (ts.isElementAccessExpression(e) && !e.questionDotToken) {
         const base = destrSpellingOf(e.expression);
         const key = e.argumentExpression;
@@ -7508,6 +7558,9 @@ function destrSpellingOf(rhs) {
             return `${base}[${key.text}]`;
         if (ts.isNumericLiteral(key))
             return `${base}[${String(Number(key.text))}]`;
+        if ((ts.isStringLiteral(key) || ts.isNoSubstitutionTemplateLiteral(key)) &&
+            !key.text.includes("\0"))
+            return `${base}.${key.text}`;
         return null;
     }
     if (ts.isCallExpression(e) && !e.questionDotToken) {
@@ -8667,7 +8720,7 @@ export function lowerForOf(lowerer, stmt) {
                 loc: locOf(iterSrc),
             };
     }
-    if (iterable.type.kind === "bytes") {
+    if (iterable.type.kind === "bytes" || indexedUnionArms(lowerer, iterable.type)) {
         return lowerForOfBytes(lowerer, stmt, iterable, labels);
     }
     if (iterable.type.kind !== "array") {
@@ -9242,40 +9295,53 @@ function lowerForOfStoredNumericIterator(lowerer, stmt, state, labels) {
         lowerer.unsupported("SC1031", decl.name);
     const loc = locOf(stmt);
     const sourceT = state.sourceType;
-    if (!((sourceT.kind === "array" && sourceT.elem.kind === "f64") || sourceT.kind === "bytes")) {
+    // A union of typed arrays and number arrays (indexed-unions.ts) reads
+    // through its arms' own length and element reads.
+    const unionArms = indexedUnionArms(lowerer, sourceT);
+    if (!((sourceT.kind === "array" && sourceT.elem.kind === "f64") ||
+        sourceT.kind === "bytes" ||
+        unionArms)) {
         throw new InternalCompilerError("internal: retained numeric iterator has a non-numeric source");
     }
     const indexRef = () => varRef(state.indexLocalId, F64, loc);
     const doneRef = () => varRef(state.doneLocalId, BOOL, loc);
     const sourceRef = () => varRef(state.sourceLocalId, sourceT, loc);
-    const sourceLength = () => sourceT.kind === "array"
-        ? {
-            kind: "arrIntrinsic",
-            method: "length",
-            receiver: sourceRef(),
-            args: [],
-            type: F64,
-            loc,
-        }
-        : {
-            kind: "bytesIntrinsic",
-            method: "length",
-            receiver: sourceRef(),
-            args: [],
-            type: F64,
-            loc,
-        };
-    const valueT = sourceT.kind === "array" ? arrayValueType(lowerer, F64) : F64;
-    const sourceValue = () => sourceT.kind === "array"
-        ? arrayValueRead(lowerer, sourceRef(), indexRef(), F64, loc)
-        : {
-            kind: "bytesIntrinsic",
-            method: "get",
-            receiver: sourceRef(),
-            args: [indexRef()],
-            type: F64,
-            loc,
-        };
+    const sourceLength = () => unionArms
+        ? lowerIndexedUnionMember(lowerer, sourceRef(), unionArms, "length", loc)
+        : sourceT.kind === "array"
+            ? {
+                kind: "arrIntrinsic",
+                method: "length",
+                receiver: sourceRef(),
+                args: [],
+                type: F64,
+                loc,
+            }
+            : {
+                kind: "bytesIntrinsic",
+                method: "length",
+                receiver: sourceRef(),
+                args: [],
+                type: F64,
+                loc,
+            };
+    const valueT = sourceT.kind === "array" || (unionArms && !allBytesArms(unionArms))
+        ? arrayValueType(lowerer, F64)
+        : F64;
+    const sourceValue = () => unionArms
+        ? allBytesArms(unionArms)
+            ? lowerIndexedUnionNumberRead(lowerer, sourceRef(), unionArms, indexRef(), loc)
+            : lowerIndexedUnionRead(lowerer, sourceRef(), unionArms, indexRef(), loc)
+        : sourceT.kind === "array"
+            ? arrayValueRead(lowerer, sourceRef(), indexRef(), F64, loc)
+            : {
+                kind: "bytesIntrinsic",
+                method: "get",
+                receiver: sourceRef(),
+                args: [indexRef()],
+                type: F64,
+                loc,
+            };
     const one = { kind: "numLit", value: 1, type: F64, loc };
     lowerer.scopes.push(new Map());
     try {