package core:odin/ast

⌘K
Ctrl+K
or
/

    Index

    Types (100)
    Procedure Groups (2)

    Types

    Array_Type ¶

    Array_Type :: struct {
    	using node: Expr,
    	open:  odin_tokenizer.Pos,
    	tag:   ^Expr,
    	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

    Assign_Stmt ¶

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

    Attribute ¶

    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

    Auto_Cast ¶

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

    Bad_Decl ¶

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

    Bad_Expr ¶

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

    Bad_Stmt ¶

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

    Basic_Directive ¶

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

    Basic_Lit ¶

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

    Binary_Expr ¶

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

    Bit_Field_Field ¶

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

    Bit_Field_Type ¶

    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

    Bit_Set_Type ¶

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

    Block_Stmt ¶

    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

    Branch_Stmt ¶

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

    Call_Expr ¶

    Call_Expr :: struct {
    	using node: Expr,
    	inlining: Proc_Inlining,
    	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

    Case_Clause ¶

    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

    Comment_Group ¶

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

    Comp_Lit ¶

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

    Decl ¶

    Decl :: struct {
    	using decl_base: Stmt,
    }
    Related Procedures With Parameters
    Procedures Through `using` From Stmt
    Procedures Through `using` From Node

    Defer_Stmt ¶

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

    Deref_Expr ¶

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

    Distinct_Type ¶

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

    Dynamic_Array_Type ¶

    Dynamic_Array_Type :: struct {
    	using node:  Expr,
    	tag:         ^Expr,
    	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

    Ellipsis ¶

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

    Empty_Stmt ¶

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

    Enum_Type ¶

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

    Expr ¶

    Expr :: struct {
    	using expr_base: Node,
    	derived_expr: Any_Expr,
    }
    Related Procedures With Parameters
    Procedures Through `using` From Node

    Expr_Stmt ¶

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

    Field ¶

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

    Field_Flag ¶

    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_List ¶

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

    Field_Value ¶

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

    File ¶

    File :: struct {
    	using node:           Node,
    	id:                   int,
    	pkg:                  ^Package,
    	fullpath:             string,
    	src:                  string,
    	tags:                 [dynamic]odin_tokenizer.Token,
    	docs:                 ^Comment_Group,
    	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

    For_Stmt ¶

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

    Foreign_Block_Decl ¶

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

    Foreign_Import_Decl ¶

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

    Helper_Type ¶

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

    Ident ¶

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

    If_Stmt ¶

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

    Implicit ¶

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

    Implicit_Selector_Expr ¶

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

    Import_Decl ¶

    Import_Decl :: struct {
    	using node: Decl,
    	docs:       ^Comment_Group,
    	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

    Index_Expr ¶

    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

    Inline_Asm_Dialect ¶

    Inline_Asm_Dialect :: enum u8 {
    	Default = 0, 
    	ATT     = 1, 
    	Intel   = 2, 
    }

    Inline_Asm_Expr ¶

    Inline_Asm_Expr :: struct {
    	using node:         Expr,
    	tok:                odin_tokenizer.Token,
    	param_types:        []^Expr,
    	return_type:        ^Expr,
    	has_side_effects:   bool,
    	is_align_stack:     bool,
    	dialect:            Inline_Asm_Dialect,
    	open:               odin_tokenizer.Pos,
    	constraints_string: ^Expr,
    	asm_string:         ^Expr,
    	close:              odin_tokenizer.Pos,
    }
    Procedures Through `using` From Expr
    Procedures Through `using` From Node

    Inline_Range_Stmt ¶

    Inline_Range_Stmt :: struct {
    	using node: Stmt,
    	label:      ^Expr,
    	inline_pos: odin_tokenizer.Pos,
    	for_pos:    odin_tokenizer.Pos,
    	val0:       ^Expr,
    	val1:       ^Expr,
    	in_pos:     odin_tokenizer.Pos,
    	expr:       ^Expr,
    	body:       ^Stmt,
    }
    Procedures Through `using` From Stmt
    Procedures Through `using` From Node

    Map_Type ¶

    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

    Matrix_Index_Expr ¶

    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

    Matrix_Type ¶

    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

    Multi_Pointer_Type ¶

    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

    Node ¶

    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 ¶

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

    Node_State_Flags ¶

    Node_State_Flags :: distinct bit_set[Node_State_Flag]

    Or_Branch_Expr ¶

    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

    Or_Else_Expr ¶

    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

    Or_Return_Expr ¶

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

    Package ¶

    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

    Package_Decl ¶

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

    Package_Kind ¶

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

    Paren_Expr ¶

    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

    Pointer_Type ¶

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

    Poly_Type ¶

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

    Proc_Calling_Convention_Extra ¶

    Proc_Calling_Convention_Extra :: enum i32 {
    	Foreign_Block_Default, 
    }

    Proc_Group ¶

    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

    Proc_Inlining ¶

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

    Proc_Lit ¶

    Proc_Lit :: struct {
    	using node:    Expr,
    	type:          ^Proc_Type,
    	body:          ^Stmt,
    	tags:          Proc_Tags,
    	inlining:      Proc_Inlining,
    	where_token:   odin_tokenizer.Token,
    	where_clauses: []^Expr,
    }
    Procedures Through `using` From Expr
    Procedures Through `using` From Node

    Proc_Tag ¶

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

    Proc_Tags ¶

    Proc_Tags :: distinct bit_set[Proc_Tag; u32]

    Proc_Type ¶

    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

    Range_Stmt ¶

    Range_Stmt :: struct {
    	using node: Stmt,
    	label:   ^Expr,
    	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

    Relative_Type ¶

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

    Return_Stmt ¶

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

    Selector_Call_Expr ¶

    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

    Selector_Expr ¶

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

    Slice_Expr ¶

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

    Stmt ¶

    Stmt :: struct {
    	using stmt_base: Node,
    	derived_stmt: Any_Stmt,
    }
    Related Procedures With Parameters
    Procedures Through `using` From Node

    Struct_Type ¶

    Struct_Type :: struct {
    	using node:      Expr,
    	tok_pos:         odin_tokenizer.Pos,
    	poly_params:     ^Field_List,
    	align:           ^Expr,
    	min_field_align: ^Expr,
    	max_field_align: ^Expr,
    	where_token:     odin_tokenizer.Token,
    	where_clauses:   []^Expr,
    	is_packed:       bool,
    	is_raw_union:    bool,
    	is_no_copy:      bool,
    	fields:          ^Field_List,
    	name_count:      int,
    }
    Procedures Through `using` From Expr
    Procedures Through `using` From Node

    Switch_Stmt ¶

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

    Tag_Expr ¶

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

    Tag_Stmt ¶

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

    Ternary_If_Expr ¶

    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

    Ternary_When_Expr ¶

    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

    Type_Assertion ¶

    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

    Type_Cast ¶

    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

    Type_Switch_Stmt ¶

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

    Typeid_Type ¶

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

    Types

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

    Unary_Expr ¶

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

    Undef ¶

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

    Union_Type ¶

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

    Union_Type_Kind ¶

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

    Using_Stmt ¶

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

    Value_Decl ¶

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

    Visitor ¶

    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

    When_Stmt ¶

    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

    Constants

    Field_Flags_Record_Poly_Params ¶

    Field_Flags_Record_Poly_Params :: Field_Flags{.Typeid_Token, .Default_Parameters}

    Field_Flags_Signature ¶

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

    Field_Flags_Signature_Params ¶

    Field_Flags_Signature_Params :: Field_Flags_Signature | {Field_Flag.Typeid_Token}

    Field_Flags_Signature_Results ¶

    Field_Flags_Signature_Results :: Field_Flags_Signature

    Field_Flags_Struct ¶

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

    Variables

    field_flag_strings ¶

    field_flag_strings: [Field_Flag]string = …

    field_hash_flag_strings ¶

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

    Procedures

    clone_array ¶

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

    clone_decl ¶

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

    clone_dynamic_array ¶

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

    clone_expr ¶

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

    clone_node ¶

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

    clone_stmt ¶

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

    inspect ¶

    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 ¶

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

    new_from_positions ¶

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

    strip_or_return_expr ¶

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

    unparen_expr ¶

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

    Other things

    walk ¶

    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

    Source Files

    Generation Information

    Generated with odin version dev-2024-10 (vendor "odin") Windows_amd64 @ 2024-10-05 21:10:06.321434200 +0000 UTC