Skip to content

Commit d90297f

Browse files
medvednikovmedvednikov
committed
fmt
1 parent e321437 commit d90297f

8 files changed

Lines changed: 188 additions & 187 deletions

File tree

‎examples/clock/clock.v‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -28,11 +28,11 @@ const second_hand_color = gg.red
2828

2929
struct App {
3030
minutes_tic []f32 = [f32(center - tw), tp, center + tw, tp, center + tw, tp, center + tw,
31-
tp + 1 * th, center - tw, tp + 1 * th]
31+
tp + 1 * th, center - tw, tp + 1 * th]
3232
hours_tic []f32 = [f32(center - tw), tp, center + tw, tp, center + tw, tp, center + tw,
33-
tp + 2 * th, center - tw, tp + 2 * th]
33+
tp + 2 * th, center - tw, tp + 2 * th]
3434
hours3_tic []f32 = [f32(center - tw), tp, center + tw, tp, center + tw, tp, center + tw,
35-
tp + 3 * th, center - tw, tp + 3 * th]
35+
tp + 3 * th, center - tw, tp + 3 * th]
3636

3737
hour_hand []f32 = [f32(329), 161, 350, 140, 371, 161, 371, 413, 329, 413]
3838
minute_hand []f32 = [f32(334.25), 40.25, 350, 24.5, 365.75, 40.25, 365.75, 427, 334.25, 427]

‎vlib/term/ui/input.v‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -202,7 +202,7 @@ pub:
202202
skip_init_checks bool
203203
// All kill signals to set up exit listeners on:
204204
reset []os.Signal = [.hup, .int, .quit, .ill, .abrt, .bus, .fpe, .kill, .segv, .pipe, .alrm, .term,
205-
.stop]
205+
.stop]
206206
}
207207

208208
@[inline]

‎vlib/v/checker/check_types.v‎

Lines changed: 20 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -1192,11 +1192,11 @@ fn (mut c Checker) infer_fn_generic_types(func &ast.Fn, mut node ast.CallExpr) {
11921192
typ = typ.set_nr_muls(0)
11931193
}
11941194
}
1195-
} else if param.typ.has_flag(.generic) && param_sym.name == gt_name {
1196-
typ = ast.mktyp(arg.typ)
1197-
if typ == ast.nil_type {
1198-
typ = ast.voidptr_type
1199-
}
1195+
} else if param.typ.has_flag(.generic) && param_sym.name == gt_name {
1196+
typ = ast.mktyp(arg.typ)
1197+
if typ == ast.nil_type {
1198+
typ = ast.voidptr_type
1199+
}
12001200
sym := c.table.final_sym(arg.typ)
12011201
if sym.info is ast.FnType {
12021202
mut func_ := sym.info.func
@@ -1215,10 +1215,10 @@ fn (mut c Checker) infer_fn_generic_types(func &ast.Fn, mut node ast.CallExpr) {
12151215
}
12161216
}
12171217
}
1218-
if (arg.is_mut || arg.expr.is_auto_deref_var()) && typ.is_ptr()
1219-
&& !param.typ.is_ptr() {
1220-
typ = typ.deref()
1221-
}
1218+
if (arg.is_mut || arg.expr.is_auto_deref_var()) && typ.is_ptr()
1219+
&& !param.typ.is_ptr() {
1220+
typ = typ.deref()
1221+
}
12221222
// resolve &T &&T ...
12231223
if param.typ.nr_muls() > 0 && typ.nr_muls() > 0 {
12241224
param_muls := param.typ.nr_muls()
@@ -1229,17 +1229,17 @@ fn (mut c Checker) infer_fn_generic_types(func &ast.Fn, mut node ast.CallExpr) {
12291229
typ.set_nr_muls(0)
12301230
}
12311231
}
1232-
} else if param.typ.has_flag(.generic) {
1233-
mut arg_typ := if c.table.sym(arg.typ).kind == .any {
1234-
c.unwrap_generic(arg.typ)
1235-
} else {
1236-
arg.typ
1237-
}
1238-
if (arg.is_mut || arg.expr.is_auto_deref_var()) && arg_typ.is_ptr()
1239-
&& !param.typ.is_ptr() {
1240-
arg_typ = arg_typ.deref()
1241-
}
1242-
arg_sym := c.table.final_sym(arg_typ)
1232+
} else if param.typ.has_flag(.generic) {
1233+
mut arg_typ := if c.table.sym(arg.typ).kind == .any {
1234+
c.unwrap_generic(arg.typ)
1235+
} else {
1236+
arg.typ
1237+
}
1238+
if (arg.is_mut || arg.expr.is_auto_deref_var()) && arg_typ.is_ptr()
1239+
&& !param.typ.is_ptr() {
1240+
arg_typ = arg_typ.deref()
1241+
}
1242+
arg_sym := c.table.final_sym(arg_typ)
12431243
if param.typ.has_flag(.variadic) {
12441244
typ = ast.mktyp(arg_typ)
12451245
} else if arg_sym.info is ast.Array && param_sym.info is ast.Array {

‎vlib/v/checker/checker.v‎

Lines changed: 12 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -5608,23 +5608,23 @@ fn (mut c Checker) mark_as_referenced(mut node ast.Expr, as_interface bool) {
56085608
match type_sym.kind {
56095609
.struct {
56105610
info := type_sym.info as ast.Struct
5611-
if !info.is_heap && !node.obj.is_inherited {
5612-
obj.is_auto_heap = true
5613-
}
5611+
if !info.is_heap && !node.obj.is_inherited {
5612+
obj.is_auto_heap = true
56145613
}
5615-
.sum_type, .interface {}
5616-
.function {
5617-
if type_sym.info is ast.FnType {
5618-
if type_sym.info.is_anon {
5619-
obj.is_auto_heap = true
5620-
}
5614+
}
5615+
.sum_type, .interface {}
5616+
.function {
5617+
if type_sym.info is ast.FnType {
5618+
if type_sym.info.is_anon {
5619+
obj.is_auto_heap = true
56215620
}
56225621
}
5623-
else {
5624-
obj.is_auto_heap = true
5625-
}
5622+
}
5623+
else {
5624+
obj.is_auto_heap = true
56265625
}
56275626
}
5627+
}
56285628
}
56295629
}
56305630
ast.SelectorExpr {

‎vlib/v/gen/c/fn.v‎

Lines changed: 93 additions & 91 deletions
Original file line numberDiff line numberDiff line change
@@ -1656,22 +1656,22 @@ fn (mut g Gen) resolve_return_type(node ast.CallExpr) ast.Type {
16561656
} else {
16571657
node.return_type.clear_option_and_result()
16581658
}
1659-
} else {
1660-
mut fn_var_type := ast.void_type
1661-
lookup_name := if node.left is ast.Ident { node.left.name } else { node.name }
1662-
resolved_current_type := g.resolve_current_fn_generic_param_type(lookup_name)
1663-
if resolved_current_type != 0
1664-
&& g.table.final_sym(g.unwrap_generic(resolved_current_type)).kind == .function {
1665-
fn_var_type = g.unwrap_generic(g.recheck_concrete_type(resolved_current_type))
1666-
} else if node.is_fn_var {
1667-
fn_var_type = g.unwrap_generic(g.recheck_concrete_type(node.fn_var_type))
1668-
}
1669-
if fn_var_type == 0 {
1670-
if obj := node.scope.find_var(lookup_name) {
1671-
if g.table.final_sym(g.unwrap_generic(obj.typ)).kind == .function {
1672-
fn_var_type = g.unwrap_generic(g.recheck_concrete_type(obj.typ))
1673-
}
1659+
} else {
1660+
mut fn_var_type := ast.void_type
1661+
lookup_name := if node.left is ast.Ident { node.left.name } else { node.name }
1662+
resolved_current_type := g.resolve_current_fn_generic_param_type(lookup_name)
1663+
if resolved_current_type != 0
1664+
&& g.table.final_sym(g.unwrap_generic(resolved_current_type)).kind == .function {
1665+
fn_var_type = g.unwrap_generic(g.recheck_concrete_type(resolved_current_type))
1666+
} else if node.is_fn_var {
1667+
fn_var_type = g.unwrap_generic(g.recheck_concrete_type(node.fn_var_type))
1668+
}
1669+
if fn_var_type == 0 {
1670+
if obj := node.scope.find_var(lookup_name) {
1671+
if g.table.final_sym(g.unwrap_generic(obj.typ)).kind == .function {
1672+
fn_var_type = g.unwrap_generic(g.recheck_concrete_type(obj.typ))
16741673
}
1674+
}
16751675
}
16761676
if fn_var_type != 0 {
16771677
fn_sym := g.table.final_sym(fn_var_type)
@@ -2098,19 +2098,19 @@ fn (mut g Gen) generic_fn_call_concrete_types(func ast.Fn, node ast.CallExpr) []
20982098
if arg_type == 0 {
20992099
continue
21002100
}
2101-
if arg_type in [ast.int_literal_type, ast.float_literal_type] {
2102-
continue
2103-
}
2104-
param_sym := g.table.sym(param.typ)
2105-
if (arg.expr is ast.PrefixExpr && arg.expr.op == .amp && param.typ.nr_muls() > 0)
2106-
|| param_sym.info is ast.FnType {
2107-
trust_node_concrete_types = false
2108-
break
2109-
}
2110-
if param_sym.info is ast.FnType
2111-
&& (arg_type.has_flag(.generic) || g.type_has_unresolved_generic_parts(arg_type)) {
2112-
continue
2113-
}
2101+
if arg_type in [ast.int_literal_type, ast.float_literal_type] {
2102+
continue
2103+
}
2104+
param_sym := g.table.sym(param.typ)
2105+
if (arg.expr is ast.PrefixExpr && arg.expr.op == .amp && param.typ.nr_muls() > 0)
2106+
|| param_sym.info is ast.FnType {
2107+
trust_node_concrete_types = false
2108+
break
2109+
}
2110+
if param_sym.info is ast.FnType
2111+
&& (arg_type.has_flag(.generic) || g.type_has_unresolved_generic_parts(arg_type)) {
2112+
continue
2113+
}
21142114
if resolved_param_type := muttable.convert_generic_type(param.typ, func.generic_names,
21152115
concrete_types)
21162116
{
@@ -2220,8 +2220,9 @@ fn (mut g Gen) resolve_current_fn_generic_param_value_type(name string) ast.Type
22202220
continue
22212221
}
22222222
mut muttable := unsafe { &ast.Table(g.table) }
2223-
resolved_param_type := if resolved := muttable.convert_generic_type(param.typ, generic_names,
2224-
g.cur_concrete_types) {
2223+
resolved_param_type := if resolved := muttable.convert_generic_type(param.typ,
2224+
generic_names, g.cur_concrete_types)
2225+
{
22252226
g.unwrap_generic(resolved)
22262227
} else {
22272228
g.unwrap_generic(g.recheck_concrete_type(param.typ))
@@ -2248,8 +2249,9 @@ fn (mut g Gen) resolve_current_fn_generic_param_key_type(name string) ast.Type {
22482249
continue
22492250
}
22502251
mut muttable := unsafe { &ast.Table(g.table) }
2251-
resolved_param_type := if resolved := muttable.convert_generic_type(param.typ, generic_names,
2252-
g.cur_concrete_types) {
2252+
resolved_param_type := if resolved := muttable.convert_generic_type(param.typ,
2253+
generic_names, g.cur_concrete_types)
2254+
{
22532255
g.unwrap_generic(resolved)
22542256
} else {
22552257
g.unwrap_generic(g.recheck_concrete_type(param.typ))
@@ -2576,38 +2578,39 @@ fn (mut g Gen) method_call(node ast.CallExpr) {
25762578
if node.concrete_types.len == method_generic_names_len && node.concrete_types.len > 0 {
25772579
trust_node_concrete_types = node.raw_concrete_types.len == method_generic_names_len
25782580
&& node.raw_concrete_types.len > 0
2579-
if !trust_node_concrete_types {
2580-
trust_node_concrete_types = true
2581-
mut muttable := unsafe { &ast.Table(g.table) }
2582-
for i, arg in node.args {
2581+
if !trust_node_concrete_types {
2582+
trust_node_concrete_types = true
2583+
mut muttable := unsafe { &ast.Table(g.table) }
2584+
for i, arg in node.args {
25832585
param := if method_for_generics.is_variadic
25842586
&& i >= method_for_generics.params.len - 1 {
25852587
method_for_generics.params.last()
25862588
} else {
25872589
method_for_generics.params[i + 1]
25882590
}
2589-
if resolved_param_type := muttable.convert_generic_type(param.typ,
2590-
method_for_generics.generic_names, node.concrete_types)
2591-
{
2592-
mut arg_type := g.resolved_generic_call_arg_type(arg)
2593-
if arg_type in [ast.int_literal_type, ast.float_literal_type] {
2594-
continue
2595-
}
2596-
if arg.expr.is_auto_deref_var() && arg_type.is_ptr() && !param.typ.is_ptr() {
2597-
arg_type = arg_type.deref()
2598-
}
2599-
param_sym := g.table.sym(param.typ)
2600-
if (arg.expr is ast.PrefixExpr && arg.expr.op == .amp
2601-
&& param.typ.nr_muls() > 0)
2602-
|| (arg.expr.is_auto_deref_var() && g.resolved_generic_call_arg_type(arg).is_ptr()
2603-
&& !param.typ.is_ptr()) || param_sym.info is ast.FnType {
2604-
trust_node_concrete_types = false
2605-
break
2606-
}
2607-
if g.unwrap_generic(resolved_param_type) != g.unwrap_generic(arg_type) {
2608-
trust_node_concrete_types = false
2609-
break
2610-
}
2591+
if resolved_param_type := muttable.convert_generic_type(param.typ,
2592+
method_for_generics.generic_names, node.concrete_types)
2593+
{
2594+
mut arg_type := g.resolved_generic_call_arg_type(arg)
2595+
if arg_type in [ast.int_literal_type, ast.float_literal_type] {
2596+
continue
2597+
}
2598+
if arg.expr.is_auto_deref_var() && arg_type.is_ptr() && !param.typ.is_ptr() {
2599+
arg_type = arg_type.deref()
2600+
}
2601+
param_sym := g.table.sym(param.typ)
2602+
if (arg.expr is ast.PrefixExpr && arg.expr.op == .amp
2603+
&& param.typ.nr_muls() > 0)
2604+
|| (arg.expr.is_auto_deref_var()
2605+
&& g.resolved_generic_call_arg_type(arg).is_ptr()
2606+
&& !param.typ.is_ptr()) || param_sym.info is ast.FnType {
2607+
trust_node_concrete_types = false
2608+
break
2609+
}
2610+
if g.unwrap_generic(resolved_param_type) != g.unwrap_generic(arg_type) {
2611+
trust_node_concrete_types = false
2612+
break
2613+
}
26112614
} else {
26122615
trust_node_concrete_types = false
26132616
break
@@ -2735,22 +2738,21 @@ fn (mut g Gen) method_call(node ast.CallExpr) {
27352738
} else {
27362739
method_for_generics.params[offset + i]
27372740
}
2738-
if !param.typ.has_flag(.generic)
2739-
&& !g.type_has_unresolved_generic_parts(param.typ) {
2741+
if !param.typ.has_flag(.generic) && !g.type_has_unresolved_generic_parts(param.typ) {
27402742
continue
27412743
}
27422744
if param.typ == receiver_param_type {
27432745
continue
27442746
}
27452747
slot := rec_len + generic_arg_idx
2746-
if slot < concrete_types.len {
2747-
mut arg_type := g.resolved_generic_call_arg_type(arg)
2748-
if arg.expr.is_auto_deref_var() && arg_type.is_ptr() && !param.typ.is_ptr() {
2749-
arg_type = arg_type.deref()
2750-
}
2751-
current_type := concrete_types[slot]
2752-
if current_type != 0 && !current_type.has_flag(.generic)
2753-
&& !g.type_has_unresolved_generic_parts(current_type)
2748+
if slot < concrete_types.len {
2749+
mut arg_type := g.resolved_generic_call_arg_type(arg)
2750+
if arg.expr.is_auto_deref_var() && arg_type.is_ptr() && !param.typ.is_ptr() {
2751+
arg_type = arg_type.deref()
2752+
}
2753+
current_type := concrete_types[slot]
2754+
if current_type != 0 && !current_type.has_flag(.generic)
2755+
&& !g.type_has_unresolved_generic_parts(current_type)
27542756
&& arg_type in [ast.int_literal_type, ast.float_literal_type] {
27552757
generic_arg_idx++
27562758
continue
@@ -2761,29 +2763,29 @@ fn (mut g Gen) method_call(node ast.CallExpr) {
27612763
&& receiver_concrete_types.len + node.raw_concrete_types.len == full_method_generic_names_len {
27622764
explicit_slot = slot - rec_len
27632765
}
2764-
mut explicit_concrete_type := ast.no_type
2765-
if explicit_slot >= 0 && explicit_slot < node.raw_concrete_types.len {
2766-
explicit_concrete_type = g.unwrap_generic(node.raw_concrete_types[explicit_slot])
2767-
} else if slot < node.concrete_types.len {
2768-
explicit_concrete_type = g.unwrap_generic(node.concrete_types[slot])
2766+
mut explicit_concrete_type := ast.no_type
2767+
if explicit_slot >= 0 && explicit_slot < node.raw_concrete_types.len {
2768+
explicit_concrete_type = g.unwrap_generic(node.raw_concrete_types[explicit_slot])
2769+
} else if slot < node.concrete_types.len {
2770+
explicit_concrete_type = g.unwrap_generic(node.concrete_types[slot])
2771+
}
2772+
if arg.expr is ast.PrefixExpr && arg.expr.op == .amp && param.typ.nr_muls() > 0 {
2773+
inner_type := g.resolved_expr_type(arg.expr.right, arg.expr.right_type)
2774+
mut resolved_inner_type := g.unwrap_generic(g.recheck_concrete_type(inner_type))
2775+
if arg.expr.right.is_auto_deref_var() && resolved_inner_type.is_ptr() {
2776+
resolved_inner_type = resolved_inner_type.deref()
27692777
}
2770-
if arg.expr is ast.PrefixExpr && arg.expr.op == .amp && param.typ.nr_muls() > 0 {
2771-
inner_type := g.resolved_expr_type(arg.expr.right, arg.expr.right_type)
2772-
mut resolved_inner_type := g.unwrap_generic(g.recheck_concrete_type(inner_type))
2773-
if arg.expr.right.is_auto_deref_var() && resolved_inner_type.is_ptr() {
2774-
resolved_inner_type = resolved_inner_type.deref()
2775-
}
2776-
if resolved_inner_type != 0 && !resolved_inner_type.has_flag(.generic)
2777-
&& !g.type_has_unresolved_generic_parts(resolved_inner_type) {
2778-
concrete_types[slot] = resolved_inner_type
2779-
generic_arg_idx++
2780-
continue
2781-
}
2778+
if resolved_inner_type != 0 && !resolved_inner_type.has_flag(.generic)
2779+
&& !g.type_has_unresolved_generic_parts(resolved_inner_type) {
2780+
concrete_types[slot] = resolved_inner_type
2781+
generic_arg_idx++
2782+
continue
27822783
}
2783-
if explicit_concrete_type != 0 {
2784-
node_concrete_type := explicit_concrete_type
2785-
if node_concrete_type != 0 && !node_concrete_type.has_flag(.generic)
2786-
&& !g.type_has_unresolved_generic_parts(node_concrete_type)
2784+
}
2785+
if explicit_concrete_type != 0 {
2786+
node_concrete_type := explicit_concrete_type
2787+
if node_concrete_type != 0 && !node_concrete_type.has_flag(.generic)
2788+
&& !g.type_has_unresolved_generic_parts(node_concrete_type)
27872789
&& (trust_node_concrete_types || node_concrete_type == arg_type) {
27882790
concrete_types[slot] = node_concrete_type
27892791
generic_arg_idx++
@@ -2794,8 +2796,8 @@ fn (mut g Gen) method_call(node ast.CallExpr) {
27942796
&& !g.type_has_unresolved_generic_parts(arg_type) {
27952797
if g.type_has_unresolved_generic_parts(param.typ) {
27962798
prev_concrete_types := concrete_types.clone()
2797-
g.infer_generic_call_concrete_types_from_types(full_method_generic_names,
2798-
mut concrete_types, arg, param.typ, arg_type)
2799+
g.infer_generic_call_concrete_types_from_types(full_method_generic_names, mut
2800+
concrete_types, arg, param.typ, arg_type)
27992801
if concrete_types != prev_concrete_types {
28002802
generic_arg_idx++
28012803
continue

0 commit comments

Comments
 (0)
⚡