vlang
diff --git a/Collapse file
‎vlib/v/ast/types.v‎
Copy file name to clipboard
+6Lines changed: 6 additions & 0 deletions b/Collapse file
‎vlib/v/ast/types.v‎
Copy file name to clipboard
+6Lines changed: 6 additions & 0 deletions
diff --git a/Collapse file
‎vlib/v/builder/builder.v‎
Copy file name to clipboard
+3-2Lines changed: 3 additions & 2 deletions b/Collapse file
‎vlib/v/builder/builder.v‎
Copy file name to clipboard
+3-2Lines changed: 3 additions & 2 deletions
diff --git a/Collapse file
‎vlib/v/checker/autocomplete.v‎
Copy file name to clipboard
+117-47Lines changed: 117 additions & 47 deletions b/Collapse file
‎vlib/v/checker/autocomplete.v‎
Copy file name to clipboard
+117-47Lines changed: 117 additions & 47 deletions
diff --git a/Collapse file
‎vlib/v/checker/checker.v‎
Copy file name to clipboard
+9-33Lines changed: 9 additions & 33 deletions b/Collapse file
‎vlib/v/checker/checker.v‎
Copy file name to clipboard
+9-33Lines changed: 9 additions & 33 deletions
diff --git a/Collapse file
‎vlib/v/checker/fn.v‎
Copy file name to clipboard
+1-3Lines changed: 1 addition & 3 deletions b/Collapse file
‎vlib/v/checker/fn.v‎
Copy file name to clipboard
+1-3Lines changed: 1 addition & 3 deletions
diff --git a/Collapse file
‎vlib/v/parser/parser.v‎
Copy file name to clipboard
+2-5Lines changed: 2 additions & 5 deletions b/Collapse file
‎vlib/v/parser/parser.v‎
Copy file name to clipboard
+2-5Lines changed: 2 additions & 5 deletions
@@ -188,6 +188,7 @@ pub mut:
 	generic_types  []Type
 	concrete_types []Type
 	parent_type    Type
+	name_pos       token.Pos
 }
 
 // instantiation of a generic struct
@@ -212,6 +213,7 @@ pub mut:
 	generic_types  []Type
 	concrete_types []Type
 	parent_type    Type
+	name_pos       token.Pos
 }
 
 pub struct Enum {
@@ -222,6 +224,7 @@ pub:
 	uses_exprs       bool
 	typ              Type
 	attrs            map[string][]Attr
+	name_pos         token.Pos
 }
 
 @[minify]
@@ -231,6 +234,7 @@ pub mut:
 pub:
 	language  Language
 	is_import bool
+	name_pos  token.Pos
 }
 
 pub struct Aggregate {
@@ -273,6 +277,7 @@ pub struct Map {
 pub mut:
 	key_type   Type
 	value_type Type
+	name_pos   token.Pos
 }
 
 @[minify]
@@ -287,6 +292,7 @@ pub mut:
 	generic_types  []Type
 	concrete_types []Type
 	parent_type    Type
+	name_pos       token.Pos
 }
 
 // <atomic.h> defines special typenames
 
@@ -549,10 +549,11 @@ pub fn (mut b Builder) print_warnings_and_errors() {
 			}
 		}
 		if b.pref.json_errors {
-			util.print_json_errors(json_errors)
+			if !b.pref.is_vls || b.pref.linfo.method !in [.definition, .completion, .signature_help] {
+				util.print_json_errors(json_errors)
+			}
 			// eprintln(json2.encode_pretty(json_errors))
 		}
-
 		if !b.pref.skip_warnings {
 			for file in b.parsed_files {
 				for err in file.warnings {
 
@@ -5,6 +5,7 @@ module checker
 import strings
 import v.ast
 import os
+import token
 
 enum DetailKind {
 	text           = 1
@@ -43,77 +44,130 @@ struct Detail {
 	insert_text_format ?int // 1 for PlainText, 2 for Snippet
 }
 
+fn (mut c Checker) get_fn_from_call_expr(node ast.CallExpr) !ast.Fn {
+	fn_name := node.name
+	return if node.is_method {
+		left_sym := c.table.sym(c.unwrap_generic(node.left_type))
+		c.table.find_method(left_sym, fn_name) or {
+			return error('failed to find method "${fn_name}"')
+		}
+	} else {
+		c.table.find_fn(fn_name) or { return error('failed to find fn "${fn_name}"') }
+	}
+}
+
 // Autocomplete for function parameters `os.write_bytes(**path string, bytes []u8***)` etc
 pub fn (mut c Checker) autocomplete_for_fn_call_expr(node ast.CallExpr) {
-	// Make sure this ident is on the same line and same file as request
-	same_line := c.pref.linfo.line_nr + 1 == node.pos.line_nr
-	if !same_line {
-		return
-	}
-	if node.pos.file_idx < 0 {
+	if c.pref.linfo.method != .signature_help {
 		return
 	}
-	if c.pref.linfo.path != c.table.filelist[node.pos.file_idx] {
+	if !c.vls_is_the_node(node.name_pos) {
 		return
 	}
-	col := c.pref.linfo.expr.all_after_last('^').int()
-	if node.name_pos.col + node.name_pos.len + 1 != col {
-		return
-	}
-	fn_name := node.name
-	f := if node.is_method {
-		left_sym := c.table.sym(c.unwrap_generic(node.left_type))
-		c.table.find_method(left_sym, fn_name) or {
-			println('failed to find method "${fn_name}"')
-			return
-		}
-	} else {
-		c.table.find_fn(fn_name) or {
-			println('failed to find fn "${fn_name}"')
-			return
-		}
+	f := c.get_fn_from_call_expr(node) or {
+		println(err)
+		exit(1)
 	}
 	res := c.build_fn_summary(f)
 	println(res)
 	exit(0)
 }
 
-fn (mut c Checker) ident_gotodef() {
-	mut ident_name := c.pref.linfo.expr.after('gd^').trim_space()
-	mod_name := ident_name.all_before_last('.')
-	resolved_mod_name := c.try_resolve_to_import_mod_name(mod_name)
-	if resolved_mod_name.len > 0 {
-		ident_name = resolved_mod_name + '.' + ident_name.all_after_last('.')
-	}
-	if f := c.table.find_fn(ident_name) {
-		println('${f.file}:${f.pos.line_nr}:${f.pos.col}')
+fn (mut c Checker) ident_gotodef(node_ ast.Expr) {
+	if c.pref.linfo.method != .definition {
+		return
+	}
+	if !c.vls_is_the_node(node_.pos()) {
 		return
 	}
+	mut node := unsafe { node_ }
+	mut pos := token.Pos{}
+	match mut node {
+		ast.CallExpr {
+			if !c.vls_is_the_node(node.name_pos) {
+				return
+			}
+			f := c.get_fn_from_call_expr(node) or {
+				println(err)
+				exit(1)
+			}
+			pos = f.name_pos
+		}
+		ast.Ident {
+			// global objects
+			for _, obj in c.table.global_scope.objects {
+				if obj is ast.ConstField && obj.name == node.name {
+					pos = obj.pos
+					break
+				} else if obj is ast.GlobalField && obj.name == node.name {
+					pos = obj.pos
+					break
+				} else if obj is ast.Var && obj.name == node.name {
+					pos = obj.pos
+					break
+				}
+			}
+			// local objects
+			if pos == token.Pos{} && !isnil(c.fn_scope) {
+				if obj := c.fn_scope.find_var(node.name) {
+					pos = obj.pos
+				}
+			}
+			//
+		}
+		ast.StructInit {
+			if !c.vls_is_the_node(node.name_pos) {
+				return
+			}
+			mut info := c.table.sym(node.typ).info
+			pos = match mut info {
+				ast.Struct {
+					info.name_pos
+				}
+				ast.Alias {
+					info.name_pos
+				}
+				ast.SumType {
+					info.name_pos
+				}
+				else {
+					pos
+				}
+			}
+		}
+		ast.SelectorExpr {
+			sym := c.table.sym(node.expr_type)
+			f := c.table.find_field(sym, node.field_name) or {
+				println('failed to find field "${node.field_name}"')
+				exit(1)
+			}
+			pos = f.pos
+		}
+		else {}
+	}
+	if pos.file_idx != -1 {
+		println('${c.table.filelist[pos.file_idx]}:${pos.line_nr + 1}:${pos.col}')
+	}
+	exit(0)
 }
 
 // Autocomplete for `myvar. ...`, `os. ...`
 fn (mut c Checker) ident_autocomplete(node ast.Ident) {
+	if c.pref.linfo.method != .completion {
+		return
+	}
 	// Mini LS hack (v -line-info "a.v:16")
 	if c.pref.is_verbose {
 		println(
 			'checker.ident_autocomplete() info.line_nr=${c.pref.linfo.line_nr} node.line_nr=${node.pos.line_nr} ' +
 			' node.col=${node.pos.col} pwd="${os.getwd()}" file="${c.file.path}", ' +
-			//' pref.linfo.path="${c.pref.linfo.path}" node.name="${node.name}" expr="${c.pref.linfo.expr}"')
-		 ' pref.linfo.path="${c.pref.linfo.path}" node.name="${node.name}" node.mod="${node.mod}" col="${c.pref.linfo.col}"')
+			' pref.linfo.path="${c.pref.linfo.path}" node.name="${node.name}" node.mod="${node.mod}" col="${c.pref.linfo.col}"')
 	}
 	if node.mod == 'builtin' {
 		// User can't type in `builtin.func(` at all
 		return
 	}
-	// Make sure this ident is on the same line and same file as request
-	same_line := c.pref.linfo.line_nr == node.pos.line_nr
-	if !same_line {
-		return
-	}
-	if node.pos.file_idx < 0 {
-		return
-	}
-	if c.pref.linfo.path != c.table.filelist[node.pos.file_idx] {
+	if !c.vls_is_the_node(node.pos) {
 		return
 	}
 	check_name := if c.pref.linfo.col == node.pos.col {
@@ -142,7 +196,6 @@ fn (mut c Checker) ident_autocomplete(node ast.Ident) {
 		c.module_autocomplete(mod_name)
 		exit(0)
 	}
-
 	if node.kind == .unresolved {
 		eprintln('unresolved type, maybe "${node.name}" was not defined. otherwise this is a bug, should never happen; please report')
 		exit(1)
@@ -196,8 +249,7 @@ fn (c &Checker) build_fn_summary(func ast.Fn) string {
 	sb.writeln('\t}]')
 	sb.writeln('}],')
 	sb.writeln('"activeSignature":0,')
-	sb.writeln('"activeParameter":0,')
-	sb.writeln('"_type":"SignatureHelp"')
+	sb.writeln('"activeParameter":0')
 	sb.writeln('}')
 	return sb.str()
 }
@@ -341,7 +393,7 @@ fn (c &Checker) vls_gen_type_details(mut details []Detail, sym ast.TypeSymbol) {
 
 fn (c &Checker) vls_write_details(details []Detail) {
 	mut sb := strings.new_builder(details.len * 32)
-	sb.writeln('{"details" : [')
+	sb.writeln('{"details": [')
 	for detail in details {
 		sb.write_string('{"kind":${int(detail.kind)},')
 		sb.write_string('"label":"${detail.label}",')
@@ -386,3 +438,21 @@ fn (c &Checker) vls_map_v_kind_to_lsp_kind(kind ast.Kind) DetailKind {
 	}
 	return .text
 }
+
+fn (c &Checker) vls_is_the_node(pos token.Pos) bool {
+	// Make sure this ident is on the same line and same file as request
+	same_line := c.pref.linfo.line_nr == pos.line_nr
+	if !same_line {
+		return false
+	}
+	if pos.file_idx < 0 {
+		return false
+	}
+	if c.pref.linfo.path != c.table.filelist[pos.file_idx] {
+		return false
+	}
+	if c.pref.linfo.col > pos.col + pos.len || c.pref.linfo.col < pos.col {
+		return false
+	}
+	return true
+}
@@ -442,35 +442,6 @@ pub fn (mut c Checker) check_files(ast_files []&ast.File) {
 			c.error('a _test.v file should have *at least* one `test_` function', token.Pos{})
 		}
 	}
-	// After the main checker run, run the line info check, print line info, and exit (if it's present)
-	if !c.pref.linfo.is_running && c.pref.line_info != '' { //'' && c.pref.linfo.line_nr == 0 {
-		// c.do_line_info(c.pref.line_info, ast_files)
-		// println('setting is_running=true,  pref.path=${c.pref.linfo.path} curdir' + os.getwd())
-		c.pref.linfo.is_running = true
-		// println('linfo path=${c.pref.linfo.path}')
-		// Go to definition
-		if c.pref.linfo.expr.starts_with('gd^') {
-			c.ident_gotodef()
-			exit(0)
-		}
-		for i, file in ast_files {
-			// println(file.path)
-			if file.path == c.pref.linfo.path {
-				// println('running c.check_files')
-				c.check_files([ast_files[i]])
-				exit(0)
-			} else if file.path.starts_with('./') {
-				// Maybe it's a "./foo.v", linfo.path has an absolute path
-				abs_path := os.join_path(os.getwd(), file.path).replace('/./', '/') // TODO: join_path shouldn't have /./
-				if abs_path == c.pref.linfo.path {
-					c.check_files([ast_files[i]])
-					exit(0)
-				}
-			}
-		}
-		println('failed to find file "${c.pref.linfo.path}"')
-		exit(0)
-	}
 	// Make sure fn main is defined in non lib builds
 	if c.pref.build_mode == .build_module || c.pref.is_test {
 		return
@@ -3017,6 +2988,11 @@ pub fn (mut c Checker) expr(mut node ast.Expr) ast.Type {
 		c.error('checker: too many expr levels: ${c.expr_level} ', node.pos())
 		return ast.void_type
 	}
+	defer {
+		if c.pref.is_vls {
+			c.ident_gotodef(node)
+		}
+	}
 	match mut node {
 		ast.IfExpr {
 			return c.if_expr(mut node)
@@ -4144,10 +4120,10 @@ fn (mut c Checker) resolve_var_fn(func &ast.Fn, mut node ast.Ident, name string)
 }
 
 fn (mut c Checker) ident(mut node ast.Ident) ast.Type {
-	if c.pref.linfo.is_running {
-		// LS hack (v -line-info "a.v:16")
-		// TODO perf $if
-		c.ident_autocomplete(node)
+	defer {
+		if c.pref.is_vls {
+			c.ident_autocomplete(node)
+		}
 	}
 	// TODO: move this
 	if c.const_deps.len > 0 {
 
@@ -760,9 +760,7 @@ fn (mut c Checker) call_expr(mut node ast.CallExpr) ast.Type {
 		c.fn_call(mut node, mut continue_check)
 	}
 	if c.pref.is_vls {
-		if c.pref.linfo.expr.starts_with('fn^') {
-			c.autocomplete_for_fn_call_expr(node)
-		}
+		c.autocomplete_for_fn_call_expr(node)
 	}
 	if !continue_check {
 		return ast.void_type
 
@@ -1596,11 +1596,6 @@ fn (mut p Parser) name_expr() ast.Expr {
 			// prepend the full import
 			mod = p.imports[p.tok.lit]
 		}
-		if p.pref.linfo.is_running {
-			// VLS autocomplete for module fns: `os...`
-			// TODO perf $if
-			// p.module_autocomplete(node)
-		}
 		line_nr := p.tok.line_nr
 		p.next()
 		p.check(.dot)
@@ -2930,6 +2925,7 @@ fn (mut p Parser) type_decl() ast.TypeDecl {
 				variants:      variant_types
 				is_generic:    generic_types.len > 0
 				generic_types: generic_types
+				name_pos:      name_pos
 			}
 			is_pub: is_pub
 		})
@@ -2986,6 +2982,7 @@ fn (mut p Parser) type_decl() ast.TypeDecl {
 		info:       ast.Alias{
 			parent_type: parent_type
 			language:    parent_language
+			name_pos:    name_pos
 		}
 		is_pub:     is_pub
 	})
Original file line number	Diff line number	Diff line change
`@@ -549,10 +549,11 @@ pub fn (mut b Builder) print_warnings_and_errors() {`
`549`	`549`	`}`
`550`	`550`	`}`
`551`	`551`	`if b.pref.json_errors {`
`552`		`- util.print_json_errors(json_errors)`
	`552`	`+ if !b.pref.is_vls \|\| b.pref.linfo.method !in [.definition, .completion, .signature_help] {`
	`553`	`+ util.print_json_errors(json_errors)`
	`554`	`+ }`
`553`	`555`	`// eprintln(json2.encode_pretty(json_errors))`
`554`	`556`	`}`
`555`		`-`
`556`	`557`	`if !b.pref.skip_warnings {`
`557`	`558`	`for file in b.parsed_files {`
`558`	`559`	`for err in file.warnings {`
Original file line number	Diff line number	Diff line change
`@@ -760,9 +760,7 @@ fn (mut c Checker) call_expr(mut node ast.CallExpr) ast.Type {`
`760`	`760`	`c.fn_call(mut node, mut continue_check)`
`761`	`761`	`}`
`762`	`762`	`if c.pref.is_vls {`
`763`		`- if c.pref.linfo.expr.starts_with('fn^') {`
`764`		`- c.autocomplete_for_fn_call_expr(node)`
`765`		`- }`
	`763`	`+ c.autocomplete_for_fn_call_expr(node)`
`766`	`764`	`}`
`767`	`765`	`if !continue_check {`
`768`	`766`	`return ast.void_type`