mirror/v
1
0
Fork 0
mirror of https://github.com/vlang/v.git synced 2023-08-10 21:13:21 +03:00
Code Issues Projects Releases Wiki Activity

checker: minor cleanup of struct_init() (#10310)

Browse Source
This commit is contained in:
yuyi 2021-06-03 14:48:19 +08:00 committed by GitHub
parent 4089aa38c5
commit 86d70fade7
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
1 changed files with 54 additions and 54 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

108
vlib/v/checker/checker.v
View File

@ -670,43 +670,44 @@ fn (mut c Checker) unwrap_generic_struct(struct_type ast.Type, generic_names []s
return struct_type
}
pub fn (mut c Checker) struct_init(mut struct_init ast.StructInit) ast.Type {
if struct_init.typ == ast.void_type {
pub fn (mut c Checker) struct_init(mut node ast.StructInit) ast.Type {
if node.typ == ast.void_type {
// Short syntax `({foo: bar})`
if c.expected_type == ast.void_type {
c.error('unexpected short struct syntax', struct_init.pos)
c.error('unexpected short struct syntax', node.pos)
return ast.void_type
}
sym := c.table.get_type_symbol(c.expected_type)
if sym.kind == .array {
struct_init.typ = c.table.value_type(c.expected_type)
node.typ = c.table.value_type(c.expected_type)
} else {
struct_init.typ = c.expected_type
node.typ = c.expected_type
}
}
struct_sym := c.table.get_type_symbol(struct_init.typ)
struct_sym := c.table.get_type_symbol(node.typ)
if struct_sym.info is ast.Struct {
if struct_sym.info.generic_types.len > 0 && struct_sym.info.concrete_types.len == 0
&& c.table.cur_concrete_types.len == 0 {
c.error('generic struct init must specify type parameter, e.g. Foo<int>',
struct_init.pos)
node.pos)
}
} else if struct_sym.info is ast.Alias {
parent_sym := c.table.get_type_symbol(struct_sym.info.parent_type)
// e.g. ´x := MyMapAlias{}´, should be a cast to alias type ´x := MyMapAlias(map[...]...)´
if parent_sym.kind == .map {
alias_str := c.table.type_to_str(struct_init.typ)
alias_str := c.table.type_to_str(node.typ)
map_str := c.table.type_to_str(struct_sym.info.parent_type)
c.error('direct map alias init is not possible, use `${alias_str}($map_str{})` instead',
struct_init.pos)
node.pos)
return ast.void_type
}
}
utyp := c.unwrap_generic_struct(struct_init.typ, c.table.cur_fn.generic_names, c.table.cur_concrete_types)
c.ensure_type_exists(utyp, struct_init.pos) or {}
type_sym := c.table.get_type_symbol(utyp)
unwrapped_struct_type := c.unwrap_generic_struct(node.typ, c.table.cur_fn.generic_names,
c.table.cur_concrete_types)
c.ensure_type_exists(unwrapped_struct_type, node.pos) or {}
type_sym := c.table.get_type_symbol(unwrapped_struct_type)
if !c.inside_unsafe && type_sym.kind == .sum_type {
c.note('direct sum type init (`x := SumType{}`) will be removed soon', struct_init.pos)
c.note('direct sum type init (`x := SumType{}`) will be removed soon', node.pos)
}
// Make sure the first letter is capital, do not allow e.g. `x := string{}`,
// but `x := T{}` is ok.
@ -715,43 +716,42 @@ pub fn (mut c Checker) struct_init(mut struct_init ast.StructInit) ast.Type {
pos := type_sym.name.last_index('.') or { -1 }
first_letter := type_sym.name[pos + 1]
if !first_letter.is_capital() {
c.error('cannot initialize builtin type `$type_sym.name`', struct_init.pos)
c.error('cannot initialize builtin type `$type_sym.name`', node.pos)
}
}
if type_sym.kind == .sum_type && struct_init.fields.len == 1 {
sexpr := struct_init.fields[0].expr.str()
if type_sym.kind == .sum_type && node.fields.len == 1 {
sexpr := node.fields[0].expr.str()
c.error('cast to sum type using `${type_sym.name}($sexpr)` not `$type_sym.name{$sexpr}`',
struct_init.pos)
node.pos)
}
if type_sym.kind == .interface_ {
c.error('cannot instantiate interface `$type_sym.name`', struct_init.pos)
c.error('cannot instantiate interface `$type_sym.name`', node.pos)
}
if type_sym.info is ast.Alias {
if type_sym.info.parent_type.is_number() {
c.error('cannot instantiate number type alias `$type_sym.name`', struct_init.pos)
c.error('cannot instantiate number type alias `$type_sym.name`', node.pos)
return ast.void_type
}
}
// allow init structs from generic if they're private except the type is from builtin module
if !type_sym.is_public && type_sym.kind != .placeholder && type_sym.language != .c
&& (type_sym.mod != c.mod && !(struct_init.typ.has_flag(.generic)
&& type_sym.mod != 'builtin')) {
c.error('type `$type_sym.name` is private', struct_init.pos)
&& (type_sym.mod != c.mod && !(node.typ.has_flag(.generic) && type_sym.mod != 'builtin')) {
c.error('type `$type_sym.name` is private', node.pos)
}
if type_sym.kind == .struct_ {
info := type_sym.info as ast.Struct
if info.attrs.len > 0 && info.attrs[0].name == 'noinit' && type_sym.mod != c.mod {
c.error('struct `$type_sym.name` is declared with a `[noinit]` attribute, so ' +
'it cannot be initialized with `$type_sym.name{}`', struct_init.pos)
'it cannot be initialized with `$type_sym.name{}`', node.pos)
}
}
if type_sym.name.len == 1 && c.table.cur_fn.generic_names.len == 0 {
c.error('unknown struct `$type_sym.name`', struct_init.pos)
c.error('unknown struct `$type_sym.name`', node.pos)
return 0
}
match type_sym.kind {
.placeholder {
c.error('unknown struct: $type_sym.name', struct_init.pos)
c.error('unknown struct: $type_sym.name', node.pos)
return ast.void_type
}
// string & array are also structs but .kind of string/array
@ -761,33 +761,33 @@ pub fn (mut c Checker) struct_init(mut struct_init ast.StructInit) ast.Type {
info_t := type_sym.info as ast.Alias
sym := c.table.get_type_symbol(info_t.parent_type)
if sym.kind == .placeholder { // pending import symbol did not resolve
c.error('unknown struct: $type_sym.name', struct_init.pos)
c.error('unknown struct: $type_sym.name', node.pos)
return ast.void_type
}
if sym.kind == .struct_ {
info = sym.info as ast.Struct
} else {
c.error('alias type name: $sym.name is not struct type', struct_init.pos)
c.error('alias type name: $sym.name is not struct type', node.pos)
}
} else {
info = type_sym.info as ast.Struct
}
if struct_init.is_short {
if node.is_short {
exp_len := info.fields.len
got_len := struct_init.fields.len
got_len := node.fields.len
if exp_len != got_len {
amount := if exp_len < got_len { 'many' } else { 'few' }
c.error('too $amount fields in `$type_sym.name` literal (expecting $exp_len, got $got_len)',
struct_init.pos)
node.pos)
}
}
mut inited_fields := []string{}
for i, field in struct_init.fields {
for i, field in node.fields {
mut info_field := ast.StructField{}
mut embed_type := ast.Type(0)
mut is_embed := false
mut field_name := ''
if struct_init.is_short {
if node.is_short {
if i >= info.fields.len {
// It doesn't make sense to check for fields that don't exist.
// We should just stop here.
@ -795,7 +795,7 @@ pub fn (mut c Checker) struct_init(mut struct_init ast.StructInit) ast.Type {
}
info_field = info.fields[i]
field_name = info_field.name
struct_init.fields[i].name = field_name
node.fields[i].name = field_name
} else {
field_name = field.name
mut exists := false
@ -841,8 +841,8 @@ pub fn (mut c Checker) struct_init(mut struct_init ast.StructInit) ast.Type {
field.pos)
}
}
struct_init.fields[i].typ = expr_type
struct_init.fields[i].expected_type = embed_type
node.fields[i].typ = expr_type
node.fields[i].expected_type = embed_type
} else {
inited_fields << field_name
field_type_sym := c.table.get_type_symbol(info_field.typ)
@ -873,8 +873,8 @@ pub fn (mut c Checker) struct_init(mut struct_init ast.StructInit) ast.Type {
field.pos)
}
}
struct_init.fields[i].typ = expr_type
struct_init.fields[i].expected_type = info_field.typ
node.fields[i].typ = expr_type
node.fields[i].expected_type = info_field.typ
}
if expr_type.is_ptr() && expected_type.is_ptr() {
if mut field.expr is ast.Ident {
@ -904,23 +904,23 @@ pub fn (mut c Checker) struct_init(mut struct_init ast.StructInit) ast.Type {
if field.has_default_expr || field.name in inited_fields {
continue
}
if field.typ.is_ptr() && !field.typ.has_flag(.shared_f)
&& !struct_init.has_update_expr && !c.pref.translated {
if field.typ.is_ptr() && !field.typ.has_flag(.shared_f) && !node.has_update_expr
&& !c.pref.translated {
c.error('reference field `${type_sym.name}.$field.name` must be initialized',
struct_init.pos)
node.pos)
}
// Do not allow empty uninitialized sum types
/*
sym := c.table.get_type_symbol(field.typ)
if sym.kind == .sum_type {
c.warn('sum type field `${type_sym.name}.$field.name` must be initialized',
struct_init.pos)
node.pos)
}
*/
// Check for `[required]` struct attr
if field.attrs.contains('required') && !struct_init.is_short {
if field.attrs.contains('required') && !node.is_short {
mut found := false
for init_field in struct_init.fields {
for init_field in node.fields {
if field.name == init_field.name {
found = true
break
@ -928,37 +928,37 @@ pub fn (mut c Checker) struct_init(mut struct_init ast.StructInit) ast.Type {
}
if !found {
c.error('field `${type_sym.name}.$field.name` must be initialized',
struct_init.pos)
node.pos)
}
}
}
}
else {}
}
if struct_init.has_update_expr {
update_type := c.expr(struct_init.update_expr)
struct_init.update_expr_type = update_type
if node.has_update_expr {
update_type := c.expr(node.update_expr)
node.update_expr_type = update_type
if c.table.type_kind(update_type) != .struct_ {
s := c.table.type_to_str(update_type)
c.error('expected struct, found `$s`', struct_init.update_expr.position())
} else if update_type != struct_init.typ {
c.error('expected struct, found `$s`', node.update_expr.position())
} else if update_type != node.typ {
from_sym := c.table.get_type_symbol(update_type)
to_sym := c.table.get_type_symbol(struct_init.typ)
to_sym := c.table.get_type_symbol(node.typ)
from_info := from_sym.info as ast.Struct
to_info := to_sym.info as ast.Struct
// TODO this check is too strict
if !c.check_struct_signature(from_info, to_info) {
c.error('struct `$from_sym.name` is not compatible with struct `$to_sym.name`',
struct_init.update_expr.position())
node.update_expr.position())
}
}
if !struct_init.update_expr.is_lvalue() {
if !node.update_expr.is_lvalue() {
// cgen will repeat `update_expr` for each field
// so enforce an lvalue for efficiency
c.error('expression is not an lvalue', struct_init.update_expr.position())
c.error('expression is not an lvalue', node.update_expr.position())
}
}
return utyp
return unwrapped_struct_type
}
fn (mut c Checker) check_div_mod_by_zero(expr ast.Expr, op_kind token.Kind) {