@tilua/compiler 2.3.0 → 3.0.0

package/dist/{chunk-HE6YH7U3.js → chunk-X4DM2BX2.js}

@@ -21,10 +21,10 @@ var nil = () => ({ type: "NilLiteral", ...span() });
 var boolean = (value) => ({ type: "BooleanLiteral", value, ...span() });
 var number = (value, raw = String(value)) => ({ type: "NumberLiteral", value, raw, ...span() });
 var string = (value) => ({ type: "StringLiteral", value, raw: "", ...span() });
-var member = (object, property) => isLuauName(property) ? { type: "MemberExpression", object, property: identifier(property), ...span() } : index(object, string(property));
-var index = (object, key) => ({ type: "IndexExpression", object, index: key, ...span() });
+var member = (object2, property) => isLuauName(property) ? { type: "MemberExpression", object: object2, property: identifier(property), ...span() } : index(object2, string(property));
+var index = (object2, key) => ({ type: "IndexExpression", object: object2, index: key, ...span() });
 var call = (callee, args) => ({ type: "CallExpression", callee, arguments: args, ...span() });
-var methodCall = (object, method, args) => ({ type: "MethodCallExpression", object, method: identifier(method), arguments: args, ...span() });
+var methodCall = (object2, method, args) => ({ type: "MethodCallExpression", object: object2, method: identifier(method), arguments: args, ...span() });
 var functionExpression = (func) => ({ type: "FunctionExpression", func, ...span() });
 var binary = (operator, left, right) => ({ type: "BinaryExpression", operator, left, right, ...span() });
 var unary = (operator, argument) => ({ type: "UnaryExpression", operator, argument, ...span() });
@@ -140,6 +140,62 @@ var Names = class _Names {
   }
 };
 
+// src/language.ts
+import { readFileSync } from "fs";
+var read = (name) => readFileSync(new URL(`../runtime/${name}`, import.meta.url), "utf8");
+var implemented = (source) => new Set([...source.matchAll(/function __NAME__\.(\w+)/g)].map((m) => m[1]));
+var array = read("array.luau");
+var string2 = read("string.luau");
+var object = read("object.luau");
+var arrayMethods = implemented(array);
+var stringMethods = implemented(string2);
+var objectMethods = implemented(object);
+function every(type, is, seen = /* @__PURE__ */ new Set()) {
+  if (!type || seen.has(type)) return false;
+  seen.add(type);
+  if (type.kind === "union") {
+    return type.types.filter((m) => !(m.kind === "primitive" && m.name === "nil")).every((m) => every(m, is, seen));
+  }
+  if (type.kind === "typeParam") return every(type.constraint, is, seen);
+  return is(type);
+}
+var isArray = (type) => every(type, (t) => t.kind === "array" || t.kind === "tuple");
+var isString = (type) => every(type, (t) => t.kind === "primitive" && t.name === "string" || t.kind === "literal" && t.base === "string" || t.kind === "templateLiteral");
+function objectKeys(type) {
+  const members = type?.kind === "union" ? type.types : type ? [type] : [];
+  const orders = [];
+  let open = false;
+  for (const member2 of members) {
+    const keys = [];
+    for (const part of member2.kind === "intersection" ? member2.types : [member2]) {
+      if (part.kind !== "object") continue;
+      for (const key of part.properties.keys()) if (!keys.includes(key)) keys.push(key);
+      if (part.indexer) open = true;
+    }
+    orders.push(keys);
+  }
+  const order = JSON.stringify(orders[0] ?? []);
+  const known = orders.length && orders.every((keys) => JSON.stringify(keys) === order) ? `{ ${orders[0].map((key) => JSON.stringify(key)).join(", ")} }` : "nil";
+  return { known, open: String(open) };
+}
+var plugin = {
+  runtime: { array, string: string2, object },
+  methodCall({ method, receiver, use }) {
+    if (isString(receiver)) {
+      return stringMethods.has(method) ? { callee: `${use("string")}.${method}` } : void 0;
+    }
+    if (isArray(receiver)) {
+      return arrayMethods.has(method) ? { callee: `${use("array")}.${method}` } : void 0;
+    }
+    if (objectMethods.has(method)) {
+      const keys = objectKeys(receiver);
+      return { callee: `${use("object")}.${method}`, prepend: [keys.known, keys.open] };
+    }
+    return void 0;
+  }
+};
+var languageLowering = { plugin, from: "tilua" };
+
 // src/lower.ts
 function lower(program2, scopes, options = {}) {
   return new Lowerer(program2, scopes, options).run();
@@ -323,21 +379,34 @@ var Lowerer = class {
     if (id === void 0) return node.name;
     return this.scopes.bindings.get(id)?.kind === "global" ? node.name : void 0;
   }
-  /** What a library says `receiver:method(...)` is. The last library
-   *  loaded is asked first, so a project's own library can answer for a
-   *  method an earlier one also claims; no answer leaves an ordinary Luau
-   *  method call, which is what a value that answers to the method itself
-   *  wants (`text:upper()`). */
+  /** The language's own lowering, then each library's, in load order. A
+   *  runtime is named by its lowering's place here (`loweringRuntime`). */
+  get lowerings() {
+    return this.allLowerings ??= [languageLowering, ...this.options.lowerings ?? []];
+  }
+  allLowerings;
+  /** What `receiver:method(...)` becomes, when Luau alone would not run it.
+   *
+   *  A method the receiver's metatable gave it — the analyzer says so, and
+   *  whose metatable it was (`methodSources`) — is asked of whoever declared
+   *  that metatable, and only them: the language lowers its own
+   *  (`names:filter(f)` becomes a call into its runtime), a library its own,
+   *  and one the program declared is taken at its word. Any other method is
+   *  a member of the receiver's own, which a library may still claim
+   *  (`console:log`), the last library loaded first. No answer leaves an
+   *  ordinary Luau method call: `text:upper()` reaches Lua's own. */
   loweredMethodCall(node) {
-    const lowerings = this.options.lowerings;
-    if (!lowerings?.some((l) => l.plugin.methodCall)) return void 0;
+    const lowerings = this.lowerings;
+    const source = this.options.types?.methodSources.get(node);
+    const asked = source?.origin === "language" ? [0] : source?.origin === "library" ? lowerings.flatMap((l, i) => l.library === source.library ? [i] : []) : source?.origin === "program" ? [] : lowerings.map((_, i) => i).slice(1).reverse();
+    if (!asked.some((i) => lowerings[i].plugin.methodCall)) return void 0;
     const receiver = this.options.types?.typeOf.get(node.object);
     const receiverGlobal = this.globalName(node.object);
     const info = this.lazyArguments(node.arguments);
-    for (let i = lowerings.length - 1; i >= 0; i--) {
-      const plugin = lowerings[i].plugin;
-      if (!plugin.methodCall) continue;
-      const answer = plugin.methodCall({
+    for (const i of asked) {
+      const plugin2 = lowerings[i].plugin;
+      if (!plugin2.methodCall) continue;
+      const answer = plugin2.methodCall({
         method: node.method.name,
         receiver,
         receiverGlobal,
@@ -360,15 +429,15 @@ var Lowerer = class {
   }
   /** What a library says a call to a global — `print(x)` — is. */
   loweredGlobalCall(node) {
-    const lowerings = this.options.lowerings;
+    const lowerings = this.lowerings;
     if (!lowerings?.some((l) => l.plugin.globalCall)) return void 0;
     const name = this.globalName(node.callee);
     if (name === void 0) return void 0;
     const info = this.lazyArguments(node.arguments);
     for (let i = lowerings.length - 1; i >= 0; i--) {
-      const plugin = lowerings[i].plugin;
-      if (!plugin.globalCall) continue;
-      const answer = plugin.globalCall({
+      const plugin2 = lowerings[i].plugin;
+      if (!plugin2.globalCall) continue;
+      const answer = plugin2.globalCall({
         name,
         at: this.callSite(node.callee),
         get arguments() {
@@ -382,7 +451,7 @@ var Lowerer = class {
   }
   /** What a library says a global read as a value — `local p = print` — is. */
   loweredGlobalValue(node) {
-    const lowerings = this.options.lowerings;
+    const lowerings = this.lowerings;
     if (!lowerings?.some((l) => l.plugin.globalValue)) return void 0;
     const name = this.globalName(node);
     if (name === void 0) return void 0;
@@ -412,7 +481,7 @@ var Lowerer = class {
     try {
       return parseExpressionFromSource(source);
     } catch (error) {
-      this.report(node, `'${this.options.lowerings[index2].from}' lowered this to Luau that does not parse: ${JSON.stringify(source)} (${error.message})`);
+      this.report(node, `'${this.lowerings[index2].from}' lowered this to Luau that does not parse: ${JSON.stringify(source)} (${error.message})`);
       return void 0;
     }
   }
@@ -433,8 +502,8 @@ var Lowerer = class {
       ], true)));
     }
     for (const { index: index2, runtime: runtime2, name } of this.loweringUsed) {
-      const { plugin, from } = this.options.lowerings[index2];
-      const source = plugin.runtime?.[runtime2];
+      const { plugin: plugin2, from } = this.lowerings[index2];
+      const source = plugin2.runtime?.[runtime2];
       if (source === void 0) {
         this.diagnostics.push({
           message: `'${from}' asked for a runtime it does not have: '${runtime2}'`,
@@ -769,6 +838,7 @@ var Lowerer = class {
       case "ExportTypeAliasStatement":
       case "DeclareStatement":
       case "DeclareClassStatement":
+      case "DeclareMetatableStatement":
       case "ErrorStatement":
         return [];
       case "VariableDeclaration":
@@ -846,12 +916,13 @@ var Lowerer = class {
         }];
       case "GenericForStatement": {
         const prelude = [];
+        const variable = declared(node.variable);
         let item;
-        if (node.variable.type === "IdentifierPattern") {
-          item = this.name(node.variable.name);
+        if (variable.type === "IdentifierPattern") {
+          item = this.name(variable.name);
         } else {
           item = this.names.fresh("item");
-          prelude.push(...this.destructure(node.variable, identifier(item), "declare"));
+          prelude.push(...this.destructure(variable, identifier(item), "declare"));
         }
         const form = this.options.types?.loops.get(node) ?? { walks: "values", viaIter: false };
         let source = this.expression(node.iterator);
@@ -1118,7 +1189,7 @@ end
    *  level, where every name is declared up front — nothing is declared,
    *  only assigned. */
   variableDeclaration(node, mode) {
-    const target = node.name;
+    const target = declared(node.name);
     if (!node.init) {
       const names = identifierPatterns(target);
       if (mode === "declare") return [local(names.map((p) => this.name(p.name)), [])];
@@ -1160,6 +1231,12 @@ end
     const reads = [];
     const after = [];
     const bind = (target, value, fallback) => {
+      if (target.type === "MemberExpression" || target.type === "IndexExpression") {
+        const reference = this.expression(target);
+        reads.push({ name: "", target: reference, value, temp: false });
+        if (fallback) after.push(this.defaultValue(reference, fallback));
+        return;
+      }
       if (target.type === "IdentifierPattern") {
         const name2 = this.name(target.name);
         const reference = mode === "declare" ? identifier(name2) : this.reference(target);
@@ -1232,6 +1309,11 @@ end
    *  a temporary that a nested pattern then destructures (`then`). The
    *  statement creating it is pushed onto `after`. */
   restTarget(target, initial, mode, after) {
+    if (target.type === "MemberExpression" || target.type === "IndexExpression") {
+      const reference = this.expression(target);
+      after.push(assign([reference], [initial]));
+      return { target: reference, then: [] };
+    }
     if (target.type === "IdentifierPattern") {
       if (mode === "declare") {
         const name2 = this.name(target.name);
@@ -1357,11 +1439,11 @@ end
   callValues(node) {
     const chain = optionalChain(node);
     if (chain) return this.optionalChainExpression(chain);
-    const object = linkObject(node);
-    if (node.type === "CallExpression" && object.type === "Identifier") {
-      return this.link(node, this.reference(object));
+    const object2 = linkObject(node);
+    if (node.type === "CallExpression" && object2.type === "Identifier") {
+      return this.link(node, this.reference(object2));
     }
-    return this.link(node, this.expression(object));
+    return this.link(node, this.expression(object2));
   }
   /** A call is one value in tilua, and Luau would hand on every value one
    *  returns in the last place of an argument list or a `return`: it is
@@ -1380,11 +1462,13 @@ end
    *  the last value of a list expands, so the whole list is built as an
    *  array first and that is what expands. A call written last is one
    *  value — see `keptToOne`. */
-  arguments(list) {
+  arguments(written) {
+    const { items: list, many } = packs(written);
     const spreads = list.filter((a) => a.type === "SpreadElement");
     if (!spreads.length) {
       const lowered = list.map((a) => this.expression(a));
-      return lowered.length ? [...lowered.slice(0, -1), this.keptToOne(lowered[lowered.length - 1])] : lowered;
+      const last2 = list.length - 1;
+      return lowered.length && !many.has(list[last2]) ? [...lowered.slice(0, -1), this.keptToOne(lowered[last2])] : lowered;
     }
     const unpack = (value) => call(member(this.builtin("table"), "unpack"), [value]);
     const last = list[list.length - 1];
@@ -1398,16 +1482,16 @@ end
     }))];
   }
   /** One link of an access chain, read from `object`. */
-  link(node, object) {
+  link(node, object2) {
     switch (node.type) {
       case "MemberExpression":
-        return member(object, node.property.name);
+        return member(object2, node.property.name);
       case "IndexExpression":
-        return index(object, this.expression(node.index));
+        return index(object2, this.expression(node.index));
       case "CallExpression": {
         const lowered = this.loweredGlobalCall(node);
         const args = this.arguments(node.arguments);
-        if (!lowered) return call(object, args);
+        if (!lowered) return call(object2, args);
         return call(calleePath(lowered.callee), [...lowered.prepend, ...args]);
       }
       case "MethodCallExpression": {
@@ -1416,14 +1500,14 @@ end
         if (lowered) {
           return call(calleePath(lowered.callee), [
             ...lowered.prepend,
-            ...lowered.passReceiver ? [object] : [],
+            ...lowered.passReceiver ? [object2] : [],
             ...args
           ]);
         }
         if (!isLuauName(node.method.name)) {
           this.report(node.method, `'${node.method.name}' is a Luau keyword and cannot be called with ':'`);
         }
-        return methodCall(object, node.method.name, args);
+        return methodCall(object2, node.method.name, args);
       }
     }
   }
@@ -1444,8 +1528,8 @@ end
     }
     return out;
   }
-  applySegment(segment, object) {
-    return segment.reduce((value, link) => this.link(link, value), object);
+  applySegment(segment, object2) {
+    return segment.reduce((value, link) => this.link(link, value), object2);
   }
   /** `a?.b:m()` as a statement:
    *  `do local ref = a if ref ~= nil then ref.b:m() end end` */
@@ -1521,9 +1605,9 @@ end
     const before = [];
     let target;
     if (node.target.type === "MemberExpression" || node.target.type === "IndexExpression") {
-      const object = this.expression(node.target.object);
+      const object2 = this.expression(node.target.object);
       const objectName = this.names.fresh("target");
-      before.push(local([objectName], [object]));
+      before.push(local([objectName], [object2]));
       if (node.target.type === "MemberExpression") {
         target = member(identifier(objectName), node.target.property.name);
       } else {
@@ -1645,8 +1729,9 @@ end
   /** `[1, ...xs, 2]`. Without a spread it is a Luau sequence; with one, the
    *  runs of plain elements and the spread arrays are joined by `concat`. */
   arrayExpression(node) {
-    if (!node.elements.some((e) => e.type === "SpreadElement")) {
-      return table(node.elements.map((e) => ({ type: "TableFieldPositional", value: this.expression(e) })));
+    const elements = packs(node.elements).items;
+    if (!elements.some((e) => e.type === "SpreadElement")) {
+      return table(elements.map((e) => ({ type: "TableFieldPositional", value: this.expression(e) })));
     }
     const parts = [];
     let current = [];
@@ -1658,7 +1743,7 @@ end
       })));
       current = [];
     };
-    for (const element of node.elements) {
+    for (const element of elements) {
       if (element.type === "SpreadElement") {
         flush(false);
         parts.push(this.expression(element.argument));
@@ -1670,6 +1755,29 @@ end
     return call(this.helper("concat"), parts);
   }
 };
+function packs(list) {
+  const items = [];
+  const many = /* @__PURE__ */ new Set();
+  const add = (elements) => {
+    for (const element of elements) {
+      if (element.type === "SpreadElement" && element.argument.type === "ArrayExpression") {
+        const inner = element.argument.elements;
+        add(inner);
+        const last = inner[inner.length - 1];
+        if (last && (last.type === "CallExpression" || last.type === "MethodCallExpression")) many.add(last);
+      } else {
+        items.push(element);
+      }
+    }
+  };
+  add(list);
+  items.forEach((item, i) => {
+    if (!many.has(item) || i === items.length - 1) return;
+    many.delete(item);
+    items[i] = { type: "SpreadElement", argument: { type: "ArrayExpression", elements: [item], ...spanOf(item) }, ...spanOf(item) };
+  });
+  return { items, many };
+}
 function isLink(node) {
   return node.type === "MemberExpression" || node.type === "IndexExpression" || node.type === "CallExpression" || node.type === "MethodCallExpression";
 }
@@ -1718,10 +1826,19 @@ function memberChain(e) {
   }
   return void 0;
 }
+function declared(target) {
+  if (target.type === "MemberExpression" || target.type === "IndexExpression") {
+    throw new Error("a declaration binds names, not a member or an index");
+  }
+  return target;
+}
 function identifierPatterns(target) {
   switch (target.type) {
     case "IdentifierPattern":
       return [target];
+    case "MemberExpression":
+    case "IndexExpression":
+      return [];
     case "ObjectPattern":
       return [...target.properties.flatMap((p) => identifierPatterns(p.value)), ...target.rest ? identifierPatterns(target.rest) : []];
     case "ArrayPattern":
@@ -1871,15 +1988,15 @@ async function loadLowerings(modules) {
   for (const module of modules) {
     try {
       const loaded = await import(pathToFileURL(module.file).href);
-      const plugin = loaded.default;
-      if (!plugin || typeof plugin !== "object") {
+      const plugin2 = loaded.default;
+      if (!plugin2 || typeof plugin2 !== "object") {
         problems.push({
           file: module.file,
           message: `'${module.from}' lowering module has no default export`
         });
         continue;
       }
-      lowerings.push({ plugin, from: module.from });
+      lowerings.push({ plugin: plugin2, from: module.from, library: module.library });
     } catch (error) {
       problems.push({
         file: module.file,
@@ -1891,7 +2008,7 @@ async function loadLowerings(modules) {
 }
 
 // src/bundle.ts
-import { readFileSync, statSync } from "fs";
+import { readFileSync as readFileSync2, statSync } from "fs";
 import { dirname, relative, resolve as resolve2 } from "path";
 import {
   parse,
@@ -2202,7 +2319,7 @@ function parseFile(file, diagnostics, directives) {
   }
   let text;
   try {
-    text = readFileSync(file, "utf8");
+    text = readFileSync2(file, "utf8");
   } catch {
     diagnostics.push({ file, message: "Cannot read file", line: 1, column: 1, category: "module" });
     return void 0;
@@ -2236,7 +2353,7 @@ function parsedLibrary(file) {
   }
   const cached = libraryCache.get(file);
   if (cached && cached.stamp === stamp) return cached.program;
-  const program2 = parse(readFileSync(file, "utf8"));
+  const program2 = parse(readFileSync2(file, "utf8"));
   libraryCache.set(file, { stamp, program: program2 });
   return program2;
 }
@@ -2259,7 +2376,7 @@ function analyzeModules(modules, config) {
     const done = analyzed.get(file);
     if (done) return done;
     const remembered = moduleAnalyses.get(file);
-    if (remembered && remembered.setting === settingFor && libs.length === remembered.libs.length && remembered.libs.every((lib, i) => lib === libs[i]) && remembered.program === program2 && [...remembered.read].every(([read, stamp]) => stampOf(read) === stamp)) {
+    if (remembered && remembered.setting === settingFor && libs.length === remembered.libs.length && remembered.libs.every((lib, i) => lib === libs[i]) && remembered.program === program2 && [...remembered.read].every(([read2, stamp]) => stampOf(read2) === stamp)) {
       analyzed.set(file, remembered.result);
       readWhile.set(file, remembered.read);
       return remembered.result;
@@ -2283,12 +2400,12 @@ function analyzeModules(modules, config) {
     const result = { types, diagnostics: said };
     if (partials === before) {
       analyzed.set(file, result);
-      const read = readWhile.get(file) ?? /* @__PURE__ */ new Map();
+      const read2 = readWhile.get(file) ?? /* @__PURE__ */ new Map();
       const own = stampOf(file);
-      if (own !== void 0) read.set(file, own);
-      readWhile.set(file, read);
-      if ([...read.values()].every((stamp) => stamp !== void 0)) {
-        moduleAnalyses.set(file, { setting: settingFor, libs: [...libs], program: program2, read, result });
+      if (own !== void 0) read2.set(file, own);
+      readWhile.set(file, read2);
+      if ([...read2.values()].every((stamp) => stamp !== void 0)) {
+        moduleAnalyses.set(file, { setting: settingFor, libs: [...libs], program: program2, read: read2, result });
       }
     }
     return result;
@@ -2297,11 +2414,11 @@ function analyzeModules(modules, config) {
     const target = resolveModulePath(file, specifier, config);
     if (!target) return void 0;
     const noteRead = () => {
-      const read = readWhile.get(file) ?? /* @__PURE__ */ new Map();
-      readWhile.set(file, read);
+      const read2 = readWhile.get(file) ?? /* @__PURE__ */ new Map();
+      readWhile.set(file, read2);
       const stamp = stampOf(target);
-      if (stamp !== void 0) read.set(target, stamp);
-      for (const [below, belowStamp] of readWhile.get(target) ?? []) read.set(below, belowStamp);
+      if (stamp !== void 0) read2.set(target, stamp);
+      for (const [below, belowStamp] of readWhile.get(target) ?? []) read2.set(below, belowStamp);
     };
     if (inProgress.has(target)) {
       partials++;
@@ -2315,7 +2432,7 @@ function analyzeModules(modules, config) {
     let program2 = byFile.get(target)?.program;
     if (!program2) {
       try {
-        program2 = parse(readFileSync(target, "utf8"));
+        program2 = parse(readFileSync2(target, "utf8"));
       } catch {
         return void 0;
       }