@tilua/compiler 2.1.0 → 2.3.0

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

@@ -262,12 +262,10 @@ var Lowerer = class {
       for (const node of allNodes(this.source.body)) {
         const statement = node;
         if (statement.type === "VariableDeclaration") {
-          statement.names.forEach((target, index2) => {
-            const value = statement.init[index2];
-            if (target.type !== "IdentifierPattern" || !value) return;
-            const binding = this.bindingByDeclaration.get(target);
-            if (binding) this.declarations.set(binding.id, value);
-          });
+          const target = statement.name;
+          if (target.type !== "IdentifierPattern" || !statement.init) continue;
+          const binding = this.bindingByDeclaration.get(target);
+          if (binding) this.declarations.set(binding.id, statement.init);
         } else if (statement.type === "FunctionDeclaration") {
           const binding = this.bindingByDeclaration.get(statement.name);
           if (binding) this.declarations.set(binding.id, statement);
@@ -541,7 +539,7 @@ var Lowerer = class {
           const declaration = statement.declaration;
           if (declaration.type === "FunctionDeclaration" || declaration.type === "ClassDeclaration") {
             exportBinding(declaration.name, declaration.name.name);
-          } else for (const pattern of declaration.names.flatMap(identifierPatterns)) exportBinding(pattern, pattern.name);
+          } else for (const pattern of identifierPatterns(declaration.name)) exportBinding(pattern, pattern.name);
           break;
         }
         case "ExportDefaultStatement":
@@ -577,7 +575,7 @@ var Lowerer = class {
     for (const statement of statements) {
       const declaration = statement.type === "ExportStatement" ? statement.declaration : statement;
       if (declaration.type === "VariableDeclaration") {
-        for (const pattern of declaration.names.flatMap(identifierPatterns)) {
+        for (const pattern of identifierPatterns(declaration.name)) {
           if (!this.isRewritten(pattern)) locals.push(this.name(pattern.name));
         }
       } else if ((declaration.type === "FunctionDeclaration" || declaration.type === "ClassDeclaration") && !this.isRewritten(declaration.name)) {
@@ -674,7 +672,7 @@ var Lowerer = class {
         continue;
       }
       if (statement.type !== "VariableDeclaration") continue;
-      const patterns = statement.names.flatMap(identifierPatterns);
+      const patterns = identifierPatterns(statement.name);
       const end = { line: { start: statement.line.end }, column: { start: statement.column.end } };
       const needed = patterns.some((pattern) => {
         const binding = this.bindingByDeclaration.get(pattern);
@@ -715,7 +713,7 @@ var Lowerer = class {
     const body = [];
     for (const statement of statements) {
       if (statement.type === "VariableDeclaration") {
-        for (const pattern of statement.names.flatMap(identifierPatterns)) locals.push(this.name(pattern.name));
+        for (const pattern of identifierPatterns(statement.name)) locals.push(this.name(pattern.name));
         body.push(...this.variableDeclaration(statement, "assign"));
       } else if (statement.type === "FunctionDeclaration") {
         locals.push(this.name(statement.name.name));
@@ -867,7 +865,7 @@ var Lowerer = class {
         )];
       }
       case "ReturnStatement":
-        return [returns(node.argument ? [this.expression(node.argument)] : [])];
+        return [returns(node.argument ? [this.keptToOne(this.expression(node.argument))] : [])];
       case "BreakStatement":
         return [{ type: "BreakStatement", ...spanOf(node) }];
       case "ContinueStatement":
@@ -1116,63 +1114,37 @@ end
       ...spanOf(node)
     };
   }
-  /** `const a, { b } = x, y`. In "assign" mode — a module's top level, where
-   *  every name is declared up front — nothing is declared, only assigned. */
+  /** `const a = x`, `const { a, b } = x`. In "assign" mode — a module's top
+   *  level, where every name is declared up front — nothing is declared,
+   *  only assigned. */
   variableDeclaration(node, mode) {
-    if (mode === "assign" && !node.init.length) {
-      const exported = node.names.flatMap(identifierPatterns).filter((p) => this.isRewritten(p));
+    const target = node.name;
+    if (!node.init) {
+      const names = identifierPatterns(target);
+      if (mode === "declare") return [local(names.map((p) => this.name(p.name)), [])];
+      const exported = names.filter((p) => this.isRewritten(p));
       return exported.length ? [assign(exported.map((p) => this.reference(p)), exported.map(() => nil()))] : [];
     }
-    const init = this.values(node.init);
-    if (node.names.every((n) => n.type === "IdentifierPattern")) {
-      const names2 = node.names;
-      return mode === "declare" ? [local(names2.map((n) => this.name(n.name)), init)] : [assign(names2.map((n) => this.reference(n)), init)];
-    }
-    const only = node.names.length === 1 && node.init.length === 1 ? node.names[0] : void 0;
-    if (only && only.type !== "IdentifierPattern") {
-      if (init[0].type === "Identifier") return this.destructure(only, init[0], mode);
-      const temp = this.names.fresh("ref");
-      return [local([temp], init), ...this.destructure(only, identifier(temp), mode)];
-    }
-    const after = [];
-    const names = [];
-    const targets = [];
-    for (const target of node.names) {
-      if (target.type === "IdentifierPattern") {
-        names.push(this.name(target.name));
-        targets.push(this.reference(target));
-        continue;
-      }
-      const temp = this.names.fresh("ref");
-      names.push(temp);
-      targets.push(identifier(temp));
-      after.push(...this.destructure(target, identifier(temp), mode));
+    const value = this.expression(node.init);
+    if (target.type === "IdentifierPattern") {
+      return mode === "declare" ? [local([this.name(target.name)], [value])] : [assign([this.reference(target)], [value])];
     }
-    if (mode === "declare") return [local(names, init), ...after];
-    const temps = node.names.flatMap((t, i) => t.type === "IdentifierPattern" ? [] : [names[i]]);
-    return [...temps.length ? [local(temps, [])] : [], assign(targets, init), ...after];
+    if (value.type === "Identifier") return this.destructure(target, value, mode);
+    const temp = this.names.fresh("ref");
+    return [local([temp], [value]), ...this.destructure(target, identifier(temp), mode)];
   }
   assignment(node) {
-    if (node.targets.every((t) => t.type !== "ObjectPattern" && t.type !== "ArrayPattern")) {
-      return [assign(node.targets.map((t) => this.expression(t)), this.values(node.values))];
+    const target = node.target;
+    const value = this.expression(node.value);
+    if (target.type !== "ObjectPattern" && target.type !== "ArrayPattern") {
+      return [assign([this.expression(target)], [value])];
     }
-    const values = this.values(node.values);
-    const only = node.targets.length === 1 && values.length === 1 ? node.targets[0] : void 0;
-    if (only && (only.type === "ObjectPattern" || only.type === "ArrayPattern") && values[0].type === "Identifier") {
-      const statements = this.destructure(only, values[0], "assign");
+    if (value.type === "Identifier") {
+      const statements = this.destructure(target, value, "assign");
       return statements.some((s) => s.type === "LocalStatement") ? [doBlock(statements)] : statements;
     }
-    const temps = node.targets.map(() => this.names.fresh("ref"));
-    const body = [local(temps, values)];
-    node.targets.forEach((target, i) => {
-      const value = identifier(temps[i]);
-      if (target.type === "ObjectPattern" || target.type === "ArrayPattern") {
-        body.push(...this.destructure(target, value, "assign"));
-      } else {
-        body.push(assign([this.expression(target)], [value]));
-      }
-    });
-    return [doBlock(body)];
+    const temp = this.names.fresh("ref");
+    return [doBlock([local([temp], [value]), ...this.destructure(target, identifier(temp), "assign")])];
   }
   // --------------------------------------------------------
   // Destructuring
@@ -1307,7 +1279,7 @@ end
       if (through !== void 0) {
         return call(member(this.superClassReference(node), through), [
           identifier(this.thisName()),
-          ...this.values(node.arguments)
+          ...this.arguments(node.arguments)
         ]);
       }
     }
@@ -1392,35 +1364,27 @@ end
     return this.link(node, this.expression(object));
   }
   /** A call is one value in tilua, and Luau would hand on every value one
-   *  in the last place of an argument list or an array returns. Types say
-   *  how many a call returns; where a type says nothing — `any`, `unknown`
-   *  — the call is kept to one: `f((g()))`. */
-  keptToOne(nodes, values) {
-    const node = nodes[nodes.length - 1];
-    const last = values[values.length - 1];
-    if (!node || !last || !expandsToMany(last)) return values;
-    const type = this.options.types?.typeOf.get(node);
-    if (type && type.kind !== "any" && type.kind !== "unknown") return values;
-    return [...values.slice(0, -1), parenthesized(last)];
+   *  returns in the last place of an argument list or a `return`: it is
+   *  kept to one there, `f((g()))`. Every value is taken only where the
+   *  program asks for them, as an array's last element: `[g()]`. */
+  keptToOne(value) {
+    return expandsToMany(value) ? parenthesized(value) : value;
   }
   /** Is this `scriptArgs` the language's own, not a name the file declared? */
   isLanguageGlobal(node) {
     const id = this.bindingIdOf(node);
     return id === void 0 || this.scopes.bindings.get(id)?.kind === "global";
   }
-  /** A list of values — a call's arguments, a `return`'s, a declaration's,
-   *  an assignment's. `f(a, ...xs)` is Lua's own last-value expansion,
+  /** A call's arguments. `f(a, ...xs)` is Lua's own last-value expansion,
    *  `f(a, table.unpack(xs))`; a spread anywhere else cannot be, since only
    *  the last value of a list expands, so the whole list is built as an
-   *  array first and that is what expands.
-   *
-   *  `arguments` is set for a call's arguments, where Luau hands on every
-   *  value the last one returns — see `keptToOne`. */
-  values(list, asArguments = false) {
+   *  array first and that is what expands. A call written last is one
+   *  value — see `keptToOne`. */
+  arguments(list) {
     const spreads = list.filter((a) => a.type === "SpreadElement");
     if (!spreads.length) {
       const lowered = list.map((a) => this.expression(a));
-      return asArguments ? this.keptToOne(list, lowered) : lowered;
+      return lowered.length ? [...lowered.slice(0, -1), this.keptToOne(lowered[lowered.length - 1])] : lowered;
     }
     const unpack = (value) => call(member(this.builtin("table"), "unpack"), [value]);
     const last = list[list.length - 1];
@@ -1442,13 +1406,13 @@ end
         return index(object, this.expression(node.index));
       case "CallExpression": {
         const lowered = this.loweredGlobalCall(node);
-        const args = this.values(node.arguments, true);
+        const args = this.arguments(node.arguments);
         if (!lowered) return call(object, args);
         return call(calleePath(lowered.callee), [...lowered.prepend, ...args]);
       }
       case "MethodCallExpression": {
         const lowered = this.loweredMethodCall(node);
-        const args = this.values(node.arguments, true);
+        const args = this.arguments(node.arguments);
         if (lowered) {
           return call(calleePath(lowered.callee), [
             ...lowered.prepend,
@@ -1682,29 +1646,27 @@ end
    *  runs of plain elements and the spread arrays are joined by `concat`. */
   arrayExpression(node) {
     if (!node.elements.some((e) => e.type === "SpreadElement")) {
-      const elements = node.elements;
-      return table(this.keptToOne(elements, elements.map((e) => this.expression(e))).map((value) => ({ type: "TableFieldPositional", value })));
+      return table(node.elements.map((e) => ({ type: "TableFieldPositional", value: this.expression(e) })));
     }
     const parts = [];
     let current = [];
-    const flush = () => {
+    const flush = (last) => {
       if (!current.length) return;
       parts.push(table(current.map((e, i) => {
         const value = this.expression(e);
-        const last = i === current.length - 1;
-        return { type: "TableFieldPositional", value: last && expandsToMany(value) ? parenthesized(value) : value };
+        return { type: "TableFieldPositional", value: last || i < current.length - 1 ? value : this.keptToOne(value) };
       })));
       current = [];
     };
     for (const element of node.elements) {
       if (element.type === "SpreadElement") {
-        flush();
+        flush(false);
         parts.push(this.expression(element.argument));
       } else {
         current.push(element);
       }
     }
-    flush();
+    flush(true);
     return call(this.helper("concat"), parts);
   }
 };
@@ -1773,7 +1735,7 @@ function topLevelDeclaration(statements, name) {
   for (const statement of statements) {
     const declaration = statement.type === "ExportStatement" ? statement.declaration : statement;
     if (declaration.type === "VariableDeclaration") {
-      const pattern = declaration.names.flatMap(identifierPatterns).find((p) => p.name === name);
+      const pattern = identifierPatterns(declaration.name).find((p) => p.name === name);
       if (pattern) return { type: "Declaration", node: pattern };
     } else if (declaration.type === "FunctionDeclaration" && declaration.name.name === name) {
       return { type: "Declaration", node: declaration.name };

package/dist/cli.cjs

@@ -274,12 +274,10 @@ var Lowerer = class {
       for (const node of allNodes(this.source.body)) {
         const statement = node;
         if (statement.type === "VariableDeclaration") {
-          statement.names.forEach((target, index2) => {
-            const value = statement.init[index2];
-            if (target.type !== "IdentifierPattern" || !value) return;
-            const binding = this.bindingByDeclaration.get(target);
-            if (binding) this.declarations.set(binding.id, value);
-          });
+          const target = statement.name;
+          if (target.type !== "IdentifierPattern" || !statement.init) continue;
+          const binding = this.bindingByDeclaration.get(target);
+          if (binding) this.declarations.set(binding.id, statement.init);
         } else if (statement.type === "FunctionDeclaration") {
           const binding = this.bindingByDeclaration.get(statement.name);
           if (binding) this.declarations.set(binding.id, statement);
@@ -553,7 +551,7 @@ var Lowerer = class {
           const declaration = statement.declaration;
           if (declaration.type === "FunctionDeclaration" || declaration.type === "ClassDeclaration") {
             exportBinding(declaration.name, declaration.name.name);
-          } else for (const pattern of declaration.names.flatMap(identifierPatterns)) exportBinding(pattern, pattern.name);
+          } else for (const pattern of identifierPatterns(declaration.name)) exportBinding(pattern, pattern.name);
           break;
         }
         case "ExportDefaultStatement":
@@ -589,7 +587,7 @@ var Lowerer = class {
     for (const statement of statements) {
       const declaration = statement.type === "ExportStatement" ? statement.declaration : statement;
       if (declaration.type === "VariableDeclaration") {
-        for (const pattern of declaration.names.flatMap(identifierPatterns)) {
+        for (const pattern of identifierPatterns(declaration.name)) {
           if (!this.isRewritten(pattern)) locals.push(this.name(pattern.name));
         }
       } else if ((declaration.type === "FunctionDeclaration" || declaration.type === "ClassDeclaration") && !this.isRewritten(declaration.name)) {
@@ -686,7 +684,7 @@ var Lowerer = class {
         continue;
       }
       if (statement.type !== "VariableDeclaration") continue;
-      const patterns = statement.names.flatMap(identifierPatterns);
+      const patterns = identifierPatterns(statement.name);
       const end = { line: { start: statement.line.end }, column: { start: statement.column.end } };
       const needed = patterns.some((pattern) => {
         const binding = this.bindingByDeclaration.get(pattern);
@@ -727,7 +725,7 @@ var Lowerer = class {
     const body = [];
     for (const statement of statements) {
       if (statement.type === "VariableDeclaration") {
-        for (const pattern of statement.names.flatMap(identifierPatterns)) locals.push(this.name(pattern.name));
+        for (const pattern of identifierPatterns(statement.name)) locals.push(this.name(pattern.name));
         body.push(...this.variableDeclaration(statement, "assign"));
       } else if (statement.type === "FunctionDeclaration") {
         locals.push(this.name(statement.name.name));
@@ -879,7 +877,7 @@ var Lowerer = class {
         )];
       }
       case "ReturnStatement":
-        return [returns(node.argument ? [this.expression(node.argument)] : [])];
+        return [returns(node.argument ? [this.keptToOne(this.expression(node.argument))] : [])];
       case "BreakStatement":
         return [{ type: "BreakStatement", ...spanOf(node) }];
       case "ContinueStatement":
@@ -1128,63 +1126,37 @@ end
       ...spanOf(node)
     };
   }
-  /** `const a, { b } = x, y`. In "assign" mode — a module's top level, where
-   *  every name is declared up front — nothing is declared, only assigned. */
+  /** `const a = x`, `const { a, b } = x`. In "assign" mode — a module's top
+   *  level, where every name is declared up front — nothing is declared,
+   *  only assigned. */
   variableDeclaration(node, mode) {
-    if (mode === "assign" && !node.init.length) {
-      const exported = node.names.flatMap(identifierPatterns).filter((p) => this.isRewritten(p));
+    const target = node.name;
+    if (!node.init) {
+      const names = identifierPatterns(target);
+      if (mode === "declare") return [local(names.map((p) => this.name(p.name)), [])];
+      const exported = names.filter((p) => this.isRewritten(p));
       return exported.length ? [assign(exported.map((p) => this.reference(p)), exported.map(() => nil()))] : [];
     }
-    const init = this.values(node.init);
-    if (node.names.every((n) => n.type === "IdentifierPattern")) {
-      const names2 = node.names;
-      return mode === "declare" ? [local(names2.map((n) => this.name(n.name)), init)] : [assign(names2.map((n) => this.reference(n)), init)];
-    }
-    const only = node.names.length === 1 && node.init.length === 1 ? node.names[0] : void 0;
-    if (only && only.type !== "IdentifierPattern") {
-      if (init[0].type === "Identifier") return this.destructure(only, init[0], mode);
-      const temp = this.names.fresh("ref");
-      return [local([temp], init), ...this.destructure(only, identifier(temp), mode)];
-    }
-    const after = [];
-    const names = [];
-    const targets = [];
-    for (const target of node.names) {
-      if (target.type === "IdentifierPattern") {
-        names.push(this.name(target.name));
-        targets.push(this.reference(target));
-        continue;
-      }
-      const temp = this.names.fresh("ref");
-      names.push(temp);
-      targets.push(identifier(temp));
-      after.push(...this.destructure(target, identifier(temp), mode));
+    const value = this.expression(node.init);
+    if (target.type === "IdentifierPattern") {
+      return mode === "declare" ? [local([this.name(target.name)], [value])] : [assign([this.reference(target)], [value])];
     }
-    if (mode === "declare") return [local(names, init), ...after];
-    const temps = node.names.flatMap((t, i) => t.type === "IdentifierPattern" ? [] : [names[i]]);
-    return [...temps.length ? [local(temps, [])] : [], assign(targets, init), ...after];
+    if (value.type === "Identifier") return this.destructure(target, value, mode);
+    const temp = this.names.fresh("ref");
+    return [local([temp], [value]), ...this.destructure(target, identifier(temp), mode)];
   }
   assignment(node) {
-    if (node.targets.every((t) => t.type !== "ObjectPattern" && t.type !== "ArrayPattern")) {
-      return [assign(node.targets.map((t) => this.expression(t)), this.values(node.values))];
+    const target = node.target;
+    const value = this.expression(node.value);
+    if (target.type !== "ObjectPattern" && target.type !== "ArrayPattern") {
+      return [assign([this.expression(target)], [value])];
     }
-    const values = this.values(node.values);
-    const only = node.targets.length === 1 && values.length === 1 ? node.targets[0] : void 0;
-    if (only && (only.type === "ObjectPattern" || only.type === "ArrayPattern") && values[0].type === "Identifier") {
-      const statements = this.destructure(only, values[0], "assign");
+    if (value.type === "Identifier") {
+      const statements = this.destructure(target, value, "assign");
       return statements.some((s) => s.type === "LocalStatement") ? [doBlock(statements)] : statements;
     }
-    const temps = node.targets.map(() => this.names.fresh("ref"));
-    const body = [local(temps, values)];
-    node.targets.forEach((target, i) => {
-      const value = identifier(temps[i]);
-      if (target.type === "ObjectPattern" || target.type === "ArrayPattern") {
-        body.push(...this.destructure(target, value, "assign"));
-      } else {
-        body.push(assign([this.expression(target)], [value]));
-      }
-    });
-    return [doBlock(body)];
+    const temp = this.names.fresh("ref");
+    return [doBlock([local([temp], [value]), ...this.destructure(target, identifier(temp), "assign")])];
   }
   // --------------------------------------------------------
   // Destructuring
@@ -1319,7 +1291,7 @@ end
       if (through !== void 0) {
         return call(member(this.superClassReference(node), through), [
           identifier(this.thisName()),
-          ...this.values(node.arguments)
+          ...this.arguments(node.arguments)
         ]);
       }
     }
@@ -1404,35 +1376,27 @@ end
     return this.link(node, this.expression(object));
   }
   /** A call is one value in tilua, and Luau would hand on every value one
-   *  in the last place of an argument list or an array returns. Types say
-   *  how many a call returns; where a type says nothing — `any`, `unknown`
-   *  — the call is kept to one: `f((g()))`. */
-  keptToOne(nodes, values) {
-    const node = nodes[nodes.length - 1];
-    const last = values[values.length - 1];
-    if (!node || !last || !expandsToMany(last)) return values;
-    const type = this.options.types?.typeOf.get(node);
-    if (type && type.kind !== "any" && type.kind !== "unknown") return values;
-    return [...values.slice(0, -1), parenthesized(last)];
+   *  returns in the last place of an argument list or a `return`: it is
+   *  kept to one there, `f((g()))`. Every value is taken only where the
+   *  program asks for them, as an array's last element: `[g()]`. */
+  keptToOne(value) {
+    return expandsToMany(value) ? parenthesized(value) : value;
   }
   /** Is this `scriptArgs` the language's own, not a name the file declared? */
   isLanguageGlobal(node) {
     const id = this.bindingIdOf(node);
     return id === void 0 || this.scopes.bindings.get(id)?.kind === "global";
   }
-  /** A list of values — a call's arguments, a `return`'s, a declaration's,
-   *  an assignment's. `f(a, ...xs)` is Lua's own last-value expansion,
+  /** A call's arguments. `f(a, ...xs)` is Lua's own last-value expansion,
    *  `f(a, table.unpack(xs))`; a spread anywhere else cannot be, since only
    *  the last value of a list expands, so the whole list is built as an
-   *  array first and that is what expands.
-   *
-   *  `arguments` is set for a call's arguments, where Luau hands on every
-   *  value the last one returns — see `keptToOne`. */
-  values(list, asArguments = false) {
+   *  array first and that is what expands. A call written last is one
+   *  value — see `keptToOne`. */
+  arguments(list) {
     const spreads = list.filter((a) => a.type === "SpreadElement");
     if (!spreads.length) {
       const lowered = list.map((a) => this.expression(a));
-      return asArguments ? this.keptToOne(list, lowered) : lowered;
+      return lowered.length ? [...lowered.slice(0, -1), this.keptToOne(lowered[lowered.length - 1])] : lowered;
     }
     const unpack = (value) => call(member(this.builtin("table"), "unpack"), [value]);
     const last = list[list.length - 1];
@@ -1454,13 +1418,13 @@ end
         return index(object, this.expression(node.index));
       case "CallExpression": {
         const lowered = this.loweredGlobalCall(node);
-        const args2 = this.values(node.arguments, true);
+        const args2 = this.arguments(node.arguments);
         if (!lowered) return call(object, args2);
         return call(calleePath(lowered.callee), [...lowered.prepend, ...args2]);
       }
       case "MethodCallExpression": {
         const lowered = this.loweredMethodCall(node);
-        const args2 = this.values(node.arguments, true);
+        const args2 = this.arguments(node.arguments);
         if (lowered) {
           return call(calleePath(lowered.callee), [
             ...lowered.prepend,
@@ -1694,29 +1658,27 @@ end
    *  runs of plain elements and the spread arrays are joined by `concat`. */
   arrayExpression(node) {
     if (!node.elements.some((e) => e.type === "SpreadElement")) {
-      const elements = node.elements;
-      return table(this.keptToOne(elements, elements.map((e) => this.expression(e))).map((value) => ({ type: "TableFieldPositional", value })));
+      return table(node.elements.map((e) => ({ type: "TableFieldPositional", value: this.expression(e) })));
     }
     const parts = [];
     let current = [];
-    const flush = () => {
+    const flush = (last) => {
       if (!current.length) return;
       parts.push(table(current.map((e, i) => {
         const value = this.expression(e);
-        const last = i === current.length - 1;
-        return { type: "TableFieldPositional", value: last && expandsToMany(value) ? parenthesized(value) : value };
+        return { type: "TableFieldPositional", value: last || i < current.length - 1 ? value : this.keptToOne(value) };
       })));
       current = [];
     };
     for (const element of node.elements) {
       if (element.type === "SpreadElement") {
-        flush();
+        flush(false);
         parts.push(this.expression(element.argument));
       } else {
         current.push(element);
       }
     }
-    flush();
+    flush(true);
     return call(this.helper("concat"), parts);
   }
 };
@@ -1785,7 +1747,7 @@ function topLevelDeclaration(statements, name) {
   for (const statement of statements) {
     const declaration = statement.type === "ExportStatement" ? statement.declaration : statement;
     if (declaration.type === "VariableDeclaration") {
-      const pattern = declaration.names.flatMap(identifierPatterns).find((p) => p.name === name);
+      const pattern = identifierPatterns(declaration.name).find((p) => p.name === name);
       if (pattern) return { type: "Declaration", node: pattern };
     } else if (declaration.type === "FunctionDeclaration" && declaration.name.name === name) {
       return { type: "Declaration", node: declaration.name };

package/dist/cli.js

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

package/dist/index.cjs

@@ -298,12 +298,10 @@ var Lowerer = class {
       for (const node of allNodes(this.source.body)) {
         const statement = node;
         if (statement.type === "VariableDeclaration") {
-          statement.names.forEach((target, index2) => {
-            const value = statement.init[index2];
-            if (target.type !== "IdentifierPattern" || !value) return;
-            const binding = this.bindingByDeclaration.get(target);
-            if (binding) this.declarations.set(binding.id, value);
-          });
+          const target = statement.name;
+          if (target.type !== "IdentifierPattern" || !statement.init) continue;
+          const binding = this.bindingByDeclaration.get(target);
+          if (binding) this.declarations.set(binding.id, statement.init);
         } else if (statement.type === "FunctionDeclaration") {
           const binding = this.bindingByDeclaration.get(statement.name);
           if (binding) this.declarations.set(binding.id, statement);
@@ -577,7 +575,7 @@ var Lowerer = class {
           const declaration = statement.declaration;
           if (declaration.type === "FunctionDeclaration" || declaration.type === "ClassDeclaration") {
             exportBinding(declaration.name, declaration.name.name);
-          } else for (const pattern of declaration.names.flatMap(identifierPatterns)) exportBinding(pattern, pattern.name);
+          } else for (const pattern of identifierPatterns(declaration.name)) exportBinding(pattern, pattern.name);
           break;
         }
         case "ExportDefaultStatement":
@@ -613,7 +611,7 @@ var Lowerer = class {
     for (const statement of statements) {
       const declaration = statement.type === "ExportStatement" ? statement.declaration : statement;
       if (declaration.type === "VariableDeclaration") {
-        for (const pattern of declaration.names.flatMap(identifierPatterns)) {
+        for (const pattern of identifierPatterns(declaration.name)) {
           if (!this.isRewritten(pattern)) locals.push(this.name(pattern.name));
         }
       } else if ((declaration.type === "FunctionDeclaration" || declaration.type === "ClassDeclaration") && !this.isRewritten(declaration.name)) {
@@ -710,7 +708,7 @@ var Lowerer = class {
         continue;
       }
       if (statement.type !== "VariableDeclaration") continue;
-      const patterns = statement.names.flatMap(identifierPatterns);
+      const patterns = identifierPatterns(statement.name);
       const end = { line: { start: statement.line.end }, column: { start: statement.column.end } };
       const needed = patterns.some((pattern) => {
         const binding = this.bindingByDeclaration.get(pattern);
@@ -751,7 +749,7 @@ var Lowerer = class {
     const body = [];
     for (const statement of statements) {
       if (statement.type === "VariableDeclaration") {
-        for (const pattern of statement.names.flatMap(identifierPatterns)) locals.push(this.name(pattern.name));
+        for (const pattern of identifierPatterns(statement.name)) locals.push(this.name(pattern.name));
         body.push(...this.variableDeclaration(statement, "assign"));
       } else if (statement.type === "FunctionDeclaration") {
         locals.push(this.name(statement.name.name));
@@ -903,7 +901,7 @@ var Lowerer = class {
         )];
       }
       case "ReturnStatement":
-        return [returns(node.argument ? [this.expression(node.argument)] : [])];
+        return [returns(node.argument ? [this.keptToOne(this.expression(node.argument))] : [])];
       case "BreakStatement":
         return [{ type: "BreakStatement", ...spanOf(node) }];
       case "ContinueStatement":
@@ -1152,63 +1150,37 @@ end
       ...spanOf(node)
     };
   }
-  /** `const a, { b } = x, y`. In "assign" mode — a module's top level, where
-   *  every name is declared up front — nothing is declared, only assigned. */
+  /** `const a = x`, `const { a, b } = x`. In "assign" mode — a module's top
+   *  level, where every name is declared up front — nothing is declared,
+   *  only assigned. */
   variableDeclaration(node, mode) {
-    if (mode === "assign" && !node.init.length) {
-      const exported = node.names.flatMap(identifierPatterns).filter((p) => this.isRewritten(p));
+    const target = node.name;
+    if (!node.init) {
+      const names = identifierPatterns(target);
+      if (mode === "declare") return [local(names.map((p) => this.name(p.name)), [])];
+      const exported = names.filter((p) => this.isRewritten(p));
       return exported.length ? [assign(exported.map((p) => this.reference(p)), exported.map(() => nil()))] : [];
     }
-    const init = this.values(node.init);
-    if (node.names.every((n) => n.type === "IdentifierPattern")) {
-      const names2 = node.names;
-      return mode === "declare" ? [local(names2.map((n) => this.name(n.name)), init)] : [assign(names2.map((n) => this.reference(n)), init)];
-    }
-    const only = node.names.length === 1 && node.init.length === 1 ? node.names[0] : void 0;
-    if (only && only.type !== "IdentifierPattern") {
-      if (init[0].type === "Identifier") return this.destructure(only, init[0], mode);
-      const temp = this.names.fresh("ref");
-      return [local([temp], init), ...this.destructure(only, identifier(temp), mode)];
-    }
-    const after = [];
-    const names = [];
-    const targets = [];
-    for (const target of node.names) {
-      if (target.type === "IdentifierPattern") {
-        names.push(this.name(target.name));
-        targets.push(this.reference(target));
-        continue;
-      }
-      const temp = this.names.fresh("ref");
-      names.push(temp);
-      targets.push(identifier(temp));
-      after.push(...this.destructure(target, identifier(temp), mode));
+    const value = this.expression(node.init);
+    if (target.type === "IdentifierPattern") {
+      return mode === "declare" ? [local([this.name(target.name)], [value])] : [assign([this.reference(target)], [value])];
     }
-    if (mode === "declare") return [local(names, init), ...after];
-    const temps = node.names.flatMap((t, i) => t.type === "IdentifierPattern" ? [] : [names[i]]);
-    return [...temps.length ? [local(temps, [])] : [], assign(targets, init), ...after];
+    if (value.type === "Identifier") return this.destructure(target, value, mode);
+    const temp = this.names.fresh("ref");
+    return [local([temp], [value]), ...this.destructure(target, identifier(temp), mode)];
   }
   assignment(node) {
-    if (node.targets.every((t) => t.type !== "ObjectPattern" && t.type !== "ArrayPattern")) {
-      return [assign(node.targets.map((t) => this.expression(t)), this.values(node.values))];
+    const target = node.target;
+    const value = this.expression(node.value);
+    if (target.type !== "ObjectPattern" && target.type !== "ArrayPattern") {
+      return [assign([this.expression(target)], [value])];
     }
-    const values = this.values(node.values);
-    const only = node.targets.length === 1 && values.length === 1 ? node.targets[0] : void 0;
-    if (only && (only.type === "ObjectPattern" || only.type === "ArrayPattern") && values[0].type === "Identifier") {
-      const statements = this.destructure(only, values[0], "assign");
+    if (value.type === "Identifier") {
+      const statements = this.destructure(target, value, "assign");
       return statements.some((s) => s.type === "LocalStatement") ? [doBlock(statements)] : statements;
     }
-    const temps = node.targets.map(() => this.names.fresh("ref"));
-    const body = [local(temps, values)];
-    node.targets.forEach((target, i) => {
-      const value = identifier(temps[i]);
-      if (target.type === "ObjectPattern" || target.type === "ArrayPattern") {
-        body.push(...this.destructure(target, value, "assign"));
-      } else {
-        body.push(assign([this.expression(target)], [value]));
-      }
-    });
-    return [doBlock(body)];
+    const temp = this.names.fresh("ref");
+    return [doBlock([local([temp], [value]), ...this.destructure(target, identifier(temp), "assign")])];
   }
   // --------------------------------------------------------
   // Destructuring
@@ -1343,7 +1315,7 @@ end
       if (through !== void 0) {
         return call(member(this.superClassReference(node), through), [
           identifier(this.thisName()),
-          ...this.values(node.arguments)
+          ...this.arguments(node.arguments)
         ]);
       }
     }
@@ -1428,35 +1400,27 @@ end
     return this.link(node, this.expression(object));
   }
   /** A call is one value in tilua, and Luau would hand on every value one
-   *  in the last place of an argument list or an array returns. Types say
-   *  how many a call returns; where a type says nothing — `any`, `unknown`
-   *  — the call is kept to one: `f((g()))`. */
-  keptToOne(nodes, values) {
-    const node = nodes[nodes.length - 1];
-    const last = values[values.length - 1];
-    if (!node || !last || !expandsToMany(last)) return values;
-    const type = this.options.types?.typeOf.get(node);
-    if (type && type.kind !== "any" && type.kind !== "unknown") return values;
-    return [...values.slice(0, -1), parenthesized(last)];
+   *  returns in the last place of an argument list or a `return`: it is
+   *  kept to one there, `f((g()))`. Every value is taken only where the
+   *  program asks for them, as an array's last element: `[g()]`. */
+  keptToOne(value) {
+    return expandsToMany(value) ? parenthesized(value) : value;
   }
   /** Is this `scriptArgs` the language's own, not a name the file declared? */
   isLanguageGlobal(node) {
     const id = this.bindingIdOf(node);
     return id === void 0 || this.scopes.bindings.get(id)?.kind === "global";
   }
-  /** A list of values — a call's arguments, a `return`'s, a declaration's,
-   *  an assignment's. `f(a, ...xs)` is Lua's own last-value expansion,
+  /** A call's arguments. `f(a, ...xs)` is Lua's own last-value expansion,
    *  `f(a, table.unpack(xs))`; a spread anywhere else cannot be, since only
    *  the last value of a list expands, so the whole list is built as an
-   *  array first and that is what expands.
-   *
-   *  `arguments` is set for a call's arguments, where Luau hands on every
-   *  value the last one returns — see `keptToOne`. */
-  values(list, asArguments = false) {
+   *  array first and that is what expands. A call written last is one
+   *  value — see `keptToOne`. */
+  arguments(list) {
     const spreads = list.filter((a) => a.type === "SpreadElement");
     if (!spreads.length) {
       const lowered = list.map((a) => this.expression(a));
-      return asArguments ? this.keptToOne(list, lowered) : lowered;
+      return lowered.length ? [...lowered.slice(0, -1), this.keptToOne(lowered[lowered.length - 1])] : lowered;
     }
     const unpack = (value) => call(member(this.builtin("table"), "unpack"), [value]);
     const last = list[list.length - 1];
@@ -1478,13 +1442,13 @@ end
         return index(object, this.expression(node.index));
       case "CallExpression": {
         const lowered = this.loweredGlobalCall(node);
-        const args = this.values(node.arguments, true);
+        const args = this.arguments(node.arguments);
         if (!lowered) return call(object, args);
         return call(calleePath(lowered.callee), [...lowered.prepend, ...args]);
       }
       case "MethodCallExpression": {
         const lowered = this.loweredMethodCall(node);
-        const args = this.values(node.arguments, true);
+        const args = this.arguments(node.arguments);
         if (lowered) {
           return call(calleePath(lowered.callee), [
             ...lowered.prepend,
@@ -1718,29 +1682,27 @@ end
    *  runs of plain elements and the spread arrays are joined by `concat`. */
   arrayExpression(node) {
     if (!node.elements.some((e) => e.type === "SpreadElement")) {
-      const elements = node.elements;
-      return table(this.keptToOne(elements, elements.map((e) => this.expression(e))).map((value) => ({ type: "TableFieldPositional", value })));
+      return table(node.elements.map((e) => ({ type: "TableFieldPositional", value: this.expression(e) })));
     }
     const parts = [];
     let current = [];
-    const flush = () => {
+    const flush = (last) => {
       if (!current.length) return;
       parts.push(table(current.map((e, i) => {
         const value = this.expression(e);
-        const last = i === current.length - 1;
-        return { type: "TableFieldPositional", value: last && expandsToMany(value) ? parenthesized(value) : value };
+        return { type: "TableFieldPositional", value: last || i < current.length - 1 ? value : this.keptToOne(value) };
       })));
       current = [];
     };
     for (const element of node.elements) {
       if (element.type === "SpreadElement") {
-        flush();
+        flush(false);
         parts.push(this.expression(element.argument));
       } else {
         current.push(element);
       }
     }
-    flush();
+    flush(true);
     return call(this.helper("concat"), parts);
   }
 };
@@ -1809,7 +1771,7 @@ function topLevelDeclaration(statements, name) {
   for (const statement of statements) {
     const declaration = statement.type === "ExportStatement" ? statement.declaration : statement;
     if (declaration.type === "VariableDeclaration") {
-      const pattern = declaration.names.flatMap(identifierPatterns).find((p) => p.name === name);
+      const pattern = identifierPatterns(declaration.name).find((p) => p.name === name);
       if (pattern) return { type: "Declaration", node: pattern };
     } else if (declaration.type === "FunctionDeclaration" && declaration.name.name === name) {
       return { type: "Declaration", node: declaration.name };

package/dist/index.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tilua/compiler",
-  "version": "2.1.0",
+  "version": "2.3.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.1.0"
+    "@tilua/parser": "^2.3.0"
   },
   "devDependencies": {
     "@types/node": "^22.20.2",