@scriptc/compiler 0.2.5 → 0.2.7

package/dist/ir/validate.js

@@ -4,7 +4,7 @@
  * an ICE that points at source is a gift to whoever debugs it.
  */
 import { validByteNumberToken } from "./byte-numbers.js";
-import { arrayOf, BYTES_ELEMENT_NAME, BOOL, BYTES_U8, bytesOf, canAdaptDynFuncTo, canDynCheckTo, canConvertToDyn, canExitIslandToType, canMarshalIntoIsland, canMarshalTypedFuncIntoIsland, DYN, DYN_HANDLE_KINDS, F64, ffiClassType, ffiSourceParamTypes, islandPromisePayloadTag, isDynTypedRefType, isFfiCallbackParam, isFfiContextParam, isFfiReleaseParam, isJsonSafeType, isJsonStringifySafeType, isRefCounted, isSupportedArrayElem, isSupportedIndexValue, isSupportedMapKey, isSupportedMapValue, isSupportedSetElem, isUnitType, jsOpResultKind, JSVAL, REF_TRUTHY_KINDS, RUNTIME_EMITTER_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, shapeHasAccessorSlots, STRING, typeEquals, typeKey, unionContainerArmsOk, VOID, } from "./ir.js";
+import { arrayOf, BYTES_ELEMENT_NAME, BOOL, BYTES_U8, bytesOf, canAdaptDynFuncTo, canDynCheckTo, canConvertToDyn, canExitIslandToType, canMarshalIntoIsland, canMarshalTypedFuncIntoIsland, DYN, DYN_HANDLE_KINDS, F64, ffiClassType, ffiSourceParamTypes, islandPromisePayloadTag, isDynTypedRefType, isFfiCallbackParam, isFfiContextParam, isFfiReleaseParam, isJsonSafeType, isJsonStringifySafeType, isRefCounted, isSortValuesElement, isSupportedArrayElem, isSupportedIndexValue, isSupportedMapKey, isSupportedMapValue, isSupportedSetElem, isUnitType, jsOpResultKind, JSVAL, REF_TRUTHY_KINDS, RUNTIME_EMITTER_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, shapeHasAccessorSlots, STRING, typeEquals, typeKey, unionContainerArmsOk, VOID, } from "./ir.js";
 import { DYN_CLASS_PROPERTIES } from "./ir.js";
 import { unionWideningTags } from "./analysis.js";
 import { alwaysReturns } from "./control-flow.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,
             });
         }
@@ -656,9 +683,8 @@ export function validateModule(mod) {
         }
         u.arms.forEach((arm, i) => {
             // The unit kinds (undefinedT/nullT) are valid arms — union membership
-            // is the ONLY place they may appear. Containers are valid beside
-            // unit arms: tag tests distinguish absence while the reference
-            // payload preserves identity. The shared rule refuses data siblings.
+            // is the ONLY place they may appear. Container payloads preserve
+            // identity; promise data siblings retain their separate fence.
             if (arm.kind === "void" ||
                 arm.kind === "union" ||
                 arm.kind === "dyn" ||
@@ -667,8 +693,7 @@ export function validateModule(mod) {
                 arm.kind === "generator") {
                 errors.push({ message: `union ${u.id}: arm ${i} is ${arm.kind}`, loc: noLoc });
             }
-            if ((arm.kind === "map" || arm.kind === "set" || arm.kind === "promise") &&
-                !unionContainerArmsOk(u.arms)) {
+            if (arm.kind === "promise" && !unionContainerArmsOk(u.arms)) {
                 errors.push({
                     message: `union ${u.id}: ${arm.kind} arm ${i} beside non-unit arms`,
                     loc: noLoc,
@@ -831,11 +856,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 +893,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 +950,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}`);
@@ -924,16 +973,16 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
     if (isUnitType(fn.returnType)) {
         err(`return type is bare unit type ${fn.returnType.kind}`, fn.loc);
     }
-    // Exception snapshots may be captured, but are never public parameters
-    // or return values. Their payload crosses those boundaries explicitly.
+    // Exception snapshots may be captured or passed to internal conversion
+    // helpers. They are not source-level types and never return as values.
     if (fn.returnType.kind === "caught")
         err("return type is caught", fn.loc);
     for (const p of fn.params) {
+        if (p.type.kind === "caught" && fn.name !== "%caught.dynamicValue")
+            err(`param "${p.name}" is caught-typed`, fn.loc);
         if (!locals.has(p.localId)) {
             err(`param "${p.name}" has no local entry "${p.localId}"`, fn.loc);
         }
-        if (p.type.kind === "caught")
-            err(`param "${p.name}" is caught-typed`, fn.loc);
     }
     for (const c of [...(fn.captures ?? []), ...(fn.classCaptures ?? [])]) {
         const local = locals.get(c.localId);
@@ -1090,6 +1139,23 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
     }
     // Keep expression families in separate functions so native bootstrap builds
     // do not feed LLVM a single control-flow graph containing every IR check.
+    /** fieldAbsent nodes that sit directly in a field-slot write (a
+     * recordLit field, recordSet value, recordClone override, or a ternary
+     * arm in one of those positions) — the only places the absent state may
+     * appear. */
+    const fieldSlotValues = new Set();
+    function checkSlotValue(e) {
+        const mark = (v) => {
+            if (v.kind === "fieldAbsent")
+                fieldSlotValues.add(v);
+            else if (v.kind === "ternary") {
+                mark(v.then);
+                mark(v.else_);
+            }
+        };
+        mark(e);
+        checkExpr(e);
+    }
     function checkExpr(e) {
         switch (e.kind) {
             case "numLit":
@@ -1162,6 +1228,8 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
             case "recordKeyGet":
             case "recordOvfHas":
             case "recordOvfKeys":
+            case "recordHas":
+            case "fieldAbsent":
                 return checkRecordExpr(e);
             case "dynFrom":
             case "dynFromJsval":
@@ -1409,6 +1477,12 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                     allowed.add("throw");
                     allowed.add("runtimeFence");
                 }
+                if (e.diverges) {
+                    const last = e.stmts[e.stmts.length - 1];
+                    if (last?.kind !== "runtimeFence")
+                        err("diverging seqExpr must end in a runtimeFence", e.loc);
+                    allowed.add("runtimeFence");
+                }
                 const flat = (ss) => {
                     for (const s of ss) {
                         if (!allowed.has(s.kind)) {
@@ -2047,7 +2121,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 }
@@ -2071,7 +2147,27 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                                                                                                 ? { argTypes: [e.type], result: e.type }
                                                                                                 : e.method === "shift"
                                                                                                     ? { argTypes: [], result: e.type } // union-checked below
-                                                                                                    : { argTypes: [], result: F64 }; // length
+                                                                                                    : e.method === "sortValues"
+                                                                                                        ? { argTypes: [F64, null], result: VOID }
+                                                                                                        : { 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 === "sortValues") {
+                    const arms = elem.kind === "union" ? unions.get(elem.unionId)?.arms : undefined;
+                    if (!isSortValuesElement(elem, arms))
+                        err(`arrIntrinsic sortValues on ${elem.kind} elements`, e.loc);
+                    const cmp = e.args[1]?.type;
+                    if (!cmp ||
+                        cmp.kind !== "func" ||
+                        cmp.params.length > 2 ||
+                        !cmp.params.every((param) => typeEquals(param, elem)) ||
+                        cmp.ret.kind !== "f64")
+                        err("arrIntrinsic sortValues comparator must be (elem, elem) => number", e.loc);
+                }
                 if (e.method === "getNumber" && elem.kind !== "f64") {
                     err(`arrIntrinsic getNumber requires f64 elements, got ${elem.kind}`, e.loc);
                 }
@@ -2354,6 +2450,9 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                     break;
                 }
                 const wantCaps = target.captures ?? [];
+                if (e.adapts === true && locals.get(e.captures[0] ?? "")?.type.kind !== "func") {
+                    err(`closure ${e.fnName}: an adapter's first capture must be a function`, e.loc);
+                }
                 if (target.captures === undefined && e.captures.length > 0) {
                     err(`closure over plain function "${e.fnName}" cannot capture`, e.loc);
                 }
@@ -2503,9 +2602,23 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                 // exactly when D strictly descends from C AND the two completed
                 // constructor ABIs agree (what newValue completion rests on).
                 checkExpr(e.value);
+                if (e.kind === "upcast" && e.type.kind === "func" && e.value.type.kind === "func") {
+                    const source = e.value.type;
+                    const target = e.type;
+                    if (source.rest !== target.rest ||
+                        source.restAbi !== target.restAbi ||
+                        source.argumentsAll !== target.argumentsAll ||
+                        source.params.length !== target.params.length ||
+                        !source.params.every((param, i) => typeEquals(param, target.params[i])) ||
+                        source.ret.kind !== "object" ||
+                        target.ret.kind !== "object" ||
+                        !isStrictSubclass(source.ret.className, target.ret.className))
+                        err("function upcast requires identical parameters and a covariant class return", e.loc);
+                    break;
+                }
                 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;
                     }
@@ -2670,7 +2783,11 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                     if (p)
                         expectType(a, p.type, `virtualCall ${e.className}.${e.method} arg ${i}`);
                 });
-                if (!typeEquals(e.type, callSiteReturnType(impl))) {
+                const returned = callSiteReturnType(impl);
+                if (!typeEquals(e.type, returned) &&
+                    !(e.type.kind === "object" &&
+                        returned.kind === "object" &&
+                        isStrictSubclass(returned.className, e.type.className))) {
                     err(`virtualCall ${e.className}.${e.method} result type mismatch`, e.loc);
                 }
                 break;
@@ -2696,7 +2813,10 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                 const want = recordValidation.get(shape.id).initializationFields;
                 const seen = new Set();
                 for (const f of e.fields) {
-                    checkExpr(f.value);
+                    if (f.drop || f.overflow)
+                        checkExpr(f.value);
+                    else
+                        checkSlotValue(f.value);
                     if (seen.has(f.name))
                         err(`recordLit initializes field "${f.name}" twice`, e.loc);
                     seen.add(f.name);
@@ -2756,7 +2876,7 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                 const want = recordValidation.get(shape.id).initializationFields;
                 const seen = new Set();
                 for (const f of e.overrides) {
-                    checkExpr(f.value);
+                    checkSlotValue(f.value);
                     if (seen.has(f.name))
                         err(`recordClone overrides field "${f.name}" twice`, e.loc);
                     seen.add(f.name);
@@ -2768,6 +2888,30 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                 }
                 break;
             }
+            case "recordHas": {
+                checkExpr(e.obj);
+                const shape = records.get(e.shapeId);
+                if (!shape)
+                    err(`recordHas on undeclared shape "${e.shapeId}"`, e.loc);
+                else if (!recordValidation.get(e.shapeId)?.fields.has(e.field))
+                    err(`shape ${e.shapeId} has no field "${e.field}"`, e.loc);
+                expectType(e.obj, { kind: "record", shapeId: e.shapeId }, "recordHas receiver");
+                if (e.type.kind !== "bool")
+                    err("recordHas must be bool", e.loc);
+                break;
+            }
+            case "fieldAbsent": {
+                const def = unions.get(e.unionId);
+                if (!def)
+                    err(`fieldAbsent of undeclared union "${e.unionId}"`, e.loc);
+                else if (!def.arms.some((arm) => arm.kind === "undefinedT"))
+                    err(`fieldAbsent of ${e.unionId}: the union has no undefined arm`, e.loc);
+                if (e.type.kind !== "union" || e.type.unionId !== e.unionId)
+                    err("fieldAbsent must have its union type", e.loc);
+                if (!fieldSlotValues.has(e))
+                    err("fieldAbsent outside a record field write", e.loc);
+                break;
+            }
             case "recordGet": {
                 checkExpr(e.obj);
                 const shape = records.get(e.shapeId);
@@ -3065,8 +3209,8 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                 if (e.test === "instanceof") {
                     if (!e.className)
                         err("caughtTest instanceof without a class", e.loc);
-                    else if (!hierarchy.has(e.className)) {
-                        err(`caughtTest instanceof against non-hierarchy class "${e.className}"`, e.loc);
+                    else if (!classes.has(e.className)) {
+                        err(`caughtTest instanceof against undeclared class "${e.className}"`, e.loc);
                     }
                 }
                 else if (e.className !== undefined) {
@@ -3102,9 +3246,9 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                 const ok = t.kind === "f64" ||
                     t.kind === "bool" ||
                     t.kind === "string" ||
-                    (t.kind === "object" && hierarchy.has(t.className));
+                    (t.kind === "object" && classes.has(t.className));
                 if (!ok) {
-                    err(`caughtNarrow to ${t.kind === "object" ? `non-hierarchy class "${t.className}"` : t.kind}`, e.loc);
+                    err(`caughtNarrow to ${t.kind === "object" ? `undeclared class "${t.className}"` : t.kind}`, e.loc);
                 }
                 break;
             }
@@ -3258,6 +3402,19 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
         }
     }
     function checkIntrinsicExpr(e) {
+        if (e.name === "module.tdzCheck") {
+            const [flag, name] = e.args;
+            if (e.args.length !== 2 || flag === undefined || name?.kind !== "strLit") {
+                err("module.tdzCheck takes a flag and a binding-name literal", e.loc);
+                return;
+            }
+            checkExpr(flag);
+            if (flag.type.kind !== "bool")
+                err("module.tdzCheck flag must be bool", e.loc);
+            if (e.type.kind !== "void")
+                err("module.tdzCheck must be void", e.loc);
+            return;
+        }
         if (e.name === "module.await") {
             if (e.args.length !== 1)
                 err("module.await takes exactly one argument", e.loc);
@@ -3365,6 +3522,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);
@@ -5226,7 +5390,7 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
             }
             case "assign": {
                 const binding = locals.get(s.localId) ?? globals.get(s.localId);
-                if (s.initializes && !binding?.tdz) {
+                if (s.initializes && !binding?.tdz && globals.get(s.localId)?.initFlag === undefined) {
                     err(`initializing assign requires a TDZ binding "${s.localId}"`, s.loc);
                 }
                 if (!binding)
@@ -5364,7 +5528,7 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
             }
             case "recordSet": {
                 checkExpr(s.obj);
-                checkExpr(s.value);
+                checkSlotValue(s.value);
                 const shape = records.get(s.shapeId);
                 const field = recordValidation.get(s.shapeId)?.fields.get(s.field);
                 if (!shape)