Add UI for Value Tracking

src/EditorFeatures/Core/Extensibility/Commands/PredefinedCommandHandlerNames.cs

@@ -178,5 +178,10 @@ internal static class PredefinedCommandHandlerNames
         /// Command handler name for Edit and Continue file save handler.
         /// </summary>
         public const string EditAndContinueFileSave = "Edit and Continue Save File Handler";
+
+        /// <summary>
+        /// Command handler name for showing the Value Tracking tool window.
+        /// </summary>
+        public const string ShowValueTracking = "Show Value Tracking";
     }
 }

src/EditorFeatures/Core/ValueTracking/ValueTrackedItem.cs

@@ -2,19 +2,86 @@
 // 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.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.Classification;
+using Microsoft.CodeAnalysis.Host;
+using Microsoft.CodeAnalysis.Shared.Extensions;
+using Microsoft.CodeAnalysis.Text;
+using Roslyn.Utilities;
+
 namespace Microsoft.CodeAnalysis.ValueTracking
 {
     internal class ValueTrackedItem
     {
-        public Location Location { get; }
         public ISymbol Symbol { get; }
+        public ValueTrackedItem? Parent { get; }
+
+        public Document Document { get; }
+        public TextSpan Span { get; }
+        public ImmutableArray<ClassifiedSpan> ClassifiedSpans { get; }
+        public SourceText SourceText { get; }
+        public LineSpan LineSpan { get; }
 
-        public ValueTrackedItem(
-            Location location,
-            ISymbol symbol)
+        private ValueTrackedItem(
+            ISymbol symbol,
+            SourceText sourceText,
+            ImmutableArray<ClassifiedSpan> classifiedSpans,
+            TextSpan textSpan,
+            Document document,
+            LineSpan lineSpan,
+            ValueTrackedItem? parent = null)
         {
-            Location = location;
             Symbol = symbol;
+            Parent = parent;
+
+            Span = textSpan;
+            ClassifiedSpans = classifiedSpans;
+            SourceText = sourceText;
+            LineSpan = lineSpan;
+            Document = document;
+        }
+
+        public static async Task<ValueTrackedItem?> TryCreateAsync(Solution solution, Location location, ISymbol symbol, ValueTrackedItem? parent = null, CancellationToken cancellationToken = default)
+        {
+            Contract.ThrowIfNull(location.SourceTree);
+
+            var document = solution.GetRequiredDocument(location.SourceTree);
+            var excerptService = document.Services.GetService<IDocumentExcerptService>();
+            SourceText? sourceText = null;
+            ImmutableArray<ClassifiedSpan> classifiedSpans = default;
+
+            if (excerptService != null)
+            {
+                var result = await excerptService.TryExcerptAsync(document, location.SourceSpan, ExcerptMode.SingleLine, cancellationToken).ConfigureAwait(false);
+                if (result.HasValue)
+                {
+                    var value = result.Value;
+                    sourceText = value.Content;
+                }
+            }
+
+            if (sourceText is null)
+            {
+                var documentSpan = await ClassifiedSpansAndHighlightSpanFactory.GetClassifiedDocumentSpanAsync(document, location.SourceSpan, cancellationToken).ConfigureAwait(false);
+                var classificationResult = await ClassifiedSpansAndHighlightSpanFactory.ClassifyAsync(documentSpan, cancellationToken).ConfigureAwait(false);
+                classifiedSpans = classificationResult.ClassifiedSpans;
+                sourceText = await location.SourceTree.GetTextAsync(cancellationToken).ConfigureAwait(false);
+            }
+
+            sourceText.GetLineAndOffset(location.SourceSpan.Start, out var lineStart, out var _);
+            sourceText.GetLineAndOffset(location.SourceSpan.End, out var lineEnd, out var _);
+            var lineSpan = LineSpan.FromBounds(lineStart, lineEnd);
+
+            return new ValueTrackedItem(
+                        symbol,
+                        sourceText,
+                        classifiedSpans,
+                        location.SourceSpan,
+                        document,
+                        lineSpan,
+                        parent: parent);
         }
     }
 }

src/EditorFeatures/Core/ValueTracking/ValueTrackingService.cs

@@ -49,7 +49,11 @@ or ILocalSymbol
                 foreach (var syntaxRef in symbol.DeclaringSyntaxReferences)
                 {
                     var location = Location.Create(syntaxRef.SyntaxTree, syntaxRef.Span);
-                    progressCollector.Report(new ValueTrackedItem(location, symbol));
+                    var item = await ValueTrackedItem.TryCreateAsync(solution, location, symbol, parent: null, cancellationToken).ConfigureAwait(false);
+                    if (item is not null)
+                    {
+                        progressCollector.Report(item);
+                    }
                 }
 
                 var findReferenceProgressCollector = new FindReferencesProgress(progressCollector);
@@ -75,7 +79,7 @@ public Task TrackValueSourceAsync(
             ValueTrackingProgressCollector progressCollector,
             CancellationToken cancellationToken)
         {
-            throw new NotImplementedException();
+            return Task.CompletedTask;
         }
 
         private class FindReferencesProgress : IStreamingFindReferencesProgress, IStreamingProgressTracker
@@ -100,14 +104,17 @@ public FindReferencesProgress(ValueTrackingProgressCollector valueTrackingProgre
 
             public ValueTask OnFindInDocumentStartedAsync(Document document) => new();
 
-            public ValueTask OnReferenceFoundAsync(ISymbol symbol, ReferenceLocation location)
+            public async ValueTask OnReferenceFoundAsync(ISymbol symbol, ReferenceLocation location)
             {
                 if (location.IsWrittenTo)
                 {
-                    _valueTrackingProgressCollector.Report(new ValueTrackedItem(location.Location, symbol));
+                    var solution = location.Document.Project.Solution;
+                    var item = await ValueTrackedItem.TryCreateAsync(solution, location.Location, symbol, parent: null, CancellationToken.None).ConfigureAwait(false);
+                    if (item is not null)
+                    {
+                        _valueTrackingProgressCollector.Report(item);
+                    }
                 }
-
-                return new();
             }
 
             public ValueTask OnStartedAsync() => new();

src/EditorFeatures/Test/ValueTracking/AbstractBaseValueTrackingTests.cs

@@ -44,8 +44,7 @@ internal static async Task<ISymbol> GetSelectedSymbolAsync(TextSpan textSpan, Do
 
         internal static void ValidateItem(ValueTrackedItem item, int line)
         {
-            var lineSpan = item.Location.GetLineSpan();
-            Assert.Equal(line, lineSpan.StartLinePosition.Line);
+            Assert.Equal(line, item.LineSpan.Start);
         }
     }
 }

src/VisualStudio/Core/Def/Commands.vsct

@@ -411,6 +411,19 @@
           <LocCanonicalName>RemoveUnusedReferences</LocCanonicalName>
         </Strings>
       </Button>
+
+      <Button guid="guidRoslynGrpId" id="cmdidshowValueTracking" priority="0x0203" type="Button">
+        <Parent guid="guidSHLMainMenu" id="IDG_VS_EDIT_GOTO"/>
+        <CommandFlag>DynamicVisibility</CommandFlag>
+        <CommandFlag>DefaultInvisible</CommandFlag>
+        <CommandFlag>CommandWellOnly</CommandFlag>
+        <Strings>
+          <ButtonText>Track Value Source</ButtonText>
+          <CommandName>ShowValueTrackingCommandName</CommandName>
+          <CanonicalName>ShowValueTracking</CanonicalName>
+          <LocCanonicalName>ViewEditorConfigSettings</LocCanonicalName>
+        </Strings>
+      </Button>
     </Buttons>
 
     <Menus>
@@ -516,6 +529,10 @@
     <CommandPlacement guid="guidRoslynGrpId" id="cmdidRemoveUnusedReferences" priority="0xF200">
       <Parent guid="guidSHLMainMenu" id="IDG_VS_CTXT_REFROOT_ADD" />
     </CommandPlacement>
+
+    <CommandPlacement guid="guidRoslynGrpId" id="cmdidshowValueTracking" priority="0x0203">
+      <Parent guid="guidSHLMainMenu" id="IDG_VS_CODEWIN_NAVIGATETOLOCATION"/>
+    </CommandPlacement>
   </CommandPlacements>
 
   <KeyBindings>
@@ -601,6 +618,8 @@
       <IDSymbol name="cmdidRunCodeAnalysisForProject"  value="0x0201" />
 
       <IDSymbol name="cmdidRemoveUnusedReferences" value="0x202" />
+
+      <IDSymbol name="cmdidshowValueTracking"  value="0x0203" />
     </GuidSymbol>
 
     <GuidSymbol name="guidCSharpInteractiveCommandSet" value="{1492db0a-85a2-4e43-bf0d-ce55b89a8cc6}">

src/VisualStudio/Core/Def/Guids.cs

@@ -125,6 +125,9 @@ internal static class Guids
         public static readonly Guid RoslynCommandSetId = new(RoslynCommandSetIdString);
         public static readonly Guid RoslynGroupId = new(RoslynGroupIdString);
 
+        public const string ValueTrackingToolWindowIdString = "60a19d42-2dd7-43f3-be90-c7a9cb7d28f4";
+        public static readonly Guid ValueTrackingToolWindowId = new(ValueTrackingToolWindowIdString);
+
         // TODO: Remove pending https://github.com/dotnet/roslyn/issues/8927 .
         // Interactive guids
         public const string InteractiveCommandSetIdString = "00B8868B-F9F5-4970-A048-410B05508506";

src/VisualStudio/Core/Def/ID.RoslynCommands.cs

@@ -50,6 +50,7 @@ public static class RoslynCommands
 
             public const int RunCodeAnalysisForProject = 0x0201;
             public const int RemoveUnusedReferences = 0x0202;
+            public const int GoToValueTrackingWindow = 0x0203;
         }
     }
 }

src/VisualStudio/Core/Def/Implementation/CommandBindings.cs

@@ -8,6 +8,7 @@
 using Microsoft.CodeAnalysis.Editor.Commanding.Commands;
 using Microsoft.VisualStudio.Editor.Commanding;
 using Microsoft.VisualStudio.LanguageServices;
+using Microsoft.VisualStudio.LanguageServices.ValueTracking;
 
 namespace Microsoft.VisualStudio.Editor.Implementation
 {
@@ -28,5 +29,9 @@ internal sealed class CommandBindings
         [Export]
         [CommandBinding(Guids.CSharpGroupIdString, ID.CSharpCommands.ContextOrganizeRemoveAndSort, typeof(SortAndRemoveUnnecessaryImportsCommandArgs))]
         internal CommandBindingDefinition contextOrganizeRemoveAndSortCommandBinding;
+
+        [Export]
+        [CommandBinding(Guids.RoslynGroupIdString, ID.RoslynCommands.GoToValueTrackingWindow, typeof(ValueTrackingEditorCommandArgs))]
+        internal CommandBindingDefinition gotoDataFlowToolCommandBinding;
     }
 }

src/VisualStudio/Core/Def/PackageRegistration.pkgdef

@@ -24,3 +24,9 @@
 "Value"=dword:00000000
 "Title"="Enable experimental C#/VB LSP completion experience"
 "PreviewPaneChannels"="IntPreview,int.main"
+
+// The option page configuration is duplicated in RoslynPackage
+// [ProvideToolWindow(typeof(ValueTracking.ValueTrackingToolWindow))]
+[$RootKey$\ToolWindows\{60a19d42-2dd7-43f3-be90-c7a9cb7d28f4}]
+"Name"="Microsoft.VisualStudio.LanguageServices.ValueTracking.ValueTrackingToolWindow"
+@="{6cf2e545-6109-4730-8883-cf43d7aec3e1}"

src/VisualStudio/Core/Def/RoslynPackage.cs

@@ -19,28 +19,23 @@
 using Microsoft.CodeAnalysis.Logging;
 using Microsoft.CodeAnalysis.Notification;
 using Microsoft.CodeAnalysis.Options;
-using Microsoft.CodeAnalysis.Remote;
 using Microsoft.CodeAnalysis.Telemetry;
 using Microsoft.CodeAnalysis.Versions;
 using Microsoft.VisualStudio.ComponentModelHost;
 using Microsoft.VisualStudio.LanguageServices.ColorSchemes;
 using Microsoft.VisualStudio.LanguageServices.Experimentation;
 using Microsoft.VisualStudio.LanguageServices.Implementation;
-using Microsoft.VisualStudio.LanguageServices.Implementation.DesignerAttribute;
 using Microsoft.VisualStudio.LanguageServices.Implementation.Diagnostics;
 using Microsoft.VisualStudio.LanguageServices.Implementation.Interactive;
 using Microsoft.VisualStudio.LanguageServices.Implementation.LanguageService;
 using Microsoft.VisualStudio.LanguageServices.Implementation.ProjectSystem;
 using Microsoft.VisualStudio.LanguageServices.Implementation.ProjectSystem.RuleSets;
-using Microsoft.VisualStudio.LanguageServices.Implementation.ProjectTelemetry;
 using Microsoft.VisualStudio.LanguageServices.Implementation.TableDataSource;
-using Microsoft.VisualStudio.LanguageServices.Implementation.TodoComments;
 using Microsoft.VisualStudio.LanguageServices.Implementation.UnusedReferences;
 using Microsoft.VisualStudio.LanguageServices.Telemetry;
 using Microsoft.VisualStudio.PlatformUI;
 using Microsoft.VisualStudio.Shell;
 using Microsoft.VisualStudio.Shell.Interop;
-using Microsoft.VisualStudio.Shell.ServiceBroker;
 using Microsoft.VisualStudio.TaskStatusCenter;
 using Microsoft.VisualStudio.Telemetry;
 using Microsoft.VisualStudio.TextManager.Interop;
@@ -51,6 +46,9 @@
 namespace Microsoft.VisualStudio.LanguageServices.Setup
 {
     [Guid(Guids.RoslynPackageIdString)]
+
+    // The option page configuration is duplicated in PackageRegistration.pkgdef
+    [ProvideToolWindow(typeof(ValueTracking.ValueTrackingToolWindow))]
     internal sealed class RoslynPackage : AbstractPackage
     {
         // The randomly-generated key name is used for serializing the ILSpy decompiler EULA preference to the .SUO
@@ -188,6 +186,19 @@ protected override async Task LoadComponentsAsync(CancellationToken cancellation
             LoadComponentsBackgroundAsync(cancellationToken).Forget();
         }
 
+        // Overrides for VSSDK003 fix 
+        // See https://github.com/Microsoft/VSSDK-Analyzers/blob/main/doc/VSSDK003.md
+        public override IVsAsyncToolWindowFactory GetAsyncToolWindowFactory(Guid toolWindowType)
+            => toolWindowType == typeof(ValueTracking.ValueTrackingToolWindow).GUID
+                ? this
+                : base.GetAsyncToolWindowFactory(toolWindowType);
+
+        protected override string GetToolWindowTitle(Type toolWindowType, int id)
+                => base.GetToolWindowTitle(toolWindowType, id);
+
+        protected override Task<object?> InitializeToolWindowAsync(Type toolWindowType, int id, CancellationToken cancellationToken)
+            => Task.FromResult((object?)null);
+
         private async Task LoadComponentsBackgroundAsync(CancellationToken cancellationToken)
         {
             await TaskScheduler.Default;

src/VisualStudio/Core/Def/ValueTracking/BindableTextBlock.cs

@@ -0,0 +1,37 @@
+// 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.ObjectModel;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Documents;
+using Roslyn.Utilities;
+
+namespace Microsoft.VisualStudio.LanguageServices.ValueTracking
+{
+    internal class BindableTextBlock : TextBlock
+    {
+        public IList<Inline> InlineCollection
+        {
+            get { return (ObservableCollection<Inline>)GetValue(InlineListProperty); }
+            set { SetValue(InlineListProperty, value); }
+        }
+
+        public static readonly DependencyProperty InlineListProperty =
+            DependencyProperty.Register(nameof(InlineCollection), typeof(IList<Inline>), typeof(BindableTextBlock), new UIPropertyMetadata(null, OnPropertyChanged));
+
+        private static void OnPropertyChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
+        {
+            var textBlock = (BindableTextBlock)sender;
+            var newList = (IList<Inline>)e.NewValue;
+
+            textBlock.Inlines.Clear();
+            foreach (var inline in newList)
+            {
+                textBlock.Inlines.Add(inline);
+            }
+        }
+    }
+}

src/VisualStudio/Core/Def/ValueTracking/EmptyTreeViewItem.cs

@@ -0,0 +1,15 @@
+// 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.VisualStudio.LanguageServices.ValueTracking
+{
+    internal class EmptyTreeViewItem : TreeViewItemBase
+    {
+        public static EmptyTreeViewItem Instance { get; } = new();
+
+        private EmptyTreeViewItem()
+        {
+        }
+    }
+}

src/VisualStudio/Core/Def/ValueTracking/TreeViewItemBase.cs

@@ -0,0 +1,43 @@
+// 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.ComponentModel;
+using System.Runtime.CompilerServices;
+
+namespace Microsoft.VisualStudio.LanguageServices.ValueTracking
+{
+    internal class TreeViewItemBase : INotifyPropertyChanged
+    {
+        private bool _isExpanded = false;
+        public bool IsNodeExpanded
+        {
+            get => _isExpanded;
+            set => SetProperty(ref _isExpanded, value);
+        }
+
+        private bool _isSelected = false;
+        public bool IsNodeSelected
+        {
+            get => _isSelected;
+            set => SetProperty(ref _isSelected, value);
+        }
+
+        public event PropertyChangedEventHandler? PropertyChanged;
+
+        protected void SetProperty<T>(ref T field, T value, [CallerMemberName] string name = "")
+        {
+            if (EqualityComparer<T>.Default.Equals(field, value))
+            {
+                return;
+            }
+
+            field = value;
+            NotifyPropertyChanged(name);
+        }
+
+        protected void NotifyPropertyChanged(string name)
+            => PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(name));
+    }
+}