parser,checker: fix vls fn signature (#25572)

Author: kbkpbot

vlib/v/checker/assign.v

@@ -149,8 +149,13 @@ fn (mut c Checker) assign_stmt(mut node ast.AssignStmt) {
 	for i, mut left in node.left {
 		if mut left is ast.CallExpr {
 			// ban `foo() = 10`
-			c.error('cannot call function `${left.name}()` on the left side of an assignment',
-				left.pos)
+			if c.pref.is_vls {
+				// in `vls` mode, code is incomplete, eval left also
+				c.expr(mut left)
+			} else {
+				c.error('cannot call function `${left.name}()` on the left side of an assignment',
+					left.pos)
+			}
 		} else if mut left is ast.PrefixExpr {
 			// ban `*foo() = 10`
 			if left.right is ast.CallExpr && left.op == .mul {
@@ -504,7 +509,7 @@ fn (mut c Checker) assign_stmt(mut node ast.AssignStmt) {
 					c.error('cannot use infix expression on the left side of `${node.op}`',
 						left.pos)
 				}
-				if is_decl {
+				if is_decl && !c.pref.is_vls {
 					c.error('non-name `${left}` on left side of `:=`', left.pos())
 				}
 

vlib/v/checker/autocomplete.v

@@ -44,23 +44,38 @@ struct Detail {
 }
 
 // Autocomplete for function parameters `os.write_bytes(**path string, bytes []u8***)` etc
-pub fn (mut c Checker) autocomplete_for_fn_call_expr() {
-	mut fn_name := if c.pref.linfo.expr.ends_with('(') {
-		c.pref.linfo.expr[..c.pref.linfo.expr.len - 1].trim_space()
-	} else {
-		c.pref.linfo.expr.replace('()', '').trim_space()
+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
 	}
-	mod_name := fn_name.all_before_last('.')
-	resolved_mod_name := c.try_resolve_to_import_mod_name(mod_name)
-	if resolved_mod_name.len > 0 {
-		fn_name = resolved_mod_name + '.' + fn_name.all_after_last('.')
+	if node.pos.file_idx < 0 {
+		return
+	}
+	if c.pref.linfo.path != c.table.filelist[node.pos.file_idx] {
+		return
 	}
-	f := c.table.find_fn(fn_name) or {
-		println('failed to find fn "${fn_name}"')
+	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
+		}
+	}
 	res := c.build_fn_summary(f)
 	println(res)
+	exit(0)
 }
 
 fn (mut c Checker) ident_gotodef() {
@@ -139,6 +154,7 @@ fn (mut c Checker) ident_autocomplete(node ast.Ident) {
 	mut details := []Detail{cap: 10}
 	c.vls_gen_type_details(mut details, sym)
 	c.vls_write_details(details)
+	exit(0)
 }
 
 fn (mut c Checker) module_autocomplete(mod string) {
@@ -150,26 +166,39 @@ fn (mut c Checker) module_autocomplete(mod string) {
 	c.vls_write_details(details)
 }
 
-fn (c &Checker) build_fn_summary(method ast.Fn) string {
-	mut sb := strings.new_builder(64)
-	sb.write_string(method.name.all_after_last('.'))
-	sb.write_string('(')
-	for i, param in method.params {
-		if method.is_method && i == 0 {
+fn (c &Checker) build_fn_summary(func ast.Fn) string {
+	mut sb := strings.new_builder(128)
+	fn_name := func.name.all_after_last('.')
+	sb.writeln('{\n"signatures":[{')
+	sb.write_string('\t"label":"${fn_name}(')
+	mut params := []string{cap: func.params.len}
+	for i, param in func.params {
+		if func.is_method && i == 0 {
 			// skip receiver
 			continue
 		}
-		sb.write_string(param.name)
-		sb.write_string(' ')
-		sb.write_string(c.table.type_to_str(param.typ))
-		if i < method.params.len - 1 {
-			sb.write_string(', ')
-		}
+		params << '${param.name} ${c.table.type_to_str(param.typ)}'
 	}
+	sb.write_string(params.join(', '))
 	sb.write_string(')')
-	if method.return_type != ast.void_type {
-		sb.write_string(c.table.type_to_str(method.return_type))
+	if func.return_type != ast.void_type {
+		sb.write_string(' ')
+		sb.write_string(c.table.type_to_str(func.return_type))
+	}
+	sb.writeln('",\n\t"parameters":[{')
+	for i, p in params {
+		sb.write_string('\t\t"label":"${p}"')
+		if i < params.len - 1 {
+			sb.write_string(',')
+		}
+		sb.writeln('')
 	}
+	sb.writeln('\t}]')
+	sb.writeln('}],')
+	sb.writeln('"activeSignature":0,')
+	sb.writeln('"activeParameter":0,')
+	sb.writeln('"_type":"SignatureHelp"')
+	sb.writeln('}')
 	return sb.str()
 }
 

vlib/v/checker/checker.v

@@ -453,10 +453,6 @@ pub fn (mut c Checker) check_files(ast_files []&ast.File) {
 			c.ident_gotodef()
 			exit(0)
 		}
-		if c.pref.linfo.expr.contains('()') || c.pref.linfo.expr.ends_with('(') {
-			c.autocomplete_for_fn_call_expr()
-			exit(0)
-		}
 		for i, file in ast_files {
 			// println(file.path)
 			if file.path == c.pref.linfo.path {

vlib/v/checker/fn.v

@@ -759,6 +759,11 @@ fn (mut c Checker) call_expr(mut node ast.CallExpr) ast.Type {
 	} else {
 		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)
+		}
+	}
 	if !continue_check {
 		return ast.void_type
 	}

vlib/v/parser/fn.v

@@ -52,7 +52,7 @@ fn (mut p Parser) call_expr(language ast.Language, mod string) ast.CallExpr {
 	}
 	p.check(.lpar)
 	args := p.call_args()
-	if p.tok.kind != .rpar {
+	if p.tok.kind != .rpar && !p.pref.is_vls {
 		params := p.table.fns[fn_name] or { unsafe { p.table.fns['${p.mod}.${fn_name}'] } }.params
 		if args.len < params.len && p.prev_tok.kind != .comma {
 			pos := if p.tok.kind == .eof { p.prev_tok.pos() } else { p.tok.pos() }
@@ -70,7 +70,9 @@ fn (mut p Parser) call_expr(language ast.Language, mod string) ast.CallExpr {
 		}
 	}
 	last_pos := p.tok.pos()
-	p.next()
+	if p.tok.kind == .rpar {
+		p.next()
+	}
 	mut pos := first_pos.extend(last_pos)
 	mut or_stmts := []ast.Stmt{} // TODO: remove unnecessary allocations by just using .absent
 	mut or_pos := p.tok.pos()

vlib/v/tests/vls/autocomplete_module_test.v

@@ -31,6 +31,19 @@ const autocomplete_info_for_mod_struct = '{"details" : [
 {"kind":2,"label":"add","detail":"void","documentation":""}
 ]}'
 
+const fn_signature_info_for_all_before_last = '{
+"signatures":[{
+	"label":"all_before_last(sub string) string",
+	"parameters":[{
+		"label":"sub string"
+	}]
+}],
+"activeSignature":0,
+"activeParameter":0,
+"_type":"SignatureHelp"
+}
+'
+
 struct TestData {
 	cmd    string
 	output string
@@ -57,6 +70,10 @@ const test_data = [
 		cmd:    'v -check -json-errors -nocolor -vls-mode -line-info "${text_file}:26:28" ${os.quoted_path(text_file)}'
 		output: autocomplete_info_for_mod_sample_mod1
 	},
+	TestData{
+		cmd:    'v -check -json-errors -nocolor -vls-mode -line-info "${text_file}:24:fn^26" ${os.quoted_path(text_file)}'
+		output: fn_signature_info_for_all_before_last
+	},
 	TestData{
 		cmd:    'v -check -json-errors -nocolor -vls-mode -line-info "${text_file}:27:8" ${os.quoted_path(text_file)}'
 		output: ''
@@ -163,19 +180,18 @@ const test_data = [
 fn test_main() {
 	mut total_errors := 0
 
-	dump(text_file)
 	for t in test_data {
 		res := os.execute(t.cmd)
 		if res.exit_code < 0 {
 			println('fail execute ${t.cmd}')
 			panic(res.output)
 		}
 		res_output := $if windows {
-			res.output.replace('\r\n', '\n').trim_space()
+			res.output.replace('\r\n', '\n')
 		} $else {
-			res.output.trim_space()
+			res.output
 		}
-		if t.output.trim_space() != res_output {
+		if t.output.trim_space() != res_output.trim_space() {
 			println('${term.red('FAIL')} ${t.cmd}')
 			if diff_ := diff.compare_text(t.output, res_output) {
 				println(term.header('difference:', '-'))