@tilua/compiler 1.0.2 → 2.0.0

package/dist/index.cjs

@@ -137,144 +137,6 @@ function isLuauName(name) {
   return /^[A-Za-z_][A-Za-z0-9_]*$/.test(name) && !LUAU_KEYWORDS.has(name);
 }
 
-// src/console.ts
-var CONSOLE_RUNTIME = `
-local __NAME__ = (function()
-    local console = {}
-    local MAX_DEPTH = 4
-    local ESCAPES = { ["\\n"] = "\\\\n", ["\\r"] = "\\\\r", ["\\t"] = "\\\\t", ["\\""] = "\\\\\\"", ["\\\\"] = "\\\\\\\\" }
-
-    local function quote(text)
-        return '"' .. text:gsub('[%c"\\\\]', function(c) return ESCAPES[c] or ("\\\\%d"):format(c:byte()) end) .. '"'
-    end
-
-    -- A table with 1..n and nothing else prints as a list, as it was written.
-    local function isArray(value)
-        local count = 0
-        for key in pairs(value) do
-            if type(key) ~= "number" then return false end
-            count = count + 1
-        end
-        return count == #value
-    end
-
-    local function isIdentifier(key)
-        return type(key) == "string" and key:match("^[A-Za-z_][A-Za-z0-9_]*$") ~= nil
-    end
-
-    local render
-
-    local function renderTable(value, meta, seen, depth, indent)
-        if seen[value] then return "<cycle>" end
-        if depth > MAX_DEPTH then return "..." end
-        seen[value] = true
-        local inner = indent .. "  "
-        local parts = {}
-        if isArray(value) then
-            for i = 1, #value do
-                parts[#parts + 1] = inner .. render(value[i], nil, seen, depth + 1, inner)
-            end
-        else
-            local keys = {}
-            for key in pairs(value) do keys[#keys + 1] = key end
-            table.sort(keys, function(a, b) return tostring(a) < tostring(b) end)
-            for _, key in ipairs(keys) do
-                local name = isIdentifier(key) and key or ("[" .. render(key, nil, seen, depth + 1, inner) .. "]")
-                parts[#parts + 1] = inner .. name .. " = " .. render(value[key], nil, seen, depth + 1, inner)
-            end
-        end
-        seen[value] = nil
-        if #parts == 0 then return "{}" end
-        local open = isArray(value) and "[" or "{"
-        local close = isArray(value) and "]" or "}"
-        return open .. "\\n" .. table.concat(parts, ",\\n") .. "\\n" .. indent .. close
-    end
-
-    -- \`meta\` is what the compiler knew about this value and the runtime cannot:
-    -- a function's type, and the code it was written as.
-    render = function(value, meta, seen, depth, indent)
-        local kind = type(value)
-        if kind == "string" then return quote(value) end
-        if kind == "number" or kind == "boolean" or kind == "nil" then return tostring(value) end
-        if kind == "function" then
-            if meta == nil then return "function" end
-            if meta[2] == nil or meta[2] == "" then return meta[1] end
-            return meta[1] .. "  " .. meta[2]
-        end
-        if kind == "table" then
-            local shown = rawget(value, "__tostring") == nil and getmetatable(value)
-            -- A value with its own \`__tostring\` (a Roblox Vector3, a class
-            -- instance that says how it reads) is trusted to describe itself.
-            if shown ~= nil and rawget(shown, "__tostring") ~= nil then return tostring(value) end
-            return renderTable(value, meta, seen, depth, indent)
-        end
-        return tostring(value)
-    end
-
-    local function describe(meta, index, value)
-        return render(value, meta ~= nil and meta[index] or nil, {}, 1, "")
-    end
-
-    local function join(meta, count, ...)
-        local parts = {}
-        for i = 1, count do
-            parts[#parts + 1] = describe(meta, i, (select(i, ...)))
-        end
-        return table.concat(parts, " ")
-    end
-
-    -- A line of the bundle, as the place in the project that wrote it.
-    local lines = __LINES__
-    local function place(line)
-        local origin = lines ~= nil and lines[tonumber(line)]
-        if origin == nil then return nil end
-        return origin[1] .. ":" .. tostring(origin[2])
-    end
-
-    -- Luau names the bundle in every frame; the project's files are what the
-    -- reader knows. Frames the map has nothing for are dropped: they are this
-    -- runtime's own, and the bundle's.
-    local function trace(level)
-        local raw = debug.traceback(nil, level)
-        local out = {}
-        for frame in raw:gmatch("[^\\n]+") do
-            local line = frame:match(":(%d+)")
-            local at = line ~= nil and place(line) or nil
-            if at ~= nil then
-                local name = frame:match("function ([%w_.:]+)")
-                out[#out + 1] = "    at " .. at .. (name ~= nil and (" (" .. name .. ")") or "")
-            end
-        end
-        return table.concat(out, "\\n")
-    end
-
-    -- Never on the caller's thread: reporting a problem must not become one.
-    local detach = (task ~= nil and task.spawn) or function(f) return f() end
-
-    local function raise(prefix, meta, count, ...)
-        local message = prefix .. join(meta, count, ...)
-        local where = trace(3)
-        detach(function()
-            error(where ~= "" and (message .. "\\n" .. where) or message, 0)
-        end)
-    end
-
-    function console.log(meta, ...)
-        print(join(meta, select("#", ...), ...))
-    end
-
-    function console.warn(meta, ...)
-        raise("[warn] ", meta, select("#", ...), ...)
-    end
-
-    function console.error(meta, ...)
-        raise("", meta, select("#", ...), ...)
-    end
-
-    return console
-end)()
-`;
-
 // src/names.ts
 var Names = class _Names {
   constructor(taken) {
@@ -354,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 });
   }
@@ -422,60 +288,9 @@ var Lowerer = class {
   }
   loweringNames = /* @__PURE__ */ new Map();
   loweringUsed = [];
-  /** What a library says `receiver:method(...)` is. The last library
-   *  loaded is asked first, so a project's own library can answer for a
-   *  method an earlier one also claims; no answer leaves an ordinary Luau
-   *  method call, which is what a value that answers to the method itself
-   *  wants (`text:upper()`). */
-  /** `console:log(a, f)` and its two siblings.
-   *
-   *  Handled here rather than through a library's lowering because what they
-   *  need is not a different callee but *more than was written*: a function
-   *  prints as its type and its code, and neither survives to runtime. The
-   *  compiler is the only thing that has both, so it passes them along:
-   *
-   *      console:log(a, double)
-   *      -- becomes
-   *      tilua_console.log({ [2] = { "(x: number) => number", "(x: number) => x * 2" } }, a, double)
-   *
-   *  The meta table is `nil` when nothing was worth saying, which is most
-   *  calls. `console` itself is never passed: it holds nothing. */
-  consoleCall(node) {
-    if (node.object.type !== "Identifier" || node.object.name !== "console") return void 0;
-    const method = node.method.name;
-    if (method !== "log" && method !== "warn" && method !== "error") return void 0;
-    const binding = this.scopes.bindingOf.get(node.object);
-    if (binding !== void 0 && this.scopes.bindings.get(binding)?.kind !== "global") return void 0;
-    const meta = this.consoleMeta(node.arguments);
-    return call(
-      member(this.helper("console"), method),
-      [meta ?? nil(), ...this.values(node.arguments)]
-    );
-  }
-  /** What the compiler knows about the arguments and the runtime cannot:
-   *  for each function argument, the type it was inferred as and the code it
-   *  was written as. Keyed by position, so an argument that needs nothing
-   *  costs nothing. */
-  consoleMeta(args) {
-    const fields = [];
-    args.forEach((argument, index2) => {
-      const type = this.options.types?.typeOf.get(argument);
-      if (!type || !isFunctionType(type)) return;
-      const written = this.writtenSource(this.declarationOf(argument) ?? argument);
-      fields.push({
-        type: "TableFieldComputed",
-        key: number(index2 + 1),
-        value: table([
-          { type: "TableFieldPositional", value: string((0, import_parser2.formatType)(type)) },
-          { type: "TableFieldPositional", value: string(written) }
-        ])
-      });
-    });
-    return fields.length ? table(fields) : void 0;
-  }
   /** What a name was declared as: the value of `const f = ...`, or the whole
-   *  `function f() { ... }`. Built once, on the first `console` call that
-   *  needs it — most files have none. */
+   *  `function f() { ... }`. Built once, on the first call a library asks
+   *  about — most files have none. */
   declarationOf(argument) {
     if (argument.type !== "Identifier") return void 0;
     if (!this.declarations) {
@@ -514,21 +329,131 @@ var Lowerer = class {
     const trim = (line) => line.startsWith(indent) ? line.slice(indent.length) : line;
     return [first, ...middle.map(trim), trim(last)].join("\n");
   }
+  /** Where `node` was written, as a library is told it. */
+  callSite(node) {
+    return { file: this.options.file, line: node.line.start, column: node.column.start };
+  }
+  /** What the compiler knows about each argument and the runtime cannot:
+   *  its type, and the code it — or what it names — was written as. Built
+   *  only if a library reads it. */
+  argumentInfo(args) {
+    return args.map((argument) => {
+      const declaration = this.declarationOf(argument);
+      const type = this.options.types?.typeOf.get(argument);
+      return {
+        type,
+        typeText: type ? (0, import_parser2.formatType)(type) : void 0,
+        source: this.writtenSource(argument),
+        declaration: declaration ? this.writtenSource(declaration) : void 0,
+        spread: argument.type === "SpreadElement"
+      };
+    });
+  }
+  /** 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;
+    return this.scopes.bindings.get(id)?.kind === "global" ? node.name : void 0;
+  }
+  /** What a library says `receiver:method(...)` is. The last library
+   *  loaded is asked first, so a project's own library can answer for a
+   *  method an earlier one also claims; no answer leaves an ordinary Luau
+   *  method call, which is what a value that answers to the method itself
+   *  wants (`text:upper()`). */
   loweredMethodCall(node) {
     const lowerings = this.options.lowerings;
-    if (!lowerings?.length) return void 0;
+    if (!lowerings?.some((l) => l.plugin.methodCall)) return void 0;
     const receiver = this.options.types?.typeOf.get(node.object);
+    const receiverGlobal = this.globalName(node.object);
+    const info = this.lazyArguments(node.arguments);
     for (let i = lowerings.length - 1; i >= 0; i--) {
-      const answer = lowerings[i].plugin.methodCall?.({
+      const plugin = lowerings[i].plugin;
+      if (!plugin.methodCall) continue;
+      const answer = plugin.methodCall({
         method: node.method.name,
         receiver,
+        receiverGlobal,
         argumentCount: node.arguments.length,
+        at: this.callSite(node.method),
+        get arguments() {
+          return info();
+        },
+        use: (runtime2) => this.loweringRuntime(i, runtime2)
+      });
+      if (answer) {
+        return {
+          callee: answer.callee,
+          prepend: this.prepended(answer.prepend, i, node),
+          passReceiver: answer.passReceiver !== false
+        };
+      }
+    }
+    return void 0;
+  }
+  /** What a library says a call to a global — `print(x)` — is. */
+  loweredGlobalCall(node) {
+    const lowerings = this.options.lowerings;
+    if (!lowerings?.some((l) => l.plugin.globalCall)) return void 0;
+    const name = this.globalName(node.callee);
+    if (name === void 0) return void 0;
+    const info = this.lazyArguments(node.arguments);
+    for (let i = lowerings.length - 1; i >= 0; i--) {
+      const plugin = lowerings[i].plugin;
+      if (!plugin.globalCall) continue;
+      const answer = plugin.globalCall({
+        name,
+        at: this.callSite(node.callee),
+        get arguments() {
+          return info();
+        },
+        use: (runtime2) => this.loweringRuntime(i, runtime2)
+      });
+      if (answer) return { callee: answer.callee, prepend: this.prepended(answer.prepend, i, node) };
+    }
+    return void 0;
+  }
+  /** What a library says a global read as a value — `local p = print` — is. */
+  loweredGlobalValue(node) {
+    const lowerings = this.options.lowerings;
+    if (!lowerings?.some((l) => l.plugin.globalValue)) return void 0;
+    const name = this.globalName(node);
+    if (name === void 0) return void 0;
+    for (let i = lowerings.length - 1; i >= 0; i--) {
+      const answer = lowerings[i].plugin.globalValue?.({
+        name,
+        at: this.callSite(node),
         use: (runtime2) => this.loweringRuntime(i, runtime2)
       });
-      if (answer) return { callee: answer.callee, passReceiver: answer.passReceiver !== false };
+      if (answer !== void 0) return this.libraryExpression(answer, i, node);
     }
     return void 0;
   }
+  lazyArguments(args) {
+    let info;
+    return () => info ??= this.argumentInfo(args);
+  }
+  prepended(sources, index2, node) {
+    return (sources ?? []).flatMap((source) => {
+      const expression = this.libraryExpression(source, index2, node);
+      return expression ? [expression] : [];
+    });
+  }
+  /** Luau a library wrote as an expression. One that does not parse is the
+   *  library's mistake, reported at the call it was written for. */
+  libraryExpression(source, index2, node) {
+    try {
+      return (0, import_luau_parser.parseExpressionFromSource)(source);
+    } catch (error) {
+      this.report(node, `'${this.options.lowerings[index2].from}' lowered this to Luau that does not parse: ${JSON.stringify(source)} (${error.message})`);
+      return void 0;
+    }
+  }
   helperDefinitions() {
     const out = [];
     const assign2 = this.helpers.get("assign");
@@ -556,12 +481,9 @@ var Lowerer = class {
         });
         continue;
       }
-      out.push(...(0, import_luau_parser.parse)(source.replace(/__NAME__/g, name)).body.statements);
-    }
-    const console = this.helpers.get("console");
-    if (console) {
       const lines = this.options.module?.lines ?? "nil";
-      out.push(...(0, import_luau_parser.parse)(CONSOLE_RUNTIME.replace(/__NAME__/g, console).replace(/__LINES__/g, lines)).body.statements);
+      const fail = this.options.module?.fail ?? "nil";
+      out.push(...(0, import_luau_parser.parse)(source.replace(/__NAME__/g, name).replace(/__LINES__/g, lines).replace(/__FAIL__/g, fail)).body.statements);
     }
     const concat = this.helpers.get("concat");
     if (concat) {
@@ -730,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":
@@ -909,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 [];
@@ -962,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":
@@ -1022,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.
   // ============================================================
@@ -1048,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 = {} }
@@ -1058,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
@@ -1120,6 +1049,7 @@ end
             }
             break;
           case "ClassMethod":
+            if (member2.isAbstract) break;
             out.push(this.functionStatement(
               member(self, member2.name.name),
               member2,
@@ -1141,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;
@@ -1419,7 +1349,11 @@ end
     }
     switch (node.type) {
       case "Identifier":
-        return this.reference(node);
+        if (node.name === "scriptArgs" && this.isLanguageGlobal(node)) {
+          this.usesScriptArgs = true;
+          return identifier("scriptArgs");
+        }
+        return this.loweredGlobalValue(node) ?? this.reference(node);
       case "NilLiteral":
         return nil();
       case "BooleanLiteral":
@@ -1428,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");
@@ -1450,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":
@@ -1462,12 +1389,15 @@ 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 global = node.type === "MemberExpression" ? this.loweredGlobalValue(node) : void 0;
+        if (global) return global;
         return this.link(node, this.expression(linkObject(node)));
       }
       case "ParenthesizedExpression":
@@ -1487,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") {
@@ -1513,15 +1476,21 @@ end
         return member(object, node.property.name);
       case "IndexExpression":
         return index(object, this.expression(node.index));
-      case "CallExpression":
-        return call(object, this.values(node.arguments));
+      case "CallExpression": {
+        const lowered = this.loweredGlobalCall(node);
+        const args = this.values(node.arguments, true);
+        if (!lowered) return call(object, args);
+        return call(calleePath(lowered.callee), [...lowered.prepend, ...args]);
+      }
       case "MethodCallExpression": {
-        const consoleCall = this.consoleCall(node);
-        if (consoleCall) return consoleCall;
-        const args = this.values(node.arguments);
         const lowered = this.loweredMethodCall(node);
+        const args = this.values(node.arguments, true);
         if (lowered) {
-          return call(calleePath(lowered.callee), lowered.passReceiver ? [object, ...args] : args);
+          return call(calleePath(lowered.callee), [
+            ...lowered.prepend,
+            ...lowered.passReceiver ? [object] : [],
+            ...args
+          ]);
         }
         if (!isLuauName(node.method.name)) {
           this.report(node.method, `'${node.method.name}' is a Luau keyword and cannot be called with ':'`);
@@ -1749,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 = [];
@@ -1934,10 +1904,6 @@ function mentions(expression, name) {
   walk(expression);
   return found;
 }
-function isFunctionType(type) {
-  if (type.kind === "function") return true;
-  return type.kind === "intersection" && type.types.some((t) => t.kind === "function");
-}
 function allNodes(root) {
   const out = [];
   const visit = (value) => {
@@ -1952,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) {
@@ -2061,16 +2045,19 @@ async function bundle(options) {
     const file = pending.shift();
     if (modules.has(file)) continue;
     const source = sources.get(file);
+    const shown = (0, import_node_path2.relative)(root, file).replace(/\\/g, "/");
     const lowered = lower(source.program, source.scopes, {
       names,
       types: analysis.types.get(file),
       lowerings,
       target: options.target ?? config?.target,
       source: source.text,
+      file: shown,
       module: {
         name: source.name,
         require: requireExpression,
         lines: `${G}.lines`,
+        fail: `${G}.fail`,
         resolve: (specifier) => {
           const target = (0, import_parser3.resolveModulePath)(file, specifier, config);
           if (!target || target.endsWith(".d.tilua") || !sources.has(target)) return void 0;
@@ -2080,7 +2067,6 @@ async function bundle(options) {
       }
     });
     for (const d of lowered.diagnostics) diagnostics.push({ file, ...d, category: "module" });
-    const shown = (0, import_node_path2.relative)(root, file).replace(/\\/g, "/");
     for (const statement of allStatements(lowered.statements)) {
       const line = lowered.origins.get(statement);
       if (line !== void 0) origins.set(statement, { file: shown, line });
@@ -2089,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) {
@@ -2114,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()) {
@@ -2130,11 +2120,21 @@ async function bundle(options) {
     fields.push(field("load", functionExpression(functionBody([module2.exportsName], module2.statements, true))));
     modulesTable.fields.push({ type: "TableFieldComputed", key: string(module2.name), value: table(fields) });
   }
-  const start = call(requireExpression, [string(sources.get(entry).name)]);
-  program2.body.statements.push(modules.get(entry).info.exports ? returns([start]) : callStatement(start));
+  const ok = names.fresh("ok");
+  const result = names.fresh("result");
+  const entryStatements = (0, import_luau_parser2.parse)(`
+local ${ok}, ${result} = xpcall(function()
+    return ${G}.require(${JSON.stringify(sources.get(entry).name)})
+end, ${G}.fail)
+if not ${ok} then
+    error(${result}, 0)
+end
+${modules.get(entry).info.exports ? `return ${result}` : ""}
+`).body.statements;
+  program2.body.statements.push(...entryStatements);
   const map = buildLineMap(program2, (0, import_luau_parser2.parse)((0, import_luau_parser2.print)(program2)), origins);
   if (map.size) {
-    program2.body.statements.splice(program2.body.statements.length - 1, 0, assign(
+    program2.body.statements.splice(program2.body.statements.length - entryStatements.length, 0, assign(
       [member(identifier(G), "lines")],
       [(0, import_luau_parser2.parseExpressionFromSource)(lineMapSource(map))]
     ));
@@ -2146,6 +2146,52 @@ function runtime(G) {
 local ${G}
 ${G} = {
     modules = {},
+    -- Filled in just before the entry runs: bundle line -> { file, line }.
+    lines = nil,
+    -- What an error nothing caught says, in the project's files: the bundle's
+    -- own positions in the message are replaced by the places they came from,
+    -- and a traceback of those places follows. A message that is not a string
+    -- is left as it is, and a position that is not this bundle's (a library
+    -- that raised its error with one already mapped) is left alone.
+    fail = function(message)
+        if type(message) ~= "string" then
+            return message
+        end
+        local lines = ${G}.lines
+        if lines == nil then
+            return debug.traceback(message, 2)
+        end
+        local chunk
+        if debug.info ~= nil then
+            chunk = debug.info(1, "s")
+        else
+            chunk = debug.getinfo(1, "S").short_src
+        end
+        local prefix = chunk:gsub("%p", "%%%0")
+        local function place(line)
+            local origin = lines[tonumber(line)]
+            if origin == nil then
+                return nil
+            end
+            return origin[1] .. ":" .. tostring(origin[2])
+        end
+        local mapped = message:gsub(prefix .. ":(%d+)", function(line)
+            return place(line)
+        end)
+        local frames = {}
+        for frame in debug.traceback("", 2):gmatch("[^\\n]+") do
+            local line = frame:match(prefix .. ":(%d+)")
+            local at = line ~= nil and place(line) or nil
+            if at ~= nil then
+                local name = frame:match("function ([%w_.:]+)")
+                frames[#frames + 1] = "    at " .. at .. (name ~= nil and (" (" .. name .. ")") or "")
+            end
+        end
+        if #frames == 0 then
+            return mapped
+        end
+        return mapped .. "\\n" .. table.concat(frames, "\\n")
+    end,
     records = {},
     require = function(name)
         local record = ${G}.records[name]