@scriptc/compiler 0.3.2 → 0.3.3

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

@@ -1,8 +1,13 @@
+import { lowerProtocolPropertyRead } from "./class-protocol-dispatch.js";
 import { generatorDrain } from "./iterator-adapters.js";
+import { lowerEventObjectProperty, lowerEventObjectPropertyWrite } from "./lower-event-target.js";
 import { lowerEventStaticProperty } from "./builtins/numbers.js";
 import { lowerUnionEquality, tagEqualityMayMissAlias } from "./strict-equality.js";
 import { isOptionalProcessStreamProperty } from "./builtins/process.js";
 import { lowerWorkerMetadata } from "./builtins/workers.js";
+import { lowerBlobInstanceof } from "./builtins/blob.js";
+import { lowerKeyObjectInstanceof } from "./builtins/key-object.js";
+import { STATS_TYPE_TESTS } from "./builtins/filesystem.js";
 import { threadsImportOf } from "../threads-import.js";
 import { experimentalImportOf, lifetimeRegionMemberOf } from "../experimental-import.js";
 import { dynUndefinedExpr, nodeThrowExpr, numLit, strLit, varRef } from "../../ir/build.js";
@@ -24,7 +29,7 @@ import { checkedClassAssertion, checkedClassUnionAssertion } from "./class-asser
 import { checkedArmExtraction } from "./coercions/unions.js";
 import { narrowClassUnion, narrowStoredClassValue } from "./class-unions.js";
 import { lowerUnionFieldRead, lowerUnionFieldWrite } from "./expressions/union-fields.js";
-import { captureContextArguments } from "./function-context.js";
+import { captureContextArguments, declareContextLocal } from "./function-context.js";
 import { OBJECT_CALLABLE_VALUES } from "./surfaces.js";
 import { wasiGuestPath } from "../../wasi-paths.js";
 import { BIGINT_T, BYTES_ELEMENT_NAME, BOOL, CAUGHT, DYN, DYN_HANDLE_KINDS, F64, NULL_T, REF_TRUTHY_KINDS, REGEX, RUNTIME_ERROR_CLASSES, SEARCH_PARAMS_T, STRING, UNDEFINED_T, VOID, arrayOf, canAdaptDynFuncTo, canDynCheckTo, canBoxFuncIntoDyn, funcOf, isDynTypedRefType, isSupportedArrayElem, isUnitType, shapeHasAccessorSlots, typeEquals, typeKey, unionContainerArmsOk, } from "../../ir/ir.js";
@@ -50,7 +55,7 @@ import { funcTypeFromParamShapes } from "./call-signatures.js";
 import { implicitMonoFile, objLitGenericFnInfoOf, objLitGenericFnNodeOf, requireObjLitGenericReceiver, } from "./generic-functions.js";
 import { lowerTaggedTemplate } from "./lower-calls.js";
 import { mixinFnOfCallee } from "./lower-mixins.js";
-import { isConstAssertionTypeNode, isGenericCallableMemberType, isOsConstantsType, isParseArgsDynTypeName, underConstAssertion, unitOnlyUnion, withUnitArm, } from "../type-mapper.js";
+import { isConstAssertionTypeNode, isGenericCallableMemberType, isLegacyUrlSymbol, isOsConstantsType, isParseArgsDynTypeName, underConstAssertion, unitOnlyUnion, withUnitArm, } from "../type-mapper.js";
 import { iteratorResultValueRead, lowerYield } from "./lower-generators.js";
 import { errorPropertyRead, errorPropertyWrite, errorToStringCall } from "./error-methods.js";
 import { lowerStreamProperty, lowerStreamStateProperty, streamSidesOf } from "./lower-stream.js";
@@ -79,6 +84,7 @@ import { lowerUrlAssignment } from "./builtins/url.js";
 import { jsBindingHasOpenWrites } from "./lower-stmts.js";
 import { checkedClassInstanceOf } from "./class-construction.js";
 import { lowerModuleNamespaceElement } from "./module-namespace-elements.js";
+import { isPerfEntryType, perfEntryTag } from "./builtins/performance.js";
 /** A template piece's RAW text (String.raw's contract: escapes stay
  * characters). 7's client AST ships no rawText at runtime (the typing
  * declares it; the serialized node data omits it), so the raw span comes
@@ -1786,7 +1792,7 @@ function lowerExprInner(lowerer, expr) {
         // attached this name to it (`exports.<name> =` nowhere in the
         // file), the honest answer is undefined. tsc types the read off the
         // REPLACEMENT (its CJS model is identity-blind), which is exactly
-        // the silent divergence this lowering closes. Reads in modules with
+        // the undiagnosed divergence this lowering closes. Reads in modules with
         // real `exports.<name> =` attachments keep their fences.
         {
             const ex = lowerReplacedExportsRead(lowerer, expr);
@@ -1801,6 +1807,13 @@ function lowerExprInner(lowerer, expr) {
             if (tm)
                 return tm;
         }
+        // Property signatures of class-backed protocols read implementing
+        // classes' fields directly.
+        if (!hasOptionalChainGuard(expr.expression)) {
+            const typed = lowerProtocolPropertyRead(lowerer, expr);
+            if (typed)
+                return typed;
+        }
         const handled = lowerer.lowerProcessEnvGet(expr) ??
             lowerer.lowerServerProperty(expr) ??
             // diagnostics_channel Channel receivers — name/hasSubscribers
@@ -1831,6 +1844,7 @@ function lowerExprInner(lowerer, expr) {
             // the inner access maps no type of its own.
             lowerStreamStateProperty(lowerer, expr) ??
             lowerStreamObjectProperty(lowerer, expr) ??
+            lowerEventObjectProperty(lowerer, expr) ??
             lowerer.lowerUnionProperty(expr) ??
             lowerer.lowerFieldRead(expr);
         // A union-typed field read narrows like an identifier when the
@@ -2078,7 +2092,8 @@ function lowerExprInner(lowerer, expr) {
         if (isParseArgsDynProperty(lowerer, expr) ||
             isStatFsDynProperty(lowerer, expr) ||
             segmentDataProperty ||
-            osConstants) {
+            osConstants ||
+            isLegacyUrlSymbol(lowerer.checker.getSymbolAtLocation(expr.name), lowerer)) {
             const recv = lowerer.lowerExpr(expr.expression);
             if (recv.type.kind === "dyn") {
                 const key = {
@@ -4313,10 +4328,10 @@ export function lowerIntrinsicProperty(lowerer, expr) {
             const receiver = lowerer.lowerExpr(expr.expression);
             return { kind: "libCall", fn: "stats.size", args: [receiver], type: F64, loc: locOf(expr) };
         }
-        if (name === "isFile" || name === "isDirectory") {
+        if (Object.hasOwn(STATS_TYPE_TESTS, name)) {
             lowerer.unsupported("SC1090", expr, `Stats methods as values (call '${name}' directly)`);
         }
-        lowerer.noLowering(`Stats.${name}`, expr, "isFile(), isDirectory(), isSymbolicLink(), dev, ino, size, blocks, nlink, atimeMs, mtimeMs, and ctimeMs are the supported Stats members", lowerer.checker.getSymbolAtLocation(expr.name));
+        lowerer.noLowering(`Stats.${name}`, expr, "isFile(), isDirectory(), isSymbolicLink(), isBlockDevice(), isCharacterDevice(), isFIFO(), isSocket(), dev, mode, nlink, uid, gid, rdev, blksize, ino, size, blocks, atimeMs, mtimeMs, ctimeMs, birthtimeMs, atime, mtime, ctime, and birthtime are the supported Stats members", lowerer.checker.getSymbolAtLocation(expr.name));
     }
     if (kind === "date") {
         const methods = new Set([
@@ -7149,6 +7164,8 @@ export function ensureString(lowerer, e, node) {
         // prints its elements like an array (not lowered — fenced) — every
         // other record is Object.prototype.toString's constant.
         const shape = lowerer.shapes.get(e.type.shapeId);
+        if (isPerfEntryType(lowerer, e.type))
+            return perfEntryTag(lowerer, e, e.type, e.loc);
         if (shape && !shape.tuple && !shape.fields.some((f) => f.name === "toString")) {
             return { kind: "toString", operand: e, type: STRING, loc: e.loc };
         }
@@ -7299,7 +7316,23 @@ export function lowerAsExpression(lowerer, expr) {
                 lowerer.unsupported("SC1090", expr, "opaque structural views of classes or accessor records (name the property's concrete type to retain native accessor dispatch)");
             }
             const boxed = lowerer.coerceInto(expr, inner, DYN);
-            return boxed.kind === "dynFrom" ? { ...boxed, liveRef: true } : boxed;
+            // Only references box live; a scalar or unit source (`value as
+            // unknown as View`) is an ordinary snapshot.
+            const seen = new Set();
+            const live = (type) => {
+                if (type.kind === "record" ||
+                    type.kind === "array" ||
+                    type.kind === "bytes" ||
+                    isDynTypedRefType(type))
+                    return true;
+                if (type.kind !== "union" || seen.has(type.unionId))
+                    return false;
+                seen.add(type.unionId);
+                return lowerer.unions.get(type.unionId)?.arms.some(live) ?? false;
+            };
+            return boxed.kind === "dynFrom" && live(boxed.value.type)
+                ? { ...boxed, liveRef: true }
+                : boxed;
         }
         // Collection assertions are interface views only: their backing
         // value must already have the same native key/element/value layout.
@@ -7943,6 +7976,13 @@ export function lowerBinary(lowerer, expr) {
         if (ts.isPropertyAccessExpression(expr.left) || ts.isElementAccessExpression(expr.left)) {
             fenceNodeModuleMutation(lowerer, expr.left, "assignment");
         }
+        // The writable Event accessors on Event subclass instances, in value
+        // position (`const r = (event.returnValue = false)`).
+        if (op === ts.SyntaxKind.EqualsToken && ts.isPropertyAccessExpression(expr.left)) {
+            const eventWrite = lowerEventObjectPropertyWrite(lowerer, expr.left, expr.right);
+            if (eventWrite)
+                return eventWrite;
+        }
         // `x = e` in EXPRESSION position (`while ((idx = s.indexOf("\n")) !== -1)`,
         // `f(x = v)`): evaluate e once, write the binding, yield the assigned
         // value — JS evaluation order. Variable targets only (locals and module
@@ -8279,14 +8319,24 @@ export function lowerBinary(lowerer, expr) {
                 reference.kind === "union" ||
                 DYN_HANDLE_KINDS.has(reference.kind)) &&
                 lowerer.dynConvertible(reference)) {
+                // Records, arrays and byte views compare by the capsule identity
+                // their dyn reads produce, including when they arrive through a
+                // union (an optional array field read from a typed record).
+                const liveArm = (type) => {
+                    if (type.kind === "array" || type.kind === "bytes")
+                        return true;
+                    const shape = type.kind === "record" ? lowerer.shapes.get(type.shapeId) : undefined;
+                    return !!shape && (shape.fields.length > 0 || shape.indexValue !== undefined);
+                };
                 const boxed = {
                     kind: "dynFrom",
                     value: scalarSide,
                     type: DYN,
                     loc: scalarSide.loc,
                     ...(reference.kind === "record" ||
-                        reference.kind === "array" ||
-                        reference.kind === "bytes"
+                        liveArm(reference) ||
+                        (reference.kind === "union" &&
+                            (lowerer.unions.get(reference.unionId)?.arms.some(liveArm) ?? false))
                         ? { liveRef: true }
                         : {}),
                 };
@@ -8550,8 +8600,8 @@ export function lowerBinary(lowerer, expr) {
     // the checker typed the binding as `string`. An optional string is not
     // itself a string operand for `+`: `undefined + 1` and
     // `undefined + undefined` are NaN, while a present string concatenates.
-    // Keep this predicate exact so a nullable string does not silently take
-    // the string path either.
+    // Keep this predicate exact so a nullable string does not take the
+    // string path either.
     const optionalStringType = (type) => {
         if (type.kind !== "union")
             return false;
@@ -9545,6 +9595,7 @@ function typeofAnswer(arm) {
         case "searchParams":
         case "stats":
         case "fileHandle":
+        case "dir":
         case "spawnRes":
         case "child":
         case "netServer":
@@ -10175,6 +10226,14 @@ export function lowerInstanceOf(lowerer, expr, loc) {
             return { kind: "libCall", fn: "event.is", args: [value, kind], type: BOOL, loc };
         }
     }
+    {
+        const blob = lowerBlobInstanceof(lowerer, expr);
+        if (blob)
+            return blob;
+        const keyObject = lowerKeyObjectInstanceof(lowerer, expr);
+        if (keyObject)
+            return keyObject;
+    }
     if (lowerer.isStdlibGlobal(expr.right, "SharedArrayBuffer")) {
         const value = lowerer.coerceInto(expr.left, lowerer.lowerExpr(expr.left), DYN);
         return { kind: "libCall", fn: "sharedArrayBuffer.is", args: [value], type: BOOL, loc };
@@ -10629,7 +10688,7 @@ function lowerPrivateIn(lowerer, expr, priv, loc) {
     // A GENERIC family: JS has ONE runtime class and ONE brand for every
     // instantiation, while these layouts mint one class per instantiation
     // — a cross-instantiation check would answer false where Node says
-    // true, so the family fences rather than silently splitting the brand.
+    // true, so the family reports SC1090 instead of splitting the brand.
     if (info.generic || info.genericInstance) {
         lowerer.unsupported("SC1090", expr, `'${pname} in …' inside a generic class (JS shares one brand across every instantiation; these layouts mint one class per instantiation)`);
     }
@@ -13027,8 +13086,8 @@ function lowerFieldCompoundValue(lowerer, access, op, rhsNode, loc) {
     // accounting; dot spelling only — symbol-keyed element targets are
     // static fields): read the member (dynKeyGet), VALIDATE it as a
     // number (dynCheck — a non-number member throws the catchable
-    // TypeError where JS would ToNumber-coerce; loud, never a silent
-    // NaN — SEMANTICS.md), combine, write back (dyn.keySet). The
+    // TypeError where JS would ToNumber-coerce; it throws instead of
+    // producing NaN — SEMANTICS.md), combine, write back (dyn.keySet). The
     // receiver and member read are saved before evaluating the RHS.
     if (ts.isPropertyAccessExpression(access)) {
         let probed = tryLowerExpression(lowerer, access.expression);
@@ -13102,22 +13161,33 @@ function lowerFieldCompoundValue(lowerer, access, op, rhsNode, loc) {
     target.obj = save(target.obj, "%compoundReceiver");
     // Accessors observe getter, RHS side effects, then setter, all through
     // the saved receiver.
-    const read = save(lowerer.fieldGetExpr(target, locOf(access), access), "%compoundOld");
+    const fieldRead = lowerer.fieldGetExpr(target, locOf(access), access);
+    // `+=` on a stored string field reads it into a mutable local, so the
+    // concat below can append to that local in place.
+    const storedString = op === "+" &&
+        fieldRead.type.kind === "string" &&
+        target.fieldType.kind === "string" &&
+        (target.container === "class" || target.container === "record");
+    let read;
+    if (storedString) {
+        const old = declareContextLocal(lowerer.ctx, "%compoundOld", STRING, true, undefined, undefined);
+        body.push({ kind: "varDecl", localId: old.id, init: fieldRead, loc: fieldRead.loc });
+        read = varRef(old.id, STRING, fieldRead.loc);
+    }
+    else {
+        read = save(fieldRead, "%compoundOld");
+    }
     const rhs = save(rhsNode ? lowerer.lowerExpr(rhsNode) : { kind: "numLit", value: 1, type: F64, loc }, "%compoundRhs");
     const numericRhs = rhs.type.kind === "dyn" && isJsSourceFile(access.getSourceFile())
         ? { kind: "dynCheck", value: rhs, type: F64, loc: rhs.loc }
         : lowerOptionalNumber(lowerer, rhs, loc);
     let value;
+    let appended = null;
     const numericRead = lowerOptionalNumber(lowerer, read, loc, access);
     const bigintValue = rhsNode ? bigintCompoundValue(op, read, rhs, loc) : null;
     if (op === "+" && read.type.kind === "string") {
-        value = {
-            kind: "strConcat",
-            left: read,
-            right: lowerer.ensureString(rhs, rhsNode ?? access),
-            type: STRING,
-            loc,
-        };
+        appended = lowerer.ensureString(rhs, rhsNode ?? access);
+        value = { kind: "strConcat", left: read, right: appended, type: STRING, loc };
     }
     else if (numericRead.type.kind === "f64" && numericRhs.type.kind === "f64") {
         value = { kind: "bin", op, left: numericRead, right: numericRhs, type: F64, loc };
@@ -13142,6 +13212,26 @@ function lowerFieldCompoundValue(lowerer, access, op, rhsNode, loc) {
     else {
         lowerer.unsupported("SC1043", access);
     }
+    if (storedString && rhs.type.kind === "string" && read.kind === "varRef" && appended !== null) {
+        // The field gives up its value before the concat (no code runs in
+        // between: both operands are already strings), and the concat is the
+        // self-append `old = old + rhs`, which hands the local's reference to
+        // the runtime: the old string is then uniquely owned unless something
+        // else holds it, and is appended to in place. Repeated `this.text += s`
+        // is linear rather than a copy per append.
+        const oldId = read.localId;
+        const oldLoc = read.loc;
+        const oldRef = () => varRef(oldId, STRING, oldLoc);
+        const concat = {
+            kind: "strConcat",
+            left: oldRef(),
+            right: appended,
+            type: STRING,
+            loc,
+        };
+        body.push(lowerer.fieldSetStmt(target, { kind: "strLit", value: "", type: STRING, loc }, loc, access), { kind: "assign", localId: oldId, value: concat, loc }, lowerer.fieldSetStmt(target, oldRef(), loc, access));
+        return { kind: "seqExpr", stmts: body, result: oldRef(), type: STRING, loc };
+    }
     const result = save(value, "%compoundResult");
     body.push(lowerer.fieldSetStmt(target, lowerer.coerceInto(access, result, target.fieldType), loc, access));
     return { kind: "seqExpr", stmts: body, result, type: result.type, loc };