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

checker: minor cleanup of selector_expr() (#10316)

pull/10341/head
yuyi 2021-06-03 21:49:50 +08:00 committed by GitHub
parent c8d5e783a3
commit f4486d79c3
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
1 changed files with 29 additions and 30 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

59
vlib/v/checker/checker.v
View File

@ -2822,21 +2822,21 @@ fn is_expr_panic_or_exit(expr ast.Expr) bool {
}
}
pub fn (mut c Checker) selector_expr(mut selector_expr ast.SelectorExpr) ast.Type {
pub fn (mut c Checker) selector_expr(mut node ast.SelectorExpr) ast.Type {
prevent_sum_type_unwrapping_once := c.prevent_sum_type_unwrapping_once
c.prevent_sum_type_unwrapping_once = false
using_new_err_struct_save := c.using_new_err_struct
// TODO remove; this avoids a breaking change in syntax
if '$selector_expr.expr' == 'err' {
if '$node.expr' == 'err' {
c.using_new_err_struct = true
}
// T.name, typeof(expr).name
mut name_type := 0
match mut selector_expr.expr {
match mut node.expr {
ast.Ident {
name := selector_expr.expr.name
name := node.expr.name
valid_generic := util.is_generic_type_name(name) && name in c.table.cur_fn.generic_names
if valid_generic {
name_type = ast.Type(c.table.find_type_idx(name)).set_flag(.generic)
@ -2845,22 +2845,21 @@ pub fn (mut c Checker) selector_expr(mut selector_expr ast.SelectorExpr) ast.Typ
// Note: in future typeof() should be a type known at compile-time
// sum types should not be handled dynamically
ast.TypeOf {
name_type = c.expr(selector_expr.expr.expr)
name_type = c.expr(node.expr.expr)
}
else {}
}
if name_type > 0 {
if selector_expr.field_name != 'name' {
c.error('invalid field `.$selector_expr.field_name` for type `$selector_expr.expr`',
selector_expr.pos)
if node.field_name != 'name' {
c.error('invalid field `.$node.field_name` for type `$node.expr`', node.pos)
}
selector_expr.name_type = name_type
node.name_type = name_type
return ast.string_type
}
//
old_selector_expr := c.inside_selector_expr
c.inside_selector_expr = true
typ := c.expr(selector_expr.expr)
typ := c.expr(node.expr)
c.inside_selector_expr = old_selector_expr
//
c.using_new_err_struct = using_new_err_struct_save
@ -2868,28 +2867,28 @@ pub fn (mut c Checker) selector_expr(mut selector_expr ast.SelectorExpr) ast.Typ
// This means that the variable's value was assigned to an
// unknown function or method, so the error was already handled
// earlier
// c.error('unknown selector expression', selector_expr.pos)
// c.error('unknown selector expression', node.pos)
return ast.void_type
}
selector_expr.expr_type = typ
if selector_expr.expr_type.has_flag(.optional) && !((selector_expr.expr is ast.Ident
&& (selector_expr.expr as ast.Ident).kind == .constant)) {
node.expr_type = typ
if node.expr_type.has_flag(.optional) && !((node.expr is ast.Ident
&& (node.expr as ast.Ident).kind == .constant)) {
c.error('cannot access fields of an optional, handle the error with `or {...}` or propagate it with `?`',
selector_expr.pos)
node.pos)
}
field_name := selector_expr.field_name
field_name := node.field_name
utyp := c.unwrap_generic(typ)
sym := c.table.get_type_symbol(utyp)
if (typ.has_flag(.variadic) || sym.kind == .array_fixed) && field_name == 'len' {
selector_expr.typ = ast.int_type
node.typ = ast.int_type
return ast.int_type
}
if sym.kind == .chan {
if field_name == 'closed' {
selector_expr.typ = ast.bool_type
node.typ = ast.bool_type
return ast.bool_type
} else if field_name in ['len', 'cap'] {
selector_expr.typ = ast.u32_type
node.typ = ast.u32_type
return ast.u32_type
}
}
@ -2903,7 +2902,7 @@ pub fn (mut c Checker) selector_expr(mut selector_expr ast.SelectorExpr) ast.Typ
for embed in sym_info.embeds {
embed_sym := c.table.get_type_symbol(embed)
if embed_sym.embed_name() == field_name {
selector_expr.typ = embed
node.typ = embed
return embed
}
}
@ -2926,9 +2925,9 @@ pub fn (mut c Checker) selector_expr(mut selector_expr ast.SelectorExpr) ast.Typ
if found_fields.len == 1 {
field = found_fields[0]
has_field = true
selector_expr.from_embed_type = embed_of_found_fields[0]
node.from_embed_type = embed_of_found_fields[0]
} else if found_fields.len > 1 {
c.error('ambiguous field `$field_name`', selector_expr.pos)
c.error('ambiguous field `$field_name`', node.pos)
}
}
if sym.kind in [.aggregate, .sum_type] {
@ -2937,38 +2936,38 @@ pub fn (mut c Checker) selector_expr(mut selector_expr ast.SelectorExpr) ast.Typ
}
if !c.inside_unsafe {
if sym.info is ast.Struct {
if sym.info.is_union && selector_expr.next_token !in token.assign_tokens {
if sym.info.is_union && node.next_token !in token.assign_tokens {
c.warn('reading a union field (or its address) requires `unsafe`',
selector_expr.pos)
node.pos)
}
}
}
}
if has_field {
if sym.mod != c.mod && !field.is_pub && sym.language != .c {
c.error('field `${sym.name}.$field_name` is not public', selector_expr.pos)
c.error('field `${sym.name}.$field_name` is not public', node.pos)
}
field_sym := c.table.get_type_symbol(field.typ)
if field_sym.kind in [.sum_type, .interface_] {
if !prevent_sum_type_unwrapping_once {
if scope_field := selector_expr.scope.find_struct_field(utyp, field_name) {
if scope_field := node.scope.find_struct_field(utyp, field_name) {
return scope_field.smartcasts.last()
}
}
}
selector_expr.typ = field.typ
node.typ = field.typ
return field.typ
}
if sym.kind !in [.struct_, .aggregate, .interface_, .sum_type] {
if sym.kind != .placeholder {
c.error('`$sym.name` has no property `$selector_expr.field_name`', selector_expr.pos)
c.error('`$sym.name` has no property `$node.field_name`', node.pos)
}
} else {
if sym.info is ast.Struct {
suggestion := util.new_suggestion(field_name, sym.info.fields.map(it.name))
c.error(suggestion.say(unknown_field_msg), selector_expr.pos)
c.error(suggestion.say(unknown_field_msg), node.pos)
}
c.error(unknown_field_msg, selector_expr.pos)
c.error(unknown_field_msg, node.pos)
}
return ast.void_type
}