kopscript 0.7.2 → 0.9.0

package/dist/checker.js

@@ -221,7 +221,7 @@ export class Checker {
         this.externValues.set(decl.name, T.STRING);
         const resolvedPath = resolve(dirname(this.currentFilePath), decl.path);
         if (!existsSync(resolvedPath)) {
-            this.diagnostics.error(`Cannot find file '${decl.path}' referenced by 'raw string ${decl.name}' (looked for '${resolvedPath}')`, decl.line, decl.col);
+            this.diagnostics.error("KS4001", `Cannot find file '${decl.path}' referenced by 'raw string ${decl.name}' (looked for '${resolvedPath}')`, decl.line, decl.col);
             return;
         }
         this.rawContents.set(decl.name, readFileSync(resolvedPath, "utf-8"));
@@ -272,10 +272,10 @@ export class Checker {
         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);
+                this.diagnostics.error("KS4002", `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);
+                this.diagnostics.error("KS4003", `Duplicate top-level declaration '${name}'`, line, col);
             }
             seen.set(name, true);
         };
@@ -305,11 +305,11 @@ export class Checker {
             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);
+            this.diagnostics.error("KS4004", `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);
+                this.diagnostics.error("KS4005", `Exported class '${decl.name}' implements interface '${ifaceName}', which isn't exported`, decl.line, decl.col);
             }
         }
     }
@@ -321,7 +321,7 @@ export class Checker {
             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);
+                this.diagnostics.error("KS4006", `Exported interface '${decl.name}' extends interface '${baseName}', which isn't exported`, decl.line, decl.col);
             }
         }
     }
@@ -342,10 +342,10 @@ export class Checker {
         if (!resolved) {
             const name = node.kind === "NamedType" ? node.name : "[]";
             if (name !== "[]" && this.genericTypeParams.has(name) && !node.typeArgs) {
-                this.diagnostics.error(`Generic type '${name}' requires a type argument (e.g. '${name}<T>')`, line, col);
+                this.diagnostics.error("KS4007", `Generic type '${name}' requires a type argument (e.g. '${name}<T>')`, line, col);
             }
             else {
-                this.diagnostics.error(`Unknown type '${name}'`, line, col);
+                this.diagnostics.error("KS4008", `Unknown type '${name}'`, line, col);
             }
             return T.UNKNOWN;
         }
@@ -380,10 +380,10 @@ export class Checker {
             case "interface": {
                 const isGeneric = this.genericTypeParams.has(type.name);
                 if (isGeneric && !type.typeArg) {
-                    this.diagnostics.error(`Generic type '${type.name}' requires a type argument (e.g. '${type.name}<T>')`, line, col);
+                    this.diagnostics.error("KS4009", `Generic type '${type.name}' requires a type argument (e.g. '${type.name}<T>')`, line, col);
                 }
                 else if (!isGeneric && type.typeArg) {
-                    this.diagnostics.error(`Type '${type.name}' is not generic — it doesn't take a type argument`, line, col);
+                    this.diagnostics.error("KS4010", `Type '${type.name}' is not generic — it doesn't take a type argument`, line, col);
                 }
                 if (type.typeArg)
                     this.validateGenericArity(type.typeArg, line, col);
@@ -450,7 +450,7 @@ export class Checker {
         const members = new Map();
         decl.members.forEach((name, index) => {
             if (members.has(name)) {
-                this.diagnostics.error(`Duplicate enum member '${name}'`, decl.line, decl.col);
+                this.diagnostics.error("KS4011", `Duplicate enum member '${name}'`, decl.line, decl.col);
                 return;
             }
             members.set(name, index);
@@ -468,14 +468,14 @@ export class Checker {
         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);
+                this.diagnostics.error("KS4012", `Interface '${decl.name}' can only extend other interfaces (unknown interface '${baseName}')`, decl.line, decl.col);
                 continue;
             }
             // v1 generics can't appear in a base list at all — only as a
             // standalone type (field/param/return/local, `new Box<T>()`). A
             // class/interface always implements/extends a *bare* name.
             if (this.genericTypeParams.has(baseName)) {
-                this.diagnostics.error(`Interface '${decl.name}' cannot extend generic interface '${baseName}' — not supported in v1`, decl.line, decl.col);
+                this.diagnostics.error("KS4013", `Interface '${decl.name}' cannot extend generic interface '${baseName}' — not supported in v1`, decl.line, decl.col);
                 continue;
             }
             bases.push(baseName);
@@ -492,7 +492,7 @@ export class Checker {
         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);
+                this.diagnostics.error("KS4014", `Circular interface inheritance detected involving '${decl.name}'`, decl.line, decl.col);
                 return;
             }
             if (seen.has(current))
@@ -563,13 +563,13 @@ export class Checker {
             // standalone type (field/param/return/local, `new Box<T>()`). A
             // class always extends/implements a *bare* name.
             if (this.genericTypeParams.has(baseName)) {
-                this.diagnostics.error(`Class '${decl.name}' cannot extend/implement generic type '${baseName}' — not supported in v1`, decl.line, decl.col);
+                this.diagnostics.error("KS4015", `Class '${decl.name}' cannot extend/implement generic type '${baseName}' — not supported in v1`, decl.line, decl.col);
                 continue;
             }
             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);
+                    this.diagnostics.error("KS4016", `Class '${decl.name}' cannot extend multiple classes ('${superclass}' and '${baseName}')`, decl.line, decl.col);
                 }
                 else {
                     superclass = baseName;
@@ -579,7 +579,7 @@ export class Checker {
                 interfaces.push(baseName);
             }
             else {
-                this.diagnostics.error(`Unknown base class or interface '${baseName}'`, decl.line, decl.col);
+                this.diagnostics.error("KS4017", `Unknown base class or interface '${baseName}'`, decl.line, decl.col);
             }
         }
         this.classes.set(decl.name, {
@@ -602,7 +602,7 @@ export class Checker {
         let current = info.superclass;
         while (current) {
             if (seen.has(current)) {
-                this.diagnostics.error(`Circular inheritance detected involving '${decl.name}'`, decl.line, decl.col);
+                this.diagnostics.error("KS4018", `Circular inheritance detected involving '${decl.name}'`, decl.line, decl.col);
                 return;
             }
             seen.add(current);
@@ -617,11 +617,11 @@ export class Checker {
             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);
+                this.diagnostics.error("KS4019", `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);
+            this.diagnostics.error("KS4020", `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
@@ -644,28 +644,28 @@ export class Checker {
                 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);
+                this.diagnostics.error("KS4021", `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);
+                    this.diagnostics.error("KS4022", `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);
+                    this.diagnostics.error("KS4023", `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);
+                        this.diagnostics.error("KS4024", `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);
+                this.diagnostics.error("KS4025", `Method '${method.name}' marked 'override' but no matching method was found in a base class`, method.line, method.col);
             }
         }
     }
@@ -677,12 +677,12 @@ export class Checker {
             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);
+                    this.diagnostics.error("KS4026", `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);
+                    this.diagnostics.error("KS4027", `Class '${decl.name}' member '${sig.name}' does not match the signature required by interface '${ifaceName}'`, decl.line, decl.col);
                 }
             }
         }
@@ -772,13 +772,13 @@ export class Checker {
             return;
         if (visibility === "private") {
             if (ctx.currentClass?.name !== owner) {
-                this.diagnostics.error(`'${memberName}' is private and not accessible outside class '${owner}'`, line, col);
+                this.diagnostics.error("KS4028", `'${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);
+            this.diagnostics.error("KS4029", `'${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?
@@ -840,13 +840,13 @@ export class Checker {
     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);
+                this.diagnostics.error("KS4030", `'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);
+            this.diagnostics.error("KS4031", `A function/method returning 'task'/'task<T>' must be marked 'async'`, line, col);
         }
         return declaredReturnType;
     }
@@ -886,13 +886,13 @@ export class Checker {
                 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);
+                    this.diagnostics.error("KS4032", `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);
+                        this.diagnostics.error("KS4033", `Base constructor argument ${i + 1} has type '${T.typeToString(argType)}', expected '${T.typeToString(expected)}'`, arg.line, arg.col);
                     }
                 });
             }
@@ -922,7 +922,7 @@ export class Checker {
                 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);
+                this.diagnostics.error("KS4034", `Cannot assign value of type '${T.typeToString(initType)}' to static field of type '${T.typeToString(declaredType)}'`, field.line, field.col);
             }
         }
     }
@@ -939,7 +939,7 @@ export class Checker {
                 this.recordHover(stmt.nameLine, stmt.nameCol, `${stmt.isConst ? "const" : "let"} ${stmt.name}: ${T.typeToString(declaredType)}`);
                 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);
+                    this.diagnostics.error("KS4035", `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;
@@ -994,11 +994,11 @@ export class Checker {
                 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);
+                        this.diagnostics.error("KS4036", `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);
+                    this.diagnostics.error("KS4037", `Cannot iterate over non-array type '${T.typeToString(iterableType)}'`, stmt.line, stmt.col);
                 }
                 const forScope = scope.child();
                 forScope.declare(stmt.varName, declaredVarType, false);
@@ -1008,14 +1008,14 @@ export class Checker {
             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);
+                    this.diagnostics.error("KS4038", `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);
+                    this.diagnostics.error("KS4039", `'${stmt.kind === "BreakStatement" ? "break" : "continue"}' used outside of a loop`, stmt.line, stmt.col);
                 }
                 return;
             case "ExpressionStatement":
@@ -1039,30 +1039,30 @@ export class Checker {
                 this.checkExpression(stmt.expression, scope, ctx);
                 return;
             case "FunctionDecl":
-                this.diagnostics.error(`Nested function declarations are not supported`, stmt.line, stmt.col);
+                this.diagnostics.error("KS4040", `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);
+                this.diagnostics.error("KS4041", `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);
+                this.diagnostics.error("KS4042", `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);
+                this.diagnostics.error("KS4043", `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);
+                this.diagnostics.error("KS4044", `'extern' declarations are only allowed at the top level of a file`, stmt.line, stmt.col);
                 return;
             case "RawStringDecl":
-                this.diagnostics.error(`'raw' declarations are only allowed at the top level of a file`, stmt.line, stmt.col);
+                this.diagnostics.error("KS4045", `'raw' 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);
+            this.diagnostics.error("KS4046", `Expected type '${T.typeToString(expected)}' for ${context}, got '${T.typeToString(actual)}'`, line, col);
         }
     }
     // Recognizes `name != null` / `name == null` (either operand order) as a
@@ -1129,7 +1129,7 @@ export class Checker {
                 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);
+                        this.diagnostics.error("KS4047", `Array elements must all have the same type`, expr.line, expr.col);
                         break;
                     }
                 }
@@ -1156,14 +1156,14 @@ export class Checker {
                 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);
+                this.diagnostics.error("KS4048", `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);
+                this.diagnostics.error("KS4049", `'this' used outside of a class method`, expr.line, expr.col);
                 return T.UNKNOWN;
             }
             case "UnaryExpr": {
@@ -1203,13 +1203,13 @@ export class Checker {
                     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);
+                            this.diagnostics.error("KS4050", `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);
+                    this.diagnostics.error("KS4051", `Cannot assign value of type '${T.typeToString(valueType)}' to target of type '${T.typeToString(targetType)}'`, expr.line, expr.col);
                 }
                 return targetType;
             }
@@ -1226,7 +1226,7 @@ export class Checker {
                 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);
+                    this.diagnostics.error("KS4052", `Cannot index into non-array type '${T.typeToString(objType)}'`, expr.line, expr.col);
                 }
                 return T.UNKNOWN;
             }
@@ -1240,13 +1240,13 @@ export class Checker {
                 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);
+                    this.diagnostics.error("KS4053", `'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);
+                    this.diagnostics.error("KS4054", `Cannot 'await' a value of type '${T.typeToString(operandType)}'`, expr.line, expr.col);
                 }
                 return T.UNKNOWN;
             }
@@ -1268,7 +1268,7 @@ export class Checker {
             return this.checkLambda(expr, expected, scope, ctx);
         if (expr.kind === "NullLiteral") {
             if (expected.kind !== "nullable" && expected.kind !== "unknown") {
-                this.diagnostics.error(`Cannot assign 'null' to non-nullable type '${T.typeToString(expected)}'`, expr.line, expr.col);
+                this.diagnostics.error("KS4055", `Cannot assign 'null' to non-nullable type '${T.typeToString(expected)}'`, expr.line, expr.col);
                 return T.UNKNOWN;
             }
             return expected;
@@ -1278,7 +1278,7 @@ export class Checker {
     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);
+                this.diagnostics.error("KS4056", `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();
@@ -1289,13 +1289,13 @@ export class Checker {
             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);
+            this.diagnostics.error("KS4057", `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);
+                this.diagnostics.error("KS4058", `Lambda parameter '${p.name}' has type '${T.typeToString(declared)}', expected '${T.typeToString(expectedParamType)}'`, expr.line, expr.col);
             }
             return declared;
         });
@@ -1330,7 +1330,7 @@ export class Checker {
         }
         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);
+            this.diagnostics.error("KS4059", `Lambda body has type '${T.typeToString(actual)}', expected '${T.typeToString(expectedReturnType)}'`, expr.line, expr.col);
         }
         return actual;
     }
@@ -1361,12 +1361,12 @@ export class Checker {
             if (nullSide) {
                 const otherType = nullSide === "left" ? rightType : leftType;
                 if (otherType.kind !== "nullable" && otherType.kind !== "unknown") {
-                    this.diagnostics.error(`Type '${T.typeToString(otherType)}' can never be null — only a nullable type (e.g. '${T.typeToString(otherType)}?') can be compared to 'null'`, line, col);
+                    this.diagnostics.error("KS4060", `Type '${T.typeToString(otherType)}' can never be null — only a nullable type (e.g. '${T.typeToString(otherType)}?') can be compared to 'null'`, line, col);
                 }
                 return T.BOOL;
             }
             if (!T.typesEqual(leftType, rightType)) {
-                this.diagnostics.error(`Cannot compare '${T.typeToString(leftType)}' with '${T.typeToString(rightType)}'`, line, col);
+                this.diagnostics.error("KS4061", `Cannot compare '${T.typeToString(leftType)}' with '${T.typeToString(rightType)}'`, line, col);
             }
             return T.BOOL;
         }
@@ -1387,7 +1387,7 @@ export class Checker {
                     expr.args.forEach((a) => this.checkExpression(a, scope, ctx));
                     return T.VOID;
                 }
-                this.diagnostics.error(`Undefined function '${expr.callee.name}'`, expr.line, expr.col);
+                this.diagnostics.error("KS4062", `Undefined function '${expr.callee.name}'`, expr.line, expr.col);
                 expr.args.forEach((a) => this.checkExpression(a, scope, ctx));
                 return T.UNKNOWN;
             }
@@ -1427,43 +1427,43 @@ export class Checker {
             return calleeType.returnType;
         }
         if (calleeType.kind !== "unknown") {
-            this.diagnostics.error(`Cannot call a value of type '${T.typeToString(calleeType)}'`, expr.line, expr.col);
+            this.diagnostics.error("KS4063", `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);
+            this.diagnostics.error("KS4064", `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);
+                this.diagnostics.error("KS4065", `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);
+            this.diagnostics.error("KS4066", `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);
+            this.diagnostics.error("KS4067", `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);
+            this.diagnostics.error("KS4068", `Unknown class '${expr.className}'`, expr.line, expr.col);
             expr.args.forEach((a) => this.checkExpression(a, scope, ctx));
             return T.UNKNOWN;
         }
         let typeArg;
         if (info.typeParam && !expr.typeArgs) {
-            this.diagnostics.error(`Generic class '${expr.className}' requires a type argument (e.g. 'new ${expr.className}<T>(...)')`, expr.line, expr.col);
+            this.diagnostics.error("KS4069", `Generic class '${expr.className}' requires a type argument (e.g. 'new ${expr.className}<T>(...)')`, expr.line, expr.col);
             // Abstractly-typed (T-containing) ctor params, un-substitutable
             // without a real type argument, would otherwise cascade into a
             // confusing "expected 'T'" error on every argument — one clear error
@@ -1472,7 +1472,7 @@ export class Checker {
             return T.UNKNOWN;
         }
         if (!info.typeParam && expr.typeArgs) {
-            this.diagnostics.error(`Class '${expr.className}' is not generic — it doesn't take a type argument`, expr.line, expr.col);
+            this.diagnostics.error("KS4070", `Class '${expr.className}' is not generic — it doesn't take a type argument`, expr.line, expr.col);
             expr.args.forEach((a) => this.checkExpression(a, scope, ctx));
             return T.UNKNOWN;
         }
@@ -1487,13 +1487,13 @@ export class Checker {
             ctorParams = ctorParams.map((p) => this.substituteTypeParam(p, paramName, arg));
         }
         if (expr.args.length !== ctorParams.length) {
-            this.diagnostics.error(`Expected ${ctorParams.length} constructor argument(s), got ${expr.args.length}`, expr.line, expr.col);
+            this.diagnostics.error("KS4071", `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);
+                this.diagnostics.error("KS4072", `Constructor argument ${i + 1} has type '${T.typeToString(argType)}', expected '${T.typeToString(expected)}'`, arg.line, arg.col);
             }
         });
         return T.classType(expr.className, typeArg);
@@ -1538,7 +1538,7 @@ export class Checker {
     // 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);
+            this.diagnostics.error("KS4073", `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);
         }
@@ -1547,12 +1547,12 @@ export class Checker {
         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);
+                this.diagnostics.error("KS4074", `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);
+            this.diagnostics.error("KS4075", `Map callback must take a single '${T.typeToString(elementType)}' parameter, got '${T.typeToString(argType)}'`, arg.line, arg.col);
         }
         return T.arrayOf(argType.returnType);
     }
@@ -1573,7 +1573,7 @@ export class Checker {
                 this.recordHover(expr.object.line, expr.object.col, `enum ${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);
+                    this.diagnostics.error("KS4076", `Enum '${objName}' has no member '${expr.property}'`, expr.line, expr.col);
                     return { type: T.UNKNOWN, methodInfo: null };
                 }
                 return { type: T.enumType(objName), methodInfo: null };
@@ -1590,13 +1590,13 @@ export class Checker {
                     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);
+                this.diagnostics.error("KS4077", `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 === "nullable") {
-            this.diagnostics.error(`Cannot access member '${expr.property}' on possibly-null type '${T.typeToString(objectType)}' — check for null first (e.g. 'if (x != null) { ... }')`, expr.line, expr.col);
+            this.diagnostics.error("KS4078", `Cannot access member '${expr.property}' on possibly-null type '${T.typeToString(objectType)}' — check for null first (e.g. 'if (x != null) { ... }')`, expr.line, expr.col);
             return { type: T.UNKNOWN, methodInfo: null };
         }
         if (objectType.kind === "string") {
@@ -1610,7 +1610,7 @@ export class Checker {
             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);
+            this.diagnostics.error("KS4079", `Unknown string member '${expr.property}'`, expr.line, expr.col);
             return { type: T.UNKNOWN, methodInfo: null };
         }
         if (objectType.kind === "array") {
@@ -1626,7 +1626,7 @@ export class Checker {
             // 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);
+            this.diagnostics.error("KS4080", `Unknown array member '${expr.property}'`, expr.line, expr.col);
             return { type: T.UNKNOWN, methodInfo: null };
         }
         if (objectType.kind === "state") {
@@ -1642,7 +1642,7 @@ export class Checker {
                 };
                 return { type: method.returnType, methodInfo: method };
             }
-            this.diagnostics.error(`Unknown state member '${expr.property}'`, expr.line, expr.col);
+            this.diagnostics.error("KS4081", `Unknown state member '${expr.property}'`, expr.line, expr.col);
             return { type: T.UNKNOWN, methodInfo: null };
         }
         if (objectType.kind === "class") {
@@ -1658,7 +1658,7 @@ export class Checker {
                 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);
+                        this.diagnostics.error("KS4082", `'${expr.property}' has no setter and can only be assigned within ${field.owner}'s constructor`, expr.line, expr.col);
                     }
                 }
                 return { type: substitute(field.info.type), methodInfo: null };
@@ -1669,7 +1669,7 @@ export class Checker {
                 const info = paramName ? { ...method.info, params: method.info.params.map(substitute), returnType: substitute(method.info.returnType) } : method.info;
                 return { type: info.returnType, methodInfo: info };
             }
-            this.diagnostics.error(`Class '${objectType.name}' has no member '${expr.property}'`, expr.line, expr.col);
+            this.diagnostics.error("KS4083", `Class '${objectType.name}' has no member '${expr.property}'`, expr.line, expr.col);
             return { type: T.UNKNOWN, methodInfo: null };
         }
         if (objectType.kind === "interface") {
@@ -1684,11 +1684,11 @@ export class Checker {
                 const returnType = substitute(sig.returnType);
                 return { type: returnType, methodInfo: { params, returnType, visibility: "public", isVirtual: false, isOverride: false } };
             }
-            this.diagnostics.error(`Interface '${objectType.name}' has no member '${expr.property}'`, expr.line, expr.col);
+            this.diagnostics.error("KS4084", `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);
+            this.diagnostics.error("KS4085", `Cannot access member '${expr.property}' on type '${T.typeToString(objectType)}'`, expr.line, expr.col);
         }
         return { type: T.UNKNOWN, methodInfo: null };
     }
@@ -1696,19 +1696,19 @@ export class Checker {
         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);
+            this.diagnostics.error("KS4086", `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);
+            this.diagnostics.error("KS4087", `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);
+                        this.diagnostics.error("KS4088", `match patterns must be string literals`, value.line, value.col);
                     }
                     else {
                         this.checkExpression(value, scope, ctx);
@@ -1721,7 +1721,7 @@ export class Checker {
                 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);
+                this.diagnostics.error("KS4089", `match arm result type '${T.typeToString(armResultType)}' does not match preceding arms' type '${T.typeToString(resultType)}'`, arm.line, arm.col);
             }
         }
         return resultType ?? T.UNKNOWN;