@scriptc/compiler 0.2.1 → 0.2.2

package/dist/frontend/type-mapper.js

@@ -6,6 +6,7 @@ import { BIGINT_T } from "../ir/ir.js";
 import { literalValues } from "./literal-values.js";
 import { remapUnionDiscriminant } from "./union-discriminants.js";
 import { isJsSourceFile, isNodeTypesPath } from "./program.js";
+import { functionCanReturnUndefined } from "./function-completion.js";
 import { accessorSlotProp, recordTextCodecClass } from "../ir/ir.js";
 // typeKey moved to ir/ir.ts (the backend needs it too, for per-type
 // helper interning); re-exported here so frontend call sites keep their
@@ -19,10 +20,12 @@ export function jsOpenObjectType(decl, type, shapes, unions) {
     const arms = type.kind === "union" ? unions.get(type.unionId)?.arms : [type];
     const present = arms?.filter((arm) => arm.kind !== "undefinedT");
     const parameter = ts.isParameter(decl) ? decl : decl.parent && ts.isParameter(decl.parent) ? decl.parent : null;
-    // Numeric array parameters in JavaScript also accept typed arrays. Keep
+    // Array parameters in JavaScript also accept typed arrays. Keep
     // their runtime storage at the boundary, including default [] parameters.
     if (parameter && !parameter.dotDotDotToken && present?.length === 1 &&
-        present[0].kind === "array" && present[0].elem.kind === "f64")
+        present[0].kind === "array")
+        return DYN;
+    if (parameter && !parameter.dotDotDotToken && present?.length === 1 && present[0].kind === "bytes")
         return DYN;
     // An unannotated JavaScript parameter's object default is a fallback,
     // not a closed class contract. Published code routinely passes another
@@ -34,6 +37,10 @@ export function jsOpenObjectType(decl, type, shapes, unions) {
     if (present?.length !== 1 || present[0].kind !== "record")
         return type;
     const shape = shapes.get(present[0].shapeId);
+    // JavaScript dictionaries allow missing keys and inherited properties.
+    // A typed index slot cannot represent either of those reads faithfully.
+    if (shape?.indexValue && !shape.tuple)
+        return DYN;
     const unitOnly = (field) => isUnitType(field) || field.kind === "void" ||
         field.kind === "union" && unions.get(field.unionId)?.arms.every(isUnitType) === true;
     return shape && !shape.tuple && !shape.indexValue &&
@@ -1534,6 +1541,19 @@ function mapTypeInner(type, ctx) {
             isDeclaredInAmbientModule(d, "diagnostics_channel"))) {
         return F64;
     }
+    // Node names this result; the ambient WHATWG declaration uses a type literal.
+    const encodeResult = psym && checker.declarationsOf(psym).some((decl) => {
+        if (!ctx.isStdlibFile(decl.getSourceFile()))
+            return false;
+        if (ts.isInterfaceDeclaration(decl) && decl.name.text === "EncodeIntoResult")
+            return true;
+        const parent = decl.parent;
+        return ts.isTypeLiteralNode(decl) && parent?.kind === ts.SyntaxKind.MethodSignature &&
+            parent.name && ts.isIdentifier(parent.name) && parent.name.text === "encodeInto" &&
+            parent.parent && ts.isInterfaceDeclaration(parent.parent) && parent.parent.name.text === "TextEncoder";
+    });
+    if (encodeResult)
+        return { kind: "record", shapeId: ctx.shapes.intern([{ name: "read", type: F64 }, { name: "written", type: F64 }]) };
     // WHATWG codec instances have ordinary reference identity and ownership.
     // Their private encoding slot is omitted from enumeration and JSON.
     if ((psym?.name === "TextEncoder" || psym?.name === "TextDecoder") &&
@@ -1720,9 +1740,8 @@ function mapTypeInner(type, ctx) {
     // ArrayBuffer value exists. The other TypedArray flavors stay
     // unmapped (the record path's index-signature check rejects them).
     // RegExpMatchArray (s.match's result) IS a string[] here — the honest
-    // slice: [whole match, ...captures] (a nonparticipating capture reads
-    // "" — SEMANTICS.md). The `.index`/`.input`/`.groups` extras fence per
-    // member like any other unlowered array property.
+    // slice: [whole match, ...captures]. Nonparticipating captures use the
+    // array's undefined element state; numeric access preserves that state.
     if (isStdlibInterface("RegExpMatchArray"))
         return arrayOf(STRING);
     // TemplateStringsArray (a tag function's first parameter): a string[] —
@@ -1882,6 +1901,10 @@ function mapTypeInner(type, ctx) {
             isDeclaredInAmbientModule(d, "tls"))) {
         return { kind: "secureCtx" };
     }
+    // Scrypt's runtime options retain property accessors and aliases. Use
+    // checked values so presence probes and repeated getter reads match Node.
+    if (psym?.name === "ScryptOptions" && checker.declarationsOf(psym).some((d) => ts.isInterfaceDeclaration(d) && ctx.isStdlibFile(d.getSourceFile()) && isDeclaredInAmbientModule(d, "crypto")))
+        return DYN;
     // crypto.Hash / crypto.Hmac: native incremental digest handles. Keep
     // provenance module-qualified so user classes with these common names
     // retain their ordinary structural/class representation.
@@ -2214,28 +2237,53 @@ function mapTypeInner(type, ctx) {
             ], false, undefined, ["address", "family", "port"]),
         };
     }
+    // Filesystem options are data records. Keep their declared optional fields
+    // instead of allowing arbitrary standard-library interfaces into records.
+    if ((psym?.name === "FileReadOptions" || psym?.name === "ReadOptions" || psym?.name === "ReadOptionsWithBuffer" || psym?.name === "WriteOptions") &&
+        checker.declarationsOf(psym).some((d) => ts.isInterfaceDeclaration(d) && ctx.isStdlibFile(d.getSourceFile()) &&
+            (isDeclaredInAmbientModule(d, "fs/promises") || isDeclaredInAmbientModule(d, "fs")))) {
+        const fields = [];
+        for (const property of checker.getPropertiesOfType(widened)) {
+            if (!["buffer", "offset", "length", "position"].includes(property.name))
+                return null;
+            const type = mapType(checker.getTypeOfSymbol(property), ctx);
+            if (!type)
+                return null;
+            fields.push({ name: property.name, type });
+        }
+        const order = fields.map((field) => field.name);
+        fields.sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+        return { kind: "record", shapeId: ctx.shapes.intern(fields, false, undefined, order) };
+    }
     // fs/promises FileReadResult<T> / FileWriteResult<T>: the two-field
     // null-prototype objects returned by FileHandle.read/write. The native
     // record does not model the prototype (unobservable through the lowered
     // surface); it preserves the caller buffer/string by reference.
-    if ((psym?.name === "FileReadResult" || psym?.name === "FileWriteResult") &&
+    if ((psym?.name === "FileReadResult" || psym?.name === "FileWriteResult" || psym?.name === "FileReadvResult" || psym?.name === "FileWritevResult" || psym?.name === "ReadVResult" || psym?.name === "WriteVResult") &&
         checker.declarationsOf(psym).some((d) => ts.isInterfaceDeclaration(d) &&
             ctx.isStdlibFile(d.getSourceFile()) &&
-            isDeclaredInAmbientModule(d, "fs/promises"))) {
+            (isDeclaredInAmbientModule(d, "fs/promises") ||
+                ((psym.name === "ReadVResult" || psym.name === "WriteVResult") && isDeclaredInAmbientModule(d, "fs"))))) {
         const args = checker.getTypeArguments(widened);
         if (args.length !== 1)
             return null;
-        const payload = mapType(args[0], ctx);
-        if (!payload || !(payload.kind === "string" || (payload.kind === "bytes" && payload.elem === "u8"))) {
+        const vector = psym.name === "FileReadvResult" || psym.name === "FileWritevResult" || psym.name === "ReadVResult" || psym.name === "WriteVResult";
+        const emptyVector = vector && checker.isArrayType(args[0]) &&
+            (checker.getTypeArguments(args[0])[0].flags & ts.TypeFlags.Never) !== 0;
+        const payload = emptyVector ? arrayOf(bytesOf("u8")) : mapType(args[0], ctx);
+        if (!payload || (vector
+            ? !(payload.kind === "array" && payload.elem.kind === "bytes" && payload.elem.elem === "u8")
+            : !(payload.kind === "string" || (payload.kind === "bytes" && payload.elem === "u8")))) {
             return null;
         }
-        const count = psym.name === "FileReadResult" ? "bytesRead" : "bytesWritten";
+        const count = psym.name === "FileReadResult" || psym.name === "FileReadvResult" || psym.name === "ReadVResult" ? "bytesRead" : "bytesWritten";
+        const payloadName = vector ? "buffers" : "buffer";
         return {
             kind: "record",
             shapeId: ctx.shapes.intern([
-                { name: "buffer", type: payload },
+                { name: payloadName, type: payload },
                 { name: count, type: F64 },
-            ], false, undefined, [count, "buffer"]),
+            ], false, undefined, [count, payloadName]),
         };
     }
     // fs.Dirent (readdirSync's withFileTypes rows): interned explicitly on
@@ -2469,9 +2517,19 @@ function mapTypeInner(type, ctx) {
                 ts.isParameter(decl) &&
                 (decl.questionToken !== undefined || decl.initializer !== undefined);
             let pt = mapType(checker.getTypeOfSymbol(p), ctx);
+            if (decl && ts.isParameter(decl) && ts.isSetAccessorDeclaration(decl.parent) && isJsSourceFile(decl.getSourceFile()))
+                pt = DYN;
             // An inferred JavaScript binding pattern consumes an iterable; it
             // does not require the caller's array to have exactly this length.
-            if (decl && ts.isParameter(decl) && ts.isArrayBindingPattern(decl.name) &&
+            const executor = decl && ts.isParameter(decl) ? decl.parent : null;
+            const construction = executor?.parent;
+            const constructorSymbol = construction && ts.isNewExpression(construction)
+                ? checker.getSymbolAtLocation(construction.expression) : undefined;
+            const nativeExecutor = executor && (ts.isArrowFunction(executor) || ts.isFunctionExpression(executor)) &&
+                construction && ts.isNewExpression(construction) && construction.arguments?.[0] === executor &&
+                ts.isIdentifier(construction.expression) && construction.expression.text === "Promise" &&
+                constructorSymbol && checker.declarationsOf(constructorSymbol).some((site) => ctx.isStdlibFile(site.getSourceFile()));
+            if (!nativeExecutor && decl && ts.isParameter(decl) && !decl.dotDotDotToken && !ts.isSetAccessorDeclaration(decl.parent) &&
                 isJsSourceFile(decl.getSourceFile()) && !decl.type &&
                 !/@(?:param|type)\b/.test(decl.getSourceFile().text.slice(decl.parent?.pos ?? decl.pos, decl.getStart())))
                 pt = DYN;
@@ -2510,8 +2568,19 @@ function mapTypeInner(type, ctx) {
             (retT.flags & (ts.TypeFlags.Null | ts.TypeFlags.Undefined)) !== 0;
         let ret = jsUnitReturn || (!ctx.dynamic && (retT.flags & ts.TypeFlags.Any) !== 0)
             ? DYN : retT.flags & ts.TypeFlags.Never ? VOID : mapType(retT, ctx);
-        if (sigDecl && isJsSourceFile(sigDecl.getSourceFile()) && ret?.kind === "array" && ret.elem.kind === "f64")
+        if (sigDecl && ts.isGetAccessorDeclaration(sigDecl) && isJsSourceFile(sigDecl.getSourceFile()))
+            ret = DYN;
+        if (sigDecl && isJsSourceFile(sigDecl.getSourceFile()) && ret?.kind === "array")
+            ret = DYN;
+        if (sigDecl && ts.isFunctionLike(sigDecl) && isJsSourceFile(sigDecl.getSourceFile()) && !sigDecl.type &&
+            !/@returns?\b/.test(sigDecl.getSourceFile().text.slice(sigDecl.pos, sigDecl.getStart())) && ret?.kind === "record")
+            ret = DYN;
+        if (sigDecl && ts.isFunctionLike(sigDecl) && isJsSourceFile(sigDecl.getSourceFile()) && !sigDecl.type &&
+            !/@returns?\b/.test(sigDecl.getSourceFile().text.slice(sigDecl.pos, sigDecl.getStart())) &&
+            (ret?.kind === "date" || ret?.kind === "union" && ctx.unions.get(ret.unionId)?.arms.some((arm) => arm.kind === "func")))
             ret = DYN;
+        if (ret && sigDecl && isJsSourceFile(sigDecl.getSourceFile()) && functionCanReturnUndefined(sigDecl))
+            ret = withUndefinedArm(ret, ctx.unions) ?? ret;
         if (!ret)
             return null;
         return typedRest