edict-lang 1.2.0 → 1.6.0

package/dist/checker/check.js

@@ -7,22 +7,28 @@ import { typeMismatch, arityMismatch, notAFunction, unknownField, unknownRecord,
 import { findCandidates } from "../resolver/levenshtein.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" };
+import { BUILTIN_FUNCTIONS } from "../builtins/builtins.js";
+import { OPTION_ENUM_DEF, RESULT_ENUM_DEF } from "../builtins/builtin-enums.js";
+import { UNKNOWN_TYPE, INT_TYPE, FLOAT_TYPE, STRING_TYPE, BOOL_TYPE } from "../ast/type-constants.js";
 /**
  * Entry point: type-check a validated + resolved Edict module.
  */
 export function typeCheck(module) {
     const errors = [];
+    const typeInfo = {
+        inferredReturnTypes: new Map(),
+        inferredLetTypes: new Map(),
+        inferredLambdaParamTypes: new Map(),
+    };
     const rootEnv = new TypeEnv();
     // Register built-in function signatures
     for (const [name, builtin] of BUILTIN_FUNCTIONS) {
         rootEnv.bind(name, builtin.type);
     }
+    // Register built-in enum type definitions (Option, Result)
+    // so enum_constructor and match patterns work through typeCheck.
+    rootEnv.registerTypeDef("Option", OPTION_ENUM_DEF);
+    rootEnv.registerTypeDef("Result", RESULT_ENUM_DEF);
     // Register type definitions (records, enums, type aliases)
     for (const def of module.definitions) {
         registerTypeDef(def, rootEnv);
@@ -31,25 +37,26 @@ export function typeCheck(module) {
     for (const def of module.definitions) {
         registerValueDef(def, rootEnv);
     }
-    // Register imports as unknown
+    // Register imports — use declared types when available, fall back to unknown
     for (const imp of module.imports) {
         for (const name of imp.names) {
-            rootEnv.bind(name, UNKNOWN_TYPE);
+            const declaredType = imp.types?.[name];
+            rootEnv.bind(name, declaredType ?? UNKNOWN_TYPE);
         }
     }
     // Type-check each definition
     for (const def of module.definitions) {
         switch (def.kind) {
             case "fn":
-                checkFunction(def, rootEnv, errors);
+                checkFunction(def, rootEnv, errors, typeInfo);
                 break;
             case "const":
-                checkConst(def, rootEnv, errors);
+                checkConst(def, rootEnv, errors, typeInfo);
                 break;
             // record, enum, type — no body to type-check
         }
     }
-    return errors;
+    return { errors, typeInfo };
 }
 // =============================================================================
 // Registration
@@ -68,9 +75,9 @@ function registerValueDef(def, env) {
         case "fn": {
             const fnType = {
                 kind: "fn_type",
-                params: def.params.map((p) => p.type),
+                params: def.params.map((p) => p.type ?? UNKNOWN_TYPE),
                 effects: [...def.effects],
-                returnType: def.returnType,
+                returnType: def.returnType ?? UNKNOWN_TYPE,
             };
             env.bind(def.name, fnType);
             break;
@@ -83,89 +90,96 @@ function registerValueDef(def, env) {
 // =============================================================================
 // Function checking
 // =============================================================================
-function checkFunction(fn, rootEnv, errors) {
+function checkFunction(fn, rootEnv, errors, typeInfo) {
     const fnEnv = rootEnv.child();
     // Bind params
     for (const param of fn.params) {
         fnEnv.bind(param.name, param.type);
     }
-    // Check contracts
+    // Infer body type first (needed when returnType is omitted)
+    const bodyType = inferExprList(fn.body, fnEnv, errors, typeInfo);
+    // Determine effective return type: explicit annotation or inferred from body
+    const hadExplicitReturnType = !!fn.returnType;
+    const effectiveReturnType = fn.returnType ?? bodyType;
+    // Store inferred return type in side-table (no AST mutation)
+    if (!fn.returnType) {
+        typeInfo.inferredReturnTypes.set(fn.id, effectiveReturnType);
+    }
+    // Check contracts (postconditions bind `result` to the effective return type)
     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");
+            postEnv.bind("result", effectiveReturnType);
+            const condType = inferExpr(contract.condition, postEnv, errors, typeInfo);
+            checkExpectedType(condType, BOOL_TYPE, contract.id, fnEnv, errors);
         }
         else {
-            const condType = inferExpr(contract.condition, fnEnv, errors);
-            checkExpectedType(condType, BOOL_TYPE, contract.id, fnEnv, errors, "pre-contract condition must be Bool");
+            const condType = inferExpr(contract.condition, fnEnv, errors, typeInfo);
+            checkExpectedType(condType, BOOL_TYPE, contract.id, fnEnv, errors);
         }
     }
-    // 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");
+    // If returnType was explicit, check body against it
+    if (hadExplicitReturnType && bodyType && !isUnknown(bodyType) && !isUnknown(resolveType(fn.returnType, fnEnv))) {
+        checkExpectedType(bodyType, fn.returnType, fn.id, fnEnv, errors);
     }
 }
-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");
+function checkConst(def, env, errors, typeInfo) {
+    const valType = inferExpr(def.value, env, errors, typeInfo);
+    checkExpectedType(valType, def.type, def.id, env, errors);
 }
 // =============================================================================
 // Type inference
 // =============================================================================
-function inferExprList(exprs, env, errors) {
+function inferExprList(exprs, env, errors, typeInfo) {
     if (exprs.length === 0)
         return UNKNOWN_TYPE;
     let currentEnv = env;
     let lastType = UNKNOWN_TYPE;
     for (const expr of exprs) {
-        lastType = inferExpr(expr, currentEnv, errors);
+        lastType = inferExpr(expr, currentEnv, errors, typeInfo);
         if (expr.kind === "let") {
             currentEnv = currentEnv.child();
-            // Bind the let name in child env
-            const bindType = expr.type ?? lastType;
+            // Bind the let name in child env, using inferred type from side-table if needed
+            const bindType = expr.type ?? typeInfo.inferredLetTypes.get(expr.id) ?? lastType;
             currentEnv.bind(expr.name, bindType);
         }
     }
     return lastType;
 }
-function inferExpr(expr, env, errors) {
+function inferExpr(expr, env, errors, typeInfo) {
     switch (expr.kind) {
         case "literal":
             return inferLiteral(expr);
         case "ident":
             return env.getType(expr.name) ?? UNKNOWN_TYPE;
         case "binop":
-            return inferBinop(expr, env, errors);
+            return inferBinop(expr, env, errors, typeInfo);
         case "unop":
-            return inferUnop(expr, env, errors);
+            return inferUnop(expr, env, errors, typeInfo);
         case "call":
-            return inferCall(expr, env, errors);
+            return inferCall(expr, env, errors, typeInfo);
         case "if":
-            return inferIf(expr, env, errors);
+            return inferIf(expr, env, errors, typeInfo);
         case "let":
-            return inferLet(expr, env, errors);
+            return inferLet(expr, env, errors, typeInfo);
         case "match":
-            return inferMatch(expr, env, errors);
+            return inferMatch(expr, env, errors, typeInfo);
         case "array":
-            return inferArray(expr, env, errors);
+            return inferArray(expr, env, errors, typeInfo);
         case "tuple_expr":
-            return inferTuple(expr, env, errors);
+            return inferTuple(expr, env, errors, typeInfo);
         case "record_expr":
-            return inferRecordExpr(expr, env, errors);
+            return inferRecordExpr(expr, env, errors, typeInfo);
         case "enum_constructor":
-            return inferEnumConstructor(expr, env, errors);
+            return inferEnumConstructor(expr, env, errors, typeInfo);
         case "access":
-            return inferAccess(expr, env, errors);
+            return inferAccess(expr, env, errors, typeInfo);
         case "lambda":
-            return inferLambda(expr, env, errors);
+            return inferLambda(expr, env, errors, typeInfo);
         case "block":
-            return inferExprList(expr.body, env.child(), errors);
+            return inferExprList(expr.body, env.child(), errors, typeInfo);
         case "string_interp":
-            return inferStringInterp(expr, env, errors);
+            return inferStringInterp(expr, env, errors, typeInfo);
     }
 }
 // =============================================================================
@@ -184,9 +198,9 @@ function inferLiteral(expr) {
     }
     return UNKNOWN_TYPE;
 }
-function inferBinop(expr, env, errors) {
-    const leftType = inferExpr(expr.left, env, errors);
-    const rightType = inferExpr(expr.right, env, errors);
+function inferBinop(expr, env, errors, typeInfo) {
+    const leftType = inferExpr(expr.left, env, errors, typeInfo);
+    const rightType = inferExpr(expr.right, env, errors, typeInfo);
     // unknown propagation
     if (isUnknown(leftType) || isUnknown(rightType))
         return UNKNOWN_TYPE;
@@ -234,8 +248,8 @@ function inferBinop(expr, env, errors) {
     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);
+function inferUnop(expr, env, errors, typeInfo) {
+    const operandType = inferExpr(expr.operand, env, errors, typeInfo);
     if (isUnknown(operandType))
         return UNKNOWN_TYPE;
     if (expr.op === "not") {
@@ -251,12 +265,12 @@ function inferUnop(expr, env, errors) {
     }
     return operandType;
 }
-function inferCall(expr, env, errors) {
-    const fnType = inferExpr(expr.fn, env, errors);
+function inferCall(expr, env, errors, typeInfo) {
+    const fnType = inferExpr(expr.fn, env, errors, typeInfo);
     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);
+            inferExpr(arg, env, errors, typeInfo);
         return UNKNOWN_TYPE;
     }
     const resolved = resolveType(fnType, env);
@@ -264,7 +278,7 @@ function inferCall(expr, env, errors) {
         errors.push(notAFunction(expr.id, fnType));
         // Still infer arg types for error propagation
         for (const arg of expr.args)
-            inferExpr(arg, env, errors);
+            inferExpr(arg, env, errors, typeInfo);
         return UNKNOWN_TYPE;
     }
     // Check arity
@@ -274,21 +288,27 @@ function inferCall(expr, env, errors) {
     // 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}`);
+        const arg = expr.args[i];
+        const expectedParamType = resolved.params[i];
+        // If arg is a lambda and expected param is fn_type, propagate param types
+        const resolvedExpected = resolveType(expectedParamType, env);
+        const argType = (arg.kind === "lambda" && resolvedExpected.kind === "fn_type")
+            ? inferLambdaWithContext(arg, resolvedExpected, env, errors, typeInfo)
+            : inferExpr(arg, env, errors, typeInfo);
+        checkExpectedType(argType, expectedParamType, arg.id, env, errors);
     }
     // Infer remaining surplus args
     for (let i = checkCount; i < expr.args.length; i++) {
-        inferExpr(expr.args[i], env, errors);
+        inferExpr(expr.args[i], env, errors, typeInfo);
     }
     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);
+function inferIf(expr, env, errors, typeInfo) {
+    const condType = inferExpr(expr.condition, env, errors, typeInfo);
+    checkExpectedType(condType, BOOL_TYPE, expr.id, env, errors);
+    const thenType = inferExprList(expr.then, env.child(), errors, typeInfo);
     if (expr.else) {
-        const elseType = inferExprList(expr.else, env.child(), errors);
+        const elseType = inferExprList(expr.else, env.child(), errors, typeInfo);
         if (!isUnknown(thenType) && !isUnknown(elseType)) {
             if (!typesEqual(thenType, elseType, env)) {
                 errors.push(typeMismatch(expr.id, thenType, elseType));
@@ -299,21 +319,25 @@ function inferIf(expr, env, errors) {
     // No else → Option<thenType>
     return { kind: "option", inner: thenType };
 }
-function inferLet(expr, env, errors) {
-    const valType = inferExpr(expr.value, env, errors);
+function inferLet(expr, env, errors, typeInfo) {
+    const valType = inferExpr(expr.value, env, errors, typeInfo);
     if (expr.type) {
-        checkExpectedType(valType, expr.type, expr.id, env, errors, "let value must match type annotation");
+        checkExpectedType(valType, expr.type, expr.id, env, errors);
         return expr.type;
     }
+    // Store inferred type in side-table (no AST mutation)
+    if (!isUnknown(valType)) {
+        typeInfo.inferredLetTypes.set(expr.id, valType);
+    }
     return valType;
 }
-function inferMatch(expr, env, errors) {
-    const targetType = inferExpr(expr.target, env, errors);
+function inferMatch(expr, env, errors, typeInfo) {
+    const targetType = inferExpr(expr.target, env, errors, typeInfo);
     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);
+        const bodyType = inferExprList(arm.body, armEnv, errors, typeInfo);
         if (resultType === null) {
             resultType = bodyType;
         }
@@ -382,13 +406,13 @@ function inferPattern(pattern, targetType, armEnv, rootEnv, errors) {
         }
     }
 }
-function inferArray(expr, env, errors) {
+function inferArray(expr, env, errors, typeInfo) {
     if (expr.elements.length === 0) {
         return { kind: "array", element: UNKNOWN_TYPE };
     }
-    const firstType = inferExpr(expr.elements[0], env, errors);
+    const firstType = inferExpr(expr.elements[0], env, errors, typeInfo);
     for (let i = 1; i < expr.elements.length; i++) {
-        const elType = inferExpr(expr.elements[i], env, errors);
+        const elType = inferExpr(expr.elements[i], env, errors, typeInfo);
         if (!isUnknown(firstType) && !isUnknown(elType)) {
             if (!typesEqual(firstType, elType, env)) {
                 errors.push(typeMismatch(expr.elements[i].id, firstType, elType));
@@ -397,31 +421,31 @@ function inferArray(expr, env, errors) {
     }
     return { kind: "array", element: firstType };
 }
-function inferTuple(expr, env, errors) {
-    const elementTypes = expr.elements.map((el) => inferExpr(el, env, errors));
+function inferTuple(expr, env, errors, typeInfo) {
+    const elementTypes = expr.elements.map((el) => inferExpr(el, env, errors, typeInfo));
     return { kind: "tuple", elements: elementTypes };
 }
-function inferRecordExpr(expr, env, errors) {
+function inferRecordExpr(expr, env, errors, typeInfo) {
     const def = env.lookupTypeDef(expr.name);
     if (!def) {
-        const cands = collectTypeDefNames(env, "record");
+        const cands = env.allTypeDefNames("record");
         const suggestion = cands.length > 0
             ? { nodeId: expr.id, field: "name", value: findCandidates(expr.name, cands)[0] ?? cands[0] }
             : undefined;
         errors.push(unknownRecord(expr.id, expr.name, cands, suggestion));
         // Still infer field value types
         for (const f of expr.fields)
-            inferExpr(f.value, env, errors);
+            inferExpr(f.value, env, errors, typeInfo);
         return UNKNOWN_TYPE;
     }
     if (def.kind !== "record") {
-        const cands = collectTypeDefNames(env, "record");
+        const cands = env.allTypeDefNames("record");
         const suggestion = cands.length > 0
             ? { nodeId: expr.id, field: "name", value: findCandidates(expr.name, cands)[0] ?? cands[0] }
             : undefined;
         errors.push(unknownRecord(expr.id, expr.name, cands, suggestion));
         for (const f of expr.fields)
-            inferExpr(f.value, env, errors);
+            inferExpr(f.value, env, errors, typeInfo);
         return UNKNOWN_TYPE;
     }
     const recordDef = def;
@@ -444,34 +468,34 @@ function inferRecordExpr(expr, env, errors) {
                 ? { nodeId: expr.id, field: "field", value: cands[0] }
                 : undefined;
             errors.push(unknownField(expr.id, expr.name, fieldInit.name, availFields, suggestion));
-            inferExpr(fieldInit.value, env, errors);
+            inferExpr(fieldInit.value, env, errors, typeInfo);
             continue;
         }
-        const valType = inferExpr(fieldInit.value, env, errors);
-        checkExpectedType(valType, fieldDef.type, expr.id, env, errors, `field '${fieldInit.name}'`);
+        const valType = inferExpr(fieldInit.value, env, errors, typeInfo);
+        checkExpectedType(valType, fieldDef.type, expr.id, env, errors);
     }
     return { kind: "named", name: expr.name };
 }
-function inferEnumConstructor(expr, env, errors) {
+function inferEnumConstructor(expr, env, errors, typeInfo) {
     const def = env.lookupTypeDef(expr.enumName);
     if (!def) {
-        const cands = collectTypeDefNames(env, "enum");
+        const cands = env.allTypeDefNames("enum");
         const suggestion = cands.length > 0
             ? { nodeId: expr.id, field: "enumName", value: findCandidates(expr.enumName, cands)[0] ?? cands[0] }
             : undefined;
         errors.push(unknownEnum(expr.id, expr.enumName, cands, suggestion));
         for (const f of expr.fields)
-            inferExpr(f.value, env, errors);
+            inferExpr(f.value, env, errors, typeInfo);
         return UNKNOWN_TYPE;
     }
     if (def.kind !== "enum") {
-        const cands = collectTypeDefNames(env, "enum");
+        const cands = env.allTypeDefNames("enum");
         const suggestion = cands.length > 0
             ? { nodeId: expr.id, field: "enumName", value: findCandidates(expr.enumName, cands)[0] ?? cands[0] }
             : undefined;
         errors.push(unknownEnum(expr.id, expr.enumName, cands, suggestion));
         for (const f of expr.fields)
-            inferExpr(f.value, env, errors);
+            inferExpr(f.value, env, errors, typeInfo);
         return UNKNOWN_TYPE;
     }
     const enumDef = def;
@@ -484,7 +508,7 @@ function inferEnumConstructor(expr, env, errors) {
             : (availVariants.length > 0 ? { nodeId: expr.id, field: "variant", value: availVariants[0] } : undefined);
         errors.push(unknownVariant(expr.id, expr.enumName, expr.variant, availVariants, suggestion));
         for (const f of expr.fields)
-            inferExpr(f.value, env, errors);
+            inferExpr(f.value, env, errors, typeInfo);
         return UNKNOWN_TYPE;
     }
     // Check field count and types
@@ -497,16 +521,16 @@ function inferEnumConstructor(expr, env, errors) {
                 ? { nodeId: expr.id, field: "field", value: cands[0] }
                 : undefined;
             errors.push(unknownField(expr.id, `${expr.enumName}.${expr.variant}`, fieldInit.name, availFields, suggestion));
-            inferExpr(fieldInit.value, env, errors);
+            inferExpr(fieldInit.value, env, errors, typeInfo);
             continue;
         }
-        const valType = inferExpr(fieldInit.value, env, errors);
-        checkExpectedType(valType, fieldDef.type, expr.id, env, errors, `field '${fieldInit.name}'`);
+        const valType = inferExpr(fieldInit.value, env, errors, typeInfo);
+        checkExpectedType(valType, fieldDef.type, expr.id, env, errors);
     }
     return { kind: "named", name: expr.enumName };
 }
-function inferAccess(expr, env, errors) {
-    const targetType = inferExpr(expr.target, env, errors);
+function inferAccess(expr, env, errors, typeInfo) {
+    const targetType = inferExpr(expr.target, env, errors, typeInfo);
     if (isUnknown(targetType))
         return UNKNOWN_TYPE;
     const resolved = resolveType(targetType, env);
@@ -531,22 +555,53 @@ function inferAccess(expr, env, errors) {
     }
     return field.type;
 }
-function inferLambda(expr, env, errors) {
+function inferLambda(expr, env, errors, typeInfo) {
     const lamEnv = env.child();
     for (const param of expr.params) {
-        lamEnv.bind(param.name, param.type);
+        lamEnv.bind(param.name, param.type ?? UNKNOWN_TYPE);
+    }
+    const bodyType = inferExprList(expr.body, lamEnv, errors, typeInfo);
+    return {
+        kind: "fn_type",
+        params: expr.params.map((p) => p.type ?? UNKNOWN_TYPE),
+        effects: [],
+        returnType: bodyType,
+    };
+}
+/**
+ * Infer lambda type with expected fn_type context from a call site.
+ * Propagates param types from the expected signature to untyped lambda params.
+ */
+function inferLambdaWithContext(expr, expectedType, env, errors, typeInfo) {
+    const lamEnv = env.child();
+    for (let i = 0; i < expr.params.length; i++) {
+        const param = expr.params[i];
+        if (param.type) {
+            // Explicit type — use it
+            lamEnv.bind(param.name, param.type);
+        }
+        else if (i < expectedType.params.length) {
+            // Infer from expected fn_type
+            const inferred = expectedType.params[i];
+            // Store inferred type in side-table (no AST mutation)
+            typeInfo.inferredLambdaParamTypes.set(param.id, inferred);
+            lamEnv.bind(param.name, inferred);
+        }
+        else {
+            lamEnv.bind(param.name, UNKNOWN_TYPE);
+        }
     }
-    const bodyType = inferExprList(expr.body, lamEnv, errors);
+    const bodyType = inferExprList(expr.body, lamEnv, errors, typeInfo);
     return {
         kind: "fn_type",
-        params: expr.params.map((p) => p.type),
+        params: expr.params.map((p) => p.type ?? typeInfo.inferredLambdaParamTypes.get(p.id) ?? UNKNOWN_TYPE),
         effects: [],
         returnType: bodyType,
     };
 }
-function inferStringInterp(expr, env, errors) {
+function inferStringInterp(expr, env, errors, typeInfo) {
     for (const part of expr.parts) {
-        const partType = inferExpr(part, env, errors);
+        const partType = inferExpr(part, env, errors, typeInfo);
         checkExpectedType(partType, STRING_TYPE, part.id, env, errors);
     }
     return STRING_TYPE;
@@ -554,7 +609,7 @@ function inferStringInterp(expr, env, errors) {
 // =============================================================================
 // Utility functions
 // =============================================================================
-function checkExpectedType(actual, expected, nodeId, env, errors, _hint) {
+function checkExpectedType(actual, expected, nodeId, env, errors) {
     if (isUnknown(actual) || isUnknown(expected))
         return;
     if (!typesEqual(actual, expected, env)) {
@@ -573,7 +628,7 @@ function isString(type) {
 function isNumeric(type, env) {
     const resolved = resolveType(type, env);
     if (resolved.kind === "basic") {
-        return resolved.name === "Int" || resolved.name === "Float";
+        return resolved.name === "Int" || resolved.name === "Int64" || resolved.name === "Float";
     }
     if (resolved.kind === "unit_type")
         return true;
@@ -589,10 +644,4 @@ function inferLiteralPatternType(value) {
     }
     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