@thigasdevelopment/luam 0.19.5 → 0.19.6

package/luam.mjs

@@ -4008,6 +4008,188 @@ function parseNamedAnnotation(stream, declaration) {
   return { kind: "type-optional", element, position: optional.position };
 }
 
+// ../compiler/src/parser/token-stream.ts
+var ParserError = class extends Error {
+  diagnostic;
+  constructor(diagnostic) {
+    super(diagnostic.message);
+    this.name = "ParserError";
+    this.diagnostic = diagnostic;
+  }
+};
+var TokenStream = class {
+  diagnostics = [];
+  tokens;
+  index = 0;
+  erased = [];
+  spans = /* @__PURE__ */ new Map();
+  constructor(tokens) {
+    this.tokens = tokens;
+  }
+  peek(offset = 0) {
+    const token = this.tokens[Math.min(this.index + offset, this.tokens.length - 1)];
+    return token;
+  }
+  current() {
+    return this.peek();
+  }
+  isEof() {
+    return this.current().kind === "eof";
+  }
+  next() {
+    const token = this.current();
+    if (!this.isEof()) {
+      this.index += 1;
+    }
+    return token;
+  }
+  checkpoint() {
+    return this.index;
+  }
+  speculate() {
+    return { index: this.index, erasures: this.erased.length, diagnostics: this.diagnostics.length };
+  }
+  rewind(point) {
+    this.index = point.index;
+    this.erased.length = point.erasures;
+    this.diagnostics.length = point.diagnostics;
+  }
+  eraseFrom(checkpoint, kind = "annotation") {
+    const first = this.tokens[checkpoint];
+    const last = this.tokens[this.index - 1];
+    if (first !== void 0 && last !== void 0 && first.kind !== "eof") {
+      this.erased.push({ start: first.position.offset, end: last.end.offset, kind });
+    }
+  }
+  eraseToCurrent(checkpoint) {
+    const first = this.tokens[checkpoint];
+    if (first !== void 0 && first.kind !== "eof") {
+      this.erased.push({ start: first.position.offset, end: this.current().position.offset, kind: "annotation" });
+    }
+  }
+  extendDeclarationErasure(end) {
+    const last = this.erased[this.erased.length - 1];
+    if (last !== void 0 && last.kind === "declaration" && last.end <= end) {
+      last.end = end;
+    }
+  }
+  erasures() {
+    return [...this.erased];
+  }
+  recordSpan(node, checkpoint) {
+    const span = this.sourceSpanFrom(checkpoint);
+    if (span !== null) {
+      this.spans.set(node, span);
+    }
+  }
+  nodeSpans() {
+    return this.spans;
+  }
+  sourceSpanFrom(checkpoint) {
+    const first = this.tokens[checkpoint];
+    const last = this.tokens[this.index - 1];
+    return first === void 0 || last === void 0 || first.kind === "eof" ? null : { start: first.position.offset, end: last.end.offset };
+  }
+  check(kind, value) {
+    const token = this.current();
+    return token.kind === kind && (value === void 0 || token.value === value);
+  }
+  checkAhead(offset, kind, value) {
+    const token = this.peek(offset);
+    return token.kind === kind && (value === void 0 || token.value === value);
+  }
+  match(kind, value) {
+    if (!this.check(kind, value)) {
+      return false;
+    }
+    this.next();
+    return true;
+  }
+  expect(kind, value) {
+    if (this.check(kind, value)) {
+      return this.next();
+    }
+    const expected = value === void 0 ? kind : `"${value}"`;
+    throw this.error(`Expected ${expected} but found "${this.describeCurrent()}".`, "parse-unexpected-token");
+  }
+  checkName(offset = 0) {
+    const token = this.peek(offset);
+    return token.kind === "identifier" || token.kind === "keyword" && isLuamKeyword(token.value);
+  }
+  expectName() {
+    if (this.checkName()) {
+      return this.next();
+    }
+    throw this.error(`Expected a name but found "${this.describeCurrent()}".`, "parse-unexpected-token");
+  }
+  describeCurrent() {
+    const token = this.current();
+    return token.kind === "eof" ? "<end of file>" : token.value;
+  }
+  error(message, code = "parse-error") {
+    const token = this.current();
+    return new ParserError(createDiagnostic("parser", code, message, token.position, "error", token.end));
+  }
+  errorAt(message, code, position2, end) {
+    return new ParserError(createDiagnostic("parser", code, message, position2, "error", end));
+  }
+  report(code, message, position2) {
+    this.diagnostics.push(createDiagnostic("parser", code, message, position2));
+  }
+};
+
+// ../compiler/src/parser/type-parameters.ts
+function emptyTypeParameters() {
+  return { names: [], constraints: [] };
+}
+function parseTypeParameters(stream) {
+  const list = emptyTypeParameters();
+  if (!stream.check("operator", "<")) {
+    return list;
+  }
+  const checkpoint = stream.checkpoint();
+  stream.next();
+  do {
+    list.names.push(stream.expect("identifier").value);
+    list.constraints.push(stream.match("keyword", "extends") ? parseTypeAnnotation(stream) : null);
+  } while (stream.match("punctuation", ","));
+  stream.expect("operator", ">");
+  stream.eraseFrom(checkpoint);
+  return list;
+}
+function parseTypeArguments(stream) {
+  const args = [];
+  if (!stream.check("operator", "<")) {
+    return args;
+  }
+  const checkpoint = stream.checkpoint();
+  stream.next();
+  do {
+    args.push(parseTypeAnnotation(stream));
+  } while (stream.match("punctuation", ","));
+  stream.expect("operator", ">");
+  stream.eraseFrom(checkpoint);
+  return args;
+}
+function parseCallTypeArguments(stream) {
+  if (!stream.check("operator", "<")) {
+    return [];
+  }
+  const point = stream.speculate();
+  try {
+    const args = parseTypeArguments(stream);
+    if (args.length > 0 && stream.check("punctuation", "(")) {
+      return args;
+    }
+  } catch (error) {
+    if (!(error instanceof ParserError)) {
+      throw error;
+    }
+  }
+  stream.rewind(point);
+  return [];
+}
+
 // ../compiler/src/parser/function-expression.ts
 function parseParameter(stream) {
   const token = stream.current();
@@ -4038,11 +4220,20 @@ function parseParameters(stream) {
 }
 function parseFunctionExpression(stream) {
   const position2 = stream.expect("keyword", "function").position;
+  const typeParameters = parseTypeParameters(stream);
   const parameters = parseParameters(stream);
   const returnAnnotation = parseOptionalAnnotation(stream);
   const body = parseBlock(stream, ["end"]);
   stream.expect("keyword", "end");
-  return { kind: "function-expression", parameters, returnAnnotation, body, position: position2 };
+  return {
+    kind: "function-expression",
+    typeParameters: typeParameters.names,
+    typeConstraints: typeParameters.constraints,
+    parameters,
+    returnAnnotation,
+    body,
+    position: position2
+  };
 }
 function parseFunctionName(stream) {
   const token = stream.expect("identifier");
@@ -4060,11 +4251,25 @@ function parseFunctionName(stream) {
 function parseFunctionDeclaration(stream, isLocal, isExported = false, isHttpExport = false) {
   const position2 = stream.expect("keyword", "function").position;
   const { name, isMethod } = parseFunctionName(stream);
+  const typeParameters = parseTypeParameters(stream);
   const parameters = parseParameters(stream);
   const returnAnnotation = parseOptionalAnnotation(stream);
   const body = parseBlock(stream, ["end"]);
   stream.expect("keyword", "end");
-  return { kind: "function-declaration", name, isLocal, isExported, isHttpExport, isMethod, parameters, returnAnnotation, body, position: position2 };
+  return {
+    kind: "function-declaration",
+    name,
+    isLocal,
+    isExported,
+    isHttpExport,
+    isMethod,
+    typeParameters: typeParameters.names,
+    typeConstraints: typeParameters.constraints,
+    parameters,
+    returnAnnotation,
+    body,
+    position: position2
+  };
 }
 
 // ../compiler/src/parser/precedence.ts
@@ -4159,7 +4364,7 @@ function parsePrimary(stream) {
   if (token.kind === "keyword" && token.value === "new" && stream.checkAhead(1, "identifier")) {
     stream.next();
     const className = stream.next().value;
-    const typeArguments = parseNewTypeArguments(stream);
+    const typeArguments = parseTypeArguments(stream);
     return { kind: "new-expression", className, typeArguments, args: parseArguments(stream), position: token.position };
   }
   if (token.kind === "keyword" && CALLABLE_KEYWORDS.has(token.value) && stream.checkAhead(1, "punctuation", "(")) {
@@ -4192,20 +4397,6 @@ function parsePrimary(stream) {
   }
   throw stream.error(`Unexpected "${stream.describeCurrent()}" in expression.`, "parse-unexpected-token");
 }
-function parseNewTypeArguments(stream) {
-  const args = [];
-  if (!stream.check("operator", "<")) {
-    return args;
-  }
-  const checkpoint = stream.checkpoint();
-  stream.next();
-  do {
-    args.push(parseTypeAnnotation(stream));
-  } while (stream.match("punctuation", ","));
-  stream.expect("operator", ">");
-  stream.eraseFrom(checkpoint);
-  return args;
-}
 function parseArguments(stream) {
   if (stream.check("string") || stream.check("template") || stream.check("punctuation", "{")) {
     return [parsePrimary(stream)];
@@ -4244,11 +4435,13 @@ function parseSuffixed(stream) {
     if (token.kind === "punctuation" && token.value === ":" && stream.checkName(1)) {
       stream.next();
       const method = stream.next().value;
-      expression = { kind: "call-expression", callee: expression, method, args: parseArguments(stream), position: token.position };
+      const typeArguments2 = parseCallTypeArguments(stream);
+      expression = { kind: "call-expression", callee: expression, method, typeArguments: typeArguments2, args: parseArguments(stream), position: token.position };
       continue;
     }
-    if (isCallStart(stream)) {
-      expression = { kind: "call-expression", callee: expression, method: null, args: parseArguments(stream), position: token.position };
+    const typeArguments = parseCallTypeArguments(stream);
+    if (typeArguments.length > 0 || isCallStart(stream)) {
+      expression = { kind: "call-expression", callee: expression, method: null, typeArguments, args: parseArguments(stream), position: token.position };
       continue;
     }
     return expression;
@@ -4367,128 +4560,6 @@ function recoverInBlock(stream, error, terminators = BRACE_TERMINATORS) {
   }
 }
 
-// ../compiler/src/parser/token-stream.ts
-var ParserError = class extends Error {
-  diagnostic;
-  constructor(diagnostic) {
-    super(diagnostic.message);
-    this.name = "ParserError";
-    this.diagnostic = diagnostic;
-  }
-};
-var TokenStream = class {
-  diagnostics = [];
-  tokens;
-  index = 0;
-  erased = [];
-  spans = /* @__PURE__ */ new Map();
-  constructor(tokens) {
-    this.tokens = tokens;
-  }
-  peek(offset = 0) {
-    const token = this.tokens[Math.min(this.index + offset, this.tokens.length - 1)];
-    return token;
-  }
-  current() {
-    return this.peek();
-  }
-  isEof() {
-    return this.current().kind === "eof";
-  }
-  next() {
-    const token = this.current();
-    if (!this.isEof()) {
-      this.index += 1;
-    }
-    return token;
-  }
-  checkpoint() {
-    return this.index;
-  }
-  eraseFrom(checkpoint, kind = "annotation") {
-    const first = this.tokens[checkpoint];
-    const last = this.tokens[this.index - 1];
-    if (first !== void 0 && last !== void 0 && first.kind !== "eof") {
-      this.erased.push({ start: first.position.offset, end: last.end.offset, kind });
-    }
-  }
-  eraseToCurrent(checkpoint) {
-    const first = this.tokens[checkpoint];
-    if (first !== void 0 && first.kind !== "eof") {
-      this.erased.push({ start: first.position.offset, end: this.current().position.offset, kind: "annotation" });
-    }
-  }
-  extendDeclarationErasure(end) {
-    const last = this.erased[this.erased.length - 1];
-    if (last !== void 0 && last.kind === "declaration" && last.end <= end) {
-      last.end = end;
-    }
-  }
-  erasures() {
-    return [...this.erased];
-  }
-  recordSpan(node, checkpoint) {
-    const span = this.sourceSpanFrom(checkpoint);
-    if (span !== null) {
-      this.spans.set(node, span);
-    }
-  }
-  nodeSpans() {
-    return this.spans;
-  }
-  sourceSpanFrom(checkpoint) {
-    const first = this.tokens[checkpoint];
-    const last = this.tokens[this.index - 1];
-    return first === void 0 || last === void 0 || first.kind === "eof" ? null : { start: first.position.offset, end: last.end.offset };
-  }
-  check(kind, value) {
-    const token = this.current();
-    return token.kind === kind && (value === void 0 || token.value === value);
-  }
-  checkAhead(offset, kind, value) {
-    const token = this.peek(offset);
-    return token.kind === kind && (value === void 0 || token.value === value);
-  }
-  match(kind, value) {
-    if (!this.check(kind, value)) {
-      return false;
-    }
-    this.next();
-    return true;
-  }
-  expect(kind, value) {
-    if (this.check(kind, value)) {
-      return this.next();
-    }
-    const expected = value === void 0 ? kind : `"${value}"`;
-    throw this.error(`Expected ${expected} but found "${this.describeCurrent()}".`, "parse-unexpected-token");
-  }
-  checkName(offset = 0) {
-    const token = this.peek(offset);
-    return token.kind === "identifier" || token.kind === "keyword" && isLuamKeyword(token.value);
-  }
-  expectName() {
-    if (this.checkName()) {
-      return this.next();
-    }
-    throw this.error(`Expected a name but found "${this.describeCurrent()}".`, "parse-unexpected-token");
-  }
-  describeCurrent() {
-    const token = this.current();
-    return token.kind === "eof" ? "<end of file>" : token.value;
-  }
-  error(message, code = "parse-error") {
-    const token = this.current();
-    return new ParserError(createDiagnostic("parser", code, message, token.position, "error", token.end));
-  }
-  errorAt(message, code, position2, end) {
-    return new ParserError(createDiagnostic("parser", code, message, position2, "error", end));
-  }
-  report(code, message, position2) {
-    this.diagnostics.push(createDiagnostic("parser", code, message, position2));
-  }
-};
-
 // ../compiler/src/parser/declarations.ts
 var DECLARATION_NAMES = /* @__PURE__ */ new Set(["class", "interface", "enum"]);
 var CLASS_MODIFIERS = /* @__PURE__ */ new Set(["extends", "implements"]);
@@ -4573,6 +4644,8 @@ function parseClassMethod(stream, token, decorators, isStatic) {
     isConstructor: token.value === "constructor",
     isSynthetic: false,
     isStatic,
+    typeParameters: expression.typeParameters,
+    typeConstraints: expression.typeConstraints,
     parameters: expression.parameters,
     returnAnnotation: expression.returnAnnotation,
     body: expression.body,
@@ -4590,6 +4663,8 @@ function parseBraceClassMethod(stream, token, decorators, isStatic) {
     isConstructor: token.value === "constructor",
     isSynthetic: false,
     isStatic,
+    typeParameters: [],
+    typeConstraints: [],
     parameters,
     returnAnnotation,
     body,
@@ -4638,35 +4713,6 @@ function parseClassMember(stream) {
   expectClassFieldBoundary(stream, token);
   return { kind: "class-field", name: token.value, annotation, value, decorators, isStatic, position: token.position };
 }
-function parseTypeParameters(stream) {
-  const list = { names: [], constraints: [] };
-  if (!stream.check("operator", "<")) {
-    return list;
-  }
-  const checkpoint = stream.checkpoint();
-  stream.next();
-  do {
-    list.names.push(stream.expect("identifier").value);
-    list.constraints.push(stream.match("keyword", "extends") ? parseTypeAnnotation(stream) : null);
-  } while (stream.match("punctuation", ","));
-  stream.expect("operator", ">");
-  stream.eraseFrom(checkpoint);
-  return list;
-}
-function parseTypeArguments(stream) {
-  const args = [];
-  if (!stream.check("operator", "<")) {
-    return args;
-  }
-  const checkpoint = stream.checkpoint();
-  stream.next();
-  do {
-    args.push(parseTypeAnnotation(stream));
-  } while (stream.match("punctuation", ","));
-  stream.expect("operator", ">");
-  stream.eraseFrom(checkpoint);
-  return args;
-}
 function parseClassModifiers(stream, declaration) {
   while (stream.check("keyword") && CLASS_MODIFIERS.has(stream.current().value)) {
     if (stream.next().value === "extends") {
@@ -5305,10 +5351,12 @@ function typeToString(type) {
   }
   if (type.kind === "function") {
     const parameters = type.parameters.map(typeToString);
+    const names = type.typeParameters ?? [];
     if (type.isVariadic) {
       parameters.push(type.variadicType === void 0 ? "..." : `...: ${typeToString(type.variadicType)}`);
     }
-    return `fun(${parameters.join(", ")}): ${typeToString(type.returnType)}`;
+    const generic = names.length === 0 ? "" : `<${names.join(", ")}>`;
+    return `fun${generic}(${parameters.join(", ")}): ${typeToString(type.returnType)}`;
   }
   return type.kind;
 }
@@ -6762,7 +6810,7 @@ import { tmpdir } from "node:os";
 import { join as join2 } from "node:path";
 
 // src/cli/version.ts
-var VERSION = true ? "0.19.5" : "0.0.0-dev";
+var VERSION = true ? "0.19.6" : "0.0.0-dev";
 var PROGRAM_NAME = "luam";
 var PROGRAM_DESCRIPTION = "luam \u2014 the Luam compiler for Multi Theft Auto resources.";
 
@@ -8780,6 +8828,13 @@ function assignmentFact(narrowed, declared) {
 }
 
 // ../compiler/src/checker/type-substitution.ts
+function shadowed(substitutions, names) {
+  const remaining = new Map(substitutions);
+  for (const name of names) {
+    remaining.delete(name);
+  }
+  return remaining;
+}
 function substituteType(type, substitutions) {
   if (type.kind === "named") {
     const args = type.typeArguments ?? [];
@@ -8801,10 +8856,17 @@ function substituteType(type, substitutions) {
     return createUnion(type.options.map((option) => substituteType(option, substitutions)));
   }
   if (type.kind === "function") {
-    const parameters = type.parameters.map((parameter) => substituteType(parameter, substitutions));
-    const returnType = substituteType(type.returnType, substitutions);
-    const variadicType = type.variadicType === void 0 ? void 0 : substituteType(type.variadicType, substitutions);
-    return createFunction(parameters, returnType, type.minimumArguments, type.isVariadic, type.parameterNames, variadicType);
+    const own = type.typeParameters ?? [];
+    const outer = own.length === 0 ? substitutions : shadowed(substitutions, own);
+    const parameters = type.parameters.map((parameter) => substituteType(parameter, outer));
+    const returnType = substituteType(type.returnType, outer);
+    const variadicType = type.variadicType === void 0 ? void 0 : substituteType(type.variadicType, outer);
+    const substituted = createFunction(parameters, returnType, type.minimumArguments, type.isVariadic, type.parameterNames, variadicType);
+    if (own.length > 0) {
+      substituted.typeParameters = [...own];
+      substituted.typeConstraints = (type.typeConstraints ?? []).map((constraint) => constraint === null ? null : substituteType(constraint, outer));
+    }
+    return substituted;
   }
   if (type.kind === "tuple") {
     return createTuple(type.elements.map((element) => substituteType(element, substitutions)));
@@ -8921,21 +8983,24 @@ function satisfies(context, argument, constraint) {
   }
   return isAssignable(argument, constraint, { allowNil: false });
 }
-function checkTypeConstraints(context, name, typeArguments, position2) {
-  const info = context.declarations.lookupClass(name);
-  if (info === null) {
-    return;
-  }
-  info.typeConstraints.forEach((constraint, index) => {
+function reportConstraintViolations(context, owner, typeParameters, typeConstraints, typeArguments, position2) {
+  typeConstraints.forEach((constraint, index) => {
     const argument = typeArguments[index];
     if (constraint === null || argument === void 0 || argument.kind === "any" || satisfies(context, argument, constraint)) {
       return;
     }
-    const parameter = info.typeParameters[index] ?? "T";
-    const message = `Type argument "${typeToString(argument)}" does not satisfy "${parameter} extends ${typeToString(constraint)}" on class "${name}".`;
+    const parameter = typeParameters[index] ?? "T";
+    const message = `Type argument "${typeToString(argument)}" does not satisfy "${parameter} extends ${typeToString(constraint)}" on ${owner}.`;
     context.report("check-generic-constraint", message, position2);
   });
 }
+function checkTypeConstraints(context, name, typeArguments, position2) {
+  const info = context.declarations.lookupClass(name);
+  if (info === null) {
+    return;
+  }
+  reportConstraintViolations(context, `class "${name}"`, info.typeParameters, info.typeConstraints, typeArguments, position2);
+}
 
 // ../mta-types/src/lua-standard.ts
 var LUA_GLOBALS = {
@@ -15027,6 +15092,8 @@ function accessorMethod(field2, decorator, name) {
     isConstructor: false,
     isSynthetic: true,
     isStatic: false,
+    typeParameters: [],
+    typeConstraints: [],
     parameters: decorator === "Getter" ? [] : [value],
     returnAnnotation: decorator === "Getter" ? field2.annotation : voidAnnotation,
     body,
@@ -15035,7 +15102,7 @@ function accessorMethod(field2, decorator, name) {
   };
 }
 function generatedMethod(field2, name, parameters, returnAnnotation, kind, fields) {
-  return { kind: "class-method", name, isConstructor: false, isSynthetic: true, isStatic: false, parameters, returnAnnotation, body: [], decorators: [], generated: { kind, fields }, position: field2.position };
+  return { kind: "class-method", name, isConstructor: false, isSynthetic: true, isStatic: false, typeParameters: [], typeConstraints: [], parameters, returnAnnotation, body: [], decorators: [], generated: { kind, fields }, position: field2.position };
 }
 function typeName(name, node) {
   return { kind: "type-name", name, typeArguments: [], position: node.position };
@@ -15073,6 +15140,8 @@ function staticMethod(statement, name, returnAnnotation, kind, descriptor) {
     isConstructor: false,
     isSynthetic: true,
     isStatic: true,
+    typeParameters: [],
+    typeConstraints: [],
     parameters: [value],
     returnAnnotation,
     body: [],
@@ -18570,6 +18639,33 @@ function specializeEventCall(context, expression, signature) {
   return candidate === null ? null : specialize(signature, candidate);
 }
 
+// ../compiler/src/checker/generic-call.ts
+function countArguments(total) {
+  return total === 1 ? "1 type argument" : `${total} type arguments`;
+}
+function substituteSignature(signature, substitutions) {
+  const parameters = signature.parameters.map((parameter) => substituteType(parameter, substitutions));
+  const returnType = substituteType(signature.returnType, substitutions);
+  const variadicType = signature.variadicType === void 0 ? void 0 : substituteType(signature.variadicType, substitutions);
+  return createFunction(parameters, returnType, signature.minimumArguments, signature.isVariadic, signature.parameterNames, variadicType);
+}
+function specializeCall(context, owner, signature, argumentTypes, typeArguments, position2) {
+  const names = signature.typeParameters ?? [];
+  if (names.length === 0) {
+    if (typeArguments.length > 0) {
+      context.report("check-generic-arity", `${owner} does not accept type arguments.`, position2);
+    }
+    return signature;
+  }
+  const explicit = typeArguments.map((argument) => context.resolveAnnotation(argument));
+  if (typeArguments.length > 0 && explicit.length !== names.length) {
+    context.report("check-generic-arity", `${owner} expects ${countArguments(names.length)} but received ${explicit.length}.`, position2);
+  }
+  const resolved2 = typeArguments.length > 0 ? names.map((unused, index) => explicit[index] ?? ANY_TYPE) : inferTypeArguments(names, signature.parameters, argumentTypes);
+  reportConstraintViolations(context, owner, names, signature.typeConstraints ?? [], resolved2, position2);
+  return substituteSignature(signature, new Map(names.map((name, index) => [name, resolved2[index] ?? ANY_TYPE])));
+}
+
 // ../compiler/src/checker/method-receiver.ts
 var SELF_PARAMETER = "self";
 function resolveNonNominalMethod(receiver, method) {
@@ -19383,15 +19479,48 @@ function checkLoopBody(context, body, facts) {
   checkBlock(context, body);
   context.setFlow(entry);
 }
+function isTruthyLiteral(condition) {
+  if (condition.kind === "group-expression") {
+    return isTruthyLiteral(condition.expression);
+  }
+  const literal2 = condition.kind === "number-literal" || condition.kind === "string-literal" || condition.kind === "template-literal";
+  return literal2 || condition.kind === "boolean-literal" && condition.value;
+}
+function isFalsyLiteral(condition) {
+  if (condition.kind === "group-expression") {
+    return isFalsyLiteral(condition.expression);
+  }
+  return condition.kind === "nil-literal" || condition.kind === "boolean-literal" && !condition.value;
+}
+function hasBreak(body) {
+  return body.some((statement) => {
+    if (statement.kind === "break-statement") {
+      return true;
+    }
+    if (statement.kind === "do-statement") {
+      return hasBreak(statement.body);
+    }
+    if (statement.kind === "if-statement") {
+      return statement.clauses.some((clause) => hasBreak(clause.body)) || statement.alternate !== null && hasBreak(statement.alternate);
+    }
+    return false;
+  });
+}
 function checkWhile(context, statement) {
   forgetAssignedPaths(context, statement.body);
   checkExpression(context, statement.condition);
   checkLoopBody(context, statement.body, conditionFacts(context, statement.condition));
   context.applyFlowFacts(negatedFacts(context, statement.condition));
+  if (isTruthyLiteral(statement.condition) && !hasBreak(statement.body)) {
+    context.markUnreachable();
+  }
 }
 function checkRepeat(context, statement) {
   checkLoopBody(context, statement.body, /* @__PURE__ */ new Map());
   checkExpression(context, statement.condition);
+  if (isFalsyLiteral(statement.condition) && !hasBreak(statement.body)) {
+    context.markUnreachable();
+  }
 }
 function checkNumericFor(context, statement) {
   const bounds = [statement.start, statement.limit, statement.step].filter((value) => value !== null);
@@ -19505,7 +19634,31 @@ function buildFunctionType(context, parameters, returnAnnotation, contextual = n
   const names = named2.map((parameter) => parameter.name);
   return createFunction(types, context.resolveAnnotation(returnAnnotation), minimumArguments(context, parameters), isVariadic, names);
 }
-function checkFunctionBody(context, parameters, returnAnnotation, body, signature, selfType2) {
+function applyTypeParameters(context, type, names, constraints) {
+  if (names.length === 0) {
+    return type;
+  }
+  context.noteTypeParameters(names);
+  type.typeParameters = [...names];
+  type.typeConstraints = names.map((unused, index) => {
+    const constraint = constraints[index];
+    return constraint === void 0 || constraint === null ? null : context.resolveAnnotation(constraint);
+  });
+  return type;
+}
+var FALLTHROUGH_KINDS = /* @__PURE__ */ new Set(["any", "void", "nil", "optional", "unknown"]);
+function toleratesFallthrough(declared) {
+  if (FALLTHROUGH_KINDS.has(declared.kind)) {
+    return true;
+  }
+  return declared.kind === "union" && declared.options.some((option) => option.kind === "nil");
+}
+function reportMissingReturn(context, declared, position2) {
+  const name = typeToString(declared);
+  const repair = declared.kind === "tuple" ? "Add a return on every path." : `Add a return on every path, or declare "${name}?".`;
+  context.report("check-missing-return", `This function declares "${name}" but can end without returning a value. ${repair}`, position2);
+}
+function checkFunctionBody(context, parameters, returnAnnotation, body, signature, selfType2, position2 = ORIGIN) {
   forgetAssignedPaths(context, body);
   const entry = context.flowState;
   context.setFlow(cloneFlow(entry));
@@ -19523,6 +19676,10 @@ function checkFunctionBody(context, parameters, returnAnnotation, body, signatur
     }
   }
   checkStatements(context, body);
+  const declared = context.currentReturnType();
+  if (declared !== null && context.flowState.reachable && !toleratesFallthrough(declared)) {
+    reportMissingReturn(context, declared, position2);
+  }
   const inferred = context.popReturnType();
   if (returnAnnotation === null) {
     signature.returnType = inferred;
@@ -19616,7 +19773,8 @@ function checkAssignment(context, statement) {
   });
 }
 function checkFunctionDeclaration(context, statement) {
-  const type = buildFunctionType(context, statement.parameters, statement.returnAnnotation);
+  const built = buildFunctionType(context, statement.parameters, statement.returnAnnotation);
+  const type = applyTypeParameters(context, built, statement.typeParameters, statement.typeConstraints);
   if (statement.name.kind === "identifier") {
     const symbol = { name: statement.name.name, type, isLocal: statement.isLocal, position: statement.position };
     if (statement.isLocal) {
@@ -19626,7 +19784,7 @@ function checkFunctionDeclaration(context, statement) {
     }
   }
   context.record(statement.name, type);
-  checkFunctionBody(context, statement.parameters, statement.returnAnnotation, statement.body, type, statement.isMethod ? ANY_TYPE : null);
+  checkFunctionBody(context, statement.parameters, statement.returnAnnotation, statement.body, type, statement.isMethod ? ANY_TYPE : null, statement.position);
 }
 function checkReturn(context, statement) {
   const valueTypes = checkValueList(context, statement.values);
@@ -19819,17 +19977,18 @@ function checkMember(context, expression) {
   }
   return context.record(expression, extension === null ? ANY_TYPE : EXTENSION_RESULTS[extension.result]);
 }
-function countArguments(total) {
+function countArguments2(total) {
   return total === 1 ? "1 argument" : `${total} arguments`;
 }
-function checkSignature(context, args, signature, position2) {
-  const argumentTypes = checkValueList(context, args, signature.parameters);
+function checkSignature(context, args, declared, position2, owner = "This call", typeArguments = []) {
+  const argumentTypes = checkValueList(context, args, declared.parameters);
+  const signature = specializeCall(context, owner, declared, argumentTypes, typeArguments, position2);
   if (argumentTypes.length < signature.minimumArguments) {
-    const message = `This call expects at least ${countArguments(signature.minimumArguments)} but received ${argumentTypes.length}.`;
+    const message = `This call expects at least ${countArguments2(signature.minimumArguments)} but received ${argumentTypes.length}.`;
     context.report("check-argument-count", message, position2);
   }
   if (!signature.isVariadic && argumentTypes.length > signature.parameters.length) {
-    const message = `This call expects at most ${countArguments(signature.parameters.length)} but received ${argumentTypes.length}.`;
+    const message = `This call expects at most ${countArguments2(signature.parameters.length)} but received ${argumentTypes.length}.`;
     context.report("check-argument-count", message, position2);
   }
   signature.parameters.forEach((parameter, index) => {
@@ -19850,13 +20009,17 @@ function checkSignature(context, args, signature, position2) {
   }
   return signature.returnType;
 }
+function callOwner(expression) {
+  const name = expression.method ?? (expression.callee.kind === "identifier" ? expression.callee.name : null);
+  return name === null ? "This call" : `Function "${name}"`;
+}
 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);
+  return checkSignature(context, expression.args, calleeType, expression.position, callOwner(expression), expression.typeArguments);
 }
 function isSuperCall(expression) {
   return expression.method === null && expression.callee.kind === "identifier" && expression.callee.name === "super";
@@ -19871,14 +20034,14 @@ function checkMethodCall(context, expression, method, receiver) {
       checkValueList(context, expression.args);
       return ANY_TYPE;
     }
-    return checkSignature(context, expression.args, withoutSelfParameter(signature), expression.position);
+    return checkSignature(context, expression.args, withoutSelfParameter(signature), expression.position, callOwner(expression), expression.typeArguments);
   }
   const declared = memberOf(context, receiver, 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);
+    return checkSignature(context, expression.args, declared.type, expression.position, callOwner(expression), expression.typeArguments);
   }
   if (!isMtaElement(context, receiver.name)) {
     checkValueList(context, expression.args);
@@ -20019,8 +20182,9 @@ function checkMultiValueExpression(context, expression, expected = null) {
     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);
+      const built = buildFunctionType(context, expression.parameters, expression.returnAnnotation, contextualFunction(expected));
+      const type = applyTypeParameters(context, built, expression.typeParameters, expression.typeConstraints);
+      checkFunctionBody(context, expression.parameters, expression.returnAnnotation, expression.body, type, null, expression.position);
       return context.record(expression, type);
     }
     case "binary-expression": {
@@ -20109,7 +20273,7 @@ function registerMembers(context, info, statement) {
   }
   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 type = member.kind === "class-field" ? fieldTypes.get(member) ?? ANY_TYPE : member.isSynthetic ? syntheticMethodType(context, member, fieldTypes) : applyTypeParameters(context, buildFunctionType(context, member.parameters, member.returnAnnotation), member.typeParameters, member.typeConstraints);
     const decorators = member.decorators.map((decorator) => decorator.name);
     if (member.kind === "class-method" && isMetamethodMember(member)) {
       checkMetamethod(context, info.name, member, type);
@@ -20169,11 +20333,11 @@ function checkMethodBody(context, info, member) {
     return;
   }
   if (member.isStatic) {
-    checkFunctionBody(context, member.parameters, member.returnAnnotation, member.body, signature, null);
+    checkFunctionBody(context, member.parameters, member.returnAnnotation, member.body, signature, null, member.position);
     return;
   }
   context.pushClassMethod({ className: info.name, methodName: member.name });
-  checkFunctionBody(context, member.parameters, member.returnAnnotation, member.body, signature, selfType(info));
+  checkFunctionBody(context, member.parameters, member.returnAnnotation, member.body, signature, selfType(info), member.position);
   context.popClassMethod();
 }
 function resolveSuperClass(context, statement) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@thigasdevelopment/luam",
-    "version": "0.19.5",
+    "version": "0.19.6",
     "description": "The Luam compiler for Multi Theft Auto resources.",
     "keywords": [
         "mta",