@scriptc/compiler 0.2.2 → 0.2.3

package/dist/ir/validate.js

@@ -358,8 +358,13 @@ export const LIB_FN_SIGS = {
     "url.port": { argTypes: [URL_T], result: STRING },
     "url.pathname": { argTypes: [URL_T], result: STRING },
     "url.href": { argTypes: [URL_T], result: STRING },
+    "url.set": { argTypes: [URL_T, STRING, STRING], result: VOID },
+    "url.setChecked": { argTypes: [URL_T, STRING, DYN], result: VOID },
     "url.fileURLToPathUrl": { argTypes: [URL_T], result: STRING },
     "url.fileURLToPathChecked": { argTypes: [DYN], result: STRING },
+    "url.fileURLToPathOptions": { argTypes: [DYN, DYN], result: STRING },
+    "url.fileURLToPathBuffer": { argTypes: [DYN, DYN], result: BYTES_U8 },
+    "url.pathToFileURLChecked": { argTypes: [DYN, DYN], result: URL_T },
     "url.fileURLToPathStr": { argTypes: [STRING], result: STRING },
     "url.pathToFileURL": { argTypes: [STRING], result: URL_T },
     "url.pathToFileURLPlatform": { argTypes: [STRING, BOOL], result: URL_T },
@@ -400,6 +405,15 @@ export const LIB_FN_SIGS = {
     "qs.unescape": { argTypes: [STRING], result: STRING },
     "util.parseArgs": { argTypes: [DYN], result: DYN },
     "util.parseEnv": { argTypes: [DYN], result: DYN },
+    "util.getSystemErrorName": { argTypes: [DYN], result: STRING },
+    "util.getSystemErrorMessage": { argTypes: [DYN], result: STRING },
+    "util.systemErrorEntries": { argTypes: [], result: DYN },
+    "util.stripVTControlCharacters": { argTypes: [DYN], result: STRING },
+    "util.toUSVString": { argTypes: [DYN], result: STRING },
+    "util.isDeepStrictEqual": { argTypes: [DYN, DYN, DYN], result: BOOL },
+    "util.styleText": { argTypes: [DYN, DYN, DYN], result: STRING },
+    "util.typeIs": { argTypes: [DYN, STRING], result: BOOL },
+    "util.typeValue": { argTypes: [DYN, STRING], result: DYN },
     "fs.statSync": { argTypes: [STRING], result: STATS_T },
     "fs.lstatSync": { argTypes: [STRING], result: STATS_T },
     "fs.fstatSync": { argTypes: [F64], result: STATS_T },
@@ -407,9 +421,17 @@ export const LIB_FN_SIGS = {
     "fs.fsyncSync": { argTypes: [F64], result: VOID },
     "fs.fdatasyncSync": { argTypes: [F64], result: VOID },
     "fs.ftruncateSync": { argTypes: [F64, F64], result: VOID },
+    "fs.utimesSync": { argTypes: [DYN, DYN, DYN], result: VOID },
+    "fs.futimesSync": { argTypes: [DYN, DYN, DYN], result: VOID },
+    "fs.lutimesSync": { argTypes: [DYN, DYN, DYN], result: VOID },
     "fs.readvSync": { argTypes: [F64, arrayOf(BYTES_U8), F64], result: F64 },
     "fs.writevSync": { argTypes: [F64, arrayOf(BYTES_U8), F64], result: F64 },
-    "fs.linkSync": { argTypes: [STRING, STRING], result: VOID },
+    "fs.linkSync": { argTypes: [DYN, DYN], result: VOID },
+    "fs.symlinkSync": { argTypes: [DYN, DYN, DYN], result: VOID },
+    "fs.readlinkSync": { argTypes: [DYN, DYN], result: DYN },
+    "fs.statfsSync": { argTypes: [DYN, DYN], result: DYN },
+    "fs.readlinkSyncStr": { argTypes: [DYN, DYN], result: STRING },
+    "fs.readlinkSyncBuffer": { argTypes: [DYN, DYN], result: BYTES_U8 },
     "fs.openSync": { argTypes: [STRING, STRING], result: F64 },
     "fs.openNumericSync": { argTypes: [STRING, F64, F64], result: F64 },
     "fs.readSync": { argTypes: [F64, BYTES_U8, F64, F64, F64], result: F64 },
@@ -1051,6 +1073,14 @@ export const LIB_FN_SIGS = {
     "fsp.mkdirRecursiveMode": { argTypes: [STRING, F64], result: { kind: "promise", inner: VOID } },
     "fsp.unlink": { argTypes: [STRING], result: { kind: "promise", inner: VOID } },
     "fsp.chmod": { argTypes: [STRING, F64], result: { kind: "promise", inner: VOID } },
+    "fsp.link": { argTypes: [DYN, DYN], result: { kind: "promise", inner: VOID } },
+    "fsp.symlink": { argTypes: [DYN, DYN, DYN], result: { kind: "promise", inner: VOID } },
+    "fsp.readlink": { argTypes: [DYN, DYN], result: { kind: "promise", inner: DYN } },
+    "fsp.statfs": { argTypes: [DYN, DYN], result: { kind: "promise", inner: DYN } },
+    "fsp.readlinkStr": { argTypes: [DYN, DYN], result: { kind: "promise", inner: STRING } },
+    "fsp.readlinkBuffer": { argTypes: [DYN, DYN], result: { kind: "promise", inner: BYTES_U8 } },
+    "fsp.utimes": { argTypes: [DYN, DYN, DYN], result: { kind: "promise", inner: VOID } },
+    "fsp.lutimes": { argTypes: [DYN, DYN, DYN], result: { kind: "promise", inner: VOID } },
     "fsp.rename": { argTypes: [STRING, STRING], result: { kind: "promise", inner: VOID } },
     "fsp.readdir": { argTypes: [STRING], result: { kind: "promise", inner: arrayOf(STRING) } },
     // Result is promise<call-site Dirent record array>; the libCall case
@@ -1067,6 +1097,7 @@ export const LIB_FN_SIGS = {
     "fileHandle.datasync": { argTypes: [FILEHANDLE_T], result: { kind: "promise", inner: VOID } },
     "fileHandle.truncate": { argTypes: [FILEHANDLE_T, F64], result: { kind: "promise", inner: VOID } },
     "fileHandle.chmod": { argTypes: [FILEHANDLE_T, F64], result: { kind: "promise", inner: VOID } },
+    "fileHandle.utimes": { argTypes: [FILEHANDLE_T, DYN, DYN], result: { kind: "promise", inner: VOID } },
     "fileHandle.readv": { argTypes: [FILEHANDLE_T, arrayOf(BYTES_U8), F64], result: { kind: "promise", inner: VOID } },
     "fileHandle.writev": { argTypes: [FILEHANDLE_T, arrayOf(BYTES_U8), F64], result: { kind: "promise", inner: VOID } },
     // read/write carry call-site result record shapes; the validator checks
@@ -1390,6 +1421,9 @@ export const LIB_FN_SIGS = {
     "assert.shapeEnd": { argTypes: [STRING, BOOL], result: VOID },
     "assert.regexErrTest": { argTypes: [REGEX, { kind: "object", className: "%Error" }], result: BOOL },
     "assert.unwantedRejection": { argTypes: [{ kind: "object", className: "%Error" }, STRING, BOOL], result: VOID },
+    "assert.unwantedError": { argTypes: [STRING, BOOL, STRING, BOOL], result: VOID },
+    "assert.noErrorPredicate": { argTypes: [DYN, DYN], result: BOOL },
+    "assert.regexDynTest": { argTypes: [REGEX, DYN], result: BOOL },
     "assert.expectsErrDyn": { argTypes: [DYN, DYN, STRING, BOOL], result: VOID },
     // assert.ifError's typed entries (always throw; unit args never
     // lower). The error slot is program-dependent — any %Error-hierarchy
@@ -1761,6 +1795,7 @@ export function validateModule(mod) {
         });
     }
     const classesByName = new Map();
+    const classFields = new Map();
     for (const cls of mod.classes ?? []) {
         if (classesByName.has(cls.name)) {
             errors.push({ message: `duplicate class "${cls.name}"`, loc: cls.loc });
@@ -1813,16 +1848,24 @@ export function validateModule(mod) {
                 errors.push({ message: `class ${cls.name}: invalid symbol field metadata`, loc: cls.loc });
             }
         }
-        const seen = new Set();
+        // Reuse duplicate detection as the field index for function validation.
+        // Array.find selected the first field, even in an invalid duplicate layout.
+        const seen = new Map();
         for (const f of cls.fields) {
             if (seen.has(f.name)) {
                 errors.push({ message: `class ${cls.name}: duplicate field "${f.name}"`, loc: cls.loc });
             }
-            seen.add(f.name);
+            else
+                seen.set(f.name, f.type);
             if (isUnitType(f.type)) {
                 errors.push({ message: `class ${cls.name}: field "${f.name}" is ${f.type.kind}`, loc: cls.loc });
             }
         }
+        // Duplicate class names, like classesByName, select the last declaration.
+        if (seen.size > 0)
+            classFields.set(cls.name, seen);
+        else
+            classFields.delete(cls.name);
         // Constructor presence is checked at `new` sites (below): a class kept
         // only for its layout/type (reachability never constructs it) carries
         // no constructor function, and that is fine — nothing calls it.
@@ -1899,30 +1942,41 @@ export function validateModule(mod) {
     }
     const noLoc = { file: mod.sourceFile, start: 0, end: 0 };
     const recordsById = new Map();
+    const recordIds = new Set((mod.records ?? []).map((record) => record.id));
+    const recordValidation = new Map();
     for (const rec of mod.records ?? []) {
         if (recordsById.has(rec.id)) {
             errors.push({ message: `duplicate record shape "${rec.id}"`, loc: noLoc });
         }
         recordsById.set(rec.id, rec);
-        const seen = new Set();
+        const fields = new Map();
         for (const f of rec.fields) {
-            if (seen.has(f.name)) {
+            if (fields.has(f.name)) {
                 errors.push({ message: `record ${rec.id}: duplicate field "${f.name}"`, loc: noLoc });
             }
-            seen.add(f.name);
+            else
+                fields.set(f.name, f.type);
             // Unit kinds (undefinedT/nullT) exist only as union arms — a BARE
             // unit field is as malformed as a void one. dyn and jsval slots
             // are valid; both are refcounted values held by the record shape.
             if (f.type.kind === "void" || isUnitType(f.type)) {
                 errors.push({ message: `record ${rec.id}: field "${f.name}" is ${f.type.kind}`, loc: noLoc });
             }
-            if (f.type.kind === "record" && !new Set((mod.records ?? []).map((r) => r.id)).has(f.type.shapeId)) {
+            if (f.type.kind === "record" && !recordIds.has(f.type.shapeId)) {
                 errors.push({
                     message: `record ${rec.id}: field "${f.name}" references undeclared shape "${f.type.shapeId}"`,
                     loc: noLoc,
                 });
             }
         }
+        // Reads historically use the first duplicate field, while literal and
+        // clone checks use the last. Preserve both on malformed shapes; valid
+        // shapes share one index. All indexes belong to this validation call.
+        recordValidation.set(rec.id, {
+            fields,
+            initializationFields: fields.size === rec.fields.length ? fields : new Map(rec.fields.map((field) => [field.name, field.type])),
+            hasAccessorSlots: shapeHasAccessorSlots(rec),
+        });
         // Canonical order is the shape's identity — enforce it.
         const sorted = [...rec.fields].map((f) => f.name).sort();
         if (rec.fields.some((f, i) => f.name !== sorted[i])) {
@@ -1975,7 +2029,7 @@ export function validateModule(mod) {
             for (const candidate of cases) {
                 const arm = u.arms[candidate.tag];
                 const record = arm?.kind === "record" ? recordsById.get(arm.shapeId) : undefined;
-                const member = record?.fields.find((entry) => entry.name === field);
+                const member = record ? recordValidation.get(record.id)?.fields.get(field) : undefined;
                 if (!Number.isInteger(candidate.tag) || candidate.tag < 0 || !member || tags.has(candidate.tag)) {
                     errors.push({ message: `union ${u.id}: invalid discriminant tag ${candidate.tag}`, loc: noLoc });
                 }
@@ -1988,8 +2042,8 @@ export function validateModule(mod) {
                         errors.push({ message: `union ${u.id}: undefined discriminant value`, loc: noLoc });
                         continue;
                     }
-                    const fieldTypes = member?.type.kind === "union"
-                        ? unionsById.get(member.type.unionId)?.arms ?? [] : member ? [member.type] : [];
+                    const fieldTypes = member?.kind === "union"
+                        ? unionsById.get(member.unionId)?.arms ?? [] : member ? [member] : [];
                     const valid = fieldTypes.some((type) => typeof value === "string" ? type.kind === "string"
                         : typeof value === "boolean" ? type.kind === "bool"
                             : typeof value === "number" && Number.isFinite(value) && type.kind === "f64");
@@ -2152,12 +2206,34 @@ export function validateModule(mod) {
             }
         }
     }
+    // Class metadata is invariant across functions. Keep field lookup, hierarchy
+    // membership, and virtual-call resolution local to this validation invocation.
+    const classValidation = {
+        fields: classFields,
+        hierarchy: new Set(), implementations: new Map(), virtualCalls: new Map(),
+    };
+    for (const cls of classesByName.values()) {
+        if (cls.base !== undefined) {
+            classValidation.hierarchy.add(cls.name);
+            classValidation.hierarchy.add(cls.base);
+        }
+        if (cls.name === RUNTIME_EMITTER_CLASS)
+            classValidation.hierarchy.add(cls.name);
+        for (const method of new Set(cls.methods ?? [])) {
+            if (cls.abstractMethods?.includes(method))
+                continue;
+            let implementations = classValidation.implementations.get(method);
+            if (!implementations)
+                classValidation.implementations.set(method, (implementations = []));
+            implementations.push(cls);
+        }
+    }
     for (const fn of mod.functions) {
-        validateFunction(fn, functionsByName, ffiByName, classesByName, recordsById, unionsById, globalsById, errors);
+        validateFunction(fn, functionsByName, ffiByName, classesByName, recordsById, recordValidation, unionsById, globalsById, classValidation, errors);
     }
     return errors;
 }
-function validateFunction(fn, functions, ffiByName, classes, records, unions, globals, errors) {
+function validateFunction(fn, functions, ffiByName, classes, records, recordValidation, unions, globals, classValidation, errors) {
     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 = [
@@ -2200,17 +2276,41 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
         }
         return false;
     };
-    const hierarchy = new Set();
-    for (const c of classes.values()) {
-        if (c.base !== undefined) {
-            hierarchy.add(c.name);
-            hierarchy.add(c.base);
-        }
-        // The runtime emitter class is ALWAYS a hierarchy member: ScrEmitter
-        // carries its vtable word even with no subclass in the program.
-        if (c.name === RUNTIME_EMITTER_CLASS)
-            hierarchy.add(c.name);
-    }
+    const hierarchy = classValidation.hierarchy;
+    const virtualCallInfo = (className, method) => {
+        let methods = classValidation.virtualCalls.get(className);
+        const cached = methods?.get(method);
+        if (cached)
+            return cached;
+        if (!methods)
+            classValidation.virtualCalls.set(className, (methods = new Map()));
+        let declared = false;
+        let implementation;
+        for (let c = classes.get(className); c; c = c.base !== undefined ? classes.get(c.base) : undefined) {
+            if (c.methods?.includes(method)) {
+                declared = true;
+                if (!c.abstractMethods?.includes(method)) {
+                    implementation = functions.get(`%${c.name}.${method}`);
+                    break;
+                }
+            }
+        }
+        let hasOverride = false;
+        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))
+                    continue;
+                hasOverride = true;
+                implementation ??= functions.get(`%${c.name}.${method}`);
+                if (implementation)
+                    break;
+            }
+        }
+        const result = { declared, hasOverride, implementation };
+        methods.set(method, result);
+        return result;
+    };
     // Unit kinds live only inside unions: a bare-unit local, param, or
     // return type is frontend breakage (mapType never produces them).
     for (const l of fn.locals) {
@@ -2636,15 +2736,15 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                 // dyn field with fieldDyn set (validated numeric read-modify-write).
                 checkExpr(e.obj);
                 const cls = classes.get(e.className);
-                const field = cls?.fields.find((f) => f.name === e.field);
+                const fieldType = classValidation.fields.get(e.className)?.get(e.field);
                 if (!cls)
                     err(`fieldIncDec on undeclared class "${e.className}"`, e.loc);
-                else if (!field)
+                else if (!fieldType)
                     err(`class ${e.className} has no field "${e.field}"`, e.loc);
                 else {
                     expectType(e.obj, { kind: "object", className: e.className }, "fieldIncDec receiver");
-                    if (e.fieldDyn ? field.type.kind !== "dyn" : field.type.kind !== "f64") {
-                        err(`fieldIncDec ${e.className}.${e.field} field/flag mismatch (${field.type.kind})`, e.loc);
+                    if (e.fieldDyn ? fieldType.kind !== "dyn" : fieldType.kind !== "f64") {
+                        err(`fieldIncDec ${e.className}.${e.field} field/flag mismatch (${fieldType.kind})`, e.loc);
                     }
                 }
                 if (e.type.kind !== "f64")
@@ -3668,14 +3768,14 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
             case "fieldGet": {
                 checkExpr(e.obj);
                 const cls = classes.get(e.className);
-                const field = cls?.fields.find((f) => f.name === e.field);
+                const fieldType = classValidation.fields.get(e.className)?.get(e.field);
                 if (!cls)
                     err(`fieldGet on undeclared class "${e.className}"`, e.loc);
-                else if (!field)
+                else if (!fieldType)
                     err(`class ${e.className} has no field "${e.field}"`, e.loc);
                 else {
                     expectType(e.obj, { kind: "object", className: e.className }, "fieldGet receiver");
-                    if (!typeEquals(e.type, field.type)) {
+                    if (!typeEquals(e.type, fieldType)) {
                         err(`fieldGet ${e.className}.${e.field} type mismatch`, e.loc);
                     }
                 }
@@ -3849,30 +3949,15 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                 // is then well-formed against any concrete override below — the
                 // frontend's override-exactness rule makes every implementation
                 // ABI-identical, so any one of them carries the slot's signature.
-                let declared = false;
-                let impl;
-                for (let c = classes.get(e.className); c; c = c.base !== undefined ? classes.get(c.base) : undefined) {
-                    if (c.methods?.includes(e.method)) {
-                        declared = true;
-                        if (!c.abstractMethods?.includes(e.method)) {
-                            impl = functions.get(`%${c.name}.${e.method}`);
-                            break;
-                        }
-                    }
-                }
-                if (!declared) {
+                const info = virtualCallInfo(e.className, e.method);
+                if (!info.declared) {
                     err(`virtualCall ${e.className}.${e.method}: no declaration on the base chain`, e.loc);
                     break;
                 }
-                const concreteBelow = [...classes.values()].filter((c) => c.methods?.includes(e.method) &&
-                    !c.abstractMethods?.includes(e.method) &&
-                    isStrictSubclass(c.name, e.className));
-                if (concreteBelow.length === 0) {
+                if (!info.hasOverride) {
                     err(`virtualCall ${e.className}.${e.method}: no concrete override below the static class`, e.loc);
                 }
-                impl ??= concreteBelow
-                    .map((c) => functions.get(`%${c.name}.${e.method}`))
-                    .find((f) => f !== undefined);
+                const impl = info.implementation;
                 if (!impl) {
                     err(`virtualCall ${e.className}.${e.method}: no implementation function exists`, e.loc);
                     break;
@@ -3908,7 +3993,7 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                     err(`recordLit of undeclared shape "${e.type.shapeId}"`, e.loc);
                     break;
                 }
-                const want = new Map(shape.fields.map((f) => [f.name, f.type]));
+                const want = recordValidation.get(shape.id).initializationFields;
                 const seen = new Set();
                 for (const f of e.fields) {
                     checkExpr(f.value);
@@ -3964,11 +4049,11 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                     err(`recordClone of undeclared shape "${e.type.shapeId}"`, e.loc);
                     break;
                 }
-                if (shape.tuple || shape.indexValue || shapeHasAccessorSlots(shape)) {
+                if (shape.tuple || shape.indexValue || recordValidation.get(shape.id).hasAccessorSlots) {
                     err(`recordClone requires a plain declared-field shape, got ${shape.id}`, e.loc);
                 }
                 expectType(e.source, e.type, "recordClone source");
-                const want = new Map(shape.fields.map((f) => [f.name, f.type]));
+                const want = recordValidation.get(shape.id).initializationFields;
                 const seen = new Set();
                 for (const f of e.overrides) {
                     checkExpr(f.value);
@@ -3986,14 +4071,14 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
             case "recordGet": {
                 checkExpr(e.obj);
                 const shape = records.get(e.shapeId);
-                const field = shape?.fields.find((f) => f.name === e.field);
+                const field = recordValidation.get(e.shapeId)?.fields.get(e.field);
                 if (!shape)
                     err(`recordGet on undeclared shape "${e.shapeId}"`, e.loc);
                 else if (!field)
                     err(`shape ${e.shapeId} has no field "${e.field}"`, e.loc);
                 else {
                     expectType(e.obj, { kind: "record", shapeId: e.shapeId }, "recordGet receiver");
-                    if (!typeEquals(e.type, field.type)) {
+                    if (!typeEquals(e.type, field)) {
                         err(`recordGet ${e.shapeId}.${e.field} type mismatch`, e.loc);
                     }
                 }
@@ -4365,9 +4450,9 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                 }
                 def.arms.forEach((arm, i) => {
                     const fieldType = arm.kind === "record"
-                        ? records.get(arm.shapeId)?.fields.find((f) => f.name === e.field)?.type
+                        ? recordValidation.get(arm.shapeId)?.fields.get(e.field)
                         : arm.kind === "object"
-                            ? classes.get(arm.className)?.fields.find((f) => f.name === e.field)?.type
+                            ? classValidation.fields.get(arm.className)?.get(e.field)
                             : undefined;
                     if (!fieldType) {
                         err(`unionDisc: arm ${i} of ${e.unionId} has no field "${e.field}"`, e.loc);
@@ -4430,7 +4515,7 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                         return;
                     }
                     const literal = e.key.kind === "strLit" ? e.key.value : null;
-                    const declared = literal !== null ? shape.fields.find((f) => f.name === literal)?.type : undefined;
+                    const declared = literal !== null ? recordValidation.get(shape.id)?.fields.get(literal) : undefined;
                     if (declared) {
                         if (!surfaces(declared)) {
                             err(`unionKeyGet: arm ${i} field "${literal}" of type ${declared.kind} cannot surface as the result`, e.loc);
@@ -4651,11 +4736,11 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
             const countName = e.fn === "fileHandle.read" || e.fn === "fileHandle.readv" ? "bytesRead" : "bytesWritten";
             const payloadName = e.fn === "fileHandle.readv" || e.fn === "fileHandle.writev" ? "buffers" : "buffer";
             const payload = e.args[1]?.type;
-            const count = shape?.fields.find((f) => f.name === countName);
-            const buffer = shape?.fields.find((f) => f.name === payloadName);
+            const count = shape ? recordValidation.get(shape.id)?.fields.get(countName) : undefined;
+            const buffer = shape ? recordValidation.get(shape.id)?.fields.get(payloadName) : undefined;
             const ok = shape !== undefined && !shape.tuple && shape.indexValue === undefined && shape.fields.length === 2 &&
-                count?.type.kind === "f64" && payload !== undefined && buffer !== undefined &&
-                typeEquals(buffer.type, payload);
+                count?.kind === "f64" && payload !== undefined && buffer !== undefined &&
+                typeEquals(buffer, payload);
             if (!ok) {
                 err(`libCall ${e.fn} must return a promise of { ${countName}: number, ${payloadName} }`, e.loc);
             }
@@ -5948,17 +6033,17 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                     break;
                 }
                 const rec = records.get(resultT.shapeId);
-                const doneF = rec?.fields.find((f) => f.name === "done");
-                const valueF = rec?.fields.find((f) => f.name === "value");
-                if (!rec || rec.fields.length !== 2 || doneF?.type.kind !== "bool" || valueF === undefined) {
+                const doneF = rec ? recordValidation.get(rec.id)?.fields.get("done") : undefined;
+                const valueF = rec ? recordValidation.get(rec.id)?.fields.get("value") : undefined;
+                if (!rec || rec.fields.length !== 2 || doneF?.kind !== "bool" || valueF === undefined) {
                     err(`genResume result record ${resultT.shapeId} is not { done: bool, value: V }`, e.loc);
                     break;
                 }
-                if (valueF.type.kind === "dyn")
+                if (valueF.kind === "dyn")
                     break;
-                const vdef = valueF.type.kind === "union" ? unions.get(valueF.type.unionId) : undefined;
+                const vdef = valueF.kind === "union" ? unions.get(valueF.unionId) : undefined;
                 if (!vdef || !vdef.arms.some((a) => a.kind === "undefinedT")) {
-                    err(`genResume value slot ${typeKey(valueF.type)} is neither dyn nor an undefined-armed union`, e.loc);
+                    err(`genResume value slot ${typeKey(valueF)} is neither dyn nor an undefined-armed union`, e.loc);
                 }
                 break;
             }
@@ -6042,10 +6127,10 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                     break;
                 }
                 const shape = records.get(e.type.shapeId);
-                const fields = new Map(shape?.fields.map((f) => [f.name, f.type]) ?? []);
-                const prom = fields.get("promise");
-                const resolve = fields.get("resolve");
-                const reject = fields.get("reject");
+                const fields = recordValidation.get(e.type.shapeId)?.initializationFields;
+                const prom = fields?.get("promise");
+                const resolve = fields?.get("resolve");
+                const reject = fields?.get("reject");
                 if (!shape || shape.fields.length !== 3 || !prom || !resolve || !reject) {
                     err("promiseWithResolvers record must be { promise, resolve, reject }", e.loc);
                     break;
@@ -6357,14 +6442,14 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                 checkExpr(s.obj);
                 checkExpr(s.value);
                 const cls = classes.get(s.className);
-                const field = cls?.fields.find((f) => f.name === s.field);
+                const fieldType = classValidation.fields.get(s.className)?.get(s.field);
                 if (!cls)
                     err(`fieldSet on undeclared class "${s.className}"`, s.loc);
-                else if (!field)
+                else if (!fieldType)
                     err(`class ${s.className} has no field "${s.field}"`, s.loc);
                 else {
                     expectType(s.obj, { kind: "object", className: s.className }, "fieldSet receiver");
-                    expectType(s.value, field.type, `fieldSet ${s.className}.${s.field}`);
+                    expectType(s.value, fieldType, `fieldSet ${s.className}.${s.field}`);
                 }
                 break;
             }
@@ -6372,14 +6457,14 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                 checkExpr(s.obj);
                 checkExpr(s.value);
                 const shape = records.get(s.shapeId);
-                const field = shape?.fields.find((f) => f.name === s.field);
+                const field = recordValidation.get(s.shapeId)?.fields.get(s.field);
                 if (!shape)
                     err(`recordSet on undeclared shape "${s.shapeId}"`, s.loc);
                 else if (!field)
                     err(`shape ${s.shapeId} has no field "${s.field}"`, s.loc);
                 else {
                     expectType(s.obj, { kind: "record", shapeId: s.shapeId }, "recordSet receiver");
-                    expectType(s.value, field.type, `recordSet ${s.shapeId}.${s.field}`);
+                    expectType(s.value, field, `recordSet ${s.shapeId}.${s.field}`);
                 }
                 break;
             }