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();
     }
 }