RustQ.Rust.AST.Builder (rustq v0.11.1)

Expression, statement, and simple item constructors for RustQ.Rust.AST.

Alias the focused builders together:

alias RustQ.Rust.AST.Builder, as: A
alias RustQ.Rust.AST.ItemBuilder, as: I
alias RustQ.Rust.AST.PatternBuilder, as: P
alias RustQ.Rust.AST.TypeBuilder, as: T

The main families are:

items — use/1, module/3, const/4, static/4, type_alias/3, impl/2, and macro-item constructors
statements — let/3, assign/2, if_let/4, return_stmt/1, and block-oriented macros such as block/1, match/2, and arm/3
expressions — call/2, path_call/3, method/4, struct_expr/2, constructors such as ok/1, and binary-operation helpers
conversion — expr/1, pat_expr/1, type/1, and path normalization

struct_expr/2 builds a struct literal. Use I.struct/3 for a struct declaration and I.function/3 for a function declaration.

Summary

Functions

add(left, right)

allow_attr(value)

and_(left, right)

arg(name, type)

arm(pattern, opts \\ [], list)

array(values)

assign(target, expression)

assign_op(target, op, expression)

atom(name, opts \\ [])

attr(path, args \\ [])

attr_value(path, value)

badarg()

badarg_arm()

binary(left, op, right)

block(list)

block_expr(body)

break()

break(expression)

byte_string(value)

call(name, args \\ [])

cast(expression, type)

closure(args, body)

const(name, type, expression, opts \\ [])

continue()

deref(expression)

derive(paths)

div(left, right)

early_return(expression)

eq(left, right)

err(expression)

escape_expr(source)

expr(value)

expr_path(path)

field(receiver, field)

flatten(values)

for_(pattern, expression, body)

function_arg(arg)

function_arg(name, type)

function_args(args)

gt(left, right)

gte(left, right)

if_expr(condition, list)

if_expr(condition, then_body, else_body)

if_let(pattern, expression, then_body, opts \\ [])

impl(target, opts \\ [])

index(receiver, index)

let(name, expression, opts \\ [])

let_else(pattern, expression, else_body)

let_mut(name, expression, opts \\ [])

lit(value)

loop(body)

lt(left, right)

lte(left, right)

macro_call(path, args \\ [])

macro_capture(name)

macro_item(source)

macro_item_call(path, args \\ [])

macro_item_token_call(path, tokens)

macro_repeat(tokens, opts \\ [])

macro_rule(pattern, expansion)

macro_rules(name, rules, opts \\ [])

macro_var(name, fragment)

match(expr, list)

match_expr(expression, arms)

maybe_expr(value)

method(receiver, method, args \\ [], opts \\ [])

module(name, items, opts \\ [])

mul(left, right)

mut_ref(expression)

ne(left, right)

neg(expression)

nif_attr(opts \\ [])

none()

not_(expression)

ok()

ok(expression)

or_(left, right)

pat(name)

pat_expr(value)

path(parts)

path(first, second)

path(first, second, third)

path_call(parts, args \\ [], opts \\ [])

path_parts(parts)

path_value(parts)

range(start, stop)

receiver(opts \\ [])

ref(expression)

resource_impl_attr()

return(expression)

return_badarg()

return_stmt(expression)

slice(values)

some(expression)

static(name, type, expression, opts \\ [])

stmt(expression)

struct_expr(path, fields)

sub(left, right)

token_macro(path, tokens)

trait_path(path)

try(expression)

tuple(values)

type(value)

type_alias(name, type, opts \\ [])

type_path(parts_or_part, opts \\ [])

unsafe_block(body)

use(parts)

var(name)

vec(values)

wildcard()

Functions

add(left, right)

allow_attr(value)

and_(left, right)

arg(name, type)

arm(pattern, opts \\ [], list)

(macro)

array(values)

assign(target, expression)

assign_op(target, op, expression)

atom(name, opts \\ [])

attr(path, args \\ [])

attr_value(path, value)

badarg()

badarg_arm()

binary(left, op, right)

block(list)

(macro)

block_expr(body)

break()

break(expression)

byte_string(value)

call(name, args \\ [])

cast(expression, type)

closure(args, body)

const(name, type, expression, opts \\ [])

continue()

deref(expression)

derive(paths)

div(left, right)

early_return(expression)

eq(left, right)

err(expression)

escape_expr(source)

expr(value)

expr_path(path)

field(receiver, field)

flatten(values)

for_(pattern, expression, body)

function_arg(arg)

function_arg(name, type)

function_args(args)

gt(left, right)

gte(left, right)

if_expr(condition, list)

(macro)

if_expr(condition, then_body, else_body)

if_let(pattern, expression, then_body, opts \\ [])

impl(target, opts \\ [])

index(receiver, index)

let(name, expression, opts \\ [])

let_else(pattern, expression, else_body)

let_mut(name, expression, opts \\ [])

lit(value)

loop(body)

lt(left, right)

lte(left, right)

macro_call(path, args \\ [])

macro_capture(name)

macro_item(source)

macro_item_call(path, args \\ [])

macro_item_token_call(path, tokens)

macro_repeat(tokens, opts \\ [])

macro_rule(pattern, expansion)

macro_rules(name, rules, opts \\ [])

macro_var(name, fragment)

match(expr, list)

(macro)

match_expr(expression, arms)

maybe_expr(value)

method(receiver, method, args \\ [], opts \\ [])

module(name, items, opts \\ [])

mul(left, right)

mut_ref(expression)

ne(left, right)

neg(expression)

nif_attr(opts \\ [])

none()

not_(expression)

ok()

ok(expression)

or_(left, right)

pat(name)

pat_expr(value)

path(parts)

path(first, second)

path(first, second, third)

path_call(parts, args \\ [], opts \\ [])

path_parts(parts)

path_value(parts)

range(start, stop)

receiver(opts \\ [])

ref(expression)

resource_impl_attr()

return(expression)

(macro)

return_badarg()

return_stmt(expression)

slice(values)

some(expression)

static(name, type, expression, opts \\ [])

stmt(expression)

struct_expr(path, fields)

sub(left, right)

token_macro(path, tokens)

trait_path(path)

try(expression)

tuple(values)

type(value)

type_alias(name, type, opts \\ [])

type_path(parts_or_part, opts \\ [])