@tilua/compiler 2.3.0 → 2.4.0

package/dist/{chunk-HE6YH7U3.js → chunk-3ZQ3EITC.js}

@@ -846,12 +846,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 +1119,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 +1161,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 +1239,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);
@@ -1380,11 +1392,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];
@@ -1645,8 +1659,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 +1673,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 +1685,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 +1756,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":

package/dist/cli.cjs

@@ -858,12 +858,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);
@@ -1130,7 +1131,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)), [])];
@@ -1172,6 +1173,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);
@@ -1244,6 +1251,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);
@@ -1392,11 +1404,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];
@@ -1657,8 +1671,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 = [];
@@ -1670,7 +1685,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));
@@ -1682,6 +1697,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";
 }
@@ -1730,10 +1768,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":

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   bundle
-} from "./chunk-HE6YH7U3.js";
+} from "./chunk-3ZQ3EITC.js";
 
 // src/cli.ts
 import { writeFileSync } from "fs";

package/dist/index.cjs

@@ -882,12 +882,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);
@@ -1154,7 +1155,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)), [])];
@@ -1196,6 +1197,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);
@@ -1268,6 +1275,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);
@@ -1416,11 +1428,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];
@@ -1681,8 +1695,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 = [];
@@ -1694,7 +1709,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));
@@ -1706,6 +1721,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";
 }
@@ -1754,10 +1792,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":

package/dist/index.js

@@ -4,7 +4,7 @@ import {
   lower,
   program,
   resolveConfig
-} from "./chunk-HE6YH7U3.js";
+} from "./chunk-3ZQ3EITC.js";
 
 // src/compile.ts
 import { readFileSync } from "fs";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tilua/compiler",
-  "version": "2.3.0",
+  "version": "2.4.0",
   "description": "Compiles tilua to Luau: lowers the @tilua/parser AST to a luau-parser AST and prints it",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -37,7 +37,7 @@
   "type": "module",
   "dependencies": {
     "luau-parser": "^1.0.3",
-    "@tilua/parser": "^2.3.0"
+    "@tilua/parser": "^2.4.0"
   },
   "devDependencies": {
     "@types/node": "^22.20.2",