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

vfmt: handle for ;; loops; run vfmt on parser.v

pull/4282/head
Alexander Medvednikov 2020-04-07 15:48:13 +02:00
parent 8f9a8e1e7f
commit 275b20a184
2 changed files with 171 additions and 216 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
vlib/v/fmt/fmt.v
View File

@ -132,7 +132,9 @@ fn (f mut Fmt) stmt(node ast.Stmt) {
f.write(', ') f.write(', ')
} }
} }
f.writeln('') if !f.single_line_if {
f.writeln('')
}
f.is_assign = false f.is_assign = false
} }
ast.Attr { ast.Attr {
@ -207,6 +209,21 @@ fn (f mut Fmt) stmt(node ast.Stmt) {
f.writeln('\n') f.writeln('\n')
} }
} }
ast.ForCStmt {
f.write('for ')
if it.has_init {
f.single_line_if = true // to keep all for ;; exprs on the same line
f.stmt(it.init)
f.single_line_if = false
}
f.write('; ')
f.expr(it.cond)
f.write('; ')
f.expr(it.inc)
f.writeln('{ ')
f.stmts(it.stmts)
f.writeln('}')
}
ast.ForInStmt { ast.ForInStmt {
f.write('for ') f.write('for ')
if it.key_var != '' { if it.key_var != '' {
@ -294,8 +311,10 @@ fn (f mut Fmt) stmt(node ast.Stmt) {
f.writeln('}') f.writeln('}')
} }
else { else {
eprintln('fmt stmt: unknown node: ' + typeof(node)) eprintln('fmt stmt: unhandled node ' + typeof(node))
// exit(1) if typeof(node) != 'unknown v.ast.Expr' {
exit(1)
}
} }
} }
} }

362
vlib/v/parser/parser.v
View File

@ -15,42 +15,40 @@ import (
) )
struct Parser { struct Parser {
scanner &scanner.Scanner scanner &scanner.Scanner
file_name string file_name string
mut: mut:
tok token.Token tok token.Token
peek_tok token.Token peek_tok token.Token
table &table.Table table &table.Table
is_c bool is_c bool
inside_if bool inside_if bool
pref &pref.Preferences pref &pref.Preferences
builtin_mod bool builtin_mod bool
mod string mod string
attr string attr string
expr_mod string expr_mod string
scope &ast.Scope scope &ast.Scope
global_scope &ast.Scope global_scope &ast.Scope
imports map[string]string imports map[string]string
ast_imports []ast.Import ast_imports []ast.Import
is_amp bool is_amp bool
returns bool returns bool
inside_match_case bool // to separate `match_expr { }` from `Struct{}` inside_match_case bool // to separate `match_expr { }` from `Struct{}`
//comments []ast.Comment
} }
// 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{ mut p := parser.Parser{
scanner: s scanner: s
table: table table: table
pref: &pref.Preferences{} pref: &pref.Preferences{}
scope: scope scope: scope
// scope: &ast.Scope{start_pos: 0, parent: 0}
global_scope: &ast.Scope{ global_scope: &ast.Scope{
start_pos: 0 start_pos: 0
parent: 0 parent: 0
} }
} }
p.init_parse_fns() p.init_parse_fns()
p.read_first_token() p.read_first_token()
@ -63,22 +61,23 @@ pub fn parse_file(path string, table &table.Table, comments_mode scanner.Comment
// panic(err) // panic(err)
// } // }
mut stmts := []ast.Stmt mut stmts := []ast.Stmt
mut p := Parser{ mut p := parser.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
pref: pref pref: pref
scope: &ast.Scope{ scope: &ast.Scope{
start_pos: 0 start_pos: 0
parent: 0 parent: 0
} }
global_scope: global_scope global_scope: global_scope
} }
// comments_mode: comments_mode // comments_mode: comments_mode
p.read_first_token() p.read_first_token()
// module decl // module decl
module_decl := if p.tok.kind == .key_module { p.module_decl() } else { ast.Module{name: 'main' module_decl := if p.tok.kind == .key_module { p.module_decl() } else { ast.Module{
} } name: 'main'
} }
p.mod = module_decl.name p.mod = module_decl.name
p.builtin_mod = p.mod == 'builtin' p.builtin_mod = p.mod == 'builtin'
// imports // imports
@ -87,9 +86,9 @@ pub fn parse_file(path string, table &table.Table, comments_mode scanner.Comment
for p.tok.kind == .key_import { for p.tok.kind == .key_import {
imports << p.import_stmt() imports << p.import_stmt()
} }
*/ */
// TODO: import only mode // TODO: import only mode
for { for {
// res := s.scan() // res := s.scan()
if p.tok.kind == .eof { if p.tok.kind == .eof {
// println('EOF, breaking') // println('EOF, breaking')
@ -108,7 +107,6 @@ pub fn parse_file(path string, table &table.Table, comments_mode scanner.Comment
stmts: stmts stmts: stmts
scope: p.scope scope: p.scope
global_scope: p.global_scope global_scope: p.global_scope
//comments: p.comments
} }
} }
@ -138,8 +136,6 @@ fn (q mut Queue) run() {
q.mu.unlock() q.mu.unlock()
} }
*/ */
pub fn parse_files(paths []string, table &table.Table, pref &pref.Preferences, global_scope &ast.Scope) []ast.File { pub fn parse_files(paths []string, table &table.Table, pref &pref.Preferences, global_scope &ast.Scope) []ast.File {
/* /*
println('\n\n\nparse_files()') println('\n\n\nparse_files()')
@ -155,8 +151,7 @@ pub fn parse_files(paths []string, table &table.Table, pref &pref.Preferences, g
} }
time.sleep_ms(100) time.sleep_ms(100)
return q.parsed_ast_files return q.parsed_ast_files
*/ */
// /////////////// // ///////////////
mut files := []ast.File mut files := []ast.File
for path in paths { for path in paths {
@ -204,7 +199,7 @@ pub fn (p mut Parser) parse_block_no_scope() []ast.Stmt {
p.check(.lcbr) p.check(.lcbr)
mut stmts := []ast.Stmt mut stmts := []ast.Stmt
if p.tok.kind != .rcbr { if p.tok.kind != .rcbr {
for { for {
stmts << p.stmt() stmts << p.stmt()
// p.warn('after stmt(): tok=$p.tok.str()') // p.warn('after stmt(): tok=$p.tok.str()')
if p.tok.kind in [.eof, .rcbr] { if p.tok.kind in [.eof, .rcbr] {
@ -222,8 +217,6 @@ fn (p mut Parser) next_with_comment() {
p.peek_tok = p.scanner.scan() p.peek_tok = p.scanner.scan()
} }
*/ */
fn (p mut Parser) next() { fn (p mut Parser) next() {
p.tok = p.peek_tok p.tok = p.peek_tok
p.peek_tok = p.scanner.scan() p.peek_tok = p.scanner.scan()
@ -232,7 +225,7 @@ fn (p mut Parser) next() {
p.comments << ast.Comment{text:p.tok.lit, line_nr:p.tok.line_nr} p.comments << ast.Comment{text:p.tok.lit, line_nr:p.tok.line_nr}
p.next() p.next()
} }
*/ */
} }
fn (p mut Parser) check(expected token.Kind) { fn (p mut Parser) check(expected token.Kind) {
@ -278,7 +271,7 @@ pub fn (p mut Parser) top_stmt() ast.Stmt {
p.error('wrong pub keyword usage') p.error('wrong pub keyword usage')
return ast.Stmt{} return ast.Stmt{}
} }
} }
} }
.lsbr { .lsbr {
return p.attribute() return p.attribute()
@ -344,7 +337,7 @@ pub fn (p mut Parser) comment() ast.Comment {
pos := p.tok.position() pos := p.tok.position()
text := p.tok.lit text := p.tok.lit
p.next() p.next()
//p.next_with_comment() // p.next_with_comment()
return ast.Comment{ return ast.Comment{
text: text text: text
pos: pos pos: pos
@ -409,10 +402,10 @@ pub fn (p mut Parser) stmt() ast.Stmt {
.key_go { .key_go {
p.next() p.next()
expr := p.expr(0) expr := p.expr(0)
//mut call_expr := &ast.CallExpr(0) // TODO // mut call_expr := &ast.CallExpr(0) // TODO
match expr { match expr {
ast.CallExpr { ast.CallExpr {
//call_expr = it // call_expr = it
} }
else { else {
p.error('expression in `go` must be a function call') p.error('expression in `go` must be a function call')
@ -433,8 +426,7 @@ pub fn (p mut Parser) stmt() ast.Stmt {
// `x := ...` // `x := ...`
if p.tok.kind == .name && p.peek_tok.kind in [.decl_assign, .comma] { if p.tok.kind == .name && p.peek_tok.kind in [.decl_assign, .comma] {
return p.assign_stmt() return p.assign_stmt()
} } else if p.tok.kind == .name && p.peek_tok.kind == .colon {
else if p.tok.kind == .name && p.peek_tok.kind == .colon {
// `label:` // `label:`
name := p.check_name() name := p.check_name()
p.check(.colon) p.check(.colon)
@ -457,10 +449,10 @@ pub fn (p mut Parser) assign_expr(left ast.Expr) ast.AssignExpr {
val := p.expr(0) val := p.expr(0)
match left { match left {
ast.IndexExpr { ast.IndexExpr {
//it.mark_as_setter() // it.mark_as_setter()
it.is_setter = true it.is_setter = true
} }
else{} else {}
} }
node := ast.AssignExpr{ node := ast.AssignExpr{
left: left left: left
@ -505,8 +497,6 @@ fn (p mut Parser) range_expr(low ast.Expr) ast.Expr {
return node return node
} }
*/ */
pub fn (p &Parser) error(s string) { pub fn (p &Parser) error(s string) {
mut kind := 'error:' mut kind := 'error:'
if p.pref.is_verbose { if p.pref.is_verbose {
@ -558,7 +548,7 @@ fn (p mut Parser) struct_init(short_syntax bool) ast.StructInit {
mut field_names := []string mut field_names := []string
mut exprs := []ast.Expr mut exprs := []ast.Expr
mut i := 0 mut 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()
@ -566,8 +556,7 @@ fn (p mut Parser) struct_init(short_syntax bool) ast.StructInit {
if is_short_syntax { if is_short_syntax {
expr := p.expr(0) expr := p.expr(0)
exprs << expr exprs << expr
} } else {
else {
field_name = p.check_name() field_name = p.check_name()
field_names << field_name field_names << field_name
} }
@ -614,11 +603,11 @@ pub fn (p mut Parser) name_expr() ast.Expr {
return p.string_expr() return p.string_expr()
} }
known_var := p.scope.known_var(p.tok.lit) known_var := p.scope.known_var(p.tok.lit)
if p.peek_tok.kind == .dot && !known_var && (is_c || p.known_import(p.tok.lit) || p.mod.all_after('.') == p.tok.lit) { if p.peek_tok.kind == .dot && !known_var && (is_c || p.known_import(p.tok.lit) || p.mod.all_after('.') ==
p.tok.lit) {
if is_c { if is_c {
mod = 'C' mod = 'C'
} } else {
else {
// prepend the full import // prepend the full import
mod = p.imports[p.tok.lit] mod = p.imports[p.tok.lit]
} }
@ -651,7 +640,7 @@ pub fn (p mut Parser) name_expr() ast.Expr {
// 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 {
p.check(.comma) p.check(.comma)
arg = p.expr(0) // len arg = p.expr(0) // len
has_arg = true has_arg = true
} }
p.check(.rpar) p.check(.rpar)
@ -663,29 +652,23 @@ pub fn (p mut Parser) name_expr() ast.Expr {
} }
p.expr_mod = '' p.expr_mod = ''
return node return node
} } else {
else {
// fn call // fn call
// println('calling $p.tok.lit') // println('calling $p.tok.lit')
x := p.call_expr(is_c, mod) // TODO `node,typ :=` should work x := p.call_expr(is_c, mod) // TODO `node,typ :=` should work
node = x node = x
} }
} } else if p.peek_tok.kind == .lcbr && (p.tok.lit[0].is_capital() || is_c || (p.builtin_mod && p.tok.lit in
else if p.peek_tok.kind == .lcbr && (p.tok.lit[0].is_capital() || is_c || table.builtin_type_names)) && (p.tok.lit.len in [1, 2] || !p.tok.lit[p.tok.lit.len - 1].is_capital()) &&
(p.builtin_mod && p.tok.lit in table.builtin_type_names)) && !p.inside_match_case {
(p.tok.lit.len in [1,2] || !p.tok.lit[p.tok.lit.len - 1].is_capital()) &&
!p.inside_match_case
{
// || p.table.known_type(p.tok.lit)) { // || p.table.known_type(p.tok.lit)) {
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() mut enum_name := p.check_name()
if mod != '' { if mod != '' {
enum_name = mod + '.' + enum_name enum_name = mod + '.' + enum_name
} } else {
else {
enum_name = p.prepend_mod(enum_name) enum_name = p.prepend_mod(enum_name)
} }
// p.warn('Color.green $enum_name ' + p.prepend_mod(enum_name) + 'mod=$mod') // p.warn('Color.green $enum_name ' + p.prepend_mod(enum_name) + 'mod=$mod')
@ -694,14 +677,12 @@ pub fn (p mut Parser) name_expr() ast.Expr {
// println('enum val $enum_name . $val') // println('enum val $enum_name . $val')
p.expr_mod = '' p.expr_mod = ''
return ast.EnumVal{ return ast.EnumVal{
enum_name: enum_name // lp.prepend_mod(enum_name) enum_name: enum_name
val: val val: val
pos: p.tok.position() pos: p.tok.position()
mod: mod mod: mod
} }
} } else {
else {
mut ident := ast.Ident{} mut ident := ast.Ident{}
ident = p.parse_ident(is_c) ident = p.parse_ident(is_c)
node = ident node = ident
@ -714,11 +695,11 @@ pub fn (p mut Parser) expr(precedence int) ast.Expr {
// println('\n\nparser.expr()') // println('\n\nparser.expr()')
mut typ := table.void_type mut typ := table.void_type
mut node := ast.Expr{} mut node := ast.Expr{}
//defer { // defer {
//if p.tok.kind == .comment { // if p.tok.kind == .comment {
//p.comment() // p.comment()
//} // }
//} // }
// Prefix // Prefix
match p.tok.kind { match p.tok.kind {
.name { .name {
@ -772,7 +753,7 @@ pub fn (p mut Parser) expr(precedence int) ast.Expr {
node = ast.None{} node = ast.None{}
} }
.key_sizeof { .key_sizeof {
p.next() // sizeof p.next() // sizeof
p.check(.lpar) p.check(.lpar)
if p.tok.kind == .amp { if p.tok.kind == .amp {
p.next() p.next()
@ -805,15 +786,12 @@ pub fn (p mut Parser) expr(precedence int) ast.Expr {
p.next() p.next()
if p.tok.kind == .string { if p.tok.kind == .string {
node = p.map_init() node = p.map_init()
} } else {
else {
if p.peek_tok.kind == .pipe { if p.peek_tok.kind == .pipe {
node = p.assoc() node = p.assoc()
} } else if p.peek_tok.kind == .colon || p.tok.kind == .rcbr {
else if p.peek_tok.kind == .colon || p.tok.kind == .rcbr { node = p.struct_init(true) // short_syntax: true
node = p.struct_init(true) // short_syntax: true } else {
}
else {
p.error('unexpected {') p.error('unexpected {')
} }
} }
@ -830,14 +808,11 @@ pub fn (p mut Parser) expr(precedence int) ast.Expr {
for precedence < p.tok.precedence() { for precedence < p.tok.precedence() {
if p.tok.kind.is_assign() { if p.tok.kind.is_assign() {
node = p.assign_expr(node) node = p.assign_expr(node)
} } else if p.tok.kind == .dot {
else if p.tok.kind == .dot {
node = p.dot_expr(node) node = p.dot_expr(node)
} } else if p.tok.kind == .lsbr {
else if p.tok.kind == .lsbr {
node = p.index_expr(node) node = p.index_expr(node)
} } else if p.tok.kind == .key_as {
else if p.tok.kind == .key_as {
pos := p.tok.position() pos := p.tok.position()
p.next() p.next()
typ = p.parse_type() typ = p.parse_type()
@ -846,8 +821,7 @@ pub fn (p mut Parser) expr(precedence int) ast.Expr {
typ: typ typ: typ
pos: pos pos: pos
} }
} } else if p.tok.kind == .left_shift {
else if p.tok.kind == .left_shift {
// TODO: handle in later stages since this // TODO: handle in later stages since this
// will fudge left shift as it makes it right assoc // will fudge left shift as it makes it right assoc
// `arr << 'a'` | `arr << 'a' + 'b'` // `arr << 'a'` | `arr << 'a' + 'b'`
@ -860,11 +834,9 @@ pub fn (p mut Parser) expr(precedence int) ast.Expr {
op: tok.kind op: tok.kind
pos: tok.position() pos: tok.position()
} }
} } else if p.tok.kind.is_infix() {
else if p.tok.kind.is_infix() {
node = p.infix_expr(node) node = p.infix_expr(node)
} } else if p.tok.kind in [.inc, .dec] {
else if p.tok.kind in [.inc, .dec] {
// Postfix // Postfix
node = ast.PostfixExpr{ node = ast.PostfixExpr{
op: p.tok.kind op: p.tok.kind
@ -873,8 +845,7 @@ pub fn (p mut Parser) expr(precedence int) ast.Expr {
} }
p.next() p.next()
// return node // TODO bring back, only allow ++/-- in exprs in translated code // return node // TODO bring back, only allow ++/-- in exprs in translated code
} } else {
else {
return node return node
} }
} }
@ -899,7 +870,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 mut has_low := true
if p.tok.kind == .dotdot { if p.tok.kind == .dotdot {
has_low = false has_low = false
@ -911,13 +882,13 @@ fn (p mut Parser) index_expr(left ast.Expr) ast.IndexExpr {
left: left left: left
pos: p.tok.position() pos: p.tok.position()
index: ast.RangeExpr{ index: ast.RangeExpr{
low: ast.Expr{} low: ast.Expr{}
high: high high: high
has_high: true has_high: true
} }
} }
} }
expr := p.expr(0) // `[expr]` or `[expr..]` expr := p.expr(0) // `[expr]` or `[expr..]`
mut has_high := false mut has_high := false
if p.tok.kind == .dotdot { if p.tok.kind == .dotdot {
// [start..end] or [start..] // [start..end] or [start..]
@ -932,11 +903,11 @@ fn (p mut Parser) index_expr(left ast.Expr) ast.IndexExpr {
left: left left: left
pos: p.tok.position() pos: p.tok.position()
index: ast.RangeExpr{ index: ast.RangeExpr{
low: expr low: expr
high: high high: high
has_high: has_high has_high: has_high
has_low: has_low has_low: has_low
} }
} }
} }
// [expr] // [expr]
@ -993,8 +964,8 @@ fn (p mut Parser) dot_expr(left ast.Expr) ast.Expr {
pos: pos pos: pos
is_method: true is_method: true
or_block: ast.OrExpr{ or_block: ast.OrExpr{
stmts: or_stmts stmts: or_stmts
} }
} }
mut node := ast.Expr{} mut node := ast.Expr{}
node = mcall_expr node = mcall_expr
@ -1029,8 +1000,6 @@ fn (p mut Parser) infix_expr(left ast.Expr) ast.Expr {
expr = ast.InfixExpr{ expr = ast.InfixExpr{
left: left left: left
right: right right: right
// right_type: typ
op: op op: op
pos: pos pos: pos
} }
@ -1069,12 +1038,10 @@ fn (p mut Parser) for_statement() ast.Stmt {
pos: pos pos: pos
is_inf: true is_inf: true
} }
} } else if p.tok.kind == .key_mut {
else if p.tok.kind == .key_mut {
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{} mut init := ast.Stmt{}
mut cond := p.new_true_expr() mut cond := p.new_true_expr()
// mut inc := ast.Stmt{} // mut inc := ast.Stmt{}
@ -1083,18 +1050,10 @@ fn (p mut Parser) for_statement() ast.Stmt {
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
} else if p.tok.kind != .semicolon {
} }
else if p.tok.kind != .semicolon {}
// allow `for ;; i++ {` // allow `for ;; i++ {`
// Allow `for i = 0; i < ...` // Allow `for i = 0; i < ...`
/*
cond, typ = p.expr(0)
if typ.kind != _bool {
p.error('non-bool used as for condition')
}
*/
// println(1)
// }
p.check(.semicolon) p.check(.semicolon)
if p.tok.kind != .semicolon { if p.tok.kind != .semicolon {
mut typ := table.void_type mut typ := table.void_type
@ -1115,8 +1074,7 @@ fn (p mut Parser) for_statement() ast.Stmt {
inc: inc inc: inc
pos: pos pos: pos
} }
} } 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 := '' mut key_var_name := ''
mut val_var_name := p.check_name() mut val_var_name := p.check_name()
@ -1145,8 +1103,7 @@ fn (p mut Parser) for_statement() ast.Stmt {
name: val_var_name name: val_var_name
typ: table.int_type typ: table.int_type
}) })
} } else {
else {
// this type will be set in checker // this type will be set in checker
p.scope.register(val_var_name, ast.Var{ p.scope.register(val_var_name, ast.Var{
name: val_var_name name: val_var_name
@ -1186,17 +1143,15 @@ fn (p mut Parser) if_expr() ast.IfExpr {
mut comment := ast.Comment{} mut 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 { // if p.tok.kind == .comment {
//if p.tok.kind == .comment { // p.error('place comments inside {}')
//p.error('place comments inside {}') // }
//} // comment = p.check_comment()
//comment = p.check_comment()
p.check(.key_else) p.check(.key_else)
if p.tok.kind == .key_if { if p.tok.kind == .key_if {
p.check(.key_if) p.check(.key_if)
} } else {
else {
has_else = true has_else = true
branches << ast.IfBranch{ branches << ast.IfBranch{
stmts: p.parse_block() stmts: p.parse_block()
@ -1223,8 +1178,7 @@ fn (p mut Parser) if_expr() ast.IfExpr {
var_name: var_name var_name: var_name
expr: expr expr: expr
} }
} } else {
else {
cond = p.expr(0) cond = p.expr(0)
} }
p.inside_if = false p.inside_if = false
@ -1236,7 +1190,7 @@ fn (p mut Parser) if_expr() ast.IfExpr {
cond: cond cond: cond
stmts: stmts stmts: stmts
pos: branch_pos pos: branch_pos
comment: ast.Comment{}// comment comment: ast.Comment{}
} }
if p.tok.kind != .key_else { if p.tok.kind != .key_else {
break break
@ -1325,16 +1279,15 @@ fn (p mut Parser) array_init() ast.ArrayInit {
idx := p.table.find_or_register_array(elem_type, 1) idx := p.table.find_or_register_array(elem_type, 1)
array_type = table.new_type(idx) array_type = table.new_type(idx)
} }
} } else {
else {
// [1,2,3] // [1,2,3]
for i := 0; p.tok.kind != .rsbr; i++ { for i := 0; p.tok.kind != .rsbr; i++{
expr := p.expr(0) expr := p.expr(0)
exprs << expr exprs << expr
if p.tok.kind == .comma { if p.tok.kind == .comma {
p.check(.comma) p.check(.comma)
} }
//p.check_comment() // p.check_comment()
} }
line_nr := p.tok.line_nr line_nr := p.tok.line_nr
p.check(.rsbr) p.check(.rsbr)
@ -1386,11 +1339,9 @@ fn (p mut Parser) parse_number_literal() ast.Expr {
mut node := ast.Expr{} mut node := ast.Expr{}
if lit.contains('.') { if lit.contains('.') {
node = ast.FloatLiteral{ node = ast.FloatLiteral{
// val: lit.f64()
val: lit val: lit
} }
} } else {
else {
node = ast.IntegerLiteral{ node = ast.IntegerLiteral{
val: lit val: lit
} }
@ -1444,8 +1395,7 @@ fn (p mut Parser) import_stmt() []ast.Import {
} }
} }
p.check(.rpar) p.check(.rpar)
} } else {
else {
imports << p.parse_import() imports << p.parse_import()
} }
return imports return imports
@ -1473,14 +1423,13 @@ fn (p mut Parser) const_decl() ast.ConstDecl {
name: name name: name
expr: expr expr: expr
pos: p.tok.position() pos: p.tok.position()
} }
fields << field fields << field
p.global_scope.register(field.name, field) p.global_scope.register(field.name, field)
} }
p.check(.rpar) p.check(.rpar)
return ast.ConstDecl{ return ast.ConstDecl{
pos : pos pos: pos
fields: fields fields: fields
is_pub: is_pub is_pub: is_pub
} }
@ -1494,14 +1443,13 @@ fn (p mut Parser) struct_decl() ast.StructDecl {
} }
if p.tok.kind == .key_struct { if p.tok.kind == .key_struct {
p.check(.key_struct) p.check(.key_struct)
} } else {
else {
p.check(.key_union) p.check(.key_union)
} }
is_c := p.tok.lit == 'C' && p.peek_tok.kind == .dot is_c := p.tok.lit == 'C' && p.peek_tok.kind == .dot
if is_c { if is_c {
p.next() // C p.next() // C
p.next() // . p.next() // .
} }
is_typedef := p.attr == 'typedef' is_typedef := p.attr == 'typedef'
mut name := p.check_name() mut name := p.check_name()
@ -1512,7 +1460,6 @@ fn (p mut Parser) struct_decl() ast.StructDecl {
mut mut_pos := -1 mut mut_pos := -1
mut pub_pos := -1 mut pub_pos := -1
mut pub_mut_pos := -1 mut pub_mut_pos := -1
for p.tok.kind != .rcbr { for p.tok.kind != .rcbr {
mut comment := ast.Comment{} mut comment := ast.Comment{}
if p.tok.kind == .comment { if p.tok.kind == .comment {
@ -1523,18 +1470,15 @@ fn (p mut Parser) struct_decl() ast.StructDecl {
if p.tok.kind == .key_mut { if p.tok.kind == .key_mut {
p.check(.key_mut) p.check(.key_mut)
pub_mut_pos = fields.len pub_mut_pos = fields.len
} } else {
else {
pub_pos = fields.len pub_pos = fields.len
} }
p.check(.colon) p.check(.colon)
} } else if p.tok.kind == .key_mut {
else if p.tok.kind == .key_mut {
p.check(.key_mut) p.check(.key_mut)
p.check(.colon) p.check(.colon)
mut_pos = fields.len mut_pos = fields.len
} } else if p.tok.kind == .key_global {
else if p.tok.kind == .key_global {
p.check(.key_global) p.check(.key_global)
p.check(.colon) p.check(.colon)
} }
@ -1547,14 +1491,14 @@ fn (p mut Parser) struct_decl() ast.StructDecl {
s := p.table.get_type_symbol(typ) s := p.table.get_type_symbol(typ)
println('XXXX' + s.str()) println('XXXX' + s.str())
} }
*/ */
mut default_expr := '' // ast.Expr{} mut default_expr := '' // ast.Expr{}
if p.tok.kind == .assign { if p.tok.kind == .assign {
// Default value // Default value
p.next() p.next()
default_expr = p.tok.lit default_expr = p.tok.lit
p.expr(0) p.expr(0)
//default_expr = p.expr(0) // default_expr = p.expr(0)
} }
if p.tok.kind == .comment { if p.tok.kind == .comment {
comment = p.comment() comment = p.comment()
@ -1576,25 +1520,23 @@ fn (p mut Parser) struct_decl() ast.StructDecl {
p.check(.rcbr) p.check(.rcbr)
if is_c { if is_c {
name = 'C.$name' name = 'C.$name'
} } else {
else {
name = p.prepend_mod(name) name = p.prepend_mod(name)
} }
t := table.TypeSymbol{ t := table.TypeSymbol{
kind: .struct_ kind: .struct_
name: name name: name
info: table.Struct{ info: table.Struct{
fields: fields fields: fields
is_typedef: is_typedef is_typedef: is_typedef
} }
} }
mut ret := 0 mut 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
ret = p.table.register_builtin_type_symbol(t) ret = p.table.register_builtin_type_symbol(t)
} } else {
else {
ret = p.table.register_type_symbol(t) ret = p.table.register_type_symbol(t)
} }
if ret == -1 { if ret == -1 {
@ -1618,7 +1560,7 @@ fn (p mut Parser) interface_decl() ast.InterfaceDecl {
if is_pub { if is_pub {
p.next() p.next()
} }
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 mut field_names := []string
@ -1647,13 +1589,12 @@ fn (p mut Parser) return_stmt() ast.Return {
pos: p.tok.position() pos: p.tok.position()
} }
} }
for { for {
expr := p.expr(0) expr := p.expr(0)
exprs << expr exprs << expr
if p.tok.kind == .comma { if p.tok.kind == .comma {
p.check(.comma) p.check(.comma)
} } else {
else {
break break
} }
} }
@ -1667,7 +1608,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 mut idents := []ast.Ident
for { for {
is_mut := p.tok.kind == .key_mut is_mut := p.tok.kind == .key_mut
if is_mut { if is_mut {
p.check(.key_mut) p.check(.key_mut)
@ -1684,8 +1625,7 @@ fn (p mut Parser) parse_assign_lhs() []ast.Ident {
idents << ident idents << ident
if p.tok.kind == .comma { if p.tok.kind == .comma {
p.check(.comma) p.check(.comma)
} } else {
else {
break break
} }
} }
@ -1695,13 +1635,12 @@ 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 mut exprs := []ast.Expr
for { for {
expr := p.expr(0) expr := p.expr(0)
exprs << expr exprs << expr
if p.tok.kind == .comma { if p.tok.kind == .comma {
p.check(.comma) p.check(.comma)
} } else {
else {
break break
} }
} }
@ -1716,7 +1655,7 @@ fn (p mut Parser) assign_stmt() ast.Stmt {
idents := p.parse_assign_lhs() idents := p.parse_assign_lhs()
pos := p.tok.position() pos := p.tok.position()
op := p.tok.kind op := p.tok.kind
p.next() // :=, = p.next() // :=, =
exprs := p.parse_assign_rhs() exprs := p.parse_assign_rhs()
is_decl := op == .decl_assign is_decl := op == .decl_assign
for i, ident in idents { for i, ident in idents {
@ -1736,8 +1675,7 @@ fn (p mut Parser) assign_stmt() ast.Stmt {
name: ident.name name: ident.name
expr: exprs[i] expr: exprs[i]
}) })
} } else {
else {
p.scope.register(ident.name, ast.Var{ p.scope.register(ident.name, ast.Var{
name: ident.name name: ident.name
}) })
@ -1771,7 +1709,8 @@ fn (p mut Parser) hash() ast.HashStmt {
} }
fn (p mut Parser) global_decl() ast.GlobalDecl { fn (p mut Parser) global_decl() ast.GlobalDecl {
if !p.pref.translated && !p.pref.is_live && !p.builtin_mod && !p.pref.building_v && p.mod != 'ui' && p.mod != 'gg2' && p.mod != 'uiold' && !os.getwd().contains('/volt') && !p.pref.enable_globals { if !p.pref.translated && !p.pref.is_live && !p.builtin_mod && !p.pref.building_v && p.mod != 'ui' &&
p.mod != 'gg2' && p.mod != 'uiold' && !os.getwd().contains('/volt') && !p.pref.enable_globals {
p.error('use `v --enable-globals ...` to enable globals') p.error('use `v --enable-globals ...` to enable globals')
} }
p.next() p.next()
@ -1796,8 +1735,7 @@ fn (p mut Parser) global_decl() ast.GlobalDecl {
if !p.cgen.nogen { if !p.cgen.nogen {
p.cgen.consts << g p.cgen.consts << g
} }
*/ */
glob := ast.GlobalDecl{ glob := ast.GlobalDecl{
name: name name: name
typ: typ typ: typ
@ -1818,8 +1756,8 @@ fn (p mut Parser) match_expr() ast.MatchExpr {
p.check(.lcbr) p.check(.lcbr)
mut branches := []ast.MatchBranch mut branches := []ast.MatchBranch
mut have_final_else := false mut have_final_else := false
for { for {
comment := p.check_comment() // comment before {} comment := p.check_comment() // comment before {}
mut exprs := []ast.Expr mut exprs := []ast.Expr
branch_pos := p.tok.position() branch_pos := p.tok.position()
p.open_scope() p.open_scope()
@ -1827,10 +1765,9 @@ fn (p mut Parser) match_expr() ast.MatchExpr {
if p.tok.kind == .key_else { if p.tok.kind == .key_else {
have_final_else = true have_final_else = true
p.next() p.next()
} } else if p.tok.kind == .name && (p.tok.lit in table.builtin_type_names || p.tok.lit[0].is_capital() ||
// Sum type match p.peek_tok.kind == .dot) {
else if p.tok.kind == .name && // Sum type match
(p.tok.lit in table.builtin_type_names || p.tok.lit[0].is_capital() || p.peek_tok.kind == .dot) {
// if sym.kind == .sum_type { // if sym.kind == .sum_type {
// p.warn('is sum') // p.warn('is sum')
// TODO `exprs << ast.Type{...}` // TODO `exprs << ast.Type{...}`
@ -1851,10 +1788,9 @@ fn (p mut Parser) match_expr() ast.MatchExpr {
p.parse_type() p.parse_type()
} }
is_sum_type = true is_sum_type = true
} } else {
else {
// Expression match // Expression match
for { for {
p.inside_match_case = true p.inside_match_case = true
expr := p.expr(0) expr := p.expr(0)
p.inside_match_case = false p.inside_match_case = false
@ -1922,8 +1858,8 @@ fn (p mut Parser) enum_decl() ast.EnumDecl {
kind: .enum_ kind: .enum_
name: name name: name
info: table.Enum{ info: table.Enum{
vals: vals vals: vals
} }
}) })
return ast.EnumDecl{ return ast.EnumDecl{
name: name name: name
@ -1944,7 +1880,7 @@ fn (p mut Parser) type_decl() ast.TypeDecl {
if p.tok.kind == .assign { if p.tok.kind == .assign {
// type SumType = A | B | c // type SumType = A | B | c
p.next() p.next()
for { for {
variant_type := p.parse_type() variant_type := p.parse_type()
sum_variants << variant_type sum_variants << variant_type
if p.tok.kind != .pipe { if p.tok.kind != .pipe {
@ -1956,8 +1892,8 @@ fn (p mut Parser) type_decl() ast.TypeDecl {
kind: .sum_type kind: .sum_type
name: p.prepend_mod(name) name: p.prepend_mod(name)
info: table.SumType{ info: table.SumType{
variants: sum_variants variants: sum_variants
} }
}) })
return ast.SumTypeDecl{ return ast.SumTypeDecl{
name: name name: name
@ -1983,8 +1919,8 @@ fn (p mut Parser) type_decl() ast.TypeDecl {
name: p.prepend_mod(name) name: p.prepend_mod(name)
parent_idx: pid parent_idx: pid
info: table.Alias{ info: table.Alias{
foo: '' foo: ''
} }
}) })
return ast.AliasTypeDecl{ return ast.AliasTypeDecl{
name: name name: name
@ -1993,7 +1929,7 @@ fn (p mut Parser) type_decl() ast.TypeDecl {
} }
} }
fn (p mut Parser) assoc() ast.Assoc{ fn (p mut Parser) assoc() ast.Assoc {
var_name := p.check_name() var_name := p.check_name()
pos := p.tok.position() pos := p.tok.position()
var := p.scope.find_var(var_name) or { var := p.scope.find_var(var_name) or {
@ -2004,7 +1940,7 @@ fn (p mut Parser) assoc() ast.Assoc{
mut fields := []string mut fields := []string
mut vals := []ast.Expr mut vals := []ast.Expr
p.check(.pipe) p.check(.pipe)
for { for {
fields << p.check_name() fields << p.check_name()
p.check(.colon) p.check(.colon)
expr := p.expr(0) expr := p.expr(0)