From 0ce9a49cc7726ca6ce99a9466071b4b933a100d3 Mon Sep 17 00:00:00 2001
From: Andrew Hall <andrha@microsoft.com>
Date: Wed, 1 Dec 2021 12:20:58 -0800
Subject: [PATCH 1/2] Add new parser/lexer to the StackTraceAnalyzer (#57598)
 (#58050)

No functional changes, just moving to the new API and cleaning up unused code
---
 eng/targets/Services.props                    |   1 +
 .../StackTraceExplorerService.cs              | 112 +++++++
 .../StackTraceExplorerUtilities.cs            | 207 ++++++++++++
 .../StackTraceExplorerTests.cs                | 291 +++++++++++++++--
 .../Test/Utilities/StackFrameUtils.cs         | 230 +++++++++++++
 .../CSharpStackTraceExplorerService.cs        |  84 -----
 .../StackFrame/StackFrameNodeDefinitions.cs   |  22 +-
 .../DotnetStackFrameParser.cs                 |  36 +-
 .../IStackTraceExplorerService.cs             |  27 +-
 .../StackTraceExplorer/IgnoredFrame.cs        |  10 +-
 .../StackTraceExplorer/ParsedFrame.cs         |   8 +-
 .../StackTraceExplorer/ParsedStackFrame.cs    | 232 +------------
 .../StackFrameParserHelpers.cs                | 308 ------------------
 .../StackFrameSymbolPart.cs                   |  26 ++
 .../StackTraceExplorer/StackTraceAnalyzer.cs  |  11 +-
 .../VSDebugCallstackParser.cs                 |  14 +-
 .../IgnoredFrameViewModel.cs                  |   2 +-
 .../StackTraceExplorer/StackFrameViewModel.cs | 204 ++++++++----
 .../StackTraceExplorerRootViewModel.cs        |   6 +-
 .../StackTraceExplorerTab.cs                  |   4 +-
 .../StackTraceExplorerToolWindow.cs           |   3 +-
 .../StackTraceExplorerViewModel.cs            |   6 +-
 .../Portable/Workspace/Solution/Project.cs    |   9 +
 .../Remote/InProcRemostHostClient.cs          |   2 +
 .../Core/RemoteWorkspacesResources.resx       |   3 +
 .../Remote/Core/ServiceDescriptors.cs         |   2 +
 .../Core/xlf/RemoteWorkspacesResources.cs.xlf |   5 +
 .../Core/xlf/RemoteWorkspacesResources.de.xlf |   5 +
 .../Core/xlf/RemoteWorkspacesResources.es.xlf |   5 +
 .../Core/xlf/RemoteWorkspacesResources.fr.xlf |   5 +
 .../Core/xlf/RemoteWorkspacesResources.it.xlf |   5 +
 .../Core/xlf/RemoteWorkspacesResources.ja.xlf |   5 +
 .../Core/xlf/RemoteWorkspacesResources.ko.xlf |   5 +
 .../Core/xlf/RemoteWorkspacesResources.pl.xlf |   5 +
 .../xlf/RemoteWorkspacesResources.pt-BR.xlf   |   5 +
 .../Core/xlf/RemoteWorkspacesResources.ru.xlf |   5 +
 .../Core/xlf/RemoteWorkspacesResources.tr.xlf |   5 +
 .../xlf/RemoteWorkspacesResources.zh-Hans.xlf |   5 +
 .../xlf/RemoteWorkspacesResources.zh-Hant.xlf |   5 +
 .../RemoteStackTraceExplorerService.cs        |  48 +++
 .../Common/EmbeddedSyntaxNode.cs              |  50 +++
 .../Common/EmbeddedSyntaxToken.cs             |  42 +++
 .../Common/EmbeddedSyntaxTrivia.cs            |   7 +
 43 files changed, 1281 insertions(+), 791 deletions(-)
 create mode 100644 src/EditorFeatures/Core/StackTraceExplorer/StackTraceExplorerService.cs
 create mode 100644 src/EditorFeatures/Core/StackTraceExplorer/StackTraceExplorerUtilities.cs
 create mode 100644 src/EditorFeatures/Test/Utilities/StackFrameUtils.cs
 delete mode 100644 src/Features/CSharp/Portable/StackTraceExplorer/CSharpStackTraceExplorerService.cs
 delete mode 100644 src/Features/Core/Portable/StackTraceExplorer/StackFrameParserHelpers.cs
 create mode 100644 src/Features/Core/Portable/StackTraceExplorer/StackFrameSymbolPart.cs
 create mode 100644 src/Workspaces/Remote/ServiceHub/Services/StackTraceExplorer/RemoteStackTraceExplorerService.cs

diff --git a/eng/targets/Services.props b/eng/targets/Services.props
index 4d197a5dd3701..cad3d601e7b63 100644
--- a/eng/targets/Services.props
+++ b/eng/targets/Services.props
@@ -39,6 +39,7 @@
     <ServiceHubService Include="Microsoft.VisualStudio.LanguageServices.UnusedReferenceAnalysis" ClassName="Microsoft.CodeAnalysis.Remote.RemoteUnusedReferenceAnalysisService+Factory" />
     <ServiceHubService Include="Microsoft.VisualStudio.LanguageServices.ProcessTelemetry" ClassName="Microsoft.CodeAnalysis.Remote.RemoteProcessTelemetryService+Factory" />
     <ServiceHubService Include="Microsoft.VisualStudio.LanguageServices.CompilationAvailable" ClassName="Microsoft.CodeAnalysis.Remote.RemoteCompilationAvailableService+Factory" />
+    <ServiceHubService Include="Microsoft.VisualStudio.LanguageServices.StackTraceExplorer" ClassName="Microsoft.CodeAnalysis.Remote.Services.StackTraceExplorer.RemoteStackTraceExplorerService+Factory" />
   </ItemGroup>
 
   <!--
diff --git a/src/EditorFeatures/Core/StackTraceExplorer/StackTraceExplorerService.cs b/src/EditorFeatures/Core/StackTraceExplorer/StackTraceExplorerService.cs
new file mode 100644
index 0000000000000..ec8b16abc5983
--- /dev/null
+++ b/src/EditorFeatures/Core/StackTraceExplorer/StackTraceExplorerService.cs
@@ -0,0 +1,112 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Composition;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.EmbeddedLanguages.StackFrame;
+using Microsoft.CodeAnalysis.FindUsages;
+using Microsoft.CodeAnalysis.Host.Mef;
+using Microsoft.CodeAnalysis.Remote;
+using Microsoft.CodeAnalysis.StackTraceExplorer;
+using Roslyn.Utilities;
+
+namespace Microsoft.CodeAnalysis.Editor.StackTraceExplorer
+{
+    [ExportWorkspaceService(typeof(IStackTraceExplorerService)), Shared]
+    internal class StackTraceExplorerService : IStackTraceExplorerService
+    {
+        [ImportingConstructor]
+        [System.Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
+        public StackTraceExplorerService()
+        {
+        }
+
+        public (Document? document, int line) GetDocumentAndLine(Solution solution, ParsedFrame frame)
+        {
+            if (frame is ParsedStackFrame parsedFrame)
+            {
+                var matches = GetFileMatches(solution, parsedFrame.Root, out var line);
+                if (matches.IsEmpty)
+                {
+                    return default;
+                }
+
+                return (matches[0], line);
+            }
+
+            return default;
+        }
+
+        public async Task<DefinitionItem?> TryFindDefinitionAsync(Solution solution, ParsedFrame frame, StackFrameSymbolPart symbolPart, CancellationToken cancellationToken)
+        {
+            if (frame is not ParsedStackFrame parsedFrame)
+            {
+                return null;
+            }
+
+            var client = await RemoteHostClient.TryGetClientAsync(solution.Workspace, cancellationToken).ConfigureAwait(false);
+            if (client is not null)
+            {
+                var result = await client.TryInvokeAsync<IRemoteStackTraceExplorerService, SerializableDefinitionItem?>(
+                    solution,
+                    (service, solutionInfo, cancellationToken) => service.TryFindDefinitionAsync(solutionInfo, parsedFrame.ToString(), symbolPart, cancellationToken),
+                    cancellationToken).ConfigureAwait(false);
+
+                if (!result.HasValue)
+                {
+                    return null;
+                }
+
+                var serializedDefinition = result.Value;
+                if (!serializedDefinition.HasValue)
+                {
+                    return null;
+                }
+
+                return await serializedDefinition.Value.RehydrateAsync(solution, cancellationToken).ConfigureAwait(false);
+            }
+
+            return await StackTraceExplorerUtilities.GetDefinitionAsync(solution, parsedFrame.Root, symbolPart, cancellationToken).ConfigureAwait(false);
+        }
+
+        private static ImmutableArray<Document> GetFileMatches(Solution solution, StackFrameCompilationUnit root, out int lineNumber)
+        {
+            lineNumber = 0;
+            if (root.FileInformationExpression is null)
+            {
+                return ImmutableArray<Document>.Empty;
+            }
+
+            var fileName = root.FileInformationExpression.Path.ToString();
+            var lineString = root.FileInformationExpression.Line.ToString();
+            RoslynDebug.AssertNotNull(lineString);
+            lineNumber = int.Parse(lineString);
+
+            var documentName = Path.GetFileName(fileName);
+            var potentialMatches = new HashSet<Document>();
+
+            foreach (var project in solution.Projects)
+            {
+                foreach (var document in project.Documents)
+                {
+                    if (document.FilePath == fileName)
+                    {
+                        return ImmutableArray.Create(document);
+                    }
+
+                    else if (document.Name == documentName)
+                    {
+                        potentialMatches.Add(document);
+                    }
+                }
+            }
+
+            return potentialMatches.ToImmutableArray();
+        }
+    }
+}
diff --git a/src/EditorFeatures/Core/StackTraceExplorer/StackTraceExplorerUtilities.cs b/src/EditorFeatures/Core/StackTraceExplorer/StackTraceExplorerUtilities.cs
new file mode 100644
index 0000000000000..935901ca01365
--- /dev/null
+++ b/src/EditorFeatures/Core/StackTraceExplorer/StackTraceExplorerUtilities.cs
@@ -0,0 +1,207 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections.Immutable;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.Editor.FindUsages;
+using Microsoft.CodeAnalysis.EmbeddedLanguages.StackFrame;
+using Microsoft.CodeAnalysis.FindUsages;
+using Microsoft.CodeAnalysis.Shared.Extensions;
+using Microsoft.CodeAnalysis.StackTraceExplorer;
+using Roslyn.Utilities;
+
+namespace Microsoft.CodeAnalysis.Editor.StackTraceExplorer
+{
+    internal static class StackTraceExplorerUtilities
+    {
+        public static async Task<DefinitionItem?> GetDefinitionAsync(Solution solution, StackFrameCompilationUnit compilationUnit, StackFrameSymbolPart symbolPart, CancellationToken cancellationToken)
+        {
+            // MemberAccessExpression is [Expression].[Identifier], and Identifier is the 
+            // method name.
+            var typeExpression = compilationUnit.MethodDeclaration.MemberAccessExpression.Left;
+
+            // typeExpression.ToString() returns the full expression (or identifier)
+            // including arity for generic types. 
+            var fullyQualifiedTypeName = typeExpression.ToString();
+
+            var typeName = typeExpression is StackFrameQualifiedNameNode qualifiedName
+                ? qualifiedName.Right.ToString()
+                : typeExpression.ToString();
+
+            RoslynDebug.AssertNotNull(fullyQualifiedTypeName);
+
+            var methodIdentifier = compilationUnit.MethodDeclaration.MemberAccessExpression.Right;
+            var methodTypeArguments = compilationUnit.MethodDeclaration.TypeArguments;
+            var methodArguments = compilationUnit.MethodDeclaration.ArgumentList;
+
+            var methodName = methodIdentifier.ToString();
+
+            //
+            // Do a first pass to find projects with the type name to check first 
+            //
+            using var _ = PooledObjects.ArrayBuilder<Project>.GetInstance(out var candidateProjects);
+            foreach (var project in solution.Projects)
+            {
+                if (!project.SupportsCompilation)
+                {
+                    continue;
+                }
+
+                var containsSymbol = await project.ContainsSymbolsWithNameAsync(
+                    typeName,
+                    SymbolFilter.Type,
+                    cancellationToken).ConfigureAwait(false);
+
+                if (containsSymbol)
+                {
+                    var matchingMethods = await GetMatchingMembersFromCompilationAsync(project).ConfigureAwait(false);
+                    if (matchingMethods.Any())
+                    {
+                        return await GetDefinitionAsync(matchingMethods[0]).ConfigureAwait(false);
+                    }
+                }
+                else
+                {
+                    candidateProjects.Add(project);
+                }
+            }
+
+            //
+            // Do a second pass to check the remaining compilations
+            // for the symbol, which may be a metadata symbol in the compilation
+            //
+            foreach (var project in candidateProjects)
+            {
+                var matchingMethods = await GetMatchingMembersFromCompilationAsync(project).ConfigureAwait(false);
+                if (matchingMethods.Any())
+                {
+                    return await GetDefinitionAsync(matchingMethods[0]).ConfigureAwait(false);
+                }
+            }
+
+            return null;
+
+            //
+            // Local Functions
+            //
+
+            async Task<ImmutableArray<IMethodSymbol>> GetMatchingMembersFromCompilationAsync(Project project)
+            {
+                var compilation = await project.GetRequiredCompilationAsync(cancellationToken).ConfigureAwait(false);
+                var type = compilation.GetTypeByMetadataName(fullyQualifiedTypeName);
+                if (type is null)
+                {
+                    return ImmutableArray<IMethodSymbol>.Empty;
+                }
+
+                var members = type.GetMembers();
+                return members
+                    .OfType<IMethodSymbol>()
+                    .Where(m => m.Name == methodName)
+                    .Where(m => MatchTypeArguments(m.TypeArguments, methodTypeArguments))
+                    .Where(m => MatchParameters(m.Parameters, methodArguments))
+                    .ToImmutableArrayOrEmpty();
+            }
+
+            Task<DefinitionItem> GetDefinitionAsync(IMethodSymbol method)
+            {
+                ISymbol symbol = method;
+                if (symbolPart == StackFrameSymbolPart.ContainingType)
+                {
+                    symbol = method.ContainingType;
+                }
+
+                return symbol.ToNonClassifiedDefinitionItemAsync(solution, includeHiddenLocations: true, cancellationToken);
+            }
+        }
+
+        private static bool MatchParameters(ImmutableArray<IParameterSymbol> parameters, StackFrameParameterList stackFrameParameters)
+        {
+            if (parameters.Length != stackFrameParameters.Parameters.Length)
+            {
+                return false;
+            }
+
+            for (var i = 0; i < stackFrameParameters.Parameters.Length; i++)
+            {
+                var stackFrameParameter = stackFrameParameters.Parameters[i];
+                var paramSymbol = parameters[i];
+
+                if (paramSymbol.Name != stackFrameParameter.Identifier.ToString())
+                {
+                    return false;
+                }
+
+                if (!MatchType(paramSymbol.Type, stackFrameParameter.Type))
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        private static bool MatchTypeArguments(ImmutableArray<ITypeSymbol> typeArguments, StackFrameTypeArgumentList? stackFrameTypeArgumentList)
+        {
+            if (stackFrameTypeArgumentList is null)
+            {
+                return typeArguments.IsEmpty;
+            }
+
+            if (typeArguments.IsEmpty)
+            {
+                return false;
+            }
+
+            var stackFrameTypeArguments = stackFrameTypeArgumentList.TypeArguments;
+            return typeArguments.Length == stackFrameTypeArguments.Length;
+        }
+
+        private static bool MatchType(ITypeSymbol type, StackFrameTypeNode stackFrameType)
+        {
+            if (type is IArrayTypeSymbol arrayType)
+            {
+                if (stackFrameType is not StackFrameArrayTypeNode arrayTypeNode)
+                {
+                    return false;
+                }
+
+                ITypeSymbol currentType = arrayType;
+
+                // Iterate through each array expression and make sure the dimensions
+                // match the element types in an array.
+                // Ex: string[,][] 
+                // [,] is a 2 dimension array with element type string[]
+                // [] is a 1 dimension array with element type string
+                foreach (var arrayExpression in arrayTypeNode.ArrayRankSpecifiers)
+                {
+                    if (currentType is not IArrayTypeSymbol currentArrayType)
+                    {
+                        return false;
+                    }
+
+                    if (currentArrayType.Rank != arrayExpression.CommaTokens.Length + 1)
+                    {
+                        return false;
+                    }
+
+                    currentType = currentArrayType.ElementType;
+                }
+
+                // All array types have been exchausted from the
+                // stackframe identifier and the type is still an array
+                if (currentType is IArrayTypeSymbol)
+                {
+                    return false;
+                }
+
+                return MatchType(currentType, arrayTypeNode.TypeIdentifier);
+            }
+
+            return type.Name == stackFrameType.ToString();
+        }
+    }
+}
diff --git a/src/EditorFeatures/Test/StackTraceExplorer/StackTraceExplorerTests.cs b/src/EditorFeatures/Test/StackTraceExplorer/StackTraceExplorerTests.cs
index be3d1dbc9d87c..ec43226c9a684 100644
--- a/src/EditorFeatures/Test/StackTraceExplorer/StackTraceExplorerTests.cs
+++ b/src/EditorFeatures/Test/StackTraceExplorer/StackTraceExplorerTests.cs
@@ -6,12 +6,14 @@
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
-using Microsoft.CodeAnalysis.StackTraceExplorer;
+using Microsoft.CodeAnalysis.Editor.FindUsages;
+using Microsoft.CodeAnalysis.Editor.UnitTests.Utilities;
 using Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces;
+using Microsoft.CodeAnalysis.Shared.Extensions;
+using Microsoft.CodeAnalysis.StackTraceExplorer;
 using Microsoft.CodeAnalysis.Test.Utilities;
 using Roslyn.Test.Utilities;
 using Xunit;
-using Microsoft.CodeAnalysis.Shared.Extensions;
 
 namespace Microsoft.CodeAnalysis.UnitTests.StackTraceExplorer
 {
@@ -27,8 +29,20 @@ private static async Task TestSymbolFoundAsync(string inputLine, string code)
             var stackFrame = result.ParsedFrames[0] as ParsedStackFrame;
             AssertEx.NotNull(stackFrame);
 
-            var symbol = await stackFrame.ResolveSymbolAsync(workspace.CurrentSolution, CancellationToken.None);
+            // Test that ToString() and reparsing keeps the same outcome
+            var reparsedResult = await StackTraceAnalyzer.AnalyzeAsync(stackFrame.ToString(), CancellationToken.None);
+            Assert.Single(reparsedResult.ParsedFrames);
+
+            var reparsedFrame = reparsedResult.ParsedFrames[0] as ParsedStackFrame;
+            AssertEx.NotNull(reparsedFrame);
+            StackFrameUtils.AssertEqual(stackFrame.Root, reparsedFrame.Root);
 
+            // Get the definition for the parsed frame
+            var service = workspace.Services.GetRequiredService<IStackTraceExplorerService>();
+            var definition = await service.TryFindDefinitionAsync(workspace.CurrentSolution, stackFrame, StackFrameSymbolPart.Method, CancellationToken.None);
+            AssertEx.NotNull(definition);
+
+            // Get the symbol that was indicated in the source code by cursor position
             var cursorDoc = workspace.Documents.Single();
             var selectedSpan = cursorDoc.SelectedSpans.Single();
             var doc = workspace.CurrentSolution.GetRequiredDocument(cursorDoc.Id);
@@ -39,7 +53,24 @@ private static async Task TestSymbolFoundAsync(string inputLine, string code)
             var expectedSymbol = semanticModel.GetDeclaredSymbol(node);
             AssertEx.NotNull(expectedSymbol);
 
-            Assert.Equal(expectedSymbol, symbol);
+            // Compare the definition found to the definition for the test symbol
+            var expectedDefinition = expectedSymbol.ToNonClassifiedDefinitionItem(workspace.CurrentSolution, includeHiddenLocations: true);
+
+            Assert.Equal(expectedDefinition.IsExternal, definition.IsExternal);
+            AssertEx.SetEqual(expectedDefinition.NameDisplayParts, definition.NameDisplayParts);
+            AssertEx.SetEqual(expectedDefinition.OriginationParts, definition.OriginationParts);
+            AssertEx.SetEqual(expectedDefinition.Properties, definition.Properties);
+            AssertEx.SetEqual(expectedDefinition.SourceSpans, definition.SourceSpans);
+            AssertEx.SetEqual(expectedDefinition.Tags, definition.Tags);
+        }
+
+        private static void AssertContents(ImmutableArray<ParsedFrame> frames, params string[] contents)
+        {
+            Assert.Equal(contents.Length, frames.Length);
+            for (var i = 0; i < contents.Length; i++)
+            {
+                Assert.Equal(contents[i], frames[i].ToString());
+            }
         }
 
         [Fact]
@@ -58,11 +89,41 @@ class MyClass
 }");
         }
 
+        [Theory]
+        [InlineData("object", "Object")]
+        [InlineData("bool", "Boolean")]
+        [InlineData("sbyte", "SByte")]
+        [InlineData("byte", "Byte")]
+        [InlineData("decimal", "Decimal")]
+        [InlineData("float", "Single")]
+        [InlineData("double", "Double")]
+        [InlineData("short", "Int16")]
+        [InlineData("int", "Int32")]
+        [InlineData("long", "Int64")]
+        [InlineData("string", "String")]
+        [InlineData("ushort", "UInt16")]
+        [InlineData("uint", "UInt32")]
+        [InlineData("ulong", "UInt64")]
+        public Task TestSpecialTypes(string type, string typeName)
+        {
+            return TestSymbolFoundAsync(
+                $"at ConsoleApp.MyClass.M({typeName} value)",
+                @$"using System;
+
+namespace ConsoleApp
+{{
+    class MyClass
+    {{
+        void [|M|]({type} value) {{}}
+    }}
+}}");
+        }
+
         [Fact]
         public Task TestSymbolFound_DebuggerLine_SingleSimpleClassParam()
         {
             return TestSymbolFoundAsync(
-                "ConsoleApp4.dll!ConsoleApp4.MyClass.M(string s)",
+                "ConsoleApp4.dll!ConsoleApp4.MyClass.M(String s)",
                 @"using System;
 
 namespace ConsoleApp4
@@ -94,7 +155,7 @@ class MyClass
         public Task TestSymbolFound_ExceptionLine_SingleSimpleClassParam()
         {
             return TestSymbolFoundAsync(
-                "at ConsoleApp4.MyClass.M(string s)",
+                "at ConsoleApp4.MyClass.M(String s)",
                 @"using System;
 
 namespace ConsoleApp4
@@ -122,6 +183,51 @@ class MyClass
 }");
         }
 
+        [Fact]
+        public Task TestSymbolFound_GenericType()
+        {
+            return TestSymbolFoundAsync(
+                @"at ConsoleApp.MyClass`1.M(String s)",
+                @"using System;
+namespace ConsoleApp
+{
+    class MyClass<T> 
+    {
+        void [|M|](string s) { }
+    }
+}");
+        }
+
+        [Fact]
+        public Task TestSymbolFound_GenericType2()
+        {
+            return TestSymbolFoundAsync(
+                @"at ConsoleApp.MyClass`2.M(String s)",
+                @"using System;
+namespace ConsoleApp
+{
+    class MyClass<T, U> 
+    {
+        void [|M|](string s) { }
+    }
+}");
+        }
+
+        [Fact]
+        public Task TestSymbolFound_GenericType_GenericArg()
+        {
+            return TestSymbolFoundAsync(
+                @"at ConsoleApp.MyClass`1.M(T s)",
+                @"using System;
+namespace ConsoleApp
+{
+    class MyClass<T>
+    {
+        void [|M|](T s) { }
+    }
+}");
+        }
+
         [Fact]
         public Task TestSymbolFound_ExceptionLine_GenericMethod()
         {
@@ -170,7 +276,130 @@ class MyClass
 }");
         }
 
-        [Fact(Skip = "The parser does not handle arity on types yet")]
+        [Fact]
+        public Task TestSymbolFound_ParameterSpacing()
+        {
+            return TestSymbolFoundAsync(
+                "at ConsoleApp.MyClass.M( String   s    )",
+                @"
+namespace ConsoleApp
+{
+    class MyClass
+    {
+        void [|M|](string s)
+        {
+        }
+    }
+}");
+        }
+
+        [Fact]
+        public Task TestSymbolFound_OverloadsWithSameName()
+        {
+            return TestSymbolFoundAsync(
+                "at ConsoleApp.MyClass.M(String value)",
+                @"
+namespace ConsoleApp
+{
+    class MyClass
+    {
+        void [|M|](string value)
+        {
+        }
+
+        void M(int value)
+        {
+        }
+    }
+}");
+        }
+
+        [Fact]
+        public Task TestSymbolFound_ArrayParameter()
+        {
+            return TestSymbolFoundAsync(
+                "at ConsoleApp.MyClass.M(String[] s)",
+                @"
+namespace ConsoleApp
+{
+    class MyClass
+    {
+        void [|M|](string[] s)
+        {
+        }
+    }
+}");
+        }
+
+        [Fact]
+        public Task TestSymbolFound_MultidimensionArrayParameter()
+        {
+            return TestSymbolFoundAsync(
+                "at ConsoleApp.MyClass.M(String[,] s)",
+                @"
+namespace ConsoleApp
+{
+    class MyClass
+    {
+        void [|M|](string[,] s)
+        {
+        }
+    }
+}");
+        }
+
+        [Fact]
+        public Task TestSymbolFound_MultidimensionArrayParameter_WithSpaces()
+        {
+            return TestSymbolFoundAsync(
+                "at ConsoleApp.MyClass.M(String[ , ] s)",
+                @"
+namespace ConsoleApp
+{
+    class MyClass
+    {
+        void [|M|](string[,] s)
+        {
+        }
+    }
+}");
+        }
+
+        [Fact]
+        public Task TestSymbolFound_MultidimensionArrayParameter_WithSpaces2()
+        {
+            return TestSymbolFoundAsync(
+                "at ConsoleApp.MyClass.M(String[,] s)",
+                @"
+namespace ConsoleApp
+{
+    class MyClass
+    {
+        void [|M|](string[ , ] s)
+        {
+        }
+    }
+}");
+        }
+
+        [Fact]
+        public Task TestSymbolFound_MultidimensionArrayParameter2()
+        {
+            return TestSymbolFoundAsync(
+                "at ConsoleApp.MyClass.M(String[,][] s)",
+                @"
+namespace ConsoleApp
+{
+    class MyClass
+    {
+        void [|M|](string[,][] s)
+        {
+        }
+    }
+}");
+        }
+
+        [Fact(Skip = "Symbol search for nested types does not work")]
         public Task TestSymbolFound_ExceptionLine_GenericsHierarchy()
         {
             return TestSymbolFoundAsync(
@@ -183,7 +412,7 @@ class MyClass<A>
     {
         public class MyInnerClass<B>
         {
-            public void M<T>(T t) 
+            public void [|M|]<T>(T t) 
             {
                 throw new Exception();
             }
@@ -457,8 +686,9 @@ class C
             Assert.Equal(1, result.ParsedFrames.Length);
 
             var parsedFame = result.ParsedFrames.OfType<ParsedStackFrame>().Single();
-            var symbol = await parsedFame.ResolveSymbolAsync(workspace.CurrentSolution, CancellationToken.None);
-            Assert.Null(symbol);
+            var service = workspace.Services.GetRequiredService<IStackTraceExplorerService>();
+            var definition = await service.TryFindDefinitionAsync(workspace.CurrentSolution, parsedFame, StackFrameSymbolPart.Method, CancellationToken.None);
+            Assert.Null(definition);
         }
 
         [Fact]
@@ -467,31 +697,32 @@ public async Task TestActivityLogParsing()
             var activityLogException = @"Exception occurred while loading solution options: System.Runtime.InteropServices.COMException (0x8000FFFF): Catastrophic failure (Exception from HRESULT: 0x8000FFFF (E_UNEXPECTED))&#x000D;&#x000A;   at System.Runtime.InteropServices.Marshal.ThrowExceptionForHRInternal(Int32 errorCode, IntPtr errorInfo)&#x000D;&#x000A;   at Microsoft.VisualStudio.Shell.Package.Initialize()&#x000D;&#x000A;--- End of stack trace from previous location where exception was thrown ---&#x000D;&#x000A;   at System.Runtime.ExceptionServices.ExceptionDispatchInfo.Throw&lt;string&gt;()&#x000D;&#x000A;   at Microsoft.VisualStudio.Telemetry.WindowsErrorReporting.WatsonReport.GetClrWatsonExceptionInfo(Exception exceptionObject)";
 
             var result = await StackTraceAnalyzer.AnalyzeAsync(activityLogException, CancellationToken.None);
-            Assert.Equal(6, result.ParsedFrames.Length);
-
-            var ignoredFrame1 = result.ParsedFrames[0] as IgnoredFrame;
-            AssertEx.NotNull(ignoredFrame1);
-            Assert.Equal(@"Exception occurred while loading solution options: System.Runtime.InteropServices.COMException (0x8000FFFF): Catastrophic failure (Exception from HRESULT: 0x8000FFFF (E_UNEXPECTED))", ignoredFrame1.OriginalText);
+            AssertContents(result.ParsedFrames,
+                @"Exception occurred while loading solution options: System.Runtime.InteropServices.COMException (0x8000FFFF): Catastrophic failure (Exception from HRESULT: 0x8000FFFF (E_UNEXPECTED))",
+                @"at System.Runtime.InteropServices.Marshal.ThrowExceptionForHRInternal(Int32 errorCode, IntPtr errorInfo)",
+                @"at Microsoft.VisualStudio.Shell.Package.Initialize()",
+                @"--- End of stack trace from previous location where exception was thrown ---",
+                @"at System.Runtime.ExceptionServices.ExceptionDispatchInfo.Throw<string>()",
+                @"at Microsoft.VisualStudio.Telemetry.WindowsErrorReporting.WatsonReport.GetClrWatsonExceptionInfo(Exception exceptionObject)");
+        }
 
-            var parsedFrame2 = result.ParsedFrames[1] as ParsedStackFrame;
-            AssertEx.NotNull(parsedFrame2);
-            Assert.Equal(@"at System.Runtime.InteropServices.Marshal.ThrowExceptionForHRInternal(Int32 errorCode, IntPtr errorInfo)", parsedFrame2.OriginalText);
+        [Fact]
+        public async Task TestMetadataSymbol()
+        {
+            var code = @"class C{}";
+            using var workspace = TestWorkspace.CreateCSharp(code);
 
-            var parsedFrame3 = result.ParsedFrames[2] as ParsedStackFrame;
-            AssertEx.NotNull(parsedFrame3);
-            Assert.Equal(@"at Microsoft.VisualStudio.Shell.Package.Initialize()", parsedFrame3.OriginalText);
+            var result = await StackTraceAnalyzer.AnalyzeAsync("at System.String.ToLower()", CancellationToken.None);
+            Assert.Single(result.ParsedFrames);
 
-            var ignoredFrame4 = result.ParsedFrames[3] as IgnoredFrame;
-            AssertEx.NotNull(ignoredFrame4);
-            Assert.Equal(@"--- End of stack trace from previous location where exception was thrown ---", ignoredFrame4.OriginalText);
+            var frame = result.ParsedFrames[0] as ParsedStackFrame;
+            AssertEx.NotNull(frame);
 
-            var parsedFrame5 = result.ParsedFrames[4] as ParsedStackFrame;
-            AssertEx.NotNull(parsedFrame5);
-            Assert.Equal(@"at System.Runtime.ExceptionServices.ExceptionDispatchInfo.Throw<string>()", parsedFrame5.OriginalText);
+            var service = workspace.Services.GetRequiredService<IStackTraceExplorerService>();
+            var definition = await service.TryFindDefinitionAsync(workspace.CurrentSolution, frame, StackFrameSymbolPart.Method, CancellationToken.None);
 
-            var parsedFrame6 = result.ParsedFrames[5] as ParsedStackFrame;
-            AssertEx.NotNull(parsedFrame6);
-            Assert.Equal(@"at Microsoft.VisualStudio.Telemetry.WindowsErrorReporting.WatsonReport.GetClrWatsonExceptionInfo(Exception exceptionObject)", parsedFrame6.OriginalText);
+            AssertEx.NotNull(definition);
+            Assert.Equal("String.ToLower", definition.NameDisplayParts.ToVisibleDisplayString(includeLeftToRightMarker: false));
         }
     }
 }
diff --git a/src/EditorFeatures/Test/Utilities/StackFrameUtils.cs b/src/EditorFeatures/Test/Utilities/StackFrameUtils.cs
new file mode 100644
index 0000000000000..cf0a4010cdcf6
--- /dev/null
+++ b/src/EditorFeatures/Test/Utilities/StackFrameUtils.cs
@@ -0,0 +1,230 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Linq;
+using System.Text;
+using Microsoft.CodeAnalysis.EmbeddedLanguages.StackFrame;
+using Roslyn.Test.Utilities;
+using Xunit;
+
+namespace Microsoft.CodeAnalysis.Editor.UnitTests.Utilities
+{
+    using StackFrameNodeOrToken = CodeAnalysis.EmbeddedLanguages.Common.EmbeddedSyntaxNodeOrToken<StackFrameKind, StackFrameNode>;
+    using StackFrameToken = CodeAnalysis.EmbeddedLanguages.Common.EmbeddedSyntaxToken<StackFrameKind>;
+    using StackFrameTrivia = CodeAnalysis.EmbeddedLanguages.Common.EmbeddedSyntaxTrivia<StackFrameKind>;
+
+    internal static class StackFrameUtils
+    {
+        public static void AssertEqual(StackFrameNodeOrToken expected, StackFrameNodeOrToken actual)
+        {
+            Assert.Equal(expected.IsNode, actual.IsNode);
+            if (expected.IsNode)
+            {
+                AssertEqual(expected.Node, actual.Node);
+            }
+            else
+            {
+                AssertEqual(expected.Token, actual.Token);
+            }
+        }
+
+        public static void AssertEqual(StackFrameNode? expected, StackFrameNode? actual)
+        {
+            if (expected is null)
+            {
+                Assert.Null(actual);
+                return;
+            }
+
+            AssertEx.NotNull(actual);
+
+            Assert.Equal(expected.Kind, actual.Kind);
+            Assert.True(expected.ChildCount == actual.ChildCount, PrintChildDifference(expected, actual));
+
+            for (var i = 0; i < expected.ChildCount; i++)
+            {
+                AssertEqual(expected.ChildAt(i), actual.ChildAt(i));
+            }
+
+            static string PrintChildDifference(StackFrameNode expected, StackFrameNode actual)
+            {
+                var sb = new StringBuilder();
+                sb.Append("Expected: ");
+                Print(expected, sb);
+                sb.AppendLine();
+
+                sb.Append("Actual: ");
+                Print(actual, sb);
+
+                return sb.ToString();
+            }
+        }
+
+        public static void Print(StackFrameNode node, StringBuilder sb)
+        {
+            foreach (var child in node)
+            {
+                if (child.IsNode)
+                {
+                    Print(child.Node, sb);
+                }
+                else
+                {
+                    if (!child.Token.LeadingTrivia.IsDefaultOrEmpty)
+                    {
+                        Print(child.Token.LeadingTrivia, sb);
+                    }
+
+                    sb.Append(child.Token.VirtualChars.CreateString());
+
+                    if (!child.Token.TrailingTrivia.IsDefaultOrEmpty)
+                    {
+                        Print(child.Token.TrailingTrivia, sb);
+                    }
+                }
+            }
+        }
+
+        public static void Print(ImmutableArray<StackFrameTrivia> triviaArray, StringBuilder sb)
+        {
+            if (triviaArray.IsDefault)
+            {
+                sb.Append("<default>");
+                return;
+            }
+
+            if (triviaArray.IsEmpty)
+            {
+                sb.Append("<empty>");
+                return;
+            }
+
+            foreach (var trivia in triviaArray)
+            {
+                sb.Append(trivia.VirtualChars.CreateString());
+            }
+        }
+
+        public static void AssertEqual(StackFrameToken expected, StackFrameToken actual)
+        {
+            Assert.Equal(expected.Kind, actual.Kind);
+            Assert.Equal(expected.IsMissing, actual.IsMissing);
+            Assert.Equal(expected.VirtualChars.CreateString(), actual.VirtualChars.CreateString());
+
+            AssertEqual(expected.LeadingTrivia, actual.LeadingTrivia, expected);
+            AssertEqual(expected.TrailingTrivia, actual.TrailingTrivia, expected);
+        }
+
+        public static void AssertEqual(ImmutableArray<StackFrameTrivia> expected, ImmutableArray<StackFrameTrivia> actual, StackFrameToken token)
+        {
+            var diffMessage = PrintDiff();
+
+            if (expected.IsDefault)
+            {
+                Assert.True(actual.IsDefault, diffMessage);
+                return;
+            }
+
+            Assert.False(actual.IsDefault, diffMessage);
+            Assert.True(expected.Length == actual.Length, diffMessage);
+
+            for (var i = 0; i < expected.Length; i++)
+            {
+                AssertEqual(expected[i], actual[i]);
+            }
+
+            string PrintDiff()
+            {
+                var sb = new StringBuilder();
+                sb.AppendLine($"Trivia is different on {token.Kind}");
+                sb.Append("Expected: ");
+
+                if (!expected.IsDefaultOrEmpty)
+                {
+                    sb.Append('[');
+                }
+
+                Print(expected, sb);
+
+                if (expected.IsDefaultOrEmpty)
+                {
+                    sb.AppendLine();
+                }
+                else
+                {
+                    sb.AppendLine("]");
+                }
+
+                sb.Append("Actual: ");
+
+                if (!actual.IsDefaultOrEmpty)
+                {
+                    sb.Append('[');
+                }
+
+                Print(actual, sb);
+
+                if (!actual.IsDefaultOrEmpty)
+                {
+                    sb.Append(']');
+                }
+
+                return sb.ToString();
+            }
+        }
+
+        public static void AssertEqual(StackFrameTrivia expected, StackFrameTrivia actual)
+        {
+            Assert.Equal(expected.Kind, actual.Kind);
+            Assert.Equal(expected.VirtualChars.CreateString(), actual.VirtualChars.CreateString());
+        }
+
+        public static IEnumerable<CodeAnalysis.EmbeddedLanguages.VirtualChars.VirtualCharSequence> Enumerate(StackFrameToken token)
+        {
+            foreach (var trivia in token.LeadingTrivia)
+            {
+                yield return trivia.VirtualChars;
+            }
+
+            yield return token.VirtualChars;
+
+            foreach (var trivia in token.TrailingTrivia)
+            {
+                yield return trivia.VirtualChars;
+            }
+        }
+
+        public static IEnumerable<CodeAnalysis.EmbeddedLanguages.VirtualChars.VirtualCharSequence> Enumerate(StackFrameNode node)
+        {
+            foreach (var nodeOrToken in node)
+            {
+                if (nodeOrToken.IsNode)
+                {
+                    foreach (var charSequence in Enumerate(nodeOrToken.Node))
+                    {
+                        yield return charSequence;
+                    }
+                }
+                else if (nodeOrToken.Token.Kind != StackFrameKind.None)
+                {
+                    foreach (var charSequence in Enumerate(nodeOrToken.Token))
+                    {
+                        yield return charSequence;
+                    }
+                }
+                else
+                {
+                    // If we encounter a None token make sure it has default values
+                    Assert.True(nodeOrToken.Token.IsMissing);
+                    Assert.True(nodeOrToken.Token.LeadingTrivia.IsDefault);
+                    Assert.True(nodeOrToken.Token.TrailingTrivia.IsDefault);
+                    Assert.Null(nodeOrToken.Token.Value);
+                    Assert.True(nodeOrToken.Token.VirtualChars.IsDefault);
+                }
+            }
+        }
+    }
+}
diff --git a/src/Features/CSharp/Portable/StackTraceExplorer/CSharpStackTraceExplorerService.cs b/src/Features/CSharp/Portable/StackTraceExplorer/CSharpStackTraceExplorerService.cs
deleted file mode 100644
index dfee6288646d2..0000000000000
--- a/src/Features/CSharp/Portable/StackTraceExplorer/CSharpStackTraceExplorerService.cs
+++ /dev/null
@@ -1,84 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-using System;
-using System.Collections.Generic;
-using System.Collections.Immutable;
-using System.Composition;
-using System.Linq;
-using Microsoft.CodeAnalysis.CSharp.Syntax;
-using Microsoft.CodeAnalysis.Host.Mef;
-using Microsoft.CodeAnalysis.StackTraceExplorer;
-using Roslyn.Utilities;
-
-namespace Microsoft.CodeAnalysis.CSharp.StackTraceExplorer
-{
-    [Shared]
-    [ExportLanguageService(typeof(IStackTraceExplorerService), language: LanguageNames.CSharp)]
-    internal class CSharpStackTraceExplorerService : IStackTraceExplorerService
-    {
-        [ImportingConstructor]
-        [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
-        public CSharpStackTraceExplorerService()
-        {
-        }
-
-        public string GetTypeMetadataName(string className)
-        {
-            var typeNameSyntax = SyntaxFactory.ParseTypeName(className);
-            if (typeNameSyntax is QualifiedNameSyntax qualifiedNameSyntax)
-            {
-                return GetMetadataNameOfQualifiedNameSyntax(qualifiedNameSyntax);
-            }
-
-            return GetGenericNameWithArity(typeNameSyntax);
-        }
-
-        private static string GetMetadataNameOfQualifiedNameSyntax(QualifiedNameSyntax originalSyntax)
-        {
-            SyntaxNode syntax = originalSyntax;
-            Stack<string> parts = new();
-
-            while (true)
-            {
-                if (syntax is QualifiedNameSyntax qualifiedNameSyntax)
-                {
-                    syntax = qualifiedNameSyntax.Left;
-                    parts.Push(GetGenericNameWithArity(qualifiedNameSyntax.Right));
-                }
-                else
-                {
-                    parts.Push(GetGenericNameWithArity(syntax));
-                    break;
-                }
-            }
-
-            return parts.Join(".");
-        }
-
-        private static string GetGenericNameWithArity(SyntaxNode node)
-        {
-            if (node is not GenericNameSyntax genericNameSyntax)
-            {
-                return node.ToString();
-            }
-
-            return $"{genericNameSyntax.Identifier}`{genericNameSyntax.Arity}";
-        }
-
-        public string GetMethodSymbolName(string methodName)
-        {
-            methodName = methodName.Replace("[", "<").Replace("]", ">");
-            // Add a void return so it parses as a method declaration and not constructor
-            var declaration = SyntaxFactory.ParseMemberDeclaration($"void {methodName}");
-            if (declaration is MethodDeclarationSyntax methodDeclarationSyntax)
-            {
-                var paramList = methodDeclarationSyntax.ParameterList.Parameters.Select(p => p.Type?.ToString());
-                return $"{methodDeclarationSyntax.Identifier}{methodDeclarationSyntax.TypeParameterList}({paramList.Join(", ")})";
-            }
-
-            return methodName;
-        }
-    }
-}
diff --git a/src/Features/Core/Portable/EmbeddedLanguages/StackFrame/StackFrameNodeDefinitions.cs b/src/Features/Core/Portable/EmbeddedLanguages/StackFrame/StackFrameNodeDefinitions.cs
index 5c1c921b0cb1d..752fb4c5c632f 100644
--- a/src/Features/Core/Portable/EmbeddedLanguages/StackFrame/StackFrameNodeDefinitions.cs
+++ b/src/Features/Core/Portable/EmbeddedLanguages/StackFrame/StackFrameNodeDefinitions.cs
@@ -201,27 +201,31 @@ internal sealed class StackFrameArrayTypeNode : StackFrameTypeNode
     {
         /// <summary>
         /// The type identifier without the array indicators.
+        /// <code>
         /// string[][]
         /// ^----^
+        /// </code>
         /// </summary>
         public readonly StackFrameNameNode TypeIdentifier;
 
         /// <summary>
         /// Each unique array identifier for the type
+        /// <code>
         /// string[,][]
-        ///        ^--- First array expression = "[,]"
-        ///           ^- Second array expression = "[]" 
+        ///        ^---  First array rank specifier  = "[,]"
+        ///           ^- Second array rank specifier = "[]" 
+        /// </code>
         /// </summary>
-        public ImmutableArray<StackFrameArrayRankSpecifier> ArrayExpressions;
+        public ImmutableArray<StackFrameArrayRankSpecifier> ArrayRankSpecifiers;
 
-        public StackFrameArrayTypeNode(StackFrameNameNode typeIdentifier, ImmutableArray<StackFrameArrayRankSpecifier> arrayExpressions) : base(StackFrameKind.ArrayTypeExpression)
+        public StackFrameArrayTypeNode(StackFrameNameNode typeIdentifier, ImmutableArray<StackFrameArrayRankSpecifier> arrayRankSpecifiers) : base(StackFrameKind.ArrayTypeExpression)
         {
-            Debug.Assert(!arrayExpressions.IsDefaultOrEmpty);
+            Debug.Assert(!arrayRankSpecifiers.IsDefaultOrEmpty);
             TypeIdentifier = typeIdentifier;
-            ArrayExpressions = arrayExpressions;
+            ArrayRankSpecifiers = arrayRankSpecifiers;
         }
 
-        internal override int ChildCount => 1 + ArrayExpressions.Length;
+        internal override int ChildCount => 1 + ArrayRankSpecifiers.Length;
 
         public override void Accept(IStackFrameNodeVisitor visitor)
             => visitor.Visit(this);
@@ -230,7 +234,7 @@ internal override StackFrameNodeOrToken ChildAt(int index)
             => index switch
             {
                 0 => TypeIdentifier,
-                _ => ArrayExpressions[index - 1]
+                _ => ArrayRankSpecifiers[index - 1]
             };
     }
 
@@ -435,4 +439,4 @@ internal override StackFrameNodeOrToken ChildAt(int index)
                 _ => throw new InvalidOperationException()
             };
     }
-}
+}
\ No newline at end of file
diff --git a/src/Features/Core/Portable/StackTraceExplorer/DotnetStackFrameParser.cs b/src/Features/Core/Portable/StackTraceExplorer/DotnetStackFrameParser.cs
index d6a539e5057cb..b7f15b190711d 100644
--- a/src/Features/Core/Portable/StackTraceExplorer/DotnetStackFrameParser.cs
+++ b/src/Features/Core/Portable/StackTraceExplorer/DotnetStackFrameParser.cs
@@ -2,53 +2,27 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-using System;
 using System.Diagnostics.CodeAnalysis;
-using Microsoft.CodeAnalysis.Text;
+using Microsoft.CodeAnalysis.EmbeddedLanguages.StackFrame;
 
 namespace Microsoft.CodeAnalysis.StackTraceExplorer
 {
     internal sealed class DotnetStackFrameParser : IStackFrameParser
     {
-        private const string StackTraceAtStart = "at ";
-        private const string StackTraceSymbolAndFileSplit = " in ";
-
         /// <summary>
-        /// Tries to parse a StackFrame following convention from Environment.StackTrace
-        /// https://docs.microsoft.com/en-us/dotnet/api/system.environment.stacktrace has
-        /// details on output format and expected strings
-        /// 
-        /// Example:
-        /// at ConsoleApp4.MyClass.M() in C:\repos\ConsoleApp4\ConsoleApp4\Program.cs:line 26
+        /// Uses <see cref="StackFrameParser"/> to parse a line if possible
         /// </summary>
         public bool TryParseLine(string line, [NotNullWhen(true)] out ParsedFrame? parsedFrame)
         {
             parsedFrame = null;
+            var tree = StackFrameParser.TryParse(line);
 
-            if (!line.Trim().StartsWith(StackTraceAtStart))
-            {
-                return false;
-            }
-
-            var success = StackFrameParserHelpers.TryParseMethodSignature(line.AsSpan(), out var classSpan, out var methodSpan, out var argsSpan);
-            if (!success)
+            if (tree is null)
             {
                 return false;
             }
 
-            var splitIndex = line.IndexOf(StackTraceSymbolAndFileSplit);
-
-            // The line has " in <filename>:line <line number>"
-            if (splitIndex > 0)
-            {
-                var fileInformationStart = splitIndex + StackTraceSymbolAndFileSplit.Length;
-                var fileInformationSpan = new TextSpan(fileInformationStart, line.Length - fileInformationStart);
-
-                parsedFrame = new ParsedStackFrame(line, classSpan, methodSpan, argsSpan, fileInformationSpan);
-                return true;
-            }
-
-            parsedFrame = new ParsedStackFrame(line, classSpan, methodSpan, argsSpan);
+            parsedFrame = new ParsedStackFrame(tree);
             return true;
         }
     }
diff --git a/src/Features/Core/Portable/StackTraceExplorer/IStackTraceExplorerService.cs b/src/Features/Core/Portable/StackTraceExplorer/IStackTraceExplorerService.cs
index bb74831a2a6e1..ee5d13649b76f 100644
--- a/src/Features/Core/Portable/StackTraceExplorer/IStackTraceExplorerService.cs
+++ b/src/Features/Core/Portable/StackTraceExplorer/IStackTraceExplorerService.cs
@@ -2,25 +2,28 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-using System;
-using System.Collections.Generic;
-using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.EmbeddedLanguages.StackFrame;
+using Microsoft.CodeAnalysis.FindUsages;
 using Microsoft.CodeAnalysis.Host;
+using Microsoft.CodeAnalysis.Remote;
 
 namespace Microsoft.CodeAnalysis.StackTraceExplorer
 {
-    internal interface IStackTraceExplorerService : ILanguageService
+    internal interface IStackTraceExplorerService : IWorkspaceService
     {
         /// <summary>
-        /// Given the <see cref="ParsedStackFrame.TypeSpan"/>, get the equivalent name
-        /// in metadata that can be used to look up the type
+        /// If the <paramref name="frame"/> has file information, attempts to map it to existing documents
+        /// in a solution. Looks for an exact filepath match first, then defaults to 
+        /// a best guess.
         /// </summary>
-        string GetTypeMetadataName(string className);
+        (Document? document, int line) GetDocumentAndLine(Solution solution, ParsedFrame frame);
+        Task<DefinitionItem?> TryFindDefinitionAsync(Solution solution, ParsedFrame frame, StackFrameSymbolPart symbolPart, CancellationToken cancellationToken);
+    }
 
-        /// <summary>
-        /// Given the <see cref="ParsedStackFrame.MethodSpan"/>, get the symbol name
-        /// for to match <see cref="IMethodSymbol"/> of a given type
-        /// </summary>
-        string GetMethodSymbolName(string methodName);
+    internal interface IRemoteStackTraceExplorerService
+    {
+        ValueTask<SerializableDefinitionItem?> TryFindDefinitionAsync(PinnedSolutionInfo solutionInfo, string frameString, StackFrameSymbolPart symbolPart, CancellationToken cancellationToken);
     }
 }
diff --git a/src/Features/Core/Portable/StackTraceExplorer/IgnoredFrame.cs b/src/Features/Core/Portable/StackTraceExplorer/IgnoredFrame.cs
index da730ed875e94..246a4443bba9e 100644
--- a/src/Features/Core/Portable/StackTraceExplorer/IgnoredFrame.cs
+++ b/src/Features/Core/Portable/StackTraceExplorer/IgnoredFrame.cs
@@ -6,8 +6,16 @@ namespace Microsoft.CodeAnalysis.StackTraceExplorer
 {
     internal sealed class IgnoredFrame : ParsedFrame
     {
-        public IgnoredFrame(string originalText) : base(originalText)
+        private readonly string _originalText;
+
+        public IgnoredFrame(string originalText)
+        {
+            _originalText = originalText;
+        }
+
+        public override string ToString()
         {
+            return _originalText;
         }
     }
 }
diff --git a/src/Features/Core/Portable/StackTraceExplorer/ParsedFrame.cs b/src/Features/Core/Portable/StackTraceExplorer/ParsedFrame.cs
index 1bfe0201a0ece..9e65a78a3290b 100644
--- a/src/Features/Core/Portable/StackTraceExplorer/ParsedFrame.cs
+++ b/src/Features/Core/Portable/StackTraceExplorer/ParsedFrame.cs
@@ -6,14 +6,8 @@ namespace Microsoft.CodeAnalysis.StackTraceExplorer
 {
     internal abstract class ParsedFrame
     {
-        /// <summary>
-        /// The original text that this frame was parsed from
-        /// </summary>
-        public string OriginalText { get; }
-
-        public ParsedFrame(string originalText)
+        public ParsedFrame()
         {
-            OriginalText = originalText;
         }
     }
 }
diff --git a/src/Features/Core/Portable/StackTraceExplorer/ParsedStackFrame.cs b/src/Features/Core/Portable/StackTraceExplorer/ParsedStackFrame.cs
index 2e1512e7b0134..5b464fc65d575 100644
--- a/src/Features/Core/Portable/StackTraceExplorer/ParsedStackFrame.cs
+++ b/src/Features/Core/Portable/StackTraceExplorer/ParsedStackFrame.cs
@@ -2,247 +2,39 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
-using System.Diagnostics;
 using System.IO;
 using System.Linq;
-using System.Text.RegularExpressions;
 using System.Threading;
 using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.EmbeddedLanguages.Common;
+using Microsoft.CodeAnalysis.EmbeddedLanguages.StackFrame;
 using Microsoft.CodeAnalysis.Shared.Extensions;
-using Microsoft.CodeAnalysis.Text;
 using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.StackTraceExplorer
 {
     /// <summary>
-    /// A line of text that was parsed by <see cref="StackTraceAnalyzer" />
-    /// to provide metadata bout the line. Expected to be the parsed output 
-    /// of a serialized <see cref="StackFrame"/>
+    /// A line from <see cref="StackTraceAnalyzer.Parse(string, CancellationToken)"/> that
+    /// was parsed by <see cref="StackFrameParser"/>
     /// </summary>
     internal sealed class ParsedStackFrame : ParsedFrame
     {
-        public ParsedStackFrame(
-            string originalText,
-            TextSpan typeSpan,
-            TextSpan methodSpan,
-            TextSpan argsSpan,
-            TextSpan fileSpan = default)
-            : base(originalText)
-        {
-            Contract.ThrowIfTrue(typeSpan.IsEmpty);
-            Contract.ThrowIfTrue(methodSpan.IsEmpty);
-
-            TypeSpan = typeSpan;
-            MethodSpan = methodSpan;
-            ArgsSpan = argsSpan;
-            FileSpan = fileSpan;
-        }
-
-        /// <summary>
-        /// The full type name parsed from the line. 
-        /// ex: [|Microsoft.CodeAnalysis.Editor.CallstackExplorer.|]Example(arg1, arg2)
-        /// </summary>
-        public TextSpan TypeSpan { get; }
-
-        /// <summary>
-        /// The method name span
-        /// ex: Microsoft.CodeAnalysis.Editor.CallstackExplorer.[|Example|](arg1, arg2)
-        /// </summary>
-        public TextSpan MethodSpan { get; }
-
-        /// <summary>
-        /// The span of comma seperated arguments.
-        /// ex: Microsoft.CodeAnalysis.Editor.CallstackExplorer.Example[|(arg1, arg2)|]
-        /// </summary>
-        public TextSpan ArgsSpan { get; }
-
-        /// <summary>
-        /// The span representing file information on the stack trace line. Is not always available, so it's 
-        /// possible this span is <see langword="default"/>
-        /// </summary>
-        public TextSpan FileSpan { get; }
-
-        public async Task<ISymbol?> ResolveSymbolAsync(Solution solution, CancellationToken cancellationToken)
-        {
-            // The original span for type includes the trailing '.', which we don't want when
-            // looking for the class by metadata name
-            var fullyQualifiedTypeName = OriginalText[TypeSpan.Start..(TypeSpan.End - 1)];
-            var methodName = GetMethodText();
-
-            foreach (var project in solution.Projects)
-            {
-                var service = project.GetLanguageService<IStackTraceExplorerService>();
-                if (service is null)
-                {
-                    continue;
-                }
-
-                var metadataName = service.GetTypeMetadataName(fullyQualifiedTypeName);
-                var memberName = service.GetMethodSymbolName(methodName);
-
-                var compilation = await project.GetRequiredCompilationAsync(cancellationToken).ConfigureAwait(false);
-                var type = compilation.GetTypeByMetadataName(metadataName);
-                if (type is null)
-                {
-                    continue;
-                }
-
-                var members = type.GetMembers();
-                var matchingMembers = members
-                    .OfType<IMethodSymbol>()
-                    .Where(m => MemberMatchesMethodName(m, memberName))
-                    .ToImmutableArrayOrEmpty();
-
-                if (matchingMembers.Length == 0)
-                {
-                    continue;
-                }
-
-                if (matchingMembers.Length == 1)
-                {
-                    return matchingMembers[0];
-                }
-            }
-
-            return null;
-
-            // TODO: Improve perf here. ToDisplayString is fairly expensive
-            static bool MemberMatchesMethodName(ISymbol member, string memberToSearchFor)
-            {
-                var displayName = member.ToDisplayString();
-                var dotIndex = displayName.LastIndexOf(".");
-                var memberName = dotIndex >= 0
-                    ? displayName[(dotIndex + 1)..]
-                    : displayName;
-
-                return string.Equals(memberName, memberToSearchFor);
-            }
-        }
-
-        /// <summary>
-        /// Gets all of the text prior to the <see cref="TypeSpan"/>
-        /// </summary>
-        /// <returns></returns>
-        public string GetTextBeforeType()
-        {
-            return OriginalText[..TypeSpan.Start];
-        }
-
-        /// <summary>
-        /// Gets the text representing the fully qualified type name
-        /// </summary>
-        public string GetQualifiedTypeText()
-        {
-            return OriginalText[TypeSpan.Start..TypeSpan.End];
-        }
-
-        /// <summary>
-        /// Gets the method text, including the arguments to the method
-        /// </summary>
-        public string GetMethodText()
-        {
-            return OriginalText[MethodSpan.Start..ArgsSpan.End];
-        }
-
-        /// <summary>
-        /// Gets the text after the last parsed span available. This is after
-        /// file information if it is available, otherwise after the argument information.
-        /// </summary>
-        public string GetTrailingText()
-        {
-            var lastSpan = FileSpan == default
-                ? ArgsSpan
-                : FileSpan;
-
-            if (lastSpan.End + 1 == OriginalText.Length)
-            {
-                return string.Empty;
-            }
-
-            return OriginalText[(lastSpan.End + 1)..];
-        }
-
-        /// <summary>
-        /// If the frame has file information, gets the text between the method and file information.
-        /// ex: at ConsoleApp4.MyClass.M[T](T t) in [|C:\repos\Test\MyClass.cs:line 7|]
-        /// </summary>
-        public string? GetFileText()
-        {
-            if (FileSpan == default)
-            {
-                return null;
-            }
-
-            return OriginalText[FileSpan.Start..FileSpan.End];
-        }
+        public readonly StackFrameTree Tree;
 
-        /// <summary>
-        /// If the frame has file information, gets the text between the method and file information.
-        /// ex: at ConsoleApp4.MyClass.M[T](T t)[| in |]C:\repos\Test\MyClass.cs:line 7
-        /// </summary>
-        public string? GetTextBetweenTypeAndFile()
+        public ParsedStackFrame(
+            StackFrameTree tree)
         {
-            if (FileSpan == default)
-            {
-                return null;
-            }
-
-            return OriginalText[(ArgsSpan.End + 1)..FileSpan.Start];
+            Tree = tree;
         }
 
-        internal (Document? document, int line) GetDocumentAndLine(Solution solution)
-        {
-            var fileMatches = GetFileMatches(solution, out var lineNumber);
-            if (fileMatches.IsEmpty)
-            {
-                return (null, 0);
-            }
-
-            return (fileMatches.First(), lineNumber);
-        }
+        public StackFrameCompilationUnit Root => Tree.Root;
 
-        /// <summary>
-        /// If the <see cref="FileSpan"/> exists it attempts to map the file path that exists
-        /// in that span to a document in the solution. It's possible the file path won't match exactly,
-        /// so it does a best effort to match based on name.
-        /// </summary>
-        private ImmutableArray<Document> GetFileMatches(Solution solution, out int lineNumber)
+        public override string ToString()
         {
-            var fileText = OriginalText[FileSpan.Start..FileSpan.End];
-            var regex = new Regex(@"(?<fileName>.+):(line)\s*(?<lineNumber>[0-9]+)");
-            var match = regex.Match(fileText);
-            Debug.Assert(match.Success);
-
-            var fileNameGroup = match.Groups["fileName"];
-            var lineNumberGroup = match.Groups["lineNumber"];
-
-            lineNumber = int.Parse(lineNumberGroup.Value);
-
-            var fileName = fileNameGroup.Value;
-            Debug.Assert(!string.IsNullOrEmpty(fileName));
-
-            var documentName = Path.GetFileName(fileName);
-            var potentialMatches = new HashSet<Document>();
-
-            foreach (var project in solution.Projects)
-            {
-                foreach (var document in project.Documents)
-                {
-                    if (document.FilePath == fileName)
-                    {
-                        return ImmutableArray.Create(document);
-                    }
-
-                    else if (document.Name == documentName)
-                    {
-                        potentialMatches.Add(document);
-                    }
-                }
-            }
-
-            return potentialMatches.ToImmutableArray();
+            return Tree.Text.CreateString();
         }
     }
 }
diff --git a/src/Features/Core/Portable/StackTraceExplorer/StackFrameParserHelpers.cs b/src/Features/Core/Portable/StackTraceExplorer/StackFrameParserHelpers.cs
deleted file mode 100644
index 18d7f41e576da..0000000000000
--- a/src/Features/Core/Portable/StackTraceExplorer/StackFrameParserHelpers.cs
+++ /dev/null
@@ -1,308 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-using System;
-using System.Diagnostics;
-using Microsoft.CodeAnalysis.Text;
-using Roslyn.Utilities;
-
-namespace Microsoft.CodeAnalysis.StackTraceExplorer
-{
-    internal class StackFrameParserHelpers
-    {
-        /// <summary>
-        /// Makes sure that the string at least somewhat resembles the correct form.
-        /// Does not check validity on class or method identifiers
-        /// Example line:
-        /// at ConsoleApp4.MyClass.ThrowAtOne(p1, p2) 
-        ///   |-------------------||--------||-------| 
-        ///           Class          Method    Args   
-        /// </summary>
-        /// <remarks>
-        /// See https://docs.microsoft.com/en-us/dotnet/api/system.environment.stacktrace for more information
-        /// on expected stacktrace form. At time of writing, this is based on the following "ToString" implementation in the runtime: 
-        /// https://github.com/dotnet/runtime/blob/72d643d05ab23888f30a57d447154e36f979f3d1/src/libraries/System.Private.CoreLib/src/System/Diagnostics/StackTrace.cs#L206
-        /// </remarks>
-
-        public static bool TryParseMethodSignature(ReadOnlySpan<char> line, out TextSpan classSpan, out TextSpan methodSpan, out TextSpan argsSpan)
-        {
-
-            var state = new ParseStateMachine();
-            Debug.Assert(state.CurrentParsingSpan == CurrentParsingSpan.Type);
-
-            for (var i = 0; i < line.Length; i++)
-            {
-                if (state.CurrentParsingSpan == CurrentParsingSpan.Finished)
-                {
-                    break;
-                }
-
-                var c = line[i];
-                state.CurrentSpanLength++;
-
-                //
-                // Every if statement should be a branch and always end with a "continue" statement.
-                // It is cumbersome to read this as a switch statement, especially given that not all branches
-                // are just switches on a character. If new arms are added, follow the general rule that
-                // all top if statements should not continue execution after they exit.
-                //
-
-                //
-                // When starting to parse an identifier we want the first character to be valid. Arguments will
-                // be an exception here so don't check validity of those characters for the first item
-                //
-                if (state.CurrentSpanLength == 1 && state.CurrentParsingSpan != CurrentParsingSpan.Arguments)
-                {
-                    // When starting to parse an identifier we want the first character to be valid
-                    if (!UnicodeCharacterUtilities.IsIdentifierStartCharacter(c))
-                    {
-                        state.Reset();
-                        continue;
-                    }
-
-                    // If we're starting to parse the type then we want the previous character to either be a space
-                    // or this to be the beginning of the string. We don't want to try to have valid identifier starts
-                    // as a subword of some text
-                    if (i > 0)
-                    {
-                        var previousChar = line[i - 1];
-                        if (previousChar != ' ')
-                        {
-                            state.Reset();
-                            continue;
-                        }
-                    }
-
-                    continue;
-                }
-
-                if (c == ' ')
-                {
-                    if (!state.AllowSpace)
-                    {
-                        // We encountered a space in an area we don't expect. Reset the state and start trying to parse
-                        // the next block as a method signature
-                        state.Reset();
-                    }
-
-                    continue;
-                }
-
-                if (c == '.')
-                {
-                    // Dot separators are allowed in the following cases:
-                    // 1. We are parsing the fully qualified type portion
-                    // 2. We are parsing arguments which could use a dot to fully qualify a type
-                    // 3. We are inside of a generic context, which could use dot to fully qualify a type
-                    if (state.CurrentParsingSpan == CurrentParsingSpan.Type || state.CurrentParsingSpan == CurrentParsingSpan.Arguments)
-                    {
-                        // Check that the previous item was a valid identifier character or ] (generic closure)
-                        if (i > 0)
-                        {
-                            var previousChar = line[i - 1];
-                            if (UnicodeCharacterUtilities.IsIdentifierPartCharacter(previousChar) || previousChar == ']')
-                            {
-                                continue;
-                            }
-                        }
-
-                        // Either there is no previous character, or the previous character does not allow for a '.' 
-                        // following it. Reset and continue parsing
-                        state.Reset();
-                        continue;
-                    }
-
-                    continue;
-                }
-
-                if (c == '[' || c == '<')
-                {
-                    state.GenericDepth++;
-                    continue;
-                }
-
-                if (c == ']' || c == '>')
-                {
-                    if (state.GenericDepth == 0)
-                    {
-                        state.Reset();
-                    }
-                    else
-                    {
-                        state.GenericDepth--;
-                    }
-
-                    continue;
-                }
-
-                if (c == '(')
-                {
-                    if (state.CurrentParsingSpan == CurrentParsingSpan.Type)
-                    {
-                        state.StartParsingArguments(line);
-                    }
-                    else
-                    {
-                        // In cases where we encounter a '(' and already are parsing arguments we want
-                        // to stop parsing. This could be problematic in cases where the value of a variable
-                        // is provided and is a string, but for now we will just fail parsing that.
-                        state.Reset();
-                    }
-
-                    continue;
-                }
-
-                if (c == ')')
-                {
-                    // ')' is invalid except for closing the end of the arguments list
-                    if (state.CurrentParsingSpan != CurrentParsingSpan.Arguments)
-                    {
-                        state.Reset();
-                        continue;
-                    }
-
-                    // Similar to assuming that '(' will always be considered a start of the argument section, we assume
-                    // that ')' will end it. There are cases where this is not true, but for now that's not supported.
-                    state.StopParsingArguments();
-                    continue;
-                }
-
-                if (c == ',')
-                {
-                    // Comma is allowed if we are parsing arguments or are currently going through a generic list. 
-                    // As of now, no validation is done that the comma is valid in this location
-                    if (state.CurrentParsingSpan != CurrentParsingSpan.Arguments && state.GenericDepth == 0)
-                    {
-                        state.Reset();
-                    }
-
-                    continue;
-                }
-
-                // In cases where we have no explicitly handled a character, our last effort is to make sure 
-                // we are only accepting valid identifier characters. Every character that needs to be handled 
-                // differently should be before this check
-                if (!UnicodeCharacterUtilities.IsIdentifierPartCharacter(c))
-                {
-                    state.Reset();
-                    continue;
-                }
-            }
-
-            classSpan = state.TypeSpan;
-            methodSpan = state.MethodSpan;
-            argsSpan = state.ArgumentsSpan;
-
-            return state.CurrentParsingSpan == CurrentParsingSpan.Finished &&
-                classSpan != default &&
-                methodSpan != default &&
-                argsSpan != default;
-        }
-
-        private struct ParseStateMachine
-        {
-            public int GenericDepth;
-            public bool InsideGeneric => GenericDepth > 0;
-            public bool AllowSpace => InsideGeneric || CurrentParsingSpan == CurrentParsingSpan.Arguments;
-            public int CurrentSpanStart { get; private set; }
-            public int CurrentSpanLength;
-            public CurrentParsingSpan CurrentParsingSpan { get; private set; }
-
-            /// <summary>
-            /// [|ConsoleApp4.MyClass|].M(string s, int i) 
-            /// </summary>
-            public TextSpan TypeSpan { get; private set; }
-
-            /// <summary>
-            /// ConsoleApp4.MyClass.[|M|](string s, int i) 
-            /// </summary>
-            public TextSpan MethodSpan { get; private set; }
-
-            /// <summary>
-            /// ConsoleApp4.MyClass.M([|string s, int i|]) 
-            /// </summary>
-            public TextSpan ArgumentsSpan { get; private set; }
-
-            public void Reset()
-            {
-                SoftReset();
-                CurrentParsingSpan = CurrentParsingSpan.Type;
-                TypeSpan = default;
-                MethodSpan = default;
-                ArgumentsSpan = default;
-            }
-
-            /// <summary>
-            /// Resets data that is common between a <see cref="Reset"/>, <see cref="StopParsingArguments"/>, and <see cref="StartParsingArguments"/>
-            /// </summary>
-            private void SoftReset()
-            {
-                CurrentSpanStart = CurrentSpanStart + CurrentSpanLength;
-                CurrentSpanLength = 0;
-                GenericDepth = 0;
-            }
-
-            internal void StopParsingArguments()
-            {
-                if (CurrentParsingSpan != CurrentParsingSpan.Arguments)
-                {
-                    throw new InvalidOperationException();
-                }
-
-                ArgumentsSpan = new TextSpan(CurrentSpanStart, CurrentSpanLength);
-                SoftReset();
-                CurrentParsingSpan = CurrentParsingSpan.Finished;
-            }
-
-            internal void StartParsingArguments(ReadOnlySpan<char> line)
-            {
-                if (CurrentParsingSpan != CurrentParsingSpan.Type)
-                {
-                    throw new InvalidOperationException();
-                }
-
-                var typeAndMethodSpan = new TextSpan(CurrentSpanStart, CurrentSpanLength);
-                SoftReset();
-                CurrentParsingSpan = CurrentParsingSpan.Arguments;
-
-                var dotIndex = -1;
-
-                for (var i = typeAndMethodSpan.End - 1; i >= typeAndMethodSpan.Start; i--)
-                {
-                    if (line[i] == '.')
-                    {
-                        dotIndex = i;
-                        break;
-                    }
-                }
-
-                if (dotIndex == -1)
-                {
-                    throw new InvalidOperationException();
-                }
-
-                TypeSpan = new TextSpan(typeAndMethodSpan.Start, (dotIndex - typeAndMethodSpan.Start) + 1);
-
-                var methodStart = dotIndex + 1;
-                var methodLength = (typeAndMethodSpan.End - 1) - methodStart;
-                MethodSpan = new TextSpan(methodStart, methodLength);
-            }
-        }
-
-        /// <summary>
-        /// Order is important here. This is the order we expect
-        /// parts of a method declaration to be parsed.
-        /// at ConsoleApp4.MyClass.ThrowAtOne(p1, p2,) 
-        ///   |-------------------||--------||-------| 
-        ///           Class          Method    Args   
-        /// </summary>
-        private enum CurrentParsingSpan
-        {
-            Type = 0,
-            Method,
-            Arguments,
-            Finished
-        }
-    }
-}
diff --git a/src/Features/Core/Portable/StackTraceExplorer/StackFrameSymbolPart.cs b/src/Features/Core/Portable/StackTraceExplorer/StackFrameSymbolPart.cs
new file mode 100644
index 0000000000000..d9c07c988d514
--- /dev/null
+++ b/src/Features/Core/Portable/StackTraceExplorer/StackFrameSymbolPart.cs
@@ -0,0 +1,26 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace Microsoft.CodeAnalysis.StackTraceExplorer
+{
+    /// <summary>
+    /// Determines what type of symbol to look for
+    /// when mapping a <see cref="ParsedStackFrame"/> to
+    /// a location.
+    /// </summary>
+    internal enum StackFrameSymbolPart
+    {
+        /// <summary>
+        /// The intended lookup is to find a method symbol associated 
+        /// with a <see cref="ParsedStackFrame"/>
+        /// </summary>
+        Method,
+
+        /// <summary>
+        /// The intended lookup is to find a type symbol associated
+        /// with a <see cref="ParsedStackFrame"/>
+        /// </summary>
+        ContainingType
+    }
+}
diff --git a/src/Features/Core/Portable/StackTraceExplorer/StackTraceAnalyzer.cs b/src/Features/Core/Portable/StackTraceExplorer/StackTraceAnalyzer.cs
index b0cc47e9297e9..e088bf787b366 100644
--- a/src/Features/Core/Portable/StackTraceExplorer/StackTraceAnalyzer.cs
+++ b/src/Features/Core/Portable/StackTraceExplorer/StackTraceAnalyzer.cs
@@ -8,6 +8,7 @@
 using System.Net;
 using System.Threading;
 using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.EmbeddedLanguages.StackFrame;
 
 namespace Microsoft.CodeAnalysis.StackTraceExplorer
 {
@@ -19,13 +20,13 @@ internal static class StackTraceAnalyzer
         /// take the result from the first parser that returns 
         /// success.
         /// </summary>
-        private static readonly ImmutableArray<IStackFrameParser> Parsers = ImmutableArray.Create<IStackFrameParser>(
+        private static readonly ImmutableArray<IStackFrameParser> s_parsers = ImmutableArray.Create<IStackFrameParser>(
             new DotnetStackFrameParser(),
             new VSDebugCallstackParser(),
             new DefaultStackParser()
         );
 
-        internal static Task<StackTraceAnalysisResult> AnalyzeAsync(string callstack, CancellationToken cancellationToken)
+        public static Task<StackTraceAnalysisResult> AnalyzeAsync(string callstack, CancellationToken cancellationToken)
         {
             var parsedFrames = Parse(callstack, cancellationToken);
             return Task.FromResult(new StackTraceAnalysisResult(parsedFrames.ToImmutableArray()));
@@ -39,7 +40,7 @@ private static IEnumerable<ParsedFrame> Parse(string callstack, CancellationToke
 
                 var trimmedLine = line.Trim();
 
-                foreach (var parser in Parsers)
+                foreach (var parser in s_parsers)
                 {
                     if (parser.TryParseLine(trimmedLine, out var parsedFrame))
                     {
@@ -50,7 +51,7 @@ private static IEnumerable<ParsedFrame> Parse(string callstack, CancellationToke
             }
         }
 
-        private static readonly char[] _lineSplit = new[] { '\n' };
+        private static readonly char[] s_lineSplit = new[] { '\n' };
 
         private static IEnumerable<string> SplitLines(string callstack)
         {
@@ -60,7 +61,7 @@ private static IEnumerable<string> SplitLines(string callstack)
             // equivalents ">" and "<" so we can parse correctly
             callstack = WebUtility.HtmlDecode(callstack);
 
-            return callstack.Split(_lineSplit, StringSplitOptions.RemoveEmptyEntries);
+            return callstack.Split(s_lineSplit, StringSplitOptions.RemoveEmptyEntries);
         }
     }
 }
diff --git a/src/Features/Core/Portable/StackTraceExplorer/VSDebugCallstackParser.cs b/src/Features/Core/Portable/StackTraceExplorer/VSDebugCallstackParser.cs
index a5a965249e2dc..b89a6a7c00216 100644
--- a/src/Features/Core/Portable/StackTraceExplorer/VSDebugCallstackParser.cs
+++ b/src/Features/Core/Portable/StackTraceExplorer/VSDebugCallstackParser.cs
@@ -6,6 +6,7 @@
 using System.Text;
 using System.Diagnostics.CodeAnalysis;
 using Microsoft.CodeAnalysis.Text;
+using Microsoft.CodeAnalysis.EmbeddedLanguages.StackFrame;
 
 namespace Microsoft.CodeAnalysis.StackTraceExplorer
 {
@@ -27,20 +28,15 @@ public bool TryParseLine(string line, [NotNullWhen(true)] out ParsedFrame? parse
                 return false;
             }
 
-            var success = StackFrameParserHelpers.TryParseMethodSignature(line.AsSpan().Slice(startPoint), out var classSpan, out var methodSpan, out var argsSpan);
+            var textToParse = line[startPoint..];
+            var tree = StackFrameParser.TryParse(textToParse);
 
-            if (!success)
+            if (tree is null)
             {
                 return false;
             }
 
-            // The spans need to be fixed up by the start point since we didn't
-            // pass everyting from '!' and before to the parser
-            classSpan = new TextSpan(classSpan.Start + startPoint, classSpan.Length);
-            methodSpan = new TextSpan(methodSpan.Start + startPoint, methodSpan.Length);
-            argsSpan = new TextSpan(argsSpan.Start + startPoint, argsSpan.Length);
-
-            parsedFrame = new ParsedStackFrame(line, classSpan, methodSpan, argsSpan);
+            parsedFrame = new ParsedStackFrame(tree);
             return true;
         }
     }
diff --git a/src/VisualStudio/Core/Def/StackTraceExplorer/IgnoredFrameViewModel.cs b/src/VisualStudio/Core/Def/StackTraceExplorer/IgnoredFrameViewModel.cs
index 5b7dd8a7d7fc7..5202ccf79cf7d 100644
--- a/src/VisualStudio/Core/Def/StackTraceExplorer/IgnoredFrameViewModel.cs
+++ b/src/VisualStudio/Core/Def/StackTraceExplorer/IgnoredFrameViewModel.cs
@@ -25,7 +25,7 @@ public IgnoredFrameViewModel(IgnoredFrame frame, IClassificationFormatMap format
 
         protected override IEnumerable<Inline> CreateInlines()
         {
-            var run = MakeClassifiedRun(ClassificationTypeNames.ExcludedCode, _frame.OriginalText);
+            var run = MakeClassifiedRun(ClassificationTypeNames.ExcludedCode, _frame.ToString());
             yield return run;
         }
     }
diff --git a/src/VisualStudio/Core/Def/StackTraceExplorer/StackFrameViewModel.cs b/src/VisualStudio/Core/Def/StackTraceExplorer/StackFrameViewModel.cs
index 8be0a043170d5..317c573f7370d 100644
--- a/src/VisualStudio/Core/Def/StackTraceExplorer/StackFrameViewModel.cs
+++ b/src/VisualStudio/Core/Def/StackTraceExplorer/StackFrameViewModel.cs
@@ -4,32 +4,40 @@
 
 using System;
 using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Diagnostics;
+using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 using System.Windows.Documents;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Classification;
-using Microsoft.CodeAnalysis.Editor.GoToDefinition;
 using Microsoft.CodeAnalysis.Editor.Host;
 using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
-using Microsoft.CodeAnalysis.StackTraceExplorer;
+using Microsoft.CodeAnalysis.EmbeddedLanguages.Common;
+using Microsoft.CodeAnalysis.EmbeddedLanguages.StackFrame;
 using Microsoft.CodeAnalysis.ErrorReporting;
+using Microsoft.CodeAnalysis.FindUsages;
 using Microsoft.CodeAnalysis.Navigation;
 using Microsoft.CodeAnalysis.Options;
+using Microsoft.CodeAnalysis.PooledObjects;
+using Microsoft.CodeAnalysis.StackTraceExplorer;
 using Microsoft.VisualStudio.Text.Classification;
 using Roslyn.Utilities;
-using System.Diagnostics;
 
 namespace Microsoft.VisualStudio.LanguageServices.StackTraceExplorer
 {
+    using StackFrameToken = EmbeddedSyntaxToken<StackFrameKind>;
+    using StackFrameTrivia = EmbeddedSyntaxTrivia<StackFrameKind>;
+
     internal class StackFrameViewModel : FrameViewModel
     {
         private readonly ParsedStackFrame _frame;
         private readonly IThreadingContext _threadingContext;
         private readonly Workspace _workspace;
-        private readonly IStreamingFindUsagesPresenter _streamingPresenter;
+        private readonly IStackTraceExplorerService _stackExplorerService;
+        private readonly Dictionary<StackFrameSymbolPart, DefinitionItem?> _definitionCache = new();
 
-        private ISymbol? _cachedSymbol;
         private Document? _cachedDocument;
         private int _cachedLineNumber;
 
@@ -38,14 +46,13 @@ public StackFrameViewModel(
             IThreadingContext threadingContext,
             Workspace workspace,
             IClassificationFormatMap formatMap,
-            ClassificationTypeMap typeMap,
-            IStreamingFindUsagesPresenter streamingPresenter)
+            ClassificationTypeMap typeMap)
             : base(formatMap, typeMap)
         {
             _frame = frame;
             _threadingContext = threadingContext;
             _workspace = workspace;
-            _streamingPresenter = streamingPresenter;
+            _stackExplorerService = workspace.Services.GetRequiredService<IStackTraceExplorerService>();
         }
 
         public override bool ShowMouseOver => true;
@@ -60,22 +67,16 @@ public async Task NavigateToClassAsync(CancellationToken cancellationToken)
         {
             try
             {
-                var symbol = await GetSymbolAsync(cancellationToken).ConfigureAwait(false);
-
-                if (symbol is not { ContainingSymbol: not null })
+                var definition = await GetDefinitionAsync(StackFrameSymbolPart.ContainingType, cancellationToken).ConfigureAwait(false);
+                if (definition is null)
                 {
-                    // Show some dialog?
                     return;
                 }
 
-                // Use the parent class instead of the method to navigate to
-                symbol = symbol.ContainingSymbol;
-
-                var success = NavigateToSymbol(symbol, cancellationToken);
-                if (!success)
+                var canNavigate = await definition.CanNavigateToAsync(_workspace, cancellationToken).ConfigureAwait(false);
+                if (canNavigate)
                 {
-                    // show some dialog?
-                    return;
+                    await definition.TryNavigateToAsync(_workspace, showInPreviewTab: true, activateTab: false, cancellationToken).ConfigureAwait(false);
                 }
             }
             catch (Exception ex) when (FatalError.ReportAndCatchUnlessCanceled(ex, cancellationToken))
@@ -93,20 +94,16 @@ public async Task NavigateToMethodAsync(CancellationToken cancellationToken)
         {
             try
             {
-                var symbol = await _frame.ResolveSymbolAsync(_workspace.CurrentSolution, cancellationToken).ConfigureAwait(false);
-
-                if (symbol is null)
+                var definition = await GetDefinitionAsync(StackFrameSymbolPart.Method, cancellationToken).ConfigureAwait(false);
+                if (definition is null)
                 {
-                    // Show some dialog?
                     return;
                 }
 
-                var success = NavigateToSymbol(symbol, cancellationToken);
-
-                if (!success)
+                var canNavigate = await definition.CanNavigateToAsync(_workspace, cancellationToken).ConfigureAwait(false);
+                if (canNavigate)
                 {
-                    // Show some dialog?
-                    return;
+                    await definition.TryNavigateToAsync(_workspace, showInPreviewTab: true, activateTab: false, cancellationToken).ConfigureAwait(false);
                 }
             }
             catch (Exception ex) when (FatalError.ReportAndCatchUnlessCanceled(ex, cancellationToken))
@@ -114,15 +111,6 @@ public async Task NavigateToMethodAsync(CancellationToken cancellationToken)
             }
         }
 
-        private bool NavigateToSymbol(ISymbol symbol, CancellationToken cancellationToken)
-            => GoToDefinitionHelpers.TryGoToDefinition(
-                    symbol,
-                    _workspace.CurrentSolution,
-                    _threadingContext,
-                    _streamingPresenter,
-                    thirdPartyNavigationAllowed: true,
-                    cancellationToken: cancellationToken);
-
         public void NavigateToFile()
         {
             var cancellationToken = _threadingContext.DisposalToken;
@@ -167,39 +155,70 @@ public async Task NavigateToFileAsync(CancellationToken cancellationToken)
 
         protected override IEnumerable<Inline> CreateInlines()
         {
-            yield return MakeClassifiedRun(ClassificationTypeNames.Text, _frame.GetTextBeforeType());
+            var methodDeclaration = _frame.Root.MethodDeclaration;
+            var tree = _frame.Tree;
+            var className = methodDeclaration.MemberAccessExpression.Left;
+            var classLeadingTrivia = GetLeadingTrivia(className);
+            yield return MakeClassifiedRun(ClassificationTypeNames.Text, CreateString(classLeadingTrivia));
+
+            //
+            // Build the link to the class
+            //
 
             var classLink = new Hyperlink();
-            classLink.Inlines.Add(MakeClassifiedRun(ClassificationTypeNames.ClassName, _frame.GetQualifiedTypeText()));
+            var classLinkText = className.ToString();
+            classLink.Inlines.Add(MakeClassifiedRun(ClassificationTypeNames.ClassName, classLinkText));
             classLink.Click += (s, a) => NavigateToClass();
             classLink.RequestNavigate += (s, a) => NavigateToClass();
             yield return classLink;
 
+            // Since we're only using the left side of a qualified name, we expect 
+            // there to be no trivia on the right (trailing).
+            Debug.Assert(GetTrailingTrivia(className).IsEmpty);
+
+            //
+            // Build the link to the method
+            //
             var methodLink = new Hyperlink();
-            methodLink.Inlines.Add(MakeClassifiedRun(ClassificationTypeNames.MethodName, _frame.GetMethodText()));
+            var methodTextBuilder = new StringBuilder();
+            methodTextBuilder.Append(methodDeclaration.MemberAccessExpression.DotToken.ToFullString());
+            methodTextBuilder.Append(methodDeclaration.MemberAccessExpression.Right.ToFullString());
+
+            if (methodDeclaration.TypeArguments is not null)
+            {
+                methodTextBuilder.Append(methodDeclaration.TypeArguments.ToFullString());
+            }
+
+            methodTextBuilder.Append(methodDeclaration.ArgumentList.ToFullString());
+            methodLink.Inlines.Add(MakeClassifiedRun(ClassificationTypeNames.MethodName, methodTextBuilder.ToString()));
             methodLink.Click += (s, a) => NavigateToSymbol();
             methodLink.RequestNavigate += (s, a) => NavigateToSymbol();
             yield return methodLink;
 
-            if (_frame.FileSpan != default)
+            //
+            // If there is file information build a link to that
+            //
+            if (_frame.Root.FileInformationExpression is not null)
             {
-                var textBetween = _frame.GetTextBetweenTypeAndFile();
-                if (textBetween is not null)
-                {
-                    yield return MakeClassifiedRun(ClassificationTypeNames.Text, textBetween);
-                }
-
-                var fileText = _frame.GetFileText();
-                RoslynDebug.AssertNotNull(fileText);
-
-                var fileHyperlink = new Hyperlink();
-                fileHyperlink.Inlines.Add(MakeClassifiedRun(ClassificationTypeNames.Text, fileText));
-                fileHyperlink.RequestNavigate += (s, e) => NavigateToFile();
-                fileHyperlink.Click += (s, e) => NavigateToFile();
-                yield return fileHyperlink;
+                var fileInformation = _frame.Root.FileInformationExpression;
+                var leadingTrivia = GetLeadingTrivia(fileInformation);
+                yield return MakeClassifiedRun(ClassificationTypeNames.Text, CreateString(leadingTrivia));
+
+                var fileLink = new Hyperlink();
+                var fileLinkText = _frame.Root.FileInformationExpression.ToString();
+                fileLink.Inlines.Add(MakeClassifiedRun(ClassificationTypeNames.Text, fileInformation.ToString()));
+                fileLink.Click += (s, a) => NavigateToFile();
+                fileLink.RequestNavigate += (s, a) => NavigateToFile();
+                yield return fileLink;
+
+                var trailingTrivia = GetTrailingTrivia(fileInformation);
+                yield return MakeClassifiedRun(ClassificationTypeNames.Text, CreateString(trailingTrivia));
             }
 
-            yield return MakeClassifiedRun(ClassificationTypeNames.Text, _frame.GetTrailingText());
+            //
+            // Don't lose the trailing trivia text
+            //
+            yield return MakeClassifiedRun(ClassificationTypeNames.Text, _frame.Root.EndOfLineToken.ToFullString());
         }
 
         private (Document? document, int lineNumber) GetDocumentAndLine()
@@ -209,19 +228,80 @@ protected override IEnumerable<Inline> CreateInlines()
                 return (_cachedDocument, _cachedLineNumber);
             }
 
-            (_cachedDocument, _cachedLineNumber) = _frame.GetDocumentAndLine(_workspace.CurrentSolution);
+            (_cachedDocument, _cachedLineNumber) = _stackExplorerService.GetDocumentAndLine(_workspace.CurrentSolution, _frame);
             return (_cachedDocument, _cachedLineNumber);
         }
 
-        private async Task<ISymbol?> GetSymbolAsync(CancellationToken cancellationToken)
+        private async Task<DefinitionItem?> GetDefinitionAsync(StackFrameSymbolPart symbolPart, CancellationToken cancellationToken)
+        {
+            if (_definitionCache.TryGetValue(symbolPart, out var definition) && definition is not null)
+            {
+                return definition;
+            }
+
+            _definitionCache[symbolPart] = await _stackExplorerService.TryFindDefinitionAsync(_workspace.CurrentSolution, _frame, symbolPart, cancellationToken).ConfigureAwait(false);
+            return _definitionCache[symbolPart];
+        }
+
+        private static ImmutableArray<StackFrameTrivia> GetLeadingTrivia(StackFrameNode node)
+        {
+            if (node.ChildCount == 0)
+            {
+                return ImmutableArray<StackFrameTrivia>.Empty;
+            }
+
+            var child = node[0];
+            if (child.IsNode)
+            {
+                return GetLeadingTrivia(child.Node);
+            }
+
+            return child.Token.LeadingTrivia;
+        }
+
+        private static ImmutableArray<StackFrameTrivia> GetTrailingTrivia(StackFrameNode node)
+        {
+            if (node.ChildCount == 0)
+            {
+                return ImmutableArray<StackFrameTrivia>.Empty;
+            }
+
+            var child = node[^1];
+            if (child.IsNode)
+            {
+                return GetTrailingTrivia(child.Node);
+            }
+
+            return child.Token.TrailingTrivia;
+        }
+
+        /// <summary>
+        /// Depth first traversal of the descendents of a node to the tokens
+        /// </summary>
+        private static void GetLeafTokens(StackFrameNode node, ArrayBuilder<StackFrameToken> builder)
+        {
+            foreach (var child in node)
+            {
+                if (child.IsNode)
+                {
+                    GetLeafTokens(child.Node, builder);
+                }
+                else
+                {
+                    builder.Add(child.Token);
+                }
+            }
+        }
+
+        private static string CreateString(ImmutableArray<StackFrameTrivia> triviaList)
         {
-            if (_cachedSymbol is not null)
+            using var _ = PooledStringBuilder.GetInstance(out var sb);
+            foreach (var trivia in triviaList)
             {
-                return _cachedSymbol;
+                sb.Append(trivia.ToString());
             }
 
-            _cachedSymbol = await _frame.ResolveSymbolAsync(_workspace.CurrentSolution, cancellationToken).ConfigureAwait(false);
-            return _cachedSymbol;
+            return sb.ToString();
         }
     }
 }
diff --git a/src/VisualStudio/Core/Def/StackTraceExplorer/StackTraceExplorerRootViewModel.cs b/src/VisualStudio/Core/Def/StackTraceExplorer/StackTraceExplorerRootViewModel.cs
index 8811f42992a85..5fca23a15954a 100644
--- a/src/VisualStudio/Core/Def/StackTraceExplorer/StackTraceExplorerRootViewModel.cs
+++ b/src/VisualStudio/Core/Def/StackTraceExplorer/StackTraceExplorerRootViewModel.cs
@@ -18,15 +18,13 @@ internal class StackTraceExplorerRootViewModel : ViewModelBase
         private readonly IClassificationFormatMap _formatMap;
         private readonly ClassificationTypeMap _typeMap;
         private readonly IThreadingContext _threadingContext;
-        private readonly IStreamingFindUsagesPresenter _streamingFindUsagesPresenter;
 
-        public StackTraceExplorerRootViewModel(IThreadingContext threadingContext, VisualStudioWorkspace workspace, IClassificationFormatMap formatMap, ClassificationTypeMap typeMap, IStreamingFindUsagesPresenter streamingFindUsagesPresenter)
+        public StackTraceExplorerRootViewModel(IThreadingContext threadingContext, VisualStudioWorkspace workspace, IClassificationFormatMap formatMap, ClassificationTypeMap typeMap)
         {
             _threadingContext = threadingContext;
             _workspace = workspace;
             _formatMap = formatMap;
             _typeMap = typeMap;
-            _streamingFindUsagesPresenter = streamingFindUsagesPresenter;
         }
 
         public ObservableCollection<StackTraceExplorerTab> Tabs { get; } = new();
@@ -45,7 +43,7 @@ public void AddNewTab(bool triggerPaste)
                 ? 0
                 : Tabs.Max(t => t.NameIndex);
 
-            var newTab = new StackTraceExplorerTab(_threadingContext, _workspace, _formatMap, _typeMap, _streamingFindUsagesPresenter, highestIndex + 1);
+            var newTab = new StackTraceExplorerTab(_threadingContext, _workspace, _formatMap, _typeMap, highestIndex + 1);
             Tabs.Add(newTab);
 
             SelectedTab = newTab;
diff --git a/src/VisualStudio/Core/Def/StackTraceExplorer/StackTraceExplorerTab.cs b/src/VisualStudio/Core/Def/StackTraceExplorer/StackTraceExplorerTab.cs
index 4d39bd5ba3c09..f4a3f3cc12be8 100644
--- a/src/VisualStudio/Core/Def/StackTraceExplorer/StackTraceExplorerTab.cs
+++ b/src/VisualStudio/Core/Def/StackTraceExplorer/StackTraceExplorerTab.cs
@@ -23,11 +23,11 @@ internal class StackTraceExplorerTab
         public event EventHandler? OnClosed;
         public bool IsEmpty => _stackExplorerVM.Frames.Count == 0;
 
-        public StackTraceExplorerTab(IThreadingContext threadingContext, VisualStudioWorkspace workspace, IClassificationFormatMap formatMap, ClassificationTypeMap typeMap, IStreamingFindUsagesPresenter streamingFindUsagesPresenter, int nameIndex)
+        public StackTraceExplorerTab(IThreadingContext threadingContext, VisualStudioWorkspace workspace, IClassificationFormatMap formatMap, ClassificationTypeMap typeMap, int nameIndex)
         {
             NameIndex = nameIndex;
 
-            _stackExplorerVM = new StackTraceExplorerViewModel(threadingContext, workspace, typeMap, formatMap, streamingFindUsagesPresenter);
+            _stackExplorerVM = new StackTraceExplorerViewModel(threadingContext, workspace, typeMap, formatMap);
             Content = new StackTraceExplorer(_stackExplorerVM);
 
             CloseClick = new DelegateCommand(_ =>
diff --git a/src/VisualStudio/Core/Def/StackTraceExplorer/StackTraceExplorerToolWindow.cs b/src/VisualStudio/Core/Def/StackTraceExplorer/StackTraceExplorerToolWindow.cs
index eb62ba85796b5..8554d478e502f 100644
--- a/src/VisualStudio/Core/Def/StackTraceExplorer/StackTraceExplorerToolWindow.cs
+++ b/src/VisualStudio/Core/Def/StackTraceExplorer/StackTraceExplorerToolWindow.cs
@@ -56,9 +56,8 @@ public void InitializeIfNeeded(RoslynPackage roslynPackage)
             var formatMap = formatMapService.GetClassificationFormatMap(StandardContentTypeNames.Text);
             var typeMap = roslynPackage.ComponentModel.GetService<ClassificationTypeMap>();
             var threadingContext = roslynPackage.ComponentModel.GetService<IThreadingContext>();
-            var streamingFindUsagesPresenter = roslynPackage.ComponentModel.GetService<IStreamingFindUsagesPresenter>();
 
-            Root = new StackTraceExplorerRoot(new StackTraceExplorerRootViewModel(threadingContext, workspace, formatMap, typeMap, streamingFindUsagesPresenter))
+            Root = new StackTraceExplorerRoot(new StackTraceExplorerRootViewModel(threadingContext, workspace, formatMap, typeMap))
             {
                 HorizontalAlignment = HorizontalAlignment.Stretch,
                 VerticalAlignment = VerticalAlignment.Stretch
diff --git a/src/VisualStudio/Core/Def/StackTraceExplorer/StackTraceExplorerViewModel.cs b/src/VisualStudio/Core/Def/StackTraceExplorer/StackTraceExplorerViewModel.cs
index 3500f04b6aa5d..64f6297e730de 100644
--- a/src/VisualStudio/Core/Def/StackTraceExplorer/StackTraceExplorerViewModel.cs
+++ b/src/VisualStudio/Core/Def/StackTraceExplorer/StackTraceExplorerViewModel.cs
@@ -20,7 +20,6 @@ internal class StackTraceExplorerViewModel : ViewModelBase
     {
         private readonly IThreadingContext _threadingContext;
         private readonly Workspace _workspace;
-        private readonly IStreamingFindUsagesPresenter _streamingFindUsagesPresenter;
         public ObservableCollection<FrameViewModel> Frames { get; } = new();
 
         private bool _isLoading;
@@ -50,7 +49,7 @@ internal void OnClear()
 
         public string InstructionText => ServicesVSResources.Paste_valid_stack_trace;
 
-        public StackTraceExplorerViewModel(IThreadingContext threadingContext, Workspace workspace, ClassificationTypeMap classificationTypeMap, IClassificationFormatMap formatMap, IStreamingFindUsagesPresenter streamingFindUsagesPresenter)
+        public StackTraceExplorerViewModel(IThreadingContext threadingContext, Workspace workspace, ClassificationTypeMap classificationTypeMap, IClassificationFormatMap formatMap)
         {
             _threadingContext = threadingContext;
             _workspace = workspace;
@@ -58,7 +57,6 @@ public StackTraceExplorerViewModel(IThreadingContext threadingContext, Workspace
             workspace.WorkspaceChanged += Workspace_WorkspaceChanged;
             _classificationTypeMap = classificationTypeMap;
             _formatMap = formatMap;
-            _streamingFindUsagesPresenter = streamingFindUsagesPresenter;
 
             Frames.CollectionChanged += CallstackLines_CollectionChanged;
         }
@@ -120,7 +118,7 @@ private FrameViewModel GetViewModel(ParsedFrame frame)
             => frame switch
             {
                 IgnoredFrame ignoredFrame => new IgnoredFrameViewModel(ignoredFrame, _formatMap, _classificationTypeMap),
-                ParsedStackFrame stackFrame => new StackFrameViewModel(stackFrame, _threadingContext, _workspace, _formatMap, _classificationTypeMap, _streamingFindUsagesPresenter),
+                ParsedStackFrame stackFrame => new StackFrameViewModel(stackFrame, _threadingContext, _workspace, _formatMap, _classificationTypeMap),
                 _ => throw ExceptionUtilities.UnexpectedValue(frame)
             };
     }
diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/Project.cs b/src/Workspaces/Core/Portable/Workspace/Solution/Project.cs
index 1ffe6c160f843..0c79feb8cdfe8 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/Project.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/Project.cs
@@ -344,6 +344,15 @@ internal Task<bool> ContainsSymbolsWithNameAsync(
                 cancellationToken);
         }
 
+        internal Task<bool> ContainsSymbolsWithNameAsync(
+            string name, SymbolFilter filter, CancellationToken cancellationToken)
+        {
+            return ContainsSymbolsWithNameAsync(
+                typeName => name == typeName,
+                filter,
+                cancellationToken);
+        }
+
         internal Task<bool> ContainsSymbolsWithNameAsync(
             Func<string, bool> predicate, SymbolFilter filter, CancellationToken cancellationToken)
         {
diff --git a/src/Workspaces/CoreTestUtilities/Remote/InProcRemostHostClient.cs b/src/Workspaces/CoreTestUtilities/Remote/InProcRemostHostClient.cs
index 09fb6ec54da6b..21c9d5fce8591 100644
--- a/src/Workspaces/CoreTestUtilities/Remote/InProcRemostHostClient.cs
+++ b/src/Workspaces/CoreTestUtilities/Remote/InProcRemostHostClient.cs
@@ -14,6 +14,7 @@
 using Microsoft.CodeAnalysis.EditAndContinue;
 using Microsoft.CodeAnalysis.Extensions;
 using Microsoft.CodeAnalysis.Host;
+using Microsoft.CodeAnalysis.Remote.Services.StackTraceExplorer;
 using Microsoft.CodeAnalysis.Serialization;
 using Microsoft.ServiceHub.Framework;
 using Nerdbank.Streams;
@@ -212,6 +213,7 @@ public InProcRemoteServices(HostWorkspaceServices workspaceServices, TraceListen
                 RegisterRemoteBrokeredService(new RemoteInheritanceMarginService.Factory());
                 RegisterRemoteBrokeredService(new RemoteUnusedReferenceAnalysisService.Factory());
                 RegisterRemoteBrokeredService(new RemoteCompilationAvailableService.Factory());
+                RegisterRemoteBrokeredService(new RemoteStackTraceExplorerService.Factory());
             }
 
             public void Dispose()
diff --git a/src/Workspaces/Remote/Core/RemoteWorkspacesResources.resx b/src/Workspaces/Remote/Core/RemoteWorkspacesResources.resx
index cd31b96fdf410..711236fa3ac77 100644
--- a/src/Workspaces/Remote/Core/RemoteWorkspacesResources.resx
+++ b/src/Workspaces/Remote/Core/RemoteWorkspacesResources.resx
@@ -213,4 +213,7 @@
   <data name="FeatureName_CompilationAvailable" xml:space="preserve">
     <value>Project semantics availability</value>
   </data>
+  <data name="FeatureName_StackTraceExplorer" xml:space="preserve">
+    <value>Stack Trace Explorer</value>
+  </data>
 </root>
\ No newline at end of file
diff --git a/src/Workspaces/Remote/Core/ServiceDescriptors.cs b/src/Workspaces/Remote/Core/ServiceDescriptors.cs
index 63a9ca51c3fa9..d973eb1283769 100644
--- a/src/Workspaces/Remote/Core/ServiceDescriptors.cs
+++ b/src/Workspaces/Remote/Core/ServiceDescriptors.cs
@@ -25,6 +25,7 @@
 using Microsoft.CodeAnalysis.ProjectTelemetry;
 using Microsoft.CodeAnalysis.Rename;
 using Microsoft.CodeAnalysis.Shared.TestHooks;
+using Microsoft.CodeAnalysis.StackTraceExplorer;
 using Microsoft.CodeAnalysis.SymbolSearch;
 using Microsoft.CodeAnalysis.TodoComments;
 using Microsoft.CodeAnalysis.UnusedReferences;
@@ -77,6 +78,7 @@ internal sealed class ServiceDescriptors
             (typeof(IRemoteUnusedReferenceAnalysisService), null),
             (typeof(IRemoteProcessTelemetryService), null),
             (typeof(IRemoteCompilationAvailableService), null),
+            (typeof(IRemoteStackTraceExplorerService), null),
         });
 
         internal readonly RemoteSerializationOptions Options;
diff --git a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.cs.xlf b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.cs.xlf
index 2ce3cb9933d84..bd78855426cfc 100644
--- a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.cs.xlf
+++ b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.cs.xlf
@@ -122,6 +122,11 @@
         <target state="translated">Poskytovatel prostředků</target>
         <note />
       </trans-unit>
+      <trans-unit id="FeatureName_StackTraceExplorer">
+        <source>Stack Trace Explorer</source>
+        <target state="new">Stack Trace Explorer</target>
+        <note />
+      </trans-unit>
       <trans-unit id="FeatureName_SymbolFinder">
         <source>Symbol finder</source>
         <target state="translated">Vyhledávání symbolů</target>
diff --git a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.de.xlf b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.de.xlf
index 38a3e5d875e8d..168888fab7707 100644
--- a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.de.xlf
+++ b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.de.xlf
@@ -122,6 +122,11 @@
         <target state="translated">Objektanbieter</target>
         <note />
       </trans-unit>
+      <trans-unit id="FeatureName_StackTraceExplorer">
+        <source>Stack Trace Explorer</source>
+        <target state="new">Stack Trace Explorer</target>
+        <note />
+      </trans-unit>
       <trans-unit id="FeatureName_SymbolFinder">
         <source>Symbol finder</source>
         <target state="translated">Symbolsuche</target>
diff --git a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.es.xlf b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.es.xlf
index 1d090c2418c1c..1bca7a507182e 100644
--- a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.es.xlf
+++ b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.es.xlf
@@ -122,6 +122,11 @@
         <target state="translated">Proveedor de recursos</target>
         <note />
       </trans-unit>
+      <trans-unit id="FeatureName_StackTraceExplorer">
+        <source>Stack Trace Explorer</source>
+        <target state="new">Stack Trace Explorer</target>
+        <note />
+      </trans-unit>
       <trans-unit id="FeatureName_SymbolFinder">
         <source>Symbol finder</source>
         <target state="translated">Localizador de símbolos</target>
diff --git a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.fr.xlf b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.fr.xlf
index b92556883dcfe..5007994441e27 100644
--- a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.fr.xlf
+++ b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.fr.xlf
@@ -122,6 +122,11 @@
         <target state="translated">Fournisseur de ressources</target>
         <note />
       </trans-unit>
+      <trans-unit id="FeatureName_StackTraceExplorer">
+        <source>Stack Trace Explorer</source>
+        <target state="new">Stack Trace Explorer</target>
+        <note />
+      </trans-unit>
       <trans-unit id="FeatureName_SymbolFinder">
         <source>Symbol finder</source>
         <target state="translated">Outil de recherche de symboles</target>
diff --git a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.it.xlf b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.it.xlf
index 31fa8f418e11d..f7db4bda55c9e 100644
--- a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.it.xlf
+++ b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.it.xlf
@@ -122,6 +122,11 @@
         <target state="translated">Provider di asset</target>
         <note />
       </trans-unit>
+      <trans-unit id="FeatureName_StackTraceExplorer">
+        <source>Stack Trace Explorer</source>
+        <target state="new">Stack Trace Explorer</target>
+        <note />
+      </trans-unit>
       <trans-unit id="FeatureName_SymbolFinder">
         <source>Symbol finder</source>
         <target state="translated">Strumento di ricerca simboli</target>
diff --git a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.ja.xlf b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.ja.xlf
index 31c7f52a40a82..10af9837d06e0 100644
--- a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.ja.xlf
+++ b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.ja.xlf
@@ -122,6 +122,11 @@
         <target state="translated">資産プロバイダー</target>
         <note />
       </trans-unit>
+      <trans-unit id="FeatureName_StackTraceExplorer">
+        <source>Stack Trace Explorer</source>
+        <target state="new">Stack Trace Explorer</target>
+        <note />
+      </trans-unit>
       <trans-unit id="FeatureName_SymbolFinder">
         <source>Symbol finder</source>
         <target state="translated">シンボル検索</target>
diff --git a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.ko.xlf b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.ko.xlf
index 1fe1535e4996a..d68a4690eeaae 100644
--- a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.ko.xlf
+++ b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.ko.xlf
@@ -122,6 +122,11 @@
         <target state="translated">자산 공급자</target>
         <note />
       </trans-unit>
+      <trans-unit id="FeatureName_StackTraceExplorer">
+        <source>Stack Trace Explorer</source>
+        <target state="new">Stack Trace Explorer</target>
+        <note />
+      </trans-unit>
       <trans-unit id="FeatureName_SymbolFinder">
         <source>Symbol finder</source>
         <target state="translated">기호 찾기</target>
diff --git a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.pl.xlf b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.pl.xlf
index 1237091d50e6c..ee0d9b1ce3ec1 100644
--- a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.pl.xlf
+++ b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.pl.xlf
@@ -122,6 +122,11 @@
         <target state="translated">Dostawca elementów zawartości</target>
         <note />
       </trans-unit>
+      <trans-unit id="FeatureName_StackTraceExplorer">
+        <source>Stack Trace Explorer</source>
+        <target state="new">Stack Trace Explorer</target>
+        <note />
+      </trans-unit>
       <trans-unit id="FeatureName_SymbolFinder">
         <source>Symbol finder</source>
         <target state="translated">Wyszukiwanie symboli</target>
diff --git a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.pt-BR.xlf b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.pt-BR.xlf
index 6b8f0960ac800..ebe44d5dc63bb 100644
--- a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.pt-BR.xlf
+++ b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.pt-BR.xlf
@@ -122,6 +122,11 @@
         <target state="translated">Provedor de ativos</target>
         <note />
       </trans-unit>
+      <trans-unit id="FeatureName_StackTraceExplorer">
+        <source>Stack Trace Explorer</source>
+        <target state="new">Stack Trace Explorer</target>
+        <note />
+      </trans-unit>
       <trans-unit id="FeatureName_SymbolFinder">
         <source>Symbol finder</source>
         <target state="translated">Localizador de símbolo</target>
diff --git a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.ru.xlf b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.ru.xlf
index cb64b032f222a..51136013069e6 100644
--- a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.ru.xlf
+++ b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.ru.xlf
@@ -122,6 +122,11 @@
         <target state="translated">Поставщик ресурсов</target>
         <note />
       </trans-unit>
+      <trans-unit id="FeatureName_StackTraceExplorer">
+        <source>Stack Trace Explorer</source>
+        <target state="new">Stack Trace Explorer</target>
+        <note />
+      </trans-unit>
       <trans-unit id="FeatureName_SymbolFinder">
         <source>Symbol finder</source>
         <target state="translated">Поиск символов</target>
diff --git a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.tr.xlf b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.tr.xlf
index 5b965be493fdf..4ce0b9d6f5773 100644
--- a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.tr.xlf
+++ b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.tr.xlf
@@ -122,6 +122,11 @@
         <target state="translated">Varlık sağlayıcısı</target>
         <note />
       </trans-unit>
+      <trans-unit id="FeatureName_StackTraceExplorer">
+        <source>Stack Trace Explorer</source>
+        <target state="new">Stack Trace Explorer</target>
+        <note />
+      </trans-unit>
       <trans-unit id="FeatureName_SymbolFinder">
         <source>Symbol finder</source>
         <target state="translated">Sembol bulucu</target>
diff --git a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.zh-Hans.xlf b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.zh-Hans.xlf
index a16a90460b881..69f687e043e73 100644
--- a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.zh-Hans.xlf
+++ b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.zh-Hans.xlf
@@ -122,6 +122,11 @@
         <target state="translated">资产提供商</target>
         <note />
       </trans-unit>
+      <trans-unit id="FeatureName_StackTraceExplorer">
+        <source>Stack Trace Explorer</source>
+        <target state="new">Stack Trace Explorer</target>
+        <note />
+      </trans-unit>
       <trans-unit id="FeatureName_SymbolFinder">
         <source>Symbol finder</source>
         <target state="translated">符号查找器</target>
diff --git a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.zh-Hant.xlf b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.zh-Hant.xlf
index fe19293259df0..37e5eda58f50a 100644
--- a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.zh-Hant.xlf
+++ b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.zh-Hant.xlf
@@ -122,6 +122,11 @@
         <target state="translated">資產提供者</target>
         <note />
       </trans-unit>
+      <trans-unit id="FeatureName_StackTraceExplorer">
+        <source>Stack Trace Explorer</source>
+        <target state="new">Stack Trace Explorer</target>
+        <note />
+      </trans-unit>
       <trans-unit id="FeatureName_SymbolFinder">
         <source>Symbol finder</source>
         <target state="translated">符號尋找工具</target>
diff --git a/src/Workspaces/Remote/ServiceHub/Services/StackTraceExplorer/RemoteStackTraceExplorerService.cs b/src/Workspaces/Remote/ServiceHub/Services/StackTraceExplorer/RemoteStackTraceExplorerService.cs
new file mode 100644
index 0000000000000..c1947a37c9bfb
--- /dev/null
+++ b/src/Workspaces/Remote/ServiceHub/Services/StackTraceExplorer/RemoteStackTraceExplorerService.cs
@@ -0,0 +1,48 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.Editor.StackTraceExplorer;
+using Microsoft.CodeAnalysis.EmbeddedLanguages.StackFrame;
+using Microsoft.CodeAnalysis.FindUsages;
+using Microsoft.CodeAnalysis.StackTraceExplorer;
+
+namespace Microsoft.CodeAnalysis.Remote.Services.StackTraceExplorer
+{
+    internal sealed class RemoteStackTraceExplorerService : BrokeredServiceBase, IRemoteStackTraceExplorerService
+    {
+        internal sealed class Factory : FactoryBase<IRemoteStackTraceExplorerService>
+        {
+            protected override IRemoteStackTraceExplorerService CreateService(in ServiceConstructionArguments arguments)
+                => new RemoteStackTraceExplorerService(arguments);
+        }
+
+        public RemoteStackTraceExplorerService(in ServiceConstructionArguments arguments) : base(arguments)
+        {
+        }
+
+        public ValueTask<SerializableDefinitionItem?> TryFindDefinitionAsync(PinnedSolutionInfo solutionInfo, string frameString, StackFrameSymbolPart symbolPart, CancellationToken cancellationToken)
+        {
+            return RunServiceAsync<SerializableDefinitionItem?>(async cancellationToken =>
+            {
+                var solution = await GetSolutionAsync(solutionInfo, cancellationToken).ConfigureAwait(false);
+                var result = await StackTraceAnalyzer.AnalyzeAsync(frameString, cancellationToken).ConfigureAwait(false);
+                if (result.ParsedFrames.Length != 1 || result.ParsedFrames[0] is not ParsedStackFrame parsedFrame)
+                {
+                    throw new InvalidOperationException();
+                }
+
+                var definition = await StackTraceExplorerUtilities.GetDefinitionAsync(solution, parsedFrame.Root, symbolPart, cancellationToken).ConfigureAwait(false);
+                if (definition is null)
+                {
+                    return null;
+                }
+
+                return SerializableDefinitionItem.Dehydrate(id: 0, definition);
+            }, cancellationToken);
+        }
+    }
+}
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/EmbeddedLanguages/Common/EmbeddedSyntaxNode.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/EmbeddedLanguages/Common/EmbeddedSyntaxNode.cs
index 2c5689b88beb7..67f6a99e7b86d 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/EmbeddedLanguages/Common/EmbeddedSyntaxNode.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/EmbeddedLanguages/Common/EmbeddedSyntaxNode.cs
@@ -4,7 +4,9 @@
 
 using System;
 using System.Diagnostics;
+using System.Text;
 using Microsoft.CodeAnalysis.EmbeddedLanguages.VirtualChars;
+using Microsoft.CodeAnalysis.PooledObjects;
 using Microsoft.CodeAnalysis.Text;
 
 namespace Microsoft.CodeAnalysis.EmbeddedLanguages.Common
@@ -103,6 +105,54 @@ public bool Contains(VirtualChar virtualChar)
             return false;
         }
 
+        /// <summary>
+        /// Returns the string representation of this node, not including its leading and trailing trivia.
+        /// </summary>
+        /// <returns>The string representation of this node, not including its leading and trailing trivia.</returns>
+        /// <remarks>The length of the returned string is always the same as Span.Length</remarks>
+        public override string ToString()
+        {
+            using var _ = PooledStringBuilder.GetInstance(out var sb);
+            WriteTo(sb, leading: false, trailing: false);
+            return sb.ToString();
+        }
+
+        /// <summary>
+        /// Returns full string representation of this node including its leading and trailing trivia.
+        /// </summary>
+        /// <returns>The full string representation of this node including its leading and trailing trivia.</returns>
+        /// <remarks>The length of the returned string is always the same as FullSpan.Length</remarks>
+        public string ToFullString()
+        {
+            using var _ = PooledStringBuilder.GetInstance(out var sb);
+            WriteTo(sb, leading: true, trailing: true);
+            return sb.ToString();
+        }
+
+        /// <summary>
+        /// Writes the node to a stringbuilder.
+        /// </summary>
+        /// <param name="leading">If false, leading trivia will not be added</param>
+        /// <param name="trailing">If false, trailing trivia will not be added</param>
+        public void WriteTo(StringBuilder sb, bool leading, bool trailing)
+        {
+            for (var i = 0; i < this.ChildCount; i++)
+            {
+                var child = this[i];
+                var currentLeading = leading || i > 0;
+                var curentTrailing = trailing || i < (this.ChildCount - 1);
+
+                if (child.IsNode)
+                {
+                    child.Node.WriteTo(sb, currentLeading, curentTrailing);
+                }
+                else
+                {
+                    child.Token.WriteTo(sb, currentLeading, curentTrailing);
+                }
+            }
+        }
+
         public Enumerator GetEnumerator()
             => new(this);
 
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/EmbeddedLanguages/Common/EmbeddedSyntaxToken.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/EmbeddedLanguages/Common/EmbeddedSyntaxToken.cs
index ddbeb7f618641..71718d20083fc 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/EmbeddedLanguages/Common/EmbeddedSyntaxToken.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/EmbeddedLanguages/Common/EmbeddedSyntaxToken.cs
@@ -4,7 +4,9 @@
 
 using System.Collections.Immutable;
 using System.Diagnostics;
+using System.Text;
 using Microsoft.CodeAnalysis.EmbeddedLanguages.VirtualChars;
+using Microsoft.CodeAnalysis.PooledObjects;
 using Microsoft.CodeAnalysis.Text;
 
 namespace Microsoft.CodeAnalysis.EmbeddedLanguages.Common
@@ -69,5 +71,45 @@ public EmbeddedSyntaxToken<TSyntaxKind> With(
 
         public TextSpan GetSpan()
             => EmbeddedSyntaxHelpers.GetSpan(this.VirtualChars);
+
+        public override string ToString()
+        {
+            using var _ = PooledStringBuilder.GetInstance(out var sb);
+            WriteTo(sb, leading: false, trailing: false);
+            return sb.ToString();
+        }
+
+        public string ToFullString()
+        {
+            using var _ = PooledStringBuilder.GetInstance(out var sb);
+            WriteTo(sb, leading: true, trailing: true);
+            return sb.ToString();
+        }
+
+        /// <summary>
+        /// Writes the token to a stringbuilder.
+        /// </summary>
+        /// <param name="leading">If false, leading trivia will not be added</param>
+        /// <param name="trailing">If false, trailing trivia will not be added</param>
+        public void WriteTo(StringBuilder sb, bool leading, bool trailing)
+        {
+            if (leading)
+            {
+                foreach (var trivia in LeadingTrivia)
+                {
+                    sb.Append(trivia.ToString());
+                }
+            }
+
+            sb.Append(VirtualChars.CreateString());
+
+            if (trailing)
+            {
+                foreach (var trivia in TrailingTrivia)
+                {
+                    sb.Append(trivia.ToString());
+                }
+            }
+        }
     }
 }
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/EmbeddedLanguages/Common/EmbeddedSyntaxTrivia.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/EmbeddedLanguages/Common/EmbeddedSyntaxTrivia.cs
index 7f06e3138c56e..afb1b70c9ea0d 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/EmbeddedLanguages/Common/EmbeddedSyntaxTrivia.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/EmbeddedLanguages/Common/EmbeddedSyntaxTrivia.cs
@@ -5,6 +5,7 @@
 using System.Collections.Immutable;
 using System.Diagnostics;
 using Microsoft.CodeAnalysis.EmbeddedLanguages.VirtualChars;
+using Microsoft.CodeAnalysis.Text;
 
 namespace Microsoft.CodeAnalysis.EmbeddedLanguages.Common
 {
@@ -29,5 +30,11 @@ public EmbeddedSyntaxTrivia(TSyntaxKind kind, VirtualCharSequence virtualChars,
             VirtualChars = virtualChars;
             Diagnostics = diagnostics;
         }
+
+        public TextSpan GetSpan()
+            => EmbeddedSyntaxHelpers.GetSpan(this.VirtualChars);
+
+        public override string ToString()
+            => VirtualChars.CreateString();
     }
 }

From f17419c5f71c744d07e9d15b9312cc7042983f9b Mon Sep 17 00:00:00 2001
From: David Wengier <david.wengier@microsoft.com>
Date: Thu, 2 Dec 2021 07:40:23 +1100
Subject: [PATCH 2/2] Read SourceLink info and call service to retrieve source
 from there (#57978)

---
 eng/Versions.props                            |   1 +
 .../AbstractPdbSourceDocumentTests.cs         | 303 ++++++++++++++++++
 .../NullResultMetadataAsSourceFileProvider.cs |  58 ++++
 .../PdbFileLocatorServiceTests.cs             | 101 ++++++
 .../PdbSourceDocumentLoaderServiceTests.cs    |  82 +++++
 ....NullResultMetadataAsSourceFileProvider.cs |  61 ----
 .../PdbSourceDocumentTests.cs                 | 283 +---------------
 .../TestSourceLinkService.cs                  |  45 +++
 .../Microsoft.CodeAnalysis.Features.csproj    |   1 +
 .../DocumentDebugInfoReader.cs                |  34 +-
 .../IPdbFileLocatorService.cs                 |   2 +-
 .../IPdbSourceDocumentLoaderService.cs        |   4 +-
 .../IPdbSourceDocumentLogger.cs               |  20 ++
 .../PdbSourceDocument/ISourceLinkService.cs   |  35 ++
 .../PdbFileLocatorService.cs                  |  55 +++-
 .../PdbSourceDocumentLoaderService.cs         | 137 +++++---
 ...rceDocumentMetadataAsSourceFileProvider.cs | 107 +++----
 .../PdbSourceDocument/SourceLinkMap.cs        | 229 +++++++++++++
 .../DevDivInsertionFiles.csproj               |   2 +
 19 files changed, 1099 insertions(+), 461 deletions(-)
 create mode 100644 src/EditorFeatures/CSharpTest/PdbSourceDocument/AbstractPdbSourceDocumentTests.cs
 create mode 100644 src/EditorFeatures/CSharpTest/PdbSourceDocument/NullResultMetadataAsSourceFileProvider.cs
 create mode 100644 src/EditorFeatures/CSharpTest/PdbSourceDocument/PdbFileLocatorServiceTests.cs
 create mode 100644 src/EditorFeatures/CSharpTest/PdbSourceDocument/PdbSourceDocumentLoaderServiceTests.cs
 delete mode 100644 src/EditorFeatures/CSharpTest/PdbSourceDocument/PdbSourceDocumentTests.NullResultMetadataAsSourceFileProvider.cs
 create mode 100644 src/EditorFeatures/CSharpTest/PdbSourceDocument/TestSourceLinkService.cs
 create mode 100644 src/Features/Core/Portable/PdbSourceDocument/IPdbSourceDocumentLogger.cs
 create mode 100644 src/Features/Core/Portable/PdbSourceDocument/ISourceLinkService.cs
 create mode 100644 src/Features/Core/Portable/PdbSourceDocument/SourceLinkMap.cs

diff --git a/eng/Versions.props b/eng/Versions.props
index b64b741468b2c..30018a673bb07 100644
--- a/eng/Versions.props
+++ b/eng/Versions.props
@@ -124,6 +124,7 @@
     <MicrosoftPortableTargetsVersion>0.1.2-dev</MicrosoftPortableTargetsVersion>
     <MicrosoftServiceHubClientVersion>3.1.4</MicrosoftServiceHubClientVersion>
     <MicrosoftServiceHubFrameworkVersion>3.1.4</MicrosoftServiceHubFrameworkVersion>
+    <MicrosoftSourceLinkToolsVersion>1.1.1-beta-21566-01</MicrosoftSourceLinkToolsVersion>
     <MicrosoftVisualBasicVersion>10.1.0</MicrosoftVisualBasicVersion>
     <MicrosoftVisualStudioCacheVersion>17.0.13-alpha</MicrosoftVisualStudioCacheVersion>
     <MicrosoftVisualStudioCallHierarchyPackageDefinitionsVersion>15.8.27812-alpha</MicrosoftVisualStudioCallHierarchyPackageDefinitionsVersion>
diff --git a/src/EditorFeatures/CSharpTest/PdbSourceDocument/AbstractPdbSourceDocumentTests.cs b/src/EditorFeatures/CSharpTest/PdbSourceDocument/AbstractPdbSourceDocumentTests.cs
new file mode 100644
index 0000000000000..4cc1bff1419f7
--- /dev/null
+++ b/src/EditorFeatures/CSharpTest/PdbSourceDocument/AbstractPdbSourceDocumentTests.cs
@@ -0,0 +1,303 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.Editor.UnitTests;
+using Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces;
+using Microsoft.CodeAnalysis.Emit;
+using Microsoft.CodeAnalysis.Host;
+using Microsoft.CodeAnalysis.MetadataAsSource;
+using Microsoft.CodeAnalysis.PdbSourceDocument;
+using Microsoft.CodeAnalysis.Shared.Extensions;
+using Microsoft.CodeAnalysis.Test.Utilities;
+using Microsoft.CodeAnalysis.Text;
+using Roslyn.Test.Utilities;
+using Roslyn.Utilities;
+using Xunit;
+
+namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.PdbSourceDocument
+{
+    [UseExportProvider]
+    public abstract class AbstractPdbSourceDocumentTests
+    {
+        public enum Location
+        {
+            OnDisk,
+            Embedded
+        }
+
+        protected static Task TestAsync(
+            Location pdbLocation,
+            Location sourceLocation,
+            string metadataSource,
+            Func<Compilation, ISymbol> symbolMatcher,
+            string[]? preprocessorSymbols = null,
+            bool buildReferenceAssembly = false,
+            bool expectNullResult = false)
+        {
+            return RunTestAsync(path => TestAsync(
+                path,
+                pdbLocation,
+                sourceLocation,
+                metadataSource,
+                symbolMatcher,
+                preprocessorSymbols,
+                buildReferenceAssembly,
+                expectNullResult));
+        }
+
+        protected static async Task RunTestAsync(Func<string, Task> testRunner)
+        {
+            var path = Path.Combine(Path.GetTempPath(), nameof(PdbSourceDocumentTests));
+
+            try
+            {
+                Directory.CreateDirectory(path);
+
+                await testRunner(path);
+            }
+            finally
+            {
+                if (Directory.Exists(path))
+                {
+                    Directory.Delete(path, recursive: true);
+                }
+            }
+        }
+
+        protected static async Task TestAsync(
+            string path,
+            Location pdbLocation,
+            Location sourceLocation,
+            string metadataSource,
+            Func<Compilation, ISymbol> symbolMatcher,
+            string[]? preprocessorSymbols,
+            bool buildReferenceAssembly,
+            bool expectNullResult)
+        {
+            MarkupTestFile.GetSpan(metadataSource, out var source, out var expectedSpan);
+
+            var (project, symbol) = await CompileAndFindSymbolAsync(
+                path,
+                pdbLocation,
+                sourceLocation,
+                source,
+                symbolMatcher,
+                preprocessorSymbols,
+                buildReferenceAssembly,
+                windowsPdb: false);
+
+            await GenerateFileAndVerifyAsync(project, symbol, source, expectedSpan, expectNullResult);
+        }
+
+        protected static async Task GenerateFileAndVerifyAsync(
+            Project project,
+            ISymbol symbol,
+            string expected,
+            Text.TextSpan expectedSpan,
+            bool expectNullResult)
+        {
+            var (actual, actualSpan) = await GetGeneratedSourceTextAsync(project, symbol, expectNullResult);
+
+            if (actual is null)
+                return;
+
+            // Compare exact texts and verify that the location returned is exactly that
+            // indicated by expected
+            AssertEx.EqualOrDiff(expected, actual.ToString());
+            Assert.Equal(expectedSpan.Start, actualSpan.Start);
+            Assert.Equal(expectedSpan.End, actualSpan.End);
+        }
+
+        protected static async Task<(SourceText?, TextSpan)> GetGeneratedSourceTextAsync(
+            Project project,
+            ISymbol symbol,
+            bool expectNullResult)
+        {
+            using var workspace = (TestWorkspace)project.Solution.Workspace;
+
+            var service = workspace.GetService<IMetadataAsSourceFileService>();
+            try
+            {
+                var file = await service.GetGeneratedFileAsync(project, symbol, signaturesOnly: false, allowDecompilation: false, CancellationToken.None).ConfigureAwait(false);
+
+                if (expectNullResult)
+                {
+                    Assert.Same(NullResultMetadataAsSourceFileProvider.NullResult, file);
+                    return (null, default);
+                }
+                else
+                {
+                    Assert.NotSame(NullResultMetadataAsSourceFileProvider.NullResult, file);
+                }
+
+                AssertEx.NotNull(file, $"No source document was found in the pdb for the symbol.");
+
+                var masWorkspace = service.TryGetWorkspace();
+
+                var document = masWorkspace!.CurrentSolution.Projects.First().Documents.First();
+
+                Assert.Equal(document.FilePath, file.FilePath);
+
+                var actual = await document.GetTextAsync();
+                var actualSpan = file!.IdentifierLocation.SourceSpan;
+
+                return (actual, actualSpan);
+            }
+            finally
+            {
+                service.CleanupGeneratedFiles();
+                service.TryGetWorkspace()?.Dispose();
+            }
+        }
+
+        protected static Task<(Project, ISymbol)> CompileAndFindSymbolAsync(
+            string path,
+            Location pdbLocation,
+            Location sourceLocation,
+            string source,
+            Func<Compilation, ISymbol> symbolMatcher,
+            string[]? preprocessorSymbols = null,
+            bool buildReferenceAssembly = false,
+            bool windowsPdb = false,
+            Encoding? encoding = null)
+        {
+            var sourceText = SourceText.From(source, encoding: encoding ?? Encoding.UTF8);
+            return CompileAndFindSymbolAsync(path, pdbLocation, sourceLocation, sourceText, symbolMatcher, preprocessorSymbols, buildReferenceAssembly, windowsPdb);
+        }
+
+        protected static async Task<(Project, ISymbol)> CompileAndFindSymbolAsync(
+            string path,
+            Location pdbLocation,
+            Location sourceLocation,
+            SourceText source,
+            Func<Compilation, ISymbol> symbolMatcher,
+            string[]? preprocessorSymbols = null,
+            bool buildReferenceAssembly = false,
+            bool windowsPdb = false,
+            Encoding? fallbackEncoding = null)
+        {
+            var preprocessorSymbolsAttribute = preprocessorSymbols?.Length > 0
+                ? $"PreprocessorSymbols=\"{string.Join(";", preprocessorSymbols)}\""
+                : "";
+
+            // We construct our own composition here because we only want the decompilation metadata as source provider
+            // to be available.
+            var composition = EditorTestCompositions.EditorFeatures
+                .WithExcludedPartTypes(ImmutableHashSet.Create(typeof(IMetadataAsSourceFileProvider)))
+                .AddParts(typeof(PdbSourceDocumentMetadataAsSourceFileProvider), typeof(NullResultMetadataAsSourceFileProvider));
+
+            var workspace = TestWorkspace.Create(@$"
+<Workspace>
+    <Project Language=""{LanguageNames.CSharp}"" CommonReferences=""true"" ReferencesOnDisk=""true"" {preprocessorSymbolsAttribute}>
+    </Project>
+</Workspace>", composition: composition);
+
+            var project = workspace.CurrentSolution.Projects.First();
+
+            CompileTestSource(path, source, project, pdbLocation, sourceLocation, buildReferenceAssembly, windowsPdb, fallbackEncoding);
+
+            project = project.AddMetadataReference(MetadataReference.CreateFromFile(GetDllPath(path)));
+
+            var mainCompilation = await project.GetRequiredCompilationAsync(CancellationToken.None).ConfigureAwait(false);
+
+            var symbol = symbolMatcher(mainCompilation);
+
+            AssertEx.NotNull(symbol, $"Couldn't find symbol to go-to-def for.");
+
+            return (project, symbol);
+        }
+
+        protected static void CompileTestSource(string path, SourceText source, Project project, Location pdbLocation, Location sourceLocation, bool buildReferenceAssembly, bool windowsPdb, Encoding? fallbackEncoding = null)
+        {
+            var dllFilePath = GetDllPath(path);
+            var sourceCodePath = GetSourceFilePath(path);
+            var pdbFilePath = GetPdbPath(path);
+
+            var assemblyName = "ReferencedAssembly";
+
+            var languageServices = project.Solution.Workspace.Services.GetLanguageServices(LanguageNames.CSharp);
+            var compilationFactory = languageServices.GetRequiredService<ICompilationFactoryService>();
+            var options = compilationFactory.GetDefaultCompilationOptions().WithOutputKind(OutputKind.DynamicallyLinkedLibrary);
+            var parseOptions = project.ParseOptions;
+
+            var compilation = compilationFactory
+                .CreateCompilation(assemblyName, options)
+                .AddSyntaxTrees(SyntaxFactory.ParseSyntaxTree(source, options: parseOptions, path: sourceCodePath))
+                .AddReferences(project.MetadataReferences);
+
+            IEnumerable<EmbeddedText>? embeddedTexts;
+            if (sourceLocation == Location.OnDisk)
+            {
+                embeddedTexts = null;
+                File.WriteAllText(sourceCodePath, source.ToString(), source.Encoding);
+            }
+            else
+            {
+                embeddedTexts = new[] { EmbeddedText.FromSource(sourceCodePath, source) };
+            }
+
+            EmitOptions emitOptions;
+            if (buildReferenceAssembly)
+            {
+                pdbFilePath = null;
+                emitOptions = new EmitOptions(metadataOnly: true, includePrivateMembers: false);
+            }
+            else if (pdbLocation == Location.OnDisk)
+            {
+                emitOptions = new EmitOptions(debugInformationFormat: DebugInformationFormat.PortablePdb, pdbFilePath: pdbFilePath);
+            }
+            else
+            {
+                pdbFilePath = null;
+                emitOptions = new EmitOptions(debugInformationFormat: DebugInformationFormat.Embedded);
+            }
+
+            // TODO: When supported, move this to pdbLocation
+            if (windowsPdb)
+            {
+                emitOptions = emitOptions.WithDebugInformationFormat(DebugInformationFormat.Pdb);
+            }
+
+            if (fallbackEncoding is null)
+            {
+                emitOptions = emitOptions.WithDefaultSourceFileEncoding(source.Encoding);
+            }
+            else
+            {
+                emitOptions = emitOptions.WithFallbackSourceFileEncoding(fallbackEncoding);
+            }
+
+            using (var dllStream = FileUtilities.CreateFileStreamChecked(File.Create, dllFilePath, nameof(dllFilePath)))
+            using (var pdbStream = (pdbFilePath == null ? null : FileUtilities.CreateFileStreamChecked(File.Create, pdbFilePath, nameof(pdbFilePath))))
+            {
+                var result = compilation.Emit(dllStream, pdbStream, options: emitOptions, embeddedTexts: embeddedTexts);
+                Assert.Empty(result.Diagnostics.Where(d => d.Severity == DiagnosticSeverity.Error));
+            }
+        }
+
+        protected static string GetDllPath(string path)
+        {
+            return Path.Combine(path, "reference.dll");
+        }
+
+        protected static string GetSourceFilePath(string path)
+        {
+            return Path.Combine(path, "source.cs");
+        }
+
+        protected static string GetPdbPath(string path)
+        {
+            return Path.Combine(path, "reference.pdb");
+        }
+    }
+}
diff --git a/src/EditorFeatures/CSharpTest/PdbSourceDocument/NullResultMetadataAsSourceFileProvider.cs b/src/EditorFeatures/CSharpTest/PdbSourceDocument/NullResultMetadataAsSourceFileProvider.cs
new file mode 100644
index 0000000000000..f37ca191fad10
--- /dev/null
+++ b/src/EditorFeatures/CSharpTest/PdbSourceDocument/NullResultMetadataAsSourceFileProvider.cs
@@ -0,0 +1,58 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Composition;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.Host.Mef;
+using Microsoft.CodeAnalysis.MetadataAsSource;
+using Microsoft.CodeAnalysis.PdbSourceDocument;
+
+namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.PdbSourceDocument
+{
+    /// <summary>
+    /// IMetadataAsSourceFileService has to always return a result, but for our testing
+    /// we remove the decompilation provider that would normally ensure that. This provider
+    /// takes it place to ensure we always return a known null result, so we can also verify
+    /// against it in tests.
+    /// </summary>
+    [ExportMetadataAsSourceFileProvider("Dummy"), Shared]
+    [ExtensionOrder(After = PdbSourceDocumentMetadataAsSourceFileProvider.ProviderName)]
+    internal class NullResultMetadataAsSourceFileProvider : IMetadataAsSourceFileProvider
+    {
+        // Represents a null result
+        public static MetadataAsSourceFile NullResult = new("", null, null, null);
+
+        [ImportingConstructor]
+        [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
+        public NullResultMetadataAsSourceFileProvider()
+        {
+        }
+
+        public void CleanupGeneratedFiles(Workspace? workspace)
+        {
+        }
+
+        public Task<MetadataAsSourceFile?> GetGeneratedFileAsync(Workspace workspace, Project project, ISymbol symbol, bool signaturesOnly, bool allowDecompilation, string tempPath, CancellationToken cancellationToken)
+        {
+            return Task.FromResult<MetadataAsSourceFile?>(NullResult);
+        }
+
+        public Project? MapDocument(Document document)
+        {
+            return null;
+        }
+
+        public bool TryAddDocumentToWorkspace(Workspace workspace, string filePath, Text.SourceTextContainer sourceTextContainer)
+        {
+            return true;
+        }
+
+        public bool TryRemoveDocumentFromWorkspace(Workspace workspace, string filePath)
+        {
+            return true;
+        }
+    }
+}
diff --git a/src/EditorFeatures/CSharpTest/PdbSourceDocument/PdbFileLocatorServiceTests.cs b/src/EditorFeatures/CSharpTest/PdbSourceDocument/PdbFileLocatorServiceTests.cs
new file mode 100644
index 0000000000000..872a5f14cbd59
--- /dev/null
+++ b/src/EditorFeatures/CSharpTest/PdbSourceDocument/PdbFileLocatorServiceTests.cs
@@ -0,0 +1,101 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.CSharp.UnitTests;
+using Microsoft.CodeAnalysis.PdbSourceDocument;
+using Roslyn.Test.Utilities;
+using Xunit;
+
+namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.PdbSourceDocument
+{
+    public class PdbFileLocatorServiceTests : AbstractPdbSourceDocumentTests
+    {
+        [Fact]
+        public async Task ReturnsPdbPathFromDebugger()
+        {
+            var source = @"
+public class C
+{
+    public event System.EventHandler [|E|] { add { } remove { } }
+}";
+
+            await RunTestAsync(async path =>
+            {
+                MarkupTestFile.GetSpan(source, out var metadataSource, out var expectedSpan);
+
+                var (project, symbol) = await CompileAndFindSymbolAsync(path, Location.OnDisk, Location.OnDisk, metadataSource, c => c.GetMember("C.E"));
+
+                // Move the PDB to a path that only our fake debugger service knows about
+                var pdbFilePath = Path.Combine(path, "SourceLink.pdb");
+                File.Move(GetPdbPath(path), pdbFilePath);
+
+                var sourceLinkService = new TestSourceLinkService(pdbFilePath: pdbFilePath);
+                var service = new PdbFileLocatorService(sourceLinkService);
+
+                using var result = await service.GetDocumentDebugInfoReaderAsync(GetDllPath(path), logger: null, CancellationToken.None);
+
+                Assert.NotNull(result);
+            });
+        }
+
+        [Fact]
+        public async Task DoesntReadNonPortablePdbs()
+        {
+            var source = @"
+public class C
+{
+    public event System.EventHandler [|E|] { add { } remove { } }
+}";
+
+            await RunTestAsync(async path =>
+            {
+                MarkupTestFile.GetSpan(source, out var metadataSource, out var expectedSpan);
+
+                var (project, symbol) = await CompileAndFindSymbolAsync(path, Location.OnDisk, Location.OnDisk, metadataSource, c => c.GetMember("C.E"));
+
+                // Move the PDB to a path that only our fake debugger service knows about
+                var pdbFilePath = Path.Combine(path, "SourceLink.pdb");
+                File.Move(GetPdbPath(path), pdbFilePath);
+
+                var sourceLinkService = new TestSourceLinkService(pdbFilePath: pdbFilePath, isPortablePdb: false);
+                var service = new PdbFileLocatorService(sourceLinkService);
+
+                using var result = await service.GetDocumentDebugInfoReaderAsync(GetDllPath(path), logger: null, CancellationToken.None);
+
+                Assert.Null(result);
+            });
+        }
+
+        [Fact]
+        public async Task NoPdbFoundReturnsNull()
+        {
+            var source = @"
+public class C
+{
+    public event System.EventHandler [|E|] { add { } remove { } }
+}";
+
+            await RunTestAsync(async path =>
+            {
+                MarkupTestFile.GetSpan(source, out var metadataSource, out var expectedSpan);
+
+                var (project, symbol) = await CompileAndFindSymbolAsync(path, Location.OnDisk, Location.OnDisk, metadataSource, c => c.GetMember("C.E"));
+
+                // Move the PDB to a path that only our fake debugger service knows about
+                var pdbFilePath = Path.Combine(path, "SourceLink.pdb");
+                File.Move(GetPdbPath(path), pdbFilePath);
+
+                var sourceLinkService = new TestSourceLinkService(pdbFilePath: null);
+                var service = new PdbFileLocatorService(sourceLinkService);
+
+                using var result = await service.GetDocumentDebugInfoReaderAsync(GetDllPath(path), logger: null, CancellationToken.None);
+
+                Assert.Null(result);
+            });
+        }
+    }
+}
diff --git a/src/EditorFeatures/CSharpTest/PdbSourceDocument/PdbSourceDocumentLoaderServiceTests.cs b/src/EditorFeatures/CSharpTest/PdbSourceDocument/PdbSourceDocumentLoaderServiceTests.cs
new file mode 100644
index 0000000000000..e24ab6bd694c3
--- /dev/null
+++ b/src/EditorFeatures/CSharpTest/PdbSourceDocument/PdbSourceDocumentLoaderServiceTests.cs
@@ -0,0 +1,82 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections.Immutable;
+using System.IO;
+using System.Security.Cryptography;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.CSharp.UnitTests;
+using Microsoft.CodeAnalysis.PdbSourceDocument;
+using Roslyn.Test.Utilities;
+using Xunit;
+
+namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.PdbSourceDocument
+{
+    public class PdbSourceDocumentLoaderServiceTests : AbstractPdbSourceDocumentTests
+    {
+        [Fact]
+        public async Task ReturnsSourceFileFromSourceLink()
+        {
+            var source = @"
+public class C
+{
+    public event System.EventHandler [|E|] { add { } remove { } }
+}";
+
+            await RunTestAsync(async path =>
+            {
+                MarkupTestFile.GetSpan(source, out var metadataSource, out var expectedSpan);
+
+                var (project, symbol) = await CompileAndFindSymbolAsync(path, Location.OnDisk, Location.OnDisk, metadataSource, c => c.GetMember("C.E"));
+
+                // Move the source file to a path that only our fake debugger service knows about
+                var sourceFilePath = Path.Combine(path, "SourceLink.cs");
+                File.Move(GetSourceFilePath(path), sourceFilePath);
+
+                var sourceLinkService = new TestSourceLinkService(sourceFilePath: sourceFilePath);
+                var service = new PdbSourceDocumentLoaderService(sourceLinkService);
+
+                using var hash = SHA256.Create();
+                var fileHash = hash.ComputeHash(File.ReadAllBytes(sourceFilePath));
+
+                var sourceDocument = new SourceDocument("goo.cs", Text.SourceHashAlgorithm.Sha256, fileHash.ToImmutableArray(), null, "https://sourcelink");
+                var result = await service.LoadSourceDocumentAsync(path, sourceDocument, Encoding.UTF8, logger: null, CancellationToken.None);
+
+                Assert.NotNull(result);
+                Assert.Equal(sourceFilePath, result!.FilePath);
+            });
+        }
+
+        [Fact]
+        public async Task NoUrlFoundReturnsNull()
+        {
+            var source = @"
+public class C
+{
+    public event System.EventHandler [|E|] { add { } remove { } }
+}";
+
+            await RunTestAsync(async path =>
+            {
+                MarkupTestFile.GetSpan(source, out var metadataSource, out var expectedSpan);
+
+                var (project, symbol) = await CompileAndFindSymbolAsync(path, Location.OnDisk, Location.OnDisk, metadataSource, c => c.GetMember("C.E"));
+
+                // Move the source file to a path that only our fake debugger service knows about
+                var sourceFilePath = Path.Combine(path, "SourceLink.cs");
+                File.Move(GetSourceFilePath(path), sourceFilePath);
+
+                var sourceLinkService = new TestSourceLinkService(sourceFilePath: sourceFilePath);
+                var service = new PdbSourceDocumentLoaderService(sourceLinkService);
+
+                var sourceDocument = new SourceDocument("goo.cs", Text.SourceHashAlgorithm.None, default, null, SourceLinkUrl: null);
+                var result = await service.LoadSourceDocumentAsync(path, sourceDocument, Encoding.UTF8, logger: null, CancellationToken.None);
+
+                Assert.Null(result);
+            });
+        }
+    }
+}
diff --git a/src/EditorFeatures/CSharpTest/PdbSourceDocument/PdbSourceDocumentTests.NullResultMetadataAsSourceFileProvider.cs b/src/EditorFeatures/CSharpTest/PdbSourceDocument/PdbSourceDocumentTests.NullResultMetadataAsSourceFileProvider.cs
deleted file mode 100644
index 822ffbc639b8f..0000000000000
--- a/src/EditorFeatures/CSharpTest/PdbSourceDocument/PdbSourceDocumentTests.NullResultMetadataAsSourceFileProvider.cs
+++ /dev/null
@@ -1,61 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-using System;
-using System.Composition;
-using System.Threading;
-using System.Threading.Tasks;
-using Microsoft.CodeAnalysis.Host.Mef;
-using Microsoft.CodeAnalysis.MetadataAsSource;
-using Microsoft.CodeAnalysis.PdbSourceDocument;
-
-namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.PdbSourceDocument
-{
-    public partial class PdbSourceDocumentTests
-    {
-        /// <summary>
-        /// IMetadataAsSourceFileService has to always return a result, but for our testing
-        /// we remove the decompilation provider that would normally ensure that. This provider
-        /// takes it place to ensure we always return a known null result, so we can also verify
-        /// against it in tests.
-        /// </summary>
-        [ExportMetadataAsSourceFileProvider("Dummy"), Shared]
-        [ExtensionOrder(After = PdbSourceDocumentMetadataAsSourceFileProvider.ProviderName)]
-        internal class NullResultMetadataAsSourceFileProvider : IMetadataAsSourceFileProvider
-        {
-            // Represents a null result
-            public static MetadataAsSourceFile NullResult = new("", null, null, null);
-
-            [ImportingConstructor]
-            [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
-            public NullResultMetadataAsSourceFileProvider()
-            {
-            }
-
-            public void CleanupGeneratedFiles(Workspace? workspace)
-            {
-            }
-
-            public Task<MetadataAsSourceFile?> GetGeneratedFileAsync(Workspace workspace, Project project, ISymbol symbol, bool signaturesOnly, bool allowDecompilation, string tempPath, CancellationToken cancellationToken)
-            {
-                return Task.FromResult<MetadataAsSourceFile?>(NullResult);
-            }
-
-            public Project? MapDocument(Document document)
-            {
-                return null;
-            }
-
-            public bool TryAddDocumentToWorkspace(Workspace workspace, string filePath, Text.SourceTextContainer sourceTextContainer)
-            {
-                return true;
-            }
-
-            public bool TryRemoveDocumentFromWorkspace(Workspace workspace, string filePath)
-            {
-                return true;
-            }
-        }
-    }
-}
diff --git a/src/EditorFeatures/CSharpTest/PdbSourceDocument/PdbSourceDocumentTests.cs b/src/EditorFeatures/CSharpTest/PdbSourceDocument/PdbSourceDocumentTests.cs
index 93081ad9d0e81..16c13ec0302a8 100644
--- a/src/EditorFeatures/CSharpTest/PdbSourceDocument/PdbSourceDocumentTests.cs
+++ b/src/EditorFeatures/CSharpTest/PdbSourceDocument/PdbSourceDocumentTests.cs
@@ -2,22 +2,11 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-using System;
-using System.Collections.Generic;
-using System.Collections.Immutable;
 using System.IO;
 using System.Linq;
 using System.Text;
-using System.Threading;
 using System.Threading.Tasks;
-using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.UnitTests;
-using Microsoft.CodeAnalysis.Editor.UnitTests;
-using Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces;
-using Microsoft.CodeAnalysis.Emit;
-using Microsoft.CodeAnalysis.Host;
-using Microsoft.CodeAnalysis.MetadataAsSource;
-using Microsoft.CodeAnalysis.PdbSourceDocument;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 using Microsoft.CodeAnalysis.Test.Utilities;
 using Microsoft.CodeAnalysis.Text;
@@ -27,15 +16,8 @@
 
 namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.PdbSourceDocument
 {
-    [UseExportProvider]
-    public partial class PdbSourceDocumentTests
+    public partial class PdbSourceDocumentTests : AbstractPdbSourceDocumentTests
     {
-        public enum Location
-        {
-            OnDisk,
-            Embedded
-        }
-
         [Theory]
         [CombinatorialData]
         public async Task PreprocessorSymbols1(Location pdbLocation, Location sourceLocation)
@@ -693,268 +675,5 @@ await RunTestAsync(async path =>
                 AssertEx.EqualOrDiff(source, actualText.ToString());
             });
         }
-
-        private static Task TestAsync(
-            Location pdbLocation,
-            Location sourceLocation,
-            string metadataSource,
-            Func<Compilation, ISymbol> symbolMatcher,
-            string[]? preprocessorSymbols = null,
-            bool buildReferenceAssembly = false,
-            bool expectNullResult = false)
-        {
-            return RunTestAsync(path => TestAsync(
-                path,
-                pdbLocation,
-                sourceLocation,
-                metadataSource,
-                symbolMatcher,
-                preprocessorSymbols,
-                buildReferenceAssembly,
-                expectNullResult));
-        }
-
-        private static async Task RunTestAsync(Func<string, Task> testRunner)
-        {
-            var path = Path.Combine(Path.GetTempPath(), nameof(PdbSourceDocumentTests));
-
-            try
-            {
-                Directory.CreateDirectory(path);
-
-                await testRunner(path);
-            }
-            finally
-            {
-                if (Directory.Exists(path))
-                {
-                    Directory.Delete(path, recursive: true);
-                }
-            }
-        }
-
-        private static async Task TestAsync(
-            string path,
-            Location pdbLocation,
-            Location sourceLocation,
-            string metadataSource,
-            Func<Compilation, ISymbol> symbolMatcher,
-            string[]? preprocessorSymbols,
-            bool buildReferenceAssembly,
-            bool expectNullResult)
-        {
-            MarkupTestFile.GetSpan(metadataSource, out var source, out var expectedSpan);
-
-            var (project, symbol) = await CompileAndFindSymbolAsync(
-                path,
-                pdbLocation,
-                sourceLocation,
-                source,
-                symbolMatcher,
-                preprocessorSymbols,
-                buildReferenceAssembly,
-                windowsPdb: false);
-
-            await GenerateFileAndVerifyAsync(project, symbol, source, expectedSpan, expectNullResult);
-        }
-
-        private static async Task GenerateFileAndVerifyAsync(
-            Project project,
-            ISymbol symbol,
-            string expected,
-            Text.TextSpan expectedSpan,
-            bool expectNullResult)
-        {
-            var (actual, actualSpan) = await GetGeneratedSourceTextAsync(project, symbol, expectNullResult);
-
-            if (actual is null)
-                return;
-
-            // Compare exact texts and verify that the location returned is exactly that
-            // indicated by expected
-            AssertEx.EqualOrDiff(expected, actual.ToString());
-            Assert.Equal(expectedSpan.Start, actualSpan.Start);
-            Assert.Equal(expectedSpan.End, actualSpan.End);
-        }
-
-        private static async Task<(SourceText?, TextSpan)> GetGeneratedSourceTextAsync(
-            Project project,
-            ISymbol symbol,
-            bool expectNullResult)
-        {
-            using var workspace = (TestWorkspace)project.Solution.Workspace;
-
-            var service = workspace.GetService<IMetadataAsSourceFileService>();
-            try
-            {
-                var file = await service.GetGeneratedFileAsync(project, symbol, signaturesOnly: false, allowDecompilation: false, CancellationToken.None).ConfigureAwait(false);
-
-                if (expectNullResult)
-                {
-                    Assert.Same(NullResultMetadataAsSourceFileProvider.NullResult, file);
-                    return (null, default);
-                }
-                else
-                {
-                    Assert.NotSame(NullResultMetadataAsSourceFileProvider.NullResult, file);
-                }
-
-                AssertEx.NotNull(file, $"No source document was found in the pdb for the symbol.");
-
-                var masWorkspace = service.TryGetWorkspace();
-
-                var document = masWorkspace!.CurrentSolution.Projects.First().Documents.First();
-
-                var actual = await document.GetTextAsync();
-                var actualSpan = file!.IdentifierLocation.SourceSpan;
-
-                return (actual, actualSpan);
-            }
-            finally
-            {
-                service.CleanupGeneratedFiles();
-                service.TryGetWorkspace()?.Dispose();
-            }
-        }
-
-        private static Task<(Project, ISymbol)> CompileAndFindSymbolAsync(
-            string path,
-            Location pdbLocation,
-            Location sourceLocation,
-            string source,
-            Func<Compilation, ISymbol> symbolMatcher,
-            string[]? preprocessorSymbols = null,
-            bool buildReferenceAssembly = false,
-            bool windowsPdb = false,
-            Encoding? encoding = null)
-        {
-            var sourceText = SourceText.From(source, encoding: encoding ?? Encoding.UTF8);
-            return CompileAndFindSymbolAsync(path, pdbLocation, sourceLocation, sourceText, symbolMatcher, preprocessorSymbols, buildReferenceAssembly, windowsPdb);
-        }
-
-        private static async Task<(Project, ISymbol)> CompileAndFindSymbolAsync(
-            string path,
-            Location pdbLocation,
-            Location sourceLocation,
-            SourceText source,
-            Func<Compilation, ISymbol> symbolMatcher,
-            string[]? preprocessorSymbols = null,
-            bool buildReferenceAssembly = false,
-            bool windowsPdb = false,
-            Encoding? fallbackEncoding = null)
-        {
-            var preprocessorSymbolsAttribute = preprocessorSymbols?.Length > 0
-                ? $"PreprocessorSymbols=\"{string.Join(";", preprocessorSymbols)}\""
-                : "";
-
-            // We construct our own composition here because we only want the decompilation metadata as source provider
-            // to be available.
-            var composition = EditorTestCompositions.EditorFeatures
-                .WithExcludedPartTypes(ImmutableHashSet.Create(typeof(IMetadataAsSourceFileProvider)))
-                .AddParts(typeof(PdbSourceDocumentMetadataAsSourceFileProvider), typeof(NullResultMetadataAsSourceFileProvider));
-
-            var workspace = TestWorkspace.Create(@$"
-<Workspace>
-    <Project Language=""{LanguageNames.CSharp}"" CommonReferences=""true"" ReferencesOnDisk=""true"" {preprocessorSymbolsAttribute}>
-    </Project>
-</Workspace>", composition: composition);
-
-            var project = workspace.CurrentSolution.Projects.First();
-
-            CompileTestSource(path, source, project, pdbLocation, sourceLocation, buildReferenceAssembly, windowsPdb, fallbackEncoding);
-
-            project = project.AddMetadataReference(MetadataReference.CreateFromFile(GetDllPath(path)));
-
-            var mainCompilation = await project.GetRequiredCompilationAsync(CancellationToken.None).ConfigureAwait(false);
-
-            var symbol = symbolMatcher(mainCompilation);
-
-            AssertEx.NotNull(symbol, $"Couldn't find symbol to go-to-def for.");
-
-            return (project, symbol);
-        }
-
-        private static void CompileTestSource(string path, SourceText source, Project project, Location pdbLocation, Location sourceLocation, bool buildReferenceAssembly, bool windowsPdb, Encoding? fallbackEncoding = null)
-        {
-            var dllFilePath = GetDllPath(path);
-            var sourceCodePath = GetSourceFilePath(path);
-            var pdbFilePath = GetPdbPath(path);
-
-            var assemblyName = "ReferencedAssembly";
-
-            var languageServices = project.Solution.Workspace.Services.GetLanguageServices(LanguageNames.CSharp);
-            var compilationFactory = languageServices.GetRequiredService<ICompilationFactoryService>();
-            var options = compilationFactory.GetDefaultCompilationOptions().WithOutputKind(OutputKind.DynamicallyLinkedLibrary);
-            var parseOptions = project.ParseOptions;
-
-            var compilation = compilationFactory
-                .CreateCompilation(assemblyName, options)
-                .AddSyntaxTrees(SyntaxFactory.ParseSyntaxTree(source, options: parseOptions, path: sourceCodePath))
-                .AddReferences(project.MetadataReferences);
-
-            IEnumerable<EmbeddedText>? embeddedTexts;
-            if (sourceLocation == Location.OnDisk)
-            {
-                embeddedTexts = null;
-                File.WriteAllText(sourceCodePath, source.ToString(), source.Encoding);
-            }
-            else
-            {
-                embeddedTexts = new[] { EmbeddedText.FromSource(sourceCodePath, source) };
-            }
-
-            EmitOptions emitOptions;
-            if (buildReferenceAssembly)
-            {
-                pdbFilePath = null;
-                emitOptions = new EmitOptions(metadataOnly: true, includePrivateMembers: false);
-            }
-            else if (pdbLocation == Location.OnDisk)
-            {
-                emitOptions = new EmitOptions(debugInformationFormat: DebugInformationFormat.PortablePdb, pdbFilePath: pdbFilePath);
-            }
-            else
-            {
-                pdbFilePath = null;
-                emitOptions = new EmitOptions(debugInformationFormat: DebugInformationFormat.Embedded);
-            }
-
-            // TODO: When supported, move this to pdbLocation
-            if (windowsPdb)
-            {
-                emitOptions = emitOptions.WithDebugInformationFormat(DebugInformationFormat.Pdb);
-            }
-
-            if (fallbackEncoding is null)
-            {
-                emitOptions = emitOptions.WithDefaultSourceFileEncoding(source.Encoding);
-            }
-            else
-            {
-                emitOptions = emitOptions.WithFallbackSourceFileEncoding(fallbackEncoding);
-            }
-
-            using (var dllStream = FileUtilities.CreateFileStreamChecked(File.Create, dllFilePath, nameof(dllFilePath)))
-            using (var pdbStream = (pdbFilePath == null ? null : FileUtilities.CreateFileStreamChecked(File.Create, pdbFilePath, nameof(pdbFilePath))))
-            {
-                var result = compilation.Emit(dllStream, pdbStream, options: emitOptions, embeddedTexts: embeddedTexts);
-                Assert.Empty(result.Diagnostics.Where(d => d.Severity == DiagnosticSeverity.Error));
-            }
-        }
-
-        private static string GetDllPath(string path)
-        {
-            return Path.Combine(path, "reference.dll");
-        }
-
-        private static string GetSourceFilePath(string path)
-        {
-            return Path.Combine(path, "source.cs");
-        }
-
-        private static string GetPdbPath(string path)
-        {
-            return Path.Combine(path, "reference.pdb");
-        }
     }
 }
diff --git a/src/EditorFeatures/CSharpTest/PdbSourceDocument/TestSourceLinkService.cs b/src/EditorFeatures/CSharpTest/PdbSourceDocument/TestSourceLinkService.cs
new file mode 100644
index 0000000000000..87918089e5ac7
--- /dev/null
+++ b/src/EditorFeatures/CSharpTest/PdbSourceDocument/TestSourceLinkService.cs
@@ -0,0 +1,45 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Reflection.PortableExecutable;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.PdbSourceDocument;
+
+namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.PdbSourceDocument
+{
+    internal class TestSourceLinkService : ISourceLinkService
+    {
+        private readonly string? _pdbFilePath;
+        private readonly string? _sourceFilePath;
+        private readonly bool _isPortablePdb;
+
+        public TestSourceLinkService(string? pdbFilePath = null, string? sourceFilePath = null, bool isPortablePdb = true)
+        {
+            _pdbFilePath = pdbFilePath;
+            _sourceFilePath = sourceFilePath;
+            _isPortablePdb = isPortablePdb;
+        }
+
+        public Task<PdbFilePathResult?> GetPdbFilePathAsync(string dllPath, PEReader peReader, IPdbSourceDocumentLogger? logger, CancellationToken cancellationToken)
+        {
+            if (_pdbFilePath is null)
+            {
+                return Task.FromResult<PdbFilePathResult?>(null);
+            }
+
+            return Task.FromResult<PdbFilePathResult?>(new PdbFilePathResult(_pdbFilePath, "status", Log: null, _isPortablePdb));
+        }
+
+        public Task<SourceFilePathResult?> GetSourceFilePathAsync(string url, string relativePath, IPdbSourceDocumentLogger? logger, CancellationToken cancellationToken)
+        {
+            if (_sourceFilePath is null)
+            {
+                return Task.FromResult<SourceFilePathResult?>(null);
+            }
+
+            return Task.FromResult<SourceFilePathResult?>(new SourceFilePathResult(_sourceFilePath, Log: null));
+        }
+    }
+}
diff --git a/src/Features/Core/Portable/Microsoft.CodeAnalysis.Features.csproj b/src/Features/Core/Portable/Microsoft.CodeAnalysis.Features.csproj
index ce801621deb77..0d40e2fb88215 100644
--- a/src/Features/Core/Portable/Microsoft.CodeAnalysis.Features.csproj
+++ b/src/Features/Core/Portable/Microsoft.CodeAnalysis.Features.csproj
@@ -130,6 +130,7 @@
     <PackageReference Include="System.Threading.Tasks.Extensions" Version="$(SystemThreadingTasksExtensionsVersion)" />
     <PackageReference Include="Microsoft.DiaSymReader" Version="$(MicrosoftDiaSymReaderVersion)" />
     <PackageReference Include="Microsoft.CodeAnalysis.AnalyzerUtilities" Version="$(MicrosoftCodeAnalysisAnalyzerUtilitiesVersion)" />
+    <PackageReference Include="System.Text.Json" Version="$(SystemTextJsonVersion)" />
   </ItemGroup>
   <Import Project="..\..\..\Compilers\Core\AnalyzerDriver\AnalyzerDriver.projitems" Label="Shared" />
   <Import Project="..\..\..\Dependencies\CodeAnalysis.Debugging\Microsoft.CodeAnalysis.Debugging.projitems" Label="Shared" />
diff --git a/src/Features/Core/Portable/PdbSourceDocument/DocumentDebugInfoReader.cs b/src/Features/Core/Portable/PdbSourceDocument/DocumentDebugInfoReader.cs
index c980904eb26ce..65ec76ef83056 100644
--- a/src/Features/Core/Portable/PdbSourceDocument/DocumentDebugInfoReader.cs
+++ b/src/Features/Core/Portable/PdbSourceDocument/DocumentDebugInfoReader.cs
@@ -8,6 +8,7 @@
 using System.Reflection.PortableExecutable;
 using Microsoft.CodeAnalysis.Debugging;
 using Microsoft.CodeAnalysis.PooledObjects;
+using Microsoft.SourceLink.Tools;
 
 namespace Microsoft.CodeAnalysis.PdbSourceDocument
 {
@@ -47,13 +48,44 @@ public ImmutableArray<SourceDocument> FindSourceDocuments(ISymbol symbol)
                 var checksum = _pdbReader.GetBlobContent(document.Hash);
 
                 var embeddedTextBytes = TryGetEmbeddedTextBytes(handle);
+                var sourceLinkUrl = TryGetSourceLinkUrl(handle);
 
-                sourceDocuments.Add(new SourceDocument(filePath, hashAlgorithm, checksum, embeddedTextBytes));
+                sourceDocuments.Add(new SourceDocument(filePath, hashAlgorithm, checksum, embeddedTextBytes, sourceLinkUrl));
             }
 
             return sourceDocuments.ToImmutable();
         }
 
+        private string? TryGetSourceLinkUrl(DocumentHandle handle)
+        {
+            var document = _pdbReader.GetDocument(handle);
+            if (document.Name.IsNil)
+                return null;
+
+            var documentName = _pdbReader.GetString(document.Name);
+            if (documentName is null)
+                return null;
+
+            foreach (var cdiHandle in _pdbReader.GetCustomDebugInformation(EntityHandle.ModuleDefinition))
+            {
+                var cdi = _pdbReader.GetCustomDebugInformation(cdiHandle);
+                if (_pdbReader.GetGuid(cdi.Kind) == PortableCustomDebugInfoKinds.SourceLink && !cdi.Value.IsNil)
+                {
+                    var blobReader = _pdbReader.GetBlobReader(cdi.Value);
+                    var sourceLinkJson = blobReader.ReadUTF8(blobReader.Length);
+
+                    var map = SourceLinkMap.Parse(sourceLinkJson);
+
+                    if (map.TryGetUri(documentName, out var uri))
+                    {
+                        return uri;
+                    }
+                }
+            }
+
+            return null;
+        }
+
         private byte[]? TryGetEmbeddedTextBytes(DocumentHandle handle)
         {
             var handles = _pdbReader.GetCustomDebugInformation(handle);
diff --git a/src/Features/Core/Portable/PdbSourceDocument/IPdbFileLocatorService.cs b/src/Features/Core/Portable/PdbSourceDocument/IPdbFileLocatorService.cs
index 398145a744668..a1806acded3a2 100644
--- a/src/Features/Core/Portable/PdbSourceDocument/IPdbFileLocatorService.cs
+++ b/src/Features/Core/Portable/PdbSourceDocument/IPdbFileLocatorService.cs
@@ -9,6 +9,6 @@ namespace Microsoft.CodeAnalysis.PdbSourceDocument
 {
     internal interface IPdbFileLocatorService
     {
-        Task<DocumentDebugInfoReader?> GetDocumentDebugInfoReaderAsync(string dllPath, CancellationToken cancellationToken);
+        Task<DocumentDebugInfoReader?> GetDocumentDebugInfoReaderAsync(string dllPath, IPdbSourceDocumentLogger? logger, CancellationToken cancellationToken);
     }
 }
diff --git a/src/Features/Core/Portable/PdbSourceDocument/IPdbSourceDocumentLoaderService.cs b/src/Features/Core/Portable/PdbSourceDocument/IPdbSourceDocumentLoaderService.cs
index 28df2304be115..f3b27a12a552f 100644
--- a/src/Features/Core/Portable/PdbSourceDocument/IPdbSourceDocumentLoaderService.cs
+++ b/src/Features/Core/Portable/PdbSourceDocument/IPdbSourceDocumentLoaderService.cs
@@ -10,6 +10,8 @@ namespace Microsoft.CodeAnalysis.PdbSourceDocument
 {
     internal interface IPdbSourceDocumentLoaderService
     {
-        Task<TextLoader?> LoadSourceDocumentAsync(SourceDocument sourceDocument, Encoding? defaultEncoding, CancellationToken cancellationToken);
+        Task<SourceFileInfo?> LoadSourceDocumentAsync(string tempFilePath, SourceDocument sourceDocument, Encoding encoding, IPdbSourceDocumentLogger? logger, CancellationToken cancellationToken);
     }
+
+    internal sealed record SourceFileInfo(string FilePath, TextLoader Loader);
 }
diff --git a/src/Features/Core/Portable/PdbSourceDocument/IPdbSourceDocumentLogger.cs b/src/Features/Core/Portable/PdbSourceDocument/IPdbSourceDocumentLogger.cs
new file mode 100644
index 0000000000000..0735a85ad05a6
--- /dev/null
+++ b/src/Features/Core/Portable/PdbSourceDocument/IPdbSourceDocumentLogger.cs
@@ -0,0 +1,20 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Microsoft.CodeAnalysis.PdbSourceDocument
+{
+    /// <summary>
+    /// Logs messages when navigating to external sources (eg. SourceLink, embedded) so that users can
+    /// troubleshoot issues that might prevent it working (authentication, checksum errors, etc.)
+    /// </summary>
+    internal interface IPdbSourceDocumentLogger
+    {
+        void Clear();
+        void Log(string message);
+    }
+}
diff --git a/src/Features/Core/Portable/PdbSourceDocument/ISourceLinkService.cs b/src/Features/Core/Portable/PdbSourceDocument/ISourceLinkService.cs
new file mode 100644
index 0000000000000..b736048a9a8e8
--- /dev/null
+++ b/src/Features/Core/Portable/PdbSourceDocument/ISourceLinkService.cs
@@ -0,0 +1,35 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Reflection.PortableExecutable;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Microsoft.CodeAnalysis.PdbSourceDocument
+{
+    internal interface ISourceLinkService
+    {
+        Task<SourceFilePathResult?> GetSourceFilePathAsync(string url, string relativePath, IPdbSourceDocumentLogger? logger, CancellationToken cancellationToken);
+
+        Task<PdbFilePathResult?> GetPdbFilePathAsync(string dllPath, PEReader peReader, IPdbSourceDocumentLogger? logger, CancellationToken cancellationToken);
+    }
+
+    // The following types mirror types in Microsoft.VisualStudio.Debugger.Contracts which cannot be referenced at this layer
+
+    /// <summary>
+    /// The result of findding a PDB file
+    /// </summary>
+    /// <param name="PdbFilePath">The path to the PDB file in the debugger cache</param>
+    /// <param name="Status">Status of the operation</param>
+    /// <param name="Log">Any log messages the debugger wrote during the operation</param>
+    /// <param name="IsPortablePdb">Whether the PDB found is portable</param>
+    internal record PdbFilePathResult(string PdbFilePath, string Status, string? Log, bool IsPortablePdb);
+
+    /// <summary>
+    /// The result of finding a source file via SourceLink
+    /// </summary>
+    /// <param name="SourceFilePath">The path to the source file in the debugger cache</param>
+    /// <param name="Log">Any log messages the debugger wrote during the operation</param>
+    internal record SourceFilePathResult(string SourceFilePath, string? Log);
+}
diff --git a/src/Features/Core/Portable/PdbSourceDocument/PdbFileLocatorService.cs b/src/Features/Core/Portable/PdbSourceDocument/PdbFileLocatorService.cs
index 6652b2809c9c5..2552ebc435811 100644
--- a/src/Features/Core/Portable/PdbSourceDocument/PdbFileLocatorService.cs
+++ b/src/Features/Core/Portable/PdbSourceDocument/PdbFileLocatorService.cs
@@ -4,7 +4,9 @@
 
 using System;
 using System.Composition;
+using System.Diagnostics.CodeAnalysis;
 using System.IO;
+using System.Reflection.Metadata;
 using System.Reflection.PortableExecutable;
 using System.Threading;
 using System.Threading.Tasks;
@@ -17,23 +19,29 @@ namespace Microsoft.CodeAnalysis.PdbSourceDocument
     [Export(typeof(IPdbFileLocatorService)), Shared]
     internal sealed class PdbFileLocatorService : IPdbFileLocatorService
     {
+        private const int SymbolLocatorTimeout = 2000;
+
+        private readonly ISourceLinkService? _sourceLinkService;
+
         [ImportingConstructor]
-        [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
-        public PdbFileLocatorService()
+        [SuppressMessage("RoslynDiagnosticsReliability", "RS0033:Importing constructor should be [Obsolete]", Justification = "Used in test code")]
+        public PdbFileLocatorService([Import(AllowDefault = true)] ISourceLinkService? sourceLinkService)
         {
+            _sourceLinkService = sourceLinkService;
         }
 
-        public Task<DocumentDebugInfoReader?> GetDocumentDebugInfoReaderAsync(string dllPath, CancellationToken cancellationToken)
+        public async Task<DocumentDebugInfoReader?> GetDocumentDebugInfoReaderAsync(string dllPath, IPdbSourceDocumentLogger? logger, CancellationToken cancellationToken)
         {
             var dllStream = IOUtilities.PerformIO(() => File.OpenRead(dllPath));
             if (dllStream is null)
-                return Task.FromResult<DocumentDebugInfoReader?>(null);
+                return null;
 
             Stream? pdbStream = null;
             DocumentDebugInfoReader? result = null;
             var peReader = new PEReader(dllStream);
             try
             {
+                // Try to load the pdb file from disk, or embedded
                 if (peReader.TryOpenAssociatedPortablePdb(dllPath, pdbPath => File.OpenRead(pdbPath), out var pdbReaderProvider, out _))
                 {
                     Contract.ThrowIfNull(pdbReaderProvider);
@@ -41,17 +49,34 @@ public PdbFileLocatorService()
                     result = new DocumentDebugInfoReader(peReader, pdbReaderProvider);
                 }
 
-                // TODO: Otherwise call the debugger to find the PDB from a symbol server etc.
-                if (result is null)
+                // Otherwise call the debugger to find the PDB from a symbol server etc.
+                if (result is null && _sourceLinkService is not null)
                 {
-                    // Debugger needs:
-                    // - PDB MVID
-                    // - PDB Age
-                    // - PDB TimeStamp
-                    // - PDB Path
-                    // - DLL Path
-                    // 
-                    // Most of this info comes from the CodeView Debug Directory from the dll
+                    var delay = Task.Delay(SymbolLocatorTimeout, cancellationToken);
+                    var pdbResultTask = _sourceLinkService.GetPdbFilePathAsync(dllPath, peReader, logger, cancellationToken);
+
+                    var winner = await Task.WhenAny(pdbResultTask, delay).ConfigureAwait(false);
+
+                    if (winner == pdbResultTask)
+                    {
+                        var pdbResult = await pdbResultTask.ConfigureAwait(false);
+
+                        // TODO: Support windows PDBs: https://github.com/dotnet/roslyn/issues/55834
+                        // TODO: Log results from pdbResult.Log: https://github.com/dotnet/roslyn/issues/57352
+                        if (pdbResult is not null && pdbResult.IsPortablePdb)
+                        {
+                            pdbStream = IOUtilities.PerformIO(() => File.OpenRead(pdbResult.PdbFilePath));
+                            if (pdbStream is not null)
+                            {
+                                var readerProvider = MetadataReaderProvider.FromPortablePdbStream(pdbStream);
+                                result = new DocumentDebugInfoReader(peReader, readerProvider);
+                            }
+                        }
+                    }
+                    else
+                    {
+                        // TODO: Log the timeout: https://github.com/dotnet/roslyn/issues/57352
+                    }
                 }
             }
             catch (BadImageFormatException)
@@ -71,7 +96,7 @@ public PdbFileLocatorService()
                 }
             }
 
-            return Task.FromResult<DocumentDebugInfoReader?>(result);
+            return result;
         }
     }
 }
diff --git a/src/Features/Core/Portable/PdbSourceDocument/PdbSourceDocumentLoaderService.cs b/src/Features/Core/Portable/PdbSourceDocument/PdbSourceDocumentLoaderService.cs
index a1a2a8bfc33e0..3466b3d9a9642 100644
--- a/src/Features/Core/Portable/PdbSourceDocument/PdbSourceDocumentLoaderService.cs
+++ b/src/Features/Core/Portable/PdbSourceDocument/PdbSourceDocumentLoaderService.cs
@@ -4,13 +4,13 @@
 
 using System;
 using System.Composition;
+using System.Diagnostics.CodeAnalysis;
 using System.IO;
 using System.IO.Compression;
 using System.Linq;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
-using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.CodeAnalysis.Shared.Utilities;
 using Microsoft.CodeAnalysis.Text;
 
@@ -19,86 +19,149 @@ namespace Microsoft.CodeAnalysis.PdbSourceDocument
     [Export(typeof(IPdbSourceDocumentLoaderService)), Shared]
     internal sealed class PdbSourceDocumentLoaderService : IPdbSourceDocumentLoaderService
     {
+        private const int SourceLinkTimeout = 1000;
+        private readonly ISourceLinkService? _sourceLinkService;
+
         [ImportingConstructor]
-        [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
-        public PdbSourceDocumentLoaderService()
+        [SuppressMessage("RoslynDiagnosticsReliability", "RS0033:Importing constructor should be [Obsolete]", Justification = "Used in test code")]
+        public PdbSourceDocumentLoaderService([Import(AllowDefault = true)] ISourceLinkService? sourceLinkService)
         {
+            _sourceLinkService = sourceLinkService;
         }
 
-        public Task<TextLoader?> LoadSourceDocumentAsync(SourceDocument sourceDocument, Encoding? defaultEncoding, CancellationToken cancellationToken)
+        public async Task<SourceFileInfo?> LoadSourceDocumentAsync(string tempFilePath, SourceDocument sourceDocument, Encoding encoding, IPdbSourceDocumentLogger? logger, CancellationToken cancellationToken)
         {
             // First we try getting "local" files, either from embedded source or a local file on disk
-            var stream = TryGetEmbeddedSourceStream(sourceDocument) ??
-                TryGetFileStream(sourceDocument);
+            // and if they don't work we call the debugger to download a file from SourceLink info
+            return TryGetEmbeddedSourceFile(tempFilePath, sourceDocument, encoding) ??
+                TryGetOriginalFile(sourceDocument, encoding) ??
+                await TryGetSourceLinkFileAsync(sourceDocument, encoding, logger, cancellationToken).ConfigureAwait(false);
+        }
+
+        private static SourceFileInfo? TryGetEmbeddedSourceFile(string tempFilePath, SourceDocument sourceDocument, Encoding encoding)
+        {
+            if (sourceDocument.EmbeddedTextBytes is null)
+                return null;
+
+            var filePath = Path.Combine(tempFilePath, Path.GetFileName(sourceDocument.FilePath));
+
+            // We might have already navigated to this file before, so it might exist, but
+            // we still need to re-validate the checksum and make sure its not the wrong file
+            if (File.Exists(filePath) &&
+                LoadSourceFile(filePath, sourceDocument, encoding, ignoreChecksum: false) is { } existing)
+            {
+                return existing;
+            }
+
+            var embeddedTextBytes = sourceDocument.EmbeddedTextBytes;
+            var uncompressedSize = BitConverter.ToInt32(embeddedTextBytes, 0);
+            var stream = new MemoryStream(embeddedTextBytes, sizeof(int), embeddedTextBytes.Length - sizeof(int));
+
+            if (uncompressedSize != 0)
+            {
+                var decompressed = new MemoryStream(uncompressedSize);
+
+                using (var deflater = new DeflateStream(stream, CompressionMode.Decompress))
+                {
+                    deflater.CopyTo(decompressed);
+                }
+
+                if (decompressed.Length != uncompressedSize)
+                {
+                    return null;
+                }
+
+                stream = decompressed;
+            }
 
             if (stream is not null)
             {
+                // Even though Roslyn supports loading SourceTexts from a stream, Visual Studio requires
+                // a file to exist on disk so we have to write embedded source to a temp file.
                 using (stream)
                 {
-                    var encoding = defaultEncoding ?? Encoding.UTF8;
                     try
                     {
-                        var sourceText = EncodedStringText.Create(stream, defaultEncoding: encoding, checksumAlgorithm: sourceDocument.HashAlgorithm);
-
-                        var fileChecksum = sourceText.GetChecksum();
-                        if (fileChecksum.SequenceEqual(sourceDocument.Checksum))
+                        stream.Position = 0;
+                        using (var file = File.OpenWrite(filePath))
                         {
-                            var textAndVersion = TextAndVersion.Create(sourceText, VersionStamp.Default, sourceDocument.FilePath);
-                            var textLoader = TextLoader.From(textAndVersion);
-                            return Task.FromResult<TextLoader?>(textLoader);
+                            stream.CopyTo(file);
                         }
+
+                        new FileInfo(filePath).IsReadOnly = true;
                     }
                     catch (IOException)
                     {
                         // TODO: Log message to inform the user what went wrong: https://github.com/dotnet/roslyn/issues/57352
+                        return null;
                     }
                 }
-            }
 
-            // TODO: Call the debugger to download the file
-            // Maybe they'll download to a temp file, in which case this method could return a string
-            // or maybe they'll return a stream, in which case we could create a new StreamTextLoader
+                return LoadSourceFile(filePath, sourceDocument, encoding, ignoreChecksum: false);
+            }
 
-            return Task.FromResult<TextLoader?>(null);
+            return null;
         }
 
-        private static Stream? TryGetEmbeddedSourceStream(SourceDocument sourceDocument)
+        private async Task<SourceFileInfo?> TryGetSourceLinkFileAsync(SourceDocument sourceDocument, Encoding encoding, IPdbSourceDocumentLogger? logger, CancellationToken cancellationToken)
         {
-            if (sourceDocument.EmbeddedTextBytes is null)
+            if (_sourceLinkService is null || sourceDocument.SourceLinkUrl is null)
                 return null;
 
-            var embeddedTextBytes = sourceDocument.EmbeddedTextBytes;
-            var uncompressedSize = BitConverter.ToInt32(embeddedTextBytes, 0);
-            var stream = new MemoryStream(embeddedTextBytes, sizeof(int), embeddedTextBytes.Length - sizeof(int));
+            // This should ideally be the repo-relative path to the file, and come from SourceLink: https://github.com/dotnet/sourcelink/pull/699
+            var relativePath = Path.GetFileName(sourceDocument.FilePath);
 
-            if (uncompressedSize != 0)
-            {
-                var decompressed = new MemoryStream(uncompressedSize);
+            var delay = Task.Delay(SourceLinkTimeout, cancellationToken);
+            var sourceFileTask = _sourceLinkService.GetSourceFilePathAsync(sourceDocument.SourceLinkUrl, relativePath, logger, cancellationToken);
 
-                using (var deflater = new DeflateStream(stream, CompressionMode.Decompress))
+            var winner = await Task.WhenAny(sourceFileTask, delay).ConfigureAwait(false);
+
+            if (winner == sourceFileTask)
+            {
+                var sourceFile = await sourceFileTask.ConfigureAwait(false);
+                if (sourceFile is not null)
                 {
-                    deflater.CopyTo(decompressed);
+                    // TODO: Log results from sourceFile.Log: https://github.com/dotnet/roslyn/issues/57352
+                    // TODO: Don't ignore the checksum here: https://github.com/dotnet/roslyn/issues/55834
+                    return LoadSourceFile(sourceFile.SourceFilePath, sourceDocument, encoding, ignoreChecksum: true);
                 }
-
-                if (decompressed.Length != uncompressedSize)
+                else
                 {
-                    return null;
+                    // TODO: Log the timeout: https://github.com/dotnet/roslyn/issues/57352
                 }
-
-                stream = decompressed;
             }
 
-            return stream;
+            return null;
         }
 
-        private static Stream? TryGetFileStream(SourceDocument sourceDocument)
+        private static SourceFileInfo? TryGetOriginalFile(SourceDocument sourceDocument, Encoding encoding)
         {
             if (File.Exists(sourceDocument.FilePath))
             {
-                return IOUtilities.PerformIO(() => new FileStream(sourceDocument.FilePath, FileMode.Open, FileAccess.Read, FileShare.Read | FileShare.Delete));
+                return LoadSourceFile(sourceDocument.FilePath, sourceDocument, encoding, ignoreChecksum: false);
             }
 
             return null;
         }
+
+        private static SourceFileInfo? LoadSourceFile(string filePath, SourceDocument sourceDocument, Encoding encoding, bool ignoreChecksum)
+        {
+            return IOUtilities.PerformIO(() =>
+            {
+                using var stream = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read | FileShare.Delete);
+
+                var sourceText = SourceText.From(stream, encoding, sourceDocument.HashAlgorithm, throwIfBinaryDetected: true);
+
+                var fileChecksum = sourceText.GetChecksum();
+                if (ignoreChecksum || fileChecksum.SequenceEqual(sourceDocument.Checksum))
+                {
+                    var textAndVersion = TextAndVersion.Create(sourceText, VersionStamp.Default, filePath);
+                    var textLoader = TextLoader.From(textAndVersion);
+                    return new SourceFileInfo(filePath, textLoader);
+                }
+
+                return null;
+            });
+        }
     }
 }
diff --git a/src/Features/Core/Portable/PdbSourceDocument/PdbSourceDocumentMetadataAsSourceFileProvider.cs b/src/Features/Core/Portable/PdbSourceDocument/PdbSourceDocumentMetadataAsSourceFileProvider.cs
index 030e15903ca88..10ad8fddb5216 100644
--- a/src/Features/Core/Portable/PdbSourceDocument/PdbSourceDocumentMetadataAsSourceFileProvider.cs
+++ b/src/Features/Core/Portable/PdbSourceDocument/PdbSourceDocumentMetadataAsSourceFileProvider.cs
@@ -17,6 +17,7 @@
 using Microsoft.CodeAnalysis.MetadataAsSource;
 using Microsoft.CodeAnalysis.PooledObjects;
 using Microsoft.CodeAnalysis.Shared.Extensions;
+using Microsoft.CodeAnalysis.Shared.Utilities;
 using Microsoft.CodeAnalysis.Text;
 using Roslyn.Utilities;
 
@@ -30,16 +31,21 @@ internal sealed class PdbSourceDocumentMetadataAsSourceFileProvider : IMetadataA
 
         private readonly IPdbFileLocatorService _pdbFileLocatorService;
         private readonly IPdbSourceDocumentLoaderService _pdbSourceDocumentLoaderService;
+        private readonly IPdbSourceDocumentLogger? _logger;
 
         private readonly Dictionary<string, ProjectId> _assemblyToProjectMap = new();
         private readonly Dictionary<string, (DocumentId documentId, Encoding encoding)> _fileToDocumentMap = new();
 
         [ImportingConstructor]
         [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
-        public PdbSourceDocumentMetadataAsSourceFileProvider(IPdbFileLocatorService pdbFileLocatorService, IPdbSourceDocumentLoaderService pdbSourceDocumentLoaderService)
+        public PdbSourceDocumentMetadataAsSourceFileProvider(
+            IPdbFileLocatorService pdbFileLocatorService,
+            IPdbSourceDocumentLoaderService pdbSourceDocumentLoaderService,
+            [Import(AllowDefault = true)] IPdbSourceDocumentLogger? logger)
         {
             _pdbFileLocatorService = pdbFileLocatorService;
             _pdbSourceDocumentLoaderService = pdbSourceDocumentLoaderService;
+            _logger = logger;
         }
 
         public async Task<MetadataAsSourceFile?> GetGeneratedFileAsync(Workspace workspace, Project project, ISymbol symbol, bool signaturesOnly, bool allowDecompilation, string tempPath, CancellationToken cancellationToken)
@@ -67,7 +73,7 @@ public PdbSourceDocumentMetadataAsSourceFileProvider(IPdbFileLocatorService pdbF
             ImmutableDictionary<string, string> pdbCompilationOptions;
             ImmutableArray<SourceDocument> sourceDocuments;
             // We know we have a DLL, call and see if we can find metadata readers for it, and for the PDB (whereever it may be)
-            using (var documentDebugInfoReader = await _pdbFileLocatorService.GetDocumentDebugInfoReaderAsync(dllPath, cancellationToken).ConfigureAwait(false))
+            using (var documentDebugInfoReader = await _pdbFileLocatorService.GetDocumentDebugInfoReaderAsync(dllPath, _logger, cancellationToken).ConfigureAwait(false))
             {
                 if (documentDebugInfoReader is null)
                     return null;
@@ -93,13 +99,6 @@ public PdbSourceDocumentMetadataAsSourceFileProvider(IPdbFileLocatorService pdbF
                 defaultEncoding = Encoding.GetEncoding(fallbackEncodingString);
             }
 
-            // Get text loaders for our documents. We do this here because if we can't load any of the files, then
-            // we can't provide any results, so there is no point adding a project to the workspace etc.
-            var textLoaderTasks = sourceDocuments.Select(sd => _pdbSourceDocumentLoaderService.LoadSourceDocumentAsync(sd, defaultEncoding, cancellationToken)).ToArray();
-            var textLoaders = await Task.WhenAll(textLoaderTasks).ConfigureAwait(false);
-            if (textLoaders.Where(t => t is null).Any())
-                return null;
-
             if (!_assemblyToProjectMap.TryGetValue(assemblyName, out var projectId))
             {
                 // Get the project info now, so we can dispose the documentDebugInfoReader sooner
@@ -114,64 +113,44 @@ public PdbSourceDocumentMetadataAsSourceFileProvider(IPdbFileLocatorService pdbF
                 _assemblyToProjectMap.Add(assemblyName, projectId);
             }
 
+            var tempFilePath = Path.Combine(tempPath, projectId.Id.ToString());
+            // Create the directory. It's possible a parallel deletion is happening in another process, so we may have
+            // to retry this a few times.
+            var loopCount = 0;
+            while (!Directory.Exists(tempFilePath))
+            {
+                // Protect against infinite loops.
+                if (loopCount++ > 10)
+                    return null;
+
+                IOUtilities.PerformIO(() => Directory.CreateDirectory(tempFilePath));
+            }
+
+            // Get text loaders for our documents. We do this here because if we can't load any of the files, then
+            // we can't provide any results, so there is no point adding a project to the workspace etc.
+            var encoding = defaultEncoding ?? Encoding.UTF8;
+            var sourceFileInfoTasks = sourceDocuments.Select(sd => _pdbSourceDocumentLoaderService.LoadSourceDocumentAsync(tempFilePath, sd, encoding, _logger, cancellationToken)).ToArray();
+            var sourceFileInfos = await Task.WhenAll(sourceFileInfoTasks).ConfigureAwait(false);
+            if (sourceFileInfos is null || sourceFileInfos.Where(t => t is null).Any())
+                return null;
+
             var symbolId = SymbolKey.Create(symbol, cancellationToken);
             var navigateProject = workspace.CurrentSolution.GetRequiredProject(projectId);
 
-            Contract.ThrowIfFalse(sourceDocuments.Length == textLoaders.Length);
-
-            // Combine text loaders and file paths. Task.WhenAll ensures order is preserved.
-            var filePathsAndTextLoaders = sourceDocuments.Select((sd, i) => (sd.FilePath, textLoaders[i]!)).ToImmutableArray();
-            var documentInfos = CreateDocumentInfos(filePathsAndTextLoaders, navigateProject);
+            var documentInfos = CreateDocumentInfos(sourceFileInfos, navigateProject);
             if (documentInfos.Length > 0)
             {
                 workspace.OnDocumentsAdded(documentInfos);
                 navigateProject = workspace.CurrentSolution.GetRequiredProject(projectId);
             }
 
-            var documentPath = filePathsAndTextLoaders[0].FilePath;
+            var documentPath = sourceFileInfos[0]!.FilePath;
             var document = navigateProject.Documents.FirstOrDefault(d => d.FilePath?.Equals(documentPath, StringComparison.OrdinalIgnoreCase) ?? false);
 
-            // TODO: Can we avoid writing a temp file, and convince Visual Studio to open a file that doesn't exist on disk? https://github.com/dotnet/roslyn/issues/55834
-            var tempFilePath = Path.Combine(tempPath, projectId.Id.ToString(), Path.GetFileName(documentPath));
-
-            // We might already know about this file, but lets make sure it still exists too
-            if (!_fileToDocumentMap.ContainsKey(tempFilePath) || !File.Exists(tempFilePath))
+            // In order to open documents in VS we need to understand the link from temp file to document and its encoding
+            if (!_fileToDocumentMap.ContainsKey(documentPath))
             {
-                // We have the content, so write it out to disk
-                var text = await document.GetTextAsync(cancellationToken).ConfigureAwait(false);
-
-                // Create the directory. It's possible a parallel deletion is happening in another process, so we may have
-                // to retry this a few times.
-                var directoryToCreate = Path.GetDirectoryName(tempFilePath)!;
-                var loopCount = 0;
-                while (!Directory.Exists(directoryToCreate))
-                {
-                    // Protect against infinite loops.
-                    if (loopCount++ > 10)
-                        return null;
-
-                    try
-                    {
-                        Directory.CreateDirectory(directoryToCreate);
-                    }
-                    catch (DirectoryNotFoundException)
-                    {
-                    }
-                    catch (UnauthorizedAccessException)
-                    {
-                    }
-                }
-
-                var encoding = text.Encoding ?? Encoding.UTF8;
-                using (var textWriter = new StreamWriter(tempFilePath, append: false, encoding: encoding))
-                {
-                    text.Write(textWriter, cancellationToken);
-                }
-
-                // Mark read-only
-                new FileInfo(tempFilePath).IsReadOnly = true;
-
-                _fileToDocumentMap[tempFilePath] = (document.Id, encoding);
+                _fileToDocumentMap[documentPath] = (document.Id, encoding);
             }
 
             var navigateLocation = await MetadataAsSourceHelpers.GetLocationInGeneratedSourceAsync(symbolId, document, cancellationToken).ConfigureAwait(false);
@@ -183,7 +162,7 @@ public PdbSourceDocumentMetadataAsSourceFileProvider(IPdbFileLocatorService pdbF
                 navigateDocument!.Name,
                 FeaturesResources.from_metadata);
 
-            return new MetadataAsSourceFile(tempFilePath, navigateLocation, documentName, navigateDocument.FilePath);
+            return new MetadataAsSourceFile(documentPath, navigateLocation, documentName, navigateDocument.FilePath);
         }
 
         private static ProjectInfo? CreateProjectInfo(Workspace workspace, Project project, ImmutableDictionary<string, string> pdbCompilationOptions, string assemblyName)
@@ -211,23 +190,25 @@ public PdbSourceDocumentMetadataAsSourceFileProvider(IPdbFileLocatorService pdbF
                 metadataReferences: project.MetadataReferences.ToImmutableArray()); // TODO: Read references from PDB info: https://github.com/dotnet/roslyn/issues/55834
         }
 
-        private static ImmutableArray<DocumentInfo> CreateDocumentInfos(ImmutableArray<(string FilePath, TextLoader Loader)> filePaths, Project project)
+        private static ImmutableArray<DocumentInfo> CreateDocumentInfos(SourceFileInfo?[] sourceFileInfos, Project project)
         {
             using var _ = ArrayBuilder<DocumentInfo>.GetInstance(out var documents);
 
-            foreach (var sourceDocument in filePaths)
+            foreach (var info in sourceFileInfos)
             {
+                Contract.ThrowIfNull(info);
+
                 // If a document has multiple symbols then we would already know about it
-                if (project.Documents.Contains(d => d.FilePath?.Equals(sourceDocument.FilePath, StringComparison.OrdinalIgnoreCase) ?? false))
+                if (project.Documents.Contains(d => d.FilePath?.Equals(info.FilePath, StringComparison.OrdinalIgnoreCase) ?? false))
                     continue;
 
                 var documentId = DocumentId.CreateNewId(project.Id);
 
                 documents.Add(DocumentInfo.Create(
                     documentId,
-                    Path.GetFileName(sourceDocument.FilePath),
-                    filePath: sourceDocument.FilePath,
-                    loader: sourceDocument.Loader));
+                    Path.GetFileName(info.FilePath),
+                    filePath: info.FilePath,
+                    loader: info.Loader));
             }
 
             return documents.ToImmutable();
@@ -280,5 +261,5 @@ public void CleanupGeneratedFiles(Workspace? workspace)
         }
     }
 
-    internal sealed record SourceDocument(string FilePath, SourceHashAlgorithm HashAlgorithm, ImmutableArray<byte> Checksum, byte[]? EmbeddedTextBytes);
+    internal sealed record SourceDocument(string FilePath, SourceHashAlgorithm HashAlgorithm, ImmutableArray<byte> Checksum, byte[]? EmbeddedTextBytes, string? SourceLinkUrl);
 }
diff --git a/src/Features/Core/Portable/PdbSourceDocument/SourceLinkMap.cs b/src/Features/Core/Portable/PdbSourceDocument/SourceLinkMap.cs
new file mode 100644
index 0000000000000..b51a9017c4aae
--- /dev/null
+++ b/src/Features/Core/Portable/PdbSourceDocument/SourceLinkMap.cs
@@ -0,0 +1,229 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Diagnostics;
+using System.IO;
+using System.Linq;
+using System.Text.Json;
+
+#if NETCOREAPP
+using System.Diagnostics.CodeAnalysis;
+#endif
+
+namespace Microsoft.SourceLink.Tools
+{
+    /// <summary>
+    /// Source Link URL map. Maps file paths matching Source Link patterns to URLs.
+    /// </summary>
+    internal readonly struct SourceLinkMap
+    {
+        private readonly ReadOnlyCollection<Entry> _entries;
+
+        private SourceLinkMap(ReadOnlyCollection<Entry> mappings)
+        {
+            _entries = mappings;
+        }
+
+        public readonly struct Entry
+        {
+            public readonly FilePathPattern FilePath;
+            public readonly UriPattern Uri;
+
+            public Entry(FilePathPattern filePath, UriPattern uri)
+            {
+                FilePath = filePath;
+                Uri = uri;
+            }
+
+            public void Deconstruct(out FilePathPattern filePath, out UriPattern uri)
+            {
+                filePath = FilePath;
+                uri = Uri;
+            }
+        }
+
+        public readonly struct FilePathPattern
+        {
+            public readonly string Path;
+            public readonly bool IsPrefix;
+
+            public FilePathPattern(string path, bool isPrefix)
+            {
+                Path = path;
+                IsPrefix = isPrefix;
+            }
+        }
+
+        public readonly struct UriPattern
+        {
+            public readonly string Prefix;
+            public readonly string Suffix;
+
+            public UriPattern(string prefix, string suffix)
+            {
+                Prefix = prefix;
+                Suffix = suffix;
+            }
+        }
+
+        public IReadOnlyList<Entry> Entries => _entries;
+
+        /// <summary>
+        /// Parses Source Link JSON string.
+        /// </summary>
+        /// <exception cref="ArgumentNullException"><paramref name="json"/> is null.</exception>
+        /// <exception cref="InvalidDataException">The JSON does not follow Source Link specification.</exception>
+        /// <exception cref="JsonException"><paramref name="json"/> is not valid JSON string.</exception>
+        public static SourceLinkMap Parse(string json)
+        {
+            if (json is null)
+            {
+                throw new ArgumentNullException(nameof(json));
+            }
+
+            var list = new List<Entry>();
+
+            var root = JsonDocument.Parse(json, new JsonDocumentOptions() { AllowTrailingCommas = true }).RootElement;
+            if (root.ValueKind != JsonValueKind.Object)
+            {
+                throw new InvalidDataException();
+            }
+
+            foreach (var rootEntry in root.EnumerateObject())
+            {
+                if (!rootEntry.NameEquals("documents"))
+                {
+                    // potential future extensibility
+                    continue;
+                }
+
+                if (rootEntry.Value.ValueKind != JsonValueKind.Object)
+                {
+                    throw new InvalidDataException();
+                }
+
+                foreach (var documentsEntry in rootEntry.Value.EnumerateObject())
+                {
+                    if (documentsEntry.Value.ValueKind != JsonValueKind.String ||
+                        !TryParseEntry(documentsEntry.Name, documentsEntry.Value.GetString()!, out var entry))
+                    {
+                        throw new InvalidDataException();
+                    }
+
+                    list.Add(entry);
+                }
+            }
+
+            // Sort the map by decreasing file path length. This ensures that the most specific paths will checked before the least specific
+            // and that absolute paths will be checked before a wildcard path with a matching base
+            list.Sort((left, right) => -left.FilePath.Path.Length.CompareTo(right.FilePath.Path.Length));
+
+            return new SourceLinkMap(new ReadOnlyCollection<Entry>(list));
+        }
+
+        private static bool TryParseEntry(string key, string value, out Entry entry)
+        {
+            entry = default;
+
+            // VALIDATION RULES
+            // 1. The only acceptable wildcard is one and only one '*', which if present will be replaced by a relative path
+            // 2. If the filepath does not contain a *, the uri cannot contain a * and if the filepath contains a * the uri must contain a *
+            // 3. If the filepath contains a *, it must be the final character
+            // 4. If the uri contains a *, it may be anywhere in the uri
+            if (key.Length == 0)
+            {
+                return false;
+            }
+
+            var filePathStar = key.IndexOf('*');
+            if (filePathStar == key.Length - 1)
+            {
+                key = key.Substring(0, filePathStar);
+            }
+            else if (filePathStar >= 0)
+            {
+                return false;
+            }
+
+            string uriPrefix, uriSuffix;
+            var uriStar = value.IndexOf('*');
+            if (uriStar >= 0)
+            {
+                if (filePathStar < 0)
+                {
+                    return false;
+                }
+
+                uriPrefix = value.Substring(0, uriStar);
+                uriSuffix = value.Substring(uriStar + 1);
+
+                if (uriSuffix.IndexOf('*') >= 0)
+                {
+                    return false;
+                }
+            }
+            else
+            {
+                uriPrefix = value;
+                uriSuffix = "";
+            }
+
+            entry = new Entry(
+                new FilePathPattern(key, isPrefix: filePathStar >= 0),
+                new UriPattern(uriPrefix, uriSuffix));
+
+            return true;
+        }
+
+        /// <summary>
+        /// Maps specified <paramref name="path"/> to the corresponding URL.
+        /// </summary>
+        /// <exception cref="ArgumentNullException"><paramref name="path"/> is null.</exception>
+        public bool TryGetUri(
+            string path,
+#if NETCOREAPP
+            [NotNullWhen(true)]
+#endif
+            out string? uri)
+        {
+            if (path == null)
+            {
+                throw new ArgumentNullException(nameof(path));
+            }
+
+            if (path.IndexOf('*') >= 0)
+            {
+                uri = null;
+                return false;
+            }
+
+            // Note: the mapping function is case-insensitive.
+
+            foreach (var (file, mappedUri) in _entries)
+            {
+                if (file.IsPrefix)
+                {
+                    if (path.StartsWith(file.Path, StringComparison.OrdinalIgnoreCase))
+                    {
+                        var escapedPath = string.Join("/", path.Substring(file.Path.Length).Split(new[] { '/', '\\' }).Select(Uri.EscapeDataString));
+                        uri = mappedUri.Prefix + escapedPath + mappedUri.Suffix;
+                        return true;
+                    }
+                }
+                else if (string.Equals(path, file.Path, StringComparison.OrdinalIgnoreCase))
+                {
+                    Debug.Assert(mappedUri.Suffix.Length == 0);
+                    uri = mappedUri.Prefix;
+                    return true;
+                }
+            }
+
+            uri = null;
+            return false;
+        }
+    }
+}
diff --git a/src/Setup/DevDivInsertionFiles/DevDivInsertionFiles.csproj b/src/Setup/DevDivInsertionFiles/DevDivInsertionFiles.csproj
index 22d651b93f265..ea94e133c607e 100644
--- a/src/Setup/DevDivInsertionFiles/DevDivInsertionFiles.csproj
+++ b/src/Setup/DevDivInsertionFiles/DevDivInsertionFiles.csproj
@@ -134,6 +134,8 @@
       <_Dependency Remove="System.ValueTuple"/>
       <_Dependency Remove="System.Security.AccessControl"/>
       <_Dependency Remove="System.Security.Principal.Windows"/>
+      <_Dependency Remove="System.Text.Encodings.Web" />
+      <_Dependency Remove="System.Text.Json" />
       <_Dependency Remove="System.Threading.AccessControl"/>
       <_Dependency Remove="System.Threading.Tasks.Dataflow"/>
       <_Dependency Remove="System.Threading.Tasks.Extensions" />