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: cleanup in fn.v (#18958)

Browse Source
This commit is contained in:
yuyi 2023-07-25 05:12:43 +08:00 committed by GitHub
parent c6ddbd308e
commit b29f3caeec
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
1 changed files with 44 additions and 48 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

92
vlib/v/checker/fn.v
View File

@ -893,16 +893,14 @@ fn (mut c Checker) fn_call(mut node ast.CallExpr, mut continue_check &bool) ast.
if typ != 0 {
generic_vts := c.table.final_sym(typ)
if generic_vts.kind == .function {
info := generic_vts.info as ast.FnType
func = info.func
if generic_vts.info is ast.FnType {
func = generic_vts.info.func
found = true
found_in_args = true
} else {
vts := c.table.sym(c.unwrap_generic(typ))
if vts.kind == .function {
info := vts.info as ast.FnType
func = info.func
if vts.info is ast.FnType {
func = vts.info.func
found = true
found_in_args = true
}
@ -914,8 +912,8 @@ fn (mut c Checker) fn_call(mut node ast.CallExpr, mut continue_check &bool) ast.
if obj := c.file.global_scope.find(fn_name) {
if obj.typ != 0 {
sym := c.table.sym(obj.typ)
if sym.kind == .function {
func = (sym.info as ast.FnType).func
if sym.info is ast.FnType {
func = sym.info.func
found = true
}
}
@ -931,13 +929,13 @@ fn (mut c Checker) fn_call(mut node ast.CallExpr, mut continue_check &bool) ast.
}
if obj.typ != 0 {
sym := c.table.sym(obj.typ)
if sym.kind == .function {
if sym.info is ast.FnType {
// at this point, the const metadata should be already known,
// and we are sure that it is just a function
c.table.fns[qualified_const_name].usages++
c.table.fns[func.name].usages++
found = true
func = (sym.info as ast.FnType).func
func = sym.info.func
node.is_fn_a_const = true
node.fn_var_type = obj.typ
node.const_name = qualified_const_name
@ -1053,9 +1051,8 @@ fn (mut c Checker) fn_call(mut node ast.CallExpr, mut continue_check &bool) ast.
if func.is_variadic && i >= func.params.len - 1 {
param_sym := c.table.sym(param.typ)
mut expected_type := param.typ
if param_sym.kind == .array {
info := param_sym.array_info()
expected_type = info.elem_type
if param_sym.info is ast.Array {
expected_type = param_sym.info.elem_type
c.expected_type = expected_type
}
typ := c.expr(mut call_arg.expr)
@ -1196,18 +1193,17 @@ fn (mut c Checker) fn_call(mut node ast.CallExpr, mut continue_check &bool) ast.
if param.typ.has_flag(.generic) {
continue
}
if param_typ_sym.kind == .array && arg_typ_sym.kind == .array {
param_info := param_typ_sym.info as ast.Array
param_elem_type := c.table.unaliased_type(param_info.elem_type)
arg_info := arg_typ_sym.info as ast.Array
arg_elem_type := c.table.unaliased_type(arg_info.elem_type)
if param_typ_sym.info is ast.Array && arg_typ_sym.info is ast.Array {
param_elem_type := c.table.unaliased_type(param_typ_sym.info.elem_type)
arg_elem_type := c.table.unaliased_type(arg_typ_sym.info.elem_type)
param_nr_muls := param.typ.nr_muls()
arg_nr_muls := if call_arg.is_mut {
arg_typ.nr_muls() + 1
} else {
arg_typ.nr_muls()
}
if param_nr_muls == arg_nr_muls && param_info.nr_dims == arg_info.nr_dims
if param_nr_muls == arg_nr_muls
&& param_typ_sym.info.nr_dims == arg_typ_sym.info.nr_dims
&& param_elem_type == arg_elem_type {
continue
}
@ -1255,24 +1251,27 @@ fn (mut c Checker) fn_call(mut node ast.CallExpr, mut continue_check &bool) ast.
if param_type.is_any_kind_of_pointer() && arg_typ.is_any_kind_of_pointer() {
continue
}
param_typ_sym_ := c.table.sym(c.table.unaliased_type(param_type))
arg_typ_sym_ := c.table.sym(c.table.unaliased_type(arg_typ))
unaliased_param_sym := c.table.sym(c.table.unaliased_type(param_type))
unaliased_arg_sym := c.table.sym(c.table.unaliased_type(arg_typ))
// Allow `[32]i8` as `&i8` etc
if ((arg_typ_sym_.kind == .array_fixed || arg_typ_sym_.kind == .array)
if ((unaliased_arg_sym.kind == .array_fixed || unaliased_arg_sym.kind == .array)
&& (param_is_number
|| c.table.unaliased_type(param_type).is_any_kind_of_pointer()))
|| ((param_typ_sym_.kind == .array_fixed || param_typ_sym_.kind == .array)
|| ((unaliased_param_sym.kind == .array_fixed
|| unaliased_param_sym.kind == .array)
&& (typ_is_number || c.table.unaliased_type(arg_typ).is_any_kind_of_pointer())) {
continue
}
// Allow `[N]anyptr` as `[N]anyptr`
if arg_typ_sym_.kind == .array && param_typ_sym_.kind == .array {
if (arg_typ_sym_.info as ast.Array).elem_type.is_any_kind_of_pointer()
&& (param_typ_sym_.info as ast.Array).elem_type.is_any_kind_of_pointer() {
if unaliased_arg_sym.info is ast.Array && unaliased_param_sym.info is ast.Array {
if unaliased_arg_sym.info.elem_type.is_any_kind_of_pointer()
&& unaliased_param_sym.info.elem_type.is_any_kind_of_pointer() {
continue
}
} else if arg_typ_sym_.kind == .array_fixed && param_typ_sym_.kind == .array_fixed {
if (arg_typ_sym_.info as ast.ArrayFixed).elem_type.is_any_kind_of_pointer()&& (param_typ_sym_.info as ast.ArrayFixed).elem_type.is_any_kind_of_pointer() {
} else if unaliased_arg_sym.info is ast.ArrayFixed
&& unaliased_param_sym.info is ast.ArrayFixed {
if unaliased_arg_sym.info.elem_type.is_any_kind_of_pointer()
&& unaliased_param_sym.info.elem_type.is_any_kind_of_pointer() {
continue
}
}
@ -1417,9 +1416,9 @@ fn (mut c Checker) get_comptime_args(func ast.Fn, node_ ast.CallExpr, concrete_t
mut ctyp := c.get_comptime_var_type(call_arg.expr)
if ctyp != ast.void_type {
arg_sym := c.table.sym(ctyp)
if arg_sym.kind == .array && param_typ.has_flag(.generic)
if arg_sym.info is ast.Array && param_typ.has_flag(.generic)
&& c.table.final_sym(param_typ).kind == .array {
ctyp = (arg_sym.info as ast.Array).elem_type
ctyp = arg_sym.info.elem_type
}
comptime_args[i] = ctyp
}
@ -1432,9 +1431,9 @@ fn (mut c Checker) get_comptime_args(func ast.Fn, node_ ast.CallExpr, concrete_t
if param_typ.has_flag(.variadic) {
ctyp = ast.mktyp(ctyp)
comptime_args[i] = ctyp
} else if arg_sym.kind == .array && param_typ.has_flag(.generic)
} else if arg_sym.info is ast.Array && param_typ.has_flag(.generic)
&& param_typ_sym.kind == .array {
ctyp = c.get_generic_array_element_type(arg_sym.info as ast.Array)
ctyp = c.get_generic_array_element_type(arg_sym.info)
comptime_args[i] = ctyp
} else if arg_sym.kind in [.struct_, .interface_, .sum_type] {
mut generic_types := []ast.Type{}
@ -1458,9 +1457,9 @@ fn (mut c Checker) get_comptime_args(func ast.Fn, node_ ast.CallExpr, concrete_t
}
}
} else if arg_sym.kind == .any {
mut cparam_type_sym := c.table.sym(c.unwrap_generic(ctyp))
if param_typ_sym.kind == .array && cparam_type_sym.kind == .array {
ctyp = (cparam_type_sym.info as ast.Array).elem_type
cparam_type_sym := c.table.sym(c.unwrap_generic(ctyp))
if param_typ_sym.kind == .array && cparam_type_sym.info is ast.Array {
ctyp = cparam_type_sym.info.elem_type
comptime_args[i] = ctyp
} else {
if node_.args[i].expr.is_auto_deref_var() {
@ -1528,20 +1527,18 @@ fn (mut c Checker) resolve_fn_generic_args(func ast.Fn, mut node ast.CallExpr) [
// cast_fixed_array_ret casts a ArrayFixed type created to return to a non returning one
fn (mut c Checker) cast_fixed_array_ret(typ ast.Type, sym ast.TypeSymbol) ast.Type {
if sym.kind == .array_fixed && (sym.info as ast.ArrayFixed).is_fn_ret {
info := sym.info as ast.ArrayFixed
return c.table.find_or_register_array_fixed(info.elem_type, info.size, info.size_expr,
false)
if sym.info is ast.ArrayFixed && sym.info.is_fn_ret {
return c.table.find_or_register_array_fixed(sym.info.elem_type, sym.info.size,
sym.info.size_expr, false)
}
return typ
}
// cast_to_fixed_array_ret casts a ArrayFixed type created to do not return to a returning one
fn (mut c Checker) cast_to_fixed_array_ret(typ ast.Type, sym ast.TypeSymbol) ast.Type {
if sym.kind == .array_fixed && !(sym.info as ast.ArrayFixed).is_fn_ret {
info := sym.info as ast.ArrayFixed
return c.table.find_or_register_array_fixed(info.elem_type, info.size, info.size_expr,
true)
if sym.info is ast.ArrayFixed && !sym.info.is_fn_ret {
return c.table.find_or_register_array_fixed(sym.info.elem_type, sym.info.size,
sym.info.size_expr, true)
}
return typ
}
@ -1634,7 +1631,7 @@ fn (mut c Checker) method_call(mut node ast.CallExpr) ast.Type {
if !c.check_types(arg_type, info.elem_type) && !c.check_types(left_type, arg_type) {
c.error('cannot ${method_name} `${arg_sym.name}` to `${left_sym.name}`', arg_expr.pos())
}
} else if final_left_sym.info is ast.Array && method_name in ['first', 'last', 'pop'] {
} else if final_left_sym.kind == .array && method_name in ['first', 'last', 'pop'] {
return c.array_builtin_method_call(mut node, left_type, final_left_sym)
} else if c.pref.backend.is_js() && left_sym.name.starts_with('Promise[')
&& method_name == 'wait' {
@ -1648,13 +1645,12 @@ fn (mut c Checker) method_call(mut node ast.CallExpr) ast.Type {
node.return_type = info.concrete_types[0]
node.return_type.set_flag(.option)
return node.return_type
} else if left_sym.kind == .thread && method_name == 'wait' {
info := left_sym.info as ast.Thread
} else if left_sym.info is ast.Thread && method_name == 'wait' {
if node.args.len > 0 {
c.error('wait() does not have any arguments', node.args[0].pos)
}
node.return_type = info.return_type
return info.return_type
node.return_type = left_sym.info.return_type
return left_sym.info.return_type
} else if left_sym.kind == .char && left_type.nr_muls() == 0 && method_name == 'str' {
c.error('calling `.str()` on type `char` is not allowed, use its address or cast it to an integer instead',
node.left.pos().extend(node.pos))