From c47cf9bc4c0de07bbafb5134c282356eaba21ffd Mon Sep 17 00:00:00 2001 From: Alexander Medvednikov Date: Wed, 27 May 2026 13:43:12 +0300 Subject: [PATCH] all: fix more fn shadowing warnings in v2 + tools --- cmd/tools/vast/vast.v | 6 ++--- vlib/v/gen/js/fn.v | 4 ++-- vlib/v2/transformer/monomorphize.v | 10 ++++----- vlib/v2/types/checker.v | 18 +++++++-------- vlib/v2/types/checker_ownership.v | 36 +++++++++++++++--------------- 5 files changed, 37 insertions(+), 37 deletions(-) diff --git a/cmd/tools/vast/vast.v b/cmd/tools/vast/vast.v index d44c6683d..dedb941a4 100644 --- a/cmd/tools/vast/vast.v +++ b/cmd/tools/vast/vast.v @@ -157,9 +157,9 @@ fn json_file(file string) string { ast_json := json(file) // support .v and .vsh file file_name := file[0..(file.len - os.file_ext(file).len)] - json_file := file_name + '.json' - os.write_file(json_file, ast_json) or { panic(err) } - return json_file + out_file := file_name + '.json' + os.write_file(out_file, ast_json) or { panic(err) } + return out_file } // generate json string diff --git a/vlib/v/gen/js/fn.v b/vlib/v/gen/js/fn.v index 5fa578379..fb5e3161b 100644 --- a/vlib/v/gen/js/fn.v +++ b/vlib/v/gen/js/fn.v @@ -810,8 +810,8 @@ fn (mut g JsGen) gen_anon_fn(mut fun ast.AnonFn) { mut inherited2copy := map[string]string{} for inherited in fun.inherited_vars { if !inherited.is_mut { - copy := g.copy_val(inherited.typ, inherited.name) - inherited2copy[inherited.name] = copy + copied := g.copy_val(inherited.typ, inherited.name) + inherited2copy[inherited.name] = copied } } diff --git a/vlib/v2/transformer/monomorphize.v b/vlib/v2/transformer/monomorphize.v index 9800dd24b..54502fc94 100644 --- a/vlib/v2/transformer/monomorphize.v +++ b/vlib/v2/transformer/monomorphize.v @@ -311,14 +311,14 @@ pub fn (mut t Transformer) type_to_ast_expr(typ types.Type, pos token.Pos) ast.E // generic FnDecl plus a concrete type bindings map, e.g. foo + {T:int} -> foo_T_int. // Mirrors cleanc's specialized_fn_name so a future swap is name-compatible. pub fn (t &Transformer) specialized_fn_name(decl ast.FnDecl, bindings map[string]types.Type) string { - generic_param_names := decl_generic_param_names(decl) - if generic_param_names.len == 0 { + gp_names := decl_generic_param_names(decl) + if gp_names.len == 0 { return decl.name } mut all_placeholders := true - mut placeholder_parts := []string{cap: generic_param_names.len} - mut concrete_parts := []string{cap: generic_param_names.len} - for gp_name in generic_param_names { + mut placeholder_parts := []string{cap: gp_names.len} + mut concrete_parts := []string{cap: gp_names.len} + for gp_name in gp_names { concrete := bindings[gp_name] or { // Missing binding: fall back to the placeholder itself so we still // generate a parseable name (caller is expected to skip incomplete specs). diff --git a/vlib/v2/types/checker.v b/vlib/v2/types/checker.v index 85143e0ed..3ff7d4506 100644 --- a/vlib/v2/types/checker.v +++ b/vlib/v2/types/checker.v @@ -3256,8 +3256,8 @@ fn (mut c Checker) type_expr(expr ast.Expr) Type { parts := selector_expr_parts(resolved) if parts.len >= 2 { module_alias := parts[parts.len - 2] - type_name := parts[parts.len - 1] - if typ := c.lookup_type_in_module(module_alias, type_name) { + tname := parts[parts.len - 1] + if typ := c.lookup_type_in_module(module_alias, tname) { return typ } } @@ -6614,8 +6614,8 @@ fn (mut c Checker) selector_expr(expr ast.SelectorExpr) Type { parts := selector_expr_parts(expr.lhs) if parts.len >= 2 { module_alias := parts[parts.len - 2] - type_name := parts[parts.len - 1] - if lhs_type := c.lookup_type_in_module(module_alias, type_name) { + tname := parts[parts.len - 1] + if lhs_type := c.lookup_type_in_module(module_alias, tname) { if selector_type := comptime_type_metadata_selector_type(expr.rhs.name) { return selector_type } @@ -7200,15 +7200,15 @@ fn (c &Checker) lookup_type_by_name(name string) ?Type { if name.contains('__') { dunder_idx := name.last_index('__') or { -1 } mod_name := name[..dunder_idx].replace('__', '.') - type_name := name[dunder_idx + 2..] + tname := name[dunder_idx + 2..] if mod_obj := c.scope.lookup_parent(mod_name, 0) { if mod_obj is Module { - if typ := mod_obj.scope.lookup_type_parent(type_name, 0) { + if typ := mod_obj.scope.lookup_type_parent(tname, 0) { return typ } } } - if typ := c.lookup_type_in_env_module(mod_name, type_name) { + if typ := c.lookup_type_in_env_module(mod_name, tname) { return typ } short_name := name.all_after('__') @@ -7220,8 +7220,8 @@ fn (c &Checker) lookup_type_by_name(name string) ?Type { } if name.contains('.') { mod_name := name.all_before_last('.') - type_name := name.all_after_last('.') - if typ := c.lookup_type_in_env_module(mod_name, type_name) { + tname := name.all_after_last('.') + if typ := c.lookup_type_in_env_module(mod_name, tname) { return typ } } diff --git a/vlib/v2/types/checker_ownership.v b/vlib/v2/types/checker_ownership.v index 586466a12..8b0ba3c4f 100644 --- a/vlib/v2/types/checker_ownership.v +++ b/vlib/v2/types/checker_ownership.v @@ -35,8 +35,8 @@ fn (mut c Checker) ownership_check_ident(name string, pos token.Pos) { move_position := move_file.position(info.move_pos) errors.error('use of moved value: `${name}`', errors.details(file, file.position(pos), 2), .error, file.position(pos)) - type_name := if info.type_name.len > 0 { info.type_name } else { 'string' } - eprintln(' --> move occurs because `${name}` has type `${type_name}`, which does not implement the `Copy` interface') + tname := if info.type_name.len > 0 { info.type_name } else { 'string' } + eprintln(' --> move occurs because `${name}` has type `${tname}`, which does not implement the `Copy` interface') if info.is_fn_call { eprintln(' --> value moved into function `${info.fn_name}` at ${move_position}') eprintln('help: consider cloning the value if the performance cost is acceptable') @@ -122,12 +122,12 @@ fn (mut c Checker) ownership_consume_expr(expr ast.Expr, pos token.Pos, target s exit(1) } } - type_name := c.owned_var_types[name] or { 'string' } + tname := c.owned_var_types[name] or { 'string' } c.moved_vars[name] = MovedVar{ moved_to: target move_pos: pos suggest_clone: false - type_name: type_name + type_name: tname } } @@ -201,13 +201,13 @@ fn (mut c Checker) ownership_check_call_args(expr ast.CallExpr) { exit(1) } } - type_name := c.owned_var_types[arg_name] or { 'string' } + tname := c.owned_var_types[arg_name] or { 'string' } c.moved_vars[arg_name] = MovedVar{ moved_to: fn_name move_pos: expr.pos is_fn_call: true fn_name: fn_name - type_name: type_name + type_name: tname } // Track that parameter i of this function receives an owned value key := '${fn_name}__param_${i}' @@ -237,13 +237,13 @@ fn (mut c Checker) ownership_check_return(stmt ast.ReturnStmt) { // This function returns an owned value — mark the function c.ownership_fns[c.ownership_cur_fn] = true // The returned variable is moved out of this scope - type_name := c.owned_var_types[name] or { 'string' } + tname := c.owned_var_types[name] or { 'string' } c.moved_vars[name] = MovedVar{ moved_to: c.ownership_cur_fn move_pos: c.owned_vars[name] // use the owned position as fallback is_fn_call: true fn_name: c.ownership_cur_fn - type_name: type_name + type_name: tname } } else if ownership_is_to_owned_call(expr) { // Direct return of .to_owned() call, e.g. `return 'x'.to_owned()` @@ -326,21 +326,21 @@ fn (mut c Checker) ownership_mark_from_call_expr(lhs_name string, call ast.CallE arg_name := ownership_expr_ident_name(call.args[param_idx]) if arg_name.len > 0 { if arg_name in c.owned_vars { - type_name := c.owned_var_types[arg_name] or { 'string' } + tname := c.owned_var_types[arg_name] or { 'string' } c.owned_vars[lhs_name] = pos - c.owned_var_types[lhs_name] = type_name + c.owned_var_types[lhs_name] = tname return true } if arg_name in c.moved_vars { info := c.moved_vars[arg_name] if info.is_fn_call && info.fn_name == fn_name { - type_name := if info.type_name.len > 0 { + tname := if info.type_name.len > 0 { info.type_name } else { 'string' } c.owned_vars[lhs_name] = pos - c.owned_var_types[lhs_name] = type_name + c.owned_var_types[lhs_name] = tname return true } } @@ -1289,13 +1289,13 @@ fn (mut c Checker) ownership_check_method_call(expr ast.CallExpr) { exit(1) } } - type_name := c.owned_var_types[recv_name] or { 'string' } + tname := c.owned_var_types[recv_name] or { 'string' } c.moved_vars[recv_name] = MovedVar{ moved_to: method_name move_pos: expr.pos is_fn_call: true fn_name: method_name - type_name: type_name + type_name: tname } } @@ -1327,7 +1327,7 @@ fn (mut c Checker) ownership_reject_global_move(name string, pos token.Pos, targ if name !in c.ownership_owned_globals { return } - type_name := c.ownership_owned_globals[name] + tname := c.ownership_owned_globals[name] if pos.id > 0 { file := c.file_set.file(pos) errors.error('cannot move out of global `${name}`', errors.details(file, @@ -1335,7 +1335,7 @@ fn (mut c Checker) ownership_reject_global_move(name string, pos token.Pos, targ } else { eprintln('error: cannot move out of global `${name}`') } - eprintln(' --> global `${name}` has type `${type_name}`, which does not implement the `Copy` interface') + eprintln(' --> global `${name}` has type `${tname}`, which does not implement the `Copy` interface') if is_call { eprintln(' --> moving a global into `${target}` would leave the global in an undefined state') eprintln('help: pass a borrow (`&${name}`) or clone (`${name}.clone()`) instead') @@ -1390,12 +1390,12 @@ fn (mut c Checker) ownership_check_closure_captures(expr ast.FnLiteral) { exit(1) } } - type_name := c.owned_var_types[name] or { 'string' } + tname := c.owned_var_types[name] or { 'string' } c.moved_vars[name] = MovedVar{ moved_to: 'closure' move_pos: expr.pos suggest_clone: false - type_name: type_name + type_name: tname } } } -- 2.39.5