luaut-parser 3.0.0 → 4.0.0

package/dist/index.d.cts

@@ -54,6 +54,10 @@ interface InterpolatedStringPart_String {
 interface InterpolatedStringPart_Expression {
     kind: "expression";
     raw: string;
+    /** Where `raw` starts in the file, so what is parsed from it can be
+     *  placed there rather than at the top of an imaginary one. */
+    line: number;
+    column: number;
 }
 interface InterpolatedStringToken extends BaseToken {
     type: "InterpolatedString";
@@ -68,7 +72,72 @@ declare class LexError extends Error {
     column: number;
     constructor(message: string, line: number, column: number);
 }
-declare function tokenize(source: string): Token[];
+/** A `--` comment: its text after the dashes (a long comment's content), and
+ *  where it starts and ends. */
+interface SourceComment {
+    text: string;
+    line: number;
+    column: number;
+    endLine: number;
+}
+interface TokenizeOptions {
+    /** When given, a malformed token is recorded here instead of thrown, and
+     *  lexing goes on: an unclosed string or comment ends at the end of its
+     *  line (a long bracket at the end of the source), and a character that
+     *  starts no token is skipped. An editor mid-keystroke still gets every
+     *  other token. */
+    errors?: LexError[];
+    /** When given, every comment is collected here, in order. */
+    comments?: SourceComment[];
+}
+declare function tokenize(source: string, options?: TokenizeOptions): Token[];
+
+/**
+ * Comments that switch checking off, as TypeScript's `// @ts-...` comments do:
+ *
+ *     --@luaut-nocheck         no scope or type errors anywhere in this file
+ *     --@luaut-ignore          none on the next line of code
+ *     --@luaut-expect-error    none on the next line of code, and an error if
+ *                              that line has none to suppress
+ *
+ * A space after `--` is fine, and so is text after the directive (a reason).
+ * `nocheck` counts only in the comments before the first line of code, as in
+ * TypeScript. Syntax errors are never suppressed: code that does not parse
+ * cannot be compiled either way.
+ */
+type DirectiveKind = "nocheck" | "ignore" | "expect-error";
+interface Directive {
+    kind: DirectiveKind;
+    /** Where the comment starts. */
+    line: number;
+    column: number;
+    /** `ignore` / `expect-error`: the line whose diagnostics it covers — the
+     *  next line with code on it. */
+    target?: number;
+}
+interface Directives {
+    /** The file has `--@luaut-nocheck` before its first line of code. */
+    nocheck: boolean;
+    /** Every directive, in order — a `nocheck` after the code starts included,
+     *  so a tool can point out that it does nothing. */
+    all: Directive[];
+}
+/** The directives in `comments`, placed against `tokens` (both from one
+ *  `tokenize` of the file). */
+declare function readDirectives(comments: readonly SourceComment[], tokens: readonly Token[]): Directives;
+/** The directives of `source`, for a caller that parsed it some other way. */
+declare function directivesOf(source: string): Directives;
+interface DirectiveOutcome<T> {
+    /** The diagnostics no directive suppresses. */
+    kept: T[];
+    /** `--@luaut-expect-error` comments with nothing to suppress. Each is an
+     *  error to report: "Unused '@luaut-expect-error' directive". */
+    unusedExpectErrors: Directive[];
+}
+/** Filter scope and type diagnostics — never syntax errors — through the
+ *  file's directives. `lineOf` gives the line a diagnostic starts on. */
+declare function applyDirectives<T>(directives: Directives, diagnostics: readonly T[], lineOf: (diagnostic: T) => number): DirectiveOutcome<T>;
+declare const UNUSED_EXPECT_ERROR = "Unused '@luaut-expect-error' directive";
 
 interface BaseNode {
     line: {
@@ -226,6 +295,9 @@ interface ArrayPatternElement extends BaseNode {
  *  assign to a member instead: see `FunctionDeclarationStatement`. */
 interface FunctionDeclaration extends BaseNode {
     type: "FunctionDeclaration";
+    /** The name on the line the body is written on, when the declaration is
+     *  an overload set — `name` is the first signature's. */
+    implementationName?: Identifier;
     name: Identifier;
     func: FunctionBody;
     attributes?: string[];
@@ -247,6 +319,9 @@ interface FunctionDeclarationStatement extends BaseNode {
  *  followed by the implementation `function f(...) ... end`. */
 interface FunctionSignature extends BaseNode {
     type: "FunctionSignature";
+    /** The name this signature was written with — one line of an overload
+     *  set, each of which a tool can point at on its own. */
+    name?: Identifier;
     generics: GenericTypeParameter[];
     params: FunctionParameter[];
     hasVarargs: boolean;
@@ -347,7 +422,14 @@ interface GenericTypeParameter extends BaseNode {
     constraint?: TypeNode;
     default?: TypeNode | TypePackNode;
 }
-type Expression = Identifier | NilLiteral | BooleanLiteral | NumberLiteral | StringLiteral | InterpolatedStringExpression | VarargExpression | FunctionExpression | TableExpression | ArrayExpression | BinaryExpression | UnaryExpression | MemberExpression | IndexExpression | CallExpression | MethodCallExpression | ParenthesizedExpression | TypeAssertionExpression | SatisfiesExpression | AsConstExpression | IfElseExpression;
+type Expression = Identifier | NilLiteral | BooleanLiteral | NumberLiteral | StringLiteral | InterpolatedStringExpression | VarargExpression | FunctionExpression | TableExpression | ArrayExpression | BinaryExpression | UnaryExpression | MemberExpression | IndexExpression | CallExpression | MethodCallExpression | ParenthesizedExpression | TypeAssertionExpression | SatisfiesExpression | AsConstExpression | IfElseExpression | ErrorExpression;
+/** An expression that could not be parsed. Only produced in recovery mode
+ *  (`parseWithRecovery`), where a broken initializer, condition, field value or
+ *  argument keeps its place in the tree; its span covers the skipped tokens
+ *  (and is empty when nothing was written). Its type is `any`. */
+interface ErrorExpression extends BaseNode {
+    type: "ErrorExpression";
+}
 interface Identifier extends BaseNode {
     type: "Identifier";
     name: string;
@@ -474,6 +556,9 @@ interface MemberExpression extends BaseNode {
     type: "MemberExpression";
     object: Expression;
     property: Identifier;
+    /** `object?.property` — when `object` is nil, the whole chain this link
+     *  belongs to is nil and nothing after it is evaluated. */
+    optional?: boolean;
 }
 interface IndexExpression extends BaseNode {
     type: "IndexExpression";
@@ -484,12 +569,22 @@ interface CallExpression extends BaseNode {
     type: "CallExpression";
     callee: Expression;
     arguments: Expression[];
+    /** `f<T>(x)` — type arguments written out rather than inferred. */
+    typeArguments?: (TypeNode | TypePackNode)[];
+    /** `f?.(...)` — see `MemberExpression.optional`. The call does not happen,
+     *  and the arguments are not evaluated, when `callee` is nil. */
+    optional?: boolean;
 }
 interface MethodCallExpression extends BaseNode {
     type: "MethodCallExpression";
     object: Expression;
     method: Identifier;
     arguments: Expression[];
+    /** `obj:m<T>(x)` — see `CallExpression.typeArguments`. */
+    typeArguments?: (TypeNode | TypePackNode)[];
+    /** `object?:method(...)` — see `MemberExpression.optional`. The
+     *  arguments are not evaluated when `object` is nil. */
+    optional?: boolean;
 }
 interface ParenthesizedExpression extends BaseNode {
     type: "ParenthesizedExpression";
@@ -724,6 +819,11 @@ interface ParserOptions {
      *  first one. The returned AST has an `ErrorStatement` wherever a statement
      *  could not be parsed. */
     recover?: boolean;
+    /** Recovery only: read where a block ends from indentation when an `end`
+     *  is missing — a line indented no deeper than the line that opened the
+     *  block is past it. Valid code never needs this; `parseWithRecovery`
+     *  reparses with it when the first pass found an `end` missing. */
+    indentation?: boolean;
 }
 declare function parse(source: string): Program;
 declare function parseTokens(tokens: Token[]): Program;
@@ -731,13 +831,16 @@ declare function parseExpressionFromSource(raw: string): Expression;
 interface RecoverResult {
     program: Program;
     errors: ParseError[];
+    /** The file's `--@luaut-...` comments; see `applyDirectives`. */
+    directives: Directives;
 }
 /**
- * Like `parse`, but never throws on a syntax error: it records every error,
- * synchronizes to the next statement boundary, and returns a best-effort AST
- * (with `ErrorStatement` nodes where statements were skipped). A lexer error
- * still can't produce a partial token stream, so it comes back as the sole
- * entry in `errors` alongside an empty program.
+ * Like `parse`, but never throws on a syntax error: it records every error and
+ * returns a best-effort AST. A broken expression becomes an `ErrorExpression`,
+ * a broken field or argument is skipped to the next `,`, a missing `)`, `}`,
+ * `then`, `do` or `end` is recorded and read past, and only what none of those
+ * cover becomes an `ErrorStatement`. A malformed token (an unclosed string) is
+ * an error too, and the rest of the file still lexes.
  *
  * This is the entry point a language server should use for open documents.
  */
@@ -786,7 +889,7 @@ interface ScopeDiagnostic {
         };
     };
     message: string;
-    kind: "redeclare" | "const-assign" | "type-only";
+    kind: "redeclare" | "const-assign" | "type-only" | "undeclared" | "use-before-define";
 }
 interface ScopeAnalysis {
     /** Every Identifier that appears in a variable *usage* position (i.e.
@@ -812,6 +915,12 @@ interface AnalyzeScopesOptions {
      *  one of these does not count as "defining" it, so `declarationNode`
      *  is left unset even though the binding exists up front. */
     builtinGlobals?: readonly string[];
+    /** Report each read of a name nothing declares — not a local, not one of
+     *  `builtinGlobals`, not `declare`d in the file, never assigned as a
+     *  global: "Cannot find name 'x'", as TypeScript says. Only meaningful
+     *  when `builtinGlobals` lists everything the file's type libraries
+     *  declare, so it is off unless asked for. */
+    reportUndeclared?: boolean;
 }
 declare function getBinding(analysis: ScopeAnalysis, id: Identifier | IdentifierPattern): Binding | undefined;
 declare function isGlobal(binding: Binding): boolean;
@@ -927,6 +1036,9 @@ interface FunctionType {
     /** Names of the function's own generic parameters (`function f<T>(...)`).
      *  `params` / `returns` may contain `typeParam` nodes for these. */
     typeParams?: string[];
+    /** `<T = Instance>` — what a call uses for a parameter it is not given and
+     *  cannot infer. */
+    typeParamDefaults?: Record<string, Type>;
     /** Set when the function was declared with an `x is T` / `asserts x` return. */
     predicate?: TypePredicate;
 }
@@ -1109,8 +1221,9 @@ declare function formatType(t: Type): string;
 
 interface TypeDiagnostic {
     /** Usually an expression or statement; a type where the type is wrong
-     *  (`declare class A extends NotAClass`). */
-    node: Expression | Statement | TypeNode;
+     *  (`declare class A extends NotAClass`), or a block where nothing in it
+     *  is to blame (a function that never returns). Only its span is read. */
+    node: Expression | Statement | TypeNode | Block;
     message: string;
 }
 interface TypeAnalysis {
@@ -1172,6 +1285,11 @@ interface AnalyzeTypesOptions {
     resolveModule?: (specifier: string) => ModuleExports | undefined;
     /** Emit assignability diagnostics (default: true). */
     diagnostics?: boolean;
+    /** Report each type name nothing declares: "Cannot find name 'Nope'".
+     *  Only meaningful when `libs` holds everything the file can name, so it
+     *  is off unless asked for — exactly like `analyzeScopes`'s
+     *  `reportUndeclared`. */
+    reportUnknownTypes?: boolean;
 }
 declare function analyzeTypes(program: Program, scopes: ScopeAnalysis, options?: AnalyzeTypesOptions): TypeAnalysis;
 /** The exports of an analyzed module, in the shape another module's
@@ -1180,6 +1298,27 @@ declare function moduleExports(program: Program, scopes: ScopeAnalysis, types: T
 /** For `export ... from`: the same resolver the module was analyzed with. */
 resolveModule?: (specifier: string) => ModuleExports | undefined): ModuleExports;
 
+/**
+ * The types that belong to the language itself, available in every file with
+ * or without a type library — as TypeScript's `Partial` and `ReturnType` are.
+ *
+ * They are written in luaut on top of `keyof`, `T[K]`, conditional types with
+ * `infer`, mapped types and set difference; the analyzer knows none of these
+ * names. A type library or the file itself may declare one of them again, and
+ * that declaration wins.
+ *
+ * What a runtime provides — `print`, `string`, `game` — is not here: that is a
+ * type library's job (`@luaut/lua`, `@luaut/roblox`).
+ *
+ * The methods an array and a string answer to — `names:filter(f)`,
+ * `text:trim()` — are a library's too. `propertyType` reads them from types
+ * named `ArrayMethods<T>` and `StringMethods`, whichever library declares
+ * those; the library also says which of them the compiler must emit code for
+ * (`luaut.methods` in its package.json). Nothing about `filter` is written
+ * into the analyzer.
+ */
+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 (...unknown) -> infer R ? R : never\ntype Parameters<T> = T extends (...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";
+
 interface ProjectHost {
     /** A file's text, or `undefined` when there is no such file. */
     readFile(path: string): string | undefined;
@@ -1194,7 +1333,7 @@ interface LuautConfig {
     readonly directory: string;
     /** The config file's text, for locating problems in it. */
     readonly source: string;
-    /** Type libraries to load, in order: `"luau"`, `"@luaut/roblox"`, `"./types"`. */
+    /** Type libraries to load, in order: `"lua"`, `"@luaut/roblox"`, `"./types"`. */
     readonly types: readonly string[];
     /** Import path aliases, as in tsconfig: `{ "@shared/*": ["src/shared/*"] }`. */
     readonly paths: Readonly<Record<string, readonly string[]>>;
@@ -1235,10 +1374,93 @@ declare function stripJsonComments(text: string): string;
 interface TypeLibraries {
     /** Definitions files, dependencies before what depends on them. */
     readonly files: readonly string[];
+    /** Lowering modules the libraries ship, in the same order. */
+    readonly lowerings: readonly LoweringModule[];
     readonly problems: readonly ConfigProblem[];
 }
+/** A library's own lowering: JavaScript the compiler loads and asks what a
+ *  call written against this library's types should become.
+ *
+ *  The library declares the *types* in its definitions file; this is the other
+ *  half. `names:filter(f)` is a call to a function only because `@luaut/lua`
+ *  says so and ships the Luau behind it — the compiler knows how to ask, and
+ *  nothing about `filter`.
+ *
+ *  `luaut.lowering` in the package.json names the module; what it must export
+ *  is the compiler's business (see luaut-build's `LoweringPlugin`). */
+interface LoweringModule {
+    /** The JavaScript module to load. */
+    readonly file: string;
+    /** The package it came from, for reporting. */
+    readonly from: string;
+}
 declare function resolveTypeLibraries(config: LuautConfig, host?: ProjectHost): TypeLibraries;
 
+/**
+ * The contract between a type library and the compiler.
+ *
+ * A library's definitions file says what a value *is*; when what it gives is
+ * not something the value already answers to, the library must also say how
+ * it runs. `names:filter(f)` is a call to a function because `@luaut/lua`
+ * declares the method and ships the Luau behind it — the compiler lowers the
+ * language (`import`, `export`, `?.`, `a ? b : c`, destructuring, spreads)
+ * and asks a library about everything else.
+ *
+ * These types are declarations only: nothing here runs, and the parser never
+ * loads a lowering module. They live here so a library can be written in
+ * TypeScript against the same contract the compiler implements, without
+ * depending on the compiler.
+ *
+ *     // lowering.ts, in a type library
+ *     import type { LoweringPlugin } from "luaut-parser"
+ *
+ *     const plugin: LoweringPlugin = {
+ *         runtime: { array: "local __NAME__ = {}\n..." },
+ *         methodCall({ method, receiver, use }) {
+ *             if (receiver?.kind === "array" && method === "filter") {
+ *                 return { callee: `${use("array")}.filter` }
+ *             }
+ *             return undefined
+ *         },
+ *     }
+ *     export default plugin
+ */
+
+interface LoweringPlugin {
+    /** Luau the plugin needs in the output, by a key it chooses. Each is a
+     *  file's worth of source with `__NAME__` standing for the local the
+     *  compiler gives it, and each is emitted once, at the top of the output,
+     *  only if `use` asked for it:
+     *
+     *      local __NAME__ = {}
+     *      function __NAME__.filter(t, test) ... end
+     */
+    readonly runtime?: Readonly<Record<string, string>>;
+    /** What `receiver:method(...)` becomes. `undefined` leaves a plain Luau
+     *  method call, which is what a value that answers to the method itself
+     *  wants — `text:upper()` reaches Lua's own. */
+    methodCall?(call: MethodCall): MethodLowering | undefined;
+}
+interface MethodCall {
+    /** The name written after `:`. */
+    readonly method: string;
+    /** The receiver's type, as the analyzer worked it out. `undefined` when
+     *  nothing typed it, where a plugin should decline rather than guess. */
+    readonly receiver: Type | undefined;
+    /** How many arguments were written. */
+    readonly argumentCount: number;
+    /** The local name the output gives one of `runtime`'s entries, emitting
+     *  it if this is the first call that needed it. */
+    use(runtime: string): string;
+}
+interface MethodLowering {
+    /** What to call instead: a name, or a `table.member` path — usually built
+     *  from `use(...)`. */
+    readonly callee: string;
+    /** Pass the receiver as the first argument. Default: yes. */
+    readonly passReceiver?: boolean;
+}
+
 /** Every file `specifier` could mean from `fromFile`, in the order they are
  *  tried. A resolver that caches should watch all of them: creating an earlier
  *  candidate changes what the import means. */
@@ -1285,4 +1507,4 @@ declare const luautparser: {
     readonly analyzeTypes: typeof analyzeTypes;
 };
 
-export { type AnalyzeTypesOptions, type AnyType, 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, CONFIG_FILE_NAMES, type CallExpression, type CallStatement, type ClassInfo, type CompoundAssignmentStatement, type ConditionalType, type ConditionalTypeNode, type ConfigLookup, type ConfigProblem, type ContinueStatement, type DeclareClassStatement, type DeclareStatement, type DifferenceType, type DifferenceTypeNode, type DoStatement, type EOFToken, type ErrorStatement, type ExportAllStatement, type ExportDefaultStatement, type ExportNamedStatement, type ExportSpecifier, type ExportStatement, type ExportTypeAliasStatement, type ExportedType, type Expression, 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 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, LexError, type LiteralToken, type LiteralType, type LuautConfig, type MappedType, type MappedTypeNode, type MemberExpression, type MethodCallExpression, type ModuleExports, type NeverType, type NilLiteral, type Node, type NumberLiteral, type NumericForStatement, type ObjectPattern, type ObjectPatternProperty, type ObjectProperty, type ObjectType, type OperatorToken, Operators, 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 SourceMapNode, type SourceMapOptions, type SourceMapTypes, type SpreadElement, type Statement, type StringLiteral, type TableExpression, type TableField, type TableTypeNode, type TableTypeProperty, type TemplateLiteralType, type TemplateLiteralTypeNode, type Token, 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 TypePackNode, type TypeParamType, type TypePredicate, type TypePredicateNode, type TypeReference, type TypedIdentifier, type TypeofTypeNode, type UnaryExpression, UnaryOperators, type UnionType, type UnionTypeNode, type UnknownType, type VarargExpression, type VariableDeclaration, type VariadicTypeNode, type WhileStatement, analyzeScopes, analyzeTypes, anyType, arrayOf, booleanType, bufferType, containsTypeParam, luautparser as default, difference, equalTypes, falsyType, findConfig, fn, formatType, getBinding, intersection, isAssignable, isClassType, isGlobal, isPossiblyFalsy, isPossiblyTruthy, isUnassignedGlobal, literal, loadConfig, luautparser, matchInfer, moduleCandidates, moduleExports, narrowExclude, narrowFalsy, narrowTo, narrowTruthy, neverType, nilType, nodeHost, numberType, objectType, optional, overlaps, parse, parseExpressionFromSource, parseTokens, parseWithRecovery, primitive, resolveModulePath, resolveTypeLibraries, setAliasExpander, sourceMapTypes, stringType, stripJsonComments, substitute, templateMatches, threadType, tokenize, tuple, typeParam, unify, union, unknownType, widen };
+export { type AnalyzeTypesOptions, type AnyType, 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, CONFIG_FILE_NAMES, type CallExpression, type CallStatement, type ClassInfo, type CompoundAssignmentStatement, type ConditionalType, type ConditionalTypeNode, type ConfigLookup, type ConfigProblem, type ContinueStatement, type DeclareClassStatement, 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 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 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, LexError, type LiteralToken, type LiteralType, type LoweringModule, type LoweringPlugin, type LuautConfig, 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 TableExpression, type TableField, type TableTypeNode, type TableTypeProperty, type TemplateLiteralType, type TemplateLiteralTypeNode, 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 TypePackNode, type TypeParamType, type TypePredicate, type TypePredicateNode, type TypeReference, type TypedIdentifier, type TypeofTypeNode, UNUSED_EXPECT_ERROR, type UnaryExpression, UnaryOperators, type UnionType, type UnionTypeNode, type UnknownType, type VarargExpression, type VariableDeclaration, type VariadicTypeNode, type WhileStatement, analyzeScopes, analyzeTypes, anyType, applyDirectives, arrayOf, booleanType, bufferType, containsTypeParam, luautparser as default, difference, directivesOf, equalTypes, falsyType, findConfig, fn, formatType, getBinding, intersection, isAssignable, isClassType, isGlobal, isPossiblyFalsy, isPossiblyTruthy, isUnassignedGlobal, literal, loadConfig, luautparser, matchInfer, moduleCandidates, moduleExports, narrowExclude, narrowFalsy, narrowTo, narrowTruthy, neverType, nilType, nodeHost, numberType, objectType, optional, overlaps, parse, parseExpressionFromSource, parseTokens, parseWithRecovery, primitive, readDirectives, resolveModulePath, resolveTypeLibraries, setAliasExpander, sourceMapTypes, stringType, stripJsonComments, substitute, templateMatches, threadType, tokenize, tuple, typeParam, unify, union, unknownType, widen };