@scriptc/compiler 0.0.33 → 0.0.35

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

@@ -625,7 +625,7 @@ export function declaredReturnType(L, decl, blame) {
    * instead of the generic supported-types recitation; a no-op for every
    * other unmappable type (the caller's badType reports those). */
 function fenceGenericSignatureResult(L, blame, t) {
-    const parts = t.isUnionType() ? t.getTypes() : [t];
+    const parts = t.isUnionType() ? ts.constituentTypes(t) : [t];
     if (!parts.some((p) => L.checker.getCallSignatures(p).some((s) => (s.typeParameters?.length ?? 0) > 0))) {
         return;
     }
@@ -931,6 +931,7 @@ export function internGenericInstance(L, blame, info, params, returnType, makeBi
         info.instances.set(key, inst);
         L.instantiationQueue.push({ info, inst });
     }
+    L.noteGenericInstanceDemand(inst);
     return inst;
 }
 /** The type parameters of `info` declared with a `keyof` CONSTRAINT
@@ -1045,8 +1046,8 @@ export function unifySignatureBindings(L, info, rsig, bindings, tsBindings) {
         // unbound type parameter surfaces as a mapping diagnostic later).
         if (declared.isUnionType()) {
             const unitFlags = ts.TypeFlags.Undefined | ts.TypeFlags.Null;
-            const dParts = declared.getTypes().filter((t) => !(t.flags & unitFlags));
-            const iParts = inst.isUnionType() ? inst.getTypes().filter((t) => !(t.flags & unitFlags)) : [inst];
+            const dParts = ts.constituentTypes(declared).filter((t) => !(t.flags & unitFlags));
+            const iParts = inst.isUnionType() ? ts.constituentTypes(inst).filter((t) => !(t.flags & unitFlags)) : [inst];
             if (dParts.length === 1 && iParts.length === 1)
                 unify(dParts[0], iParts[0], depth + 1);
             return;
@@ -1442,7 +1443,7 @@ export function lowerGenericFnValue(L, ref, info) {
             // A `Fn | undefined`-flavored slot: the value can only inhabit the
             // one callable arm — judge by it (the requireExactArityValue union
             // rule).
-            const callable = pinT.getTypes().map((t) => L.checker.getCallSignatures(t)).filter((s) => s.length === 1);
+            const callable = ts.constituentTypes(pinT).map((t) => L.checker.getCallSignatures(t)).filter((s) => s.length === 1);
             if (callable.length === 1)
                 target = callable[0][0];
         }
@@ -1781,6 +1782,16 @@ function internImplicitInstance(L, blame, info, shapes, argTypes) {
     // the pinned signature over a missing body, which the linker never
     // sees because the poison also fenced the call statement.
     try {
+        // Implicit-any instances lower EAGERLY at the call site so their
+        // inferred return type is available immediately. They therefore do
+        // not pass through emitReachable's queued generic-instance wave,
+        // which normally batches checker work before lowering a body. Prime
+        // this exact committed instance body here; repeated instantiations of
+        // the same declaration find the facade memos warm.
+        L.checker.prefetchRoots([
+            ...info.decl.parameters.flatMap((param) => param.initializer ? [param.initializer] : []),
+            ...(info.decl.body ? [info.decl.body] : []),
+        ]);
         const fn = L.lowerGenericInstance(info, inst);
         L.implicitFns.push(fn);
     }
@@ -6409,48 +6420,8 @@ export function recordKeysArrayCall(L, receiver, argIr, shape, loc) {
         helper = `%obj.keys.${L.arrHofHelpers.size}`;
         const ref = { kind: "varRef", localId: "r.0", type: argIr, loc };
         const outRef = { kind: "varRef", localId: "out.0", type: resultT, loc };
-        const body = [
-            { kind: "varDecl", localId: "out.0", init: { kind: "arrayLit", elems: [], type: resultT, loc }, loc },
-        ];
-        const order = shape.declaredOrder ?? shape.fields.map((f) => f.name);
-        for (const name of order) {
-            const f = shape.fields.find((x) => x.name === name);
-            const pushStmt = {
-                kind: "exprStmt",
-                expr: {
-                    kind: "arrIntrinsic",
-                    method: "push",
-                    receiver: outRef,
-                    args: [{ kind: "strLit", value: f.name, type: STRING, loc }],
-                    type: F64,
-                    loc,
-                },
-                loc,
-            };
-            // Undefined-armed fields: the push is guarded by a tag test (the
-            // key exists exactly when the arm is not undefined).
-            const utag = f.type.kind === "union" ? L.armTag(f.type.unionId, UNDEFINED_T) : -1;
-            body.push(utag >= 0 && f.type.kind === "union"
-                ? {
-                    kind: "if",
-                    cond: {
-                        kind: "unionIsTag",
-                        unionId: f.type.unionId,
-                        tag: utag,
-                        negated: true,
-                        value: { kind: "recordGet", obj: ref, shapeId: argIr.shapeId, field: f.name, type: f.type, loc },
-                        type: BOOL,
-                        loc,
-                    },
-                    then: [pushStmt],
-                    else_: null,
-                    loc,
-                }
-                : pushStmt);
-        }
-        body.push({ kind: "return", value: outRef, loc });
         L.arrHofHelpers.set(key, helper);
-        L.liftedFns.push({
+        const fn = {
             name: helper,
             params: [{ localId: "r.0", name: "r", type: argIr }],
             returnType: resultT,
@@ -6458,9 +6429,56 @@ export function recordKeysArrayCall(L, receiver, argIr, shape, loc) {
                 { id: "r.0", name: "r", type: argIr, mutable: true },
                 { id: "out.0", name: "out", type: resultT, mutable: false },
             ],
-            body,
+            body: [],
             loc,
-        });
+        };
+        const finalize = () => {
+            const current = L.shapes.get(argIr.shapeId) ?? shape;
+            const body = [
+                { kind: "varDecl", localId: "out.0", init: { kind: "arrayLit", elems: [], type: resultT, loc }, loc },
+            ];
+            const order = current.declaredOrder ?? current.fields.map((f) => f.name);
+            for (const name of order) {
+                const f = current.fields.find((x) => x.name === name);
+                const pushStmt = {
+                    kind: "exprStmt",
+                    expr: {
+                        kind: "arrIntrinsic",
+                        method: "push",
+                        receiver: outRef,
+                        args: [{ kind: "strLit", value: f.name, type: STRING, loc }],
+                        type: F64,
+                        loc,
+                    },
+                    loc,
+                };
+                // Undefined-armed fields: the push is guarded by a tag test (the
+                // key exists exactly when Object.keys would list it).
+                const utag = f.type.kind === "union" ? L.armTag(f.type.unionId, UNDEFINED_T) : -1;
+                body.push(utag >= 0 && f.type.kind === "union"
+                    ? {
+                        kind: "if",
+                        cond: {
+                            kind: "unionIsTag",
+                            unionId: f.type.unionId,
+                            tag: utag,
+                            negated: true,
+                            value: { kind: "recordGet", obj: ref, shapeId: argIr.shapeId, field: f.name, type: f.type, loc },
+                            type: BOOL,
+                            loc,
+                        },
+                        then: [pushStmt],
+                        else_: null,
+                        loc,
+                    }
+                    : pushStmt);
+            }
+            body.push({ kind: "return", value: outRef, loc });
+            fn.body = body;
+        };
+        finalize();
+        L.shapeOrderHelperFinalizers.push(finalize);
+        L.liftedFns.push(fn);
     }
     return { kind: "call", callee: helper, args: [receiver], type: resultT, loc };
 }
@@ -7170,109 +7188,15 @@ function lowerObjectStaticCall(L, call, access) {
             L.badType(call, L.typeOf(call));
         valueT = tupleShape.fields.find((f) => f.name === "1").type;
     }
-    const order = shape.declaredOrder ?? shape.fields.map((f) => f.name);
     const key = `obj.${member}:${argIr.shapeId}:${typeKey(resultT)}`;
     let helper = L.arrHofHelpers.get(key);
     if (!helper) {
         helper = `%obj.${member}.${L.arrHofHelpers.size}`;
         const recT = argIr;
         const ref = { kind: "varRef", localId: "r.0", type: recT, loc };
-        const body = [
-            { kind: "varDecl", localId: "out.0", init: { kind: "arrayLit", elems: [], type: resultT, loc }, loc },
-        ];
         const outRef = { kind: "varRef", localId: "out.0", type: resultT, loc };
-        for (const name of order) {
-            const f = shape.fields.find((x) => x.name === name);
-            const raw = { kind: "recordGet", obj: ref, shapeId: argIr.shapeId, field: f.name, type: f.type, loc };
-            // The pushed element per member; null when the field's value
-            // cannot flow into the result element type.
-            const elemOf = (value, vt) => {
-                if (!valueT)
-                    return null;
-                if (typeEquals(vt, valueT))
-                    return value;
-                if (valueT.kind === "union" && vt.kind !== "union") {
-                    const tag = L.armTag(valueT.unionId, vt);
-                    if (tag >= 0) {
-                        return { kind: "unionWrap", unionId: valueT.unionId, tag, value, type: valueT, loc };
-                    }
-                }
-                return null;
-            };
-            // Undefined-armed fields: the push is guarded by a tag test, and
-            // the pushed value is the narrowed non-undefined arm.
-            let guardUndefTag = null;
-            let value = raw;
-            let vt = f.type;
-            if (f.type.kind === "union") {
-                const undefTag = L.armTag(f.type.unionId, UNDEFINED_T);
-                if (undefTag >= 0) {
-                    guardUndefTag = undefTag;
-                    const arms = L.unions.get(f.type.unionId)?.arms ?? [];
-                    const others = arms.filter((a) => a.kind !== "undefinedT");
-                    if (typeEquals(f.type, valueT ?? f.type)) {
-                        // The field union IS the result union (single-field shapes):
-                        // push the raw box — but then the undefined skip must NOT
-                        // narrow. Handled below via vt === valueT.
-                        value = raw;
-                        vt = f.type;
-                    }
-                    else if (others.length === 1) {
-                        vt = others[0];
-                        // A UNIT other arm (`null | undefined` fields — the mixed-
-                        // defaults spread idiom; undefined was filtered above, so
-                        // the unit is null): units carry no payload, so the guarded
-                        // push writes the unit LITERAL — unionNarrow to a unit arm
-                        // (and unionWrap of a narrowed unit) is malformed IR; the
-                        // literal is the one legal unit spelling.
-                        value = isUnitType(vt)
-                            ? { kind: "unitLit", unit: "null", type: vt, loc }
-                            : { kind: "unionNarrow", unionId: f.type.unionId, tag: L.armTag(f.type.unionId, vt), value: raw, type: vt, loc };
-                    }
-                    else {
-                        L.unsupported("SC1090", call, `Object.${member} over '${L.fmt(argIr)}' (field '${f.name}' is a multi-arm union that ` +
-                            "cannot re-tag into the result element type — read the fields directly)");
-                    }
-                }
-                else if (!typeEquals(f.type, valueT ?? f.type)) {
-                    L.unsupported("SC1090", call, `Object.${member} over '${L.fmt(argIr)}' (field '${f.name}' is a union that cannot ` +
-                        "re-tag into the result element type — read the fields directly)");
-                }
-            }
-            const coerced = elemOf(value, vt);
-            if (!coerced) {
-                L.unsupported("SC1090", call, `Object.${member} over '${L.fmt(argIr)}' (field '${f.name}' of type '${L.fmt(f.type)}' ` +
-                    `cannot flow into the '${L.fmt(valueT)}' result element — read the fields directly)`);
-            }
-            const pushed = member === "values"
-                ? coerced
-                : {
-                    kind: "recordLit",
-                    fields: [
-                        { name: "0", value: { kind: "strLit", value: f.name, type: STRING, loc } },
-                        { name: "1", value: coerced },
-                    ],
-                    type: tupleT,
-                    loc,
-                };
-            const pushStmt = {
-                kind: "exprStmt",
-                expr: { kind: "arrIntrinsic", method: "push", receiver: outRef, args: [pushed], type: F64, loc },
-                loc,
-            };
-            body.push(guardUndefTag !== null && f.type.kind === "union"
-                ? {
-                    kind: "if",
-                    cond: { kind: "unionIsTag", unionId: f.type.unionId, tag: guardUndefTag, negated: true, value: raw, type: BOOL, loc },
-                    then: [pushStmt],
-                    else_: null,
-                    loc,
-                }
-                : pushStmt);
-        }
-        body.push({ kind: "return", value: outRef, loc });
         L.arrHofHelpers.set(key, helper);
-        L.liftedFns.push({
+        const fn = {
             name: helper,
             params: [{ localId: "r.0", name: "r", type: recT }],
             returnType: resultT,
@@ -7280,9 +7204,110 @@ function lowerObjectStaticCall(L, call, access) {
                 { id: "r.0", name: "r", type: recT, mutable: true },
                 { id: "out.0", name: "out", type: resultT, mutable: false },
             ],
-            body,
+            body: [],
             loc,
-        });
+        };
+        const finalize = () => {
+            const current = L.shapes.get(argIr.shapeId) ?? shape;
+            const body = [
+                { kind: "varDecl", localId: "out.0", init: { kind: "arrayLit", elems: [], type: resultT, loc }, loc },
+            ];
+            const order = current.declaredOrder ?? current.fields.map((f) => f.name);
+            for (const name of order) {
+                const f = current.fields.find((x) => x.name === name);
+                const raw = { kind: "recordGet", obj: ref, shapeId: argIr.shapeId, field: f.name, type: f.type, loc };
+                // The pushed element per member; null when the field's value
+                // cannot flow into the result element type.
+                const elemOf = (value, vt) => {
+                    if (!valueT)
+                        return null;
+                    if (typeEquals(vt, valueT))
+                        return value;
+                    if (valueT.kind === "union" && vt.kind !== "union") {
+                        const tag = L.armTag(valueT.unionId, vt);
+                        if (tag >= 0) {
+                            return { kind: "unionWrap", unionId: valueT.unionId, tag, value, type: valueT, loc };
+                        }
+                    }
+                    return null;
+                };
+                // Undefined-armed fields: the push is guarded by a tag test, and
+                // the pushed value is the narrowed non-undefined arm.
+                let guardUndefTag = null;
+                let value = raw;
+                let vt = f.type;
+                if (f.type.kind === "union") {
+                    const undefTag = L.armTag(f.type.unionId, UNDEFINED_T);
+                    if (undefTag >= 0) {
+                        guardUndefTag = undefTag;
+                        const arms = L.unions.get(f.type.unionId)?.arms ?? [];
+                        const others = arms.filter((a) => a.kind !== "undefinedT");
+                        if (typeEquals(f.type, valueT ?? f.type)) {
+                            // The field union IS the result union (single-field shapes):
+                            // push the raw box — but then the undefined skip must NOT
+                            // narrow. Handled below via vt === valueT.
+                            value = raw;
+                            vt = f.type;
+                        }
+                        else if (others.length === 1) {
+                            vt = others[0];
+                            // A UNIT other arm (`null | undefined` fields — the mixed-
+                            // defaults spread idiom; undefined was filtered above, so
+                            // the unit is null): units carry no payload, so the guarded
+                            // push writes the unit LITERAL — unionNarrow to a unit arm
+                            // (and unionWrap of a narrowed unit) is malformed IR; the
+                            // literal is the one legal unit spelling.
+                            value = isUnitType(vt)
+                                ? { kind: "unitLit", unit: "null", type: vt, loc }
+                                : { kind: "unionNarrow", unionId: f.type.unionId, tag: L.armTag(f.type.unionId, vt), value: raw, type: vt, loc };
+                        }
+                        else {
+                            L.unsupported("SC1090", call, `Object.${member} over '${L.fmt(argIr)}' (field '${f.name}' is a multi-arm union that ` +
+                                "cannot re-tag into the result element type — read the fields directly)");
+                        }
+                    }
+                    else if (!typeEquals(f.type, valueT ?? f.type)) {
+                        L.unsupported("SC1090", call, `Object.${member} over '${L.fmt(argIr)}' (field '${f.name}' is a union that cannot ` +
+                            "re-tag into the result element type — read the fields directly)");
+                    }
+                }
+                const coerced = elemOf(value, vt);
+                if (!coerced) {
+                    L.unsupported("SC1090", call, `Object.${member} over '${L.fmt(argIr)}' (field '${f.name}' of type '${L.fmt(f.type)}' ` +
+                        `cannot flow into the '${L.fmt(valueT)}' result element — read the fields directly)`);
+                }
+                const pushed = member === "values"
+                    ? coerced
+                    : {
+                        kind: "recordLit",
+                        fields: [
+                            { name: "0", value: { kind: "strLit", value: f.name, type: STRING, loc } },
+                            { name: "1", value: coerced },
+                        ],
+                        type: tupleT,
+                        loc,
+                    };
+                const pushStmt = {
+                    kind: "exprStmt",
+                    expr: { kind: "arrIntrinsic", method: "push", receiver: outRef, args: [pushed], type: F64, loc },
+                    loc,
+                };
+                body.push(guardUndefTag !== null && f.type.kind === "union"
+                    ? {
+                        kind: "if",
+                        cond: { kind: "unionIsTag", unionId: f.type.unionId, tag: guardUndefTag, negated: true, value: raw, type: BOOL, loc },
+                        then: [pushStmt],
+                        else_: null,
+                        loc,
+                    }
+                    : pushStmt);
+            }
+            body.push({ kind: "return", value: outRef, loc });
+            fn.body = body;
+        };
+        finalize();
+        L.shapeOrderHelperFinalizers.push(finalize);
+        L.liftedFns.push(fn);
     }
     return { kind: "call", callee: helper, args: [receiver], type: resultT, loc };
 }