@scriptc/compiler 0.2.5 → 0.2.7

package/dist/ir/validate.test.js

@@ -1,5 +1,5 @@
 import { expect, test } from "vitest";
-import { BOOL, DYN, DYN_CLASS_PROPERTIES, F64, NULL_T, STRING, SYMBOL_T, UNDEFINED_T, VOID, arrayOf, mapOf, setOf, } from "./ir.js";
+import { BOOL, DYN, DYN_CLASS_PROPERTIES, F64, NULL_T, STRING, SYMBOL_T, UNDEFINED_T, VOID, arrayOf, funcOf, mapOf, setOf, } from "./ir.js";
 import { deserializeModule, serializeModule } from "./serialize.js";
 import { validateModule } from "./validate.js";
 const loc = { file: "numeric-read.ts", start: 0, end: 0 };
@@ -263,17 +263,18 @@ test.each([mapOf(STRING, F64), setOf(STRING), { kind: "promise", inner: F64 }])(
     expect(validateModule(mod)).toEqual([]);
     expect(deserializeModule(serializeModule(mod))).toEqual(mod);
 });
-test.each([mapOf(STRING, F64), setOf(STRING), { kind: "promise", inner: F64 }])("%j payloads still refuse unrelated data siblings", (type) => {
+test.each([{ kind: "promise", inner: F64 }])("%j payloads still refuse unrelated data siblings", (type) => {
     const mod = expressionModule({ kind: "numLit", value: 0, type: F64, loc }, [
         { id: "mixed", arms: [type, STRING, UNDEFINED_T] },
     ]);
     expect(validateModule(mod).map((error) => error.message)).toContain(`union mixed: ${type.kind} arm 0 beside non-unit arms`);
 });
-test("two differently typed Map payloads cannot silently share one tag test", () => {
+test("differently typed collection payloads preserve separate union tags", () => {
     const mod = expressionModule({ kind: "numLit", value: 0, type: F64, loc }, [
         { id: "maps", arms: [mapOf(STRING, F64), mapOf(STRING, STRING), UNDEFINED_T] },
     ]);
-    expect(validateModule(mod).filter((error) => error.message.includes("beside non-unit arms"))).toHaveLength(2);
+    expect(validateModule(mod)).toEqual([]);
+    expect(deserializeModule(serializeModule(mod))).toEqual(mod);
 });
 function numericReadModule(overrides = {}) {
     const read = {
@@ -286,7 +287,7 @@ function numericReadModule(overrides = {}) {
         ...overrides,
     };
     return {
-        irVersion: 13,
+        irVersion: 15,
         sourceFile: loc.file,
         entry: "main",
         functions: [
@@ -330,9 +331,35 @@ test.each(["copyWithin", "fill", "fillUndefined"])("indexed array mutation %s va
         expect(validateModule(deserializeModule(serializeModule(invalid))).length).toBeGreaterThan(0);
     }
 });
+test.each(["sortPrimitive", "toSortedPrimitive"])("primitive ordering %s validates its serialized element and result contract", (method) => {
+    for (const elem of [STRING, F64, BOOL]) {
+        const type = arrayOf(elem);
+        const expr = {
+            kind: "arrIntrinsic",
+            method,
+            receiver: { kind: "arrayLit", elems: [], type, loc },
+            args: [],
+            type,
+            loc,
+        };
+        const mod = expressionModule(expr, []);
+        expect(validateModule(mod)).toEqual([]);
+        expect(deserializeModule(serializeModule(mod))).toEqual(mod);
+        for (const change of [
+            { args: [{ kind: "numLit", value: 1, type: F64, loc }] },
+            { type: F64 },
+            {
+                receiver: { kind: "arrayLit", elems: [], type: arrayOf(type), loc },
+                type: arrayOf(type),
+            },
+        ]) {
+            expect(validateModule(expressionModule({ ...expr, ...change }, [])).length).toBeGreaterThan(0);
+        }
+    }
+});
 function expressionModule(expr, unions) {
     return {
-        irVersion: 13,
+        irVersion: 15,
         sourceFile: loc.file,
         entry: "main",
         unions,
@@ -743,6 +770,67 @@ test("virtual-call validation uses the nearest concrete ancestor instead of an o
     mod.classes.find((cls) => cls.name === "Root").methods = [];
     expect(validateModule(mod)).toEqual([]);
 });
+test("erased generic families admit compatible object views without supplying virtual slots", () => {
+    const concrete = { kind: "object", className: "Concrete" };
+    const family = { kind: "object", className: "Family" };
+    const mod = expressionModule({
+        kind: "upcast",
+        value: { kind: "varRef", localId: "value", type: concrete, loc },
+        type: family,
+        loc,
+    }, []);
+    mod.functions[0].params = [{ localId: "value", name: "value", type: concrete }];
+    mod.functions[0].locals = [{ id: "value", name: "value", type: concrete, mutable: false }];
+    mod.classes = [
+        { name: "Root", fields: [{ name: "value", type: F64 }], methods: [], loc },
+        { name: "Family", base: "Root", fields: [{ name: "value", type: F64 }], methods: [], loc },
+        { name: "Storage", base: "Root", fields: [{ name: "value", type: F64 }], methods: [], loc },
+        {
+            name: "Concrete",
+            base: "Storage",
+            genericOf: "Family",
+            fields: [{ name: "value", type: F64 }],
+            methods: [],
+            loc,
+        },
+    ];
+    expect(validateModule(deserializeModule(serializeModule(mod)))).toEqual([]);
+    mod.classes[3].fields[0].type = STRING;
+    expect(validateModule(mod).map((error) => error.message)).toContain('class Concrete: generic family "Family" has an incompatible prefix');
+    mod.classes[3].fields[0].type = F64;
+    delete mod.classes[3].base;
+    expect(validateModule(mod).map((error) => error.message)).toContain('class Concrete: generic family "Family" has a different storage root');
+    mod.classes[3].base = "Storage";
+    mod.classes[1].genericOf = "Concrete";
+    expect(validateModule(mod).map((error) => error.message)).toContain('class Concrete: generic family "Family" must name an erased declaration');
+    const calls = virtualCallModule();
+    calls.classes = calls.classes.filter((cls) => cls.name !== "Second");
+    const first = calls.classes.find((cls) => cls.name === "First");
+    delete first.base;
+    first.genericOf = "Base";
+    expect(validateModule(calls).map((error) => error.message)).toContain("in caller0: virtualCall Base.run: no concrete override below the static class");
+});
+test("erased family membership cannot reinterpret a specialized constructor ABI", () => {
+    const mod = expressionModule({
+        kind: "upcast",
+        value: {
+            kind: "varRef",
+            localId: "ctor",
+            type: { kind: "classval", className: "Concrete" },
+            loc,
+        },
+        type: { kind: "classval", className: "Family" },
+        loc,
+    }, []);
+    const ctor = { kind: "classval", className: "Concrete" };
+    mod.functions[0].params = [{ localId: "ctor", name: "ctor", type: ctor }];
+    mod.functions[0].locals = [{ id: "ctor", name: "ctor", type: ctor, mutable: false }];
+    mod.classes = [
+        { name: "Family", fields: [], methods: [], loc },
+        { name: "Concrete", genericOf: "Family", fields: [], methods: [], loc },
+    ];
+    expect(validateModule(mod).map((error) => error.message)).toContain('in main: upcast: "Concrete" does not extend "Family"');
+});
 test("library callbacks retain child, specialized, and generic result diagnostics", () => {
     const expr = {
         kind: "libCall",
@@ -1056,7 +1144,7 @@ test.each([
 function tdzModule(mutable = true) {
     const value = { kind: "numLit", value: 0, type: F64, loc };
     return {
-        irVersion: 13,
+        irVersion: 15,
         sourceFile: loc.file,
         entry: "main",
         functions: [
@@ -1179,6 +1267,79 @@ test.each(["receiver", "key", "result"])("overflow presence checks its %s type",
     const message = slot === "result" ? "recordOvfHas must be bool" : `recordOvfHas ${slot}`;
     expect(validateModule(mod).some((error) => error.message.includes(message))).toBe(true);
 });
+function fieldPresenceModule(absentInLiteral) {
+    const optional = { kind: "union", unionId: "maybeCount" };
+    const record = { kind: "record", shapeId: "item" };
+    const absent = { kind: "fieldAbsent", unionId: "maybeCount", type: optional, loc };
+    const literal = {
+        kind: "recordLit",
+        fields: [
+            {
+                name: "count",
+                value: absentInLiteral
+                    ? {
+                        kind: "ternary",
+                        cond: { kind: "boolLit", value: true, type: BOOL, loc },
+                        then: {
+                            kind: "unionWrap",
+                            unionId: "maybeCount",
+                            tag: 0,
+                            value: { kind: "numLit", value: 1, type: F64, loc },
+                            type: optional,
+                            loc,
+                        },
+                        else_: absent,
+                        type: optional,
+                        loc,
+                    }
+                    : {
+                        kind: "unionWrap",
+                        unionId: "maybeCount",
+                        tag: 1,
+                        value: { kind: "unitLit", unit: "undefined", type: UNDEFINED_T, loc },
+                        type: optional,
+                        loc,
+                    },
+            },
+        ],
+        type: record,
+        loc,
+    };
+    const check = {
+        kind: "recordHas",
+        obj: literal,
+        shapeId: "item",
+        field: "count",
+        type: BOOL,
+        loc,
+    };
+    const mod = expressionModule(check, [{ id: "maybeCount", arms: [F64, UNDEFINED_T] }]);
+    mod.records = [{ id: "item", fields: [{ name: "count", type: optional }] }];
+    if (!absentInLiteral)
+        mod.functions[0].body.push({ kind: "exprStmt", expr: absent, loc });
+    return mod;
+}
+test("field presence checks and absent field states validate and serialize", () => {
+    const mod = fieldPresenceModule(true);
+    expect(validateModule(mod)).toEqual([]);
+    expect(deserializeModule(serializeModule(mod))).toEqual(mod);
+});
+test("the absent field state is confined to field writes", () => {
+    expect(validateModule(fieldPresenceModule(false)).some((error) => error.message.includes("fieldAbsent outside a record field write"))).toBe(true);
+});
+test("the absent field state requires an undefined arm", () => {
+    const mod = fieldPresenceModule(true);
+    mod.unions = [{ id: "maybeCount", arms: [F64, STRING] }];
+    expect(validateModule(mod).some((error) => error.message.includes("the union has no undefined arm"))).toBe(true);
+});
+test("field presence checks name a declared field", () => {
+    const mod = fieldPresenceModule(true);
+    const statement = mod.functions[0].body[0];
+    if (statement.kind !== "exprStmt" || statement.expr.kind !== "recordHas")
+        throw new Error("fixture");
+    statement.expr.field = "missing";
+    expect(validateModule(mod).some((error) => error.message.includes('has no field "missing"'))).toBe(true);
+});
 test("TDZ locals require a shared box", () => {
     const mod = tdzModule();
     delete mod.functions[0].locals[0].boxed;
@@ -1186,7 +1347,7 @@ test("TDZ locals require a shared box", () => {
 });
 function discriminatedModule() {
     return {
-        irVersion: 13,
+        irVersion: 15,
         sourceFile: loc.file,
         entry: "main",
         functions: [{ name: "main", params: [], locals: [], returnType: VOID, body: [], loc }],
@@ -1338,4 +1499,191 @@ test("typed-array brand tests serialize their element kind and reject misplaced
     expr.test = "array";
     expect(validateModule(mod).map((d) => d.message)).toContain("in main: dynTest bytesElem requires a valid bytes test");
 });
+test("function result views preserve the parameter ABI and reject reversed covariance", () => {
+    const source = {
+        kind: "func",
+        params: [F64],
+        ret: { kind: "object", className: "Child" },
+    };
+    const target = {
+        kind: "func",
+        params: [F64],
+        ret: { kind: "object", className: "Base" },
+    };
+    const mod = expressionModule({
+        kind: "upcast",
+        value: { kind: "varRef", localId: "callback", type: source, loc },
+        type: target,
+        loc,
+    }, []);
+    mod.classes = [
+        { name: "Base", fields: [], loc },
+        { name: "Child", base: "Base", fields: [], loc },
+        { name: "Other", fields: [], loc },
+    ];
+    mod.functions[0].params = [{ localId: "callback", name: "callback", type: source }];
+    mod.functions[0].locals = [{ id: "callback", name: "callback", type: source, mutable: false }];
+    expect(validateModule(deserializeModule(serializeModule(mod)))).toEqual([]);
+    for (const variant of [
+        "parameter",
+        "arity",
+        "rest",
+        "rest-abi",
+        "arguments",
+        "return",
+        "unrelated",
+        "reverse",
+    ]) {
+        const bad = structuredClone(mod);
+        const stmt = bad.functions[0].body[0];
+        if (stmt.kind !== "exprStmt" || stmt.expr.kind !== "upcast" || stmt.expr.type.kind !== "func")
+            throw new Error("fixture");
+        const type = stmt.expr.type;
+        if (variant === "parameter")
+            type.params[0] = STRING;
+        if (variant === "arity")
+            type.params.push(F64);
+        if (variant === "rest")
+            type.rest = true;
+        if (variant === "rest-abi")
+            type.restAbi = "jsval";
+        if (variant === "arguments")
+            type.argumentsAll = true;
+        if (variant === "return")
+            type.ret = F64;
+        if (variant === "unrelated")
+            type.ret = { kind: "object", className: "Other" };
+        if (variant === "reverse") {
+            if (stmt.expr.value.type.kind !== "func")
+                throw new Error("fixture");
+            stmt.expr.value.type.ret = { kind: "object", className: "Base" };
+            type.ret = { kind: "object", className: "Child" };
+        }
+        expect(validateModule(bad).map((error) => error.message), variant).toContain("in main: function upcast requires identical parameters and a covariant class return");
+    }
+});
+test("abstract virtual slots admit subclass returns without admitting unrelated return layouts", () => {
+    const mod = virtualCallModule();
+    const base = { kind: "object", className: "Base" };
+    const child = { kind: "object", className: "First" };
+    for (const fn of mod.functions.filter((fn) => fn.name.startsWith("%"))) {
+        fn.params.push({ localId: "result", name: "result", type: child });
+        fn.locals.push({ id: "result", name: "result", type: child, mutable: false });
+        fn.returnType = child;
+        fn.body = [
+            { kind: "return", value: { kind: "varRef", localId: "result", type: child, loc }, loc },
+        ];
+    }
+    for (const fn of mod.functions.filter((fn) => fn.name.startsWith("caller"))) {
+        fn.params.push({ localId: "result", name: "result", type: child });
+        fn.locals.push({ id: "result", name: "result", type: child, mutable: false });
+        const stmt = fn.body[0];
+        if (stmt.kind !== "exprStmt" || stmt.expr.kind !== "virtualCall")
+            throw new Error("fixture");
+        stmt.expr.type = base;
+        stmt.expr.args.push({ kind: "varRef", localId: "result", type: child, loc });
+    }
+    expect(validateModule(deserializeModule(serializeModule(mod)))).toEqual([]);
+    mod.classes.find((cls) => cls.name === "First").base = "Unrelated";
+    expect(validateModule(mod).map((error) => error.message)).toEqual([
+        "in caller0: virtualCall Base.run result type mismatch",
+        "in caller1: virtualCall Base.run result type mismatch",
+    ]);
+});
+test("signature adapters capture the function whose identity they share", () => {
+    const source = { kind: "func", params: [F64], ret: VOID };
+    const target = { kind: "func", params: [F64, F64], ret: VOID };
+    const adapter = {
+        kind: "closure",
+        fnName: "view",
+        captures: ["f.0"],
+        adapts: true,
+        type: target,
+        loc,
+    };
+    const mod = expressionModule(adapter, []);
+    mod.functions[0].locals.push({
+        id: "f.0",
+        name: "f",
+        type: source,
+        mutable: false,
+        boxed: true,
+    });
+    mod.functions.push({
+        name: "view",
+        params: [
+            { localId: "a.0", name: "a", type: F64 },
+            { localId: "b.0", name: "b", type: F64 },
+        ],
+        captures: [{ localId: "f.0", name: "f", type: source }],
+        locals: [
+            { id: "f.0", name: "f", type: source, mutable: false, boxed: true },
+            { id: "a.0", name: "a", type: F64, mutable: false },
+            { id: "b.0", name: "b", type: F64, mutable: false },
+        ],
+        returnType: VOID,
+        body: [],
+        loc,
+    });
+    expect(validateModule(mod)).toEqual([]);
+    expect(deserializeModule(serializeModule(mod))).toEqual(mod);
+    const numeric = structuredClone(mod);
+    for (const fn of numeric.functions)
+        for (const local of fn.locals)
+            if (local.id === "f.0")
+                local.type = F64;
+    numeric.functions[1].captures = [{ localId: "f.0", name: "f", type: F64 }];
+    expect(validateModule(numeric).some((error) => error.message.includes("an adapter's first capture must be a function"))).toBe(true);
+});
+test("runtime comparator sort validates element kinds and the comparator shape", () => {
+    const comparator = (params, ret = F64) => ({
+        kind: "closure",
+        fnName: "cmp",
+        captures: [],
+        type: funcOf(params, ret),
+        loc,
+    });
+    const sortModule = (elem, cmp, arms) => {
+        const mod = numericReadModule({
+            method: "sortValues",
+            receiver: { kind: "arrayLit", elems: [], type: arrayOf(elem), loc },
+            args: [{ kind: "numLit", value: 0, type: F64, loc }, cmp],
+            type: VOID,
+        });
+        const params = cmp.type.kind === "func" ? cmp.type.params : [];
+        mod.functions.push({
+            name: "cmp",
+            params: params.map((type, index) => ({ localId: `p${index}`, name: `p${index}`, type })),
+            locals: params.map((type, index) => ({
+                id: `p${index}`,
+                name: `p${index}`,
+                type,
+                mutable: false,
+            })),
+            returnType: F64,
+            body: [{ kind: "return", value: { kind: "numLit", value: 0, type: F64, loc }, loc }],
+            loc,
+        });
+        if (arms)
+            mod.unions = [{ id: "u", arms }];
+        return mod;
+    };
+    const union = { kind: "union", unionId: "u" };
+    for (const mod of [
+        sortModule(F64, comparator([F64, F64])),
+        sortModule(STRING, comparator([STRING])),
+        sortModule(union, comparator([union, union]), [STRING, F64]),
+    ]) {
+        expect(validateModule(mod)).toEqual([]);
+        expect(deserializeModule(serializeModule(mod))).toEqual(mod);
+    }
+    for (const [mod, message] of [
+        [sortModule(BOOL, comparator([BOOL, BOOL])), "sortValues on bool"],
+        [sortModule(union, comparator([union, union]), [STRING, UNDEFINED_T]), "sortValues on union"],
+        [sortModule(F64, comparator([STRING, STRING])), "comparator must be"],
+        [sortModule(F64, comparator([F64, F64, F64])), "comparator must be"],
+    ]) {
+        expect(validateModule(mod).some((error) => error.message.includes(message))).toBe(true);
+    }
+});
 //# sourceMappingURL=validate.test.js.map