Replace any with union for subtyping in core:odin/ast

core/odin/ast/ast.odin

@@ -34,7 +34,7 @@ Node :: struct {
 	pos:         tokenizer.Pos,
 	end:         tokenizer.Pos,
 	state_flags: Node_State_Flags,
-	derived:     any,
+	derived:     Any_Node,
 }
 
 Comment_Group :: struct {
@@ -88,9 +88,11 @@ File :: struct {
 
 Expr :: struct {
 	using expr_base: Node,
+	derived_expr: Any_Expr,
 }
 Stmt :: struct {
 	using stmt_base: Node,
+	derived_stmt: Any_Stmt,
 }
 Decl :: struct {
 	using decl_base: Stmt,
@@ -541,7 +543,7 @@ unparen_expr :: proc(expr: ^Expr) -> (val: ^Expr) {
 		return
 	}
 	for {
-		e, ok := val.derived.(Paren_Expr)
+		e, ok := val.derived.(^Paren_Expr)
 		if !ok || e.expr == nil {
 			break
 		}
@@ -758,4 +760,173 @@ Matrix_Type :: struct {
 	row_count:    ^Expr,
 	column_count: ^Expr,
 	elem:         ^Expr,
-}
+}
+
+
+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,
+	^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,
+
+	^Bad_Stmt,
+	^Empty_Stmt,
+	^Expr_Stmt,
+	^Tag_Stmt,
+	^Assign_Stmt,
+	^Block_Stmt,
+	^If_Stmt,
+	^When_Stmt,
+	^Return_Stmt,
+	^Defer_Stmt,
+	^For_Stmt,
+	^Range_Stmt,
+	^Inline_Range_Stmt,
+	^Case_Clause,
+	^Switch_Stmt,
+	^Type_Switch_Stmt,
+	^Branch_Stmt,
+	^Using_Stmt,
+
+	^Bad_Decl,
+	^Value_Decl,
+	^Package_Decl,
+	^Import_Decl,
+	^Foreign_Block_Decl,
+	^Foreign_Import_Decl,
+
+	^Attribute,
+	^Field,
+	^Field_List,
+}
+
+
+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,
+	^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,
+}
+
+
+Any_Stmt :: union {
+	^Bad_Stmt,
+	^Empty_Stmt,
+	^Expr_Stmt,
+	^Tag_Stmt,
+	^Assign_Stmt,
+	^Block_Stmt,
+	^If_Stmt,
+	^When_Stmt,
+	^Return_Stmt,
+	^Defer_Stmt,
+	^For_Stmt,
+	^Range_Stmt,
+	^Inline_Range_Stmt,
+	^Case_Clause,
+	^Switch_Stmt,
+	^Type_Switch_Stmt,
+	^Branch_Stmt,
+	^Using_Stmt,
+
+	^Bad_Decl,
+	^Value_Decl,
+	^Package_Decl,
+	^Import_Decl,
+	^Foreign_Block_Decl,
+	^Foreign_Import_Decl,
+}

core/odin/ast/clone.odin

@@ -1,16 +1,25 @@
 package odin_ast
 
+import "core:intrinsics"
 import "core:mem"
 import "core:fmt"
+import "core:reflect"
 import "core:odin/tokenizer"
+_ :: intrinsics
 
 new :: proc($T: typeid, pos, end: tokenizer.Pos) -> ^T {
 	n, _ := mem.new(T)
 	n.pos = pos
 	n.end = end
-	n.derived = n^
+	n.derived = n
 	base: ^Node = n // dummy check
 	_ = base // "Use" type to make -vet happy
+	when intrinsics.type_has_field(T, "derived_expr") {
+		n.derived_expr = n
+	}
+	when intrinsics.type_has_field(T, "derived_stmt") {
+		n.derived_stmt = n
+	}
 	return n
 }
 
@@ -61,228 +70,248 @@ clone_node :: proc(node: ^Node) -> ^Node {
 
 	size := size_of(Node)
 	align := align_of(Node)
-	ti := type_info_of(node.derived.id)
+	ti := reflect.union_variant_type_info(node.derived)
 	if ti != nil {
 		size = ti.size
 		align = ti.align
 	}
 
-	switch in node.derived {
-	case Package, File:
+	#partial switch in node.derived {
+	case ^Package, ^File:
 		panic("Cannot clone this node type")
 	}
 
 	res := cast(^Node)mem.alloc(size, align)
 	src: rawptr = node
 	if node.derived != nil {
-		src = node.derived.data
+		src = (^rawptr)(&node.derived)^
 	}
 	mem.copy(res, src, size)
-	res.derived.data = rawptr(res)
-	res.derived.id = node.derived.id
+	res_any: any
+	res_any.data = res
+	res_any.id = ti.id
 
-	switch r in &res.derived {
-	case Bad_Expr:
-	case Ident:
-	case Implicit:
-	case Undef:
-	case Basic_Lit:
+	reflect.set_union_value(res.derived, res_any)
 
-	case Ellipsis:
+	derived_expr := reflect.struct_field_value_by_name(res_any, "derived_expr", true)
+	derived_stmt := reflect.struct_field_value_by_name(res_any, "derived_stmt", true)
+	reflect.set_union_value(res.derived, derived_expr)
+	reflect.set_union_value(res.derived, derived_stmt)
+
+	switch r in res.derived {
+	case ^Package, ^File:
+	case ^Bad_Expr:
+	case ^Ident:
+	case ^Implicit:
+	case ^Undef:
+	case ^Basic_Lit:
+	case ^Basic_Directive:
+	case ^Comment_Group:
+
+	case ^Ellipsis:
 		r.expr = clone(r.expr)
-	case Proc_Lit:
+	case ^Proc_Lit:
 		r.type = auto_cast clone(r.type)
 		r.body = clone(r.body)
-	case Comp_Lit:
+	case ^Comp_Lit:
 		r.type  = clone(r.type)
 		r.elems = clone(r.elems)
 
-	case Tag_Expr:
+	case ^Tag_Expr:
 		r.expr = clone(r.expr)
-	case Unary_Expr:
+	case ^Unary_Expr:
 		r.expr = clone(r.expr)
-	case Binary_Expr:
+	case ^Binary_Expr:
 		r.left  = clone(r.left)
 		r.right = clone(r.right)
-	case Paren_Expr:
+	case ^Paren_Expr:
 		r.expr = clone(r.expr)
-	case Selector_Expr:
+	case ^Selector_Expr:
 		r.expr = clone(r.expr)
 		r.field = auto_cast clone(r.field)
-	case Implicit_Selector_Expr:
+	case ^Implicit_Selector_Expr:
 		r.field = auto_cast clone(r.field)
-	case Selector_Call_Expr:
+	case ^Selector_Call_Expr:
 		r.expr = clone(r.expr)
 		r.call = auto_cast clone(r.call)
-	case Index_Expr:
+	case ^Index_Expr:
 		r.expr = clone(r.expr)
 		r.index = clone(r.index)
-	case Matrix_Index_Expr:
+	case ^Matrix_Index_Expr:
 		r.expr = clone(r.expr)
 		r.row_index = clone(r.row_index)
 		r.column_index = clone(r.column_index)
-	case Deref_Expr:
+	case ^Deref_Expr:
 		r.expr = clone(r.expr)
-	case Slice_Expr:
+	case ^Slice_Expr:
 		r.expr = clone(r.expr)
 		r.low  = clone(r.low)
 		r.high = clone(r.high)
-	case Call_Expr:
+	case ^Call_Expr:
 		r.expr = clone(r.expr)
 		r.args = clone(r.args)
-	case Field_Value:
+	case ^Field_Value:
 		r.field = clone(r.field)
 		r.value = clone(r.value)
-	case Ternary_If_Expr:
+	case ^Ternary_If_Expr:
 		r.x    = clone(r.x)
 		r.cond = clone(r.cond)
 		r.y    = clone(r.y)
-	case Ternary_When_Expr:
+	case ^Ternary_When_Expr:
 		r.x    = clone(r.x)
 		r.cond = clone(r.cond)
 		r.y    = clone(r.y)
-	case Or_Else_Expr:
+	case ^Or_Else_Expr:
 		r.x    = clone(r.x)
 		r.y    = clone(r.y)
-	case Or_Return_Expr:
+	case ^Or_Return_Expr:
 		r.expr = clone(r.expr)
-	case Type_Assertion:
+	case ^Type_Assertion:
 		r.expr = clone(r.expr)
 		r.type = clone(r.type)
-	case Type_Cast:
+	case ^Type_Cast:
 		r.type = clone(r.type)
 		r.expr = clone(r.expr)
-	case Auto_Cast:
+	case ^Auto_Cast:
 		r.expr = clone(r.expr)
-	case Inline_Asm_Expr:
+	case ^Inline_Asm_Expr:
 		r.param_types        = clone(r.param_types)
 		r.return_type        = clone(r.return_type)
 		r.constraints_string = clone(r.constraints_string)
 		r.asm_string         = clone(r.asm_string)
 
-	case Bad_Stmt:
+	case ^Bad_Stmt:
 		// empty
-	case Empty_Stmt:
+	case ^Empty_Stmt:
 		// empty
-	case Expr_Stmt:
+	case ^Expr_Stmt:
 		r.expr = clone(r.expr)
-	case Tag_Stmt:
+	case ^Tag_Stmt:
 		r.stmt = clone(r.stmt)
 
-	case Assign_Stmt:
+	case ^Assign_Stmt:
 		r.lhs = clone(r.lhs)
 		r.rhs = clone(r.rhs)
-	case Block_Stmt:
+	case ^Block_Stmt:
 		r.label = clone(r.label)
 		r.stmts = clone(r.stmts)
-	case If_Stmt:
+	case ^If_Stmt:
 		r.label     = clone(r.label)
 		r.init      = clone(r.init)
 		r.cond      = clone(r.cond)
 		r.body      = clone(r.body)
 		r.else_stmt = clone(r.else_stmt)
-	case When_Stmt:
+	case ^When_Stmt:
 		r.cond      = clone(r.cond)
 		r.body      = clone(r.body)
 		r.else_stmt = clone(r.else_stmt)
-	case Return_Stmt:
+	case ^Return_Stmt:
 		r.results = clone(r.results)
-	case Defer_Stmt:
+	case ^Defer_Stmt:
 		r.stmt = clone(r.stmt)
-	case For_Stmt:
+	case ^For_Stmt:
 		r.label = clone(r.label)
 		r.init = clone(r.init)
 		r.cond = clone(r.cond)
 		r.post = clone(r.post)
 		r.body = clone(r.body)
-	case Range_Stmt:
+	case ^Range_Stmt:
 		r.label = clone(r.label)
 		r.vals = clone(r.vals)
 		r.expr = clone(r.expr)
 		r.body = clone(r.body)
-	case Case_Clause:
+	case ^Inline_Range_Stmt:
+		r.label = clone(r.label)
+		r.val0 = clone(r.val0)
+		r.val1 = clone(r.val1)
+		r.expr = clone(r.expr)
+		r.body = clone(r.body)
+	case ^Case_Clause:
 		r.list = clone(r.list)
 		r.body = clone(r.body)
-	case Switch_Stmt:
+	case ^Switch_Stmt:
 		r.label = clone(r.label)
 		r.init = clone(r.init)
 		r.cond = clone(r.cond)
 		r.body = clone(r.body)
-	case Type_Switch_Stmt:
+	case ^Type_Switch_Stmt:
 		r.label = clone(r.label)
 		r.tag  = clone(r.tag)
 		r.expr = clone(r.expr)
 		r.body = clone(r.body)
-	case Branch_Stmt:
+	case ^Branch_Stmt:
 		r.label = auto_cast clone(r.label)
-	case Using_Stmt:
+	case ^Using_Stmt:
 		r.list = clone(r.list)
-	case Bad_Decl:
-	case Value_Decl:
+	case ^Bad_Decl:
+	case ^Value_Decl:
 		r.attributes = clone(r.attributes)
 		r.names      = clone(r.names)
 		r.type       = clone(r.type)
 		r.values     = clone(r.values)
-	case Package_Decl:
-	case Import_Decl:
-	case Foreign_Block_Decl:
+	case ^Package_Decl:
+	case ^Import_Decl:
+	case ^Foreign_Block_Decl:
 		r.attributes      = clone(r.attributes)
 		r.foreign_library = clone(r.foreign_library)
 		r.body            = clone(r.body)
-	case Foreign_Import_Decl:
+	case ^Foreign_Import_Decl:
 		r.name = auto_cast clone(r.name)
-	case Proc_Group:
+	case ^Proc_Group:
 		r.args = clone(r.args)
-	case Attribute:
+	case ^Attribute:
 		r.elems = clone(r.elems)
-	case Field:
+	case ^Field:
 		r.names         = clone(r.names)
 		r.type          = clone(r.type)
 		r.default_value = clone(r.default_value)
-	case Field_List:
+	case ^Field_List:
 		r.list = clone(r.list)
-	case Typeid_Type:
+	case ^Typeid_Type:
 		r.specialization = clone(r.specialization)
-	case Helper_Type:
+	case ^Helper_Type:
 		r.type = clone(r.type)
-	case Distinct_Type:
+	case ^Distinct_Type:
 		r.type = clone(r.type)
-	case Poly_Type:
+	case ^Poly_Type:
 		r.type = auto_cast clone(r.type)
 		r.specialization = clone(r.specialization)
-	case Proc_Type:
+	case ^Proc_Type:
 		r.params  = auto_cast clone(r.params)
 		r.results = auto_cast clone(r.results)
-	case Pointer_Type:
+	case ^Pointer_Type:
 		r.elem = clone(r.elem)
-	case Multi_Pointer_Type:
+	case ^Multi_Pointer_Type:
 		r.elem = clone(r.elem)
-	case Array_Type:
+	case ^Array_Type:
 		r.len  = clone(r.len)
 		r.elem = clone(r.elem)
-	case Dynamic_Array_Type:
+	case ^Dynamic_Array_Type:
 		r.elem = clone(r.elem)
-	case Struct_Type:
+	case ^Struct_Type:
 		r.poly_params = auto_cast clone(r.poly_params)
 		r.align = clone(r.align)
 		r.fields = auto_cast clone(r.fields)
-	case Union_Type:
+	case ^Union_Type:
 		r.poly_params = auto_cast clone(r.poly_params)
 		r.align = clone(r.align)
 		r.variants = clone(r.variants)
-	case Enum_Type:
+	case ^Enum_Type:
 		r.base_type = clone(r.base_type)
 		r.fields = clone(r.fields)
-	case Bit_Set_Type:
+	case ^Bit_Set_Type:
 		r.elem = clone(r.elem)
 		r.underlying = clone(r.underlying)
-	case Map_Type:
+	case ^Map_Type:
 		r.key = clone(r.key)
 		r.value = clone(r.value)
-	case Matrix_Type:
+	case ^Matrix_Type:
 		r.row_count = clone(r.row_count)
 		r.column_count = clone(r.column_count)
 		r.elem = clone(r.elem)
+	case ^Relative_Type:
+		r.tag = clone(r.tag)
+		r.type = clone(r.type)
 	case:
 		fmt.panicf("Unhandled node kind: %T", r)
 	}

core/odin/ast/walk.odin

@@ -59,64 +59,64 @@ walk :: proc(v: ^Visitor, node: ^Node) {
 	}
 
 	switch n in &node.derived {
-	case File:
+	case ^File:
 		if n.docs != nil {
 			walk(v, n.docs)
 		}
 		walk_stmt_list(v, n.decls[:])
-	case Package:
+	case ^Package:
 		for _, f in n.files {
 			walk(v, f)
 		}
 
-	case Comment_Group:
+	case ^Comment_Group:
 		// empty
-	case Bad_Expr:
-	case Ident:
-	case Implicit:
-	case Undef:
-	case Basic_Lit:
-	case Basic_Directive:
-	case Ellipsis:
+	case ^Bad_Expr:
+	case ^Ident:
+	case ^Implicit:
+	case ^Undef:
+	case ^Basic_Lit:
+	case ^Basic_Directive:
+	case ^Ellipsis:
 		if n.expr != nil {
 			walk(v, n.expr)
 		}
-	case Proc_Lit:
+	case ^Proc_Lit:
 		walk(v, n.type)
 		walk(v, n.body)
 		walk_expr_list(v, n.where_clauses)
-	case Comp_Lit:
+	case ^Comp_Lit:
 		if n.type != nil {
 			walk(v, n.type)
 		}
 		walk_expr_list(v, n.elems)
-	case Tag_Expr:
+	case ^Tag_Expr:
 		walk(v, n.expr)
-	case Unary_Expr:
+	case ^Unary_Expr:
 		walk(v, n.expr)
-	case Binary_Expr:
+	case ^Binary_Expr:
 		walk(v, n.left)
 		walk(v, n.right)
-	case Paren_Expr:
+	case ^Paren_Expr:
 		walk(v, n.expr)
-	case Selector_Expr:
+	case ^Selector_Expr:
 		walk(v, n.expr)
 		walk(v, n.field)
-	case Implicit_Selector_Expr:
+	case ^Implicit_Selector_Expr:
 		walk(v, n.field)
-	case Selector_Call_Expr:
+	case ^Selector_Call_Expr:
 		walk(v, n.expr)
 		walk(v, n.call)
-	case Index_Expr:
+	case ^Index_Expr:
 		walk(v, n.expr)
 		walk(v, n.index)
-	case Matrix_Index_Expr:
+	case ^Matrix_Index_Expr:
 		walk(v, n.expr)
 		walk(v, n.row_index)
 		walk(v, n.column_index)
-	case Deref_Expr:
+	case ^Deref_Expr:
 		walk(v, n.expr)
-	case Slice_Expr:
+	case ^Slice_Expr:
 		walk(v, n.expr)
 		if n.low != nil {
 			walk(v, n.low)
@@ -124,57 +124,57 @@ walk :: proc(v: ^Visitor, node: ^Node) {
 		if n.high != nil {
 			walk(v, n.high)
 		}
-	case Call_Expr:
+	case ^Call_Expr:
 		walk(v, n.expr)
 		walk_expr_list(v, n.args)
-	case Field_Value:
+	case ^Field_Value:
 		walk(v, n.field)
 		walk(v, n.value)
-	case Ternary_If_Expr:
+	case ^Ternary_If_Expr:
 		walk(v, n.x)
 		walk(v, n.cond)
 		walk(v, n.y)
-	case Ternary_When_Expr:
+	case ^Ternary_When_Expr:
 		walk(v, n.x)
 		walk(v, n.cond)
 		walk(v, n.y)
-	case Or_Else_Expr:
+	case ^Or_Else_Expr:
 		walk(v, n.x)
 		walk(v, n.y)
-	case Or_Return_Expr:
+	case ^Or_Return_Expr:
 		walk(v, n.expr)
-	case Type_Assertion:
+	case ^Type_Assertion:
 		walk(v, n.expr)
 		if n.type != nil {
 			walk(v, n.type)
 		}
-	case Type_Cast:
+	case ^Type_Cast:
 		walk(v, n.type)
 		walk(v, n.expr)
-	case Auto_Cast:
+	case ^Auto_Cast:
 		walk(v, n.expr)
-	case Inline_Asm_Expr:
+	case ^Inline_Asm_Expr:
 		walk_expr_list(v, n.param_types)
 		walk(v, n.return_type)
 		walk(v, n.constraints_string)
 		walk(v, n.asm_string)
 
 
-	case Bad_Stmt:
-	case Empty_Stmt:
-	case Expr_Stmt:
+	case ^Bad_Stmt:
+	case ^Empty_Stmt:
+	case ^Expr_Stmt:
 		walk(v, n.expr)
-	case Tag_Stmt:
+	case ^Tag_Stmt:
 		walk(v, n.stmt)
-	case Assign_Stmt:
+	case ^Assign_Stmt:
 		walk_expr_list(v, n.lhs)
 		walk_expr_list(v, n.rhs)
-	case Block_Stmt:
+	case ^Block_Stmt:
 		if n.label != nil {
 			walk(v, n.label)
 		}
 		walk_stmt_list(v, n.stmts)
-	case If_Stmt:
+	case ^If_Stmt:
 		if n.label != nil {
 			walk(v, n.label)
 		}
@@ -186,17 +186,17 @@ walk :: proc(v: ^Visitor, node: ^Node) {
 		if n.else_stmt != nil {
 			walk(v, n.else_stmt)
 		}
-	case When_Stmt:
+	case ^When_Stmt:
 		walk(v, n.cond)
 		walk(v, n.body)
 		if n.else_stmt != nil {
 			walk(v, n.else_stmt)
 		}
-	case Return_Stmt:
+	case ^Return_Stmt:
 		walk_expr_list(v, n.results)
-	case Defer_Stmt:
+	case ^Defer_Stmt:
 		walk(v, n.stmt)
-	case For_Stmt:
+	case ^For_Stmt:
 		if n.label != nil {
 			walk(v, n.label)
 		}
@@ -210,7 +210,7 @@ walk :: proc(v: ^Visitor, node: ^Node) {
 			walk(v, n.post)
 		}
 		walk(v, n.body)
-	case Range_Stmt:
+	case ^Range_Stmt:
 		if n.label != nil {
 			walk(v, n.label)
 		}
@@ -221,7 +221,7 @@ walk :: proc(v: ^Visitor, node: ^Node) {
 		}
 		walk(v, n.expr)
 		walk(v, n.body)
-	case Inline_Range_Stmt:
+	case ^Inline_Range_Stmt:
 		if n.label != nil {
 			walk(v, n.label)
 		}
@@ -233,10 +233,10 @@ walk :: proc(v: ^Visitor, node: ^Node) {
 		}
 		walk(v, n.expr)
 		walk(v, n.body)
-	case Case_Clause:
+	case ^Case_Clause:
 		walk_expr_list(v, n.list)
 		walk_stmt_list(v, n.body)
-	case Switch_Stmt:
+	case ^Switch_Stmt:
 		if n.label != nil {
 			walk(v, n.label)
 		}
@@ -247,7 +247,7 @@ walk :: proc(v: ^Visitor, node: ^Node) {
 			walk(v, n.cond)
 		}
 		walk(v, n.body)
-	case Type_Switch_Stmt:
+	case ^Type_Switch_Stmt:
 		if n.label != nil {
 			walk(v, n.label)
 		}
@@ -258,16 +258,16 @@ walk :: proc(v: ^Visitor, node: ^Node) {
 			walk(v, n.expr)
 		}
 		walk(v, n.body)
-	case Branch_Stmt:
+	case ^Branch_Stmt:
 		if n.label != nil {
 			walk(v, n.label)
 		}
-	case Using_Stmt:
+	case ^Using_Stmt:
 		walk_expr_list(v, n.list)
 
 
-	case Bad_Decl:
-	case Value_Decl:
+	case ^Bad_Decl:
+	case ^Value_Decl:
 		if n.docs != nil {
 			walk(v, n.docs)
 		}
@@ -280,21 +280,21 @@ walk :: proc(v: ^Visitor, node: ^Node) {
 		if n.comment != nil {
 			walk(v, n.comment)
 		}
-	case Package_Decl:
+	case ^Package_Decl:
 		if n.docs != nil {
 			walk(v, n.docs)
 		}
 		if n.comment != nil {
 			walk(v, n.comment)
 		}
-	case Import_Decl:
+	case ^Import_Decl:
 		if n.docs != nil {
 			walk(v, n.docs)
 		}
 		if n.comment != nil {
 			walk(v, n.comment)
 		}
-	case Foreign_Block_Decl:
+	case ^Foreign_Block_Decl:
 		if n.docs != nil {
 			walk(v, n.docs)
 		}
@@ -303,7 +303,7 @@ walk :: proc(v: ^Visitor, node: ^Node) {
 			walk(v, n.foreign_library)
 		}
 		walk(v, n.body)
-	case Foreign_Import_Decl:
+	case ^Foreign_Import_Decl:
 		if n.docs != nil {
 			walk(v, n.docs)
 		}
@@ -313,11 +313,11 @@ walk :: proc(v: ^Visitor, node: ^Node) {
 			walk(v, n.comment)
 		}
 
-	case Proc_Group:
+	case ^Proc_Group:
 		walk_expr_list(v, n.args)
-	case Attribute:
+	case ^Attribute:
 		walk_expr_list(v, n.elems)
-	case Field:
+	case ^Field:
 		if n.docs != nil {
 			walk(v, n.docs)
 		}
@@ -331,31 +331,31 @@ walk :: proc(v: ^Visitor, node: ^Node) {
 		if n.comment != nil {
 			walk(v, n.comment)
 		}
-	case Field_List:
+	case ^Field_List:
 		for x in n.list {
 			walk(v, x)
 		}
-	case Typeid_Type:
+	case ^Typeid_Type:
 		if n.specialization != nil {
 			walk(v, n.specialization)
 		}
-	case Helper_Type:
+	case ^Helper_Type:
 		walk(v, n.type)
-	case Distinct_Type:
+	case ^Distinct_Type:
 		walk(v, n.type)
-	case Poly_Type:
+	case ^Poly_Type:
 		walk(v, n.type)
 		if n.specialization != nil {
 			walk(v, n.specialization)
 		}
-	case Proc_Type:
+	case ^Proc_Type:
 		walk(v, n.params)
 		walk(v, n.results)
-	case Pointer_Type:
+	case ^Pointer_Type:
 		walk(v, n.elem)
-	case Multi_Pointer_Type:
+	case ^Multi_Pointer_Type:
 		walk(v, n.elem)
-	case Array_Type:
+	case ^Array_Type:
 		if n.tag != nil {
 			walk(v, n.tag)
 		}
@@ -363,12 +363,12 @@ walk :: proc(v: ^Visitor, node: ^Node) {
 			walk(v, n.len)
 		}
 		walk(v, n.elem)
-	case Dynamic_Array_Type:
+	case ^Dynamic_Array_Type:
 		if n.tag != nil {
 			walk(v, n.tag)
 		}
 		walk(v, n.elem)
-	case Struct_Type:
+	case ^Struct_Type:
 		if n.poly_params != nil {
 			walk(v, n.poly_params)
 		}
@@ -377,7 +377,7 @@ walk :: proc(v: ^Visitor, node: ^Node) {
 		}
 		walk_expr_list(v, n.where_clauses)
 		walk(v, n.fields)
-	case Union_Type:
+	case ^Union_Type:
 		if n.poly_params != nil {
 			walk(v, n.poly_params)
 		}
@@ -386,23 +386,23 @@ walk :: proc(v: ^Visitor, node: ^Node) {
 		}
 		walk_expr_list(v, n.where_clauses)
 		walk_expr_list(v, n.variants)
-	case Enum_Type:
+	case ^Enum_Type:
 		if n.base_type != nil {
 			walk(v, n.base_type)
 		}
 		walk_expr_list(v, n.fields)
-	case Bit_Set_Type:
+	case ^Bit_Set_Type:
 		walk(v, n.elem)
 		if n.underlying != nil {
 			walk(v, n.underlying)
 		}
-	case Map_Type:
+	case ^Map_Type:
 		walk(v, n.key)
 		walk(v, n.value)
-	case Relative_Type:
+	case ^Relative_Type:
 		walk(v, n.tag)
 		walk(v, n.type)
-	case Matrix_Type:
+	case ^Matrix_Type:
 		walk(v, n.row_count)
 		walk(v, n.column_count)
 		walk(v, n.elem)