@tilua/parser 3.0.1 → 3.1.0

package/dist/index.cjs

@@ -24,6 +24,7 @@ __export(index_exports, {
   CONFIG_FILE_NAMES: () => CONFIG_FILE_NAMES,
   Keywords: () => Keywords,
   LANGUAGE_GLOBALS: () => LANGUAGE_GLOBALS,
+  LUAU_KEYWORDS: () => LUAU_KEYWORDS,
   LexError: () => LexError,
   Operators: () => Operators,
   PRELUDE_SOURCE: () => PRELUDE_SOURCE,
@@ -45,20 +46,27 @@ __export(index_exports, {
   difference: () => difference,
   directivesOf: () => directivesOf,
   equalTypes: () => equalTypes,
+  escapeLuauString: () => escapeLuauString,
   falsyType: () => falsyType,
   findConfig: () => findConfig,
   fn: () => fn,
   formatType: () => formatType,
   getBinding: () => getBinding,
+  hasMembers: () => hasMembers,
   intersection: () => intersection,
   isAssignable: () => isAssignable,
   isClassType: () => isClassType,
+  isFunctionType: () => isFunctionType,
   isGlobal: () => isGlobal,
+  isIdentifier: () => isIdentifier,
+  isInstanceOf: () => isInstanceOf,
+  isLuauName: () => isLuauName,
   isPossiblyFalsy: () => isPossiblyFalsy,
   isPossiblyTruthy: () => isPossiblyTruthy,
   isUnassignedGlobal: () => isUnassignedGlobal,
   literal: () => literal,
   loadConfig: () => loadConfig,
+  luauString: () => luauString,
   matchInfer: () => matchInfer,
   moduleCandidates: () => moduleCandidates,
   moduleExports: () => moduleExports,
@@ -81,6 +89,7 @@ __export(index_exports, {
   readDirectives: () => readDirectives,
   resolveModulePath: () => resolveModulePath,
   resolveTypeLibraries: () => resolveTypeLibraries,
+  returnsTuple: () => returnsTuple,
   setAliasExpander: () => setAliasExpander,
   setDeferredBound: () => setDeferredBound,
   sourceMapTypes: () => sourceMapTypes,
@@ -99,7 +108,8 @@ __export(index_exports, {
   unknownType: () => unknownType,
   widen: () => widen,
   withAliasName: () => withAliasName,
-  withoutAliasName: () => withoutAliasName
+  withoutAliasName: () => withoutAliasName,
+  withoutNil: () => withoutNil2
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -708,7 +718,7 @@ function bindThis(func, at) {
   func.isMethod = true;
 }
 function bindThisParam(params, at) {
-  params.unshift({ type: "FunctionParameter", name: "this", ...spanFrom(at, at) });
+  params.unshift({ type: "FunctionParameter", name: "this", implicit: true, ...spanFrom(at, at) });
 }
 var ParseError = class extends Error {
   constructor(message, line, column) {
@@ -1765,7 +1775,7 @@ var Parser = class {
         };
       }
       if (isMethod) {
-        func.params.unshift({ type: "FunctionParameter", name: "self", ...spanFrom(target, target) });
+        func.params.unshift({ type: "FunctionParameter", name: "self", implicit: true, ...spanFrom(target, target) });
         func.isMethod = true;
       }
       return {
@@ -1959,47 +1969,7 @@ var Parser = class {
     const isStatic = modifiers.has("static");
     if (this.checkKeyword("function")) {
       this.advance();
-      const memberName = this.parseIdentifier();
-      if (modifiers.has("abstract")) {
-        const head = this.parseFunctionHead();
-        const func = {
-          type: "FunctionBody",
-          generics: head.generics,
-          params: head.params,
-          hasVarargs: head.hasVarargs,
-          returnType: head.returnType,
-          predicate: head.predicate,
-          body: { type: "Block", statements: [], ...spanFrom(head.start, this.previous()) },
-          ...spanFrom(head.start, this.previous())
-        };
-        if (!isStatic) bindThis(func, start);
-        if (!head.returnType) this.problem("An abstract method has no body to infer from: write its return type");
-        if (this.checkPunctuator("{")) this.problem("An abstract method has no body");
-        return { type: "ClassMethod", name: memberName, isStatic, func, isAbstract: true, ...spanFrom(start, this.previous()) };
-      }
-      const signatures = [];
-      let written = memberName;
-      while (true) {
-        const head = this.parseFunctionHead();
-        if (this.isClassOverloadContinuation(memberName.name, isStatic)) {
-          if (!isStatic) bindThisParam(head.params, start);
-          signatures.push({ ...this.headToSignature(head), name: written });
-          if (isStatic) this.advance();
-          this.expectKeyword("function");
-          written = this.parseIdentifier();
-          continue;
-        }
-        const func = this.headToBody(head, start);
-        if (!isStatic) bindThis(func, start);
-        return {
-          type: "ClassMethod",
-          name: memberName,
-          isStatic,
-          func,
-          signatures: signatures.length ? signatures : void 0,
-          ...spanFrom(start, this.previous())
-        };
-      }
+      return this.parseClassMethod(start, modifiers);
     }
     if (!isStatic && this.checkIdentifierValue("constructor") && this.punctuatorAt(1, "(")) {
       this.advance();
@@ -2009,6 +1979,9 @@ var Parser = class {
       bindThis(func, start);
       return { type: "ClassConstructor", func, ...spanFrom(start, this.previous()) };
     }
+    if (this.startsMethodShorthand(0)) {
+      return this.parseClassMethod(start, modifiers);
+    }
     if ((this.checkIdentifierValue("get") || this.checkIdentifierValue("set")) && this.peek(1).type === "Identifier" && this.punctuatorAt(2, "(")) {
       const kind = this.advance().value;
       const memberName = this.parseIdentifier();
@@ -2038,25 +2011,90 @@ var Parser = class {
       return { type: "ClassField", name: memberName, isStatic, typeAnnotation, init, ...spanFrom(start, this.previous()) };
     }
     if (this.recover) {
-      this.softError("Expected a class member: a field, 'function', 'constructor', 'get' or 'set'");
+      this.softError("Expected a class member: a field, a method, 'constructor', 'get' or 'set'");
       this.advance();
       return void 0;
     }
-    this.error("Expected a class member: a field, 'function', 'constructor', 'get' or 'set'");
+    this.error("Expected a class member: a field, a method, 'constructor', 'get' or 'set'");
+  }
+  /** A name at `offset` opening a method without `function`: `name(` or
+   *  `name<T>(`. A field's name is followed by `:` or `=` instead. */
+  startsMethodShorthand(offset) {
+    if (this.peek(offset).type !== "Identifier") return false;
+    const next = this.peek(offset + 1);
+    return (next.type === "Punctuator" || next.type === "Operator") && (next.value === "(" || next.value === "<");
+  }
+  /** A method, from its name on: `function` (if written) and the modifiers
+   *  are behind. */
+  parseClassMethod(start, modifiers) {
+    const isStatic = modifiers.has("static");
+    const memberName = this.parseIdentifier();
+    if (modifiers.has("abstract")) {
+      const head = this.parseFunctionHead();
+      const func = {
+        type: "FunctionBody",
+        generics: head.generics,
+        params: head.params,
+        hasVarargs: head.hasVarargs,
+        returnType: head.returnType,
+        predicate: head.predicate,
+        body: { type: "Block", statements: [], ...spanFrom(head.start, this.previous()) },
+        ...spanFrom(head.start, this.previous())
+      };
+      if (!isStatic) bindThis(func, start);
+      if (!head.returnType) this.problem("An abstract method has no body to infer from: write its return type");
+      if (this.checkPunctuator("{")) this.problem("An abstract method has no body");
+      return { type: "ClassMethod", name: memberName, isStatic, func, isAbstract: true, ...spanFrom(start, this.previous()) };
+    }
+    const signatures = [];
+    let written = memberName;
+    while (true) {
+      const head = this.parseFunctionHead();
+      const skip = this.classOverloadContinuation(memberName.name, isStatic);
+      if (skip !== void 0) {
+        if (!isStatic) bindThisParam(head.params, start);
+        signatures.push({ ...this.headToSignature(head), name: written });
+        for (let i = 0; i < skip; i++) this.advance();
+        written = this.parseIdentifier();
+        continue;
+      }
+      const func = this.headToBody(head, start);
+      if (!isStatic) bindThis(func, start);
+      return {
+        type: "ClassMethod",
+        name: memberName,
+        isStatic,
+        func,
+        signatures: signatures.length ? signatures : void 0,
+        ...spanFrom(start, this.previous())
+      };
+    }
   }
-  /** Give a class method its `this`: a real first parameter, the way
-   *  `function T:m()` gets a real `self`. Every later pass — scopes, types,
-   *  arity, lowering — then sees an ordinary parameter and needs to know
-   *  nothing about classes. */
   /** After a bodyless head inside a class body, does another declaration of
-   *  the same member follow? Then the head was an overload signature. */
-  isClassOverloadContinuation(name, isStatic) {
-    const offset = isStatic ? 1 : 0;
-    if (isStatic && !this.checkIdentifierValue("static")) return false;
+   *  the same member follow? Then the head was an overload signature, and
+   *  this is how many tokens stand before the next one's name: a `;` that
+   *  ends the head, as TypeScript writes it, the modifiers, and `function`
+   *  when it is written. `undefined` when no overload follows. Each head may
+   *  be written either way, with `function` or without. */
+  classOverloadContinuation(name, isStatic) {
+    let offset = 0;
+    if (this.punctuatorAt(0, ";")) offset++;
+    let sawStatic = false;
+    while (true) {
+      const t = this.peek(offset);
+      const word = t.type === "Identifier" ? t.value : void 0;
+      if (word === void 0 || !CLASS_MODIFIERS.has(word) || this.startsMethodShorthand(offset)) break;
+      if (word === "static") sawStatic = true;
+      offset++;
+    }
+    if (sawStatic !== isStatic) return void 0;
     const keyword = this.peek(offset);
-    if (!(keyword.type === "Keyword" && keyword.value === "function")) return false;
-    const named = this.peek(offset + 1);
-    return named.type === "Identifier" && named.value === name;
+    const hasKeyword = keyword.type === "Keyword" && keyword.value === "function";
+    if (hasKeyword) offset++;
+    const named = this.peek(offset);
+    if (!(named.type === "Identifier" && named.value === name)) return void 0;
+    if (!hasKeyword && !this.startsMethodShorthand(offset)) return void 0;
+    return offset;
   }
   operatorAt(ahead, value) {
     const token = this.peek(ahead);
@@ -4676,11 +4714,34 @@ declare metatable<T> T[]: {
 -- \`nil\` when it is missing; an indexer's keys follow the named ones. A
 -- member of the table's own with one of these names is what a call reaches,
 -- and a class instance, which has a metatable of its own, has none of them.
+--
+-- The rest are JavaScript's \`Object\` functions, written as methods of the
+-- table they take first:
+--
+--     point:hasOwn("x")           -- Object.hasOwn(point, "x")
+--     point:assign({ z: 3 })      -- Object.assign(point, { z: 3 })
+--     point:freeze()              -- Object.freeze(point)
+--
+-- \`hasOwn\` asks the table itself, not what its metatable's \`__index\`
+-- lends it. \`assign\` copies each source's members onto the table, later ones
+-- over earlier ones, skipping a \`nil\` source, and answers the table. \`freeze\`
+-- is Luau's \`table.freeze\`; under Lua 5.1, which cannot freeze a table, the
+-- table is answered as it is and \`isFrozen\` is false.
 declare metatable<T extends {}> T: {
     __index: {
         keys: (self: T) => ObjectKeys<T>,
         values: (self: T) => ObjectValues<T>,
         entries: (self: T) => ObjectEntries<T>,
+
+        hasOwn: (self: T, key: unknown) => boolean,
+        hasOwnProperty: (self: T, key: unknown) => boolean,
+        assign: (<U>(self: T, source: U) => T & U)
+            & (<U, V>(self: T, a: U, b: V) => T & U & V)
+            & (<U, V, W>(self: T, a: U, b: V, c: W) => T & U & V & W)
+            -- Generic like the rest: a plain signature would be tried first.
+            & (<S extends {}>(self: T, ...sources: S[]) => T),
+        freeze: (self: T) => Readonly<T>,
+        isFrozen: (self: T) => boolean,
     },
 }
 `;
@@ -11866,7 +11927,53 @@ function aliasTargets(config, specifier) {
 
 // src/project/sourcemap.ts
 var import_node_path4 = require("path");
+
+// src/luau.ts
+var LUAU_KEYWORDS = /* @__PURE__ */ new Set([
+  "and",
+  "break",
+  "do",
+  "else",
+  "elseif",
+  "end",
+  "false",
+  "for",
+  "function",
+  "if",
+  "in",
+  "local",
+  "nil",
+  "not",
+  "or",
+  "repeat",
+  "return",
+  "then",
+  "true",
+  "until",
+  "while"
+]);
 var IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function isIdentifier(name) {
+  return IDENTIFIER.test(name);
+}
+function isLuauName(name) {
+  return IDENTIFIER.test(name) && !LUAU_KEYWORDS.has(name);
+}
+var NAMED_ESCAPES = {
+  "\\": "\\\\",
+  '"': '\\"',
+  "\n": "\\n",
+  "\r": "\\r",
+  "	": "\\t"
+};
+function escapeLuauString(text) {
+  return text.replace(/[\\"\x00-\x1f\x7f]/g, (c) => NAMED_ESCAPES[c] ?? `\\${c.charCodeAt(0).toString().padStart(3, "0")}`);
+}
+function luauString(text) {
+  return `"${escapeLuauString(text)}"`;
+}
+
+// src/project/sourcemap.ts
 var INSTANCE_MEMBERS = /* @__PURE__ */ new Set(["Name", "ClassName", "Parent", "Archivable"]);
 var SCRIPT_EXTENSIONS = /* @__PURE__ */ new Set([".tilua", ".luau", ".lua"]);
 function sourceMapTypes(text, path, options) {
@@ -11893,7 +12000,7 @@ function sourceMapTypes(text, path, options) {
     const alias = aliasFor(segments);
     aliasOfNode.set(node, alias);
     for (const filePath of node.filePaths ?? []) aliasOfFile.set(fileKey((0, import_node_path4.resolve)(directory, filePath)), alias);
-    const className = IDENTIFIER.test(node.className) && options.classes.has(node.className) ? node.className : "Instance";
+    const className = isIdentifier(node.className) && options.classes.has(node.className) ? node.className : "Instance";
     const taken = options.membersOf?.(className) ?? INSTANCE_MEMBERS;
     const members = [];
     if (parent) members.push(`Parent: ${parent}`);
@@ -11902,7 +12009,7 @@ function sourceMapTypes(text, path, options) {
       if (!isNode(child)) continue;
       const childAlias = visit(child, [...segments, child.name], alias);
       const service = child.name === child.className && options.classes.has(child.className);
-      if (!IDENTIFIER.test(child.name) || taken.has(child.name) && !service || named.has(child.name)) continue;
+      if (!isIdentifier(child.name) || taken.has(child.name) && !service || named.has(child.name)) continue;
       named.add(child.name);
       members.push(`${child.name}: ${childAlias}`);
     }
@@ -11944,6 +12051,34 @@ function fileKey(path) {
   return process.platform === "win32" ? normalized.toLowerCase() : normalized;
 }
 
+// src/loweringHelpers.ts
+function withoutNil2(type) {
+  if (!type) return [];
+  const members = type.kind === "union" ? type.types : [type];
+  return members.filter((m) => !(m.kind === "primitive" && m.name === "nil"));
+}
+function isFunctionType(type) {
+  const members = withoutNil2(type);
+  return members.length > 0 && members.every((m) => m.kind === "function" || m.kind === "intersection" && m.types.every(isFunctionType));
+}
+function everyObject(type, test) {
+  const members = withoutNil2(type);
+  return members.length > 0 && members.every((m) => m.kind === "object" && test(m));
+}
+function isInstanceOf(type, className) {
+  return everyObject(type, (m) => m.class !== void 0 && m.class.ancestors.includes(className));
+}
+function hasMembers(type, names) {
+  return everyObject(type, (m) => names.every((name) => m.properties.has(name)));
+}
+function returnsTuple(receiver, method) {
+  return everyObject(receiver, (m) => {
+    const found = m.properties.get(method)?.type;
+    const signatures = !found ? [] : found.kind === "intersection" ? found.types : [found];
+    return signatures.length > 0 && signatures.every((f) => f.kind === "function" && f.returns.kind === "tuple");
+  });
+}
+
 // src/index.ts
 var tilua = {
   tokenize,
@@ -11964,6 +12099,7 @@ var index_default = tilua;
   CONFIG_FILE_NAMES,
   Keywords,
   LANGUAGE_GLOBALS,
+  LUAU_KEYWORDS,
   LexError,
   Operators,
   PRELUDE_SOURCE,
@@ -11984,20 +12120,27 @@ var index_default = tilua;
   difference,
   directivesOf,
   equalTypes,
+  escapeLuauString,
   falsyType,
   findConfig,
   fn,
   formatType,
   getBinding,
+  hasMembers,
   intersection,
   isAssignable,
   isClassType,
+  isFunctionType,
   isGlobal,
+  isIdentifier,
+  isInstanceOf,
+  isLuauName,
   isPossiblyFalsy,
   isPossiblyTruthy,
   isUnassignedGlobal,
   literal,
   loadConfig,
+  luauString,
   matchInfer,
   moduleCandidates,
   moduleExports,
@@ -12020,6 +12163,7 @@ var index_default = tilua;
   readDirectives,
   resolveModulePath,
   resolveTypeLibraries,
+  returnsTuple,
   setAliasExpander,
   setDeferredBound,
   sourceMapTypes,
@@ -12038,5 +12182,6 @@ var index_default = tilua;
   unknownType,
   widen,
   withAliasName,
-  withoutAliasName
+  withoutAliasName,
+  withoutNil
 });

package/dist/index.d.cts

@@ -639,6 +639,12 @@ interface FunctionParameter extends BaseNode {
     typeAnnotation?: TypeNode;
     /** default value (`function f(a = 1) end`) */
     default?: Expression;
+    /** Not written in the source: the `this` a class method is given, or the
+     *  `self` of `function T:m()`. It carries the span of what implies it
+     *  (the method, the `T:m`) so a diagnostic has somewhere to point, but no
+     *  text there is its name — an editor colours, hovers and renames none
+     *  of it. */
+    implicit?: boolean;
 }
 interface FunctionBody extends BaseNode {
     type: "FunctionBody";
@@ -1601,7 +1607,7 @@ resolveModule?: (specifier: string) => ModuleExports | undefined): ModuleExports
  * `ObjectValues<T>` and `ObjectEntries<T>`, an object's members as tuples in
  * the order they were written.
  */
-declare const PRELUDE_SOURCE = "\n-- In Luau only `nil` and `false` are falsy: `0` and `\"\"` are truthy.\n-- These are what truthiness narrowing computes, made available to write down.\ntype Falsy = nil | false\ntype Truthy<T> = T - Falsy\n\n-- `-` is set difference. Over a union it drops members; over a concrete type\n-- it simplifies away; over an opaque type (`unknown`, an unresolved parameter)\n-- it is kept, so `Exclude<unknown, 1>` stays `unknown - 1`.\ntype Exclude<T, U> = T - U\ntype Extract<T, U> = T extends U ? T : never\ntype NonNullable<T> = T - nil\n\ntype ReturnType<T> = T extends (...args: unknown[]) => infer R ? R : never\ntype Parameters<T> = T extends (...args: infer P) => unknown ? P : never\n\ntype Partial<T> = { [K in keyof T]?: T[K] }\ntype Required<T> = { [K in keyof T]-?: T[K] }\ntype Readonly<T> = { readonly [K in keyof T]: T[K] }\ntype Mutable<T> = { -readonly [K in keyof T]: T[K] }\n\ntype Pick<T, K> = { [P in K]: T[P] }\ntype Omit<T, K> = Pick<T, Exclude<keyof T, K>>\ntype Record<K, V> = { [P in K]: V }\n\n-- ============================================================\n-- The metatables of the language's own values\n-- ============================================================\n\n-- A string's methods. The first group is Lua's string library, which a\n-- string really answers to; where Lua answers several values, tilua answers\n-- one, as the global functions do (`find` is an array, `gsub` the new\n-- string). The second group is written the way JavaScript writes it.\n--\n-- Positions are Lua's: `sub` and `slice` count from 1, and `indexOf` is\n-- `nil` when the text is not there.\ndeclare metatable string: {\n    __index: {\n        upper: (self: string) => string,\n        lower: (self: string) => string,\n        len: (self: string) => number,\n        sub: (self: string, i: number, j?: number) => string,\n        rep: (self: string, n: number, separator?: string) => string,\n        reverse: (self: string) => string,\n        format: (self: string, ...args: unknown[]) => string,\n        byte: ((self: string, i?: number) => number) & ((self: string, i: number, j: number) => number[]),\n        find: (self: string, pattern: string, init?: number, plain?: boolean) => [number, number, ...string[]] | nil,\n        match: (self: string, pattern: string, init?: number) => [...string[]] | nil,\n        gmatch: (self: string, pattern: string) => () => [string, ...string[]] | nil,\n        gsub: (self: string, pattern: string, replacement: unknown, n?: number) => string,\n\n        trim: (self: string) => string,\n        trimStart: (self: string) => string,\n        trimEnd: (self: string) => string,\n        startsWith: (self: string, text: string) => boolean,\n        endsWith: (self: string, text: string) => boolean,\n        includes: (self: string, text: string) => boolean,\n        indexOf: (self: string, text: string, start?: number) => number | nil,\n        slice: (self: string, start?: number, stop?: number) => string,\n        replace: (self: string, text: string, replacement: string) => string,\n        replaceAll: (self: string, text: string, replacement: string) => string,\n        padStart: (self: string, length: number, padding?: string) => string,\n        padEnd: (self: string, length: number, padding?: string) => string,\n    },\n}\n\n-- An array's methods. Lua gives an array no metatable: the compiler lowers\n-- each call to a plain function, so they work on any array, one a Lua\n-- library made included.\n--\n-- Indices are Lua's: the first element is 1, and `indexOf` / `findIndex`\n-- answer `nil` rather than JavaScript's -1. `sort` takes Lua's comparator\n-- (true when `a` comes first). `push`, `pop`, `shift`, `unshift`,\n-- `sort` and `reverse` change the array; everything else returns a new one.\n-- A `filter` whose test is a guard \u2014 `v is S`, or `v => v ~= nil` \u2014\n-- answers an array of what it let through.\ndeclare metatable<T> T[]: {\n    __index: {\n        find: (self: T[], test: (value: T, index: number) => boolean) => T | nil,\n        findIndex: (self: T[], test: (value: T, index: number) => boolean) => number | nil,\n        filter: (<S extends T>(self: T[], test: (value: T, index: number) => value is S) => S[])\n            & ((self: T[], test: (value: T, index: number) => boolean) => T[]),\n        map: <U>(self: T[], transform: (value: T, index: number) => U) => U[],\n        forEach: (self: T[], visit: (value: T, index: number) => nil) => nil,\n        some: (self: T[], test: (value: T, index: number) => boolean) => boolean,\n        every: (self: T[], test: (value: T, index: number) => boolean) => boolean,\n        reduce: <U>(self: T[], step: (total: U, value: T, index: number) => U, initial: U) => U,\n        includes: (self: T[], value: T) => boolean,\n        indexOf: (self: T[], value: T, start?: number) => number | nil,\n        join: (self: T[], separator?: string) => string,\n        concat: (self: T[], ...others: T[][]) => T[],\n        slice: (self: T[], start?: number, stop?: number) => T[],\n        flat: (self: T[]) => T[],\n        reverse: (self: T[]) => T[],\n        sort: (self: T[], compare?: (a: T, b: T) => boolean) => T[],\n        push: (self: T[], ...args: T[]) => number,\n        pop: (self: T[]) => T | nil,\n        shift: (self: T[]) => T | nil,\n        unshift: (self: T[], ...args: T[]) => number,\n    },\n}\n\n-- A table's methods. Unlike JavaScript's `Object.keys`, they answer a\n-- tuple, in the order the table's type wrote its members:\n--\n--     const point = { x: 1, y: \"up\" }\n--     point:keys()     -- [\"x\", \"y\"]\n--     point:values()   -- [number, string]\n--     point:entries()  -- [[\"x\", number], [\"y\", string]]\n--\n-- A Lua table has no order of its own, so the compiler hands its runtime the\n-- keys as the type lists them. An optional member keeps its place, holding\n-- `nil` when it is missing; an indexer's keys follow the named ones. A\n-- member of the table's own with one of these names is what a call reaches,\n-- and a class instance, which has a metatable of its own, has none of them.\ndeclare metatable<T extends {}> T: {\n    __index: {\n        keys: (self: T) => ObjectKeys<T>,\n        values: (self: T) => ObjectValues<T>,\n        entries: (self: T) => ObjectEntries<T>,\n    },\n}\n";
+declare const PRELUDE_SOURCE = "\n-- In Luau only `nil` and `false` are falsy: `0` and `\"\"` are truthy.\n-- These are what truthiness narrowing computes, made available to write down.\ntype Falsy = nil | false\ntype Truthy<T> = T - Falsy\n\n-- `-` is set difference. Over a union it drops members; over a concrete type\n-- it simplifies away; over an opaque type (`unknown`, an unresolved parameter)\n-- it is kept, so `Exclude<unknown, 1>` stays `unknown - 1`.\ntype Exclude<T, U> = T - U\ntype Extract<T, U> = T extends U ? T : never\ntype NonNullable<T> = T - nil\n\ntype ReturnType<T> = T extends (...args: unknown[]) => infer R ? R : never\ntype Parameters<T> = T extends (...args: infer P) => unknown ? P : never\n\ntype Partial<T> = { [K in keyof T]?: T[K] }\ntype Required<T> = { [K in keyof T]-?: T[K] }\ntype Readonly<T> = { readonly [K in keyof T]: T[K] }\ntype Mutable<T> = { -readonly [K in keyof T]: T[K] }\n\ntype Pick<T, K> = { [P in K]: T[P] }\ntype Omit<T, K> = Pick<T, Exclude<keyof T, K>>\ntype Record<K, V> = { [P in K]: V }\n\n-- ============================================================\n-- The metatables of the language's own values\n-- ============================================================\n\n-- A string's methods. The first group is Lua's string library, which a\n-- string really answers to; where Lua answers several values, tilua answers\n-- one, as the global functions do (`find` is an array, `gsub` the new\n-- string). The second group is written the way JavaScript writes it.\n--\n-- Positions are Lua's: `sub` and `slice` count from 1, and `indexOf` is\n-- `nil` when the text is not there.\ndeclare metatable string: {\n    __index: {\n        upper: (self: string) => string,\n        lower: (self: string) => string,\n        len: (self: string) => number,\n        sub: (self: string, i: number, j?: number) => string,\n        rep: (self: string, n: number, separator?: string) => string,\n        reverse: (self: string) => string,\n        format: (self: string, ...args: unknown[]) => string,\n        byte: ((self: string, i?: number) => number) & ((self: string, i: number, j: number) => number[]),\n        find: (self: string, pattern: string, init?: number, plain?: boolean) => [number, number, ...string[]] | nil,\n        match: (self: string, pattern: string, init?: number) => [...string[]] | nil,\n        gmatch: (self: string, pattern: string) => () => [string, ...string[]] | nil,\n        gsub: (self: string, pattern: string, replacement: unknown, n?: number) => string,\n\n        trim: (self: string) => string,\n        trimStart: (self: string) => string,\n        trimEnd: (self: string) => string,\n        startsWith: (self: string, text: string) => boolean,\n        endsWith: (self: string, text: string) => boolean,\n        includes: (self: string, text: string) => boolean,\n        indexOf: (self: string, text: string, start?: number) => number | nil,\n        slice: (self: string, start?: number, stop?: number) => string,\n        replace: (self: string, text: string, replacement: string) => string,\n        replaceAll: (self: string, text: string, replacement: string) => string,\n        padStart: (self: string, length: number, padding?: string) => string,\n        padEnd: (self: string, length: number, padding?: string) => string,\n    },\n}\n\n-- An array's methods. Lua gives an array no metatable: the compiler lowers\n-- each call to a plain function, so they work on any array, one a Lua\n-- library made included.\n--\n-- Indices are Lua's: the first element is 1, and `indexOf` / `findIndex`\n-- answer `nil` rather than JavaScript's -1. `sort` takes Lua's comparator\n-- (true when `a` comes first). `push`, `pop`, `shift`, `unshift`,\n-- `sort` and `reverse` change the array; everything else returns a new one.\n-- A `filter` whose test is a guard \u2014 `v is S`, or `v => v ~= nil` \u2014\n-- answers an array of what it let through.\ndeclare metatable<T> T[]: {\n    __index: {\n        find: (self: T[], test: (value: T, index: number) => boolean) => T | nil,\n        findIndex: (self: T[], test: (value: T, index: number) => boolean) => number | nil,\n        filter: (<S extends T>(self: T[], test: (value: T, index: number) => value is S) => S[])\n            & ((self: T[], test: (value: T, index: number) => boolean) => T[]),\n        map: <U>(self: T[], transform: (value: T, index: number) => U) => U[],\n        forEach: (self: T[], visit: (value: T, index: number) => nil) => nil,\n        some: (self: T[], test: (value: T, index: number) => boolean) => boolean,\n        every: (self: T[], test: (value: T, index: number) => boolean) => boolean,\n        reduce: <U>(self: T[], step: (total: U, value: T, index: number) => U, initial: U) => U,\n        includes: (self: T[], value: T) => boolean,\n        indexOf: (self: T[], value: T, start?: number) => number | nil,\n        join: (self: T[], separator?: string) => string,\n        concat: (self: T[], ...others: T[][]) => T[],\n        slice: (self: T[], start?: number, stop?: number) => T[],\n        flat: (self: T[]) => T[],\n        reverse: (self: T[]) => T[],\n        sort: (self: T[], compare?: (a: T, b: T) => boolean) => T[],\n        push: (self: T[], ...args: T[]) => number,\n        pop: (self: T[]) => T | nil,\n        shift: (self: T[]) => T | nil,\n        unshift: (self: T[], ...args: T[]) => number,\n    },\n}\n\n-- A table's methods. Unlike JavaScript's `Object.keys`, they answer a\n-- tuple, in the order the table's type wrote its members:\n--\n--     const point = { x: 1, y: \"up\" }\n--     point:keys()     -- [\"x\", \"y\"]\n--     point:values()   -- [number, string]\n--     point:entries()  -- [[\"x\", number], [\"y\", string]]\n--\n-- A Lua table has no order of its own, so the compiler hands its runtime the\n-- keys as the type lists them. An optional member keeps its place, holding\n-- `nil` when it is missing; an indexer's keys follow the named ones. A\n-- member of the table's own with one of these names is what a call reaches,\n-- and a class instance, which has a metatable of its own, has none of them.\n--\n-- The rest are JavaScript's `Object` functions, written as methods of the\n-- table they take first:\n--\n--     point:hasOwn(\"x\")           -- Object.hasOwn(point, \"x\")\n--     point:assign({ z: 3 })      -- Object.assign(point, { z: 3 })\n--     point:freeze()              -- Object.freeze(point)\n--\n-- `hasOwn` asks the table itself, not what its metatable's `__index`\n-- lends it. `assign` copies each source's members onto the table, later ones\n-- over earlier ones, skipping a `nil` source, and answers the table. `freeze`\n-- is Luau's `table.freeze`; under Lua 5.1, which cannot freeze a table, the\n-- table is answered as it is and `isFrozen` is false.\ndeclare metatable<T extends {}> T: {\n    __index: {\n        keys: (self: T) => ObjectKeys<T>,\n        values: (self: T) => ObjectValues<T>,\n        entries: (self: T) => ObjectEntries<T>,\n\n        hasOwn: (self: T, key: unknown) => boolean,\n        hasOwnProperty: (self: T, key: unknown) => boolean,\n        assign: (<U>(self: T, source: U) => T & U)\n            & (<U, V>(self: T, a: U, b: V) => T & U & V)\n            & (<U, V, W>(self: T, a: U, b: V, c: W) => T & U & V & W)\n            -- Generic like the rest: a plain signature would be tried first.\n            & (<S extends {}>(self: T, ...sources: S[]) => T),\n        freeze: (self: T) => Readonly<T>,\n        isFrozen: (self: T) => boolean,\n    },\n}\n";
 
 interface ProjectHost {
     /** A file's text, or `undefined` when there is no such file. */
@@ -1722,6 +1728,10 @@ declare function resolveTypeLibraries(config: TiluaConfig, host?: ProjectHost):
  *         },
  *     }
  *     export default plugin
+ *
+ * What a plugin runs to decide and to write — `luauString`, `isInstanceOf`,
+ * `returnsTuple`, ... — is exported beside this contract (see `luau.ts` and
+ * `loweringHelpers.ts`), so no plugin keeps a copy.
  */
 
 interface LoweringPlugin {
@@ -1865,6 +1875,66 @@ declare function sourceMapTypes(text: string, path: string, options: SourceMapOp
     problem?: string;
 };
 
+/**
+ * Writing Luau source as text: what a name may be and how a string is quoted.
+ *
+ * The compiler emits Luau, a lowering plugin hands back Luau expressions, and
+ * a server filling placeholders into a bundle writes Luau strings. Each needs
+ * the same few rules, and they live here so none of them keeps its own copy.
+ * Nothing here parses or runs Luau.
+ */
+/** Luau's reserved words. tilua reserves most of them too — `local` is the
+ *  exception, so a tilua name can still be one of these. */
+declare const LUAU_KEYWORDS: ReadonlySet<string>;
+/** Is `name` shaped like a name — a letter or `_`, then letters, digits and
+ *  `_`? tilua's and Luau's names are both this shape; whether it is also a
+ *  keyword is another question (`isLuauName`). */
+declare function isIdentifier(name: string): boolean;
+/** Can `name` be written bare in Luau — as a variable, `t.name` or `{ name = v }`? */
+declare function isLuauName(name: string): boolean;
+/** `text` as the inside of a double-quoted Luau string, without the quotes:
+ *  for splicing into a `"..."` that is already written.
+ *
+ *  Every control character is escaped, as `\n` where Luau has a name for it and
+ *  as three decimal digits otherwise — always three, so a digit that follows
+ *  (`"\1" .. "2"`) is never read as part of the escape. Not `JSON.stringify`:
+ *  its `\u0001` is not a Luau escape. Anything else, `é` or `한` included, is
+ *  written as it is; Luau source is UTF-8. */
+declare function escapeLuauString(text: string): string;
+/** `text` as a double-quoted Luau string literal: `"a\nb"`. */
+declare function luauString(text: string): string;
+
+/**
+ * Questions a lowering plugin asks of a type, answered once here.
+ *
+ * A plugin decides how to lower a call from the receiver's or an argument's
+ * type (see `LoweringPlugin`). The same few questions come up in every one —
+ * is it a function, is it an instance of this class, what does this method
+ * return — and a plugin imports these rather than walking the type model
+ * itself:
+ *
+ *     import { isInstanceOf } from "@tilua/parser"
+ *
+ * Each looks through a union with `nil` (`Part | nil`): whether the value may
+ * be missing is a check the analyzer asked for elsewhere, not a reason to
+ * lower differently.
+ */
+
+/** The members of `type` that are not `nil`: `[A, B]` for `A | B | nil`,
+ *  `[T]` for any other `T`, and `[]` for `undefined` or `nil` alone. */
+declare function withoutNil(type: Type | undefined): Type[];
+/** A function, or an overloaded one (an intersection of functions). */
+declare function isFunctionType(type: Type | undefined): boolean;
+/** An instance of `className` or of a class extending it: a `Part` is an
+ *  instance of `BasePart` and of `Instance`. */
+declare function isInstanceOf(type: Type | undefined, className: string): boolean;
+/** Has every one of `names` as a member — a structural check, for a type
+ *  known by its shape rather than its class. */
+declare function hasMembers(type: Type | undefined, names: readonly string[]): boolean;
+/** Does every signature of `receiver`'s `method` return a tuple — several
+ *  values, as tilua has them in one array? False when the method is missing. */
+declare function returnsTuple(receiver: Type | undefined, method: string): boolean;
+
 declare const tilua: {
     readonly tokenize: typeof tokenize;
     readonly parseTokens: typeof parseTokens;
@@ -1878,4 +1948,4 @@ declare const tilua: {
     readonly analyzeTypes: typeof analyzeTypes;
 };
 
-export { type AnalyzeTypesOptions, type AnyType, type ArgumentInfo, type ArrayExpression, type ArrayPattern, type ArrayPatternElement, type ArrayType, type ArrayTypeNode, type AsConstExpression, type AssignmentStatement, type BaseNode, type BaseToken, type BinaryExpression, BinaryOperators, type Binding, type BindingId, type BindingKind, type BindingTarget, type Block, type BooleanLiteral, type BreakStatement, type BuildTarget, CONFIG_FILE_NAMES, type CallExpression, type CallLowering, type CallSite, type CallStatement, type ClassAccessibility, type ClassAccessor, type ClassConstructor, type ClassDeclaration, type ClassExpression, type ClassField, type ClassInfo, type ClassLike, type ClassMember, type ClassMethod, type CompoundAssignmentStatement, type ConditionalType, type ConditionalTypeNode, type ConfigLookup, type ConfigProblem, type ContinueStatement, type DeclareClassStatement, type DeclareMetatableStatement, type DeclareStatement, type DifferenceType, type DifferenceTypeNode, type Directive, type DirectiveKind, type DirectiveOutcome, type Directives, type DoStatement, type EOFToken, type ErrorExpression, type ErrorStatement, type ExportAllStatement, type ExportDefaultStatement, type ExportNamedStatement, type ExportSpecifier, type ExportStatement, type ExportTypeAliasStatement, type ExportedType, type Expression, type ExpressionStatement, type FunctionBody, type FunctionDeclaration, type FunctionDeclarationStatement, type FunctionExpression, type FunctionName, type FunctionParam, type FunctionParameter, type FunctionSignature, type FunctionType, type FunctionTypeNode, type FunctionTypeParameter, type GenericForStatement, type GenericRefType, type GenericTypeParameter, type GlobalCall, type GlobalValue, type Identifier, type IdentifierPattern, type IdentifierToken, type IfClause, type IfElseExpression, type IfStatement, type ImportSpecifier, type ImportStatement, type IndexExpression, type IndexedAccessType, type IndexedAccessTypeNode, type InferType, type InferTypeNode, type InterpolatedStringExpression, type InterpolatedStringPart, type InterpolatedStringPart_Expression, type InterpolatedStringPart_String, type InterpolatedStringToken, type IntersectionType, type IntersectionTypeNode, type KeyofType, type KeyofTypeNode, type KeywordToken, Keywords, LANGUAGE_GLOBALS, LexError, type LiteralToken, type LiteralType, type LoweringModule, type LoweringPlugin, type MappedType, type MappedTypeNode, type MemberExpression, type MethodCall, type MethodCallExpression, type MethodLowering, type ModuleExports, type NeverType, type NilLiteral, type Node, type NumberLiteral, type NumericForStatement, type ObjectPattern, type ObjectPatternProperty, type ObjectProperty, type ObjectType, type OperatorToken, Operators, PRELUDE_SOURCE, type ParenthesizedExpression, type ParenthesizedTypeNode, ParseError, type ParserOptions, type PrimitiveName, type PrimitiveType, type Program, type ProjectHost, type PunctuatorToken, Punctuators, type RecoverResult, type RepeatStatement, type ReturnStatement, type SatisfiesExpression, type ScopeAnalysis, type ScopeDiagnostic, type SourceComment, type SourceMapNode, type SourceMapOptions, type SourceMapTypes, type SpreadElement, type Statement, type StringLiteral, type SuperExpression, type TableExpression, type TableField, type TableTypeNode, type TableTypeProperty, type TemplateLiteralType, type TemplateLiteralTypeNode, type TiluaConfig, type Token, type TokenizeOptions, type TupleType, type TupleTypeNode, type Type, type TypeAliasStatement, type TypeAnalysis, type TypeAssertionExpression, type TypeDiagnostic, type TypeLibraries, type TypeLiteralBoolean, type TypeLiteralNumber, type TypeLiteralString, type TypeNode, type TypeOrigin, type TypeParamType, type TypePredicate, type TypePredicateNode, type TypeReference, type TypedIdentifier, type TypeofTypeNode, UNUSED_EXPECT_ERROR, type UnaryExpression, UnaryOperators, type Unification, type UnionType, type UnionTypeNode, type UnknownType, type VariableDeclaration, type WhileStatement, aliasNameOf, analyzeScopes, analyzeTypes, anyType, applyDirectives, arrayOf, booleanType, bufferType, containsTypeParam, declaredUnknownType, tilua as default, difference, directivesOf, equalTypes, falsyType, findConfig, fn, formatType, getBinding, intersection, isAssignable, isClassType, isGlobal, isPossiblyFalsy, isPossiblyTruthy, isUnassignedGlobal, literal, loadConfig, matchInfer, moduleCandidates, moduleExports, narrowExclude, narrowFalsy, narrowTo, narrowTruthy, neverType, nilType, nodeHost, numberType, objectType, optional, overlaps, parse, parseExpressionFromSource, parseTokens, parseWithRecovery, primitive, readDirectives, resolveModulePath, resolveTypeLibraries, setAliasExpander, setDeferredBound, sourceMapTypes, stringType, stripJsonComments, substitute, templateMatches, threadType, tilua, tokenize, tuple, tupleMembers, typeParam, unify, union, unknownType, widen, withAliasName, withoutAliasName };
+export { type AnalyzeTypesOptions, type AnyType, type ArgumentInfo, type ArrayExpression, type ArrayPattern, type ArrayPatternElement, type ArrayType, type ArrayTypeNode, type AsConstExpression, type AssignmentStatement, type BaseNode, type BaseToken, type BinaryExpression, BinaryOperators, type Binding, type BindingId, type BindingKind, type BindingTarget, type Block, type BooleanLiteral, type BreakStatement, type BuildTarget, CONFIG_FILE_NAMES, type CallExpression, type CallLowering, type CallSite, type CallStatement, type ClassAccessibility, type ClassAccessor, type ClassConstructor, type ClassDeclaration, type ClassExpression, type ClassField, type ClassInfo, type ClassLike, type ClassMember, type ClassMethod, type CompoundAssignmentStatement, type ConditionalType, type ConditionalTypeNode, type ConfigLookup, type ConfigProblem, type ContinueStatement, type DeclareClassStatement, type DeclareMetatableStatement, type DeclareStatement, type DifferenceType, type DifferenceTypeNode, type Directive, type DirectiveKind, type DirectiveOutcome, type Directives, type DoStatement, type EOFToken, type ErrorExpression, type ErrorStatement, type ExportAllStatement, type ExportDefaultStatement, type ExportNamedStatement, type ExportSpecifier, type ExportStatement, type ExportTypeAliasStatement, type ExportedType, type Expression, type ExpressionStatement, type FunctionBody, type FunctionDeclaration, type FunctionDeclarationStatement, type FunctionExpression, type FunctionName, type FunctionParam, type FunctionParameter, type FunctionSignature, type FunctionType, type FunctionTypeNode, type FunctionTypeParameter, type GenericForStatement, type GenericRefType, type GenericTypeParameter, type GlobalCall, type GlobalValue, type Identifier, type IdentifierPattern, type IdentifierToken, type IfClause, type IfElseExpression, type IfStatement, type ImportSpecifier, type ImportStatement, type IndexExpression, type IndexedAccessType, type IndexedAccessTypeNode, type InferType, type InferTypeNode, type InterpolatedStringExpression, type InterpolatedStringPart, type InterpolatedStringPart_Expression, type InterpolatedStringPart_String, type InterpolatedStringToken, type IntersectionType, type IntersectionTypeNode, type KeyofType, type KeyofTypeNode, type KeywordToken, Keywords, LANGUAGE_GLOBALS, LUAU_KEYWORDS, LexError, type LiteralToken, type LiteralType, type LoweringModule, type LoweringPlugin, type MappedType, type MappedTypeNode, type MemberExpression, type MethodCall, type MethodCallExpression, type MethodLowering, type ModuleExports, type NeverType, type NilLiteral, type Node, type NumberLiteral, type NumericForStatement, type ObjectPattern, type ObjectPatternProperty, type ObjectProperty, type ObjectType, type OperatorToken, Operators, PRELUDE_SOURCE, type ParenthesizedExpression, type ParenthesizedTypeNode, ParseError, type ParserOptions, type PrimitiveName, type PrimitiveType, type Program, type ProjectHost, type PunctuatorToken, Punctuators, type RecoverResult, type RepeatStatement, type ReturnStatement, type SatisfiesExpression, type ScopeAnalysis, type ScopeDiagnostic, type SourceComment, type SourceMapNode, type SourceMapOptions, type SourceMapTypes, type SpreadElement, type Statement, type StringLiteral, type SuperExpression, type TableExpression, type TableField, type TableTypeNode, type TableTypeProperty, type TemplateLiteralType, type TemplateLiteralTypeNode, type TiluaConfig, type Token, type TokenizeOptions, type TupleType, type TupleTypeNode, type Type, type TypeAliasStatement, type TypeAnalysis, type TypeAssertionExpression, type TypeDiagnostic, type TypeLibraries, type TypeLiteralBoolean, type TypeLiteralNumber, type TypeLiteralString, type TypeNode, type TypeOrigin, type TypeParamType, type TypePredicate, type TypePredicateNode, type TypeReference, type TypedIdentifier, type TypeofTypeNode, UNUSED_EXPECT_ERROR, type UnaryExpression, UnaryOperators, type Unification, type UnionType, type UnionTypeNode, type UnknownType, type VariableDeclaration, type WhileStatement, aliasNameOf, analyzeScopes, analyzeTypes, anyType, applyDirectives, arrayOf, booleanType, bufferType, containsTypeParam, declaredUnknownType, tilua as default, difference, directivesOf, equalTypes, escapeLuauString, falsyType, findConfig, fn, formatType, getBinding, hasMembers, intersection, isAssignable, isClassType, isFunctionType, isGlobal, isIdentifier, isInstanceOf, isLuauName, isPossiblyFalsy, isPossiblyTruthy, isUnassignedGlobal, literal, loadConfig, luauString, matchInfer, moduleCandidates, moduleExports, narrowExclude, narrowFalsy, narrowTo, narrowTruthy, neverType, nilType, nodeHost, numberType, objectType, optional, overlaps, parse, parseExpressionFromSource, parseTokens, parseWithRecovery, primitive, readDirectives, resolveModulePath, resolveTypeLibraries, returnsTuple, setAliasExpander, setDeferredBound, sourceMapTypes, stringType, stripJsonComments, substitute, templateMatches, threadType, tilua, tokenize, tuple, tupleMembers, typeParam, unify, union, unknownType, widen, withAliasName, withoutAliasName, withoutNil };

package/dist/index.d.ts

@@ -639,6 +639,12 @@ interface FunctionParameter extends BaseNode {
     typeAnnotation?: TypeNode;
     /** default value (`function f(a = 1) end`) */
     default?: Expression;
+    /** Not written in the source: the `this` a class method is given, or the
+     *  `self` of `function T:m()`. It carries the span of what implies it
+     *  (the method, the `T:m`) so a diagnostic has somewhere to point, but no
+     *  text there is its name — an editor colours, hovers and renames none
+     *  of it. */
+    implicit?: boolean;
 }
 interface FunctionBody extends BaseNode {
     type: "FunctionBody";
@@ -1601,7 +1607,7 @@ resolveModule?: (specifier: string) => ModuleExports | undefined): ModuleExports
  * `ObjectValues<T>` and `ObjectEntries<T>`, an object's members as tuples in
  * the order they were written.
  */
-declare const PRELUDE_SOURCE = "\n-- In Luau only `nil` and `false` are falsy: `0` and `\"\"` are truthy.\n-- These are what truthiness narrowing computes, made available to write down.\ntype Falsy = nil | false\ntype Truthy<T> = T - Falsy\n\n-- `-` is set difference. Over a union it drops members; over a concrete type\n-- it simplifies away; over an opaque type (`unknown`, an unresolved parameter)\n-- it is kept, so `Exclude<unknown, 1>` stays `unknown - 1`.\ntype Exclude<T, U> = T - U\ntype Extract<T, U> = T extends U ? T : never\ntype NonNullable<T> = T - nil\n\ntype ReturnType<T> = T extends (...args: unknown[]) => infer R ? R : never\ntype Parameters<T> = T extends (...args: infer P) => unknown ? P : never\n\ntype Partial<T> = { [K in keyof T]?: T[K] }\ntype Required<T> = { [K in keyof T]-?: T[K] }\ntype Readonly<T> = { readonly [K in keyof T]: T[K] }\ntype Mutable<T> = { -readonly [K in keyof T]: T[K] }\n\ntype Pick<T, K> = { [P in K]: T[P] }\ntype Omit<T, K> = Pick<T, Exclude<keyof T, K>>\ntype Record<K, V> = { [P in K]: V }\n\n-- ============================================================\n-- The metatables of the language's own values\n-- ============================================================\n\n-- A string's methods. The first group is Lua's string library, which a\n-- string really answers to; where Lua answers several values, tilua answers\n-- one, as the global functions do (`find` is an array, `gsub` the new\n-- string). The second group is written the way JavaScript writes it.\n--\n-- Positions are Lua's: `sub` and `slice` count from 1, and `indexOf` is\n-- `nil` when the text is not there.\ndeclare metatable string: {\n    __index: {\n        upper: (self: string) => string,\n        lower: (self: string) => string,\n        len: (self: string) => number,\n        sub: (self: string, i: number, j?: number) => string,\n        rep: (self: string, n: number, separator?: string) => string,\n        reverse: (self: string) => string,\n        format: (self: string, ...args: unknown[]) => string,\n        byte: ((self: string, i?: number) => number) & ((self: string, i: number, j: number) => number[]),\n        find: (self: string, pattern: string, init?: number, plain?: boolean) => [number, number, ...string[]] | nil,\n        match: (self: string, pattern: string, init?: number) => [...string[]] | nil,\n        gmatch: (self: string, pattern: string) => () => [string, ...string[]] | nil,\n        gsub: (self: string, pattern: string, replacement: unknown, n?: number) => string,\n\n        trim: (self: string) => string,\n        trimStart: (self: string) => string,\n        trimEnd: (self: string) => string,\n        startsWith: (self: string, text: string) => boolean,\n        endsWith: (self: string, text: string) => boolean,\n        includes: (self: string, text: string) => boolean,\n        indexOf: (self: string, text: string, start?: number) => number | nil,\n        slice: (self: string, start?: number, stop?: number) => string,\n        replace: (self: string, text: string, replacement: string) => string,\n        replaceAll: (self: string, text: string, replacement: string) => string,\n        padStart: (self: string, length: number, padding?: string) => string,\n        padEnd: (self: string, length: number, padding?: string) => string,\n    },\n}\n\n-- An array's methods. Lua gives an array no metatable: the compiler lowers\n-- each call to a plain function, so they work on any array, one a Lua\n-- library made included.\n--\n-- Indices are Lua's: the first element is 1, and `indexOf` / `findIndex`\n-- answer `nil` rather than JavaScript's -1. `sort` takes Lua's comparator\n-- (true when `a` comes first). `push`, `pop`, `shift`, `unshift`,\n-- `sort` and `reverse` change the array; everything else returns a new one.\n-- A `filter` whose test is a guard \u2014 `v is S`, or `v => v ~= nil` \u2014\n-- answers an array of what it let through.\ndeclare metatable<T> T[]: {\n    __index: {\n        find: (self: T[], test: (value: T, index: number) => boolean) => T | nil,\n        findIndex: (self: T[], test: (value: T, index: number) => boolean) => number | nil,\n        filter: (<S extends T>(self: T[], test: (value: T, index: number) => value is S) => S[])\n            & ((self: T[], test: (value: T, index: number) => boolean) => T[]),\n        map: <U>(self: T[], transform: (value: T, index: number) => U) => U[],\n        forEach: (self: T[], visit: (value: T, index: number) => nil) => nil,\n        some: (self: T[], test: (value: T, index: number) => boolean) => boolean,\n        every: (self: T[], test: (value: T, index: number) => boolean) => boolean,\n        reduce: <U>(self: T[], step: (total: U, value: T, index: number) => U, initial: U) => U,\n        includes: (self: T[], value: T) => boolean,\n        indexOf: (self: T[], value: T, start?: number) => number | nil,\n        join: (self: T[], separator?: string) => string,\n        concat: (self: T[], ...others: T[][]) => T[],\n        slice: (self: T[], start?: number, stop?: number) => T[],\n        flat: (self: T[]) => T[],\n        reverse: (self: T[]) => T[],\n        sort: (self: T[], compare?: (a: T, b: T) => boolean) => T[],\n        push: (self: T[], ...args: T[]) => number,\n        pop: (self: T[]) => T | nil,\n        shift: (self: T[]) => T | nil,\n        unshift: (self: T[], ...args: T[]) => number,\n    },\n}\n\n-- A table's methods. Unlike JavaScript's `Object.keys`, they answer a\n-- tuple, in the order the table's type wrote its members:\n--\n--     const point = { x: 1, y: \"up\" }\n--     point:keys()     -- [\"x\", \"y\"]\n--     point:values()   -- [number, string]\n--     point:entries()  -- [[\"x\", number], [\"y\", string]]\n--\n-- A Lua table has no order of its own, so the compiler hands its runtime the\n-- keys as the type lists them. An optional member keeps its place, holding\n-- `nil` when it is missing; an indexer's keys follow the named ones. A\n-- member of the table's own with one of these names is what a call reaches,\n-- and a class instance, which has a metatable of its own, has none of them.\ndeclare metatable<T extends {}> T: {\n    __index: {\n        keys: (self: T) => ObjectKeys<T>,\n        values: (self: T) => ObjectValues<T>,\n        entries: (self: T) => ObjectEntries<T>,\n    },\n}\n";
+declare const PRELUDE_SOURCE = "\n-- In Luau only `nil` and `false` are falsy: `0` and `\"\"` are truthy.\n-- These are what truthiness narrowing computes, made available to write down.\ntype Falsy = nil | false\ntype Truthy<T> = T - Falsy\n\n-- `-` is set difference. Over a union it drops members; over a concrete type\n-- it simplifies away; over an opaque type (`unknown`, an unresolved parameter)\n-- it is kept, so `Exclude<unknown, 1>` stays `unknown - 1`.\ntype Exclude<T, U> = T - U\ntype Extract<T, U> = T extends U ? T : never\ntype NonNullable<T> = T - nil\n\ntype ReturnType<T> = T extends (...args: unknown[]) => infer R ? R : never\ntype Parameters<T> = T extends (...args: infer P) => unknown ? P : never\n\ntype Partial<T> = { [K in keyof T]?: T[K] }\ntype Required<T> = { [K in keyof T]-?: T[K] }\ntype Readonly<T> = { readonly [K in keyof T]: T[K] }\ntype Mutable<T> = { -readonly [K in keyof T]: T[K] }\n\ntype Pick<T, K> = { [P in K]: T[P] }\ntype Omit<T, K> = Pick<T, Exclude<keyof T, K>>\ntype Record<K, V> = { [P in K]: V }\n\n-- ============================================================\n-- The metatables of the language's own values\n-- ============================================================\n\n-- A string's methods. The first group is Lua's string library, which a\n-- string really answers to; where Lua answers several values, tilua answers\n-- one, as the global functions do (`find` is an array, `gsub` the new\n-- string). The second group is written the way JavaScript writes it.\n--\n-- Positions are Lua's: `sub` and `slice` count from 1, and `indexOf` is\n-- `nil` when the text is not there.\ndeclare metatable string: {\n    __index: {\n        upper: (self: string) => string,\n        lower: (self: string) => string,\n        len: (self: string) => number,\n        sub: (self: string, i: number, j?: number) => string,\n        rep: (self: string, n: number, separator?: string) => string,\n        reverse: (self: string) => string,\n        format: (self: string, ...args: unknown[]) => string,\n        byte: ((self: string, i?: number) => number) & ((self: string, i: number, j: number) => number[]),\n        find: (self: string, pattern: string, init?: number, plain?: boolean) => [number, number, ...string[]] | nil,\n        match: (self: string, pattern: string, init?: number) => [...string[]] | nil,\n        gmatch: (self: string, pattern: string) => () => [string, ...string[]] | nil,\n        gsub: (self: string, pattern: string, replacement: unknown, n?: number) => string,\n\n        trim: (self: string) => string,\n        trimStart: (self: string) => string,\n        trimEnd: (self: string) => string,\n        startsWith: (self: string, text: string) => boolean,\n        endsWith: (self: string, text: string) => boolean,\n        includes: (self: string, text: string) => boolean,\n        indexOf: (self: string, text: string, start?: number) => number | nil,\n        slice: (self: string, start?: number, stop?: number) => string,\n        replace: (self: string, text: string, replacement: string) => string,\n        replaceAll: (self: string, text: string, replacement: string) => string,\n        padStart: (self: string, length: number, padding?: string) => string,\n        padEnd: (self: string, length: number, padding?: string) => string,\n    },\n}\n\n-- An array's methods. Lua gives an array no metatable: the compiler lowers\n-- each call to a plain function, so they work on any array, one a Lua\n-- library made included.\n--\n-- Indices are Lua's: the first element is 1, and `indexOf` / `findIndex`\n-- answer `nil` rather than JavaScript's -1. `sort` takes Lua's comparator\n-- (true when `a` comes first). `push`, `pop`, `shift`, `unshift`,\n-- `sort` and `reverse` change the array; everything else returns a new one.\n-- A `filter` whose test is a guard \u2014 `v is S`, or `v => v ~= nil` \u2014\n-- answers an array of what it let through.\ndeclare metatable<T> T[]: {\n    __index: {\n        find: (self: T[], test: (value: T, index: number) => boolean) => T | nil,\n        findIndex: (self: T[], test: (value: T, index: number) => boolean) => number | nil,\n        filter: (<S extends T>(self: T[], test: (value: T, index: number) => value is S) => S[])\n            & ((self: T[], test: (value: T, index: number) => boolean) => T[]),\n        map: <U>(self: T[], transform: (value: T, index: number) => U) => U[],\n        forEach: (self: T[], visit: (value: T, index: number) => nil) => nil,\n        some: (self: T[], test: (value: T, index: number) => boolean) => boolean,\n        every: (self: T[], test: (value: T, index: number) => boolean) => boolean,\n        reduce: <U>(self: T[], step: (total: U, value: T, index: number) => U, initial: U) => U,\n        includes: (self: T[], value: T) => boolean,\n        indexOf: (self: T[], value: T, start?: number) => number | nil,\n        join: (self: T[], separator?: string) => string,\n        concat: (self: T[], ...others: T[][]) => T[],\n        slice: (self: T[], start?: number, stop?: number) => T[],\n        flat: (self: T[]) => T[],\n        reverse: (self: T[]) => T[],\n        sort: (self: T[], compare?: (a: T, b: T) => boolean) => T[],\n        push: (self: T[], ...args: T[]) => number,\n        pop: (self: T[]) => T | nil,\n        shift: (self: T[]) => T | nil,\n        unshift: (self: T[], ...args: T[]) => number,\n    },\n}\n\n-- A table's methods. Unlike JavaScript's `Object.keys`, they answer a\n-- tuple, in the order the table's type wrote its members:\n--\n--     const point = { x: 1, y: \"up\" }\n--     point:keys()     -- [\"x\", \"y\"]\n--     point:values()   -- [number, string]\n--     point:entries()  -- [[\"x\", number], [\"y\", string]]\n--\n-- A Lua table has no order of its own, so the compiler hands its runtime the\n-- keys as the type lists them. An optional member keeps its place, holding\n-- `nil` when it is missing; an indexer's keys follow the named ones. A\n-- member of the table's own with one of these names is what a call reaches,\n-- and a class instance, which has a metatable of its own, has none of them.\n--\n-- The rest are JavaScript's `Object` functions, written as methods of the\n-- table they take first:\n--\n--     point:hasOwn(\"x\")           -- Object.hasOwn(point, \"x\")\n--     point:assign({ z: 3 })      -- Object.assign(point, { z: 3 })\n--     point:freeze()              -- Object.freeze(point)\n--\n-- `hasOwn` asks the table itself, not what its metatable's `__index`\n-- lends it. `assign` copies each source's members onto the table, later ones\n-- over earlier ones, skipping a `nil` source, and answers the table. `freeze`\n-- is Luau's `table.freeze`; under Lua 5.1, which cannot freeze a table, the\n-- table is answered as it is and `isFrozen` is false.\ndeclare metatable<T extends {}> T: {\n    __index: {\n        keys: (self: T) => ObjectKeys<T>,\n        values: (self: T) => ObjectValues<T>,\n        entries: (self: T) => ObjectEntries<T>,\n\n        hasOwn: (self: T, key: unknown) => boolean,\n        hasOwnProperty: (self: T, key: unknown) => boolean,\n        assign: (<U>(self: T, source: U) => T & U)\n            & (<U, V>(self: T, a: U, b: V) => T & U & V)\n            & (<U, V, W>(self: T, a: U, b: V, c: W) => T & U & V & W)\n            -- Generic like the rest: a plain signature would be tried first.\n            & (<S extends {}>(self: T, ...sources: S[]) => T),\n        freeze: (self: T) => Readonly<T>,\n        isFrozen: (self: T) => boolean,\n    },\n}\n";
 
 interface ProjectHost {
     /** A file's text, or `undefined` when there is no such file. */
@@ -1722,6 +1728,10 @@ declare function resolveTypeLibraries(config: TiluaConfig, host?: ProjectHost):
  *         },
  *     }
  *     export default plugin
+ *
+ * What a plugin runs to decide and to write — `luauString`, `isInstanceOf`,
+ * `returnsTuple`, ... — is exported beside this contract (see `luau.ts` and
+ * `loweringHelpers.ts`), so no plugin keeps a copy.
  */
 
 interface LoweringPlugin {
@@ -1865,6 +1875,66 @@ declare function sourceMapTypes(text: string, path: string, options: SourceMapOp
     problem?: string;
 };
 
+/**
+ * Writing Luau source as text: what a name may be and how a string is quoted.
+ *
+ * The compiler emits Luau, a lowering plugin hands back Luau expressions, and
+ * a server filling placeholders into a bundle writes Luau strings. Each needs
+ * the same few rules, and they live here so none of them keeps its own copy.
+ * Nothing here parses or runs Luau.
+ */
+/** Luau's reserved words. tilua reserves most of them too — `local` is the
+ *  exception, so a tilua name can still be one of these. */
+declare const LUAU_KEYWORDS: ReadonlySet<string>;
+/** Is `name` shaped like a name — a letter or `_`, then letters, digits and
+ *  `_`? tilua's and Luau's names are both this shape; whether it is also a
+ *  keyword is another question (`isLuauName`). */
+declare function isIdentifier(name: string): boolean;
+/** Can `name` be written bare in Luau — as a variable, `t.name` or `{ name = v }`? */
+declare function isLuauName(name: string): boolean;
+/** `text` as the inside of a double-quoted Luau string, without the quotes:
+ *  for splicing into a `"..."` that is already written.
+ *
+ *  Every control character is escaped, as `\n` where Luau has a name for it and
+ *  as three decimal digits otherwise — always three, so a digit that follows
+ *  (`"\1" .. "2"`) is never read as part of the escape. Not `JSON.stringify`:
+ *  its `\u0001` is not a Luau escape. Anything else, `é` or `한` included, is
+ *  written as it is; Luau source is UTF-8. */
+declare function escapeLuauString(text: string): string;
+/** `text` as a double-quoted Luau string literal: `"a\nb"`. */
+declare function luauString(text: string): string;
+
+/**
+ * Questions a lowering plugin asks of a type, answered once here.
+ *
+ * A plugin decides how to lower a call from the receiver's or an argument's
+ * type (see `LoweringPlugin`). The same few questions come up in every one —
+ * is it a function, is it an instance of this class, what does this method
+ * return — and a plugin imports these rather than walking the type model
+ * itself:
+ *
+ *     import { isInstanceOf } from "@tilua/parser"
+ *
+ * Each looks through a union with `nil` (`Part | nil`): whether the value may
+ * be missing is a check the analyzer asked for elsewhere, not a reason to
+ * lower differently.
+ */
+
+/** The members of `type` that are not `nil`: `[A, B]` for `A | B | nil`,
+ *  `[T]` for any other `T`, and `[]` for `undefined` or `nil` alone. */
+declare function withoutNil(type: Type | undefined): Type[];
+/** A function, or an overloaded one (an intersection of functions). */
+declare function isFunctionType(type: Type | undefined): boolean;
+/** An instance of `className` or of a class extending it: a `Part` is an
+ *  instance of `BasePart` and of `Instance`. */
+declare function isInstanceOf(type: Type | undefined, className: string): boolean;
+/** Has every one of `names` as a member — a structural check, for a type
+ *  known by its shape rather than its class. */
+declare function hasMembers(type: Type | undefined, names: readonly string[]): boolean;
+/** Does every signature of `receiver`'s `method` return a tuple — several
+ *  values, as tilua has them in one array? False when the method is missing. */
+declare function returnsTuple(receiver: Type | undefined, method: string): boolean;
+
 declare const tilua: {
     readonly tokenize: typeof tokenize;
     readonly parseTokens: typeof parseTokens;
@@ -1878,4 +1948,4 @@ declare const tilua: {
     readonly analyzeTypes: typeof analyzeTypes;
 };
 
-export { type AnalyzeTypesOptions, type AnyType, type ArgumentInfo, type ArrayExpression, type ArrayPattern, type ArrayPatternElement, type ArrayType, type ArrayTypeNode, type AsConstExpression, type AssignmentStatement, type BaseNode, type BaseToken, type BinaryExpression, BinaryOperators, type Binding, type BindingId, type BindingKind, type BindingTarget, type Block, type BooleanLiteral, type BreakStatement, type BuildTarget, CONFIG_FILE_NAMES, type CallExpression, type CallLowering, type CallSite, type CallStatement, type ClassAccessibility, type ClassAccessor, type ClassConstructor, type ClassDeclaration, type ClassExpression, type ClassField, type ClassInfo, type ClassLike, type ClassMember, type ClassMethod, type CompoundAssignmentStatement, type ConditionalType, type ConditionalTypeNode, type ConfigLookup, type ConfigProblem, type ContinueStatement, type DeclareClassStatement, type DeclareMetatableStatement, type DeclareStatement, type DifferenceType, type DifferenceTypeNode, type Directive, type DirectiveKind, type DirectiveOutcome, type Directives, type DoStatement, type EOFToken, type ErrorExpression, type ErrorStatement, type ExportAllStatement, type ExportDefaultStatement, type ExportNamedStatement, type ExportSpecifier, type ExportStatement, type ExportTypeAliasStatement, type ExportedType, type Expression, type ExpressionStatement, type FunctionBody, type FunctionDeclaration, type FunctionDeclarationStatement, type FunctionExpression, type FunctionName, type FunctionParam, type FunctionParameter, type FunctionSignature, type FunctionType, type FunctionTypeNode, type FunctionTypeParameter, type GenericForStatement, type GenericRefType, type GenericTypeParameter, type GlobalCall, type GlobalValue, type Identifier, type IdentifierPattern, type IdentifierToken, type IfClause, type IfElseExpression, type IfStatement, type ImportSpecifier, type ImportStatement, type IndexExpression, type IndexedAccessType, type IndexedAccessTypeNode, type InferType, type InferTypeNode, type InterpolatedStringExpression, type InterpolatedStringPart, type InterpolatedStringPart_Expression, type InterpolatedStringPart_String, type InterpolatedStringToken, type IntersectionType, type IntersectionTypeNode, type KeyofType, type KeyofTypeNode, type KeywordToken, Keywords, LANGUAGE_GLOBALS, LexError, type LiteralToken, type LiteralType, type LoweringModule, type LoweringPlugin, type MappedType, type MappedTypeNode, type MemberExpression, type MethodCall, type MethodCallExpression, type MethodLowering, type ModuleExports, type NeverType, type NilLiteral, type Node, type NumberLiteral, type NumericForStatement, type ObjectPattern, type ObjectPatternProperty, type ObjectProperty, type ObjectType, type OperatorToken, Operators, PRELUDE_SOURCE, type ParenthesizedExpression, type ParenthesizedTypeNode, ParseError, type ParserOptions, type PrimitiveName, type PrimitiveType, type Program, type ProjectHost, type PunctuatorToken, Punctuators, type RecoverResult, type RepeatStatement, type ReturnStatement, type SatisfiesExpression, type ScopeAnalysis, type ScopeDiagnostic, type SourceComment, type SourceMapNode, type SourceMapOptions, type SourceMapTypes, type SpreadElement, type Statement, type StringLiteral, type SuperExpression, type TableExpression, type TableField, type TableTypeNode, type TableTypeProperty, type TemplateLiteralType, type TemplateLiteralTypeNode, type TiluaConfig, type Token, type TokenizeOptions, type TupleType, type TupleTypeNode, type Type, type TypeAliasStatement, type TypeAnalysis, type TypeAssertionExpression, type TypeDiagnostic, type TypeLibraries, type TypeLiteralBoolean, type TypeLiteralNumber, type TypeLiteralString, type TypeNode, type TypeOrigin, type TypeParamType, type TypePredicate, type TypePredicateNode, type TypeReference, type TypedIdentifier, type TypeofTypeNode, UNUSED_EXPECT_ERROR, type UnaryExpression, UnaryOperators, type Unification, type UnionType, type UnionTypeNode, type UnknownType, type VariableDeclaration, type WhileStatement, aliasNameOf, analyzeScopes, analyzeTypes, anyType, applyDirectives, arrayOf, booleanType, bufferType, containsTypeParam, declaredUnknownType, tilua as default, difference, directivesOf, equalTypes, falsyType, findConfig, fn, formatType, getBinding, intersection, isAssignable, isClassType, isGlobal, isPossiblyFalsy, isPossiblyTruthy, isUnassignedGlobal, literal, loadConfig, matchInfer, moduleCandidates, moduleExports, narrowExclude, narrowFalsy, narrowTo, narrowTruthy, neverType, nilType, nodeHost, numberType, objectType, optional, overlaps, parse, parseExpressionFromSource, parseTokens, parseWithRecovery, primitive, readDirectives, resolveModulePath, resolveTypeLibraries, setAliasExpander, setDeferredBound, sourceMapTypes, stringType, stripJsonComments, substitute, templateMatches, threadType, tilua, tokenize, tuple, tupleMembers, typeParam, unify, union, unknownType, widen, withAliasName, withoutAliasName };
+export { type AnalyzeTypesOptions, type AnyType, type ArgumentInfo, type ArrayExpression, type ArrayPattern, type ArrayPatternElement, type ArrayType, type ArrayTypeNode, type AsConstExpression, type AssignmentStatement, type BaseNode, type BaseToken, type BinaryExpression, BinaryOperators, type Binding, type BindingId, type BindingKind, type BindingTarget, type Block, type BooleanLiteral, type BreakStatement, type BuildTarget, CONFIG_FILE_NAMES, type CallExpression, type CallLowering, type CallSite, type CallStatement, type ClassAccessibility, type ClassAccessor, type ClassConstructor, type ClassDeclaration, type ClassExpression, type ClassField, type ClassInfo, type ClassLike, type ClassMember, type ClassMethod, type CompoundAssignmentStatement, type ConditionalType, type ConditionalTypeNode, type ConfigLookup, type ConfigProblem, type ContinueStatement, type DeclareClassStatement, type DeclareMetatableStatement, type DeclareStatement, type DifferenceType, type DifferenceTypeNode, type Directive, type DirectiveKind, type DirectiveOutcome, type Directives, type DoStatement, type EOFToken, type ErrorExpression, type ErrorStatement, type ExportAllStatement, type ExportDefaultStatement, type ExportNamedStatement, type ExportSpecifier, type ExportStatement, type ExportTypeAliasStatement, type ExportedType, type Expression, type ExpressionStatement, type FunctionBody, type FunctionDeclaration, type FunctionDeclarationStatement, type FunctionExpression, type FunctionName, type FunctionParam, type FunctionParameter, type FunctionSignature, type FunctionType, type FunctionTypeNode, type FunctionTypeParameter, type GenericForStatement, type GenericRefType, type GenericTypeParameter, type GlobalCall, type GlobalValue, type Identifier, type IdentifierPattern, type IdentifierToken, type IfClause, type IfElseExpression, type IfStatement, type ImportSpecifier, type ImportStatement, type IndexExpression, type IndexedAccessType, type IndexedAccessTypeNode, type InferType, type InferTypeNode, type InterpolatedStringExpression, type InterpolatedStringPart, type InterpolatedStringPart_Expression, type InterpolatedStringPart_String, type InterpolatedStringToken, type IntersectionType, type IntersectionTypeNode, type KeyofType, type KeyofTypeNode, type KeywordToken, Keywords, LANGUAGE_GLOBALS, LUAU_KEYWORDS, LexError, type LiteralToken, type LiteralType, type LoweringModule, type LoweringPlugin, type MappedType, type MappedTypeNode, type MemberExpression, type MethodCall, type MethodCallExpression, type MethodLowering, type ModuleExports, type NeverType, type NilLiteral, type Node, type NumberLiteral, type NumericForStatement, type ObjectPattern, type ObjectPatternProperty, type ObjectProperty, type ObjectType, type OperatorToken, Operators, PRELUDE_SOURCE, type ParenthesizedExpression, type ParenthesizedTypeNode, ParseError, type ParserOptions, type PrimitiveName, type PrimitiveType, type Program, type ProjectHost, type PunctuatorToken, Punctuators, type RecoverResult, type RepeatStatement, type ReturnStatement, type SatisfiesExpression, type ScopeAnalysis, type ScopeDiagnostic, type SourceComment, type SourceMapNode, type SourceMapOptions, type SourceMapTypes, type SpreadElement, type Statement, type StringLiteral, type SuperExpression, type TableExpression, type TableField, type TableTypeNode, type TableTypeProperty, type TemplateLiteralType, type TemplateLiteralTypeNode, type TiluaConfig, type Token, type TokenizeOptions, type TupleType, type TupleTypeNode, type Type, type TypeAliasStatement, type TypeAnalysis, type TypeAssertionExpression, type TypeDiagnostic, type TypeLibraries, type TypeLiteralBoolean, type TypeLiteralNumber, type TypeLiteralString, type TypeNode, type TypeOrigin, type TypeParamType, type TypePredicate, type TypePredicateNode, type TypeReference, type TypedIdentifier, type TypeofTypeNode, UNUSED_EXPECT_ERROR, type UnaryExpression, UnaryOperators, type Unification, type UnionType, type UnionTypeNode, type UnknownType, type VariableDeclaration, type WhileStatement, aliasNameOf, analyzeScopes, analyzeTypes, anyType, applyDirectives, arrayOf, booleanType, bufferType, containsTypeParam, declaredUnknownType, tilua as default, difference, directivesOf, equalTypes, escapeLuauString, falsyType, findConfig, fn, formatType, getBinding, hasMembers, intersection, isAssignable, isClassType, isFunctionType, isGlobal, isIdentifier, isInstanceOf, isLuauName, isPossiblyFalsy, isPossiblyTruthy, isUnassignedGlobal, literal, loadConfig, luauString, matchInfer, moduleCandidates, moduleExports, narrowExclude, narrowFalsy, narrowTo, narrowTruthy, neverType, nilType, nodeHost, numberType, objectType, optional, overlaps, parse, parseExpressionFromSource, parseTokens, parseWithRecovery, primitive, readDirectives, resolveModulePath, resolveTypeLibraries, returnsTuple, setAliasExpander, setDeferredBound, sourceMapTypes, stringType, stripJsonComments, substitute, templateMatches, threadType, tilua, tokenize, tuple, tupleMembers, typeParam, unify, union, unknownType, widen, withAliasName, withoutAliasName, withoutNil };

package/dist/index.js

@@ -603,7 +603,7 @@ function bindThis(func, at) {
   func.isMethod = true;
 }
 function bindThisParam(params, at) {
-  params.unshift({ type: "FunctionParameter", name: "this", ...spanFrom(at, at) });
+  params.unshift({ type: "FunctionParameter", name: "this", implicit: true, ...spanFrom(at, at) });
 }
 var ParseError = class extends Error {
   constructor(message, line, column) {
@@ -1660,7 +1660,7 @@ var Parser = class {
         };
       }
       if (isMethod) {
-        func.params.unshift({ type: "FunctionParameter", name: "self", ...spanFrom(target, target) });
+        func.params.unshift({ type: "FunctionParameter", name: "self", implicit: true, ...spanFrom(target, target) });
         func.isMethod = true;
       }
       return {
@@ -1854,47 +1854,7 @@ var Parser = class {
     const isStatic = modifiers.has("static");
     if (this.checkKeyword("function")) {
       this.advance();
-      const memberName = this.parseIdentifier();
-      if (modifiers.has("abstract")) {
-        const head = this.parseFunctionHead();
-        const func = {
-          type: "FunctionBody",
-          generics: head.generics,
-          params: head.params,
-          hasVarargs: head.hasVarargs,
-          returnType: head.returnType,
-          predicate: head.predicate,
-          body: { type: "Block", statements: [], ...spanFrom(head.start, this.previous()) },
-          ...spanFrom(head.start, this.previous())
-        };
-        if (!isStatic) bindThis(func, start);
-        if (!head.returnType) this.problem("An abstract method has no body to infer from: write its return type");
-        if (this.checkPunctuator("{")) this.problem("An abstract method has no body");
-        return { type: "ClassMethod", name: memberName, isStatic, func, isAbstract: true, ...spanFrom(start, this.previous()) };
-      }
-      const signatures = [];
-      let written = memberName;
-      while (true) {
-        const head = this.parseFunctionHead();
-        if (this.isClassOverloadContinuation(memberName.name, isStatic)) {
-          if (!isStatic) bindThisParam(head.params, start);
-          signatures.push({ ...this.headToSignature(head), name: written });
-          if (isStatic) this.advance();
-          this.expectKeyword("function");
-          written = this.parseIdentifier();
-          continue;
-        }
-        const func = this.headToBody(head, start);
-        if (!isStatic) bindThis(func, start);
-        return {
-          type: "ClassMethod",
-          name: memberName,
-          isStatic,
-          func,
-          signatures: signatures.length ? signatures : void 0,
-          ...spanFrom(start, this.previous())
-        };
-      }
+      return this.parseClassMethod(start, modifiers);
     }
     if (!isStatic && this.checkIdentifierValue("constructor") && this.punctuatorAt(1, "(")) {
       this.advance();
@@ -1904,6 +1864,9 @@ var Parser = class {
       bindThis(func, start);
       return { type: "ClassConstructor", func, ...spanFrom(start, this.previous()) };
     }
+    if (this.startsMethodShorthand(0)) {
+      return this.parseClassMethod(start, modifiers);
+    }
     if ((this.checkIdentifierValue("get") || this.checkIdentifierValue("set")) && this.peek(1).type === "Identifier" && this.punctuatorAt(2, "(")) {
       const kind = this.advance().value;
       const memberName = this.parseIdentifier();
@@ -1933,25 +1896,90 @@ var Parser = class {
       return { type: "ClassField", name: memberName, isStatic, typeAnnotation, init, ...spanFrom(start, this.previous()) };
     }
     if (this.recover) {
-      this.softError("Expected a class member: a field, 'function', 'constructor', 'get' or 'set'");
+      this.softError("Expected a class member: a field, a method, 'constructor', 'get' or 'set'");
       this.advance();
       return void 0;
     }
-    this.error("Expected a class member: a field, 'function', 'constructor', 'get' or 'set'");
+    this.error("Expected a class member: a field, a method, 'constructor', 'get' or 'set'");
+  }
+  /** A name at `offset` opening a method without `function`: `name(` or
+   *  `name<T>(`. A field's name is followed by `:` or `=` instead. */
+  startsMethodShorthand(offset) {
+    if (this.peek(offset).type !== "Identifier") return false;
+    const next = this.peek(offset + 1);
+    return (next.type === "Punctuator" || next.type === "Operator") && (next.value === "(" || next.value === "<");
+  }
+  /** A method, from its name on: `function` (if written) and the modifiers
+   *  are behind. */
+  parseClassMethod(start, modifiers) {
+    const isStatic = modifiers.has("static");
+    const memberName = this.parseIdentifier();
+    if (modifiers.has("abstract")) {
+      const head = this.parseFunctionHead();
+      const func = {
+        type: "FunctionBody",
+        generics: head.generics,
+        params: head.params,
+        hasVarargs: head.hasVarargs,
+        returnType: head.returnType,
+        predicate: head.predicate,
+        body: { type: "Block", statements: [], ...spanFrom(head.start, this.previous()) },
+        ...spanFrom(head.start, this.previous())
+      };
+      if (!isStatic) bindThis(func, start);
+      if (!head.returnType) this.problem("An abstract method has no body to infer from: write its return type");
+      if (this.checkPunctuator("{")) this.problem("An abstract method has no body");
+      return { type: "ClassMethod", name: memberName, isStatic, func, isAbstract: true, ...spanFrom(start, this.previous()) };
+    }
+    const signatures = [];
+    let written = memberName;
+    while (true) {
+      const head = this.parseFunctionHead();
+      const skip = this.classOverloadContinuation(memberName.name, isStatic);
+      if (skip !== void 0) {
+        if (!isStatic) bindThisParam(head.params, start);
+        signatures.push({ ...this.headToSignature(head), name: written });
+        for (let i = 0; i < skip; i++) this.advance();
+        written = this.parseIdentifier();
+        continue;
+      }
+      const func = this.headToBody(head, start);
+      if (!isStatic) bindThis(func, start);
+      return {
+        type: "ClassMethod",
+        name: memberName,
+        isStatic,
+        func,
+        signatures: signatures.length ? signatures : void 0,
+        ...spanFrom(start, this.previous())
+      };
+    }
   }
-  /** Give a class method its `this`: a real first parameter, the way
-   *  `function T:m()` gets a real `self`. Every later pass — scopes, types,
-   *  arity, lowering — then sees an ordinary parameter and needs to know
-   *  nothing about classes. */
   /** After a bodyless head inside a class body, does another declaration of
-   *  the same member follow? Then the head was an overload signature. */
-  isClassOverloadContinuation(name, isStatic) {
-    const offset = isStatic ? 1 : 0;
-    if (isStatic && !this.checkIdentifierValue("static")) return false;
+   *  the same member follow? Then the head was an overload signature, and
+   *  this is how many tokens stand before the next one's name: a `;` that
+   *  ends the head, as TypeScript writes it, the modifiers, and `function`
+   *  when it is written. `undefined` when no overload follows. Each head may
+   *  be written either way, with `function` or without. */
+  classOverloadContinuation(name, isStatic) {
+    let offset = 0;
+    if (this.punctuatorAt(0, ";")) offset++;
+    let sawStatic = false;
+    while (true) {
+      const t = this.peek(offset);
+      const word = t.type === "Identifier" ? t.value : void 0;
+      if (word === void 0 || !CLASS_MODIFIERS.has(word) || this.startsMethodShorthand(offset)) break;
+      if (word === "static") sawStatic = true;
+      offset++;
+    }
+    if (sawStatic !== isStatic) return void 0;
     const keyword = this.peek(offset);
-    if (!(keyword.type === "Keyword" && keyword.value === "function")) return false;
-    const named = this.peek(offset + 1);
-    return named.type === "Identifier" && named.value === name;
+    const hasKeyword = keyword.type === "Keyword" && keyword.value === "function";
+    if (hasKeyword) offset++;
+    const named = this.peek(offset);
+    if (!(named.type === "Identifier" && named.value === name)) return void 0;
+    if (!hasKeyword && !this.startsMethodShorthand(offset)) return void 0;
+    return offset;
   }
   operatorAt(ahead, value) {
     const token = this.peek(ahead);
@@ -4571,11 +4599,34 @@ declare metatable<T> T[]: {
 -- \`nil\` when it is missing; an indexer's keys follow the named ones. A
 -- member of the table's own with one of these names is what a call reaches,
 -- and a class instance, which has a metatable of its own, has none of them.
+--
+-- The rest are JavaScript's \`Object\` functions, written as methods of the
+-- table they take first:
+--
+--     point:hasOwn("x")           -- Object.hasOwn(point, "x")
+--     point:assign({ z: 3 })      -- Object.assign(point, { z: 3 })
+--     point:freeze()              -- Object.freeze(point)
+--
+-- \`hasOwn\` asks the table itself, not what its metatable's \`__index\`
+-- lends it. \`assign\` copies each source's members onto the table, later ones
+-- over earlier ones, skipping a \`nil\` source, and answers the table. \`freeze\`
+-- is Luau's \`table.freeze\`; under Lua 5.1, which cannot freeze a table, the
+-- table is answered as it is and \`isFrozen\` is false.
 declare metatable<T extends {}> T: {
     __index: {
         keys: (self: T) => ObjectKeys<T>,
         values: (self: T) => ObjectValues<T>,
         entries: (self: T) => ObjectEntries<T>,
+
+        hasOwn: (self: T, key: unknown) => boolean,
+        hasOwnProperty: (self: T, key: unknown) => boolean,
+        assign: (<U>(self: T, source: U) => T & U)
+            & (<U, V>(self: T, a: U, b: V) => T & U & V)
+            & (<U, V, W>(self: T, a: U, b: V, c: W) => T & U & V & W)
+            -- Generic like the rest: a plain signature would be tried first.
+            & (<S extends {}>(self: T, ...sources: S[]) => T),
+        freeze: (self: T) => Readonly<T>,
+        isFrozen: (self: T) => boolean,
     },
 }
 `;
@@ -11761,7 +11812,53 @@ function aliasTargets(config, specifier) {
 
 // src/project/sourcemap.ts
 import { dirname as dirname4, extname, resolve as resolve4 } from "path";
+
+// src/luau.ts
+var LUAU_KEYWORDS = /* @__PURE__ */ new Set([
+  "and",
+  "break",
+  "do",
+  "else",
+  "elseif",
+  "end",
+  "false",
+  "for",
+  "function",
+  "if",
+  "in",
+  "local",
+  "nil",
+  "not",
+  "or",
+  "repeat",
+  "return",
+  "then",
+  "true",
+  "until",
+  "while"
+]);
 var IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function isIdentifier(name) {
+  return IDENTIFIER.test(name);
+}
+function isLuauName(name) {
+  return IDENTIFIER.test(name) && !LUAU_KEYWORDS.has(name);
+}
+var NAMED_ESCAPES = {
+  "\\": "\\\\",
+  '"': '\\"',
+  "\n": "\\n",
+  "\r": "\\r",
+  "	": "\\t"
+};
+function escapeLuauString(text) {
+  return text.replace(/[\\"\x00-\x1f\x7f]/g, (c) => NAMED_ESCAPES[c] ?? `\\${c.charCodeAt(0).toString().padStart(3, "0")}`);
+}
+function luauString(text) {
+  return `"${escapeLuauString(text)}"`;
+}
+
+// src/project/sourcemap.ts
 var INSTANCE_MEMBERS = /* @__PURE__ */ new Set(["Name", "ClassName", "Parent", "Archivable"]);
 var SCRIPT_EXTENSIONS = /* @__PURE__ */ new Set([".tilua", ".luau", ".lua"]);
 function sourceMapTypes(text, path, options) {
@@ -11788,7 +11885,7 @@ function sourceMapTypes(text, path, options) {
     const alias = aliasFor(segments);
     aliasOfNode.set(node, alias);
     for (const filePath of node.filePaths ?? []) aliasOfFile.set(fileKey(resolve4(directory, filePath)), alias);
-    const className = IDENTIFIER.test(node.className) && options.classes.has(node.className) ? node.className : "Instance";
+    const className = isIdentifier(node.className) && options.classes.has(node.className) ? node.className : "Instance";
     const taken = options.membersOf?.(className) ?? INSTANCE_MEMBERS;
     const members = [];
     if (parent) members.push(`Parent: ${parent}`);
@@ -11797,7 +11894,7 @@ function sourceMapTypes(text, path, options) {
       if (!isNode(child)) continue;
       const childAlias = visit(child, [...segments, child.name], alias);
       const service = child.name === child.className && options.classes.has(child.className);
-      if (!IDENTIFIER.test(child.name) || taken.has(child.name) && !service || named.has(child.name)) continue;
+      if (!isIdentifier(child.name) || taken.has(child.name) && !service || named.has(child.name)) continue;
       named.add(child.name);
       members.push(`${child.name}: ${childAlias}`);
     }
@@ -11839,6 +11936,34 @@ function fileKey(path) {
   return process.platform === "win32" ? normalized.toLowerCase() : normalized;
 }
 
+// src/loweringHelpers.ts
+function withoutNil2(type) {
+  if (!type) return [];
+  const members = type.kind === "union" ? type.types : [type];
+  return members.filter((m) => !(m.kind === "primitive" && m.name === "nil"));
+}
+function isFunctionType(type) {
+  const members = withoutNil2(type);
+  return members.length > 0 && members.every((m) => m.kind === "function" || m.kind === "intersection" && m.types.every(isFunctionType));
+}
+function everyObject(type, test) {
+  const members = withoutNil2(type);
+  return members.length > 0 && members.every((m) => m.kind === "object" && test(m));
+}
+function isInstanceOf(type, className) {
+  return everyObject(type, (m) => m.class !== void 0 && m.class.ancestors.includes(className));
+}
+function hasMembers(type, names) {
+  return everyObject(type, (m) => names.every((name) => m.properties.has(name)));
+}
+function returnsTuple(receiver, method) {
+  return everyObject(receiver, (m) => {
+    const found = m.properties.get(method)?.type;
+    const signatures = !found ? [] : found.kind === "intersection" ? found.types : [found];
+    return signatures.length > 0 && signatures.every((f) => f.kind === "function" && f.returns.kind === "tuple");
+  });
+}
+
 // src/index.ts
 var tilua = {
   tokenize,
@@ -11858,6 +11983,7 @@ export {
   CONFIG_FILE_NAMES,
   Keywords,
   LANGUAGE_GLOBALS,
+  LUAU_KEYWORDS,
   LexError,
   Operators,
   PRELUDE_SOURCE,
@@ -11879,20 +12005,27 @@ export {
   difference,
   directivesOf,
   equalTypes,
+  escapeLuauString,
   falsyType,
   findConfig,
   fn,
   formatType,
   getBinding,
+  hasMembers,
   intersection,
   isAssignable,
   isClassType,
+  isFunctionType,
   isGlobal,
+  isIdentifier,
+  isInstanceOf,
+  isLuauName,
   isPossiblyFalsy,
   isPossiblyTruthy,
   isUnassignedGlobal,
   literal,
   loadConfig,
+  luauString,
   matchInfer,
   moduleCandidates,
   moduleExports,
@@ -11915,6 +12048,7 @@ export {
   readDirectives,
   resolveModulePath,
   resolveTypeLibraries,
+  returnsTuple,
   setAliasExpander,
   setDeferredBound,
   sourceMapTypes,
@@ -11933,5 +12067,6 @@ export {
   unknownType,
   widen,
   withAliasName,
-  withoutAliasName
+  withoutAliasName,
+  withoutNil2 as withoutNil
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tilua/parser",
-  "version": "3.0.1",
+  "version": "3.1.0",
   "description": "tilua parser for roblox",
   "main": "./dist/index.js",
   "module": "./dist/index.js",