gopls/internal/golang: implement dynamicFuncCallType with typeutil.ClassifyCall

Also fix some typos I came across.

Change-Id: Ib3e73852c8260bf0a537ffb7c23ec1815c9546e1
Reviewed-on: https://go-review.googlesource.com/c/tools/+/658236
Reviewed-by: Alan Donovan <adonovan@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>

Author: jba

gopls/internal/golang/implementation.go

@@ -32,6 +32,7 @@ import (
 	"golang.org/x/tools/internal/astutil/cursor"
 	"golang.org/x/tools/internal/astutil/edge"
 	"golang.org/x/tools/internal/event"
+	"golang.org/x/tools/internal/typesinternal"
 )
 
 // This file defines the new implementation of the 'implementation'
@@ -937,6 +938,9 @@ func implFuncs(pkg *cache.Package, pgf *parsego.File, pos token.Pos) ([]protocol
 	}
 
 	info := pkg.TypesInfo()
+	if info.Types == nil || info.Defs == nil || info.Uses == nil {
+		panic("one of info.Types, .Defs or .Uses is nil")
+	}
 
 	// Find innermost enclosing FuncType or CallExpr.
 	//
@@ -1088,29 +1092,10 @@ func beneathFuncDef(cur cursor.Cursor) bool {
 //
 // Tested via ../test/marker/testdata/implementation/signature.txt.
 func dynamicFuncCallType(info *types.Info, call *ast.CallExpr) types.Type {
-	fun := ast.Unparen(call.Fun)
-	tv := info.Types[fun]
-
-	// Reject conversion, or call to built-in.
-	if !tv.IsValue() {
-		return nil
-	}
-
-	// Reject call to named func/method.
-	if id, ok := fun.(*ast.Ident); ok && is[*types.Func](info.Uses[id]) {
-		return nil
+	if typesinternal.ClassifyCall(info, call) == typesinternal.CallDynamic {
+		return info.Types[call.Fun].Type.Underlying()
 	}
-
-	// Reject method selections (T.method() or x.method())
-	if sel, ok := fun.(*ast.SelectorExpr); ok {
-		seln, ok := info.Selections[sel]
-		if !ok || seln.Kind() != types.FieldVal {
-			return nil
-		}
-	}
-
-	// TODO(adonovan): consider x() where x : TypeParam.
-	return tv.Type.Underlying() // e.g. x() or x.field()
+	return nil
 }
 
 // inToken reports whether pos is within the token of

gopls/internal/test/marker/testdata/implementation/issue67041.txt

@@ -1,5 +1,5 @@
-This test verifies that implementations uses the correct object when querying
-local implementations . As described in golang/go#67041), a bug led to it
+This test verifies that Implementations uses the correct object when querying
+local implementations. As described in golang/go#67041, a bug led to it
 comparing types from different realms.
 
 -- go.mod --

internal/typesinternal/classify_call.go

@@ -42,19 +42,6 @@ func (k CallKind) String() string {
 // and further classifies function calls as static calls (where the function is known),
 // dynamic interface calls, and other dynamic calls.
 //
-// For static, interface and builtin calls, ClassifyCall returns the [types.Object]
-// for the name of the caller. For calls of instantiated functions and
-// methods, it returns the object for the corresponding generic function
-// or method on the generic type.
-// The relationships between the return values are:
-//
-//		CallKind       object
-//		CallStatic     *types.Func
-//	 	CallInterface  *types.Func
-//		CallBuiltin    *types.Builtin
-//		CallDynamic    nil
-//		CallConversion nil
-//
 // For the declarations:
 //
 //	func f() {}
@@ -66,33 +53,33 @@ func (k CallKind) String() string {
 //
 // ClassifyCall returns the following:
 //
-//	f()           CallStatic        the *types.Func for f
-//	g[int]()      CallStatic        the *types.Func for g[T]
-//	i.M()         CallInterface     the *types.Func for i.M
-//	min(1, 2)     CallBuiltin       the *types.Builtin for min
-//	v()           CallDynamic       nil
-//	s[0]()        CallDynamic       nil
-//	int(x)        CallConversion    nil
-//	[]byte("")    CallConversion    nil
-func ClassifyCall(info *types.Info, call *ast.CallExpr) (CallKind, types.Object) {
+//	f()           CallStatic
+//	g[int]()      CallStatic
+//	i.M()         CallInterface
+//	min(1, 2)     CallBuiltin
+//	v()           CallDynamic
+//	s[0]()        CallDynamic
+//	int(x)        CallConversion
+//	[]byte("")    CallConversion
+func ClassifyCall(info *types.Info, call *ast.CallExpr) CallKind {
 	if info.Types == nil {
 		panic("ClassifyCall: info.Types is nil")
 	}
 	if info.Types[call.Fun].IsType() {
-		return CallConversion, nil
+		return CallConversion
 	}
 	obj := Used(info, call.Fun)
 	// Classify the call by the type of the object, if any.
 	switch obj := obj.(type) {
 	case *types.Builtin:
-		return CallBuiltin, obj
+		return CallBuiltin
 	case *types.Func:
 		if interfaceMethod(obj) {
-			return CallInterface, obj
+			return CallInterface
 		}
-		return CallStatic, obj
+		return CallStatic
 	default:
-		return CallDynamic, nil
+		return CallDynamic
 	}
 }
 

internal/typesinternal/classify_call_test.go

@@ -101,34 +101,30 @@ func TestClassifyCallAndUsed(t *testing.T) {
 
 	typeParam := lookup("tests").Type().(*types.Signature).TypeParams().At(0).Obj()
 
-	// A unique value for marking that Used returns the same object as ClassifyCall.
-	same := &types.Label{}
-
 	// Expected Calls are in the order of CallExprs at the end of src, above.
 	wants := []struct {
-		kind        ti.CallKind
-		classifyObj types.Object // the object returned from ClassifyCall
-		usedObj     types.Object // the object returned from Used, sometimes different
+		kind    ti.CallKind
+		usedObj types.Object // the object returned from Used
 	}{
-		{ti.CallStatic, lookup("g"), same},         // g
-		{ti.CallDynamic, nil, lookup("f")},         // f
-		{ti.CallBuiltin, printlnObj, same},         // println
-		{ti.CallStatic, member("S", "g"), same},    // z.g
-		{ti.CallStatic, member("S", "g"), same},    // a.b.c.g
-		{ti.CallStatic, member("S", "g"), same},    // S.g(z, 1)
-		{ti.CallDynamic, nil, member("z", "f")},    // z.f
-		{ti.CallInterface, member("I", "m"), same}, // I(nil).m
-		{ti.CallConversion, nil, lookup("I")},      // I(nil)
-		{ti.CallDynamic, nil, same},                // m[0]
-		{ti.CallDynamic, nil, same},                // n[0]
-		{ti.CallStatic, lookup("F"), same},         // F[int]
-		{ti.CallStatic, lookup("F"), same},         // F[T]
-		{ti.CallDynamic, nil, same},                // f(){}
-		{ti.CallConversion, nil, same},             // []byte
-		{ti.CallConversion, nil, lookup("A")},      // A[int]
-		{ti.CallConversion, nil, typeParam},        // T
-		{ti.CallStatic, member("S", "g"), same},    // (z.g)
-		{ti.CallStatic, member("S", "g"), same},    // (z).g
+		{ti.CallStatic, lookup("g")},         // g
+		{ti.CallDynamic, lookup("f")},        // f
+		{ti.CallBuiltin, printlnObj},         // println
+		{ti.CallStatic, member("S", "g")},    // z.g
+		{ti.CallStatic, member("S", "g")},    // a.b.c.g
+		{ti.CallStatic, member("S", "g")},    // S.g(z, 1)
+		{ti.CallDynamic, member("z", "f")},   // z.f
+		{ti.CallInterface, member("I", "m")}, // I(nil).m
+		{ti.CallConversion, lookup("I")},     // I(nil)
+		{ti.CallDynamic, nil},                // m[0]
+		{ti.CallDynamic, nil},                // n[0]
+		{ti.CallStatic, lookup("F")},         // F[int]
+		{ti.CallStatic, lookup("F")},         // F[T]
+		{ti.CallDynamic, nil},                // f(){}
+		{ti.CallConversion, nil},             // []byte
+		{ti.CallConversion, lookup("A")},     // A[int]
+		{ti.CallConversion, typeParam},       // T
+		{ti.CallStatic, member("S", "g")},    // (z.g)
+		{ti.CallStatic, member("S", "g")},    // (z).g
 	}
 
 	i := 0
@@ -143,20 +139,14 @@ func TestClassifyCallAndUsed(t *testing.T) {
 			}
 			prefix := fmt.Sprintf("%s (#%d)", buf.String(), i)
 
-			gotKind, gotObj := ti.ClassifyCall(info, call)
+			gotKind := ti.ClassifyCall(info, call)
 			want := wants[i]
 
 			if gotKind != want.kind {
 				t.Errorf("%s kind: got %s, want %s", prefix, gotKind, want.kind)
 			}
-			if gotObj != want.classifyObj {
-				t.Errorf("%s obj: got %v (%[2]T), want %v", prefix, gotObj, want.classifyObj)
-			}
 
 			w := want.usedObj
-			if w == same {
-				w = want.classifyObj
-			}
 			if g := ti.Used(info, call.Fun); g != w {
 				t.Errorf("%s used obj: got %v (%[2]T), want %v", prefix, g, w)
 			}