@scriptc/compiler 0.3.5 → 0.4.0

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

@@ -200,11 +200,11 @@ function looseAssertTypeSupported(lowerer, type) {
 function lowerAssertLooseEqual(lowerer, expr, loc, negated) {
     const surface = negated ? "assert.notEqual" : "assert.equal";
     requireStatementPosition(lowerer, expr, surface);
-    if (expr.arguments.length < 2 || expr.arguments.length > 3) {
-        lowerer.noLowering(`${surface} with ${expr.arguments.length} arguments`, expr);
+    if (expr.arguments.nodes.length < 2 || expr.arguments.nodes.length > 3) {
+        lowerer.noLowering(`${surface} with ${expr.arguments.nodes.length} arguments`, expr);
     }
-    const aNode = expr.arguments[0];
-    const bNode = expr.arguments[1];
+    const aNode = expr.arguments.nodes[0];
+    const bNode = expr.arguments.nodes[1];
     if (!aNode || !bNode)
         throw new InternalCompilerError(`${surface} arity fence returned unexpectedly`);
     const left = lowerer.lowerExpr(aNode);
@@ -246,7 +246,7 @@ function lowerAssertLooseEqual(lowerer, expr, loc, negated) {
     });
     const actual = inspectOnFailure(a);
     const expected = inspectOnFailure(b);
-    const { msg, hasMsg } = lowerMessageArg(lowerer, expr.arguments[2], loc);
+    const { msg, hasMsg } = lowerMessageArg(lowerer, expr.arguments.nodes[2], loc);
     const result = {
         kind: "libCall",
         fn: "assert.looseResult",
@@ -262,7 +262,7 @@ function lowerAssertLooseEqual(lowerer, expr, loc, negated) {
  * side's array type. Literals have no side effects, so lowering order is
  * unobservable. */
 function lowerComparedOperands(lowerer, aNode, bNode, loc) {
-    const emptyArrayLit = (n) => ts.isArrayLiteralExpression(n) && n.elements.length === 0;
+    const emptyArrayLit = (n) => ts.isArrayLiteralExpression(n) && n.elements.nodes.length === 0;
     const emptyOf = (t) => ({ kind: "arrayLit", elems: [], type: t, loc });
     // A dyn other side adopts number[] — the dyn array a boxed empty
     // literal builds is elementless, so any elem type serves.
@@ -311,13 +311,13 @@ function typeHasUnion(lowerer, t, visiting) {
 function lowerAssertLooseDeep(lowerer, expr, loc, negated) {
     const surface = negated ? "assert.notDeepEqual" : "assert.deepEqual";
     requireStatementPosition(lowerer, expr, surface);
-    if (expr.arguments.length < 2 || expr.arguments.length > 3) {
-        lowerer.noLowering(`${surface} with ${expr.arguments.length} arguments`, expr);
+    if (expr.arguments.nodes.length < 2 || expr.arguments.nodes.length > 3) {
+        lowerer.noLowering(`${surface} with ${expr.arguments.nodes.length} arguments`, expr);
     }
-    const aNode = expr.arguments[0];
-    const bNode = expr.arguments[1];
+    const aNode = expr.arguments.nodes[0];
+    const bNode = expr.arguments.nodes[1];
     const { a, b } = lowerComparedOperands(lowerer, aNode, bNode, loc);
-    const { msg, hasMsg } = lowerMessageArg(lowerer, expr.arguments[2], loc);
+    const { msg, hasMsg } = lowerMessageArg(lowerer, expr.arguments.nodes[2], loc);
     refuseUnrenderedDeepOperands(lowerer, surface, [
         [a, aNode],
         [b, bNode],
@@ -400,13 +400,13 @@ function boxDeepOperand(lowerer, surface, e, node, a, b) {
 function lowerAssertPartialDeep(lowerer, expr, loc) {
     const surface = "assert.partialDeepStrictEqual";
     requireStatementPosition(lowerer, expr, surface);
-    if (expr.arguments.length < 2 || expr.arguments.length > 3) {
-        lowerer.noLowering(`${surface} with ${expr.arguments.length} arguments`, expr);
+    if (expr.arguments.nodes.length < 2 || expr.arguments.nodes.length > 3) {
+        lowerer.noLowering(`${surface} with ${expr.arguments.nodes.length} arguments`, expr);
     }
-    const aNode = expr.arguments[0];
-    const bNode = expr.arguments[1];
+    const aNode = expr.arguments.nodes[0];
+    const bNode = expr.arguments.nodes[1];
     const { a, b } = lowerComparedOperands(lowerer, aNode, bNode, loc);
-    const { msg, hasMsg } = lowerMessageArg(lowerer, expr.arguments[2], loc);
+    const { msg, hasMsg } = lowerMessageArg(lowerer, expr.arguments.nodes[2], loc);
     refuseUnrenderedDeepOperands(lowerer, surface, [
         [a, aNode],
         [b, bNode],
@@ -701,7 +701,7 @@ export function lowerAssertDirectCall(lowerer, expr, loc) {
     if (module !== "assert" && module !== "assert/strict")
         return null;
     const calleeSym = lowerer.checker.getSymbolAtLocation(callee);
-    const decl = calleeSym ? lowerer.checker.declarationsOf(calleeSym)[0] : undefined;
+    const decl = calleeSym ? calleeSym.declarations[0] : undefined;
     if (decl && ts.isNamespaceImport(decl)) {
         lowerer.unsupported("SC1013", expr, "calling a module namespace object (Node throws TypeError there — " +
             'use the default import: import assert from "node:assert")');
@@ -713,22 +713,22 @@ export function lowerAssertDirectCall(lowerer, expr, loc) {
  * call's SOURCE TEXT (Node re-reads the file at runtime — the frontend has
  * the same bytes at compile time). */
 function lowerAssertOk(lowerer, expr, loc) {
-    requireStatementPosition(lowerer, expr, expr.expression.getText());
-    if (expr.arguments.length < 1 || expr.arguments.length > 2) {
-        lowerer.noLowering(`${expr.expression.getText()} with ${expr.arguments.length} arguments`, expr, "the supported forms are assert(value) and assert(value, message)");
+    requireStatementPosition(lowerer, expr, ts.getTextOfNode(expr.expression));
+    if (expr.arguments.nodes.length < 1 || expr.arguments.nodes.length > 2) {
+        lowerer.noLowering(`${ts.getTextOfNode(expr.expression)} with ${expr.arguments.nodes.length} arguments`, expr, "the supported forms are assert(value) and assert(value, message)");
     }
-    const valueNode = expr.arguments[0];
+    const valueNode = expr.arguments.nodes[0];
     const stmts = [];
     const value = stableValue(lowerer, stmts, lowerer.lowerExpr(valueNode), "%assertOkValue", loc);
     const pass = stableValue(lowerer, stmts, lowerer.ensureBool(value, valueNode), "%assertOkPass", loc);
-    const msgNode = expr.arguments[1];
+    const msgNode = expr.arguments.nodes[1];
     let msg;
     let generated = false;
     if (!msgNode || (ts.isIdentifier(msgNode) && msgNode.text === "undefined")) {
         // Node reads the CALLSITE LINE and slices the expression out of it
         // (internal/errors/error_source.js) — a call spanning lines truncates
         // at the first newline, so the compile-time text does too.
-        const source = expr.getText().split("\n", 1)[0];
+        const source = ts.getTextOfNode(expr).split("\n", 1)[0];
         const text = `The expression evaluated to a falsy value:\n\n  ${source}\n`;
         msg = { kind: "strLit", value: text, type: STRING, loc };
         generated = true;
@@ -752,12 +752,12 @@ function lowerAssertOk(lowerer, expr, loc) {
  * assert.ok over a false literal. */
 function lowerAssertFail(lowerer, expr, loc) {
     requireStatementPosition(lowerer, expr, "assert.fail");
-    if (expr.arguments.length > 1) {
-        lowerer.noLowering(`assert.fail with ${expr.arguments.length} arguments`, expr, "the supported form is fail(message?) — the deprecated fail(actual, expected, ...) has no lowering");
+    if (expr.arguments.nodes.length > 1) {
+        lowerer.noLowering(`assert.fail with ${expr.arguments.nodes.length} arguments`, expr, "the supported form is fail(message?) — the deprecated fail(actual, expected, ...) has no lowering");
     }
     let msg;
     let generated;
-    const msgNode = expr.arguments[0];
+    const msgNode = expr.arguments.nodes[0];
     const stmts = [];
     if (!msgNode || (ts.isIdentifier(msgNode) && msgNode.text === "undefined")) {
         msg = { kind: "strLit", value: "Failed", type: STRING, loc };
@@ -796,13 +796,13 @@ function lowerAssertFail(lowerer, expr, loc) {
 function lowerAssertEqual(lowerer, expr, loc, negated, deep) {
     const surface = `assert.${deep ? (negated ? "notDeepStrictEqual" : "deepStrictEqual") : negated ? "notStrictEqual" : "strictEqual"}`;
     requireStatementPosition(lowerer, expr, surface);
-    if (expr.arguments.length < 2 || expr.arguments.length > 3) {
-        lowerer.noLowering(`${surface} with ${expr.arguments.length} arguments`, expr);
+    if (expr.arguments.nodes.length < 2 || expr.arguments.nodes.length > 3) {
+        lowerer.noLowering(`${surface} with ${expr.arguments.nodes.length} arguments`, expr);
     }
-    const aNode = expr.arguments[0];
-    const bNode = expr.arguments[1];
+    const aNode = expr.arguments.nodes[0];
+    const bNode = expr.arguments.nodes[1];
     const { a, b } = lowerComparedOperands(lowerer, aNode, bNode, loc);
-    const { msg, hasMsg } = lowerMessageArg(lowerer, expr.arguments[2], loc);
+    const { msg, hasMsg } = lowerMessageArg(lowerer, expr.arguments.nodes[2], loc);
     // An Assert instance with skipPrototype: Node compares own properties
     // without the prototype check, so operands of different static types (two
     // classes, a class and a record) can be equal. They compare as
@@ -940,8 +940,8 @@ function lowerAssertEqual(lowerer, expr, loc, negated, deep) {
     // the call through a binding whose DECLARED constructor differs from the
     // value's runtime one compares by the declared brand (SEMANTICS.md).
     if (a.type.kind === "bytes" && typeEquals(a.type, b.type)) {
-        const brandA = bytesBrandOf(lowerer, expr.arguments[0]);
-        const brandB = bytesBrandOf(lowerer, expr.arguments[1]);
+        const brandA = bytesBrandOf(lowerer, expr.arguments.nodes[0]);
+        const brandB = bytesBrandOf(lowerer, expr.arguments.nodes[1]);
         if (!deep) {
             // Brands shape only the failure HEADER (same-structure vs
             // reference-equal expectation); an unclassifiable side defers to the
@@ -956,7 +956,7 @@ function lowerAssertEqual(lowerer, expr, loc, negated, deep) {
             };
         }
         if (!skipPrototype && (brandA === null || brandB === null)) {
-            lowerer.noLowering(`${surface} of typed-array values whose constructor is not in the static type`, brandA === null ? expr.arguments[0] : expr.arguments[1], "Node's deep equality compares prototypes (a Buffer is never deep-equal to a plain Uint8Array) — annotate the value so its constructor is visible");
+            lowerer.noLowering(`${surface} of typed-array values whose constructor is not in the static type`, brandA === null ? expr.arguments.nodes[0] : expr.arguments.nodes[1], "Node's deep equality compares prototypes (a Buffer is never deep-equal to a plain Uint8Array) — annotate the value so its constructor is visible");
         }
         // The brand is the prototype; skipPrototype ignores it.
         const sameBrand = skipPrototype || brandA === brandB;
@@ -1076,15 +1076,15 @@ function deepCheckCall(lowerer, a, b, variant, verdictOf, negated, msg, hasMsg,
 function lowerAssertMatch(lowerer, expr, loc, negated) {
     const surface = negated ? "assert.doesNotMatch" : "assert.match";
     requireStatementPosition(lowerer, expr, surface);
-    if (expr.arguments.length < 2 || expr.arguments.length > 3) {
-        lowerer.noLowering(`${surface} with ${expr.arguments.length} arguments`, expr);
+    if (expr.arguments.nodes.length < 2 || expr.arguments.nodes.length > 3) {
+        lowerer.noLowering(`${surface} with ${expr.arguments.nodes.length} arguments`, expr);
     }
-    const s = lowerer.lowerExprExpecting(expr.arguments[0], STRING);
-    const re = lowerer.lowerExpr(expr.arguments[1]);
+    const s = lowerer.lowerExprExpecting(expr.arguments.nodes[0], STRING);
+    const re = lowerer.lowerExpr(expr.arguments.nodes[1]);
     if (re.type.kind !== "regex") {
-        lowerer.noLowering(`${surface} with a non-regex pattern`, expr.arguments[1], "the second argument must be a regular expression");
+        lowerer.noLowering(`${surface} with a non-regex pattern`, expr.arguments.nodes[1], "the second argument must be a regular expression");
     }
-    const { msg, hasMsg } = lowerMessageArg(lowerer, expr.arguments[2], loc);
+    const { msg, hasMsg } = lowerMessageArg(lowerer, expr.arguments.nodes[2], loc);
     const neg = { kind: "boolLit", value: negated, type: BOOL, loc };
     return { kind: "libCall", fn: "assert.match", args: [s, re, neg, msg, hasMsg], type: VOID, loc };
 }
@@ -1147,13 +1147,13 @@ function classifyThrowsExpected(lowerer, surface, node, loc) {
     while (ts.isParenthesizedExpression(obj))
         obj = obj.expression;
     if (ts.isObjectLiteralExpression(obj)) {
-        if (obj.properties.length === 0) {
+        if (obj.properties.nodes.length === 0) {
             lowerer.noLowering(`${surface} with an empty expected object`, obj, "Node rejects this (the error 'may not be an empty object') — name at least one of name/message/code");
         }
         // Duplicate keys keep the LAST value (JS object-literal semantics);
         // property order is preserved for argument evaluation.
         const byId = new Map();
-        for (const prop of obj.properties) {
+        for (const prop of obj.properties.nodes) {
             const named = ts.isPropertyAssignment(prop) || ts.isShorthandPropertyAssignment(prop) ? prop : null;
             if (!named || !(ts.isIdentifier(named.name) || ts.isStringLiteral(named.name))) {
                 lowerer.noLowering(`${surface} with this expected-object property form`, prop, "plain `key: value` properties are the lowered form");
@@ -1231,12 +1231,12 @@ function classifyThrowsExpected(lowerer, surface, node, loc) {
 function lowerAssertThrows(lowerer, expr, loc, doesNot = false) {
     const surface = doesNot ? "assert.doesNotThrow" : "assert.throws";
     requireStatementPosition(lowerer, expr, surface);
-    if (expr.arguments.length < 1 || expr.arguments.length > 3) {
-        lowerer.noLowering(`${surface} with ${expr.arguments.length} arguments`, expr, `the supported forms are ${surface}(fn), ${surface}(fn, expected), and ${surface}(fn, expected, message)`);
+    if (expr.arguments.nodes.length < 1 || expr.arguments.nodes.length > 3) {
+        lowerer.noLowering(`${surface} with ${expr.arguments.nodes.length} arguments`, expr, `the supported forms are ${surface}(fn), ${surface}(fn, expected), and ${surface}(fn, expected, message)`);
     }
-    const fn = lowerer.lowerExpr(expr.arguments[0]);
+    const fn = lowerer.lowerExpr(expr.arguments.nodes[0]);
     if (fn.type.kind !== "func" || fn.type.params.length !== 0) {
-        lowerer.noLowering(`${surface} with this callback shape`, expr.arguments[0], "the callback must be a zero-parameter function");
+        lowerer.noLowering(`${surface} with this callback shape`, expr.arguments.nodes[0], "the callback must be a zero-parameter function");
     }
     const { expected, msg, hasMsg } = throwsArguments(lowerer, surface, expr, loc);
     if (doesNot)
@@ -1264,14 +1264,14 @@ function lowerAssertThrows(lowerer, expr, loc, doesNot = false) {
  * expectations fence — the runtime predicate is throw-shaped). */
 function lowerAssertRejects(lowerer, expr, loc, doesNot) {
     const surface = doesNot ? "assert.doesNotReject" : "assert.rejects";
-    if (expr.arguments.length < 1 || expr.arguments.length > 3) {
-        lowerer.noLowering(`${surface} with ${expr.arguments.length} arguments`, expr, `the supported forms are ${doesNot ? "doesNotReject" : "rejects"}(fn), (fn, expected), and (fn, expected, message)`);
+    if (expr.arguments.nodes.length < 1 || expr.arguments.nodes.length > 3) {
+        lowerer.noLowering(`${surface} with ${expr.arguments.nodes.length} arguments`, expr, `the supported forms are ${doesNot ? "doesNotReject" : "rejects"}(fn), (fn, expected), and (fn, expected, message)`);
     }
-    const recv = lowerer.lowerExpr(expr.arguments[0]);
+    const recv = lowerer.lowerExpr(expr.arguments.nodes[0]);
     const recvIsPromise = recv.type.kind === "promise";
     if (!recvIsPromise &&
         (recv.type.kind !== "func" || recv.type.params.length !== 0 || recv.type.ret.kind !== "promise")) {
-        lowerer.noLowering(`${surface} with this first argument`, expr.arguments[0], "an async (promise-returning) zero-parameter function or a promise are the lowered forms " +
+        lowerer.noLowering(`${surface} with this first argument`, expr.arguments.nodes[0], "an async (promise-returning) zero-parameter function or a promise are the lowered forms " +
             "(a bare thenable — an object with a then method — has no lowering: wrap it, e.g. Promise.resolve().then(() => thenable))");
     }
     const { expected, msg, hasMsg } = throwsArguments(lowerer, surface, expr, loc);
@@ -1312,29 +1312,29 @@ function refuseNoErrorShape(lowerer, surface, expr, expected) {
         // Node itself rejects this form (ERR_INVALID_ARG_TYPE: "expected"
         // must be a function or RegExp) — the fence is the compile-time
         // statement of the same rule.
-        lowerer.noLowering(`${surface} with an object-shape expectation`, expr.arguments[1], "Node rejects this form when the callback fails — use a class, a regex, a validation callback, or a bare call");
+        lowerer.noLowering(`${surface} with an object-shape expectation`, expr.arguments.nodes[1], "Node rejects this form when the callback fails — use a class, a regex, a validation callback, or a bare call");
     }
 }
 /** The shared expected/message argument split (arguments 2 and 3): a
  * string expected IS the message. Only no-error assertions permit a third
  * argument in this form, evaluating it before ignoring its value. */
 function throwsArguments(lowerer, surface, expr, loc) {
-    const expectedNode = expr.arguments[1];
+    const expectedNode = expr.arguments.nodes[1];
     // A literal `undefined` expected counts as omitted (Node reads the
     // message from the THIRD argument in that spelling).
     const expected = expectedNode && !(ts.isIdentifier(expectedNode) && expectedNode.text === "undefined")
         ? classifyThrowsExpected(lowerer, surface, expectedNode, loc)
         : { form: "bare" };
     if (expected.form === "message") {
-        if (expr.arguments.length === 3 &&
+        if (expr.arguments.nodes.length === 3 &&
             surface !== "assert.doesNotThrow" &&
             surface !== "assert.doesNotReject") {
-            lowerer.noLowering(`${surface} with a string expected argument AND a message`, expr.arguments[2], "Node rejects this form (the string IS the message) — use an expected shape second");
+            lowerer.noLowering(`${surface} with a string expected argument AND a message`, expr.arguments.nodes[2], "Node rejects this form (the string IS the message) — use an expected shape second");
         }
-        if (expr.arguments[2]) {
+        if (expr.arguments.nodes[2]) {
             // No-error assertions ignore the third value in the string-second
             // form, while ordinary argument evaluation still runs it once.
-            const ignored = lowerer.lowerExpr(expr.arguments[2]);
+            const ignored = lowerer.lowerExpr(expr.arguments.nodes[2]);
             const message = lowerer.declareHiddenLocal("%assertNoErrorMessage", STRING);
             return {
                 expected,
@@ -1353,7 +1353,7 @@ function throwsArguments(lowerer, surface, expr, loc) {
         }
         return { expected, msg: expected.msg, hasMsg: expected.hasMsg };
     }
-    const { msg, hasMsg } = lowerMessageArg(lowerer, expr.arguments[2], loc);
+    const { msg, hasMsg } = lowerMessageArg(lowerer, expr.arguments.nodes[2], loc);
     return { expected, msg, hasMsg };
 }
 /** The extra call-site arguments a form carries into its helper, in the
@@ -1755,10 +1755,10 @@ function ifErrorLibFn(lowerer, t) {
  * an interned helper. Anything else fences. */
 function lowerAssertIfError(lowerer, expr, loc) {
     requireStatementPosition(lowerer, expr, "assert.ifError");
-    if (expr.arguments.length !== 1) {
-        lowerer.noLowering(`assert.ifError with ${expr.arguments.length} arguments`, expr, "the supported form is ifError(value)");
+    if (expr.arguments.nodes.length !== 1) {
+        lowerer.noLowering(`assert.ifError with ${expr.arguments.nodes.length} arguments`, expr, "the supported form is ifError(value)");
     }
-    const argNode = expr.arguments[0];
+    const argNode = expr.arguments.nodes[0];
     const argT = lowerer.mapTypeOf(lowerer.typeOf(argNode));
     if (argT && isUnitType(argT)) {
         // null/undefined can never throw, and a unit-typed expression has no
@@ -1896,6 +1896,7 @@ const BYTES_BRANDS = new Set([
     "Int8Array",
     "Int16Array",
     "Int32Array",
+    "Float16Array",
     "Float32Array",
     "Float64Array",
     "BigInt64Array",