@scriptc/compiler 0.3.4 → 0.3.5

package/dist/frontend/lowering/lower-exprs.d.ts

@@ -205,6 +205,10 @@ export declare function lowerAbsenceProbe(lowerer: Lowerer, node: ts.Expression)
  * change the target or the value used by the operator. The expression yields
  * the computed value before a typed array or Buffer coerces it for storage. */
 export declare function lowerElementCompound(lowerer: Lowerer, expr: ts.BinaryExpression, op: CompoundOp): IrExpr;
+/** `a[i] op= rhs` in statement position: a string array append becomes the
+ * canonical `a[i] = a[i] + rhs` store (receiver and index saved first),
+ * which the backend appends in place; other forms keep the value path. */
+export declare function lowerElementCompoundStatement(lowerer: Lowerer, expr: ts.BinaryExpression, op: CompoundOp): IrStmt;
 /** JavaScript callable members live on the closure, so aliases and chained
  * writes share the same storage as Object.defineProperties. */
 export declare function lowerNativeFunctionAssignment(lowerer: Lowerer, expr: ts.BinaryExpression): IrExpr | null;

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

@@ -22,6 +22,7 @@ import { literalUnionArm } from "../union-discriminants.js";
  * comparisons, nullish coalescing and optional chains, conditions and
  * ToBoolean/ToString coercion helpers, and field/element reads and writes
  * (FieldTarget). */
+import { isFsStreamMember, lowerFsStreamProperty } from "./builtins/fs-streams.js";
 import * as ts from "../ts7/adapter.js";
 import { isZlibStreamMember, lowerZlibStreamBytesWritten } from "./builtins/compression.js";
 import { constituentTypes } from "../ts7/checker.js";
@@ -599,6 +600,7 @@ function lowerExprInner(lowerer, expr) {
             const sym = lowerer.resolveValueSymbol(expr);
             const projection = sym ? lowerer.staticCallables.get(sym) : undefined;
             if (projection?.kind === "promisified-exec-file" ||
+                projection?.kind === "promisified-exec" ||
                 projection?.kind === "promisified-builtin") {
                 lowerer.unsupported("SC1090", expr, `a promisified builtin as a value (call '${expr.text}' directly)`);
             }
@@ -4166,6 +4168,8 @@ export function lowerIntrinsicProperty(lowerer, expr) {
     const numberMember = lowerer.stdlibGlobalMember(expr, "Number");
     if (numberMember === "parseInt" || numberMember === "parseFloat")
         return lowerNumberParserValue(lowerer, numberMember, locOf(expr));
+    if (lowerer.stdlibGlobalMember(expr, "Buffer") === "poolSize")
+        return { kind: "libCall", fn: "buffer.poolSize", args: [], type: F64, loc: locOf(expr) };
     if (lowerer.stdlibGlobalMember(expr, "Buffer") === "isBuffer")
         return lowerCheckedPredicateValue(lowerer, "Buffer.isBuffer", "buffer", locOf(expr));
     if (lowerer.stdlibGlobalMember(expr, "Date") === "now")
@@ -6343,6 +6347,21 @@ function tupleLiteralIndex(node) {
  * change the target or the value used by the operator. The expression yields
  * the computed value before a typed array or Buffer coerces it for storage. */
 export function lowerElementCompound(lowerer, expr, op) {
+    const lowered = lowerElementCompoundParts(lowerer, expr, op, false);
+    if (!lowered.expr)
+        throw new InternalCompilerError("a compound element value lowered to statements");
+    return lowered.expr;
+}
+/** `a[i] op= rhs` in statement position: a string array append becomes the
+ * canonical `a[i] = a[i] + rhs` store (receiver and index saved first),
+ * which the backend appends in place; other forms keep the value path. */
+export function lowerElementCompoundStatement(lowerer, expr, op) {
+    const lowered = lowerElementCompoundParts(lowerer, expr, op, true);
+    if (lowered.stmts)
+        return { kind: "block", body: lowered.stmts, loc: locOf(expr) };
+    return { kind: "exprStmt", expr: lowered.expr, loc: locOf(expr) };
+}
+function lowerElementCompoundParts(lowerer, expr, op, statement) {
     const target = expr.left;
     fenceNodeModuleMutation(lowerer, target, "assignment");
     const loc = locOf(expr);
@@ -6377,7 +6396,7 @@ export function lowerElementCompound(lowerer, expr, op) {
             },
             loc,
         });
-        return { kind: "seqExpr", stmts, result: value, type: DYN, loc };
+        return { expr: { kind: "seqExpr", stmts, result: value, type: DYN, loc }, stmts: null };
     }
     const receiverType = checked.type.kind === "array" || checked.type.kind === "bytes"
         ? checked.type
@@ -6435,6 +6454,27 @@ export function lowerElementCompound(lowerer, expr, op) {
     const valueType = elementType.kind === "union" && lowerer.armTag(elementType.unionId, UNDEFINED_T) >= 0
         ? lowerer.stripUndefinedArm(elementType)
         : elementType;
+    if (statement &&
+        op === "+" &&
+        receiver.type.kind === "array" &&
+        receiver.type.elem.kind === "string") {
+        // Receiver, index, old element (read inside the concat), rhs, write.
+        const appended = {
+            kind: "strConcat",
+            left: oldValue,
+            right: lowerer.ensureString(rhs, expr.right),
+            type: STRING,
+            loc,
+        };
+        return {
+            expr: null,
+            stmts: [
+                { kind: "varDecl", localId: receiverLocal.id, init: receiver, loc },
+                { kind: "varDecl", localId: indexLocal.id, init: index, loc },
+                { kind: "arraySet", arr: receiverRef(), index: indexRef(), value: appended, loc },
+            ],
+        };
+    }
     let computed;
     if (op === "+" && valueType.kind === "string") {
         computed = {
@@ -6457,17 +6497,18 @@ export function lowerElementCompound(lowerer, expr, op) {
     }
     else if (valueType.kind === "dyn" && isJsSourceFile(expr.getSourceFile())) {
         const left = lowerer.coerceToExpected(oldRef(), DYN), right = lowerer.coerceToExpected(rhs, DYN);
-        const numeric = ["-", "*", "/", "%", "**"].includes(op);
-        computed = {
-            kind: "libCall",
-            fn: op === "+" ? "dyn.add" : numeric ? "dyn.arithmetic" : "dyn.bitwise",
-            args: op === "+" ? [left, right] : [left, right, strLit(op, loc)],
-            type: DYN,
-            loc,
-        };
+        computed = dynCompoundValue(op, left, right, loc);
+    }
+    else if (rhs.type.kind === "dyn" &&
+        receiver.type.kind === "array" &&
+        lowerer.dynConvertible(oldValue.type) &&
+        lowerer.dynConvertible(valueType)) {
+        // An untyped right operand: the expanded `a[i] = a[i] op rhs`, checked
+        // back into the element type.
+        computed = lowerer.coerceInto(expr, dynCompoundValue(op, lowerer.coerceToExpected(oldRef(), DYN), lowerer.coerceToExpected(rhs, DYN), loc), valueType);
     }
     else {
-        lowerer.unsupported("SC1043", expr);
+        compoundUnsupported(lowerer, expr, op, oldValue.type, rhs.type);
     }
     const resultLocal = lowerer.declareHiddenLocal("%compoundResult", computed.type);
     const resultRef = () => varRef(resultLocal.id, computed.type, loc);
@@ -6475,17 +6516,20 @@ export function lowerElementCompound(lowerer, expr, op) {
         ? arrayValueStore(lowerer, receiverRef(), indexRef(), resultRef(), receiver.type.elem, loc)
         : { kind: "bytesSet", arr: receiverRef(), index: indexRef(), value: resultRef(), loc };
     return {
-        kind: "seqExpr",
-        stmts: [
-            { kind: "varDecl", localId: receiverLocal.id, init: receiver, loc },
-            { kind: "varDecl", localId: indexLocal.id, init: index, loc },
-            { kind: "varDecl", localId: oldLocal.id, init: oldValue, loc },
-            { kind: "varDecl", localId: resultLocal.id, init: computed, loc },
-            write,
-        ],
-        result: resultRef(),
-        type: computed.type,
-        loc,
+        expr: {
+            kind: "seqExpr",
+            stmts: [
+                { kind: "varDecl", localId: receiverLocal.id, init: receiver, loc },
+                { kind: "varDecl", localId: indexLocal.id, init: index, loc },
+                { kind: "varDecl", localId: oldLocal.id, init: oldValue, loc },
+                { kind: "varDecl", localId: resultLocal.id, init: computed, loc },
+                write,
+            ],
+            result: resultRef(),
+            type: computed.type,
+            loc,
+        },
+        stmts: null,
     };
 }
 /** ToString of one stabilized `string[]` element read for `+=`: a missing
@@ -7477,7 +7521,7 @@ export function lowerPrefixUnary(lowerer, expr) {
                 ? { kind: "dynCheck", value: raw, type: F64, loc }
                 : lowerOptionalNumber(lowerer, raw, loc, expr.operand);
             if (operand.type.kind !== "f64")
-                lowerer.unsupported("SC1043", expr);
+                operatorUnsupported(lowerer, expr, "-", [raw.type]);
             if (operand.kind === "numLit")
                 return { ...operand, value: -operand.value, loc };
             return { kind: "unary", op: "-", operand, type: F64, loc };
@@ -7495,7 +7539,7 @@ export function lowerPrefixUnary(lowerer, expr) {
             }
             const operand = lowerOptionalNumber(lowerer, raw, loc, expr.operand);
             if (operand.type.kind !== "f64")
-                lowerer.unsupported("SC1043", expr);
+                operatorUnsupported(lowerer, expr, "+", [raw.type]);
             return operand;
         }
         case ts.SyntaxKind.ExclamationToken: {
@@ -7524,7 +7568,7 @@ export function lowerPrefixUnary(lowerer, expr) {
             // otherwise numeric slot to the checked-dynamic tree.
             const operand = lowerOptionalNumber(lowerer, raw, loc, expr.operand);
             if (operand.type.kind !== "f64")
-                lowerer.unsupported("SC1043", expr);
+                operatorUnsupported(lowerer, expr, "~", [raw.type]);
             return { kind: "unary", op: "~", operand, type: F64, loc };
         }
         case ts.SyntaxKind.PlusPlusToken:
@@ -7781,7 +7825,7 @@ export function lowerIncDecTarget(lowerer, expr, target, prefix) {
         };
     }
     if (target.type.kind !== "f64")
-        lowerer.unsupported("SC1043", expr);
+        operatorUnsupported(lowerer, expr, op === "+" ? "++" : "--", [target.type]);
     return { kind: "incDec", op, prefix, localId: target.id, type: F64, loc };
 }
 /** Whether a lowered statement can live inside a seqExpr. These statements
@@ -7874,26 +7918,51 @@ export function lowerCompoundValueToTarget(lowerer, expr, compound, target) {
     if (numericRead.type.kind === "f64" && numericRhs.type.kind === "f64") {
         return lowerer.coerceInto(expr, { kind: "bin", op: compound, left: numericRead, right: numericRhs, type: F64, loc }, target.type);
     }
+    // An untyped operand: exactly the expanded `x = x op rhs` — the runtime
+    // operator on both values, then the checked conversion into the
+    // target's declared type (a string result for a number target throws the
+    // catchable TypeError, as the expanded assignment does).
     if ((target.type.kind === "dyn" || rhs.type.kind === "dyn") &&
-        isJsSourceFile(expr.getSourceFile())) {
+        (isJsSourceFile(expr.getSourceFile()) ||
+            (lowerer.dynConvertible(read.type) && lowerer.dynConvertible(rhs.type)))) {
         const left = lowerer.coerceInto(expr.left, read, DYN);
         const right = lowerer.coerceInto(expr.right, rhs, DYN);
-        const numeric = ["-", "*", "/", "%", "**"].includes(compound);
-        const computed = {
-            kind: "libCall",
-            fn: compound === "+" ? "dyn.add" : numeric ? "dyn.arithmetic" : "dyn.bitwise",
-            args: compound === "+"
-                ? [left, right]
-                : [left, right, { kind: "strLit", value: compound, type: STRING, loc }],
-            type: DYN,
-            loc,
-        };
-        return lowerer.coerceInto(expr, computed, target.type);
+        return lowerer.coerceInto(expr, dynCompoundValue(compound, left, right, loc), target.type);
     }
     const bigint = bigintCompoundValue(compound, read, rhs, loc);
     if (bigint)
         return bigint;
-    lowerer.unsupported("SC1043", expr);
+    compoundUnsupported(lowerer, expr, compound, read.type, rhs.type);
+}
+/** The runtime operator of a compound assignment over two checked-dynamic
+ * operands (Node's ToPrimitive/ToNumeric order lives in the runtime). */
+function dynCompoundValue(op, left, right, loc) {
+    const numeric = ["-", "*", "/", "%", "**"].includes(op);
+    return {
+        kind: "libCall",
+        fn: op === "+" ? "dyn.add" : numeric ? "dyn.arithmetic" : "dyn.bitwise",
+        args: op === "+" ? [left, right] : [left, right, strLit(op, loc)],
+        type: DYN,
+        loc,
+    };
+}
+/** An operand type in an SC1043 message: checked-dynamic values (`any`,
+ * `unknown`) are "untyped", everything else its quoted type. */
+function operandText(lowerer, t) {
+    return t.kind === "dyn" ? "untyped" : `'${lowerer.fmt(t)}'`;
+}
+/** SC1043 for a compound assignment whose operand types have no lowering,
+ * naming the operator and both types rather than the comparison wording. */
+function compoundUnsupported(lowerer, node, op, target, value) {
+    lowerer.unsupported("SC1043", node, `compound '${op}=' assignments of ${operandText(lowerer, value)} values to ${operandText(lowerer, target)} targets`);
+}
+/** SC1043 for an arithmetic, unary or update operator whose operand types
+ * have no lowering (comparisons keep the registry wording). */
+function operatorUnsupported(lowerer, node, op, operands) {
+    const [first, second] = operands;
+    lowerer.unsupported("SC1043", node, second === undefined
+        ? `'${op}' operations on ${operandText(lowerer, first)} values`
+        : `'${op}' operations on ${operandText(lowerer, first)} and ${operandText(lowerer, second)} values`);
 }
 /** Equality of two NaN-coded values (nan-coded-reads.ts), each of which may
  * stand for undefined and never holds a genuine NaN: Node's undefined equals
@@ -8782,7 +8851,7 @@ export function lowerBinary(lowerer, expr) {
                     };
                 }
             }
-            lowerer.unsupported("SC1043", expr);
+            operatorUnsupported(lowerer, expr, "+", [left.type, right.type]);
             break;
         case ts.SyntaxKind.MinusToken:
         case ts.SyntaxKind.AsteriskToken:
@@ -8790,7 +8859,7 @@ export function lowerBinary(lowerer, expr) {
         case ts.SyntaxKind.PercentToken:
         case ts.SyntaxKind.AsteriskAsteriskToken: {
             if (!bothNum)
-                lowerer.unsupported("SC1043", expr);
+                operatorUnsupported(lowerer, expr, ts.tokenToString(op) ?? "?", [left.type, right.type]);
             const binOp = op === ts.SyntaxKind.MinusToken
                 ? "-"
                 : op === ts.SyntaxKind.AsteriskToken
@@ -8820,7 +8889,7 @@ export function lowerBinary(lowerer, expr) {
         case ts.SyntaxKind.GreaterThanGreaterThanToken:
         case ts.SyntaxKind.GreaterThanGreaterThanGreaterThanToken: {
             if (!bothNum)
-                lowerer.unsupported("SC1043", expr);
+                operatorUnsupported(lowerer, expr, ts.tokenToString(op) ?? "?", [left.type, right.type]);
             const bitOp = op === ts.SyntaxKind.AmpersandToken
                 ? "&"
                 : op === ts.SyntaxKind.BarToken
@@ -10533,10 +10602,12 @@ export function lowerInstanceOf(lowerer, expr, loc) {
     if (left.type.kind === "union") {
         const unionId = left.type.unionId;
         const arms = lowerer.unions.get(unionId)?.arms;
-        // Ordinary records and scalar values do not carry a class prototype.
-        // Dynamic/opaque runtime objects keep their existing instanceof fences.
+        // Ordinary records, arrays and scalar values do not carry a class
+        // prototype (no program class extends Array). Dynamic/opaque runtime
+        // objects keep their existing instanceof fences.
         if (arms?.every((arm) => arm.kind === "object" ||
             arm.kind === "record" ||
+            arm.kind === "array" ||
             arm.kind === "f64" ||
             arm.kind === "string" ||
             arm.kind === "bool" ||
@@ -10595,6 +10666,10 @@ export function lowerInstanceOf(lowerer, expr, loc) {
             }
             return { kind: "call", callee: helper, args: [left], type: BOOL, loc };
         }
+        // A class arm could hold an instance: the test cannot be decided
+        // statically.
+        if (arms?.some((arm) => arm.kind === "object"))
+            lowerer.unsupported("SC1090", expr, "'instanceof' on a union of class instances and values without a class prototype test");
     }
     if (left.type.kind !== "object") {
         return readsClassAfter(lowerer, target, expr.right, [{ kind: "exprStmt", expr: left, loc }], {
@@ -13143,7 +13218,7 @@ function lowerFieldCompoundValue(lowerer, access, op, rhsNode, loc) {
                 ? { kind: "dynCheck", value: rhs, type: F64, loc: rhs.loc }
                 : lowerOptionalNumber(lowerer, rhs, loc);
             if (numericRhs.type.kind !== "f64")
-                lowerer.unsupported("SC1043", access);
+                compoundUnsupported(lowerer, access, op, F64, numericRhs.type);
             const value = save({ kind: "bin", op, left: cur, right: numericRhs, type: F64, loc }, "%compoundResult");
             const boxed = { kind: "dynFrom", value, type: DYN, loc };
             body.push({
@@ -13204,22 +13279,16 @@ function lowerFieldCompoundValue(lowerer, access, op, rhsNode, loc) {
     else if (bigintValue) {
         value = bigintValue;
     }
-    else if (target.fieldType.kind === "dyn" && isJsSourceFile(access.getSourceFile())) {
-        const numeric = ["-", "*", "/", "%", "**"].includes(op);
-        const left = lowerer.coerceToExpected(read, DYN);
-        const right = lowerer.coerceToExpected(rhs, DYN);
-        value = {
-            kind: "libCall",
-            fn: op === "+" ? "dyn.add" : numeric ? "dyn.arithmetic" : "dyn.bitwise",
-            args: op === "+"
-                ? [left, right]
-                : [left, right, { kind: "strLit", value: op, type: STRING, loc }],
-            type: DYN,
-            loc,
-        };
+    else if ((target.fieldType.kind === "dyn" && isJsSourceFile(access.getSourceFile())) ||
+        // An untyped right operand: the expanded `o.f = o.f op rhs`; the field
+        // write below checks the result into the declared field type.
+        (rhs.type.kind === "dyn" &&
+            lowerer.dynConvertible(read.type) &&
+            lowerer.dynConvertible(target.fieldType))) {
+        value = dynCompoundValue(op, lowerer.coerceToExpected(read, DYN), lowerer.coerceToExpected(rhs, DYN), loc);
     }
     else {
-        lowerer.unsupported("SC1043", access);
+        compoundUnsupported(lowerer, access, op, read.type, rhs.type);
     }
     if (storedString && rhs.type.kind === "string" && read.kind === "varRef" && appended !== null) {
         // The field gives up its value before the concat (no code runs in
@@ -13260,6 +13329,11 @@ function lowerStreamObjectProperty(lowerer, expr) {
     if (expr.name.text === "bytesWritten" && isZlibStreamMember(lowerer, expr)) {
         return lowerZlibStreamBytesWritten(lowerer, expr);
     }
+    if (isFsStreamMember(lowerer, expr)) {
+        const member = lowerFsStreamProperty(lowerer, expr);
+        if (member)
+            return member;
+    }
     return lowerStreamProperty(lowerer, expr, info);
 }
 /** The primitive-constructor closure (`String`/`Number`/`Boolean` as a