Document highlights

internal/ast/ast.go

@@ -3149,6 +3149,10 @@ func (node *ThrowStatement) computeSubtreeFacts() SubtreeFacts {
 	return propagateSubtreeFacts(node.Expression)
 }
 
+func IsThrowStatement(node *Node) bool {
+	return node.Kind == KindThrowStatement
+}
+
 // TryStatement
 
 type TryStatement struct {
@@ -6111,6 +6115,10 @@ func (node *YieldExpression) computeSubtreeFacts() SubtreeFacts {
 	return propagateSubtreeFacts(node.Expression) | SubtreeContainsForAwaitOrAsyncGenerator
 }
 
+func IsYieldExpression(node *Node) bool {
+	return node.Kind == KindYieldExpression
+}
+
 // ArrowFunction
 
 type ArrowFunction struct {

internal/checker/checker.go

@@ -10873,7 +10873,7 @@ func (c *Checker) checkPropertyAccessExpressionOrQualifiedName(node *ast.Node, l
 		c.checkPropertyNotUsedBeforeDeclaration(prop, node, right)
 		c.markPropertyAsReferenced(prop, node, c.isSelfTypeAccess(left, parentSymbol))
 		c.symbolNodeLinks.Get(node).resolvedSymbol = prop
-		c.checkPropertyAccessibility(node, left.Kind == ast.KindSuperKeyword, isWriteAccess(node), apparentType, prop)
+		c.checkPropertyAccessibility(node, left.Kind == ast.KindSuperKeyword, IsWriteAccess(node), apparentType, prop)
 		if c.isAssignmentToReadonlyEntity(node, prop, assignmentKind) {
 			c.error(right, diagnostics.Cannot_assign_to_0_because_it_is_a_read_only_property, right.Text())
 			return c.errorType
@@ -15715,9 +15715,9 @@ func (c *Checker) GetTypeOfSymbolAtLocation(symbol *ast.Symbol, location *ast.No
 			if ast.IsRightSideOfQualifiedNameOrPropertyAccess(location) {
 				location = location.Parent
 			}
-			if ast.IsExpressionNode(location) && (!ast.IsAssignmentTarget(location) || isWriteAccess(location)) {
+			if ast.IsExpressionNode(location) && (!ast.IsAssignmentTarget(location) || IsWriteAccess(location)) {
 				var t *Type
-				if isWriteAccess(location) && location.Kind == ast.KindPropertyAccessExpression {
+				if IsWriteAccess(location) && location.Kind == ast.KindPropertyAccessExpression {
 					t = c.checkPropertyAccessExpression(location, CheckModeNormal, true /*writeOnly*/)
 				} else {
 					t = c.getTypeOfExpression(location)
@@ -15735,7 +15735,7 @@ func (c *Checker) GetTypeOfSymbolAtLocation(symbol *ast.Symbol, location *ast.No
 		// to it at the given location. Since we have no control flow information for the
 		// hypothetical reference (control flow information is created and attached by the
 		// binder), we simply return the declared type of the symbol.
-		if isRightSideOfAccessExpression(location) && isWriteAccess(location.Parent) {
+		if isRightSideOfAccessExpression(location) && IsWriteAccess(location.Parent) {
 			return c.getWriteTypeOfSymbol(symbol)
 		}
 	}

internal/checker/utilities.go

@@ -1078,7 +1078,7 @@ func isWriteOnlyAccess(node *ast.Node) bool {
 	return accessKind(node) == AccessKindWrite
 }
 
-func isWriteAccess(node *ast.Node) bool {
+func IsWriteAccess(node *ast.Node) bool {
 	return accessKind(node) != AccessKindRead
 }
 

internal/fourslash/_scripts/convertFourslash.mts

@@ -178,6 +178,8 @@ function parseFourslashStatement(statement: ts.Statement): Cmd[] | undefined {
                 case "baselineFindAllReferences":
                     // `verify.baselineFindAllReferences(...)`
                     return parseBaselineFindAllReferencesArgs(callExpression.arguments);
+                case "baselineDocumentHighlights":
+                    return parseBaselineDocumentHighlightsArgs(callExpression.arguments);
                 case "baselineQuickInfo":
                     return [parseBaselineQuickInfo(callExpression.arguments)];
                 case "baselineSignatureHelp":
@@ -778,6 +780,90 @@ function parseBaselineFindAllReferencesArgs(args: readonly ts.Expression[]): [Ve
     }];
 }
 
+function parseBaselineDocumentHighlightsArgs(args: readonly ts.Expression[]): [VerifyBaselineDocumentHighlightsCmd] | undefined {
+    const newArgs: string[] = [];
+    let preferences: string | undefined;
+    for (const arg of args) {
+        let strArg;
+        if (strArg = getArrayLiteralExpression(arg)) {
+            for (const elem of strArg.elements) {
+                const newArg = parseBaselineDocumentHighlightsArg(elem);
+                if (!newArg) {
+                    return undefined;
+                }
+                newArgs.push(newArg);
+            }
+        }
+        else if (ts.isObjectLiteralExpression(arg)) {
+            // User preferences case, but multiple files isn't implemented in corsa yet
+        }
+        else if (strArg = parseBaselineDocumentHighlightsArg(arg)) {
+            newArgs.push(strArg);
+        }
+        else {
+            console.error(`Unrecognized argument in verify.baselineDocumentHighlights: ${arg.getText()}`);
+            return undefined;
+        }
+    }
+
+    if (newArgs.length === 0) {
+        newArgs.push("ToAny(f.Ranges())...");
+    }
+
+    return [{
+        kind: "verifyBaselineDocumentHighlights",
+        args: newArgs,
+        preferences: preferences ? preferences : "nil /*preferences*/",
+    }];
+}
+
+function parseBaselineDocumentHighlightsArg(arg: ts.Expression): string | undefined {
+    if (ts.isStringLiteral(arg)) {
+        return getGoStringLiteral(arg.text);
+    }
+    else if (ts.isIdentifier(arg) || (ts.isElementAccessExpression(arg) && ts.isIdentifier(arg.expression))) {
+        const argName = ts.isIdentifier(arg) ? arg.text : (arg.expression as ts.Identifier).text;
+        const file = arg.getSourceFile();
+        const varStmts = file.statements.filter(ts.isVariableStatement);
+        for (const varStmt of varStmts) {
+            for (const decl of varStmt.declarationList.declarations) {
+                if (ts.isArrayBindingPattern(decl.name) && decl.initializer?.getText().includes("ranges")) {
+                    for (let i = 0; i < decl.name.elements.length; i++) {
+                        const elem = decl.name.elements[i];
+                        if (ts.isBindingElement(elem) && ts.isIdentifier(elem.name) && elem.name.text === argName) {
+                            // `const [range_0, ..., range_n, ...] = test.ranges();` and arg is `range_n`
+                            if (elem.dotDotDotToken === undefined) {
+                                return `f.Ranges()[${i}]`;
+                            }
+                            // `const [range_0, ..., ...rest] = test.ranges();` and arg is `rest[n]`
+                            if (ts.isElementAccessExpression(arg)) {
+                                return `f.Ranges()[${i + parseInt(arg.argumentExpression!.getText())}]`;
+                            }
+                            // `const [range_0, ..., ...rest] = test.ranges();` and arg is `rest`
+                            return `ToAny(f.Ranges()[${i}:])...`;
+                        }
+                    }
+                }
+            }
+        }
+        const init = getNodeOfKind(arg, ts.isCallExpression);
+        if (init) {
+            const result = getRangesByTextArg(init);
+            if (result) {
+                return result;
+            }
+        }
+    }
+    else if (ts.isCallExpression(arg)) {
+        const result = getRangesByTextArg(arg);
+        if (result) {
+            return result;
+        }
+    }
+    console.error(`Unrecognized argument in verify.baselineRename: ${arg.getText()}`);
+    return undefined;
+}
+
 function parseBaselineGoToDefinitionArgs(args: readonly ts.Expression[]): [VerifyBaselineGoToDefinitionCmd] | undefined {
     const newArgs = [];
     for (const arg of args) {
@@ -1262,6 +1348,12 @@ interface VerifyBaselineRenameCmd {
     preferences: string;
 }
 
+interface VerifyBaselineDocumentHighlightsCmd {
+    kind: "verifyBaselineDocumentHighlights";
+    args: string[];
+    preferences: string;
+}
+
 interface GoToCmd {
     kind: "goTo";
     // !!! `selectRange` and `rangeStart` require parsing variables and `test.ranges()[n]`
@@ -1289,6 +1381,7 @@ interface VerifyRenameInfoCmd {
 type Cmd =
     | VerifyCompletionsCmd
     | VerifyBaselineFindAllReferencesCmd
+    | VerifyBaselineDocumentHighlightsCmd
     | VerifyBaselineGoToDefinitionCmd
     | VerifyBaselineQuickInfoCmd
     | VerifyBaselineSignatureHelpCmd
@@ -1332,6 +1425,10 @@ function generateBaselineFindAllReferences({ markers, ranges }: VerifyBaselineFi
     return `f.VerifyBaselineFindAllReferences(t, ${markers.join(", ")})`;
 }
 
+function generateBaselineDocumentHighlights({ args, preferences }: VerifyBaselineDocumentHighlightsCmd): string {
+    return `f.VerifyBaselineDocumentHighlights(t, ${preferences}, ${args.join(", ")})`;
+}
+
 function generateBaselineGoToDefinition({ markers, ranges }: VerifyBaselineGoToDefinitionCmd): string {
     if (ranges || markers.length === 0) {
         return `f.VerifyBaselineGoToDefinition(t)`;
@@ -1372,6 +1469,8 @@ function generateCmd(cmd: Cmd): string {
             return generateVerifyCompletions(cmd);
         case "verifyBaselineFindAllReferences":
             return generateBaselineFindAllReferences(cmd);
+        case "verifyBaselineDocumentHighlights":
+            return generateBaselineDocumentHighlights(cmd);
         case "verifyBaselineGoToDefinition":
             return generateBaselineGoToDefinition(cmd);
         case "verifyBaselineQuickInfo":

internal/fourslash/_scripts/failingTests.txt

@@ -162,8 +162,15 @@ TestCompletionsUniqueSymbol1
 TestConstEnumQuickInfoAndCompletionList
 TestConstQuickInfoAndCompletionList
 TestContextuallyTypedFunctionExpressionGeneric1
+TestDocumentHighlightInExport1
+TestDocumentHighlightInTypeExport
+TestDocumentHighlightJSDocTypedef
+TestDocumentHighlightTemplateStrings
+TestDocumentHighlightsInvalidGlobalThis
+TestDocumentHighlights_40082
 TestDoubleUnderscoreCompletions
 TestEditJsdocType
+TestEmptyExportFindReferences
 TestExportDefaultClass
 TestExportDefaultFunction
 TestFindAllReferencesDynamicImport1
@@ -173,6 +180,7 @@ TestFindAllRefsCommonJsRequire2
 TestFindAllRefsCommonJsRequire3
 TestFindAllRefsExportEquals
 TestFindAllRefsForDefaultExport03
+TestFindAllRefsForModule
 TestFindAllRefsModuleDotExports
 TestFindAllRefs_importType_typeofImport
 TestFindReferencesAfterEdit
@@ -201,6 +209,14 @@ TestGetJavaScriptQuickInfo6
 TestGetJavaScriptQuickInfo7
 TestGetJavaScriptQuickInfo8
 TestGetJavaScriptSyntacticDiagnostics24
+TestGetOccurrencesAsyncAwait3
+TestGetOccurrencesClassExpressionConstructor
+TestGetOccurrencesConstructor
+TestGetOccurrencesConstructor2
+TestGetOccurrencesIfElseBroken
+TestGetOccurrencesOfAnonymousFunction
+TestGetOccurrencesStringLiteralTypes
+TestGetOccurrencesStringLiterals
 TestGetQuickInfoForIntersectionTypes
 TestHoverOverComment
 TestImportCompletionsPackageJsonExportsSpecifierEndsInTs
@@ -264,6 +280,7 @@ TestJsdocThrowsTagCompletion
 TestJsdocTypedefTag
 TestJsdocTypedefTag2
 TestJsdocTypedefTagNamespace
+TestJsdocTypedefTagServices
 TestJsxFindAllReferencesOnRuntimeImportWithPaths1
 TestLetQuickInfoAndCompletionList
 TestLocalFunction
@@ -329,6 +346,7 @@ TestPathCompletionsTypesVersionsWildcard4
 TestPathCompletionsTypesVersionsWildcard5
 TestPathCompletionsTypesVersionsWildcard6
 TestProtoVarVisibleWithOuterScopeUnderscoreProto
+TestQualifiedName_import_declaration_with_variable_entity_names
 TestQuickInfoAlias
 TestQuickInfoAssertionNodeNotReusedWhenTypeNotEquivalent1
 TestQuickInfoBindingPatternInJsdocNoCrash1

internal/fourslash/fourslash.go

@@ -1031,6 +1031,83 @@ func (f *FourslashTest) VerifyBaselineSignatureHelp(t *testing.T) {
 	}
 }
 
+func (f *FourslashTest) VerifyBaselineDocumentHighlights(
+	t *testing.T,
+	preferences *ls.UserPreferences,
+	markerOrRangeOrNames ...MarkerOrRangeOrName,
+) {
+	var markerOrRanges []MarkerOrRange
+	for _, markerOrRangeOrName := range markerOrRangeOrNames {
+		switch markerOrNameOrRange := markerOrRangeOrName.(type) {
+		case string:
+			marker, ok := f.testData.MarkerPositions[markerOrNameOrRange]
+			if !ok {
+				t.Fatalf("Marker '%s' not found", markerOrNameOrRange)
+			}
+			markerOrRanges = append(markerOrRanges, marker)
+		case *Marker:
+			markerOrRanges = append(markerOrRanges, markerOrNameOrRange)
+		case *RangeMarker:
+			markerOrRanges = append(markerOrRanges, markerOrNameOrRange)
+		default:
+			t.Fatalf("Invalid marker or range type: %T. Expected string, *Marker, or *RangeMarker.", markerOrNameOrRange)
+		}
+	}
+
+	f.verifyBaselineDocumentHighlights(t, preferences, markerOrRanges)
+}
+
+func (f *FourslashTest) verifyBaselineDocumentHighlights(
+	t *testing.T,
+	preferences *ls.UserPreferences,
+	markerOrRanges []MarkerOrRange,
+) {
+	for _, markerOrRange := range markerOrRanges {
+		f.goToMarker(t, markerOrRange)
+
+		params := &lsproto.DocumentHighlightParams{
+			TextDocument: lsproto.TextDocumentIdentifier{
+				Uri: ls.FileNameToDocumentURI(f.activeFilename),
+			},
+			Position: f.currentCaretPosition,
+		}
+		resMsg, result, resultOk := sendRequest(t, f, lsproto.TextDocumentDocumentHighlightInfo, params)
+		if resMsg == nil {
+			if f.lastKnownMarkerName == nil {
+				t.Fatalf("Nil response received for document highlights request at pos %v", f.currentCaretPosition)
+			} else {
+				t.Fatalf("Nil response received for document highlights request at marker '%s'", *f.lastKnownMarkerName)
+			}
+		}
+		if !resultOk {
+			if f.lastKnownMarkerName == nil {
+				t.Fatalf("Unexpected document highlights response type at pos %v: %T", f.currentCaretPosition, resMsg.AsResponse().Result)
+			} else {
+				t.Fatalf("Unexpected document highlights response type at marker '%s': %T", *f.lastKnownMarkerName, resMsg.AsResponse().Result)
+			}
+		}
+
+		highlights := result.DocumentHighlights
+		if highlights == nil {
+			highlights = &[]*lsproto.DocumentHighlight{}
+		}
+
+		var spans []lsproto.Location
+		for _, h := range *highlights {
+			spans = append(spans, lsproto.Location{
+				Uri:   ls.FileNameToDocumentURI(f.activeFilename),
+				Range: h.Range,
+			})
+		}
+
+		// Add result to baseline
+		f.addResultToBaseline(t, "documentHighlights", f.getBaselineForLocationsWithFileContents(spans, baselineFourslashLocationsOptions{
+			marker:     markerOrRange,
+			markerName: "/*HIGHLIGHTS*/",
+		}))
+	}
+}
+
 // Collects all named markers if provided, or defaults to anonymous ranges
 func (f *FourslashTest) lookupMarkersOrGetRanges(t *testing.T, markers []string) []MarkerOrRange {
 	var referenceLocations []MarkerOrRange

internal/fourslash/tests/documentHighlight_test.go

@@ -0,0 +1,19 @@
+package fourslash
+
+import (
+	"testing"
+
+	"github.com/microsoft/typescript-go/internal/fourslash"
+	. "github.com/microsoft/typescript-go/internal/fourslash/tests/util"
+	"github.com/microsoft/typescript-go/internal/testutil"
+)
+
+func TestDocumentHighlights(t *testing.T) {
+	t.Parallel()
+	defer testutil.RecoverAndFail(t, "Panic on fourslash test")
+	const content = `[|function|] [|f|](x: typeof [|f|]) { 
+	[|f|]([|f|]);
+}`
+	f := fourslash.NewFourslash(t, nil /*capabilities*/, content)
+	f.VerifyBaselineDocumentHighlights(t, nil /*preferences*/, ToAny(f.Ranges())...)
+}

internal/fourslash/tests/gen/documentHighlightAtInheritedProperties1_test.go

@@ -0,0 +1,22 @@
+package fourslash_test
+
+import (
+	"testing"
+
+	"github.com/microsoft/typescript-go/internal/fourslash"
+	. "github.com/microsoft/typescript-go/internal/fourslash/tests/util"
+	"github.com/microsoft/typescript-go/internal/testutil"
+)
+
+func TestDocumentHighlightAtInheritedProperties1(t *testing.T) {
+	t.Parallel()
+
+	defer testutil.RecoverAndFail(t, "Panic on fourslash test")
+	const content = `// @Filename: file1.ts
+interface interface1 extends interface1 {
+   [|doStuff|](): void;
+   [|propName|]: string;
+}`
+	f := fourslash.NewFourslash(t, nil /*capabilities*/, content)
+	f.VerifyBaselineDocumentHighlights(t, nil /*preferences*/, ToAny(f.Ranges())...)
+}