package core:odin/ast

Source

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, 
	^Struct_Type, 
	^Union_Type, 
	^Enum_Type, 
	^Bit_Set_Type, 
	^Map_Type, 
	^Relative_Type, 
	^Matrix_Type, 
	^Bit_Field_Type, 
}

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, 
	^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, 
}

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, 
	^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, 
}

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,
}

Assign_Stmt :: struct {
	using node: Stmt,
	lhs:  []^Expr,
	op:   odin_tokenizer.Token,
	rhs:  []^Expr,
}

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

Auto_Cast :: struct {
	using node: Expr,
	op:   odin_tokenizer.Token,
	expr: ^Expr,
}

Bad_Decl :: struct {
	using node: Decl,
}

Bad_Expr :: struct {
	using node: Expr,
}

Bad_Stmt :: struct {
	using node: Stmt,
}

Basic_Directive :: struct {
	using node: Expr,
	tok:  odin_tokenizer.Token,
	name: string,
}

Basic_Lit :: struct {
	using node: Expr,
	tok:  odin_tokenizer.Token,
}

Binary_Expr :: struct {
	using node: Expr,
	left:  ^Expr,
	op:    odin_tokenizer.Token,
	right: ^Expr,
}

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,
}

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,
}

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,
}

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

Branch_Stmt :: struct {
	using node: Stmt,
	tok:   odin_tokenizer.Token,
	label: ^Ident,
}

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,
}

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

Comment_Group :: struct {
	using node: Node,
	list: []odin_tokenizer.Token,
}

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,
}

Decl :: struct {
	using decl_base: Stmt,
}

Defer_Stmt :: struct {
	using node: Stmt,
	stmt: ^Stmt,
}

Deref_Expr :: struct {
	using node: Expr,
	expr: ^Expr,
	op:   odin_tokenizer.Token,
}

Distinct_Type :: struct {
	using node: Expr,
	tok:  odin_tokenizer.Token_Kind,
	type: ^Expr,
}

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,
}

Ellipsis :: struct {
	using node: Expr,
	tok:  odin_tokenizer.Token_Kind,
	expr: ^Expr,
}

Empty_Stmt :: struct {
	using node: Stmt,
	semicolon: odin_tokenizer.Pos,
}

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,
}

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

Expr_Stmt :: struct {
	using node: Stmt,
	expr: ^Expr,
}

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,
}

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 :: distinct bit_set[Field_Flag]

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

Field_Value :: struct {
	using node: Expr,
	field: ^Expr,
	sep:   odin_tokenizer.Pos,
	value: ^Expr,
}

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,
}

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,
}

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,
}

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,
}

Helper_Type :: struct {
	using node: Expr,
	tok:  odin_tokenizer.Token_Kind,
	type: ^Expr,
}

Ident :: struct {
	using node: Expr,
	name: string,
}

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,
}

Implicit :: struct {
	using node: Expr,
	tok:  odin_tokenizer.Token,
}

Implicit_Selector_Expr :: struct {
	using node: Expr,
	field: ^Ident,
}

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,
}

Index_Expr :: struct {
	using node: Expr,
	expr:  ^Expr,
	open:  odin_tokenizer.Pos,
	index: ^Expr,
	close: odin_tokenizer.Pos,
}

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

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,
}

Inline_Range_Stmt :: Unroll_Range_Stmt

Map_Type :: struct {
	using node: Expr,
	tok_pos: odin_tokenizer.Pos,
	key:     ^Expr,
	value:   ^Expr,
}

Matrix_Index_Expr :: struct {
	using node:   Expr,
	expr:         ^Expr,
	open:         odin_tokenizer.Pos,
	row_index:    ^Expr,
	column_index: ^Expr,
	close:        odin_tokenizer.Pos,
}

Matrix_Type :: struct {
	using node:   Expr,
	tok_pos:      odin_tokenizer.Pos,
	row_count:    ^Expr,
	column_count: ^Expr,
	elem:         ^Expr,
}

Multi_Pointer_Type :: struct {
	using node: Expr,
	open:    odin_tokenizer.Pos,
	pointer: odin_tokenizer.Pos,
	close:   odin_tokenizer.Pos,
	elem:    ^Expr,
}

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

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

Node_State_Flags :: distinct bit_set[Node_State_Flag]

Or_Branch_Expr :: struct {
	using node: Expr,
	expr:  ^Expr,
	token: odin_tokenizer.Token,
	label: ^Expr,
}

Or_Else_Expr :: struct {
	using node: Expr,
	x:     ^Expr,
	token: odin_tokenizer.Token,
	y:     ^Expr,
}

Or_Return_Expr :: struct {
	using node: Expr,
	expr:  ^Expr,
	token: odin_tokenizer.Token,
}

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

Package_Decl :: struct {
	using node: Decl,
	docs:    ^Comment_Group,
	// possibly nil
	token:   odin_tokenizer.Token,
	name:    string,
	comment: ^Comment_Group,
}

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

Paren_Expr :: struct {
	using node: Expr,
	open:  odin_tokenizer.Pos,
	expr:  ^Expr,
	close: odin_tokenizer.Pos,
}

Pointer_Type :: struct {
	using node: Expr,
	tag:     ^Expr,
	// possibly nil
	pointer: odin_tokenizer.Pos,
	elem:    ^Expr,
}

Poly_Type :: struct {
	using node:     Expr,
	dollar:         odin_tokenizer.Pos,
	type:           ^Ident,
	specialization: ^Expr,
}

Proc_Calling_Convention :: union {
	string, 
	Proc_Calling_Convention_Extra, 
}

Proc_Calling_Convention_Extra :: enum i32 {
	Foreign_Block_Default, 
}

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

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

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

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

Proc_Tags :: distinct bit_set[Proc_Tag; u32]

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,
}

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

Relative_Type :: struct {
	using node: Expr,
	tag:  ^Expr,
	type: ^Expr,
}

Return_Stmt :: struct {
	using node: Stmt,
	results: []^Expr,
}

Selector_Call_Expr :: struct {
	using node:    Expr,
	expr:          ^Expr,
	call:          ^Call_Expr,
	modified_call: bool,
}

Selector_Expr :: struct {
	using node: Expr,
	expr:  ^Expr,
	op:    odin_tokenizer.Token,
	field: ^Ident,
}

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,
}

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

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,
	fields:          ^Field_List,
	name_count:      int,
}

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,
}

Tag_Expr :: struct {
	using node: Expr,
	op:   odin_tokenizer.Token,
	name: string,
	expr: ^Expr,
}

Tag_Stmt :: struct {
	using node: Stmt,
	op:   odin_tokenizer.Token,
	name: string,
	stmt: ^Stmt,
}

Ternary_If_Expr :: struct {
	using node: Expr,
	x:    ^Expr,
	op1:  odin_tokenizer.Token,
	cond: ^Expr,
	op2:  odin_tokenizer.Token,
	y:    ^Expr,
}

Ternary_When_Expr :: struct {
	using node: Expr,
	x:    ^Expr,
	op1:  odin_tokenizer.Token,
	cond: ^Expr,
	op2:  odin_tokenizer.Token,
	y:    ^Expr,
}

Type_Assertion :: struct {
	using node: Expr,
	expr:  ^Expr,
	dot:   odin_tokenizer.Pos,
	open:  odin_tokenizer.Pos,
	type:  ^Expr,
	close: odin_tokenizer.Pos,
}

Type_Cast :: struct {
	using node: Expr,
	tok:   odin_tokenizer.Token,
	open:  odin_tokenizer.Pos,
	type:  ^Expr,
	close: odin_tokenizer.Pos,
	expr:  ^Expr,
}

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

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

Unary_Expr :: struct {
	using node: Expr,
	op:   odin_tokenizer.Token,
	expr: ^Expr,
}

Undef :: struct {
	using node: Expr,
	tok:  odin_tokenizer.Token_Kind,
}

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,
}

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

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,
}

Using_Stmt :: struct {
	using node: Stmt,
	list: []^Expr,
}

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,
}

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

When_Stmt :: struct {
	using node: Stmt,
	when_pos:  odin_tokenizer.Pos,
	cond:      ^Expr,
	body:      ^Stmt,
	else_stmt: ^Stmt,
}

Field_Flags_Record_Poly_Params :: Field_Flags{.Typeid_Token, .Default_Parameters}

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 | {Field_Flag.Typeid_Token}

Field_Flags_Signature_Results :: Field_Flags_Signature

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

field_flag_strings: [Field_Flag]string = …

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

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

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

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

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

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

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

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

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

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

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

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

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

clone :: proc{
	clone_node,
	clone_expr,
	clone_stmt,
	clone_decl,
	clone_array,
	clone_dynamic_array,
}

new :: proc{
	new_from_positions,
	new_from_pos_and_end_node,
}