Add Go To Definition support for file paths in string literals (#12323)

- [x] Analyze existing Go To Definition flow and understand the
architecture
- [x] Add logic to detect string literals containing file paths in
RemoteGoToDefinitionService
- [x] Implement file path resolution and validation logic in
AbstractDefinitionService
- [x] Add tests in CohostGoToDefinitionEndpointTest.cs for various
scenarios
- [x] Build and validate compilation
- [x] Address PR feedback (all rounds):
  - [x] Renamed method to `TryGetDefinitionFromStringLiteralAsync`
  - [x] Changed log messages to debug level
- [x] Use `GetRequiredAbsoluteIndex` instead of
`sourceText.Lines.GetPosition`
- [x] Added file extension check (.cshtml/.razor) before path resolution
  - [x] Removed absolute path handling
  - [x] Use `ContainsDocument` instead of `TryGetDocument`
  - [x] Added WorkItem attributes to all new tests
- [x] Added entry to copilot-instructions.md about
GetRequiredAbsoluteIndex
  - [x] Updated tests to use local `FileName` helper
  - [x] Use `IsRazorFilePath()` extension method
  - [x] Use pattern matching for tilde path check
- [x] Removed `DocumentFilePaths` checks (redundant with
`ContainsDocument`)
  - [x] Move string literal check before C# Go-to-Definition call
  - [x] Merged main branch (test files moved to new location)
- [x] Move IsRazorFilePath check into TryResolveFilePath method for
better encapsulation
  - [x] Remove tests with incorrect expectations
  - [x] Merge main again and fix build errors

## Implementation Summary

Added support for navigating to Razor/CSHTML files by filename string in
Go To Definition (F12). When the cursor is in a string literal
containing a file path (e.g., `@Html.Partial("~/Views/xy.cshtml")`),
pressing F12 will navigate to that file.

### Key Features:
- Supports tilde paths (`~/...`) relative to project root
- Supports relative paths (relative to current file)
- Works with both .razor and .cshtml files
- Only processes strings with .cshtml or .razor extensions

### Technical Approach:
- Checks for string literals BEFORE calling C# Go-to-Definition
(prevents navigation to String class when file exists)
- Uses `IsRazorFilePath()` extension method for file type checking
(inside TryResolveFilePath)
- Uses pattern matching for tilde path detection
- Only modifies Workspaces and Remote layers (as per requirements)

### Test Status:
All 7 tests now pass (includes 4 new tests from main merge):
- ✅ StringLiteral_TildePath - Navigates to file using tilde path
- ✅ StringLiteral_RelativePath - Navigates to file using relative path  
- ✅ StringLiteral_RazorComponent - Navigates to .razor component file
- ✅ StringLiteral_NotFileReference (4 variants) - Correctly ignores
non-file strings

Fixes #4325

<!-- START COPILOT CODING AGENT SUFFIX -->



<details>

<summary>Original prompt</summary>

> 
> ----
> 
> *This section details on the original issue you should resolve*
> 
> <issue_title>Navigating to partial razor files by filename
string</issue_title>
> <issue_description>_This issue has been moved from [a ticket on
Developer
Community](https://developercommunity.visualstudio.com/t/Navigating-to-partial-razor-files-by-fil/1479773)._
> 
> ---
> In our codebase we often break webpages down by adding components with
the following snippet:
> 
> ```
> @Html.Partial("~/Views/xy.cshtml")
> ```
> It would be very useful if you could navigate to the specified .cshtml
file by putting the caret in the string, and pressing F12, as you often
do with other code sections.
> 
> ---
> ### Original Comments
> 
> #### Feedback Bot on 7/20/2021, 06:59 PM: 
> 
> Thank you for taking the time to provide your suggestion. We will do
some preliminary checks to make sure we can proceed further. We'll
provide an update once the issue has been triaged by the product team.
> 
> #### Feedback Bot on 8/4/2021, 03:55 PM: 
> 
> <p>Your suggestion has been queued up for prioritization. Feature
suggestions are prioritized based on the value to our broader developer
community and the product roadmap. We may not be able to pursue this one
immediately, but we will continue to monitor it for community input</p>
> </issue_description>
> 
> <agent_instructions>Don't make any changes to the compiler layer, or
to the Microsoft.AspNetCore.Razor.LanguageServer project. Changes should
be focused in services in either the Workspace or Remote projects. No
new services or endpoints will be needed. Comprehensive tests should go
in the existing CohostGoToDefinitionEndpointTest.cs
file.</agent_instructions>
> 
> ## Comments on the Issue (you are @copilot in this section)
> 
> <comments>
> </comments>
> 


</details>

Fixes #4325

<!-- START COPILOT CODING AGENT TIPS -->
---

✨ Let Copilot coding agent [set things up for
you](https://github.com/dotnet/razor/issues/new?title=✨+Set+up+Copilot+instructions&body=Configure%20instructions%20for%20this%20repository%20as%20documented%20in%20%5BBest%20practices%20for%20Copilot%20coding%20agent%20in%20your%20repository%5D%28https://gh.io/copilot-coding-agent-tips%29%2E%0A%0A%3COnboard%20this%20repo%3E&assignees=copilot)
— coding agent works faster and does higher quality work when set up for
your repo.

Author: davidwengier

.github/copilot-instructions.md

@@ -37,6 +37,7 @@ Razor documents contain multiple languages:
 - Prefer immutable collection types and pooled collections where possible
 - Use `using` statements for disposable resources
 - Ensure proper async/await patterns, avoid `Task.Wait()`
+- Use GetRequiredAbsoluteIndex for converting positions to absolute indexes
 
 ### Testing Patterns
 

src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/GoToDefinition/AbstractDefinitionService.cs

@@ -2,13 +2,16 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Diagnostics;
+using System.IO;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Razor.Language;
 using Microsoft.CodeAnalysis.Razor.DocumentMapping;
 using Microsoft.CodeAnalysis.Razor.Logging;
 using Microsoft.CodeAnalysis.Razor.ProjectSystem;
 using Microsoft.CodeAnalysis.Razor.Workspaces;
+using Microsoft.CodeAnalysis.Text;
+using CSharpSyntaxKind = Microsoft.CodeAnalysis.CSharp.SyntaxKind;
 
 namespace Microsoft.CodeAnalysis.Razor.GoToDefinition;
 
@@ -100,4 +103,93 @@ private async Task<LspRange> GetNavigateRangeAsync(IDocumentSnapshot documentSna
         // at least then press F7 to go there.
         return LspFactory.DefaultRange;
     }
+
+    public async Task<LspLocation[]?> TryGetDefinitionFromStringLiteralAsync(
+        IDocumentSnapshot documentSnapshot,
+        Position position,
+        CancellationToken cancellationToken)
+    {
+        _logger.LogDebug($"Attempting to get definition from string literal at position {position}.");
+
+        // Get the C# syntax tree to analyze the string literal
+        var syntaxTree = await documentSnapshot.GetCSharpSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);
+        var root = await syntaxTree.GetRootAsync(cancellationToken).ConfigureAwait(false);
+        var sourceText = await syntaxTree.GetTextAsync(cancellationToken).ConfigureAwait(false);
+
+        // Convert position to absolute index
+        var absoluteIndex = sourceText.GetRequiredAbsoluteIndex(position);
+
+        // Find the token at the current position
+        var token = root.FindToken(absoluteIndex);
+
+        // Check if we're in a string literal
+        if (token.IsKind(CSharpSyntaxKind.StringLiteralToken))
+        {
+            var literalText = token.ValueText;
+            _logger.LogDebug($"Found string literal: {literalText}");
+
+            // Try to resolve the file path
+            if (TryResolveFilePath(documentSnapshot, literalText, out var resolvedPath))
+            {
+                _logger.LogDebug($"Resolved file path: {resolvedPath}");
+                return [LspFactory.CreateLocation(resolvedPath, LspFactory.DefaultRange)];
+            }
+        }
+
+        return null;
+    }
+
+    private bool TryResolveFilePath(IDocumentSnapshot documentSnapshot, string filePath, out string resolvedPath)
+    {
+        resolvedPath = string.Empty;
+
+        if (string.IsNullOrWhiteSpace(filePath))
+        {
+            return false;
+        }
+
+        // Only process if it looks like a Razor file path
+        if (!filePath.IsRazorFilePath())
+        {
+            return false;
+        }
+
+        var project = documentSnapshot.Project;
+
+        // Handle tilde paths (~/ or ~\) - these are relative to the project root
+        if (filePath is ['~', '/' or '\\', ..])
+        {
+            var projectDirectory = Path.GetDirectoryName(project.FilePath);
+            if (projectDirectory is null)
+            {
+                return false;
+            }
+
+            // Remove the tilde and normalize path separators
+            var relativePath = filePath.Substring(2).Replace('/', Path.DirectorySeparatorChar).Replace('\\', Path.DirectorySeparatorChar);
+            var candidatePath = Path.GetFullPath(Path.Combine(projectDirectory, relativePath));
+
+            if (project.ContainsDocument(candidatePath))
+            {
+                resolvedPath = candidatePath;
+                return true;
+            }
+        }
+
+        // Handle relative paths - relative to the current document
+        var currentDocumentDirectory = Path.GetDirectoryName(documentSnapshot.FilePath);
+        if (currentDocumentDirectory is not null)
+        {
+            var normalizedPath = filePath.Replace('/', Path.DirectorySeparatorChar).Replace('\\', Path.DirectorySeparatorChar);
+            var candidatePath = Path.GetFullPath(Path.Combine(currentDocumentDirectory, normalizedPath));
+
+            if (project.ContainsDocument(candidatePath))
+            {
+                resolvedPath = candidatePath;
+                return true;
+            }
+        }
+
+        return false;
+    }
 }

src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/GoToDefinition/IDefinitionService.cs

@@ -20,4 +20,9 @@ internal interface IDefinitionService
         bool ignoreComponentAttributes,
         bool includeMvcTagHelpers,
         CancellationToken cancellationToken);
+
+    Task<LspLocation[]?> TryGetDefinitionFromStringLiteralAsync(
+        IDocumentSnapshot documentSnapshot,
+        Position position,
+        CancellationToken cancellationToken);
 }

src/Razor/src/Microsoft.CodeAnalysis.Remote.Razor/GoToDefinition/RemoteGoToDefinitionService.cs

@@ -75,6 +75,21 @@ protected override IRemoteGoToDefinitionService CreateService(in ServiceArgs arg
             return Results(componentLocations);
         }
 
+        // Check if we're in a string literal with a file path (before calling C# which would navigate to String class)
+        if (positionInfo.LanguageKind is RazorLanguageKind.CSharp)
+        {
+            var stringLiteralLocations = await _definitionService.TryGetDefinitionFromStringLiteralAsync(
+                context.Snapshot,
+                positionInfo.Position,
+                cancellationToken)
+                .ConfigureAwait(false);
+
+            if (stringLiteralLocations is { Length: > 0 })
+            {
+                return Results(stringLiteralLocations);
+            }
+        }
+
         if (positionInfo.LanguageKind is RazorLanguageKind.Html or RazorLanguageKind.Razor)
         {
             // If it isn't a Razor construct, and it isn't C#, let the server know to delegate to HTML.