From 272eaaa704442a1d0b26cfc6817730db69230201 Mon Sep 17 00:00:00 2001 From: Joe Conigliaro Date: Thu, 5 Mar 2020 23:57:05 +1100 Subject: [PATCH] v2: remove type fields from parser & some cleanup --- vlib/v/ast/ast.v | 1 - vlib/v/checker/checker.v | 12 ++++---- vlib/v/parser/fn.v | 17 ------------ vlib/v/parser/parser.v | 60 ++++++++++------------------------------ 4 files changed, 21 insertions(+), 69 deletions(-) diff --git a/vlib/v/ast/ast.v b/vlib/v/ast/ast.v index 1ed878d9fe..b8f0e1db20 100644 --- a/vlib/v/ast/ast.v +++ b/vlib/v/ast/ast.v @@ -175,7 +175,6 @@ pub: pub struct Return { pub: pos token.Position - expected_type table.Type // TODO: remove once checker updated exprs []Expr } diff --git a/vlib/v/checker/checker.v b/vlib/v/checker/checker.v index 9566ab0a0a..373615bcaf 100644 --- a/vlib/v/checker/checker.v +++ b/vlib/v/checker/checker.v @@ -300,16 +300,11 @@ pub fn (c mut Checker) selector_expr(selector_expr ast.SelectorExpr) table.Type // TODO: non deferred pub fn (c mut Checker) return_stmt(return_stmt ast.Return) { - mut got_types := []table.Type c.expected_type = c.fn_return_type if return_stmt.exprs.len == 0 { return } - for expr in return_stmt.exprs { - typ := c.expr(expr) - got_types << typ - } - expected_type := return_stmt.expected_type + expected_type := c.fn_return_type expected_type_sym := c.table.get_type_symbol(expected_type) exp_is_optional := table.type_is_optional(expected_type) mut expected_types := [expected_type] @@ -317,6 +312,11 @@ pub fn (c mut Checker) return_stmt(return_stmt ast.Return) { mr_info := expected_type_sym.info as table.MultiReturn expected_types = mr_info.types } + mut got_types := []table.Type + for expr in return_stmt.exprs { + typ := c.expr(expr) + got_types << typ + } // allow `none` & `error (Option)` return types for function that returns optional if exp_is_optional && table.type_idx(got_types[0]) in [table.none_type_idx, c.table.type_idxs['Option']] { return diff --git a/vlib/v/parser/fn.v b/vlib/v/parser/fn.v index be8d058caa..39c1ddd2c9 100644 --- a/vlib/v/parser/fn.v +++ b/vlib/v/parser/fn.v @@ -120,28 +120,11 @@ fn (p mut Parser) fn_decl() ast.FnDecl { }) // p.table.register_var(var) } - // - /* - - arg := table.Var{ - name: arg_name - typ: arg_type - } - args << arg - // p.table.register_var(arg) - arg := table.Var{ - name: arg_name - typ: typ - } - args << arg - p.table.register_var(arg) - */ // Return type mut typ := table.void_type if p.tok.kind.is_start_of_type() { typ = p.parse_type() } - p.return_type = typ // Register if is_method { type_sym := p.table.get_type_symbol(rec_type) diff --git a/vlib/v/parser/parser.v b/vlib/v/parser/parser.v index 10fb9b2471..86feec4091 100644 --- a/vlib/v/parser/parser.v +++ b/vlib/v/parser/parser.v @@ -34,16 +34,13 @@ mut: peek_tok token.Token // vars []string table &table.Table - return_type table.Type // current function's return type is_c bool - // // prefix_parse_fns []PrefixParseFn inside_if bool pref &pref.Preferences // Preferences shared from V struct builtin_mod bool mod string expr_mod string - expected_type table.Type scope &ast.Scope imports map[string]string ast_imports []ast.Import @@ -482,20 +479,12 @@ pub fn (p mut Parser) parse_ident(is_c bool) ast.Ident { fn (p mut Parser) struct_init() ast.StructInit { typ := p.parse_type() p.expr_mod = '' - sym := p.table.get_type_symbol(typ) + // sym := p.table.get_type_symbol(typ) // p.warn('struct init typ=$sym.name') p.check(.lcbr) mut field_names := []string mut exprs := []ast.Expr mut i := 0 - // TODO `if sym.info is table.Struct` - mut is_struct := false - match sym.info { - table.Struct { - is_struct = true - } - else {} - } 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 { @@ -508,20 +497,6 @@ fn (p mut Parser) struct_init() ast.StructInit { field_name = p.check_name() field_names << field_name } - // Set expected type for this field's expression - // p.warn('$sym.name field $field_name') - if is_struct { - info := sym.info as table.Struct - if is_short_syntax {} - else { - field := sym.find_field(field_name) or { - p.error('field `${sym.name}.$field_name` not found') - continue - } - p.expected_type = field.typ - } - // p.warn('setting exp $field.typ') - } if !is_short_syntax { p.check(.colon) expr := p.expr(0) @@ -812,6 +787,13 @@ pub fn (p mut Parser) expr(precedence int) ast.Expr { } else if p.tok.kind.is_infix() { node = p.infix_expr(node) + match node { + ast.PrefixExpr { + println('IS PREFIX') + return node + } + else {} + } } // Postfix else if p.tok.kind in [.inc, .dec] { @@ -950,6 +932,12 @@ fn (p mut Parser) infix_expr(left ast.Expr) ast.Expr { precedence := p.tok.precedence() pos := p.tok.position() p.next() + if op == .mul && p.peek_tok.kind in [.assign, .decl_assign] { + return ast.PrefixExpr{ + op: op + right: p.expr(0) + } + } mut right := ast.Expr{} right = p.expr(precedence) mut expr := ast.Expr{} @@ -975,19 +963,6 @@ fn (p &Parser) is_addative() bool { fn (p mut Parser) enum_val() ast.EnumVal { p.check(.dot) val := p.check_name() - /* - if p.expected_type == 0 { - p.error('wtf') - } - */ - - /* - sym := p.table.get_type_symbol(p.expected_type) //or { - //return ast.EnumVal{val:val} - //} - p.warn(sym.name) - */ - return ast.EnumVal{ val: val pos: p.tok.position() @@ -1469,18 +1444,14 @@ fn (p mut Parser) return_stmt() ast.Return { p.next() // return expressions mut exprs := []ast.Expr - // return type idents - // mut got_tis := []table.Type - if table.type_idx(p.return_type) == table.void_type_idx { + if p.tok.kind == .rcbr { return ast.Return{ pos: p.tok.position() } } for { - // expr,ti := p.expr(0) expr := p.expr(0) exprs << expr - // got_tis << ti if p.tok.kind == .comma { p.check(.comma) } @@ -1489,7 +1460,6 @@ fn (p mut Parser) return_stmt() ast.Return { } } stmt := ast.Return{ - expected_type: p.return_type exprs: exprs pos: p.tok.position() }