lsp/completion: search deeper for candidate type mods

Now we search up to three levels for candidate modifiers. For example,
we can now complete "foo" to "foo()()" (double invocation).

Granted this is rarely useful, but it generalizes and simplifies the
searching we did for dereference modifiers.

Updates golang/go#46045.

Change-Id: Ibf0be8158e16a0a26a6344a346f34af8fe182bb0
Reviewed-on: https://go-review.googlesource.com/c/tools/+/323450
Run-TryBot: Muir Manders <[email protected]>
gopls-CI: kokoro <[email protected]>
TryBot-Result: Go Bot <[email protected]>
Reviewed-by: Robert Findley <[email protected]>
Trust: Rebecca Stambler <[email protected]>

Author: muirdm

internal/lsp/source/completion/completion.go

@@ -2394,86 +2394,67 @@ func (c *completer) fakeObj(T types.Type) *types.Var {
 	return types.NewVar(token.NoPos, c.pkg.GetTypes(), "", T)
 }
 
-// anyCandType reports whether f returns true for any candidate type
-// derivable from c. For example, from "foo" we might derive "&foo",
-// and "foo()".
-func (c *candidate) anyCandType(f func(t types.Type, addressable bool) bool) bool {
-	if c.obj == nil || c.obj.Type() == nil {
-		return false
-	}
-
-	objType := c.obj.Type()
-
-	if f(objType, c.addressable) {
-		return true
-	}
-
-	// If c is a func type with a single result, offer the result type.
-	if sig, ok := objType.Underlying().(*types.Signature); ok {
-		if sig.Results().Len() == 1 && f(sig.Results().At(0).Type(), false) {
-			// Mark the candidate so we know to append "()" when formatting.
-			c.mods = append(c.mods, invoke)
+// derivableTypes iterates types you can derive from t. For example,
+// from "foo" we might derive "&foo", and "foo()".
+func derivableTypes(t types.Type, addressable bool, f func(t types.Type, addressable bool, mod typeModKind) bool) bool {
+	switch t := t.Underlying().(type) {
+	case *types.Signature:
+		// If t is a func type with a single result, offer the result type.
+		if t.Results().Len() == 1 && f(t.Results().At(0).Type(), false, invoke) {
 			return true
 		}
-	}
-
-	var (
-		seenPtrTypes map[types.Type]bool
-		ptrType      = objType
-		ptrDepth     int
-	)
-
-	// Check if dereferencing c would match our type inference. We loop
-	// since c could have arbitrary levels of pointerness.
-	for {
-		ptr, ok := ptrType.Underlying().(*types.Pointer)
-		if !ok {
-			break
-		}
-
-		ptrDepth++
-
-		// Avoid pointer type cycles.
-		if seenPtrTypes[ptrType] {
-			break
-		}
-
-		if _, named := ptrType.(*types.Named); named {
-			// Lazily allocate "seen" since it isn't used normally.
-			if seenPtrTypes == nil {
-				seenPtrTypes = make(map[types.Type]bool)
-			}
-
-			// Track named pointer types we have seen to detect cycles.
-			seenPtrTypes[ptrType] = true
+	case *types.Array:
+		// Try converting array to slice.
+		if f(types.NewSlice(t.Elem()), false, takeSlice) {
+			return true
 		}
-
-		if f(ptr.Elem(), false) {
-			for i := 0; i < ptrDepth; i++ {
-				// Mark the candidate so we know to prepend "*" when formatting.
-				c.mods = append(c.mods, dereference)
-			}
+	case *types.Pointer:
+		if f(t.Elem(), false, dereference) {
 			return true
 		}
-
-		ptrType = ptr.Elem()
 	}
 
 	// Check if c is addressable and a pointer to c matches our type inference.
-	if c.addressable && f(types.NewPointer(objType), false) {
-		// Mark the candidate so we know to prepend "&" when formatting.
-		c.mods = append(c.mods, reference)
+	if addressable && f(types.NewPointer(t), false, reference) {
 		return true
 	}
 
-	if array, ok := objType.Underlying().(*types.Array); ok {
-		if f(types.NewSlice(array.Elem()), false) {
-			c.mods = append(c.mods, takeSlice)
+	return false
+}
+
+// anyCandType reports whether f returns true for any candidate type
+// derivable from c. It searches up to three levels of type
+// modification. For example, given "foo" we could discover "***foo"
+// or "*foo()".
+func (c *candidate) anyCandType(f func(t types.Type, addressable bool) bool) bool {
+	if c.obj == nil || c.obj.Type() == nil {
+		return false
+	}
+
+	const maxDepth = 3
+
+	var searchTypes func(t types.Type, addressable bool, mods []typeModKind) bool
+	searchTypes = func(t types.Type, addressable bool, mods []typeModKind) bool {
+		if f(t, addressable) {
+			if len(mods) > 0 {
+				newMods := make([]typeModKind, len(mods)+len(c.mods))
+				copy(newMods, mods)
+				copy(newMods[len(mods):], c.mods)
+				c.mods = newMods
+			}
 			return true
 		}
+
+		if len(mods) == maxDepth {
+			return false
+		}
+
+		return derivableTypes(t, addressable, func(t types.Type, addressable bool, mod typeModKind) bool {
+			return searchTypes(t, addressable, append(mods, mod))
+		})
 	}
 
-	return false
+	return searchTypes(c.obj.Type(), c.addressable, make([]typeModKind, 0, maxDepth))
 }
 
 // matchingCandidate reports whether cand matches our type inferences.

internal/lsp/testdata/summary.txt.golden

@@ -2,7 +2,7 @@
 CallHierarchyCount = 2
 CodeLensCount = 5
 CompletionsCount = 265
-CompletionSnippetCount = 100
+CompletionSnippetCount = 102
 UnimportedCompletionsCount = 5
 DeepCompletionsCount = 5
 FuzzyCompletionsCount = 8

internal/lsp/testdata/typemods/type_mods.go

@@ -0,0 +1,15 @@
+package typemods
+
+func fooFunc() func() int { //@item(modFooFunc, "fooFunc", "func() func() int", "func")
+	return func() int {
+		return 0
+	}
+}
+
+func fooPtr() *int { //@item(modFooPtr, "fooPtr", "func() *int", "func")
+	return nil
+}
+
+func _() {
+	var _ int = foo //@snippet(" //", modFooFunc, "fooFunc()()", "fooFunc()()"),snippet(" //", modFooPtr, "*fooPtr()", "*fooPtr()")
+}