Add support for displaying reference kind in Find All References window.

src/EditorFeatures/Core/FindUsages/AbstractFindUsagesService.ProgressAdapter.cs

@@ -35,7 +35,7 @@ public async Task OnReferenceFoundAsync(Document document, TextSpan span)
                 var documentSpan = await ClassifiedSpansAndHighlightSpanFactory.GetClassifiedDocumentSpanAsync(
                     document, span, _context.CancellationToken).ConfigureAwait(false);
                 await _context.OnReferenceFoundAsync(new SourceReferenceItem(
-                    _definition, documentSpan, isWrittenTo: false)).ConfigureAwait(false);
+                    _definition, documentSpan, ValueUsageInfo.None)).ConfigureAwait(false);
             }
 
             public Task ReportProgressAsync(int current, int maximum)

src/EditorFeatures/Core/FindUsages/IDefinitionsAndReferencesFactory.cs

@@ -187,7 +187,7 @@ public static async Task<SourceReferenceItem> TryCreateSourceReferenceItemAsync(
             var documentSpan = await ClassifiedSpansAndHighlightSpanFactory.GetClassifiedDocumentSpanAsync(
                 document, sourceSpan, cancellationToken).ConfigureAwait(false);
 
-            return new SourceReferenceItem(definitionItem, documentSpan, referenceLocation.IsWrittenTo);
+            return new SourceReferenceItem(definitionItem, documentSpan, referenceLocation.ValueUsageInfo);
         }
 
         private static SymbolDisplayFormat GetFormat(ISymbol definition)

src/Features/Core/Portable/ChangeSignature/DelegateInvokeMethodReferenceFinder.cs

@@ -81,6 +81,7 @@ protected override async Task<ImmutableArray<FinderLocation>> FindReferencesInDo
             // FAR on the Delegate type and use those results to find Invoke calls
 
             var syntaxFactsService = document.GetLanguageService<ISyntaxFactsService>();
+            var semanticFactsService = document.GetLanguageService<ISemanticFactsService>();
 
             var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
             var nodes = root.DescendantNodes();
@@ -104,7 +105,8 @@ protected override async Task<ImmutableArray<FinderLocation>> FindReferencesInDo
                 .Where(e => semanticModel.GetSymbolInfo(e, cancellationToken).Symbol.OriginalDefinition == methodSymbol);
 
             return invocations.Concat(convertedAnonymousFunctions).SelectAsArray(
-                n => new FinderLocation(n, new ReferenceLocation(document, null, n.GetLocation(), isImplicit: false, isWrittenTo: false, candidateReason: CandidateReason.None)));
+                n => new FinderLocation(n, new ReferenceLocation(document, null, n.GetLocation(), isImplicit: false,
+                    valueUsageInfo: semanticModel.GetValueUsageInfo(n, semanticFactsService, cancellationToken), candidateReason: CandidateReason.None)));
         }
     }
 }

src/Features/Core/Portable/FindUsages/SourceReferenceItem.cs

@@ -1,6 +1,8 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
 using System;
+using System.Collections.Concurrent;
+using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.FindUsages
 {
@@ -10,6 +12,11 @@ namespace Microsoft.CodeAnalysis.FindUsages
     /// </summary>
     internal sealed class SourceReferenceItem
     {
+        // We can have only a handful of different values for ValueUsageInfo flags enum, so the maximum size of this dictionary is capped.
+        // So, we store this as a static dictionary which will be held in memory for the lifetime of the process.
+        private static readonly ConcurrentDictionary<ValueUsageInfo, MultiDictionary<string, string>> s_valueUsageInfoToReferenceInfoMap
+            = new ConcurrentDictionary<ValueUsageInfo, MultiDictionary<string, string>>();
+
         /// <summary>
         /// The definition this reference corresponds to.
         /// </summary>
@@ -25,11 +32,49 @@ internal sealed class SourceReferenceItem
         /// </summary>
         public bool IsWrittenTo { get; }
 
+        /// <summary>
+        /// Additional information about the reference.
+        /// Each entry represents a key-values pair of data. For example, consider the below entry:
+        ///     { "ValueUsageInfo" } = { "Read", "Write" }
+        /// This entry indicates that the reference has additional value usage information which indicate
+        /// it is a read/write reference, such as say 'a++'.
+        /// </summary>
+        public MultiDictionary<string, string> ReferenceInfo { get; }
+
+        [Obsolete]
         public SourceReferenceItem(DefinitionItem definition, DocumentSpan sourceSpan, bool isWrittenTo)
         {
             Definition = definition;
             SourceSpan = sourceSpan;
             IsWrittenTo = isWrittenTo;
+            ReferenceInfo = GetOrCreateReferenceInfo(ValueUsageInfo.None);
+        }
+
+        public SourceReferenceItem(DefinitionItem definition, DocumentSpan sourceSpan, MultiDictionary<string, string> referenceInfo)
+        {
+            Definition = definition;
+            SourceSpan = sourceSpan;
+            ReferenceInfo = referenceInfo ?? throw new ArgumentNullException(nameof(referenceInfo));
+        }
+
+        internal SourceReferenceItem(DefinitionItem definition, DocumentSpan sourceSpan, ValueUsageInfo valueUsageInfo)
+            : this(definition, sourceSpan, GetOrCreateReferenceInfo(valueUsageInfo))
+        {
+            IsWrittenTo = valueUsageInfo.IsWrittenTo();
+        }
+
+        private static MultiDictionary<string, string> GetOrCreateReferenceInfo(ValueUsageInfo valueUsageInfo)
+            => s_valueUsageInfoToReferenceInfoMap.GetOrAdd(valueUsageInfo, CreateReferenceInfo);
+
+        private static MultiDictionary<string, string> CreateReferenceInfo(ValueUsageInfo valueUsageInfo)
+        {
+            var referenceInfo = new MultiDictionary<string, string>();
+            foreach (var value in valueUsageInfo.ToLocalizableValues())
+            {
+                referenceInfo.Add(nameof(ValueUsageInfo), value);
+            }
+
+            return referenceInfo;
         }
     }
 }

src/Features/Core/Portable/MakeFieldReadonly/MakeFieldReadonlyDiagnosticAnalyzer.cs

@@ -155,7 +155,7 @@ private static bool IsFieldWrite(IFieldReferenceOperation fieldReference, ISymbo
         {
             // Check if the underlying member is being written or a writable reference to the member is taken.
             var valueUsageInfo = fieldReference.GetValueUsageInfo();
-            if (!valueUsageInfo.ContainsWriteOrWritableRef())
+            if (!valueUsageInfo.IsWrittenTo())
             {
                 return false;
             }

src/Features/Core/Portable/RemoveUnusedMembers/AbstractRemoveUnusedMembersDiagnosticAnalyzer.cs

@@ -1,4 +1,4 @@
-// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
 using System.Collections.Generic;
 using System.Collections.Immutable;
@@ -263,7 +263,7 @@ private void OnSymbolEnd(SymbolAnalysisContext symbolEndContext, bool hasInvalid
                         // Check if the underlying member is neither read nor a readable reference to the member is taken.
                         // If so, we flag the member as either unused (never written) or unread (written but not read).
                         if (TryRemove(member, out var valueUsageInfo) &&
-                            !valueUsageInfo.ContainsReadOrReadableRef())
+                            !valueUsageInfo.IsReadFrom())
                         {
                             Debug.Assert(IsCandidateSymbol(member));
                             Debug.Assert(!member.IsImplicitlyDeclared);
@@ -299,7 +299,7 @@ private void OnSymbolEnd(SymbolAnalysisContext symbolEndContext, bool hasInvalid
                             }
 
                             // Report IDE0051 or IDE0052 based on whether the underlying member has any Write/WritableRef/NonReadWriteRef references or not.
-                            var rule = !valueUsageInfo.ContainsWriteOrWritableRef() && !valueUsageInfo.ContainsNonReadWriteRef() && !symbolsReferencedInDocComments.Contains(member)
+                            var rule = !valueUsageInfo.IsWrittenTo() && !valueUsageInfo.IsNameReference() && !symbolsReferencedInDocComments.Contains(member)
                                 ? s_removeUnusedMembersRule
                                 : s_removeUnreadMembersRule;
 
@@ -466,4 +466,4 @@ private bool IsEntryPoint(IMethodSymbol methodSymbol)
                     methodSymbol.ReturnType.OriginalDefinition == _genericTaskType);
         }
     }
-}
+}

src/VisualStudio/Core/Def/Implementation/FindReferences/AbstractFindUsagesCustomColumnDefinition.cs

@@ -0,0 +1,46 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Linq;
+using Microsoft.VisualStudio.Shell.TableControl;
+using Roslyn.Utilities;
+
+namespace Microsoft.VisualStudio.LanguageServices.FindUsages
+{
+    /// <summary>
+    /// Implementation of a custom, dynamic column for the Find All References window.
+    /// </summary>
+    internal abstract class AbstractFindUsagesCustomColumnDefinition : TableColumnDefinitionBase
+    {
+        protected AbstractFindUsagesCustomColumnDefinition()
+        {
+            DefaultColumnState = new ColumnState2(Name, isVisible: false, DefaultWidth);
+        }
+
+        public ColumnState2 DefaultColumnState { get; }
+
+        public override bool TryGetFilterItems(ITableEntryHandle entry, out IEnumerable<string> filterItems)
+        {
+            // Determine the constituent strings for the display value in column, which should be used for applying the filter.
+            // For example, if value "Read, Write" is displayed in column for an entry, we will return "Read" and "Write" here,
+            // so filtering based on individual filter terms can be done.
+            if (IsFilterable &&
+                entry.TryGetValue(Name, out var value) &&
+                value is string displayString &&
+                !string.IsNullOrEmpty(displayString))
+            {
+                filterItems = SplitColumnDisplayValue(displayString);
+                return true;
+            }
+
+            return base.TryGetFilterItems(entry, out filterItems);
+        }
+
+        public abstract string GetDisplayStringForColumnValues(MultiDictionary<string, string>.ValueSet values);
+        protected abstract IEnumerable<string> SplitColumnDisplayValue(string displayValue);
+
+        protected static string JoinValues(MultiDictionary<string, string>.ValueSet values) => string.Join(", ", values.Order());
+        protected static IEnumerable<string> SplitAndTrimValue(string displayValue) => displayValue.Split(',').Select(v => v.Trim());
+    }
+}