@tilua/compiler 1.1.0 → 2.1.0

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()) {
@@ -2148,7 +2216,22 @@ ${G} = {
 }
 `;
 }
+function stampOf(file) {
+  try {
+    const at = (0, import_node_fs.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 = (0, import_node_fs.readFileSync)(file, "utf8");
@@ -2158,7 +2241,9 @@ function parseFile(file, diagnostics, directives) {
   }
   try {
     const program = (0, import_parser3.parse)(text);
-    directives.set(file, (0, import_parser3.directivesOf)(text));
+    const found = (0, import_parser3.directivesOf)(text);
+    directives.set(file, found);
+    if (stamp !== void 0) parsedFiles.set(file, { stamp, program, text, directives: found });
     return { program, text };
   } catch (error) {
     if (error instanceof import_parser3.ParseError || error instanceof import_parser3.LexError) {
@@ -2172,22 +2257,93 @@ function parseFile(file, diagnostics, directives) {
 function importedSpecifiers(program) {
   return program.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 = (0, import_node_fs.statSync)(file);
+    stamp = `${at.size}:${at.mtimeMs}`;
+  } catch {
+    stamp = "";
+  }
+  const cached = libraryCache.get(file);
+  if (cached && cached.stamp === stamp) return cached.program;
+  const program = (0, import_parser3.parse)((0, import_node_fs.readFileSync)(file, "utf8"));
+  libraryCache.set(file, { stamp, program });
+  return program;
+}
+var moduleAnalyses = /* @__PURE__ */ new Map();
 function analyzeModules(modules, config2) {
   const out2 = [];
   const analyses = /* @__PURE__ */ new Map();
   const libraries = config2 ? (0, import_parser3.resolveTypeLibraries)(config2) : { files: [], lowerings: [], problems: [] };
   for (const p of libraries.problems) out2.push({ file: p.file, message: p.message, line: p.line ?? 1, column: p.column ?? 1, category: "config" });
-  const libs = libraries.files.map((file) => (0, import_parser3.parse)((0, import_node_fs.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("|")}#${config2?.directory ?? ""}#${JSON.stringify(config2?.paths ?? {})}`;
+  const analyzeModule = (file, program) => {
+    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 === program && [...remembered.read].every(([read, stamp]) => stampOf(read) === stamp)) {
+      analyzed.set(file, remembered.result);
+      readWhile.set(file, remembered.read);
+      return remembered.result;
+    }
+    const scopes = (0, import_parser3.analyzeScopes)(program, { 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 = (0, import_parser3.analyzeTypes)(program, 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, read, result });
+      }
+    }
+    return result;
+  };
   const resolverFor = (file) => (specifier) => {
     const target = (0, import_parser3.resolveModulePath)(file, specifier, config2);
     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 program = byFile.get(target)?.program;
     if (!program) {
       try {
@@ -2199,30 +2355,19 @@ function analyzeModules(modules, config2) {
     inProgress.add(target);
     try {
       const scopes = (0, import_parser3.analyzeScopes)(program, { builtinGlobals: globals });
-      const types = (0, import_parser3.analyzeTypes)(program, scopes, { libs, resolveModule: resolverFor(target), diagnostics: false });
+      const types = byFile.has(target) ? analyzeModule(target, program).types : (0, import_parser3.analyzeTypes)(program, scopes, { libs, resolveModule: resolverFor(target), diagnostics: false });
       const exports2 = (0, import_parser3.moduleExports)(program, scopes, types, resolverFor(target));
       exportsCache.set(target, exports2);
+      noteRead();
       return exports2;
     } finally {
       inProgress.delete(target);
     }
   };
   for (const module2 of modules) {
-    const scopes = (0, import_parser3.analyzeScopes)(module2.program, { builtinGlobals: globals, reportUndeclared: libs.length > 0 });
-    for (const d of scopes.diagnostics) {
-      if (d.kind !== "undeclared") continue;
-      out2.push({ file: module2.file, message: d.message, line: d.node.line.start, column: d.node.column.start, category: "type" });
-    }
-    const types = (0, import_parser3.analyzeTypes)(module2.program, scopes, {
-      libs,
-      resolveModule: resolverFor(module2.file),
-      reportUnknownTypes: libs.length > 0
-    });
+    const { types, diagnostics } = analyzeModule(module2.file, module2.program);
     analyses.set(module2.file, types);
-    for (const d of types.diagnostics) {
-      const at = d.node;
-      out2.push({ file: module2.file, message: d.message, line: at.line.start, column: at.column.start, category: "type" });
-    }
+    out2.push(...diagnostics);
   }
   return { types: analyses, diagnostics: out2, lowerings: [...libraries.lowerings] };
 }

package/dist/cli.js

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