Revert "Merge pull request #54654 from CyrusNajmabadi/farOrder2"

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

@@ -33,17 +33,19 @@ internal class DelegateInvokeMethodReferenceFinder : AbstractReferenceFinder<IMe
  protected override bool CanFind(IMethodSymbol symbol)
  => symbol.MethodKind == MethodKind.DelegateInvoke;
 
- protected override async Task<ImmutableArray<ISymbol>> DetermineCascadedSymbolsAsync(
+ protected override async Task<ImmutableArray<(ISymbol symbol, FindReferencesCascadeDirection cascadeDirection)>> DetermineCascadedSymbolsAsync(
  IMethodSymbol symbol,
  Solution solution,
+ IImmutableSet<Project> projects,
  FindReferencesSearchOptions options,
+ FindReferencesCascadeDirection cascadeDirection,
  CancellationToken cancellationToken)
  {
- using var _ = ArrayBuilder<ISymbol>.GetInstance(out var result);
+ using var _ = ArrayBuilder<(ISymbol symbol, FindReferencesCascadeDirection cascadeDirection)>.GetInstance(out var result);
 
  var beginInvoke = symbol.ContainingType.GetMembers(WellKnownMemberNames.DelegateBeginInvokeName).FirstOrDefault();
  if (beginInvoke != null)
- result.Add(beginInvoke);
+ result.Add((beginInvoke, cascadeDirection));
 
  // All method group references
  foreach (var project in solution.Projects)
@@ -53,7 +55,7 @@ protected override async Task<ImmutableArray<ISymbol>> DetermineCascadedSymbolsA
  var changeSignatureService = document.GetLanguageService<AbstractChangeSignatureService>();
  var cascaded = await changeSignatureService.DetermineCascadedSymbolsFromDelegateInvokeAsync(
  symbol, document, cancellationToken).ConfigureAwait(false);
- result.AddRange(cascaded);
+ result.AddRange(cascaded.SelectAsArray(s => (s, cascadeDirection)));
  }
  }
 

src/Workspaces/Core/Portable/FindSymbols/FindReferences/DependentTypeFinder.cs

@@ -83,33 +83,20 @@ private static async Task<ImmutableArray<INamedTypeSymbol>> DescendInheritanceTr
  // are passed in. There is no need to check D as there's no way it could
  // contribute an intermediate type that affects A or C. We only need to check
  // A, B and C
- //
- // An exception to the above rule is if we're just searching a single project.
- // in that case there can be no intermediary projects that could add types.
- // So we can just limit ourselves to that single project.
 
  // First find all the projects that could potentially reference this type.
- List<Project> orderedProjectsToExamine;
+ var projectsThatCouldReferenceType = await GetProjectsThatCouldReferenceTypeAsync(
+ type, solution, searchInMetadata, cancellationToken).ConfigureAwait(false);
 
- if (projects.Count == 1)
- {
- orderedProjectsToExamine = projects.ToList();
- }
- else
- {
- var projectsThatCouldReferenceType = await GetProjectsThatCouldReferenceTypeAsync(
- type, solution, searchInMetadata, cancellationToken).ConfigureAwait(false);
-
- // Now, based on the list of projects that could actually reference the type,
- // and the list of projects the caller wants to search, find the actual list of
- // projects we need to search through.
- //
- // This list of projects is properly topologically ordered. Because of this we
- // can just process them in order from first to last because we know no project
- // in this list could affect a prior project.
- orderedProjectsToExamine = GetOrderedProjectsToExamine(
- solution, projects, projectsThatCouldReferenceType);
- }
+ // Now, based on the list of projects that could actually reference the type,
+ // and the list of projects the caller wants to search, find the actual list of
+ // projects we need to search through.
+ //
+ // This list of projects is properly topologically ordered. Because of this we
+ // can just process them in order from first to last because we know no project
+ // in this list could affect a prior project.
+ var orderedProjectsToExamine = GetOrderedProjectsToExamine(
+ solution, projects, projectsThatCouldReferenceType);
 
  // The final set of results we'll be returning.
  using var _1 = GetSymbolSet(out var result);
@@ -291,7 +278,7 @@ private static IEnumerable<ProjectId> GetProjectsThatCouldReferenceType(
  {
  // Get all the projects that depend on 'project' as well as 'project' itself.
  return dependencyGraph.GetProjectsThatTransitivelyDependOnThisProject(project.Id)
- .Concat(project.Id);
+  .Concat(project.Id);
  }
 
  private static List<Project> GetOrderedProjectsToExamine(

src/Workspaces/Core/Portable/FindSymbols/FindReferences/FindReferencesCascadeDirection.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;
+
+namespace Microsoft.CodeAnalysis.FindSymbols
+{
+ [Flags]
+ internal enum FindReferencesCascadeDirection
+ {
+ /// <summary>
+ /// Cascade up the inheritance hierarchy.
+ /// </summary>
+ Up = 1,
+
+ /// <summary>
+ /// Cascade down the inheritance hierarchy.
+ /// </summary>
+ Down = 2,
+
+ /// <summary>
+ /// Cascade in both directions.
+ /// </summary>
+ UpAndDown = Up | Down,
+ }
+
+ internal static class FindReferencesCascadeDirectionExtensions
+ {
+ public static bool HasFlag(this FindReferencesCascadeDirection value, FindReferencesCascadeDirection flag)
+ => (value & flag) == flag;
+ }
+}