vieter-v
/
v
2
0
Fork 0
Code Issues Pull Requests Releases Activity

fmt: use var instead of mut

pull/4417/head
Alexander Medvednikov 2020-04-15 01:55:51 +02:00
parent efaec8be8e
commit f34352faf9
4 changed files with 170 additions and 170 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
vlib/v/fmt/fmt.v
View File

@ -143,7 +143,7 @@ fn (f mut Fmt) stmt(node ast.Stmt) {
for i, ident in it.left { for i, ident in it.left {
var_info := ident.var_info() var_info := ident.var_info()
if var_info.is_mut { if var_info.is_mut {
f.write('mut ') f.write('var ')
} }
f.expr(ident) f.expr(ident)
if i < it.left.len - 1 { if i < it.left.len - 1 {
@ -578,7 +578,7 @@ fn (f mut Fmt) expr(node ast.Expr) {
ast.MatchExpr { ast.MatchExpr {
f.write('match ') f.write('match ')
if it.is_mut { if it.is_mut {
f.write('mut ') f.write('var ')
} }
f.expr(it.cond) f.expr(it.cond)
f.writeln(' {') f.writeln(' {')

100
vlib/v/gen/cgen.v
View File

@ -74,7 +74,7 @@ pub fn cgen(files []ast.File, table &table.Table, pref &pref.Preferences) string
} else { } else {
} }
// println('start cgen2') // println('start cgen2')
mut g := Gen{ var g := Gen{
out: strings.new_builder(1000) out: strings.new_builder(1000)
typedefs: strings.new_builder(100) typedefs: strings.new_builder(100)
typedefs2: 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() g.init()
// //
mut autofree_used := false var autofree_used := false
for file in files { for file in files {
g.file = file g.file = file
// println('\ncgen "$g.file.path" nr_stmts=$file.stmts.len') // 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 { 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)) res += c_current_commit_hash_default.replace('@@@', util.githash(g.pref.building_v))
return res return res
} }
@ -194,7 +194,7 @@ pub fn (g mut Gen) write_typeof_functions() {
pub fn (g mut Gen) typ(t table.Type) string { pub fn (g mut Gen) typ(t table.Type) string {
nr_muls := table.type_nr_muls(t) nr_muls := table.type_nr_muls(t)
sym := g.table.get_type_symbol(t) sym := g.table.get_type_symbol(t)
mut styp := sym.name.replace('.', '__') var styp := sym.name.replace('.', '__')
if nr_muls > 0 { if nr_muls > 0 {
styp += strings.repeat(`*`, nr_muls) styp += strings.repeat(`*`, nr_muls)
} }
@ -390,7 +390,7 @@ fn (g mut Gen) stmt(node ast.Stmt) {
g.comp_if(it) g.comp_if(it)
} }
ast.DeferStmt { ast.DeferStmt {
mut defer_stmt := *it var defer_stmt := *it
defer_stmt.ifdef = g.defer_ifdef defer_stmt.ifdef = g.defer_ifdef
g.defer_stmts << defer_stmt g.defer_stmts << defer_stmt
} }
@ -646,7 +646,7 @@ fn (g mut Gen) gen_assert_stmt(a ast.AssertStmt) {
g.write(')') g.write(')')
g.inside_ternary = false g.inside_ternary = false
s_assertion := a.expr.str().replace('"', "\'") s_assertion := a.expr.str().replace('"', "\'")
mut mod_path := g.file.path var mod_path := g.file.path
$if windows { $if windows {
mod_path = g.file.path.replace('\\', '\\\\') 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 { if assign_stmt.left.len > assign_stmt.right.len {
// multi return // multi return
mut or_stmts := []ast.Stmt var or_stmts := []ast.Stmt
mut return_type := table.void_type var return_type := table.void_type
match assign_stmt.right[0] { match assign_stmt.right[0] {
ast.CallExpr { ast.CallExpr {
or_stmts = it.or_block.stmts 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] val := assign_stmt.right[i]
ident_var_info := ident.var_info() ident_var_info := ident.var_info()
styp := g.typ(ident_var_info.typ) styp := g.typ(ident_var_info.typ)
mut is_call := false var is_call := false
mut or_stmts := []ast.Stmt var or_stmts := []ast.Stmt
mut return_type := table.void_type var return_type := table.void_type
match val { match val {
ast.CallExpr { ast.CallExpr {
is_call = true is_call = true
@ -742,7 +742,7 @@ fn (g mut Gen) gen_assign_stmt(assign_stmt ast.AssignStmt) {
} }
} else { } else {
right_sym := g.table.get_type_symbol(assign_stmt.right_types[i]) 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 { match val {
ast.ArrayInit { ast.ArrayInit {
is_fixed_array_init = it.is_fixed 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 { 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 { match val {
ast.Ident { ast.Ident {
is_ident = true 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) { fn (g mut Gen) assign_expr(node ast.AssignExpr) {
// g.write('/*assign_expr*/') // g.write('/*assign_expr*/')
mut is_call := false var is_call := false
mut or_stmts := []ast.Stmt var or_stmts := []ast.Stmt
mut return_type := table.void_type var return_type := table.void_type
match node.val { match node.val {
ast.CallExpr { ast.CallExpr {
is_call = true is_call = true
@ -1146,7 +1146,7 @@ fn (g mut Gen) assign_expr(node ast.AssignExpr) {
if table.type_is(node.right_type, .optional) { if table.type_is(node.right_type, .optional) {
g.right_is_opt = true 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 { if node.left_type == table.string_type_idx && node.op == .plus_assign {
// str += str2 => `str = string_add(str, str2)` // str += str2 => `str = string_add(str, str2)`
g.expr(node.left) g.expr(node.left)
@ -1164,7 +1164,7 @@ fn (g mut Gen) assign_expr(node ast.AssignExpr) {
g.is_assign_lhs = false g.is_assign_lhs = false
right_sym := g.table.get_type_symbol(node.right_type) right_sym := g.table.get_type_symbol(node.right_type)
// left_sym := g.table.get_type_symbol(node.left_type) // left_sym := g.table.get_type_symbol(node.left_type)
mut cloned := false var cloned := false
// !g.is_array_set // !g.is_array_set
if g.autofree && right_sym.kind in [.array, .string] { if g.autofree && right_sym.kind in [.array, .string] {
if g.gen_clone_assignment(node.val, right_sym, false) { 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)} */') // 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) type_sym := g.table.get_type_symbol(node.cond_type)
mut tmp := '' var tmp := ''
if type_sym.kind != .void { if type_sym.kind != .void {
tmp = g.new_tmp_var() 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. // If expression? Assign the value to a temp var.
// Previously ?: was used, but it's too unreliable. // Previously ?: was used, but it's too unreliable.
type_sym := g.table.get_type_symbol(node.typ) type_sym := g.table.get_type_symbol(node.typ)
mut tmp := '' var tmp := ''
if type_sym.kind != .void { if type_sym.kind != .void {
tmp = g.new_tmp_var() tmp = g.new_tmp_var()
// g.writeln('$ti.name $tmp;') // g.writeln('$ti.name $tmp;')
@ -1517,7 +1517,7 @@ fn (g mut Gen) if_expr(node ast.IfExpr) {
g.inside_ternary = false g.inside_ternary = false
} else { } else {
guard_ok := g.new_tmp_var() guard_ok := g.new_tmp_var()
mut is_guard := false var is_guard := false
for i, branch in node.branches { for i, branch in node.branches {
if i == 0 { if i == 0 {
match branch.cond { 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) { fn (g mut Gen) index_expr(node ast.IndexExpr) {
// TODO else doesn't work with sum types // TODO else doesn't work with sum types
mut is_range := false var is_range := false
match node.index { match node.index {
ast.RangeExpr { ast.RangeExpr {
sym := g.table.get_type_symbol(node.left_type) 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 { } else if sym.kind == .array {
info := sym.info as table.Array info := sym.info as table.Array
elem_type_str := g.typ(info.elem_type) elem_type_str := g.typ(info.elem_type)
mut is_selector := false var is_selector := false
match node.left { match node.left {
ast.SelectorExpr { ast.SelectorExpr {
// `vals[i].field = x` is an exception and requires `array_get`: // `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.expr(node.left)
g.write(', ') g.write(', ')
g.expr(node.index) g.expr(node.index)
mut need_wrapper := true var need_wrapper := true
/* /*
match node.right { match node.right {
ast.EnumVal, ast.Ident { ast.EnumVal, ast.Ident {
@ -1762,10 +1762,10 @@ fn (g mut Gen) return_statement(node ast.Return) {
g.write(' ') g.write(' ')
typ_sym := g.table.get_type_symbol(g.fn_decl.return_type) typ_sym := g.table.get_type_symbol(g.fn_decl.return_type)
mr_info := typ_sym.info as table.MultiReturn 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] != if fn_return_is_optional { // && !table.type_is(node.types[0], .optional) && node.types[0] !=
styp = styp[7..] // remove 'Option_' styp = styp[7..] // remove 'Option_'
mut x := styp var x := styp
if x.ends_with('_ptr') { if x.ends_with('_ptr') {
x = x.replace('_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 // `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 != if fn_return_is_optional && !table.type_is(node.types[0], .optional) && return_sym.name !=
'Option' { 'Option' {
mut is_none := false var is_none := false
mut is_error := false var is_error := false
expr0 := node.exprs[0] expr0 := node.exprs[0]
match expr0 { match expr0 {
ast.None { ast.None {
@ -1808,7 +1808,7 @@ fn (g mut Gen) return_statement(node ast.Return) {
} }
if !is_none && !is_error { if !is_none && !is_error {
styp := g.typ(g.fn_decl.return_type)[7..] // remove 'Option_' styp := g.typ(g.fn_decl.return_type)[7..] // remove 'Option_'
mut x := styp var x := styp
if x.ends_with('_ptr') { if x.ends_with('_ptr') {
x = x.replace('_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) { fn (g mut Gen) struct_init(struct_init ast.StructInit) {
mut info := table.Struct{} var info := table.Struct{}
mut is_struct := false var is_struct := false
sym := g.table.get_type_symbol(struct_init.typ) sym := g.table.get_type_symbol(struct_init.typ)
if sym.kind == .struct_ { if sym.kind == .struct_ {
is_struct = true is_struct = true
@ -1887,8 +1887,8 @@ fn (g mut Gen) struct_init(struct_init ast.StructInit) {
} else { } else {
g.writeln('($styp){') g.writeln('($styp){')
} }
mut fields := []string var fields := []string
mut inited_fields := []string // TODO this is done in checker, move to ast node 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 { 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. // Get fields for {a,b} short syntax. Fields array wasn't set in the parser.
for f in info.fields { for f in info.fields {
@ -2057,7 +2057,7 @@ const (
) )
fn (g mut Gen) write_builtin_types() { 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 // builtin types need to be on top
// everything except builtin will get sorted // everything except builtin will get sorted
for builtin_name in builtins { 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 // Sort the types, make sure types that are referenced by other types
// are added before them. // are added before them.
fn (g mut Gen) write_sorted_types() { 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 { for typ in g.table.types {
if !(typ.name in builtins) { if !(typ.name in builtins) {
types << typ types << typ
@ -2128,7 +2128,7 @@ int typ;
// .array_fixed { // .array_fixed {
styp := typ.name.replace('.', '__') styp := typ.name.replace('.', '__')
// array_fixed_char_300 => char x[300] // array_fixed_char_300 => char x[300]
mut fixed := styp[12..] var fixed := styp[12..]
len := styp.after('_') len := styp.after('_')
fixed = fixed[..fixed.len - len.len - 1] fixed = fixed[..fixed.len - len.len - 1]
g.definitions.writeln('typedef $fixed $styp [$len];') g.definitions.writeln('typedef $fixed $styp [$len];')
@ -2141,16 +2141,16 @@ int typ;
// sort structs by dependant fields // sort structs by dependant fields
fn (g Gen) sort_structs(typesa []table.TypeSymbol) []table.TypeSymbol { 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 // types name list
mut type_names := []string var type_names := []string
for typ in typesa { for typ in typesa {
type_names << typ.name type_names << typ.name
} }
// loop over types // loop over types
for t in typesa { for t in typesa {
// create list of deps // create list of deps
mut field_deps := []string var field_deps := []string
match t.info { match t.info {
table.ArrayFixed { table.ArrayFixed {
dep := g.table.get_type_symbol(it.elem_type).name 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') '\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 // sort types
mut types_sorted := []table.TypeSymbol var types_sorted := []table.TypeSymbol
for node in dep_graph_sorted.nodes { for node in dep_graph_sorted.nodes {
types_sorted << g.table.types[g.table.type_idxs[node.name]] 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) { fn (g mut Gen) type_of_last_statement(stmts []ast.Stmt) (string, string) {
mut last_type := '' var last_type := ''
mut last_expr_result_type := '' var last_expr_result_type := ''
if stmts.len > 0 { if stmts.len > 0 {
last_stmt := stmts[stmts.len - 1] last_stmt := stmts[stmts.len - 1]
last_type = typeof(last_stmt) 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 { fn (g Gen) get_all_test_function_names() []string {
mut tfuncs := []string var tfuncs := []string
mut tsuite_begin := '' var tsuite_begin := ''
mut tsuite_end := '' var tsuite_end := ''
for _, f in g.table.fns { for _, f in g.table.fns {
if f.name == 'testsuite_begin' { if f.name == 'testsuite_begin' {
tsuite_begin = f.name tsuite_begin = f.name
@ -2693,7 +2693,7 @@ fn (g Gen) get_all_test_function_names() []string {
continue continue
} }
} }
mut all_tfuncs := []string var all_tfuncs := []string
if tsuite_begin.len > 0 { if tsuite_begin.len > 0 {
all_tfuncs << tsuite_begin all_tfuncs << tsuite_begin
} }
@ -2701,7 +2701,7 @@ fn (g Gen) get_all_test_function_names() []string {
if tsuite_end.len > 0 { if tsuite_end.len > 0 {
all_tfuncs << tsuite_end all_tfuncs << tsuite_end
} }
mut all_tfuncs_c := []string var all_tfuncs_c := []string
for f in all_tfuncs { for f in all_tfuncs {
all_tfuncs_c << f.replace('.', '__') 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 // x := node.call_expr as ast.CallEpxr // TODO
match node.call_expr { match node.call_expr {
ast.CallExpr { ast.CallExpr {
mut name := it.name.replace('.', '__') var name := it.name.replace('.', '__')
if it.is_method { if it.is_method {
receiver_sym := g.table.get_type_symbol(it.receiver_type) receiver_sym := g.table.get_type_symbol(it.receiver_type)
name = receiver_sym.name + '_' + name 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) { fn (g mut Gen) gen_str_default(sym table.TypeSymbol, styp string) {
mut convertor := '' var convertor := ''
mut typename := '' var typename := ''
if sym.parent_idx in table.integer_type_idxs { if sym.parent_idx in table.integer_type_idxs {
convertor = 'int' convertor = 'int'
typename = 'int' typename = 'int'

38
vlib/v/parser/fn.v
View File

@ -28,8 +28,8 @@ pub fn (p mut Parser) call_expr(is_c bool, mod string) ast.CallExpr {
pos: first_pos.pos pos: first_pos.pos
len: last_pos.pos - first_pos.pos + last_pos.len len: last_pos.pos - first_pos.pos + last_pos.len
} }
mut or_stmts := []ast.Stmt var or_stmts := []ast.Stmt
mut is_or_block_used := false var is_or_block_used := false
if p.tok.kind == .key_orelse { if p.tok.kind == .key_orelse {
p.next() p.next()
p.open_scope() 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 { pub fn (p mut Parser) call_args() []ast.CallArg {
mut args := []ast.CallArg var args := []ast.CallArg
for p.tok.kind != .rpar { for p.tok.kind != .rpar {
mut is_mut := false var is_mut := false
if p.tok.kind == .key_mut { if p.tok.kind == .key_mut {
p.check(.key_mut) p.check(.key_mut)
is_mut = true is_mut = true
@ -96,11 +96,11 @@ fn (p mut Parser) fn_decl() ast.FnDecl {
p.check(.dot) p.check(.dot)
} }
// Receiver? // Receiver?
mut rec_name := '' var rec_name := ''
mut is_method := false var is_method := false
mut rec_type := table.void_type var rec_type := table.void_type
mut rec_mut := false var rec_mut := false
mut args := []table.Arg var args := []table.Arg
if p.tok.kind == .lpar { if p.tok.kind == .lpar {
p.next() // ( p.next() // (
is_method = true is_method = true
@ -129,7 +129,7 @@ fn (p mut Parser) fn_decl() ast.FnDecl {
} }
p.check(.rpar) p.check(.rpar)
} }
mut name := '' var name := ''
if p.tok.kind == .name { if p.tok.kind == .name {
// TODO high order fn // TODO high order fn
name = p.check_name() name = p.check_name()
@ -161,13 +161,13 @@ fn (p mut Parser) fn_decl() ast.FnDecl {
}) })
} }
// Return type // Return type
mut return_type := table.void_type var return_type := table.void_type
if p.tok.kind.is_start_of_type() { if p.tok.kind.is_start_of_type() {
return_type = p.parse_type() return_type = p.parse_type()
} }
// Register // Register
if is_method { 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 ()') // p.warn('reg method $type_sym.name . $name ()')
type_sym.register_method(table.Fn{ type_sym.register_method(table.Fn{
name: name name: name
@ -195,7 +195,7 @@ fn (p mut Parser) fn_decl() ast.FnDecl {
}) })
} }
// Body // Body
mut stmts := []ast.Stmt var stmts := []ast.Stmt
no_body := p.tok.kind != .lcbr no_body := p.tok.kind != .lcbr
if p.tok.kind == .lcbr { if p.tok.kind == .lcbr {
stmts = p.parse_block() 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) { fn (p mut Parser) fn_args() ([]table.Arg, bool) {
p.check(.lpar) p.check(.lpar)
mut args := []table.Arg var args := []table.Arg
mut is_variadic := false var is_variadic := false
// `int, int, string` (no names, just types) // `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)) || 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 p.peek_tok.kind == .rpar
if types_only { if types_only {
// p.warn('types only') // p.warn('types only')
mut arg_no := 1 var arg_no := 1
for p.tok.kind != .rpar { for p.tok.kind != .rpar {
arg_name := 'arg_$arg_no' arg_name := 'arg_$arg_no'
is_mut := p.tok.kind == .key_mut is_mut := p.tok.kind == .key_mut
@ -244,7 +244,7 @@ fn (p mut Parser) fn_args() ([]table.Arg, bool) {
p.check(.ellipsis) p.check(.ellipsis)
is_variadic = true is_variadic = true
} }
mut arg_type := p.parse_type() var arg_type := p.parse_type()
if is_variadic { if is_variadic {
arg_type = table.type_set(arg_type, .variadic) arg_type = table.type_set(arg_type, .variadic)
} }
@ -263,7 +263,7 @@ fn (p mut Parser) fn_args() ([]table.Arg, bool) {
} }
} else { } else {
for p.tok.kind != .rpar { for p.tok.kind != .rpar {
mut arg_names := [p.check_name()] var arg_names := [p.check_name()]
// `a, b, c int` // `a, b, c int`
for p.tok.kind == .comma { for p.tok.kind == .comma {
p.check(.comma) p.check(.comma)
@ -277,7 +277,7 @@ fn (p mut Parser) fn_args() ([]table.Arg, bool) {
p.check(.ellipsis) p.check(.ellipsis)
is_variadic = true is_variadic = true
} }
mut typ := p.parse_type() var typ := p.parse_type()
if is_variadic { if is_variadic {
typ = table.type_set(typ, .variadic) typ = table.type_set(typ, .variadic)
} }

198
vlib/v/parser/parser.v
View File

@ -42,7 +42,7 @@ mut:
// for tests // for tests
pub fn parse_stmt(text string, table &table.Table, scope &ast.Scope) ast.Stmt { pub fn parse_stmt(text string, table &table.Table, scope &ast.Scope) ast.Stmt {
s := scanner.new_scanner(text, .skip_comments) s := scanner.new_scanner(text, .skip_comments)
mut p := Parser{ var p := Parser{
scanner: s scanner: s
table: table table: table
pref: &pref.Preferences{} 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 { // text := os.read_file(path) or {
// panic(err) // panic(err)
// } // }
mut stmts := []ast.Stmt var stmts := []ast.Stmt
mut p := Parser{ var p := Parser{
scanner: scanner.new_scanner_file(path, comments_mode) scanner: scanner.new_scanner_file(path, comments_mode)
table: table table: table
file_name: path file_name: path
@ -78,12 +78,12 @@ pub fn parse_file(path string, table &table.Table, comments_mode scanner.Comment
// comments_mode: comments_mode // comments_mode: comments_mode
p.read_first_token() p.read_first_token()
for p.tok.kind == .comment { for p.tok.kind == .comment {
mut stmt := ast.Stmt{} // TODO sum type << bug var stmt := ast.Stmt{} // TODO sum type << bug
com := p.comment() com := p.comment()
stmt = com stmt = com
stmts << stmt stmts << stmt
} }
mut mstmt := ast.Stmt{} var mstmt := ast.Stmt{}
module_decl := p.module_decl() module_decl := p.module_decl()
mstmt = module_decl mstmt = module_decl
stmts << mstmt stmts << mstmt
@ -160,7 +160,7 @@ pub fn parse_files(paths []string, table &table.Table, pref &pref.Preferences, g
return q.parsed_ast_files return q.parsed_ast_files
*/ */
// /////////////// // ///////////////
mut files := []ast.File var files := []ast.File
for path in paths { for path in paths {
// println('parse_files $path') // println('parse_files $path')
files << parse_file(path, table, .skip_comments, pref, global_scope) 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 { pub fn (p mut Parser) parse_block_no_scope() []ast.Stmt {
p.check(.lcbr) p.check(.lcbr)
mut stmts := []ast.Stmt var stmts := []ast.Stmt
if p.tok.kind != .rcbr { if p.tok.kind != .rcbr {
for { for {
stmts << p.stmt() stmts << p.stmt()
@ -482,7 +482,7 @@ fn (p mut Parser) attribute() ast.Attr {
if p.tok.kind == .key_if { if p.tok.kind == .key_if {
p.next() p.next()
} }
mut name := p.check_name() var name := p.check_name()
if p.tok.kind == .colon { if p.tok.kind == .colon {
p.next() p.next()
if p.tok.kind == .name { 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) { pub fn (p &Parser) error_with_pos(s string, pos token.Position) {
mut kind := 'error:' var kind := 'error:'
if p.pref.is_verbose { if p.pref.is_verbose {
print_backtrace() print_backtrace()
kind = 'parser error:' 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 { pub fn (p mut Parser) parse_ident(is_c bool) ast.Ident {
// p.warn('name ') // p.warn('name ')
pos := p.tok.position() pos := p.tok.position()
mut name := p.check_name() var name := p.check_name()
if name == '_' { if name == '_' {
return ast.Ident{ return ast.Ident{
name: '_' name: '_'
@ -558,7 +558,7 @@ pub fn (p mut Parser) parse_ident(is_c bool) ast.Ident {
if p.expr_mod.len > 0 { if p.expr_mod.len > 0 {
name = '${p.expr_mod}.$name' name = '${p.expr_mod}.$name'
} }
mut ident := ast.Ident{ var ident := ast.Ident{
kind: .unresolved kind: .unresolved
name: name name: name
is_c: is_c is_c: is_c
@ -576,14 +576,14 @@ fn (p mut Parser) struct_init(short_syntax bool) ast.StructInit {
if !short_syntax { if !short_syntax {
p.check(.lcbr) p.check(.lcbr)
} }
mut field_names := []string var field_names := []string
mut exprs := []ast.Expr var exprs := []ast.Expr
mut i := 0 var i := 0
is_short_syntax := p.peek_tok.kind != .colon && p.tok.kind != .rcbr // `Vec{a,b,c} is_short_syntax := p.peek_tok.kind != .colon && p.tok.kind != .rcbr // `Vec{a,b,c}
// p.warn(is_short_syntax.str()) // p.warn(is_short_syntax.str())
for p.tok.kind != .rcbr { for p.tok.kind != .rcbr {
p.check_comment() p.check_comment()
mut field_name := '' var field_name := ''
if is_short_syntax { if is_short_syntax {
expr := p.expr(0) expr := p.expr(0)
exprs << expr 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 { pub fn (p mut Parser) name_expr() ast.Expr {
mut node := ast.Expr{} var node := ast.Expr{}
is_c := p.tok.lit == 'C' is_c := p.tok.lit == 'C'
mut mod := '' var mod := ''
// p.warn('resetting') // p.warn('resetting')
p.expr_mod = '' p.expr_mod = ''
// `map[string]int` initialization // `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()') // p.warn('name expr $p.tok.lit $p.peek_tok.str()')
// fn call or type cast // fn call or type cast
if p.peek_tok.kind == .lpar { if p.peek_tok.kind == .lpar {
mut name := p.tok.lit var name := p.tok.lit
if mod.len > 0 { if mod.len > 0 {
name = '${mod}.$name' 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', if (name in p.table.type_idxs || name_w_mod in p.table.type_idxs) && !(name in ['C.stat',
'C.sigaction']) { 'C.sigaction']) {
// TODO handle C.stat() // TODO handle C.stat()
mut to_typ := p.parse_type() var to_typ := p.parse_type()
if p.is_amp { if p.is_amp {
// Handle `&Foo(0)` // Handle `&Foo(0)`
to_typ = table.type_to_ptr(to_typ) to_typ = table.type_to_ptr(to_typ)
} }
p.check(.lpar) p.check(.lpar)
mut expr := ast.Expr{} var expr := ast.Expr{}
mut arg := ast.Expr{} var arg := ast.Expr{}
mut has_arg := false var has_arg := false
expr = p.expr(0) expr = p.expr(0)
// TODO, string(b, len) // TODO, string(b, len)
if p.tok.kind == .comma && table.type_idx(to_typ) == table.string_type_idx { 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 return p.struct_init(false) // short_syntax: false
} else if p.peek_tok.kind == .dot && (p.tok.lit[0].is_capital() && !known_var) { } else if p.peek_tok.kind == .dot && (p.tok.lit[0].is_capital() && !known_var) {
// `Color.green` // `Color.green`
mut enum_name := p.check_name() var enum_name := p.check_name()
if mod != '' { if mod != '' {
enum_name = mod + '.' + enum_name enum_name = mod + '.' + enum_name
} else { } else {
@ -715,7 +715,7 @@ pub fn (p mut Parser) name_expr() ast.Expr {
mod: mod mod: mod
} }
} else { } else {
mut ident := ast.Ident{} var ident := ast.Ident{}
ident = p.parse_ident(is_c) ident = p.parse_ident(is_c)
node = ident 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 { pub fn (p mut Parser) expr(precedence int) ast.Expr {
// println('\n\nparser.expr()') // println('\n\nparser.expr()')
mut typ := table.void_type var typ := table.void_type
mut node := ast.Expr{} var node := ast.Expr{}
is_stmt_ident := p.is_stmt_ident is_stmt_ident := p.is_stmt_ident
p.is_stmt_ident = false p.is_stmt_ident = false
// defer { // defer {
@ -908,7 +908,7 @@ fn (p mut Parser) prefix_expr() ast.PrefixExpr {
fn (p mut Parser) index_expr(left ast.Expr) ast.IndexExpr { fn (p mut Parser) index_expr(left ast.Expr) ast.IndexExpr {
// left == `a` in `a[0]` // left == `a` in `a[0]`
p.next() // [ p.next() // [
mut has_low := true var has_low := true
if p.tok.kind == .dotdot { if p.tok.kind == .dotdot {
has_low = false has_low = false
// [..end] // [..end]
@ -926,11 +926,11 @@ fn (p mut Parser) index_expr(left ast.Expr) ast.IndexExpr {
} }
} }
expr := p.expr(0) // `[expr]` or `[expr..]` expr := p.expr(0) // `[expr]` or `[expr..]`
mut has_high := false var has_high := false
if p.tok.kind == .dotdot { if p.tok.kind == .dotdot {
// [start..end] or [start..] // [start..end] or [start..]
p.check(.dotdot) p.check(.dotdot)
mut high := ast.Expr{} var high := ast.Expr{}
if p.tok.kind != .rsbr { if p.tok.kind != .rsbr {
has_high = true has_high = true
high = p.expr(0) high = p.expr(0)
@ -964,7 +964,7 @@ fn (p mut Parser) filter() {
fn (p mut Parser) dot_expr(left ast.Expr) ast.Expr { fn (p mut Parser) dot_expr(left ast.Expr) ast.Expr {
p.next() p.next()
mut name_pos := p.tok.position() var name_pos := p.tok.position()
field_name := p.check_name() field_name := p.check_name()
is_filter := field_name in ['filter', 'map'] is_filter := field_name in ['filter', 'map']
if is_filter { if is_filter {
@ -981,8 +981,8 @@ fn (p mut Parser) dot_expr(left ast.Expr) ast.Expr {
p.next() p.next()
args := p.call_args() args := p.call_args()
p.check(.rpar) p.check(.rpar)
mut or_stmts := []ast.Stmt var or_stmts := []ast.Stmt
mut is_or_block_used := false var is_or_block_used := false
if p.tok.kind == .key_orelse { if p.tok.kind == .key_orelse {
p.next() p.next()
p.open_scope() p.open_scope()
@ -1015,7 +1015,7 @@ fn (p mut Parser) dot_expr(left ast.Expr) ast.Expr {
is_used: is_or_block_used is_used: is_or_block_used
} }
} }
mut node := ast.Expr{} var node := ast.Expr{}
node = mcall_expr node = mcall_expr
if is_filter { if is_filter {
p.close_scope() p.close_scope()
@ -1027,7 +1027,7 @@ fn (p mut Parser) dot_expr(left ast.Expr) ast.Expr {
field: field_name field: field_name
pos: name_pos pos: name_pos
} }
mut node := ast.Expr{} var node := ast.Expr{}
node = sel_expr node = sel_expr
if is_filter { if is_filter {
p.close_scope() p.close_scope()
@ -1042,9 +1042,9 @@ fn (p mut Parser) infix_expr(left ast.Expr) ast.Expr {
precedence := p.tok.precedence() precedence := p.tok.precedence()
pos := p.tok.position() pos := p.tok.position()
p.next() p.next()
mut right := ast.Expr{} var right := ast.Expr{}
right = p.expr(precedence) right = p.expr(precedence)
mut expr := ast.Expr{} var expr := ast.Expr{}
expr = ast.InfixExpr{ expr = ast.InfixExpr{
left: left left: left
right: right right: right
@ -1085,13 +1085,13 @@ fn (p mut Parser) for_stmt() ast.Stmt {
p.error('`mut` is not required in for loops') p.error('`mut` is not required in for loops')
} else if p.peek_tok.kind in [.decl_assign, .assign, .semicolon] || p.tok.kind == .semicolon { } else if p.peek_tok.kind in [.decl_assign, .assign, .semicolon] || p.tok.kind == .semicolon {
// `for i := 0; i < 10; i++ {` // `for i := 0; i < 10; i++ {`
mut init := ast.Stmt{} var init := ast.Stmt{}
mut cond := p.new_true_expr() var cond := p.new_true_expr()
// mut inc := ast.Stmt{} // mut inc := ast.Stmt{}
mut inc := ast.Expr{} var inc := ast.Expr{}
mut has_init := false var has_init := false
mut has_cond := false var has_cond := false
mut has_inc := false var has_inc := false
if p.peek_tok.kind in [.assign, .decl_assign] { if p.peek_tok.kind in [.assign, .decl_assign] {
init = p.assign_stmt() init = p.assign_stmt()
has_init = true has_init = true
@ -1101,7 +1101,7 @@ fn (p mut Parser) for_stmt() ast.Stmt {
// Allow `for i = 0; i < ...` // Allow `for i = 0; i < ...`
p.check(.semicolon) p.check(.semicolon)
if p.tok.kind != .semicolon { if p.tok.kind != .semicolon {
mut typ := table.void_type var typ := table.void_type
cond = p.expr(0) cond = p.expr(0)
has_cond = true 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] { } else if p.peek_tok.kind in [.key_in, .comma] {
// `for i in vals`, `for i in start .. end` // `for i in vals`, `for i in start .. end`
mut key_var_name := '' var key_var_name := ''
mut val_var_name := p.check_name() var val_var_name := p.check_name()
if p.tok.kind == .comma { if p.tok.kind == .comma {
p.check(.comma) p.check(.comma)
key_var_name = val_var_name key_var_name = val_var_name
@ -1143,8 +1143,8 @@ fn (p mut Parser) for_stmt() ast.Stmt {
// 0 .. 10 // 0 .. 10
// start := p.tok.lit.int() // start := p.tok.lit.int()
// TODO use RangeExpr // TODO use RangeExpr
mut high_expr := ast.Expr{} var high_expr := ast.Expr{}
mut is_range := false var is_range := false
if p.tok.kind == .dotdot { if p.tok.kind == .dotdot {
is_range = true is_range = true
p.check(.dotdot) p.check(.dotdot)
@ -1187,12 +1187,12 @@ fn (p mut Parser) for_stmt() ast.Stmt {
fn (p mut Parser) if_expr() ast.IfExpr { fn (p mut Parser) if_expr() ast.IfExpr {
pos := p.tok.position() pos := p.tok.position()
mut branches := []ast.IfBranch var branches := []ast.IfBranch
mut has_else := false var has_else := false
for p.tok.kind in [.key_if, .key_else] { for p.tok.kind in [.key_if, .key_else] {
p.inside_if = true p.inside_if = true
branch_pos := p.tok.position() branch_pos := p.tok.position()
mut comment := ast.Comment{} var comment := ast.Comment{}
if p.tok.kind == .key_if { if p.tok.kind == .key_if {
p.check(.key_if) p.check(.key_if)
} else { } else {
@ -1214,8 +1214,8 @@ fn (p mut Parser) if_expr() ast.IfExpr {
break break
} }
} }
mut cond := ast.Expr{} var cond := ast.Expr{}
mut is_or := false var is_or := false
// `if x := opt() {` // `if x := opt() {`
if p.peek_tok.kind == .decl_assign { if p.peek_tok.kind == .decl_assign {
is_or = true is_or = true
@ -1262,7 +1262,7 @@ fn (p mut Parser) string_expr() ast.Expr {
if is_raw || is_cstr { if is_raw || is_cstr {
p.next() p.next()
} }
mut node := ast.Expr{} var node := ast.Expr{}
val := p.tok.lit val := p.tok.lit
pos := p.tok.position() pos := p.tok.position()
if p.peek_tok.kind != .str_dollar { if p.peek_tok.kind != .str_dollar {
@ -1275,9 +1275,9 @@ fn (p mut Parser) string_expr() ast.Expr {
} }
return node return node
} }
mut exprs := []ast.Expr var exprs := []ast.Expr
mut vals := []string var vals := []string
mut efmts := []string var efmts := []string
// Handle $ interpolation // Handle $ interpolation
for p.tok.kind == .string { for p.tok.kind == .string {
vals << p.tok.lit vals << p.tok.lit
@ -1287,7 +1287,7 @@ fn (p mut Parser) string_expr() ast.Expr {
} }
p.check(.str_dollar) p.check(.str_dollar)
exprs << p.expr(0) exprs << p.expr(0)
mut efmt := []string var efmt := []string
if p.tok.kind == .colon { if p.tok.kind == .colon {
efmt << ':' efmt << ':'
p.next() p.next()
@ -1319,13 +1319,13 @@ fn (p mut Parser) string_expr() ast.Expr {
fn (p mut Parser) array_init() ast.ArrayInit { fn (p mut Parser) array_init() ast.ArrayInit {
first_pos := p.tok.position() first_pos := p.tok.position()
mut last_pos := token.Position{} var last_pos := token.Position{}
p.check(.lsbr) p.check(.lsbr)
// p.warn('array_init() exp=$p.expected_type') // p.warn('array_init() exp=$p.expected_type')
mut array_type := table.void_type var array_type := table.void_type
mut elem_type := table.void_type var elem_type := table.void_type
mut exprs := []ast.Expr var exprs := []ast.Expr
mut is_fixed := false var is_fixed := false
if p.tok.kind == .rsbr { if p.tok.kind == .rsbr {
// []typ => `[]` and `typ` must be on the same line // []typ => `[]` and `typ` must be on the same line
line_nr := p.tok.line_nr 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 { fn (p mut Parser) map_init() ast.MapInit {
pos := p.tok.position() pos := p.tok.position()
mut keys := []ast.Expr var keys := []ast.Expr
mut vals := []ast.Expr var vals := []ast.Expr
for p.tok.kind != .rcbr && p.tok.kind != .eof { for p.tok.kind != .rcbr && p.tok.kind != .eof {
// p.check(.str) // p.check(.str)
key := p.expr(0) 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 { fn (p mut Parser) parse_number_literal() ast.Expr {
lit := p.tok.lit lit := p.tok.lit
pos := p.tok.position() pos := p.tok.position()
mut node := ast.Expr{} var node := ast.Expr{}
if lit.index_any('.eE') >= 0 { if lit.index_any('.eE') >= 0 {
node = ast.FloatLiteral{ node = ast.FloatLiteral{
val: lit val: lit
@ -1443,7 +1443,7 @@ fn (p mut Parser) parse_number_literal() ast.Expr {
} }
fn (p mut Parser) module_decl() ast.Module { fn (p mut Parser) module_decl() ast.Module {
mut name := 'main' var name := 'main'
is_skipped := p.tok.kind != .key_module is_skipped := p.tok.kind != .key_module
if !is_skipped { if !is_skipped {
p.check(.key_module) p.check(.key_module)
@ -1460,8 +1460,8 @@ fn (p mut Parser) module_decl() ast.Module {
fn (p mut Parser) parse_import() ast.Import { fn (p mut Parser) parse_import() ast.Import {
pos := p.tok.position() pos := p.tok.position()
mut mod_name := p.check_name() var mod_name := p.check_name()
mut mod_alias := mod_name var mod_alias := mod_name
for p.tok.kind == .dot { for p.tok.kind == .dot {
p.check(.dot) p.check(.dot)
submod_name := p.check_name() 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 { fn (p mut Parser) import_stmt() []ast.Import {
p.check(.key_import) p.check(.key_import)
mut imports := []ast.Import var imports := []ast.Import
if p.tok.kind == .lpar { if p.tok.kind == .lpar {
p.check(.lpar) p.check(.lpar)
for p.tok.kind != .rpar { for p.tok.kind != .rpar {
@ -1508,7 +1508,7 @@ fn (p mut Parser) const_decl() ast.ConstDecl {
pos := p.tok.position() pos := p.tok.position()
p.check(.key_const) p.check(.key_const)
p.check(.lpar) p.check(.lpar)
mut fields := []ast.ConstField var fields := []ast.ConstField
for p.tok.kind != .rpar { for p.tok.kind != .rpar {
if p.tok.kind == .comment { if p.tok.kind == .comment {
p.comment() p.comment()
@ -1556,17 +1556,17 @@ fn (p mut Parser) struct_decl() ast.StructDecl {
if !is_c && no_body { if !is_c && no_body {
p.error('`$p.tok.lit` lacks body') p.error('`$p.tok.lit` lacks body')
} }
mut name := p.check_name() var name := p.check_name()
// println('struct decl $name') // println('struct decl $name')
mut ast_fields := []ast.StructField var ast_fields := []ast.StructField
mut fields := []table.Field var fields := []table.Field
mut mut_pos := -1 var mut_pos := -1
mut pub_pos := -1 var pub_pos := -1
mut pub_mut_pos := -1 var pub_mut_pos := -1
if !no_body { if !no_body {
p.check(.lcbr) p.check(.lcbr)
for p.tok.kind != .rcbr { for p.tok.kind != .rcbr {
mut comment := ast.Comment{} var comment := ast.Comment{}
if p.tok.kind == .comment { if p.tok.kind == .comment {
comment = p.comment() comment = p.comment()
} }
@ -1597,8 +1597,8 @@ fn (p mut Parser) struct_decl() ast.StructDecl {
println('XXXX' + s.str()) println('XXXX' + s.str())
} }
*/ */
mut default_expr := ast.Expr{} var default_expr := ast.Expr{}
mut has_default_expr := false var has_default_expr := false
if p.tok.kind == .assign { if p.tok.kind == .assign {
// Default value // Default value
p.next() p.next()
@ -1614,7 +1614,7 @@ fn (p mut Parser) struct_decl() ast.StructDecl {
} }
has_default_expr = true has_default_expr = true
} }
mut attr := ast.Attr{} var attr := ast.Attr{}
if p.tok.kind == .lsbr { if p.tok.kind == .lsbr {
attr = p.attribute() attr = p.attribute()
} }
@ -1654,7 +1654,7 @@ fn (p mut Parser) struct_decl() ast.StructDecl {
is_union: is_union is_union: is_union
} }
} }
mut ret := 0 var ret := 0
if p.builtin_mod && t.name in table.builtin_type_names { if p.builtin_mod && t.name in table.builtin_type_names {
// this allows overiding the builtins type // this allows overiding the builtins type
// with the real struct type info parsed from builtin // with the real struct type info parsed from builtin
@ -1687,7 +1687,7 @@ fn (p mut Parser) interface_decl() ast.InterfaceDecl {
p.next() // `interface` p.next() // `interface`
interface_name := p.check_name() interface_name := p.check_name()
p.check(.lcbr) p.check(.lcbr)
mut field_names := []string var field_names := []string
for p.tok.kind != .rcbr && p.tok.kind != .eof { for p.tok.kind != .rcbr && p.tok.kind != .eof {
line_nr := p.tok.line_nr line_nr := p.tok.line_nr
name := p.check_name() name := p.check_name()
@ -1707,7 +1707,7 @@ fn (p mut Parser) interface_decl() ast.InterfaceDecl {
fn (p mut Parser) return_stmt() ast.Return { fn (p mut Parser) return_stmt() ast.Return {
p.next() p.next()
// return expressions // return expressions
mut exprs := []ast.Expr var exprs := []ast.Expr
if p.tok.kind == .rcbr { if p.tok.kind == .rcbr {
return ast.Return{ return ast.Return{
pos: p.tok.position() 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` // left hand side of `=` or `:=` in `a,b,c := 1,2,3`
fn (p mut Parser) parse_assign_lhs() []ast.Ident { fn (p mut Parser) parse_assign_lhs() []ast.Ident {
mut idents := []ast.Ident var idents := []ast.Ident
for { for {
is_mut := p.tok.kind == .key_mut || p.tok.kind == .key_var is_mut := p.tok.kind == .key_mut || p.tok.kind == .key_var
if is_mut { if is_mut {
@ -1741,7 +1741,7 @@ fn (p mut Parser) parse_assign_lhs() []ast.Ident {
if is_static { if is_static {
p.check(.key_static) p.check(.key_static)
} }
mut ident := p.parse_ident(false) var ident := p.parse_ident(false)
ident.is_mut = is_mut ident.is_mut = is_mut
ident.info = ast.IdentVar{ ident.info = ast.IdentVar{
is_mut: is_mut 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` // right hand side of `=` or `:=` in `a,b,c := 1,2,3`
fn (p mut Parser) parse_assign_rhs() []ast.Expr { fn (p mut Parser) parse_assign_rhs() []ast.Expr {
mut exprs := []ast.Expr var exprs := []ast.Expr
for { for {
expr := p.expr(0) expr := p.expr(0)
exprs << expr exprs << expr
@ -1831,7 +1831,7 @@ fn (p mut Parser) global_decl() ast.GlobalDecl {
name := p.check_name() name := p.check_name()
// println(name) // println(name)
typ := p.parse_type() typ := p.parse_type()
mut expr := ast.Expr{} var expr := ast.Expr{}
has_expr := p.tok.kind == .assign has_expr := p.tok.kind == .assign
if has_expr { if has_expr {
p.next() p.next()
@ -1866,20 +1866,20 @@ fn (p mut Parser) match_expr() ast.MatchExpr {
match_first_pos := p.tok.position() match_first_pos := p.tok.position()
p.check(.key_match) p.check(.key_match)
is_mut := p.tok.kind in [.key_mut, .key_var] is_mut := p.tok.kind in [.key_mut, .key_var]
mut is_sum_type := false var is_sum_type := false
if is_mut { if is_mut {
p.next() p.next()
} }
cond := p.expr(0) cond := p.expr(0)
p.check(.lcbr) p.check(.lcbr)
mut branches := []ast.MatchBranch var branches := []ast.MatchBranch
for { for {
branch_first_pos := p.tok.position() branch_first_pos := p.tok.position()
comment := p.check_comment() // comment before {} comment := p.check_comment() // comment before {}
mut exprs := []ast.Expr var exprs := []ast.Expr
p.open_scope() p.open_scope()
// final else // final else
mut is_else := false var is_else := false
if p.tok.kind == .key_else { if p.tok.kind == .key_else {
is_else = true is_else = true
p.next() p.next()
@ -1893,7 +1893,7 @@ fn (p mut Parser) match_expr() ast.MatchExpr {
x := ast.Type{ x := ast.Type{
typ: typ typ: typ
} }
mut expr := ast.Expr{} var expr := ast.Expr{}
expr = x expr = x
exprs << expr exprs << expr
p.scope.register('it', ast.Var{ p.scope.register('it', ast.Var{
@ -1963,15 +1963,15 @@ fn (p mut Parser) enum_decl() ast.EnumDecl {
p.check(.key_enum) p.check(.key_enum)
name := p.prepend_mod(p.check_name()) name := p.prepend_mod(p.check_name())
p.check(.lcbr) p.check(.lcbr)
mut vals := []string var vals := []string
// mut default_exprs := []ast.Expr // mut default_exprs := []ast.Expr
mut fields := []ast.EnumField var fields := []ast.EnumField
for p.tok.kind != .eof && p.tok.kind != .rcbr { for p.tok.kind != .eof && p.tok.kind != .rcbr {
pos := p.tok.position() pos := p.tok.position()
val := p.check_name() val := p.check_name()
vals << val vals << val
mut expr := ast.Expr{} var expr := ast.Expr{}
mut has_expr := false var has_expr := false
// p.warn('enum val $val') // p.warn('enum val $val')
if p.tok.kind == .assign { if p.tok.kind == .assign {
p.next() p.next()
@ -2009,7 +2009,7 @@ fn (p mut Parser) type_decl() ast.TypeDecl {
} }
p.check(.key_type) p.check(.key_type)
name := p.check_name() name := p.check_name()
mut sum_variants := []table.Type var sum_variants := []table.Type
if p.tok.kind == .assign { if p.tok.kind == .assign {
p.next() // TODO require `=` p.next() // TODO require `=`
} }
@ -2075,8 +2075,8 @@ fn (p mut Parser) assoc() ast.Assoc {
return ast.Assoc{} return ast.Assoc{}
} }
// println('assoc var $name typ=$var.typ') // println('assoc var $name typ=$var.typ')
mut fields := []string var fields := []string
mut vals := []ast.Expr var vals := []ast.Expr
p.check(.pipe) p.check(.pipe)
for { for {
fields << p.check_name() fields << p.check_name()