Add classified text output for VS Find All References (#4030)

Author: navya9singh

internal/fourslash/baselineutil.go

@@ -26,6 +26,7 @@ const (
 	closingTagCmd               baselineCommand = "Closing Tag"
 	documentHighlightsCmd       baselineCommand = "documentHighlights"
 	findAllReferencesCmd        baselineCommand = "findAllReferences"
+	vsFindAllReferencesCmd      baselineCommand = "vsFindAllReferences"
 	goToDefinitionCmd           baselineCommand = "goToDefinition"
 	goToImplementationCmd       baselineCommand = "goToImplementation"
 	goToSourceDefinitionCmd     baselineCommand = "goToSourceDefinition"
@@ -78,7 +79,7 @@ func getBaselineFileName(t *testing.T, command baselineCommand) string {
 
 func getBaselineExtension(command baselineCommand) string {
 	switch command {
-	case quickInfoCmd, signatureHelpCmd, smartSelectionCmd, inlayHintsCmd, nonSuggestionDiagnosticsCmd, documentSymbolsCmd, closingTagCmd:
+	case quickInfoCmd, signatureHelpCmd, smartSelectionCmd, inlayHintsCmd, nonSuggestionDiagnosticsCmd, documentSymbolsCmd, closingTagCmd, vsFindAllReferencesCmd:
 		return "baseline"
 	case callHierarchyCmd:
 		return "callHierarchy.txt"

internal/fourslash/fourslash.go

@@ -2330,6 +2330,86 @@ func (f *FourslashTest) VerifyBaselineFindAllReferences(
 	}
 }
 
+func (f *FourslashTest) VerifyBaselineVsFindAllReferences(
+	t *testing.T,
+	markers ...string,
+) {
+	referenceLocations := f.lookupMarkersOrGetRanges(t, markers)
+
+	for _, markerOrRange := range referenceLocations {
+		f.GoToMarkerOrRange(t, markerOrRange)
+
+		params := &lsproto.ReferenceParams{
+			TextDocument: lsproto.TextDocumentIdentifier{
+				Uri: lsconv.FileNameToDocumentURI(f.activeFilename),
+			},
+			Position: f.currentCaretPosition,
+			Context: &lsproto.ReferenceContext{
+				IncludeDeclaration: true,
+			},
+		}
+		result := sendRequest(t, f, lsproto.TextDocumentVSReferencesInfo, params)
+		// Sort cross-project results for deterministic baselines
+		if result.VsReferenceItems != nil && len(*result.VsReferenceItems) > 0 {
+			items := *result.VsReferenceItems
+			slices.SortStableFunc(items, func(a, b *lsproto.VsReferenceItem) int {
+				ap, bp := "", ""
+				if a.VSProjectName != nil {
+					ap = *a.VSProjectName
+				}
+				if b.VSProjectName != nil {
+					bp = *b.VSProjectName
+				}
+				if ap != bp {
+					if ap < bp {
+						return -1
+					}
+					return 1
+				}
+				if a.VSLocation.Uri != b.VSLocation.Uri {
+					if string(a.VSLocation.Uri) < string(b.VSLocation.Uri) {
+						return -1
+					}
+					return 1
+				}
+				if a.VSLocation.Range.Start.Line != b.VSLocation.Range.Start.Line {
+					return int(a.VSLocation.Range.Start.Line) - int(b.VSLocation.Range.Start.Line)
+				}
+				return int(a.VSLocation.Range.Start.Character) - int(b.VSLocation.Range.Start.Character)
+			})
+			// Re-number IDs sequentially after sort
+			idRemap := make(map[int32]int32, len(items))
+			for i, item := range items {
+				idRemap[item.VSId] = int32(i)
+				item.VSId = int32(i)
+			}
+			for _, item := range items {
+				if item.VSDefinitionId != nil {
+					newDefId := idRemap[*item.VSDefinitionId]
+					item.VSDefinitionId = &newDefId
+				}
+			}
+		}
+		// Include file contents with markers
+		var locations []lsproto.Location
+		if result.VsReferenceItems != nil {
+			for _, item := range *result.VsReferenceItems {
+				locations = append(locations, item.VSLocation)
+			}
+		}
+		fileContents := f.getBaselineForLocationsWithFileContents(locations, baselineFourslashLocationsOptions{
+			marker:     markerOrRange,
+			markerName: "/*FIND ALL REFS*/",
+		})
+
+		if jsonStr, err := core.StringifyJson(result, "", "  "); err == nil {
+			f.addResultToBaseline(t, vsFindAllReferencesCmd, fileContents+"\n\n"+jsonStr)
+		} else {
+			t.Fatalf("Failed to stringify VS references result for baseline: %v", err)
+		}
+	}
+}
+
 func (f *FourslashTest) VerifyBaselineCodeLens(t *testing.T, preferences *lsutil.UserPreferences) {
 	if preferences != nil {
 		reset := f.ConfigureWithReset(t, *preferences)

internal/fourslash/tests/constructorFindAllReferences1VS_test.go

@@ -0,0 +1,23 @@
+package fourslash_test
+
+import (
+	"testing"
+
+	"github.com/microsoft/typescript-go/internal/fourslash"
+	"github.com/microsoft/typescript-go/internal/lsp/lsproto"
+	"github.com/microsoft/typescript-go/internal/testutil"
+)
+
+func TestConstructorFindAllReferences1VS(t *testing.T) {
+	t.Parallel()
+	defer testutil.RecoverAndFail(t, "Panic on fourslash test")
+	const content = `export class C {
+    /**/public constructor() { }
+    public foo() { }
+}
+
+new C().foo();`
+	f, done := fourslash.NewFourslash(t, &lsproto.ClientCapabilities{VSSupportsVisualStudioExtensions: new(true)}, content)
+	defer done()
+	f.VerifyBaselineVsFindAllReferences(t, "")
+}

internal/fourslash/tests/findAllRefsForDefaultExportVS_test.go

@@ -0,0 +1,24 @@
+package fourslash_test
+
+import (
+	"testing"
+
+	"github.com/microsoft/typescript-go/internal/fourslash"
+	"github.com/microsoft/typescript-go/internal/lsp/lsproto"
+	"github.com/microsoft/typescript-go/internal/testutil"
+)
+
+func TestFindAllRefsForDefaultExportVS(t *testing.T) {
+	t.Parallel()
+	defer testutil.RecoverAndFail(t, "Panic on fourslash test")
+	const content = `// @Filename: a.ts
+export default function /*def*/f() {}
+// @Filename: b.ts
+import /*deg*/g from "./a";
+[|/*ref*/g|]();
+// @Filename: c.ts
+import { f } from "./a";`
+	f, done := fourslash.NewFourslash(t, &lsproto.ClientCapabilities{VSSupportsVisualStudioExtensions: new(true)}, content)
+	defer done()
+	f.VerifyBaselineVsFindAllReferences(t, "def", "deg")
+}

internal/fourslash/tests/findAllRefsInheritedProperties1VS_test.go

@@ -0,0 +1,25 @@
+package fourslash_test
+
+import (
+	"testing"
+
+	"github.com/microsoft/typescript-go/internal/fourslash"
+	"github.com/microsoft/typescript-go/internal/lsp/lsproto"
+	"github.com/microsoft/typescript-go/internal/testutil"
+)
+
+func TestFindAllRefsInheritedProperties1VS(t *testing.T) {
+	t.Parallel()
+	defer testutil.RecoverAndFail(t, "Panic on fourslash test")
+	const content = `class class1 extends class1 {
+   /*1*/doStuff() { }
+   /*2*/propName: string;
+}
+
+var v: class1;
+v./*3*/doStuff();
+v./*4*/propName;`
+	f, done := fourslash.NewFourslash(t, &lsproto.ClientCapabilities{VSSupportsVisualStudioExtensions: new(true)}, content)
+	defer done()
+	f.VerifyBaselineVsFindAllReferences(t, "1", "2", "3", "4")
+}

internal/fourslash/tests/findReferencesAcrossMultipleProjectsVS_test.go

@@ -0,0 +1,25 @@
+package fourslash_test
+
+import (
+	"testing"
+
+	"github.com/microsoft/typescript-go/internal/fourslash"
+	"github.com/microsoft/typescript-go/internal/lsp/lsproto"
+	"github.com/microsoft/typescript-go/internal/testutil"
+)
+
+func TestFindReferencesAcrossMultipleProjectsVS(t *testing.T) {
+	t.Parallel()
+	defer testutil.RecoverAndFail(t, "Panic on fourslash test")
+	const content = `//@Filename: a.ts
+/*1*/var /*2*/x: number;
+//@Filename: b.ts
+/// <reference path="a.ts" />
+/*3*/x++;
+//@Filename: c.ts
+/// <reference path="a.ts" />
+/*4*/x++;`
+	f, done := fourslash.NewFourslash(t, &lsproto.ClientCapabilities{VSSupportsVisualStudioExtensions: new(true)}, content)
+	defer done()
+	f.VerifyBaselineVsFindAllReferences(t, "1", "2", "3", "4")
+}

internal/fourslash/tests/tsxFindAllReferences1VS_test.go

@@ -0,0 +1,29 @@
+package fourslash_test
+
+import (
+	"testing"
+
+	"github.com/microsoft/typescript-go/internal/fourslash"
+	"github.com/microsoft/typescript-go/internal/lsp/lsproto"
+	"github.com/microsoft/typescript-go/internal/testutil"
+)
+
+func TestTsxFindAllReferences1VS(t *testing.T) {
+	t.Parallel()
+	defer testutil.RecoverAndFail(t, "Panic on fourslash test")
+	const content = `//@Filename: file.tsx
+declare namespace JSX {
+    interface Element { }
+    interface IntrinsicElements {
+        /*1*/div: {
+            name?: string;
+            isOpen?: boolean;
+        };
+        span: { n: string; };
+    }
+}
+var x = /*2*/</*3*/div />;`
+	f, done := fourslash.NewFourslash(t, &lsproto.ClientCapabilities{VSSupportsVisualStudioExtensions: new(true)}, content)
+	defer done()
+	f.VerifyBaselineVsFindAllReferences(t, "1", "2", "3")
+}

internal/ls/crossproject.go

@@ -308,6 +308,34 @@ func combineReferences(results iter.Seq[lsproto.ReferencesResponse]) lsproto.Ref
 	return lsproto.LocationsOrNull{Locations: combineResponseLocations(results)}
 }
 
+func combineVsReferences(results iter.Seq[lsproto.VsReferencesResponse]) lsproto.VsReferencesResponse {
+	var combined []*lsproto.VsReferenceItem
+	// Re-number IDs across projects to maintain unique IDs and correct definition references
+	nextId := int32(0)
+	for resp := range results {
+		if resp.VsReferenceItems == nil {
+			continue
+		}
+		// Map old IDs to new IDs for this batch
+		idMap := make(map[int32]int32)
+		for _, item := range *resp.VsReferenceItems {
+			oldId := item.VSId
+			newId := nextId
+			idMap[oldId] = newId
+			nextId++
+
+			newItem := *item
+			newItem.VSId = newId
+			if item.VSDefinitionId != nil {
+				newDefId := idMap[*item.VSDefinitionId]
+				newItem.VSDefinitionId = &newDefId
+			}
+			combined = append(combined, &newItem)
+		}
+	}
+	return lsproto.VsReferencesResponse{VsReferenceItems: &combined}
+}
+
 func combineImplementations(results iter.Seq[lsproto.ImplementationResponse]) lsproto.ImplementationResponse {
 	var combined []*lsproto.LocationLink
 	var seenLocations collections.Set[lsproto.Location]

internal/ls/displaypartswriter.go

@@ -35,6 +35,7 @@ func (w *displayPartsWriter) addRun(classification lsproto.ClassificationTypeNam
 		w.runs = append(w.runs, &lsproto.ClassifiedTextRun{
 			ClassificationTypeName: string(classification),
 			Text:                   text,
+			VSType:                 "ClassifiedTextRun",
 		})
 	}
 	w.lastWritten = text