gopls/internal/regtest/marker: port all deep and fuzzy completion tests

Port @deep and @fuzzy markers, which were just @complete with different
options. Since we support settings.json in the new marker tests, there
was no need for new markers.

For golang/go#54845

Change-Id: I56f670b51084fa20e71c607a7f20e0372c793598
Reviewed-on: https://go-review.googlesource.com/c/tools/+/537881
Auto-Submit: Robert Findley <[email protected]>
Reviewed-by: Alan Donovan <[email protected]>
LUCI-TryBot-Result: Go LUCI <[email protected]>

Author: findleyr

gopls/internal/lsp/completion_test.go

@@ -49,32 +49,6 @@ func (r *runner) CompletionSnippet(t *testing.T, src span.Span, expected tests.C
 	}
 }
 
-func (r *runner) DeepCompletion(t *testing.T, src span.Span, test tests.Completion, items tests.CompletionItems) {
-	got := r.callCompletion(t, src, func(opts *source.Options) {
-		opts.DeepCompletion = true
-		opts.Matcher = source.CaseInsensitive
-		opts.CompleteUnimported = false
-	})
-	got = tests.FilterBuiltins(src, got)
-	want := expected(t, test, items)
-	if diff := tests.DiffCompletionItems(want, got); diff != "" {
-		t.Errorf("mismatching completion items (-want +got):\n%s", diff)
-	}
-}
-
-func (r *runner) FuzzyCompletion(t *testing.T, src span.Span, test tests.Completion, items tests.CompletionItems) {
-	got := r.callCompletion(t, src, func(opts *source.Options) {
-		opts.DeepCompletion = true
-		opts.Matcher = source.Fuzzy
-		opts.CompleteUnimported = false
-	})
-	got = tests.FilterBuiltins(src, got)
-	want := expected(t, test, items)
-	if diff := tests.DiffCompletionItems(want, got); diff != "" {
-		t.Errorf("mismatching completion items (-want +got):\n%s", diff)
-	}
-}
-
 func (r *runner) CaseSensitiveCompletion(t *testing.T, src span.Span, test tests.Completion, items tests.CompletionItems) {
 	got := r.callCompletion(t, src, func(opts *source.Options) {
 		opts.Matcher = source.CaseSensitive

gopls/internal/lsp/source/options.go

@@ -595,6 +595,9 @@ type InternalOptions struct {
 	// LiteralCompletions controls whether literal candidates such as
 	// "&someStruct{}" are offered. Tests disable this flag to simplify
 	// their expected values.
+	//
+	// TODO(rfindley): this is almost unnecessary now. Remove it along with the
+	// old marker tests.
 	LiteralCompletions bool
 
 	// VerboseWorkDoneProgress controls whether the LSP server should send

gopls/internal/lsp/testdata/summary.txt.golden

@@ -1,10 +1,8 @@
 -- summary --
 CallHierarchyCount = 2
-CompletionsCount = 178
-CompletionSnippetCount = 41
-DeepCompletionsCount = 5
-FuzzyCompletionsCount = 8
-RankedCompletionsCount = 163
+CompletionsCount = 177
+CompletionSnippetCount = 27
+RankedCompletionsCount = 151
 CaseSensitiveCompletionsCount = 4
 SemanticTokenCount = 3
 SuggestedFixCount = 80

gopls/internal/lsp/tests/tests.go

@@ -58,8 +58,6 @@ type CallHierarchy = map[span.Span]*CallHierarchyResult
 type CompletionItems = map[token.Pos]*completion.CompletionItem
 type Completions = map[span.Span][]Completion
 type CompletionSnippets = map[span.Span][]CompletionSnippet
-type DeepCompletions = map[span.Span][]Completion
-type FuzzyCompletions = map[span.Span][]Completion
 type CaseSensitiveCompletions = map[span.Span][]Completion
 type RankCompletions = map[span.Span][]Completion
 type SemanticTokens = []span.Span
@@ -79,8 +77,6 @@ type Data struct {
 	CompletionItems          CompletionItems
 	Completions              Completions
 	CompletionSnippets       CompletionSnippets
-	DeepCompletions          DeepCompletions
-	FuzzyCompletions         FuzzyCompletions
 	CaseSensitiveCompletions CaseSensitiveCompletions
 	RankCompletions          RankCompletions
 	SemanticTokens           SemanticTokens
@@ -114,8 +110,6 @@ type Tests interface {
 	CallHierarchy(*testing.T, span.Span, *CallHierarchyResult)
 	Completion(*testing.T, span.Span, Completion, CompletionItems)
 	CompletionSnippet(*testing.T, span.Span, CompletionSnippet, bool, CompletionItems)
-	DeepCompletion(*testing.T, span.Span, Completion, CompletionItems)
-	FuzzyCompletion(*testing.T, span.Span, Completion, CompletionItems)
 	CaseSensitiveCompletion(*testing.T, span.Span, Completion, CompletionItems)
 	RankCompletion(*testing.T, span.Span, Completion, CompletionItems)
 	SemanticTokens(*testing.T, span.Span)
@@ -235,8 +229,6 @@ func load(t testing.TB, mode string, dir string) *Data {
 		CompletionItems:          make(CompletionItems),
 		Completions:              make(Completions),
 		CompletionSnippets:       make(CompletionSnippets),
-		DeepCompletions:          make(DeepCompletions),
-		FuzzyCompletions:         make(FuzzyCompletions),
 		RankCompletions:          make(RankCompletions),
 		CaseSensitiveCompletions: make(CaseSensitiveCompletions),
 		Renames:                  make(Renames),
@@ -500,16 +492,6 @@ func Run(t *testing.T, tests Tests, data *Data) {
 		}
 	})
 
-	t.Run("DeepCompletion", func(t *testing.T) {
-		t.Helper()
-		eachCompletion(t, data.DeepCompletions, tests.DeepCompletion)
-	})
-
-	t.Run("FuzzyCompletion", func(t *testing.T) {
-		t.Helper()
-		eachCompletion(t, data.FuzzyCompletions, tests.FuzzyCompletion)
-	})
-
 	t.Run("CaseSensitiveCompletion", func(t *testing.T) {
 		t.Helper()
 		eachCompletion(t, data.CaseSensitiveCompletions, tests.CaseSensitiveCompletion)
@@ -665,8 +647,6 @@ func checkData(t *testing.T, data *Data) {
 	fmt.Fprintf(buf, "CallHierarchyCount = %v\n", len(data.CallHierarchy))
 	fmt.Fprintf(buf, "CompletionsCount = %v\n", countCompletions(data.Completions))
 	fmt.Fprintf(buf, "CompletionSnippetCount = %v\n", snippetCount)
-	fmt.Fprintf(buf, "DeepCompletionsCount = %v\n", countCompletions(data.DeepCompletions))
-	fmt.Fprintf(buf, "FuzzyCompletionsCount = %v\n", countCompletions(data.FuzzyCompletions))
 	fmt.Fprintf(buf, "RankedCompletionsCount = %v\n", countCompletions(data.RankCompletions))
 	fmt.Fprintf(buf, "CaseSensitiveCompletionsCount = %v\n", countCompletions(data.CaseSensitiveCompletions))
 	fmt.Fprintf(buf, "SemanticTokenCount = %v\n", len(data.SemanticTokens))
@@ -764,14 +744,6 @@ func (data *Data) collectCompletions(typ CompletionTestType) func(span.Span, []t
 		})
 	}
 	switch typ {
-	case CompletionDeep:
-		return func(src span.Span, expected []token.Pos) {
-			result(data.DeepCompletions, src, expected)
-		}
-	case CompletionFuzzy:
-		return func(src span.Span, expected []token.Pos) {
-			result(data.FuzzyCompletions, src, expected)
-		}
 	case CompletionRank:
 		return func(src span.Span, expected []token.Pos) {
 			result(data.RankCompletions, src, expected)

gopls/internal/lsp/testdata/address/address.go gopls/internal/regtest/marker/testdata/completion/address.txt

@@ -1,3 +1,17 @@
+This test exercises the reference and dereference completion modifiers.
+
+TODO: remove the need to set "literalCompletions" here, as this is one of the
+few places this setting is needed.
+
+-- flags --
+-ignore_extra_diags
+
+-- go.mod --
+module golang.org/lsptests
+
+go 1.18
+
+-- address/address.go --
 package address
 
 func wantsPtr(*int)            {}
@@ -13,39 +27,39 @@ func _() {
 		b int    //@item(addrB, "b", "int", "var")
 	)
 
-	wantsPtr()   //@rank(")", addrB, addrA),snippet(")", addrB, "&b", "&b")
-	wantsPtr(&b) //@snippet(")", addrB, "b", "b")
+	wantsPtr()   //@rank(")", addrB, addrA),snippet(")", addrB, "&b")
+	wantsPtr(&b) //@snippet(")", addrB, "b")
 
-	wantsVariadicPtr() //@rank(")", addrB, addrA),snippet(")", addrB, "&b", "&b")
+	wantsVariadicPtr() //@rank(")", addrB, addrA),snippet(")", addrB, "&b")
 
 	var s foo
 	s.c          //@item(addrDeepC, "s.c", "int", "field")
-	wantsPtr()   //@snippet(")", addrDeepC, "&s.c", "&s.c")
-	wantsPtr(s)  //@snippet(")", addrDeepC, "&s.c", "&s.c")
-	wantsPtr(&s) //@snippet(")", addrDeepC, "s.c", "s.c")
+	wantsPtr()   //@snippet(")", addrDeepC, "&s.c")
+	wantsPtr(s)  //@snippet(")", addrDeepC, "&s.c")
+	wantsPtr(&s) //@snippet(")", addrDeepC, "s.c")
 
 	// don't add "&" in item (it gets added as an additional edit)
-	wantsPtr(&s.c) //@snippet(")", addrFieldC, "c", "c")
+	wantsPtr(&s.c) //@snippet(")", addrFieldC, "c")
 
 	// check dereferencing as well
 	var c *int    //@item(addrCPtr, "c", "*int", "var")
-	var _ int = _ //@rank("_ //", addrCPtr, addrA),snippet("_ //", addrCPtr, "*c", "*c")
+	var _ int = _ //@rank("_ //", addrCPtr, addrA),snippet("_ //", addrCPtr, "*c")
 
-	wantsVariadic() //@rank(")", addrCPtr, addrA),snippet(")", addrCPtr, "*c", "*c")
+	wantsVariadic() //@rank(")", addrCPtr, addrA),snippet(")", addrCPtr, "*c")
 
 	var d **int   //@item(addrDPtr, "d", "**int", "var")
-	var _ int = _ //@rank("_ //", addrDPtr, addrA),snippet("_ //", addrDPtr, "**d", "**d")
+	var _ int = _ //@rank("_ //", addrDPtr, addrA),snippet("_ //", addrDPtr, "**d")
 
 	type namedPtr *int
 	var np namedPtr //@item(addrNamedPtr, "np", "namedPtr", "var")
 
 	var _ int = _ //@rank("_ //", addrNamedPtr, addrA)
 
 	// don't get tripped up by recursive pointer type
-	type dontMessUp *dontMessUp
+	type dontMessUp *dontMessUp //@item(dontMessUp, "dontMessUp", "*dontMessUp", "type")
 	var dmu *dontMessUp //@item(addrDMU, "dmu", "*dontMessUp", "var")
 
-	var _ int = dmu //@complete(" //", addrDMU)
+	var _ int = dmu //@complete(" //", addrDMU, dontMessUp)
 }
 
 func (f foo) ptr() *foo { return &f }
@@ -59,8 +73,8 @@ func _() {
 	// addressable
 	getFoo().ptr().c //@item(addrGetFooPtrC, "getFoo().ptr().c", "int", "field")
 
-	wantsPtr()   //@rank(addrGetFooPtrC, addrGetFooC),snippet(")", addrGetFooPtrC, "&getFoo().ptr().c", "&getFoo().ptr().c")
-	wantsPtr(&g) //@rank(addrGetFooPtrC, addrGetFooC),snippet(")", addrGetFooPtrC, "getFoo().ptr().c", "getFoo().ptr().c")
+	wantsPtr()   //@snippet(")", addrGetFooPtrC, "&getFoo().ptr().c")
+	wantsPtr(&g) //@snippet(")", addrGetFooPtrC, "getFoo().ptr().c")
 }
 
 type nested struct {
@@ -74,5 +88,5 @@ func _() {
 	getNested().f.ptr().c //@item(addrNestedPtrC, "getNested().f.ptr().c", "int", "field")
 
 	// addrNestedC is not addressable, so rank lower
-	wantsPtr(getNestedfc) //@fuzzy(")", addrNestedPtrC, addrNestedC)
+	wantsPtr(getNestedfc) //@complete(")", addrNestedPtrC, addrNestedC)
 }

gopls/internal/lsp/testdata/deep/deep.go gopls/internal/regtest/marker/testdata/completion/deep.txt

@@ -1,3 +1,20 @@
+This test exercises deep completion.
+
+-- settings.json --
+{
+	"completeUnimported": false,
+	"matcher": "caseInsensitive"
+}
+
+-- flags --
+-ignore_extra_diags
+
+-- go.mod --
+module golang.org/lsptests
+
+go 1.18
+
+-- deep/deep.go --
 package deep
 
 import "context"
@@ -14,9 +31,9 @@ func wantsDeepB(deepB) {}
 func _() {
 	var a deepA   //@item(deepAVar, "a", "deepA", "var")
 	a.b           //@item(deepABField, "a.b", "deepB", "field")
-	wantsDeepB(a) //@deep(")", deepABField, deepAVar)
+	wantsDeepB(a) //@complete(")", deepABField, deepAVar)
 
-	deepA{a} //@snippet("}", deepABField, "a.b", "a.b")
+	deepA{a} //@snippet("}", deepABField, "a.b")
 }
 
 func wantsContext(context.Context) {}
@@ -32,7 +49,7 @@ func _() {
 	var cork struct{ err error }
 	cork.err         //@item(deepCorkErr, "cork.err", "error", "field")
 	context          //@item(deepContextPkg, "context", "\"context\"", "package")
-	var _ error = co //@rank(" //", deepCorkErr, deepContextPkg)
+	var _ error = co // rank(" //", deepCorkErr, deepContextPkg)
 }
 
 func _() {
@@ -42,7 +59,7 @@ func _() {
 	}
 	var circle deepCircle   //@item(deepCircle, "circle", "deepCircle", "var")
 	circle.deepCircle       //@item(deepCircleField, "circle.deepCircle", "*deepCircle", "field")
-	var _ deepCircle = circ //@deep(" //", deepCircle, deepCircleField),snippet(" //", deepCircleField, "*circle.deepCircle", "*circle.deepCircle")
+	var _ deepCircle = circ //@complete(" //", deepCircle, deepCircleField),snippet(" //", deepCircleField, "*circle.deepCircle")
 }
 
 func _() {
@@ -60,7 +77,7 @@ func _() {
 	var a deepEmbedA //@item(deepEmbedA, "a", "deepEmbedA", "var")
 	a.deepEmbedB     //@item(deepEmbedB, "a.deepEmbedB", "deepEmbedB", "field")
 	a.deepEmbedC     //@item(deepEmbedC, "a.deepEmbedC", "deepEmbedC", "field")
-	wantsC(a)        //@deep(")", deepEmbedC, deepEmbedA, deepEmbedB)
+	wantsC(a)        //@complete(")", deepEmbedC, deepEmbedA, deepEmbedB)
 }
 
 func _() {
@@ -70,7 +87,7 @@ func _() {
 	}
 
 	nested{
-		a: 123, //@deep(" //", deepNestedField)
+		a: 123, //@complete(" //", deepNestedField)
 	}
 }
 
@@ -89,54 +106,5 @@ func _() {
 
 	// "a.d" should be ranked above the deeper "a.b.c"
 	var i int
-	i = a //@deep(" //", deepAD, deepABC, deepA, deepAB)
-}
-
-type foo struct {
-	b bar
-}
-
-func (f foo) bar() bar {
-	return f.b
-}
-
-func (f foo) barPtr() *bar {
-	return &f.b
-}
-
-type bar struct{}
-
-func (b bar) valueReceiver() int {
-	return 0
-}
-
-func (b *bar) ptrReceiver() int {
-	return 0
-}
-
-func _() {
-	var (
-		i int
-		f foo
-	)
-
-	f.bar().valueReceiver    //@item(deepBarValue, "f.bar().valueReceiver", "func() int", "method")
-	f.barPtr().ptrReceiver   //@item(deepBarPtrPtr, "f.barPtr().ptrReceiver", "func() int", "method")
-	f.barPtr().valueReceiver //@item(deepBarPtrValue, "f.barPtr().valueReceiver", "func() int", "method")
-
-	i = fbar //@fuzzy(" //", deepBarValue, deepBarPtrPtr, deepBarPtrValue)
-}
-
-func (b baz) Thing() struct{ val int } {
-	return b.thing
-}
-
-type baz struct {
-	thing struct{ val int }
-}
-
-func (b baz) _() {
-	b.Thing().val    //@item(deepBazMethVal, "b.Thing().val", "int", "field")
-	b.thing.val      //@item(deepBazFieldVal, "b.thing.val", "int", "field")
-	var _ int = bval //@rank(" //", deepBazFieldVal, deepBazMethVal)
+	i = a //@complete(" //", deepAD, deepABC, deepA, deepAB)
 }