Remove unneeded semicolons from the core library

core/odin/ast/ast.odin

@@ -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 {

core/odin/ast/clone.odin

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

core/odin/ast/walk.odin

@@ -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)
 }
 

core/odin/doc-format/doc_format.odin

@@ -7,24 +7,24 @@ Array :: struct($T: typeid) {
 	length: u32le,
 }
 
-String :: distinct Array(byte);
+String :: distinct Array(byte)
 
-Version_Type_Major :: 0;
-Version_Type_Minor :: 1;
-Version_Type_Patch :: 0;
+Version_Type_Major :: 0
+Version_Type_Minor :: 1
+Version_Type_Patch :: 0
 
 Version_Type :: struct {
 	major, minor, patch: u8,
 	_: u8,
-};
+}
 
 Version_Type_Default :: Version_Type{
 	major=Version_Type_Major,
 	minor=Version_Type_Minor,
 	patch=Version_Type_Patch,
-};
+}
 
-Magic_String :: "odindoc\x00";
+Magic_String :: "odindoc\x00"
 
 Header_Base :: struct {
 	magic: [8]byte,
@@ -45,10 +45,10 @@ Header :: struct {
 	types:    Array(Type),
 }
 
-File_Index   :: distinct u32le;
-Pkg_Index    :: distinct u32le;
-Entity_Index :: distinct u32le;
-Type_Index   :: distinct u32le;
+File_Index   :: distinct u32le
+Pkg_Index    :: distinct u32le
+Entity_Index :: distinct u32le
+Type_Index   :: distinct u32le
 
 
 Position :: struct {
@@ -56,7 +56,7 @@ Position :: struct {
 	line:   u32le,
 	column: u32le,
 	offset: u32le,
-};
+}
 
 File :: struct {
 	pkg:  Pkg_Index,
@@ -69,7 +69,7 @@ Pkg_Flag :: enum u32le {
 	Init    = 2,
 }
 
-Pkg_Flags :: distinct bit_set[Pkg_Flag; u32le];
+Pkg_Flags :: distinct bit_set[Pkg_Flag; u32le]
 
 Pkg :: struct {
 	fullpath: String,
@@ -108,7 +108,7 @@ Entity_Flag :: enum u32le {
 	Var_Static       = 10,
 }
 
-Entity_Flags :: distinct bit_set[Entity_Flag; u32le];
+Entity_Flags :: distinct bit_set[Entity_Flag; u32le]
 
 Entity :: struct {
 	kind:             Entity_Kind,
@@ -169,7 +169,7 @@ Type_Kind :: enum u32le {
 	Multi_Pointer      = 22,
 }
 
-Type_Elems_Cap :: 4;
+Type_Elems_Cap :: 4
 
 Type :: struct {
 	kind:  Type_Kind,
@@ -239,26 +239,26 @@ Type :: struct {
 	where_clauses: Array(String),
 }
 
-Type_Flags_Basic :: distinct bit_set[Type_Flag_Basic; u32le];
+Type_Flags_Basic :: distinct bit_set[Type_Flag_Basic; u32le]
 Type_Flag_Basic :: enum u32le {
 	Untyped = 1,
 }
 
-Type_Flags_Struct :: distinct bit_set[Type_Flag_Struct; u32le];
+Type_Flags_Struct :: distinct bit_set[Type_Flag_Struct; u32le]
 Type_Flag_Struct :: enum u32le {
 	Polymorphic = 0,
 	Packed      = 1,
 	Raw_Union   = 2,
 }
 
-Type_Flags_Union :: distinct bit_set[Type_Flag_Union; u32le];
+Type_Flags_Union :: distinct bit_set[Type_Flag_Union; u32le]
 Type_Flag_Union :: enum u32le {
 	Polymorphic = 0,
 	No_Nil      = 1,
 	Maybe       = 2,
 }
 
-Type_Flags_Proc :: distinct bit_set[Type_Flag_Proc; u32le];
+Type_Flags_Proc :: distinct bit_set[Type_Flag_Proc; u32le]
 Type_Flag_Proc :: enum u32le {
 	Polymorphic = 0,
 	Diverging   = 1,
@@ -267,7 +267,7 @@ Type_Flag_Proc :: enum u32le {
 	C_Vararg    = 4,
 }
 
-Type_Flags_Bit_Set :: distinct bit_set[Type_Flag_Bit_Set; u32le];
+Type_Flags_Bit_Set :: distinct bit_set[Type_Flag_Bit_Set; u32le]
 Type_Flag_Bit_Set :: enum u32le {
 	Range            = 1,
 	Op_Lt            = 2,
@@ -276,13 +276,13 @@ Type_Flag_Bit_Set :: enum u32le {
 }
 
 from_array :: proc(base: ^Header_Base, a: $A/Array($T)) -> []T {
-	s: mem.Raw_Slice;
-	s.data = rawptr(uintptr(base) + uintptr(a.offset));
-	s.len = int(a.length);
-	return transmute([]T)s;
+	s: mem.Raw_Slice
+	s.data = rawptr(uintptr(base) + uintptr(a.offset))
+	s.len = int(a.length)
+	return transmute([]T)s
 }
 from_string :: proc(base: ^Header_Base, s: String) -> string {
-	return string(from_array(base, s));
+	return string(from_array(base, s))
 }
 
 
@@ -298,22 +298,22 @@ Reader_Error :: enum {
 
 read_from_bytes :: proc(data: []byte) -> (h: ^Header, err: Reader_Error) {
 	if len(data) < size_of(Header_Base) {
-		err = .Header_Too_Small;
-		return;
+		err = .Header_Too_Small
+		return
 	}
-	header_base := (^Header_Base)(raw_data(data));
+	header_base := (^Header_Base)(raw_data(data))
 	if header_base.magic != Magic_String {
-		err = .Invalid_Magic;
-		return;
+		err = .Invalid_Magic
+		return
 	}
 	if len(data) < int(header_base.total_size) {
-		err = .Data_Too_Small;
-		return;
+		err = .Data_Too_Small
+		return
 	}
 	if header_base.version != Version_Type_Default {
-		err = .Invalid_Version;
-		return;
+		err = .Invalid_Version
+		return
 	}
-	h = (^Header)(header_base);
-	return;
+	h = (^Header)(header_base)
+	return
 }

core/odin/format/format.odin

@@ -4,38 +4,38 @@ import "core:odin/printer"
 import "core:odin/parser"
 import "core:odin/ast"
 
-default_style := printer.default_style;
+default_style := printer.default_style
 
 simplify :: proc(file: ^ast.File) {
 
 }
 
 format :: proc(filepath: string, source: string, config: printer.Config, parser_flags := parser.Flags{}, allocator := context.allocator) -> (string, bool) {
-	config := config;
+	config := config
 
 	pkg := ast.Package {
 		kind = .Normal,
-	};
+	}
 
 	file := ast.File {
 		pkg = &pkg,
 		src = source,
 		fullpath = filepath,
-	};
-
-	config.newline_limit      = clamp(config.newline_limit, 0, 16);
-	config.spaces             = clamp(config.spaces, 1, 16);
-	config.align_length_break = clamp(config.align_length_break, 0, 64);
-
-	p := parser.default_parser(parser_flags);
-
-	ok := parser.parse_file(&p, &file);
-
-	if !ok || file.syntax_error_count > 0  {
-		return {}, false;
 	}
 
-	prnt := printer.make_printer(config, allocator);
+	config.newline_limit      = clamp(config.newline_limit, 0, 16)
+	config.spaces             = clamp(config.spaces, 1, 16)
+	config.align_length_break = clamp(config.align_length_break, 0, 64)
 
-	return printer.print(&prnt, &file), true;
+	p := parser.default_parser(parser_flags)
+
+	ok := parser.parse_file(&p, &file)
+
+	if !ok || file.syntax_error_count > 0  {
+		return {}, false
+	}
+
+	prnt := printer.make_printer(config, allocator)
+
+	return printer.print(&prnt, &file), true
 }

core/odin/parser/parse_files.odin

@@ -8,82 +8,82 @@ import "core:os"
 import "core:slice"
 
 collect_package :: proc(path: string) -> (pkg: ^ast.Package, success: bool) {
-	NO_POS :: tokenizer.Pos{};
+	NO_POS :: tokenizer.Pos{}
 
-	pkg_path, pkg_path_ok := filepath.abs(path);
+	pkg_path, pkg_path_ok := filepath.abs(path)
 	if !pkg_path_ok {
-		return;
+		return
 	}
 
-	path_pattern := fmt.tprintf("%s/*.odin", pkg_path);
-	matches, err := filepath.glob(path_pattern);
-	defer delete(matches);
+	path_pattern := fmt.tprintf("%s/*.odin", pkg_path)
+	matches, err := filepath.glob(path_pattern)
+	defer delete(matches)
 
 	if err != nil {
-		return;
+		return
 	}
 
-	pkg = ast.new(ast.Package, NO_POS, NO_POS);
-	pkg.fullpath = pkg_path;
+	pkg = ast.new(ast.Package, NO_POS, NO_POS)
+	pkg.fullpath = pkg_path
 
 	for match in matches {
-		src: []byte;
-		fullpath, ok := filepath.abs(match);
+		src: []byte
+		fullpath, ok := filepath.abs(match)
 		if !ok {
-			return;
+			return
 		}
-		src, ok = os.read_entire_file(fullpath);
+		src, ok = os.read_entire_file(fullpath)
 		if !ok {
-			delete(fullpath);
-			return;
+			delete(fullpath)
+			return
 		}
-		file := ast.new(ast.File, NO_POS, NO_POS);
-		file.pkg = pkg;
-		file.src = string(src);
-		file.fullpath = fullpath;
-		pkg.files[fullpath] = file;
+		file := ast.new(ast.File, NO_POS, NO_POS)
+		file.pkg = pkg
+		file.src = string(src)
+		file.fullpath = fullpath
+		pkg.files[fullpath] = file
 	}
 
-	success = true;
-	return;
+	success = true
+	return
 }
 
 parse_package :: proc(pkg: ^ast.Package, p: ^Parser = nil) -> bool {
-	p := p;
+	p := p
 	if p == nil {
-		p = &Parser{};
-		p^ = default_parser();
+		p = &Parser{}
+		p^ = default_parser()
 	}
 
-	ok := true;
+	ok := true
 
-	files := make([]^ast.File, len(pkg.files), context.temp_allocator);
-	i := 0;
+	files := make([]^ast.File, len(pkg.files), context.temp_allocator)
+	i := 0
 	for _, file in pkg.files {
-		files[i] = file;
-		i += 1;
+		files[i] = file
+		i += 1
 	}
-	slice.sort(files);
+	slice.sort(files)
 
 	for file in files {
 		if !parse_file(p, file) {
-			ok = false;
+			ok = false
 		}
 		if pkg.name == "" {
-			pkg.name = file.pkg_decl.name;
+			pkg.name = file.pkg_decl.name
 		} else if pkg.name != file.pkg_decl.name {
-			error(p, file.pkg_decl.pos, "different package name, expected '%s', got '%s'", pkg.name, file.pkg_decl.name);
+			error(p, file.pkg_decl.pos, "different package name, expected '%s', got '%s'", pkg.name, file.pkg_decl.name)
 		}
 	}
 
-	return ok;
+	return ok
 }
 
 parse_package_from_path :: proc(path: string, p: ^Parser = nil) -> (pkg: ^ast.Package, ok: bool) {
-	pkg, ok = collect_package(path);
+	pkg, ok = collect_package(path)
 	if !ok {
-		return;
+		return
 	}
-	ok = parse_package(pkg, p);
-	return;
+	ok = parse_package(pkg, p)
+	return
 }

core/odin/tokenizer/token.odin

@@ -17,15 +17,15 @@ Pos :: struct {
 
 pos_compare :: proc(lhs, rhs: Pos) -> int {
 	if lhs.offset != rhs.offset {
-		return -1 if (lhs.offset < rhs.offset) else +1;
+		return -1 if (lhs.offset < rhs.offset) else +1
 	}
 	if lhs.line != rhs.line {
-		return -1 if (lhs.line < rhs.line) else +1;
+		return -1 if (lhs.line < rhs.line) else +1
 	}
 	if lhs.column != rhs.column {
-		return -1 if (lhs.column < rhs.column) else +1;
+		return -1 if (lhs.column < rhs.column) else +1
 	}
-	return strings.compare(lhs.file, rhs.file);
+	return strings.compare(lhs.file, rhs.file)
 }
 
 Token_Kind :: enum u32 {
@@ -156,7 +156,7 @@ Token_Kind :: enum u32 {
 
 	B_Custom_Keyword_Begin = COUNT+1,
 	// ... Custom keywords
-};
+}
 
 tokens := [Token_Kind.COUNT]string {
 	"Invalid",
@@ -281,60 +281,60 @@ tokens := [Token_Kind.COUNT]string {
 	"inline",
 	"no_inline",
 	"",
-};
+}
 
-custom_keyword_tokens: []string;
+custom_keyword_tokens: []string
 
 
 is_newline :: proc(tok: Token) -> bool {
-	return tok.kind == .Semicolon && tok.text == "\n";
+	return tok.kind == .Semicolon && tok.text == "\n"
 }
 
 
 token_to_string :: proc(tok: Token) -> string {
 	if is_newline(tok) {
-		return "newline";
+		return "newline"
 	}
-	return to_string(tok.kind);
+	return to_string(tok.kind)
 }
 
 to_string :: proc(kind: Token_Kind) -> string {
 	if Token_Kind.Invalid <= kind && kind < Token_Kind.COUNT {
-		return tokens[kind];
+		return tokens[kind]
 	}
 	if Token_Kind.B_Custom_Keyword_Begin < kind {
-		n := int(u16(kind)-u16(Token_Kind.B_Custom_Keyword_Begin));
+		n := int(u16(kind)-u16(Token_Kind.B_Custom_Keyword_Begin))
 		if n < len(custom_keyword_tokens) {
-			return custom_keyword_tokens[n];
+			return custom_keyword_tokens[n]
 		}
 	}
 
-	return "Invalid";
+	return "Invalid"
 }
 
 is_literal  :: proc(kind: Token_Kind) -> bool {
-	return Token_Kind.B_Literal_Begin  < kind && kind < Token_Kind.B_Literal_End;
+	return Token_Kind.B_Literal_Begin  < kind && kind < Token_Kind.B_Literal_End
 }
 is_operator :: proc(kind: Token_Kind) -> bool {
 	#partial switch kind {
 	case .B_Operator_Begin .. .B_Operator_End:
-		return true;
+		return true
 	case .In, .Not_In:
-		return true;
+		return true
 	case .If:
-		return true;
+		return true
 	}
-	return false;
+	return false
 }
 is_assignment_operator :: proc(kind: Token_Kind) -> bool {
-	return Token_Kind.B_Assign_Op_Begin < kind && kind < Token_Kind.B_Assign_Op_End || kind == Token_Kind.Eq;
+	return Token_Kind.B_Assign_Op_Begin < kind && kind < Token_Kind.B_Assign_Op_End || kind == Token_Kind.Eq
 }
 is_keyword :: proc(kind: Token_Kind) -> bool {
 	switch {
 	case Token_Kind.B_Keyword_Begin < kind && kind < Token_Kind.B_Keyword_End:
-		return true;
+		return true
 	case Token_Kind.B_Custom_Keyword_Begin < kind:
-		return true;
+		return true
 	}
-	return false;
+	return false
 }