Remove unneeded semicolons from the core library

2026-08-05 15:18:49 +00:00 · 2021-08-31 22:21:13 +01:00
parent b176af2742
commit 251da264ed
187 changed files with 27227 additions and 27227 deletions
@@ -8,7 +8,7 @@ Proc_Tag :: enum {
 	Optional_Ok,
 	Optional_Second,
 }
-Proc_Tags :: distinct bit_set[Proc_Tag; u32];
+Proc_Tags :: distinct bit_set[Proc_Tag; u32]

 Proc_Inlining :: enum u32 {
 	None      = 0,
@@ -28,7 +28,7 @@ Node_State_Flag :: enum {
 	Bounds_Check,
 	No_Bounds_Check,
 }
-Node_State_Flags :: distinct bit_set[Node_State_Flag];
+Node_State_Flags :: distinct bit_set[Node_State_Flag]

 Node :: struct {
 	pos:         tokenizer.Pos,
@@ -526,18 +526,18 @@ Foreign_Import_Decl :: struct {

 // Other things
 unparen_expr :: proc(expr: ^Expr) -> (val: ^Expr) {
-	val = expr;
+	val = expr
 	if expr == nil {
-		return;
+		return
 	}
 	for {
-		e, ok := val.derived.(Paren_Expr);
+		e, ok := val.derived.(Paren_Expr)
 		if !ok || e.expr == nil {
-			break;
+			break
 		}
-		val = e.expr;
+		val = e.expr
 	}
-	return;
+	return
 }

 Field_Flag :: enum {
@@ -554,16 +554,16 @@ Field_Flag :: enum {
 	Typeid_Token,
 }

-Field_Flags :: distinct bit_set[Field_Flag];
+Field_Flags :: distinct bit_set[Field_Flag]

 Field_Flags_Struct :: Field_Flags{
 	.Using,
 	.Tags,
-};
+}
 Field_Flags_Record_Poly_Params :: Field_Flags{
 	.Typeid_Token,
 	.Default_Parameters,
-};
+}
 Field_Flags_Signature :: Field_Flags{
 	.Ellipsis,
 	.Using,
@@ -571,10 +571,10 @@ Field_Flags_Signature :: Field_Flags{
 	.C_Vararg,
 	.Auto_Cast,
 	.Default_Parameters,
-};
+}

-Field_Flags_Signature_Params  :: Field_Flags_Signature | {Field_Flag.Typeid_Token};
-Field_Flags_Signature_Results :: Field_Flags_Signature;
+Field_Flags_Signature_Params  :: Field_Flags_Signature | {Field_Flag.Typeid_Token}
+Field_Flags_Signature_Results :: Field_Flags_Signature


 Proc_Group :: struct {
@@ -5,13 +5,13 @@ import "core:fmt"
 import "core:odin/tokenizer"

 new :: proc($T: typeid, pos, end: tokenizer.Pos) -> ^T {
-	n, _ := mem.new(T);
-	n.pos = pos;
-	n.end = end;
-	n.derived = n^;
-	base: ^Node = n; // dummy check
-	_ = base; // "Use" type to make -vet happy
-	return n;
+	n, _ := mem.new(T)
+	n.pos = pos
+	n.end = end
+	n.derived = n^
+	base: ^Node = n // dummy check
+	_ = base // "Use" type to make -vet happy
+	return n
 }

 clone :: proc{
@@ -21,65 +21,65 @@ clone :: proc{
 	clone_decl,
 	clone_array,
 	clone_dynamic_array,
-};
+}

 clone_array :: proc(array: $A/[]^$T) -> A {
 	if len(array) == 0 {
-		return nil;
+		return nil
 	}
-	res := make(A, len(array));
+	res := make(A, len(array))
 	for elem, i in array {
-		res[i] = auto_cast clone(elem);
+		res[i] = auto_cast clone(elem)
 	}
-	return res;
+	return res
 }

 clone_dynamic_array :: proc(array: $A/[dynamic]^$T) -> A {
 	if len(array) == 0 {
-		return nil;
+		return nil
 	}
-	res := make(A, len(array));
+	res := make(A, len(array))
 	for elem, i in array {
-		res[i] = auto_cast clone(elem);
+		res[i] = auto_cast clone(elem)
 	}
-	return res;
+	return res
 }

 clone_expr :: proc(node: ^Expr) -> ^Expr {
-	return cast(^Expr)clone_node(node);
+	return cast(^Expr)clone_node(node)
 }
 clone_stmt :: proc(node: ^Stmt) -> ^Stmt {
-	return cast(^Stmt)clone_node(node);
+	return cast(^Stmt)clone_node(node)
 }
 clone_decl :: proc(node: ^Decl) -> ^Decl {
-	return cast(^Decl)clone_node(node);
+	return cast(^Decl)clone_node(node)
 }
 clone_node :: proc(node: ^Node) -> ^Node {
 	if node == nil {
-		return nil;
+		return nil
 	}

-	size := size_of(Node);
-	align := align_of(Node);
-	ti := type_info_of(node.derived.id);
+	size := size_of(Node)
+	align := align_of(Node)
+	ti := type_info_of(node.derived.id)
 	if ti != nil {
-		size = ti.size;
-		align = ti.align;
+		size = ti.size
+		align = ti.align
 	}

 	switch in node.derived {
 	case Package, File:
-		panic("Cannot clone this node type");
+		panic("Cannot clone this node type")
 	}

-	res := cast(^Node)mem.alloc(size, align);
-	src: rawptr = node;
+	res := cast(^Node)mem.alloc(size, align)
+	src: rawptr = node
 	if node.derived != nil {
-		src = node.derived.data;
+		src = node.derived.data
 	}
-	mem.copy(res, src, size);
-	res.derived.data = rawptr(res);
-	res.derived.id = node.derived.id;
+	mem.copy(res, src, size)
+	res.derived.data = rawptr(res)
+	res.derived.id = node.derived.id

 	switch r in &res.derived {
 	case Bad_Expr:
@@ -89,196 +89,196 @@ clone_node :: proc(node: ^Node) -> ^Node {
 	case Basic_Lit:

 	case Ellipsis:
-		r.expr = clone(r.expr);
+		r.expr = clone(r.expr)
 	case Proc_Lit:
-		r.type = auto_cast clone(r.type);
-		r.body = clone(r.body);
+		r.type = auto_cast clone(r.type)
+		r.body = clone(r.body)
 	case Comp_Lit:
-		r.type  = clone(r.type);
-		r.elems = clone(r.elems);
+		r.type  = clone(r.type)
+		r.elems = clone(r.elems)

 	case Tag_Expr:
-		r.expr = clone(r.expr);
+		r.expr = clone(r.expr)
 	case Unary_Expr:
-		r.expr = clone(r.expr);
+		r.expr = clone(r.expr)
 	case Binary_Expr:
-		r.left  = clone(r.left);
-		r.right = clone(r.right);
+		r.left  = clone(r.left)
+		r.right = clone(r.right)
 	case Paren_Expr:
-		r.expr = clone(r.expr);
+		r.expr = clone(r.expr)
 	case Selector_Expr:
-		r.expr = clone(r.expr);
-		r.field = auto_cast clone(r.field);
+		r.expr = clone(r.expr)
+		r.field = auto_cast clone(r.field)
 	case Implicit_Selector_Expr:
-		r.field = auto_cast clone(r.field);
+		r.field = auto_cast clone(r.field)
 	case Selector_Call_Expr:
-		r.expr = clone(r.expr);
-		r.call = auto_cast clone(r.call);
+		r.expr = clone(r.expr)
+		r.call = auto_cast clone(r.call)
 	case Index_Expr:
-		r.expr = clone(r.expr);
-		r.index = clone(r.index);
+		r.expr = clone(r.expr)
+		r.index = clone(r.index)
 	case Deref_Expr:
-		r.expr = clone(r.expr);
+		r.expr = clone(r.expr)
 	case Slice_Expr:
-		r.expr = clone(r.expr);
-		r.low  = clone(r.low);
-		r.high = clone(r.high);
+		r.expr = clone(r.expr)
+		r.low  = clone(r.low)
+		r.high = clone(r.high)
 	case Call_Expr:
-		r.expr = clone(r.expr);
-		r.args = clone(r.args);
+		r.expr = clone(r.expr)
+		r.args = clone(r.args)
 	case Field_Value:
-		r.field = clone(r.field);
-		r.value = clone(r.value);
+		r.field = clone(r.field)
+		r.value = clone(r.value)
 	case Ternary_If_Expr:
-		r.x    = clone(r.x);
-		r.cond = clone(r.cond);
-		r.y    = clone(r.y);
+		r.x    = clone(r.x)
+		r.cond = clone(r.cond)
+		r.y    = clone(r.y)
 	case Ternary_When_Expr:
-		r.x    = clone(r.x);
-		r.cond = clone(r.cond);
-		r.y    = clone(r.y);
+		r.x    = clone(r.x)
+		r.cond = clone(r.cond)
+		r.y    = clone(r.y)
 	case Or_Else_Expr:
-		r.x    = clone(r.x);
-		r.y    = clone(r.y);
+		r.x    = clone(r.x)
+		r.y    = clone(r.y)
 	case Or_Return_Expr:
-		r.expr = clone(r.expr);
+		r.expr = clone(r.expr)
 	case Type_Assertion:
-		r.expr = clone(r.expr);
-		r.type = clone(r.type);
+		r.expr = clone(r.expr)
+		r.type = clone(r.type)
 	case Type_Cast:
-		r.type = clone(r.type);
-		r.expr = clone(r.expr);
+		r.type = clone(r.type)
+		r.expr = clone(r.expr)
 	case Auto_Cast:
-		r.expr = clone(r.expr);
+		r.expr = clone(r.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);
+		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:
 		// empty
 	case Empty_Stmt:
 		// empty
 	case Expr_Stmt:
-		r.expr = clone(r.expr);
+		r.expr = clone(r.expr)
 	case Tag_Stmt:
-		r.stmt = clone(r.stmt);
+		r.stmt = clone(r.stmt)

 	case Assign_Stmt:
-		r.lhs = clone(r.lhs);
-		r.rhs = clone(r.rhs);
+		r.lhs = clone(r.lhs)
+		r.rhs = clone(r.rhs)
 	case Block_Stmt:
-		r.label = auto_cast clone(r.label);
-		r.stmts = clone(r.stmts);
+		r.label = auto_cast clone(r.label)
+		r.stmts = clone(r.stmts)
 	case If_Stmt:
-		r.label     = auto_cast 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);
+		r.label     = auto_cast 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:
-		r.cond      = clone(r.cond);
-		r.body      = clone(r.body);
-		r.else_stmt = clone(r.else_stmt);
+		r.cond      = clone(r.cond)
+		r.body      = clone(r.body)
+		r.else_stmt = clone(r.else_stmt)
 	case Return_Stmt:
-		r.results = clone(r.results);
+		r.results = clone(r.results)
 	case Defer_Stmt:
-		r.stmt = clone(r.stmt);
+		r.stmt = clone(r.stmt)
 	case For_Stmt:
-		r.label = auto_cast clone(r.label);
-		r.init = clone(r.init);
-		r.cond = clone(r.cond);
-		r.post = clone(r.post);
-		r.body = clone(r.body);
+		r.label = auto_cast 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:
-		r.label = auto_cast clone(r.label);
-		r.vals = clone(r.vals);
-		r.expr = clone(r.expr);
-		r.body = clone(r.body);
+		r.label = auto_cast clone(r.label)
+		r.vals = clone(r.vals)
+		r.expr = clone(r.expr)
+		r.body = clone(r.body)
 	case Case_Clause:
-		r.list = clone(r.list);
-		r.body = clone(r.body);
+		r.list = clone(r.list)
+		r.body = clone(r.body)
 	case Switch_Stmt:
-		r.label = auto_cast clone(r.label);
-		r.init = clone(r.init);
-		r.cond = clone(r.cond);
-		r.body = clone(r.body);
+		r.label = auto_cast clone(r.label)
+		r.init = clone(r.init)
+		r.cond = clone(r.cond)
+		r.body = clone(r.body)
 	case Type_Switch_Stmt:
-		r.label = auto_cast clone(r.label);
-		r.tag  = clone(r.tag);
-		r.expr = clone(r.expr);
-		r.body = clone(r.body);
+		r.label = auto_cast clone(r.label)
+		r.tag  = clone(r.tag)
+		r.expr = clone(r.expr)
+		r.body = clone(r.body)
 	case Branch_Stmt:
-		r.label = auto_cast clone(r.label);
+		r.label = auto_cast clone(r.label)
 	case Using_Stmt:
-		r.list = clone(r.list);
+		r.list = clone(r.list)
 	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);
+		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:
-		r.attributes      = clone(r.attributes);
-		r.foreign_library = clone(r.foreign_library);
-		r.body            = clone(r.body);
+		r.attributes      = clone(r.attributes)
+		r.foreign_library = clone(r.foreign_library)
+		r.body            = clone(r.body)
 	case Foreign_Import_Decl:
-		r.name = auto_cast clone(r.name);
+		r.name = auto_cast clone(r.name)
 	case Proc_Group:
-		r.args = clone(r.args);
+		r.args = clone(r.args)
 	case Attribute:
-		r.elems = clone(r.elems);
+		r.elems = clone(r.elems)
 	case Field:
-		r.names         = clone(r.names);
-		r.type          = clone(r.type);
-		r.default_value = clone(r.default_value);
+		r.names         = clone(r.names)
+		r.type          = clone(r.type)
+		r.default_value = clone(r.default_value)
 	case Field_List:
-		r.list = clone(r.list);
+		r.list = clone(r.list)
 	case Typeid_Type:
-		r.specialization = clone(r.specialization);
+		r.specialization = clone(r.specialization)
 	case Helper_Type:
-		r.type = clone(r.type);
+		r.type = clone(r.type)
 	case Distinct_Type:
-		r.type = clone(r.type);
+		r.type = clone(r.type)
 	case Poly_Type:
-		r.type = auto_cast clone(r.type);
-		r.specialization = clone(r.specialization);
+		r.type = auto_cast clone(r.type)
+		r.specialization = clone(r.specialization)
 	case Proc_Type:
-		r.params  = auto_cast clone(r.params);
-		r.results = auto_cast clone(r.results);
+		r.params  = auto_cast clone(r.params)
+		r.results = auto_cast clone(r.results)
 	case Pointer_Type:
-		r.elem = clone(r.elem);
+		r.elem = clone(r.elem)
 	case Multi_Pointer_Type:
-		r.elem = clone(r.elem);
+		r.elem = clone(r.elem)
 	case Array_Type:
-		r.len  = clone(r.len);
-		r.elem = clone(r.elem);
+		r.len  = clone(r.len)
+		r.elem = clone(r.elem)
 	case Dynamic_Array_Type:
-		r.elem = clone(r.elem);
+		r.elem = clone(r.elem)
 	case Struct_Type:
-		r.poly_params = auto_cast clone(r.poly_params);
-		r.align = clone(r.align);
-		r.fields = auto_cast clone(r.fields);
+		r.poly_params = auto_cast clone(r.poly_params)
+		r.align = clone(r.align)
+		r.fields = auto_cast clone(r.fields)
 	case Union_Type:
-		r.poly_params = auto_cast clone(r.poly_params);
-		r.align = clone(r.align);
-		r.variants = clone(r.variants);
+		r.poly_params = auto_cast clone(r.poly_params)
+		r.align = clone(r.align)
+		r.variants = clone(r.variants)
 	case Enum_Type:
-		r.base_type = clone(r.base_type);
-		r.fields = clone(r.fields);
+		r.base_type = clone(r.base_type)
+		r.fields = clone(r.fields)
 	case Bit_Set_Type:
-		r.elem = clone(r.elem);
-		r.underlying = clone(r.underlying);
+		r.elem = clone(r.elem)
+		r.underlying = clone(r.underlying)
 	case Map_Type:
-		r.key = clone(r.key);
-		r.value = clone(r.value);
+		r.key = clone(r.key)
+		r.value = clone(r.value)

 	case:
-		fmt.panicf("Unhandled node kind: %T", r);
+		fmt.panicf("Unhandled node kind: %T", r)
 	}

-	return res;
+	return res
 }
@@ -18,15 +18,15 @@ Visitor :: struct {
 inspect :: proc(node: ^Node, f: proc(^Node) -> bool) {
 	v := &Visitor{
 		visit = proc(v: ^Visitor, node: ^Node) -> ^Visitor {
-			f := (proc(^Node) -> bool)(v.data);
+			f := (proc(^Node) -> bool)(v.data)
 			if f(node) {
-				return v;
+				return v
 			}
-			return nil;
+			return nil
 		},
 		data = rawptr(f),
-	};
-	walk(v, node);
+	}
+	walk(v, node)
 }


@@ -37,36 +37,36 @@ inspect :: proc(node: ^Node, f: proc(^Node) -> bool) {
 walk :: proc(v: ^Visitor, node: ^Node) {
 	walk_expr_list :: proc(v: ^Visitor, list: []^Expr) {
 		for x in list {
-			walk(v, x);
+			walk(v, x)
 		}
 	}

 	walk_stmt_list :: proc(v: ^Visitor, list: []^Stmt) {
 		for x in list {
-			walk(v, x);
+			walk(v, x)
 		}
 	}
 	walk_attribute_list :: proc(v: ^Visitor, list: []^Attribute) {
 		for x in list {
-			walk(v, x);
+			walk(v, x)
 		}
 	}


-	v := v;
+	v := v
 	if v = v->visit(node); v == nil {
-		return;
+		return
 	}

 	switch n in &node.derived {
 	case File:
 		if n.docs != nil {
-			walk(v, n.docs);
+			walk(v, n.docs)
 		}
-		walk_stmt_list(v, n.decls[:]);
+		walk_stmt_list(v, n.decls[:])
 	case Package:
 		for _, f in n.files {
-			walk(v, f);
+			walk(v, f)
 		}

 	case Comment_Group:
@@ -79,330 +79,330 @@ walk :: proc(v: ^Visitor, node: ^Node) {
 	case Basic_Directive:
 	case Ellipsis:
 		if n.expr != nil {
-			walk(v, n.expr);
+			walk(v, n.expr)
 		}
 	case Proc_Lit:
-		walk(v, n.type);
-		walk(v, n.body);
-		walk_expr_list(v, n.where_clauses);
+		walk(v, n.type)
+		walk(v, n.body)
+		walk_expr_list(v, n.where_clauses)
 	case Comp_Lit:
 		if n.type != nil {
-			walk(v, n.type);
+			walk(v, n.type)
 		}
-		walk_expr_list(v, n.elems);
+		walk_expr_list(v, n.elems)
 	case Tag_Expr:
-		walk(v, n.expr);
+		walk(v, n.expr)
 	case Unary_Expr:
-		walk(v, n.expr);
+		walk(v, n.expr)
 	case Binary_Expr:
-		walk(v, n.left);
-		walk(v, n.right);
+		walk(v, n.left)
+		walk(v, n.right)
 	case Paren_Expr:
-		walk(v, n.expr);
+		walk(v, n.expr)
 	case Selector_Expr:
-		walk(v, n.expr);
-		walk(v, n.field);
+		walk(v, n.expr)
+		walk(v, n.field)
 	case Implicit_Selector_Expr:
-		walk(v, n.field);
+		walk(v, n.field)
 	case Selector_Call_Expr:
-		walk(v, n.expr);
-		walk(v, n.call);
+		walk(v, n.expr)
+		walk(v, n.call)
 	case Index_Expr:
-		walk(v, n.expr);
-		walk(v, n.index);
+		walk(v, n.expr)
+		walk(v, n.index)
 	case Deref_Expr:
-		walk(v, n.expr);
+		walk(v, n.expr)
 	case Slice_Expr:
-		walk(v, n.expr);
+		walk(v, n.expr)
 		if n.low != nil {
-			walk(v, n.low);
+			walk(v, n.low)
 		}
 		if n.high != nil {
-			walk(v, n.high);
+			walk(v, n.high)
 		}
 	case Call_Expr:
-		walk(v, n.expr);
-		walk_expr_list(v, n.args);
+		walk(v, n.expr)
+		walk_expr_list(v, n.args)
 	case Field_Value:
-		walk(v, n.field);
-		walk(v, n.value);
+		walk(v, n.field)
+		walk(v, n.value)
 	case Ternary_If_Expr:
-		walk(v, n.x);
-		walk(v, n.cond);
-		walk(v, n.y);
+		walk(v, n.x)
+		walk(v, n.cond)
+		walk(v, n.y)
 	case Ternary_When_Expr:
-		walk(v, n.x);
-		walk(v, n.cond);
-		walk(v, n.y);
+		walk(v, n.x)
+		walk(v, n.cond)
+		walk(v, n.y)
 	case Or_Else_Expr:
-		walk(v, n.x);
-		walk(v, n.y);
+		walk(v, n.x)
+		walk(v, n.y)
 	case Or_Return_Expr:
-		walk(v, n.expr);
+		walk(v, n.expr)
 	case Type_Assertion:
-		walk(v, n.expr);
+		walk(v, n.expr)
 		if n.type != nil {
-			walk(v, n.type);
+			walk(v, n.type)
 		}
 	case Type_Cast:
-		walk(v, n.type);
-		walk(v, n.expr);
+		walk(v, n.type)
+		walk(v, n.expr)
 	case Auto_Cast:
-		walk(v, n.expr);
+		walk(v, n.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);
+		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:
-		walk(v, n.expr);
+		walk(v, n.expr)
 	case Tag_Stmt:
-		walk(v, n.stmt);
+		walk(v, n.stmt)
 	case Assign_Stmt:
-		walk_expr_list(v, n.lhs);
-		walk_expr_list(v, n.rhs);
+		walk_expr_list(v, n.lhs)
+		walk_expr_list(v, n.rhs)
 	case Block_Stmt:
 		if n.label != nil {
-			walk(v, n.label);
+			walk(v, n.label)
 		}
-		walk_stmt_list(v, n.stmts);
+		walk_stmt_list(v, n.stmts)
 	case If_Stmt:
 		if n.label != nil {
-			walk(v, n.label);
+			walk(v, n.label)
 		}
 		if n.init != nil {
-			walk(v, n.init);
+			walk(v, n.init)
 		}
-		walk(v, n.cond);
-		walk(v, n.body);
+		walk(v, n.cond)
+		walk(v, n.body)
 		if n.else_stmt != nil {
-			walk(v, n.else_stmt);
+			walk(v, n.else_stmt)
 		}
 	case When_Stmt:
-		walk(v, n.cond);
-		walk(v, n.body);
+		walk(v, n.cond)
+		walk(v, n.body)
 		if n.else_stmt != nil {
-			walk(v, n.else_stmt);
+			walk(v, n.else_stmt)
 		}
 	case Return_Stmt:
-		walk_expr_list(v, n.results);
+		walk_expr_list(v, n.results)
 	case Defer_Stmt:
-		walk(v, n.stmt);
+		walk(v, n.stmt)
 	case For_Stmt:
 		if n.label != nil {
-			walk(v, n.label);
+			walk(v, n.label)
 		}
 		if n.init != nil {
-			walk(v, n.init);
+			walk(v, n.init)
 		}
 		if n.cond != nil {
-			walk(v, n.cond);
+			walk(v, n.cond)
 		}
 		if n.post != nil {
-			walk(v, n.post);
+			walk(v, n.post)
 		}
-		walk(v, n.body);
+		walk(v, n.body)
 	case Range_Stmt:
 		if n.label != nil {
-			walk(v, n.label);
+			walk(v, n.label)
 		}
 		for val in n.vals {
 			if val != nil {
-				walk(v, val);
+				walk(v, val)
 			}
 		}
-		walk(v, n.expr);
-		walk(v, n.body);
+		walk(v, n.expr)
+		walk(v, n.body)
 	case Inline_Range_Stmt:
 		if n.label != nil {
-			walk(v, n.label);
+			walk(v, n.label)
 		}
 		if n.val0 != nil {
-			walk(v, n.val0);
+			walk(v, n.val0)
 		}
 		if n.val1 != nil {
-			walk(v, n.val1);
+			walk(v, n.val1)
 		}
-		walk(v, n.expr);
-		walk(v, n.body);
+		walk(v, n.expr)
+		walk(v, n.body)
 	case Case_Clause:
-		walk_expr_list(v, n.list);
-		walk_stmt_list(v, n.body);
+		walk_expr_list(v, n.list)
+		walk_stmt_list(v, n.body)
 	case Switch_Stmt:
 		if n.label != nil {
-			walk(v, n.label);
+			walk(v, n.label)
 		}
 		if n.init != nil {
-			walk(v, n.init);
+			walk(v, n.init)
 		}
 		if n.cond != nil {
-			walk(v, n.cond);
+			walk(v, n.cond)
 		}
-		walk(v, n.body);
+		walk(v, n.body)
 	case Type_Switch_Stmt:
 		if n.label != nil {
-			walk(v, n.label);
+			walk(v, n.label)
 		}
 		if n.tag != nil {
-			walk(v, n.tag);
+			walk(v, n.tag)
 		}
 		if n.expr != nil {
-			walk(v, n.expr);
+			walk(v, n.expr)
 		}
-		walk(v, n.body);
+		walk(v, n.body)
 	case Branch_Stmt:
 		if n.label != nil {
-			walk(v, n.label);
+			walk(v, n.label)
 		}
 	case Using_Stmt:
-		walk_expr_list(v, n.list);
+		walk_expr_list(v, n.list)


 	case Bad_Decl:
 	case Value_Decl:
 		if n.docs != nil {
-			walk(v, n.docs);
+			walk(v, n.docs)
 		}
-		walk_attribute_list(v, n.attributes[:]);
-		walk_expr_list(v, n.names);
+		walk_attribute_list(v, n.attributes[:])
+		walk_expr_list(v, n.names)
 		if n.type != nil {
-			walk(v, n.type);
+			walk(v, n.type)
 		}
-		walk_expr_list(v, n.values);
+		walk_expr_list(v, n.values)
 		if n.comment != nil {
-			walk(v, n.comment);
+			walk(v, n.comment)
 		}
 	case Package_Decl:
 		if n.docs != nil {
-			walk(v, n.docs);
+			walk(v, n.docs)
 		}
 		if n.comment != nil {
-			walk(v, n.comment);
+			walk(v, n.comment)
 		}
 	case Import_Decl:
 		if n.docs != nil {
-			walk(v, n.docs);
+			walk(v, n.docs)
 		}
 		if n.comment != nil {
-			walk(v, n.comment);
+			walk(v, n.comment)
 		}
 	case Foreign_Block_Decl:
 		if n.docs != nil {
-			walk(v, n.docs);
+			walk(v, n.docs)
 		}
-		walk_attribute_list(v, n.attributes[:]);
+		walk_attribute_list(v, n.attributes[:])
 		if n.foreign_library != nil {
-			walk(v, n.foreign_library);
+			walk(v, n.foreign_library)
 		}
-		walk(v, n.body);
+		walk(v, n.body)
 	case Foreign_Import_Decl:
 		if n.docs != nil {
-			walk(v, n.docs);
+			walk(v, n.docs)
 		}
-		walk_attribute_list(v, n.attributes[:]);
-		walk(v, n.name);
+		walk_attribute_list(v, n.attributes[:])
+		walk(v, n.name)
 		if n.comment != nil {
-			walk(v, n.comment);
+			walk(v, n.comment)
 		}

 	case Proc_Group:
-		walk_expr_list(v, n.args);
+		walk_expr_list(v, n.args)
 	case Attribute:
-		walk_expr_list(v, n.elems);
+		walk_expr_list(v, n.elems)
 	case Field:
 		if n.docs != nil {
-			walk(v, n.docs);
+			walk(v, n.docs)
 		}
-		walk_expr_list(v, n.names);
+		walk_expr_list(v, n.names)
 		if n.type != nil {
-			walk(v, n.type);
+			walk(v, n.type)
 		}
 		if n.default_value != nil {
-			walk(v, n.default_value);
+			walk(v, n.default_value)
 		}
 		if n.comment != nil {
-			walk(v, n.comment);
+			walk(v, n.comment)
 		}
 	case Field_List:
 		for x in n.list {
-			walk(v, x);
+			walk(v, x)
 		}
 	case Typeid_Type:
 		if n.specialization != nil {
-			walk(v, n.specialization);
+			walk(v, n.specialization)
 		}
 	case Helper_Type:
-		walk(v, n.type);
+		walk(v, n.type)
 	case Distinct_Type:
-		walk(v, n.type);
+		walk(v, n.type)
 	case Poly_Type:
-		walk(v, n.type);
+		walk(v, n.type)
 		if n.specialization != nil {
-			walk(v, n.specialization);
+			walk(v, n.specialization)
 		}
 	case Proc_Type:
-		walk(v, n.params);
-		walk(v, n.results);
+		walk(v, n.params)
+		walk(v, n.results)
 	case Pointer_Type:
-		walk(v, n.elem);
+		walk(v, n.elem)
 	case Multi_Pointer_Type:
-		walk(v, n.elem);
+		walk(v, n.elem)
 	case Array_Type:
 		if n.tag != nil {
-			walk(v, n.tag);
+			walk(v, n.tag)
 		}
 		if n.len != nil {
-			walk(v, n.len);
+			walk(v, n.len)
 		}
-		walk(v, n.elem);
+		walk(v, n.elem)
 	case Dynamic_Array_Type:
 		if n.tag != nil {
-			walk(v, n.tag);
+			walk(v, n.tag)
 		}
-		walk(v, n.elem);
+		walk(v, n.elem)
 	case Struct_Type:
 		if n.poly_params != nil {
-			walk(v, n.poly_params);
+			walk(v, n.poly_params)
 		}
 		if n.align != nil {
-			walk(v, n.align);
+			walk(v, n.align)
 		}
-		walk_expr_list(v, n.where_clauses);
-		walk(v, n.fields);
+		walk_expr_list(v, n.where_clauses)
+		walk(v, n.fields)
 	case Union_Type:
 		if n.poly_params != nil {
-			walk(v, n.poly_params);
+			walk(v, n.poly_params)
 		}
 		if n.align != nil {
-			walk(v, n.align);
+			walk(v, n.align)
 		}
-		walk_expr_list(v, n.where_clauses);
-		walk_expr_list(v, n.variants);
+		walk_expr_list(v, n.where_clauses)
+		walk_expr_list(v, n.variants)
 	case Enum_Type:
 		if n.base_type != nil {
-			walk(v, n.base_type);
+			walk(v, n.base_type)
 		}
-		walk_expr_list(v, n.fields);
+		walk_expr_list(v, n.fields)
 	case Bit_Set_Type:
-		walk(v, n.elem);
+		walk(v, n.elem)
 		if n.underlying != nil {
-			walk(v, n.underlying);
+			walk(v, n.underlying)
 		}
 	case Map_Type:
-		walk(v, n.key);
-		walk(v, n.value);
+		walk(v, n.key)
+		walk(v, n.value)
 	case Relative_Type:
-		walk(v, n.tag);
-		walk(v, n.type);
+		walk(v, n.tag)
+		walk(v, n.type)

 	case:
-		fmt.panicf("ast.walk: unexpected node type %T", n);
+		fmt.panicf("ast.walk: unexpected node type %T", n)
 	}

-	v->visit(nil);
+	v->visit(nil)
 }