@thigasdevelopment/luam 0.10.0 → 0.10.1

package/luam.mjs

@@ -3686,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();
@@ -3776,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");
   }
@@ -4792,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) {
@@ -4877,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;
   }
@@ -4912,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") {
@@ -5013,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;
@@ -5999,7 +6037,7 @@ import { tmpdir } from "node:os";
 import { join as join2 } from "node:path";
 
 // src/cli/version.ts
-var VERSION = true ? "0.10.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.";
 
@@ -7198,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
@@ -11287,6 +11328,12 @@ var CheckContext = class {
     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) {
@@ -11309,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);
   }
@@ -12350,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);
 }
 
@@ -12426,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;
@@ -12574,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":
@@ -12823,11 +12874,21 @@ function checkEnumDeclaration(context, statement) {
 }
 
 // ../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" || right.kind !== "string-literal") {
+  if (left.kind !== "member-expression" || left.object.kind !== "identifier") {
     return null;
   }
-  return { name: left.object.name, property: left.property, value: createStringLiteral(right.value) };
+  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;
@@ -13331,6 +13392,7 @@ function check(program2, mode, environment = DEFAULT_ENVIRONMENT, options = {})
     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.10.0",
+    "version": "0.10.1",
     "description": "The Luam compiler for Multi Theft Auto resources.",
     "keywords": [
         "mta",