Statements

pub enum Stmt {
    /// An assignment, such as `x = 1`
    Assignment(Assignment),
    
    /// A do block, `do end`
    Do(Do),
    
    /// A function call on its own, such as `call()`
    FunctionCall(FunctionCall),
    
    /// A function declaration, such as `function x() end`
    FunctionDeclaration(FunctionDeclaration),
    
    /// A generic for loop, such as `for index, value in pairs(list) do end`
    GenericFor(GenericFor),
    
    /// An if statement
    If(If),
    
    /// A local assignment, such as `local x = 1`
    LocalAssignment(LocalAssignment),
    
    /// A local function declaration, such as `local function x() end`
    LocalFunction(LocalFunction),
    
    /// A numeric for loop, such as `for index = 1, 10 do end`
    NumericFor(NumericFor),
    
    /// A repeat loop
    Repeat(Repeat),
    
    /// A while loop
    While(While),
    
    /// A compound assignment, such as `+=` (Luau/CFX Lua only)
    #[cfg(any(feature = "luau", feature = "cfxlua"))]
    CompoundAssignment(CompoundAssignment),
    
    /// An exported type declaration, such as `export type Meters = number` (Luau only)
    #[cfg(feature = "luau")]
    ExportedTypeDeclaration(ExportedTypeDeclaration),
    
    /// A type declaration, such as `type Meters = number` (Luau only)
    #[cfg(feature = "luau")]
    TypeDeclaration(TypeDeclaration),
    
    /// An exported type function (Luau only)
    #[cfg(feature = "luau")]
    ExportedTypeFunction(ExportedTypeFunction),
    
    /// A type function (Luau only)
    #[cfg(feature = "luau")]
    TypeFunction(TypeFunction),
    
    /// A goto statement, such as `goto label` (Lua 5.2/LuaJIT only)
    #[cfg(any(feature = "lua52", feature = "luajit"))]
    Goto(Goto),
    
    /// A label, such as `::label::` (Lua 5.2/LuaJIT only)
    #[cfg(any(feature = "lua52", feature = "luajit"))]
    Label(Label),
}

pub struct Assignment {
    var_list: Punctuated<Var>,
    equal_token: TokenReference,
    expr_list: Punctuated<Expression>,
}

pub fn new(var_list: Punctuated<Var>, expr_list: Punctuated<Expression>) -> Self

pub fn expressions(&self) -> &Punctuated<Expression>

pub fn equal_token(&self) -> &TokenReference

pub fn variables(&self) -> &Punctuated<Var>

pub fn with_variables(self, var_list: Punctuated<Var>) -> Self
pub fn with_equal_token(self, equal_token: TokenReference) -> Self
pub fn with_expressions(self, expr_list: Punctuated<Expression>) -> Self

pub struct LocalAssignment {
    local_token: TokenReference,
    #[cfg(feature = "luau")]
    type_specifiers: Vec<Option<TypeSpecifier>>,
    name_list: Punctuated<TokenReference>,
    #[cfg(feature = "lua54")]
    attributes: Vec<Option<Attribute>>,
    equal_token: Option<TokenReference>,
    expr_list: Punctuated<Expression>,
}

pub fn new(name_list: Punctuated<TokenReference>) -> Self

pub fn local_token(&self) -> &TokenReference
pub fn equal_token(&self) -> Option<&TokenReference>
pub fn expressions(&self) -> &Punctuated<Expression>
pub fn names(&self) -> &Punctuated<TokenReference>

#[cfg(feature = "luau")]
pub fn type_specifiers(&self) -> impl Iterator<Item = Option<&TypeSpecifier>>

#[cfg(any(feature = "lua54", feature = "cfxlua"))]
pub fn attributes(&self) -> impl Iterator<Item = Option<&Attribute>>

pub struct FunctionDeclaration {
    #[cfg(feature = "luau")]
    attributes: Vec<LuauAttribute>,
    function_token: TokenReference,
    name: FunctionName,
    body: FunctionBody,
}

pub fn new(name: FunctionName) -> Self

#[cfg(feature = "luau")]
pub fn attributes(&self) -> impl Iterator<Item = &LuauAttribute>
pub fn function_token(&self) -> &TokenReference
pub fn body(&self) -> &FunctionBody
pub fn name(&self) -> &FunctionName

pub struct LocalFunction {
    #[cfg(feature = "luau")]
    attributes: Vec<LuauAttribute>,
    local_token: TokenReference,
    function_token: TokenReference,
    name: TokenReference,
    body: FunctionBody,
}

pub fn new(name: TokenReference) -> Self

#[cfg(feature = "luau")]
pub fn attributes(&self) -> impl Iterator<Item = &LuauAttribute>
pub fn local_token(&self) -> &TokenReference
pub fn function_token(&self) -> &TokenReference
pub fn body(&self) -> &FunctionBody
pub fn name(&self) -> &TokenReference

pub struct If {
    if_token: TokenReference,
    condition: Expression,
    then_token: TokenReference,
    block: Block,
    else_if: Option<Vec<ElseIf>>,
    else_token: Option<TokenReference>,
    r#else: Option<Block>,
    end_token: TokenReference,
}

pub fn new(condition: Expression) -> Self

pub fn if_token(&self) -> &TokenReference
pub fn condition(&self) -> &Expression
pub fn then_token(&self) -> &TokenReference
pub fn block(&self) -> &Block
pub fn else_token(&self) -> Option<&TokenReference>
pub fn else_if(&self) -> Option<&Vec<ElseIf>>
pub fn else_block(&self) -> Option<&Block>
pub fn end_token(&self) -> &TokenReference

pub struct While {
    while_token: TokenReference,
    condition: Expression,
    do_token: TokenReference,
    block: Block,
    end_token: TokenReference,
}

pub fn new(condition: Expression) -> Self
pub fn while_token(&self) -> &TokenReference
pub fn condition(&self) -> &Expression
pub fn do_token(&self) -> &TokenReference
pub fn block(&self) -> &Block
pub fn end_token(&self) -> &TokenReference

pub struct Repeat {
    repeat_token: TokenReference,
    block: Block,
    until_token: TokenReference,
    until: Expression,
}

pub fn new(until: Expression) -> Self
pub fn repeat_token(&self) -> &TokenReference
pub fn block(&self) -> &Block
pub fn until_token(&self) -> &TokenReference
pub fn until(&self) -> &Expression

pub struct NumericFor {
    for_token: TokenReference,
    index_variable: TokenReference,
    equal_token: TokenReference,
    start: Expression,
    start_end_comma: TokenReference,
    end: Expression,
    end_step_comma: Option<TokenReference>,
    step: Option<Expression>,
    do_token: TokenReference,
    block: Block,
    end_token: TokenReference,
    #[cfg(feature = "luau")]
    type_specifier: Option<TypeSpecifier>,
}

pub struct GenericFor {
    for_token: TokenReference,
    names: Punctuated<TokenReference>,
    in_token: TokenReference,
    expr_list: Punctuated<Expression>,
    do_token: TokenReference,
    block: Block,
    end_token: TokenReference,
    #[cfg(feature = "luau")]
    type_specifiers: Vec<Option<TypeSpecifier>>,
}

pub struct Do {
    do_token: TokenReference,
    block: Block,
    end_token: TokenReference,
}

pub fn new() -> Self
pub fn do_token(&self) -> &TokenReference
pub fn block(&self) -> &Block
pub fn end_token(&self) -> &TokenReference