ast,checker,cgen: cleanup remaining misleading names of local variables for typ := x.table.sym()

spytheman · spytheman · commit 0df1ae8e2da8 · 2025-10-12T12:22:51.000+03:00
diff --git a/vlib/v/ast/table.v b/vlib/v/ast/table.v
@@ -1164,8 +1164,7 @@ pub fn (mut t Table) find_or_register_chan(elem_type Type, is_mut bool) int {
 	if existing_idx > 0 {
 		return existing_idx
 	}
-	// register
-	chan_typ := TypeSymbol{
+	chan_sym := TypeSymbol{
 		parent_idx: chan_type_idx
 		kind:       .chan
 		name:       name
@@ -1175,7 +1174,7 @@ pub fn (mut t Table) find_or_register_chan(elem_type Type, is_mut bool) int {
 			is_mut:    is_mut
 		}
 	}
-	return t.register_sym(chan_typ)
+	return t.register_sym(chan_sym)
 }
 
 pub fn (mut t Table) find_or_register_map(key_type Type, value_type Type) int {
@@ -1186,8 +1185,7 @@ pub fn (mut t Table) find_or_register_map(key_type Type, value_type Type) int {
 	if existing_idx > 0 {
 		return existing_idx
 	}
-	// register
-	map_typ := TypeSymbol{
+	map_sym := TypeSymbol{
 		parent_idx: map_type_idx
 		kind:       .map
 		name:       name
@@ -1197,7 +1195,7 @@ pub fn (mut t Table) find_or_register_map(key_type Type, value_type Type) int {
 			value_type: value_type
 		}
 	}
-	return t.register_sym(map_typ)
+	return t.register_sym(map_sym)
 }
 
 pub fn (mut t Table) find_or_register_thread(return_type Type) int {
@@ -1208,8 +1206,7 @@ pub fn (mut t Table) find_or_register_thread(return_type Type) int {
 	if existing_idx > 0 {
 		return existing_idx
 	}
-	// register
-	thread_typ := TypeSymbol{
+	thread_sym := TypeSymbol{
 		parent_idx: thread_type_idx
 		kind:       .thread
 		name:       name
@@ -1218,7 +1215,7 @@ pub fn (mut t Table) find_or_register_thread(return_type Type) int {
 			return_type: return_type
 		}
 	}
-	return t.register_sym(thread_typ)
+	return t.register_sym(thread_sym)
 }
 
 pub fn (mut t Table) find_or_register_promise(return_type Type) int {
@@ -1321,16 +1318,15 @@ pub fn (mut t Table) find_or_register_multi_return(mr_typs []Type) int {
 	if existing_idx > 0 {
 		return existing_idx
 	}
-	// register
-	mr_type := TypeSymbol{
+	multireg_sym := TypeSymbol{
 		kind:  .multi_return
 		name:  name
 		cname: cname
 		info:  MultiReturn{
 			types: mr_typs
 		}
 	}
-	return t.register_sym(mr_type)
+	return t.register_sym(multireg_sym)
 }
 
 pub fn (mut t Table) find_or_register_fn_type(f Fn, is_anon bool, has_decl bool) int {
@@ -1366,7 +1362,7 @@ pub fn (mut t Table) add_placeholder_type(name string, cname string, language La
 	if name.contains('.') {
 		modname = name.all_before_last('.')
 	}
-	ph_type := TypeSymbol{
+	placeholder_sym := TypeSymbol{
 		kind:       .placeholder
 		name:       name
 		cname:      util.no_dots(cname).replace_each(['&', ''])
@@ -1375,7 +1371,7 @@ pub fn (mut t Table) add_placeholder_type(name string, cname string, language La
 		is_pub:     true
 		is_builtin: name in builtins
 	}
-	return t.register_sym(ph_type)
+	return t.register_sym(placeholder_sym)
 }
 
 @[inline]
diff --git a/vlib/v/checker/interface.v b/vlib/v/checker/interface.v
@@ -122,8 +122,8 @@ fn (mut c Checker) interface_decl(mut node ast.InterfaceDecl) {
 				continue
 			}
 			if is_js {
-				mtyp := c.table.sym(method.return_type)
-				if !mtyp.is_js_compatible() {
+				mrsym := c.table.sym(method.return_type)
+				if !mrsym.is_js_compatible() {
 					c.error('method ${method.name} returns non JS type', method.pos)
 				}
 			}
@@ -179,8 +179,8 @@ fn (mut c Checker) interface_decl(mut node ast.InterfaceDecl) {
 					}
 				}
 				if is_js {
-					ptyp := c.table.sym(param.typ)
-					if !ptyp.is_js_compatible() && !(j == method.params.len - 1
+					psym := c.table.sym(param.typ)
+					if !psym.is_js_compatible() && !(j == method.params.len - 1
 						&& method.is_variadic) {
 						c.error('method `${method.name}` accepts non JS type as parameter',
 							method.pos)
diff --git a/vlib/v/gen/c/array.v b/vlib/v/gen/c/array.v
@@ -1431,8 +1431,8 @@ fn (mut g Gen) gen_array_wait(node ast.CallExpr) {
 	thread_type := arr.array_info().elem_type
 	thread_sym := g.table.sym(thread_type)
 	thread_ret_type := thread_sym.thread_info().return_type
-	eltyp := g.table.sym(thread_ret_type).cname
-	fn_name := g.register_thread_array_wait_call(eltyp)
+	elsymcname := g.table.sym(thread_ret_type).cname
+	fn_name := g.register_thread_array_wait_call(elsymcname)
 	g.write('${fn_name}(')
 	if node.left_type.is_ptr() {
 		g.write('*')
@@ -1446,8 +1446,8 @@ fn (mut g Gen) gen_fixed_array_wait(node ast.CallExpr) {
 	thread_type := arr.array_fixed_info().elem_type
 	thread_sym := g.table.sym(thread_type)
 	thread_ret_type := thread_sym.thread_info().return_type
-	eltyp := g.table.sym(thread_ret_type).cname
-	fn_name := g.register_thread_fixed_array_wait_call(node, eltyp)
+	elsymcname := g.table.sym(thread_ret_type).cname
+	fn_name := g.register_thread_fixed_array_wait_call(node, elsymcname)
 	g.write('${fn_name}(')
 	g.expr(node.left)
 	g.write(')')
diff --git a/vlib/v/gen/c/assign.v b/vlib/v/gen/c/assign.v
@@ -1264,10 +1264,10 @@ fn (mut g Gen) gen_cross_var_assign(node &ast.AssignStmt) {
 				sym := g.table.sym(g.table.unaliased_type(left.left_type))
 				if sym.kind == .array {
 					info := sym.info as ast.Array
-					elem_typ := g.table.sym(info.elem_type)
+					elem_sym := g.table.sym(info.elem_type)
 					needs_clone := info.elem_type == ast.string_type && g.is_autofree
 
-					if elem_typ.kind == .function {
+					if elem_sym.kind == .function {
 						left_typ := node.left_types[i]
 						left_sym := g.table.sym(left_typ)
 						g.write_fn_ptr_decl(left_sym.info as ast.FnType, '_var_${left.pos.pos}')
@@ -1291,8 +1291,8 @@ fn (mut g Gen) gen_cross_var_assign(node &ast.AssignStmt) {
 					g.writeln(');')
 				} else if sym.kind == .array_fixed {
 					info := sym.info as ast.ArrayFixed
-					elem_typ := g.table.sym(info.elem_type)
-					if elem_typ.kind == .function {
+					elem_sym := g.table.sym(info.elem_type)
+					if elem_sym.kind == .function {
 						left_typ := node.left_types[i]
 						left_sym := g.table.sym(left_typ)
 						g.write_fn_ptr_decl(left_sym.info as ast.FnType, '_var_${left.pos.pos}')
@@ -1318,8 +1318,8 @@ fn (mut g Gen) gen_cross_var_assign(node &ast.AssignStmt) {
 					skeytyp := g.styp(info.key_type)
 					styp := g.styp(info.value_type)
 					zero := g.type_default(info.value_type)
-					val_typ := g.table.sym(info.value_type)
-					if val_typ.kind == .function {
+					val_sym := g.table.sym(info.value_type)
+					if val_sym.kind == .function {
 						left_type := node.left_types[i]
 						left_sym := g.table.sym(left_type)
 						g.write_fn_ptr_decl(left_sym.info as ast.FnType, '_var_${left.pos.pos}')
@@ -1337,7 +1337,7 @@ fn (mut g Gen) gen_cross_var_assign(node &ast.AssignStmt) {
 					g.write(', &(${skeytyp}[]){')
 					g.expr(left.index)
 					g.write('}')
-					if val_typ.kind == .function {
+					if val_sym.kind == .function {
 						g.writeln(', &(voidptr[]){ ${zero} });')
 					} else {
 						g.writeln(', &(${styp}[]){ ${zero} });')
diff --git a/vlib/v/gen/c/cgen.v b/vlib/v/gen/c/cgen.v
@@ -7573,8 +7573,8 @@ fn (mut g Gen) type_default_impl(typ_ ast.Type, decode_sumtype bool) string {
 		}
 		.map {
 			info := sym.map_info()
-			key_typ := g.table.sym(info.key_type)
-			hash_fn, key_eq_fn, clone_fn, free_fn := g.map_fn_ptrs(key_typ)
+			key_sym := g.table.sym(info.key_type)
+			hash_fn, key_eq_fn, clone_fn, free_fn := g.map_fn_ptrs(key_sym)
 			noscan_key := g.check_noscan(info.key_type)
 			noscan_value := g.check_noscan(info.value_type)
 			mut noscan := if noscan_key.len != 0 || noscan_value.len != 0 { '_noscan' } else { '' }
@@ -7588,7 +7588,7 @@ fn (mut g Gen) type_default_impl(typ_ ast.Type, decode_sumtype bool) string {
 			}
 			init_str := 'builtin__new_map${noscan}(sizeof(${g.styp(info.key_type)}), sizeof(${g.styp(info.value_type)}), ${hash_fn}, ${key_eq_fn}, ${clone_fn}, ${free_fn})'
 			if typ.has_flag(.shared_f) {
-				mtyp := '__shared__Map_${key_typ.cname}_${g.styp(info.value_type).replace('*',
+				mtyp := '__shared__Map_${key_sym.cname}_${g.styp(info.value_type).replace('*',
 					'_ptr')}'
 				return '(${mtyp}*)__dup_shared_map(&(${mtyp}){.mtx = {0}, .val =${init_str}}, sizeof(${mtyp}))'
 			} else {
diff --git a/vlib/v/gen/js/js.v b/vlib/v/gen/js/js.v
@@ -2913,10 +2913,10 @@ fn (mut g JsGen) gen_if_expr(node ast.IfExpr) {
 }
 
 fn (mut g JsGen) gen_index_expr(expr ast.IndexExpr) {
-	left_typ := g.table.sym(expr.left_type)
+	left_sym := g.table.sym(expr.left_type)
 	// TODO: Handle splice setting if it's implemented
 	if expr.index is ast.RangeExpr {
-		if left_typ.kind == .string {
+		if left_sym.kind == .string {
 			g.write('string_slice(')
 		} else {
 			g.write('array_slice(')
@@ -2943,7 +2943,7 @@ fn (mut g JsGen) gen_index_expr(expr ast.IndexExpr) {
 			g.write('.len')
 		}
 		g.write(')')
-	} else if left_typ.kind == .map {
+	} else if left_sym.kind == .map {
 		g.expr(expr.left)
 
 		if expr.is_setter {
@@ -2956,17 +2956,17 @@ fn (mut g JsGen) gen_index_expr(expr ast.IndexExpr) {
 		g.write('.\$toJS()')
 		if expr.is_setter {
 			// g.write(', ${g.to_js_typ_val(left_typ.)')
-			match left_typ.info {
+			match left_sym.info {
 				ast.Map {
-					g.write(', ${g.to_js_typ_val(left_typ.info.value_type)}')
+					g.write(', ${g.to_js_typ_val(left_sym.info.value_type)}')
 				}
 				else {
 					verror('unreachable')
 				}
 			}
 		}
 		g.write(')')
-	} else if left_typ.kind == .string {
+	} else if left_sym.kind == .string {
 		if expr.is_setter {
 			// TODO: What's the best way to do this?
 			// 'string'[3] = `o`
@@ -3769,10 +3769,11 @@ fn replace_op(s string) string {
 }
 
 fn (mut g JsGen) gen_postfix_index_expr(expr ast.IndexExpr, op token.Kind) {
-	left_typ := g.table.sym(expr.left_type)
+	left_sym := g.table.sym(expr.left_type)
+	left_sym_kind := left_sym.kind
 	// TODO: Handle splice setting if it's implemented
 	if expr.index is ast.RangeExpr {
-		if left_typ.kind == .array {
+		if left_sym_kind == .array {
 			g.write('array_slice(')
 		} else {
 			g.write('string_slice(')
@@ -3799,7 +3800,7 @@ fn (mut g JsGen) gen_postfix_index_expr(expr ast.IndexExpr, op token.Kind) {
 			g.write('.len')
 		}
 		g.write(')')
-	} else if left_typ.kind == .map {
+	} else if left_sym_kind == .map {
 		g.expr(expr.left)
 
 		if expr.is_setter {
@@ -3842,7 +3843,7 @@ fn (mut g JsGen) gen_postfix_index_expr(expr ast.IndexExpr, op token.Kind) {
 			}
 			g.write(')')
 		}
-	} else if left_typ.kind == .string {
+	} else if left_sym_kind == .string {
 		if expr.is_setter {
 			// TODO: What's the best way to do this?
 			// 'string'[3] = `o`
diff --git a/vlib/v/gen/wasm/gen.v b/vlib/v/gen/wasm/gen.v
@@ -858,8 +858,8 @@ pub fn (mut g Gen) expr(node ast.Expr, expected ast.Type) {
 			g.literalint(g.enum_vals[type_name].fields[node.val], ts_type)
 		}
 		ast.OffsetOf {
-			styp := g.table.sym(node.struct_type)
-			if styp.kind != .struct {
+			sym := g.table.sym(node.struct_type)
+			if sym.kind != .struct {
 				g.v_error('__offsetof expects a struct Type as first argument', node.pos)
 			}
 			off := g.get_field_offset(node.struct_type, node.field)

Original file line number	Diff line number	Diff line change
`@@ -1164,8 +1164,7 @@ pub fn (mut t Table) find_or_register_chan(elem_type Type, is_mut bool) int {`
`1164`	`1164`	`if existing_idx > 0 {`
`1165`	`1165`	`return existing_idx`
`1166`	`1166`	`}`
`1167`		`- // register`
`1168`		`- chan_typ := TypeSymbol{`
	`1167`	`+ chan_sym := TypeSymbol{`
`1169`	`1168`	`parent_idx: chan_type_idx`
`1170`	`1169`	`kind: .chan`
`1171`	`1170`	`name: name`
`@@ -1175,7 +1174,7 @@ pub fn (mut t Table) find_or_register_chan(elem_type Type, is_mut bool) int {`
`1175`	`1174`	`is_mut: is_mut`
`1176`	`1175`	`}`
`1177`	`1176`	`}`
`1178`		`- return t.register_sym(chan_typ)`
	`1177`	`+ return t.register_sym(chan_sym)`
`1179`	`1178`	`}`
`1180`	`1179`
`1181`	`1180`	`pub fn (mut t Table) find_or_register_map(key_type Type, value_type Type) int {`
`@@ -1186,8 +1185,7 @@ pub fn (mut t Table) find_or_register_map(key_type Type, value_type Type) int {`
`1186`	`1185`	`if existing_idx > 0 {`
`1187`	`1186`	`return existing_idx`
`1188`	`1187`	`}`
`1189`		`- // register`
`1190`		`- map_typ := TypeSymbol{`
	`1188`	`+ map_sym := TypeSymbol{`
`1191`	`1189`	`parent_idx: map_type_idx`
`1192`	`1190`	`kind: .map`
`1193`	`1191`	`name: name`
`@@ -1197,7 +1195,7 @@ pub fn (mut t Table) find_or_register_map(key_type Type, value_type Type) int {`
`1197`	`1195`	`value_type: value_type`
`1198`	`1196`	`}`
`1199`	`1197`	`}`
`1200`		`- return t.register_sym(map_typ)`
	`1198`	`+ return t.register_sym(map_sym)`
`1201`	`1199`	`}`
`1202`	`1200`
`1203`	`1201`	`pub fn (mut t Table) find_or_register_thread(return_type Type) int {`
`@@ -1208,8 +1206,7 @@ pub fn (mut t Table) find_or_register_thread(return_type Type) int {`
`1208`	`1206`	`if existing_idx > 0 {`
`1209`	`1207`	`return existing_idx`
`1210`	`1208`	`}`
`1211`		`- // register`
`1212`		`- thread_typ := TypeSymbol{`
	`1209`	`+ thread_sym := TypeSymbol{`
`1213`	`1210`	`parent_idx: thread_type_idx`
`1214`	`1211`	`kind: .thread`
`1215`	`1212`	`name: name`
`@@ -1218,7 +1215,7 @@ pub fn (mut t Table) find_or_register_thread(return_type Type) int {`
`1218`	`1215`	`return_type: return_type`
`1219`	`1216`	`}`
`1220`	`1217`	`}`
`1221`		`- return t.register_sym(thread_typ)`
	`1218`	`+ return t.register_sym(thread_sym)`
`1222`	`1219`	`}`
`1223`	`1220`
`1224`	`1221`	`pub fn (mut t Table) find_or_register_promise(return_type Type) int {`
`@@ -1321,16 +1318,15 @@ pub fn (mut t Table) find_or_register_multi_return(mr_typs []Type) int {`
`1321`	`1318`	`if existing_idx > 0 {`
`1322`	`1319`	`return existing_idx`
`1323`	`1320`	`}`
`1324`		`- // register`
`1325`		`- mr_type := TypeSymbol{`
	`1321`	`+ multireg_sym := TypeSymbol{`
`1326`	`1322`	`kind: .multi_return`
`1327`	`1323`	`name: name`
`1328`	`1324`	`cname: cname`
`1329`	`1325`	`info: MultiReturn{`
`1330`	`1326`	`types: mr_typs`
`1331`	`1327`	`}`
`1332`	`1328`	`}`
`1333`		`- return t.register_sym(mr_type)`
	`1329`	`+ return t.register_sym(multireg_sym)`
`1334`	`1330`	`}`
`1335`	`1331`
`1336`	`1332`	`pub fn (mut t Table) find_or_register_fn_type(f Fn, is_anon bool, has_decl bool) int {`
`@@ -1366,7 +1362,7 @@ pub fn (mut t Table) add_placeholder_type(name string, cname string, language La`
`1366`	`1362`	`if name.contains('.') {`
`1367`	`1363`	`modname = name.all_before_last('.')`
`1368`	`1364`	`}`
`1369`		`- ph_type := TypeSymbol{`
	`1365`	`+ placeholder_sym := TypeSymbol{`
`1370`	`1366`	`kind: .placeholder`
`1371`	`1367`	`name: name`
`1372`	`1368`	`cname: util.no_dots(cname).replace_each(['&', ''])`
`@@ -1375,7 +1371,7 @@ pub fn (mut t Table) add_placeholder_type(name string, cname string, language La`
`1375`	`1371`	`is_pub: true`
`1376`	`1372`	`is_builtin: name in builtins`
`1377`	`1373`	`}`
`1378`		`- return t.register_sym(ph_type)`
	`1374`	`+ return t.register_sym(placeholder_sym)`
`1379`	`1375`	`}`
`1380`	`1376`
`1381`	`1377`	`@[inline]`
Original file line number	Diff line number	Diff line change
`@@ -122,8 +122,8 @@ fn (mut c Checker) interface_decl(mut node ast.InterfaceDecl) {`
`122`	`122`	`continue`
`123`	`123`	`}`
`124`	`124`	`if is_js {`
`125`		`- mtyp := c.table.sym(method.return_type)`
`126`		`- if !mtyp.is_js_compatible() {`
	`125`	`+ mrsym := c.table.sym(method.return_type)`
	`126`	`+ if !mrsym.is_js_compatible() {`
`127`	`127`	`c.error('method ${method.name} returns non JS type', method.pos)`
`128`	`128`	`}`
`129`	`129`	`}`
`@@ -179,8 +179,8 @@ fn (mut c Checker) interface_decl(mut node ast.InterfaceDecl) {`
`179`	`179`	`}`
`180`	`180`	`}`
`181`	`181`	`if is_js {`
`182`		`- ptyp := c.table.sym(param.typ)`
`183`		`- if !ptyp.is_js_compatible() && !(j == method.params.len - 1`
	`182`	`+ psym := c.table.sym(param.typ)`
	`183`	`+ if !psym.is_js_compatible() && !(j == method.params.len - 1`
`184`	`184`	`&& method.is_variadic) {`
`185`	`185`	c.error('method `${method.name}` accepts non JS type as parameter',
`186`	`186`	`method.pos)`
Original file line number	Diff line number	Diff line change
`@@ -858,8 +858,8 @@ pub fn (mut g Gen) expr(node ast.Expr, expected ast.Type) {`
`858`	`858`	`g.literalint(g.enum_vals[type_name].fields[node.val], ts_type)`
`859`	`859`	`}`
`860`	`860`	`ast.OffsetOf {`
`861`		`- styp := g.table.sym(node.struct_type)`
`862`		`- if styp.kind != .struct {`
	`861`	`+ sym := g.table.sym(node.struct_type)`
	`862`	`+ if sym.kind != .struct {`
`863`	`863`	`g.v_error('__offsetof expects a struct Type as first argument', node.pos)`
`864`	`864`	`}`
`865`	`865`	`off := g.get_field_offset(node.struct_type, node.field)`