@scriptc/compiler 0.4.6 → 0.4.8

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

@@ -16,6 +16,9 @@ import * as ts from "../ts7/adapter.js";
 import { checkedPrivateReceiver, localPrivateBrandClass } from "./private-brands.js";
 import { staticCondition } from "./static-typeof.js";
 import { constituentTypes } from "../ts7/checker.js";
+import { recordMayKeepSource } from "./record-sources.js";
+import { recordStringCall } from "./record-links.js";
+import { nullProtoRecordShape } from "./null-prototype.js";
 import { lowerMaybePromiseAwait, maybePromiseUnionOf, promiseArmedUnionOf, } from "./maybe-promise.js";
 import { checkedClassUnionAssertion } from "./class-assertions.js";
 import { BIGINT_T, BOOL, CAUGHT, DYN, F64, NULL_T, REF_TRUTHY_KINDS, REGEX, STRING, UNDEFINED_T, VOID, arrayOf, funcOf, isUnitType, typeEquals, typeKey, } from "../../ir/ir.js";
@@ -43,17 +46,20 @@ import { classSymbolKeyOf } from "./symbol-fields.js";
 import { lowerTypeofExpr } from "./expressions/typeof.js";
 import { lowerIdentifierExpr } from "./expressions/identifiers.js";
 import { lowerFieldCompoundValue, lowerIncDec } from "./expressions/updates.js";
-import { lowerTernary, v8CalleeText } from "./expressions/narrowing.js";
+import { lowerTernary, staleReadMessage } from "./expressions/narrowing.js";
+import { checkedArmExtraction } from "./coercions/unions.js";
 import { classFieldTarget, lowerPropertyAccessExpr, lowerUnionKeyedRead, } from "./expressions/property-access.js";
 import { lowerNullishPair } from "./expressions/binary.js";
 import { lowerElementCompoundParts, recordKeyLiteralText } from "./expressions/element-access.js";
+import { heldEnvValueType } from "./builtins/environment.js";
 import { OBJECT_PROTOTYPE_MEMBERS } from "../shape-inference/domain.js";
 export { DEFERRED_READ_MESSAGE, abstractPropertyDeclOf, builtinFunctionValue, builtinGlobalValue, fieldGetExpr, fieldTarget, isMatchSliceType, lowerFieldRead, lowerGroupsProjection, lowerIntrinsicProperty, lowerUnionProperty, matchResultNamedGroupsOf, primitiveConstructorOr, } from "./expressions/property-access.js";
 export { lowerAsExpression, lowerTernary, maybeNarrow, runtimeOptionalGuardIds, runtimeOptionalTrueIds, v8CalleeText, withRuntimeOptionalNarrowed, } from "./expressions/narrowing.js";
 export { ensureString, lowerBinary, lowerCompoundValueToTarget, lowerElementCompound, lowerNativeFunctionAssignment, lowerStrictEquality, lowerUnitComparison, } from "./expressions/binary.js";
-export { jsHoldsDynObject, lowerArrayLiteral } from "./expressions/array-literals.js";
+export { jsHoldsDynObject, jsHoldsMixedClassConstructors, lowerArrayLiteral, } from "./expressions/array-literals.js";
 export { lowerElementAccess, lowerElementWrite, lowerEnvironmentKey, lowerRecordKeyRead, } from "./expressions/element-access.js";
 export { fieldSetStmt, lowerIncDec, lowerIncDecTarget, lowerPrefixUnary, } from "./expressions/updates.js";
+import { lowerDeleteExpression } from "./primitive-throws.js";
 import { awaitDynThenable, programMayDefineThenables } from "./thenables.js";
 import { awaitsChildThenable } from "./handle-properties.js";
 export { lowerInstanceOf } from "./expressions/relational.js";
@@ -299,7 +305,23 @@ function lowerExprInner(lowerer, expr) {
             if (operand)
                 return operand;
             if (target && target.kind !== "union" && !typeEquals(target, inner.type)) {
-                const helper = lowerer.narrowedArmHelper(inner.type.unionId, target, loc, assertedCalleeMessage(expr, target));
+                const unionId = inner.type.unionId;
+                const messages = assertedFailureMessages(lowerer, expr, unionId, target);
+                if (messages !== null && messages.size > 1) {
+                    // Each failing arm throws the TypeError Node gives the operation
+                    // that consumes the value (`x!.f` on null or on undefined).
+                    const local = lowerer.declareHiddenLocal("%asserted", inner.type);
+                    const extracted = checkedArmExtraction(lowerer, varRef(local.id, inner.type, loc), lowerer.armTag(unionId, target), target, (found) => staleReadMessage(expr, found));
+                    if (extracted)
+                        return {
+                            kind: "seqExpr",
+                            stmts: [{ kind: "varDecl", localId: local.id, init: inner, loc }],
+                            result: extracted,
+                            type: target,
+                            loc,
+                        };
+                }
+                const helper = lowerer.narrowedArmHelper(unionId, target, loc, messages?.size === 1 ? [...messages][0] : undefined);
                 if (helper) {
                     return lowerer.checkedNarrowCall(helper, inner, target, loc);
                 }
@@ -661,6 +683,11 @@ function lowerExprInner(lowerer, expr) {
             ? "'new.target' (no runtime invocation record exists in compiled code)"
             : `'${name}' (module-loader metadata has no equivalent in a compiled binary)`);
     }
+    // `delete` in expression position: a primitive base answers the way the
+    // statement form does (true, or Node's ToObject TypeError); other bases
+    // keep the fence.
+    if (ts.isDeleteExpression(expr))
+        return lowerDeleteExpression(lowerer, expr);
     const entry = UNSUPPORTED_EXPR[expr.kind];
     if (entry)
         lowerer.unsupported(entry.code, expr, entry.feature);
@@ -1445,19 +1472,24 @@ const NUMERIC_COMPOUNDS = new Set([
     ts.SyntaxKind.GreaterThanGreaterThanEqualsToken,
     ts.SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken,
 ]);
-/** The TypeError Node raises when an asserted callee (`t[k]!(…)`, `o.f!()`)
- * holds no function: `!` is erased, so the call itself throws "<callee> is
- * not a function" in V8's spelling of the callee. */
-function assertedCalleeMessage(expr, target) {
-    if (target.kind !== "func")
-        return undefined;
-    let child = expr;
-    while (ts.isParenthesizedExpression(child.parent))
-        child = child.parent;
-    const call = child.parent;
-    if (!ts.isCallExpression(call) || call.expression !== child || call.questionDotToken)
-        return undefined;
-    return `${v8CalleeText(expr.expression)} is not a function`;
+/** The TypeErrors Node throws when the operation consuming `expr!` (a
+ * member read, a call) finds one of the union's other arms instead of
+ * `target`, or null when that operation does not throw for them (the
+ * stranded-value message applies). A call on a value of another arm throws
+ * "<callee> is not a function" in V8's spelling of the callee, because `!`
+ * is erased and the call itself throws. */
+function assertedFailureMessages(lowerer, expr, unionId, target) {
+    const arms = lowerer.unions.get(unionId)?.arms ?? [];
+    const messages = new Set();
+    for (const found of arms) {
+        if (typeEquals(found, target))
+            continue;
+        const message = staleReadMessage(expr, found);
+        if (message === null)
+            return null;
+        messages.add(message);
+    }
+    return messages.size > 0 ? messages : null;
 }
 /** Whether the use of `t[i]!` tells undefined from NaN: a converting use
  * that takes the value itself (see convertingUseOf), or a destination that
@@ -1924,6 +1956,24 @@ export function lowerOptionalNumber(lowerer, operand, loc, narrowedNode) {
         ? value
         : { kind: "seqExpr", stmts: prefix, result: value, type: F64, loc };
 }
+/** A numeric operand of an operator: the binary arithmetic and bitwise six
+ * (and their ordering comparisons), unary `+`, `-` and `~`, and compound
+ * assignment's read and right side. JavaScript applies ToNumber to a
+ * `null`/`undefined` LITERAL — 0 and NaN — so the operand lowers to a
+ * number literal, the form every other ToNumber fold already uses.
+ *
+ * Other numeric uses keep `lowerOptionalNumber`'s optional-union handling
+ * alone, because their callers fold a unit literal themselves: a builtin's
+ * ToNumber argument emits the same NaN, and an element key keeps its
+ * property-key semantics (`a[null]` reads `a.null`, not `a[0]`). Only a
+ * JavaScript source reaches this with a unit operand; TypeScript rejects the
+ * position (TS18050) before any lowering runs.
+ */
+export function lowerOperatorNumber(lowerer, operand, loc, narrowedNode) {
+    if (operand.kind === "unitLit")
+        return numLit(operand.unit === "null" ? 0 : NaN, loc);
+    return lowerOptionalNumber(lowerer, operand, loc, narrowedNode);
+}
 /** A number argument of a builtin that converts it with ToNumber (Math
  * functions, String.fromCharCode, the global isNaN/isFinite, DataView
  * offsets and values). ToNumber(undefined) is NaN, so a missing value — an
@@ -2161,6 +2211,12 @@ export function lowerAbsenceProbe(lowerer, node) {
     const header = lowerer.lowerHttpHeadersElement(expr);
     if (header)
         return header;
+    // A keyed read through a value HELD from process.env (`const env =
+    // process.env; env[k] ?? fallback`) aliases the live table: the ordinary
+    // lowering is getenv, whose `string | undefined` result already carries
+    // the missing arm this probe reconstructs for record keys.
+    if (heldEnvValueType(lowerer, expr.expression) !== null)
+        return null;
     const receiverT = lowerer.mapTypeOf(lowerer.typeOf(expr.expression));
     if (receiverT?.kind === "record") {
         const shape = lowerer.shapes.get(receiverT.shapeId);
@@ -2254,10 +2310,16 @@ export function lowerDynMemberAssignment(lowerer, expr, recv) {
     const loc = locOf(expr);
     const target = expr.left;
     const receiver = lowerer.declareHiddenLocal("%setReceiver", DYN);
-    const keyValue = ts.isElementAccessExpression(target)
+    const boxedKey = ts.isElementAccessExpression(target)
         ? lowerer.lowerExprExpecting(target.argumentExpression, DYN)
         : lowerer.coerceToExpected({ kind: "strLit", value: target.name.text, type: STRING, loc }, DYN);
-    const key = lowerer.declareHiddenLocal("%setKey", DYN);
+    // A key that is a string before boxing is its own property key: the
+    // write takes it as a string, without boxing it and coercing it back.
+    const stringKey = ts.isElementAccessExpression(target) &&
+        boxedKey.kind === "dynFrom" &&
+        boxedKey.value.type.kind === "string";
+    const keyValue = stringKey ? boxedKey.value : boxedKey;
+    const key = lowerer.declareHiddenLocal("%setKey", stringKey ? STRING : DYN);
     const raw = lowerer.lowerExpr(expr.right);
     const value = raw.type.kind === "void"
         ? {
@@ -2285,8 +2347,12 @@ export function lowerDynMemberAssignment(lowerer, expr, recv) {
                 kind: "exprStmt",
                 expr: {
                     kind: "libCall",
-                    fn: "dyn.keySetComputed",
-                    args: [varRef(receiver.id, DYN, loc), varRef(key.id, DYN, loc), stored],
+                    fn: stringKey ? "dyn.keySet" : "dyn.keySetComputed",
+                    args: [
+                        varRef(receiver.id, DYN, loc),
+                        varRef(key.id, stringKey ? STRING : DYN, loc),
+                        stored,
+                    ],
                     type: VOID,
                     loc,
                 },
@@ -2354,6 +2420,16 @@ const NODE_CONSTRUCTOR_GLOBALS = new Set([
 /** An operand of `+` with a string: ToString of ToPrimitive with the
  * default hint, which tries a class instance's valueOf before toString. */
 export function concatOperand(lowerer, e, node) {
+    // `+` converts an object with ToPrimitive's default hint, which tries
+    // valueOf before toString: a linked copy or a record with a kept source
+    // adds as its source does (record-links.ts).
+    if (e.type.kind === "record" &&
+        recordMayKeepSource(lowerer, e.type) &&
+        lowerer.shapes
+            .get(e.type.shapeId)
+            ?.fields.every((f) => f.name !== "toString" && f.name !== "valueOf") === true &&
+        nullProtoRecordShape(lowerer, e.type) === null)
+        return recordStringCall(lowerer, e, "primitive", e.loc, "toString");
     return (classToStringConversion(lowerer, e, "default", node) ??
         classUnionToString(lowerer, e, "default", node) ??
         lowerer.ensureString(e, node));