@thigasdevelopment/luam 0.17.0 → 0.18.0

package/luam.mjs

@@ -4515,6 +4515,10 @@ function parseDecorators(stream) {
       skipDecoratorArguments(stream);
     }
   }
+  const last = decorators[decorators.length - 1];
+  if (last !== void 0 && !stream.isEof() && stream.current().position.line === last.position.line) {
+    stream.report("parse-decorator-line", `Expected a line break after "@${last.name}".`, stream.current().position);
+  }
   return decorators;
 }
 function parseClassMethod(stream, token, decorators) {
@@ -4653,7 +4657,7 @@ function parseInterfaceDeclaration(stream) {
   stream.eraseFrom(checkpoint, "declaration");
   return declaration;
 }
-function parseEnumDeclaration(stream) {
+function parseEnumDeclaration(stream, isLocal = false) {
   const position2 = stream.next().position;
   const name = stream.expect("identifier").value;
   const members = [];
@@ -4666,7 +4670,7 @@ function parseEnumDeclaration(stream) {
     }
   }
   stream.expect("punctuation", "}");
-  return { kind: "enum-declaration", name, members, position: position2 };
+  return { kind: "enum-declaration", name, isLocal, members, position: position2 };
 }
 function parseDeclaration(stream) {
   const decorators = parseDecorators(stream);
@@ -4829,7 +4833,10 @@ function parseKeywordStatement(stream, value) {
   const token = stream.current();
   if (value === "local") {
     stream.next();
-    return stream.check("keyword", "function") ? parseFunctionDeclaration(stream, true) : parseLocalStatement(stream, token.position);
+    if (stream.check("keyword", "function")) {
+      return parseFunctionDeclaration(stream, true);
+    }
+    return stream.check("keyword", "enum") ? parseEnumDeclaration(stream, true) : parseLocalStatement(stream, token.position);
   }
   if (value === "function") {
     return parseFunctionDeclaration(stream, false);
@@ -5558,7 +5565,7 @@ var MANIFEST_FIELDS = [
   field("author", OPTIONAL_STRING, "Author written to the generated meta.xml.", { owner: "identity" }),
   field("version", OPTIONAL_STRING, "Version written to the generated meta.xml.", { owner: "identity" }),
   field("description", OPTIONAL_STRING, "Description written to the generated meta.xml.", { owner: "identity" }),
-  table("compilerOptions", "Settings that change how the source is checked and emitted.", COMPILER_OPTION_FIELDS, { defaultValue: {}, owner: "compiler" }),
+  table("compiler", "Settings that change how the source is checked and emitted.", COMPILER_OPTION_FIELDS, { defaultValue: {}, owner: "compiler" }),
   table("sources", "Paths and patterns that make up the project, grouped by the side each file runs on.", SOURCE_FIELDS, {
     defaultValue: {},
     owner: "sources"
@@ -5603,7 +5610,8 @@ var MANIFEST_FIELDS = [
 var MANIFEST_RECORD = recordType("Manifest", MANIFEST_FIELDS);
 var ENV_MEMBER_TYPE = OPTIONAL_STRING;
 var REMOVED_FIELDS = {
-  oop: 'Move it to "compilerOptions = { oop = true }".',
+  oop: 'Move it to "compiler = { oop = true }".',
+  compilerOptions: 'Rename it to "compiler = { ... }".',
   sourceDirs: 'Replace it with "sources = { server = { ... }, client = { ... }, shared = { ... } }", listing paths or patterns per side.',
   assetDirs: `Replace it with "assets = { { from = 'assets/**/*', to = 'assets' } }", naming a destination for each entry.`,
   mta: `Replace it with "engine = { minVersion = '1.6.0' }".`,
@@ -6411,7 +6419,7 @@ function flag(source, name, fallback) {
   return readBoolean(source, name) ?? fallback;
 }
 function readCompilerOptions(value) {
-  const source = readTable(value, "compilerOptions") ?? EMPTY;
+  const source = readTable(value, "compiler") ?? EMPTY;
   return {
     strict: flag(source, "strict", DEFAULT_COMPILER_OPTIONS.strict),
     oop: flag(source, "oop", DEFAULT_COMPILER_OPTIONS.oop),
@@ -6576,7 +6584,7 @@ import { tmpdir } from "node:os";
 import { join as join2 } from "node:path";
 
 // src/cli/version.ts
-var VERSION = true ? "0.17.0" : "0.0.0-dev";
+var VERSION = true ? "0.18.0" : "0.0.0-dev";
 var PROGRAM_NAME = "luam";
 var PROGRAM_DESCRIPTION = "luam \u2014 the Luam compiler for Multi Theft Auto resources.";
 
@@ -8119,7 +8127,7 @@ function ambientFromRegistry(registry) {
   return {
     classes: registry.allClasses(),
     interfaces: registry.allInterfaces(),
-    enums: registry.allEnums(),
+    enums: registry.allEnums().filter((info) => info.isLocal !== true),
     globals: registry.allGlobals(),
     events: registry.allEvents()
   };
@@ -13425,8 +13433,10 @@ var CheckContext = class {
   returnStack = [];
   methodStack = [];
   projectEnvironments = /* @__PURE__ */ new Map();
+  predeclared = /* @__PURE__ */ new Map();
   ambientClasses = /* @__PURE__ */ new Set();
   ambientInterfaces = /* @__PURE__ */ new Set();
+  ambientEnums = /* @__PURE__ */ new Set();
   constructor(mode, environment, ambient = EMPTY_AMBIENT, project = EMPTY_PROJECT_DECLARATIONS, oop = false) {
     this.mode = mode;
     this.environment = environment;
@@ -13465,12 +13475,41 @@ var CheckContext = class {
     }
     return null;
   }
+  predeclareClass(info) {
+    this.predeclared.set(info.name, info);
+  }
+  takePredeclaredClass(name) {
+    const info = this.predeclared.get(name) ?? null;
+    this.predeclared.delete(name);
+    return info;
+  }
+  isPredeclaredClass(name) {
+    return this.predeclared.has(name);
+  }
+  awaitsDeclaration(name) {
+    const seen = /* @__PURE__ */ new Set();
+    let current = this.declarations.lookupClass(name);
+    while (current !== null && !seen.has(current.name)) {
+      if (this.predeclared.has(current.name)) {
+        return true;
+      }
+      seen.add(current.name);
+      current = current.superClass === null ? null : this.declarations.lookupClass(current.superClass);
+    }
+    return false;
+  }
+  insideFunction() {
+    return this.returnStack.length > 0;
+  }
   isAmbientClass(name) {
     return this.ambientClasses.has(name);
   }
   isAmbientInterface(name) {
     return this.ambientInterfaces.has(name);
   }
+  isAmbientEnum(name) {
+    return this.ambientEnums.has(name);
+  }
   noteExternalReference(name, position2) {
     if (!this.externalReferences.has(name)) {
       this.externalReferences.set(name, position2);
@@ -13623,6 +13662,7 @@ var CheckContext = class {
       this.declarations.declareInterface(info);
     }
     for (const info of ambient.enums) {
+      this.ambientEnums.add(info.name);
       this.declarations.declareEnum(info);
       this.binder.declareGlobal({ name: info.name, type: createNamed(info.name), isLocal: false, position: info.position });
     }
@@ -13929,23 +13969,168 @@ function accessorNames(fieldName, isBoolean) {
   };
 }
 
-// ../compiler/src/checker/decorators.ts
+// ../compiler/src/checker/decorator-catalog.ts
+var CONFLICT = "`check-decorator-conflict` when a generated name is already declared by a hand-written member.";
+var SPREAD = "On a class it applies to every field of that class; on a field it applies to that field alone.";
+var NOTHING = "Nothing. The emitted Lua is unchanged; the decorator only makes the checker validate how the class is used.";
 var KNOWN_DECORATORS = /* @__PURE__ */ new Map([
-  ["Getter", { name: "Getter", documentation: "Generates a typed getter for each decorated field." }],
-  ["Setter", { name: "Setter", documentation: "Generates a typed setter for each decorated field." }],
-  ["FluentSetter", { name: "FluentSetter", documentation: "Generates a setter that returns self." }],
-  ["ToString", { name: "ToString", documentation: "Generates a shallow string representation." }],
-  ["Equals", { name: "Equals", documentation: "Generates shallow field equality." }],
-  ["Clone", { name: "Clone", documentation: "Generates a shallow clone." }],
-  ["Serializable", { name: "Serializable", documentation: "Generates toTable()." }],
-  ["Deserialize", { name: "Deserialize", documentation: "Generates fromTable(values)." }],
-  ["Lazy", { name: "Lazy", documentation: "Generates a caching getter for an initialized field." }],
-  ["Observable", { name: "Observable", documentation: "Generates a notifying setter and listener registration." }],
-  ["ReadOnly", { name: "ReadOnly", documentation: "Prevents writes outside methods of the declaring class." }],
-  ["Deprecated", { name: "Deprecated", documentation: "Reports a warning when the decorated member is used." }],
-  ["Override", { name: "Override", documentation: "Requires a matching superclass method." }],
-  ["Builder", { name: "Builder", documentation: "Generates a companion builder class." }]
+  [
+    "Getter",
+    {
+      name: "Getter",
+      documentation: "Generates a typed getter for each decorated field.",
+      targets: ["class", "field"],
+      generates: ["`getField(): FieldType`, returning the field unchanged.", "A boolean field uses `isField()`, and a boolean already named `isReady` keeps `isReady()` instead of `isIsReady()`."],
+      rules: [SPREAD, "The accessor is an ordinary member: completion after `:` lists it, and go-to-definition lands on the field that generated it."],
+      diagnostics: [CONFLICT]
+    }
+  ],
+  [
+    "Setter",
+    {
+      name: "Setter",
+      documentation: "Generates a typed setter for each decorated field.",
+      targets: ["class", "field"],
+      generates: ["`setField(value: FieldType): void`, assigning the field.", "A boolean field named `isReady` becomes `setReady(value)`."],
+      rules: [SPREAD, "The parameter is typed from the field, so a wrong argument is `check-type-mismatch`, exactly as for a hand-written method."],
+      diagnostics: [CONFLICT]
+    }
+  ],
+  [
+    "FluentSetter",
+    {
+      name: "FluentSetter",
+      documentation: "Generates a chainable setter that returns the same instance.",
+      targets: ["field"],
+      generates: ["`withField(value: FieldType): OwnerClass`, assigning the field and returning `self`."],
+      rules: ["The returned value is the same instance, never a copy, so calls chain: `session:withTimeout(60):withTimeout(90)`.", "It does not replace `@Setter`; declare both when `setField` is wanted as well."],
+      diagnostics: [CONFLICT]
+    }
+  ],
+  [
+    "ToString",
+    {
+      name: "ToString",
+      documentation: "Generates a shallow string representation.",
+      targets: ["class"],
+      generates: ["`toString(): string`, formatted as `ClassName{field=value, field=value}`."],
+      rules: ["Every field of the class is included, in declaration order, through `tostring`.", "It is shallow: a table field is rendered as its `tostring` address, not as its contents."],
+      diagnostics: [CONFLICT]
+    }
+  ],
+  [
+    "Equals",
+    {
+      name: "Equals",
+      documentation: "Generates shallow field equality.",
+      targets: ["class"],
+      generates: ["`equals(other: OwnerClass): boolean`, comparing every field with `==`."],
+      rules: ["It is shallow: two tables with the same contents are equal only when they are the same table.", "It does not overload the Lua `==` operator; call `equals` explicitly."],
+      diagnostics: [CONFLICT]
+    }
+  ],
+  [
+    "Clone",
+    {
+      name: "Clone",
+      documentation: "Generates a shallow clone.",
+      targets: ["class"],
+      generates: ["`clone(): OwnerClass`, a new instance carrying the same field values."],
+      rules: ["The copy is built with `new OwnerClass()` and no constructor arguments, then every field is assigned.", "It is shallow: a table stored in a field is the same table in the clone."],
+      diagnostics: [CONFLICT]
+    }
+  ],
+  [
+    "Serializable",
+    {
+      name: "Serializable",
+      documentation: "Generates a plain-table view of the fields.",
+      targets: ["class"],
+      generates: ["`toTable(): table`, a plain table keyed by field name."],
+      rules: ["It is shallow: a table stored in a field is the same table in the result.", "It pairs with `@Deserialize` for a round trip."],
+      diagnostics: [CONFLICT]
+    }
+  ],
+  [
+    "Deserialize",
+    {
+      name: "Deserialize",
+      documentation: "Generates field assignment from a plain table.",
+      targets: ["class"],
+      generates: ["`fromTable(values: table): void`, assigning the fields of the current instance."],
+      rules: ["It assigns onto the existing instance and returns nothing.", "Every field is assigned, so a key missing from `values` sets that field to `nil`."],
+      diagnostics: [CONFLICT]
+    }
+  ],
+  [
+    "Lazy",
+    {
+      name: "Lazy",
+      documentation: "Generates a caching getter for an initialized field.",
+      targets: ["field"],
+      generates: ["`getField(): FieldType`, running the initializer on first access and reusing the result afterwards."],
+      rules: ["The initializer is not emitted as an initial class value; the getter runs it while the field is still `nil`.", "Naming follows `@Getter`, so a boolean field yields `isField()`."],
+      diagnostics: ["`check-lazy-initializer` when the decorated field has no initializer.", CONFLICT]
+    }
+  ],
+  [
+    "Observable",
+    {
+      name: "Observable",
+      documentation: "Generates a notifying setter and listener registration.",
+      targets: ["field"],
+      generates: ["`setField(value: FieldType): void`, assigning the field and then calling every listener with the new value.", "`onFieldChanged(listener): void`, appending a listener."],
+      rules: ["Listeners live on the instance and run in registration order.", "Only the generated setter notifies; assigning `instance.field = value` directly does not."],
+      diagnostics: [CONFLICT]
+    }
+  ],
+  [
+    "ReadOnly",
+    {
+      name: "ReadOnly",
+      documentation: "Prevents writes outside methods of the declaring class.",
+      targets: ["field"],
+      generates: [NOTHING],
+      rules: ["Reads are always allowed.", "Methods of the declaring class may assign the field; every other place may not."],
+      diagnostics: ["`check-readonly-assignment` on an assignment outside the declaring class."]
+    }
+  ],
+  [
+    "Deprecated",
+    {
+      name: "Deprecated",
+      documentation: "Reports a warning when the decorated member is used.",
+      targets: ["field", "method"],
+      generates: [NOTHING],
+      rules: ["The report lands on every use site, not on the declaration.", "It is a warning, so it never blocks the build."],
+      diagnostics: ["`check-deprecated-use` at every read or call of the member."]
+    }
+  ],
+  [
+    "Override",
+    {
+      name: "Override",
+      documentation: "Requires a matching superclass method.",
+      targets: ["method"],
+      generates: [NOTHING],
+      rules: ["The class must declare a parent with `extends`, and that parent must declare the method with an identical signature.", "It does not change dispatch; call the parent implementation with `super(...)`."],
+      diagnostics: ["`check-invalid-override` when the superclass has no such method or the signature differs."]
+    }
+  ],
+  [
+    "Builder",
+    {
+      name: "Builder",
+      documentation: "Generates a companion builder class.",
+      targets: ["class"],
+      generates: ["`OwnerClassBuilder`, a separate class declared beside the decorated one.", "`withField(value: FieldType): OwnerClassBuilder` for every field, and `build(): OwnerClass`."],
+      rules: ["The builder adds no member to the decorated class; construct it with `new OwnerClassBuilder()`.", "`build()` calls `new OwnerClass()` with no constructor arguments, then assigns the collected fields."],
+      diagnostics: [CONFLICT]
+    }
+  ]
 ]);
+
+// ../compiler/src/checker/decorators.ts
 function memberExpression(field2) {
   return {
     kind: "member-expression",
@@ -13988,7 +14173,8 @@ function validateDecorators(context, decorators, target) {
   const valid = [];
   const seen = /* @__PURE__ */ new Set();
   for (const decorator of decorators) {
-    if (!KNOWN_DECORATORS.has(decorator.name)) {
+    const definition = KNOWN_DECORATORS.get(decorator.name);
+    if (definition === void 0) {
       context.report("check-unknown-decorator", `Unknown decorator "@${decorator.name}".`, decorator.position);
       continue;
     }
@@ -13997,13 +14183,7 @@ function validateDecorators(context, decorators, target) {
       continue;
     }
     seen.add(decorator.name);
-    const classOnly = /* @__PURE__ */ new Set(["ToString", "Equals", "Clone", "Serializable", "Deserialize", "Builder"]);
-    const methodOnly = /* @__PURE__ */ new Set(["Override"]);
-    const memberOnly = /* @__PURE__ */ new Set(["Deprecated"]);
-    const classAllowed = /* @__PURE__ */ new Set(["Getter", "Setter", ...classOnly]);
-    const fieldAllowed = /* @__PURE__ */ new Set(["Getter", "Setter", "FluentSetter", "Lazy", "Observable", "ReadOnly", ...memberOnly]);
-    const methodAllowed = /* @__PURE__ */ new Set([...methodOnly, ...memberOnly]);
-    if (target === "class" && !classAllowed.has(decorator.name) || target === "field" && !fieldAllowed.has(decorator.name) || target === "method" && !methodAllowed.has(decorator.name)) {
+    if (!definition.targets.includes(target)) {
       context.report("check-decorator-target", `Decorator "@${decorator.name}" is not valid on this ${target}.`, decorator.position);
       continue;
     }
@@ -17469,7 +17649,7 @@ function isElementType(name) {
 }
 
 // ../compiler/src/checker/oop-members.ts
-var OOP_HINT = 'Set "compilerOptions = { oop = true }" in .luam.manifest to enable the MTA OOP API.';
+var OOP_HINT = 'Set "compiler = { oop = true }" in .luam.manifest to enable the MTA OOP API.';
 function scopeLabel2(environment) {
   return environment === "shared" ? "shared" : `${environment}-only`;
 }
@@ -17609,6 +17789,9 @@ function resolveNamedMember(context, name, expression) {
   if (isMtaElement(context, name)) {
     return resolveMtaMember(context, name, expression.property, expression.position)?.type ?? ANY_TYPE;
   }
+  if (context.awaitsDeclaration(name)) {
+    return ANY_TYPE;
+  }
   const contract = context.declarations.lookupClass(name) === null ? context.declarations.lookupInterface(name) : null;
   if (contract === null) {
     return null;
@@ -17638,6 +17821,10 @@ function checkNewExpression(context, expression) {
     context.report("check-unknown-class", `Class "${expression.className}" is not defined.`, expression.position);
     return ANY_TYPE;
   }
+  if (context.isPredeclaredClass(expression.className) && !context.insideFunction()) {
+    const message = `Class "${expression.className}" is declared further down this file, so it does not exist yet at this point.`;
+    context.report("check-class-before-declaration", message, expression.position);
+  }
   const constructor = context.declarations.lookupMember(expression.className, "constructor");
   if (constructor !== null && constructor.type.kind === "function") {
     checkSignature(context, expression.args, constructor.type, expression.position);
@@ -17723,30 +17910,6 @@ function checkUnary(context, operator, operand, expression) {
   return context.record(expression, NUMBER_TYPE);
 }
 
-// ../compiler/src/checker/template.ts
-function parseInterpolation(segment) {
-  const separator = segment.value.indexOf(":");
-  const path = (separator === -1 ? segment.value : segment.value.slice(0, separator)).trim();
-  const fallback = separator === -1 ? null : segment.value.slice(separator + 1).trim();
-  const root = path.split(".")[0] ?? "";
-  return { raw: segment.value, path, root, fallback, position: segment.position };
-}
-function collectInterpolations(segments) {
-  return segments.filter((segment) => segment.kind === "interpolation").map(parseInterpolation);
-}
-function collectTemplateRoots(segments) {
-  const roots = [];
-  for (const interpolation of collectInterpolations(segments)) {
-    if (interpolation.root.length > 0 && !roots.includes(interpolation.root)) {
-      roots.push(interpolation.root);
-    }
-  }
-  return roots;
-}
-function templateLiteralText(segments) {
-  return segments.map((segment) => segment.kind === "text" ? segment.value : `\${${segment.value}}`).join("");
-}
-
 // ../compiler/src/checker/union-members.ts
 function isShapeOption(context, option) {
   if (option.kind === "record") {
@@ -17788,990 +17951,1073 @@ function resolveUnionMember(context, type, expression) {
   return ANY_TYPE;
 }
 
-// ../compiler/src/checker/expressions.ts
-var EXTENSION_RESULTS = {
-  boolean: BOOLEAN_TYPE,
-  number: NUMBER_TYPE,
-  string: STRING_TYPE,
-  table: TABLE_TYPE
-};
-function isNativeConstruction(context, expression) {
-  const object = expression.object;
-  if (expression.property !== NATIVE_CONSTRUCTOR || object.kind !== "identifier") {
-    return false;
-  }
-  return nativeConstructor(context, object.name) !== null;
-}
-function checkMember(context, expression) {
-  if (expression.object.kind === "identifier" && isMtaClassReference(context, expression.object.name)) {
-    context.references.add(expression.object.name);
-    return context.record(expression, resolveMtaStaticMember(context, expression.object.name, expression.property, expression.position)?.type ?? ANY_TYPE);
+// ../compiler/src/checker/discriminant.ts
+function literalValue(expression) {
+  if (expression.kind === "string-literal") {
+    return createStringLiteral(expression.value);
   }
-  if (isNativeConstruction(context, expression) && expression.object.kind === "identifier") {
-    const name = expression.object.name;
-    const message = `Construct "${name}" with "new ${name}(...)". The "${name}.new(...)" form is not part of the language.`;
-    context.report("check-native-constructor", message, expression.position);
+  if (expression.kind === "boolean-literal") {
+    return createBooleanLiteral(expression.value);
   }
-  const library = resolveLibraryMember(context, expression);
-  if (library !== null) {
-    checkExpression(context, expression.object);
-    return context.record(expression, library);
+  return expression.kind === "number-literal" ? createNumberLiteral(expression.value) : null;
+}
+function discriminantTest(left, right) {
+  if (left.kind !== "member-expression" || left.object.kind !== "identifier") {
+    return null;
   }
-  const objectType = checkExpression(context, expression.object);
-  if (objectType.kind === "record") {
-    return context.record(expression, resolveRecordMember(context, objectType, expression));
+  const value = literalValue(right);
+  return value === null ? null : { name: left.object.name, property: left.property, value };
+}
+function subjectType(context, name) {
+  const type = context.narrowedType(name) ?? context.binder.lookup(name)?.type ?? null;
+  return type === null ? null : withoutNil(type);
+}
+function filterOptions(context, test, keep) {
+  const subject = subjectType(context, test.name);
+  if (subject === null || subject.kind !== "union") {
+    return null;
   }
-  if (objectType.kind === "union") {
-    const option = resolveUnionMember(context, objectType, expression);
-    if (option !== null) {
-      return context.record(expression, option);
+  const matched = [];
+  for (const option of subject.options) {
+    const member = optionMemberType(context, option, test.property);
+    if (member === null) {
+      return null;
+    }
+    if (isAssignable(test.value, member) === keep) {
+      matched.push(option);
     }
   }
-  if (objectType.kind === "map" && isAssignable(STRING_TYPE, objectType.key)) {
-    return context.record(expression, objectType.value);
-  }
-  const named2 = objectType.kind === "named" ? resolveNamedMember(context, objectType.name, expression) : null;
-  if (named2 !== null) {
-    return context.record(expression, named2);
+  return matched.length === 0 || matched.length === subject.options.length ? null : createUnion(matched);
+}
+function discriminantFact(context, left, right, keep) {
+  const test = discriminantTest(left, right) ?? discriminantTest(right, left);
+  if (test === null) {
+    return null;
   }
-  const extension = extensionFor(objectType, expression.property);
-  if (extension !== null) {
-    reportExtensionForm(context, expression, extension);
+  const narrowed = filterOptions(context, test, keep);
+  return narrowed === null ? null : [test.name, narrowed];
+}
+
+// ../compiler/src/checker/narrowing.ts
+var GUARD_FUNCTION = "type";
+var GUARD_TYPES = {
+  boolean: BOOLEAN_TYPE,
+  function: createFunction([], ANY_TYPE, 0, true),
+  nil: NIL_TYPE,
+  number: NUMBER_TYPE,
+  string: STRING_TYPE,
+  table: TABLE_TYPE,
+  thread: THREAD_TYPE,
+  userdata: USERDATA_TYPE
+};
+function declaredType(context, name) {
+  return context.binder.lookup(name)?.type ?? null;
+}
+function guardedName(expression) {
+  if (expression.kind !== "call-expression" || expression.callee.kind !== "identifier" || expression.callee.name !== GUARD_FUNCTION) {
+    return null;
   }
-  return context.record(expression, extension === null ? ANY_TYPE : EXTENSION_RESULTS[extension.result]);
+  const [argument] = expression.args;
+  return argument !== void 0 && argument.kind === "identifier" ? argument.name : null;
 }
-function countArguments(total) {
-  return total === 1 ? "1 argument" : `${total} arguments`;
+function guardFact(left, right) {
+  const name = guardedName(left);
+  const value = right.kind === "string-literal" ? GUARD_TYPES[right.value] : void 0;
+  return name === null || value === void 0 ? null : [name, value];
 }
-function checkSignature(context, args, signature, position2) {
-  const argumentTypes = checkValueList(context, args, signature.parameters);
-  if (argumentTypes.length < signature.minimumArguments) {
-    const message = `This call expects at least ${countArguments(signature.minimumArguments)} but received ${argumentTypes.length}.`;
-    context.report("check-argument-count", message, position2);
+function nilComparison(left, right) {
+  if (left.kind === "identifier" && right.kind === "nil-literal") {
+    return left.name;
   }
-  if (!signature.isVariadic && argumentTypes.length > signature.parameters.length) {
-    const message = `This call expects at most ${countArguments(signature.parameters.length)} but received ${argumentTypes.length}.`;
-    context.report("check-argument-count", message, position2);
+  return right.kind === "identifier" && left.kind === "nil-literal" ? right.name : null;
+}
+function present2(context, name, facts) {
+  const declared = declaredType(context, name);
+  if (declared !== null) {
+    facts.set(name, withoutNil(declared));
   }
-  signature.parameters.forEach((parameter, index) => {
-    const argumentType = argumentTypes[index];
-    const argument = args[index];
-    if (argumentType !== void 0 && argument !== void 0) {
-      context.expectAssignable(argumentType, parameter, argument.position, `Argument ${index + 1}`);
-    }
-  });
-  if (signature.isVariadic && signature.variadicType !== void 0) {
-    for (let index = signature.parameters.length; index < argumentTypes.length; index += 1) {
-      const argumentType = argumentTypes[index];
-      const argument = args[Math.min(index, args.length - 1)];
-      if (argumentType !== void 0 && argument !== void 0) {
-        context.expectAssignable(argumentType, signature.variadicType, argument.position, `Argument ${index + 1}`);
-      }
+}
+function mergeAlternatives(left, right, facts) {
+  for (const [name, type] of left) {
+    const other = right.get(name);
+    if (other !== void 0) {
+      facts.set(name, createUnion([type, other]));
     }
   }
-  return signature.returnType;
 }
-function checkArguments(context, expression, calleeType) {
-  if (calleeType.kind !== "function") {
-    checkValueList(context, expression.args);
-    reportNotCallable(context, expression, calleeType);
-    return ANY_TYPE;
+function applyDiscriminant(context, left, right, keep, facts) {
+  const fact = discriminantFact(context, left, right, keep);
+  if (fact !== null) {
+    facts.set(fact[0], fact[1]);
   }
-  return checkSignature(context, expression.args, calleeType, expression.position);
 }
-function isSuperCall(expression) {
-  return expression.method === null && expression.callee.kind === "identifier" && expression.callee.name === "super";
-}
-function isLegacySuperCall(expression) {
-  return expression.method === "super" && expression.callee.kind === "identifier" && expression.callee.name === "self";
-}
-function checkMethodCall(context, expression, method, receiver) {
-  if (receiver.kind !== "named") {
-    checkValueList(context, expression.args);
-    return ANY_TYPE;
+function collectFacts(context, expression, facts) {
+  if (expression.kind === "group-expression") {
+    collectFacts(context, expression.expression, facts);
+    return;
   }
-  const declared = context.declarations.lookupMember(receiver.name, method);
-  if (declared?.type.kind === "function") {
-    if (declared.deprecated === true) {
-      context.warn("check-deprecated-use", `Member "${method}" is deprecated.`, expression.position);
-    }
-    return checkSignature(context, expression.args, declared.type, expression.position);
+  if (expression.kind === "identifier") {
+    present2(context, expression.name, facts);
+    return;
   }
-  if (!isMtaElement(context, receiver.name)) {
-    checkValueList(context, expression.args);
-    return ANY_TYPE;
+  if (expression.kind !== "binary-expression") {
+    return;
   }
-  const member = resolveMtaMember(context, receiver.name, method, expression.position);
-  if (member === null || member.type.kind !== "function") {
-    checkValueList(context, expression.args);
-    return ANY_TYPE;
+  if (expression.operator === "and") {
+    collectFacts(context, expression.left, facts);
+    collectFacts(context, expression.right, facts);
+    return;
   }
-  return checkSignature(context, expression.args, member.type, expression.position);
-}
-function checkCall(context, expression) {
-  if (isLegacySuperCall(expression)) {
-    checkValueList(context, expression.args);
-    context.report("check-invalid-super", 'Call "super(...)" directly instead of "self:super(...)".', expression.position);
-    return context.record(expression, ANY_TYPE);
+  if (expression.operator === "or") {
+    mergeAlternatives(conditionFacts(context, expression.left), conditionFacts(context, expression.right), facts);
+    return;
   }
-  if (isSuperCall(expression)) {
-    return context.record(expression, checkSuperCall(context, expression));
+  if (expression.operator === "==") {
+    const guard = guardFact(expression.left, expression.right) ?? guardFact(expression.right, expression.left);
+    const missing = nilComparison(expression.left, expression.right);
+    if (guard !== null) {
+      facts.set(guard[0], guard[1]);
+    } else if (missing !== null) {
+      facts.set(missing, NIL_TYPE);
+    } else {
+      applyDiscriminant(context, expression.left, expression.right, true, facts);
+    }
+    return;
   }
-  if (expression.method === null && expression.callee.kind === "identifier" && isMtaClassReference(context, expression.callee.name)) {
-    context.references.add(expression.callee.name);
-    const constructor = resolveMtaConstructor(context, expression.callee.name, expression.position);
-    if (constructor === null) {
-      checkValueList(context, expression.args);
-      return context.record(expression, ANY_TYPE);
+  if (expression.operator === "~=") {
+    const name = nilComparison(expression.left, expression.right);
+    if (name !== null) {
+      present2(context, name, facts);
+    } else {
+      applyDiscriminant(context, expression.left, expression.right, false, facts);
     }
-    return context.record(expression, checkSignature(context, expression.args, constructor, expression.position));
   }
-  if (expression.method === null) {
-    context.calledMembers.add(expression.callee);
+}
+function conditionFacts(context, condition) {
+  const facts = /* @__PURE__ */ new Map();
+  collectFacts(context, condition, facts);
+  return facts;
+}
+function alwaysExits(body) {
+  const last = body[body.length - 1];
+  if (last === void 0) {
+    return false;
   }
-  const calleeType = checkExpression(context, expression.callee);
-  if (expression.method !== null) {
-    return context.record(expression, checkMethodCall(context, expression, expression.method, calleeType));
+  if (last.kind === "return-statement" || last.kind === "break-statement") {
+    return true;
   }
-  if (expression.callee.kind === "identifier" && context.binder.isBuiltinReference(expression.callee.name)) {
-    checkEventUsage(context, expression);
-    const specialized = specializeEventCall(context, expression, calleeType);
-    return context.record(expression, checkArguments(context, expression, specialized ?? calleeType));
+  if (last.kind !== "if-statement" || last.alternate === null) {
+    return false;
   }
-  return context.record(expression, checkArguments(context, expression, calleeType));
+  return last.clauses.every((clause) => alwaysExits(clause.body)) && alwaysExits(last.alternate);
 }
-function checkTable(context, expression) {
-  const valueTypes = expression.fields.map((field2) => {
-    if (field2.key !== null) {
-      checkExpression(context, field2.key);
-    }
-    return checkExpression(context, field2.value);
-  });
-  const isRecord = expression.fields.every((field2) => field2.name !== null);
-  if (isRecord) {
-    const members = /* @__PURE__ */ new Map();
-    expression.fields.forEach((field2, index) => {
-      if (field2.name !== null) {
-        members.set(field2.name, valueTypes[index] ?? ANY_TYPE);
-      }
-    });
-    return context.record(expression, createLiteralRecord(members));
-  }
-  const isArray = expression.fields.every((field2) => field2.key === null && field2.name === null);
-  if (!isArray) {
-    return context.record(expression, TABLE_TYPE);
+function guardFacts(context, statement) {
+  const [clause] = statement.kind === "if-statement" ? statement.clauses : [];
+  if (statement.kind !== "if-statement" || statement.alternate !== null || statement.clauses.length !== 1 || clause === void 0) {
+    return /* @__PURE__ */ new Map();
   }
-  return context.record(expression, createArray(createUnion(valueTypes)));
+  return alwaysExits(clause.body) ? negatedFacts(context, clause.condition) : /* @__PURE__ */ new Map();
 }
-function checkTemplate(context, expression) {
-  for (const interpolation of collectInterpolations(expression.segments)) {
-    if (interpolation.root.length === 0) {
-      const message = 'Template interpolation is empty. Write "${name}", "${object.field}", or "${name:fallback}".';
-      context.report("check-empty-interpolation", message, interpolation.position);
-      continue;
-    }
-    if (context.binder.lookup(interpolation.root) === null) {
-      const message = `Template interpolation "${interpolation.path}" refers to "${interpolation.root}", which is not in scope.`;
-      context.report("check-unknown-template-root", message, interpolation.position);
+function negatedFacts(context, condition) {
+  const facts = /* @__PURE__ */ new Map();
+  if (condition.kind === "binary-expression" && condition.operator === "or") {
+    for (const [name, type] of [...negatedFacts(context, condition.left), ...negatedFacts(context, condition.right)]) {
+      facts.set(name, type);
     }
+    return facts;
   }
-  return context.record(expression, STRING_TYPE);
-}
-function checkMultiValueExpression(context, expression, expected = null) {
-  switch (expression.kind) {
-    case "nil-literal":
-      return context.record(expression, NIL_TYPE);
-    case "boolean-literal":
-      return context.record(expression, createBooleanLiteral(expression.value));
-    case "number-literal":
-      return context.record(expression, createNumberLiteral(expression.value));
-    case "string-literal":
-      return context.record(expression, createStringLiteral(expression.value));
-    case "template-literal":
-      return checkTemplate(context, expression);
-    case "vararg-expression":
-      return context.record(expression, ANY_TYPE);
-    case "identifier": {
-      context.references.add(expression.name);
-      const symbol = context.binder.lookup(expression.name);
-      if (symbol === null) {
-        checkGlobalReference(context, expression.name, expression.position);
-      }
-      return context.record(expression, context.narrowedType(expression.name) ?? symbol?.type ?? ANY_TYPE);
-    }
-    case "member-expression":
-      return checkMember(context, expression);
-    case "index-expression": {
-      const objectType = checkExpression(context, expression.object);
-      const indexType = checkExpression(context, expression.index);
-      if (objectType.kind === "map") {
-        context.expectAssignable(indexType, objectType.key, expression.index.position, "Key");
-        return context.record(expression, objectType.value);
-      }
-      return context.record(expression, objectType.kind === "array" ? objectType.element : ANY_TYPE);
-    }
-    case "call-expression":
-      return checkCall(context, expression);
-    case "new-expression":
-      return context.record(expression, checkNewExpression(context, expression));
-    case "table-expression":
-      return checkTable(context, expression);
-    case "function-expression": {
-      const type = buildFunctionType(context, expression.parameters, expression.returnAnnotation, contextualFunction(expected));
-      checkFunctionBody(context, expression.parameters, expression.returnAnnotation, expression.body, type, null);
-      return context.record(expression, type);
-    }
-    case "binary-expression": {
-      const left = checkExpression(context, expression.left);
-      const right = checkExpression(context, expression.right);
-      return checkBinary(context, expression.operator, left, right, expression);
+  if (condition.kind === "binary-expression" && condition.operator === "==") {
+    const name = nilComparison(condition.left, condition.right);
+    if (name !== null) {
+      present2(context, name, facts);
+    } else {
+      applyDiscriminant(context, condition.left, condition.right, false, facts);
     }
-    case "unary-expression":
-      return checkUnary(context, expression.operator, checkExpression(context, expression.operand), expression);
-    default:
-      return context.record(expression, checkExpression(context, expression.expression, expected));
   }
+  if (condition.kind === "binary-expression" && condition.operator === "~=") {
+    applyDiscriminant(context, condition.left, condition.right, true, facts);
+  }
+  if (condition.kind === "unary-expression" && condition.operator === "not" && condition.operand.kind === "identifier") {
+    present2(context, condition.operand.name, facts);
+  }
+  return facts;
 }
-function checkExpression(context, expression, expected = null) {
-  return firstValueOf(checkMultiValueExpression(context, expression, expected));
+
+// ../compiler/src/checker/control-flow.ts
+var ITERATOR_FUNCTIONS = /* @__PURE__ */ new Set(["pairs", "ipairs"]);
+function checkBlock(context, body) {
+  context.binder.pushScope();
+  checkStatements(context, body);
+  context.binder.popScope();
 }
-function checkValueList(context, values, expected = []) {
-  const types = [];
-  values.forEach((value, index) => {
-    const type = checkMultiValueExpression(context, value, expected[index] ?? null);
-    if (index === values.length - 1) {
-      types.push(...valuesOf(type));
-      return;
-    }
-    types.push(firstValueOf(type));
-  });
-  return types;
+function checkNarrowedBlock(context, facts, body) {
+  context.pushNarrowing(facts);
+  checkBlock(context, body);
+  context.popNarrowing();
 }
-
-// ../compiler/src/checker/classes.ts
-function fieldType(context, member) {
-  const valueType = member.value === null ? null : checkExpression(context, member.value);
-  if (member.annotation === null) {
-    return valueType ?? ANY_TYPE;
-  }
-  const declared = context.resolveAnnotation(member.annotation);
-  if (valueType !== null && member.value !== null) {
-    context.expectAssignable(valueType, declared, member.value.position, `Field "${member.name}"`);
+function checkIf(context, clauses, alternate) {
+  for (const clause of clauses) {
+    checkExpression(context, clause.condition);
+    checkNarrowedBlock(context, conditionFacts(context, clause.condition), clause.body);
   }
-  return declared;
-}
-function checkFieldName(context, member) {
-  if (member.name !== "constructor") {
+  if (alternate === null) {
     return;
   }
-  const message = 'A "constructor" is the class constructor, not a field. Write it as "constructor = function (...) ... end" or rename the field.';
-  context.report("check-invalid-constructor", message, member.position);
+  const [only] = clauses;
+  checkNarrowedBlock(context, clauses.length === 1 && only !== void 0 ? negatedFacts(context, only.condition) : /* @__PURE__ */ new Map(), alternate);
 }
-function syntheticMethodType(context, member, fieldTypes) {
-  const fieldType2 = [...fieldTypes].find(([field2]) => field2.position.offset === member.position.offset)?.[1] ?? ANY_TYPE;
-  if (member.generated?.kind === "lazy") {
-    return createFunction([], fieldType2);
-  }
-  if (member.generated === void 0) {
-    return member.parameters.length === 0 ? createFunction([], fieldType2) : createFunction([fieldType2], VOID_TYPE);
+function checkNumericFor(context, statement) {
+  const bounds = [statement.start, statement.limit, statement.step].filter((value) => value !== null);
+  for (const bound of bounds) {
+    const type = checkExpression(context, bound);
+    if (!isNumeric(type)) {
+      context.report("check-invalid-operand", `Numeric "for" expects "number" but received "${typeToString(type)}".`, bound.position);
+    }
   }
-  return buildFunctionType(context, member.parameters, member.returnAnnotation);
+  context.binder.pushScope();
+  context.binder.declare({ name: statement.variable.name, type: NUMBER_TYPE, isLocal: true, position: statement.variable.position, origin: "local" });
+  checkStatements(context, statement.body);
+  context.binder.popScope();
 }
-function registerMembers(context, info, statement) {
-  const fieldTypes = /* @__PURE__ */ new Map();
-  for (const member of statement.members) {
-    if (member.kind === "class-field") {
-      checkFieldName(context, member);
-      fieldTypes.set(member, fieldType(context, member));
-    }
+function iteratedTypes(context, iterators) {
+  const [iterator] = iterators;
+  if (iterators.length !== 1 || iterator === void 0 || iterator.kind !== "call-expression" || iterator.callee.kind !== "identifier") {
+    return [];
   }
-  const generated = expandClassDecorators(context, statement, fieldTypes);
-  for (const member of [...statement.members, ...generated]) {
-    const type = member.kind === "class-field" ? fieldTypes.get(member) ?? ANY_TYPE : member.isSynthetic ? syntheticMethodType(context, member, fieldTypes) : buildFunctionType(context, member.parameters, member.returnAnnotation);
-    const decorators = member.decorators.map((decorator) => decorator.name);
-    info.members.set(member.name, {
-      name: member.name,
-      type,
-      isMethod: member.kind === "class-method",
-      position: member.position,
-      readOnly: decorators.includes("ReadOnly"),
-      deprecated: decorators.includes("Deprecated")
-    });
+  const [source] = iterator.args;
+  if (!ITERATOR_FUNCTIONS.has(iterator.callee.name) || source === void 0) {
+    return [];
   }
-  return generated;
+  const type = context.typeOf(source);
+  if (type.kind === "map") {
+    return iterator.callee.name === "ipairs" ? [NUMBER_TYPE, type.value] : [type.key, type.value];
+  }
+  return type.kind === "array" ? [NUMBER_TYPE, type.element] : [];
 }
-function declareBuilder(context, info, statement) {
-  if (!statement.decorators.some((decorator) => decorator.name === "Builder")) {
+function checkGenericFor(context, statement) {
+  statement.iterators.forEach((iterator) => checkExpression(context, iterator));
+  const iterated = iteratedTypes(context, statement.iterators);
+  context.binder.pushScope();
+  statement.variables.forEach((variable, index) => {
+    const inferred = iterated[index] ?? ANY_TYPE;
+    const declared = variable.annotation === null ? inferred : context.resolveAnnotation(variable.annotation);
+    context.binder.declare({ name: variable.name, type: declared, isLocal: true, position: variable.position, origin: "local" });
+  });
+  checkStatements(context, statement.body);
+  context.binder.popScope();
+}
+
+// ../compiler/src/checker/events.ts
+function resolveParameters(context, declaration) {
+  const parameters = [];
+  const names = /* @__PURE__ */ new Set();
+  let invalid = false;
+  declaration.parameters.forEach((parameter, index) => {
+    const type = context.resolveAnnotation(parameter.annotation);
+    if (parameter.name.length > 0 && names.has(parameter.name)) {
+      context.report("check-duplicate-event-parameter", `Event "${declaration.name}" declares parameter "${parameter.name}" more than once.`, parameter.position);
+      invalid = true;
+    }
+    if (parameter.isVararg && index !== declaration.parameters.length - 1) {
+      context.report("check-invalid-event-parameter", `Variadic parameter of event "${declaration.name}" must be last.`, parameter.position);
+      invalid = true;
+    }
+    if (parameter.name.length > 0) {
+      names.add(parameter.name);
+    }
+    parameters.push({ name: parameter.name, type, isVariadic: parameter.isVararg, position: parameter.position });
+  });
+  return { parameters, invalid };
+}
+function checkEventDeclaration(context, declaration) {
+  if (context.declarations.lookupEvent(declaration.name) !== null) {
+    context.report("check-duplicate-event", `Event "${declaration.name}" is already defined.`, declaration.position);
     return;
   }
-  const name = `${statement.name}Builder`;
-  const members = /* @__PURE__ */ new Map();
-  for (const field2 of statement.members) {
-    if (field2.kind === "class-field") {
-      const type = info.members.get(field2.name)?.type ?? ANY_TYPE;
-      const method = `with${field2.name[0]?.toUpperCase()}${field2.name.slice(1)}`;
-      members.set(method, { name: method, type: { kind: "function", parameters: [type], minimumArguments: 1, isVariadic: false, returnType: createNamed(name) }, isMethod: true, position: field2.position });
-    }
+  let invalid = declaration.name.length === 0;
+  if (invalid) {
+    context.report("check-invalid-event-name", "An event name cannot be empty.", declaration.position);
   }
-  members.set("build", { name: "build", type: { kind: "function", parameters: [], minimumArguments: 0, isVariadic: false, returnType: createNamed(statement.name) }, isMethod: true, position: statement.position });
-  context.declarations.declareClass({ name, superClass: null, interfaces: [], members, position: statement.position });
-  context.declareModuleGlobal({ name, type: createNamed(name), isLocal: false, position: statement.position });
-}
-function checkMethodBody(context, info, member) {
-  const explicitSelf = member.parameters.find((parameter) => parameter.name === "self");
-  if (explicitSelf !== void 0) {
-    context.report("check-explicit-self-parameter", 'Class methods receive "self" automatically; remove it from the parameter list.', explicitSelf.position);
+  const resolved2 = resolveParameters(context, declaration);
+  invalid = invalid || resolved2.invalid;
+  if (declaration.returnAnnotation !== null && context.resolveAnnotation(declaration.returnAnnotation).kind !== "void") {
+    context.report("check-event-return-type", `Event "${declaration.name}" can only declare a "void" return type.`, declaration.returnAnnotation.position);
+    invalid = true;
   }
-  const signature = info.members.get(member.name)?.type;
-  if (signature?.kind !== "function") {
-    return;
+  if (!invalid) {
+    context.declarations.declareEvent({
+      name: declaration.name,
+      parameters: resolved2.parameters,
+      environment: context.environment,
+      position: declaration.position
+    });
   }
-  context.pushClassMethod({ className: info.name, methodName: member.name });
-  checkFunctionBody(context, member.parameters, member.returnAnnotation, member.body, signature, createNamed(info.name));
-  context.popClassMethod();
 }
-function resolveSuperClass(context, statement) {
-  if (statement.superClass === null) {
-    return null;
+
+// ../compiler/src/checker/statements.ts
+var ORIGIN = { line: 0, column: 0, offset: 0 };
+function minimumArguments(context, parameters) {
+  const index = parameters.findIndex((parameter) => {
+    const type = context.resolveAnnotation(parameter.annotation);
+    return parameter.isVararg || type.kind === "optional" || type.kind === "any";
+  });
+  return index === -1 ? parameters.length : index;
+}
+function buildFunctionType(context, parameters, returnAnnotation, contextual = null) {
+  const isVariadic = parameters.some((parameter) => parameter.isVararg);
+  const types = parameters.filter((parameter) => !parameter.isVararg).map((parameter, index) => parameter.annotation === null ? contextual?.parameters[index] ?? ANY_TYPE : context.resolveAnnotation(parameter.annotation));
+  return createFunction(types, context.resolveAnnotation(returnAnnotation), minimumArguments(context, parameters), isVariadic);
+}
+function checkFunctionBody(context, parameters, returnAnnotation, body, signature, selfType) {
+  context.binder.pushScope();
+  context.pushReturnType(returnAnnotation === null ? null : context.resolveAnnotation(returnAnnotation));
+  if (selfType !== null) {
+    context.binder.declare({ name: "self", type: selfType, isLocal: true, position: ORIGIN });
   }
-  if (context.declarations.lookupClass(statement.superClass) !== null) {
-    if (context.isAmbientClass(statement.superClass)) {
-      context.noteExternalReference(statement.superClass, statement.position);
+  let parameterIndex = 0;
+  for (const parameter of parameters) {
+    const type = parameter.isVararg ? ANY_TYPE : signature.parameters[parameterIndex] ?? ANY_TYPE;
+    context.binder.declare({ name: parameter.name, type, isLocal: true, position: parameter.position, origin: "parameter" });
+    if (!parameter.isVararg) {
+      parameterIndex += 1;
     }
-    return statement.superClass;
   }
-  if (context.mtaClasses !== null && context.mtaClasses.lookupClass(statement.superClass) !== null) {
-    const message2 = `Class "${statement.name}" cannot extend native MTA class "${statement.superClass}".`;
-    context.report("check-native-class-inheritance", message2, statement.position);
-    return null;
+  checkStatements(context, body);
+  const inferred = context.popReturnType();
+  if (returnAnnotation === null) {
+    signature.returnType = inferred;
   }
-  const message = `Class "${statement.name}" extends "${statement.superClass}", which is not defined.`;
-  context.noteExternalReference(statement.superClass, statement.position);
-  context.report("check-unknown-class", message, statement.position);
-  return null;
+  context.binder.popScope();
 }
-function checkClassDeclaration(context, statement) {
-  if (context.declarations.lookupClass(statement.name) !== null) {
-    context.report("check-duplicate-class", `Class "${statement.name}" is already defined.`, statement.position);
-    return;
+function valueAt(values, valueTypes, index) {
+  if (values[index] !== void 0) {
+    return values[index];
   }
-  if (context.mtaClasses !== null && context.mtaClasses.lookupClass(statement.name) !== null) {
-    context.report("check-duplicate-class", `Class "${statement.name}" is reserved by MTA when OOP is enabled.`, statement.position);
+  return index < valueTypes.length ? values[values.length - 1] : void 0;
+}
+function checkLocal(context, statement) {
+  const valueTypes = checkValueList(context, statement.values);
+  statement.declarations.forEach((declaration, index) => {
+    const value = valueAt(statement.values, valueTypes, index);
+    const valueType = valueTypes[index] ?? NIL_TYPE;
+    context.forgetNarrowing(declaration.name);
+    if (declaration.annotation === null) {
+      const inferred = context.allowNil || value === void 0 ? ANY_TYPE : widenInferred(valueType);
+      context.binder.declare({ name: declaration.name, type: inferred, isLocal: true, position: declaration.position, origin: "local" });
+      return;
+    }
+    const declared = context.resolveAnnotation(declaration.annotation);
+    if (value !== void 0) {
+      context.expectAssignable(valueType, declared, value.position, `Variable "${declaration.name}"`);
+    }
+    context.binder.declare({ name: declaration.name, type: declared, isLocal: true, position: declaration.position, origin: "local" });
+  });
+}
+function checkCompoundOperand(context, operator, type, position2) {
+  if (operator === "..=") {
+    if (!isConcatenable(type)) {
+      context.report("check-invalid-operand", `Operator "..=" cannot be applied to "${typeToString(type)}".`, position2);
+    }
     return;
   }
-  const info = {
-    name: statement.name,
-    superClass: resolveSuperClass(context, statement),
-    interfaces: statement.interfaces,
-    members: /* @__PURE__ */ new Map(),
-    position: statement.position
-  };
-  const generated = registerMembers(context, info, statement);
-  context.generatedMembers.set(statement, generated);
-  context.declarations.declareClass(info);
-  context.declareModuleGlobal({ name: info.name, type: createNamed(info.name), isLocal: false, position: statement.position });
-  declareBuilder(context, info, statement);
-  checkInterfaces(context, info);
-  checkOverrides(context, info, statement);
-  for (const member of statement.members) {
-    if (member.kind === "class-method") {
-      checkMethodBody(context, info, member);
+  if (!isNumeric(type)) {
+    context.report("check-invalid-operand", `Operator "${operator}" cannot be applied to "${typeToString(type)}".`, position2);
+  }
+}
+function checkAssignment(context, statement) {
+  const valueTypes = checkValueList(context, statement.values);
+  statement.targets.forEach((target, index) => {
+    const targetType = checkExpression(context, target);
+    const valueType = valueTypes[index] ?? NIL_TYPE;
+    const value = valueAt(statement.values, valueTypes, index);
+    if (target.kind === "member-expression") {
+      const object = context.typeOf(target.object);
+      const frame = context.currentClassMethod();
+      if (object.kind === "named") {
+        const member = context.declarations.lookupMember(object.name, target.property);
+        if (member?.readOnly === true && (frame === null || frame.className !== object.name)) {
+          context.report("check-readonly-assignment", `Field "${target.property}" is read-only outside class "${object.name}".`, target.position);
+        }
+      }
+    }
+    if (statement.operator !== "=") {
+      checkCompoundOperand(context, statement.operator, targetType, target.position);
+      if (statement.values.length > 0) {
+        checkCompoundOperand(context, statement.operator, valueType, value?.position ?? target.position);
+      }
+      return;
+    }
+    if (target.kind === "identifier" && context.binder.lookup(target.name) === null) {
+      context.declareModuleGlobal({ name: target.name, type: valueType, isLocal: false, position: target.position });
+      return;
+    }
+    const declared = target.kind === "identifier" ? context.binder.lookup(target.name)?.type ?? targetType : targetType;
+    if (value !== void 0) {
+      context.expectAssignable(valueType, declared, value.position, "Assignment");
+    }
+    if (target.kind === "identifier") {
+      context.forgetNarrowing(target.name);
+    }
+  });
+}
+function checkFunctionDeclaration(context, statement) {
+  const type = buildFunctionType(context, statement.parameters, statement.returnAnnotation);
+  if (statement.name.kind === "identifier") {
+    const symbol = { name: statement.name.name, type, isLocal: statement.isLocal, position: statement.position };
+    if (statement.isLocal) {
+      context.binder.declare({ ...symbol, origin: "local" });
+    } else {
+      context.declareModuleGlobal(symbol);
     }
   }
+  context.record(statement.name, type);
+  checkFunctionBody(context, statement.parameters, statement.returnAnnotation, statement.body, type, statement.isMethod ? ANY_TYPE : null);
 }
-function checkInterfaceDeclaration(context, statement) {
-  if (context.declarations.lookupInterface(statement.name) !== null) {
-    context.report("check-duplicate-interface", `Interface "${statement.name}" is already defined.`, statement.position);
+function checkReturn(context, statement) {
+  const valueTypes = checkValueList(context, statement.values);
+  const expected = context.currentReturnType();
+  if (expected === null) {
+    context.inferReturnType(createTuple(valueTypes));
     return;
   }
-  const members = /* @__PURE__ */ new Map();
-  for (const name of new Set(statement.superInterfaces)) {
-    const parent = context.declarations.lookupInterface(name);
-    if (name === statement.name || context.declarations.interfaceExtends(name, statement.name)) {
-      context.report("check-interface-cycle", `Interface "${statement.name}" creates an inheritance cycle through "${name}".`, statement.position);
-    } else if (parent === null) {
-      context.noteExternalReference(name, statement.position);
-      context.report("check-unknown-interface", `Interface "${statement.name}" extends "${name}", which is not defined.`, statement.position);
-    } else if (context.isAmbientInterface(name)) {
-      context.noteExternalReference(name, statement.position);
-    }
-  }
-  if (new Set(statement.superInterfaces).size !== statement.superInterfaces.length) {
-    context.report("check-duplicate-interface-parent", `Interface "${statement.name}" extends the same interface more than once.`, statement.position);
+  if (expected.kind === "any") {
+    return;
   }
-  for (const member of statement.members) {
-    const type = member.kind === "interface-field" ? context.resolveAnnotation(member.annotation) : buildFunctionType(context, member.parameters, member.returnAnnotation);
-    const info = { name: member.name, type, isMethod: member.kind === "interface-method", position: member.position };
-    if (members.has(member.name)) {
-      context.report("check-duplicate-interface-member", `Interface "${statement.name}" declares member "${member.name}" more than once.`, member.position);
-    } else {
-      members.set(member.name, info);
+  if (expected.kind === "void") {
+    if (statement.values.length > 0) {
+      context.report("check-return-mismatch", 'This function is declared "void" and cannot return a value.', statement.position);
     }
+    return;
   }
-  const inherited = /* @__PURE__ */ new Map();
-  for (const parent of statement.superInterfaces) {
-    for (const member of context.declarations.collectInterfaceContract(parent)) {
-      const existing = members.get(member.name) ?? inherited.get(member.name);
-      if (existing !== void 0 && (existing.isMethod !== member.isMethod || typeToString(existing.type) !== typeToString(member.type))) {
-        context.report("check-conflicting-interface-member", `Interface "${statement.name}" inherits conflicting declarations of "${member.name}".`, statement.position);
-      } else if (existing === void 0) {
-        inherited.set(member.name, member);
-      }
+  if (expected.kind === "tuple") {
+    if (valueTypes.length !== expected.elements.length) {
+      const message = `This function declares ${expected.elements.length} return values but returns ${valueTypes.length}.`;
+      context.report("check-return-mismatch", message, statement.position);
+      return;
     }
+    valueTypes.forEach((type, index) => {
+      const value2 = statement.values[Math.min(index, statement.values.length - 1)];
+      context.expectAssignable(type, expected.elements[index] ?? ANY_TYPE, value2?.position ?? statement.position, `Return value ${index + 1}`);
+    });
+    return;
   }
-  context.declarations.declareInterface({
-    name: statement.name,
-    superInterfaces: statement.superInterfaces,
-    members,
-    position: statement.position
-  });
-}
-function checkEnumDeclaration(context, statement) {
-  if (context.declarations.lookupEnum(statement.name) !== null) {
-    context.report("check-duplicate-enum", `Enum "${statement.name}" is already defined.`, statement.position);
+  if (valueTypes.length > 1) {
+    const message = `This function declares one return value of type "${typeToString(expected)}" but returns ${valueTypes.length} values.`;
+    context.report("check-return-mismatch", message, statement.position);
     return;
   }
-  const members = statement.members.map((member) => member.name);
-  context.declarations.declareEnum({ name: statement.name, members, position: statement.position });
-  context.declareModuleGlobal({ name: statement.name, type: createNamed(statement.name), isLocal: false, position: statement.position });
+  const first = valueTypes[0];
+  const value = statement.values[0];
+  if (first === void 0 || value === void 0) {
+    context.expectAssignable(NIL_TYPE, expected, statement.position, "Return value");
+    return;
+  }
+  context.expectAssignable(first, expected, value.position, "Return value");
 }
-
-// ../compiler/src/checker/discriminant.ts
-function literalValue(expression) {
-  if (expression.kind === "string-literal") {
-    return createStringLiteral(expression.value);
+function checkDeclareStatement(context, statement) {
+  if (!context.isDeclarationFile) {
+    const message = 'A "declare" statement describes code the compiler does not own and belongs in a ".d.luam" file.';
+    context.report("check-declare-outside-declaration-file", message, statement.position);
+    return;
   }
-  if (expression.kind === "boolean-literal") {
-    return createBooleanLiteral(expression.value);
+  const type = context.resolveAnnotation(statement.annotation);
+  context.declareModuleGlobal({ name: statement.name, type, isLocal: false, position: statement.position });
+  context.declarations.declareGlobal({ name: statement.name, type, position: statement.position });
+}
+function checkStatement(context, statement) {
+  switch (statement.kind) {
+    case "local-statement":
+      return checkLocal(context, statement);
+    case "assignment-statement":
+      return checkAssignment(context, statement);
+    case "call-statement":
+      checkExpression(context, statement.expression);
+      return;
+    case "function-declaration":
+      return checkFunctionDeclaration(context, statement);
+    case "return-statement":
+      return checkReturn(context, statement);
+    case "do-statement":
+      return checkBlock(context, statement.body);
+    case "while-statement":
+      checkExpression(context, statement.condition);
+      return checkBlock(context, statement.body);
+    case "repeat-statement":
+      checkBlock(context, statement.body);
+      checkExpression(context, statement.condition);
+      return;
+    case "if-statement":
+      return checkIf(context, statement.clauses, statement.alternate);
+    case "numeric-for-statement":
+      return checkNumericFor(context, statement);
+    case "generic-for-statement":
+      return checkGenericFor(context, statement);
+    case "type-alias-statement": {
+      const resolved2 = context.resolveAnnotation(statement.annotation);
+      const shape = statement.annotation.kind === "type-object" || statement.annotation.kind === "type-intersection";
+      const named2 = shape ? renameRecord(resolved2, statement.name) : resolved2;
+      context.noteTypeParameters(statement.typeParameters);
+      context.binder.declareAlias(statement.name, named2, statement.typeParameters);
+      return;
+    }
+    case "declare-statement":
+      return checkDeclareStatement(context, statement);
+    case "event-declaration":
+      return checkEventDeclaration(context, statement);
+    case "class-declaration":
+      return checkClassDeclaration(context, statement);
+    case "interface-declaration":
+      return checkInterfaceDeclaration(context, statement);
+    case "enum-declaration":
+      return checkEnumDeclaration(context, statement);
+    default:
+      return;
   }
-  return expression.kind === "number-literal" ? createNumberLiteral(expression.value) : null;
 }
-function discriminantTest(left, right) {
-  if (left.kind !== "member-expression" || left.object.kind !== "identifier") {
-    return null;
+function checkStatements(context, statements) {
+  let guards = 0;
+  for (const statement of statements) {
+    checkStatement(context, statement);
+    const facts = guardFacts(context, statement);
+    if (facts.size > 0) {
+      context.pushNarrowing(facts);
+      guards += 1;
+    }
+  }
+  while (guards > 0) {
+    context.popNarrowing();
+    guards -= 1;
   }
-  const value = literalValue(right);
-  return value === null ? null : { name: left.object.name, property: left.property, value };
 }
-function subjectType(context, name) {
-  const type = context.narrowedType(name) ?? context.binder.lookup(name)?.type ?? null;
-  return type === null ? null : withoutNil(type);
+
+// ../compiler/src/checker/template.ts
+function parseInterpolation(segment) {
+  const separator = segment.value.indexOf(":");
+  const path = (separator === -1 ? segment.value : segment.value.slice(0, separator)).trim();
+  const fallback = separator === -1 ? null : segment.value.slice(separator + 1).trim();
+  const root = path.split(".")[0] ?? "";
+  return { raw: segment.value, path, root, fallback, position: segment.position };
 }
-function filterOptions(context, test, keep) {
-  const subject = subjectType(context, test.name);
-  if (subject === null || subject.kind !== "union") {
-    return null;
-  }
-  const matched = [];
-  for (const option of subject.options) {
-    const member = optionMemberType(context, option, test.property);
-    if (member === null) {
-      return null;
-    }
-    if (isAssignable(test.value, member) === keep) {
-      matched.push(option);
+function collectInterpolations(segments) {
+  return segments.filter((segment) => segment.kind === "interpolation").map(parseInterpolation);
+}
+function collectTemplateRoots(segments) {
+  const roots = [];
+  for (const interpolation of collectInterpolations(segments)) {
+    if (interpolation.root.length > 0 && !roots.includes(interpolation.root)) {
+      roots.push(interpolation.root);
     }
   }
-  return matched.length === 0 || matched.length === subject.options.length ? null : createUnion(matched);
+  return roots;
 }
-function discriminantFact(context, left, right, keep) {
-  const test = discriminantTest(left, right) ?? discriminantTest(right, left);
-  if (test === null) {
-    return null;
-  }
-  const narrowed = filterOptions(context, test, keep);
-  return narrowed === null ? null : [test.name, narrowed];
+function templateLiteralText(segments) {
+  return segments.map((segment) => segment.kind === "text" ? segment.value : `\${${segment.value}}`).join("");
 }
 
-// ../compiler/src/checker/narrowing.ts
-var GUARD_FUNCTION = "type";
-var GUARD_TYPES = {
+// ../compiler/src/checker/expressions.ts
+var EXTENSION_RESULTS = {
   boolean: BOOLEAN_TYPE,
-  function: createFunction([], ANY_TYPE, 0, true),
-  nil: NIL_TYPE,
   number: NUMBER_TYPE,
   string: STRING_TYPE,
-  table: TABLE_TYPE,
-  thread: THREAD_TYPE,
-  userdata: USERDATA_TYPE
+  table: TABLE_TYPE
 };
-function declaredType(context, name) {
-  return context.binder.lookup(name)?.type ?? null;
+function isNativeConstruction(context, expression) {
+  const object = expression.object;
+  if (expression.property !== NATIVE_CONSTRUCTOR || object.kind !== "identifier") {
+    return false;
+  }
+  return nativeConstructor(context, object.name) !== null;
 }
-function guardedName(expression) {
-  if (expression.kind !== "call-expression" || expression.callee.kind !== "identifier" || expression.callee.name !== GUARD_FUNCTION) {
-    return null;
+function checkMember(context, expression) {
+  if (expression.object.kind === "identifier" && isMtaClassReference(context, expression.object.name)) {
+    context.references.add(expression.object.name);
+    return context.record(expression, resolveMtaStaticMember(context, expression.object.name, expression.property, expression.position)?.type ?? ANY_TYPE);
+  }
+  if (isNativeConstruction(context, expression) && expression.object.kind === "identifier") {
+    const name = expression.object.name;
+    const message = `Construct "${name}" with "new ${name}(...)". The "${name}.new(...)" form is not part of the language.`;
+    context.report("check-native-constructor", message, expression.position);
+  }
+  const library = resolveLibraryMember(context, expression);
+  if (library !== null) {
+    checkExpression(context, expression.object);
+    return context.record(expression, library);
+  }
+  const objectType = checkExpression(context, expression.object);
+  if (objectType.kind === "record") {
+    return context.record(expression, resolveRecordMember(context, objectType, expression));
+  }
+  if (objectType.kind === "union") {
+    const option = resolveUnionMember(context, objectType, expression);
+    if (option !== null) {
+      return context.record(expression, option);
+    }
   }
-  const [argument] = expression.args;
-  return argument !== void 0 && argument.kind === "identifier" ? argument.name : null;
+  if (objectType.kind === "map" && isAssignable(STRING_TYPE, objectType.key)) {
+    return context.record(expression, objectType.value);
+  }
+  const named2 = objectType.kind === "named" ? resolveNamedMember(context, objectType.name, expression) : null;
+  if (named2 !== null) {
+    return context.record(expression, named2);
+  }
+  const extension = extensionFor(objectType, expression.property);
+  if (extension !== null) {
+    reportExtensionForm(context, expression, extension);
+  }
+  return context.record(expression, extension === null ? ANY_TYPE : EXTENSION_RESULTS[extension.result]);
 }
-function guardFact(left, right) {
-  const name = guardedName(left);
-  const value = right.kind === "string-literal" ? GUARD_TYPES[right.value] : void 0;
-  return name === null || value === void 0 ? null : [name, value];
+function countArguments(total) {
+  return total === 1 ? "1 argument" : `${total} arguments`;
 }
-function nilComparison(left, right) {
-  if (left.kind === "identifier" && right.kind === "nil-literal") {
-    return left.name;
+function checkSignature(context, args, signature, position2) {
+  const argumentTypes = checkValueList(context, args, signature.parameters);
+  if (argumentTypes.length < signature.minimumArguments) {
+    const message = `This call expects at least ${countArguments(signature.minimumArguments)} but received ${argumentTypes.length}.`;
+    context.report("check-argument-count", message, position2);
   }
-  return right.kind === "identifier" && left.kind === "nil-literal" ? right.name : null;
-}
-function present2(context, name, facts) {
-  const declared = declaredType(context, name);
-  if (declared !== null) {
-    facts.set(name, withoutNil(declared));
+  if (!signature.isVariadic && argumentTypes.length > signature.parameters.length) {
+    const message = `This call expects at most ${countArguments(signature.parameters.length)} but received ${argumentTypes.length}.`;
+    context.report("check-argument-count", message, position2);
   }
-}
-function mergeAlternatives(left, right, facts) {
-  for (const [name, type] of left) {
-    const other = right.get(name);
-    if (other !== void 0) {
-      facts.set(name, createUnion([type, other]));
+  signature.parameters.forEach((parameter, index) => {
+    const argumentType = argumentTypes[index];
+    const argument = args[index];
+    if (argumentType !== void 0 && argument !== void 0) {
+      context.expectAssignable(argumentType, parameter, argument.position, `Argument ${index + 1}`);
+    }
+  });
+  if (signature.isVariadic && signature.variadicType !== void 0) {
+    for (let index = signature.parameters.length; index < argumentTypes.length; index += 1) {
+      const argumentType = argumentTypes[index];
+      const argument = args[Math.min(index, args.length - 1)];
+      if (argumentType !== void 0 && argument !== void 0) {
+        context.expectAssignable(argumentType, signature.variadicType, argument.position, `Argument ${index + 1}`);
+      }
     }
   }
+  return signature.returnType;
 }
-function applyDiscriminant(context, left, right, keep, facts) {
-  const fact = discriminantFact(context, left, right, keep);
-  if (fact !== null) {
-    facts.set(fact[0], fact[1]);
+function checkArguments(context, expression, calleeType) {
+  if (calleeType.kind !== "function") {
+    checkValueList(context, expression.args);
+    reportNotCallable(context, expression, calleeType);
+    return ANY_TYPE;
   }
+  return checkSignature(context, expression.args, calleeType, expression.position);
 }
-function collectFacts(context, expression, facts) {
-  if (expression.kind === "group-expression") {
-    collectFacts(context, expression.expression, facts);
-    return;
+function isSuperCall(expression) {
+  return expression.method === null && expression.callee.kind === "identifier" && expression.callee.name === "super";
+}
+function isLegacySuperCall(expression) {
+  return expression.method === "super" && expression.callee.kind === "identifier" && expression.callee.name === "self";
+}
+function checkMethodCall(context, expression, method, receiver) {
+  if (receiver.kind !== "named") {
+    checkValueList(context, expression.args);
+    return ANY_TYPE;
   }
-  if (expression.kind === "identifier") {
-    present2(context, expression.name, facts);
-    return;
+  const declared = context.declarations.lookupMember(receiver.name, method);
+  if (declared?.type.kind === "function") {
+    if (declared.deprecated === true) {
+      context.warn("check-deprecated-use", `Member "${method}" is deprecated.`, expression.position);
+    }
+    return checkSignature(context, expression.args, declared.type, expression.position);
   }
-  if (expression.kind !== "binary-expression") {
-    return;
+  if (!isMtaElement(context, receiver.name)) {
+    checkValueList(context, expression.args);
+    return ANY_TYPE;
   }
-  if (expression.operator === "and") {
-    collectFacts(context, expression.left, facts);
-    collectFacts(context, expression.right, facts);
-    return;
+  const member = resolveMtaMember(context, receiver.name, method, expression.position);
+  if (member === null || member.type.kind !== "function") {
+    checkValueList(context, expression.args);
+    return ANY_TYPE;
   }
-  if (expression.operator === "or") {
-    mergeAlternatives(conditionFacts(context, expression.left), conditionFacts(context, expression.right), facts);
-    return;
+  return checkSignature(context, expression.args, member.type, expression.position);
+}
+function checkCall(context, expression) {
+  if (isLegacySuperCall(expression)) {
+    checkValueList(context, expression.args);
+    context.report("check-invalid-super", 'Call "super(...)" directly instead of "self:super(...)".', expression.position);
+    return context.record(expression, ANY_TYPE);
   }
-  if (expression.operator === "==") {
-    const guard = guardFact(expression.left, expression.right) ?? guardFact(expression.right, expression.left);
-    const missing = nilComparison(expression.left, expression.right);
-    if (guard !== null) {
-      facts.set(guard[0], guard[1]);
-    } else if (missing !== null) {
-      facts.set(missing, NIL_TYPE);
-    } else {
-      applyDiscriminant(context, expression.left, expression.right, true, facts);
-    }
-    return;
+  if (isSuperCall(expression)) {
+    return context.record(expression, checkSuperCall(context, expression));
   }
-  if (expression.operator === "~=") {
-    const name = nilComparison(expression.left, expression.right);
-    if (name !== null) {
-      present2(context, name, facts);
-    } else {
-      applyDiscriminant(context, expression.left, expression.right, false, facts);
+  if (expression.method === null && expression.callee.kind === "identifier" && isMtaClassReference(context, expression.callee.name)) {
+    context.references.add(expression.callee.name);
+    const constructor = resolveMtaConstructor(context, expression.callee.name, expression.position);
+    if (constructor === null) {
+      checkValueList(context, expression.args);
+      return context.record(expression, ANY_TYPE);
     }
+    return context.record(expression, checkSignature(context, expression.args, constructor, expression.position));
   }
-}
-function conditionFacts(context, condition) {
-  const facts = /* @__PURE__ */ new Map();
-  collectFacts(context, condition, facts);
-  return facts;
-}
-function alwaysExits(body) {
-  const last = body[body.length - 1];
-  if (last === void 0) {
-    return false;
+  if (expression.method === null) {
+    context.calledMembers.add(expression.callee);
   }
-  if (last.kind === "return-statement" || last.kind === "break-statement") {
-    return true;
+  const calleeType = checkExpression(context, expression.callee);
+  if (expression.method !== null) {
+    return context.record(expression, checkMethodCall(context, expression, expression.method, calleeType));
   }
-  if (last.kind !== "if-statement" || last.alternate === null) {
-    return false;
+  if (expression.callee.kind === "identifier" && context.binder.isBuiltinReference(expression.callee.name)) {
+    checkEventUsage(context, expression);
+    const specialized = specializeEventCall(context, expression, calleeType);
+    return context.record(expression, checkArguments(context, expression, specialized ?? calleeType));
   }
-  return last.clauses.every((clause) => alwaysExits(clause.body)) && alwaysExits(last.alternate);
+  return context.record(expression, checkArguments(context, expression, calleeType));
 }
-function guardFacts(context, statement) {
-  const [clause] = statement.kind === "if-statement" ? statement.clauses : [];
-  if (statement.kind !== "if-statement" || statement.alternate !== null || statement.clauses.length !== 1 || clause === void 0) {
-    return /* @__PURE__ */ new Map();
+function checkTable(context, expression) {
+  const valueTypes = expression.fields.map((field2) => {
+    if (field2.key !== null) {
+      checkExpression(context, field2.key);
+    }
+    return checkExpression(context, field2.value);
+  });
+  const isRecord = expression.fields.every((field2) => field2.name !== null);
+  if (isRecord) {
+    const members = /* @__PURE__ */ new Map();
+    expression.fields.forEach((field2, index) => {
+      if (field2.name !== null) {
+        members.set(field2.name, valueTypes[index] ?? ANY_TYPE);
+      }
+    });
+    return context.record(expression, createLiteralRecord(members));
   }
-  return alwaysExits(clause.body) ? negatedFacts(context, clause.condition) : /* @__PURE__ */ new Map();
+  const isArray = expression.fields.every((field2) => field2.key === null && field2.name === null);
+  if (!isArray) {
+    return context.record(expression, TABLE_TYPE);
+  }
+  return context.record(expression, createArray(createUnion(valueTypes)));
 }
-function negatedFacts(context, condition) {
-  const facts = /* @__PURE__ */ new Map();
-  if (condition.kind === "binary-expression" && condition.operator === "or") {
-    for (const [name, type] of [...negatedFacts(context, condition.left), ...negatedFacts(context, condition.right)]) {
-      facts.set(name, type);
+function checkTemplate(context, expression) {
+  for (const interpolation of collectInterpolations(expression.segments)) {
+    if (interpolation.root.length === 0) {
+      const message = 'Template interpolation is empty. Write "${name}", "${object.field}", or "${name:fallback}".';
+      context.report("check-empty-interpolation", message, interpolation.position);
+      continue;
+    }
+    if (context.binder.lookup(interpolation.root) === null) {
+      const message = `Template interpolation "${interpolation.path}" refers to "${interpolation.root}", which is not in scope.`;
+      context.report("check-unknown-template-root", message, interpolation.position);
     }
-    return facts;
   }
-  if (condition.kind === "binary-expression" && condition.operator === "==") {
-    const name = nilComparison(condition.left, condition.right);
-    if (name !== null) {
-      present2(context, name, facts);
-    } else {
-      applyDiscriminant(context, condition.left, condition.right, false, facts);
+  return context.record(expression, STRING_TYPE);
+}
+function checkMultiValueExpression(context, expression, expected = null) {
+  switch (expression.kind) {
+    case "nil-literal":
+      return context.record(expression, NIL_TYPE);
+    case "boolean-literal":
+      return context.record(expression, createBooleanLiteral(expression.value));
+    case "number-literal":
+      return context.record(expression, createNumberLiteral(expression.value));
+    case "string-literal":
+      return context.record(expression, createStringLiteral(expression.value));
+    case "template-literal":
+      return checkTemplate(context, expression);
+    case "vararg-expression":
+      return context.record(expression, ANY_TYPE);
+    case "identifier": {
+      context.references.add(expression.name);
+      const symbol = context.binder.lookup(expression.name);
+      if (symbol === null) {
+        checkGlobalReference(context, expression.name, expression.position);
+      }
+      return context.record(expression, context.narrowedType(expression.name) ?? symbol?.type ?? ANY_TYPE);
+    }
+    case "member-expression":
+      return checkMember(context, expression);
+    case "index-expression": {
+      const objectType = checkExpression(context, expression.object);
+      const indexType = checkExpression(context, expression.index);
+      if (objectType.kind === "map") {
+        context.expectAssignable(indexType, objectType.key, expression.index.position, "Key");
+        return context.record(expression, objectType.value);
+      }
+      return context.record(expression, objectType.kind === "array" ? objectType.element : ANY_TYPE);
+    }
+    case "call-expression":
+      return checkCall(context, expression);
+    case "new-expression":
+      return context.record(expression, checkNewExpression(context, expression));
+    case "table-expression":
+      return checkTable(context, expression);
+    case "function-expression": {
+      const type = buildFunctionType(context, expression.parameters, expression.returnAnnotation, contextualFunction(expected));
+      checkFunctionBody(context, expression.parameters, expression.returnAnnotation, expression.body, type, null);
+      return context.record(expression, type);
     }
+    case "binary-expression": {
+      const left = checkExpression(context, expression.left);
+      const right = checkExpression(context, expression.right);
+      return checkBinary(context, expression.operator, left, right, expression);
+    }
+    case "unary-expression":
+      return checkUnary(context, expression.operator, checkExpression(context, expression.operand), expression);
+    default:
+      return context.record(expression, checkExpression(context, expression.expression, expected));
   }
-  if (condition.kind === "binary-expression" && condition.operator === "~=") {
-    applyDiscriminant(context, condition.left, condition.right, true, facts);
-  }
-  if (condition.kind === "unary-expression" && condition.operator === "not" && condition.operand.kind === "identifier") {
-    present2(context, condition.operand.name, facts);
-  }
-  return facts;
 }
-
-// ../compiler/src/checker/control-flow.ts
-var ITERATOR_FUNCTIONS = /* @__PURE__ */ new Set(["pairs", "ipairs"]);
-function checkBlock(context, body) {
-  context.binder.pushScope();
-  checkStatements(context, body);
-  context.binder.popScope();
+function checkExpression(context, expression, expected = null) {
+  return firstValueOf(checkMultiValueExpression(context, expression, expected));
 }
-function checkNarrowedBlock(context, facts, body) {
-  context.pushNarrowing(facts);
-  checkBlock(context, body);
-  context.popNarrowing();
+function checkValueList(context, values, expected = []) {
+  const types = [];
+  values.forEach((value, index) => {
+    const type = checkMultiValueExpression(context, value, expected[index] ?? null);
+    if (index === values.length - 1) {
+      types.push(...valuesOf(type));
+      return;
+    }
+    types.push(firstValueOf(type));
+  });
+  return types;
 }
-function checkIf(context, clauses, alternate) {
-  for (const clause of clauses) {
-    checkExpression(context, clause.condition);
-    checkNarrowedBlock(context, conditionFacts(context, clause.condition), clause.body);
+
+// ../compiler/src/checker/classes.ts
+function fieldType(context, member) {
+  const valueType = member.value === null ? null : checkExpression(context, member.value);
+  if (member.annotation === null) {
+    return valueType === null ? ANY_TYPE : widenInferred(valueType);
   }
-  if (alternate === null) {
-    return;
+  const declared = context.resolveAnnotation(member.annotation);
+  if (valueType !== null && member.value !== null) {
+    context.expectAssignable(valueType, declared, member.value.position, `Field "${member.name}"`);
   }
-  const [only] = clauses;
-  checkNarrowedBlock(context, clauses.length === 1 && only !== void 0 ? negatedFacts(context, only.condition) : /* @__PURE__ */ new Map(), alternate);
+  return declared;
 }
-function checkNumericFor(context, statement) {
-  const bounds = [statement.start, statement.limit, statement.step].filter((value) => value !== null);
-  for (const bound of bounds) {
-    const type = checkExpression(context, bound);
-    if (!isNumeric(type)) {
-      context.report("check-invalid-operand", `Numeric "for" expects "number" but received "${typeToString(type)}".`, bound.position);
-    }
+function checkFieldName(context, member) {
+  if (member.name !== "constructor") {
+    return;
   }
-  context.binder.pushScope();
-  context.binder.declare({ name: statement.variable.name, type: NUMBER_TYPE, isLocal: true, position: statement.variable.position, origin: "local" });
-  checkStatements(context, statement.body);
-  context.binder.popScope();
+  const message = 'A "constructor" is the class constructor, not a field. Write it as "constructor = function (...) ... end" or rename the field.';
+  context.report("check-invalid-constructor", message, member.position);
 }
-function iteratedTypes(context, iterators) {
-  const [iterator] = iterators;
-  if (iterators.length !== 1 || iterator === void 0 || iterator.kind !== "call-expression" || iterator.callee.kind !== "identifier") {
-    return [];
-  }
-  const [source] = iterator.args;
-  if (!ITERATOR_FUNCTIONS.has(iterator.callee.name) || source === void 0) {
-    return [];
+function syntheticMethodType(context, member, fieldTypes) {
+  const fieldType2 = [...fieldTypes].find(([field2]) => field2.position.offset === member.position.offset)?.[1] ?? ANY_TYPE;
+  if (member.generated?.kind === "lazy") {
+    return createFunction([], fieldType2);
   }
-  const type = context.typeOf(source);
-  if (type.kind === "map") {
-    return iterator.callee.name === "ipairs" ? [NUMBER_TYPE, type.value] : [type.key, type.value];
+  if (member.generated === void 0) {
+    return member.parameters.length === 0 ? createFunction([], fieldType2) : createFunction([fieldType2], VOID_TYPE);
   }
-  return type.kind === "array" ? [NUMBER_TYPE, type.element] : [];
-}
-function checkGenericFor(context, statement) {
-  statement.iterators.forEach((iterator) => checkExpression(context, iterator));
-  const iterated = iteratedTypes(context, statement.iterators);
-  context.binder.pushScope();
-  statement.variables.forEach((variable, index) => {
-    const inferred = iterated[index] ?? ANY_TYPE;
-    const declared = variable.annotation === null ? inferred : context.resolveAnnotation(variable.annotation);
-    context.binder.declare({ name: variable.name, type: declared, isLocal: true, position: variable.position, origin: "local" });
-  });
-  checkStatements(context, statement.body);
-  context.binder.popScope();
+  return buildFunctionType(context, member.parameters, member.returnAnnotation);
 }
-
-// ../compiler/src/checker/events.ts
-function resolveParameters(context, declaration) {
-  const parameters = [];
-  const names = /* @__PURE__ */ new Set();
-  let invalid = false;
-  declaration.parameters.forEach((parameter, index) => {
-    const type = context.resolveAnnotation(parameter.annotation);
-    if (parameter.name.length > 0 && names.has(parameter.name)) {
-      context.report("check-duplicate-event-parameter", `Event "${declaration.name}" declares parameter "${parameter.name}" more than once.`, parameter.position);
-      invalid = true;
-    }
-    if (parameter.isVararg && index !== declaration.parameters.length - 1) {
-      context.report("check-invalid-event-parameter", `Variadic parameter of event "${declaration.name}" must be last.`, parameter.position);
-      invalid = true;
-    }
-    if (parameter.name.length > 0) {
-      names.add(parameter.name);
+function registerMembers(context, info, statement) {
+  const fieldTypes = /* @__PURE__ */ new Map();
+  for (const member of statement.members) {
+    if (member.kind === "class-field") {
+      checkFieldName(context, member);
+      fieldTypes.set(member, fieldType(context, member));
     }
-    parameters.push({ name: parameter.name, type, isVariadic: parameter.isVararg, position: parameter.position });
-  });
-  return { parameters, invalid };
-}
-function checkEventDeclaration(context, declaration) {
-  if (context.declarations.lookupEvent(declaration.name) !== null) {
-    context.report("check-duplicate-event", `Event "${declaration.name}" is already defined.`, declaration.position);
-    return;
-  }
-  let invalid = declaration.name.length === 0;
-  if (invalid) {
-    context.report("check-invalid-event-name", "An event name cannot be empty.", declaration.position);
-  }
-  const resolved2 = resolveParameters(context, declaration);
-  invalid = invalid || resolved2.invalid;
-  if (declaration.returnAnnotation !== null && context.resolveAnnotation(declaration.returnAnnotation).kind !== "void") {
-    context.report("check-event-return-type", `Event "${declaration.name}" can only declare a "void" return type.`, declaration.returnAnnotation.position);
-    invalid = true;
   }
-  if (!invalid) {
-    context.declarations.declareEvent({
-      name: declaration.name,
-      parameters: resolved2.parameters,
-      environment: context.environment,
-      position: declaration.position
+  const generated = expandClassDecorators(context, statement, fieldTypes);
+  for (const member of [...statement.members, ...generated]) {
+    const type = member.kind === "class-field" ? fieldTypes.get(member) ?? ANY_TYPE : member.isSynthetic ? syntheticMethodType(context, member, fieldTypes) : buildFunctionType(context, member.parameters, member.returnAnnotation);
+    const decorators = member.decorators.map((decorator) => decorator.name);
+    info.members.set(member.name, {
+      name: member.name,
+      type,
+      isMethod: member.kind === "class-method",
+      position: member.position,
+      readOnly: decorators.includes("ReadOnly"),
+      deprecated: decorators.includes("Deprecated")
     });
   }
+  return generated;
 }
-
-// ../compiler/src/checker/statements.ts
-var ORIGIN = { line: 0, column: 0, offset: 0 };
-function minimumArguments(context, parameters) {
-  const index = parameters.findIndex((parameter) => {
-    const type = context.resolveAnnotation(parameter.annotation);
-    return parameter.isVararg || type.kind === "optional" || type.kind === "any";
-  });
-  return index === -1 ? parameters.length : index;
-}
-function buildFunctionType(context, parameters, returnAnnotation, contextual = null) {
-  const isVariadic = parameters.some((parameter) => parameter.isVararg);
-  const types = parameters.filter((parameter) => !parameter.isVararg).map((parameter, index) => parameter.annotation === null ? contextual?.parameters[index] ?? ANY_TYPE : context.resolveAnnotation(parameter.annotation));
-  return createFunction(types, context.resolveAnnotation(returnAnnotation), minimumArguments(context, parameters), isVariadic);
-}
-function checkFunctionBody(context, parameters, returnAnnotation, body, signature, selfType) {
-  context.binder.pushScope();
-  context.pushReturnType(returnAnnotation === null ? null : context.resolveAnnotation(returnAnnotation));
-  if (selfType !== null) {
-    context.binder.declare({ name: "self", type: selfType, isLocal: true, position: ORIGIN });
+function declareBuilder(context, info, statement) {
+  if (!statement.decorators.some((decorator) => decorator.name === "Builder")) {
+    return;
   }
-  let parameterIndex = 0;
-  for (const parameter of parameters) {
-    const type = parameter.isVararg ? ANY_TYPE : signature.parameters[parameterIndex] ?? ANY_TYPE;
-    context.binder.declare({ name: parameter.name, type, isLocal: true, position: parameter.position, origin: "parameter" });
-    if (!parameter.isVararg) {
-      parameterIndex += 1;
+  const name = `${statement.name}Builder`;
+  const members = /* @__PURE__ */ new Map();
+  for (const field2 of statement.members) {
+    if (field2.kind === "class-field") {
+      const type = info.members.get(field2.name)?.type ?? ANY_TYPE;
+      const method = `with${field2.name[0]?.toUpperCase()}${field2.name.slice(1)}`;
+      members.set(method, { name: method, type: { kind: "function", parameters: [type], minimumArguments: 1, isVariadic: false, returnType: createNamed(name) }, isMethod: true, position: field2.position });
     }
   }
-  checkStatements(context, body);
-  const inferred = context.popReturnType();
-  if (returnAnnotation === null) {
-    signature.returnType = inferred;
-  }
-  context.binder.popScope();
+  members.set("build", { name: "build", type: { kind: "function", parameters: [], minimumArguments: 0, isVariadic: false, returnType: createNamed(statement.name) }, isMethod: true, position: statement.position });
+  context.declarations.declareClass({ name, superClass: null, interfaces: [], members, position: statement.position });
+  context.declareModuleGlobal({ name, type: createNamed(name), isLocal: false, position: statement.position });
 }
-function valueAt(values, valueTypes, index) {
-  if (values[index] !== void 0) {
-    return values[index];
+function checkMethodBody(context, info, member) {
+  const explicitSelf = member.parameters.find((parameter) => parameter.name === "self");
+  if (explicitSelf !== void 0) {
+    context.report("check-explicit-self-parameter", 'Class methods receive "self" automatically; remove it from the parameter list.', explicitSelf.position);
   }
-  return index < valueTypes.length ? values[values.length - 1] : void 0;
+  const signature = info.members.get(member.name)?.type;
+  if (signature?.kind !== "function") {
+    return;
+  }
+  context.pushClassMethod({ className: info.name, methodName: member.name });
+  checkFunctionBody(context, member.parameters, member.returnAnnotation, member.body, signature, createNamed(info.name));
+  context.popClassMethod();
 }
-function checkLocal(context, statement) {
-  const valueTypes = checkValueList(context, statement.values);
-  statement.declarations.forEach((declaration, index) => {
-    const value = valueAt(statement.values, valueTypes, index);
-    const valueType = valueTypes[index] ?? NIL_TYPE;
-    context.forgetNarrowing(declaration.name);
-    if (declaration.annotation === null) {
-      const inferred = context.allowNil || value === void 0 ? ANY_TYPE : widenInferred(valueType);
-      context.binder.declare({ name: declaration.name, type: inferred, isLocal: true, position: declaration.position, origin: "local" });
-      return;
-    }
-    const declared = context.resolveAnnotation(declaration.annotation);
-    if (value !== void 0) {
-      context.expectAssignable(valueType, declared, value.position, `Variable "${declaration.name}"`);
+function resolveSuperClass(context, statement) {
+  if (statement.superClass === null) {
+    return null;
+  }
+  if (context.declarations.lookupClass(statement.superClass) !== null) {
+    if (context.isAmbientClass(statement.superClass)) {
+      context.noteExternalReference(statement.superClass, statement.position);
     }
-    context.binder.declare({ name: declaration.name, type: declared, isLocal: true, position: declaration.position, origin: "local" });
-  });
+    return statement.superClass;
+  }
+  if (context.mtaClasses !== null && context.mtaClasses.lookupClass(statement.superClass) !== null) {
+    const message2 = `Class "${statement.name}" cannot extend native MTA class "${statement.superClass}".`;
+    context.report("check-native-class-inheritance", message2, statement.position);
+    return null;
+  }
+  const message = `Class "${statement.name}" extends "${statement.superClass}", which is not defined.`;
+  context.noteExternalReference(statement.superClass, statement.position);
+  context.report("check-unknown-class", message, statement.position);
+  return null;
 }
-function checkCompoundOperand(context, operator, type, position2) {
-  if (operator === "..=") {
-    if (!isConcatenable(type)) {
-      context.report("check-invalid-operand", `Operator "..=" cannot be applied to "${typeToString(type)}".`, position2);
-    }
-    return;
+function declareClassInfo(context, statement) {
+  if (context.declarations.lookupClass(statement.name) !== null) {
+    context.report("check-duplicate-class", `Class "${statement.name}" is already defined.`, statement.position);
+    return null;
   }
-  if (!isNumeric(type)) {
-    context.report("check-invalid-operand", `Operator "${operator}" cannot be applied to "${typeToString(type)}".`, position2);
+  if (context.mtaClasses !== null && context.mtaClasses.lookupClass(statement.name) !== null) {
+    context.report("check-duplicate-class", `Class "${statement.name}" is reserved by MTA when OOP is enabled.`, statement.position);
+    return null;
   }
+  const info = {
+    name: statement.name,
+    superClass: null,
+    interfaces: statement.interfaces,
+    members: /* @__PURE__ */ new Map(),
+    position: statement.position
+  };
+  context.declarations.declareClass(info);
+  context.declareModuleGlobal({ name: info.name, type: createNamed(info.name), isLocal: false, position: statement.position });
+  return info;
 }
-function checkAssignment(context, statement) {
-  const valueTypes = checkValueList(context, statement.values);
-  statement.targets.forEach((target, index) => {
-    const targetType = checkExpression(context, target);
-    const valueType = valueTypes[index] ?? NIL_TYPE;
-    const value = valueAt(statement.values, valueTypes, index);
-    if (target.kind === "member-expression") {
-      const object = context.typeOf(target.object);
-      const frame = context.currentClassMethod();
-      if (object.kind === "named") {
-        const member = context.declarations.lookupMember(object.name, target.property);
-        if (member?.readOnly === true && (frame === null || frame.className !== object.name)) {
-          context.report("check-readonly-assignment", `Field "${target.property}" is read-only outside class "${object.name}".`, target.position);
-        }
-      }
-    }
-    if (statement.operator !== "=") {
-      checkCompoundOperand(context, statement.operator, targetType, target.position);
-      if (statement.values.length > 0) {
-        checkCompoundOperand(context, statement.operator, valueType, value?.position ?? target.position);
-      }
-      return;
-    }
-    if (target.kind === "identifier" && context.binder.lookup(target.name) === null) {
-      context.declareModuleGlobal({ name: target.name, type: valueType, isLocal: false, position: target.position });
-      return;
-    }
-    const declared = target.kind === "identifier" ? context.binder.lookup(target.name)?.type ?? targetType : targetType;
-    if (value !== void 0) {
-      context.expectAssignable(valueType, declared, value.position, "Assignment");
-    }
-    if (target.kind === "identifier") {
-      context.forgetNarrowing(target.name);
-    }
-  });
+function declareLocalClass(context, statement) {
+  const info = declareClassInfo(context, statement);
+  if (info === null) {
+    return null;
+  }
+  info.superClass = resolveSuperClass(context, statement);
+  return info;
 }
-function checkFunctionDeclaration(context, statement) {
-  const type = buildFunctionType(context, statement.parameters, statement.returnAnnotation);
-  if (statement.name.kind === "identifier") {
-    const symbol = { name: statement.name.name, type, isLocal: statement.isLocal, position: statement.position };
-    if (statement.isLocal) {
-      context.binder.declare({ ...symbol, origin: "local" });
-    } else {
-      context.declareModuleGlobal(symbol);
+function checkClassDeclaration(context, statement) {
+  const info = context.takePredeclaredClass(statement.name) ?? declareLocalClass(context, statement);
+  if (info === null) {
+    return;
+  }
+  context.generatedMembers.set(statement, registerMembers(context, info, statement));
+  declareBuilder(context, info, statement);
+  checkInterfaces(context, info);
+  checkOverrides(context, info, statement);
+  for (const member of statement.members) {
+    if (member.kind === "class-method") {
+      checkMethodBody(context, info, member);
     }
   }
-  context.record(statement.name, type);
-  checkFunctionBody(context, statement.parameters, statement.returnAnnotation, statement.body, type, statement.isMethod ? ANY_TYPE : null);
 }
-function checkReturn(context, statement) {
-  const valueTypes = checkValueList(context, statement.values);
-  const expected = context.currentReturnType();
-  if (expected === null) {
-    context.inferReturnType(createTuple(valueTypes));
+function checkInterfaceDeclaration(context, statement) {
+  if (context.declarations.lookupInterface(statement.name) !== null) {
+    context.report("check-duplicate-interface", `Interface "${statement.name}" is already defined.`, statement.position);
     return;
   }
-  if (expected.kind === "any") {
-    return;
+  const members = /* @__PURE__ */ new Map();
+  for (const name of new Set(statement.superInterfaces)) {
+    const parent = context.declarations.lookupInterface(name);
+    if (name === statement.name || context.declarations.interfaceExtends(name, statement.name)) {
+      context.report("check-interface-cycle", `Interface "${statement.name}" creates an inheritance cycle through "${name}".`, statement.position);
+    } else if (parent === null) {
+      context.noteExternalReference(name, statement.position);
+      context.report("check-unknown-interface", `Interface "${statement.name}" extends "${name}", which is not defined.`, statement.position);
+    } else if (context.isAmbientInterface(name)) {
+      context.noteExternalReference(name, statement.position);
+    }
   }
-  if (expected.kind === "void") {
-    if (statement.values.length > 0) {
-      context.report("check-return-mismatch", 'This function is declared "void" and cannot return a value.', statement.position);
+  if (new Set(statement.superInterfaces).size !== statement.superInterfaces.length) {
+    context.report("check-duplicate-interface-parent", `Interface "${statement.name}" extends the same interface more than once.`, statement.position);
+  }
+  for (const member of statement.members) {
+    const type = member.kind === "interface-field" ? context.resolveAnnotation(member.annotation) : buildFunctionType(context, member.parameters, member.returnAnnotation);
+    const info = { name: member.name, type, isMethod: member.kind === "interface-method", position: member.position };
+    if (members.has(member.name)) {
+      context.report("check-duplicate-interface-member", `Interface "${statement.name}" declares member "${member.name}" more than once.`, member.position);
+    } else {
+      members.set(member.name, info);
     }
-    return;
   }
-  if (expected.kind === "tuple") {
-    if (valueTypes.length !== expected.elements.length) {
-      const message = `This function declares ${expected.elements.length} return values but returns ${valueTypes.length}.`;
-      context.report("check-return-mismatch", message, statement.position);
-      return;
+  const inherited = /* @__PURE__ */ new Map();
+  for (const parent of statement.superInterfaces) {
+    for (const member of context.declarations.collectInterfaceContract(parent)) {
+      const existing = members.get(member.name) ?? inherited.get(member.name);
+      if (existing !== void 0 && (existing.isMethod !== member.isMethod || typeToString(existing.type) !== typeToString(member.type))) {
+        context.report("check-conflicting-interface-member", `Interface "${statement.name}" inherits conflicting declarations of "${member.name}".`, statement.position);
+      } else if (existing === void 0) {
+        inherited.set(member.name, member);
+      }
     }
-    valueTypes.forEach((type, index) => {
-      const value2 = statement.values[Math.min(index, statement.values.length - 1)];
-      context.expectAssignable(type, expected.elements[index] ?? ANY_TYPE, value2?.position ?? statement.position, `Return value ${index + 1}`);
-    });
-    return;
   }
-  if (valueTypes.length > 1) {
-    const message = `This function declares one return value of type "${typeToString(expected)}" but returns ${valueTypes.length} values.`;
-    context.report("check-return-mismatch", message, statement.position);
+  context.declarations.declareInterface({
+    name: statement.name,
+    superInterfaces: statement.superInterfaces,
+    members,
+    position: statement.position
+  });
+}
+function checkEnumDeclaration(context, statement) {
+  const existing = context.declarations.lookupEnum(statement.name);
+  const shadowsAmbient = statement.isLocal && existing?.isLocal !== true && context.isAmbientEnum(statement.name);
+  if (existing !== null && !shadowsAmbient) {
+    context.report("check-duplicate-enum", `Enum "${statement.name}" is already defined.`, statement.position);
     return;
   }
-  const first = valueTypes[0];
-  const value = statement.values[0];
-  if (first === void 0 || value === void 0) {
-    context.expectAssignable(NIL_TYPE, expected, statement.position, "Return value");
-    return;
+  const members = statement.members.map((member) => member.name);
+  context.declarations.declareEnum({ name: statement.name, members, isLocal: statement.isLocal, position: statement.position });
+  if (statement.isLocal) {
+    context.binder.declare({ name: statement.name, type: createNamed(statement.name), isLocal: true, position: statement.position, origin: "local" });
+  } else {
+    context.declareModuleGlobal({ name: statement.name, type: createNamed(statement.name), isLocal: false, position: statement.position });
   }
-  context.expectAssignable(first, expected, value.position, "Return value");
 }
-function checkDeclareStatement(context, statement) {
-  if (!context.isDeclarationFile) {
-    const message = 'A "declare" statement describes code the compiler does not own and belongs in a ".d.luam" file.';
-    context.report("check-declare-outside-declaration-file", message, statement.position);
-    return;
+
+// ../compiler/src/checker/predeclaration.ts
+function declareHeaders(context, body) {
+  const declared = [];
+  for (const statement of body) {
+    if (statement.kind !== "class-declaration") {
+      continue;
+    }
+    const info = declareClassInfo(context, statement);
+    if (info === null) {
+      continue;
+    }
+    context.predeclareClass(info);
+    declared.push({ info, statement });
   }
-  const type = context.resolveAnnotation(statement.annotation);
-  context.declareModuleGlobal({ name: statement.name, type, isLocal: false, position: statement.position });
-  context.declarations.declareGlobal({ name: statement.name, type, position: statement.position });
+  return declared;
 }
-function checkStatement(context, statement) {
-  switch (statement.kind) {
-    case "local-statement":
-      return checkLocal(context, statement);
-    case "assignment-statement":
-      return checkAssignment(context, statement);
-    case "call-statement":
-      checkExpression(context, statement.expression);
-      return;
-    case "function-declaration":
-      return checkFunctionDeclaration(context, statement);
-    case "return-statement":
-      return checkReturn(context, statement);
-    case "do-statement":
-      return checkBlock(context, statement.body);
-    case "while-statement":
-      checkExpression(context, statement.condition);
-      return checkBlock(context, statement.body);
-    case "repeat-statement":
-      checkBlock(context, statement.body);
-      checkExpression(context, statement.condition);
-      return;
-    case "if-statement":
-      return checkIf(context, statement.clauses, statement.alternate);
-    case "numeric-for-statement":
-      return checkNumericFor(context, statement);
-    case "generic-for-statement":
-      return checkGenericFor(context, statement);
-    case "type-alias-statement": {
-      const resolved2 = context.resolveAnnotation(statement.annotation);
-      const shape = statement.annotation.kind === "type-object" || statement.annotation.kind === "type-intersection";
-      const named2 = shape ? renameRecord(resolved2, statement.name) : resolved2;
-      context.noteTypeParameters(statement.typeParameters);
-      context.binder.declareAlias(statement.name, named2, statement.typeParameters);
+function breakCycle(context, info) {
+  const seen = /* @__PURE__ */ new Set([info.name]);
+  let current = info.superClass === null ? null : context.declarations.lookupClass(info.superClass);
+  while (current !== null) {
+    if (seen.has(current.name)) {
+      context.report("check-class-cycle", `Class "${info.name}" creates an inheritance cycle through "${current.name}".`, info.position);
+      info.superClass = null;
       return;
     }
-    case "declare-statement":
-      return checkDeclareStatement(context, statement);
-    case "event-declaration":
-      return checkEventDeclaration(context, statement);
-    case "class-declaration":
-      return checkClassDeclaration(context, statement);
-    case "interface-declaration":
-      return checkInterfaceDeclaration(context, statement);
-    case "enum-declaration":
-      return checkEnumDeclaration(context, statement);
-    default:
-      return;
+    seen.add(current.name);
+    current = current.superClass === null ? null : context.declarations.lookupClass(current.superClass);
   }
 }
-function checkStatements(context, statements) {
-  let guards = 0;
-  for (const statement of statements) {
-    checkStatement(context, statement);
-    const facts = guardFacts(context, statement);
-    if (facts.size > 0) {
-      context.pushNarrowing(facts);
-      guards += 1;
-    }
+function predeclareModule(context, body) {
+  const declared = declareHeaders(context, body);
+  for (const entry of declared) {
+    entry.info.superClass = resolveSuperClass(context, entry.statement);
   }
-  while (guards > 0) {
-    context.popNarrowing();
-    guards -= 1;
+  for (const entry of declared) {
+    breakCycle(context, entry.info);
   }
 }
 
@@ -18835,6 +19081,7 @@ function check(program2, mode, environment = DEFAULT_ENVIRONMENT, options = {})
   context.isDeclarationFile = options.isDeclarationFile === true;
   const structure = context.isDeclarationFile ? checkDeclarationFile(program2.body) : checkJumps(program2.body);
   const directives = collectDirectives(program2.body, { isDeclarationFile: context.isDeclarationFile });
+  predeclareModule(context, program2.body);
   checkStatements(context, program2.body);
   reportUnknownTypes(context);
   reportUnusedSymbols(context, options.noUnusedLocals === true, options.noUnusedParameters === true);
@@ -19263,7 +19510,8 @@ function emitEnumDeclaration(state, statement) {
   }
   requireHelper(state, "class");
   const names = statement.members.map((member) => emitString(member.name));
-  return names.length === 0 ? `${statement.name} = enum {}` : `${statement.name} = enum { ${names.join(", ")} }`;
+  const target = statement.isLocal ? `local ${statement.name}` : statement.name;
+  return names.length === 0 ? `${target} = enum {}` : `${target} = enum { ${names.join(", ")} }`;
 }
 
 // ../compiler/src/emitter/loops.ts
@@ -19714,6 +19962,25 @@ function canonicalEdit(input, statement, span) {
   return { start: span.start, end: span.end, replacement: padded, lines: emitted.lines };
 }
 
+// ../compiler/src/emitter/preserve-decorators.ts
+var MARKER = new RegExp(String.fromCharCode(0) + "luam:\\d+" + String.fromCharCode(0), "g");
+function compact(text) {
+  return text.replace(MARKER, "").replace(/\s*\n\s*/g, " ").trim();
+}
+function injectedMembersText(input, statement) {
+  const generated = input.generatedMembers.get(statement) ?? [];
+  if (generated.length === 0) {
+    return null;
+  }
+  const state = createEmitState(input.types, input.references, input.generatedMembers);
+  return generated.map((member) => compact(emitMethod(state, statement.name, member))).join(", ");
+}
+function builderClassText(input, statement) {
+  const state = createEmitState(input.types, input.references, input.generatedMembers);
+  const builder = emitBuilder(state, statement);
+  return builder === null ? null : compact(builder);
+}
+
 // ../compiler/src/emitter/preserve-guards.ts
 function isPreservableExpression(expression, types) {
   switch (expression.kind) {
@@ -19834,27 +20101,52 @@ function selfEdit(source, member, span) {
   return { start: parenthesis + 1, end: parenthesis + 1, replacement: "self" };
 }
 function isKept(member) {
-  return member.kind === "class-method" || member.value !== null;
+  return !isLazyField(member) && (member.kind === "class-method" || member.value !== null);
 }
-function isLowered(statement, generated, types) {
-  if (statement.decorators.length > 0 || generated > 0) {
+function isLazyField(member) {
+  return member.kind === "class-field" && member.decorators.some((decorator) => decorator.name === "Lazy");
+}
+function isLowered(input, statement) {
+  const generated = input.generatedMembers.get(statement)?.length ?? 0;
+  const decorated = statement.decorators.length > 0 || generated > 0 || statement.members.some((member) => member.decorators.length > 0);
+  if (decorated && !input.development) {
     return true;
   }
-  return statement.members.some((member) => {
-    if (member.decorators.length > 0) {
-      return true;
+  return statement.members.some(
+    (member) => member.kind === "class-field" && member.value !== null && !isPreservableExpression(member.value, input.types)
+  );
+}
+function decoratorCommentEdits(statement) {
+  const firstByLine = /* @__PURE__ */ new Map();
+  const note = (position2) => {
+    const existing = firstByLine.get(position2.line);
+    if (existing === void 0 || position2.offset < existing) {
+      firstByLine.set(position2.line, position2.offset);
     }
-    return member.kind === "class-field" && member.value !== null && !isPreservableExpression(member.value, types);
-  });
+  };
+  for (const decorator of statement.decorators) {
+    note(decorator.position);
+  }
+  for (const member of statement.members) {
+    if (!isKept(member)) {
+      continue;
+    }
+    for (const decorator of member.decorators) {
+      note(decorator.position);
+    }
+  }
+  return [...firstByLine.values()].map((offset) => ({ start: offset, end: offset, replacement: "--" }));
 }
-function classEdits(source, statement, generated, types, spans) {
-  if (isLowered(statement, generated, types)) {
+function classEdits(input, statement, spans) {
+  const { source } = input;
+  if (isLowered(input, statement)) {
     return null;
   }
   const header = classHeaderEdit(source, statement);
   if (header === null) {
     return null;
   }
+  const injected = input.development ? injectedMembersText(input, statement) : null;
   const edits = [header];
   const kept = statement.members.filter(isKept);
   const limit = spans.span.end;
@@ -19866,7 +20158,8 @@ function classEdits(source, statement, generated, types, spans) {
     const separator = separatorAt(source, span.end, limit);
     if (!isKept(member)) {
       const end = separator === null ? span.end : separator + 1;
-      edits.push({ start: span.start, end, replacement: blankSpan(source.slice(span.start, end)) });
+      const text = source.slice(span.start, end);
+      edits.push({ start: span.start, end, replacement: isLazyField(member) ? longComment(text) : blankSpan(text) });
       continue;
     }
     if (member.kind === "class-method") {
@@ -19876,10 +20169,22 @@ function classEdits(source, statement, generated, types, spans) {
       }
       edits.push(self);
     }
-    if (separator === null && member !== kept[kept.length - 1]) {
+    if (separator === null && (member !== kept[kept.length - 1] || injected !== null)) {
       edits.push({ start: span.end, end: span.end, replacement: "," });
     }
   }
+  edits.push(...decoratorCommentEdits(statement));
+  if (injected !== null) {
+    const brace = source.lastIndexOf("}", limit);
+    if (brace <= spans.span.start) {
+      return null;
+    }
+    edits.push({ start: brace, end: brace, replacement: `${injected} ` });
+  }
+  const builder = input.development ? builderClassText(input, statement) : null;
+  if (builder !== null) {
+    edits.push({ start: limit, end: limit, replacement: ` ${builder}` });
+  }
   return edits;
 }
 
@@ -19968,8 +20273,7 @@ function surgery(collector, statement) {
     return edits2 === null ? null : { edits: edits2, wrapsBody: false };
   }
   if (statement.kind === "class-declaration") {
-    const generated = input.generatedMembers.get(statement)?.length ?? 0;
-    const edits2 = classEdits(input.source, statement, generated, input.types, { span, members: input.spans });
+    const edits2 = classEdits(input, statement, { span, members: input.spans });
     return edits2 === null ? null : { edits: edits2, wrapsBody: false };
   }
   if (loopBody(statement) === null || !isPreservableStatement(statement, input.types)) {