edict-lang 0.1.0

package/dist/check.d.ts

@@ -0,0 +1,19 @@
+import type { StructuredError } from "./errors/structured-errors.js";
+import type { EdictModule } from "./ast/nodes.js";
+export interface CheckResult {
+    ok: boolean;
+    errors: StructuredError[];
+    /** The validated module AST (only present when ok === true) */
+    module?: EdictModule;
+}
+/**
+ * Full pipeline: validate → resolve → typeCheck → effectCheck → contractVerify.
+ *
+ * If validation fails, returns validation errors (later phases skipped).
+ * If resolution fails, returns resolution errors (later phases skipped).
+ * If type checking fails, returns type errors (effect checking skipped).
+ * If effect checking fails, returns effect errors (contract verification skipped).
+ * If all passes succeed, returns `{ ok: true, errors: [] }`.
+ */
+export declare function check(ast: unknown): Promise<CheckResult>;
+//# sourceMappingURL=check.d.ts.map

package/dist/check.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check.d.ts","sourceRoot":"","sources":["../src/check.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAMrE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAElD,MAAM,WAAW,WAAW;IACxB,EAAE,EAAE,OAAO,CAAC;IACZ,MAAM,EAAE,eAAe,EAAE,CAAC;IAC1B,+DAA+D;IAC/D,MAAM,CAAC,EAAE,WAAW,CAAC;CACxB;AAED;;;;;;;;GAQG;AACH,wBAAsB,KAAK,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAAC,WAAW,CAAC,CAiC9D"}

package/dist/check.js

@@ -0,0 +1,49 @@
+// =============================================================================
+// Edict Pipeline — check(ast) → Promise<CheckResult>
+// =============================================================================
+// Runs the full pipeline: validate → resolve → typeCheck → effectCheck → contractVerify
+// Stops early if an earlier phase fails.
+import { validate } from "./validator/validate.js";
+import { resolve } from "./resolver/resolve.js";
+import { typeCheck } from "./checker/check.js";
+import { effectCheck } from "./effects/effect-check.js";
+import { contractVerify } from "./contracts/verify.js";
+/**
+ * Full pipeline: validate → resolve → typeCheck → effectCheck → contractVerify.
+ *
+ * If validation fails, returns validation errors (later phases skipped).
+ * If resolution fails, returns resolution errors (later phases skipped).
+ * If type checking fails, returns type errors (effect checking skipped).
+ * If effect checking fails, returns effect errors (contract verification skipped).
+ * If all passes succeed, returns `{ ok: true, errors: [] }`.
+ */
+export async function check(ast) {
+    // Phase 1 — Structural validation
+    const validation = validate(ast);
+    if (!validation.ok) {
+        return { ok: false, errors: validation.errors };
+    }
+    const module = ast;
+    // Phase 2a — Name resolution
+    const resolveErrors = resolve(module);
+    if (resolveErrors.length > 0) {
+        return { ok: false, errors: resolveErrors };
+    }
+    // Phase 2b — Type checking
+    const typeErrors = typeCheck(module);
+    if (typeErrors.length > 0) {
+        return { ok: false, errors: typeErrors };
+    }
+    // Phase 3 — Effect checking
+    const effectErrors = effectCheck(module);
+    if (effectErrors.length > 0) {
+        return { ok: false, errors: effectErrors };
+    }
+    // Phase 4 — Contract verification
+    const contractErrors = await contractVerify(module);
+    if (contractErrors.length > 0) {
+        return { ok: false, errors: contractErrors };
+    }
+    return { ok: true, errors: [], module };
+}
+//# sourceMappingURL=check.js.map

package/dist/check.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"check.js","sourceRoot":"","sources":["../src/check.ts"],"names":[],"mappings":"AAAA,gFAAgF;AAChF,qDAAqD;AACrD,gFAAgF;AAChF,wFAAwF;AACxF,yCAAyC;AAGzC,OAAO,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AACnD,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAChD,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAC/C,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AACxD,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAUvD;;;;;;;;GAQG;AACH,MAAM,CAAC,KAAK,UAAU,KAAK,CAAC,GAAY;IACpC,kCAAkC;IAClC,MAAM,UAAU,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC;IACjC,IAAI,CAAC,UAAU,CAAC,EAAE,EAAE,CAAC;QACjB,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,UAAU,CAAC,MAAM,EAAE,CAAC;IACpD,CAAC;IAED,MAAM,MAAM,GAAG,GAAkB,CAAC;IAElC,6BAA6B;IAC7B,MAAM,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IACtC,IAAI,aAAa,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAC3B,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,aAAa,EAAE,CAAC;IAChD,CAAC;IAED,2BAA2B;IAC3B,MAAM,UAAU,GAAG,SAAS,CAAC,MAAM,CAAC,CAAC;IACrC,IAAI,UAAU,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACxB,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,CAAC;IAC7C,CAAC;IAED,4BAA4B;IAC5B,MAAM,YAAY,GAAG,WAAW,CAAC,MAAM,CAAC,CAAC;IACzC,IAAI,YAAY,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAC1B,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,CAAC;IAC/C,CAAC;IAED,kCAAkC;IAClC,MAAM,cAAc,GAAG,MAAM,cAAc,CAAC,MAAM,CAAC,CAAC;IACpD,IAAI,cAAc,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAC5B,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,cAAc,EAAE,CAAC;IACjD,CAAC;IACD,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,CAAC;AAC5C,CAAC"}

package/dist/checker/check.d.ts

@@ -0,0 +1,7 @@
+import type { EdictModule } from "../ast/nodes.js";
+import type { StructuredError } from "../errors/structured-errors.js";
+/**
+ * Entry point: type-check a validated + resolved Edict module.
+ */
+export declare function typeCheck(module: EdictModule): StructuredError[];
+//# sourceMappingURL=check.d.ts.map

package/dist/checker/check.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check.d.ts","sourceRoot":"","sources":["../../src/checker/check.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EACR,WAAW,EAOd,MAAM,iBAAiB,CAAC;AAEzB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAC;AAqBtE;;GAEG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,WAAW,GAAG,eAAe,EAAE,CAwChE"}

package/dist/checker/check.js

@@ -0,0 +1,548 @@
+// =============================================================================
+// Type Checker — typeCheck(module) → StructuredError[]
+// =============================================================================
+// Assumes name resolution has already passed. Infers types for expressions
+// and reports type mismatches, arity errors, etc.
+import { typeMismatch, arityMismatch, notAFunction, unknownField, unknownRecord, unknownEnum, unknownVariant, missingRecordFields, } from "../errors/structured-errors.js";
+import { TypeEnv } from "./type-env.js";
+import { typesEqual, isUnknown, resolveType } from "./types-equal.js";
+import { BUILTIN_FUNCTIONS } from "../codegen/builtins.js";
+const UNKNOWN_TYPE = { kind: "named", name: "unknown" };
+const INT_TYPE = { kind: "basic", name: "Int" };
+const FLOAT_TYPE = { kind: "basic", name: "Float" };
+const STRING_TYPE = { kind: "basic", name: "String" };
+const BOOL_TYPE = { kind: "basic", name: "Bool" };
+/**
+ * Entry point: type-check a validated + resolved Edict module.
+ */
+export function typeCheck(module) {
+    const errors = [];
+    const rootEnv = new TypeEnv();
+    // Register built-in function signatures
+    for (const [name, builtin] of BUILTIN_FUNCTIONS) {
+        rootEnv.bind(name, builtin.type);
+    }
+    // Register type definitions (records, enums, type aliases)
+    for (const def of module.definitions) {
+        registerTypeDef(def, rootEnv);
+    }
+    // Register function signatures and const types
+    for (const def of module.definitions) {
+        registerValueDef(def, rootEnv);
+    }
+    // Register imports as unknown
+    for (const imp of module.imports) {
+        for (const name of imp.names) {
+            rootEnv.bind(name, UNKNOWN_TYPE);
+        }
+    }
+    // Type-check each definition
+    for (const def of module.definitions) {
+        switch (def.kind) {
+            case "fn":
+                checkFunction(def, rootEnv, errors);
+                break;
+            case "const":
+                checkConst(def, rootEnv, errors);
+                break;
+            // record, enum, type — no body to type-check
+        }
+    }
+    return errors;
+}
+// =============================================================================
+// Registration
+// =============================================================================
+function registerTypeDef(def, env) {
+    switch (def.kind) {
+        case "type":
+        case "record":
+        case "enum":
+            env.registerTypeDef(def.name, def);
+            break;
+    }
+}
+function registerValueDef(def, env) {
+    switch (def.kind) {
+        case "fn": {
+            const fnType = {
+                kind: "fn_type",
+                params: def.params.map((p) => p.type),
+                effects: [...def.effects],
+                returnType: def.returnType,
+            };
+            env.bind(def.name, fnType);
+            break;
+        }
+        case "const":
+            env.bind(def.name, def.type);
+            break;
+    }
+}
+// =============================================================================
+// Function checking
+// =============================================================================
+function checkFunction(fn, rootEnv, errors) {
+    const fnEnv = rootEnv.child();
+    // Bind params
+    for (const param of fn.params) {
+        fnEnv.bind(param.name, param.type);
+    }
+    // Check contracts
+    for (const contract of fn.contracts) {
+        if (contract.kind === "post") {
+            const postEnv = fnEnv.child();
+            postEnv.bind("result", fn.returnType);
+            const condType = inferExpr(contract.condition, postEnv, errors);
+            checkExpectedType(condType, BOOL_TYPE, contract.id, fnEnv, errors, "post-contract condition must be Bool");
+        }
+        else {
+            const condType = inferExpr(contract.condition, fnEnv, errors);
+            checkExpectedType(condType, BOOL_TYPE, contract.id, fnEnv, errors, "pre-contract condition must be Bool");
+        }
+    }
+    // Infer body type
+    const bodyType = inferExprList(fn.body, fnEnv, errors);
+    // Check return type
+    if (bodyType && !isUnknown(bodyType) && !isUnknown(resolveType(fn.returnType, fnEnv))) {
+        checkExpectedType(bodyType, fn.returnType, fn.id, fnEnv, errors, "function body type must match return type");
+    }
+}
+function checkConst(def, env, errors) {
+    const valType = inferExpr(def.value, env, errors);
+    checkExpectedType(valType, def.type, def.id, env, errors, "const value must match declared type");
+}
+// =============================================================================
+// Type inference
+// =============================================================================
+function inferExprList(exprs, env, errors) {
+    if (exprs.length === 0)
+        return UNKNOWN_TYPE;
+    let currentEnv = env;
+    let lastType = UNKNOWN_TYPE;
+    for (const expr of exprs) {
+        lastType = inferExpr(expr, currentEnv, errors);
+        if (expr.kind === "let") {
+            currentEnv = currentEnv.child();
+            // Bind the let name in child env
+            const bindType = expr.type ?? lastType;
+            currentEnv.bind(expr.name, bindType);
+        }
+    }
+    return lastType;
+}
+function inferExpr(expr, env, errors) {
+    switch (expr.kind) {
+        case "literal":
+            return inferLiteral(expr);
+        case "ident":
+            return env.getType(expr.name) ?? UNKNOWN_TYPE;
+        case "binop":
+            return inferBinop(expr, env, errors);
+        case "unop":
+            return inferUnop(expr, env, errors);
+        case "call":
+            return inferCall(expr, env, errors);
+        case "if":
+            return inferIf(expr, env, errors);
+        case "let":
+            return inferLet(expr, env, errors);
+        case "match":
+            return inferMatch(expr, env, errors);
+        case "array":
+            return inferArray(expr, env, errors);
+        case "tuple_expr":
+            return inferTuple(expr, env, errors);
+        case "record_expr":
+            return inferRecordExpr(expr, env, errors);
+        case "enum_constructor":
+            return inferEnumConstructor(expr, env, errors);
+        case "access":
+            return inferAccess(expr, env, errors);
+        case "lambda":
+            return inferLambda(expr, env, errors);
+        case "block":
+            return inferExprList(expr.body, env.child(), errors);
+    }
+}
+// =============================================================================
+// Inference helpers
+// =============================================================================
+function inferLiteral(expr) {
+    // If annotated, use that type
+    if (expr.type)
+        return expr.type;
+    if (typeof expr.value === "boolean")
+        return BOOL_TYPE;
+    if (typeof expr.value === "string")
+        return STRING_TYPE;
+    if (typeof expr.value === "number") {
+        return Number.isInteger(expr.value) ? INT_TYPE : FLOAT_TYPE;
+    }
+    return UNKNOWN_TYPE;
+}
+function inferBinop(expr, env, errors) {
+    const leftType = inferExpr(expr.left, env, errors);
+    const rightType = inferExpr(expr.right, env, errors);
+    // unknown propagation
+    if (isUnknown(leftType) || isUnknown(rightType))
+        return UNKNOWN_TYPE;
+    const op = expr.op;
+    // Logical operators: and, or, implies
+    if (op === "and" || op === "or" || op === "implies") {
+        if (!isBool(leftType)) {
+            errors.push(typeMismatch(expr.id, BOOL_TYPE, leftType));
+        }
+        if (!isBool(rightType)) {
+            errors.push(typeMismatch(expr.id, BOOL_TYPE, rightType));
+        }
+        return BOOL_TYPE;
+    }
+    // Comparison operators: ==, !=, <, >, <=, >=
+    if (op === "==" || op === "!=" || op === "<" || op === ">" || op === "<=" || op === ">=") {
+        if (!typesEqual(leftType, rightType, env)) {
+            errors.push(typeMismatch(expr.id, leftType, rightType));
+        }
+        return BOOL_TYPE;
+    }
+    // Arithmetic: +, -, *, /, %
+    if (op === "+") {
+        // + works on numeric types AND strings
+        if (isString(leftType) && isString(rightType))
+            return STRING_TYPE;
+        if (isNumeric(leftType, env) && isNumeric(rightType, env)) {
+            if (!typesEqual(leftType, rightType, env)) {
+                errors.push(typeMismatch(expr.id, leftType, rightType));
+                return UNKNOWN_TYPE;
+            }
+            return leftType;
+        }
+        errors.push(typeMismatch(expr.id, UNKNOWN_TYPE, leftType)); // Unknown since both numeric/String are valid expected
+        return UNKNOWN_TYPE;
+    }
+    // -, *, /, % — numeric only
+    if (isNumeric(leftType, env) && isNumeric(rightType, env)) {
+        if (!typesEqual(leftType, rightType, env)) {
+            errors.push(typeMismatch(expr.id, leftType, rightType));
+            return UNKNOWN_TYPE;
+        }
+        return leftType;
+    }
+    errors.push(typeMismatch(expr.id, UNKNOWN_TYPE, leftType)); // Expected numeric
+    return UNKNOWN_TYPE;
+}
+function inferUnop(expr, env, errors) {
+    const operandType = inferExpr(expr.operand, env, errors);
+    if (isUnknown(operandType))
+        return UNKNOWN_TYPE;
+    if (expr.op === "not") {
+        if (!isBool(operandType)) {
+            errors.push(typeMismatch(expr.id, BOOL_TYPE, operandType));
+        }
+        return BOOL_TYPE;
+    }
+    // Unary -
+    if (!isNumeric(operandType, env)) {
+        errors.push(typeMismatch(expr.id, UNKNOWN_TYPE, operandType)); // expected numeric
+        return UNKNOWN_TYPE;
+    }
+    return operandType;
+}
+function inferCall(expr, env, errors) {
+    const fnType = inferExpr(expr.fn, env, errors);
+    if (isUnknown(fnType)) {
+        // If fn is unknown, we can't type-check args. Infer them for side effects (let bindings)
+        for (const arg of expr.args)
+            inferExpr(arg, env, errors);
+        return UNKNOWN_TYPE;
+    }
+    const resolved = resolveType(fnType, env);
+    if (resolved.kind !== "fn_type") {
+        errors.push(notAFunction(expr.id, fnType));
+        // Still infer arg types for error propagation
+        for (const arg of expr.args)
+            inferExpr(arg, env, errors);
+        return UNKNOWN_TYPE;
+    }
+    // Check arity
+    if (expr.args.length !== resolved.params.length) {
+        errors.push(arityMismatch(expr.id, resolved.params.length, expr.args.length));
+    }
+    // Check arg types (up to the minimum of args/params)
+    const checkCount = Math.min(expr.args.length, resolved.params.length);
+    for (let i = 0; i < checkCount; i++) {
+        const argType = inferExpr(expr.args[i], env, errors);
+        checkExpectedType(argType, resolved.params[i], expr.args[i].id, env, errors, `argument ${i + 1}`);
+    }
+    // Infer remaining surplus args
+    for (let i = checkCount; i < expr.args.length; i++) {
+        inferExpr(expr.args[i], env, errors);
+    }
+    return resolved.returnType;
+}
+function inferIf(expr, env, errors) {
+    const condType = inferExpr(expr.condition, env, errors);
+    checkExpectedType(condType, BOOL_TYPE, expr.id, env, errors, "if condition must be Bool");
+    const thenType = inferExprList(expr.then, env.child(), errors);
+    if (expr.else) {
+        const elseType = inferExprList(expr.else, env.child(), errors);
+        if (!isUnknown(thenType) && !isUnknown(elseType)) {
+            if (!typesEqual(thenType, elseType, env)) {
+                errors.push(typeMismatch(expr.id, thenType, elseType));
+            }
+        }
+        return thenType;
+    }
+    // No else → Option<thenType>
+    return { kind: "option", inner: thenType };
+}
+function inferLet(expr, env, errors) {
+    const valType = inferExpr(expr.value, env, errors);
+    if (expr.type) {
+        checkExpectedType(valType, expr.type, expr.id, env, errors, "let value must match type annotation");
+        return expr.type;
+    }
+    return valType;
+}
+function inferMatch(expr, env, errors) {
+    const targetType = inferExpr(expr.target, env, errors);
+    let resultType = null;
+    for (const arm of expr.arms) {
+        const armEnv = env.child();
+        inferPattern(arm.pattern, targetType, armEnv, env, errors);
+        const bodyType = inferExprList(arm.body, armEnv, errors);
+        if (resultType === null) {
+            resultType = bodyType;
+        }
+        else if (!isUnknown(resultType) && !isUnknown(bodyType)) {
+            if (!typesEqual(resultType, bodyType, env)) {
+                errors.push(typeMismatch(arm.id, resultType, bodyType));
+            }
+        }
+    }
+    return resultType ?? UNKNOWN_TYPE;
+}
+function inferPattern(pattern, targetType, armEnv, rootEnv, errors) {
+    switch (pattern.kind) {
+        case "binding":
+            armEnv.bind(pattern.name, targetType);
+            break;
+        case "wildcard":
+            break;
+        case "literal_pattern": {
+            const litType = inferLiteralPatternType(pattern.value);
+            if (!isUnknown(targetType) && !isUnknown(litType)) {
+                if (!typesEqual(litType, targetType, rootEnv)) {
+                    errors.push(typeMismatch(null, targetType, litType));
+                }
+            }
+            break;
+        }
+        case "constructor": {
+            // Resolve the enum from target type
+            if (isUnknown(targetType)) {
+                // If target is unknown, bind sub-patterns as unknown
+                for (const sub of pattern.fields) {
+                    inferPattern(sub, UNKNOWN_TYPE, armEnv, rootEnv, errors);
+                }
+                break;
+            }
+            const resolvedTarget = resolveType(targetType, rootEnv);
+            if (resolvedTarget.kind !== "named") {
+                // Can't destructure non-named types
+                for (const sub of pattern.fields) {
+                    inferPattern(sub, UNKNOWN_TYPE, armEnv, rootEnv, errors);
+                }
+                break;
+            }
+            const enumDef = rootEnv.lookupTypeDef(resolvedTarget.name);
+            if (!enumDef || enumDef.kind !== "enum") {
+                for (const sub of pattern.fields) {
+                    inferPattern(sub, UNKNOWN_TYPE, armEnv, rootEnv, errors);
+                }
+                break;
+            }
+            const variant = enumDef.variants.find((v) => v.name === pattern.name);
+            if (!variant) {
+                // Already caught by resolver, but bind sub-patterns
+                for (const sub of pattern.fields) {
+                    inferPattern(sub, UNKNOWN_TYPE, armEnv, rootEnv, errors);
+                }
+                break;
+            }
+            // Bind positional fields
+            for (let i = 0; i < pattern.fields.length; i++) {
+                const fieldType = i < variant.fields.length ? variant.fields[i].type : UNKNOWN_TYPE;
+                inferPattern(pattern.fields[i], fieldType, armEnv, rootEnv, errors);
+            }
+            break;
+        }
+    }
+}
+function inferArray(expr, env, errors) {
+    if (expr.elements.length === 0) {
+        return { kind: "array", element: UNKNOWN_TYPE };
+    }
+    const firstType = inferExpr(expr.elements[0], env, errors);
+    for (let i = 1; i < expr.elements.length; i++) {
+        const elType = inferExpr(expr.elements[i], env, errors);
+        if (!isUnknown(firstType) && !isUnknown(elType)) {
+            if (!typesEqual(firstType, elType, env)) {
+                errors.push(typeMismatch(expr.elements[i].id, firstType, elType));
+            }
+        }
+    }
+    return { kind: "array", element: firstType };
+}
+function inferTuple(expr, env, errors) {
+    const elementTypes = expr.elements.map((el) => inferExpr(el, env, errors));
+    return { kind: "tuple", elements: elementTypes };
+}
+function inferRecordExpr(expr, env, errors) {
+    const def = env.lookupTypeDef(expr.name);
+    if (!def) {
+        errors.push(unknownRecord(expr.id, expr.name, collectTypeDefNames(env, "record")));
+        // Still infer field value types
+        for (const f of expr.fields)
+            inferExpr(f.value, env, errors);
+        return UNKNOWN_TYPE;
+    }
+    if (def.kind !== "record") {
+        errors.push(unknownRecord(expr.id, expr.name, collectTypeDefNames(env, "record")));
+        for (const f of expr.fields)
+            inferExpr(f.value, env, errors);
+        return UNKNOWN_TYPE;
+    }
+    const recordDef = def;
+    const providedFields = new Set(expr.fields.map((f) => f.name));
+    // Check required fields (no defaultValue)
+    const requiredMissing = recordDef.fields
+        .filter((f) => !f.defaultValue && !providedFields.has(f.name))
+        .map((f) => f.name);
+    if (requiredMissing.length > 0) {
+        errors.push(missingRecordFields(expr.id, expr.name, requiredMissing));
+    }
+    // Check each provided field
+    for (const fieldInit of expr.fields) {
+        const fieldDef = recordDef.fields.find((f) => f.name === fieldInit.name);
+        if (!fieldDef) {
+            errors.push(unknownField(expr.id, expr.name, fieldInit.name, recordDef.fields.map((f) => f.name)));
+            inferExpr(fieldInit.value, env, errors);
+            continue;
+        }
+        const valType = inferExpr(fieldInit.value, env, errors);
+        checkExpectedType(valType, fieldDef.type, expr.id, env, errors, `field '${fieldInit.name}'`);
+    }
+    return { kind: "named", name: expr.name };
+}
+function inferEnumConstructor(expr, env, errors) {
+    const def = env.lookupTypeDef(expr.enumName);
+    if (!def) {
+        errors.push(unknownEnum(expr.id, expr.enumName, collectTypeDefNames(env, "enum")));
+        for (const f of expr.fields)
+            inferExpr(f.value, env, errors);
+        return UNKNOWN_TYPE;
+    }
+    if (def.kind !== "enum") {
+        errors.push(unknownEnum(expr.id, expr.enumName, collectTypeDefNames(env, "enum")));
+        for (const f of expr.fields)
+            inferExpr(f.value, env, errors);
+        return UNKNOWN_TYPE;
+    }
+    const enumDef = def;
+    const variant = enumDef.variants.find((v) => v.name === expr.variant);
+    if (!variant) {
+        errors.push(unknownVariant(expr.id, expr.enumName, expr.variant, enumDef.variants.map((v) => v.name)));
+        for (const f of expr.fields)
+            inferExpr(f.value, env, errors);
+        return UNKNOWN_TYPE;
+    }
+    // Check field count and types
+    for (const fieldInit of expr.fields) {
+        const fieldDef = variant.fields.find((f) => f.name === fieldInit.name);
+        if (!fieldDef) {
+            errors.push(unknownField(expr.id, `${expr.enumName}.${expr.variant}`, fieldInit.name, variant.fields.map((f) => f.name)));
+            inferExpr(fieldInit.value, env, errors);
+            continue;
+        }
+        const valType = inferExpr(fieldInit.value, env, errors);
+        checkExpectedType(valType, fieldDef.type, expr.id, env, errors, `field '${fieldInit.name}'`);
+    }
+    return { kind: "named", name: expr.enumName };
+}
+function inferAccess(expr, env, errors) {
+    const targetType = inferExpr(expr.target, env, errors);
+    if (isUnknown(targetType))
+        return UNKNOWN_TYPE;
+    const resolved = resolveType(targetType, env);
+    if (resolved.kind !== "named") {
+        errors.push(typeMismatch(expr.id, UNKNOWN_TYPE, targetType)); // expected record type
+        return UNKNOWN_TYPE;
+    }
+    const def = env.lookupTypeDef(resolved.name);
+    if (!def || def.kind !== "record") {
+        errors.push(typeMismatch(expr.id, UNKNOWN_TYPE, targetType)); // expected record type
+        return UNKNOWN_TYPE;
+    }
+    const field = def.fields.find((f) => f.name === expr.field);
+    if (!field) {
+        errors.push(unknownField(expr.id, resolved.name, expr.field, def.fields.map((f) => f.name)));
+        return UNKNOWN_TYPE;
+    }
+    return field.type;
+}
+function inferLambda(expr, env, errors) {
+    const lamEnv = env.child();
+    for (const param of expr.params) {
+        lamEnv.bind(param.name, param.type);
+    }
+    const bodyType = inferExprList(expr.body, lamEnv, errors);
+    return {
+        kind: "fn_type",
+        params: expr.params.map((p) => p.type),
+        effects: [],
+        returnType: bodyType,
+    };
+}
+// =============================================================================
+// Utility functions
+// =============================================================================
+function checkExpectedType(actual, expected, nodeId, env, errors, _hint) {
+    if (isUnknown(actual) || isUnknown(expected))
+        return;
+    if (!typesEqual(actual, expected, env)) {
+        errors.push(typeMismatch(nodeId, expected, actual));
+    }
+}
+function isBool(type) {
+    return type.kind === "basic" && type.name === "Bool";
+}
+function isString(type) {
+    return type.kind === "basic" && type.name === "String";
+}
+function isNumeric(type, env) {
+    const resolved = resolveType(type, env);
+    if (resolved.kind === "basic") {
+        return resolved.name === "Int" || resolved.name === "Float";
+    }
+    if (resolved.kind === "unit_type")
+        return true;
+    return false;
+}
+function inferLiteralPatternType(value) {
+    if (typeof value === "boolean")
+        return BOOL_TYPE;
+    if (typeof value === "string")
+        return STRING_TYPE;
+    if (typeof value === "number") {
+        return Number.isInteger(value) ? INT_TYPE : FLOAT_TYPE;
+    }
+    return UNKNOWN_TYPE;
+}
+/**
+ * Collect known type definition names of a specific kind (for error candidates).
+ */
+function collectTypeDefNames(env, kind) {
+    return env.allTypeDefNames(kind);
+}
+//# sourceMappingURL=check.js.map