@scriptc/compiler 0.2.5 → 0.2.6

package/dist/ir/validate.js

@@ -53,7 +53,20 @@ export function validateModule(mod) {
     const ffiByName = new Map();
     const ffiSymbols = new Set();
     const moduleLoc = { file: mod.sourceFile, start: 0, end: 0 };
+    if (mod.workers !== undefined && typeof mod.workers !== "boolean")
+        errors.push({ message: "worker execution mode must be a boolean", loc: moduleLoc });
+    if (mod.workers && (mod.lib !== undefined || mod.embedded !== undefined))
+        errors.push({
+            message: "worker execution requires a native static executable",
+            loc: moduleLoc,
+        });
     for (const entry of mod.ffiImports ?? []) {
+        if (mod.workers &&
+            entry.params.some((parameter) => isFfiCallbackParam(parameter) && parameter.callback.invoke === "foreign"))
+            errors.push({
+                message: "worker execution cannot install foreign-thread callbacks",
+                loc: moduleLoc,
+            });
         if (ffiByName.has(entry.name)) {
             errors.push({ message: `duplicate FFI binding "${entry.name}"`, loc: moduleLoc });
         }
@@ -473,8 +486,19 @@ export function validateModule(mod) {
             });
         }
     }
-    // Generic-class instantiations: the named FAMILY exists and is a proper
-    // ancestor (the class object's interval is read off it — see IrClassDef).
+    // Family membership is nominal; an instance may have a separately
+    // specialized base. The family's inherited prefix must remain valid.
+    const physicalRoot = (cls) => {
+        const seen = new Set();
+        let current = cls;
+        while (current?.base !== undefined) {
+            if (seen.has(current.name))
+                return undefined;
+            seen.add(current.name);
+            current = classesByName.get(current.base);
+        }
+        return current;
+    };
     for (const cls of mod.classes ?? []) {
         if (cls.genericOf === undefined)
             continue;
@@ -484,20 +508,23 @@ export function validateModule(mod) {
                 message: `class ${cls.name}: undeclared generic family "${cls.genericOf}"`,
                 loc: cls.loc,
             });
-            continue;
         }
-        let ancestor = false;
-        const seen = new Set();
-        for (let c = cls.base !== undefined ? classesByName.get(cls.base) : undefined; c && !seen.has(c.name); c = c.base !== undefined ? classesByName.get(c.base) : undefined) {
-            seen.add(c.name);
-            if (c.name === cls.genericOf) {
-                ancestor = true;
-                break;
-            }
+        else if (family === cls || family.genericOf !== undefined) {
+            errors.push({
+                message: `class ${cls.name}: generic family "${cls.genericOf}" must name an erased declaration`,
+                loc: cls.loc,
+            });
         }
-        if (!ancestor) {
+        else if (physicalRoot(cls) !== physicalRoot(family)) {
             errors.push({
-                message: `class ${cls.name}: generic family "${cls.genericOf}" is not an ancestor`,
+                message: `class ${cls.name}: generic family "${cls.genericOf}" has a different storage root`,
+                loc: cls.loc,
+            });
+        }
+        else if (family.fields.some((field, index) => cls.fields[index]?.name !== field.name ||
+            !typeEquals(cls.fields[index].type, field.type))) {
+            errors.push({
+                message: `class ${cls.name}: generic family "${cls.genericOf}" has an incompatible prefix`,
                 loc: cls.loc,
             });
         }
@@ -831,11 +858,11 @@ export function validateModule(mod) {
         }
     }
     for (const fn of mod.functions) {
-        validateFunction(fn, functionsByName, ffiByName, classesByName, recordsById, recordValidation, unionsById, globalsById, classValidation, errors);
+        validateFunction(fn, functionsByName, ffiByName, classesByName, recordsById, recordValidation, unionsById, globalsById, classValidation, errors, mod.workers === true);
     }
     return errors;
 }
-function validateFunction(fn, functions, ffiByName, classes, records, recordValidation, unions, globals, classValidation, errors) {
+function validateFunction(fn, functions, ffiByName, classes, records, recordValidation, unions, globals, classValidation, errors, workers) {
     const locals = new Map(fn.locals.map((l) => [l.id, l]));
     const err = (message, loc) => errors.push({ message: `in ${fn.name}: ${message}`, loc });
     const asyncCaches = [
@@ -868,13 +895,37 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
     if (fn.asyncCycleCacheGlobal !== undefined && fn.asyncCacheGlobal === undefined) {
         err("an asyncCycleCacheGlobal requires a module asyncCacheGlobal", fn.loc);
     }
-    // The class graph's two questions (upcast/downcast/instanceOf/virtualCall
-    // legality): strict-descendant tests over the base links, and hierarchy
-    // membership (a class that extends or is extended).
+    // Virtual slots and constructor ABIs follow physical inheritance only.
+    // Erased family identity does not supply their specialized layout or ABI.
+    const isPhysicalSubclass = (sub, sup) => {
+        const seen = new Set([sub]);
+        for (let c = classes.get(sub)?.base; c !== undefined; c = classes.get(c)?.base) {
+            if (seen.has(c))
+                return false;
+            seen.add(c);
+            if (c === sup)
+                return true;
+        }
+        return false;
+    };
+    // Object casts may also recover an erased family. The module-level
+    // prefix check validates the fields exposed by that view.
     const isStrictSubclass = (sub, sup) => {
-        for (let c = classes.get(sub); c?.base !== undefined; c = classes.get(c.base)) {
-            if (c.base === sup)
+        const seen = new Set();
+        for (let c = classes.get(sub); c; c = c.base === undefined ? undefined : classes.get(c.base)) {
+            if (seen.has(c.name))
+                return false;
+            seen.add(c.name);
+            if (c.name !== sub && c.name === sup)
                 return true;
+            const families = new Set();
+            for (let family = c.genericOf === undefined ? undefined : classes.get(c.genericOf); family; family = family.base === undefined ? undefined : classes.get(family.base)) {
+                if (families.has(family.name))
+                    return false;
+                families.add(family.name);
+                if (family.name === sup)
+                    return true;
+            }
         }
         return false;
     };
@@ -901,7 +952,7 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
         if (declared) {
             // Preserve class-table order when choosing an abstract slot's ABI.
             for (const c of classValidation.implementations.get(method) ?? []) {
-                if (!isStrictSubclass(c.name, className))
+                if (!isPhysicalSubclass(c.name, className))
                     continue;
                 hasOverride = true;
                 implementation ??= functions.get(`%${c.name}.${method}`);
@@ -2047,7 +2098,9 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                                                             ? { argTypes: [STRING], result: STRING }
                                                             : e.method === "slice"
                                                                 ? { argTypes: [F64, F64], result: e.receiver.type }
-                                                                : e.method === "toReversed"
+                                                                : e.method === "toReversed" ||
+                                                                    e.method === "sortPrimitive" ||
+                                                                    e.method === "toSortedPrimitive"
                                                                     ? { argTypes: [], result: e.receiver.type }
                                                                     : e.method === "reverse"
                                                                         ? { argTypes: [], result: e.receiver.type }
@@ -2072,6 +2125,12 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                                                                                                 : e.method === "shift"
                                                                                                     ? { argTypes: [], result: e.type } // union-checked below
                                                                                                     : { argTypes: [], result: F64 }; // length
+                if ((e.method === "sortPrimitive" || e.method === "toSortedPrimitive") &&
+                    elem.kind !== "string" &&
+                    elem.kind !== "f64" &&
+                    elem.kind !== "bool") {
+                    err(`arrIntrinsic ${e.method} requires primitive elements, got ${elem.kind}`, e.loc);
+                }
                 if (e.method === "getNumber" && elem.kind !== "f64") {
                     err(`arrIntrinsic getNumber requires f64 elements, got ${elem.kind}`, e.loc);
                 }
@@ -2505,7 +2564,7 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                 checkExpr(e.value);
                 if (e.kind === "upcast" && e.type.kind === "classval" && e.value.type.kind === "classval") {
                     const [sub, sup] = [e.value.type.className, e.type.className];
-                    if (!isStrictSubclass(sub, sup)) {
+                    if (!isPhysicalSubclass(sub, sup)) {
                         err(`upcast: "${sub}" does not extend "${sup}"`, e.loc);
                         break;
                     }
@@ -3365,6 +3424,13 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
             err(`${e.name} must be void`, e.loc);
     }
     function checkLibCall(e) {
+        if (e.fn === "atomics.op" &&
+            (e.args[0]?.type.kind !== "bytes" ||
+                !["u8", "i8", "u16", "i16", "u32", "i32"].includes(e.args[0].type.elem))) {
+            errors.push({ message: "integer Atomics require an integer typed array", loc: e.loc });
+        }
+        if (e.fn === "worker.new" && !workers)
+            errors.push({ message: "Worker construction requires worker execution mode", loc: e.loc });
         const sig = LIB_FN_SIGS[e.fn];
         if (!sig) {
             err(`libCall of unknown library function "${e.fn}"`, e.loc);