kopscript 0.1.0

package/dist/checker.js

@@ -0,0 +1,1334 @@
+import * as T from "./types.js";
+export function emptyModuleExports() {
+    return { namedTypes: new Map(), classes: new Map(), interfaces: new Map(), enums: new Map(), functions: new Map(), externValues: new Map() };
+}
+const STRING_METHODS = {
+    Contains: { params: [T.STRING], returnType: T.BOOL, visibility: "public", isVirtual: false, isOverride: false },
+    StartsWith: { params: [T.STRING], returnType: T.BOOL, visibility: "public", isVirtual: false, isOverride: false },
+    EndsWith: { params: [T.STRING], returnType: T.BOOL, visibility: "public", isVirtual: false, isOverride: false },
+    Replace: { params: [T.STRING, T.STRING], returnType: T.STRING, visibility: "public", isVirtual: false, isOverride: false },
+    Split: { params: [T.STRING], returnType: T.arrayOf(T.STRING), visibility: "public", isVirtual: false, isOverride: false },
+    Trim: { params: [], returnType: T.STRING, visibility: "public", isVirtual: false, isOverride: false },
+    ToUpper: { params: [], returnType: T.STRING, visibility: "public", isVirtual: false, isOverride: false },
+    ToLower: { params: [], returnType: T.STRING, visibility: "public", isVirtual: false, isOverride: false },
+};
+class Scope {
+    constructor(parent = null) {
+        this.parent = parent;
+        this.vars = new Map();
+    }
+    declare(name, type, isConst) {
+        this.vars.set(name, { type, isConst });
+    }
+    resolve(name) {
+        return this.vars.get(name) ?? this.parent?.resolve(name) ?? null;
+    }
+    child() {
+        return new Scope(this);
+    }
+}
+export class Checker {
+    constructor(program, diagnostics, imports = emptyModuleExports()) {
+        this.program = program;
+        this.diagnostics = diagnostics;
+        this.imports = imports;
+        this.classes = new Map();
+        this.interfaces = new Map();
+        this.enums = new Map();
+        this.functions = new Map();
+        this.externValues = new Map();
+        this.namedTypes = new Map();
+        this.importedNames = new Set();
+    }
+    check() {
+        for (const [name, kind] of this.imports.namedTypes) {
+            this.namedTypes.set(name, kind);
+            this.importedNames.add(name);
+        }
+        for (const [name, info] of this.imports.classes)
+            this.classes.set(name, info);
+        for (const [name, info] of this.imports.interfaces)
+            this.interfaces.set(name, info);
+        for (const [name, info] of this.imports.enums)
+            this.enums.set(name, info);
+        for (const [name, info] of this.imports.functions) {
+            this.functions.set(name, info);
+            this.importedNames.add(name);
+        }
+        for (const [name, type] of this.imports.externValues) {
+            this.externValues.set(name, type);
+            this.importedNames.add(name);
+        }
+        const classDecls = this.program.statements.filter((s) => s.kind === "ClassDecl");
+        const interfaceDecls = this.program.statements.filter((s) => s.kind === "InterfaceDecl");
+        const enumDecls = this.program.statements.filter((s) => s.kind === "EnumDecl");
+        const functionDecls = this.program.statements.filter((s) => s.kind === "FunctionDecl");
+        const externFunctionDecls = this.program.statements.filter((s) => s.kind === "ExternFunctionDecl");
+        const externClassDecls = this.program.statements.filter((s) => s.kind === "ExternClassDecl");
+        const externValueDecls = this.program.statements.filter((s) => s.kind === "ExternValueDecl");
+        this.checkNoDuplicateTopLevelNames(classDecls, interfaceDecls, enumDecls, functionDecls, externFunctionDecls, externClassDecls, externValueDecls);
+        for (const c of classDecls)
+            this.namedTypes.set(c.name, "class");
+        for (const i of interfaceDecls)
+            this.namedTypes.set(i.name, "interface");
+        for (const e of enumDecls)
+            this.namedTypes.set(e.name, "enum");
+        for (const c of externClassDecls)
+            this.namedTypes.set(c.name, "class");
+        for (const e of enumDecls)
+            this.registerEnum(e);
+        for (const i of interfaceDecls)
+            this.registerInterface(i);
+        for (const i of interfaceDecls)
+            this.checkInterfaceHierarchy(i);
+        for (const i of interfaceDecls)
+            this.checkExportedInterfaceSurface(i);
+        // Extern classes register before regular ones so a class extending an
+        // extern class (e.g. `class Counter : Component` where Component comes
+        // from another package) has its base already in `this.classes` by the
+        // time hierarchy/export/virtual-override checks below need to resolve it.
+        for (const c of externClassDecls)
+            this.registerExternClass(c);
+        for (const c of classDecls)
+            this.registerClass(c);
+        for (const c of classDecls)
+            this.checkClassHierarchy(c);
+        for (const c of classDecls)
+            this.checkExportedClassSurface(c);
+        for (const c of classDecls)
+            this.checkVirtualOverride(c);
+        for (const c of classDecls)
+            this.checkInterfaceConformance(c);
+        for (const f of functionDecls)
+            this.registerFunction(f);
+        for (const f of externFunctionDecls)
+            this.registerExternFunction(f);
+        for (const v of externValueDecls)
+            this.registerExternValue(v);
+        const globalScope = new Scope();
+        for (const stmt of this.program.statements) {
+            if (stmt.kind === "ClassDecl" ||
+                stmt.kind === "InterfaceDecl" ||
+                stmt.kind === "EnumDecl" ||
+                stmt.kind === "ExternFunctionDecl" ||
+                stmt.kind === "ExternClassDecl" ||
+                stmt.kind === "ExternValueDecl") {
+                continue;
+            }
+            this.checkTopLevelStatement(stmt, globalScope);
+        }
+        for (const c of classDecls)
+            this.checkClassBody(c);
+    }
+    registerExternFunction(decl) {
+        this.functions.set(decl.name, {
+            params: decl.params.map((p) => this.resolveType(p.type, decl.line, decl.col)),
+            returnType: this.resolveType(decl.returnType, decl.line, decl.col),
+        });
+    }
+    registerExternClass(decl) {
+        const fields = new Map();
+        const staticFields = new Map();
+        for (const p of decl.properties) {
+            const info = { type: this.resolveType(p.type, decl.line, decl.col), visibility: "public", hasSetter: p.hasSetter };
+            (p.isStatic ? staticFields : fields).set(p.name, info);
+        }
+        const methods = new Map();
+        const staticMethods = new Map();
+        for (const m of decl.methods) {
+            const info = {
+                params: m.params.map((p) => this.resolveType(p.type, decl.line, decl.col)),
+                returnType: this.resolveType(m.returnType, decl.line, decl.col),
+                visibility: "public",
+                isVirtual: m.isVirtual,
+                isOverride: false,
+            };
+            (m.isStatic ? staticMethods : methods).set(m.name, info);
+        }
+        const ownCtorParams = decl.hasConstructor ? decl.ctorParams.map((p) => this.resolveType(p.type, decl.line, decl.col)) : null;
+        this.classes.set(decl.name, {
+            name: decl.name,
+            superclass: null,
+            interfaces: [],
+            fields,
+            methods,
+            staticFields,
+            staticMethods,
+            ownCtorParams,
+        });
+    }
+    registerExternValue(decl) {
+        this.externValues.set(decl.name, this.resolveType(decl.type, decl.line, decl.col));
+    }
+    // The subset of this module's registered declarations visible to a file
+    // that `using`s it. Call only after check() has run.
+    getExports() {
+        const exports = emptyModuleExports();
+        for (const stmt of this.program.statements) {
+            if (stmt.kind === "ClassDecl" && stmt.isExported) {
+                exports.namedTypes.set(stmt.name, "class");
+                exports.classes.set(stmt.name, this.classes.get(stmt.name));
+            }
+            else if (stmt.kind === "InterfaceDecl" && stmt.isExported) {
+                exports.namedTypes.set(stmt.name, "interface");
+                exports.interfaces.set(stmt.name, this.interfaces.get(stmt.name));
+            }
+            else if (stmt.kind === "EnumDecl" && stmt.isExported) {
+                exports.namedTypes.set(stmt.name, "enum");
+                exports.enums.set(stmt.name, this.enums.get(stmt.name));
+            }
+            else if (stmt.kind === "FunctionDecl" && stmt.isExported) {
+                exports.functions.set(stmt.name, this.functions.get(stmt.name));
+            }
+            else if (stmt.kind === "ExternFunctionDecl" && stmt.isExported) {
+                exports.functions.set(stmt.name, this.functions.get(stmt.name));
+            }
+            else if (stmt.kind === "ExternClassDecl" && stmt.isExported) {
+                exports.namedTypes.set(stmt.name, "class");
+                exports.classes.set(stmt.name, this.classes.get(stmt.name));
+            }
+            else if (stmt.kind === "ExternValueDecl" && stmt.isExported) {
+                exports.externValues.set(stmt.name, this.externValues.get(stmt.name));
+            }
+        }
+        return exports;
+    }
+    checkNoDuplicateTopLevelNames(classDecls, interfaceDecls, enumDecls, functionDecls, externFunctionDecls, externClassDecls, externValueDecls) {
+        const seen = new Map();
+        const declare = (name, line, col) => {
+            if (this.importedNames.has(name)) {
+                this.diagnostics.error(`Declaration '${name}' conflicts with a name brought in by 'using'`, line, col);
+            }
+            else if (seen.has(name)) {
+                this.diagnostics.error(`Duplicate top-level declaration '${name}'`, line, col);
+            }
+            seen.set(name, true);
+        };
+        for (const c of classDecls)
+            declare(c.name, c.line, c.col);
+        for (const i of interfaceDecls)
+            declare(i.name, i.line, i.col);
+        for (const e of enumDecls)
+            declare(e.name, e.line, e.col);
+        for (const f of functionDecls)
+            declare(f.name, f.line, f.col);
+        for (const f of externFunctionDecls)
+            declare(f.name, f.line, f.col);
+        for (const c of externClassDecls)
+            declare(c.name, c.line, c.col);
+        for (const v of externValueDecls)
+            declare(v.name, v.line, v.col);
+    }
+    // An exported class's superclass and directly-implemented interfaces must
+    // also be exported — otherwise a file that imports this class would have
+    // no way to even name its base type, and (more importantly) the exported
+    // slice handed to importers wouldn't be self-contained for chain-walking.
+    checkExportedClassSurface(decl) {
+        if (!decl.isExported)
+            return;
+        const info = this.classes.get(decl.name);
+        if (info.superclass && !this.isExportedName(info.superclass)) {
+            this.diagnostics.error(`Exported class '${decl.name}' has a base class '${info.superclass}' that isn't exported`, decl.line, decl.col);
+        }
+        for (const ifaceName of info.interfaces) {
+            if (!this.isExportedName(ifaceName)) {
+                this.diagnostics.error(`Exported class '${decl.name}' implements interface '${ifaceName}', which isn't exported`, decl.line, decl.col);
+            }
+        }
+    }
+    checkExportedInterfaceSurface(decl) {
+        if (!decl.isExported)
+            return;
+        const info = this.interfaces.get(decl.name);
+        if (!info)
+            return;
+        for (const baseName of info.bases) {
+            if (!this.isExportedName(baseName)) {
+                this.diagnostics.error(`Exported interface '${decl.name}' extends interface '${baseName}', which isn't exported`, decl.line, decl.col);
+            }
+        }
+    }
+    // Whether `name` is visible to another file that `using`s this one: either
+    // it was itself imported (already public by construction) or it's a local
+    // top-level declaration explicitly marked `public` (or left unmarked).
+    isExportedName(name) {
+        if (this.importedNames.has(name))
+            return true;
+        const decl = this.program.statements.find((s) => (s.kind === "ClassDecl" || s.kind === "InterfaceDecl" || s.kind === "EnumDecl" || s.kind === "ExternClassDecl") && s.name === name);
+        return decl?.isExported ?? false;
+    }
+    // ---------- registration ----------
+    resolveType(node, line, col) {
+        const resolved = T.resolveTypeNode(node, this.namedTypes);
+        if (!resolved) {
+            const name = node.kind === "NamedType" ? node.name : "[]";
+            this.diagnostics.error(`Unknown type '${name}'`, line, col);
+            return T.UNKNOWN;
+        }
+        return resolved;
+    }
+    registerEnum(decl) {
+        const members = new Map();
+        decl.members.forEach((name, index) => {
+            if (members.has(name)) {
+                this.diagnostics.error(`Duplicate enum member '${name}'`, decl.line, decl.col);
+                return;
+            }
+            members.set(name, index);
+        });
+        this.enums.set(decl.name, { name: decl.name, members });
+    }
+    registerInterface(decl) {
+        const methods = decl.methods.map((m) => ({
+            name: m.name,
+            params: m.params.map((p) => this.resolveType(p.type, m.line, m.col)),
+            returnType: this.resolveType(m.returnType, m.line, m.col),
+        }));
+        const bases = [];
+        for (const baseName of decl.baseList) {
+            if (this.namedTypes.get(baseName) !== "interface") {
+                this.diagnostics.error(`Interface '${decl.name}' can only extend other interfaces (unknown interface '${baseName}')`, decl.line, decl.col);
+                continue;
+            }
+            bases.push(baseName);
+        }
+        this.interfaces.set(decl.name, { name: decl.name, bases, methods });
+    }
+    checkInterfaceHierarchy(decl) {
+        const info = this.interfaces.get(decl.name);
+        if (!info)
+            return;
+        const seen = new Set();
+        const stack = [...info.bases];
+        while (stack.length > 0) {
+            const current = stack.pop();
+            if (current === decl.name) {
+                this.diagnostics.error(`Circular interface inheritance detected involving '${decl.name}'`, decl.line, decl.col);
+                return;
+            }
+            if (seen.has(current))
+                continue;
+            seen.add(current);
+            const currentInfo = this.interfaces.get(current);
+            if (currentInfo)
+                stack.push(...currentInfo.bases);
+        }
+    }
+    // All methods required to satisfy an interface: its own plus every
+    // transitively-inherited parent interface's (cycle-safe).
+    collectInterfaceMethods(interfaceName, seen = new Set()) {
+        if (seen.has(interfaceName))
+            return [];
+        seen.add(interfaceName);
+        const info = this.interfaces.get(interfaceName);
+        if (!info)
+            return [];
+        const inherited = info.bases.flatMap((b) => this.collectInterfaceMethods(b, seen));
+        return [...inherited, ...info.methods];
+    }
+    interfaceExtends(sub, sup) {
+        if (sub === sup)
+            return true;
+        const info = this.interfaces.get(sub);
+        if (!info)
+            return false;
+        return info.bases.some((b) => this.interfaceExtends(b, sup));
+    }
+    registerClass(decl) {
+        const fields = new Map();
+        const staticFields = new Map();
+        for (const f of decl.fields) {
+            const info = { type: this.resolveType(f.type, f.line, f.col), visibility: f.visibility, hasSetter: true };
+            (f.isStatic ? staticFields : fields).set(f.name, info);
+        }
+        for (const p of decl.properties) {
+            fields.set(p.name, { type: this.resolveType(p.type, p.line, p.col), visibility: p.visibility, hasSetter: p.hasSetter });
+        }
+        const methods = new Map();
+        const staticMethods = new Map();
+        for (const m of decl.methods) {
+            const info = {
+                params: m.params.map((p) => this.resolveType(p.type, m.line, m.col)),
+                returnType: this.resolveType(m.returnType, m.line, m.col),
+                visibility: m.visibility,
+                isVirtual: m.isVirtual,
+                isOverride: m.isOverride,
+            };
+            (m.isStatic ? staticMethods : methods).set(m.name, info);
+        }
+        const ownCtorParams = decl.constructor
+            ? decl.constructor.params.map((p) => this.resolveType(p.type, decl.constructor.line, decl.constructor.col))
+            : null;
+        let superclass = null;
+        const interfaces = [];
+        for (const baseName of decl.baseList) {
+            const kind = this.namedTypes.get(baseName);
+            if (kind === "class") {
+                if (superclass !== null) {
+                    this.diagnostics.error(`Class '${decl.name}' cannot extend multiple classes ('${superclass}' and '${baseName}')`, decl.line, decl.col);
+                }
+                else {
+                    superclass = baseName;
+                }
+            }
+            else if (kind === "interface") {
+                interfaces.push(baseName);
+            }
+            else {
+                this.diagnostics.error(`Unknown base class or interface '${baseName}'`, decl.line, decl.col);
+            }
+        }
+        this.classes.set(decl.name, {
+            name: decl.name,
+            superclass,
+            interfaces,
+            fields,
+            methods,
+            staticFields,
+            staticMethods,
+            ownCtorParams,
+        });
+    }
+    checkClassHierarchy(decl) {
+        const info = this.classes.get(decl.name);
+        this.checkBaseCall(decl, info);
+        // Detect cycles.
+        const seen = new Set([decl.name]);
+        let current = info.superclass;
+        while (current) {
+            if (seen.has(current)) {
+                this.diagnostics.error(`Circular inheritance detected involving '${decl.name}'`, decl.line, decl.col);
+                return;
+            }
+            seen.add(current);
+            current = this.classes.get(current)?.superclass ?? null;
+        }
+    }
+    // Structural validity of `: base(...)` — whether it's present/absent
+    // appropriately for whether the class has a superclass. Argument count
+    // and types are checked later, in checkClassBody, once a scope exists.
+    checkBaseCall(decl, info) {
+        if (!decl.constructor)
+            return;
+        if (info.superclass) {
+            if (!decl.constructor.baseArgs) {
+                this.diagnostics.error(`Class '${decl.name}' extends '${info.superclass}' and must call the base constructor via ': base(...)'`, decl.constructor.line, decl.constructor.col);
+            }
+        }
+        else if (decl.constructor.baseArgs) {
+            this.diagnostics.error(`Class '${decl.name}' has no base class; ': base(...)' is not valid here`, decl.constructor.line, decl.constructor.col);
+        }
+    }
+    // Walks up the inheritance chain to find the nearest ancestor that already
+    // declares a method with this name (used for virtual/override validation).
+    findNearestMethodInChain(className, methodName) {
+        let current = this.classes.get(className)?.superclass ?? null;
+        while (current) {
+            const info = this.classes.get(current);
+            const m = info?.methods.get(methodName);
+            if (m)
+                return { info: m, owner: current };
+            current = info?.superclass ?? null;
+        }
+        return null;
+    }
+    checkVirtualOverride(decl) {
+        const classInfo = this.classes.get(decl.name);
+        for (const method of decl.methods) {
+            if (method.isStatic)
+                continue; // static methods don't participate in virtual dispatch
+            const methodInfo = classInfo.methods.get(method.name);
+            if (methodInfo.isVirtual && methodInfo.isOverride) {
+                this.diagnostics.error(`Method '${method.name}' cannot be both 'virtual' and 'override'`, method.line, method.col);
+            }
+            const ancestor = this.findNearestMethodInChain(decl.name, method.name);
+            if (ancestor) {
+                const overridable = ancestor.info.isVirtual || ancestor.info.isOverride;
+                if (!methodInfo.isOverride) {
+                    this.diagnostics.error(`Method '${method.name}' hides inherited member '${ancestor.owner}.${method.name}'; add 'override' (and mark the base member 'virtual')`, method.line, method.col);
+                }
+                else if (!overridable) {
+                    this.diagnostics.error(`Cannot override non-virtual method '${ancestor.owner}.${method.name}'; mark it 'virtual' in '${ancestor.owner}'`, method.line, method.col);
+                }
+                else {
+                    const paramsMatch = methodInfo.params.length === ancestor.info.params.length &&
+                        methodInfo.params.every((p, i) => T.typesEqual(p, ancestor.info.params[i]));
+                    const returnMatches = T.typesEqual(methodInfo.returnType, ancestor.info.returnType);
+                    if (!paramsMatch || !returnMatches) {
+                        this.diagnostics.error(`Method '${method.name}' does not match the signature of overridden method '${ancestor.owner}.${method.name}'`, method.line, method.col);
+                    }
+                }
+            }
+            else if (methodInfo.isOverride) {
+                this.diagnostics.error(`Method '${method.name}' marked 'override' but no matching method was found in a base class`, method.line, method.col);
+            }
+        }
+    }
+    checkInterfaceConformance(decl) {
+        const classInfo = this.classes.get(decl.name);
+        for (const ifaceName of classInfo.interfaces) {
+            if (!this.interfaces.has(ifaceName))
+                continue; // already reported as an unknown base type
+            for (const sig of this.collectInterfaceMethods(ifaceName)) {
+                const found = this.lookupMethod(decl.name, sig.name);
+                if (!found) {
+                    this.diagnostics.error(`Class '${decl.name}' does not implement method '${sig.name}' required by interface '${ifaceName}'`, decl.line, decl.col);
+                    continue;
+                }
+                const paramsMatch = found.info.params.length === sig.params.length && found.info.params.every((p, i) => T.typesEqual(p, sig.params[i]));
+                if (!paramsMatch || !T.typesEqual(found.info.returnType, sig.returnType)) {
+                    this.diagnostics.error(`Class '${decl.name}' member '${sig.name}' does not match the signature required by interface '${ifaceName}'`, decl.line, decl.col);
+                }
+            }
+        }
+    }
+    registerFunction(decl) {
+        this.functions.set(decl.name, {
+            params: decl.params.map((p) => this.resolveType(p.type, decl.line, decl.col)),
+            returnType: this.resolveType(decl.returnType, decl.line, decl.col),
+        });
+    }
+    isSubclass(sub, sup) {
+        let current = sub;
+        while (current) {
+            if (current === sup)
+                return true;
+            current = this.classes.get(current)?.superclass ?? null;
+        }
+        return false;
+    }
+    classImplementsInterface(className, interfaceName) {
+        let current = className;
+        while (current) {
+            const info = this.classes.get(current);
+            if (!info)
+                return false;
+            if (info.interfaces.some((i) => this.interfaceExtends(i, interfaceName)))
+                return true;
+            current = info.superclass;
+        }
+        return false;
+    }
+    lookupField(className, fieldName) {
+        let current = className;
+        while (current) {
+            const info = this.classes.get(current);
+            if (!info)
+                return null;
+            const field = info.fields.get(fieldName);
+            if (field)
+                return { info: field, owner: current };
+            current = info.superclass;
+        }
+        return null;
+    }
+    lookupMethod(className, methodName) {
+        let current = className;
+        while (current) {
+            const info = this.classes.get(current);
+            if (!info)
+                return null;
+            const method = info.methods.get(methodName);
+            if (method)
+                return { info: method, owner: current };
+            current = info.superclass;
+        }
+        return null;
+    }
+    lookupStaticField(className, fieldName) {
+        let current = className;
+        while (current) {
+            const info = this.classes.get(current);
+            if (!info)
+                return null;
+            const field = info.staticFields.get(fieldName);
+            if (field)
+                return { info: field, owner: current };
+            current = info.superclass;
+        }
+        return null;
+    }
+    lookupStaticMethod(className, methodName) {
+        let current = className;
+        while (current) {
+            const info = this.classes.get(current);
+            if (!info)
+                return null;
+            const method = info.staticMethods.get(methodName);
+            if (method)
+                return { info: method, owner: current };
+            current = info.superclass;
+        }
+        return null;
+    }
+    // Enforces C#-style private/protected/public access from the current class context.
+    checkAccessibility(visibility, owner, ctx, memberName, line, col) {
+        if (visibility === "public")
+            return;
+        if (visibility === "private") {
+            if (ctx.currentClass?.name !== owner) {
+                this.diagnostics.error(`'${memberName}' is private and not accessible outside class '${owner}'`, line, col);
+            }
+            return;
+        }
+        // protected
+        if (!ctx.currentClass || !(ctx.currentClass.name === owner || this.isSubclass(ctx.currentClass.name, owner))) {
+            this.diagnostics.error(`'${memberName}' is protected and only accessible within '${owner}' or its subclasses`, line, col);
+        }
+    }
+    // Assignability: is a value of type `from` usable where type `to` is expected?
+    isAssignableType(from, to) {
+        if (from.kind === "unknown" || to.kind === "unknown")
+            return true;
+        if (to.kind === "interface") {
+            if (from.kind === "class")
+                return this.classImplementsInterface(from.name, to.name);
+            if (from.kind === "interface")
+                return this.interfaceExtends(from.name, to.name);
+            return false;
+        }
+        if (from.kind === "class" && to.kind === "class") {
+            return from.name === to.name || this.isSubclass(from.name, to.name);
+        }
+        if (from.kind === "array" && to.kind === "array") {
+            return this.isAssignableType(from.element, to.element);
+        }
+        return T.typesEqual(from, to);
+    }
+    // ---------- top-level ----------
+    // Validates that `isAsync` and the declared return type agree — `async`
+    // requires `task`/`task<T>`, and `task`/`task<T>` requires `async` (there's
+    // no way in v1 to construct a task value by hand) — and returns the type
+    // `return` statements inside the body should be checked against: the
+    // unwrapped result type for async, the declared type unchanged otherwise.
+    resolveBodyReturnType(declaredReturnType, isAsync, line, col) {
+        if (isAsync) {
+            if (declaredReturnType.kind !== "task") {
+                this.diagnostics.error(`'async' functions/methods must return 'task' or 'task<T>', got '${T.typeToString(declaredReturnType)}'`, line, col);
+                return T.UNKNOWN;
+            }
+            return declaredReturnType.resultType;
+        }
+        if (declaredReturnType.kind === "task") {
+            this.diagnostics.error(`A function/method returning 'task'/'task<T>' must be marked 'async'`, line, col);
+        }
+        return declaredReturnType;
+    }
+    checkTopLevelStatement(stmt, scope) {
+        if (stmt.kind === "FunctionDecl") {
+            this.checkFunctionBody(stmt, scope);
+            return;
+        }
+        // Top-level code allows `await`, matching real top-level await in an ES module.
+        this.checkStatement(stmt, scope, { returnType: T.VOID, currentClass: null, inConstructor: false, loopDepth: 0, isAsync: true });
+    }
+    checkFunctionBody(decl, parentScope) {
+        const info = this.functions.get(decl.name);
+        const scope = parentScope.child();
+        decl.params.forEach((p, i) => scope.declare(p.name, info.params[i], false));
+        const returnType = this.resolveBodyReturnType(info.returnType, decl.isAsync, decl.line, decl.col);
+        this.checkBlock(decl.body, scope, { returnType, currentClass: null, inConstructor: false, loopDepth: 0, isAsync: decl.isAsync });
+    }
+    checkClassBody(decl) {
+        const info = this.classes.get(decl.name);
+        if (decl.constructor) {
+            const paramScope = new Scope();
+            decl.constructor.params.forEach((p, i) => paramScope.declare(p.name, info.ownCtorParams[i], false));
+            // `base(...)` args are checked in a scope with the constructor's own
+            // params but no `this` — matching real base()/super() semantics,
+            // which must run before `this` becomes available.
+            if (decl.constructor.baseArgs && info.superclass) {
+                const baseCtorParams = this.lookupCtorParams(info.superclass);
+                const baseCtx = { returnType: T.VOID, currentClass: info, inConstructor: false, loopDepth: 0, isAsync: false };
+                if (decl.constructor.baseArgs.length !== baseCtorParams.length) {
+                    this.diagnostics.error(`Expected ${baseCtorParams.length} base constructor argument(s), got ${decl.constructor.baseArgs.length}`, decl.constructor.line, decl.constructor.col);
+                }
+                decl.constructor.baseArgs.forEach((arg, i) => {
+                    const expected = baseCtorParams[i] ?? T.UNKNOWN;
+                    const argType = this.checkExpressionExpecting(arg, expected, paramScope, baseCtx);
+                    if (!this.isAssignableType(argType, expected)) {
+                        this.diagnostics.error(`Base constructor argument ${i + 1} has type '${T.typeToString(argType)}', expected '${T.typeToString(expected)}'`, arg.line, arg.col);
+                    }
+                });
+            }
+            const scope = paramScope.child();
+            scope.declare("this", T.classType(decl.name), false);
+            this.checkBlock(decl.constructor.body, scope, { returnType: T.VOID, currentClass: info, inConstructor: true, loopDepth: 0, isAsync: false });
+        }
+        for (const method of decl.methods) {
+            const methodInfo = (method.isStatic ? info.staticMethods : info.methods).get(method.name);
+            const scope = new Scope();
+            if (!method.isStatic)
+                scope.declare("this", T.classType(decl.name), false);
+            method.params.forEach((p, i) => scope.declare(p.name, methodInfo.params[i], false));
+            const returnType = this.resolveBodyReturnType(methodInfo.returnType, method.isAsync, method.line, method.col);
+            this.checkBlock(method.body, scope, { returnType, currentClass: info, inConstructor: false, loopDepth: 0, isAsync: method.isAsync });
+        }
+        // Static field initializers run in a static context (no `this`).
+        for (const field of decl.fields) {
+            if (!field.isStatic || !field.initializer)
+                continue;
+            const declaredType = info.staticFields.get(field.name).type;
+            const initType = this.checkExpressionExpecting(field.initializer, declaredType, new Scope(), {
+                returnType: T.VOID,
+                currentClass: info,
+                inConstructor: false,
+                loopDepth: 0,
+                isAsync: false,
+            });
+            if (!this.isAssignableType(initType, declaredType)) {
+                this.diagnostics.error(`Cannot assign value of type '${T.typeToString(initType)}' to static field of type '${T.typeToString(declaredType)}'`, field.line, field.col);
+            }
+        }
+    }
+    // ---------- statements ----------
+    checkBlock(block, parentScope, ctx) {
+        const scope = parentScope.child();
+        for (const stmt of block.statements)
+            this.checkStatement(stmt, scope, ctx);
+    }
+    checkStatement(stmt, scope, ctx) {
+        switch (stmt.kind) {
+            case "VarDecl": {
+                const declaredType = this.resolveType(stmt.type, stmt.line, stmt.col);
+                const initType = this.checkExpressionExpecting(stmt.init, declaredType, scope, ctx);
+                if (!this.isAssignableType(initType, declaredType)) {
+                    this.diagnostics.error(`Cannot assign value of type '${T.typeToString(initType)}' to variable of type '${T.typeToString(declaredType)}'`, stmt.line, stmt.col);
+                }
+                scope.declare(stmt.name, declaredType, stmt.isConst);
+                return;
+            }
+            case "Block":
+                this.checkBlock(stmt, scope, ctx);
+                return;
+            case "IfStatement": {
+                const condType = this.checkExpression(stmt.condition, scope, ctx);
+                this.expectType(condType, T.BOOL, stmt.line, stmt.col, "if condition");
+                this.checkBlock(stmt.thenBranch, scope, ctx);
+                if (stmt.elseBranch) {
+                    if (stmt.elseBranch.kind === "IfStatement")
+                        this.checkStatement(stmt.elseBranch, scope, ctx);
+                    else
+                        this.checkBlock(stmt.elseBranch, scope, ctx);
+                }
+                return;
+            }
+            case "WhileStatement": {
+                const condType = this.checkExpression(stmt.condition, scope, ctx);
+                this.expectType(condType, T.BOOL, stmt.line, stmt.col, "while condition");
+                this.checkBlock(stmt.body, scope, { ...ctx, loopDepth: ctx.loopDepth + 1 });
+                return;
+            }
+            case "ForStatement": {
+                const forScope = scope.child();
+                if (stmt.init) {
+                    if (stmt.init.kind === "VarDecl")
+                        this.checkStatement(stmt.init, forScope, ctx);
+                    else
+                        this.checkExpression(stmt.init.expression, forScope, ctx);
+                }
+                if (stmt.condition) {
+                    const condType = this.checkExpression(stmt.condition, forScope, ctx);
+                    this.expectType(condType, T.BOOL, stmt.line, stmt.col, "for condition");
+                }
+                if (stmt.update)
+                    this.checkExpression(stmt.update, forScope, ctx);
+                this.checkBlock(stmt.body, forScope, { ...ctx, loopDepth: ctx.loopDepth + 1 });
+                return;
+            }
+            case "ForInStatement": {
+                const iterableType = this.checkExpression(stmt.iterable, scope, ctx);
+                const declaredVarType = this.resolveType(stmt.varType, stmt.line, stmt.col);
+                if (iterableType.kind === "array") {
+                    if (!this.isAssignableType(iterableType.element, declaredVarType)) {
+                        this.diagnostics.error(`Cannot use loop variable of type '${T.typeToString(declaredVarType)}' for array of '${T.typeToString(iterableType.element)}'`, stmt.line, stmt.col);
+                    }
+                }
+                else if (iterableType.kind !== "unknown") {
+                    this.diagnostics.error(`Cannot iterate over non-array type '${T.typeToString(iterableType)}'`, stmt.line, stmt.col);
+                }
+                const forScope = scope.child();
+                forScope.declare(stmt.varName, declaredVarType, false);
+                this.checkBlock(stmt.body, forScope, { ...ctx, loopDepth: ctx.loopDepth + 1 });
+                return;
+            }
+            case "ReturnStatement": {
+                const actual = stmt.value ? this.checkExpressionExpecting(stmt.value, ctx.returnType, scope, ctx) : T.VOID;
+                if (!this.isAssignableType(actual, ctx.returnType)) {
+                    this.diagnostics.error(`Return type '${T.typeToString(actual)}' does not match declared return type '${T.typeToString(ctx.returnType)}'`, stmt.line, stmt.col);
+                }
+                return;
+            }
+            case "BreakStatement":
+            case "ContinueStatement":
+                if (ctx.loopDepth === 0) {
+                    this.diagnostics.error(`'${stmt.kind === "BreakStatement" ? "break" : "continue"}' used outside of a loop`, stmt.line, stmt.col);
+                }
+                return;
+            case "ExpressionStatement":
+                this.checkExpression(stmt.expression, scope, ctx);
+                return;
+            case "TryStatement": {
+                this.checkBlock(stmt.tryBlock, scope, ctx);
+                if (stmt.catchBlock && stmt.catchParam) {
+                    const catchScope = scope.child();
+                    const paramType = this.resolveType(stmt.catchParam.type, stmt.line, stmt.col);
+                    catchScope.declare(stmt.catchParam.name, paramType, false);
+                    this.checkBlock(stmt.catchBlock, catchScope, ctx);
+                }
+                if (stmt.finallyBlock)
+                    this.checkBlock(stmt.finallyBlock, scope, ctx);
+                return;
+            }
+            case "ThrowStatement":
+                // No restriction on what can be thrown, matching JS's own looseness
+                // — KopScript has no base exception/error type to require conformance to.
+                this.checkExpression(stmt.expression, scope, ctx);
+                return;
+            case "FunctionDecl":
+                this.diagnostics.error(`Nested function declarations are not supported`, stmt.line, stmt.col);
+                return;
+            case "ClassDecl":
+                this.diagnostics.error(`Nested class declarations are not supported`, stmt.line, stmt.col);
+                return;
+            case "InterfaceDecl":
+                this.diagnostics.error(`Nested interface declarations are not supported`, stmt.line, stmt.col);
+                return;
+            case "EnumDecl":
+                this.diagnostics.error(`Nested enum declarations are not supported`, stmt.line, stmt.col);
+                return;
+            case "ExternFunctionDecl":
+            case "ExternClassDecl":
+            case "ExternValueDecl":
+                this.diagnostics.error(`'extern' declarations are only allowed at the top level of a file`, stmt.line, stmt.col);
+                return;
+        }
+    }
+    expectType(actual, expected, line, col, context) {
+        if (!T.typesEqual(actual, expected)) {
+            this.diagnostics.error(`Expected type '${T.typeToString(expected)}' for ${context}, got '${T.typeToString(actual)}'`, line, col);
+        }
+    }
+    // ---------- expressions ----------
+    checkExpression(expr, scope, ctx) {
+        switch (expr.kind) {
+            case "NumberLiteral":
+                return T.NUMBER;
+            case "StringLiteral":
+                return T.STRING;
+            case "BoolLiteral":
+                return T.BOOL;
+            case "InterpolatedStringLiteral":
+                for (const part of expr.parts) {
+                    if (part.kind === "Expr")
+                        this.checkExpression(part.expression, scope, ctx);
+                }
+                return T.STRING;
+            case "ArrayLiteral": {
+                if (expr.elements.length === 0)
+                    return T.arrayOf(T.UNKNOWN);
+                const elementTypes = expr.elements.map((e) => this.checkExpression(e, scope, ctx));
+                const first = elementTypes[0];
+                for (let i = 1; i < elementTypes.length; i++) {
+                    if (!T.typesEqual(elementTypes[i], first)) {
+                        this.diagnostics.error(`Array elements must all have the same type`, expr.line, expr.col);
+                        break;
+                    }
+                }
+                return T.arrayOf(first);
+            }
+            case "Identifier": {
+                const found = scope.resolve(expr.name);
+                if (found)
+                    return found.type;
+                const externValue = this.externValues.get(expr.name);
+                if (externValue)
+                    return externValue;
+                // A free function referenced by name as a value (e.g. passed as a
+                // callback) has a real function type — direct calls (`Foo(1)`)
+                // don't reach this path at all; checkCall resolves those itself.
+                const fnInfo = this.functions.get(expr.name);
+                if (fnInfo)
+                    return T.functionType(fnInfo.params, fnInfo.returnType);
+                this.diagnostics.error(`Undefined identifier '${expr.name}'`, expr.line, expr.col);
+                return T.UNKNOWN;
+            }
+            case "ThisExpr": {
+                const found = scope.resolve("this");
+                if (found)
+                    return found.type;
+                this.diagnostics.error(`'this' used outside of a class method`, expr.line, expr.col);
+                return T.UNKNOWN;
+            }
+            case "UnaryExpr": {
+                const operandType = this.checkExpression(expr.operand, scope, ctx);
+                if (expr.op === "-")
+                    this.expectType(operandType, T.NUMBER, expr.line, expr.col, "unary '-'");
+                if (expr.op === "!")
+                    this.expectType(operandType, T.BOOL, expr.line, expr.col, "unary '!'");
+                return operandType.kind === "unknown" ? T.UNKNOWN : expr.op === "-" ? T.NUMBER : T.BOOL;
+            }
+            case "BinaryExpr": {
+                const leftType = this.checkExpression(expr.left, scope, ctx);
+                const rightType = this.checkExpression(expr.right, scope, ctx);
+                return this.checkBinaryOp(expr, leftType, rightType);
+            }
+            case "LogicalExpr": {
+                const leftType = this.checkExpression(expr.left, scope, ctx);
+                const rightType = this.checkExpression(expr.right, scope, ctx);
+                this.expectType(leftType, T.BOOL, expr.line, expr.col, `'${expr.op}' operand`);
+                this.expectType(rightType, T.BOOL, expr.line, expr.col, `'${expr.op}' operand`);
+                return T.BOOL;
+            }
+            case "AssignExpr": {
+                let targetType;
+                if (expr.target.kind === "MemberExpr") {
+                    targetType = this.checkMember(expr.target, scope, ctx, true).type;
+                }
+                else {
+                    targetType = this.checkExpression(expr.target, scope, ctx);
+                    if (expr.target.kind === "Identifier") {
+                        const found = scope.resolve(expr.target.name);
+                        if (found?.isConst) {
+                            this.diagnostics.error(`Cannot assign to const variable '${expr.target.name}'`, expr.line, expr.col);
+                        }
+                    }
+                }
+                const valueType = this.checkExpressionExpecting(expr.value, targetType, scope, ctx);
+                if (!this.isAssignableType(valueType, targetType)) {
+                    this.diagnostics.error(`Cannot assign value of type '${T.typeToString(valueType)}' to target of type '${T.typeToString(targetType)}'`, expr.line, expr.col);
+                }
+                return targetType;
+            }
+            case "CallExpr":
+                return this.checkCall(expr, scope, ctx);
+            case "NewExpr":
+                return this.checkNew(expr, scope, ctx);
+            case "MemberExpr":
+                return this.checkMember(expr, scope, ctx).type;
+            case "IndexExpr": {
+                const objType = this.checkExpression(expr.object, scope, ctx);
+                const indexType = this.checkExpression(expr.index, scope, ctx);
+                this.expectType(indexType, T.NUMBER, expr.line, expr.col, "array index");
+                if (objType.kind === "array")
+                    return objType.element;
+                if (objType.kind !== "unknown") {
+                    this.diagnostics.error(`Cannot index into non-array type '${T.typeToString(objType)}'`, expr.line, expr.col);
+                }
+                return T.UNKNOWN;
+            }
+            case "MatchExpr":
+                return this.checkMatch(expr, scope, ctx);
+            case "LambdaExpr":
+                // Reached only when a lambda appears somewhere with no contextual
+                // expected type available (e.g. inside a match arm or array
+                // literal) — still checked, just without validating its params
+                // against anything. checkExpressionExpecting is the normal path.
+                return this.checkLambda(expr, T.UNKNOWN, scope, ctx);
+            case "AwaitExpr": {
+                if (!ctx.isAsync) {
+                    this.diagnostics.error(`'await' can only be used inside an 'async' function or method`, expr.line, expr.col);
+                }
+                const operandType = this.checkExpression(expr.operand, scope, ctx);
+                if (operandType.kind === "task")
+                    return operandType.resultType;
+                if (operandType.kind !== "unknown") {
+                    this.diagnostics.error(`Cannot 'await' a value of type '${T.typeToString(operandType)}'`, expr.line, expr.col);
+                }
+                return T.UNKNOWN;
+            }
+            case "StateExpr": {
+                const valueType = this.checkExpression(expr.initializer, scope, ctx);
+                return T.stateType(valueType);
+            }
+        }
+    }
+    // Like checkExpression, but for a position with a known expected type —
+    // every position a lambda can appear in has one, since KopScript requires an
+    // explicit type everywhere (the declared type of a variable/field/param,
+    // a function's declared return type, ...). Lambdas are checked against
+    // that expected type; everything else behaves exactly like
+    // checkExpression (the caller still does its own assignability check
+    // against `expected` afterward, same as before this existed).
+    checkExpressionExpecting(expr, expected, scope, ctx) {
+        if (expr.kind === "LambdaExpr")
+            return this.checkLambda(expr, expected, scope, ctx);
+        return this.checkExpression(expr, scope, ctx);
+    }
+    checkLambda(expr, expected, scope, ctx) {
+        if (expected.kind !== "function") {
+            if (expected.kind !== "unknown") {
+                this.diagnostics.error(`Lambda expression is not valid where type '${T.typeToString(expected)}' is expected`, expr.line, expr.col);
+            }
+            const paramTypes = expr.params.map((p) => this.resolveType(p.type, expr.line, expr.col));
+            const lambdaScope = scope.child();
+            expr.params.forEach((p, i) => lambdaScope.declare(p.name, paramTypes[i], false));
+            // No expected type at all: infer the return type from the body itself
+            // (expression-bodied only — see checkLambdaBody) rather than giving up.
+            const actualReturnType = this.checkLambdaBody(expr, T.UNKNOWN, lambdaScope, ctx);
+            return T.functionType(paramTypes, actualReturnType);
+        }
+        if (expr.params.length !== expected.params.length) {
+            this.diagnostics.error(`Lambda has ${expr.params.length} parameter(s), but ${expected.params.length} were expected`, expr.line, expr.col);
+        }
+        const paramTypes = expr.params.map((p, i) => {
+            const declared = this.resolveType(p.type, expr.line, expr.col);
+            const expectedParamType = expected.params[i];
+            if (expectedParamType && !T.typesEqual(declared, expectedParamType)) {
+                this.diagnostics.error(`Lambda parameter '${p.name}' has type '${T.typeToString(declared)}', expected '${T.typeToString(expectedParamType)}'`, expr.line, expr.col);
+            }
+            return declared;
+        });
+        const lambdaScope = scope.child();
+        expr.params.forEach((p, i) => lambdaScope.declare(p.name, paramTypes[i], false));
+        const actualReturnType = this.checkLambdaBody(expr, expected.returnType, lambdaScope, ctx);
+        // The expected return type might itself be UNKNOWN (e.g. Array.Map's
+        // callback: the param type is known, but the result type is exactly
+        // what we're trying to learn) — fall back to whatever the body actually
+        // produced rather than propagating UNKNOWN needlessly.
+        const resultReturnType = expected.returnType.kind === "unknown" ? actualReturnType : expected.returnType;
+        return T.functionType(paramTypes, resultReturnType);
+    }
+    // Returns the type `return` statements/the body expression actually
+    // produced. For a block body this is just `expectedReturnType` echoed
+    // back (v1 doesn't scan a block's `return` statements to infer a result
+    // type when none is expected) — inference only works for the common case
+    // of an expression-bodied lambda.
+    checkLambdaBody(expr, expectedReturnType, scope, ctx) {
+        // A lambda is a closure, not a method — it never has its own `this`
+        // (it inherits the enclosing one, matching JS arrow-function semantics,
+        // which is exactly what it compiles to) and it's never "in a
+        // constructor": even one created inside a constructor might be called
+        // long after construction finishes, so allowing a get-only property
+        // assignment inside it would be unsound. There's no async-lambda syntax
+        // in v1 either, so `await` is never valid inside one, regardless of
+        // whether the enclosing function is itself async.
+        const lambdaCtx = { returnType: expectedReturnType, currentClass: ctx.currentClass, inConstructor: false, loopDepth: 0, isAsync: false };
+        if (expr.body.kind === "Block") {
+            this.checkBlock(expr.body, scope, lambdaCtx);
+            return expectedReturnType;
+        }
+        const actual = this.checkExpressionExpecting(expr.body, expectedReturnType, scope, lambdaCtx);
+        if (expectedReturnType.kind !== "unknown" && !this.isAssignableType(actual, expectedReturnType)) {
+            this.diagnostics.error(`Lambda body has type '${T.typeToString(actual)}', expected '${T.typeToString(expectedReturnType)}'`, expr.line, expr.col);
+        }
+        return actual;
+    }
+    checkBinaryOp(expr, leftType, rightType) {
+        const { op, line, col } = expr;
+        if (op === "+") {
+            if (leftType.kind === "string" || rightType.kind === "string") {
+                return T.STRING;
+            }
+            this.expectType(leftType, T.NUMBER, line, col, "'+' operand");
+            this.expectType(rightType, T.NUMBER, line, col, "'+' operand");
+            return T.NUMBER;
+        }
+        if (op === "-" || op === "*" || op === "/" || op === "%") {
+            this.expectType(leftType, T.NUMBER, line, col, `'${op}' operand`);
+            this.expectType(rightType, T.NUMBER, line, col, `'${op}' operand`);
+            return T.NUMBER;
+        }
+        if (op === "==" || op === "!=") {
+            if (!T.typesEqual(leftType, rightType)) {
+                this.diagnostics.error(`Cannot compare '${T.typeToString(leftType)}' with '${T.typeToString(rightType)}'`, line, col);
+            }
+            return T.BOOL;
+        }
+        // <, >, <=, >=
+        this.expectType(leftType, T.NUMBER, line, col, `'${op}' operand`);
+        this.expectType(rightType, T.NUMBER, line, col, `'${op}' operand`);
+        return T.BOOL;
+    }
+    checkCall(expr, scope, ctx) {
+        // Extern values are excluded here even though they're not scope-resolved,
+        // so a function-typed extern value (rare, but valid) falls through to the
+        // generic "callee is some function-typed expression" handling below
+        // instead of hitting the "undefined function" error meant for plain names.
+        if (expr.callee.kind === "Identifier" && !scope.resolve(expr.callee.name) && !this.externValues.has(expr.callee.name)) {
+            const info = this.functions.get(expr.callee.name);
+            if (!info) {
+                if (expr.callee.name === "print") {
+                    expr.args.forEach((a) => this.checkExpression(a, scope, ctx));
+                    return T.VOID;
+                }
+                this.diagnostics.error(`Undefined function '${expr.callee.name}'`, expr.line, expr.col);
+                expr.args.forEach((a) => this.checkExpression(a, scope, ctx));
+                return T.UNKNOWN;
+            }
+            this.checkArgs(expr, info.params, scope, ctx);
+            return info.returnType;
+        }
+        if (expr.callee.kind === "MemberExpr") {
+            // Array.Map's result type is polymorphic (derived from the callback),
+            // which doesn't fit checkMember's fixed-signature methodInfo shape —
+            // handled here instead, before the generic member/call path below.
+            if (expr.callee.property === "Map") {
+                const objectType = this.checkExpression(expr.callee.object, scope, ctx);
+                if (objectType.kind === "array") {
+                    return this.checkArrayMap(expr, objectType.element, scope, ctx);
+                }
+            }
+            const { type: methodType, methodInfo } = this.checkMember(expr.callee, scope, ctx);
+            if (methodInfo) {
+                this.checkArgs(expr, methodInfo.params, scope, ctx);
+                return methodInfo.returnType;
+            }
+            if (methodType.kind === "function") {
+                this.checkArgs(expr, methodType.params, scope, ctx);
+                return methodType.returnType;
+            }
+            expr.args.forEach((a) => this.checkExpression(a, scope, ctx));
+            return methodType;
+        }
+        // Any other callee expression: a variable/parameter holding a function
+        // value, a call that itself returns a function, an immediately-invoked
+        // lambda, etc. — anything whose static type is a function type.
+        const calleeType = this.checkExpression(expr.callee, scope, ctx);
+        if (calleeType.kind === "function") {
+            this.checkArgs(expr, calleeType.params, scope, ctx);
+            return calleeType.returnType;
+        }
+        if (calleeType.kind !== "unknown") {
+            this.diagnostics.error(`Cannot call a value of type '${T.typeToString(calleeType)}'`, expr.line, expr.col);
+        }
+        expr.args.forEach((a) => this.checkExpression(a, scope, ctx));
+        return T.UNKNOWN;
+    }
+    checkArgs(expr, paramTypes, scope, ctx) {
+        if (expr.args.length !== paramTypes.length) {
+            this.diagnostics.error(`Expected ${paramTypes.length} argument(s), got ${expr.args.length}`, expr.line, expr.col);
+        }
+        expr.args.forEach((arg, i) => {
+            const expected = paramTypes[i] ?? T.UNKNOWN;
+            const argType = this.checkExpressionExpecting(arg, expected, scope, ctx);
+            if (!this.isAssignableType(argType, expected)) {
+                this.diagnostics.error(`Argument ${i + 1} has type '${T.typeToString(argType)}', expected '${T.typeToString(expected)}'`, arg.line, arg.col);
+            }
+        });
+    }
+    checkNew(expr, scope, ctx) {
+        if (this.interfaces.has(expr.className)) {
+            this.diagnostics.error(`Cannot instantiate interface '${expr.className}'`, expr.line, expr.col);
+            expr.args.forEach((a) => this.checkExpression(a, scope, ctx));
+            return T.UNKNOWN;
+        }
+        if (this.enums.has(expr.className)) {
+            this.diagnostics.error(`Cannot instantiate enum '${expr.className}'`, expr.line, expr.col);
+            expr.args.forEach((a) => this.checkExpression(a, scope, ctx));
+            return T.UNKNOWN;
+        }
+        const info = this.classes.get(expr.className);
+        if (!info) {
+            this.diagnostics.error(`Unknown class '${expr.className}'`, expr.line, expr.col);
+            expr.args.forEach((a) => this.checkExpression(a, scope, ctx));
+            return T.UNKNOWN;
+        }
+        const ctorParams = this.lookupCtorParams(expr.className);
+        if (expr.args.length !== ctorParams.length) {
+            this.diagnostics.error(`Expected ${ctorParams.length} constructor argument(s), got ${expr.args.length}`, expr.line, expr.col);
+        }
+        expr.args.forEach((arg, i) => {
+            const expected = ctorParams[i] ?? T.UNKNOWN;
+            const argType = this.checkExpressionExpecting(arg, expected, scope, ctx);
+            if (!this.isAssignableType(argType, expected)) {
+                this.diagnostics.error(`Constructor argument ${i + 1} has type '${T.typeToString(argType)}', expected '${T.typeToString(expected)}'`, arg.line, arg.col);
+            }
+        });
+        return T.classType(expr.className);
+    }
+    lookupCtorParams(className) {
+        let current = className;
+        while (current) {
+            const info = this.classes.get(current);
+            if (!info)
+                return [];
+            if (info.ownCtorParams !== null)
+                return info.ownCtorParams;
+            current = info.superclass;
+        }
+        return [];
+    }
+    // Array stdlib with a fixed (non-polymorphic) signature, given the
+    // array's own element type — everything except Map, which checkCall
+    // handles separately since its result type depends on the callback
+    // actually passed at the call site, not just the receiver.
+    arrayMethod(elementType, name) {
+        const method = { visibility: "public", isVirtual: false, isOverride: false };
+        if (name === "ForEach") {
+            return { ...method, params: [T.functionType([elementType], T.VOID)], returnType: T.VOID };
+        }
+        if (name === "Filter") {
+            return { ...method, params: [T.functionType([elementType], T.BOOL)], returnType: T.arrayOf(elementType) };
+        }
+        if (name === "Push") {
+            // Non-mutating by design, unlike JS's own Array.push — consistent
+            // with Map/Filter, and avoids introducing aliasing surprises that
+            // nothing else in the type system models. Compiles to `[...arr, x]`.
+            return { ...method, params: [elementType], returnType: T.arrayOf(elementType) };
+        }
+        return null;
+    }
+    // Array.Map: `arr.Map(f)` where f: (T) => U, result: U[]. U is whatever
+    // the callback actually returns — checkLambda infers it from the body
+    // when given a partially-known expected type (params known, return
+    // UNKNOWN); a plain function-valued argument (a named function, or a
+    // variable already holding one) already carries its own real type, so no
+    // inference is needed there at all.
+    checkArrayMap(expr, elementType, scope, ctx) {
+        if (expr.args.length !== 1) {
+            this.diagnostics.error(`Map expects exactly 1 argument, got ${expr.args.length}`, expr.line, expr.col);
+            expr.args.forEach((a) => this.checkExpression(a, scope, ctx));
+            return T.arrayOf(T.UNKNOWN);
+        }
+        const arg = expr.args[0];
+        const expectedCallbackType = T.functionType([elementType], T.UNKNOWN);
+        const argType = this.checkExpressionExpecting(arg, expectedCallbackType, scope, ctx);
+        if (argType.kind !== "function") {
+            if (argType.kind !== "unknown") {
+                this.diagnostics.error(`Map expects a function as its argument, got '${T.typeToString(argType)}'`, arg.line, arg.col);
+            }
+            return T.arrayOf(T.UNKNOWN);
+        }
+        if (argType.params.length !== 1 || !this.isAssignableType(elementType, argType.params[0])) {
+            this.diagnostics.error(`Map callback must take a single '${T.typeToString(elementType)}' parameter, got '${T.typeToString(argType)}'`, arg.line, arg.col);
+        }
+        return T.arrayOf(argType.returnType);
+    }
+    checkMember(expr, scope, ctx, isAssignTarget = false) {
+        // A bare type name as the "object" — Color.Red (enum) or Dog.Count (static) —
+        // is a type reference, not a value, so it's handled before the general expression check.
+        if (expr.object.kind === "Identifier" && !scope.resolve(expr.object.name)) {
+            const objName = expr.object.name;
+            if (this.enums.has(objName)) {
+                const enumInfo = this.enums.get(objName);
+                if (!enumInfo.members.has(expr.property)) {
+                    this.diagnostics.error(`Enum '${objName}' has no member '${expr.property}'`, expr.line, expr.col);
+                    return { type: T.UNKNOWN, methodInfo: null };
+                }
+                return { type: T.enumType(objName), methodInfo: null };
+            }
+            if (this.classes.has(objName)) {
+                const field = this.lookupStaticField(objName, expr.property);
+                if (field) {
+                    this.checkAccessibility(field.info.visibility, field.owner, ctx, expr.property, expr.line, expr.col);
+                    return { type: field.info.type, methodInfo: null };
+                }
+                const method = this.lookupStaticMethod(objName, expr.property);
+                if (method) {
+                    this.checkAccessibility(method.info.visibility, method.owner, ctx, expr.property, expr.line, expr.col);
+                    return { type: method.info.returnType, methodInfo: method.info };
+                }
+                this.diagnostics.error(`Class '${objName}' has no static member '${expr.property}'`, expr.line, expr.col);
+                return { type: T.UNKNOWN, methodInfo: null };
+            }
+        }
+        const objectType = this.checkExpression(expr.object, scope, ctx);
+        if (objectType.kind === "string") {
+            if (expr.property === "Length")
+                return { type: T.NUMBER, methodInfo: null };
+            const method = STRING_METHODS[expr.property];
+            if (method)
+                return { type: method.returnType, methodInfo: method };
+            this.diagnostics.error(`Unknown string member '${expr.property}'`, expr.line, expr.col);
+            return { type: T.UNKNOWN, methodInfo: null };
+        }
+        if (objectType.kind === "array") {
+            if (expr.property === "Length")
+                return { type: T.NUMBER, methodInfo: null };
+            const method = this.arrayMethod(objectType.element, expr.property);
+            if (method)
+                return { type: method.returnType, methodInfo: method };
+            // Map isn't handled here at all — its result type is polymorphic
+            // (derived from the callback passed at the call site), which doesn't
+            // fit this fixed-signature lookup. checkCall special-cases it before
+            // ever reaching checkMember, so `arr.Map(f)` works; `arr.Map` used as
+            // a bare value (not called) falls through to this error, same as an
+            // unknown member — a known v1 restriction.
+            this.diagnostics.error(`Unknown array member '${expr.property}'`, expr.line, expr.col);
+            return { type: T.UNKNOWN, methodInfo: null };
+        }
+        if (objectType.kind === "state") {
+            if (expr.property === "Value")
+                return { type: objectType.valueType, methodInfo: null };
+            if (expr.property === "Subscribe") {
+                const method = {
+                    params: [T.functionType([objectType.valueType], T.VOID)],
+                    returnType: T.VOID,
+                    visibility: "public",
+                    isVirtual: false,
+                    isOverride: false,
+                };
+                return { type: method.returnType, methodInfo: method };
+            }
+            this.diagnostics.error(`Unknown state member '${expr.property}'`, expr.line, expr.col);
+            return { type: T.UNKNOWN, methodInfo: null };
+        }
+        if (objectType.kind === "class") {
+            const field = this.lookupField(objectType.name, expr.property);
+            if (field) {
+                this.checkAccessibility(field.info.visibility, field.owner, ctx, expr.property, expr.line, expr.col);
+                if (isAssignTarget && !field.info.hasSetter) {
+                    const inOwnCtor = ctx.inConstructor && ctx.currentClass?.name === field.owner;
+                    if (!inOwnCtor) {
+                        this.diagnostics.error(`'${expr.property}' has no setter and can only be assigned within ${field.owner}'s constructor`, expr.line, expr.col);
+                    }
+                }
+                return { type: field.info.type, methodInfo: null };
+            }
+            const method = this.lookupMethod(objectType.name, expr.property);
+            if (method) {
+                this.checkAccessibility(method.info.visibility, method.owner, ctx, expr.property, expr.line, expr.col);
+                return { type: method.info.returnType, methodInfo: method.info };
+            }
+            this.diagnostics.error(`Class '${objectType.name}' has no member '${expr.property}'`, expr.line, expr.col);
+            return { type: T.UNKNOWN, methodInfo: null };
+        }
+        if (objectType.kind === "interface") {
+            const sig = this.collectInterfaceMethods(objectType.name).find((m) => m.name === expr.property);
+            if (sig) {
+                return { type: sig.returnType, methodInfo: { params: sig.params, returnType: sig.returnType, visibility: "public", isVirtual: false, isOverride: false } };
+            }
+            this.diagnostics.error(`Interface '${objectType.name}' has no member '${expr.property}'`, expr.line, expr.col);
+            return { type: T.UNKNOWN, methodInfo: null };
+        }
+        if (objectType.kind !== "unknown") {
+            this.diagnostics.error(`Cannot access member '${expr.property}' on type '${T.typeToString(objectType)}'`, expr.line, expr.col);
+        }
+        return { type: T.UNKNOWN, methodInfo: null };
+    }
+    checkMatch(expr, scope, ctx) {
+        const subjectType = this.checkExpression(expr.subject, scope, ctx);
+        this.expectType(subjectType, T.STRING, expr.line, expr.col, "match subject");
+        if (expr.arms.length === 0) {
+            this.diagnostics.error(`match expression must have at least one arm`, expr.line, expr.col);
+            return T.UNKNOWN;
+        }
+        const lastArm = expr.arms[expr.arms.length - 1];
+        if (lastArm.pattern.kind !== "WildcardPattern") {
+            this.diagnostics.error(`match expression must end with a wildcard '_' arm`, lastArm.line, lastArm.col);
+        }
+        let resultType = null;
+        for (const arm of expr.arms) {
+            if (arm.pattern.kind === "LiteralPattern") {
+                for (const value of arm.pattern.values) {
+                    if (value.kind !== "StringLiteral") {
+                        this.diagnostics.error(`match patterns must be string literals`, value.line, value.col);
+                    }
+                    else {
+                        this.checkExpression(value, scope, ctx);
+                    }
+                }
+            }
+            // RegexPattern and WildcardPattern need no further checking here.
+            const armResultType = this.checkExpression(arm.result, scope, ctx);
+            if (resultType === null) {
+                resultType = armResultType;
+            }
+            else if (!this.isAssignableType(armResultType, resultType)) {
+                this.diagnostics.error(`match arm result type '${T.typeToString(armResultType)}' does not match preceding arms' type '${T.typeToString(resultType)}'`, arm.line, arm.col);
+            }
+        }
+        return resultType ?? T.UNKNOWN;
+    }
+}