internal/lsp/source: fix Deref function for cyclic types

The previous fix (d1362d7) is not sufficient for all cyclic types.
This change updates Deref function to support more complex cases.
We use a map with underlying types to detect cycles.

Fixes golang/go#45510

Change-Id: I28f655a9c1d4f363cb7ae3f47db3e8567fe6e80a
GitHub-Last-Rev: 4c89874
GitHub-Pull-Request: #305
Reviewed-on: https://go-review.googlesource.com/c/tools/+/310311
Reviewed-by: Rebecca Stambler <[email protected]>
Trust: Rebecca Stambler <[email protected]>
Trust: Robert Findley <[email protected]>
Run-TryBot: Rebecca Stambler <[email protected]>
gopls-CI: kokoro <[email protected]>
TryBot-Result: Go Bot <[email protected]>

Author: ShoshinNikita

gopls/internal/regtest/completion/completion_test.go

@@ -393,21 +393,45 @@ func _() {
 	var bbbb1, bbbb2 b
 	var _ b = bbbb
 }
+
+type (
+	c *d
+	d *e
+	e **c
+)
+
+func _() {
+	var (
+		xxxxc c
+		xxxxd d
+		xxxxe e
+	)
+
+	var _ c = xxxx
+	var _ d = xxxx
+	var _ e = xxxx
+}
 `
 
 	Run(t, files, func(t *testing.T, env *Env) {
 		env.OpenFile("main.go")
 
-		completions := env.Completion("main.go", env.RegexpSearch("main.go", `var _ a = aaaa()`))
-		diff := compareCompletionResults([]string{"aaaa1", "aaaa2"}, completions.Items)
-		if diff != "" {
-			t.Fatal(diff)
+		tests := []struct {
+			re   string
+			want []string
+		}{
+			{`var _ a = aaaa()`, []string{"aaaa1", "aaaa2"}},
+			{`var _ b = bbbb()`, []string{"bbbb1", "bbbb2"}},
+			{`var _ c = xxxx()`, []string{"***xxxxd", "**xxxxe", "xxxxc"}},
+			{`var _ d = xxxx()`, []string{"***xxxxe", "*xxxxc", "xxxxd"}},
+			{`var _ e = xxxx()`, []string{"**xxxxc", "*xxxxd", "xxxxe"}},
 		}
-
-		completions = env.Completion("main.go", env.RegexpSearch("main.go", `var _ b = bbbb()`))
-		diff = compareCompletionResults([]string{"bbbb1", "bbbb2"}, completions.Items)
-		if diff != "" {
-			t.Fatal(diff)
+		for _, tt := range tests {
+			completions := env.Completion("main.go", env.RegexpSearch("main.go", tt.re))
+			diff := compareCompletionResults(tt.want, completions.Items)
+			if diff != "" {
+				t.Errorf("%s: %s", tt.re, diff)
+			}
 		}
 	})
 }

internal/lsp/source/util.go

@@ -222,17 +222,24 @@ func FormatNode(fset *token.FileSet, n ast.Node) string {
 // Deref returns a pointer's element type, traversing as many levels as needed.
 // Otherwise it returns typ.
 //
-// It can return a pointer type if the type refers to itself (see golang/go#45510).
+// It can return a pointer type for cyclic types (see golang/go#45510).
 func Deref(typ types.Type) types.Type {
+	var seen map[types.Type]struct{}
 	for {
 		p, ok := typ.Underlying().(*types.Pointer)
 		if !ok {
 			return typ
 		}
-		if typ == p.Elem() {
+		if _, ok := seen[p.Elem()]; ok {
 			return typ
 		}
+
 		typ = p.Elem()
+
+		if seen == nil {
+			seen = make(map[types.Type]struct{})
+		}
+		seen[typ] = struct{}{}
 	}
 }