From e918f8faf27af25a9fa39eb35f91d0759c71c759 Mon Sep 17 00:00:00 2001
From: Alexander Medvednikov <alexander@vlang.io>
Date: Wed, 24 Jun 2020 14:44:06 +0200
Subject: [PATCH] fmt: re-run on checker.v and cgen.v

---
 vlib/v/checker/checker.v | 147 +++++++++++++++++++++++----------------
 vlib/v/gen/cgen.v        |  99 ++++++++++----------------
 2 files changed, 122 insertions(+), 124 deletions(-)

diff --git a/vlib/v/checker/checker.v b/vlib/v/checker/checker.v
index 15c1e87409..83b0c47c7e 100644
--- a/vlib/v/checker/checker.v
+++ b/vlib/v/checker/checker.v
@@ -80,7 +80,7 @@ pub fn (mut c Checker) check_scope_vars(sc &ast.Scope) {
 				}
 				// TODO: fix all of these warnings
 				// if obj.is_mut && !obj.is_changed {
-				// 	c.warn('`$obj.name` is declared as mutable, but it was never changed', obj.pos)
+				// c.warn('`$obj.name` is declared as mutable, but it was never changed', obj.pos)
 				// }
 			}
 			else {}
@@ -190,7 +190,8 @@ fn (mut c Checker) check_file_in_main(file ast.File) bool {
 				if stmt is ast.AliasTypeDecl {
 					alias_decl := stmt as ast.AliasTypeDecl
 					if alias_decl.is_pub {
-						c.warn('type alias `$alias_decl.name` $no_pub_in_main_warning', alias_decl.pos)
+						c.warn('type alias `$alias_decl.name` $no_pub_in_main_warning',
+							alias_decl.pos)
 					}
 				} else if stmt is ast.SumTypeDecl {
 					sum_decl := stmt as ast.SumTypeDecl
@@ -308,7 +309,8 @@ pub fn (mut c Checker) struct_decl(decl ast.StructDecl) {
 		if sym.kind == .struct_ {
 			info := sym.info as table.Struct
 			if info.is_ref_only && !field.typ.is_ptr() {
-				c.error('`$sym.name` type can only be used as a reference: `&$sym.name`', field.pos)
+				c.error('`$sym.name` type can only be used as a reference: `&$sym.name`',
+					field.pos)
 			}
 		}
 		if field.has_default_expr {
@@ -317,8 +319,8 @@ pub fn (mut c Checker) struct_decl(decl ast.StructDecl) {
 			if !c.check_types(field_expr_type, field.typ) {
 				field_expr_type_sym := c.table.get_type_symbol(field_expr_type)
 				field_type_sym := c.table.get_type_symbol(field.typ)
-				c.error('default expression for field `$field.name` ' + 'has type `$field_expr_type_sym.name`, but should be `$field_type_sym.name`',
-					field.default_expr.position())
+				c.error('default expression for field `$field.name` ' +
+					'has type `$field_expr_type_sym.name`, but should be `$field_type_sym.name`', field.default_expr.position())
 			}
 		}
 	}
@@ -394,7 +396,8 @@ pub fn (mut c Checker) struct_init(mut struct_init ast.StructInit) table.Type {
 						continue
 					}
 					if field_name in inited_fields {
-						c.error('duplicate field name in struct literal: `$field_name`', field.pos)
+						c.error('duplicate field name in struct literal: `$field_name`',
+							field.pos)
 						continue
 					}
 				}
@@ -512,7 +515,8 @@ pub fn (mut c Checker) infix_expr(mut infix_expr ast.InfixExpr) table.Type {
 						pos := if left_type == promoted_type { left_pos } else { right_pos }
 						name := if left_type == promoted_type { left.name } else { right.name }
 						if infix_expr.op == .mod {
-							c.error('float modulo not allowed, use math.fmod() instead', pos)
+							c.error('float modulo not allowed, use math.fmod() instead',
+								pos)
 						} else {
 							c.error('$side type of `$infix_expr.op.str()` cannot be non-integer type $name',
 								pos)
@@ -520,8 +524,10 @@ pub fn (mut c Checker) infix_expr(mut infix_expr ast.InfixExpr) table.Type {
 					}
 				}
 				if infix_expr.op in [.div, .mod] {
-					if (infix_expr.right is ast.IntegerLiteral && infix_expr.right.str() ==
-						'0') || (infix_expr.right is ast.FloatLiteral && infix_expr.right.str().f64() == 0.0) {
+					if (infix_expr.right is ast.IntegerLiteral &&
+						infix_expr.right.str() == '0') ||
+						(infix_expr.right is ast.FloatLiteral &&
+						infix_expr.right.str().f64() == 0.0) {
 						oper := if infix_expr.op == .div { 'division' } else { 'modulo' }
 						c.error('$oper by zero', right_pos)
 					}
@@ -594,8 +600,8 @@ pub fn (mut c Checker) infix_expr(mut infix_expr ast.InfixExpr) table.Type {
 	if left_type == table.bool_type && infix_expr.op !in [.eq, .ne, .logical_or, .and] {
 		c.error('bool types only have the following operators defined: `==`, `!=`, `||`, and `&&`',
 			infix_expr.pos)
-	} else if left_type == table.string_type && infix_expr.op !in [.plus, .eq, .ne, .lt, .gt,
-		.le, .ge] {
+	} else if left_type == table.string_type &&
+		infix_expr.op !in [.plus, .eq, .ne, .lt, .gt, .le, .ge] {
 		// TODO broken !in
 		c.error('string types only have the following operators defined: `==`, `!=`, `<`, `>`, `<=`, `>=`, and `+`',
 			infix_expr.pos)
@@ -698,13 +704,13 @@ fn (mut c Checker) check_map_and_filter(is_map bool, elem_typ table.Type, call_e
 		ast.AnonFn {
 			if it.decl.args.len > 1 {
 				c.error('function needs exactly 1 argument', call_expr.pos)
-			} else if is_map && (it.decl.return_type != elem_typ || it.decl.args[0].typ !=
-				elem_typ) {
+			} else if is_map && (it.decl.return_type != elem_typ || it.decl.args[0].typ != elem_typ) {
 				c.error('type mismatch, should use `fn(a $elem_sym.name) $elem_sym.name {...}`',
 					call_expr.pos)
-			} else if !is_map && (it.decl.return_type != table.bool_type || it.decl.args[0].typ !=
-				elem_typ) {
-				c.error('type mismatch, should use `fn(a $elem_sym.name) bool {...}`', call_expr.pos)
+			} else if !is_map && (it.decl.return_type != table.bool_type ||
+				it.decl.args[0].typ != elem_typ) {
+				c.error('type mismatch, should use `fn(a $elem_sym.name) bool {...}`',
+					call_expr.pos)
 			}
 		}
 		ast.Ident {
@@ -718,8 +724,8 @@ fn (mut c Checker) check_map_and_filter(is_map bool, elem_typ table.Type, call_e
 				} else if is_map && (func.return_type != elem_typ || func.args[0].typ != elem_typ) {
 					c.error('type mismatch, should use `fn(a $elem_sym.name) $elem_sym.name {...}`',
 						call_expr.pos)
-				} else if !is_map && (func.return_type != table.bool_type || func.args[0].typ !=
-					elem_typ) {
+				} else if !is_map && (func.return_type != table.bool_type ||
+					func.args[0].typ != elem_typ) {
 					c.error('type mismatch, should use `fn(a $elem_sym.name) bool {...}`',
 						call_expr.pos)
 				}
@@ -735,15 +741,14 @@ pub fn (mut c Checker) call_method(mut call_expr ast.CallExpr) table.Type {
 	call_expr.left_type = left_type
 	left_type_sym := c.table.get_type_symbol(c.unwrap_generic(left_type))
 	method_name := call_expr.name
-
 	if left_type.has_flag(.optional) {
 		c.error('optional type cannot be called directly', call_expr.left.position())
 		return table.void_type
 	}
 	// TODO: remove this for actual methods, use only for compiler magic
 	// FIXME: Argument count != 1 will break these
-	if left_type_sym.kind == .array && method_name in ['filter', 'clone', 'repeat', 'reverse',
-		'map', 'slice'] {
+	if left_type_sym.kind == .array &&
+		method_name in ['filter', 'clone', 'repeat', 'reverse', 'map', 'slice'] {
 		mut elem_typ := table.void_type
 		if method_name in ['filter', 'map'] {
 			array_info := left_type_sym.info as table.Array
@@ -796,20 +801,22 @@ pub fn (mut c Checker) call_method(mut call_expr ast.CallExpr) table.Type {
 		if arg_sym.kind == .array {
 			info := arg_sym.info as table.Array
 			sym := c.table.get_type_symbol(info.elem_type)
-			if sym.kind != elem_sym.kind && ((elem_sym.kind == .int && sym.kind != .any_int) ||
+			if sym.kind != elem_sym.kind &&
+				((elem_sym.kind == .int && sym.kind != .any_int) ||
 				(elem_sym.kind == .f64 && sym.kind != .any_float)) {
 				c.error('type mismatch, should use `$elem_sym.name[]`', arg_expr.position())
 			}
 		} else {
-			if arg_sym.kind != elem_sym.kind && ((elem_sym.kind == .int && arg_sym.kind !=
-				.any_int) || (elem_sym.kind == .f64 && arg_sym.kind != .any_float)) {
+			if arg_sym.kind != elem_sym.kind &&
+				((elem_sym.kind == .int && arg_sym.kind != .any_int) ||
+				(elem_sym.kind == .f64 && arg_sym.kind != .any_float)) {
 				c.error('type mismatch, should use `$elem_sym.name`', arg_expr.position())
 			}
 		}
 	}
 	if method := c.table.type_find_method(left_type_sym, method_name) {
-		if !method.is_pub && !c.is_builtin_mod && !c.pref.is_test && left_type_sym.mod != c.mod &&
-			left_type_sym.mod != '' { // method.mod != c.mod {
+		if !method.is_pub && !c.is_builtin_mod && !c.pref.is_test &&
+			left_type_sym.mod != c.mod && left_type_sym.mod != '' { // method.mod != c.mod {
 			// If a private method is called outside of the module
 			// its receiver type is defined in, show an error.
 			// println('warn $method_name lef.mod=$left_type_sym.mod c.mod=$c.mod')
@@ -819,8 +826,8 @@ pub fn (mut c Checker) call_method(mut call_expr ast.CallExpr) table.Type {
 			c.fail_if_immutable(call_expr.left)
 			// call_expr.is_mut = true
 		}
-		if method.return_type == table.void_type && method.ctdefine.len > 0 && method.ctdefine !in
-			c.pref.compile_defines {
+		if method.return_type == table.void_type &&
+			method.ctdefine.len > 0 && method.ctdefine !in c.pref.compile_defines {
 			call_expr.should_be_skipped = true
 		}
 		nr_args := if method.args.len == 0 { 0 } else { method.args.len - 1 }
@@ -845,9 +852,9 @@ pub fn (mut c Checker) call_method(mut call_expr ast.CallExpr) table.Type {
 			c.expected_type = exp_arg_typ
 			got_arg_typ := c.expr(arg.expr)
 			call_expr.args[i].typ = got_arg_typ
-			if method.is_variadic && got_arg_typ.has_flag(.variadic) && call_expr.args.len -
-				1 > i {
-				c.error('when forwarding a varg variable, it must be the final argument', call_expr.pos)
+			if method.is_variadic && got_arg_typ.has_flag(.variadic) && call_expr.args.len - 1 > i {
+				c.error('when forwarding a varg variable, it must be the final argument',
+					call_expr.pos)
 			}
 			if exp_arg_sym.kind == .interface_ {
 				c.type_implements(got_arg_typ, exp_arg_typ, arg.expr.position())
@@ -857,7 +864,7 @@ pub fn (mut c Checker) call_method(mut call_expr ast.CallExpr) table.Type {
 				got_arg_sym := c.table.get_type_symbol(got_arg_typ)
 				// str method, allow type with str method if fn arg is string
 				// if exp_arg_sym.kind == .string && got_arg_sym.has_method('str') {
-				// 	continue
+				// continue
 				// }
 				if got_arg_typ != table.void_type {
 					c.error('cannot use type `$got_arg_sym.str()` as type `$exp_arg_sym.str()` in argument ${i+1} to `${left_type_sym.name}.$method_name`',
@@ -1003,7 +1010,8 @@ pub fn (mut c Checker) call_fn(mut call_expr ast.CallExpr) table.Type {
 		c.warn('function `$f.name` has been deprecated', call_expr.pos)
 	}
 	call_expr.return_type = f.return_type
-	if f.return_type == table.void_type && f.ctdefine.len > 0 && f.ctdefine !in c.pref.compile_defines {
+	if f.return_type == table.void_type &&
+		f.ctdefine.len > 0 && f.ctdefine !in c.pref.compile_defines {
 		call_expr.should_be_skipped = true
 	}
 	if f.language != .v || call_expr.language != .v {
@@ -1058,7 +1066,8 @@ pub fn (mut c Checker) call_fn(mut call_expr ast.CallExpr) table.Type {
 		typ_sym := c.table.get_type_symbol(typ)
 		arg_typ_sym := c.table.get_type_symbol(arg.typ)
 		if f.is_variadic && typ.has_flag(.variadic) && call_expr.args.len - 1 > i {
-			c.error('when forwarding a varg variable, it must be the final argument', call_expr.pos)
+			c.error('when forwarding a varg variable, it must be the final argument',
+				call_expr.pos)
 		}
 		if arg.is_mut && !call_arg.is_mut {
 			c.error('`$arg.name` is a mutable argument, you need to provide `mut`: `${call_expr.name}(mut ...)`',
@@ -1260,7 +1269,7 @@ pub fn (mut c Checker) return_stmt(mut return_stmt ast.Return) {
 			return_stmt.pos)
 		return
 	} else if return_stmt.exprs.len == 0 && !(c.expected_type == table.void_type ||
-			c.table.get_type_symbol(c.expected_type).kind == .void) {
+		c.table.get_type_symbol(c.expected_type).kind == .void) {
 		c.error('too few arguments to return', return_stmt.pos)
 		return
 	}
@@ -1359,7 +1368,9 @@ pub fn (mut c Checker) assign_stmt(mut assign_stmt ast.AssignStmt) {
 	mut right_len := assign_stmt.right.len
 	if right_first is ast.CallExpr || right_first is ast.IfExpr || right_first is ast.MatchExpr {
 		right_type0 := c.expr(right_first)
-		assign_stmt.right_types = [c.check_expr_opt_call(right_first, right_type0)]
+		assign_stmt.right_types = [
+			c.check_expr_opt_call(right_first, right_type0)
+		]
 		right_type_sym0 := c.table.get_type_symbol(right_type0)
 		if right_type_sym0.kind == .multi_return {
 			assign_stmt.right_types = right_type_sym0.mr_info().types
@@ -1444,7 +1455,8 @@ pub fn (mut c Checker) assign_stmt(mut assign_stmt ast.AssignStmt) {
 				if !left_sym.is_number() && left_type != table.string_type && !left_sym.is_pointer() {
 					c.error('operator += not defined on left operand type `$left_sym.name`',
 						left.position())
-				} else if !right_sym.is_number() && right_type != table.string_type && !right_sym.is_pointer() {
+				} else if !right_sym.is_number() && right_type != table.string_type &&
+					!right_sym.is_pointer() {
 					c.error('operator += not defined on right operand type `$right_sym.name`',
 						right.position())
 				}
@@ -1523,7 +1535,8 @@ pub fn (mut c Checker) array_init(mut array_init ast.ArrayInit) table.Type {
 	if array_init.exprs.len == 0 {
 		type_sym := c.table.get_type_symbol(c.expected_type)
 		if type_sym.kind != .array {
-			c.error('array_init: no type specified (maybe: `[]Type{}` instead of `[]`)', array_init.pos)
+			c.error('array_init: no type specified (maybe: `[]Type{}` instead of `[]`)',
+				array_init.pos)
 			return table.void_type
 		}
 		// TODO: seperate errors once bug is fixed with `x := if expr { ... } else { ... }`
@@ -1581,7 +1594,8 @@ pub fn (mut c Checker) array_init(mut array_init ast.ArrayInit) table.Type {
 			array_init.interface_types = interface_types
 		}
 		if array_init.is_fixed {
-			idx := c.table.find_or_register_array_fixed(elem_type, array_init.exprs.len, 1)
+			idx := c.table.find_or_register_array_fixed(elem_type, array_init.exprs.len,
+				1)
 			array_init.typ = table.new_type(idx)
 		} else {
 			sym := c.table.get_type_symbol(elem_type)
@@ -1589,7 +1603,8 @@ pub fn (mut c Checker) array_init(mut array_init ast.ArrayInit) table.Type {
 			array_init.typ = table.new_type(idx)
 		}
 		array_init.elem_type = elem_type
-	} else if array_init.is_fixed && array_init.exprs.len == 1 && array_init.elem_type != table.void_type {
+	} else if array_init.is_fixed && array_init.exprs.len == 1 &&
+		array_init.elem_type != table.void_type {
 		// [50]byte
 		mut fixed_size := 1
 		match array_init.exprs[0] {
@@ -1604,8 +1619,7 @@ pub fn (mut c Checker) array_init(mut array_init ast.ArrayInit) table.Type {
 				// scope.find(it.name) or {
 				// c.error('undefined ident: `$it.name`', array_init.pos)
 				// }
-				mut full_const_name := if it.mod == 'main' { it.name } else { it.mod + '.' +
-						it.name }
+				mut full_const_name := if it.mod == 'main' { it.name } else { it.mod + '.' + it.name }
 				if obj := c.file.global_scope.find_const(full_const_name) {
 					if cint := const_int_value(obj) {
 						fixed_size = cint
@@ -1619,7 +1633,8 @@ pub fn (mut c Checker) array_init(mut array_init ast.ArrayInit) table.Type {
 				c.error('expecting `int` for fixed size', array_init.pos)
 			}
 		}
-		idx := c.table.find_or_register_array_fixed(array_init.elem_type, fixed_size, 1)
+		idx := c.table.find_or_register_array_fixed(array_init.elem_type, fixed_size,
+			1)
 		array_type := table.new_type(idx)
 		array_init.typ = array_type
 	}
@@ -1771,7 +1786,8 @@ fn (mut c Checker) stmt(node ast.Stmt) {
 				value_type := c.table.value_type(typ)
 				if value_type == table.void_type || typ.has_flag(.optional) {
 					if typ != table.void_type {
-						c.error('for in: cannot index `${c.table.type_to_str(typ)}`', it.cond.position())
+						c.error('for in: cannot index `${c.table.type_to_str(typ)}`',
+							it.cond.position())
 					}
 				}
 				it.cond_type = typ
@@ -1882,7 +1898,11 @@ pub fn (mut c Checker) expr(node ast.Expr) table.Type {
 			c.cur_fn = &node.decl
 			c.stmts(node.decl.stmts)
 			c.cur_fn = keep_fn
-			return if node.is_called { node.decl.return_type } else { node.typ }
+			return if node.is_called {
+				node.decl.return_type
+			} else {
+				node.typ
+			}
 		}
 		ast.ArrayInit {
 			return c.array_init(mut node)
@@ -1925,10 +1945,11 @@ pub fn (mut c Checker) expr(node ast.Expr) table.Type {
 		ast.CastExpr {
 			node.expr_type = c.expr(node.expr)
 			sym := c.table.get_type_symbol(node.expr_type)
-			if node.typ == table.string_type && !(sym.kind in [.byte, .byteptr] || (sym.kind ==
-				.array && sym.name == 'array_byte')) {
+			if node.typ == table.string_type && !(sym.kind in [.byte, .byteptr] ||
+				(sym.kind == .array && sym.name == 'array_byte')) {
 				type_name := c.table.type_to_str(node.expr_type)
-				c.error('cannot cast type `$type_name` to string, use `x.str()` instead', node.pos)
+				c.error('cannot cast type `$type_name` to string, use `x.str()` instead',
+					node.pos)
 			}
 			if node.expr_type == table.string_type {
 				mut error_msg := 'cannot cast a string'
@@ -1957,7 +1978,10 @@ pub fn (mut c Checker) expr(node ast.Expr) table.Type {
 			if node.is_vweb {
 				// TODO assoc parser bug
 				pref := *c.pref
-				pref2 := {pref|is_vweb: true}
+				pref2 := {
+					pref |
+					is_vweb: true
+				}
 				mut c2 := new_checker(c.table, pref2)
 				c2.check(node.vweb_tmpl)
 				c.warnings << c2.warnings
@@ -2124,7 +2148,8 @@ pub fn (mut c Checker) ident(mut ident ast.Ident) table.Type {
 					// incase var was not marked as used yet (vweb tmpl)
 					obj.is_used = true
 					if ident.pos.pos < obj.pos.pos {
-						c.error('undefined variable `$ident.name` (used before declaration)', ident.pos)
+						c.error('undefined variable `$ident.name` (used before declaration)',
+							ident.pos)
 					}
 					mut typ := obj.typ
 					if typ == 0 {
@@ -2185,8 +2210,8 @@ pub fn (mut c Checker) ident(mut ident ast.Ident) table.Type {
 		}
 		// Non-anon-function object (not a call), e.g. `onclick(my_click)`
 		if func := c.table.find_fn(name) {
-			fn_type := table.new_type(c.table.find_or_register_fn_type(ident.mod, func, false,
-				true))
+			fn_type := table.new_type(c.table.find_or_register_fn_type(ident.mod, func,
+				false, true))
 			ident.name = name
 			ident.kind = .function
 			ident.info = ast.IdentFn{
@@ -2247,7 +2272,7 @@ pub fn (mut c Checker) match_expr(mut node ast.MatchExpr) table.Type {
 			if node.is_sum_type || node.is_interface {
 				ok := if cond_type_sym.kind == .sum_type {
 					// TODO verify sum type
-					//true // c.check_types(typ, cond_type)
+					// true // c.check_types(typ, cond_type)
 					info := cond_type_sym.info as table.SumType
 					typ in info.variants
 				} else {
@@ -2319,13 +2344,13 @@ fn (mut c Checker) match_exprs(mut node ast.MatchExpr, type_sym table.TypeSymbol
 				v_str := c.table.type_to_str(v)
 				if v_str !in branch_exprs {
 					is_exhaustive = false
-					unhandled << '`$v_str`'
+unhandled << '					`$v_str`'
 				}
 			} }
 		table.Enum { for v in it.vals {
 				if v !in branch_exprs {
 					is_exhaustive = false
-					unhandled << '`.$v`'
+unhandled << '					`.$v`'
 				}
 			} }
 		else { is_exhaustive = false }
@@ -2449,7 +2474,8 @@ pub fn (mut c Checker) postfix_expr(node ast.PostfixExpr) table.Type {
 	// if !typ.is_number() {
 	if !typ_sym.is_number() {
 		println(typ_sym.kind.str())
-		c.error('invalid operation: $node.op.str() (non-numeric type `$typ_sym.name`)', node.pos)
+		c.error('invalid operation: $node.op.str() (non-numeric type `$typ_sym.name`)',
+			node.pos)
 	} else {
 		c.fail_if_immutable(node.expr)
 	}
@@ -2654,7 +2680,7 @@ fn (mut c Checker) sql_expr(node ast.SqlExpr) table.Type {
 	return node.typ
 }
 
-fn (mut c Checker) sql_insert_expr(node ast.SqlStmt ) table.Type {
+fn (mut c Checker) sql_insert_expr(node ast.SqlStmt) table.Type {
 	c.expr(node.db_expr)
 	return table.void_type
 }
@@ -2695,8 +2721,8 @@ fn (mut c Checker) fn_decl(it ast.FnDecl) {
 			}
 			sym.methods.delete(idx)
 			//
-			c.error('cannot define new methods on non-local `$sym.name` (' + 'current module is `$c.mod`, `$sym.name` is from `$sym.mod`)',
-				it.pos)
+			c.error('cannot define new methods on non-local `$sym.name` (' +
+				'current module is `$c.mod`, `$sym.name` is from `$sym.mod`)', it.pos)
 		}
 	}
 	if it.language == .v {
@@ -2711,7 +2737,8 @@ fn (mut c Checker) fn_decl(it ast.FnDecl) {
 	c.expected_type = table.void_type
 	c.cur_fn = &it
 	c.stmts(it.stmts)
-	if it.language == .v && !it.no_body && it.return_type != table.void_type && !c.returns &&
+	if it.language == .v && !it.no_body &&
+		it.return_type != table.void_type && !c.returns &&
 		it.name !in ['panic', 'exit'] {
 		c.error('missing return at end of function `$it.name`', it.pos)
 	}
diff --git a/vlib/v/gen/cgen.v b/vlib/v/gen/cgen.v
index 772114f868..333b03b5d2 100644
--- a/vlib/v/gen/cgen.v
+++ b/vlib/v/gen/cgen.v
@@ -14,33 +14,9 @@ import v.depgraph
 // NB: keywords after 'new' are reserved in C++
 const (
 	c_reserved = ['delete', 'exit', 'unix', 'error', 'calloc', 'malloc', 'free', 'panic', 'auto',
-		'char',
-		'default',
-		'do',
-		'double',
-		'extern',
-		'float',
-		'inline',
-		'int',
-		'long',
-		'register',
-		'restrict',
-		'short',
-		'signed',
-		'sizeof',
-		'static',
-		'switch',
-		'typedef',
-		'union',
-		'unsigned',
-		'void',
-		'volatile',
-		'while',
-		'new',
-		'namespace',
-		'class',
-		'typename'
-	]
+		'char', 'default', 'do', 'double', 'extern', 'float', 'inline', 'int', 'long', 'register',
+		'restrict', 'short', 'signed', 'sizeof', 'static', 'switch', 'typedef', 'union', 'unsigned',
+		'void', 'volatile', 'while', 'new', 'namespace', 'class', 'typename']
 	// same order as in token.Kind
 	cmp_str    = ['eq', 'ne', 'gt', 'lt', 'ge', 'le']
 	// when operands are switched
@@ -436,8 +412,7 @@ typedef struct {
 			.alias {
 				parent := &g.table.types[typ.parent_idx]
 				styp := typ.name.replace('.', '__')
-				is_c_parent := parent.name.len > 2 && parent.name[0] == `C` && parent.name[1] ==
-					`.`
+				is_c_parent := parent.name.len > 2 && parent.name[0] == `C` && parent.name[1] == `.`
 				parent_styp := if is_c_parent { 'struct ' + parent.name[2..].replace('.', '__') } else { parent.name.replace('.',
 						'__') }
 				g.type_definitions.writeln('typedef $parent_styp $styp;')
@@ -662,7 +637,7 @@ fn (mut g Gen) stmt(node ast.Stmt) {
 			}
 		}
 		ast.FnDecl {
-			//g.tmp_count = 0 TODO
+			// g.tmp_count = 0 TODO
 			mut skip := false
 			pos := g.out.buf.len
 			if g.pref.build_mode == .build_module {
@@ -684,13 +659,15 @@ fn (mut g Gen) stmt(node ast.Stmt) {
 				// just remember `it`; main code will be generated in finish()
 				g.fn_main = node
 			} else {
-				if node.name == 'backtrace' || node.name == 'backtrace_symbols' || node.name ==
-					'backtrace_symbols_fd' {
+				if node.name == 'backtrace' ||
+					node.name == 'backtrace_symbols' ||
+					node.name == 'backtrace_symbols_fd' {
 					g.write('\n#ifndef __cplusplus\n')
 				}
 				g.gen_fn_decl(node)
-				if node.name == 'backtrace' || node.name == 'backtrace_symbols' || node.name ==
-					'backtrace_symbols_fd' {
+				if node.name == 'backtrace' ||
+					node.name == 'backtrace_symbols' ||
+					node.name == 'backtrace_symbols_fd' {
 					g.write('\n#endif\n')
 				}
 			}
@@ -770,9 +747,9 @@ fn (mut g Gen) stmt(node ast.Stmt) {
 			g.write_autofree_stmts_when_needed(node)
 			g.return_statement(node)
 		}
-		ast.SqlStmt{
+		ast.SqlStmt {
 			g.sql_insert_expr(node)
-			}
+		}
 		ast.StructDecl {
 			name := if node.language == .c { node.name.replace('.', '__') } else { c_name(node.name) }
 			// g.writeln('typedef struct {')
@@ -915,9 +892,8 @@ fn (mut g Gen) expr_with_cast(expr ast.Expr, got_type, expected_type table.Type)
 	got_is_ptr := got_type.is_ptr()
 	expected_is_ptr := expected_type.is_ptr()
 	neither_void := table.voidptr_type !in [got_type, expected_type]
-	if got_is_ptr && !expected_is_ptr && neither_void && expected_sym.kind !in [.interface_,
-		.placeholder
-	] {
+	if got_is_ptr && !expected_is_ptr && neither_void &&
+		expected_sym.kind !in [.interface_, .placeholder] {
 		got_deref_type := got_type.deref()
 		deref_sym := g.table.get_type_symbol(got_deref_type)
 		deref_will_match := expected_type in [got_type, got_deref_type, deref_sym.parent_idx]
@@ -1594,9 +1570,6 @@ fn (mut g Gen) expr(node ast.Expr) {
 		ast.SqlExpr {
 			g.sql_select_expr(node)
 		}
-		//ast.SqlInsertExpr {
-			//g.sql_insert_expr(node)
-		//}
 		ast.StringLiteral {
 			if node.is_raw {
 				escaped_val := node.val.replace_each(['"', '\\"', '\\', '\\\\'])
@@ -1865,8 +1838,8 @@ fn (mut g Gen) infix_expr(node ast.InfixExpr) {
 		}
 	} else if unaliased_left.idx() in [table.u32_type_idx, table.u64_type_idx] && unaliased_right.is_signed() &&
 		node.op in [.eq, .ne, .gt, .lt, .ge, .le] {
-		bitsize := if unaliased_left.idx() == table.u32_type_idx && unaliased_right.idx() !=
-			table.i64_type_idx { 32 } else { 64 }
+		bitsize := if unaliased_left.idx() == table.u32_type_idx &&
+			unaliased_right.idx() != table.i64_type_idx { 32 } else { 64 }
 		g.write('_us${bitsize}_${cmp_str[int(node.op)-int(token.Kind.eq)]}(')
 		g.expr(node.left)
 		g.write(',')
@@ -1874,8 +1847,8 @@ fn (mut g Gen) infix_expr(node ast.InfixExpr) {
 		g.write(')')
 	} else if unaliased_right.idx() in [table.u32_type_idx, table.u64_type_idx] && unaliased_left.is_signed() &&
 		node.op in [.eq, .ne, .gt, .lt, .ge, .le] {
-		bitsize := if unaliased_right.idx() == table.u32_type_idx && unaliased_left.idx() !=
-			table.i64_type_idx { 32 } else { 64 }
+		bitsize := if unaliased_right.idx() == table.u32_type_idx &&
+			unaliased_left.idx() != table.i64_type_idx { 32 } else { 64 }
 		g.write('_us${bitsize}_${cmp_rev[int(node.op)-int(token.Kind.eq)]}(')
 		g.expr(node.right)
 		g.write(',')
@@ -1917,8 +1890,7 @@ fn (mut g Gen) match_expr(node ast.MatchExpr) {
 		g.writeln('// match 0')
 		return
 	}
-	is_expr := (node.is_expr && node.return_type != table.void_type) || g.inside_ternary >
-		0
+	is_expr := (node.is_expr && node.return_type != table.void_type) || g.inside_ternary > 0
 	if is_expr {
 		g.inside_ternary++
 		// g.write('/* EM ret type=${g.typ(node.return_type)}		expected_type=${g.typ(node.expected_type)}  */')
@@ -2315,7 +2287,6 @@ fn (mut g Gen) return_statement(node ast.Return) {
 	sym := g.table.get_type_symbol(g.fn_decl.return_type)
 	fn_return_is_multi := sym.kind == .multi_return
 	fn_return_is_optional := g.fn_decl.return_type.has_flag(.optional)
-
 	if node.exprs.len == 0 {
 		if fn_return_is_optional {
 			tmp := g.new_tmp_var()
@@ -2414,8 +2385,8 @@ fn (mut g Gen) return_statement(node ast.Return) {
 		// normal return
 		return_sym := g.table.get_type_symbol(node.types[0])
 		// `return opt_ok(expr)` for functions that expect an optional
-		if fn_return_is_optional && !node.types[0].has_flag(.optional) && return_sym.name !=
-			'Option' {
+		if fn_return_is_optional && !node.types[0].has_flag(.optional) &&
+			return_sym.name != 'Option' {
 			styp := g.base_type(g.fn_decl.return_type)
 			opt_type := g.typ(g.fn_decl.return_type)
 			// Create a tmp for this option
@@ -2597,14 +2568,14 @@ fn (mut g Gen) struct_init(struct_init ast.StructInit) {
 	}
 	// The rest of the fields are zeroed.
 	// `inited_fields` is a list of fields that have been init'ed, they are skipped
-	//mut nr_fields := 0
+	// mut nr_fields := 0
 	if sym.kind == .struct_ {
 		info := sym.info as table.Struct
 		if info.is_union && struct_init.fields.len > 1 {
 			verror('union must not have more than 1 initializer')
 		}
-		//g.zero_struct_fields(info, inited_fields)
-		//nr_fields = info.fields.len
+		// g.zero_struct_fields(info, inited_fields)
+		// nr_fields = info.fields.len
 		for field in info.fields {
 			if field.name in inited_fields {
 				sfield := struct_init.fields[inited_fields[field.name]]
@@ -2639,7 +2610,6 @@ fn (mut g Gen) struct_init(struct_init ast.StructInit) {
 			g.zero_struct_field(field)
 			initialized = true
 		}
-
 	}
 	// if struct_init.fields.len == 0 && info.fields.len == 0 {
 	if !initialized {
@@ -2662,9 +2632,8 @@ fn (mut g Gen) zero_struct_field(field table.Field) {
 	g.writeln(',')
 }
 
-//fn (mut g Gen) zero_struct_fields(info table.Struct, inited_fields map[string]int) {
-//}
-
+// fn (mut g Gen) zero_struct_fields(info table.Struct, inited_fields map[string]int) {
+// }
 // { user | name: 'new name' }
 fn (mut g Gen) assoc(node ast.Assoc) {
 	g.writeln('// assoc')
@@ -3026,8 +2995,8 @@ fn (mut g Gen) string_inter_literal(node ast.StringInterLiteral) {
 		} else if node.expr_types[i] == table.bool_type {
 			g.expr(expr)
 			g.write(' ? _SLIT("true") : _SLIT("false")')
-		} else if node.expr_types[i].is_number() || node.expr_types[i].is_pointer() || node.fmts[i] ==
-			`d` {
+		} else if node.expr_types[i].is_number() || node.expr_types[i].is_pointer() ||
+			node.fmts[i] == `d` {
 			if node.expr_types[i].is_signed() && node.fmts[i] in [`x`, `X`, `o`] {
 				// convert to unsigned first befors C's integer propagation strikes
 				if node.expr_types[i] == table.i8_type {
@@ -3338,8 +3307,8 @@ fn (mut g Gen) or_block(var_name string, or_block ast.OrExpr, return_type table.
 		g.writeln('\tstring err = ${cvar_name}.v_error;')
 		g.writeln('\tint errcode = ${cvar_name}.ecode;')
 		stmts := or_block.stmts
-		if stmts.len > 0 && stmts[or_block.stmts.len - 1] is ast.ExprStmt && (stmts[stmts.len -
-			1] as ast.ExprStmt).typ != table.void_type {
+		if stmts.len > 0 && stmts[or_block.stmts.len - 1] is ast.ExprStmt &&
+			(stmts[stmts.len - 1] as ast.ExprStmt).typ != table.void_type {
 			g.indent++
 			for i, stmt in stmts {
 				if i == stmts.len - 1 {
@@ -3542,7 +3511,8 @@ fn (mut g Gen) comp_if_to_ifdef(name string, is_comptime_optional bool) string {
 			return 'TARGET_ORDER_IS_BIG'
 		}
 		else {
-			if is_comptime_optional || (g.pref.compile_defines_all.len > 0 && name in g.pref.compile_defines_all) {
+			if is_comptime_optional || (g.pref.compile_defines_all.len > 0 &&
+				name in g.pref.compile_defines_all) {
 				return 'CUSTOM_DEFINE_$name'
 			}
 			verror('bad os ifdef name "$name"')
@@ -4206,7 +4176,8 @@ fn (mut g Gen) gen_str_for_multi_return(info table.MultiReturn, styp, str_fn_nam
 		sym_has_str_method, str_method_expects_ptr, _ := sym.str_method_info()
 		mut arg_str_fn_name := ''
 		if sym_has_str_method {
-			arg_str_fn_name = if is_arg_ptr { field_styp.replace('*', '') + '_str' } else { field_styp + '_str' }
+			arg_str_fn_name = if is_arg_ptr { field_styp.replace('*', '') + '_str' } else { field_styp +
+					'_str' }
 		} else {
 			arg_str_fn_name = styp_to_str_fn_name(field_styp)
 		}