core/odin/ast
odin_ast
Types
103Any_Expr
Any_Expr :: union {
^Bad_Expr,
^Ident,
^Implicit,
^Undef,
^Basic_Lit,
^Basic_Directive,
^Ellipsis,
^Proc_Lit,
^Comp_Lit,
^Tag_Expr,
^Unary_Expr,
^Binary_Expr,
^Paren_Expr,
^Selector_Expr,
^Implicit_Selector_Expr,
^Selector_Call_Expr,
^Index_Expr,
^Deref_Expr,
^Slice_Expr,
^Matrix_Index_Expr,
^Call_Expr,
^Field_Value,
^Ternary_If_Expr,
^Ternary_When_Expr,
^Or_Else_Expr,
^Or_Return_Expr,
^Or_Branch_Expr,
^Type_Assertion,
^Type_Cast,
^Auto_Cast,
^Inline_Asm_Expr,
^Proc_Group,
^Typeid_Type,
^Helper_Type,
^Distinct_Type,
^Poly_Type,
^Proc_Type,
^Pointer_Type,
^Multi_Pointer_Type,
^Array_Type,
^Dynamic_Array_Type,
^Fixed_Capacity_Dynamic_Array_Type,
^Struct_Type,
^Union_Type,
^Enum_Type,
^Bit_Set_Type,
^Map_Type,
^Relative_Type,
^Matrix_Type,
^Bit_Field_Type,
}SourceAny_Node
Any_Node :: union {
^Package,
^File,
^Comment_Group,
^Bad_Expr,
^Ident,
^Implicit,
^Undef,
^Basic_Lit,
^Basic_Directive,
^Ellipsis,
^Proc_Lit,
^Comp_Lit,
^Tag_Expr,
^Unary_Expr,
^Binary_Expr,
^Paren_Expr,
^Selector_Expr,
^Implicit_Selector_Expr,
^Selector_Call_Expr,
^Index_Expr,
^Deref_Expr,
^Slice_Expr,
^Matrix_Index_Expr,
^Call_Expr,
^Field_Value,
^Ternary_If_Expr,
^Ternary_When_Expr,
^Or_Else_Expr,
^Or_Return_Expr,
^Or_Branch_Expr,
^Type_Assertion,
^Type_Cast,
^Auto_Cast,
^Inline_Asm_Expr,
^Proc_Group,
^Typeid_Type,
^Helper_Type,
^Distinct_Type,
^Poly_Type,
^Proc_Type,
^Pointer_Type,
^Multi_Pointer_Type,
^Array_Type,
^Dynamic_Array_Type,
^Fixed_Capacity_Dynamic_Array_Type,
^Struct_Type,
^Union_Type,
^Enum_Type,
^Bit_Set_Type,
^Map_Type,
^Relative_Type,
^Matrix_Type,
^Bit_Field_Type,
^Bad_Stmt,
^Empty_Stmt,
^Expr_Stmt,
^Tag_Stmt,
^Assign_Stmt,
^Block_Stmt,
^If_Stmt,
^When_Stmt,
^Return_Stmt,
^Defer_Stmt,
^For_Stmt,
^Range_Stmt,
^Inline_Range_Stmt,
^Case_Clause,
^Switch_Stmt,
^Type_Switch_Stmt,
^Branch_Stmt,
^Using_Stmt,
^Bad_Decl,
^Value_Decl,
^Package_Decl,
^Import_Decl,
^Foreign_Block_Decl,
^Foreign_Import_Decl,
^Attribute,
^Field,
^Field_List,
^Bit_Field_Field,
}SourceAny_Stmt
Any_Stmt :: union {
^Bad_Stmt,
^Empty_Stmt,
^Expr_Stmt,
^Tag_Stmt,
^Assign_Stmt,
^Block_Stmt,
^If_Stmt,
^When_Stmt,
^Return_Stmt,
^Defer_Stmt,
^For_Stmt,
^Range_Stmt,
^Inline_Range_Stmt,
^Case_Clause,
^Switch_Stmt,
^Type_Switch_Stmt,
^Branch_Stmt,
^Using_Stmt,
^Bad_Decl,
^Value_Decl,
^Package_Decl,
^Import_Decl,
^Foreign_Block_Decl,
^Foreign_Import_Decl,
}SourceArray_Type
Array_Type :: struct {
node: Expr,
open: tokenizer.Pos,
tag: ^Expr,
len: ^Expr,
close: tokenizer.Pos,
elem: ^Expr,
}SourceAssign_Stmt
Assign_Stmt :: struct {
node: Stmt,
lhs: []^Expr,
op: tokenizer.Token,
rhs: []^Expr,
}SourceAttribute
Attribute :: struct {
node: Node,
tok: tokenizer.Token_Kind,
open: tokenizer.Pos,
elems: []^Expr,
close: tokenizer.Pos,
}SourceAuto_Cast
Auto_Cast :: struct {
node: Expr,
op: tokenizer.Token,
expr: ^Expr,
}SourceBad_Decl
Bad_Decl :: struct {
node: Decl,
}SourceDeclarations
Bad_Expr
Bad_Expr :: struct {
node: Expr,
}SourceExpressions
Bad_Stmt
Bad_Stmt :: struct {
node: Stmt,
}SourceStatements
Basic_Directive
Basic_Directive :: struct {
node: Expr,
tok: tokenizer.Token,
name: string,
}SourceBasic_Lit
Basic_Lit :: struct {
node: Expr,
tok: tokenizer.Token,
}SourceBinary_Expr
Binary_Expr :: struct {
node: Expr,
left: ^Expr,
op: tokenizer.Token,
right: ^Expr,
}SourceBit_Field_Field
Bit_Field_Field :: struct {
node: Node,
docs: ^Comment_Group,
name: ^Expr,
type: ^Expr,
bit_size: ^Expr,
tag: tokenizer.Token,
comments: ^Comment_Group,
}SourceBit_Field_Type
Bit_Field_Type :: struct {
node: Expr,
tok_pos: tokenizer.Pos,
backing_type: ^Expr,
open: tokenizer.Pos,
fields: []^Bit_Field_Field,
close: tokenizer.Pos,
}SourceBit_Set_Type
Bit_Set_Type :: struct {
node: Expr,
tok_pos: tokenizer.Pos,
open: tokenizer.Pos,
elem: ^Expr,
underlying: ^Expr,
close: tokenizer.Pos,
}SourceBlock_Stmt
Block_Stmt :: struct {
node: Stmt,
label: ^Expr,
open: tokenizer.Pos,
stmts: []^Stmt,
close: tokenizer.Pos,
uses_do: bool,
}SourceBranch_Stmt
Branch_Stmt :: struct {
node: Stmt,
tok: tokenizer.Token,
label: ^Ident,
}SourceCall_Expr
Call_Expr :: struct {
node: Expr,
inlining: Proc_Inlining,
tailing: Proc_Tailing,
expr: ^Expr,
open: tokenizer.Pos,
args: []^Expr,
ellipsis: tokenizer.Token,
close: tokenizer.Pos,
}SourceCase_Clause
Case_Clause :: struct {
node: Stmt,
case_pos: tokenizer.Pos,
list: []^Expr,
terminator: tokenizer.Token,
body: []^Stmt,
}SourceComment_Group
Comment_Group :: struct {
node: Node,
list: []tokenizer.Token,
}SourceComp_Lit
Comp_Lit :: struct {
node: Expr,
type: ^Expr,
open: tokenizer.Pos,
elems: []^Expr,
close: tokenizer.Pos,
tag: ^Expr,
}SourceDecl
Decl :: struct {
decl_base: Stmt,
}SourceDefer_Stmt
Defer_Stmt :: struct {
node: Stmt,
stmt: ^Stmt,
}SourceDeref_Expr
Deref_Expr :: struct {
node: Expr,
expr: ^Expr,
op: tokenizer.Token,
}SourceDistinct_Type
Distinct_Type :: struct {
node: Expr,
tok: tokenizer.Token_Kind,
type: ^Expr,
}SourceDynamic_Array_Type
Dynamic_Array_Type :: struct {
node: Expr,
tag: ^Expr,
open: tokenizer.Pos,
dynamic_pos: tokenizer.Pos,
close: tokenizer.Pos,
elem: ^Expr,
}SourceEllipsis
Ellipsis :: struct {
node: Expr,
tok: tokenizer.Token_Kind,
expr: ^Expr,
}SourceEmpty_Stmt
Empty_Stmt :: struct {
node: Stmt,
semicolon: tokenizer.Pos,
}SourceEnum_Type
Enum_Type :: struct {
node: Expr,
tok_pos: tokenizer.Pos,
base_type: ^Expr,
open: tokenizer.Pos,
fields: []^Expr,
close: tokenizer.Pos,
is_using: bool,
}SourceExpr
Expr :: struct {
expr_base: Node,
derived_expr: Any_Expr,
}SourceBase Types
Expr_Stmt
Expr_Stmt :: struct {
node: Stmt,
expr: ^Expr,
}SourceField
Field :: struct {
node: Node,
docs: ^Comment_Group,
names: []^Expr,
type: ^Expr,
default_value: ^Expr,
tag: tokenizer.Token,
flags: Field_Flags,
comment: ^Comment_Group,
}SourceField_Flag
Field_Flag :: enum int {
Invalid = 0,
Unknown = 1,
Ellipsis = 2,
Using = 3,
No_Alias = 4,
C_Vararg = 5,
Const = 6,
Any_Int = 7,
Subtype = 8,
By_Ptr = 9,
No_Broadcast = 10,
No_Capture = 11,
Results = 12,
Tags = 13,
Default_Parameters = 14,
Typeid_Token = 15,
}SourceField_Flags
Field_Flags :: bit_set[Field_Flag; 0..15]SourceField_List
Field_List :: struct {
node: Node,
open: tokenizer.Pos,
list: []^Field,
close: tokenizer.Pos,
}SourceField_Value
Field_Value :: struct {
node: Expr,
field: ^Expr,
sep: tokenizer.Pos,
value: ^Expr,
}SourceFile
File :: struct {
node: Node,
id: int,
pkg: ^Package,
fullpath: string,
src: string,
tags: [dynamic]tokenizer.Token,
docs: ^Comment_Group,
pkg_decl: ^Package_Decl,
pkg_token: tokenizer.Token,
pkg_name: string,
decls: [dynamic]^Stmt,
imports: [dynamic]^Import_Decl,
directive_count: int,
comments: [dynamic]^Comment_Group,
syntax_warning_count: int,
syntax_error_count: int,
}SourceFixed_Capacity_Dynamic_Array_Type
Fixed_Capacity_Dynamic_Array_Type :: struct {
node: Expr,
tag: ^Expr,
open: tokenizer.Pos,
dynamic_pos: tokenizer.Pos,
capacity: ^Expr,
close: tokenizer.Pos,
elem: ^Expr,
}SourceFor_Stmt
For_Stmt :: struct {
node: Stmt,
label: ^Expr,
for_pos: tokenizer.Pos,
init: ^Stmt,
cond: ^Expr,
post: ^Stmt,
body: ^Stmt,
}SourceForeign_Block_Decl
Foreign_Block_Decl :: struct {
node: Decl,
docs: ^Comment_Group,
attributes: [dynamic]^Attribute,
tok: tokenizer.Token,
foreign_library: ^Expr,
body: ^Stmt,
}SourceForeign_Import_Decl
Foreign_Import_Decl :: struct {
node: Decl,
docs: ^Comment_Group,
attributes: [dynamic]^Attribute,
foreign_tok: tokenizer.Token,
import_tok: tokenizer.Token,
name: ^Ident,
collection_name: string,
fullpaths: []^Expr,
comment: ^Comment_Group,
}SourceHelper_Type
Helper_Type :: struct {
node: Expr,
tok: tokenizer.Token_Kind,
type: ^Expr,
}SourceIdent
Ident :: struct {
node: Expr,
name: string,
}SourceIf_Stmt
If_Stmt :: struct {
node: Stmt,
label: ^Expr,
if_pos: tokenizer.Pos,
init: ^Stmt,
cond: ^Expr,
body: ^Stmt,
else_pos: tokenizer.Pos,
else_stmt: ^Stmt,
}SourceImplicit
Implicit :: struct {
node: Expr,
tok: tokenizer.Token,
}SourceImplicit_Selector_Expr
Implicit_Selector_Expr :: struct {
node: Expr,
field: ^Ident,
}SourceImport_Decl
Import_Decl :: struct {
node: Decl,
docs: ^Comment_Group,
attributes: [dynamic]^Attribute,
is_using: bool,
import_tok: tokenizer.Token,
name: tokenizer.Token,
relpath: tokenizer.Token,
fullpath: string,
comment: ^Comment_Group,
}SourceIndex_Expr
Index_Expr :: struct {
node: Expr,
expr: ^Expr,
open: tokenizer.Pos,
index: ^Expr,
close: tokenizer.Pos,
}SourceInline_Asm_Dialect
Inline_Asm_Dialect :: enum u8 {
Default = 0,
ATT = 1,
Intel = 2,
}SourceInline_Asm_Expr
Inline_Asm_Expr :: struct {
node: Expr,
tok: tokenizer.Token,
param_types: []^Expr,
return_type: ^Expr,
has_side_effects: bool,
is_align_stack: bool,
dialect: Inline_Asm_Dialect,
open: tokenizer.Pos,
constraints_string: ^Expr,
asm_string: ^Expr,
close: tokenizer.Pos,
}SourceInline_Range_Stmt
Inline_Range_Stmt :: Unroll_Range_StmtSourceMap_Type
Map_Type :: struct {
node: Expr,
tok_pos: tokenizer.Pos,
key: ^Expr,
value: ^Expr,
}SourceMatrix_Index_Expr
Matrix_Index_Expr :: struct {
node: Expr,
expr: ^Expr,
open: tokenizer.Pos,
row_index: ^Expr,
column_index: ^Expr,
close: tokenizer.Pos,
}SourceMatrix_Type
Matrix_Type :: struct {
node: Expr,
tok_pos: tokenizer.Pos,
row_count: ^Expr,
column_count: ^Expr,
elem: ^Expr,
}SourceMulti_Pointer_Type
Multi_Pointer_Type :: struct {
node: Expr,
open: tokenizer.Pos,
pointer: tokenizer.Pos,
close: tokenizer.Pos,
elem: ^Expr,
}SourceNode
Node :: struct {
pos: tokenizer.Pos,
end: tokenizer.Pos,
state_flags: Node_State_Flags,
derived: Any_Node,
}SourceNode_State_Flag
Node_State_Flag :: enum int {
Bounds_Check = 0,
No_Bounds_Check = 1,
Type_Assert = 2,
No_Type_Assert = 3,
}SourceNode_State_Flags
Node_State_Flags :: bit_set[Node_State_Flag; 0..3]SourceOr_Branch_Expr
Or_Branch_Expr :: struct {
node: Expr,
expr: ^Expr,
token: tokenizer.Token,
label: ^Expr,
}SourceOr_Else_Expr
Or_Else_Expr :: struct {
node: Expr,
x: ^Expr,
token: tokenizer.Token,
y: ^Expr,
}SourceOr_Return_Expr
Or_Return_Expr :: struct {
node: Expr,
expr: ^Expr,
token: tokenizer.Token,
}SourcePackage
Package :: struct {
node: Node,
kind: Package_Kind,
id: int,
name: string,
fullpath: string,
files: map[string]^File,
user_data: rawptr,
}SourcePackage_Decl
Package_Decl :: struct {
node: Decl,
docs: ^Comment_Group,
token: tokenizer.Token,
name: string,
comment: ^Comment_Group,
}SourcePackage_Kind
Package_Kind :: enum int {
Normal = 0,
Runtime = 1,
Init = 2,
}SourceParen_Expr
Paren_Expr :: struct {
node: Expr,
open: tokenizer.Pos,
expr: ^Expr,
close: tokenizer.Pos,
}SourcePointer_Type
Pointer_Type :: struct {
node: Expr,
tag: ^Expr,
pointer: tokenizer.Pos,
elem: ^Expr,
}SourcePoly_Type
Poly_Type :: struct {
node: Expr,
dollar: tokenizer.Pos,
type: ^Ident,
specialization: ^Expr,
}SourceProc_Calling_Convention
Proc_Calling_Convention :: union {
string,
Proc_Calling_Convention_Extra,
}SourceProc_Calling_Convention_Extra
Proc_Calling_Convention_Extra :: enum i32 {
Foreign_Block_Default = 0,
}SourceProc_Group
Proc_Group :: struct {
node: Expr,
tok: tokenizer.Token,
open: tokenizer.Pos,
args: []^Expr,
close: tokenizer.Pos,
}SourceProc_Inlining
Proc_Inlining :: enum u32 {
None = 0,
Inline = 1,
No_Inline = 2,
}SourceProc_Lit
Proc_Lit :: struct {
node: Expr,
type: ^Proc_Type,
body: ^Stmt,
tags: Proc_Tags,
inlining: Proc_Inlining,
tailing: Proc_Tailing,
where_token: tokenizer.Token,
where_clauses: []^Expr,
}SourceProc_Tag
Proc_Tag :: enum int {
Bounds_Check = 0,
No_Bounds_Check = 1,
Optional_Ok = 2,
Optional_Allocator_Error = 3,
}SourceProc_Tags
Proc_Tags :: bit_set[Proc_Tag; u32]SourceProc_Tailing
Proc_Tailing :: enum u32 {
None = 0,
Must_Tail = 1,
}SourceProc_Type
Proc_Type :: struct {
node: Expr,
tok: tokenizer.Token,
calling_convention: Proc_Calling_Convention,
params: ^Field_List,
arrow: tokenizer.Pos,
results: ^Field_List,
tags: Proc_Tags,
generic: bool,
diverging: bool,
}SourceRange_Stmt
Range_Stmt :: struct {
node: Stmt,
label: ^Expr,
init: ^Stmt,
for_pos: tokenizer.Pos,
vals: []^Expr,
in_pos: tokenizer.Pos,
expr: ^Expr,
body: ^Stmt,
reverse: bool,
}SourceRelative_Type
Relative_Type :: struct {
node: Expr,
tag: ^Expr,
type: ^Expr,
}SourceReturn_Stmt
Return_Stmt :: struct {
node: Stmt,
results: []^Expr,
}SourceSelector_Call_Expr
Selector_Call_Expr :: struct {
node: Expr,
expr: ^Expr,
call: ^Call_Expr,
modified_call: bool,
}SourceSelector_Expr
Selector_Expr :: struct {
node: Expr,
expr: ^Expr,
op: tokenizer.Token,
field: ^Ident,
}SourceSlice_Expr
Slice_Expr :: struct {
node: Expr,
expr: ^Expr,
open: tokenizer.Pos,
low: ^Expr,
interval: tokenizer.Token,
high: ^Expr,
close: tokenizer.Pos,
}SourceStmt
Stmt :: struct {
stmt_base: Node,
derived_stmt: Any_Stmt,
}SourceStruct_Type
Struct_Type :: struct {
node: Expr,
tok_pos: tokenizer.Pos,
poly_params: ^Field_List,
align: ^Expr,
min_field_align: ^Expr,
max_field_align: ^Expr,
where_token: tokenizer.Token,
where_clauses: []^Expr,
is_packed: bool,
is_raw_union: bool,
is_no_copy: bool,
is_all_or_none: bool,
is_simple: bool,
fields: ^Field_List,
name_count: int,
}SourceSwitch_Stmt
Switch_Stmt :: struct {
node: Stmt,
label: ^Expr,
switch_pos: tokenizer.Pos,
init: ^Stmt,
cond: ^Expr,
body: ^Stmt,
partial: bool,
}SourceTag_Expr
Tag_Expr :: struct {
node: Expr,
op: tokenizer.Token,
name: string,
expr: ^Expr,
}SourceTag_Stmt
Tag_Stmt :: struct {
node: Stmt,
op: tokenizer.Token,
name: string,
stmt: ^Stmt,
}SourceTernary_If_Expr
Ternary_If_Expr :: struct {
node: Expr,
x: ^Expr,
op1: tokenizer.Token,
cond: ^Expr,
op2: tokenizer.Token,
y: ^Expr,
}SourceTernary_When_Expr
Ternary_When_Expr :: struct {
node: Expr,
x: ^Expr,
op1: tokenizer.Token,
cond: ^Expr,
op2: tokenizer.Token,
y: ^Expr,
}SourceType_Assertion
Type_Assertion :: struct {
node: Expr,
expr: ^Expr,
dot: tokenizer.Pos,
open: tokenizer.Pos,
type: ^Expr,
close: tokenizer.Pos,
}SourceType_Cast
Type_Cast :: struct {
node: Expr,
tok: tokenizer.Token,
open: tokenizer.Pos,
type: ^Expr,
close: tokenizer.Pos,
expr: ^Expr,
}SourceType_Switch_Stmt
Type_Switch_Stmt :: struct {
node: Stmt,
label: ^Expr,
switch_pos: tokenizer.Pos,
tag: ^Stmt,
expr: ^Expr,
body: ^Stmt,
partial: bool,
}SourceTypeid_Type
Typeid_Type :: struct {
node: Expr,
tok: tokenizer.Token_Kind,
specialization: ^Expr,
}SourceTypes
Unary_Expr
Unary_Expr :: struct {
node: Expr,
op: tokenizer.Token,
expr: ^Expr,
}SourceUndef
Undef :: struct {
node: Expr,
tok: tokenizer.Token_Kind,
}SourceUnion_Type
Union_Type :: struct {
node: Expr,
tok_pos: tokenizer.Pos,
poly_params: ^Field_List,
align: ^Expr,
kind: Union_Type_Kind,
where_token: tokenizer.Token,
where_clauses: []^Expr,
variants: []^Expr,
}SourceUnion_Type_Kind
Union_Type_Kind :: enum u8 {
Normal = 0,
maybe = 1,
no_nil = 2,
shared_nil = 3,
}SourceUnroll_Range_Stmt
Unroll_Range_Stmt :: struct {
node: Stmt,
label: ^Expr,
unroll_pos: tokenizer.Pos,
args: []^Expr,
for_pos: tokenizer.Pos,
val0: ^Expr,
val1: ^Expr,
in_pos: tokenizer.Pos,
expr: ^Expr,
body: ^Stmt,
}SourceUsing_Stmt
Using_Stmt :: struct {
node: Stmt,
list: []^Expr,
}SourceValue_Decl
Value_Decl :: struct {
node: Decl,
docs: ^Comment_Group,
attributes: [dynamic]^Attribute,
names: []^Expr,
type: ^Expr,
values: []^Expr,
comment: ^Comment_Group,
is_using: bool,
is_mutable: bool,
}SourceVisitor
Visitor :: struct {
visit: proc(visitor: ^Visitor, node: ^Node) -> (^Visitor),
visitor: ^Visitor,
Visitor: ^Node,
node: ^Node,
data: rawptr,
}SourceA Visitor's visit procedure is invoked for each node encountered by walk If the result visitor is not nil, walk visits each of the children of node with the new visitor, followed by a call of v.visit(v, nil)
When_Stmt
When_Stmt :: struct {
node: Stmt,
when_pos: tokenizer.Pos,
cond: ^Expr,
body: ^Stmt,
else_stmt: ^Stmt,
}SourceConstants
5Field_Flags_Record_Poly_Params
Field_Flags_Record_Poly_Params :: Field_Flags = Field_Flags{
.Typeid_Token,
.Default_Parameters,
}SourceField_Flags_Signature
Field_Flags_Signature :: Field_Flags = Field_Flags{
.Ellipsis,
.Using,
.No_Alias,
.C_Vararg,
.Const,
.Any_Int,
.By_Ptr,
.No_Broadcast,
.Default_Parameters,
}SourceField_Flags_Signature_Params
Field_Flags_Signature_Params :: Field_Flags_Signature = Field_Flags_Signature | {Field_Flag.Typeid_Token}SourceField_Flags_Signature_Results
Field_Flags_Signature_Results :: Field_Flags_SignatureSourceField_Flags_Struct
Field_Flags_Struct :: Field_Flags = Field_Flags{
.Using,
.Tags,
.Subtype,
}SourceVariables
2field_flag_strings
field_flag_strings :: [16]string = [Field_Flag]string{
.Invalid = "",
.Unknown = "",
.Ellipsis = "..",
.Using = "using",
.No_Alias = "#no_alias",
.C_Vararg = "#c_vararg",
.Const = "#const",
.Any_Int Sourcefield_hash_flag_strings
field_hash_flag_strings :: _ = []struct{key: string, flag: Field_Flag}{
{"no_alias", .No_Alias},
{"c_vararg", .C_Vararg},
{"const", .Const},
{"any_int", .Any_Int},
{"subtype", .Subtype},
{"by_ptr", .By_Ptr},
{"no_broadcast", .No_Broadcast},
{"no_caSourceProcedures
12clone_array
clone_array :: proc(array: A) -> (A)Sourceclone_decl
clone_decl :: proc(node: ^Decl) -> (^Decl)Sourceclone_dynamic_array
clone_dynamic_array :: proc(array: A) -> (A)Sourceclone_expr
clone_expr :: proc(node: ^Expr) -> (^Expr)Sourceclone_node
clone_node :: proc(node: ^Node) -> (^Node)Sourceclone_stmt
clone_stmt :: proc(node: ^Stmt) -> (^Stmt)Sourceinspect
inspect :: proc(node: ^Node, f: proc(^Node) -> (bool))Sourceinspect traverses an AST in depth-first order It starts by calling f(node), and node must be non-nil If f returns true, inspect invokes f recursively for each of the non-nil children of node, followed by a call of f(nil)
new_from_pos_and_end_node
new_from_pos_and_end_node :: proc(T: typeid, pos: tokenizer.Pos, end: ^Node) -> (^T)Sourcenew_from_positions
new_from_positions :: proc(T: typeid, pos: tokenizer.Pos, end: tokenizer.Pos) -> (^T)Sourcestrip_or_return_expr
strip_or_return_expr :: proc(expr: ^Expr) -> (val: ^Expr)Sourceunparen_expr
unparen_expr :: proc(expr: ^Expr) -> (val: ^Expr)SourceOther things
walk
walk :: proc(v: ^Visitor, node: ^Node)Sourcewalk traverses an AST in depth-first order: It starts by calling v.visit(v, node), and node must not be nil If the visitor returned by v.visit(v, node) is not nil, walk is invoked recursively with the new visitor for each of the non-nil children of node, followed by a call of the new visit procedure