@scriptc/compiler 0.4.6 → 0.4.7

package/dist/frontend/type-mapper.js

@@ -1,5 +1,6 @@
 import { InternalCompilerError } from "../errors.js";
 import { keyedHelperName } from "./lowering/stable-names.js";
+import { contentDigest } from "./lowering/unit-journal.js";
 import { mockCallRecordType, mockContextType } from "./mock-shapes.js";
 import * as ts from "./ts7/adapter.js";
 import { bodyReadsArguments } from "./arguments-usage.js";
@@ -154,8 +155,10 @@ export const FETCH_AMBIENT_TYPES = [
     "ReadableStreamReadValueResult",
     "ReadableStreamReadDoneResult",
     "TransformStream",
+    "TransformStreamDefaultController",
     "WritableStream",
     "WritableStreamDefaultWriter",
+    "WritableStreamDefaultController",
     "Blob",
     "File",
     "BlobPropertyBag",
@@ -587,9 +590,41 @@ export class UnionRegistry {
      * the key its arms give. A unit that adds a recursive union changes
      * journalSizes, so the unions past a unit's start are interned ones. */
     journalTable() {
+        // The position of each union by id, for the unions indexed so far.
+        let indexes = new Map();
+        let indexed = 0;
+        const indexOf = (id) => {
+            if (indexed > this.unions.length) {
+                indexes = new Map();
+                indexed = 0;
+            }
+            for (; indexed < this.unions.length; indexed++)
+                indexes.set(this.unions[indexed].id, indexed);
+            const index = indexes.get(id);
+            return index !== undefined && this.unions[index]?.id === id ? index : undefined;
+        };
         return {
             name: "unions",
             size: () => this.unions.length,
+            digest: (key, before) => {
+                if (!this.byId.has(key))
+                    return null;
+                let index = indexOf(key);
+                if (index === undefined) {
+                    // A list that was cut and grown again holds other unions at the
+                    // positions indexed before.
+                    indexes = new Map();
+                    indexed = 0;
+                    index = indexOf(key);
+                }
+                if (index === undefined || index >= before)
+                    return null;
+                return contentDigest(JSON.stringify(this.unions[index]));
+            },
+            holds: (entry) => {
+                const def = JSON.parse(entry);
+                return this.byKey.has(unionKey(def.arms, def.discriminant));
+            },
             entries: (from) => {
                 const out = [];
                 for (const def of this.unions.slice(from)) {
@@ -601,6 +636,11 @@ export class UnionRegistry {
                 }
                 return out;
             },
+            agrees: (entries) => entries.every((entry) => {
+                const def = JSON.parse(entry);
+                const held = this.byKey.get(unionKey(def.arms, def.discriminant));
+                return held === undefined ? !this.byId.has(def.id) : held === def.id;
+            }),
             apply: (entries) => {
                 for (const entry of entries) {
                     const def = JSON.parse(entry);
@@ -1997,6 +2037,10 @@ function mapTypeInner(type, ctx) {
                 ts.symbolName(boxSym) === "String" ||
                 ts.symbolName(boxSym) === "Boolean") &&
             boxSym.declarations.some((d) => ctx.isStdlibFile(ts.getSourceFileOfNode(d)))) {
+            // Once the program creates wrapper objects, a slot of the boxed type
+            // may hold one: the checked-dynamic value holds both.
+            if (ctx.primitiveWrappers?.())
+                return DYN;
             return ts.symbolName(boxSym) === "Number"
                 ? F64
                 : ts.symbolName(boxSym) === "String"
@@ -2398,8 +2442,22 @@ function mapTypeInner(type, ctx) {
         }
     }
     const classView = mapClassView(widened, ctx);
-    if (classView !== undefined)
+    if (classView !== undefined) {
+        // An intersection of ONE compiled class instance with data-only object
+        // types is a class instance carrying expando properties
+        // (`Box & { preview?: Preview }`): the class owns the instance's
+        // storage and the other members are properties the instance carries at
+        // run time, so the class view has no single layout to answer (null).
+        // The checked-dynamic representation IS that object model — one object,
+        // the instance's identity and prototype, class fields reading and
+        // writing through the live view, extra members in its property table.
+        if (classView === null && widened.isIntersectionType()) {
+            const expando = mapClassExpandoIntersection(widened, ctx);
+            if (expando)
+                return expando;
+        }
         return classView;
+    }
     // Class instances name a program class. The same symbol with construct
     // signatures names its static side, mapped to classval below.
     const widenedSym = widened.getSymbol();
@@ -4275,6 +4333,13 @@ function mapTypeInner(type, ctx) {
     // (als.snapshot), called through the dyn call path.
     if (callSigs.length === 1 && isAsyncLocalStorageSnapshot(callSigs[0], ctx))
         return DYN;
+    // A process/net/stream `write` method taken as a value (`typeof
+    // process.stdout.write`, the saved original of an output guard): its
+    // overload set has no single compiled signature, and the value is the
+    // stream's replaceable method slot, so it is the checked-dynamic function
+    // the stream object hands out (scr_events.c ProcessStream).
+    if (callSigs.length > 1 && isStdlibStreamWriteOverloads(callSigs, ctx))
+        return DYN;
     if (callSigs.length === 1)
         return mapCallSignature(callSigs[0], ctx);
     // Records: object types whose members are all data properties (shorthand
@@ -4590,6 +4655,16 @@ function mapTypeInner(type, ctx) {
                 !unions.recursivePending(widened)) {
                 return DYN;
             }
+            // A module namespace beside another value in one slot (`[path.posix,
+            // path.win32]`, a `['posix', path.posix]` table row): a namespace has
+            // no union representation, and as a value it is the runtime's module
+            // object, so the slot is checked-dynamic. A namespace or null keeps
+            // its union (a probed process.getBuiltinModule result).
+            if (arms.some((a) => a.kind === "moduleNs") &&
+                arms.filter((a) => !isUnitType(a)).length > 1 &&
+                !unions.recursivePending(widened)) {
+                return DYN;
+            }
             // SEVERAL PROMISE ARMS are ONE: `Promise<A> | Promise<B>` is
             // `Promise<A | B>`. A promise arm's tag IS the `instanceof Promise`
             // test, so JavaScript cannot tell the arms apart at run time (both
@@ -4669,6 +4744,27 @@ function isAsyncLocalStorageSnapshot(sig, ctx) {
         ctx.isStdlibFile(ts.getSourceFileOfNode(decl)) &&
         isDeclaredInAmbientModule(decl, "async_hooks"));
 }
+const STREAM_WRITE_OWNERS = new Set(["Socket", "Writable", "WriteStream", "WritableStream"]);
+/** Every signature is a `write` method declared on a standard-library
+ * stream interface or class (net.Socket, stream.Writable, tty.WriteStream,
+ * NodeJS.WritableStream) — @types/node's or the fallback declarations'. */
+function isStdlibStreamWriteOverloads(sigs, ctx) {
+    return sigs.every((sig) => {
+        const decl = sig.declaration;
+        if (decl === undefined ||
+            !(ts.isMethodSignatureDeclaration(decl) || ts.isMethodDeclaration(decl)))
+            return false;
+        if (!ts.isIdentifier(decl.name) || decl.name.text !== "write")
+            return false;
+        const owner = decl.parent;
+        const ownerName = owner !== undefined && (ts.isInterfaceDeclaration(owner) || ts.isClassDeclaration(owner))
+            ? (owner.name?.text ?? null)
+            : null;
+        return (ownerName !== null &&
+            STREAM_WRITE_OWNERS.has(ownerName) &&
+            ctx.isStdlibFile(ts.getSourceFileOfNode(decl)));
+    });
+}
 function mapCallSignature(sig, ctx) {
     const { checker } = ctx;
     if (sig.getTypeParameters().length && ctx.erasingSignature !== sig)
@@ -6389,6 +6485,57 @@ function mapEqualConstituentsIntersection(widened, ctx) {
     }
     return same;
 }
+/** A CLASS INSTANCE carrying expando properties
+ * (`Box & { preview?: Preview }`): one compiled class constituent and
+ * data-only object constituents that are not part of the class's own
+ * storage. It has no native layout — the class owns the struct and the
+ * other constituents are properties the instance carries at run time —
+ * and the checked-dynamic representation IS that object model: the value
+ * is the instance (identity, prototype, method dispatch), the class fields
+ * read and write through the live view in both directions, and the expando
+ * members live in its property table. Every other intersection keeps its
+ * existing treatment: reached only where the class view found extra
+ * members, and refusing everything that is not one class plus data. */
+function mapClassExpandoIntersection(widened, ctx) {
+    const { checker } = ctx;
+    if (checker.getConstructSignatures(widened).length > 0)
+        return null;
+    let classPart = null;
+    const expandoParts = [];
+    for (const part of ts.constituentTypes(widened)) {
+        const mapped = mapType(part, ctx);
+        if (mapped === null)
+            return null;
+        if (mapped.kind === "object") {
+            if (classPart !== null)
+                return null;
+            classPart = part;
+            continue;
+        }
+        // The expando members are DATA: a plain record, with no call or
+        // construct signature of its own.
+        if (mapped.kind !== "record")
+            return null;
+        if (checker.getCallSignatures(part).length > 0)
+            return null;
+        expandoParts.push(part);
+    }
+    if (classPart === null)
+        return null;
+    // The expando members are properties the class does not declare. An
+    // index signature names every key, and a member the class declares
+    // restates the class's own storage: both refine the class's members
+    // rather than add to them, and keep their diagnostics.
+    const classMembers = new Set(checker.getPropertiesOfType(classPart).map((member) => ts.symbolName(member)));
+    for (const part of expandoParts) {
+        if (checker.getIndexInfosOfType(part).length > 0)
+            return null;
+        for (const member of checker.getPropertiesOfType(part))
+            if (classMembers.has(ts.symbolName(member)))
+                return null;
+    }
+    return DYN;
+}
 function mapHybridCallableIntersection(widened, ctx) {
     const { checker, shapes } = ctx;
     if (!widened.isIntersectionType())