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: clean up infer_struct_generic_types() and infer_fn_generic_types() (#17668)

Browse Source
This commit is contained in:
yuyi
2023-03-18 04:46:56 +08:00
committed by GitHub
parent 9e7aeec215
commit 24ea00da0c
1 changed files with 78 additions and 99 deletions
Download Patch File Download Diff File Expand all files Collapse all files

177
vlib/v/checker/check_types.v
View File

@@ -676,25 +676,22 @@ fn (mut c Checker) infer_struct_generic_types(typ ast.Type, node ast.StructInit)
} }
} }
} }
if field_sym.kind == .array { if field_sym.info is ast.Array {
for t in node.fields { for t in node.fields {
if ft.name == t.name { if ft.name == t.name {
init_sym := c.table.sym(t.typ) init_sym := c.table.sym(t.typ)
if init_sym.kind == .array { if init_sym.info is ast.Array {
mut init_elem_info := init_sym.info as ast.Array mut init_elem_typ, mut field_elem_typ := init_sym.info.elem_type, field_sym.info.elem_type
mut field_elem_info := field_sym.info as ast.Array mut init_elem_sym, mut field_elem_sym := c.table.sym(init_elem_typ), c.table.sym(field_elem_typ)
mut init_elem_sym := c.table.sym(init_elem_info.elem_type)
mut field_elem_sym := c.table.sym(field_elem_info.elem_type)
for { for {
if init_elem_sym.kind == .array && field_elem_sym.kind == .array { if mut init_elem_sym.info is ast.Array
init_elem_info = init_elem_sym.info as ast.Array && mut field_elem_sym.info is ast.Array {
init_elem_sym = c.table.sym(init_elem_info.elem_type) init_elem_typ, field_elem_typ = init_elem_sym.info.elem_type, field_elem_sym.info.elem_type
field_elem_info = field_elem_sym.info as ast.Array init_elem_sym, field_elem_sym = c.table.sym(init_elem_typ), c.table.sym(field_elem_typ)
field_elem_sym = c.table.sym(field_elem_info.elem_type)
} else { } else {
if field_elem_sym.name == gt_name { if field_elem_sym.name == gt_name {
mut elem_typ := init_elem_info.elem_type mut elem_typ := init_elem_typ
if field_elem_info.elem_type.nr_muls() > 0 if field_elem_typ.nr_muls() > 0
&& elem_typ.nr_muls() > 0 { && elem_typ.nr_muls() > 0 {
elem_typ = elem_typ.set_nr_muls(0) elem_typ = elem_typ.set_nr_muls(0)
} }
@@ -707,26 +704,22 @@ fn (mut c Checker) infer_struct_generic_types(typ ast.Type, node ast.StructInit)
} }
} }
} }
} else if field_sym.kind == .array_fixed { } else if field_sym.info is ast.ArrayFixed {
for t in node.fields { for t in node.fields {
if ft.name == t.name { if ft.name == t.name {
init_sym := c.table.sym(t.typ) init_sym := c.table.sym(t.typ)
if init_sym.kind == .array_fixed { if init_sym.info is ast.ArrayFixed {
mut init_elem_info := init_sym.info as ast.ArrayFixed mut init_elem_typ, mut field_elem_typ := init_sym.info.elem_type, field_sym.info.elem_type
mut field_elem_info := field_sym.info as ast.ArrayFixed mut init_elem_sym, mut field_elem_sym := c.table.sym(init_elem_typ), c.table.sym(field_elem_typ)
mut init_elem_sym := c.table.sym(init_elem_info.elem_type)
mut field_elem_sym := c.table.sym(field_elem_info.elem_type)
for { for {
if init_elem_sym.kind == .array_fixed if mut init_elem_sym.info is ast.ArrayFixed
&& field_elem_sym.kind == .array_fixed { && mut field_elem_sym.info is ast.ArrayFixed {
init_elem_info = init_elem_sym.info as ast.ArrayFixed init_elem_typ, field_elem_typ = init_elem_sym.info.elem_type, field_elem_sym.info.elem_type
init_elem_sym = c.table.sym(init_elem_info.elem_type) init_elem_sym, field_elem_sym = c.table.sym(init_elem_typ), c.table.sym(field_elem_typ)
field_elem_info = field_elem_sym.info as ast.ArrayFixed
field_elem_sym = c.table.sym(field_elem_info.elem_type)
} else { } else {
if field_elem_sym.name == gt_name { if field_elem_sym.name == gt_name {
mut elem_typ := init_elem_info.elem_type mut elem_typ := init_elem_typ
if field_elem_info.elem_type.nr_muls() > 0 if field_elem_typ.nr_muls() > 0
&& elem_typ.nr_muls() > 0 { && elem_typ.nr_muls() > 0 {
elem_typ = elem_typ.set_nr_muls(0) elem_typ = elem_typ.set_nr_muls(0)
} }
@@ -739,27 +732,25 @@ fn (mut c Checker) infer_struct_generic_types(typ ast.Type, node ast.StructInit)
} }
} }
} }
} else if field_sym.kind == .map { } else if field_sym.info is ast.Map {
for t in node.fields { for t in node.fields {
if ft.name == t.name { if ft.name == t.name {
init_sym := c.table.sym(t.typ) init_sym := c.table.sym(t.typ)
if init_sym.kind == .map { if init_sym.info is ast.Map {
init_map_info := init_sym.info as ast.Map if field_sym.info.key_type.has_flag(.generic)
field_map_info := field_sym.info as ast.Map && c.table.sym(field_sym.info.key_type).name == gt_name {
if field_map_info.key_type.has_flag(.generic) mut key_typ := init_sym.info.key_type
&& c.table.sym(field_map_info.key_type).name == gt_name { if field_sym.info.key_type.nr_muls() > 0
mut key_typ := init_map_info.key_type
if field_map_info.key_type.nr_muls() > 0
&& key_typ.nr_muls() > 0 { && key_typ.nr_muls() > 0 {
key_typ = key_typ.set_nr_muls(0) key_typ = key_typ.set_nr_muls(0)
} }
concrete_types << key_typ concrete_types << key_typ
continue gname continue gname
} }
if field_map_info.value_type.has_flag(.generic) if field_sym.info.value_type.has_flag(.generic)
&& c.table.sym(field_map_info.value_type).name == gt_name { && c.table.sym(field_sym.info.value_type).name == gt_name {
mut val_typ := init_map_info.value_type mut val_typ := init_sym.info.value_type
if field_map_info.value_type.nr_muls() > 0 if field_sym.info.value_type.nr_muls() > 0
&& val_typ.nr_muls() > 0 { && val_typ.nr_muls() > 0 {
val_typ = val_typ.set_nr_muls(0) val_typ = val_typ.set_nr_muls(0)
} }
@@ -769,18 +760,16 @@ fn (mut c Checker) infer_struct_generic_types(typ ast.Type, node ast.StructInit)
} }
} }
} }
} else if field_sym.kind == .function { } else if field_sym.info is ast.FnType {
for t in node.fields { for t in node.fields {
if ft.name == t.name { if ft.name == t.name {
init_sym := c.table.sym(t.typ) init_sym := c.table.sym(t.typ)
if init_sym.kind == .function { if init_sym.info is ast.FnType {
init_type_func := (init_sym.info as ast.FnType).func if field_sym.info.func.params.len == init_sym.info.func.params.len {
field_type_func := (field_sym.info as ast.FnType).func for n, fn_param in field_sym.info.func.params {
if field_type_func.params.len == init_type_func.params.len {
for n, fn_param in field_type_func.params {
if fn_param.typ.has_flag(.generic) if fn_param.typ.has_flag(.generic)
&& c.table.sym(fn_param.typ).name == gt_name { && c.table.sym(fn_param.typ).name == gt_name {
mut arg_typ := init_type_func.params[n].typ mut arg_typ := init_sym.info.func.params[n].typ
if fn_param.typ.nr_muls() > 0 && arg_typ.nr_muls() > 0 { if fn_param.typ.nr_muls() > 0 && arg_typ.nr_muls() > 0 {
arg_typ = arg_typ.set_nr_muls(0) arg_typ = arg_typ.set_nr_muls(0)
} }
@@ -788,10 +777,10 @@ fn (mut c Checker) infer_struct_generic_types(typ ast.Type, node ast.StructInit)
continue gname continue gname
} }
} }
if field_type_func.return_type.has_flag(.generic) if field_sym.info.func.return_type.has_flag(.generic)
&& c.table.sym(field_type_func.return_type).name == gt_name { && c.table.sym(field_sym.info.func.return_type).name == gt_name {
mut ret_typ := init_type_func.return_type mut ret_typ := init_sym.info.func.return_type
if field_type_func.return_type.nr_muls() > 0 if field_sym.info.func.return_type.nr_muls() > 0
&& ret_typ.nr_muls() > 0 { && ret_typ.nr_muls() > 0 {
ret_typ = ret_typ.set_nr_muls(0) ret_typ = ret_typ.set_nr_muls(0)
} }
@@ -861,9 +850,9 @@ fn (mut c Checker) infer_fn_generic_types(func ast.Fn, mut node ast.CallExpr) {
break break
} }
arg := node.args[arg_i] arg := node.args[arg_i]
param_type_sym := c.table.sym(param.typ) param_sym := c.table.sym(param.typ)
if param.typ.has_flag(.generic) && param_type_sym.name == gt_name { if param.typ.has_flag(.generic) && param_sym.name == gt_name {
typ = ast.mktyp(arg.typ) typ = ast.mktyp(arg.typ)
sym := c.table.final_sym(arg.typ) sym := c.table.final_sym(arg.typ)
if sym.info is ast.FnType { if sym.info is ast.FnType {
@@ -894,86 +883,76 @@ fn (mut c Checker) infer_fn_generic_types(func ast.Fn, mut node ast.CallExpr) {
arg_sym := c.table.final_sym(arg.typ) arg_sym := c.table.final_sym(arg.typ)
if param.typ.has_flag(.variadic) { if param.typ.has_flag(.variadic) {
typ = ast.mktyp(arg.typ) typ = ast.mktyp(arg.typ)
} else if arg_sym.kind == .array && param_type_sym.kind == .array { } else if arg_sym.info is ast.Array && param_sym.info is ast.Array {
mut arg_elem_info := arg_sym.info as ast.Array mut arg_elem_typ, mut param_elem_typ := arg_sym.info.elem_type, param_sym.info.elem_type
mut param_elem_info := param_type_sym.info as ast.Array mut arg_elem_sym, mut param_elem_sym := c.table.sym(arg_elem_typ), c.table.sym(param_elem_typ)
mut arg_elem_sym := c.table.sym(arg_elem_info.elem_type)
mut param_elem_sym := c.table.sym(param_elem_info.elem_type)
for { for {
if arg_elem_sym.kind == .array && param_elem_sym.kind == .array if mut arg_elem_sym.info is ast.Array
&& mut param_elem_sym.info is ast.Array
&& c.table.cur_fn != unsafe { nil } && c.table.cur_fn != unsafe { nil }
&& param_elem_sym.name !in c.table.cur_fn.generic_names { && param_elem_sym.name !in c.table.cur_fn.generic_names {
arg_elem_info = arg_elem_sym.info as ast.Array arg_elem_typ, param_elem_typ = arg_elem_sym.info.elem_type, param_elem_sym.info.elem_type
arg_elem_sym = c.table.sym(arg_elem_info.elem_type) arg_elem_sym, param_elem_sym = c.table.sym(arg_elem_typ), c.table.sym(param_elem_typ)
param_elem_info = param_elem_sym.info as ast.Array
param_elem_sym = c.table.sym(param_elem_info.elem_type)
} else { } else {
if param_elem_sym.name == gt_name { if param_elem_sym.name == gt_name {
typ = arg_elem_info.elem_type typ = arg_elem_typ
if param_elem_info.elem_type.nr_muls() > 0 && typ.nr_muls() > 0 { if param_elem_typ.nr_muls() > 0 && typ.nr_muls() > 0 {
typ = typ.set_nr_muls(0) typ = typ.set_nr_muls(0)
} }
} }
break break
} }
} }
} else if arg_sym.kind == .array_fixed && param_type_sym.kind == .array_fixed { } else if arg_sym.info is ast.ArrayFixed && param_sym.info is ast.ArrayFixed {
mut arg_elem_info := arg_sym.info as ast.ArrayFixed mut arg_elem_typ, mut param_elem_typ := arg_sym.info.elem_type, param_sym.info.elem_type
mut param_elem_info := param_type_sym.info as ast.ArrayFixed mut arg_elem_sym, mut param_elem_sym := c.table.sym(arg_elem_typ), c.table.sym(param_elem_typ)
mut arg_elem_sym := c.table.sym(arg_elem_info.elem_type)
mut param_elem_sym := c.table.sym(param_elem_info.elem_type)
for { for {
if arg_elem_sym.kind == .array_fixed && param_elem_sym.kind == .array_fixed if mut arg_elem_sym.info is ast.ArrayFixed
&& mut param_elem_sym.info is ast.ArrayFixed
&& c.table.cur_fn != unsafe { nil } && c.table.cur_fn != unsafe { nil }
&& param_elem_sym.name !in c.table.cur_fn.generic_names { && param_elem_sym.name !in c.table.cur_fn.generic_names {
arg_elem_info = arg_elem_sym.info as ast.ArrayFixed arg_elem_typ, param_elem_typ = arg_elem_sym.info.elem_type, param_elem_sym.info.elem_type
arg_elem_sym = c.table.sym(arg_elem_info.elem_type) arg_elem_sym, param_elem_sym = c.table.sym(arg_elem_typ), c.table.sym(param_elem_typ)
param_elem_info = param_elem_sym.info as ast.ArrayFixed
param_elem_sym = c.table.sym(param_elem_info.elem_type)
} else { } else {
if param_elem_sym.name == gt_name { if param_elem_sym.name == gt_name {
typ = arg_elem_info.elem_type typ = arg_elem_typ
if param_elem_info.elem_type.nr_muls() > 0 && typ.nr_muls() > 0 { if param_elem_typ.nr_muls() > 0 && typ.nr_muls() > 0 {
typ = typ.set_nr_muls(0) typ = typ.set_nr_muls(0)
} }
} }
break break
} }
} }
} else if arg_sym.kind == .map && param_type_sym.kind == .map { } else if arg_sym.info is ast.Map && param_sym.info is ast.Map {
arg_map_info := arg_sym.info as ast.Map if param_sym.info.key_type.has_flag(.generic)
param_map_info := param_type_sym.info as ast.Map && c.table.sym(param_sym.info.key_type).name == gt_name {
if param_map_info.key_type.has_flag(.generic) typ = arg_sym.info.key_type
&& c.table.sym(param_map_info.key_type).name == gt_name { if param_sym.info.key_type.nr_muls() > 0 && typ.nr_muls() > 0 {
typ = arg_map_info.key_type
if param_map_info.key_type.nr_muls() > 0 && typ.nr_muls() > 0 {
typ = typ.set_nr_muls(0) typ = typ.set_nr_muls(0)
} }
} }
if param_map_info.value_type.has_flag(.generic) if param_sym.info.value_type.has_flag(.generic)
&& c.table.sym(param_map_info.value_type).name == gt_name { && c.table.sym(param_sym.info.value_type).name == gt_name {
typ = arg_map_info.value_type typ = arg_sym.info.value_type
if param_map_info.value_type.nr_muls() > 0 && typ.nr_muls() > 0 { if param_sym.info.value_type.nr_muls() > 0 && typ.nr_muls() > 0 {
typ = typ.set_nr_muls(0) typ = typ.set_nr_muls(0)
} }
} }
} else if arg_sym.kind == .function && param_type_sym.kind == .function { } else if arg_sym.info is ast.FnType && param_sym.info is ast.FnType {
arg_type_func := (arg_sym.info as ast.FnType).func if param_sym.info.func.params.len == arg_sym.info.func.params.len {
param_type_func := (param_type_sym.info as ast.FnType).func for n, fn_param in param_sym.info.func.params {
if param_type_func.params.len == arg_type_func.params.len {
for n, fn_param in param_type_func.params {
if fn_param.typ.has_flag(.generic) if fn_param.typ.has_flag(.generic)
&& c.table.sym(fn_param.typ).name == gt_name { && c.table.sym(fn_param.typ).name == gt_name {
typ = arg_type_func.params[n].typ typ = arg_sym.info.func.params[n].typ
if fn_param.typ.nr_muls() > 0 && typ.nr_muls() > 0 { if fn_param.typ.nr_muls() > 0 && typ.nr_muls() > 0 {
typ = typ.set_nr_muls(0) typ = typ.set_nr_muls(0)
} }
} }
} }
if param_type_func.return_type.has_flag(.generic) if param_sym.info.func.return_type.has_flag(.generic)
&& c.table.sym(param_type_func.return_type).name == gt_name { && c.table.sym(param_sym.info.func.return_type).name == gt_name {
typ = arg_type_func.return_type typ = arg_sym.info.func.return_type
if param_type_func.return_type.nr_muls() > 0 && typ.nr_muls() > 0 { if param_sym.info.func.return_type.nr_muls() > 0 && typ.nr_muls() > 0 {
typ = typ.set_nr_muls(0) typ = typ.set_nr_muls(0)
} }
} }
@@ -983,8 +962,8 @@ fn (mut c Checker) infer_fn_generic_types(func ast.Fn, mut node ast.CallExpr) {
mut concrete_types := []ast.Type{} mut concrete_types := []ast.Type{}
match arg_sym.info { match arg_sym.info {
ast.Struct, ast.Interface, ast.SumType { ast.Struct, ast.Interface, ast.SumType {
if param_type_sym.generic_types.len > 0 { if param_sym.generic_types.len > 0 {
generic_types = param_type_sym.generic_types.clone() generic_types = param_sym.generic_types.clone()
} else { } else {
generic_types = arg_sym.info.generic_types.clone() generic_types = arg_sym.info.generic_types.clone()
} }