Allow clients to specify the behavior they want on hidden locations.

src/EditorFeatures/Core/FindReferences/AbstractFindReferencesService.cs

@@ -89,7 +89,7 @@ private bool TryDisplayReferences(Tuple<IEnumerable<ReferencedSymbol>, Solution>
                 var solution = result.Item2;
                 var factory = solution.Workspace.Services.GetService<IDefinitionsAndReferencesFactory>();
                 var definitionsAndReferences = factory.CreateDefinitionsAndReferences(
-                    solution, result.Item1);
+                    solution, result.Item1, includeHiddenLocations: false);
 
                 foreach (var presenter in _referenceSymbolPresenters)
                 {

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

@@ -40,7 +40,7 @@ public ProgressAdapter(Solution solution, IFindUsagesContext context)
             {
                 _solution = solution;
                 _context = context;
-                _definitionFactory = s => s.ToDefinitionItem(solution);
+                _definitionFactory = s => s.ToDefinitionItem(solution, includeHiddenLocations: false);
             }
 
             // Do nothing functions.  The streaming far service doesn't care about
@@ -77,7 +77,7 @@ public async Task OnReferenceFoundAsync(SymbolAndProjectId definition, Reference
                 }
 
                 var referenceItem = location.TryCreateSourceReferenceItem(
-                    GetDefinitionItem(definition));
+                    GetDefinitionItem(definition), includeHiddenLocations: false);
 
                 if (referenceItem != null)
                 {

src/EditorFeatures/Core/FindUsages/AbstractFindUsagesService.cs

@@ -36,7 +36,8 @@ public async Task FindImplementationsAsync(Document document, int position, IFin
 
             foreach (var implementation in tuple.Value.implementations)
             {
-                var definitionItem = implementation.ToDefinitionItem(project.Solution);
+                var definitionItem = implementation.ToDefinitionItem(
+                    project.Solution, includeHiddenLocations: false);
                 await context.OnDefinitionFoundAsync(definitionItem).ConfigureAwait(false);
             }
         }

src/EditorFeatures/Core/GoToDefinition/GoToDefinitionHelpers.cs

@@ -112,7 +112,7 @@ internal static class GoToDefinitionHelpers
                 return false;
             }
 
-            var definition = symbol.ToDefinitionItem(solution);
+            var definition = symbol.ToDefinitionItem(solution, includeHiddenLocations: false);
             var context = presenter.StartSearch(EditorFeaturesResources.Go_to_Definition);
             try
             {

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

@@ -17,7 +17,7 @@ namespace Microsoft.CodeAnalysis.FindUsages
     internal interface IDefinitionsAndReferencesFactory : IWorkspaceService
     {
         DefinitionsAndReferences CreateDefinitionsAndReferences(
-            Solution solution, IEnumerable<ReferencedSymbol> referencedSymbols);
+            Solution solution, IEnumerable<ReferencedSymbol> referencedSymbols, bool includeHiddenLocations);
 
         DefinitionItem GetThirdPartyDefinitionItem(Solution solution, ISymbol definition);
     }
@@ -26,7 +26,7 @@ internal interface IDefinitionsAndReferencesFactory : IWorkspaceService
     internal class DefaultDefinitionsAndReferencesFactory : IDefinitionsAndReferencesFactory
     {
         public DefinitionsAndReferences CreateDefinitionsAndReferences(
-            Solution solution, IEnumerable<ReferencedSymbol> referencedSymbols)
+            Solution solution, IEnumerable<ReferencedSymbol> referencedSymbols, bool includeHiddenLocations)
         {
             var definitions = ArrayBuilder<DefinitionItem>.GetInstance();
             var references = ArrayBuilder<SourceReferenceItem>.GetInstance();
@@ -39,7 +39,8 @@ internal class DefaultDefinitionsAndReferencesFactory : IDefinitionsAndReference
             foreach (var referencedSymbol in referencedSymbols.OrderBy(GetPrecedence))
             {
                 ProcessReferencedSymbol(
-                    solution, referencedSymbol, definitions, references, uniqueLocations);
+                    solution, referencedSymbol, definitions, references,
+                    includeHiddenLocations, uniqueLocations);
             }
 
             return new DefinitionsAndReferences(
@@ -86,6 +87,7 @@ private static int GetPrecedence(ReferencedSymbol referencedSymbol)
             ReferencedSymbol referencedSymbol,
             ArrayBuilder<DefinitionItem> definitions,
             ArrayBuilder<SourceReferenceItem> references,
+            bool includeHiddenLocations,
             HashSet<DocumentSpan> uniqueSpans)
         {
             // See if this is a symbol we even want to present to the user.  If not,
@@ -95,12 +97,15 @@ private static int GetPrecedence(ReferencedSymbol referencedSymbol)
                 return;
             }
 
-            var definitionItem = referencedSymbol.Definition.ToDefinitionItem(solution, uniqueSpans);
+            var definitionItem = referencedSymbol.Definition.ToDefinitionItem(
+                solution, includeHiddenLocations, uniqueSpans);
             definitions.Add(definitionItem);
 
             // Now, create the SourceReferenceItems for all the reference locations
             // for this definition.
-            CreateReferences(referencedSymbol, references, definitionItem, uniqueSpans);
+            CreateReferences(
+                referencedSymbol, references, definitionItem,
+                includeHiddenLocations, uniqueSpans);
 
             // Finally, see if there are any third parties that want to add their
             // own result to our collection.
@@ -125,11 +130,13 @@ private static int GetPrecedence(ReferencedSymbol referencedSymbol)
             ReferencedSymbol referencedSymbol,
             ArrayBuilder<SourceReferenceItem> references,
             DefinitionItem definitionItem,
+            bool includeHiddenLocations,
             HashSet<DocumentSpan> uniqueSpans)
         {
             foreach (var referenceLocation in referencedSymbol.Locations)
             {
-                var sourceReferenceItem = referenceLocation.TryCreateSourceReferenceItem(definitionItem);
+                var sourceReferenceItem = referenceLocation.TryCreateSourceReferenceItem(
+                    definitionItem, includeHiddenLocations);
                 if (sourceReferenceItem == null)
                 {
                     continue;
@@ -148,6 +155,7 @@ internal static class DefinitionItemExtensions
         public static DefinitionItem ToDefinitionItem(
             this ISymbol definition,
             Solution solution,
+            bool includeHiddenLocations,
             HashSet<DocumentSpan> uniqueSpans = null)
         {
             var displayParts = definition.ToDisplayParts(GetFormat(definition)).ToTaggedText();
@@ -170,8 +178,14 @@ internal static class DefinitionItemExtensions
                         return DefinitionItem.CreateMetadataDefinition(
                             tags, displayParts, solution, definition, displayIfNoReferences);
                     }
-                    else if (location.IsVisibleSourceLocation())
+                    else
                     {
+                        if (!location.IsVisibleSourceLocation() &&
+                            !includeHiddenLocations)
+                        {
+                            continue;
+                        }
+
                         var document = solution.GetDocument(location.SourceTree);
                         if (document != null)
                         {
@@ -209,12 +223,14 @@ internal static class DefinitionItemExtensions
 
         public static SourceReferenceItem TryCreateSourceReferenceItem(
             this ReferenceLocation referenceLocation,
-            DefinitionItem definitionItem)
+            DefinitionItem definitionItem,
+            bool includeHiddenLocations)
         {
             var location = referenceLocation.Location;
 
             Debug.Assert(location.IsInSource);
-            if (!location.IsVisibleSourceLocation())
+            if (!location.IsVisibleSourceLocation() &&
+                !includeHiddenLocations)
             {
                 return null;
             }

src/VisualStudio/Core/Impl/RoslynVisualStudioWorkspace.cs

@@ -233,7 +233,8 @@ public override bool TryFindAllReferences(ISymbol symbol, Project project, Cance
             Solution solution, IEnumerable<ReferencedSymbol> referencedSymbols)
         {
             var service = this.Services.GetService<IDefinitionsAndReferencesFactory>();
-            var definitionsAndReferences = service.CreateDefinitionsAndReferences(solution, referencedSymbols);
+            var definitionsAndReferences = service.CreateDefinitionsAndReferences(
+                solution, referencedSymbols, includeHiddenLocations: false);
 
             foreach (var presenter in _referencedSymbolsPresenters)
             {

src/VisualStudio/Core/Test/FindResults/FindResultsTests.vb

@@ -150,7 +150,8 @@ using System.Threading;
                 Dim libraryManager = New LibraryManager(New MockServiceProvider(New MockComponentModel(workspace.ExportProvider)))
 
                 Dim factory = workspace.Services.GetService(Of IDefinitionsAndReferencesFactory)
-                Dim definitionsAndReferences = factory.CreateDefinitionsAndReferences(workspace.CurrentSolution, result)
+                Dim definitionsAndReferences = factory.CreateDefinitionsAndReferences(
+                    workspace.CurrentSolution, result, includeHiddenLocations:=False)
                 Dim findReferencesTree = libraryManager.CreateFindReferencesItems(definitionsAndReferences)
 
                 ' We cannot control the ordering of top-level nodes in the Find Symbol References window, so do not consider ordering of these items here.