1 // Copyright 2018 The Go Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style
3 // license that can be found in the LICENSE file.
17 "golang.org/x/tools/internal/lsp/cache"
18 "golang.org/x/tools/internal/lsp/diff"
19 "golang.org/x/tools/internal/lsp/diff/myers"
20 "golang.org/x/tools/internal/lsp/fuzzy"
21 "golang.org/x/tools/internal/lsp/protocol"
22 "golang.org/x/tools/internal/lsp/source"
23 "golang.org/x/tools/internal/lsp/source/completion"
24 "golang.org/x/tools/internal/lsp/tests"
25 "golang.org/x/tools/internal/span"
26 "golang.org/x/tools/internal/testenv"
27 errors "golang.org/x/xerrors"
30 func TestMain(m *testing.M) {
31 testenv.ExitIfSmallMachine()
35 func TestSource(t *testing.T) {
36 tests.RunTests(t, "../testdata", true, testSource)
40 snapshot source.Snapshot
46 func testSource(t *testing.T, datum *tests.Data) {
47 ctx := tests.Context(t)
49 cache := cache.New(ctx, nil)
50 session := cache.NewSession(ctx)
51 options := source.DefaultOptions().Clone()
52 tests.DefaultOptions(options)
53 options.SetEnvSlice(datum.Config.Env)
54 view, _, release, err := session.NewView(ctx, "source_test", span.URIFromPath(datum.Config.Dir), options)
59 defer view.Shutdown(ctx)
61 // Enable type error analyses for tests.
62 // TODO(golang/go#38212): Delete this once they are enabled by default.
63 tests.EnableAllAnalyzers(view, options)
64 view.SetOptions(ctx, options)
65 var modifications []source.FileModification
66 for filename, content := range datum.Config.Overlay {
67 kind := source.DetectLanguage("", filename)
68 if kind != source.Go {
71 modifications = append(modifications, source.FileModification{
72 URI: span.URIFromPath(filename),
79 if err := session.ModifyFiles(ctx, modifications); err != nil {
82 snapshot, release := view.Snapshot(ctx)
90 tests.Run(t, r, datum)
93 func (r *runner) CallHierarchy(t *testing.T, spn span.Span, expectedCalls *tests.CallHierarchyResult) {
94 mapper, err := r.data.Mapper(spn.URI())
98 loc, err := mapper.Location(spn)
100 t.Fatalf("failed for %v: %v", spn, err)
102 fh, err := r.snapshot.GetFile(r.ctx, spn.URI())
107 items, err := source.PrepareCallHierarchy(r.ctx, r.snapshot, fh, loc.Range.Start)
112 t.Fatalf("expected call hierarchy item to be returned for identifier at %v\n", loc.Range)
115 callLocation := protocol.Location{
117 Range: items[0].Range,
119 if callLocation != loc {
120 t.Fatalf("expected source.PrepareCallHierarchy to return identifier at %v but got %v\n", loc, callLocation)
123 incomingCalls, err := source.IncomingCalls(r.ctx, r.snapshot, fh, loc.Range.Start)
127 var incomingCallItems []protocol.CallHierarchyItem
128 for _, item := range incomingCalls {
129 incomingCallItems = append(incomingCallItems, item.From)
131 msg := tests.DiffCallHierarchyItems(incomingCallItems, expectedCalls.IncomingCalls)
133 t.Error(fmt.Sprintf("incoming calls differ: %s", msg))
136 outgoingCalls, err := source.OutgoingCalls(r.ctx, r.snapshot, fh, loc.Range.Start)
140 var outgoingCallItems []protocol.CallHierarchyItem
141 for _, item := range outgoingCalls {
142 outgoingCallItems = append(outgoingCallItems, item.To)
144 msg = tests.DiffCallHierarchyItems(outgoingCallItems, expectedCalls.OutgoingCalls)
146 t.Error(fmt.Sprintf("outgoing calls differ: %s", msg))
150 func (r *runner) Diagnostics(t *testing.T, uri span.URI, want []*source.Diagnostic) {
151 fileID, got, err := source.FileDiagnostics(r.ctx, r.snapshot, uri)
155 // A special case to test that there are no diagnostics for a file.
156 if len(want) == 1 && want[0].Source == "no_diagnostics" {
158 t.Errorf("expected no diagnostics for %s, got %v", uri, got)
162 if diff := tests.DiffDiagnostics(fileID.URI, want, got); diff != "" {
167 func (r *runner) Completion(t *testing.T, src span.Span, test tests.Completion, items tests.CompletionItems) {
168 var want []protocol.CompletionItem
169 for _, pos := range test.CompletionItems {
170 want = append(want, tests.ToProtocolCompletionItem(*items[pos]))
172 _, got := r.callCompletion(t, src, func(opts *source.Options) {
173 opts.Matcher = source.CaseInsensitive
174 opts.DeepCompletion = false
175 opts.CompleteUnimported = false
176 opts.InsertTextFormat = protocol.SnippetTextFormat
177 if !strings.Contains(string(src.URI()), "literal") {
178 opts.LiteralCompletions = false
181 got = tests.FilterBuiltins(src, got)
182 if diff := tests.DiffCompletionItems(want, got); diff != "" {
183 t.Errorf("%s: %s", src, diff)
187 func (r *runner) CompletionSnippet(t *testing.T, src span.Span, expected tests.CompletionSnippet, placeholders bool, items tests.CompletionItems) {
188 _, list := r.callCompletion(t, src, func(opts *source.Options) {
189 opts.UsePlaceholders = placeholders
190 opts.DeepCompletion = true
191 opts.CompleteUnimported = false
193 got := tests.FindItem(list, *items[expected.CompletionItem])
194 want := expected.PlainSnippet
196 want = expected.PlaceholderSnippet
198 if diff := tests.DiffSnippets(want, got); diff != "" {
199 t.Errorf("%s: %s", src, diff)
203 func (r *runner) UnimportedCompletion(t *testing.T, src span.Span, test tests.Completion, items tests.CompletionItems) {
204 var want []protocol.CompletionItem
205 for _, pos := range test.CompletionItems {
206 want = append(want, tests.ToProtocolCompletionItem(*items[pos]))
208 _, got := r.callCompletion(t, src, func(opts *source.Options) {})
209 got = tests.FilterBuiltins(src, got)
210 if diff := tests.CheckCompletionOrder(want, got, false); diff != "" {
211 t.Errorf("%s: %s", src, diff)
215 func (r *runner) DeepCompletion(t *testing.T, src span.Span, test tests.Completion, items tests.CompletionItems) {
216 var want []protocol.CompletionItem
217 for _, pos := range test.CompletionItems {
218 want = append(want, tests.ToProtocolCompletionItem(*items[pos]))
220 prefix, list := r.callCompletion(t, src, func(opts *source.Options) {
221 opts.DeepCompletion = true
222 opts.Matcher = source.CaseInsensitive
223 opts.CompleteUnimported = false
225 list = tests.FilterBuiltins(src, list)
226 fuzzyMatcher := fuzzy.NewMatcher(prefix)
227 var got []protocol.CompletionItem
228 for _, item := range list {
229 if fuzzyMatcher.Score(item.Label) <= 0 {
232 got = append(got, item)
234 if msg := tests.DiffCompletionItems(want, got); msg != "" {
235 t.Errorf("%s: %s", src, msg)
239 func (r *runner) FuzzyCompletion(t *testing.T, src span.Span, test tests.Completion, items tests.CompletionItems) {
240 var want []protocol.CompletionItem
241 for _, pos := range test.CompletionItems {
242 want = append(want, tests.ToProtocolCompletionItem(*items[pos]))
244 _, got := r.callCompletion(t, src, func(opts *source.Options) {
245 opts.DeepCompletion = true
246 opts.Matcher = source.Fuzzy
247 opts.CompleteUnimported = false
249 got = tests.FilterBuiltins(src, got)
250 if msg := tests.DiffCompletionItems(want, got); msg != "" {
251 t.Errorf("%s: %s", src, msg)
255 func (r *runner) CaseSensitiveCompletion(t *testing.T, src span.Span, test tests.Completion, items tests.CompletionItems) {
256 var want []protocol.CompletionItem
257 for _, pos := range test.CompletionItems {
258 want = append(want, tests.ToProtocolCompletionItem(*items[pos]))
260 _, list := r.callCompletion(t, src, func(opts *source.Options) {
261 opts.Matcher = source.CaseSensitive
262 opts.CompleteUnimported = false
264 list = tests.FilterBuiltins(src, list)
265 if diff := tests.DiffCompletionItems(want, list); diff != "" {
266 t.Errorf("%s: %s", src, diff)
270 func (r *runner) RankCompletion(t *testing.T, src span.Span, test tests.Completion, items tests.CompletionItems) {
271 var want []protocol.CompletionItem
272 for _, pos := range test.CompletionItems {
273 want = append(want, tests.ToProtocolCompletionItem(*items[pos]))
275 _, got := r.callCompletion(t, src, func(opts *source.Options) {
276 opts.DeepCompletion = true
277 opts.Matcher = source.Fuzzy
279 if msg := tests.CheckCompletionOrder(want, got, true); msg != "" {
280 t.Errorf("%s: %s", src, msg)
284 func (r *runner) callCompletion(t *testing.T, src span.Span, options func(*source.Options)) (string, []protocol.CompletionItem) {
285 fh, err := r.snapshot.GetFile(r.ctx, src.URI())
289 original := r.view.Options()
290 modified := original.Clone()
292 newView, err := r.view.SetOptions(r.ctx, modified)
293 if newView != r.view {
294 t.Fatalf("options change unexpectedly created new view")
299 defer r.view.SetOptions(r.ctx, original)
301 list, surrounding, err := completion.Completion(r.ctx, r.snapshot, fh, protocol.Position{
302 Line: float64(src.Start().Line() - 1),
303 Character: float64(src.Start().Column() - 1),
304 }, protocol.CompletionContext{})
305 if err != nil && !errors.As(err, &completion.ErrIsDefinition{}) {
306 t.Fatalf("failed for %v: %v", src, err)
309 if surrounding != nil {
310 prefix = strings.ToLower(surrounding.Prefix())
313 var numDeepCompletionsSeen int
314 var items []completion.CompletionItem
315 // Apply deep completion filtering.
316 for _, item := range list {
318 if !modified.DeepCompletion {
321 if numDeepCompletionsSeen >= completion.MaxDeepCompletions {
324 numDeepCompletionsSeen++
326 items = append(items, item)
328 return prefix, tests.ToProtocolCompletionItems(items)
331 func (r *runner) FoldingRanges(t *testing.T, spn span.Span) {
334 fh, err := r.snapshot.GetFile(r.ctx, spn.URI())
338 data, err := fh.Read()
344 // Test all folding ranges.
345 ranges, err := source.FoldingRange(r.ctx, r.snapshot, fh, false)
350 r.foldingRanges(t, "foldingRange", uri, string(data), ranges)
352 // Test folding ranges with lineFoldingOnly
353 ranges, err = source.FoldingRange(r.ctx, r.snapshot, fh, true)
358 r.foldingRanges(t, "foldingRange-lineFolding", uri, string(data), ranges)
361 func (r *runner) foldingRanges(t *testing.T, prefix string, uri span.URI, data string, ranges []*source.FoldingRangeInfo) {
364 nonOverlapping := nonOverlappingRanges(t, ranges)
365 for i, rngs := range nonOverlapping {
366 got, err := foldRanges(string(data), rngs)
371 tag := fmt.Sprintf("%s-%d", prefix, i)
372 want := string(r.data.Golden(tag, uri.Filename(), func() ([]byte, error) {
373 return []byte(got), nil
377 t.Errorf("%s: foldingRanges failed for %s, expected:\n%v\ngot:\n%v", tag, uri.Filename(), want, got)
382 kinds := []protocol.FoldingRangeKind{protocol.Imports, protocol.Comment}
383 for _, kind := range kinds {
384 var kindOnly []*source.FoldingRangeInfo
385 for _, fRng := range ranges {
386 if fRng.Kind == kind {
387 kindOnly = append(kindOnly, fRng)
391 nonOverlapping := nonOverlappingRanges(t, kindOnly)
392 for i, rngs := range nonOverlapping {
393 got, err := foldRanges(string(data), rngs)
398 tag := fmt.Sprintf("%s-%s-%d", prefix, kind, i)
399 want := string(r.data.Golden(tag, uri.Filename(), func() ([]byte, error) {
400 return []byte(got), nil
404 t.Errorf("%s: failed for %s, expected:\n%v\ngot:\n%v", tag, uri.Filename(), want, got)
411 func nonOverlappingRanges(t *testing.T, ranges []*source.FoldingRangeInfo) (res [][]*source.FoldingRangeInfo) {
412 for _, fRng := range ranges {
414 for i := 0; i < len(res); i++ {
416 for _, rng := range res[i] {
417 if conflict(t, rng, fRng) {
427 if setNum == len(res) {
428 res = append(res, []*source.FoldingRangeInfo{})
430 res[setNum] = append(res[setNum], fRng)
435 func conflict(t *testing.T, a, b *source.FoldingRangeInfo) bool {
436 arng, err := a.Range()
440 brng, err := b.Range()
444 // a start position is <= b start positions
445 return protocol.ComparePosition(arng.Start, brng.Start) <= 0 && protocol.ComparePosition(arng.End, brng.Start) > 0
448 func foldRanges(contents string, ranges []*source.FoldingRangeInfo) (string, error) {
451 // Apply the folds from the end of the file forward
452 // to preserve the offsets.
453 for i := len(ranges) - 1; i >= 0; i-- {
455 spn, err := fRange.Span()
459 start := spn.Start().Offset()
460 end := spn.End().Offset()
462 tmp := res[0:start] + foldedText
463 res = tmp + res[end:]
468 func (r *runner) Format(t *testing.T, spn span.Span) {
469 gofmted := string(r.data.Golden("gofmt", spn.URI().Filename(), func() ([]byte, error) {
470 cmd := exec.Command("gofmt", spn.URI().Filename())
471 out, _ := cmd.Output() // ignore error, sometimes we have intentionally ungofmt-able files
474 fh, err := r.snapshot.GetFile(r.ctx, spn.URI())
478 edits, err := source.Format(r.ctx, r.snapshot, fh)
485 data, err := fh.Read()
489 m, err := r.data.Mapper(spn.URI())
493 diffEdits, err := source.FromProtocolEdits(m, edits)
497 got := diff.ApplyEdits(string(data), diffEdits)
499 t.Errorf("format failed for %s, expected:\n%v\ngot:\n%v", spn.URI().Filename(), gofmted, got)
503 func (r *runner) SemanticTokens(t *testing.T, spn span.Span) {
504 t.Skip("nothing to test in source")
507 func (r *runner) Import(t *testing.T, spn span.Span) {
508 fh, err := r.snapshot.GetFile(r.ctx, spn.URI())
512 edits, _, err := source.AllImportsFixes(r.ctx, r.snapshot, fh)
516 data, err := fh.Read()
520 m, err := r.data.Mapper(fh.URI())
524 diffEdits, err := source.FromProtocolEdits(m, edits)
528 got := diff.ApplyEdits(string(data), diffEdits)
529 want := string(r.data.Golden("goimports", spn.URI().Filename(), func() ([]byte, error) {
530 return []byte(got), nil
533 d := myers.ComputeEdits(spn.URI(), want, got)
534 t.Errorf("import failed for %s: %s", spn.URI().Filename(), diff.ToUnified("want", "got", want, d))
538 func (r *runner) Definition(t *testing.T, spn span.Span, d tests.Definition) {
539 _, srcRng, err := spanToRange(r.data, d.Src)
543 fh, err := r.snapshot.GetFile(r.ctx, spn.URI())
547 ident, err := source.Identifier(r.ctx, r.snapshot, fh, srcRng.Start)
549 t.Fatalf("failed for %v: %v", d.Src, err)
551 h, err := source.HoverIdentifier(r.ctx, ident)
553 t.Fatalf("failed for %v: %v", d.Src, err)
555 hover, err := source.FormatHover(h, r.view.Options())
559 rng, err := ident.Declaration.MappedRange[0].Range()
564 rng, err = ident.Type.Range()
570 didSomething := false
573 tag := fmt.Sprintf("%s-hover", d.Name)
574 expectHover := string(r.data.Golden(tag, d.Src.URI().Filename(), func() ([]byte, error) {
575 return []byte(hover), nil
577 if hover != expectHover {
578 t.Errorf("hover for %s failed:\n%s", d.Src, tests.Diff(expectHover, hover))
583 if _, defRng, err := spanToRange(r.data, d.Def); err != nil {
585 } else if rng != defRng {
586 t.Errorf("for %v got %v want %v", d.Src, rng, defRng)
590 t.Errorf("no tests ran for %s", d.Src.URI())
594 func (r *runner) Implementation(t *testing.T, spn span.Span, impls []span.Span) {
595 sm, err := r.data.Mapper(spn.URI())
599 loc, err := sm.Location(spn)
601 t.Fatalf("failed for %v: %v", spn, err)
603 fh, err := r.snapshot.GetFile(r.ctx, spn.URI())
607 locs, err := source.Implementation(r.ctx, r.snapshot, fh, loc.Range.Start)
609 t.Fatalf("failed for %v: %v", spn, err)
611 if len(locs) != len(impls) {
612 t.Fatalf("got %d locations for implementation, expected %d", len(locs), len(impls))
614 var results []span.Span
615 for i := range locs {
616 locURI := locs[i].URI.SpanURI()
617 lm, err := r.data.Mapper(locURI)
621 imp, err := lm.Span(locs[i])
623 t.Fatalf("failed for %v: %v", locs[i], err)
625 results = append(results, imp)
627 // Sort results and expected to make tests deterministic.
628 sort.SliceStable(results, func(i, j int) bool {
629 return span.Compare(results[i], results[j]) == -1
631 sort.SliceStable(impls, func(i, j int) bool {
632 return span.Compare(impls[i], impls[j]) == -1
634 for i := range results {
635 if results[i] != impls[i] {
636 t.Errorf("for %dth implementation of %v got %v want %v", i, spn, results[i], impls[i])
641 func (r *runner) Highlight(t *testing.T, src span.Span, locations []span.Span) {
643 m, srcRng, err := spanToRange(r.data, src)
647 fh, err := r.snapshot.GetFile(r.ctx, src.URI())
651 highlights, err := source.Highlight(ctx, r.snapshot, fh, srcRng.Start)
653 t.Errorf("highlight failed for %s: %v", src.URI(), err)
655 if len(highlights) != len(locations) {
656 t.Fatalf("got %d highlights for highlight at %v:%v:%v, expected %d", len(highlights), src.URI().Filename(), src.Start().Line(), src.Start().Column(), len(locations))
658 // Check to make sure highlights have a valid range.
659 var results []span.Span
660 for i := range highlights {
661 h, err := m.RangeSpan(highlights[i])
663 t.Fatalf("failed for %v: %v", highlights[i], err)
665 results = append(results, h)
667 // Sort results to make tests deterministic since DocumentHighlight uses a map.
668 sort.SliceStable(results, func(i, j int) bool {
669 return span.Compare(results[i], results[j]) == -1
671 // Check to make sure all the expected highlights are found.
672 for i := range results {
673 if results[i] != locations[i] {
674 t.Errorf("want %v, got %v\n", locations[i], results[i])
679 func (r *runner) References(t *testing.T, src span.Span, itemList []span.Span) {
681 _, srcRng, err := spanToRange(r.data, src)
685 snapshot := r.snapshot
686 fh, err := snapshot.GetFile(r.ctx, src.URI())
690 for _, includeDeclaration := range []bool{true, false} {
691 t.Run(fmt.Sprintf("refs-declaration-%v", includeDeclaration), func(t *testing.T) {
692 want := make(map[span.Span]bool)
693 for i, pos := range itemList {
694 // We don't want the first result if we aren't including the declaration.
695 if i == 0 && !includeDeclaration {
700 refs, err := source.References(ctx, snapshot, fh, srcRng.Start, includeDeclaration)
702 t.Fatalf("failed for %s: %v", src, err)
704 got := make(map[span.Span]bool)
705 for _, refInfo := range refs {
706 refSpan, err := refInfo.Span()
712 if len(got) != len(want) {
713 t.Errorf("references failed: different lengths got %v want %v", len(got), len(want))
715 for spn := range got {
717 t.Errorf("references failed: incorrect references got %v want locations %v", got, want)
724 func (r *runner) Rename(t *testing.T, spn span.Span, newText string) {
725 tag := fmt.Sprintf("%s-rename", newText)
727 _, srcRng, err := spanToRange(r.data, spn)
731 fh, err := r.snapshot.GetFile(r.ctx, spn.URI())
735 changes, err := source.Rename(r.ctx, r.snapshot, fh, srcRng.Start, newText)
737 renamed := string(r.data.Golden(tag, spn.URI().Filename(), func() ([]byte, error) {
738 return []byte(err.Error()), nil
740 if err.Error() != renamed {
741 t.Errorf("rename failed for %s, expected:\n%v\ngot:\n%v\n", newText, renamed, err)
747 for editURI, edits := range changes {
748 fh, err := r.snapshot.GetFile(r.ctx, editURI)
752 data, err := fh.Read()
756 m, err := r.data.Mapper(fh.URI())
760 diffEdits, err := source.FromProtocolEdits(m, edits)
764 contents := applyEdits(string(data), diffEdits)
765 if len(changes) > 1 {
766 filename := filepath.Base(editURI.Filename())
767 contents = fmt.Sprintf("%s:\n%s", filename, contents)
769 res = append(res, contents)
776 for i, val := range res {
783 renamed := string(r.data.Golden(tag, spn.URI().Filename(), func() ([]byte, error) {
784 return []byte(got), nil
788 t.Errorf("rename failed for %s, expected:\n%v\ngot:\n%v", newText, renamed, got)
792 func applyEdits(contents string, edits []diff.TextEdit) string {
795 // Apply the edits from the end of the file forward
796 // to preserve the offsets
797 for i := len(edits) - 1; i >= 0; i-- {
799 start := edit.Span.Start().Offset()
800 end := edit.Span.End().Offset()
801 tmp := res[0:start] + edit.NewText
802 res = tmp + res[end:]
807 func (r *runner) PrepareRename(t *testing.T, src span.Span, want *source.PrepareItem) {
808 _, srcRng, err := spanToRange(r.data, src)
812 // Find the identifier at the position.
813 fh, err := r.snapshot.GetFile(r.ctx, src.URI())
817 item, err := source.PrepareRename(r.ctx, r.snapshot, fh, srcRng.Start)
819 if want.Text != "" { // expected an ident.
820 t.Errorf("prepare rename failed for %v: got error: %v", src, err)
826 t.Errorf("prepare rename failed for %v: got nil", src)
831 t.Errorf("prepare rename failed for %v: expected nil, got %v", src, item)
834 if item.Range.Start == item.Range.End {
835 // Special case for 0-length ranges. Marks can't specify a 0-length range,
836 // so just compare the start.
837 if item.Range.Start != want.Range.Start {
838 t.Errorf("prepare rename failed: incorrect point, got %v want %v", item.Range.Start, want.Range.Start)
841 if protocol.CompareRange(item.Range, want.Range) != 0 {
842 t.Errorf("prepare rename failed: incorrect range got %v want %v", item.Range, want.Range)
847 func (r *runner) Symbols(t *testing.T, uri span.URI, expectedSymbols []protocol.DocumentSymbol) {
848 fh, err := r.snapshot.GetFile(r.ctx, uri)
852 symbols, err := source.DocumentSymbols(r.ctx, r.snapshot, fh)
854 t.Errorf("symbols failed for %s: %v", uri, err)
856 if len(symbols) != len(expectedSymbols) {
857 t.Errorf("want %d top-level symbols in %v, got %d", len(expectedSymbols), uri, len(symbols))
860 if diff := tests.DiffSymbols(t, uri, expectedSymbols, symbols); diff != "" {
865 func (r *runner) WorkspaceSymbols(t *testing.T, query string, expectedSymbols []protocol.SymbolInformation, dirs map[string]struct{}) {
866 r.callWorkspaceSymbols(t, query, source.SymbolCaseInsensitive, dirs, expectedSymbols)
869 func (r *runner) FuzzyWorkspaceSymbols(t *testing.T, query string, expectedSymbols []protocol.SymbolInformation, dirs map[string]struct{}) {
870 r.callWorkspaceSymbols(t, query, source.SymbolFuzzy, dirs, expectedSymbols)
873 func (r *runner) CaseSensitiveWorkspaceSymbols(t *testing.T, query string, expectedSymbols []protocol.SymbolInformation, dirs map[string]struct{}) {
874 r.callWorkspaceSymbols(t, query, source.SymbolCaseSensitive, dirs, expectedSymbols)
877 func (r *runner) callWorkspaceSymbols(t *testing.T, query string, matcher source.SymbolMatcher, dirs map[string]struct{}, expectedSymbols []protocol.SymbolInformation) {
879 got, err := source.WorkspaceSymbols(r.ctx, matcher, source.PackageQualifiedSymbols, []source.View{r.view}, query)
883 got = tests.FilterWorkspaceSymbols(got, dirs)
884 if diff := tests.DiffWorkspaceSymbols(expectedSymbols, got); diff != "" {
889 func (r *runner) SignatureHelp(t *testing.T, spn span.Span, want *protocol.SignatureHelp) {
890 _, rng, err := spanToRange(r.data, spn)
894 fh, err := r.snapshot.GetFile(r.ctx, spn.URI())
898 gotSignature, gotActiveParameter, err := source.SignatureHelp(r.ctx, r.snapshot, fh, rng.Start)
900 // Only fail if we got an error we did not expect.
902 t.Fatalf("failed for %v: %v", spn, err)
906 if gotSignature == nil {
908 t.Fatalf("got nil signature, but expected %v", want)
912 got := &protocol.SignatureHelp{
913 Signatures: []protocol.SignatureInformation{*gotSignature},
914 ActiveParameter: float64(gotActiveParameter),
916 if diff := tests.DiffSignatures(spn, want, got); diff != "" {
921 // These are pure LSP features, no source level functionality to be tested.
922 func (r *runner) Link(t *testing.T, uri span.URI, wantLinks []tests.Link) {}
923 func (r *runner) SuggestedFix(t *testing.T, spn span.Span, actionKinds []string) {}
924 func (r *runner) FunctionExtraction(t *testing.T, start span.Span, end span.Span) {}
925 func (r *runner) CodeLens(t *testing.T, uri span.URI, want []protocol.CodeLens) {}
927 func spanToRange(data *tests.Data, spn span.Span) (*protocol.ColumnMapper, protocol.Range, error) {
928 m, err := data.Mapper(spn.URI())
930 return nil, protocol.Range{}, err
932 srcRng, err := m.Range(spn)
934 return nil, protocol.Range{}, err
936 return m, srcRng, nil