A 1-based source position in the original input.
@eryx/luau/ast Module
Type stubs for the Luau AST shape produced by src/modules/luau/native.cpp.
API Reference
Types
Position
line: number
The 1-based source line number.
column: number
The 1-based source column number.
Location
A 1-based, half-open source span in the original input.
beginline: number
The 1-based line where the span begins.
begincolumn: number
The 1-based column where the span begins.
endline: number
The 1-based line where the span ends.
endcolumn: number
The 1-based column where the span ends.
CstToken<Text>
A concrete syntax token captured from the CST.
type: "token"
Identifies this table as a concrete syntax token.
text: Text
The exact source text of the token, including raw literal spelling such as 0x10.
The span of the token itself, excluding leading and trailing trivia.
leadingText: string
Trivia immediately before this token, such as whitespace and comments.
trailingText: string
Trivia immediately after this token, such as whitespace and comments.
AstNode<Category, Type>
Shared fields present on every serialized AST node.
category: Category
The broad AST family this node belongs to.
type: Type
The specific node kind within the category.
The source span covered by the AST node.
AstStatNode<Type>
Shared fields present on every statement node.
type AstStatNode<Type> = AstNode<"stat", Type> & { hasSemicolon: boolean, semicolonToken: CstToken<";">? }
Implements: AstNode
hasSemicolon: boolean
True when the statement was terminated by an explicit semicolon.
The trailing semicolon token after this statement, when one was present.
TableAccess
The read/write access qualifier for table and extern type entries.
AstLocal
A local binding referenced by declarations and local expressions.
Implements: AstNode
name: string
The local variable name.
The identifier token that introduced or referenced this local.
The source span of the local identifier.
The local declaration shadowed by this local, if one exists.
functionDepth: number
The function nesting depth where the local is declared.
loopDepth: number
The loop nesting depth where the local is declared.
isConst: boolean
True when the local is const.
isExported: boolean
True when this local came from an exported declaration.
The type annotation attached to the local declaration.
TypeOrPack
A type argument item that can be either a type, a type pack, or an absent placeholder.
type TypeOrPack = { kind: "Type", value: AstType }
| { kind: "TypePack", value: AstTypePack }
| { kind: "None" }
TypeList
A list of types with an optional trailing type pack.
Positional type entries.
The trailing type pack, when the list ends with one.
ArgumentName
The optional source name for a function parameter type.
name: string
The parameter name text.
The source span of the parameter name.
TableIndexer
A table indexer type, such as {[K]: V}.
type TableIndexer = {
indexType: AstType,
resultType: AstType,
location: Location,
access: TableAccess,
accessLocation: Location?
}
The type used as the index key.
The type produced by the indexer.
The full source span of the indexer entry.
The optional read/write access mode.
The source span of the access qualifier, when present.
AstAttr
A function or declaration attribute such as @native or @deprecated.
type AstAttr = AstAttrNode<"attribute"> & {
attrType: "Checked" | "Native" | "Deprecated" | "DebugNoinline" | "Unknown",
name: string,
nameToken: CstToken<string>,
args: { AstExpr },
deprecatedInfo: { deprecated: boolean, use: string?, reason: string? }?
}
Implements: AstAttrNode
attrType: "Checked" | "Native" | "Deprecated" | "DebugNoinline" | "Unknown"
The normalized attribute kind.
name: string
The attribute name without the @ prefix.
The attribute name token after @.
Attribute argument expressions inside the argument list.
deprecatedInfo: { deprecated: boolean, use: string?, reason: string? }?
Parsed @deprecated payload, when available.
AstGenericType
A named generic type parameter.
type AstGenericType = AstGenericNode<"type"> & {
name: string,
nameToken: CstToken<string>,
default: AstType?,
defaultEqualsToken: CstToken<"=">?
}
Implements: AstGenericNode
name: string
The generic parameter name.
The generic parameter identifier token.
The default type after =, when present.
The = token before the default type.
AstGenericTypePack
A named generic type-pack parameter.
type AstGenericTypePack = AstGenericNode<"typePack"> & {
name: string,
nameToken: CstToken<string>,
ellipsisToken: CstToken<"...">?,
default: AstTypePack?,
defaultEqualsToken: CstToken<"=">?
}
Implements: AstGenericNode
name: string
The generic pack parameter name.
The generic pack identifier token.
The ... token that marks this generic as a type pack.
The default type pack after =, when present.
The = token before the default type pack.
AstExprGroup
A parenthesized expression.
type AstExprGroup = AstExprNode<"group"> & {
openParenToken: CstToken<"(">,
expr: AstExpr,
closeParenToken: CstToken<")">
}
Implements: AstExprNode
The opening ( token.
The expression inside the parentheses.
The closing ) token.
AstExprConstantBool
A boolean literal expression.
type AstExprConstantBool = AstExprNode<"constantBool"> & { value: boolean, token: CstToken<"true" | "false"> }
Implements: AstExprNode
value: boolean
The parsed boolean value.
The true or false keyword token.
AstExprConstantNumber
A floating point number literal expression.
type AstExprConstantNumber = AstExprNode<"constantNumber"> & { value: number, token: CstToken<string> }
Implements: AstExprNode
value: number
The parsed numeric value.
The exact number literal token, preserving raw spelling.
AstExprConstantInteger
An integer literal expression.
type AstExprConstantInteger = AstExprNode<"constantInteger"> & { value: number, token: CstToken<string> }
Implements: AstExprNode
value: number
The parsed integer value.
The exact integer literal token, preserving raw spelling.
AstExprConstantString
A string literal expression.
type AstExprConstantString = AstExprNode<"constantString"> & {
value: string,
quoteStyle: "simple" | "single" | "raw" | "unquoted" | "unknown",
isQuoted: boolean,
token: CstToken<string>
}
Implements: AstExprNode
value: string
The decoded string value.
quoteStyle: "simple" | "single" | "raw" | "unquoted" | "unknown"
The serializer's description of the source quote style.
isQuoted: boolean
True when the literal was written with quotes in source.
The exact string literal token, preserving raw spelling.
AstExprLocal
A reference to a local binding.
type AstExprLocal = AstExprNode<"local"> & { local: AstLocal, upvalue: boolean, nameToken: CstToken<string> }
Implements: AstExprNode
The local binding object being referenced.
upvalue: boolean
True when the referenced local is captured from an outer function.
The identifier token at this reference site.
AstExprGlobal
A reference to a global binding.
Implements: AstExprNode
name: string
The global name.
The global identifier token.
AstExprCall
A function or method call expression.
Implements: AstExprNode
The expression being called.
Explicit type arguments passed with <<...>>.
Runtime argument expressions.
self: boolean
True when this is a method-style self call.
The source span covering the argument syntax.
The first < token in an explicit << type argument list.
The second < token in an explicit << type argument list.
The first > token in an explicit >> type argument list.
The second > token in an explicit >> type argument list.
The opening ( token for parenthesized call arguments.
The closing ) token for parenthesized call arguments.
AstExprIndexName
A field or method-name indexing expression, such as a.b or a:b.
type AstExprIndexName = AstExprNode<"indexName"> & {
expr: AstExpr,
index: string,
indexLocation: Location,
opPosition: Position,
opToken: CstToken<"." | ":">,
indexToken: CstToken<string>
}
Implements: AstExprNode
The table or object expression being indexed.
index: string
The field or method name.
The source span of the field or method name.
The source position of the . or : operator.
The . or : token.
The identifier token after the . or : operator.
AstExprIndexExpr
A bracket indexing expression, such as a[b].
type AstExprIndexExpr = AstExprNode<"indexExpr"> & {
expr: AstExpr,
index: AstExpr,
openBracketToken: CstToken<"[">,
closeBracketToken: CstToken<"]">
}
Implements: AstExprNode
The table or object expression being indexed.
The expression inside the brackets.
The opening [ token.
The closing ] token.
AstExprFunction
A function expression.
Implements: AstExprNode
Attributes applied to the function.
Generic type parameters.
Generic type-pack parameters.
The implicit self local for method functions.
Function parameter locals.
The annotated return type pack.
vararg: boolean
True when the function accepts varargs.
The source span of the vararg marker.
The annotated vararg type pack.
The function body block.
functionDepth: number
The function nesting depth.
debugname: string
The debug name inferred by the parser.
The source span of the parameter list.
The function keyword token for full function expressions and declarations.
The opening < token for generic parameters.
The closing > token for generic parameters.
The opening ( token for the parameter list.
The closing ) token for the parameter list.
The ... token for vararg parameters.
The : token before the return annotation.
The end keyword token closing the function body.
AstExprTableItem
An item inside a table constructor.
kind: "list" | "record" | "general"
The table item form: array item, name record, or bracketed key record.
The key expression for keyed entries.
The value expression stored in the table.
AstExprTable
A table constructor expression.
Implements: AstExprNode
Table entries in source order.
The opening { token.
The closing } token.
AstExprUnary
A unary operator expression.
Implements: AstExprNode
op: string
The normalized unary operator name.
The operand expression.
The unary operator token, such as not, -, or #.
AstExprBinary
A binary operator expression.
type AstExprBinary = AstExprNode<"binary"> & { op: string, left: AstExpr, right: AstExpr, opToken: CstToken<string> }
Implements: AstExprNode
op: string
The normalized binary operator name.
The left operand.
The right operand.
The binary operator token, such as +, and, or ==.
AstExprTypeAssertion
A type assertion expression.
type AstExprTypeAssertion = AstExprNode<"typeAssertion"> & { expr: AstExpr, annotation: AstType, opToken: CstToken<"::"> }
Implements: AstExprNode
The expression being asserted.
The asserted type annotation.
The :: token.
AstExprIfElse
An if expression.
type AstExprIfElse = AstExprNode<"ifElse"> & {
condition: AstExpr,
thenExpr: AstExpr?,
elseExpr: AstExpr?,
ifKeywordToken: CstToken<"if" | "elseif">?,
thenKeywordToken: CstToken<"then">?,
elseKeywordToken: CstToken<"else" | "elseif">?
}
Implements: AstExprNode
The condition expression.
The expression after then.
The expression after else.
The if token, or elseif token for chained branches represented as nested nodes.
The then keyword token.
The else or elseif keyword token.
AstExprInterpString
An interpolated string expression.
Implements: AstExprNode
strings: { string }
Literal string segments between interpolation holes.
Expressions inside interpolation holes.
AstExprInstantiate
An expression with explicit type instantiation.
Implements: AstExprNode
The expression being instantiated.
The explicit type and type-pack arguments.
The first < token in the opening <<.
The second < token in the opening <<.
The first > token in the closing >>.
The second > token in the closing >>.
AstExprError
An expression placeholder produced for parse errors.
type AstExprError = AstExprNode<"error"> & {
expressions: { AstExpr },
messageIndex: number,
spanToken: CstToken<string>
}
Implements: AstExprNode
Child expressions retained by the parser around the error.
messageIndex: number
Index into the parser error list for the associated diagnostic.
The concrete source span token synthesized for the error range.
AstStatBlock
A statement block.
Implements: AstStatNode
Statements in the block.
The zero-width end-of-file token for the root block, when emitted.
AstStatIf
An if statement.
type AstStatIf = AstStatNode<"if"> & {
condition: AstExpr,
thenBody: AstStatBlock,
elseBody: AstStatBlock?,
thenLocation: Location?,
elseLocation: Location?,
ifKeywordToken: CstToken<"if">?,
thenKeywordToken: CstToken<"then">?,
elseKeywordToken: CstToken<"else" | "elseif">?,
endKeywordToken: CstToken<"end">
}
Implements: AstStatNode
The condition expression.
The block executed when the condition is truthy.
The else or elseif block.
The source span of the then keyword.
The source span of the else keyword.
The if keyword token. Nested elseif nodes omit this because their parent owns the elseif token.
The then keyword token.
The else or elseif keyword token.
The end keyword token closing the statement.
AstStatWhile
A while loop statement.
type AstStatWhile = AstStatNode<"while"> & {
condition: AstExpr,
body: AstStatBlock,
doLocation: Location?,
whileKeywordToken: CstToken<"while">,
doKeywordToken: CstToken<"do">?,
endKeywordToken: CstToken<"end">
}
Implements: AstStatNode
The loop condition expression.
The loop body block.
The source span of the do keyword.
The while keyword token.
The do keyword token.
The end keyword token closing the loop.
AstStatRepeat
A repeat-until loop statement.
type AstStatRepeat = AstStatNode<"repeat"> & {
body: AstStatBlock,
condition: AstExpr,
repeatKeywordToken: CstToken<"repeat">,
untilKeywordToken: CstToken<"until">
}
Implements: AstStatNode
The repeated body block.
The condition expression after until.
The repeat keyword token.
The until keyword token.
AstStatReturn
A return statement.
Implements: AstStatNode
Returned expression list.
The return keyword token.
AstStatExpr
A statement that consists of a single expression.
Implements: AstStatNode
The expression being used as a statement.
AstStatLocal
A local variable declaration statement.
Implements: AstStatNode
Declared local bindings.
Initializer expressions after =.
isConst: boolean
True when the declaration uses const.
The source span of the = token.
The local or const declaration keyword token.
The = token before initializer expressions.
AstStatFor
A numeric for loop statement.
type AstStatFor = AstStatNode<"for"> & {
var: AstLocal,
from: AstExpr,
to: AstExpr,
step: AstExpr?,
body: AstStatBlock,
doLocation: Location?,
forKeywordToken: CstToken<"for">,
equalsToken: CstToken<"=">,
endCommaToken: CstToken<",">,
stepCommaToken: CstToken<",">?,
doKeywordToken: CstToken<"do">?,
endKeywordToken: CstToken<"end">
}
Implements: AstStatNode
The loop variable local.
The initial value expression.
The limit value expression.
The optional step expression.
The loop body block.
The source span of the do keyword.
The for keyword token.
The = token after the loop variable.
The comma token between the initial and limit expressions.
The comma token before the step expression.
The do keyword token.
The end keyword token closing the loop.
AstStatForIn
A generic for-in loop statement.
Implements: AstStatNode
Loop variable locals.
Iterator expressions after in.
The loop body block.
The source span of the in keyword.
The source span of the do keyword.
The for keyword token.
The in keyword token.
The do keyword token.
The end keyword token closing the loop.
AstStatAssign
An assignment statement.
Implements: AstStatNode
Assignment target expressions.
Value expressions.
The = token between targets and values.
AstStatCompoundAssign
A compound assignment statement.
type AstStatCompoundAssign = AstStatNode<"compoundAssign"> & { op: string, var: AstExpr, value: AstExpr, opToken: CstToken<string> }
Implements: AstStatNode
op: string
The normalized compound operator name.
The assignment target expression.
The value expression.
The compound assignment operator token, such as += or ..=.
AstStatFunction
A global or table function declaration statement.
type AstStatFunction = AstStatNode<"function"> & {
name: AstExpr,
func: AstExprFunction,
functionKeywordToken: CstToken<"function">
}
Implements: AstStatNode
The function name expression.
The function body expression node.
The function keyword token that starts the declaration.
AstStatLocalFunction
A local function declaration statement.
type AstStatLocalFunction = AstStatNode<"localFunction"> & {
name: AstLocal,
func: AstExprFunction,
isConst: boolean,
localKeywordToken: CstToken<"local">,
functionKeywordToken: CstToken<"function">,
nameToken: CstToken<string>
}
Implements: AstStatNode
The declared local function binding.
The function body expression node.
isConst: boolean
True when the local function declaration is const.
The local keyword token.
The function keyword token.
The local function name identifier token.
AstStatTypeAlias
A type alias declaration statement.
type AstStatTypeAlias = AstStatNode<"typeAlias"> & {
name: string,
nameLocation: Location,
generics: { AstGenericType },
genericPacks: { AstGenericTypePack },
aliasedType: AstType,
exported: boolean,
exportKeywordToken: CstToken<"export">?,
typeKeywordToken: CstToken<"type">,
nameToken: CstToken<string>,
equalsToken: CstToken<"=">
}
Implements: AstStatNode
name: string
The alias name.
The source span of the alias name.
Generic type parameters.
Generic type-pack parameters.
The aliased type.
exported: boolean
True when this is an exported type alias.
The export keyword token.
The type keyword token.
The alias name identifier token.
The = token before the aliased type.
AstStatTypeFunction
A type function declaration statement.
type AstStatTypeFunction = AstStatNode<"typeFunction"> & {
name: string,
nameLocation: Location,
body: AstExprFunction?,
exported: boolean,
hasErrors: boolean,
exportKeywordToken: CstToken<"export">?,
typeKeywordToken: CstToken<"type">,
functionKeywordToken: CstToken<"function">,
nameToken: CstToken<string>
}
Implements: AstStatNode
name: string
The type function name.
The source span of the type function name.
The function body, when the parser produced one.
exported: boolean
True when this is an exported type function.
hasErrors: boolean
True when the parser reported errors inside this declaration.
The export keyword token.
The type keyword token.
The function keyword token.
The type function name identifier token.
AstClassMember
A member entry in a class declaration.
type AstClassMember = {
kind: "property",
qualifierLocation: Location?,
name: string,
nameLocation: Location,
typeColonLocation: Location?,
type: AstType?
}
| {
kind: "method",
qualifierLocation: Location?,
keywordLocation: Location,
name: string,
nameLocation: Location,
function: AstExprFunction
}
AstStatClass
A class declaration statement.
Implements: AstStatNode
The class local binding.
Class property and method members.
exported: boolean
True when this is an exported class declaration.
The export keyword token.
The class keyword token.
The class name identifier token.
The end keyword token closing the class declaration.
AstStatDeclareGlobal
A declare global statement.
type AstStatDeclareGlobal = AstStatNode<"declareGlobal"> & {
name: string,
nameLocation: Location,
declaredType: AstType,
declareKeywordToken: CstToken<"declare">,
nameToken: CstToken<string>,
colonToken: CstToken<":">?
}
Implements: AstStatNode
name: string
The declared global name.
The source span of the global name.
The declared global type.
The declare keyword token.
The global name identifier token.
The : token before the declared type.
AstStatDeclareFunction
A declare function statement.
type AstStatDeclareFunction = AstStatNode<"declareFunction"> & {
attributes: { AstAttr },
name: string,
nameLocation: Location,
generics: { AstGenericType },
genericPacks: { AstGenericTypePack },
params: TypeList,
paramNames: { ArgumentName },
vararg: boolean,
varargLocation: Location,
returnTypes: AstTypePack?,
declareKeywordToken: CstToken<"declare">,
functionKeywordToken: CstToken<"function">?,
nameToken: CstToken<string>
}
Implements: AstStatNode
Attributes applied to the declaration.
name: string
The declared function name.
The source span of the declared function name.
Generic type parameters.
Generic type-pack parameters.
Parameter types.
Optional parameter names.
vararg: boolean
True when the declaration accepts varargs.
The source span of the vararg marker.
Return type pack.
The declare keyword token.
The function keyword token.
The function name identifier token.
DeclaredExternTypeProperty
A property inside a declared extern type.
type DeclaredExternTypeProperty = {
name: string,
nameLocation: Location,
type: AstType?,
isMethod: boolean,
access: TableAccess,
location: Location
}
name: string
The extern property name.
The source span of the property name.
The property type.
isMethod: boolean
True when the property is declared as a method.
The optional read/write access mode.
The full source span of the property declaration.
AstStatDeclareExternType
A declare extern type statement.
type AstStatDeclareExternType = AstStatNode<"declareExternType"> & {
name: string,
superName: string?,
props: { DeclaredExternTypeProperty },
indexer: TableIndexer?,
declareKeywordToken: CstToken<"declare">,
endKeywordToken: CstToken<"end">
}
Implements: AstStatNode
name: string
The declared extern type name.
superName: string?
The optional supertype name.
Declared properties.
Optional indexer declaration.
The declare keyword token.
The end keyword token closing the extern type.
AstStatError
A statement placeholder produced for parse errors.
type AstStatError = AstStatNode<"error"> & {
expressions: { AstExpr },
statements: { AstStat },
messageIndex: number,
spanToken: CstToken<string>
}
Implements: AstStatNode
Child expressions retained by the parser around the error.
Child statements retained by the parser around the error.
messageIndex: number
Index into the parser error list for the associated diagnostic.
The concrete source span token synthesized for the error range.
AstTypeReference
A named type reference, optionally with a prefix and type arguments.
Implements: AstTypeNode
hasParameterList: boolean
True when source explicitly included a parameter list.
name: string
The referenced type name.
The source span of the referenced type name.
prefix: string?
The optional prefix before a dot.
The source span of the optional prefix.
Type and type-pack arguments inside <...>.
The prefix identifier token before the dot.
The . token between prefix and name.
The referenced type name identifier token.
The opening < token for type parameters.
The closing > token for type parameters.
AstTypeTableProp
A named property inside a table type.
type AstTypeTableProp = {
name: string,
type: AstType,
location: Location,
access: TableAccess,
accessLocation: Location?
}
name: string
The property name.
The property type.
The full source span of the property entry.
The optional read/write access mode.
The source span of the access qualifier, when present.
AstTypeTable
A table type.
Implements: AstTypeNode
Named property entries.
Optional indexer entry.
The opening { token.
The closing } token.
AstTypeFunction
A function type.
Implements: AstTypeNode
Attributes applied to the function type.
Generic type parameters.
Generic type-pack parameters.
Argument type list.
Optional argument names paired with argument types.
Return type pack after ->.
The opening < token for generic parameters.
The closing > token for generic parameters.
The opening ( token for argument types.
The closing ) token for argument types.
The -> token before return types.
AstTypeTypeof
A typeof type expression.
type AstTypeTypeof = AstTypeNode<"typeof"> & {
expr: AstExpr,
typeofKeywordToken: CstToken<"typeof">,
openParenToken: CstToken<"(">?,
closeParenToken: CstToken<")">?
}
Implements: AstTypeNode
The expression inside typeof(...).
The typeof keyword token.
The opening ( token.
The closing ) token.
AstTypeOptional
An optional type, such as T?.
Implements: AstTypeNode
The ? token after the base type.
AstTypeUnion
A union type.
Implements: AstTypeNode
Type branches in the union.
A leading | token when the union starts with one.
AstTypeIntersection
An intersection type.
Implements: AstTypeNode
Type branches in the intersection.
A leading & token when the intersection starts with one.
AstTypeError
A type placeholder produced for parse errors.
type AstTypeError = AstTypeNode<"error"> & {
types: { AstType },
isMissing: boolean,
messageIndex: number,
spanToken: CstToken<string>
}
Implements: AstTypeNode
Child types retained by the parser around the error.
isMissing: boolean
True when the type node represents a missing type.
messageIndex: number
Index into the parser error list for the associated diagnostic.
The concrete source span token synthesized for the error range.
AstTypeSingletonBool
A singleton boolean type.
type AstTypeSingletonBool = AstTypeNode<"singletonBool"> & { value: boolean, token: CstToken<"true" | "false"> }
Implements: AstTypeNode
value: boolean
The parsed boolean value.
The true or false token.
AstTypeSingletonString
A singleton string type.
type AstTypeSingletonString = AstTypeNode<"singletonString"> & { value: string, token: CstToken<string> }
Implements: AstTypeNode
value: string
The decoded string value.
The exact string literal token, preserving raw spelling.
AstTypeGroup
A parenthesized type.
type AstTypeGroup = AstTypeNode<"group"> & {
innerType: AstType,
openParenToken: CstToken<"(">,
closeParenToken: CstToken<")">
}
Implements: AstTypeNode
The type inside the parentheses.
The opening ( token.
The closing ) token.
AstTypePackExplicit
An explicit type pack.
Implements: AstTypePackNode
The contained type list.
The opening ( token around the pack.
The closing ) token around the pack.
AstTypePackVariadic
A variadic type pack.
type AstTypePackVariadic = AstTypePackNode<"variadic"> & { variadicType: AstType, ellipsisToken: CstToken<"..."> }
Implements: AstTypePackNode
The repeated type.
The ... token before or after the variadic type, depending on source form.
AstTypePackGeneric
A generic type-pack reference.
type AstTypePackGeneric = AstTypePackNode<"generic"> & {
name: string,
nameToken: CstToken<string>,
ellipsisToken: CstToken<"...">?
}
Implements: AstTypePackNode
name: string
The generic pack name.
The generic pack identifier token.
The ... token associated with the generic pack spelling.
AstTypePackUnknown
An unknown type-pack placeholder.
Implements: AstTypePackNode
The token that produced the unknown type pack.
AstTypeUnknown
An unknown type placeholder.
Implements: AstTypeNode
The token that produced the unknown type.
AstExpr
Any expression node emitted by the serializer.
type AstExpr = AstExprGroup
| AstExprConstantNil
| AstExprConstantBool
| AstExprConstantNumber
| AstExprConstantInteger
| AstExprConstantString
| AstExprLocal
| AstExprGlobal
| AstExprVarargs
| AstExprCall
| AstExprIndexName
| AstExprIndexExpr
| AstExprFunction
| AstExprTable
| AstExprUnary
| AstExprBinary
| AstExprTypeAssertion
| AstExprIfElse
| AstExprInterpString
| AstExprInstantiate
| AstExprError
AstStat
Any statement node emitted by the serializer.
type AstStat = AstStatBlock
| AstStatIf
| AstStatWhile
| AstStatRepeat
| AstStatBreak
| AstStatContinue
| AstStatReturn
| AstStatExpr
| AstStatLocal
| AstStatFor
| AstStatForIn
| AstStatAssign
| AstStatCompoundAssign
| AstStatFunction
| AstStatLocalFunction
| AstStatTypeAlias
| AstStatTypeFunction
| AstStatClass
| AstStatDeclareGlobal
| AstStatDeclareFunction
| AstStatDeclareExternType
| AstStatError
AstType
Any type node emitted by the serializer.
AstTypePack
Any type-pack node emitted by the serializer.
AstAny
Any AST payload node emitted by the serializer.
type AstAny = AstExpr
| AstStat
| AstType
| AstTypePack
| AstGenericType
| AstGenericTypePack
| AstAttr