fmt: use var instead of mut
Alexander Medvednikov
parent
efaec8be8e
commit
f34352faf9
|
|
@ -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(' {')
|
||||
|
|
|
|||
|
|
@ -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'
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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()
|
||||
|
|
|
|||
Loading…
Reference in New Issue