Lua.AST.Builder (Lua v1.0.0-rc.0)
View SourceHelpers for programmatically constructing AST nodes.
Provides a convenient API for building AST without manually creating all the struct fields. Useful for:
- Code generation
- AST transformations
- Testing
- Metaprogramming with quote/unquote
Examples
import Lua.AST.Builder
# Build a simple expression: 2 + 2
binop(:add, number(2), number(2))
# Build a local assignment: local x = 42
local(["x"], [number(42)])
# Build a function: function add(a, b) return a + b end
func_decl("add", ["a", "b"], [
return_stmt([binop(:add, var("a"), var("b"))])
])Summary
Functions
Creates an assignment statement.
Creates a binary operation.
Creates a Block node.
Creates a boolean literal
Creates a break statement
Creates a function call.
Creates a function call statement.
Creates a Chunk node.
Creates a do block.
Creates a generic for loop (for-in).
Creates a numeric for loop.
Creates a function declaration.
Creates a function expression.
Creates a goto statement
Creates an if statement.
Creates an index access (obj[index])
Creates a label
Creates a local variable declaration.
Creates a local function declaration.
Creates a method call (obj:method(args))
Creates a nil literal
Creates a number literal
Creates a property access (obj.prop)
Creates a repeat-until loop.
Creates a return statement.
Creates a string literal
Creates a table constructor.
Creates a unary operation.
Creates a variable reference
Creates a vararg expression (...)
Creates a while loop.
Functions
@spec assign([Lua.AST.Expr.t()], [Lua.AST.Expr.t()], Lua.AST.Meta.t() | nil) :: Lua.AST.Statement.Assign.t()
Creates an assignment statement.
Examples
# x = 10
assign([var("x")], [number(10)])
# x, y = 1, 2
assign([var("x"), var("y")], [number(1), number(2)])@spec binop(atom(), Lua.AST.Expr.t(), Lua.AST.Expr.t(), Lua.AST.Meta.t() | nil) :: Lua.AST.Expr.BinOp.t()
Creates a binary operation.
Operators
:add,:sub,:mul,:div,:floor_div,:mod,:pow:concat:eq,:ne,:lt,:gt,:le,:ge:and,:or
Examples
binop(:add, number(2), number(3)) # 2 + 3
binop(:lt, var("x"), number(10)) # x < 10@spec block([Lua.AST.Statement.t()], Lua.AST.Meta.t() | nil) :: Lua.AST.Block.t()
Creates a Block node.
Examples
block([
local(["x"], [number(10)]),
assign([var("x")], [number(20)])
])@spec bool(boolean(), Lua.AST.Meta.t() | nil) :: Lua.AST.Expr.Bool.t()
Creates a boolean literal
@spec break_stmt(Lua.AST.Meta.t() | nil) :: Lua.AST.Statement.Break.t()
Creates a break statement
@spec call(Lua.AST.Expr.t(), [Lua.AST.Expr.t()], Lua.AST.Meta.t() | nil) :: Lua.AST.Expr.Call.t()
Creates a function call.
Examples
call(var("print"), [string("hello")]) # print("hello")
call(property(var("io"), "write"), [string("test")]) # io.write("test")@spec call_stmt( Lua.AST.Expr.Call.t() | Lua.AST.Expr.MethodCall.t(), Lua.AST.Meta.t() | nil ) :: Lua.AST.Statement.CallStmt.t()
Creates a function call statement.
Examples
call_stmt(call(var("print"), [string("hello")]))@spec chunk([Lua.AST.Statement.t()], Lua.AST.Meta.t() | nil) :: Lua.AST.Chunk.t()
Creates a Chunk node.
Examples
chunk([local(["x"], [number(42)])])@spec do_block([Lua.AST.Statement.t()], Lua.AST.Meta.t() | nil) :: Lua.AST.Statement.Do.t()
Creates a do block.
Examples
# do local x = 10; print(x) end
do_block([
local(["x"], [number(10)]),
call_stmt(call(var("print"), [var("x")]))
])@spec for_in( [String.t()], [Lua.AST.Expr.t()], [Lua.AST.Statement.t()], Lua.AST.Meta.t() | nil ) :: Lua.AST.Statement.ForIn.t()
Creates a generic for loop (for-in).
Examples
# for k, v in pairs(t) do print(k, v) end
for_in(
["k", "v"],
[call(var("pairs"), [var("t")])],
[call_stmt(call(var("print"), [var("k"), var("v")]))]
)@spec for_num( String.t(), Lua.AST.Expr.t(), Lua.AST.Expr.t(), [Lua.AST.Statement.t()], keyword() ) :: Lua.AST.Statement.ForNum.t()
Creates a numeric for loop.
Examples
# for i = 1, 10 do print(i) end
for_num("i", number(1), number(10), [
call_stmt(call(var("print"), [var("i")]))
])
# for i = 1, 10, 2 do print(i) end
for_num("i", number(1), number(10), [...], step: number(2))@spec func_decl( String.t() | [String.t()], [String.t()], [Lua.AST.Statement.t()], keyword() ) :: Lua.AST.Statement.FuncDecl.t()
Creates a function declaration.
Examples
# function add(a, b) return a + b end
func_decl("add", ["a", "b"], [
return_stmt([binop(:add, var("a"), var("b"))])
])
# function math.add(a, b) return a + b end
func_decl(["math", "add"], ["a", "b"], [...])@spec function_expr([String.t()], [Lua.AST.Statement.t()], keyword()) :: Lua.AST.Expr.Function.t()
Creates a function expression.
Examples
# function(x, y) return x + y end
function_expr(["x", "y"], [
return_stmt([binop(:add, var("x"), var("y"))])
])
# function(...) return ... end
function_expr([], [return_stmt([vararg()])], vararg: true)@spec goto_stmt(String.t(), Lua.AST.Meta.t() | nil) :: Lua.AST.Statement.Goto.t()
Creates a goto statement
@spec if_stmt(Lua.AST.Expr.t(), [Lua.AST.Statement.t()], keyword()) :: Lua.AST.Statement.If.t()
Creates an if statement.
Examples
# if x > 0 then print(x) end
if_stmt(
binop(:gt, var("x"), number(0)),
[call_stmt(call(var("print"), [var("x")]))]
)
# if x > 0 then ... elseif x < 0 then ... else ... end
if_stmt(
binop(:gt, var("x"), number(0)),
[call_stmt(...)],
elseif: [{binop(:lt, var("x"), number(0)), [call_stmt(...)]}],
else: [call_stmt(...)]
)@spec index(Lua.AST.Expr.t(), Lua.AST.Expr.t(), Lua.AST.Meta.t() | nil) :: Lua.AST.Expr.Index.t()
Creates an index access (obj[index])
Examples
index(var("t"), number(1)) # t[1]@spec label(String.t(), Lua.AST.Meta.t() | nil) :: Lua.AST.Statement.Label.t()
Creates a label
@spec local([String.t()], [Lua.AST.Expr.t()], Lua.AST.Meta.t() | nil) :: Lua.AST.Statement.Local.t()
Creates a local variable declaration.
Examples
# local x
local(["x"], [])
# local x = 10
local(["x"], [number(10)])
# local x, y = 1, 2
local(["x", "y"], [number(1), number(2)])@spec local_func(String.t(), [String.t()], [Lua.AST.Statement.t()], keyword()) :: Lua.AST.Statement.LocalFunc.t()
Creates a local function declaration.
Examples
# local function add(a, b) return a + b end
local_func("add", ["a", "b"], [
return_stmt([binop(:add, var("a"), var("b"))])
])@spec method_call( Lua.AST.Expr.t(), String.t(), [Lua.AST.Expr.t()], Lua.AST.Meta.t() | nil ) :: Lua.AST.Expr.MethodCall.t()
Creates a method call (obj:method(args))
Examples
method_call(var("file"), "read", [string("*a")]) # file:read("*a")@spec nil_lit(Lua.AST.Meta.t() | nil) :: Lua.AST.Expr.Nil.t()
Creates a nil literal
@spec number(number(), Lua.AST.Meta.t() | nil) :: Lua.AST.Expr.Number.t()
Creates a number literal
@spec property(Lua.AST.Expr.t(), String.t(), Lua.AST.Meta.t() | nil) :: Lua.AST.Expr.Property.t()
Creates a property access (obj.prop)
Examples
property(var("io"), "write") # io.write@spec repeat_stmt([Lua.AST.Statement.t()], Lua.AST.Expr.t(), Lua.AST.Meta.t() | nil) :: Lua.AST.Statement.Repeat.t()
Creates a repeat-until loop.
Examples
# repeat x = x - 1 until x <= 0
repeat_stmt(
[assign([var("x")], [binop(:sub, var("x"), number(1))])],
binop(:le, var("x"), number(0))
)@spec return_stmt([Lua.AST.Expr.t()], Lua.AST.Meta.t() | nil) :: Lua.AST.Statement.Return.t()
Creates a return statement.
Examples
# return
return_stmt([])
# return 42
return_stmt([number(42)])
# return x, y
return_stmt([var("x"), var("y")])@spec string(String.t(), Lua.AST.Meta.t() | nil) :: Lua.AST.Expr.String.t()
Creates a string literal
@spec table( [{:list, Lua.AST.Expr.t()} | {:record, Lua.AST.Expr.t(), Lua.AST.Expr.t()}], Lua.AST.Meta.t() | nil ) :: Lua.AST.Expr.Table.t()
Creates a table constructor.
Field types
{:list, expr}- array-style field (value only){:record, key_expr, value_expr}- key-value field
Examples
# Empty table: {}
table([])
# Array: {1, 2, 3}
table([
{:list, number(1)},
{:list, number(2)},
{:list, number(3)}
])
# Record: {x = 10, y = 20}
table([
{:record, string("x"), number(10)},
{:record, string("y"), number(20)}
])@spec unop(atom(), Lua.AST.Expr.t(), Lua.AST.Meta.t() | nil) :: Lua.AST.Expr.UnOp.t()
Creates a unary operation.
Operators
:not- logical not:neg- negation (-):len- length operator (#)
Examples
unop(:neg, var("x")) # -x
unop(:not, var("flag")) # not flag
unop(:len, var("list")) # #list@spec var(String.t(), Lua.AST.Meta.t() | nil) :: Lua.AST.Expr.Var.t()
Creates a variable reference
@spec vararg(Lua.AST.Meta.t() | nil) :: Lua.AST.Expr.Vararg.t()
Creates a vararg expression (...)
@spec while_stmt(Lua.AST.Expr.t(), [Lua.AST.Statement.t()], Lua.AST.Meta.t() | nil) :: Lua.AST.Statement.While.t()
Creates a while loop.
Examples
# while x > 0 do x = x - 1 end
while_stmt(
binop(:gt, var("x"), number(0)),
[assign([var("x")], [binop(:sub, var("x"), number(1))])]
)