@scriptc/compiler 0.4.7 → 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,7 +46,8 @@ 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";
@@ -52,9 +56,10 @@ 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";
@@ -300,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);
                 }
@@ -662,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);
@@ -1446,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
@@ -2279,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"
         ? {
@@ -2310,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,
                 },
@@ -2379,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));