@scriptc/compiler 0.4.3 → 0.4.4

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

@@ -26,7 +26,7 @@ import { lowerSafeIndexRead, tryLowerIndexTruthiness, tryLowerNumericIndexRead,
 import { nsMemberIdentOf } from "./lower-namespaces.js";
 import { bindingNeverReassigned } from "./binding-analysis.js";
 import { implicitMonoFile } from "./generic-functions.js";
-import { lowerTaggedTemplate } from "./lower-calls.js";
+import { lowerPrimitiveUnionNumber, lowerTaggedTemplate } from "./lower-calls.js";
 import { unitOnlyUnion } from "../type-mapper.js";
 import { lowerYield } from "./lower-generators.js";
 import { unionWideningTags } from "../../ir/analysis.js";
@@ -272,6 +272,14 @@ function lowerExprInner(lowerer, expr) {
             const use = runtimeOptionalUseOf(expr);
             if (runtimeOptionalAssertionErases(lowerer, expr, inner, use))
                 return inner;
+            // A destination that holds null or undefined keeps the value, as `!`
+            // does in JavaScript (`return cache.get(key)!` from a function that
+            // returns `T | null`); the destination's own coercion re-tags it.
+            if (assertionDestinationHoldsNullish(lowerer, expr, inner.type))
+                return inner;
+            const operand = assertionOperand(lowerer, expr, inner, target ?? null, loc);
+            if (operand)
+                return operand;
             if (target && target.kind !== "union" && !typeEquals(target, inner.type)) {
                 const helper = lowerer.narrowedArmHelper(inner.type.unionId, target, loc);
                 if (helper) {
@@ -723,6 +731,198 @@ export function assertedElementKeepsUndefined(lowerer, node) {
     return (admits(contextual) ||
         ((contextual.flags & ts.TypeFlags.Union) !== 0 && constituentTypes(contextual).some(admits)));
 }
+/** Whether `node!` is a returned value, an arrow function's body or a call
+ * argument whose destination type (the return or parameter type) is `any`
+ * or `unknown` (as for `String(x!)` and `Number(x!)`) or holds null or
+ * undefined that the union `inner` holds and the assertion would remove.
+ * Bindings and assignments are left out: the checker narrows them to the
+ * asserted type for later reads. */
+function assertionDestinationHoldsNullish(lowerer, node, inner) {
+    const holdsNull = lowerer.armTag(inner.unionId, NULL_T) >= 0;
+    const holdsUndefined = lowerer.armTag(inner.unionId, UNDEFINED_T) >= 0;
+    if (!holdsNull && !holdsUndefined)
+        return false;
+    let outer = node;
+    while (ts.isParenthesizedExpression(outer.parent))
+        outer = outer.parent;
+    const parent = outer.parent;
+    const destination = (ts.isReturnStatement(parent) && parent.expression === outer) ||
+        (ts.isArrowFunction(parent) && parent.body === outer) ||
+        ((ts.isCallExpression(parent) || ts.isNewExpression(parent)) &&
+            parent.arguments?.nodes.includes(outer) === true);
+    if (!destination)
+        return false;
+    const contextual = lowerer.checker.getContextualType(outer);
+    if (!contextual)
+        return false;
+    const nullish = ts.TypeFlags.Any |
+        ts.TypeFlags.Unknown |
+        (holdsNull ? ts.TypeFlags.Null : 0) |
+        (holdsUndefined && !optionalStdlibParameter(lowerer, parent, outer)
+            ? ts.TypeFlags.Undefined
+            : 0);
+    if ((contextual.flags & ts.TypeFlags.Union) === 0)
+        return (contextual.flags & nullish) !== 0;
+    return constituentTypes(contextual).some((type) => (type.flags & nullish) !== 0);
+}
+/** Whether `argument` of `call` binds an optional parameter of a standard
+ * library declaration (`decoder.decode(input?)`). The undefined such a
+ * parameter's type holds comes from its optionality, and the builtin
+ * lowerings read the argument as the declared type, so `x!` keeps the
+ * checked narrowing there. */
+function optionalStdlibParameter(lowerer, call, argument) {
+    if (!ts.isCallExpression(call) && !ts.isNewExpression(call))
+        return false;
+    const declaration = lowerer.checker.getResolvedSignature(call)?.declaration;
+    if (declaration === undefined || !lowerer.isStdlibFile(ts.getSourceFileOfNode(declaration)))
+        return false;
+    const index = call.arguments?.nodes.indexOf(argument) ?? -1;
+    const parameter = declaration.parameters?.nodes[index];
+    return (parameter !== undefined &&
+        parameter.dotDotDotToken === undefined &&
+        (parameter.questionToken !== undefined || parameter.initializer !== undefined));
+}
+/** `x!` as the operand of an operator that converts its operands: an
+ * arithmetic, bitwise, relational or equality operator, `+`, a compound
+ * assignment, a unary `-`, `+`, `~` or `!`, a template span, or an argument
+ * of a Math function. `!` performs no runtime check,
+ * so a value that still holds undefined or null reaches the operator, which
+ * converts it as JavaScript does: NaN or 0 in arithmetic, false in a
+ * comparison, "undefined" or "null" in a string. Returns the operand to
+ * use, or null where the assertion narrows as usual. A numeric use gets the
+ * value converted with ToNumber; other uses get the union itself. */
+function assertionOperand(lowerer, expr, inner, target, loc) {
+    if (inner.type.kind !== "union" || target === null || target.kind === "union")
+        return null;
+    const arms = lowerer.unions.get(inner.type.unionId)?.arms;
+    if (!arms?.some(isUnitType) ||
+        !arms.every((arm) => arm.kind === "f64" || arm.kind === "string" || arm.kind === "bool" || isUnitType(arm)))
+        return null;
+    // Array and typed-array element reads keep their own handling of a
+    // missing element.
+    let operand = expr.expression;
+    while (ts.isParenthesizedExpression(operand))
+        operand = operand.expression;
+    if (ts.isElementAccessExpression(operand)) {
+        const kind = lowerer.mapTypeOf(lowerer.typeOf(operand.expression))?.kind;
+        if (kind === "array" || kind === "bytes")
+            return null;
+    }
+    const use = convertingUseOf(lowerer, expr);
+    if (use === null)
+        return null;
+    if (use === "value")
+        return inner;
+    return lowerPrimitiveUnionNumber(lowerer, inner, expr, loc);
+}
+/** How the converting use of `x!` (see assertionOperand) reads it:
+ * "number" where the use applies ToNumber, "value" where the consumer
+ * lowers the union itself (strings, equality, truthiness), null for other
+ * uses. */
+function convertingUseOf(lowerer, expr) {
+    let outer = expr;
+    while (ts.isParenthesizedExpression(outer.parent))
+        outer = outer.parent;
+    const parent = outer.parent;
+    if (ts.isTemplateSpan(parent))
+        return parent.expression === outer ? "value" : null;
+    if (ts.isPrefixUnaryExpression(parent)) {
+        if (parent.operator === ts.SyntaxKind.ExclamationToken)
+            return "value";
+        return parent.operator === ts.SyntaxKind.MinusToken ||
+            parent.operator === ts.SyntaxKind.PlusToken ||
+            parent.operator === ts.SyntaxKind.TildeToken
+            ? "number"
+            : null;
+    }
+    if (ts.isCallExpression(parent) && parent.arguments.nodes.includes(outer)) {
+        const callee = parent.expression;
+        return ts.isPropertyAccessExpression(callee) &&
+            stdlibGlobalNameOf(lowerer, callee.expression) === "Math"
+            ? "number"
+            : null;
+    }
+    if (!ts.isBinaryExpression(parent))
+        return null;
+    const op = parent.operatorToken.kind;
+    if (EQUALITY_OPERATORS.has(op))
+        return "value";
+    const other = parent.left === outer ? parent.right : parent.left;
+    const isString = (node) => (lowerer.typeOf(node).flags & ts.TypeFlags.StringLike) !== 0;
+    // With a string on either side, `+` concatenates and a comparison
+    // compares strings. `undefined + 1` and `undefined + undefined` are NaN,
+    // which a string-typed result cannot hold, so `+` takes the union only
+    // with a string partner that is not itself asserted. A partner that may
+    // hold a string or a number at run time (`any`, `unknown`) also gets the
+    // union, and `+` decides between concatenation and addition when it runs.
+    if (op === ts.SyntaxKind.PlusToken || op === ts.SyntaxKind.PlusEqualsToken) {
+        if (op === ts.SyntaxKind.PlusEqualsToken && parent.right !== outer)
+            return null;
+        let partner = other;
+        while (ts.isParenthesizedExpression(partner))
+            partner = partner.expression;
+        if (isString(other))
+            return ts.isNonNullExpression(partner) ? null : "value";
+        if (!numericPartner(lowerer.typeOf(other)))
+            return "value";
+        return isString(expr) ? null : "number";
+    }
+    if (RELATIONAL_OPERATORS.has(op))
+        return isString(other) || isString(expr) ? "value" : "number";
+    if (NUMERIC_OPERATORS.has(op))
+        return "number";
+    return NUMERIC_COMPOUNDS.has(op) && parent.right === outer ? "number" : null;
+}
+/** A `+` partner whose every value is a number, a boolean, null or
+ * undefined: `+` adds with it. */
+function numericPartner(type) {
+    const numeric = ts.TypeFlags.NumberLike |
+        ts.TypeFlags.BooleanLike |
+        ts.TypeFlags.Null |
+        ts.TypeFlags.Undefined |
+        ts.TypeFlags.Void;
+    return (type.flags & ts.TypeFlags.Union) !== 0
+        ? constituentTypes(type).every((part) => (part.flags & numeric) !== 0)
+        : (type.flags & numeric) !== 0;
+}
+const EQUALITY_OPERATORS = new Set([
+    ts.SyntaxKind.EqualsEqualsEqualsToken,
+    ts.SyntaxKind.ExclamationEqualsEqualsToken,
+    ts.SyntaxKind.EqualsEqualsToken,
+    ts.SyntaxKind.ExclamationEqualsToken,
+]);
+const RELATIONAL_OPERATORS = new Set([
+    ts.SyntaxKind.LessThanToken,
+    ts.SyntaxKind.GreaterThanToken,
+    ts.SyntaxKind.LessThanEqualsToken,
+    ts.SyntaxKind.GreaterThanEqualsToken,
+]);
+const NUMERIC_OPERATORS = new Set([
+    ts.SyntaxKind.MinusToken,
+    ts.SyntaxKind.AsteriskToken,
+    ts.SyntaxKind.SlashToken,
+    ts.SyntaxKind.PercentToken,
+    ts.SyntaxKind.AsteriskAsteriskToken,
+    ts.SyntaxKind.AmpersandToken,
+    ts.SyntaxKind.BarToken,
+    ts.SyntaxKind.CaretToken,
+    ts.SyntaxKind.LessThanLessThanToken,
+    ts.SyntaxKind.GreaterThanGreaterThanToken,
+    ts.SyntaxKind.GreaterThanGreaterThanGreaterThanToken,
+]);
+const NUMERIC_COMPOUNDS = new Set([
+    ts.SyntaxKind.MinusEqualsToken,
+    ts.SyntaxKind.AsteriskEqualsToken,
+    ts.SyntaxKind.SlashEqualsToken,
+    ts.SyntaxKind.PercentEqualsToken,
+    ts.SyntaxKind.AsteriskAsteriskEqualsToken,
+    ts.SyntaxKind.AmpersandEqualsToken,
+    ts.SyntaxKind.BarEqualsToken,
+    ts.SyntaxKind.CaretEqualsToken,
+    ts.SyntaxKind.LessThanLessThanEqualsToken,
+    ts.SyntaxKind.GreaterThanGreaterThanEqualsToken,
+    ts.SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken,
+]);
 export function runtimeOptionalAssertionErases(lowerer, expr, inner, use) {
     if (inner.type.kind !== "union" ||
         !use?.optional ||
@@ -847,6 +1047,10 @@ export function lowerCondition(lowerer, expr) {
         e.name.text === "setPrototypeOf" &&
         lowerer.isStdlibGlobal(e.expression, "Object"))
         return { kind: "boolLit", value: true, type: BOOL, loc: locOf(e) };
+    // `if (runtimeBuffer)` over an alias of the Buffer global (a
+    // capability probe): Node always defines Buffer.
+    if (lowerer.isStdlibGlobal(e, "Buffer"))
+        return { kind: "boolLit", value: true, type: BOOL, loc: locOf(e) };
     if (ts.isPropertyAccessExpression(e)) {
         const presence = lowerPromiseThenPresence(lowerer, e, {
             kind: "boolLit",