SignatureHelp: report signature of Ident if no enclosing CallExpr

Currently, SignatureHelp reports information only about an
enclosing call expression. But it would be useful to show
signature information after entering the name of a function
such as "f" or "fmt.Println", without call parens.

So, if there is no enclosing call, this change reports the
signature of the selected identifier if it is callable.

Fixes golang/go#68922

Change-Id: Ibb0700e354c5d6e5937fc7f7b5db65e9d96574bb
GitHub-Last-Rev: 5e7965e
GitHub-Pull-Request: #510
Reviewed-on: https://go-review.googlesource.com/c/tools/+/605983
Reviewed-by: Alan Donovan <[email protected]>
Reviewed-by: Robert Findley <[email protected]>
Auto-Submit: Robert Findley <[email protected]>
LUCI-TryBot-Result: Go LUCI <[email protected]>

Author: crazyhulk

gopls/doc/features/passive.md

@@ -107,6 +107,10 @@ function call.
 
 <img src='../assets/signature-help.png'>
 
+Call parens are not necessary if the cursor is within an identifier
+that denotes a function or method. For example, Signature Help at
+`once.Do(initialize‸)` will describe `initialize`, not `once.Do`.
+
 Client support:
 - **VS Code**: enabled by default.
   Also known as "[parameter hints](https://code.visualstudio.com/api/references/vscode-api#SignatureHelpProvider)" in the [IntelliSense settings](https://code.visualstudio.com/docs/editor/intellisense#_settings).

gopls/doc/release/v0.17.0.md

@@ -35,3 +35,7 @@ constructor of the type of each symbol:
 `interface`, `struct`, `signature`, `pointer`, `array`, `map`, `slice`, `chan`, `string`, `number`, `bool`, and `invalid`.
 Editors may use this for syntax coloring.
 
+## SignatureHelp for ident and values.
+
+Now, function signature help can be used on any identifier with a function
+signature, not just within the parentheses of a function being called.

gopls/internal/golang/signature_help.go

@@ -45,13 +45,32 @@ func SignatureHelp(ctx context.Context, snapshot *cache.Snapshot, fh file.Handle
 	if path == nil {
 		return nil, 0, fmt.Errorf("cannot find node enclosing position")
 	}
-FindCall:
-	for _, node := range path {
+	info := pkg.TypesInfo()
+	var fnval ast.Expr
+loop:
+	for i, node := range path {
 		switch node := node.(type) {
+		case *ast.Ident:
+			// If the selected text is a function/method Ident orSelectorExpr,
+			// even one not in function call position,
+			// show help for its signature. Example:
+			//    once.Do(initialize⁁)
+			// should show help for initialize, not once.Do.
+			if t := info.TypeOf(node); t != nil &&
+				info.Defs[node] == nil &&
+				is[*types.Signature](t.Underlying()) {
+				if sel, ok := path[i+1].(*ast.SelectorExpr); ok && sel.Sel == node {
+					fnval = sel // e.g. fmt.Println⁁
+				} else {
+					fnval = node
+				}
+				break loop
+			}
 		case *ast.CallExpr:
 			if pos >= node.Lparen && pos <= node.Rparen {
 				callExpr = node
-				break FindCall
+				fnval = callExpr.Fun
+				break loop
 			}
 		case *ast.FuncLit, *ast.FuncType:
 			// The user is within an anonymous function,
@@ -70,20 +89,19 @@ FindCall:
 		}
 
 	}
-	if callExpr == nil || callExpr.Fun == nil {
+
+	if fnval == nil {
 		return nil, 0, nil
 	}
 
-	info := pkg.TypesInfo()
-
 	// Get the type information for the function being called.
 	var sig *types.Signature
-	if tv, ok := info.Types[callExpr.Fun]; !ok {
-		return nil, 0, fmt.Errorf("cannot get type for Fun %[1]T (%[1]v)", callExpr.Fun)
+	if tv, ok := info.Types[fnval]; !ok {
+		return nil, 0, fmt.Errorf("cannot get type for Fun %[1]T (%[1]v)", fnval)
 	} else if tv.IsType() {
 		return nil, 0, nil // a conversion, not a call
 	} else if sig, ok = tv.Type.Underlying().(*types.Signature); !ok {
-		return nil, 0, fmt.Errorf("call operand is not a func or type: %[1]T (%[1]v)", callExpr.Fun)
+		return nil, 0, fmt.Errorf("call operand is not a func or type: %[1]T (%[1]v)", fnval)
 	}
 	// Inv: sig != nil
 
@@ -93,7 +111,7 @@ FindCall:
 	// There is no object in certain cases such as calling a function returned by
 	// a function (e.g. "foo()()").
 	var obj types.Object
-	switch t := callExpr.Fun.(type) {
+	switch t := fnval.(type) {
 	case *ast.Ident:
 		obj = info.ObjectOf(t)
 	case *ast.SelectorExpr:
@@ -116,7 +134,12 @@ FindCall:
 		return nil, 0, bug.Errorf("call to unexpected built-in %v (%T)", obj, obj)
 	}
 
-	activeParam := activeParameter(callExpr, sig.Params().Len(), sig.Variadic(), pos)
+	activeParam := 0
+	if callExpr != nil {
+		// only return activeParam when CallExpr
+		// because we don't modify arguments when get function signature only
+		activeParam = activeParameter(callExpr, sig.Params().Len(), sig.Variadic(), pos)
+	}
 
 	var (
 		name    string

gopls/internal/test/marker/testdata/signature/signature.txt

@@ -16,6 +16,7 @@ import (
 	"bytes"
 	"encoding/json"
 	"math/big"
+	"fmt"
 )
 
 func Foo(a string, b int) (c bool) {
@@ -49,6 +50,9 @@ func Qux() {
 	Foo("foo", 123) //@signature(",", "Foo(a string, b int) (c bool)", 0)
 	Foo("foo", 123) //@signature(" 1", "Foo(a string, b int) (c bool)", 1)
 	Foo("foo", 123) //@signature(")", "Foo(a string, b int) (c bool)", 1)
+	Foo("foo", 123) //@signature("o", "Foo(a string, b int) (c bool)", 0)
+	_ = Foo //@signature("o", "Foo(a string, b int) (c bool)", 0)
+	Foo //@signature("o", "Foo(a string, b int) (c bool)", 0)
 
 	Bar(13.37, 0x13)       //@signature("13.37", "Bar(float64, ...byte)", 0)
 	Bar(13.37, 0x37)       //@signature("0x37", "Bar(float64, ...byte)", 1)
@@ -78,9 +82,28 @@ func Qux() {
 
 	_ = make([]int, 1, 2) //@signature("2", "make(t Type, size ...int) Type", 1)
 
-	Foo(myFunc(123), 456) //@signature("myFunc", "Foo(a string, b int) (c bool)", 0)
+	Foo(myFunc(123), 456) //@signature("o(", "Foo(a string, b int) (c bool)", 0)
+	Foo(myFunc(123), 456) //@signature("(m", "Foo(a string, b int) (c bool)", 0)
+	Foo( myFunc(123), 456) //@signature(" m", "Foo(a string, b int) (c bool)", 0)
+	Foo(myFunc(123), 456) //@signature(", ", "Foo(a string, b int) (c bool)", 0)
+	Foo(myFunc(123), 456) //@signature("456", "Foo(a string, b int) (c bool)", 1)
+	Foo(myFunc) //@signature(")", "Foo(a string, b int) (c bool)", 0)
+	Foo(myFunc(123), 456) //@signature("(1", "myFunc(foo int) string", 0)
 	Foo(myFunc(123), 456) //@signature("123", "myFunc(foo int) string", 0)
 
+	fmt.Println //@signature("ln", "Println(a ...any) (n int, err error)", 0)
+	fmt.Println(myFunc) //@signature("ln", "Println(a ...any) (n int, err error)", 0)
+	fmt.Println(myFunc) //@signature("Func", "myFunc(foo int) string", 0)
+
+	var hi string = "hello"
+	var wl string = " world: %s"
+	fmt.Println(fmt.Sprintf(wl, myFunc)) //@signature("Func", "myFunc(foo int) string", 0)
+	fmt.Println(fmt.Sprintf(wl, myFunc)) //@signature("wl", "Sprintf(format string, a ...any) string", 0)
+	fmt.Println(fmt.Sprintf(wl, myFunc)) //@signature(" m", "Sprintf(format string, a ...any) string", 1)
+	fmt.Println(hi, fmt.Sprintf(wl, myFunc)) //@signature("Sprint", "Sprintf(format string, a ...any) string", 0)
+	fmt.Println(hi, fmt.Sprintf(wl, myFunc)) //@signature(" fmt", "Println(a ...any) (n int, err error)", 0)
+	fmt.Println(hi, fmt.Sprintf(wl, myFunc)) //@signature("hi", "Println(a ...any) (n int, err error)", 0)
+
 	panic("oops!")            //@signature(")", "panic(v any)", 0)
 	println("hello", "world") //@signature(",", "println(args ...Type)", 0)
 
@@ -100,6 +123,8 @@ package signature
 
 func _() {
 	Foo(//@signature("//", "Foo(a string, b int) (c bool)", 0)
+	Foo.//@signature("//", "Foo(a string, b int) (c bool)", 0)
+	Foo.//@signature("oo", "Foo(a string, b int) (c bool)", 0)
 }
 
 -- signature/signature3.go --