@tilua/compiler 1.1.0 → 2.1.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-TBSJRVKA.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";
@@ -1865,7 +1929,7 @@ async function loadLowerings(modules) {
 }
 
 // src/bundle.ts
-import { readFileSync } from "fs";
+import { readFileSync, statSync } from "fs";
 import { dirname, relative, resolve as resolve2 } from "path";
 import {
   parse,
@@ -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()) {
@@ -2154,7 +2222,22 @@ ${G} = {
 }
 `;
 }
+function stampOf(file) {
+  try {
+    const at = statSync(file);
+    return `${at.size}:${at.mtimeMs}`;
+  } catch {
+    return void 0;
+  }
+}
+var parsedFiles = /* @__PURE__ */ new Map();
 function parseFile(file, diagnostics, directives) {
+  const stamp = stampOf(file);
+  const cached = stamp !== void 0 ? parsedFiles.get(file) : void 0;
+  if (cached && cached.stamp === stamp) {
+    directives.set(file, cached.directives);
+    return { program: cached.program, text: cached.text };
+  }
   let text;
   try {
     text = readFileSync(file, "utf8");
@@ -2164,7 +2247,9 @@ function parseFile(file, diagnostics, directives) {
   }
   try {
     const program2 = parse(text);
-    directives.set(file, directivesOf(text));
+    const found = directivesOf(text);
+    directives.set(file, found);
+    if (stamp !== void 0) parsedFiles.set(file, { stamp, program: program2, text, directives: found });
     return { program: program2, text };
   } catch (error) {
     if (error instanceof ParseError || error instanceof LexError) {
@@ -2178,22 +2263,93 @@ function parseFile(file, diagnostics, directives) {
 function importedSpecifiers(program2) {
   return program2.body.statements.flatMap((s) => s.type === "ImportStatement" || s.type === "ExportAllStatement" || s.type === "ExportNamedStatement" && s.source ? [s.source.value] : []);
 }
+var libraryCache = /* @__PURE__ */ new Map();
+function parsedLibrary(file) {
+  let stamp;
+  try {
+    const at = statSync(file);
+    stamp = `${at.size}:${at.mtimeMs}`;
+  } catch {
+    stamp = "";
+  }
+  const cached = libraryCache.get(file);
+  if (cached && cached.stamp === stamp) return cached.program;
+  const program2 = parse(readFileSync(file, "utf8"));
+  libraryCache.set(file, { stamp, program: program2 });
+  return program2;
+}
+var moduleAnalyses = /* @__PURE__ */ new Map();
 function analyzeModules(modules, config) {
   const out = [];
   const analyses = /* @__PURE__ */ new Map();
   const libraries = config ? resolveTypeLibraries(config) : { files: [], lowerings: [], problems: [] };
   for (const p of libraries.problems) out.push({ file: p.file, message: p.message, line: p.line ?? 1, column: p.column ?? 1, category: "config" });
-  const libs = libraries.files.map((file) => parse(readFileSync(file, "utf8")));
+  const libs = libraries.files.map(parsedLibrary);
   const globals = libs.flatMap((lib) => lib.body.statements.flatMap((s) => s.type === "DeclareStatement" ? [s.name] : []));
   const byFile = new Map(modules.map((m) => [m.file, m]));
   const exportsCache = /* @__PURE__ */ new Map();
   const inProgress = /* @__PURE__ */ new Set();
+  const analyzed = /* @__PURE__ */ new Map();
+  let partials = 0;
+  const readWhile = /* @__PURE__ */ new Map();
+  const settingFor = `${libraries.files.join("|")}#${config?.directory ?? ""}#${JSON.stringify(config?.paths ?? {})}`;
+  const analyzeModule = (file, program2) => {
+    const done = analyzed.get(file);
+    if (done) return done;
+    const remembered = moduleAnalyses.get(file);
+    if (remembered && remembered.setting === settingFor && libs.length === remembered.libs.length && remembered.libs.every((lib, i) => lib === libs[i]) && remembered.program === program2 && [...remembered.read].every(([read, stamp]) => stampOf(read) === stamp)) {
+      analyzed.set(file, remembered.result);
+      readWhile.set(file, remembered.read);
+      return remembered.result;
+    }
+    const scopes = analyzeScopes(program2, { builtinGlobals: globals, reportUndeclared: libs.length > 0 });
+    const said = [];
+    for (const d of scopes.diagnostics) {
+      if (d.kind !== "undeclared") continue;
+      said.push({ file, message: d.message, line: d.node.line.start, column: d.node.column.start, category: "type" });
+    }
+    const before = partials;
+    const types = analyzeTypes(program2, scopes, {
+      libs,
+      resolveModule: resolverFor(file),
+      reportUnknownTypes: libs.length > 0
+    });
+    for (const d of types.diagnostics) {
+      const at = d.node;
+      said.push({ file, message: d.message, line: at.line.start, column: at.column.start, category: "type" });
+    }
+    const result = { types, diagnostics: said };
+    if (partials === before) {
+      analyzed.set(file, result);
+      const read = readWhile.get(file) ?? /* @__PURE__ */ new Map();
+      const own = stampOf(file);
+      if (own !== void 0) read.set(file, own);
+      readWhile.set(file, read);
+      if ([...read.values()].every((stamp) => stamp !== void 0)) {
+        moduleAnalyses.set(file, { setting: settingFor, libs: [...libs], program: program2, read, result });
+      }
+    }
+    return result;
+  };
   const resolverFor = (file) => (specifier) => {
     const target = resolveModulePath(file, specifier, config);
     if (!target) return void 0;
-    if (inProgress.has(target)) return { values: /* @__PURE__ */ new Map(), types: /* @__PURE__ */ new Map(), partial: true };
+    const noteRead = () => {
+      const read = readWhile.get(file) ?? /* @__PURE__ */ new Map();
+      readWhile.set(file, read);
+      const stamp = stampOf(target);
+      if (stamp !== void 0) read.set(target, stamp);
+      for (const [below, belowStamp] of readWhile.get(target) ?? []) read.set(below, belowStamp);
+    };
+    if (inProgress.has(target)) {
+      partials++;
+      return { values: /* @__PURE__ */ new Map(), types: /* @__PURE__ */ new Map(), partial: true };
+    }
     const cached = exportsCache.get(target);
-    if (cached) return cached;
+    if (cached) {
+      noteRead();
+      return cached;
+    }
     let program2 = byFile.get(target)?.program;
     if (!program2) {
       try {
@@ -2205,30 +2361,19 @@ function analyzeModules(modules, config) {
     inProgress.add(target);
     try {
       const scopes = analyzeScopes(program2, { builtinGlobals: globals });
-      const types = analyzeTypes(program2, scopes, { libs, resolveModule: resolverFor(target), diagnostics: false });
+      const types = byFile.has(target) ? analyzeModule(target, program2).types : analyzeTypes(program2, scopes, { libs, resolveModule: resolverFor(target), diagnostics: false });
       const exports = moduleExports(program2, scopes, types, resolverFor(target));
       exportsCache.set(target, exports);
+      noteRead();
       return exports;
     } finally {
       inProgress.delete(target);
     }
   };
   for (const module of modules) {
-    const scopes = analyzeScopes(module.program, { builtinGlobals: globals, reportUndeclared: libs.length > 0 });
-    for (const d of scopes.diagnostics) {
-      if (d.kind !== "undeclared") continue;
-      out.push({ file: module.file, message: d.message, line: d.node.line.start, column: d.node.column.start, category: "type" });
-    }
-    const types = analyzeTypes(module.program, scopes, {
-      libs,
-      resolveModule: resolverFor(module.file),
-      reportUnknownTypes: libs.length > 0
-    });
+    const { types, diagnostics } = analyzeModule(module.file, module.program);
     analyses.set(module.file, types);
-    for (const d of types.diagnostics) {
-      const at = d.node;
-      out.push({ file: module.file, message: d.message, line: at.line.start, column: at.column.start, category: "type" });
-    }
+    out.push(...diagnostics);
   }
   return { types: analyses, diagnostics: out, lowerings: [...libraries.lowerings] };
 }