package core:odin/ast
Source

⌘K
Ctrl+K
or
/

    Overview

    Abstract Syntax Tree for the Odin parser packages.

    Index

    Types (112)
    Procedure Groups (2)

    Types

    Any_Expr ¶
    Source · ast.odin:1064

    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, 
	^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, 
	^Asm_Template, 
	^Asm_Register, 
	^Asm_Label, 
	^Asm_Memory_Operand, 
	^Asm_Register_Group, 
}

    Any_Node ¶
    Source · ast.odin:963

    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, 
	^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, 
	^Unroll_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, 
	^Asm_Template, 
	^Asm_Spec, 
	^Asm_Register, 
	^Asm_Clobber, 
	^Asm_Label, 
	^Asm_Label_Decl, 
	^Asm_Instruction, 
	^Asm_Memory_Operand, 
	^Asm_Register_Group, 
	^Asm_Directive, 
}

    Any_Stmt ¶
    Source · ast.odin:1125

    Array_Type ¶
    Source · ast.odin:749

    Array_Type :: struct {
	using node: Expr,
	open:  odin_tokenizer.Pos,
	tag:   ^Expr,
	// possibly nil
	len:   ^Expr,
	// Unary_Expr node for [?]T array types, nil for slice types
	close: odin_tokenizer.Pos,
	elem:  ^Expr,
}
    Procedures Through `using` From Expr
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Expr
    • pos: odin_tokenizer.Pos // through expr_base
    • end: odin_tokenizer.Pos // through expr_base
    • state_flags: Node_State_Flags // through expr_base
    • derived: Any_Node // through expr_base
    • derived_expr: Any_Expr

    Asm_Clobber ¶
    Source · ast.odin:900

    Asm_Clobber :: struct {
	using node: Stmt,
	token: odin_tokenizer.Token,
	name:  string,
	value: ^Expr,
}
    Procedures Through `using` From Stmt
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Stmt
    • pos: odin_tokenizer.Pos // through stmt_base
    • end: odin_tokenizer.Pos // through stmt_base
    • state_flags: Node_State_Flags // through stmt_base
    • derived: Any_Node // through stmt_base
    • derived_stmt: Any_Stmt

    Asm_Directive ¶
    Source · ast.odin:955

    Asm_Directive :: struct {
	using node: Stmt,
	token:    odin_tokenizer.Token,
	name:     string,
	operands: []^Expr,
}
    Procedures Through `using` From Stmt
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Stmt
    • pos: odin_tokenizer.Pos // through stmt_base
    • end: odin_tokenizer.Pos // through stmt_base
    • state_flags: Node_State_Flags // through stmt_base
    • derived: Any_Node // through stmt_base
    • derived_stmt: Any_Stmt

    Asm_Instruction ¶
    Source · ast.odin:918

    Asm_Instruction :: struct {
	using node: Stmt,
	name:     ^Ident,
	operands: []^Expr,
}
    Procedures Through `using` From Stmt
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Stmt
    • pos: odin_tokenizer.Pos // through stmt_base
    • end: odin_tokenizer.Pos // through stmt_base
    • state_flags: Node_State_Flags // through stmt_base
    • derived: Any_Node // through stmt_base
    • derived_stmt: Any_Stmt

    Asm_Label ¶
    Source · ast.odin:907

    Asm_Label :: struct {
	using node: Expr,
	token: odin_tokenizer.Token,
	name:  string,
}
    Procedures Through `using` From Expr
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Expr
    • pos: odin_tokenizer.Pos // through expr_base
    • end: odin_tokenizer.Pos // through expr_base
    • state_flags: Node_State_Flags // through expr_base
    • derived: Any_Node // through expr_base
    • derived_expr: Any_Expr

    Asm_Label_Decl ¶
    Source · ast.odin:913

    Asm_Label_Decl :: struct {
	using node: Stmt,
	label: ^Asm_Label,
}
    Procedures Through `using` From Stmt
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Stmt
    • pos: odin_tokenizer.Pos // through stmt_base
    • end: odin_tokenizer.Pos // through stmt_base
    • state_flags: Node_State_Flags // through stmt_base
    • derived: Any_Node // through stmt_base
    • derived_stmt: Any_Stmt

    Asm_Memory_Operand ¶
    Source · ast.odin:930

    Asm_Memory_Operand :: struct {
	using node:       Expr,
	kind:             Asm_Memory_Operand_Kind,
	open:             odin_tokenizer.Token,
	segment_override: ^Expr,
	base:             ^Expr,
	index_op:         odin_tokenizer.Token,
	index:            ^Expr,
	scale_op:         odin_tokenizer.Token,
	scale:            ^Expr,
	disp_op:          odin_tokenizer.Token,
	disp:             ^Expr,
	close:            odin_tokenizer.Token,
	type:             ^Expr,
}
    Procedures Through `using` From Expr
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Expr
    • pos: odin_tokenizer.Pos // through expr_base
    • end: odin_tokenizer.Pos // through expr_base
    • state_flags: Node_State_Flags // through expr_base
    • derived: Any_Node // through expr_base
    • derived_expr: Any_Expr

    Asm_Memory_Operand_Kind ¶
    Source · ast.odin:924

    Asm_Memory_Operand_Kind :: enum u8 {
	Default, 
	Pre, 
	Post, 
}

    Asm_Register ¶
    Source · ast.odin:893

    Asm_Register :: struct {
	using node: Expr,
	token: odin_tokenizer.Token,
	name:  string,
	flag:  string,
}
    Procedures Through `using` From Expr
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Expr
    • pos: odin_tokenizer.Pos // through expr_base
    • end: odin_tokenizer.Pos // through expr_base
    • state_flags: Node_State_Flags // through expr_base
    • derived: Any_Node // through expr_base
    • derived_expr: Any_Expr

    Asm_Register_Group ¶
    Source · ast.odin:946

    Asm_Register_Group :: struct {
	using node:  Expr,
	open:        odin_tokenizer.Token,
	registers:   []^Expr,
	range_token: odin_tokenizer.Token,
	close:       odin_tokenizer.Token,
	type:        ^Expr,
}
    Procedures Through `using` From Expr
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Expr
    • pos: odin_tokenizer.Pos // through expr_base
    • end: odin_tokenizer.Pos // through expr_base
    • state_flags: Node_State_Flags // through expr_base
    • derived: Any_Node // through expr_base
    • derived_expr: Any_Expr

    Asm_Spec ¶
    Source · ast.odin:884

    Asm_Spec :: struct {
	using node: Stmt,
	name:       ^Ident,
	tied_name:  ^Ident,
	type:       ^Expr,
	value:      ^Expr,
	directives: []^Expr,
}
    Procedures Through `using` From Stmt
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Stmt
    • pos: odin_tokenizer.Pos // through stmt_base
    • end: odin_tokenizer.Pos // through stmt_base
    • state_flags: Node_State_Flags // through stmt_base
    • derived: Any_Node // through stmt_base
    • derived_stmt: Any_Stmt

    Asm_Template ¶
    Source · ast.odin:875

    Asm_Template :: struct {
	using node:   Expr,
	token:        odin_tokenizer.Token,
	type:         ^Proc_Type,
	specs:        []^Asm_Spec,
	clobbers:     []^Asm_Clobber,
	instructions: []^Stmt,
}
    Procedures Through `using` From Expr
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Expr
    • pos: odin_tokenizer.Pos // through expr_base
    • end: odin_tokenizer.Pos // through expr_base
    • state_flags: Node_State_Flags // through expr_base
    • derived: Any_Node // through expr_base
    • derived_expr: Any_Expr

    Assign_Stmt ¶
    Source · ast.odin:354

    Assign_Stmt :: struct {
	using node: Stmt,
	lhs:  []^Expr,
	op:   odin_tokenizer.Token,
	rhs:  []^Expr,
}
    Procedures Through `using` From Stmt
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Stmt
    • pos: odin_tokenizer.Pos // through stmt_base
    • end: odin_tokenizer.Pos // through stmt_base
    • state_flags: Node_State_Flags // through stmt_base
    • derived: Any_Node // through stmt_base
    • derived_stmt: Any_Stmt

    Attribute ¶
    Source · ast.odin:669

    Attribute :: struct {
	using node: Node,
	tok:   odin_tokenizer.Token_Kind,
	open:  odin_tokenizer.Pos,
	elems: []^Expr,
	close: odin_tokenizer.Pos,
}
    Procedures Through `using` From Node

    Fields Through using (4)
    From using node: Node

    Auto_Cast ¶
    Source · ast.odin:322

    Auto_Cast :: struct {
	using node: Expr,
	op:   odin_tokenizer.Token,
	expr: ^Expr,
}
    Procedures Through `using` From Expr
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Expr
    • pos: odin_tokenizer.Pos // through expr_base
    • end: odin_tokenizer.Pos // through expr_base
    • state_flags: Node_State_Flags // through expr_base
    • derived: Any_Node // through expr_base
    • derived_expr: Any_Expr

    Bad_Decl ¶
    Source · ast.odin:482

    Bad_Decl :: struct {
	using node: Decl,
}
    Procedures Through `using` From Decl
    Procedures Through `using` From Stmt
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Decl
    • pos: odin_tokenizer.Pos // through decl_base.stmt_base
    • end: odin_tokenizer.Pos // through decl_base.stmt_base
    • state_flags: Node_State_Flags // through decl_base.stmt_base
    • derived: Any_Node // through decl_base.stmt_base
    • derived_stmt: Any_Stmt // through decl_base

    Bad_Expr ¶
    Source · ast.odin:112

    Bad_Expr :: struct {
	using node: Expr,
}
    Procedures Through `using` From Expr
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Expr
    • pos: odin_tokenizer.Pos // through expr_base
    • end: odin_tokenizer.Pos // through expr_base
    • state_flags: Node_State_Flags // through expr_base
    • derived: Any_Node // through expr_base
    • derived_expr: Any_Expr

    Bad_Stmt ¶
    Source · ast.odin:333

    Bad_Stmt :: struct {
	using node: Stmt,
}
    Procedures Through `using` From Stmt
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Stmt
    • pos: odin_tokenizer.Pos // through stmt_base
    • end: odin_tokenizer.Pos // through stmt_base
    • state_flags: Node_State_Flags // through stmt_base
    • derived: Any_Node // through stmt_base
    • derived_stmt: Any_Stmt

    Basic_Directive ¶
    Source · ast.odin:137

    Basic_Directive :: struct {
	using node: Expr,
	tok:  odin_tokenizer.Token,
	name: string,
}
    Procedures Through `using` From Expr
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Expr
    • pos: odin_tokenizer.Pos // through expr_base
    • end: odin_tokenizer.Pos // through expr_base
    • state_flags: Node_State_Flags // through expr_base
    • derived: Any_Node // through expr_base
    • derived_expr: Any_Expr

    Basic_Lit ¶
    Source · ast.odin:132

    Basic_Lit :: struct {
	using node: Expr,
	tok:  odin_tokenizer.Token,
}
    Procedures Through `using` From Expr
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Expr
    • pos: odin_tokenizer.Pos // through expr_base
    • end: odin_tokenizer.Pos // through expr_base
    • state_flags: Node_State_Flags // through expr_base
    • derived: Any_Node // through expr_base
    • derived_expr: Any_Expr

    Binary_Expr ¶
    Source · ast.odin:182

    Binary_Expr :: struct {
	using node: Expr,
	left:  ^Expr,
	op:    odin_tokenizer.Token,
	right: ^Expr,
}
    Procedures Through `using` From Expr
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Expr
    • pos: odin_tokenizer.Pos // through expr_base
    • end: odin_tokenizer.Pos // through expr_base
    • state_flags: Node_State_Flags // through expr_base
    • derived: Any_Node // through expr_base
    • derived_expr: Any_Expr

    Bit_Field_Field ¶
    Source · ast.odin:864

    Bit_Field_Field :: struct {
	using node: Node,
	docs:     ^Comment_Group,
	// possibly nil
	name:     ^Expr,
	type:     ^Expr,
	bit_size: ^Expr,
	tag:      odin_tokenizer.Token,
	comments: ^Comment_Group,
}
    Procedures Through `using` From Node

    Fields Through using (4)
    From using node: Node

    Bit_Field_Type ¶
    Source · ast.odin:855

    Bit_Field_Type :: struct {
	using node:   Expr,
	tok_pos:      odin_tokenizer.Pos,
	backing_type: ^Expr,
	open:         odin_tokenizer.Pos,
	fields:       []^Bit_Field_Field,
	close:        odin_tokenizer.Pos,
}
    Procedures Through `using` From Expr
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Expr
    • pos: odin_tokenizer.Pos // through expr_base
    • end: odin_tokenizer.Pos // through expr_base
    • state_flags: Node_State_Flags // through expr_base
    • derived: Any_Node // through expr_base
    • derived_expr: Any_Expr

    Bit_Set_Type ¶
    Source · ast.odin:824

    Bit_Set_Type :: struct {
	using node: Expr,
	tok_pos:    odin_tokenizer.Pos,
	open:       odin_tokenizer.Pos,
	elem:       ^Expr,
	underlying: ^Expr,
	// possibly nil
	close:      odin_tokenizer.Pos,
}
    Procedures Through `using` From Expr
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Expr
    • pos: odin_tokenizer.Pos // through expr_base
    • end: odin_tokenizer.Pos // through expr_base
    • state_flags: Node_State_Flags // through expr_base
    • derived: Any_Node // through expr_base
    • derived_expr: Any_Expr

    Block_Stmt ¶
    Source · ast.odin:362

    Block_Stmt :: struct {
	using node: Stmt,
	label:   ^Expr,
	open:    odin_tokenizer.Pos,
	stmts:   []^Stmt,
	close:   odin_tokenizer.Pos,
	uses_do: bool,
}
    Procedures Through `using` From Stmt
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Stmt
    • pos: odin_tokenizer.Pos // through stmt_base
    • end: odin_tokenizer.Pos // through stmt_base
    • state_flags: Node_State_Flags // through stmt_base
    • derived: Any_Node // through stmt_base
    • derived_stmt: Any_Stmt

    Branch_Stmt ¶
    Source · ast.odin:468

    Branch_Stmt :: struct {
	using node: Stmt,
	tok:   odin_tokenizer.Token,
	label: ^Ident,
}
    Procedures Through `using` From Stmt
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Stmt
    • pos: odin_tokenizer.Pos // through stmt_base
    • end: odin_tokenizer.Pos // through stmt_base
    • state_flags: Node_State_Flags // through stmt_base
    • derived: Any_Node // through stmt_base
    • derived_stmt: Any_Stmt

    Call_Expr ¶
    Source · ast.odin:248

    Call_Expr :: struct {
	using node: Expr,
	inlining: Proc_Inlining,
	tailing:  Proc_Tailing,
	expr:     ^Expr,
	open:     odin_tokenizer.Pos,
	args:     []^Expr,
	ellipsis: odin_tokenizer.Token,
	close:    odin_tokenizer.Pos,
}
    Procedures Through `using` From Expr
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Expr
    • pos: odin_tokenizer.Pos // through expr_base
    • end: odin_tokenizer.Pos // through expr_base
    • state_flags: Node_State_Flags // through expr_base
    • derived: Any_Node // through expr_base
    • derived_expr: Any_Expr

    Case_Clause ¶
    Source · ast.odin:440

    Case_Clause :: struct {
	using node: Stmt,
	case_pos:   odin_tokenizer.Pos,
	list:       []^Expr,
	terminator: odin_tokenizer.Token,
	body:       []^Stmt,
}
    Procedures Through `using` From Stmt
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Stmt
    • pos: odin_tokenizer.Pos // through stmt_base
    • end: odin_tokenizer.Pos // through stmt_base
    • state_flags: Node_State_Flags // through stmt_base
    • derived: Any_Node // through stmt_base
    • derived_stmt: Any_Stmt

    Comment_Group ¶
    Source · ast.odin:48

    Comment_Group :: struct {
	using node: Node,
	list: []odin_tokenizer.Token,
}
    Procedures Through `using` From Node

    Fields Through using (4)
    From using node: Node

    Comp_Lit ¶
    Source · ast.odin:160

    Comp_Lit :: struct {
	using node: Expr,
	type:  ^Expr,
	// nil when type is inferred
	open:  odin_tokenizer.Pos,
	elems: []^Expr,
	close: odin_tokenizer.Pos,
	tag:   ^Expr,
}
    Procedures Through `using` From Expr
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Expr
    • pos: odin_tokenizer.Pos // through expr_base
    • end: odin_tokenizer.Pos // through expr_base
    • state_flags: Node_State_Flags // through expr_base
    • derived: Any_Node // through expr_base
    • derived_expr: Any_Expr

    Decl ¶
    Source · ast.odin:106

    Decl :: struct {
	using decl_base: Stmt,
}

    Related Procedures With Parameters
    Procedures Through `using` From Stmt
    Procedures Through `using` From Node

    Fields Through using (5)
    From using decl_base: Stmt
    • pos: odin_tokenizer.Pos // through stmt_base
    • end: odin_tokenizer.Pos // through stmt_base
    • state_flags: Node_State_Flags // through stmt_base
    • derived: Any_Node // through stmt_base
    • derived_stmt: Any_Stmt

    Defer_Stmt ¶
    Source · ast.odin:395

    Defer_Stmt :: struct {
	using node: Stmt,
	stmt: ^Stmt,
}
    Procedures Through `using` From Stmt
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Stmt
    • pos: odin_tokenizer.Pos // through stmt_base
    • end: odin_tokenizer.Pos // through stmt_base
    • state_flags: Node_State_Flags // through stmt_base
    • derived: Any_Node // through stmt_base
    • derived_stmt: Any_Stmt

    Deref_Expr ¶
    Source · ast.odin:223

    Deref_Expr :: struct {
	using node: Expr,
	expr: ^Expr,
	op:   odin_tokenizer.Token,
}
    Procedures Through `using` From Expr
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Expr
    • pos: odin_tokenizer.Pos // through expr_base
    • end: odin_tokenizer.Pos // through expr_base
    • state_flags: Node_State_Flags // through expr_base
    • derived: Any_Node // through expr_base
    • derived_expr: Any_Expr

    Distinct_Type ¶
    Source · ast.odin:709

    Distinct_Type :: struct {
	using node: Expr,
	tok:  odin_tokenizer.Token_Kind,
	type: ^Expr,
}
    Procedures Through `using` From Expr
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Expr
    • pos: odin_tokenizer.Pos // through expr_base
    • end: odin_tokenizer.Pos // through expr_base
    • state_flags: Node_State_Flags // through expr_base
    • derived: Any_Node // through expr_base
    • derived_expr: Any_Expr

    Dynamic_Array_Type ¶
    Source · ast.odin:758

    Dynamic_Array_Type :: struct {
	using node:  Expr,
	tag:         ^Expr,
	// possibly nil
	open:        odin_tokenizer.Pos,
	dynamic_pos: odin_tokenizer.Pos,
	close:       odin_tokenizer.Pos,
	elem:        ^Expr,
}
    Procedures Through `using` From Expr
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Expr
    • pos: odin_tokenizer.Pos // through expr_base
    • end: odin_tokenizer.Pos // through expr_base
    • state_flags: Node_State_Flags // through expr_base
    • derived: Any_Node // through expr_base
    • derived_expr: Any_Expr

    Ellipsis ¶
    Source · ast.odin:143

    Ellipsis :: struct {
	using node: Expr,
	tok:  odin_tokenizer.Token_Kind,
	expr: ^Expr,
}
    Procedures Through `using` From Expr
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Expr
    • pos: odin_tokenizer.Pos // through expr_base
    • end: odin_tokenizer.Pos // through expr_base
    • state_flags: Node_State_Flags // through expr_base
    • derived: Any_Node // through expr_base
    • derived_expr: Any_Expr

    Empty_Stmt ¶
    Source · ast.odin:337

    Empty_Stmt :: struct {
	using node: Stmt,
	semicolon: odin_tokenizer.Pos,
}
    Procedures Through `using` From Stmt
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Stmt
    • pos: odin_tokenizer.Pos // through stmt_base
    • end: odin_tokenizer.Pos // through stmt_base
    • state_flags: Node_State_Flags // through stmt_base
    • derived: Any_Node // through stmt_base
    • derived_stmt: Any_Stmt

    Enum_Type ¶
    Source · ast.odin:813

    Enum_Type :: struct {
	using node: Expr,
	tok_pos:   odin_tokenizer.Pos,
	base_type: ^Expr,
	// possibly nil
	open:      odin_tokenizer.Pos,
	fields:    []^Expr,
	close:     odin_tokenizer.Pos,
	is_using:  bool,
}
    Procedures Through `using` From Expr
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Expr
    • pos: odin_tokenizer.Pos // through expr_base
    • end: odin_tokenizer.Pos // through expr_base
    • state_flags: Node_State_Flags // through expr_base
    • derived: Any_Node // through expr_base
    • derived_expr: Any_Expr

    Expr ¶
    Source · ast.odin:98

    Expr :: struct {
	using expr_base: Node,
	derived_expr: Any_Expr,
}

    Related Procedures With Parameters
    Procedures Through `using` From Node

    Fields Through using (4)
    From using expr_base: Node

    Expr_Stmt ¶
    Source · ast.odin:342

    Expr_Stmt :: struct {
	using node: Stmt,
	expr: ^Expr,
}
    Procedures Through `using` From Stmt
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Stmt
    • pos: odin_tokenizer.Pos // through stmt_base
    • end: odin_tokenizer.Pos // through stmt_base
    • state_flags: Node_State_Flags // through stmt_base
    • derived: Any_Node // through stmt_base
    • derived_stmt: Any_Stmt

    Field ¶
    Source · ast.odin:677

    Field :: struct {
	using node:    Node,
	docs:          ^Comment_Group,
	// possibly nil
	names:         []^Expr,
	// Could be polymorphic
	type:          ^Expr,
	default_value: ^Expr,
	// possibly nil
	tag:           odin_tokenizer.Token,
	flags:         Field_Flags,
	comment:       ^Comment_Group,
}
    Procedures Through `using` From Node

    Fields Through using (4)
    From using node: Node

    Field_Flag ¶
    Source · ast.odin:582

    Field_Flag :: enum int {
	Invalid, 
	Unknown, 
	Ellipsis, 
	Using, 
	No_Alias, 
	C_Vararg, 
	Const, 
	Any_Int, 
	Subtype, 
	By_Ptr, 
	No_Broadcast, 
	No_Capture, 
	Results, 
	Tags, 
	Default_Parameters, 
	Typeid_Token, 
}

    Field_Flags ¶
    Source · ast.odin:580

    Field_Flags :: distinct bit_set[Field_Flag]

    Related Constants

    Field_List ¶
    Source · ast.odin:688

    Field_List :: struct {
	using node: Node,
	open:  odin_tokenizer.Pos,
	list:  []^Field,
	close: odin_tokenizer.Pos,
}
    Procedures Through `using` From Node

    Fields Through using (4)
    From using node: Node

    Field_Value ¶
    Source · ast.odin:259

    Field_Value :: struct {
	using node: Expr,
	field: ^Expr,
	sep:   odin_tokenizer.Pos,
	value: ^Expr,
}
    Procedures Through `using` From Expr
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Expr
    • pos: odin_tokenizer.Pos // through expr_base
    • end: odin_tokenizer.Pos // through expr_base
    • state_flags: Node_State_Flags // through expr_base
    • derived: Any_Node // through expr_base
    • derived_expr: Any_Expr

    File ¶
    Source · ast.odin:70

    File :: struct {
	using node:           Node,
	id:                   int,
	pkg:                  ^Package,
	fullpath:             string,
	src:                  string,
	tags:                 [dynamic]odin_tokenizer.Token,
	docs:                 ^Comment_Group,
	// possibly nil
	pkg_decl:             ^Package_Decl,
	pkg_token:            odin_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,
}
    Procedures Through `using` From Node

    Fields Through using (4)
    From using node: Node

    Fixed_Capacity_Dynamic_Array_Type ¶
    Source · ast.odin:767

    Fixed_Capacity_Dynamic_Array_Type :: struct {
	using node:  Expr,
	tag:         ^Expr,
	// possibly nil
	open:        odin_tokenizer.Pos,
	dynamic_pos: odin_tokenizer.Pos,
	capacity:    ^Expr,
	close:       odin_tokenizer.Pos,
	elem:        ^Expr,
}
    Procedures Through `using` From Expr
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Expr
    • pos: odin_tokenizer.Pos // through expr_base
    • end: odin_tokenizer.Pos // through expr_base
    • state_flags: Node_State_Flags // through expr_base
    • derived: Any_Node // through expr_base
    • derived_expr: Any_Expr

    For_Stmt ¶
    Source · ast.odin:400

    For_Stmt :: struct {
	using node: Stmt,
	label:   ^Expr,
	// possibly nil
	for_pos: odin_tokenizer.Pos,
	init:    ^Stmt,
	// possibly nil
	cond:    ^Expr,
	// possibly nil
	post:    ^Stmt,
	// possibly nil
	body:    ^Stmt,
}
    Procedures Through `using` From Stmt
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Stmt
    • pos: odin_tokenizer.Pos // through stmt_base
    • end: odin_tokenizer.Pos // through stmt_base
    • state_flags: Node_State_Flags // through stmt_base
    • derived: Any_Node // through stmt_base
    • derived_stmt: Any_Stmt

    Foreign_Block_Decl ¶
    Source · ast.odin:518

    Foreign_Block_Decl :: struct {
	using node:      Decl,
	docs:            ^Comment_Group,
	// possibly nil
	attributes:      [dynamic]^Attribute,
	// dynamic as parsing will add to them lazily
	tok:             odin_tokenizer.Token,
	foreign_library: ^Expr,
	// possibly nil
	body:            ^Stmt,
}
    Procedures Through `using` From Decl
    Procedures Through `using` From Stmt
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Decl
    • pos: odin_tokenizer.Pos // through decl_base.stmt_base
    • end: odin_tokenizer.Pos // through decl_base.stmt_base
    • state_flags: Node_State_Flags // through decl_base.stmt_base
    • derived: Any_Node // through decl_base.stmt_base
    • derived_stmt: Any_Stmt // through decl_base

    Foreign_Import_Decl ¶
    Source · ast.odin:527

    Foreign_Import_Decl :: struct {
	using node:      Decl,
	docs:            ^Comment_Group,
	// possibly nil
	attributes:      [dynamic]^Attribute,
	// dynamic as parsing will add to them lazily
	foreign_tok:     odin_tokenizer.Token,
	import_tok:      odin_tokenizer.Token,
	name:            ^Ident,
	// possibly nil
	collection_name: string,
	fullpaths:       []^Expr,
	comment:         ^Comment_Group,
}
    Procedures Through `using` From Decl
    Procedures Through `using` From Stmt
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Decl
    • pos: odin_tokenizer.Pos // through decl_base.stmt_base
    • end: odin_tokenizer.Pos // through decl_base.stmt_base
    • state_flags: Node_State_Flags // through decl_base.stmt_base
    • derived: Any_Node // through decl_base.stmt_base
    • derived_stmt: Any_Stmt // through decl_base

    Helper_Type ¶
    Source · ast.odin:703

    Helper_Type :: struct {
	using node: Expr,
	tok:  odin_tokenizer.Token_Kind,
	type: ^Expr,
}
    Procedures Through `using` From Expr
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Expr
    • pos: odin_tokenizer.Pos // through expr_base
    • end: odin_tokenizer.Pos // through expr_base
    • state_flags: Node_State_Flags // through expr_base
    • derived: Any_Node // through expr_base
    • derived_expr: Any_Expr

    Ident ¶
    Source · ast.odin:116

    Ident :: struct {
	using node: Expr,
	name: string,
}
    Procedures Through `using` From Expr
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Expr
    • pos: odin_tokenizer.Pos // through expr_base
    • end: odin_tokenizer.Pos // through expr_base
    • state_flags: Node_State_Flags // through expr_base
    • derived: Any_Node // through expr_base
    • derived_expr: Any_Expr

    If_Stmt ¶
    Source · ast.odin:371

    If_Stmt :: struct {
	using node: Stmt,
	label:     ^Expr,
	// possibly nil
	if_pos:    odin_tokenizer.Pos,
	init:      ^Stmt,
	// possibly nil
	cond:      ^Expr,
	body:      ^Stmt,
	else_pos:  odin_tokenizer.Pos,
	else_stmt: ^Stmt,
}
    Procedures Through `using` From Stmt
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Stmt
    • pos: odin_tokenizer.Pos // through stmt_base
    • end: odin_tokenizer.Pos // through stmt_base
    • state_flags: Node_State_Flags // through stmt_base
    • derived: Any_Node // through stmt_base
    • derived_stmt: Any_Stmt

    Implicit ¶
    Source · ast.odin:121

    Implicit :: struct {
	using node: Expr,
	tok:  odin_tokenizer.Token,
}
    Procedures Through `using` From Expr
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Expr
    • pos: odin_tokenizer.Pos // through expr_base
    • end: odin_tokenizer.Pos // through expr_base
    • state_flags: Node_State_Flags // through expr_base
    • derived: Any_Node // through expr_base
    • derived_expr: Any_Expr

    Implicit_Selector_Expr ¶
    Source · ast.odin:203

    Implicit_Selector_Expr :: struct {
	using node: Expr,
	field: ^Ident,
}
    Procedures Through `using` From Expr
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Expr
    • pos: odin_tokenizer.Pos // through expr_base
    • end: odin_tokenizer.Pos // through expr_base
    • state_flags: Node_State_Flags // through expr_base
    • derived: Any_Node // through expr_base
    • derived_expr: Any_Expr

    Import_Decl ¶
    Source · ast.odin:506

    Import_Decl :: struct {
	using node: Decl,
	docs:       ^Comment_Group,
	// possibly nil
	attributes: [dynamic]^Attribute,
	// dynamic as parsing will add to them lazily
	is_using:   bool,
	import_tok: odin_tokenizer.Token,
	name:       odin_tokenizer.Token,
	relpath:    odin_tokenizer.Token,
	fullpath:   string,
	comment:    ^Comment_Group,
}
    Procedures Through `using` From Decl
    Procedures Through `using` From Stmt
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Decl
    • pos: odin_tokenizer.Pos // through decl_base.stmt_base
    • end: odin_tokenizer.Pos // through decl_base.stmt_base
    • state_flags: Node_State_Flags // through decl_base.stmt_base
    • derived: Any_Node // through decl_base.stmt_base
    • derived_stmt: Any_Stmt // through decl_base

    Index_Expr ¶
    Source · ast.odin:215

    Index_Expr :: struct {
	using node: Expr,
	expr:  ^Expr,
	open:  odin_tokenizer.Pos,
	index: ^Expr,
	close: odin_tokenizer.Pos,
}
    Procedures Through `using` From Expr
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Expr
    • pos: odin_tokenizer.Pos // through expr_base
    • end: odin_tokenizer.Pos // through expr_base
    • state_flags: Node_State_Flags // through expr_base
    • derived: Any_Node // through expr_base
    • derived_expr: Any_Expr

    Inline_Range_Stmt ¶
    Source · ast.odin:422

    Inline_Range_Stmt :: Unroll_Range_Stmt
    Procedures Through `using` From Stmt
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Stmt
    • pos: odin_tokenizer.Pos // through stmt_base
    • end: odin_tokenizer.Pos // through stmt_base
    • state_flags: Node_State_Flags // through stmt_base
    • derived: Any_Node // through stmt_base
    • derived_stmt: Any_Stmt

    Map_Type ¶
    Source · ast.odin:833

    Map_Type :: struct {
	using node: Expr,
	tok_pos: odin_tokenizer.Pos,
	key:     ^Expr,
	value:   ^Expr,
}
    Procedures Through `using` From Expr
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Expr
    • pos: odin_tokenizer.Pos // through expr_base
    • end: odin_tokenizer.Pos // through expr_base
    • state_flags: Node_State_Flags // through expr_base
    • derived: Any_Node // through expr_base
    • derived_expr: Any_Expr

    Matrix_Index_Expr ¶
    Source · ast.odin:239

    Matrix_Index_Expr :: struct {
	using node:   Expr,
	expr:         ^Expr,
	open:         odin_tokenizer.Pos,
	row_index:    ^Expr,
	column_index: ^Expr,
	close:        odin_tokenizer.Pos,
}
    Procedures Through `using` From Expr
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Expr
    • pos: odin_tokenizer.Pos // through expr_base
    • end: odin_tokenizer.Pos // through expr_base
    • state_flags: Node_State_Flags // through expr_base
    • derived: Any_Node // through expr_base
    • derived_expr: Any_Expr

    Matrix_Type ¶
    Source · ast.odin:847

    Matrix_Type :: struct {
	using node:   Expr,
	tok_pos:      odin_tokenizer.Pos,
	row_count:    ^Expr,
	column_count: ^Expr,
	elem:         ^Expr,
}
    Procedures Through `using` From Expr
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Expr
    • pos: odin_tokenizer.Pos // through expr_base
    • end: odin_tokenizer.Pos // through expr_base
    • state_flags: Node_State_Flags // through expr_base
    • derived: Any_Node // through expr_base
    • derived_expr: Any_Expr

    Multi_Pointer_Type ¶
    Source · ast.odin:741

    Multi_Pointer_Type :: struct {
	using node: Expr,
	open:    odin_tokenizer.Pos,
	pointer: odin_tokenizer.Pos,
	close:   odin_tokenizer.Pos,
	elem:    ^Expr,
}
    Procedures Through `using` From Expr
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Expr
    • pos: odin_tokenizer.Pos // through expr_base
    • end: odin_tokenizer.Pos // through expr_base
    • state_flags: Node_State_Flags // through expr_base
    • derived: Any_Node // through expr_base
    • derived_expr: Any_Expr

    Node ¶
    Source · ast.odin:41

    Node :: struct {
	pos:         odin_tokenizer.Pos,
	end:         odin_tokenizer.Pos,
	state_flags: Node_State_Flags,
	derived:     Any_Node,
}

    Related Procedures With Parameters

    Node_State_Flag ¶
    Source · ast.odin:33

    Node_State_Flag :: enum int {
	Bounds_Check, 
	No_Bounds_Check, 
	Type_Assert, 
	No_Type_Assert, 
}

    Node_State_Flags ¶
    Source · ast.odin:39

    Node_State_Flags :: distinct bit_set[Node_State_Flag]

    Or_Branch_Expr ¶
    Source · ast.odin:297

    Or_Branch_Expr :: struct {
	using node: Expr,
	expr:  ^Expr,
	token: odin_tokenizer.Token,
	label: ^Expr,
}
    Procedures Through `using` From Expr
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Expr
    • pos: odin_tokenizer.Pos // through expr_base
    • end: odin_tokenizer.Pos // through expr_base
    • state_flags: Node_State_Flags // through expr_base
    • derived: Any_Node // through expr_base
    • derived_expr: Any_Expr

    Or_Else_Expr ¶
    Source · ast.odin:284

    Or_Else_Expr :: struct {
	using node: Expr,
	x:     ^Expr,
	token: odin_tokenizer.Token,
	y:     ^Expr,
}
    Procedures Through `using` From Expr
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Expr
    • pos: odin_tokenizer.Pos // through expr_base
    • end: odin_tokenizer.Pos // through expr_base
    • state_flags: Node_State_Flags // through expr_base
    • derived: Any_Node // through expr_base
    • derived_expr: Any_Expr

    Or_Return_Expr ¶
    Source · ast.odin:291

    Or_Return_Expr :: struct {
	using node: Expr,
	expr:  ^Expr,
	token: odin_tokenizer.Token,
}
    Procedures Through `using` From Expr
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Expr
    • pos: odin_tokenizer.Pos // through expr_base
    • end: odin_tokenizer.Pos // through expr_base
    • state_flags: Node_State_Flags // through expr_base
    • derived: Any_Node // through expr_base
    • derived_expr: Any_Expr

    Package ¶
    Source · ast.odin:59

    Package :: struct {
	using node: Node,
	kind:      Package_Kind,
	id:        int,
	name:      string,
	fullpath:  string,
	files:     map[string]^File,
	user_data: rawptr,
}
    Procedures Through `using` From Node

    Fields Through using (4)
    From using node: Node

    Package_Decl ¶
    Source · ast.odin:498

    Package_Decl :: struct {
	using node: Decl,
	docs:    ^Comment_Group,
	// possibly nil
	token:   odin_tokenizer.Token,
	name:    string,
	comment: ^Comment_Group,
}
    Procedures Through `using` From Decl
    Procedures Through `using` From Stmt
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Decl
    • pos: odin_tokenizer.Pos // through decl_base.stmt_base
    • end: odin_tokenizer.Pos // through decl_base.stmt_base
    • state_flags: Node_State_Flags // through decl_base.stmt_base
    • derived: Any_Node // through decl_base.stmt_base
    • derived_stmt: Any_Stmt // through decl_base

    Package_Kind ¶
    Source · ast.odin:53

    Package_Kind :: enum int {
	Normal, 
	Runtime, 
	Init, 
}

    Paren_Expr ¶
    Source · ast.odin:189

    Paren_Expr :: struct {
	using node: Expr,
	open:  odin_tokenizer.Pos,
	expr:  ^Expr,
	close: odin_tokenizer.Pos,
}
    Procedures Through `using` From Expr
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Expr
    • pos: odin_tokenizer.Pos // through expr_base
    • end: odin_tokenizer.Pos // through expr_base
    • state_flags: Node_State_Flags // through expr_base
    • derived: Any_Node // through expr_base
    • derived_expr: Any_Expr

    Pointer_Type ¶
    Source · ast.odin:734

    Pointer_Type :: struct {
	using node: Expr,
	tag:     ^Expr,
	// possibly nil
	pointer: odin_tokenizer.Pos,
	elem:    ^Expr,
}
    Procedures Through `using` From Expr
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Expr
    • pos: odin_tokenizer.Pos // through expr_base
    • end: odin_tokenizer.Pos // through expr_base
    • state_flags: Node_State_Flags // through expr_base
    • derived: Any_Node // through expr_base
    • derived_expr: Any_Expr

    Poly_Type ¶
    Source · ast.odin:715

    Poly_Type :: struct {
	using node:     Expr,
	dollar:         odin_tokenizer.Pos,
	type:           ^Ident,
	specialization: ^Expr,
}
    Procedures Through `using` From Expr
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Expr
    • pos: odin_tokenizer.Pos // through expr_base
    • end: odin_tokenizer.Pos // through expr_base
    • state_flags: Node_State_Flags // through expr_base
    • derived: Any_Node // through expr_base
    • derived_expr: Any_Expr

    Proc_Calling_Convention ¶
    Source · ast.odin:28

    Proc_Calling_Convention :: union {
	string, 
	Proc_Calling_Convention_Extra, 
}

    Proc_Calling_Convention_Extra ¶
    Source · ast.odin:25

    Proc_Calling_Convention_Extra :: enum i32 {
	Foreign_Block_Default, 
}

    Proc_Group ¶
    Source · ast.odin:661

    Proc_Group :: struct {
	using node: Expr,
	tok:   odin_tokenizer.Token,
	open:  odin_tokenizer.Pos,
	args:  []^Expr,
	close: odin_tokenizer.Pos,
}
    Procedures Through `using` From Expr
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Expr
    • pos: odin_tokenizer.Pos // through expr_base
    • end: odin_tokenizer.Pos // through expr_base
    • state_flags: Node_State_Flags // through expr_base
    • derived: Any_Node // through expr_base
    • derived_expr: Any_Expr

    Proc_Inlining ¶
    Source · ast.odin:14

    Proc_Inlining :: enum u32 {
	None      = 0, 
	Inline    = 1, 
	No_Inline = 2, 
}

    Proc_Lit ¶
    Source · ast.odin:149

    Proc_Lit :: struct {
	using node:    Expr,
	type:          ^Proc_Type,
	body:          ^Stmt,
	// nil when it represents a foreign procedure
	tags:          Proc_Tags,
	inlining:      Proc_Inlining,
	tailing:       Proc_Tailing,
	where_token:   odin_tokenizer.Token,
	where_clauses: []^Expr,
}
    Procedures Through `using` From Expr
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Expr
    • pos: odin_tokenizer.Pos // through expr_base
    • end: odin_tokenizer.Pos // through expr_base
    • state_flags: Node_State_Flags // through expr_base
    • derived: Any_Node // through expr_base
    • derived_expr: Any_Expr

    Proc_Tag ¶
    Source · ast.odin:6

    Proc_Tag :: enum int {
	Bounds_Check, 
	No_Bounds_Check, 
	Optional_Ok, 
	Optional_Allocator_Error, 
}

    Proc_Tags ¶
    Source · ast.odin:12

    Proc_Tags :: distinct bit_set[Proc_Tag; u32]

    Proc_Tailing ¶
    Source · ast.odin:20

    Proc_Tailing :: enum u32 {
	None      = 0, 
	Must_Tail = 1, 
}

    Proc_Type ¶
    Source · ast.odin:722

    Proc_Type :: struct {
	using node:         Expr,
	tok:                odin_tokenizer.Token,
	calling_convention: Proc_Calling_Convention,
	params:             ^Field_List,
	arrow:              odin_tokenizer.Pos,
	results:            ^Field_List,
	tags:               Proc_Tags,
	generic:            bool,
	diverging:          bool,
}
    Procedures Through `using` From Expr
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Expr
    • pos: odin_tokenizer.Pos // through expr_base
    • end: odin_tokenizer.Pos // through expr_base
    • state_flags: Node_State_Flags // through expr_base
    • derived: Any_Node // through expr_base
    • derived_expr: Any_Expr

    Range_Stmt ¶
    Source · ast.odin:410

    Range_Stmt :: struct {
	using node: Stmt,
	label:   ^Expr,
	// possibly nil
	init:    ^Stmt,
	for_pos: odin_tokenizer.Pos,
	vals:    []^Expr,
	in_pos:  odin_tokenizer.Pos,
	expr:    ^Expr,
	body:    ^Stmt,
	reverse: bool,
}
    Procedures Through `using` From Stmt
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Stmt
    • pos: odin_tokenizer.Pos // through stmt_base
    • end: odin_tokenizer.Pos // through stmt_base
    • state_flags: Node_State_Flags // through stmt_base
    • derived: Any_Node // through stmt_base
    • derived_stmt: Any_Stmt

    Relative_Type ¶
    Source · ast.odin:841

    Relative_Type :: struct {
	using node: Expr,
	tag:  ^Expr,
	type: ^Expr,
}
    Procedures Through `using` From Expr
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Expr
    • pos: odin_tokenizer.Pos // through expr_base
    • end: odin_tokenizer.Pos // through expr_base
    • state_flags: Node_State_Flags // through expr_base
    • derived: Any_Node // through expr_base
    • derived_expr: Any_Expr

    Return_Stmt ¶
    Source · ast.odin:390

    Return_Stmt :: struct {
	using node: Stmt,
	results: []^Expr,
}
    Procedures Through `using` From Stmt
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Stmt
    • pos: odin_tokenizer.Pos // through stmt_base
    • end: odin_tokenizer.Pos // through stmt_base
    • state_flags: Node_State_Flags // through stmt_base
    • derived: Any_Node // through stmt_base
    • derived_stmt: Any_Stmt

    Selector_Call_Expr ¶
    Source · ast.odin:208

    Selector_Call_Expr :: struct {
	using node:    Expr,
	expr:          ^Expr,
	call:          ^Call_Expr,
	modified_call: bool,
}
    Procedures Through `using` From Expr
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Expr
    • pos: odin_tokenizer.Pos // through expr_base
    • end: odin_tokenizer.Pos // through expr_base
    • state_flags: Node_State_Flags // through expr_base
    • derived: Any_Node // through expr_base
    • derived_expr: Any_Expr

    Selector_Expr ¶
    Source · ast.odin:196

    Selector_Expr :: struct {
	using node: Expr,
	expr:  ^Expr,
	op:    odin_tokenizer.Token,
	field: ^Ident,
}
    Procedures Through `using` From Expr
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Expr
    • pos: odin_tokenizer.Pos // through expr_base
    • end: odin_tokenizer.Pos // through expr_base
    • state_flags: Node_State_Flags // through expr_base
    • derived: Any_Node // through expr_base
    • derived_expr: Any_Expr

    Slice_Expr ¶
    Source · ast.odin:229

    Slice_Expr :: struct {
	using node: Expr,
	expr:     ^Expr,
	open:     odin_tokenizer.Pos,
	low:      ^Expr,
	// possibly nil
	interval: odin_tokenizer.Token,
	high:     ^Expr,
	// possibly nil
	close:    odin_tokenizer.Pos,
}
    Procedures Through `using` From Expr
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Expr
    • pos: odin_tokenizer.Pos // through expr_base
    • end: odin_tokenizer.Pos // through expr_base
    • state_flags: Node_State_Flags // through expr_base
    • derived: Any_Node // through expr_base
    • derived_expr: Any_Expr

    Stmt ¶
    Source · ast.odin:102

    Stmt :: struct {
	using stmt_base: Node,
	derived_stmt: Any_Stmt,
}

    Related Procedures With Parameters
    Procedures Through `using` From Node

    Fields Through using (4)
    From using stmt_base: Node

    Struct_Type ¶
    Source · ast.odin:777

    Struct_Type :: struct {
	using node:      Expr,
	tok_pos:         odin_tokenizer.Pos,
	poly_params:     ^Field_List,
	// possibly nil
	align:           ^Expr,
	// possibly nil
	min_field_align: ^Expr,
	// possibly nil
	max_field_align: ^Expr,
	// possibly nil
	where_token:     odin_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,
}
    Procedures Through `using` From Expr
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Expr
    • pos: odin_tokenizer.Pos // through expr_base
    • end: odin_tokenizer.Pos // through expr_base
    • state_flags: Node_State_Flags // through expr_base
    • derived: Any_Node // through expr_base
    • derived_expr: Any_Expr

    Switch_Stmt ¶
    Source · ast.odin:448

    Switch_Stmt :: struct {
	using node: Stmt,
	label:      ^Expr,
	// possibly nil
	switch_pos: odin_tokenizer.Pos,
	init:       ^Stmt,
	// possibly nil
	cond:       ^Expr,
	body:       ^Stmt,
	partial:    bool,
}
    Procedures Through `using` From Stmt
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Stmt
    • pos: odin_tokenizer.Pos // through stmt_base
    • end: odin_tokenizer.Pos // through stmt_base
    • state_flags: Node_State_Flags // through stmt_base
    • derived: Any_Node // through stmt_base
    • derived_stmt: Any_Stmt

    Tag_Expr ¶
    Source · ast.odin:169

    Tag_Expr :: struct {
	using node: Expr,
	op:   odin_tokenizer.Token,
	name: string,
	expr: ^Expr,
}
    Procedures Through `using` From Expr
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Expr
    • pos: odin_tokenizer.Pos // through expr_base
    • end: odin_tokenizer.Pos // through expr_base
    • state_flags: Node_State_Flags // through expr_base
    • derived: Any_Node // through expr_base
    • derived_expr: Any_Expr

    Tag_Stmt ¶
    Source · ast.odin:347

    Tag_Stmt :: struct {
	using node: Stmt,
	op:   odin_tokenizer.Token,
	name: string,
	stmt: ^Stmt,
}
    Procedures Through `using` From Stmt
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Stmt
    • pos: odin_tokenizer.Pos // through stmt_base
    • end: odin_tokenizer.Pos // through stmt_base
    • state_flags: Node_State_Flags // through stmt_base
    • derived: Any_Node // through stmt_base
    • derived_stmt: Any_Stmt

    Ternary_If_Expr ¶
    Source · ast.odin:266

    Ternary_If_Expr :: struct {
	using node: Expr,
	x:    ^Expr,
	op1:  odin_tokenizer.Token,
	cond: ^Expr,
	op2:  odin_tokenizer.Token,
	y:    ^Expr,
}
    Procedures Through `using` From Expr
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Expr
    • pos: odin_tokenizer.Pos // through expr_base
    • end: odin_tokenizer.Pos // through expr_base
    • state_flags: Node_State_Flags // through expr_base
    • derived: Any_Node // through expr_base
    • derived_expr: Any_Expr

    Ternary_When_Expr ¶
    Source · ast.odin:275

    Ternary_When_Expr :: struct {
	using node: Expr,
	x:    ^Expr,
	op1:  odin_tokenizer.Token,
	cond: ^Expr,
	op2:  odin_tokenizer.Token,
	y:    ^Expr,
}
    Procedures Through `using` From Expr
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Expr
    • pos: odin_tokenizer.Pos // through expr_base
    • end: odin_tokenizer.Pos // through expr_base
    • state_flags: Node_State_Flags // through expr_base
    • derived: Any_Node // through expr_base
    • derived_expr: Any_Expr

    Type_Assertion ¶
    Source · ast.odin:304

    Type_Assertion :: struct {
	using node: Expr,
	expr:  ^Expr,
	dot:   odin_tokenizer.Pos,
	open:  odin_tokenizer.Pos,
	type:  ^Expr,
	close: odin_tokenizer.Pos,
}
    Procedures Through `using` From Expr
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Expr
    • pos: odin_tokenizer.Pos // through expr_base
    • end: odin_tokenizer.Pos // through expr_base
    • state_flags: Node_State_Flags // through expr_base
    • derived: Any_Node // through expr_base
    • derived_expr: Any_Expr

    Type_Cast ¶
    Source · ast.odin:313

    Type_Cast :: struct {
	using node: Expr,
	tok:   odin_tokenizer.Token,
	open:  odin_tokenizer.Pos,
	type:  ^Expr,
	close: odin_tokenizer.Pos,
	expr:  ^Expr,
}
    Procedures Through `using` From Expr
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Expr
    • pos: odin_tokenizer.Pos // through expr_base
    • end: odin_tokenizer.Pos // through expr_base
    • state_flags: Node_State_Flags // through expr_base
    • derived: Any_Node // through expr_base
    • derived_expr: Any_Expr

    Type_Switch_Stmt ¶
    Source · ast.odin:458

    Type_Switch_Stmt :: struct {
	using node: Stmt,
	label:      ^Expr,
	// possibly nil
	switch_pos: odin_tokenizer.Pos,
	tag:        ^Stmt,
	expr:       ^Expr,
	body:       ^Stmt,
	partial:    bool,
}
    Procedures Through `using` From Stmt
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Stmt
    • pos: odin_tokenizer.Pos // through stmt_base
    • end: odin_tokenizer.Pos // through stmt_base
    • state_flags: Node_State_Flags // through stmt_base
    • derived: Any_Node // through stmt_base
    • derived_stmt: Any_Stmt

    Typeid_Type ¶
    Source · ast.odin:697

    Typeid_Type :: struct {
	using node:     Expr,
	tok:            odin_tokenizer.Token_Kind,
	specialization: ^Expr,
}
     

    Types

    Procedures Through `using` From Expr
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Expr
    • pos: odin_tokenizer.Pos // through expr_base
    • end: odin_tokenizer.Pos // through expr_base
    • state_flags: Node_State_Flags // through expr_base
    • derived: Any_Node // through expr_base
    • derived_expr: Any_Expr

    Unary_Expr ¶
    Source · ast.odin:176

    Unary_Expr :: struct {
	using node: Expr,
	op:   odin_tokenizer.Token,
	expr: ^Expr,
}
    Procedures Through `using` From Expr
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Expr
    • pos: odin_tokenizer.Pos // through expr_base
    • end: odin_tokenizer.Pos // through expr_base
    • state_flags: Node_State_Flags // through expr_base
    • derived: Any_Node // through expr_base
    • derived_expr: Any_Expr

    Undef ¶
    Source · ast.odin:127

    Undef :: struct {
	using node: Expr,
	tok:  odin_tokenizer.Token_Kind,
}
    Procedures Through `using` From Expr
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Expr
    • pos: odin_tokenizer.Pos // through expr_base
    • end: odin_tokenizer.Pos // through expr_base
    • state_flags: Node_State_Flags // through expr_base
    • derived: Any_Node // through expr_base
    • derived_expr: Any_Expr

    Union_Type ¶
    Source · ast.odin:802

    Union_Type :: struct {
	using node:    Expr,
	tok_pos:       odin_tokenizer.Pos,
	poly_params:   ^Field_List,
	// possibly nil
	align:         ^Expr,
	// possibly nil
	kind:          Union_Type_Kind,
	where_token:   odin_tokenizer.Token,
	where_clauses: []^Expr,
	variants:      []^Expr,
}
    Procedures Through `using` From Expr
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Expr
    • pos: odin_tokenizer.Pos // through expr_base
    • end: odin_tokenizer.Pos // through expr_base
    • state_flags: Node_State_Flags // through expr_base
    • derived: Any_Node // through expr_base
    • derived_expr: Any_Expr

    Union_Type_Kind ¶
    Source · ast.odin:795

    Union_Type_Kind :: enum u8 {
	Normal, 
	maybe, 
	no_nil, 
	shared_nil, 
}

    Unroll_Range_Stmt ¶
    Source · ast.odin:424

    Unroll_Range_Stmt :: struct {
	using node: Stmt,
	label:      ^Expr,
	// possibly nil
	unroll_pos: odin_tokenizer.Pos,
	args:       []^Expr,
	for_pos:    odin_tokenizer.Pos,
	val0:       ^Expr,
	val1:       ^Expr,
	// possibly nil
	in_pos:     odin_tokenizer.Pos,
	expr:       ^Expr,
	body:       ^Stmt,
}
    Procedures Through `using` From Stmt
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Stmt
    • pos: odin_tokenizer.Pos // through stmt_base
    • end: odin_tokenizer.Pos // through stmt_base
    • state_flags: Node_State_Flags // through stmt_base
    • derived: Any_Node // through stmt_base
    • derived_stmt: Any_Stmt

    Using_Stmt ¶
    Source · ast.odin:474

    Using_Stmt :: struct {
	using node: Stmt,
	list: []^Expr,
}
    Procedures Through `using` From Stmt
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Stmt
    • pos: odin_tokenizer.Pos // through stmt_base
    • end: odin_tokenizer.Pos // through stmt_base
    • state_flags: Node_State_Flags // through stmt_base
    • derived: Any_Node // through stmt_base
    • derived_stmt: Any_Stmt

    Value_Decl ¶
    Source · ast.odin:486

    Value_Decl :: struct {
	using node: Decl,
	docs:       ^Comment_Group,
	// possibly nil
	attributes: [dynamic]^Attribute,
	// dynamic as parsing will add to them lazily
	names:      []^Expr,
	type:       ^Expr,
	// possibly nil
	values:     []^Expr,
	comment:    ^Comment_Group,
	// possibly nil
	is_using:   bool,
	is_mutable: bool,
}
    Procedures Through `using` From Decl
    Procedures Through `using` From Stmt
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Decl
    • pos: odin_tokenizer.Pos // through decl_base.stmt_base
    • end: odin_tokenizer.Pos // through decl_base.stmt_base
    • state_flags: Node_State_Flags // through decl_base.stmt_base
    • derived: Any_Node // through decl_base.stmt_base
    • derived_stmt: Any_Stmt // through decl_base

    Visitor ¶
    Source · walk.odin:8

    Visitor :: struct {
	visit: proc(visitor: ^Visitor, node: ^Node) -> ^Visitor,
	data:  rawptr,
}
     

    A 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)

    Related Procedures With Parameters

    walk

    When_Stmt ¶
    Source · ast.odin:382

    When_Stmt :: struct {
	using node: Stmt,
	when_pos:  odin_tokenizer.Pos,
	cond:      ^Expr,
	body:      ^Stmt,
	else_stmt: ^Stmt,
}
    Procedures Through `using` From Stmt
    Procedures Through `using` From Node

    Fields Through using (5)
    From using node: Stmt
    • pos: odin_tokenizer.Pos // through stmt_base
    • end: odin_tokenizer.Pos // through stmt_base
    • state_flags: Node_State_Flags // through stmt_base
    • derived: Any_Node // through stmt_base
    • derived_stmt: Any_Stmt

    Constants

    Field_Flags_Record_Poly_Params ¶
    Source · ast.odin:641

    Field_Flags_Record_Poly_Params :: Field_Flags{.Typeid_Token, .Default_Parameters}

    Field_Flags_Signature ¶
    Source · ast.odin:645

    Field_Flags_Signature :: Field_Flags{.Ellipsis, .Using, .No_Alias, .C_Vararg, .Const, .Any_Int, .By_Ptr, .No_Broadcast, .Default_Parameters}

    Field_Flags_Signature_Params ¶
    Source · ast.odin:657

    Field_Flags_Signature_Params :: Field_Flags_Signature | {Field_Flag.Typeid_Token}

    Field_Flags_Signature_Results ¶
    Source · ast.odin:658

    Field_Flags_Signature_Results :: Field_Flags_Signature

    Field_Flags_Struct ¶
    Source · ast.odin:636

    Field_Flags_Struct :: Field_Flags{.Using, .Tags, .Subtype}

    Variables

    field_flag_strings ¶
    Source · ast.odin:603

    field_flag_strings: [Field_Flag]string = …

    field_hash_flag_strings ¶
    Source · ast.odin:624

    field_hash_flag_strings: []struct {
	key:  string,
	flag: Field_Flag,
} = …

    Procedures

    clone_array ¶
    Source · clone.odin:44

    clone_array :: proc(array: $A/[]^$T) -> A {…}

    Related Procedure Groups

    clone

    clone_decl ¶
    Source · clone.odin:72

    clone_decl :: proc(node: ^Decl) -> ^Decl {…}

    Related Procedure Groups

    clone

    clone_dynamic_array ¶
    Source · clone.odin:55

    clone_dynamic_array :: proc(array: $A/[dynamic]^$T) -> A {…}

    Related Procedure Groups

    clone

    clone_expr ¶
    Source · clone.odin:66

    clone_expr :: proc(node: ^Expr) -> ^Expr {…}

    Related Procedure Groups

    clone

    clone_node ¶
    Source · clone.odin:75

    clone_node :: proc(node: ^Node) -> ^Node {…}

    Related Procedure Groups

    clone

    clone_stmt ¶
    Source · clone.odin:69

    clone_stmt :: proc(node: ^Stmt) -> ^Stmt {…}

    Related Procedure Groups

    clone

    inspect ¶
    Source · walk.odin:18

    inspect :: proc(node: ^Node, f: proc(^Node) -> bool) {…}
     

    inspect 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 ¶
    Source · clone.odin:26

    new_from_pos_and_end_node :: proc($T: typeid, pos: odin_tokenizer.Pos, end: ^Node) -> ^T {…}

    Related Procedure Groups

    new

    new_from_positions ¶
    Source · clone.odin:10

    new_from_positions :: proc($T: typeid, pos, end: odin_tokenizer.Pos) -> ^T {…}

    Related Procedure Groups

    new

    strip_or_return_expr ¶
    Source · ast.odin:557

    strip_or_return_expr :: proc(expr: ^Expr) -> (val: ^Expr) {…}

    unparen_expr ¶
    Source · ast.odin:542

    unparen_expr :: proc(expr: ^Expr) -> (val: ^Expr) {…}
     

    Other things

    walk ¶
    Source · walk.odin:37

    walk :: proc(v: ^Visitor, node: ^Node) {…}
     

    walk 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

    Procedure Groups

    clone ¶
    Source · clone.odin:35

    new ¶
    Source · clone.odin:30

    Source Files

    Generation Information

    Generated with odin version dev-2026-10 (vendor "odin") Windows_amd64 @ 2026-10-10 00:25:51.511820200 +0000 UTC