@scriptc/compiler 0.3.5 → 0.3.6

package/dist/frontend/type-mapper.js

@@ -981,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) {
@@ -1070,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
@@ -1721,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).
@@ -1936,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()))) {
@@ -2942,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"];
@@ -3099,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];
@@ -4209,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) {
@@ -4227,6 +4317,7 @@ function mapErrorMetadataIntersection(type, ctx) {
                 "TypeError",
                 "URIError",
                 "AggregateError",
+                "SuppressedError",
             ].includes(symbol.name) &&
             ctx.checker.declarationsOf(symbol).some((decl) => ctx.isStdlibFile(decl.getSourceFile())));
     });