Revert "cgen: ensure variable names do not conflict with builtin methods (fix #25063) (#25178)"

This reverts commit f17e0fd.

Author: spytheman

vlib/v/gen/c/assign.v

@@ -7,126 +7,6 @@ import v.ast
 import v.util
 import v.token
 
-fn (mut g Gen) resolve_var_method_conflict(var_name string, val ast.Expr) string {
-	mut method_call := ast.CallExpr{}
-	mut has_method_call := false
-	mut receiver_type := ast.Type(0)
-	mut method_name := ''
-	match val {
-		ast.ArrayInit {
-			if var_name == 'new_array_from_c_array_noscan' {
-				return '_var_${var_name}'
-			}
-		}
-		ast.MapInit {
-			if var_name == 'new_map_noscan_key_value' {
-				return '_var_${var_name}'
-			}
-		}
-		ast.CallExpr {
-			if val.is_method {
-				method_call = val
-				has_method_call = true
-			}
-		}
-		ast.UnsafeExpr {
-			if val.expr is ast.CallExpr {
-				call_expr := val.expr as ast.CallExpr
-				if call_expr.is_method {
-					method_call = call_expr
-					has_method_call = true
-				}
-			} else if val.expr is ast.IndexExpr {
-				index_expr := val.expr as ast.IndexExpr
-				left_type := g.unwrap_generic(index_expr.left_type)
-				left_sym := g.table.sym(left_type)
-				type_name := left_sym.kind.str()
-				if (index_expr.index is ast.RangeExpr && var_name == '${type_name}_slice')
-					|| var_name in ['${type_name}_get', '${type_name}_at'] {
-					return '_var_${var_name}'
-				}
-			}
-		}
-		ast.InfixExpr {
-			receiver_type = val.left_type
-			method_name = match val.op {
-				.eq { '_eq' }
-				.ne { '_ne' }
-				.lt { '_lt' }
-				.le { '_le' }
-				.gt { '_gt' }
-				.ge { '_ge' }
-				.plus { '_plus' }
-				.minus { '_minus' }
-				.mul { '_mul' }
-				.div { '_div' }
-				.mod { '_mod' }
-				else { '' }
-			}
-			has_method_call = method_name != '' && receiver_type != 0
-		}
-		ast.IndexExpr {
-			left_type := g.unwrap_generic(val.left_type)
-			left_sym := g.table.sym(left_type)
-			type_name := left_sym.kind.str()
-			if (val.index is ast.RangeExpr && var_name == '${type_name}_slice')
-				|| var_name in ['${type_name}_get', '${type_name}_at'] {
-				return '_var_${var_name}'
-			}
-		}
-		else {}
-	}
-	if has_method_call {
-		mut left_type := ast.Type(0)
-		if method_call.left_type != 0 {
-			left_type = g.unwrap_generic(method_call.left_type)
-			method_name = method_call.name
-		} else if receiver_type != 0 {
-			left_type = g.unwrap_generic(receiver_type)
-		}
-		if left_type != 0 {
-			left_sym := g.table.sym(left_type)
-			final_left_sym := g.table.final_sym(left_type)
-			if var_name == '${left_sym.cname}_${method_name}' {
-				return '_var_${var_name}'
-			}
-			if final_left_sym.kind == .array && !(left_sym.kind == .alias
-				&& left_sym.has_method(method_name)) {
-				actual_method_name := match method_name {
-					'repeat' {
-						'repeat_to_depth'
-					}
-					'clone' {
-						'clone_to_depth'
-					}
-					'pop_left' {
-						'pop_left_noscan'
-					}
-					'pop' {
-						'pop_noscan'
-					}
-					else {
-						method_name
-					}
-				}
-				if var_name == 'array_${actual_method_name}' {
-					return '_var_${var_name}'
-				}
-			}
-			if final_left_sym.kind == .map && !(left_sym.kind == .alias
-				&& left_sym.has_method(method_name)) {
-				if method_name in ['clone', 'move'] && var_name == 'map_${method_name}' {
-					return '_var_${var_name}'
-				}
-				if method_name in ['keys', 'values'] && var_name == 'map_${method_name}' {
-					return '_var_${var_name}'
-				}
-			}
-		}
-	}
-	return var_name
-}
-
 fn (mut g Gen) expr_with_opt_or_block(expr ast.Expr, expr_typ ast.Type, var_expr ast.Expr, ret_typ ast.Type,
 	in_heap bool) {
 	gen_or := expr is ast.Ident && expr.or_expr.kind != .absent
@@ -425,14 +305,6 @@ fn (mut g Gen) assign_stmt(node_ ast.AssignStmt) {
 		is_va_list = left_sym.language == .c && left_sym.name == 'C.va_list'
 		if mut left is ast.Ident {
 			ident = left
-			if is_decl && i < node.right.len {
-				resolved_name := g.resolve_var_method_conflict(ident.name, node.right[i])
-				if resolved_name != ident.name {
-					g.transformed_var_names[ident.name] = resolved_name
-					ident.name = resolved_name
-					node.left[i] = ident
-				}
-			}
 			g.curr_var_name << ident.name
 			// id_info := ident.var_info()
 			// var_type = id_info.typ

vlib/v/gen/c/autofree.v

@@ -242,8 +242,7 @@ fn (mut g Gen) autofree_var_call(free_fn_name string, v ast.Var) {
 			af.writeln('\t\t${free_fn_name}((${base_type}*)${c_name(v.name)}.data); // autofreed option var ${g.cur_mod.name} ${g.is_builtin_mod}')
 			af.writeln('\t}')
 		} else if v.typ.idx() != ast.u8_type_idx {
-			var_name := g.transformed_var_names[v.name] or { v.name }
-			af.writeln('\t${free_fn_name}(&${c_name(var_name)}); // autofreed var ${g.cur_mod.name} ${g.is_builtin_mod}')
+			af.writeln('\t${free_fn_name}(&${c_name(v.name)}); // autofreed var ${g.cur_mod.name} ${g.is_builtin_mod}')
 		}
 	}
 	g.autofree_scope_stmts << af.str()

vlib/v/gen/c/cgen.v

@@ -258,7 +258,6 @@ mut:
 	autofree_methods       map[ast.Type]string
 	generated_free_methods map[ast.Type]bool
 	autofree_scope_stmts   []string
-	transformed_var_names  map[string]string
 	use_segfault_handler   bool = true
 	test_function_names    []string
 	/////////
@@ -5262,7 +5261,6 @@ fn (mut g Gen) ident(node ast.Ident) {
 		return
 	}
 	mut name := if node.kind == .function { c_fn_name(node.name) } else { c_name(node.name) }
-	name = g.transformed_var_names[node.name] or { name }
 	if node.kind == .constant {
 		if g.pref.translated && !g.is_builtin_mod
 			&& !util.module_is_builtin(node.name.all_before_last('.')) {