parser,ast: add vls info to support improvements to vls goto definition (#25492)

Author: kbkpbot

vlib/v/ast/table.v

@@ -6,6 +6,7 @@ module ast
 
 import v.cflag
 import v.util
+import v.token
 
 @[heap; minify]
 pub struct UsedFeatures {
@@ -87,6 +88,7 @@ pub mut:
 	gostmts            int    // how many `go` statements there were in the parsed files.
 	// When table.gostmts > 0, __VTHREADS__ is defined, which can be checked with `$if threads {`
 	enum_decls        map[string]EnumDecl
+	vls_info          map[string]VLSInfo
 	module_deprecated map[string]bool
 	module_attrs      map[string][]Attr // module attributes
 	builtin_pub_fns   map[string]bool
@@ -111,6 +113,14 @@ pub mut:
 	c_str string
 }
 
+pub struct VLSInfo {
+pub mut:
+	pos          token.Pos
+	pre_comments []Comment
+	comments     []Comment
+	end_comments []Comment
+}
+
 // used by vls to avoid leaks
 // TODO: remove manual memory management
 @[unsafe]
@@ -2765,3 +2775,8 @@ pub fn (mut t Table) get_veb_result_type_idx() int {
 	t.veb_res_idx_cache = t.find_type('veb.Result')
 	return t.veb_res_idx_cache
 }
+
+@[inline]
+pub fn (mut t Table) register_vls_info(key string, val VLSInfo) {
+	t.vls_info[key] = val
+}

vlib/v/parser/enum.v

@@ -253,6 +253,24 @@ fn (mut p Parser) enum_decl() ast.EnumDecl {
 
 	if !already_exists {
 		p.table.register_enum_decl(enum_decl)
+		if p.pref.is_vls {
+			key := 'enum_${name}'
+			val := ast.VLSInfo{
+				pos:      typ_pos
+				comments: enum_decl_comments
+			}
+			p.table.register_vls_info(key, val)
+			for f in fields {
+				f_key := 'enum_${name}.${f.name}'
+				f_val := ast.VLSInfo{
+					pos:          f.pos
+					pre_comments: f.pre_comments
+					comments:     f.comments
+					end_comments: f.next_comments
+				}
+				p.table.register_vls_info(f_key, f_val)
+			}
+		}
 	}
 	return enum_decl
 }

vlib/v/parser/fn.v

@@ -753,6 +753,19 @@ run them via `v file.v` instead',
 		p.table.register_fn_generic_types(fn_decl.fkey())
 	}
 	p.label_names = []
+	if p.pref.is_vls {
+		type_str := if (is_method || is_static_type_method) && rec.typ != ast.no_type {
+			p.table.sym(rec.typ.idx_type()).name.all_after_last('.')
+		} else {
+			''
+		}
+		key := 'fn_${p.mod}[${type_str}]${short_fn_name}'
+		val := ast.VLSInfo{
+			pos:      fn_decl.pos
+			comments: fn_decl.comments // TODO: we need comment just before fn decl
+		}
+		p.table.register_vls_info(key, val)
+	}
 	return fn_decl
 }
 

vlib/v/parser/parser.v

@@ -2572,14 +2572,26 @@ fn (mut p Parser) const_decl() ast.ConstDecl {
 	} else {
 		comments << p.eat_comments(same_line: true)
 	}
-	return ast.ConstDecl{
+	const_decl := ast.ConstDecl{
 		pos:          start_pos.extend_with_last_line(const_pos, p.prev_tok.line_nr)
 		fields:       fields
 		is_pub:       is_pub
 		end_comments: comments
 		is_block:     is_block
 		attrs:        attrs
 	}
+	if p.pref.is_vls {
+		for f in fields {
+			key := 'const_${f.name}'
+			val := ast.VLSInfo{
+				pos:          f.pos
+				comments:     f.comments
+				end_comments: f.end_comments
+			}
+			p.table.register_vls_info(key, val)
+		}
+	}
+	return const_decl
 }
 
 fn (mut p Parser) return_stmt() ast.Return {
@@ -2732,14 +2744,29 @@ fn (mut p Parser) global_decl() ast.GlobalDecl {
 	if is_block {
 		p.check(.rpar)
 	}
-	return ast.GlobalDecl{
+	global_decl := ast.GlobalDecl{
 		pos:          start_pos.extend(p.prev_tok.pos())
 		mod:          p.mod
 		fields:       fields
 		end_comments: comments
 		is_block:     is_block
 		attrs:        attrs
 	}
+	if p.pref.is_vls {
+		for f in fields {
+			mut key := 'global_${f.name}'
+			val := ast.VLSInfo{
+				pos:      global_decl.pos
+				comments: f.comments
+			}
+			p.table.register_vls_info(key, val)
+
+			// register another `module specific global`
+			key = 'global_${p.prepend_mod(f.name)}'
+			p.table.register_vls_info(key, val)
+		}
+	}
+	return global_decl
 }
 
 fn source_name(name string) string {
@@ -2802,7 +2829,7 @@ fn (mut p Parser) type_decl() ast.TypeDecl {
 		type_pos = type_pos.extend(p.tok.pos())
 		comments = p.eat_comments(same_line: true)
 		p.attrs = []
-		return ast.FnTypeDecl{
+		fn_type_decl := ast.FnTypeDecl{
 			name:          fn_name
 			mod:           p.mod
 			is_pub:        is_pub
@@ -2814,6 +2841,15 @@ fn (mut p Parser) type_decl() ast.TypeDecl {
 			attrs:         attrs
 			is_markused:   attrs.contains('markused')
 		}
+		if p.pref.is_vls {
+			key := 'fntype_${fn_name}'
+			val := ast.VLSInfo{
+				pos:      decl_pos
+				comments: comments
+			}
+			p.table.register_vls_info(key, val)
+		}
+		return fn_type_decl
 	}
 	sum_variants << p.parse_sum_type_variants()
 	// type SumType = Aaa | Bbb | Ccc
@@ -2862,6 +2898,13 @@ fn (mut p Parser) type_decl() ast.TypeDecl {
 			is_markused:   attrs.contains('markused')
 		}
 		p.table.register_sumtype(node)
+		if p.pref.is_vls {
+			key := 'sumtype_${p.prepend_mod(name)}'
+			val := ast.VLSInfo{
+				pos: node.pos
+			}
+			p.table.register_vls_info(key, val)
+		}
 		return node
 	}
 	// type MyType = int
@@ -2905,7 +2948,7 @@ fn (mut p Parser) type_decl() ast.TypeDecl {
 	}
 	comments = sum_variants[0].end_comments.clone()
 	p.attrs = []
-	return ast.AliasTypeDecl{
+	alias_type_decl := ast.AliasTypeDecl{
 		name:        name
 		is_pub:      is_pub
 		typ:         idx
@@ -2916,6 +2959,15 @@ fn (mut p Parser) type_decl() ast.TypeDecl {
 		is_markused: attrs.contains('markused')
 		attrs:       attrs
 	}
+	if p.pref.is_vls {
+		key := 'aliastype_${p.prepend_mod(name)}'
+		val := ast.VLSInfo{
+			pos:      alias_type_decl.pos
+			comments: comments
+		}
+		p.table.register_vls_info(key, val)
+	}
+	return alias_type_decl
 }
 
 fn (mut p Parser) assoc() ast.Assoc {

vlib/v/parser/struct.v

@@ -466,7 +466,7 @@ fn (mut p Parser) struct_decl(is_anon bool) ast.StructDecl {
 		return ast.StructDecl{}
 	}
 	p.expr_mod = ''
-	return ast.StructDecl{
+	struct_decl := ast.StructDecl{
 		name:             name
 		scoped_name:      scoped_name
 		is_pub:           is_pub
@@ -489,6 +489,24 @@ fn (mut p Parser) struct_decl(is_anon bool) ast.StructDecl {
 		is_implements:    is_implements
 		implements_types: implements_types
 	}
+	if p.pref.is_vls {
+		key := 'struct_${name}'
+		val := ast.VLSInfo{
+			pos:          struct_decl.pos
+			pre_comments: pre_comments
+		}
+		p.table.register_vls_info(key, val)
+		for f in ast_fields {
+			f_key := 'struct_${name}.${f.name}'
+			f_val := ast.VLSInfo{
+				pos:          f.pos
+				pre_comments: f.pre_comments
+				comments:     f.comments
+			}
+			p.table.register_vls_info(f_key, f_val)
+		}
+	}
+	return struct_decl
 }
 
 fn (mut p Parser) struct_init(typ_str string, kind ast.StructInitKind, is_option bool) ast.StructInit {
@@ -879,5 +897,21 @@ fn (mut p Parser) interface_decl() ast.InterfaceDecl {
 		name_pos:      name_pos
 	}
 	p.table.register_interface(res)
+	if p.pref.is_vls {
+		key := 'interface_${interface_name}'
+		val := ast.VLSInfo{
+			pos:          pos
+			pre_comments: pre_comments
+		}
+		p.table.register_vls_info(key, val)
+		for f in fields {
+			f_key := 'interface_${interface_name}.${f.name}'
+			f_val := ast.VLSInfo{
+				pos:      f.pos
+				comments: f.comments
+			}
+			p.table.register_vls_info(f_key, f_val)
+		}
+	}
 	return res
 }

vlib/v/parser/v_parser_test.v

@@ -314,3 +314,56 @@ fn test_parse_with_stdout() {
 	println(@LOCATION)
 	parse(.stdout)!
 }
+
+fn test_parse_vls_info() {
+	println(@LOCATION)
+	source_text := '
+const my_const = 123
+struct MyS {
+	a int
+}
+interface MyInterface {
+	method() string
+}
+__global my_global = 456
+type MyAlias = u8
+type MySum = u8 | u16
+type MyFnType = fn (msg &char, arg usize)
+
+fn (mut k MyS) add(val int) {
+	k.a += val
+}
+
+fn foo() int {
+	f := 23
+	return 10+4+f
+}
+fn ff(x int) {}
+
+fn main() {
+  ff(12 + 3)
+  x := 10
+  bar(5+7)
+  ff(8+x)
+}
+'
+	mut table := ast.new_table()
+	vpref := &pref.Preferences{
+		enable_globals: true
+		is_vls:         true
+	}
+	mut prog := parse_text(source_text, '', mut table, .skip_comments, vpref)
+	mut checker_ := checker.new_checker(table, vpref)
+	checker_.check(mut prog)
+
+	assert 'const_main.my_const' in table.vls_info
+	assert 'struct_main.MyS' in table.vls_info
+	assert 'interface_main.MyInterface' in table.vls_info
+	assert 'fn_main[MyS]add' in table.vls_info // MyS method
+	assert 'fn_main[]foo' in table.vls_info
+	assert 'global_main.my_global' in table.vls_info // module specific global
+	assert 'global_my_global' in table.vls_info
+	assert 'aliastype_main.MyAlias' in table.vls_info
+	assert 'sumtype_main.MySum' in table.vls_info
+	assert 'fntype_main.MyFnType' in table.vls_info
+}