@scriptc/compiler 0.3.4 → 0.3.6

package/dist/frontend/type-mapper.d.ts

@@ -173,6 +173,9 @@ export declare const PERF_ENTRY_FIELDS: string[];
  * PerformanceMeasure values (see mapType). The marker is an always-absent
  * optional, so dyn conversions and key walks never see it. */
 export declare function perfEntryShape(shapes: ShapeRegistry, unions: UnionRegistry): string;
+/** The `{ stdout, stderr }` record a promisified exec/execFile call
+ * fulfills with (see mapType), in Node's key order. */
+export declare function execResultShape(shapes: ShapeRegistry): string;
 /** toJSON()'s plain object over an entry: the same fields without the
  * marker. */
 export declare function perfEntryJsonShape(shapes: ShapeRegistry): string;

package/dist/frontend/type-mapper.js

@@ -760,6 +760,14 @@ export function perfEntryShape(shapes, unions) {
         { name: "startTime", type: F64 },
     ], false, undefined, PERF_ENTRY_FIELDS);
 }
+/** The `{ stdout, stderr }` record a promisified exec/execFile call
+ * fulfills with (see mapType), in Node's key order. */
+export function execResultShape(shapes) {
+    return shapes.intern([
+        { name: "stderr", type: STRING },
+        { name: "stdout", type: STRING },
+    ], false, undefined, ["stdout", "stderr"]);
+}
 /** toJSON()'s plain object over an entry: the same fields without the
  * marker. */
 export function perfEntryJsonShape(shapes) {
@@ -973,13 +981,42 @@ export function isOsConstantsSymbol(symbol, ctx, types = false) {
 /** worker_threads' Worker and MessagePort: owned runtime handles that keep
  * their live object representation (DYN) wherever they are stored. */
 function isWorkerHandleSymbol(symbol, ctx) {
-    return ((symbol?.name === "Worker" || symbol?.name === "MessagePort") &&
+    return ((symbol?.name === "Worker" ||
+        symbol?.name === "MessagePort" ||
+        symbol?.name === "MessageChannel") &&
         ctx.checker
             .declarationsOf(symbol)
             .some((d) => (ts.isClassDeclaration(d) || ts.isInterfaceDeclaration(d)) &&
             ctx.isStdlibFile(d.getSourceFile()) &&
             isDeclaredInAmbientModule(d, "worker_threads")));
 }
+/** The `{ message: any }` object type (or its union with undefined) that
+ * worker_threads declares as receiveMessageOnPort's result. */
+function isReceiveMessageResult(type, ctx) {
+    const members = type.isUnionType() ? ts.constituentTypes(type) : [type];
+    let found = false;
+    for (const member of members) {
+        if (member.flags & ts.TypeFlags.Undefined)
+            continue;
+        const decl = member.getSymbol()
+            ? ctx.checker.declarationsOf(member.getSymbol())[0]
+            : undefined;
+        let fn = decl?.parent;
+        while (fn && ts.isUnionTypeNode(fn))
+            fn = fn.parent;
+        if (!decl ||
+            !ts.isTypeLiteralNode(decl) ||
+            !fn ||
+            !ts.isFunctionDeclaration(fn) ||
+            fn.name?.text !== "receiveMessageOnPort" ||
+            !ctx.isStdlibFile(decl.getSourceFile()) ||
+            !isDeclaredInAmbientModule(fn, "worker_threads")) {
+            return false;
+        }
+        found = true;
+    }
+    return found;
+}
 /** True for a type built only from worker handles, null/undefined, and
  * arrays of those: values that keep the live DYN representation. */
 export function isWorkerHandleType(type, ctx) {
@@ -1062,6 +1099,10 @@ function mapTypeInner(type, ctx) {
         if (moduleId !== null)
             return { kind: "moduleNs", moduleId };
     }
+    // worker_threads.receiveMessageOnPort's `{ message: any } | undefined`:
+    // the runtime's { message } object, a checked-dynamic value.
+    if (isReceiveMessageResult(type, ctx))
+        return DYN;
     // @types/node spells child_process.ExecFileException as an intersection
     // type alias over two Error-derived metadata interfaces. The value is
     // still one ordinary Error; recognize the owned alias before generic
@@ -1713,6 +1754,27 @@ function mapTypeInner(type, ctx) {
                 isDeclaredInAmbientModule(d, "readline/promises")))) {
         return F64;
     }
+    // readline.Key: emitKeys' key object stays a checked-dynamic value, so
+    // it keeps Node's own shape (an undefined name, the escape sequences'
+    // code member).
+    if (psym?.name === "Key" &&
+        checker
+            .declarationsOf(psym)
+            .some((d) => ts.isInterfaceDeclaration(d) &&
+            ctx.isStdlibFile(d.getSourceFile()) &&
+            (isDeclaredInAmbientModule(d, "readline") ||
+                isDeclaredInAmbientModule(d, "readline/promises")))) {
+        return DYN;
+    }
+    // readline/promises.Readline: an f64 handle the same way.
+    if (psym?.name === "Readline" &&
+        checker
+            .declarationsOf(psym)
+            .some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
+            ctx.isStdlibFile(d.getSourceFile()) &&
+            isDeclaredInAmbientModule(d, "readline/promises"))) {
+        return F64;
+    }
     // diagnostics_channel.Channel: the channel value is an f64 handle into
     // the runtime's channel registry (the readline.Interface precedent —
     // Node's channels are process-lived too, its WeakRef machinery aside).
@@ -1928,9 +1990,10 @@ function mapTypeInner(type, ctx) {
     // The stdlib Console interface (the global console and node:console
     // Console instances) is a native handle carried by the checked-dynamic
     // representation and consumed by the console method lowerings. The
-    // stdlib Disposable (events.addAbortListener's result) is a checked
-    // object carrying its Symbol.dispose method.
-    if ((psym?.name === "Console" || psym?.name === "Disposable") &&
+    // stdlib Disposable (events.addAbortListener's result) and
+    // AsyncDisposable are checked objects carrying their Symbol.dispose or
+    // Symbol.asyncDispose method.
+    if ((psym?.name === "Console" || psym?.name === "Disposable" || psym?.name === "AsyncDisposable") &&
         checker
             .declarationsOf(psym)
             .some((d) => ts.isInterfaceDeclaration(d) && ctx.isStdlibFile(d.getSourceFile()))) {
@@ -2323,6 +2386,18 @@ function mapTypeInner(type, ctx) {
             isDeclaredInAmbientModule(d, "zlib"))) {
         return { kind: "object", className: "%Transform" };
     }
+    // fs.ReadStream / fs.WriteStream (the shipped fallback declarations):
+    // their instances are runtime Readable / Writable streams
+    // (scr_fs_stream.c).
+    if ((psym?.name === "ReadStream" || psym?.name === "WriteStream") &&
+        checker
+            .declarationsOf(psym)
+            .some((d) => ts.isClassDeclaration(d) &&
+            ctx.isStdlibFile(d.getSourceFile()) &&
+            !isNodeTypesPath(d.getSourceFile().fileName) &&
+            isDeclaredInAmbientModule(d, "fs"))) {
+        return { kind: "object", className: psym.name === "ReadStream" ? "%Readable" : "%Writable" };
+    }
     if ((psym?.name === "Readable" &&
         checker
             .declarationsOf(psym)
@@ -2602,6 +2677,17 @@ function mapTypeInner(type, ctx) {
             ], false, undefined, ["address", "family"]),
         };
     }
+    // tlsSocket.getCipher()'s { name, standardName, version }.
+    if (isStdlibInterface("CipherNameAndProtocol")) {
+        return {
+            kind: "record",
+            shapeId: ctx.shapes.intern([
+                { name: "name", type: STRING },
+                { name: "standardName", type: STRING },
+                { name: "version", type: STRING },
+            ], false, undefined, ["name", "standardName", "version"]),
+        };
+    }
     // child_process.ExecFileSyncOptionsWithStringEncoding: the exec-options
     // interface interned explicitly on the AddressInfo pattern, so a TYPED
     // options value (`const commandOptions: ExecFileSyncOptions... = {...}`,
@@ -2850,6 +2936,28 @@ function mapTypeInner(type, ctx) {
             ], false, undefined, ["uid", "gid", "username", "homedir", "shell"]),
         };
     }
+    // The promisified exec/execFile result `{ stdout: string; stderr: string }`:
+    // an anonymous type literal (@types/node's __promisify__ overloads in
+    // child_process, the shipped fallback's promisify overloads in util),
+    // so it maps by provenance and exact shape, interned as the
+    // %execFileAsync/%execAsync helpers build it. Node builds the object as
+    // { stdout, stderr }. The Buffer-typed literals do not match and stay
+    // unmapped.
+    if (psym &&
+        checker
+            .declarationsOf(psym)
+            .some((d) => ts.isTypeLiteralNode(d) &&
+            ctx.isStdlibFile(d.getSourceFile()) &&
+            (isDeclaredInAmbientModule(d, "child_process") || isDeclaredInAmbientModule(d, "util")))) {
+        const props = checker.getPropertiesOfType(widened);
+        if (props.length === 2 &&
+            props.every((p) => (p.name === "stdout" || p.name === "stderr") &&
+                (p.flags & ts.SymbolFlags.Optional) === 0 &&
+                (checker.getTypeOfSymbol(p).flags & ts.TypeFlags.String) !== 0) &&
+            props[0].name !== props[1].name) {
+            return { kind: "record", shapeId: execResultShape(ctx.shapes) };
+        }
+    }
     // crypto.X509Certificate — the Dirent-style data record: THREE visible
     // fields (fingerprint and the validFrom/validTo validity window, all
     // computed at construction by the new-expression lowering). Module-
@@ -2889,6 +2997,16 @@ function mapTypeInner(type, ctx) {
             ctx.isStdlibFile(d.getSourceFile()))) {
         return { kind: "record", shapeId: perfEntryShape(ctx.shapes, ctx.unions) };
     }
+    // readline's getCursorPos() record, in Node's key order ({ cols, rows }).
+    if (isStdlibInterface("CursorPos")) {
+        return {
+            kind: "record",
+            shapeId: ctx.shapes.intern([
+                { name: "cols", type: F64 },
+                { name: "rows", type: F64 },
+            ], false, undefined, ["cols", "rows"]),
+        };
+    }
     // process.memoryUsage()'s record, in Node's key order.
     if (isStdlibInterface("MemoryUsage")) {
         const names = ["rss", "heapTotal", "heapUsed", "external", "arrayBuffers"];
@@ -3046,6 +3164,14 @@ function mapTypeInner(type, ctx) {
             checker.getPropertiesOfType(widened).length > 0)
             return DYN;
     }
+    // A union of such hybrids that all map to ONE record is that record:
+    // node:test's Mock<F | Implementation> distributes to (F & { mock }) |
+    // (Implementation & { mock }), and the two function types can map alike.
+    if (widened.isUnionType()) {
+        const hybrid = mapUniformHybridUnion(widened, ctx);
+        if (hybrid)
+            return hybrid;
+    }
     const callSigs = checker.getCallSignatures(widened);
     if (callSigs.length === 1) {
         const sig = callSigs[0];
@@ -4156,6 +4282,23 @@ function mapHybridCallableIntersection(widened, ctx) {
     fields.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
     return { kind: "record", shapeId: shapes.intern(fields, false, undefined, declaredOrder) };
 }
+/** The record every part of a union of function-with-properties
+ * intersections maps to, or null when a part does not map to the same one. */
+function mapUniformHybridUnion(widened, ctx) {
+    const parts = ts.constituentTypes(widened);
+    if (!parts.every((p) => p.isIntersectionType()))
+        return null;
+    let first = null;
+    for (const part of parts) {
+        if (ctx.checker.getConstructSignatures(part).length > 0)
+            return null;
+        const mapped = mapHybridCallableIntersection(part, ctx);
+        if (!mapped || (first && typeKey(mapped) !== typeKey(first)))
+            return null;
+        first ??= mapped;
+    }
+    return first;
+}
 /** Optional standard error metadata refines an existing Error identity;
  * it does not allocate a structural copy or extend its native layout. */
 function mapErrorMetadataIntersection(type, ctx) {
@@ -4174,6 +4317,7 @@ function mapErrorMetadataIntersection(type, ctx) {
                 "TypeError",
                 "URIError",
                 "AggregateError",
+                "SuppressedError",
             ].includes(symbol.name) &&
             ctx.checker.declarationsOf(symbol).some((decl) => ctx.isStdlibFile(decl.getSourceFile())));
     });