@thigasdevelopment/luam 0.8.2 → 0.10.0

package/luam.mjs

@@ -3534,6 +3534,7 @@ var SYMBOLS = [
   ">",
   "=",
   "|",
+  "&",
   "?",
   "@",
   "(",
@@ -3809,14 +3810,25 @@ function parsePostfixType(stream) {
     return annotation;
   }
 }
-function parseTypeAnnotation(stream) {
+function parseIntersectionType(stream) {
   const first = parsePostfixType(stream);
+  if (!stream.check("operator", "&")) {
+    return first;
+  }
+  const parts = [first];
+  while (stream.match("operator", "&")) {
+    parts.push(parsePostfixType(stream));
+  }
+  return { kind: "type-intersection", parts, position: first.position };
+}
+function parseTypeAnnotation(stream) {
+  const first = parseIntersectionType(stream);
   if (!stream.check("operator", "|")) {
     return first;
   }
   const options = [first];
   while (stream.match("operator", "|")) {
-    options.push(parsePostfixType(stream));
+    options.push(parseIntersectionType(stream));
   }
   return { kind: "type-union", options, position: first.position };
 }
@@ -4774,6 +4786,9 @@ function createArray(element) {
 function createNamed(name) {
   return { kind: "named", name };
 }
+function createMap(key, value) {
+  return { kind: "map", key, value };
+}
 function createStringLiteral(value) {
   return { kind: "string-literal", value };
 }
@@ -4850,6 +4865,9 @@ function typeToString(type) {
   if (type.kind === "array") {
     return `${typeToString(type.element)}[]`;
   }
+  if (type.kind === "map") {
+    return `table<${typeToString(type.key)}, ${typeToString(type.value)}>`;
+  }
   if (type.kind === "optional") {
     return `${typeToString(type.element)}?`;
   }
@@ -4874,17 +4892,38 @@ function typeToString(type) {
   }
   return type.kind;
 }
+function withoutNil(type) {
+  if (type.kind === "optional") {
+    return type.element;
+  }
+  if (type.kind === "union") {
+    return createUnion(type.options.filter((option) => option.kind !== "nil"));
+  }
+  return type;
+}
+function acceptsNil(type) {
+  if (type.kind === "nil" || type.kind === "optional" || type.kind === "any" || type.kind === "unknown") {
+    return true;
+  }
+  return type.kind === "union" && type.options.some((option) => option.kind === "nil");
+}
 function isTableLike(type) {
-  return type.kind === "table" || type.kind === "array";
+  return type.kind === "table" || type.kind === "array" || type.kind === "map";
 }
 function isBooleanType(type) {
   const resolved2 = type?.kind === "optional" ? type.element : type;
   return resolved2?.kind === "boolean";
 }
 function isNumeric(type) {
+  if (type.kind === "union") {
+    return type.options.every(isNumeric);
+  }
   return type.kind === "number" || type.kind === "any" || type.kind === "unknown" || type.kind === "named";
 }
 function isConcatenable(type) {
+  if (type.kind === "union") {
+    return type.options.every(isConcatenable);
+  }
   return type.kind === "string" || type.kind === "string-literal" || isNumeric(type);
 }
 function isFunctionAssignable(source, target, options) {
@@ -4901,6 +4940,18 @@ function isFunctionAssignable(source, target, options) {
   }
   return target.returnType.kind === "void" || isAssignable(source.returnType, target.returnType, options);
 }
+function isMapAssignable(source, target, options) {
+  if (source.kind === "table") {
+    return true;
+  }
+  if (source.kind === "array") {
+    return isAssignable(NUMBER_TYPE, target.key, options) && isAssignable(source.element, target.value, options);
+  }
+  if (source.kind === "record") {
+    return isAssignable(STRING_TYPE, target.key, options) && [...source.members.values()].every((member) => isAssignable(member, target.value, options));
+  }
+  return source.kind === "map" && isAssignable(source.key, target.key, options) && isAssignable(source.value, target.value, options);
+}
 function isRecordAssignable(source, target, options) {
   for (const [name, member] of target.members) {
     const value = source.members.get(name);
@@ -4953,6 +5004,9 @@ function isAssignable(source, target, options = { allowNil: false }) {
   if (target.kind === "array") {
     return source.kind === "table" || source.kind === "array" && isAssignable(source.element, target.element, options);
   }
+  if (target.kind === "map") {
+    return isMapAssignable(source, target, options);
+  }
   if (source.kind === "function" && target.kind === "function") {
     return isFunctionAssignable(source, target, options);
   }
@@ -5012,8 +5066,8 @@ function stringValue(value) {
   return { value, type, truthy: type, falsy: null };
 }
 function unionOf(options) {
-  const present2 = options.filter((option) => option !== null);
-  return present2.length === 0 ? NIL_TYPE : createUnion([...present2]);
+  const present3 = options.filter((option) => option !== null);
+  return present3.length === 0 ? NIL_TYPE : createUnion([...present3]);
 }
 
 // ../runtime/src/helpers.ts
@@ -5945,7 +5999,7 @@ import { tmpdir } from "node:os";
 import { join as join2 } from "node:path";
 
 // src/cli/version.ts
-var VERSION = true ? "0.8.2" : "0.0.0-dev";
+var VERSION = true ? "0.10.0" : "0.0.0-dev";
 var PROGRAM_NAME = "luam";
 var PROGRAM_DESCRIPTION = "luam \u2014 the Luam compiler for Multi Theft Auto resources.";
 
@@ -10979,6 +11033,41 @@ function mtaMember(className, member) {
   return mtaClassRegistry().lookupMember(className, member);
 }
 
+// ../compiler/src/checker/type-intersection.ts
+function namedMembers(context, name) {
+  if (context.declarations.lookupInterface(name) === null && context.declarations.lookupClass(name) === null) {
+    return null;
+  }
+  return new Map(context.declarations.collectMembers(name).map((member) => [member.name, member.type]));
+}
+function partMembers(context, part) {
+  if (part.kind === "record") {
+    return part.members;
+  }
+  return part.kind === "named" ? namedMembers(context, part.name) : null;
+}
+function mergeIntersection(context, parts, position2) {
+  const members = /* @__PURE__ */ new Map();
+  for (const part of parts) {
+    const collected = partMembers(context, part);
+    if (collected === null) {
+      const message = `"${typeToString(part)}" is not an object type, so it cannot take part in an intersection.`;
+      context.report("check-invalid-intersection", message, position2);
+      continue;
+    }
+    for (const [name, type] of collected) {
+      const existing = members.get(name);
+      if (existing !== void 0 && typeToString(existing) !== typeToString(type)) {
+        const message = `Intersection declares "${name}" as both "${typeToString(existing)}" and "${typeToString(type)}".`;
+        context.report("check-conflicting-intersection-member", message, position2);
+        continue;
+      }
+      members.set(name, type);
+    }
+  }
+  return createObjectType(members);
+}
+
 // ../compiler/src/checker/type-substitution.ts
 function substituteType(type, substitutions) {
   if (type.kind === "named") {
@@ -10987,6 +11076,9 @@ function substituteType(type, substitutions) {
   if (type.kind === "array") {
     return createArray(substituteType(type.element, substitutions));
   }
+  if (type.kind === "map") {
+    return createMap(substituteType(type.key, substitutions), substituteType(type.value, substitutions));
+  }
   if (type.kind === "optional") {
     return createOptional(substituteType(type.element, substitutions));
   }
@@ -11021,6 +11113,8 @@ var BUILTIN_TYPES = {
   userdata: USERDATA_TYPE,
   void: VOID_TYPE
 };
+var TABLE_ANNOTATION = "table";
+var MAP_ARGUMENTS = 2;
 var PROJECT_POSITION = { line: 0, column: 0, offset: 0 };
 function nilHint(source, target, mode) {
   if (mode !== "strict" || source.kind !== "nil" || target.kind === "nil" || target.kind === "optional") {
@@ -11032,10 +11126,14 @@ var CheckContext = class {
   binder = new Binder();
   declarations = new DeclarationRegistry();
   diagnostics = [];
+  reported = /* @__PURE__ */ new Set();
+  narrowings = [];
   types = /* @__PURE__ */ new Map();
   references = /* @__PURE__ */ new Set();
   declaredGlobals = /* @__PURE__ */ new Map();
   externalReferences = /* @__PURE__ */ new Map();
+  unknownTypes = /* @__PURE__ */ new Map();
+  typeParameters = /* @__PURE__ */ new Set();
   generatedMembers = /* @__PURE__ */ new Map();
   mode;
   environment;
@@ -11064,6 +11162,26 @@ var CheckContext = class {
     this.binder.declareGlobal(symbol);
     this.declaredGlobals.set(symbol.name, symbol.position);
   }
+  pushNarrowing(facts) {
+    this.narrowings.push(new Map(facts));
+  }
+  popNarrowing() {
+    this.narrowings.pop();
+  }
+  forgetNarrowing(name) {
+    for (const frame of this.narrowings) {
+      frame.delete(name);
+    }
+  }
+  narrowedType(name) {
+    for (let index = this.narrowings.length - 1; index >= 0; index -= 1) {
+      const found = this.narrowings[index]?.get(name);
+      if (found !== void 0) {
+        return found;
+      }
+    }
+    return null;
+  }
   isAmbientClass(name) {
     return this.ambientClasses.has(name);
   }
@@ -11076,10 +11194,34 @@ var CheckContext = class {
     }
   }
   report(code, message, position2) {
+    this.push(code, message, position2, "error");
+  }
+  warn(code, message, position2) {
+    this.push(code, message, position2, "warning");
+  }
+  push(code, message, position2, severity) {
     if (this.mode === "nocheck") {
       return;
     }
-    this.diagnostics.push(createDiagnostic("checker", code, message, position2));
+    const key = `${code}|${position2.offset}|${message}`;
+    if (this.reported.has(key)) {
+      return;
+    }
+    this.reported.add(key);
+    this.diagnostics.push(createDiagnostic("checker", code, message, position2, severity));
+  }
+  noteTypeParameters(names) {
+    for (const name of names) {
+      this.typeParameters.add(name);
+    }
+  }
+  isTypeParameter(name) {
+    return this.typeParameters.has(name);
+  }
+  noteUnknownType(name, position2) {
+    if (!this.unknownTypes.has(name)) {
+      this.unknownTypes.set(name, position2);
+    }
   }
   record(expression, type) {
     this.types.set(expression, type);
@@ -11138,6 +11280,10 @@ var CheckContext = class {
     if (annotation.kind === "type-union") {
       return createUnion(annotation.options.map((option) => this.resolveAnnotation(option)));
     }
+    if (annotation.kind === "type-intersection") {
+      const parts = annotation.parts.map((part) => this.resolveAnnotation(part));
+      return mergeIntersection(this, parts, annotation.position);
+    }
     if (annotation.kind === "type-string-literal") {
       return createStringLiteral(annotation.value);
     }
@@ -11194,9 +11340,24 @@ var CheckContext = class {
       this.binder.declareGlobal({ name: info.name, type: info.type, isLocal: false, position: info.position });
     }
   }
+  resolveMapAnnotation(typeArguments, position2) {
+    const [key, value] = typeArguments;
+    if (key === void 0 || value === void 0 || typeArguments.length !== MAP_ARGUMENTS) {
+      const message = `Type "${TABLE_ANNOTATION}" expects a key type and a value type but received ${typeArguments.length}.`;
+      this.report("check-generic-arity", message, position2);
+      for (const argument of typeArguments) {
+        this.resolveAnnotation(argument);
+      }
+      return TABLE_TYPE;
+    }
+    return createMap(this.resolveAnnotation(key), this.resolveAnnotation(value));
+  }
   resolveNamedAnnotation(name, typeArguments, position2) {
     const builtin = BUILTIN_TYPES[name];
     if (builtin !== void 0) {
+      if (name === TABLE_ANNOTATION && typeArguments.length > 0) {
+        return this.resolveMapAnnotation(typeArguments, position2);
+      }
       if (typeArguments.length > 0) {
         this.report("check-generic-arity", `Type "${name}" does not accept type arguments.`, position2);
       }
@@ -11204,6 +11365,7 @@ var CheckContext = class {
     }
     const alias = this.binder.lookupAlias(name);
     if (alias === null) {
+      this.noteUnknownType(name, position2);
       return createNamed(name);
     }
     if (typeArguments.length !== alias.parameters.length) {
@@ -12154,8 +12316,11 @@ function reportInvalidOperand(context, operator, operand, expression) {
   context.report("check-invalid-operand", `Operator "${operator}" cannot be applied to "${typeToString(operand)}".`, expression.position);
 }
 function checkBinary(context, operator, left, right, expression) {
-  if (operator === "and" || operator === "or") {
-    return context.record(expression, createUnion([left, right]));
+  if (operator === "or") {
+    return context.record(expression, createUnion([withoutNil(left), right]));
+  }
+  if (operator === "and") {
+    return context.record(expression, acceptsNil(left) ? createUnion([right, NIL_TYPE]) : right);
   }
   if (operator === "==" || operator === "~=" || COMPARISON.has(operator)) {
     return context.record(expression, BOOLEAN_TYPE);
@@ -12212,6 +12377,47 @@ 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") {
+    return true;
+  }
+  if (option.kind !== "named") {
+    return false;
+  }
+  return context.declarations.lookupInterface(option.name) !== null || context.declarations.lookupClass(option.name) !== null;
+}
+function memberOf(context, option, property) {
+  if (option.kind === "record") {
+    return option.members.get(property) ?? null;
+  }
+  return option.kind === "named" ? context.declarations.lookupMember(option.name, property)?.type ?? null : null;
+}
+function optionMemberType(context, option, property) {
+  return isShapeOption(context, option) ? memberOf(context, option, property) : null;
+}
+function resolveUnionMember(context, type, expression) {
+  if (!type.options.every((option) => isShapeOption(context, option))) {
+    return null;
+  }
+  const resolved2 = [];
+  const missing = [];
+  for (const option of type.options) {
+    const member = memberOf(context, option, expression.property);
+    if (member === null) {
+      missing.push(`"${typeToString(option)}"`);
+    } else {
+      resolved2.push(member);
+    }
+  }
+  if (missing.length === 0) {
+    return createUnion(resolved2);
+  }
+  const message = `"${expression.property}" is not a key of every member of "${typeToString(type)}". It is missing from ${missing.join(", ")}.`;
+  context.report("check-unknown-union-key", message, expression.position);
+  return ANY_TYPE;
+}
+
 // ../compiler/src/checker/expressions.ts
 var EXTENSION_RESULTS = {
   boolean: BOOLEAN_TYPE,
@@ -12254,6 +12460,15 @@ function checkMember(context, expression) {
   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);
+    }
+  }
+  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);
@@ -12374,13 +12589,17 @@ function checkMultiValueExpression(context, expression) {
       if (symbol === null) {
         checkGlobalReference(context, expression.name, expression.position);
       }
-      return context.record(expression, symbol?.type ?? ANY_TYPE);
+      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);
-      checkExpression(context, expression.index);
+      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":
@@ -12603,20 +12822,210 @@ function checkEnumDeclaration(context, statement) {
   context.declareModuleGlobal({ name: statement.name, type: createNamed(statement.name), isLocal: false, position: statement.position });
 }
 
+// ../compiler/src/checker/discriminant.ts
+function discriminantTest(left, right) {
+  if (left.kind !== "member-expression" || left.object.kind !== "identifier" || right.kind !== "string-literal") {
+    return null;
+  }
+  return { name: left.object.name, property: left.property, value: createStringLiteral(right.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;
+  }
+  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);
+    }
+  }
+  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 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;
+  }
+  const [argument] = expression.args;
+  return argument !== void 0 && argument.kind === "identifier" ? argument.name : null;
+}
+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 nilComparison(left, right) {
+  if (left.kind === "identifier" && right.kind === "nil-literal") {
+    return left.name;
+  }
+  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));
+  }
+}
+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]));
+    }
+  }
+}
+function applyDiscriminant(context, left, right, keep, facts) {
+  const fact = discriminantFact(context, left, right, keep);
+  if (fact !== null) {
+    facts.set(fact[0], fact[1]);
+  }
+}
+function collectFacts(context, expression, facts) {
+  if (expression.kind === "group-expression") {
+    collectFacts(context, expression.expression, facts);
+    return;
+  }
+  if (expression.kind === "identifier") {
+    present2(context, expression.name, facts);
+    return;
+  }
+  if (expression.kind !== "binary-expression") {
+    return;
+  }
+  if (expression.operator === "and") {
+    collectFacts(context, expression.left, facts);
+    collectFacts(context, expression.right, facts);
+    return;
+  }
+  if (expression.operator === "or") {
+    mergeAlternatives(conditionFacts(context, expression.left), conditionFacts(context, expression.right), facts);
+    return;
+  }
+  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.operator === "~=") {
+    const name = nilComparison(expression.left, expression.right);
+    if (name !== null) {
+      present2(context, name, facts);
+    } else {
+      applyDiscriminant(context, expression.left, expression.right, false, facts);
+    }
+  }
+}
+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 (last.kind === "return-statement" || last.kind === "break-statement") {
+    return true;
+  }
+  if (last.kind !== "if-statement" || last.alternate === null) {
+    return false;
+  }
+  return last.clauses.every((clause) => alwaysExits(clause.body)) && alwaysExits(last.alternate);
+}
+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 alwaysExits(clause.body) ? negatedFacts(context, clause.condition) : /* @__PURE__ */ new Map();
+}
+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;
+  }
+  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);
+    }
+  }
+  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 checkNarrowedBlock(context, facts, body) {
+  context.pushNarrowing(facts);
+  checkBlock(context, body);
+  context.popNarrowing();
+}
 function checkIf(context, clauses, alternate) {
   for (const clause of clauses) {
     checkExpression(context, clause.condition);
-    checkBlock(context, clause.body);
+    checkNarrowedBlock(context, conditionFacts(context, clause.condition), clause.body);
   }
-  if (alternate !== null) {
-    checkBlock(context, alternate);
+  if (alternate === null) {
+    return;
   }
+  const [only] = clauses;
+  checkNarrowedBlock(context, clauses.length === 1 && only !== void 0 ? negatedFacts(context, only.condition) : /* @__PURE__ */ new Map(), alternate);
 }
 function checkNumericFor(context, statement) {
   const bounds = [statement.start, statement.limit, statement.step].filter((value) => value !== null);
@@ -12631,13 +13040,30 @@ function checkNumericFor(context, statement) {
   checkStatements(context, statement.body);
   context.binder.popScope();
 }
+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 [];
+  }
+  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 checkGenericFor(context, statement) {
   statement.iterators.forEach((iterator) => checkExpression(context, iterator));
+  const iterated = iteratedTypes(context, statement.iterators);
   context.binder.pushScope();
-  for (const variable of statement.variables) {
-    const declared = variable.annotation === null ? ANY_TYPE : context.resolveAnnotation(variable.annotation);
+  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 });
-  }
+  });
   checkStatements(context, statement.body);
   context.binder.popScope();
 }
@@ -12684,6 +13110,7 @@ function checkLocal(context, statement) {
   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 : widenLiteral(valueType);
       context.binder.declare({ name: declaration.name, type: inferred, isLocal: true, position: declaration.position });
@@ -12724,8 +13151,12 @@ function checkAssignment(context, statement) {
       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, targetType, value.position, "Assignment");
+      context.expectAssignable(valueType, declared, value.position, "Assignment");
+    }
+    if (target.kind === "identifier") {
+      context.forgetNarrowing(target.name);
     }
   });
 }
@@ -12823,7 +13254,9 @@ function checkStatement(context, statement) {
       return checkGenericFor(context, statement);
     case "type-alias-statement": {
       const resolved2 = context.resolveAnnotation(statement.annotation);
-      const named2 = statement.annotation.kind === "type-object" ? renameRecord(resolved2, statement.name) : resolved2;
+      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;
     }
@@ -12840,8 +13273,37 @@ function checkStatement(context, statement) {
   }
 }
 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;
+  }
+}
+
+// ../compiler/src/checker/type-names.ts
+function isDeclaredType(context, name) {
+  const declarations = context.declarations;
+  return declarations.lookupClass(name) !== null || declarations.lookupInterface(name) !== null || declarations.lookupEnum(name) !== null;
+}
+function isKnownTypeName(context, name) {
+  if (context.binder.lookupAlias(name) !== null || context.isTypeParameter(name)) {
+    return true;
+  }
+  return isDeclaredType(context, name) || isMtaClass(name);
+}
+function reportUnknownTypes(context) {
+  for (const [name, position2] of context.unknownTypes) {
+    if (!isKnownTypeName(context, name)) {
+      context.warn("check-unknown-type", `Type "${name}" is not defined.`, position2);
+    }
   }
 }
 
@@ -12863,6 +13325,7 @@ function check(program2, mode, environment = DEFAULT_ENVIRONMENT, options = {})
   const structure = context.isDeclarationFile ? checkDeclarationFile(program2.body) : checkJumps(program2.body);
   const directives = collectDirectives(program2.body, { isDeclarationFile: context.isDeclarationFile });
   checkStatements(context, program2.body);
+  reportUnknownTypes(context);
   return {
     diagnostics: sortDiagnostics([...structure, ...directives.diagnostics, ...context.diagnostics]),
     types: context.types,

package/package.json

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