From f34352faf921e884d09aef616383d2cb124bf823 Mon Sep 17 00:00:00 2001
From: Alexander Medvednikov <alexander@medvednikov.com>
Date: Wed, 15 Apr 2020 01:55:51 +0200
Subject: [PATCH] fmt: use var instead of mut

---
 vlib/v/fmt/fmt.v       |   4 +-
 vlib/v/gen/cgen.v      | 100 ++++++++++-----------
 vlib/v/parser/fn.v     |  38 ++++----
 vlib/v/parser/parser.v | 198 ++++++++++++++++++++---------------------
 4 files changed, 170 insertions(+), 170 deletions(-)

diff --git a/vlib/v/fmt/fmt.v b/vlib/v/fmt/fmt.v
index 8e2b79dd0c..b40389b787 100644
--- a/vlib/v/fmt/fmt.v
+++ b/vlib/v/fmt/fmt.v
@@ -143,7 +143,7 @@ fn (f mut Fmt) stmt(node ast.Stmt) {
 			for i, ident in it.left {
 				var_info := ident.var_info()
 				if var_info.is_mut {
-					f.write('mut ')
+					f.write('var ')
 				}
 				f.expr(ident)
 				if i < it.left.len - 1 {
@@ -578,7 +578,7 @@ fn (f mut Fmt) expr(node ast.Expr) {
 		ast.MatchExpr {
 			f.write('match ')
 			if it.is_mut {
-				f.write('mut ')
+				f.write('var ')
 			}
 			f.expr(it.cond)
 			f.writeln(' {')
diff --git a/vlib/v/gen/cgen.v b/vlib/v/gen/cgen.v
index 94e00d6c7e..de1810bd8c 100644
--- a/vlib/v/gen/cgen.v
+++ b/vlib/v/gen/cgen.v
@@ -74,7 +74,7 @@ pub fn cgen(files []ast.File, table &table.Table, pref &pref.Preferences) string
 	} else {
 	}
 	// println('start cgen2')
-	mut g := Gen{
+	var g := Gen{
 		out: strings.new_builder(1000)
 		typedefs: strings.new_builder(100)
 		typedefs2: strings.new_builder(100)
@@ -91,7 +91,7 @@ pub fn cgen(files []ast.File, table &table.Table, pref &pref.Preferences) string
 	}
 	g.init()
 	//
-	mut autofree_used := false
+	var autofree_used := false
 	for file in files {
 		g.file = file
 		// println('\ncgen "$g.file.path" nr_stmts=$file.stmts.len')
@@ -129,7 +129,7 @@ pub fn cgen(files []ast.File, table &table.Table, pref &pref.Preferences) string
 }
 
 pub fn (g Gen) hashes() string {
-	mut res := c_commit_hash_default.replace('@@@', util.vhash())
+	var res := c_commit_hash_default.replace('@@@', util.vhash())
 	res += c_current_commit_hash_default.replace('@@@', util.githash(g.pref.building_v))
 	return res
 }
@@ -194,7 +194,7 @@ pub fn (g mut Gen) write_typeof_functions() {
 pub fn (g mut Gen) typ(t table.Type) string {
 	nr_muls := table.type_nr_muls(t)
 	sym := g.table.get_type_symbol(t)
-	mut styp := sym.name.replace('.', '__')
+	var styp := sym.name.replace('.', '__')
 	if nr_muls > 0 {
 		styp += strings.repeat(`*`, nr_muls)
 	}
@@ -390,7 +390,7 @@ fn (g mut Gen) stmt(node ast.Stmt) {
 			g.comp_if(it)
 		}
 		ast.DeferStmt {
-			mut defer_stmt := *it
+			var defer_stmt := *it
 			defer_stmt.ifdef = g.defer_ifdef
 			g.defer_stmts << defer_stmt
 		}
@@ -646,7 +646,7 @@ fn (g mut Gen) gen_assert_stmt(a ast.AssertStmt) {
 	g.write(')')
 	g.inside_ternary = false
 	s_assertion := a.expr.str().replace('"', "\'")
-	mut mod_path := g.file.path
+	var mod_path := g.file.path
 	$if windows {
 		mod_path = g.file.path.replace('\\', '\\\\')
 	}
@@ -676,8 +676,8 @@ fn (g mut Gen) gen_assign_stmt(assign_stmt ast.AssignStmt) {
 	}
 	if assign_stmt.left.len > assign_stmt.right.len {
 		// multi return
-		mut or_stmts := []ast.Stmt
-		mut return_type := table.void_type
+		var or_stmts := []ast.Stmt
+		var return_type := table.void_type
 		match assign_stmt.right[0] {
 			ast.CallExpr {
 				or_stmts = it.or_block.stmts
@@ -719,9 +719,9 @@ fn (g mut Gen) gen_assign_stmt(assign_stmt ast.AssignStmt) {
 			val := assign_stmt.right[i]
 			ident_var_info := ident.var_info()
 			styp := g.typ(ident_var_info.typ)
-			mut is_call := false
-			mut or_stmts := []ast.Stmt
-			mut return_type := table.void_type
+			var is_call := false
+			var or_stmts := []ast.Stmt
+			var return_type := table.void_type
 			match val {
 				ast.CallExpr {
 					is_call = true
@@ -742,7 +742,7 @@ fn (g mut Gen) gen_assign_stmt(assign_stmt ast.AssignStmt) {
 				}
 			} else {
 				right_sym := g.table.get_type_symbol(assign_stmt.right_types[i])
-				mut is_fixed_array_init := false
+				var is_fixed_array_init := false
 				match val {
 					ast.ArrayInit {
 						is_fixed_array_init = it.is_fixed
@@ -783,7 +783,7 @@ fn (g mut Gen) gen_assign_stmt(assign_stmt ast.AssignStmt) {
 }
 
 fn (g mut Gen) gen_clone_assignment(val ast.Expr, right_sym table.TypeSymbol, add_eq bool) bool {
-	mut is_ident := false
+	var is_ident := false
 	match val {
 		ast.Ident {
 			is_ident = true
@@ -1114,9 +1114,9 @@ fn (g mut Gen) enum_expr(node ast.Expr) {
 
 fn (g mut Gen) assign_expr(node ast.AssignExpr) {
 	// g.write('/*assign_expr*/')
-	mut is_call := false
-	mut or_stmts := []ast.Stmt
-	mut return_type := table.void_type
+	var is_call := false
+	var or_stmts := []ast.Stmt
+	var return_type := table.void_type
 	match node.val {
 		ast.CallExpr {
 			is_call = true
@@ -1146,7 +1146,7 @@ fn (g mut Gen) assign_expr(node ast.AssignExpr) {
 		if table.type_is(node.right_type, .optional) {
 			g.right_is_opt = true
 		}
-		mut str_add := false
+		var str_add := false
 		if node.left_type == table.string_type_idx && node.op == .plus_assign {
 			// str += str2 => `str = string_add(str, str2)`
 			g.expr(node.left)
@@ -1164,7 +1164,7 @@ fn (g mut Gen) assign_expr(node ast.AssignExpr) {
 		g.is_assign_lhs = false
 		right_sym := g.table.get_type_symbol(node.right_type)
 		// left_sym := g.table.get_type_symbol(node.left_type)
-		mut cloned := false
+		var cloned := false
 		// !g.is_array_set
 		if g.autofree && right_sym.kind in [.array, .string] {
 			if g.gen_clone_assignment(node.val, right_sym, false) {
@@ -1364,7 +1364,7 @@ fn (g mut Gen) match_expr(node ast.MatchExpr) {
 		// g.write('/* EM ret type=${g.typ(node.return_type)}		expected_type=${g.typ(node.expected_type)}  */')
 	}
 	type_sym := g.table.get_type_symbol(node.cond_type)
-	mut tmp := ''
+	var tmp := ''
 	if type_sym.kind != .void {
 		tmp = g.new_tmp_var()
 	}
@@ -1492,7 +1492,7 @@ fn (g mut Gen) if_expr(node ast.IfExpr) {
 	// If expression? Assign the value to a temp var.
 	// Previously ?: was used, but it's too unreliable.
 	type_sym := g.table.get_type_symbol(node.typ)
-	mut tmp := ''
+	var tmp := ''
 	if type_sym.kind != .void {
 		tmp = g.new_tmp_var()
 		// g.writeln('$ti.name $tmp;')
@@ -1517,7 +1517,7 @@ fn (g mut Gen) if_expr(node ast.IfExpr) {
 		g.inside_ternary = false
 	} else {
 		guard_ok := g.new_tmp_var()
-		mut is_guard := false
+		var is_guard := false
 		for i, branch in node.branches {
 			if i == 0 {
 				match branch.cond {
@@ -1560,7 +1560,7 @@ fn (g mut Gen) if_expr(node ast.IfExpr) {
 
 fn (g mut Gen) index_expr(node ast.IndexExpr) {
 	// TODO else doesn't work with sum types
-	mut is_range := false
+	var is_range := false
 	match node.index {
 		ast.RangeExpr {
 			sym := g.table.get_type_symbol(node.left_type)
@@ -1615,7 +1615,7 @@ fn (g mut Gen) index_expr(node ast.IndexExpr) {
 		} else if sym.kind == .array {
 			info := sym.info as table.Array
 			elem_type_str := g.typ(info.elem_type)
-			mut is_selector := false
+			var is_selector := false
 			match node.left {
 				ast.SelectorExpr {
 					// `vals[i].field = x` is an exception and requires `array_get`:
@@ -1633,7 +1633,7 @@ fn (g mut Gen) index_expr(node ast.IndexExpr) {
 				g.expr(node.left)
 				g.write(', ')
 				g.expr(node.index)
-				mut need_wrapper := true
+				var need_wrapper := true
 				/*
 				match node.right {
 					ast.EnumVal, ast.Ident {
@@ -1762,10 +1762,10 @@ fn (g mut Gen) return_statement(node ast.Return) {
 		g.write(' ')
 		typ_sym := g.table.get_type_symbol(g.fn_decl.return_type)
 		mr_info := typ_sym.info as table.MultiReturn
-		mut styp := g.typ(g.fn_decl.return_type)
+		var styp := g.typ(g.fn_decl.return_type)
 		if fn_return_is_optional {			// && !table.type_is(node.types[0], .optional) && node.types[0] !=
 			styp = styp[7..]			// remove 'Option_'
-			mut x := styp
+			var x := styp
 			if x.ends_with('_ptr') {
 				x = x.replace('_ptr', '*')
 			}
@@ -1790,8 +1790,8 @@ fn (g mut Gen) return_statement(node ast.Return) {
 		// `return opt_ok(expr)` for functions that expect an optional
 		if fn_return_is_optional && !table.type_is(node.types[0], .optional) && return_sym.name !=
 			'Option' {
-			mut is_none := false
-			mut is_error := false
+			var is_none := false
+			var is_error := false
 			expr0 := node.exprs[0]
 			match expr0 {
 				ast.None {
@@ -1808,7 +1808,7 @@ fn (g mut Gen) return_statement(node ast.Return) {
 			}
 			if !is_none && !is_error {
 				styp := g.typ(g.fn_decl.return_type)[7..]				// remove 'Option_'
-				mut x := styp
+				var x := styp
 				if x.ends_with('_ptr') {
 					x = x.replace('_ptr', '*')
 				}
@@ -1870,8 +1870,8 @@ fn (g mut Gen) const_decl_simple_define(name, val string) {
 }
 
 fn (g mut Gen) struct_init(struct_init ast.StructInit) {
-	mut info := table.Struct{}
-	mut is_struct := false
+	var info := table.Struct{}
+	var is_struct := false
 	sym := g.table.get_type_symbol(struct_init.typ)
 	if sym.kind == .struct_ {
 		is_struct = true
@@ -1887,8 +1887,8 @@ fn (g mut Gen) struct_init(struct_init ast.StructInit) {
 	} else {
 		g.writeln('($styp){')
 	}
-	mut fields := []string
-	mut inited_fields := []string	// TODO this is done in checker, move to ast node
+	var fields := []string
+	var inited_fields := []string	// TODO this is done in checker, move to ast node
 	if struct_init.fields.len == 0 && struct_init.exprs.len > 0 {
 		// Get fields for {a,b} short syntax. Fields array wasn't set in the parser.
 		for f in info.fields {
@@ -2057,7 +2057,7 @@ const (
 )
 
 fn (g mut Gen) write_builtin_types() {
-	mut builtin_types := []table.TypeSymbol	// builtin types
+	var builtin_types := []table.TypeSymbol	// builtin types
 	// builtin types need to be on top
 	// everything except builtin will get sorted
 	for builtin_name in builtins {
@@ -2070,7 +2070,7 @@ fn (g mut Gen) write_builtin_types() {
 // Sort the types, make sure types that are referenced by other types
 // are added before them.
 fn (g mut Gen) write_sorted_types() {
-	mut types := []table.TypeSymbol	// structs that need to be sorted
+	var types := []table.TypeSymbol	// structs that need to be sorted
 	for typ in g.table.types {
 		if !(typ.name in builtins) {
 			types << typ
@@ -2128,7 +2128,7 @@ int typ;
 				// .array_fixed {
 				styp := typ.name.replace('.', '__')
 				// array_fixed_char_300 => char x[300]
-				mut fixed := styp[12..]
+				var fixed := styp[12..]
 				len := styp.after('_')
 				fixed = fixed[..fixed.len - len.len - 1]
 				g.definitions.writeln('typedef $fixed $styp [$len];')
@@ -2141,16 +2141,16 @@ int typ;
 
 // sort structs by dependant fields
 fn (g Gen) sort_structs(typesa []table.TypeSymbol) []table.TypeSymbol {
-	mut dep_graph := depgraph.new_dep_graph()
+	var dep_graph := depgraph.new_dep_graph()
 	// types name list
-	mut type_names := []string
+	var type_names := []string
 	for typ in typesa {
 		type_names << typ.name
 	}
 	// loop over types
 	for t in typesa {
 		// create list of deps
-		mut field_deps := []string
+		var field_deps := []string
 		match t.info {
 			table.ArrayFixed {
 				dep := g.table.get_type_symbol(it.elem_type).name
@@ -2183,7 +2183,7 @@ fn (g Gen) sort_structs(typesa []table.TypeSymbol) []table.TypeSymbol {
 			'\nif you feel this is an error, please create a new issue here: https://github.com/vlang/v/issues and tag @joe-conigliaro')
 	}
 	// sort types
-	mut types_sorted := []table.TypeSymbol
+	var types_sorted := []table.TypeSymbol
 	for node in dep_graph_sorted.nodes {
 		types_sorted << g.table.types[g.table.type_idxs[node.name]]
 	}
@@ -2368,8 +2368,8 @@ fn (g mut Gen) or_block(var_name string, stmts []ast.Stmt, return_type table.Typ
 }
 
 fn (g mut Gen) type_of_last_statement(stmts []ast.Stmt) (string, string) {
-	mut last_type := ''
-	mut last_expr_result_type := ''
+	var last_type := ''
+	var last_expr_result_type := ''
 	if stmts.len > 0 {
 		last_stmt := stmts[stmts.len - 1]
 		last_type = typeof(last_stmt)
@@ -2662,9 +2662,9 @@ pub fn (g mut Gen) write_tests_main() {
 }
 
 fn (g Gen) get_all_test_function_names() []string {
-	mut tfuncs := []string
-	mut tsuite_begin := ''
-	mut tsuite_end := ''
+	var tfuncs := []string
+	var tsuite_begin := ''
+	var tsuite_end := ''
 	for _, f in g.table.fns {
 		if f.name == 'testsuite_begin' {
 			tsuite_begin = f.name
@@ -2693,7 +2693,7 @@ fn (g Gen) get_all_test_function_names() []string {
 			continue
 		}
 	}
-	mut all_tfuncs := []string
+	var all_tfuncs := []string
 	if tsuite_begin.len > 0 {
 		all_tfuncs << tsuite_begin
 	}
@@ -2701,7 +2701,7 @@ fn (g Gen) get_all_test_function_names() []string {
 	if tsuite_end.len > 0 {
 		all_tfuncs << tsuite_end
 	}
-	mut all_tfuncs_c := []string
+	var all_tfuncs_c := []string
 	for f in all_tfuncs {
 		all_tfuncs_c << f.replace('.', '__')
 	}
@@ -2749,7 +2749,7 @@ fn (g mut Gen) go_stmt(node ast.GoStmt) {
 	// x := node.call_expr as ast.CallEpxr // TODO
 	match node.call_expr {
 		ast.CallExpr {
-			mut name := it.name.replace('.', '__')
+			var name := it.name.replace('.', '__')
 			if it.is_method {
 				receiver_sym := g.table.get_type_symbol(it.receiver_type)
 				name = receiver_sym.name + '_' + name
@@ -2837,8 +2837,8 @@ fn (g mut Gen) gen_str_for_type(sym table.TypeSymbol, styp string) {
 }
 
 fn (g mut Gen) gen_str_default(sym table.TypeSymbol, styp string) {
-	mut convertor := ''
-	mut typename := ''
+	var convertor := ''
+	var typename := ''
 	if sym.parent_idx in table.integer_type_idxs {
 		convertor = 'int'
 		typename = 'int'
diff --git a/vlib/v/parser/fn.v b/vlib/v/parser/fn.v
index bec1abf460..a59627072e 100644
--- a/vlib/v/parser/fn.v
+++ b/vlib/v/parser/fn.v
@@ -28,8 +28,8 @@ pub fn (p mut Parser) call_expr(is_c bool, mod string) ast.CallExpr {
 		pos: first_pos.pos
 		len: last_pos.pos - first_pos.pos + last_pos.len
 	}
-	mut or_stmts := []ast.Stmt
-	mut is_or_block_used := false
+	var or_stmts := []ast.Stmt
+	var is_or_block_used := false
 	if p.tok.kind == .key_orelse {
 		p.next()
 		p.open_scope()
@@ -60,9 +60,9 @@ pub fn (p mut Parser) call_expr(is_c bool, mod string) ast.CallExpr {
 }
 
 pub fn (p mut Parser) call_args() []ast.CallArg {
-	mut args := []ast.CallArg
+	var args := []ast.CallArg
 	for p.tok.kind != .rpar {
-		mut is_mut := false
+		var is_mut := false
 		if p.tok.kind == .key_mut {
 			p.check(.key_mut)
 			is_mut = true
@@ -96,11 +96,11 @@ fn (p mut Parser) fn_decl() ast.FnDecl {
 		p.check(.dot)
 	}
 	// Receiver?
-	mut rec_name := ''
-	mut is_method := false
-	mut rec_type := table.void_type
-	mut rec_mut := false
-	mut args := []table.Arg
+	var rec_name := ''
+	var is_method := false
+	var rec_type := table.void_type
+	var rec_mut := false
+	var args := []table.Arg
 	if p.tok.kind == .lpar {
 		p.next()		// (
 		is_method = true
@@ -129,7 +129,7 @@ fn (p mut Parser) fn_decl() ast.FnDecl {
 		}
 		p.check(.rpar)
 	}
-	mut name := ''
+	var name := ''
 	if p.tok.kind == .name {
 		// TODO high order fn
 		name = p.check_name()
@@ -161,13 +161,13 @@ fn (p mut Parser) fn_decl() ast.FnDecl {
 		})
 	}
 	// Return type
-	mut return_type := table.void_type
+	var return_type := table.void_type
 	if p.tok.kind.is_start_of_type() {
 		return_type = p.parse_type()
 	}
 	// Register
 	if is_method {
-		mut type_sym := p.table.get_type_symbol(rec_type)
+		var type_sym := p.table.get_type_symbol(rec_type)
 		// p.warn('reg method $type_sym.name . $name ()')
 		type_sym.register_method(table.Fn{
 			name: name
@@ -195,7 +195,7 @@ fn (p mut Parser) fn_decl() ast.FnDecl {
 		})
 	}
 	// Body
-	mut stmts := []ast.Stmt
+	var stmts := []ast.Stmt
 	no_body := p.tok.kind != .lcbr
 	if p.tok.kind == .lcbr {
 		stmts = p.parse_block()
@@ -226,14 +226,14 @@ fn (p mut Parser) fn_decl() ast.FnDecl {
 
 fn (p mut Parser) fn_args() ([]table.Arg, bool) {
 	p.check(.lpar)
-	mut args := []table.Arg
-	mut is_variadic := false
+	var args := []table.Arg
+	var is_variadic := false
 	// `int, int, string` (no names, just types)
 	types_only := p.tok.kind in [.amp, .and] || (p.peek_tok.kind == .comma && p.table.known_type(p.tok.lit)) ||
 		p.peek_tok.kind == .rpar
 	if types_only {
 		// p.warn('types only')
-		mut arg_no := 1
+		var arg_no := 1
 		for p.tok.kind != .rpar {
 			arg_name := 'arg_$arg_no'
 			is_mut := p.tok.kind == .key_mut
@@ -244,7 +244,7 @@ fn (p mut Parser) fn_args() ([]table.Arg, bool) {
 				p.check(.ellipsis)
 				is_variadic = true
 			}
-			mut arg_type := p.parse_type()
+			var arg_type := p.parse_type()
 			if is_variadic {
 				arg_type = table.type_set(arg_type, .variadic)
 			}
@@ -263,7 +263,7 @@ fn (p mut Parser) fn_args() ([]table.Arg, bool) {
 		}
 	} else {
 		for p.tok.kind != .rpar {
-			mut arg_names := [p.check_name()]
+			var arg_names := [p.check_name()]
 			// `a, b, c int`
 			for p.tok.kind == .comma {
 				p.check(.comma)
@@ -277,7 +277,7 @@ fn (p mut Parser) fn_args() ([]table.Arg, bool) {
 				p.check(.ellipsis)
 				is_variadic = true
 			}
-			mut typ := p.parse_type()
+			var typ := p.parse_type()
 			if is_variadic {
 				typ = table.type_set(typ, .variadic)
 			}
diff --git a/vlib/v/parser/parser.v b/vlib/v/parser/parser.v
index 3e984f77ea..378dcc8eb1 100644
--- a/vlib/v/parser/parser.v
+++ b/vlib/v/parser/parser.v
@@ -42,7 +42,7 @@ mut:
 // for tests
 pub fn parse_stmt(text string, table &table.Table, scope &ast.Scope) ast.Stmt {
 	s := scanner.new_scanner(text, .skip_comments)
-	mut p := Parser{
+	var p := Parser{
 		scanner: s
 		table: table
 		pref: &pref.Preferences{}
@@ -62,8 +62,8 @@ pub fn parse_file(path string, table &table.Table, comments_mode scanner.Comment
 	// text := os.read_file(path) or {
 	// panic(err)
 	// }
-	mut stmts := []ast.Stmt
-	mut p := Parser{
+	var stmts := []ast.Stmt
+	var p := Parser{
 		scanner: scanner.new_scanner_file(path, comments_mode)
 		table: table
 		file_name: path
@@ -78,12 +78,12 @@ pub fn parse_file(path string, table &table.Table, comments_mode scanner.Comment
 	// comments_mode: comments_mode
 	p.read_first_token()
 	for p.tok.kind == .comment {
-		mut stmt := ast.Stmt{}		// TODO sum type << bug
+		var stmt := ast.Stmt{}		// TODO sum type << bug
 		com := p.comment()
 		stmt = com
 		stmts << stmt
 	}
-	mut mstmt := ast.Stmt{}
+	var mstmt := ast.Stmt{}
 	module_decl := p.module_decl()
 	mstmt = module_decl
 	stmts << mstmt
@@ -160,7 +160,7 @@ pub fn parse_files(paths []string, table &table.Table, pref &pref.Preferences, g
 	return q.parsed_ast_files
 */
 	// ///////////////
-	mut files := []ast.File
+	var files := []ast.File
 	for path in paths {
 		// println('parse_files $path')
 		files << parse_file(path, table, .skip_comments, pref, global_scope)
@@ -204,7 +204,7 @@ pub fn (p mut Parser) parse_block() []ast.Stmt {
 
 pub fn (p mut Parser) parse_block_no_scope() []ast.Stmt {
 	p.check(.lcbr)
-	mut stmts := []ast.Stmt
+	var stmts := []ast.Stmt
 	if p.tok.kind != .rcbr {
 		for {
 			stmts << p.stmt()
@@ -482,7 +482,7 @@ fn (p mut Parser) attribute() ast.Attr {
 	if p.tok.kind == .key_if {
 		p.next()
 	}
-	mut name := p.check_name()
+	var name := p.check_name()
 	if p.tok.kind == .colon {
 		p.next()
 		if p.tok.kind == .name {
@@ -529,7 +529,7 @@ pub fn (p &Parser) warn(s string) {
 }
 
 pub fn (p &Parser) error_with_pos(s string, pos token.Position) {
-	mut kind := 'error:'
+	var kind := 'error:'
 	if p.pref.is_verbose {
 		print_backtrace()
 		kind = 'parser error:'
@@ -547,7 +547,7 @@ pub fn (p &Parser) warn_with_pos(s string, pos token.Position) {
 pub fn (p mut Parser) parse_ident(is_c bool) ast.Ident {
 	// p.warn('name ')
 	pos := p.tok.position()
-	mut name := p.check_name()
+	var name := p.check_name()
 	if name == '_' {
 		return ast.Ident{
 			name: '_'
@@ -558,7 +558,7 @@ pub fn (p mut Parser) parse_ident(is_c bool) ast.Ident {
 	if p.expr_mod.len > 0 {
 		name = '${p.expr_mod}.$name'
 	}
-	mut ident := ast.Ident{
+	var ident := ast.Ident{
 		kind: .unresolved
 		name: name
 		is_c: is_c
@@ -576,14 +576,14 @@ fn (p mut Parser) struct_init(short_syntax bool) ast.StructInit {
 	if !short_syntax {
 		p.check(.lcbr)
 	}
-	mut field_names := []string
-	mut exprs := []ast.Expr
-	mut i := 0
+	var field_names := []string
+	var exprs := []ast.Expr
+	var i := 0
 	is_short_syntax := p.peek_tok.kind != .colon && p.tok.kind != .rcbr	// `Vec{a,b,c}
 	// p.warn(is_short_syntax.str())
 	for p.tok.kind != .rcbr {
 		p.check_comment()
-		mut field_name := ''
+		var field_name := ''
 		if is_short_syntax {
 			expr := p.expr(0)
 			exprs << expr
@@ -615,9 +615,9 @@ fn (p mut Parser) struct_init(short_syntax bool) ast.StructInit {
 }
 
 pub fn (p mut Parser) name_expr() ast.Expr {
-	mut node := ast.Expr{}
+	var node := ast.Expr{}
 	is_c := p.tok.lit == 'C'
-	mut mod := ''
+	var mod := ''
 	// p.warn('resetting')
 	p.expr_mod = ''
 	// `map[string]int` initialization
@@ -649,7 +649,7 @@ pub fn (p mut Parser) name_expr() ast.Expr {
 	// p.warn('name expr  $p.tok.lit $p.peek_tok.str()')
 	// fn call or type cast
 	if p.peek_tok.kind == .lpar {
-		mut name := p.tok.lit
+		var name := p.tok.lit
 		if mod.len > 0 {
 			name = '${mod}.$name'
 		}
@@ -659,15 +659,15 @@ pub fn (p mut Parser) name_expr() ast.Expr {
 		if (name in p.table.type_idxs || name_w_mod in p.table.type_idxs) && !(name in ['C.stat',
 			'C.sigaction']) {
 			// TODO handle C.stat()
-			mut to_typ := p.parse_type()
+			var to_typ := p.parse_type()
 			if p.is_amp {
 				// Handle `&Foo(0)`
 				to_typ = table.type_to_ptr(to_typ)
 			}
 			p.check(.lpar)
-			mut expr := ast.Expr{}
-			mut arg := ast.Expr{}
-			mut has_arg := false
+			var expr := ast.Expr{}
+			var arg := ast.Expr{}
+			var has_arg := false
 			expr = p.expr(0)
 			// TODO, string(b, len)
 			if p.tok.kind == .comma && table.type_idx(to_typ) == table.string_type_idx {
@@ -697,7 +697,7 @@ pub fn (p mut Parser) name_expr() ast.Expr {
 		return p.struct_init(false)		// short_syntax: false
 	} else if p.peek_tok.kind == .dot && (p.tok.lit[0].is_capital() && !known_var) {
 		// `Color.green`
-		mut enum_name := p.check_name()
+		var enum_name := p.check_name()
 		if mod != '' {
 			enum_name = mod + '.' + enum_name
 		} else {
@@ -715,7 +715,7 @@ pub fn (p mut Parser) name_expr() ast.Expr {
 			mod: mod
 		}
 	} else {
-		mut ident := ast.Ident{}
+		var ident := ast.Ident{}
 		ident = p.parse_ident(is_c)
 		node = ident
 	}
@@ -725,8 +725,8 @@ pub fn (p mut Parser) name_expr() ast.Expr {
 
 pub fn (p mut Parser) expr(precedence int) ast.Expr {
 	// println('\n\nparser.expr()')
-	mut typ := table.void_type
-	mut node := ast.Expr{}
+	var typ := table.void_type
+	var node := ast.Expr{}
 	is_stmt_ident := p.is_stmt_ident
 	p.is_stmt_ident = false
 	// defer {
@@ -908,7 +908,7 @@ fn (p mut Parser) prefix_expr() ast.PrefixExpr {
 fn (p mut Parser) index_expr(left ast.Expr) ast.IndexExpr {
 	// left == `a` in `a[0]`
 	p.next()	// [
-	mut has_low := true
+	var has_low := true
 	if p.tok.kind == .dotdot {
 		has_low = false
 		// [..end]
@@ -926,11 +926,11 @@ fn (p mut Parser) index_expr(left ast.Expr) ast.IndexExpr {
 		}
 	}
 	expr := p.expr(0)	// `[expr]` or  `[expr..]`
-	mut has_high := false
+	var has_high := false
 	if p.tok.kind == .dotdot {
 		// [start..end] or [start..]
 		p.check(.dotdot)
-		mut high := ast.Expr{}
+		var high := ast.Expr{}
 		if p.tok.kind != .rsbr {
 			has_high = true
 			high = p.expr(0)
@@ -964,7 +964,7 @@ fn (p mut Parser) filter() {
 
 fn (p mut Parser) dot_expr(left ast.Expr) ast.Expr {
 	p.next()
-	mut name_pos := p.tok.position()
+	var name_pos := p.tok.position()
 	field_name := p.check_name()
 	is_filter := field_name in ['filter', 'map']
 	if is_filter {
@@ -981,8 +981,8 @@ fn (p mut Parser) dot_expr(left ast.Expr) ast.Expr {
 		p.next()
 		args := p.call_args()
 		p.check(.rpar)
-		mut or_stmts := []ast.Stmt
-		mut is_or_block_used := false
+		var or_stmts := []ast.Stmt
+		var is_or_block_used := false
 		if p.tok.kind == .key_orelse {
 			p.next()
 			p.open_scope()
@@ -1015,7 +1015,7 @@ fn (p mut Parser) dot_expr(left ast.Expr) ast.Expr {
 				is_used: is_or_block_used
 			}
 		}
-		mut node := ast.Expr{}
+		var node := ast.Expr{}
 		node = mcall_expr
 		if is_filter {
 			p.close_scope()
@@ -1027,7 +1027,7 @@ fn (p mut Parser) dot_expr(left ast.Expr) ast.Expr {
 		field: field_name
 		pos: name_pos
 	}
-	mut node := ast.Expr{}
+	var node := ast.Expr{}
 	node = sel_expr
 	if is_filter {
 		p.close_scope()
@@ -1042,9 +1042,9 @@ fn (p mut Parser) infix_expr(left ast.Expr) ast.Expr {
 	precedence := p.tok.precedence()
 	pos := p.tok.position()
 	p.next()
-	mut right := ast.Expr{}
+	var right := ast.Expr{}
 	right = p.expr(precedence)
-	mut expr := ast.Expr{}
+	var expr := ast.Expr{}
 	expr = ast.InfixExpr{
 		left: left
 		right: right
@@ -1085,13 +1085,13 @@ fn (p mut Parser) for_stmt() ast.Stmt {
 		p.error('`mut` is not required in for loops')
 	} else if p.peek_tok.kind in [.decl_assign, .assign, .semicolon] || p.tok.kind == .semicolon {
 		// `for i := 0; i < 10; i++ {`
-		mut init := ast.Stmt{}
-		mut cond := p.new_true_expr()
+		var init := ast.Stmt{}
+		var cond := p.new_true_expr()
 		// mut inc := ast.Stmt{}
-		mut inc := ast.Expr{}
-		mut has_init := false
-		mut has_cond := false
-		mut has_inc := false
+		var inc := ast.Expr{}
+		var has_init := false
+		var has_cond := false
+		var has_inc := false
 		if p.peek_tok.kind in [.assign, .decl_assign] {
 			init = p.assign_stmt()
 			has_init = true
@@ -1101,7 +1101,7 @@ fn (p mut Parser) for_stmt() ast.Stmt {
 		// Allow `for i = 0; i < ...`
 		p.check(.semicolon)
 		if p.tok.kind != .semicolon {
-			mut typ := table.void_type
+			var typ := table.void_type
 			cond = p.expr(0)
 			has_cond = true
 		}
@@ -1126,8 +1126,8 @@ fn (p mut Parser) for_stmt() ast.Stmt {
 		}
 	} else if p.peek_tok.kind in [.key_in, .comma] {
 		// `for i in vals`, `for i in start .. end`
-		mut key_var_name := ''
-		mut val_var_name := p.check_name()
+		var key_var_name := ''
+		var val_var_name := p.check_name()
 		if p.tok.kind == .comma {
 			p.check(.comma)
 			key_var_name = val_var_name
@@ -1143,8 +1143,8 @@ fn (p mut Parser) for_stmt() ast.Stmt {
 		// 0 .. 10
 		// start := p.tok.lit.int()
 		// TODO use RangeExpr
-		mut high_expr := ast.Expr{}
-		mut is_range := false
+		var high_expr := ast.Expr{}
+		var is_range := false
 		if p.tok.kind == .dotdot {
 			is_range = true
 			p.check(.dotdot)
@@ -1187,12 +1187,12 @@ fn (p mut Parser) for_stmt() ast.Stmt {
 
 fn (p mut Parser) if_expr() ast.IfExpr {
 	pos := p.tok.position()
-	mut branches := []ast.IfBranch
-	mut has_else := false
+	var branches := []ast.IfBranch
+	var has_else := false
 	for p.tok.kind in [.key_if, .key_else] {
 		p.inside_if = true
 		branch_pos := p.tok.position()
-		mut comment := ast.Comment{}
+		var comment := ast.Comment{}
 		if p.tok.kind == .key_if {
 			p.check(.key_if)
 		} else {
@@ -1214,8 +1214,8 @@ fn (p mut Parser) if_expr() ast.IfExpr {
 				break
 			}
 		}
-		mut cond := ast.Expr{}
-		mut is_or := false
+		var cond := ast.Expr{}
+		var is_or := false
 		// `if x := opt() {`
 		if p.peek_tok.kind == .decl_assign {
 			is_or = true
@@ -1262,7 +1262,7 @@ fn (p mut Parser) string_expr() ast.Expr {
 	if is_raw || is_cstr {
 		p.next()
 	}
-	mut node := ast.Expr{}
+	var node := ast.Expr{}
 	val := p.tok.lit
 	pos := p.tok.position()
 	if p.peek_tok.kind != .str_dollar {
@@ -1275,9 +1275,9 @@ fn (p mut Parser) string_expr() ast.Expr {
 		}
 		return node
 	}
-	mut exprs := []ast.Expr
-	mut vals := []string
-	mut efmts := []string
+	var exprs := []ast.Expr
+	var vals := []string
+	var efmts := []string
 	// Handle $ interpolation
 	for p.tok.kind == .string {
 		vals << p.tok.lit
@@ -1287,7 +1287,7 @@ fn (p mut Parser) string_expr() ast.Expr {
 		}
 		p.check(.str_dollar)
 		exprs << p.expr(0)
-		mut efmt := []string
+		var efmt := []string
 		if p.tok.kind == .colon {
 			efmt << ':'
 			p.next()
@@ -1319,13 +1319,13 @@ fn (p mut Parser) string_expr() ast.Expr {
 
 fn (p mut Parser) array_init() ast.ArrayInit {
 	first_pos := p.tok.position()
-	mut last_pos := token.Position{}
+	var last_pos := token.Position{}
 	p.check(.lsbr)
 	// p.warn('array_init() exp=$p.expected_type')
-	mut array_type := table.void_type
-	mut elem_type := table.void_type
-	mut exprs := []ast.Expr
-	mut is_fixed := false
+	var array_type := table.void_type
+	var elem_type := table.void_type
+	var exprs := []ast.Expr
+	var is_fixed := false
 	if p.tok.kind == .rsbr {
 		// []typ => `[]` and `typ` must be on the same line
 		line_nr := p.tok.line_nr
@@ -1404,8 +1404,8 @@ fn (p mut Parser) array_init() ast.ArrayInit {
 
 fn (p mut Parser) map_init() ast.MapInit {
 	pos := p.tok.position()
-	mut keys := []ast.Expr
-	mut vals := []ast.Expr
+	var keys := []ast.Expr
+	var vals := []ast.Expr
 	for p.tok.kind != .rcbr && p.tok.kind != .eof {
 		// p.check(.str)
 		key := p.expr(0)
@@ -1427,7 +1427,7 @@ fn (p mut Parser) map_init() ast.MapInit {
 fn (p mut Parser) parse_number_literal() ast.Expr {
 	lit := p.tok.lit
 	pos := p.tok.position()
-	mut node := ast.Expr{}
+	var node := ast.Expr{}
 	if lit.index_any('.eE') >= 0 {
 		node = ast.FloatLiteral{
 			val: lit
@@ -1443,7 +1443,7 @@ fn (p mut Parser) parse_number_literal() ast.Expr {
 }
 
 fn (p mut Parser) module_decl() ast.Module {
-	mut name := 'main'
+	var name := 'main'
 	is_skipped := p.tok.kind != .key_module
 	if !is_skipped {
 		p.check(.key_module)
@@ -1460,8 +1460,8 @@ fn (p mut Parser) module_decl() ast.Module {
 
 fn (p mut Parser) parse_import() ast.Import {
 	pos := p.tok.position()
-	mut mod_name := p.check_name()
-	mut mod_alias := mod_name
+	var mod_name := p.check_name()
+	var mod_alias := mod_name
 	for p.tok.kind == .dot {
 		p.check(.dot)
 		submod_name := p.check_name()
@@ -1483,7 +1483,7 @@ fn (p mut Parser) parse_import() ast.Import {
 
 fn (p mut Parser) import_stmt() []ast.Import {
 	p.check(.key_import)
-	mut imports := []ast.Import
+	var imports := []ast.Import
 	if p.tok.kind == .lpar {
 		p.check(.lpar)
 		for p.tok.kind != .rpar {
@@ -1508,7 +1508,7 @@ fn (p mut Parser) const_decl() ast.ConstDecl {
 	pos := p.tok.position()
 	p.check(.key_const)
 	p.check(.lpar)
-	mut fields := []ast.ConstField
+	var fields := []ast.ConstField
 	for p.tok.kind != .rpar {
 		if p.tok.kind == .comment {
 			p.comment()
@@ -1556,17 +1556,17 @@ fn (p mut Parser) struct_decl() ast.StructDecl {
 	if !is_c && no_body {
 		p.error('`$p.tok.lit` lacks body')
 	}
-	mut name := p.check_name()
+	var name := p.check_name()
 	// println('struct decl $name')
-	mut ast_fields := []ast.StructField
-	mut fields := []table.Field
-	mut mut_pos := -1
-	mut pub_pos := -1
-	mut pub_mut_pos := -1
+	var ast_fields := []ast.StructField
+	var fields := []table.Field
+	var mut_pos := -1
+	var pub_pos := -1
+	var pub_mut_pos := -1
 	if !no_body {
 		p.check(.lcbr)
 		for p.tok.kind != .rcbr {
-			mut comment := ast.Comment{}
+			var comment := ast.Comment{}
 			if p.tok.kind == .comment {
 				comment = p.comment()
 			}
@@ -1597,8 +1597,8 @@ fn (p mut Parser) struct_decl() ast.StructDecl {
 			println('XXXX' + s.str())
 		}
 */
-			mut default_expr := ast.Expr{}
-			mut has_default_expr := false
+			var default_expr := ast.Expr{}
+			var has_default_expr := false
 			if p.tok.kind == .assign {
 				// Default value
 				p.next()
@@ -1614,7 +1614,7 @@ fn (p mut Parser) struct_decl() ast.StructDecl {
 				}
 				has_default_expr = true
 			}
-			mut attr := ast.Attr{}
+			var attr := ast.Attr{}
 			if p.tok.kind == .lsbr {
 				attr = p.attribute()
 			}
@@ -1654,7 +1654,7 @@ fn (p mut Parser) struct_decl() ast.StructDecl {
 			is_union: is_union
 		}
 	}
-	mut ret := 0
+	var ret := 0
 	if p.builtin_mod && t.name in table.builtin_type_names {
 		// this allows overiding the builtins type
 		// with the real struct type info parsed from builtin
@@ -1687,7 +1687,7 @@ fn (p mut Parser) interface_decl() ast.InterfaceDecl {
 	p.next()	// `interface`
 	interface_name := p.check_name()
 	p.check(.lcbr)
-	mut field_names := []string
+	var field_names := []string
 	for p.tok.kind != .rcbr && p.tok.kind != .eof {
 		line_nr := p.tok.line_nr
 		name := p.check_name()
@@ -1707,7 +1707,7 @@ fn (p mut Parser) interface_decl() ast.InterfaceDecl {
 fn (p mut Parser) return_stmt() ast.Return {
 	p.next()
 	// return expressions
-	mut exprs := []ast.Expr
+	var exprs := []ast.Expr
 	if p.tok.kind == .rcbr {
 		return ast.Return{
 			pos: p.tok.position()
@@ -1731,7 +1731,7 @@ fn (p mut Parser) return_stmt() ast.Return {
 
 // left hand side of `=` or `:=` in `a,b,c := 1,2,3`
 fn (p mut Parser) parse_assign_lhs() []ast.Ident {
-	mut idents := []ast.Ident
+	var idents := []ast.Ident
 	for {
 		is_mut := p.tok.kind == .key_mut || p.tok.kind == .key_var
 		if is_mut {
@@ -1741,7 +1741,7 @@ fn (p mut Parser) parse_assign_lhs() []ast.Ident {
 		if is_static {
 			p.check(.key_static)
 		}
-		mut ident := p.parse_ident(false)
+		var ident := p.parse_ident(false)
 		ident.is_mut = is_mut
 		ident.info = ast.IdentVar{
 			is_mut: is_mut
@@ -1759,7 +1759,7 @@ fn (p mut Parser) parse_assign_lhs() []ast.Ident {
 
 // right hand side of `=` or `:=` in `a,b,c := 1,2,3`
 fn (p mut Parser) parse_assign_rhs() []ast.Expr {
-	mut exprs := []ast.Expr
+	var exprs := []ast.Expr
 	for {
 		expr := p.expr(0)
 		exprs << expr
@@ -1831,7 +1831,7 @@ fn (p mut Parser) global_decl() ast.GlobalDecl {
 	name := p.check_name()
 	// println(name)
 	typ := p.parse_type()
-	mut expr := ast.Expr{}
+	var expr := ast.Expr{}
 	has_expr := p.tok.kind == .assign
 	if has_expr {
 		p.next()
@@ -1866,20 +1866,20 @@ fn (p mut Parser) match_expr() ast.MatchExpr {
 	match_first_pos := p.tok.position()
 	p.check(.key_match)
 	is_mut := p.tok.kind in [.key_mut, .key_var]
-	mut is_sum_type := false
+	var is_sum_type := false
 	if is_mut {
 		p.next()
 	}
 	cond := p.expr(0)
 	p.check(.lcbr)
-	mut branches := []ast.MatchBranch
+	var branches := []ast.MatchBranch
 	for {
 		branch_first_pos := p.tok.position()
 		comment := p.check_comment()		// comment before {}
-		mut exprs := []ast.Expr
+		var exprs := []ast.Expr
 		p.open_scope()
 		// final else
-		mut is_else := false
+		var is_else := false
 		if p.tok.kind == .key_else {
 			is_else = true
 			p.next()
@@ -1893,7 +1893,7 @@ fn (p mut Parser) match_expr() ast.MatchExpr {
 			x := ast.Type{
 				typ: typ
 			}
-			mut expr := ast.Expr{}
+			var expr := ast.Expr{}
 			expr = x
 			exprs << expr
 			p.scope.register('it', ast.Var{
@@ -1963,15 +1963,15 @@ fn (p mut Parser) enum_decl() ast.EnumDecl {
 	p.check(.key_enum)
 	name := p.prepend_mod(p.check_name())
 	p.check(.lcbr)
-	mut vals := []string
+	var vals := []string
 	// mut default_exprs := []ast.Expr
-	mut fields := []ast.EnumField
+	var fields := []ast.EnumField
 	for p.tok.kind != .eof && p.tok.kind != .rcbr {
 		pos := p.tok.position()
 		val := p.check_name()
 		vals << val
-		mut expr := ast.Expr{}
-		mut has_expr := false
+		var expr := ast.Expr{}
+		var has_expr := false
 		// p.warn('enum val $val')
 		if p.tok.kind == .assign {
 			p.next()
@@ -2009,7 +2009,7 @@ fn (p mut Parser) type_decl() ast.TypeDecl {
 	}
 	p.check(.key_type)
 	name := p.check_name()
-	mut sum_variants := []table.Type
+	var sum_variants := []table.Type
 	if p.tok.kind == .assign {
 		p.next()		// TODO require `=`
 	}
@@ -2075,8 +2075,8 @@ fn (p mut Parser) assoc() ast.Assoc {
 		return ast.Assoc{}
 	}
 	// println('assoc var $name typ=$var.typ')
-	mut fields := []string
-	mut vals := []ast.Expr
+	var fields := []string
+	var vals := []ast.Expr
 	p.check(.pipe)
 	for {
 		fields << p.check_name()