@thigasdevelopment/luam 0.8.2 → 0.9.0

package/luam.mjs

@@ -4774,6 +4774,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 +4853,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 +4880,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 +4928,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 +4992,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 +5054,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 +5987,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.9.0" : "0.0.0-dev";
 var PROGRAM_NAME = "luam";
 var PROGRAM_DESCRIPTION = "luam \u2014 the Luam compiler for Multi Theft Auto resources.";
 
@@ -10987,6 +11029,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 +11066,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,6 +11079,8 @@ 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();
@@ -11064,6 +11113,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);
   }
@@ -11079,6 +11148,11 @@ var CheckContext = class {
     if (this.mode === "nocheck") {
       return;
     }
+    const key = `${code}|${position2.offset}|${message}`;
+    if (this.reported.has(key)) {
+      return;
+    }
+    this.reported.add(key);
     this.diagnostics.push(createDiagnostic("checker", code, message, position2));
   }
   record(expression, type) {
@@ -11194,9 +11268,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);
       }
@@ -12154,8 +12243,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);
@@ -12254,6 +12346,9 @@ function checkMember(context, expression) {
   if (objectType.kind === "record") {
     return context.record(expression, resolveRecordMember(context, objectType, expression));
   }
+  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 +12469,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 +12702,158 @@ function checkEnumDeclaration(context, statement) {
   context.declareModuleGlobal({ name: statement.name, type: createNamed(statement.name), isLocal: false, position: statement.position });
 }
 
+// ../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 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);
+    }
+    return;
+  }
+  if (expression.operator === "~=") {
+    const name = nilComparison(expression.left, expression.right);
+    if (name !== null) {
+      present2(context, name, 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);
+    }
+  }
+  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 +12868,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 +12938,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 +12979,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);
     }
   });
 }
@@ -12840,8 +13099,18 @@ 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;
   }
 }
 

package/package.json

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