@tilua/compiler 1.1.0 → 2.0.0

package/README.md

@@ -65,10 +65,14 @@ JavaScript module the build loads.
 | `function f(n = 1, { x })` | `function f(n, arg) if n == nil then n = 1 end local x = arg.x ...` |
 | `const` / `let` | `local` |
 | `class C { … }` | one table for the class, one per instance — see below |
-| `new C(x)` | `C.new(x)` |
-| `[...]` | `{...}` — the varargs as an array |
+| `return [a, b]` | `return { a, b }` — several results are an array |
+| `for (const item in xs)` | `for _, item in xs do … end` — an array or a table walked for its values |
+| `for (const item in step)` | `for item in step do … end` — an iterator function |
+| `for (const [k, v] in pairs(t))` | `for item in unpack(pairs(t), 1, 3) do local k, v = item[1], item[2] … end` — an iteration is `[step, state, first]` |
+| `pcall(f)`, and other globals Luau answers several values from | the type library's own function, answering one — see below |
 | `function f(a, ...rest)` | `function f(a, ...) local rest = {...}` |
-| `f(a, ...xs)` / `return ...xs` | `table.unpack(xs)` in the last position |
+| `scriptArgs` | the chunk's own `...`, as `local scriptArgs = { ... }` |
+| `f(a, ...xs)` | `table.unpack(xs)` in the last position |
 | `f(...xs, a)` | the list built first, then `table.unpack` of it |
 | `x as T`, `x satisfies T`, types, `declare` | removed |
 | `names:filter(f)` | whatever the type library that declared `filter` says — see below |
@@ -113,8 +117,16 @@ tilua_accessors(Dog)
 
 `__init` is what `super(...)` calls: it runs the constructor on an instance
 that already exists, so a derived class builds one table, not one per level.
-`new` is a real function on the class table — `new Dog(x)` and `Dog.new(x)`
-are the same call.
+`new` is a real function on the class table, and `Dog.new(x)` is how an
+instance is built — the way Luau builds one. An `abstract class` has no `new`,
+and an `abstract` method no function: both exist only to be checked.
+
+A method named for a metamethod — `__add`, `__tostring`, `__call`, … — is an
+ordinary function on the class table, and since the class table is its
+instances' metatable, it works as one. Luau reads metamethods off the
+metatable with `rawget`, never through its `__index`, so a class would not
+inherit its base's: `tilua_class` copies them into each class that extends
+another, and one the class writes itself replaces the copy.
 
 Two links come with every class, and they cost an instance nothing because
 they live on the class table: `ClassObject`, which an instance reads through

package/dist/{chunk-2IPPO4V3.js → chunk-KG6W5XKA.js}

@@ -180,14 +180,18 @@ var Lowerer = class {
     const body = this.options.module ? this.module(this.options.module) : this.topLevel(this.source.body.statements);
     const helpers = this.helperDefinitions();
     const captured = [...this.builtins].map(([global, local2]) => local([local2], [identifier(global)]));
+    const scriptArgs = this.usesScriptArgs && !this.options.module ? [local(["scriptArgs"], [table([{ type: "TableFieldPositional", value: vararg() }])])] : [];
     return {
-      statements: [...captured, ...helpers, ...this.classRuntimeStatements(), ...body],
+      statements: [...scriptArgs, ...captured, ...helpers, ...this.classRuntimeStatements(), ...body],
       exportsName: this.exportsName,
       module: this.info,
       diagnostics: this.diagnostics,
-      origins: this.origins
+      origins: this.origins,
+      usesScriptArgs: this.usesScriptArgs
     };
   }
+  /** Whether the file reads `scriptArgs`, the language's own global. */
+  usesScriptArgs = false;
   report(node, message) {
     this.diagnostics.push({ message, line: node.line.start, column: node.column.start });
   }
@@ -312,6 +316,10 @@ var Lowerer = class {
   /** The name a global is read by at `node`, or `undefined` when `node` is
    *  not a global — a local of the same name is the author's. */
   globalName(node) {
+    if (node.type === "MemberExpression" && !node.optional) {
+      const base = this.globalName(node.object);
+      return base === void 0 ? void 0 : `${base}.${node.property.name}`;
+    }
     if (node.type !== "Identifier") return void 0;
     const id = this.scopes.bindingOf.get(node);
     if (id === void 0) return node.name;
@@ -608,7 +616,7 @@ var Lowerer = class {
           break;
         }
         case "ReturnStatement":
-          if (declaration.arguments.length) this.report(declaration, "A module cannot return a value; export it instead");
+          if (declaration.argument) this.report(declaration, "A module cannot return a value; export it instead");
           body.push(returns([]));
           break;
         case "ImportStatement":
@@ -787,7 +795,7 @@ var Lowerer = class {
       case "CallStatement": {
         const chain = optionalChain(node.expression);
         if (chain) return [this.optionalCallStatement(chain)];
-        const expression = this.expression(node.expression);
+        const expression = this.callValues(node.expression);
         if (expression.type !== "CallExpression" && expression.type !== "MethodCallExpression") {
           this.report(node, "A statement must be a call");
           return [];
@@ -840,23 +848,26 @@ var Lowerer = class {
         }];
       case "GenericForStatement": {
         const prelude = [];
-        const variables = node.variables.map((target) => {
-          if (target.type === "IdentifierPattern") return this.name(target.name);
-          const temp = this.names.fresh("item");
-          prelude.push(...this.destructure(target, identifier(temp), "declare"));
-          return temp;
-        });
-        if (variables.length === 1 && this.options.types?.iteratesValues.has(node)) {
-          variables.unshift(this.names.fresh("_"));
+        let item;
+        if (node.variable.type === "IdentifierPattern") {
+          item = this.name(node.variable.name);
+        } else {
+          item = this.names.fresh("item");
+          prelude.push(...this.destructure(node.variable, identifier(item), "declare"));
         }
+        const form = this.options.types?.loops.get(node) ?? { walks: "values", viaIter: false };
+        let source = this.expression(node.iterator);
+        if (form.viaIter) source = methodCall(source, "__iter", []);
+        const variables = form.walks === "values" ? [this.names.fresh("_"), item] : [item];
+        const iterators = form.walks === "iteration" ? [call(this.builtin("unpack"), [source, number(1), number(3)])] : [source];
         return [genericFor(
           variables,
-          node.iterators.map((e) => this.expression(e)),
+          iterators,
           this.loopBody51(this.block(node.body, prelude)).statements
         )];
       }
       case "ReturnStatement":
-        return [returns(this.values(node.arguments))];
+        return [returns(node.argument ? [this.expression(node.argument)] : [])];
       case "BreakStatement":
         return [{ type: "BreakStatement", ...spanOf(node) }];
       case "ContinueStatement":
@@ -900,7 +911,7 @@ var Lowerer = class {
   //     end
   //     function Dog.speak(this) ... end
   //
-  // `new Dog(x)` is `Dog.new(x)`, `dog:speak()` passes the instance
+  // `Dog.new(x)` builds one, `dog:speak()` passes the instance
   // as `this`, and `super.speak()` is `Animal.speak(this)` — the
   // base's own function, run on this instance.
   // ============================================================
@@ -926,6 +937,7 @@ var Lowerer = class {
   classRuntimeStatements() {
     if (!this.classHelpers) return [];
     const { build, accessors } = this.classHelpers;
+    const metamethods = `{ ${CLASS_METAMETHODS.map((name) => `"${name}"`).join(", ")} }`;
     return parseLuau(`
 local function ${build}(base)
     local class = { __getters = {}, __setters = {} }
@@ -936,6 +948,9 @@ local function ${build}(base)
         setmetatable(class, { __index = base })
         setmetatable(class.__getters, { __index = base.__getters })
         setmetatable(class.__setters, { __index = base.__setters })
+        for _, key in ipairs(${metamethods}) do
+            class[key] = base[key]
+        end
     end
     return class
 end
@@ -998,6 +1013,7 @@ end
             }
             break;
           case "ClassMethod":
+            if (member2.isAbstract) break;
             out.push(this.functionStatement(
               member(self, member2.name.name),
               member2,
@@ -1019,7 +1035,7 @@ end
         }
       }
       out.push(this.classInit(node, self));
-      out.push(this.classNew(node, self));
+      if (!node.isAbstract) out.push(this.classNew(node, self));
       out.push(callStatement(call(identifier(accessors), [self])));
     } finally {
       this.classContext = previous;
@@ -1297,6 +1313,10 @@ end
     }
     switch (node.type) {
       case "Identifier":
+        if (node.name === "scriptArgs" && this.isLanguageGlobal(node)) {
+          this.usesScriptArgs = true;
+          return identifier("scriptArgs");
+        }
         return this.loweredGlobalValue(node) ?? this.reference(node);
       case "NilLiteral":
         return nil();
@@ -1306,8 +1326,6 @@ end
         return number(node.value, this.numberRaw(node));
       case "StringLiteral":
         return string(node.value);
-      case "VarargExpression":
-        return vararg();
       // Only a recovering parse makes one, and a syntax error stops the build.
       case "ErrorExpression":
         this.report(node, "Syntax error");
@@ -1328,11 +1346,6 @@ end
       }
       case "UnaryExpression":
         return unary(node.operator, this.expression(node.argument));
-      case "NewExpression":
-        return call(
-          member(this.expression(node.callee), "new"),
-          this.values(node.arguments)
-        );
       case "SuperExpression":
         return this.superClassReference(node);
       case "SpreadElement":
@@ -1340,17 +1353,16 @@ end
         return nil();
       case "ClassExpression":
         return this.classExpression(node);
-      case "MemberExpression":
-      case "IndexExpression":
       case "CallExpression":
-      case "MethodCallExpression": {
+      case "MethodCallExpression":
+        return this.callValues(node);
+      case "MemberExpression":
+      case "IndexExpression": {
         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));
-        }
-        return this.link(node, this.expression(object));
+        const global = node.type === "MemberExpression" ? this.loweredGlobalValue(node) : void 0;
+        if (global) return global;
+        return this.link(node, this.expression(linkObject(node)));
       }
       case "ParenthesizedExpression":
         return parenthesized(this.expression(node.expression));
@@ -1369,14 +1381,47 @@ end
         };
     }
   }
+  /** A call. */
+  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));
+    }
+    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)];
+  }
+  /** 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,
    *  `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. */
-  values(list) {
+   *  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) {
     const spreads = list.filter((a) => a.type === "SpreadElement");
-    if (!spreads.length) return list.map((a) => this.expression(a));
+    if (!spreads.length) {
+      const lowered = list.map((a) => this.expression(a));
+      return asArguments ? this.keptToOne(list, lowered) : lowered;
+    }
     const unpack = (value) => call(member(this.builtin("table"), "unpack"), [value]);
     const last = list[list.length - 1];
     if (spreads.length === 1 && last.type === "SpreadElement") {
@@ -1397,13 +1442,13 @@ end
         return index(object, this.expression(node.index));
       case "CallExpression": {
         const lowered = this.loweredGlobalCall(node);
-        const args = this.values(node.arguments);
-        if (lowered) return call(calleePath(lowered.callee), [...lowered.prepend, ...args]);
-        return call(object, args);
+        const args = this.values(node.arguments, true);
+        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);
+        const args = this.values(node.arguments, true);
         if (lowered) {
           return call(calleePath(lowered.callee), [
             ...lowered.prepend,
@@ -1637,7 +1682,8 @@ end
    *  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 = node.elements;
+      return table(this.keptToOne(elements, elements.map((e) => this.expression(e))).map((value) => ({ type: "TableFieldPositional", value })));
     }
     const parts = [];
     let current = [];
@@ -1836,6 +1882,24 @@ function allNodes(root) {
   visit(root);
   return out;
 }
+var CLASS_METAMETHODS = [
+  "__add",
+  "__sub",
+  "__mul",
+  "__div",
+  "__idiv",
+  "__mod",
+  "__pow",
+  "__unm",
+  "__concat",
+  "__len",
+  "__eq",
+  "__lt",
+  "__le",
+  "__call",
+  "__tostring",
+  "__iter"
+];
 
 // src/lowering.ts
 import { pathToFileURL } from "url";
@@ -1993,7 +2057,8 @@ async function bundle(options) {
       name: source.name,
       statements: lowered.statements,
       exportsName: lowered.exportsName,
-      info: lowered.module
+      info: lowered.module,
+      usesScriptArgs: lowered.usesScriptArgs
     });
   }
   for (const [file, fileDirectives] of directives) {
@@ -2018,6 +2083,9 @@ async function bundle(options) {
   }
   const program2 = parseLuau2(runtime(G));
   const assignment = program2.body.statements[1];
+  if ([...modules.values()].some((m) => m.usesScriptArgs)) {
+    program2.body.statements.unshift(local(["scriptArgs"], [table([{ type: "TableFieldPositional", value: { type: "VarargExpression" } }])]));
+  }
   const modulesTable = assignment.type === "AssignmentStatement" && assignment.values[0].type === "TableExpression" ? assignment.values[0].fields.find((f) => f.type === "TableFieldNamed" && f.name.name === "modules")?.value : void 0;
   if (!modulesTable) throw new Error("@tilua/compiler: the bundle runtime has no modules table");
   for (const module of modules.values()) {

package/dist/cli.cjs

@@ -192,14 +192,18 @@ var Lowerer = class {
     const body = this.options.module ? this.module(this.options.module) : this.topLevel(this.source.body.statements);
     const helpers = this.helperDefinitions();
     const captured = [...this.builtins].map(([global, local2]) => local([local2], [identifier(global)]));
+    const scriptArgs = this.usesScriptArgs && !this.options.module ? [local(["scriptArgs"], [table([{ type: "TableFieldPositional", value: vararg() }])])] : [];
     return {
-      statements: [...captured, ...helpers, ...this.classRuntimeStatements(), ...body],
+      statements: [...scriptArgs, ...captured, ...helpers, ...this.classRuntimeStatements(), ...body],
       exportsName: this.exportsName,
       module: this.info,
       diagnostics: this.diagnostics,
-      origins: this.origins
+      origins: this.origins,
+      usesScriptArgs: this.usesScriptArgs
     };
   }
+  /** Whether the file reads `scriptArgs`, the language's own global. */
+  usesScriptArgs = false;
   report(node, message) {
     this.diagnostics.push({ message, line: node.line.start, column: node.column.start });
   }
@@ -324,6 +328,10 @@ var Lowerer = class {
   /** The name a global is read by at `node`, or `undefined` when `node` is
    *  not a global — a local of the same name is the author's. */
   globalName(node) {
+    if (node.type === "MemberExpression" && !node.optional) {
+      const base = this.globalName(node.object);
+      return base === void 0 ? void 0 : `${base}.${node.property.name}`;
+    }
     if (node.type !== "Identifier") return void 0;
     const id = this.scopes.bindingOf.get(node);
     if (id === void 0) return node.name;
@@ -620,7 +628,7 @@ var Lowerer = class {
           break;
         }
         case "ReturnStatement":
-          if (declaration.arguments.length) this.report(declaration, "A module cannot return a value; export it instead");
+          if (declaration.argument) this.report(declaration, "A module cannot return a value; export it instead");
           body.push(returns([]));
           break;
         case "ImportStatement":
@@ -799,7 +807,7 @@ var Lowerer = class {
       case "CallStatement": {
         const chain = optionalChain(node.expression);
         if (chain) return [this.optionalCallStatement(chain)];
-        const expression = this.expression(node.expression);
+        const expression = this.callValues(node.expression);
         if (expression.type !== "CallExpression" && expression.type !== "MethodCallExpression") {
           this.report(node, "A statement must be a call");
           return [];
@@ -852,23 +860,26 @@ var Lowerer = class {
         }];
       case "GenericForStatement": {
         const prelude = [];
-        const variables = node.variables.map((target) => {
-          if (target.type === "IdentifierPattern") return this.name(target.name);
-          const temp = this.names.fresh("item");
-          prelude.push(...this.destructure(target, identifier(temp), "declare"));
-          return temp;
-        });
-        if (variables.length === 1 && this.options.types?.iteratesValues.has(node)) {
-          variables.unshift(this.names.fresh("_"));
+        let item;
+        if (node.variable.type === "IdentifierPattern") {
+          item = this.name(node.variable.name);
+        } else {
+          item = this.names.fresh("item");
+          prelude.push(...this.destructure(node.variable, identifier(item), "declare"));
         }
+        const form = this.options.types?.loops.get(node) ?? { walks: "values", viaIter: false };
+        let source = this.expression(node.iterator);
+        if (form.viaIter) source = methodCall(source, "__iter", []);
+        const variables = form.walks === "values" ? [this.names.fresh("_"), item] : [item];
+        const iterators = form.walks === "iteration" ? [call(this.builtin("unpack"), [source, number(1), number(3)])] : [source];
         return [genericFor(
           variables,
-          node.iterators.map((e) => this.expression(e)),
+          iterators,
           this.loopBody51(this.block(node.body, prelude)).statements
         )];
       }
       case "ReturnStatement":
-        return [returns(this.values(node.arguments))];
+        return [returns(node.argument ? [this.expression(node.argument)] : [])];
       case "BreakStatement":
         return [{ type: "BreakStatement", ...spanOf(node) }];
       case "ContinueStatement":
@@ -912,7 +923,7 @@ var Lowerer = class {
   //     end
   //     function Dog.speak(this) ... end
   //
-  // `new Dog(x)` is `Dog.new(x)`, `dog:speak()` passes the instance
+  // `Dog.new(x)` builds one, `dog:speak()` passes the instance
   // as `this`, and `super.speak()` is `Animal.speak(this)` — the
   // base's own function, run on this instance.
   // ============================================================
@@ -938,6 +949,7 @@ var Lowerer = class {
   classRuntimeStatements() {
     if (!this.classHelpers) return [];
     const { build, accessors } = this.classHelpers;
+    const metamethods = `{ ${CLASS_METAMETHODS.map((name) => `"${name}"`).join(", ")} }`;
     return (0, import_luau_parser.parse)(`
 local function ${build}(base)
     local class = { __getters = {}, __setters = {} }
@@ -948,6 +960,9 @@ local function ${build}(base)
         setmetatable(class, { __index = base })
         setmetatable(class.__getters, { __index = base.__getters })
         setmetatable(class.__setters, { __index = base.__setters })
+        for _, key in ipairs(${metamethods}) do
+            class[key] = base[key]
+        end
     end
     return class
 end
@@ -1010,6 +1025,7 @@ end
             }
             break;
           case "ClassMethod":
+            if (member2.isAbstract) break;
             out2.push(this.functionStatement(
               member(self, member2.name.name),
               member2,
@@ -1031,7 +1047,7 @@ end
         }
       }
       out2.push(this.classInit(node, self));
-      out2.push(this.classNew(node, self));
+      if (!node.isAbstract) out2.push(this.classNew(node, self));
       out2.push(callStatement(call(identifier(accessors), [self])));
     } finally {
       this.classContext = previous;
@@ -1309,6 +1325,10 @@ end
     }
     switch (node.type) {
       case "Identifier":
+        if (node.name === "scriptArgs" && this.isLanguageGlobal(node)) {
+          this.usesScriptArgs = true;
+          return identifier("scriptArgs");
+        }
         return this.loweredGlobalValue(node) ?? this.reference(node);
       case "NilLiteral":
         return nil();
@@ -1318,8 +1338,6 @@ end
         return number(node.value, this.numberRaw(node));
       case "StringLiteral":
         return string(node.value);
-      case "VarargExpression":
-        return vararg();
       // Only a recovering parse makes one, and a syntax error stops the build.
       case "ErrorExpression":
         this.report(node, "Syntax error");
@@ -1340,11 +1358,6 @@ end
       }
       case "UnaryExpression":
         return unary(node.operator, this.expression(node.argument));
-      case "NewExpression":
-        return call(
-          member(this.expression(node.callee), "new"),
-          this.values(node.arguments)
-        );
       case "SuperExpression":
         return this.superClassReference(node);
       case "SpreadElement":
@@ -1352,17 +1365,16 @@ end
         return nil();
       case "ClassExpression":
         return this.classExpression(node);
-      case "MemberExpression":
-      case "IndexExpression":
       case "CallExpression":
-      case "MethodCallExpression": {
+      case "MethodCallExpression":
+        return this.callValues(node);
+      case "MemberExpression":
+      case "IndexExpression": {
         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));
-        }
-        return this.link(node, this.expression(object));
+        const global = node.type === "MemberExpression" ? this.loweredGlobalValue(node) : void 0;
+        if (global) return global;
+        return this.link(node, this.expression(linkObject(node)));
       }
       case "ParenthesizedExpression":
         return parenthesized(this.expression(node.expression));
@@ -1381,14 +1393,47 @@ end
         };
     }
   }
+  /** A call. */
+  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));
+    }
+    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)];
+  }
+  /** 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,
    *  `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. */
-  values(list) {
+   *  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) {
     const spreads = list.filter((a) => a.type === "SpreadElement");
-    if (!spreads.length) return list.map((a) => this.expression(a));
+    if (!spreads.length) {
+      const lowered = list.map((a) => this.expression(a));
+      return asArguments ? this.keptToOne(list, lowered) : lowered;
+    }
     const unpack = (value) => call(member(this.builtin("table"), "unpack"), [value]);
     const last = list[list.length - 1];
     if (spreads.length === 1 && last.type === "SpreadElement") {
@@ -1409,13 +1454,13 @@ end
         return index(object, this.expression(node.index));
       case "CallExpression": {
         const lowered = this.loweredGlobalCall(node);
-        const args2 = this.values(node.arguments);
-        if (lowered) return call(calleePath(lowered.callee), [...lowered.prepend, ...args2]);
-        return call(object, args2);
+        const args2 = this.values(node.arguments, true);
+        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);
+        const args2 = this.values(node.arguments, true);
         if (lowered) {
           return call(calleePath(lowered.callee), [
             ...lowered.prepend,
@@ -1649,7 +1694,8 @@ end
    *  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 = node.elements;
+      return table(this.keptToOne(elements, elements.map((e) => this.expression(e))).map((value) => ({ type: "TableFieldPositional", value })));
     }
     const parts = [];
     let current = [];
@@ -1848,6 +1894,24 @@ function allNodes(root) {
   visit(root);
   return out2;
 }
+var CLASS_METAMETHODS = [
+  "__add",
+  "__sub",
+  "__mul",
+  "__div",
+  "__idiv",
+  "__mod",
+  "__pow",
+  "__unm",
+  "__concat",
+  "__len",
+  "__eq",
+  "__lt",
+  "__le",
+  "__call",
+  "__tostring",
+  "__iter"
+];
 
 // src/linemap.ts
 function statementsOf(node) {
@@ -1987,7 +2051,8 @@ async function bundle(options) {
       name: source.name,
       statements: lowered.statements,
       exportsName: lowered.exportsName,
-      info: lowered.module
+      info: lowered.module,
+      usesScriptArgs: lowered.usesScriptArgs
     });
   }
   for (const [file, fileDirectives] of directives) {
@@ -2012,6 +2077,9 @@ async function bundle(options) {
   }
   const program = (0, import_luau_parser2.parse)(runtime(G));
   const assignment = program.body.statements[1];
+  if ([...modules.values()].some((m) => m.usesScriptArgs)) {
+    program.body.statements.unshift(local(["scriptArgs"], [table([{ type: "TableFieldPositional", value: { type: "VarargExpression" } }])]));
+  }
   const modulesTable = assignment.type === "AssignmentStatement" && assignment.values[0].type === "TableExpression" ? assignment.values[0].fields.find((f) => f.type === "TableFieldNamed" && f.name.name === "modules")?.value : void 0;
   if (!modulesTable) throw new Error("@tilua/compiler: the bundle runtime has no modules table");
   for (const module2 of modules.values()) {

package/dist/cli.js

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

package/dist/index.cjs

@@ -216,14 +216,18 @@ var Lowerer = class {
     const body = this.options.module ? this.module(this.options.module) : this.topLevel(this.source.body.statements);
     const helpers = this.helperDefinitions();
     const captured = [...this.builtins].map(([global, local2]) => local([local2], [identifier(global)]));
+    const scriptArgs = this.usesScriptArgs && !this.options.module ? [local(["scriptArgs"], [table([{ type: "TableFieldPositional", value: vararg() }])])] : [];
     return {
-      statements: [...captured, ...helpers, ...this.classRuntimeStatements(), ...body],
+      statements: [...scriptArgs, ...captured, ...helpers, ...this.classRuntimeStatements(), ...body],
       exportsName: this.exportsName,
       module: this.info,
       diagnostics: this.diagnostics,
-      origins: this.origins
+      origins: this.origins,
+      usesScriptArgs: this.usesScriptArgs
     };
   }
+  /** Whether the file reads `scriptArgs`, the language's own global. */
+  usesScriptArgs = false;
   report(node, message) {
     this.diagnostics.push({ message, line: node.line.start, column: node.column.start });
   }
@@ -348,6 +352,10 @@ var Lowerer = class {
   /** The name a global is read by at `node`, or `undefined` when `node` is
    *  not a global — a local of the same name is the author's. */
   globalName(node) {
+    if (node.type === "MemberExpression" && !node.optional) {
+      const base = this.globalName(node.object);
+      return base === void 0 ? void 0 : `${base}.${node.property.name}`;
+    }
     if (node.type !== "Identifier") return void 0;
     const id = this.scopes.bindingOf.get(node);
     if (id === void 0) return node.name;
@@ -644,7 +652,7 @@ var Lowerer = class {
           break;
         }
         case "ReturnStatement":
-          if (declaration.arguments.length) this.report(declaration, "A module cannot return a value; export it instead");
+          if (declaration.argument) this.report(declaration, "A module cannot return a value; export it instead");
           body.push(returns([]));
           break;
         case "ImportStatement":
@@ -823,7 +831,7 @@ var Lowerer = class {
       case "CallStatement": {
         const chain = optionalChain(node.expression);
         if (chain) return [this.optionalCallStatement(chain)];
-        const expression = this.expression(node.expression);
+        const expression = this.callValues(node.expression);
         if (expression.type !== "CallExpression" && expression.type !== "MethodCallExpression") {
           this.report(node, "A statement must be a call");
           return [];
@@ -876,23 +884,26 @@ var Lowerer = class {
         }];
       case "GenericForStatement": {
         const prelude = [];
-        const variables = node.variables.map((target) => {
-          if (target.type === "IdentifierPattern") return this.name(target.name);
-          const temp = this.names.fresh("item");
-          prelude.push(...this.destructure(target, identifier(temp), "declare"));
-          return temp;
-        });
-        if (variables.length === 1 && this.options.types?.iteratesValues.has(node)) {
-          variables.unshift(this.names.fresh("_"));
+        let item;
+        if (node.variable.type === "IdentifierPattern") {
+          item = this.name(node.variable.name);
+        } else {
+          item = this.names.fresh("item");
+          prelude.push(...this.destructure(node.variable, identifier(item), "declare"));
         }
+        const form = this.options.types?.loops.get(node) ?? { walks: "values", viaIter: false };
+        let source = this.expression(node.iterator);
+        if (form.viaIter) source = methodCall(source, "__iter", []);
+        const variables = form.walks === "values" ? [this.names.fresh("_"), item] : [item];
+        const iterators = form.walks === "iteration" ? [call(this.builtin("unpack"), [source, number(1), number(3)])] : [source];
         return [genericFor(
           variables,
-          node.iterators.map((e) => this.expression(e)),
+          iterators,
           this.loopBody51(this.block(node.body, prelude)).statements
         )];
       }
       case "ReturnStatement":
-        return [returns(this.values(node.arguments))];
+        return [returns(node.argument ? [this.expression(node.argument)] : [])];
       case "BreakStatement":
         return [{ type: "BreakStatement", ...spanOf(node) }];
       case "ContinueStatement":
@@ -936,7 +947,7 @@ var Lowerer = class {
   //     end
   //     function Dog.speak(this) ... end
   //
-  // `new Dog(x)` is `Dog.new(x)`, `dog:speak()` passes the instance
+  // `Dog.new(x)` builds one, `dog:speak()` passes the instance
   // as `this`, and `super.speak()` is `Animal.speak(this)` — the
   // base's own function, run on this instance.
   // ============================================================
@@ -962,6 +973,7 @@ var Lowerer = class {
   classRuntimeStatements() {
     if (!this.classHelpers) return [];
     const { build, accessors } = this.classHelpers;
+    const metamethods = `{ ${CLASS_METAMETHODS.map((name) => `"${name}"`).join(", ")} }`;
     return (0, import_luau_parser.parse)(`
 local function ${build}(base)
     local class = { __getters = {}, __setters = {} }
@@ -972,6 +984,9 @@ local function ${build}(base)
         setmetatable(class, { __index = base })
         setmetatable(class.__getters, { __index = base.__getters })
         setmetatable(class.__setters, { __index = base.__setters })
+        for _, key in ipairs(${metamethods}) do
+            class[key] = base[key]
+        end
     end
     return class
 end
@@ -1034,6 +1049,7 @@ end
             }
             break;
           case "ClassMethod":
+            if (member2.isAbstract) break;
             out.push(this.functionStatement(
               member(self, member2.name.name),
               member2,
@@ -1055,7 +1071,7 @@ end
         }
       }
       out.push(this.classInit(node, self));
-      out.push(this.classNew(node, self));
+      if (!node.isAbstract) out.push(this.classNew(node, self));
       out.push(callStatement(call(identifier(accessors), [self])));
     } finally {
       this.classContext = previous;
@@ -1333,6 +1349,10 @@ end
     }
     switch (node.type) {
       case "Identifier":
+        if (node.name === "scriptArgs" && this.isLanguageGlobal(node)) {
+          this.usesScriptArgs = true;
+          return identifier("scriptArgs");
+        }
         return this.loweredGlobalValue(node) ?? this.reference(node);
       case "NilLiteral":
         return nil();
@@ -1342,8 +1362,6 @@ end
         return number(node.value, this.numberRaw(node));
       case "StringLiteral":
         return string(node.value);
-      case "VarargExpression":
-        return vararg();
       // Only a recovering parse makes one, and a syntax error stops the build.
       case "ErrorExpression":
         this.report(node, "Syntax error");
@@ -1364,11 +1382,6 @@ end
       }
       case "UnaryExpression":
         return unary(node.operator, this.expression(node.argument));
-      case "NewExpression":
-        return call(
-          member(this.expression(node.callee), "new"),
-          this.values(node.arguments)
-        );
       case "SuperExpression":
         return this.superClassReference(node);
       case "SpreadElement":
@@ -1376,17 +1389,16 @@ end
         return nil();
       case "ClassExpression":
         return this.classExpression(node);
-      case "MemberExpression":
-      case "IndexExpression":
       case "CallExpression":
-      case "MethodCallExpression": {
+      case "MethodCallExpression":
+        return this.callValues(node);
+      case "MemberExpression":
+      case "IndexExpression": {
         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));
-        }
-        return this.link(node, this.expression(object));
+        const global = node.type === "MemberExpression" ? this.loweredGlobalValue(node) : void 0;
+        if (global) return global;
+        return this.link(node, this.expression(linkObject(node)));
       }
       case "ParenthesizedExpression":
         return parenthesized(this.expression(node.expression));
@@ -1405,14 +1417,47 @@ end
         };
     }
   }
+  /** A call. */
+  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));
+    }
+    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)];
+  }
+  /** 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,
    *  `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. */
-  values(list) {
+   *  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) {
     const spreads = list.filter((a) => a.type === "SpreadElement");
-    if (!spreads.length) return list.map((a) => this.expression(a));
+    if (!spreads.length) {
+      const lowered = list.map((a) => this.expression(a));
+      return asArguments ? this.keptToOne(list, lowered) : lowered;
+    }
     const unpack = (value) => call(member(this.builtin("table"), "unpack"), [value]);
     const last = list[list.length - 1];
     if (spreads.length === 1 && last.type === "SpreadElement") {
@@ -1433,13 +1478,13 @@ end
         return index(object, this.expression(node.index));
       case "CallExpression": {
         const lowered = this.loweredGlobalCall(node);
-        const args = this.values(node.arguments);
-        if (lowered) return call(calleePath(lowered.callee), [...lowered.prepend, ...args]);
-        return call(object, args);
+        const args = this.values(node.arguments, true);
+        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);
+        const args = this.values(node.arguments, true);
         if (lowered) {
           return call(calleePath(lowered.callee), [
             ...lowered.prepend,
@@ -1673,7 +1718,8 @@ end
    *  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 = node.elements;
+      return table(this.keptToOne(elements, elements.map((e) => this.expression(e))).map((value) => ({ type: "TableFieldPositional", value })));
     }
     const parts = [];
     let current = [];
@@ -1872,6 +1918,24 @@ function allNodes(root) {
   visit(root);
   return out;
 }
+var CLASS_METAMETHODS = [
+  "__add",
+  "__sub",
+  "__mul",
+  "__div",
+  "__idiv",
+  "__mod",
+  "__pow",
+  "__unm",
+  "__concat",
+  "__len",
+  "__eq",
+  "__lt",
+  "__le",
+  "__call",
+  "__tostring",
+  "__iter"
+];
 
 // src/linemap.ts
 function statementsOf(node) {
@@ -2011,7 +2075,8 @@ async function bundle(options) {
       name: source.name,
       statements: lowered.statements,
       exportsName: lowered.exportsName,
-      info: lowered.module
+      info: lowered.module,
+      usesScriptArgs: lowered.usesScriptArgs
     });
   }
   for (const [file, fileDirectives] of directives) {
@@ -2036,6 +2101,9 @@ async function bundle(options) {
   }
   const program2 = (0, import_luau_parser2.parse)(runtime(G));
   const assignment = program2.body.statements[1];
+  if ([...modules.values()].some((m) => m.usesScriptArgs)) {
+    program2.body.statements.unshift(local(["scriptArgs"], [table([{ type: "TableFieldPositional", value: { type: "VarargExpression" } }])]));
+  }
   const modulesTable = assignment.type === "AssignmentStatement" && assignment.values[0].type === "TableExpression" ? assignment.values[0].fields.find((f) => f.type === "TableFieldNamed" && f.name.name === "modules")?.value : void 0;
   if (!modulesTable) throw new Error("@tilua/compiler: the bundle runtime has no modules table");
   for (const module2 of modules.values()) {

package/dist/index.d.cts

@@ -142,6 +142,9 @@ interface LowerResult {
      *  file it was lowered from, this is what turns a line of the bundle back
      *  into a place someone can open. */
     readonly origins: WeakMap<L.Statement, number>;
+    /** The file reads `scriptArgs`: whatever runs it has to set it up, from
+     *  the chunk's own `...` — this file, compiled alone, does it itself. */
+    readonly usesScriptArgs: boolean;
 }
 /** How a module's exports behave at runtime, beyond what its code assigns. */
 interface ModuleInfo {

package/dist/index.d.ts

@@ -142,6 +142,9 @@ interface LowerResult {
      *  file it was lowered from, this is what turns a line of the bundle back
      *  into a place someone can open. */
     readonly origins: WeakMap<L.Statement, number>;
+    /** The file reads `scriptArgs`: whatever runs it has to set it up, from
+     *  the chunk's own `...` — this file, compiled alone, does it itself. */
+    readonly usesScriptArgs: boolean;
 }
 /** How a module's exports behave at runtime, beyond what its code assigns. */
 interface ModuleInfo {

package/dist/index.js

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

package/package.json

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