ci: fix v2 tests

Author: spytheman

vlib/v2/markused/markused_test.v

@@ -1,8 +1,16 @@
 module markused
 
 import v2.ast
+import v2.token
 import v2.types
 
+fn pos(id int) token.Pos {
+	return token.Pos{
+		offset: id
+		id:     id
+	}
+}
+
 fn test_mark_used_tracks_transitive_function_calls() {
 	mut env := types.Environment.new()
 	files := [
@@ -13,44 +21,44 @@ fn test_mark_used_tracks_transitive_function_calls() {
 				ast.Stmt(ast.FnDecl{
 					name:  'main'
 					typ:   ast.FnType{}
-					pos:   1
+					pos:   pos(1)
 					stmts: [
 						ast.Stmt(ast.ExprStmt{
 							expr: ast.CallExpr{
 								lhs: ast.Ident{
 									name: 'foo'
-									pos:  2
+									pos:  pos(2)
 								}
-								pos: 2
+								pos: pos(2)
 							}
 						}),
 					]
 				}),
 				ast.Stmt(ast.FnDecl{
 					name:  'foo'
 					typ:   ast.FnType{}
-					pos:   3
+					pos:   pos(3)
 					stmts: [
 						ast.Stmt(ast.ExprStmt{
 							expr: ast.CallExpr{
 								lhs: ast.Ident{
 									name: 'bar'
-									pos:  4
+									pos:  pos(4)
 								}
-								pos: 4
+								pos: pos(4)
 							}
 						}),
 					]
 				}),
 				ast.Stmt(ast.FnDecl{
 					name: 'bar'
 					typ:  ast.FnType{}
-					pos:  5
+					pos:  pos(5)
 				}),
 				ast.Stmt(ast.FnDecl{
 					name: 'dead'
 					typ:  ast.FnType{}
-					pos:  6
+					pos:  pos(6)
 				}),
 			]
 		},
@@ -79,22 +87,22 @@ fn test_mark_used_tracks_method_calls_with_env_types() {
 				ast.Stmt(ast.FnDecl{
 					name:  'main'
 					typ:   ast.FnType{}
-					pos:   10
+					pos:   pos(10)
 					stmts: [
 						ast.Stmt(ast.ExprStmt{
 							expr: ast.CallExpr{
 								lhs: ast.SelectorExpr{
 									lhs: ast.Ident{
 										name: 'w'
-										pos:  12
+										pos:  pos(12)
 									}
 									rhs: ast.Ident{
 										name: 'ping'
-										pos:  13
+										pos:  pos(13)
 									}
-									pos: 13
+									pos: pos(13)
 								}
-								pos: 13
+								pos: pos(13)
 							}
 						}),
 					]
@@ -105,27 +113,27 @@ fn test_mark_used_tracks_method_calls_with_env_types() {
 						name: 'w'
 						typ:  ast.Ident{
 							name: 'Widget'
-							pos:  14
+							pos:  pos(14)
 						}
-						pos:  14
+						pos:  pos(14)
 					}
 					name:      'ping'
 					typ:       ast.FnType{}
-					pos:       15
+					pos:       pos(15)
 				}),
 				ast.Stmt(ast.FnDecl{
 					is_method: true
 					receiver:  ast.Parameter{
 						name: 'w'
 						typ:  ast.Ident{
 							name: 'Widget'
-							pos:  16
+							pos:  pos(16)
 						}
-						pos:  16
+						pos:  pos(16)
 					}
 					name:      'unused'
 					typ:       ast.FnType{}
-					pos:       17
+					pos:       pos(17)
 				}),
 			]
 		},
@@ -149,12 +157,12 @@ fn test_mark_used_keeps_all_functions_when_no_entry_root_exists() {
 				ast.Stmt(ast.FnDecl{
 					name: 'a'
 					typ:  ast.FnType{}
-					pos:  21
+					pos:  pos(21)
 				}),
 				ast.Stmt(ast.FnDecl{
 					name: 'b'
 					typ:  ast.FnType{}
-					pos:  22
+					pos:  pos(22)
 				}),
 			]
 		},

vlib/v2/transformer/transformer.v

@@ -872,6 +872,12 @@ fn (t &Transformer) is_interface_var(name string) bool {
 // get_var_type_name returns the type name of a variable from scope lookup
 fn (t &Transformer) get_var_type_name(name string) string {
 	typ := t.lookup_var_type(name) or { return '' }
+	if typ is types.Alias {
+		if typ.name != '' {
+			return typ.name
+		}
+		return t.type_to_name(typ.base_type)
+	}
 	if typ is types.String {
 		return 'string'
 	}
@@ -6180,7 +6186,11 @@ fn (mut t Transformer) transform_index_expr(expr ast.IndexExpr) ast.Expr {
 
 	// Lower map reads `m[key]` to `map__get(&m, &key, &zero)` in transformer so backends
 	// do not need map-specific IndexExpr logic.
-	if map_expr_typ := t.get_expr_type(expr.lhs) {
+	mut map_expr_type_opt := t.get_expr_type(expr.lhs)
+	if map_expr_type_opt == none && expr.lhs is ast.Ident {
+		map_expr_type_opt = t.lookup_var_type((expr.lhs as ast.Ident).name)
+	}
+	if map_expr_typ := map_expr_type_opt {
 		if map_type := t.unwrap_map_type(map_expr_typ) {
 			synth_pos := t.next_synth_pos()
 
@@ -9543,8 +9553,8 @@ fn (t &Transformer) infer_variant_type(value ast.Expr, variants []string) string
 			}
 		}
 		// Prefer checker-provided types for match/smartcast narrowing.
-		if value.pos > 0 {
-			if typ := t.env.get_expr_type(value.pos) {
+		if value.pos.is_valid() {
+			if typ := t.env.get_expr_type(value.pos.id) {
 				matched2 := match_sumtype_variant_name(t.type_to_c_name(typ), variants)
 				if matched2 != '' {
 					return matched2
@@ -10873,15 +10883,16 @@ fn (mut t Transformer) empty_struct_arg_expr(param_type types.Type) ast.Expr {
 	if t.is_pointer_type(param_type) {
 		mut cur := param_type
 		for cur is types.Alias {
-			cur = cur.base_type
+			cur = cur.base_type()
 		}
 		if cur is types.Pointer {
+			ptr := cur as types.Pointer
 			init_pos := t.next_synth_pos()
 			ptr_pos := t.next_synth_pos()
-			t.register_synth_type(init_pos, cur.base_type)
+			t.register_synth_type(init_pos, ptr.base_type)
 			t.register_synth_type(ptr_pos, param_type)
 			init_expr := ast.Expr(ast.InitExpr{
-				typ: t.type_to_ast_type_expr(cur.base_type)
+				typ: t.type_to_ast_type_expr(ptr.base_type)
 				pos: init_pos
 			})
 			return ast.Expr(ast.PrefixExpr{
@@ -11036,10 +11047,11 @@ fn (mut t Transformer) lower_struct_shorthand_call(args []ast.Expr, param_types
 	if t.is_pointer_type(param_type) {
 		mut cur := param_type
 		for cur is types.Alias {
-			cur = cur.base_type
+			cur = cur.base_type()
 		}
 		if cur is types.Pointer {
-			init_typ = cur.base_type
+			ptr := cur as types.Pointer
+			init_typ = ptr.base_type
 		}
 	}
 	init_pos := t.next_synth_pos()

vlib/v2/types/checker_test.v

@@ -1,7 +1,6 @@
 // Copyright (c) 2026 Alexander Medvednikov. All rights reserved.
 // Use of this source code is governed by an MIT license
 // that can be found in the LICENSE file.
-// vtest build: false
 module types
 
 import os
@@ -80,7 +79,7 @@ fn test_basic_literal_bool_false() {
 
 fn test_basic_literal_char() {
 	env := check_code('fn main() { x := `a` }')
-	assert has_type(env, 'char'), 'char literal should have char type'
+	assert has_type(env, 'rune'), 'char literal should have rune type'
 }
 
 fn test_basic_literal_string() {

vlib/v2/types/types.v

@@ -129,7 +129,7 @@ fn FnTypeAttribute.from_ast_attributes(ast_attrs []ast.Attribute) FnTypeAttribut
 	return attrs
 }
 
-struct FnType {
+pub struct FnType {
 	// generic_params []NamedType // T  ,Y
 	generic_params []string // T  ,Y
 	// TODO: save in checker.env? or gere?