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/protocol"
21 "golang.org/x/tools/internal/lsp/source"
22 "golang.org/x/tools/internal/lsp/tests"
23 "golang.org/x/tools/internal/span"
24 "golang.org/x/tools/internal/testenv"
27 func TestMain(m *testing.M) {
28 testenv.ExitIfSmallMachine()
32 func TestLSP(t *testing.T) {
33 tests.RunTests(t, "testdata", true, testLSP)
39 diagnostics map[span.URI][]*source.Diagnostic
43 func testLSP(t *testing.T, datum *tests.Data) {
44 ctx := tests.Context(t)
46 cache := cache.New(ctx, nil)
47 session := cache.NewSession(ctx)
48 options := source.DefaultOptions().Clone()
49 tests.DefaultOptions(options)
50 session.SetOptions(options)
51 options.SetEnvSlice(datum.Config.Env)
52 view, snapshot, release, err := session.NewView(ctx, datum.Config.Dir, span.URIFromPath(datum.Config.Dir), options)
57 defer view.Shutdown(ctx)
59 // Enable type error analyses for tests.
60 // TODO(golang/go#38212): Delete this once they are enabled by default.
61 tests.EnableAllAnalyzers(view, options)
62 view.SetOptions(ctx, options)
64 // Only run the -modfile specific tests in module mode with Go 1.14 or above.
65 datum.ModfileFlagAvailable = len(snapshot.ModFiles()) > 0 && testenv.Go1Point() >= 14
68 var modifications []source.FileModification
69 for filename, content := range datum.Config.Overlay {
70 kind := source.DetectLanguage("", filename)
71 if kind != source.Go {
74 modifications = append(modifications, source.FileModification{
75 URI: span.URIFromPath(filename),
82 if err := session.ModifyFiles(ctx, modifications); err != nil {
86 server: NewServer(session, testClient{}),
90 tests.Run(t, r, datum)
93 // testClient stubs any client functions that may be called by LSP functions.
94 type testClient struct {
98 // Trivially implement PublishDiagnostics so that we can call
99 // server.publishReports below to de-dup sent diagnostics.
100 func (c testClient) PublishDiagnostics(context.Context, *protocol.PublishDiagnosticsParams) error {
104 func (r *runner) CallHierarchy(t *testing.T, spn span.Span, expectedCalls *tests.CallHierarchyResult) {
105 mapper, err := r.data.Mapper(spn.URI())
109 loc, err := mapper.Location(spn)
111 t.Fatalf("failed for %v: %v", spn, err)
114 params := &protocol.CallHierarchyPrepareParams{
115 TextDocumentPositionParams: protocol.TextDocumentPositionParams{
116 TextDocument: protocol.TextDocumentIdentifier{URI: loc.URI},
117 Position: loc.Range.Start,
121 items, err := r.server.PrepareCallHierarchy(r.ctx, params)
126 t.Fatalf("expected call hierarchy item to be returned for identifier at %v\n", loc.Range)
129 callLocation := protocol.Location{
131 Range: items[0].Range,
133 if callLocation != loc {
134 t.Fatalf("expected server.PrepareCallHierarchy to return identifier at %v but got %v\n", loc, callLocation)
137 incomingCalls, err := r.server.IncomingCalls(r.ctx, &protocol.CallHierarchyIncomingCallsParams{Item: items[0]})
141 var incomingCallItems []protocol.CallHierarchyItem
142 for _, item := range incomingCalls {
143 incomingCallItems = append(incomingCallItems, item.From)
145 msg := tests.DiffCallHierarchyItems(incomingCallItems, expectedCalls.IncomingCalls)
147 t.Error(fmt.Sprintf("incoming calls: %s", msg))
150 outgoingCalls, err := r.server.OutgoingCalls(r.ctx, &protocol.CallHierarchyOutgoingCallsParams{Item: items[0]})
154 var outgoingCallItems []protocol.CallHierarchyItem
155 for _, item := range outgoingCalls {
156 outgoingCallItems = append(outgoingCallItems, item.To)
158 msg = tests.DiffCallHierarchyItems(outgoingCallItems, expectedCalls.OutgoingCalls)
160 t.Error(fmt.Sprintf("outgoing calls: %s", msg))
164 func (r *runner) CodeLens(t *testing.T, uri span.URI, want []protocol.CodeLens) {
165 if source.DetectLanguage("", uri.Filename()) != source.Mod {
168 got, err := r.server.codeLens(r.ctx, &protocol.CodeLensParams{
169 TextDocument: protocol.TextDocumentIdentifier{
170 URI: protocol.DocumentURI(uri),
176 if diff := tests.DiffCodeLens(uri, want, got); diff != "" {
177 t.Errorf("%s: %s", uri, diff)
181 func (r *runner) Diagnostics(t *testing.T, uri span.URI, want []*source.Diagnostic) {
182 // Get the diagnostics for this view if we have not done it before.
183 v := r.server.session.View(r.data.Config.Dir)
184 r.collectDiagnostics(v)
185 d := r.diagnostics[uri]
186 got := make([]*source.Diagnostic, len(d))
188 // A special case to test that there are no diagnostics for a file.
189 if len(want) == 1 && want[0].Source == "no_diagnostics" {
191 t.Errorf("expected no diagnostics for %s, got %v", uri, got)
195 if diff := tests.DiffDiagnostics(uri, want, got); diff != "" {
200 func (r *runner) FoldingRanges(t *testing.T, spn span.Span) {
202 view, err := r.server.session.ViewOf(uri)
206 original := view.Options()
209 // Test all folding ranges.
210 modified.LineFoldingOnly = false
211 view, err = view.SetOptions(r.ctx, modified)
216 ranges, err := r.server.FoldingRange(r.ctx, &protocol.FoldingRangeParams{
217 TextDocument: protocol.TextDocumentIdentifier{
218 URI: protocol.URIFromSpanURI(uri),
225 r.foldingRanges(t, "foldingRange", uri, ranges)
227 // Test folding ranges with lineFoldingOnly = true.
228 modified.LineFoldingOnly = true
229 view, err = view.SetOptions(r.ctx, modified)
234 ranges, err = r.server.FoldingRange(r.ctx, &protocol.FoldingRangeParams{
235 TextDocument: protocol.TextDocumentIdentifier{
236 URI: protocol.URIFromSpanURI(uri),
243 r.foldingRanges(t, "foldingRange-lineFolding", uri, ranges)
244 view.SetOptions(r.ctx, original)
247 func (r *runner) foldingRanges(t *testing.T, prefix string, uri span.URI, ranges []protocol.FoldingRange) {
248 m, err := r.data.Mapper(uri)
253 nonOverlapping := nonOverlappingRanges(ranges)
254 for i, rngs := range nonOverlapping {
255 got, err := foldRanges(m, string(m.Content), rngs)
260 tag := fmt.Sprintf("%s-%d", prefix, i)
261 want := string(r.data.Golden(tag, uri.Filename(), func() ([]byte, error) {
262 return []byte(got), nil
266 t.Errorf("%s: foldingRanges failed for %s, expected:\n%v\ngot:\n%v", tag, uri.Filename(), want, got)
271 kinds := []protocol.FoldingRangeKind{protocol.Imports, protocol.Comment}
272 for _, kind := range kinds {
273 var kindOnly []protocol.FoldingRange
274 for _, fRng := range ranges {
275 if fRng.Kind == string(kind) {
276 kindOnly = append(kindOnly, fRng)
280 nonOverlapping := nonOverlappingRanges(kindOnly)
281 for i, rngs := range nonOverlapping {
282 got, err := foldRanges(m, string(m.Content), rngs)
287 tag := fmt.Sprintf("%s-%s-%d", prefix, kind, i)
288 want := string(r.data.Golden(tag, uri.Filename(), func() ([]byte, error) {
289 return []byte(got), nil
293 t.Errorf("%s: foldingRanges failed for %s, expected:\n%v\ngot:\n%v", tag, uri.Filename(), want, got)
300 func nonOverlappingRanges(ranges []protocol.FoldingRange) (res [][]protocol.FoldingRange) {
301 for _, fRng := range ranges {
303 for i := 0; i < len(res); i++ {
305 for _, rng := range res[i] {
306 if conflict(rng, fRng) {
316 if setNum == len(res) {
317 res = append(res, []protocol.FoldingRange{})
319 res[setNum] = append(res[setNum], fRng)
324 func conflict(a, b protocol.FoldingRange) bool {
325 // a start position is <= b start positions
326 return (a.StartLine < b.StartLine || (a.StartLine == b.StartLine && a.StartCharacter <= b.StartCharacter)) &&
327 (a.EndLine > b.StartLine || (a.EndLine == b.StartLine && a.EndCharacter > b.StartCharacter))
330 func foldRanges(m *protocol.ColumnMapper, contents string, ranges []protocol.FoldingRange) (string, error) {
333 // Apply the edits from the end of the file forward
334 // to preserve the offsets
335 for i := len(ranges) - 1; i >= 0; i-- {
337 spn, err := m.RangeSpan(protocol.Range{
338 Start: protocol.Position{
339 Line: fRange.StartLine,
340 Character: fRange.StartCharacter,
342 End: protocol.Position{
343 Line: fRange.EndLine,
344 Character: fRange.EndCharacter,
350 start := spn.Start().Offset()
351 end := spn.End().Offset()
353 tmp := res[0:start] + foldedText
354 res = tmp + res[end:]
359 func (r *runner) Format(t *testing.T, spn span.Span) {
361 filename := uri.Filename()
362 gofmted := string(r.data.Golden("gofmt", filename, func() ([]byte, error) {
363 cmd := exec.Command("gofmt", filename)
364 out, _ := cmd.Output() // ignore error, sometimes we have intentionally ungofmt-able files
368 edits, err := r.server.Formatting(r.ctx, &protocol.DocumentFormattingParams{
369 TextDocument: protocol.TextDocumentIdentifier{
370 URI: protocol.URIFromSpanURI(uri),
379 m, err := r.data.Mapper(uri)
383 sedits, err := source.FromProtocolEdits(m, edits)
387 got := diff.ApplyEdits(string(m.Content), sedits)
389 t.Errorf("format failed for %s, expected:\n%v\ngot:\n%v", filename, gofmted, got)
393 func (r *runner) SemanticTokens(t *testing.T, spn span.Span) {
394 // no client, so use default
395 rememberToks(SemanticTypes(), SemanticModifiers())
397 filename := uri.Filename()
398 // this is called solely for coverage in semantic.go
399 _, err := r.server.semanticTokensFull(r.ctx, &protocol.SemanticTokensParams{
400 TextDocument: protocol.TextDocumentIdentifier{
401 URI: protocol.URIFromSpanURI(uri),
405 t.Errorf("%v for %s", err, filename)
407 _, err = r.server.semanticTokensRange(r.ctx, &protocol.SemanticTokensRangeParams{
408 TextDocument: protocol.TextDocumentIdentifier{
409 URI: protocol.URIFromSpanURI(uri),
411 // any legal range. Just to exercise the call.
412 Range: protocol.Range{
413 Start: protocol.Position{
417 End: protocol.Position{
424 t.Errorf("%v for Range %s", err, filename)
428 func (r *runner) Import(t *testing.T, spn span.Span) {
430 filename := uri.Filename()
431 actions, err := r.server.CodeAction(r.ctx, &protocol.CodeActionParams{
432 TextDocument: protocol.TextDocumentIdentifier{
433 URI: protocol.URIFromSpanURI(uri),
439 m, err := r.data.Mapper(uri)
443 got := string(m.Content)
444 if len(actions) > 0 {
445 res, err := applyTextDocumentEdits(r, actions[0].Edit.DocumentChanges)
451 want := string(r.data.Golden("goimports", filename, func() ([]byte, error) {
452 return []byte(got), nil
455 d := myers.ComputeEdits(uri, want, got)
456 t.Errorf("import failed for %s: %s", filename, diff.ToUnified("want", "got", want, d))
460 func (r *runner) SuggestedFix(t *testing.T, spn span.Span, actionKinds []string) {
462 view, err := r.server.session.ViewOf(uri)
467 snapshot, release := view.Snapshot(r.ctx)
470 fh, err := snapshot.GetVersionedFile(r.ctx, uri)
474 m, err := r.data.Mapper(uri)
478 rng, err := m.Range(spn)
482 // Get the diagnostics for this view if we have not done it before.
483 r.collectDiagnostics(view)
484 var diagnostics []protocol.Diagnostic
485 for _, d := range r.diagnostics[uri] {
486 // Compare the start positions rather than the entire range because
487 // some diagnostics have a range with the same start and end position (8:1-8:1).
488 // The current marker functionality prevents us from having a range of 0 length.
489 if protocol.ComparePosition(d.Range.Start, rng.Start) == 0 {
490 diagnostics = append(diagnostics, toProtocolDiagnostics([]*source.Diagnostic{d})...)
494 codeActionKinds := []protocol.CodeActionKind{}
495 for _, k := range actionKinds {
496 codeActionKinds = append(codeActionKinds, protocol.CodeActionKind(k))
498 actions, err := r.server.CodeAction(r.ctx, &protocol.CodeActionParams{
499 TextDocument: protocol.TextDocumentIdentifier{
500 URI: protocol.URIFromSpanURI(uri),
503 Context: protocol.CodeActionContext{
504 Only: codeActionKinds,
505 Diagnostics: diagnostics,
509 t.Fatalf("CodeAction %s failed: %v", spn, err)
511 if len(actions) != 1 {
512 // Hack: We assume that we only get one code action per range.
513 // TODO(rstambler): Support multiple code actions per test.
514 t.Fatalf("unexpected number of code actions, want 1, got %v", len(actions))
518 for _, k := range codeActionKinds {
519 if action.Kind == k {
525 t.Fatalf("unexpected kind for code action %s, expected one of %v, got %v", action.Title, codeActionKinds, action.Kind)
527 var res map[span.URI]string
528 if cmd := action.Command; cmd != nil {
529 edits, err := commandToEdits(r.ctx, snapshot, fh, rng, action.Command.Command)
533 res, err = applyTextDocumentEdits(r, edits)
538 res, err = applyTextDocumentEdits(r, action.Edit.DocumentChanges)
543 for u, got := range res {
544 want := string(r.data.Golden("suggestedfix_"+tests.SpanName(spn), u.Filename(), func() ([]byte, error) {
545 return []byte(got), nil
548 t.Errorf("suggested fixes failed for %s:\n%s", u.Filename(), tests.Diff(want, got))
553 func commandToEdits(ctx context.Context, snapshot source.Snapshot, fh source.VersionedFileHandle, rng protocol.Range, cmd string) ([]protocol.TextDocumentEdit, error) {
554 var command *source.Command
555 for _, c := range source.Commands {
562 return nil, fmt.Errorf("no known command for %s", cmd)
564 if !command.Applies(ctx, snapshot, fh, rng) {
565 return nil, fmt.Errorf("cannot apply %v", command.ID())
567 return command.SuggestedFix(ctx, snapshot, fh, rng)
570 func (r *runner) FunctionExtraction(t *testing.T, start span.Span, end span.Span) {
572 view, err := r.server.session.ViewOf(uri)
577 snapshot, release := view.Snapshot(r.ctx)
580 fh, err := snapshot.GetVersionedFile(r.ctx, uri)
584 m, err := r.data.Mapper(uri)
588 spn := span.New(start.URI(), start.Start(), end.End())
589 rng, err := m.Range(spn)
593 actions, err := r.server.CodeAction(r.ctx, &protocol.CodeActionParams{
594 TextDocument: protocol.TextDocumentIdentifier{
595 URI: protocol.URIFromSpanURI(uri),
598 Context: protocol.CodeActionContext{
599 Only: []protocol.CodeActionKind{"refactor.extract"},
605 // Hack: We assume that we only get one code action per range.
606 // TODO(rstambler): Support multiple code actions per test.
607 if len(actions) == 0 || len(actions) > 1 {
608 t.Fatalf("unexpected number of code actions, want 1, got %v", len(actions))
610 edits, err := commandToEdits(r.ctx, snapshot, fh, rng, actions[0].Command.Command)
614 res, err := applyTextDocumentEdits(r, edits)
618 for u, got := range res {
619 want := string(r.data.Golden("functionextraction_"+tests.SpanName(spn), u.Filename(), func() ([]byte, error) {
620 return []byte(got), nil
623 t.Errorf("function extraction failed for %s:\n%s", u.Filename(), tests.Diff(want, got))
628 func (r *runner) Definition(t *testing.T, spn span.Span, d tests.Definition) {
629 sm, err := r.data.Mapper(d.Src.URI())
633 loc, err := sm.Location(d.Src)
635 t.Fatalf("failed for %v: %v", d.Src, err)
637 tdpp := protocol.TextDocumentPositionParams{
638 TextDocument: protocol.TextDocumentIdentifier{URI: loc.URI},
639 Position: loc.Range.Start,
641 var locs []protocol.Location
642 var hover *protocol.Hover
644 params := &protocol.TypeDefinitionParams{
645 TextDocumentPositionParams: tdpp,
647 locs, err = r.server.TypeDefinition(r.ctx, params)
649 params := &protocol.DefinitionParams{
650 TextDocumentPositionParams: tdpp,
652 locs, err = r.server.Definition(r.ctx, params)
654 t.Fatalf("failed for %v: %+v", d.Src, err)
656 v := &protocol.HoverParams{
657 TextDocumentPositionParams: tdpp,
659 hover, err = r.server.Hover(r.ctx, v)
662 t.Fatalf("failed for %v: %v", d.Src, err)
665 t.Errorf("got %d locations for definition, expected 1", len(locs))
667 didSomething := false
670 tag := fmt.Sprintf("%s-hover", d.Name)
671 expectHover := string(r.data.Golden(tag, d.Src.URI().Filename(), func() ([]byte, error) {
672 return []byte(hover.Contents.Value), nil
674 if hover.Contents.Value != expectHover {
675 t.Errorf("%s:\n%s", d.Src, tests.Diff(expectHover, hover.Contents.Value))
680 locURI := locs[0].URI.SpanURI()
681 lm, err := r.data.Mapper(locURI)
685 if def, err := lm.Span(locs[0]); err != nil {
686 t.Fatalf("failed for %v: %v", locs[0], err)
687 } else if def != d.Def {
688 t.Errorf("for %v got %v want %v", d.Src, def, d.Def)
692 t.Errorf("no tests ran for %s", d.Src.URI())
696 func (r *runner) Implementation(t *testing.T, spn span.Span, impls []span.Span) {
697 sm, err := r.data.Mapper(spn.URI())
701 loc, err := sm.Location(spn)
703 t.Fatalf("failed for %v: %v", spn, err)
705 tdpp := protocol.TextDocumentPositionParams{
706 TextDocument: protocol.TextDocumentIdentifier{URI: loc.URI},
707 Position: loc.Range.Start,
709 var locs []protocol.Location
710 params := &protocol.ImplementationParams{
711 TextDocumentPositionParams: tdpp,
713 locs, err = r.server.Implementation(r.ctx, params)
715 t.Fatalf("failed for %v: %v", spn, err)
717 if len(locs) != len(impls) {
718 t.Fatalf("got %d locations for implementation, expected %d", len(locs), len(impls))
721 var results []span.Span
722 for i := range locs {
723 locURI := locs[i].URI.SpanURI()
724 lm, err := r.data.Mapper(locURI)
728 imp, err := lm.Span(locs[i])
730 t.Fatalf("failed for %v: %v", locs[i], err)
732 results = append(results, imp)
734 // Sort results and expected to make tests deterministic.
735 sort.SliceStable(results, func(i, j int) bool {
736 return span.Compare(results[i], results[j]) == -1
738 sort.SliceStable(impls, func(i, j int) bool {
739 return span.Compare(impls[i], impls[j]) == -1
741 for i := range results {
742 if results[i] != impls[i] {
743 t.Errorf("for %dth implementation of %v got %v want %v", i, spn, results[i], impls[i])
748 func (r *runner) Highlight(t *testing.T, src span.Span, locations []span.Span) {
749 m, err := r.data.Mapper(src.URI())
753 loc, err := m.Location(src)
755 t.Fatalf("failed for %v: %v", locations[0], err)
757 tdpp := protocol.TextDocumentPositionParams{
758 TextDocument: protocol.TextDocumentIdentifier{URI: loc.URI},
759 Position: loc.Range.Start,
761 params := &protocol.DocumentHighlightParams{
762 TextDocumentPositionParams: tdpp,
764 highlights, err := r.server.DocumentHighlight(r.ctx, params)
768 if len(highlights) != len(locations) {
769 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))
771 // Check to make sure highlights have a valid range.
772 var results []span.Span
773 for i := range highlights {
774 h, err := m.RangeSpan(highlights[i].Range)
776 t.Fatalf("failed for %v: %v", highlights[i], err)
778 results = append(results, h)
780 // Sort results to make tests deterministic since DocumentHighlight uses a map.
781 sort.SliceStable(results, func(i, j int) bool {
782 return span.Compare(results[i], results[j]) == -1
784 // Check to make sure all the expected highlights are found.
785 for i := range results {
786 if results[i] != locations[i] {
787 t.Errorf("want %v, got %v\n", locations[i], results[i])
792 func (r *runner) References(t *testing.T, src span.Span, itemList []span.Span) {
793 sm, err := r.data.Mapper(src.URI())
797 loc, err := sm.Location(src)
799 t.Fatalf("failed for %v: %v", src, err)
801 for _, includeDeclaration := range []bool{true, false} {
802 t.Run(fmt.Sprintf("refs-declaration-%v", includeDeclaration), func(t *testing.T) {
803 want := make(map[protocol.Location]bool)
804 for i, pos := range itemList {
805 // We don't want the first result if we aren't including the declaration.
806 if i == 0 && !includeDeclaration {
809 m, err := r.data.Mapper(pos.URI())
813 loc, err := m.Location(pos)
815 t.Fatalf("failed for %v: %v", src, err)
819 params := &protocol.ReferenceParams{
820 TextDocumentPositionParams: protocol.TextDocumentPositionParams{
821 TextDocument: protocol.TextDocumentIdentifier{URI: loc.URI},
822 Position: loc.Range.Start,
824 Context: protocol.ReferenceContext{
825 IncludeDeclaration: includeDeclaration,
828 got, err := r.server.References(r.ctx, params)
830 t.Fatalf("failed for %v: %v", src, err)
832 if len(got) != len(want) {
833 t.Errorf("references failed: different lengths got %v want %v", len(got), len(want))
835 for _, loc := range got {
837 t.Errorf("references failed: incorrect references got %v want %v", loc, want)
844 func (r *runner) Rename(t *testing.T, spn span.Span, newText string) {
845 tag := fmt.Sprintf("%s-rename", newText)
848 filename := uri.Filename()
849 sm, err := r.data.Mapper(uri)
853 loc, err := sm.Location(spn)
855 t.Fatalf("failed for %v: %v", spn, err)
858 wedit, err := r.server.Rename(r.ctx, &protocol.RenameParams{
859 TextDocument: protocol.TextDocumentIdentifier{
860 URI: protocol.URIFromSpanURI(uri),
862 Position: loc.Range.Start,
866 renamed := string(r.data.Golden(tag, filename, func() ([]byte, error) {
867 return []byte(err.Error()), nil
869 if err.Error() != renamed {
870 t.Errorf("rename failed for %s, expected:\n%v\ngot:\n%v\n", newText, renamed, err)
874 res, err := applyTextDocumentEdits(r, wedit.DocumentChanges)
878 var orderedURIs []string
879 for uri := range res {
880 orderedURIs = append(orderedURIs, string(uri))
882 sort.Strings(orderedURIs)
885 for i := 0; i < len(res); i++ {
889 uri := span.URIFromURI(orderedURIs[i])
891 got += filepath.Base(uri.Filename()) + ":\n"
896 want := string(r.data.Golden(tag, filename, func() ([]byte, error) {
897 return []byte(got), nil
900 t.Errorf("rename failed for %s:\n%s", newText, tests.Diff(want, got))
904 func (r *runner) PrepareRename(t *testing.T, src span.Span, want *source.PrepareItem) {
905 m, err := r.data.Mapper(src.URI())
909 loc, err := m.Location(src)
911 t.Fatalf("failed for %v: %v", src, err)
913 tdpp := protocol.TextDocumentPositionParams{
914 TextDocument: protocol.TextDocumentIdentifier{URI: loc.URI},
915 Position: loc.Range.Start,
917 params := &protocol.PrepareRenameParams{
918 TextDocumentPositionParams: tdpp,
920 got, err := r.server.PrepareRename(context.Background(), params)
922 t.Errorf("prepare rename failed for %v: got error: %v", src, err)
925 // we all love typed nils
927 if want.Text != "" { // expected an ident.
928 t.Errorf("prepare rename failed for %v: got nil", src)
932 if got.Start == got.End {
933 // Special case for 0-length ranges. Marks can't specify a 0-length range,
934 // so just compare the start.
935 if got.Start != want.Range.Start {
936 t.Errorf("prepare rename failed: incorrect point, got %v want %v", got.Start, want.Range.Start)
939 if protocol.CompareRange(*got, want.Range) != 0 {
940 t.Errorf("prepare rename failed: incorrect range got %v want %v", *got, want.Range)
945 func applyTextDocumentEdits(r *runner, edits []protocol.TextDocumentEdit) (map[span.URI]string, error) {
946 res := map[span.URI]string{}
947 for _, docEdits := range edits {
948 uri := docEdits.TextDocument.URI.SpanURI()
949 var m *protocol.ColumnMapper
950 // If we have already edited this file, we use the edited version (rather than the
951 // file in its original state) so that we preserve our initial changes.
952 if content, ok := res[uri]; ok {
953 m = &protocol.ColumnMapper{
955 Converter: span.NewContentConverter(
956 uri.Filename(), []byte(content)),
957 Content: []byte(content),
961 if m, err = r.data.Mapper(uri); err != nil {
965 res[uri] = string(m.Content)
966 sedits, err := source.FromProtocolEdits(m, docEdits.Edits)
970 res[uri] = applyEdits(res[uri], sedits)
975 func applyEdits(contents string, edits []diff.TextEdit) string {
978 // Apply the edits from the end of the file forward
979 // to preserve the offsets
980 for i := len(edits) - 1; i >= 0; i-- {
982 start := edit.Span.Start().Offset()
983 end := edit.Span.End().Offset()
984 tmp := res[0:start] + edit.NewText
985 res = tmp + res[end:]
990 func (r *runner) Symbols(t *testing.T, uri span.URI, expectedSymbols []protocol.DocumentSymbol) {
991 params := &protocol.DocumentSymbolParams{
992 TextDocument: protocol.TextDocumentIdentifier{
993 URI: protocol.URIFromSpanURI(uri),
996 got, err := r.server.DocumentSymbol(r.ctx, params)
1000 if len(got) != len(expectedSymbols) {
1001 t.Errorf("want %d top-level symbols in %v, got %d", len(expectedSymbols), uri, len(got))
1004 symbols := make([]protocol.DocumentSymbol, len(got))
1005 for i, s := range got {
1006 s, ok := s.(protocol.DocumentSymbol)
1008 t.Fatalf("%v: wanted []DocumentSymbols but got %v", uri, got)
1012 if diff := tests.DiffSymbols(t, uri, expectedSymbols, symbols); diff != "" {
1017 func (r *runner) WorkspaceSymbols(t *testing.T, query string, expectedSymbols []protocol.SymbolInformation, dirs map[string]struct{}) {
1018 r.callWorkspaceSymbols(t, query, source.SymbolCaseInsensitive, dirs, expectedSymbols)
1021 func (r *runner) FuzzyWorkspaceSymbols(t *testing.T, query string, expectedSymbols []protocol.SymbolInformation, dirs map[string]struct{}) {
1022 r.callWorkspaceSymbols(t, query, source.SymbolFuzzy, dirs, expectedSymbols)
1025 func (r *runner) CaseSensitiveWorkspaceSymbols(t *testing.T, query string, expectedSymbols []protocol.SymbolInformation, dirs map[string]struct{}) {
1026 r.callWorkspaceSymbols(t, query, source.SymbolCaseSensitive, dirs, expectedSymbols)
1029 func (r *runner) callWorkspaceSymbols(t *testing.T, query string, matcher source.SymbolMatcher, dirs map[string]struct{}, expectedSymbols []protocol.SymbolInformation) {
1032 original := r.server.session.Options()
1033 modified := original
1034 modified.SymbolMatcher = matcher
1035 r.server.session.SetOptions(modified)
1036 defer r.server.session.SetOptions(original)
1038 params := &protocol.WorkspaceSymbolParams{
1041 got, err := r.server.Symbol(r.ctx, params)
1045 got = tests.FilterWorkspaceSymbols(got, dirs)
1046 if diff := tests.DiffWorkspaceSymbols(expectedSymbols, got); diff != "" {
1051 func (r *runner) SignatureHelp(t *testing.T, spn span.Span, want *protocol.SignatureHelp) {
1052 m, err := r.data.Mapper(spn.URI())
1056 loc, err := m.Location(spn)
1058 t.Fatalf("failed for %v: %v", loc, err)
1060 tdpp := protocol.TextDocumentPositionParams{
1061 TextDocument: protocol.TextDocumentIdentifier{
1062 URI: protocol.URIFromSpanURI(spn.URI()),
1064 Position: loc.Range.Start,
1066 params := &protocol.SignatureHelpParams{
1067 TextDocumentPositionParams: tdpp,
1069 got, err := r.server.SignatureHelp(r.ctx, params)
1071 // Only fail if we got an error we did not expect.
1079 t.Errorf("expected no signature, got %v", got)
1084 t.Fatalf("expected %v, got nil", want)
1086 if diff := tests.DiffSignatures(spn, want, got); diff != "" {
1091 func (r *runner) Link(t *testing.T, uri span.URI, wantLinks []tests.Link) {
1092 m, err := r.data.Mapper(uri)
1096 got, err := r.server.DocumentLink(r.ctx, &protocol.DocumentLinkParams{
1097 TextDocument: protocol.TextDocumentIdentifier{
1098 URI: protocol.URIFromSpanURI(uri),
1104 if diff := tests.DiffLinks(m, wantLinks, got); diff != "" {
1109 func TestBytesOffset(t *testing.T) {
1112 pos protocol.Position
1115 {text: `a𐐀b`, pos: protocol.Position{Line: 0, Character: 0}, want: 0},
1116 {text: `a𐐀b`, pos: protocol.Position{Line: 0, Character: 1}, want: 1},
1117 {text: `a𐐀b`, pos: protocol.Position{Line: 0, Character: 2}, want: 1},
1118 {text: `a𐐀b`, pos: protocol.Position{Line: 0, Character: 3}, want: 5},
1119 {text: `a𐐀b`, pos: protocol.Position{Line: 0, Character: 4}, want: 6},
1120 {text: `a𐐀b`, pos: protocol.Position{Line: 0, Character: 5}, want: -1},
1121 {text: "aaa\nbbb\n", pos: protocol.Position{Line: 0, Character: 3}, want: 3},
1122 {text: "aaa\nbbb\n", pos: protocol.Position{Line: 0, Character: 4}, want: 3},
1123 {text: "aaa\nbbb\n", pos: protocol.Position{Line: 1, Character: 0}, want: 4},
1124 {text: "aaa\nbbb\n", pos: protocol.Position{Line: 1, Character: 3}, want: 7},
1125 {text: "aaa\nbbb\n", pos: protocol.Position{Line: 1, Character: 4}, want: 7},
1126 {text: "aaa\nbbb\n", pos: protocol.Position{Line: 2, Character: 0}, want: 8},
1127 {text: "aaa\nbbb\n", pos: protocol.Position{Line: 2, Character: 1}, want: -1},
1128 {text: "aaa\nbbb\n\n", pos: protocol.Position{Line: 2, Character: 0}, want: 8},
1131 for i, test := range tests {
1132 fname := fmt.Sprintf("test %d", i)
1133 fset := token.NewFileSet()
1134 f := fset.AddFile(fname, -1, len(test.text))
1135 f.SetLinesForContent([]byte(test.text))
1136 uri := span.URIFromPath(fname)
1137 converter := span.NewContentConverter(fname, []byte(test.text))
1138 mapper := &protocol.ColumnMapper{
1140 Converter: converter,
1141 Content: []byte(test.text),
1143 got, err := mapper.Point(test.pos)
1144 if err != nil && test.want != -1 {
1145 t.Errorf("unexpected error: %v", err)
1147 if err == nil && got.Offset() != test.want {
1148 t.Errorf("want %d for %q(Line:%d,Character:%d), but got %d", test.want, test.text, int(test.pos.Line), int(test.pos.Character), got.Offset())
1153 func (r *runner) collectDiagnostics(view source.View) {
1154 if r.diagnostics != nil {
1157 r.diagnostics = make(map[span.URI][]*source.Diagnostic)
1159 snapshot, release := view.Snapshot(r.ctx)
1162 // Always run diagnostics with analysis.
1163 reports, _ := r.server.diagnose(r.ctx, snapshot, true)
1164 r.server.publishReports(r.ctx, snapshot, reports)
1165 for uri, sent := range r.server.delivered {
1166 var diagnostics []*source.Diagnostic
1167 for _, d := range sent.sorted {
1168 diagnostics = append(diagnostics, &source.Diagnostic{
1172 Severity: d.Severity,
1177 r.diagnostics[uri] = diagnostics