@thigasdevelopment/luam 0.9.0 → 0.10.1

package/luam.mjs

@@ -3534,6 +3534,7 @@ var SYMBOLS = [
   ">",
   "=",
   "|",
+  "&",
   "?",
   "@",
   "(",
@@ -3685,7 +3686,8 @@ function scan(source) {
 }
 
 // ../compiler/src/parser/type-annotation.ts
-var TYPE_KEYWORDS = /* @__PURE__ */ new Set(["nil", "true", "false"]);
+var TYPE_KEYWORDS = /* @__PURE__ */ new Set(["nil"]);
+var BOOLEAN_KEYWORDS = /* @__PURE__ */ new Set(["true", "false"]);
 var FUNCTION_TYPE = "fun";
 function parseTypeName(stream) {
   const token = stream.current();
@@ -3775,11 +3777,24 @@ function parseObjectType(stream) {
   stream.expect("punctuation", "}");
   return { kind: "type-object", members, position: position2 };
 }
+function parseNumberLiteralType(stream) {
+  const sign = stream.check("operator", "-") ? stream.next() : null;
+  const token = stream.expect("number");
+  const value = Number(token.value);
+  return { kind: "type-number-literal", value: sign === null ? value : -value, position: sign?.position ?? token.position };
+}
 function parsePrimaryType(stream) {
   if (stream.check("string")) {
     const token = stream.next();
     return { kind: "type-string-literal", value: token.value, position: token.position };
   }
+  if (stream.check("number") || stream.check("operator", "-") && stream.checkAhead(1, "number")) {
+    return parseNumberLiteralType(stream);
+  }
+  if (stream.check("keyword") && BOOLEAN_KEYWORDS.has(stream.current().value)) {
+    const token = stream.next();
+    return { kind: "type-boolean-literal", value: token.value === "true", position: token.position };
+  }
   if (stream.check("keyword", "function")) {
     throw stream.error(`Use "${FUNCTION_TYPE}" for function types. "function" is a keyword and cannot name a type.`, "parse-invalid-type");
   }
@@ -3809,14 +3824,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 };
 }
@@ -4780,7 +4806,22 @@ function createMap(key, value) {
 function createStringLiteral(value) {
   return { kind: "string-literal", value };
 }
+function createBooleanLiteral(value) {
+  return { kind: "boolean-literal", value };
+}
+function createNumberLiteral(value) {
+  return { kind: "number-literal", value };
+}
+function isLiteralType(type) {
+  return type.kind === "string-literal" || type.kind === "boolean-literal" || type.kind === "number-literal";
+}
 function widenLiteral(type) {
+  if (type.kind === "boolean-literal") {
+    return BOOLEAN_TYPE;
+  }
+  if (type.kind === "number-literal") {
+    return NUMBER_TYPE;
+  }
   return type.kind === "string-literal" ? STRING_TYPE : type;
 }
 function createRecord(name, members, origin = null) {
@@ -4865,6 +4906,9 @@ function typeToString(type) {
   if (type.kind === "string-literal") {
     return `'${type.value.replace(/(['\\])/g, "\\$1")}'`;
   }
+  if (type.kind === "boolean-literal" || type.kind === "number-literal") {
+    return String(type.value);
+  }
   if (type.kind === "named" || type.kind === "record") {
     return type.name;
   }
@@ -4900,13 +4944,13 @@ function isTableLike(type) {
 }
 function isBooleanType(type) {
   const resolved2 = type?.kind === "optional" ? type.element : type;
-  return resolved2?.kind === "boolean";
+  return resolved2?.kind === "boolean" || resolved2?.kind === "boolean-literal";
 }
 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";
+  return type.kind === "number" || type.kind === "number-literal" || type.kind === "any" || type.kind === "unknown" || type.kind === "named";
 }
 function isConcatenable(type) {
   if (type.kind === "union") {
@@ -5001,7 +5045,13 @@ function isAssignable(source, target, options = { allowNil: false }) {
   if (source.kind === "string-literal") {
     return target.kind === "string" || target.kind === "string-literal" && source.value === target.value;
   }
-  if (target.kind === "string-literal") {
+  if (source.kind === "boolean-literal") {
+    return target.kind === "boolean" || target.kind === "boolean-literal" && source.value === target.value;
+  }
+  if (source.kind === "number-literal") {
+    return target.kind === "number" || target.kind === "number-literal" && source.value === target.value;
+  }
+  if (isLiteralType(target)) {
     return false;
   }
   return source.kind === target.kind;
@@ -5987,7 +6037,7 @@ import { tmpdir } from "node:os";
 import { join as join2 } from "node:path";
 
 // src/cli/version.ts
-var VERSION = true ? "0.9.0" : "0.0.0-dev";
+var VERSION = true ? "0.10.1" : "0.0.0-dev";
 var PROGRAM_NAME = "luam";
 var PROGRAM_DESCRIPTION = "luam \u2014 the Luam compiler for Multi Theft Auto resources.";
 
@@ -7186,6 +7236,9 @@ var Binder = class {
   lookupAlias(name) {
     return this.aliases.get(name) ?? null;
   }
+  resolvedAliases() {
+    return new Map([...this.aliases].map(([name, info]) => [name, info.type]));
+  }
 };
 
 // ../mta-types/src/lua-standard.ts
@@ -11021,6 +11074,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") {
@@ -11085,6 +11173,8 @@ var CheckContext = class {
   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;
@@ -11145,6 +11235,12 @@ 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;
     }
@@ -11153,7 +11249,20 @@ var CheckContext = class {
       return;
     }
     this.reported.add(key);
-    this.diagnostics.push(createDiagnostic("checker", code, message, position2));
+    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);
@@ -11212,9 +11321,19 @@ 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);
     }
+    if (annotation.kind === "type-boolean-literal") {
+      return createBooleanLiteral(annotation.value);
+    }
+    if (annotation.kind === "type-number-literal") {
+      return createNumberLiteral(annotation.value);
+    }
     if (annotation.kind === "type-object") {
       const members = /* @__PURE__ */ new Map();
       for (const member of annotation.members) {
@@ -11237,7 +11356,7 @@ var CheckContext = class {
     if (isAssignable(source, target, { allowNil: this.allowNil })) {
       return;
     }
-    const received = target.kind === "string-literal" || target.kind === "union" ? source : widenLiteral(source);
+    const received = isLiteralType(target) || target.kind === "union" ? source : widenLiteral(source);
     const message = `${subject} expects "${typeToString(target)}" but received "${typeToString(received)}".`;
     this.report("check-type-mismatch", `${message}${nilHint(source, target, this.mode)}`, position2);
   }
@@ -11293,6 +11412,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) {
@@ -12277,6 +12397,9 @@ function checkUnary(context, operator, operand, expression) {
   if (operator === "-" && !isNumeric(operand)) {
     reportInvalidOperand(context, operator, operand, expression);
   }
+  if (operator === "-" && operand.kind === "number-literal") {
+    return context.record(expression, createNumberLiteral(-operand.value));
+  }
   return context.record(expression, NUMBER_TYPE);
 }
 
@@ -12304,6 +12427,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,
@@ -12312,7 +12476,8 @@ var EXTENSION_RESULTS = {
   table: TABLE_TYPE
 };
 function extensionType(receiver, property) {
-  const kind = receiver.kind === "string-literal" ? "string" : receiver.kind === "string" || receiver.kind === "number" ? receiver.kind : null;
+  const literal = receiver.kind === "string-literal" ? "string" : receiver.kind === "number-literal" ? "number" : null;
+  const kind = literal ?? (receiver.kind === "string" || receiver.kind === "number" ? receiver.kind : null);
   const target = kind ?? (isTableLike(receiver) ? "table" : null);
   if (target === null) {
     return null;
@@ -12346,6 +12511,12 @@ 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);
   }
@@ -12454,9 +12625,9 @@ function checkMultiValueExpression(context, expression) {
     case "nil-literal":
       return context.record(expression, NIL_TYPE);
     case "boolean-literal":
-      return context.record(expression, BOOLEAN_TYPE);
+      return context.record(expression, createBooleanLiteral(expression.value));
     case "number-literal":
-      return context.record(expression, NUMBER_TYPE);
+      return context.record(expression, createNumberLiteral(expression.value));
     case "string-literal":
       return context.record(expression, createStringLiteral(expression.value));
     case "template-literal":
@@ -12702,6 +12873,53 @@ function checkEnumDeclaration(context, statement) {
   context.declareModuleGlobal({ name: statement.name, type: createNamed(statement.name), isLocal: false, position: statement.position });
 }
 
+// ../compiler/src/checker/discriminant.ts
+function literalValue(expression) {
+  if (expression.kind === "string-literal") {
+    return createStringLiteral(expression.value);
+  }
+  if (expression.kind === "boolean-literal") {
+    return createBooleanLiteral(expression.value);
+  }
+  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 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;
+  }
+  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 = {
@@ -12749,6 +12967,12 @@ function mergeAlternatives(left, right, facts) {
     }
   }
 }
+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);
@@ -12777,6 +13001,8 @@ function collectFacts(context, expression, facts) {
       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;
   }
@@ -12784,6 +13010,8 @@ function collectFacts(context, expression, facts) {
     const name = nilComparison(expression.left, expression.right);
     if (name !== null) {
       present2(context, name, facts);
+    } else {
+      applyDiscriminant(context, expression.left, expression.right, false, facts);
     }
   }
 }
@@ -12824,8 +13052,13 @@ function negatedFacts(context, condition) {
     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);
   }
@@ -13082,7 +13315,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;
     }
@@ -13114,6 +13349,25 @@ function checkStatements(context, statements) {
   }
 }
 
+// ../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);
+    }
+  }
+}
+
 // ../compiler/src/checker/checker.ts
 function externalReferences(context) {
   const external = /* @__PURE__ */ new Map();
@@ -13132,11 +13386,13 @@ 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,
     references: context.references,
     declarations: context.declarations,
+    aliases: context.binder.resolvedAliases(),
     declaredGlobals: context.declaredGlobals,
     externalReferences: externalReferences(context),
     directives: directives.directives,

package/package.json

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