@thigasdevelopment/luam 0.9.0 → 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 };
 }
@@ -5987,7 +5999,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.0" : "0.0.0-dev";
 var PROGRAM_NAME = "luam";
 var PROGRAM_DESCRIPTION = "luam \u2014 the Luam compiler for Multi Theft Auto resources.";
 
@@ -11021,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") {
@@ -11085,6 +11132,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 +11194,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 +11208,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,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);
     }
@@ -11293,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) {
@@ -12304,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,
@@ -12346,6 +12460,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);
   }
@@ -12702,6 +12822,43 @@ 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 = {
@@ -12749,6 +12906,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 +12940,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 +12949,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 +12991,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 +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;
     }
@@ -13114,6 +13288,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,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.9.0",
+    "version": "0.10.0",
     "description": "The Luam compiler for Multi Theft Auto resources.",
     "keywords": [
         "mta",