Simplify how we display reference counts for find-ref items.

src/VisualStudio/Core/Def/Implementation/Library/FindResults/LibraryManager_FindReferences.cs

@@ -31,51 +31,50 @@ public void PresentDefinitionsAndReferences(DefinitionsAndReferences definitions
 
             var query = from d in definitionsAndReferences.Definitions
                         from i in CreateDefinitionItems(d, definitionsAndReferences, commonPathElements)
-                        select i;
+                        select (AbstractTreeItem)i;
 
             return query.ToList();
         }
 
-        private IEnumerable<AbstractTreeItem> CreateDefinitionItems(
+        private ImmutableArray<DefinitionTreeItem> CreateDefinitionItems(
             DefinitionItem definitionItem,
             DefinitionsAndReferences definitionsAndReferences,
             int commonPathElements)
         {
-            // Each definition item may end up as several top nodes (because of partials).
-            // Add the references to the last item actually in the list.
-            var definitionTreeItems = ConvertToDefinitionTreeItems(definitionItem);
-            if (!definitionTreeItems.IsEmpty)
-            {
-                var lastTreeItem = definitionTreeItems.Last();
-                var referenceItems = CreateReferenceItems(
-                    definitionItem, definitionsAndReferences, commonPathElements);
-
-                lastTreeItem.Children.AddRange(referenceItems);
-                lastTreeItem.SetReferenceCount(referenceItems.Count);
-            }
+            var referenceItems = CreateReferenceItems(
+                definitionItem, definitionsAndReferences, commonPathElements);
 
-            return definitionTreeItems;
+            return ConvertToDefinitionTreeItems(definitionItem, referenceItems);
         }
 
-        private ImmutableArray<AbstractTreeItem> ConvertToDefinitionTreeItems(
-            DefinitionItem definitionItem)
+        private ImmutableArray<DefinitionTreeItem> ConvertToDefinitionTreeItems(
+            DefinitionItem definitionItem,
+            ImmutableArray<SourceReferenceTreeItem> referenceItems)
         {
-            var result = ImmutableArray.CreateBuilder<AbstractTreeItem>();
+            var result = ImmutableArray.CreateBuilder<DefinitionTreeItem>();
 
-            foreach (var location in definitionItem.Locations)
+            for (int i = 0, n = definitionItem.Locations.Length; i < n; i++)
             {
-                result.Add(new DefinitionTreeItem(definitionItem, location));
+                var location = definitionItem.Locations[i];
+
+                // Each definition item may end up as several top nodes (because of partials).
+                // Add the references to the last item actually in the list.
+                var definitionTreeItem = i == n - 1
+                    ? new DefinitionTreeItem(definitionItem, location)
+                    : new DefinitionTreeItem(definitionItem, location, referenceItems);
+
+                result.Add(definitionTreeItem);
             }
 
             return result.ToImmutable();
         }
 
-        private IList<SourceReferenceTreeItem> CreateReferenceItems(
+        private ImmutableArray<SourceReferenceTreeItem> CreateReferenceItems(
             DefinitionItem definitionItem,
             DefinitionsAndReferences definitionsAndReferences,
             int commonPathElements)
         {
-            var result = new List<SourceReferenceTreeItem>();
+            var result = ImmutableArray.CreateBuilder<SourceReferenceTreeItem>();
 
             var referenceItems = definitionsAndReferences.References.Where(r => r.Definition == definitionItem);
             foreach (var referenceItem in referenceItems)
@@ -95,7 +94,7 @@ public void PresentDefinitionsAndReferences(DefinitionsAndReferences definitions
             }
 
             result.Sort();
-            return result;
+            return result.ToImmutable();
         }
     }
 }
\ No newline at end of file

src/VisualStudio/Core/Def/Implementation/Library/FindResults/LibraryManager_GoToDefinition.cs

@@ -107,7 +107,6 @@ private AbstractTreeItem CreateTreeItem(INavigableItem item, int commonPathEleme
             {
                 var childItems = CreateNavigableItemTreeItems(item.ChildItems, commonPathElements);
                 result.Children.AddRange(childItems);
-                result.SetReferenceCount(childItems.Count);
             }
 
             return result;

src/VisualStudio/Core/Def/Implementation/Library/FindResults/TreeItems/AbstractTreeItem.cs

@@ -39,9 +39,5 @@ public virtual bool CanGoToDefinition()
         {
             return false;
         }
-
-        internal virtual void SetReferenceCount(int referenceCount)
-        {
-        }
     }
-}
+}
\ No newline at end of file

src/VisualStudio/Core/Def/Implementation/Library/FindResults/TreeItems/SourceDefinitionTreeItem.cs → src/VisualStudio/Core/Def/Implementation/Library/FindResults/TreeItems/DefinitionTreeItem.cs

 // 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.Immutable;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Editor.Implementation.FindReferences;
 using Microsoft.CodeAnalysis.Editor.Shared.Extensions;
 using Microsoft.VisualStudio.LanguageServices.Implementation.Utilities;
+using Roslyn.Utilities;
 
 namespace Microsoft.VisualStudio.LanguageServices.Implementation.Library.FindResults
 {
@@ -12,22 +14,47 @@ internal class DefinitionTreeItem : AbstractTreeItem
         private readonly DefinitionItem _definitionItem;
         private readonly DefinitionLocation _definitionLocation;
 
-        public DefinitionTreeItem(DefinitionItem definitionItem, DefinitionLocation definitionLocation)
+        public DefinitionTreeItem(
+            DefinitionItem definitionItem,
+            DefinitionLocation definitionLocation,
+            ImmutableArray<SourceReferenceTreeItem> referenceItems = default(ImmutableArray<SourceReferenceTreeItem>))
             : base(definitionItem.Tags.GetGlyph().GetGlyphIndex())
         {
             _definitionItem = definitionItem;
             _definitionLocation = definitionLocation;
 
+            if (!referenceItems.IsDefault)
+            {
+                this.Children.AddRange(referenceItems);
+            }
+
             this.DisplayText = CreateDisplayText();
         }
 
         private string CreateDisplayText()
         {
             var displayString = _definitionItem.DisplayParts.JoinText();
+            var referenceCount = this.Children.Count;
+
+            var referenceCountDisplay = referenceCount == 1
+                ? ServicesVSResources._1_reference
+                : string.Format(ServicesVSResources._0_references, referenceCount);
+
+            // If we don't have an origination or reference count, then just display the 
+            // parts and nothing else.  These items happen when we're getting third party
+            // results that tell us about their definition location, but not any additional
+            // reference.  We don't want to say '0' references in that case as that can
+            // be misleading.
+            return HasOrigination()
+                ? $"[{_definitionLocation.OriginationParts.JoinText()}] {displayString} ({referenceCountDisplay})"
+                : referenceCount > 0
+                    ? $"{displayString} ({referenceCountDisplay})"
+                    : displayString;
+        }
 
-            return _definitionLocation.OriginationParts.Length == 0
-                ? displayString
-                : $"[{_definitionLocation.OriginationParts.JoinText()}] {displayString}";
+        private bool HasOrigination()
+        {
+            return _definitionLocation.OriginationParts.Length > 0;
         }
 
         public override int GoToSource()
@@ -41,15 +68,5 @@ public override bool CanGoToDefinition()
         {
             return _definitionLocation.CanNavigateTo();
         }
-
-        internal override void SetReferenceCount(int referenceCount)
-        {
-            // source case.
-            var referenceCountDisplay = referenceCount == 1
-                ? ServicesVSResources._1_reference
-                : string.Format(ServicesVSResources._0_references, referenceCount);
-
-            this.DisplayText = CreateDisplayText() + $" ({referenceCountDisplay})";
-        }
     }
 }
\ No newline at end of file

src/VisualStudio/Core/Def/ServicesVisualStudio.csproj

@@ -74,7 +74,7 @@
     <Compile Include="Implementation\LanguageService\AbstractPackage.cs" />
     <Compile Include="Implementation\Library\AbstractLibraryService.cs" />
     <Compile Include="Implementation\Library\ClassView\AbstractSyncClassViewCommandHandler.cs" />
-    <Compile Include="Implementation\Library\FindResults\TreeItems\SourceDefinitionTreeItem.cs" />
+    <Compile Include="Implementation\Library\FindResults\TreeItems\DefinitionTreeItem.cs" />
     <Compile Include="Implementation\Library\ILibraryService.cs" />
     <Compile Include="Implementation\Library\ObjectBrowser\ObjectBrowserTaskExtensions.cs" />
     <Compile Include="Implementation\Library\VsNavInfo\NavInfoNodeEnum.cs" />