Add ability to underline variables in the editor that are reassigned.

src/EditorFeatures/Core.Wpf/BraceMatching/ClassificationTypeFormatDefinitions.cs → src/EditorFeatures/Core.Wpf/BraceMatching/BraceMatchingTypeFormatDefinitions.cs

@@ -13,7 +13,7 @@
 
 namespace Microsoft.CodeAnalysis.Editor.Implementation.BraceMatching
 {
- internal sealed class ClassificationTypeFormatDefinitions
+ internal sealed class BraceMatchingTypeFormatDefinitions
  {
  [Export(typeof(EditorFormatDefinition))]
  [ClassificationType(ClassificationTypeNames = ClassificationTypeDefinitions.BraceMatchingName)]

src/EditorFeatures/Core.Wpf/Microsoft.CodeAnalysis.EditorFeatures.Wpf.csproj

@@ -68,8 +68,6 @@
  <PublicAPI Include="PublicAPI.Shipped.txt" />
  <PublicAPI Include="PublicAPI.Unshipped.txt" />
  </ItemGroup>
- <ItemGroup>
- </ItemGroup>
  <ItemGroup>
  <EmbeddedResource Update="EditorFeaturesWpfResources.resx" GenerateSource="true" />
  </ItemGroup>

src/EditorFeatures/Core.Wpf/ReassignedVariable/ReassignedVariableTypeFormatDefinitions.cs

@@ -0,0 +1,34 @@
+// 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.ComponentModel.Composition;
+using System.Diagnostics.CodeAnalysis;
+using Microsoft.CodeAnalysis.Classification;
+using Microsoft.CodeAnalysis.Host.Mef;
+using Microsoft.VisualStudio.Text.Classification;
+using Microsoft.VisualStudio.Utilities;
+
+namespace Microsoft.CodeAnalysis.Editor.Implementation.ReassignedVariable
+{
+ internal sealed class ReassignedVariableTypeFormatDefinitions
+ {
+ [Export(typeof(EditorFormatDefinition))]
+ [ClassificationType(ClassificationTypeNames = ClassificationTypeNames.ReassignedVariable)]
+ [Name(ClassificationTypeNames.ReassignedVariable)]
+ [Order(After = Priority.High)]
+ [UserVisible(false)]
+ [ExcludeFromCodeCoverage]
+ private class ReassignedVariableFormatDefinition : ClassificationFormatDefinition
+ {
+ [ImportingConstructor]
+ [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
+ public ReassignedVariableFormatDefinition()
+ {
+ this.DisplayName = EditorFeaturesResources.Reassigned_variable;
+ this.TextDecorations = System.Windows.TextDecorations.Underline;
+ }
+ }
+ }
+}

src/EditorFeatures/Core/EditorFeaturesResources.resx

@@ -951,4 +951,7 @@ Do you want to proceed?</value>
  <data name="Gathering_Suggestions_Waiting_for_the_solution_to_fully_load" xml:space="preserve">
  <value>Gathering Suggestions - Waiting for the solution to fully load</value>
  </data>
+ <data name="Reassigned_variable" xml:space="preserve">
+ <value>Reassigned variable</value>
+ </data>
 </root>

src/EditorFeatures/Core/Implementation/ReassignedVariable/ReassignedVariableClassificationTypeDefinitions.cs

@@ -0,0 +1,20 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.ComponentModel.Composition;
+using Microsoft.CodeAnalysis.Classification;
+using Microsoft.VisualStudio.Language.StandardClassification;
+using Microsoft.VisualStudio.Text.Classification;
+using Microsoft.VisualStudio.Utilities;
+
+namespace Microsoft.CodeAnalysis.Editor.Implementation.ReassignedVariable
+{
+ internal class ReassignedVariableClassificationTypeDefinitions
+ {
+ [Export]
+ [Name(ClassificationTypeNames.ReassignedVariable)]
+ [BaseDefinition(PredefinedClassificationTypeNames.FormalLanguage)]
+ internal readonly ClassificationTypeDefinition? ReassignedVariableTypeDefinition;
+ }
+}

src/EditorFeatures/Core/Implementation/ReassignedVariable/ReassignedVariableOptions.cs

@@ -0,0 +1,33 @@
+// 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.Immutable;
+using System.Composition;
+using Microsoft.CodeAnalysis.Host.Mef;
+using Microsoft.CodeAnalysis.Options;
+using Microsoft.CodeAnalysis.Options.Providers;
+
+namespace Microsoft.CodeAnalysis.Editor.Implementation.UnderlineReassignment
+{
+ internal class ReassignedVariableOptions
+ {
+ public static PerLanguageOption2<bool> Underline =
+ new PerLanguageOption2<bool>(nameof(ReassignedVariableOptions), nameof(Underline), defaultValue: true,
+ storageLocations: new RoamingProfileStorageLocation("TextEditor.%LANGUAGE%.Specific.ReassignedVariable.Underline"));
+ }
+
+ [ExportOptionProvider, Shared]
+ internal class ReassignedVariableOptionsProvider : IOptionProvider
+ {
+ [ImportingConstructor]
+ [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
+ public ReassignedVariableOptionsProvider()
+ {
+ }
+
+ public ImmutableArray<IOption> Options { get; } = ImmutableArray.Create<IOption>(
+ ReassignedVariableOptions.Underline);
+ }
+}

src/EditorFeatures/Core/Implementation/ReassignedVariable/ReassignedVariableViewTaggerProvider.cs

@@ -0,0 +1,118 @@
+// 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.Composition;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.Classification;
+using Microsoft.CodeAnalysis.Editor.Implementation.Classification;
+using Microsoft.CodeAnalysis.Editor.Shared.Extensions;
+using Microsoft.CodeAnalysis.Editor.Shared.Tagging;
+using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
+using Microsoft.CodeAnalysis.Editor.Tagging;
+using Microsoft.CodeAnalysis.Host;
+using Microsoft.CodeAnalysis.Options;
+using Microsoft.CodeAnalysis.ReassignedVariable;
+using Microsoft.CodeAnalysis.Shared.Extensions;
+using Microsoft.CodeAnalysis.Shared.TestHooks;
+using Microsoft.CodeAnalysis.Text.Shared.Extensions;
+using Microsoft.VisualStudio.Text;
+using Microsoft.VisualStudio.Text.Editor;
+using Microsoft.VisualStudio.Text.Tagging;
+using Microsoft.VisualStudio.Utilities;
+using Roslyn.Utilities;
+
+namespace Microsoft.CodeAnalysis.Editor.Implementation.UnderlineReassignment
+{
+ [Export(typeof(IViewTaggerProvider))]
+ [TagType(typeof(ClassificationTag))]
+ [ContentType(ContentTypeNames.RoslynContentType)]
+ internal class ReassignedVariableViewTaggerProvider : AsynchronousViewTaggerProvider<ClassificationTag>
+ {
+ private readonly ClassificationTypeMap _typeMap;
+
+ [ImportingConstructor]
+ [SuppressMessage("RoslynDiagnosticsReliability", "RS0033:Importing constructor should be [Obsolete]", Justification = "Used in test code: https://github.com/dotnet/roslyn/issues/42814")]
+ public ReassignedVariableViewTaggerProvider(
+ IThreadingContext threadingContext,
+ IForegroundNotificationService notificationService,
+ ClassificationTypeMap typeMap,
+ IAsynchronousOperationListenerProvider listenerProvider)
+ : base(threadingContext, listenerProvider.GetListener(FeatureAttribute.Classification), notificationService)
+ {
+ _typeMap = typeMap;
+ }
+
+ protected override IEnumerable<PerLanguageOption2<bool>> PerLanguageOptions => SpecializedCollections.SingletonEnumerable(ReassignedVariableOptions.Underline);
+
+ protected override ITaggerEventSource CreateEventSource(ITextView textView, ITextBuffer subjectBuffer)
+ {
+ this.AssertIsForeground();
+ const TaggerDelay Delay = TaggerDelay.Short;
+
+ // Note: we don't listen for OnTextChanged. They'll get reported by the ViewSpan changing and also the
+ // SemanticChange notification. 
+ // 
+ // Note: when the user scrolls, we will try to reclassify variables as soon as possible. That way we appear
+ // unclassified for a very short amount of time.
+ //
+ // Note: because we use frozen-partial documents for classifying these, we may end up with incomplete
+ // semantics (esp. during solution load). Because of this, we also register to hear when the full
+ // compilation is available so that reclassify and bring ourselves up to date.
+ return new CompilationAvailableTaggerEventSource(
+ subjectBuffer, Delay,
+ ThreadingContext,
+ AsyncListener,
+ TaggerEventSources.OnViewSpanChanged(ThreadingContext, textView, textChangeDelay: Delay, scrollChangeDelay: TaggerDelay.NearImmediate),
+ TaggerEventSources.OnWorkspaceChanged(subjectBuffer, Delay, this.AsyncListener),
+ TaggerEventSources.OnDocumentActiveContextChanged(subjectBuffer, Delay));
+ }
+
+ protected override IEnumerable<SnapshotSpan> GetSpansToTag(ITextView textView, ITextBuffer subjectBuffer)
+ {
+ this.AssertIsForeground();
+
+ // Find the visible span some 100 lines +/- what's actually in view. This way
+ // if the user scrolls up/down, we'll already have the results.
+ var visibleSpan = textView.GetVisibleLinesSpan(subjectBuffer, extraLines: 100);
+ if (visibleSpan == null)
+ {
+ // Couldn't find anything visible, just fall back to classifying everything.
+ return base.GetSpansToTag(textView, subjectBuffer);
+ }
+
+ return SpecializedCollections.SingletonEnumerable(visibleSpan.Value);
+ }
+
+ protected override void ProduceTagsSynchronously(TaggerContext<ClassificationTag> context, DocumentSnapshotSpan spanToTag, int? caretPosition)
+ {
+ // Assert just so we can find out who is calling this. We should never be used in synchronous scenarios.
+ Debug.Fail("Unsupported call to ProduceTagsSynchronously");
+ }
+
+ protected override async Task ProduceTagsAsync(TaggerContext<ClassificationTag> context, DocumentSnapshotSpan spanToTag, int? caretPosition)
+ {
+ var cancellationToken = context.CancellationToken;
+
+ var document = spanToTag.Document;
+ if (document == null)
+ return;
+
+ document = document.WithFrozenPartialSemantics(cancellationToken);
+ var service = document.GetLanguageService<IReassignedVariableService>();
+ if (service == null)
+ return;
+
+ var snapshotSpan = spanToTag.SnapshotSpan;
+ var reassignedVariables = await service.GetReassignedVariablesAsync(
+ document, snapshotSpan.Span.ToTextSpan(), cancellationToken).ConfigureAwait(false);
+
+ var tag = new ClassificationTag(_typeMap.GetClassificationType(ClassificationTypeNames.ReassignedVariable));
+ foreach (var variable in reassignedVariables)
+ context.AddTag(new TagSpan<ClassificationTag>(variable.ToSnapshotSpan(snapshotSpan.Snapshot), tag));
+ }
+ }
+}