public async Task FindImplementationsAsync(Document document, int position, IFindUsagesContext context)
{
var tuple = await FindUsagesHelpers.FindImplementationsAsync(
document, position, context.CancellationToken).ConfigureAwait(false);
if (tuple == null)
{
context.ReportMessage(EditorFeaturesResources.Cannot_navigate_to_the_symbol_under_the_caret);
return;
}
var message = tuple.Value.message;
if (message != null)
{
context.ReportMessage(message);
return;
}
context.SetSearchTitle(string.Format(EditorFeaturesResources._0_implementations,
FindUsagesHelpers.GetDisplayName(tuple.Value.symbol)));
var project = tuple.Value.project;
foreach (var implementation in tuple.Value.implementations)
{
var definitionItem = implementation.ToDefinitionItem(
project.Solution, includeHiddenLocations: false);
await context.OnDefinitionFoundAsync(definitionItem).ConfigureAwait(false);
}
}
private static async Task InspectInterfaceAsync(
IFindUsagesContext context,
INamedTypeSymbol interfaceSymbol,
INamedTypeSymbol namedTypeSymbol,
Project project
)
{
foreach (var interfaceMember in interfaceSymbol.GetMembers())
{
if (context.CancellationToken.IsCancellationRequested)
{
return;
}
var impl = namedTypeSymbol.FindImplementationForInterfaceMember(interfaceMember);
if (impl == null)
{
continue;
}
var definitionItem = impl.ToNonClassifiedDefinitionItem(project.Solution, true);
#pragma warning disable CA2007 // Consider calling ConfigureAwait on the awaited task
await context.OnDefinitionFoundAsync(definitionItem);
#pragma warning restore CA2007 // Consider calling ConfigureAwait on the awaited task
}
}
public async Task FindBasesAsync(Document document, int position, IFindUsagesContext context)
{
var cancellationToken = context.CancellationToken;
var symbolAndProjectOpt = await FindUsagesHelpers.GetRelevantSymbolAndProjectAtPositionAsync(
document, position, cancellationToken).ConfigureAwait(false);
if (symbolAndProjectOpt == null)
{
await context.ReportMessageAsync(
EditorFeaturesResources.Cannot_navigate_to_the_symbol_under_the_caret).ConfigureAwait(false);
return;
}
var(symbol, project) = symbolAndProjectOpt.Value;
var bases = FindBaseHelpers.FindBases(
symbol, project, cancellationToken);
await context.SetSearchTitleAsync(
string.Format(EditorFeaturesResources._0_bases,
FindUsagesHelpers.GetDisplayName(symbol))).ConfigureAwait(false);
var found = false;
// For each potential base, try to find its definition in sources.
// If found, add it's definitionItem to the context.
// If not found but the symbol is from metadata, create it's definition item from metadata and add to the context.
foreach (var baseSymbol in bases)
{
var sourceDefinition = await SymbolFinder.FindSourceDefinitionAsync(
SymbolAndProjectId.Create(baseSymbol, project.Id), project.Solution, cancellationToken).ConfigureAwait(false);
if (sourceDefinition.Symbol != null)
{
var definitionItem = await sourceDefinition.Symbol.ToClassifiedDefinitionItemAsync(
project.Solution.GetProject(sourceDefinition.ProjectId), includeHiddenLocations : false,
FindReferencesSearchOptions.Default, cancellationToken : cancellationToken)
.ConfigureAwait(false);
await context.OnDefinitionFoundAsync(definitionItem).ConfigureAwait(false);
found = true;
}
else if (baseSymbol.Locations.Any(l => l.IsInMetadata))
{
var definitionItem = baseSymbol.ToNonClassifiedDefinitionItem(
project, includeHiddenLocations: true);
await context.OnDefinitionFoundAsync(definitionItem).ConfigureAwait(false);
found = true;
}
}
if (!found)
{
await context.ReportMessageAsync(EditorFeaturesResources.The_symbol_has_no_base)
.ConfigureAwait(false);
}
}
public static async Task FindImplementationsAsync(
ISymbol symbol, Project project, IFindUsagesContext context)
{
var cancellationToken = context.CancellationToken;
var solution = project.Solution;
var client = await RemoteHostClient.TryGetClientAsync(solution.Workspace, cancellationToken).ConfigureAwait(false);
if (client != null)
{
// Create a callback that we can pass to the server process to hear about the
// results as it finds them. When we hear about results we'll forward them to
// the 'progress' parameter which will then update the UI.
var serverCallback = new FindUsagesServerCallback(solution, context);
var success = await client.TryRunRemoteAsync(
WellKnownServiceHubServices.CodeAnalysisService,
nameof(IRemoteFindUsagesService.FindImplementationsAsync),
solution,
new object[]
{
SerializableSymbolAndProjectId.Create(symbol, project, cancellationToken),
},
serverCallback,
cancellationToken).ConfigureAwait(false);
if (success)
{
return;
}
}
// Couldn't effectively search in OOP. Perform the search in-process.
await FindImplementationsInCurrentProcessAsync(
symbol, project, context).ConfigureAwait(false);
}
public FindReferencesProgressAdapter(
Solution solution, IFindUsagesContext context, FindReferencesSearchOptions options)
{
_solution = solution;
_context = context;
_options = options;
}
private async Task<ProgressAdapter> FindReferencesWorkerAsync(
Document document, int position, IFindUsagesContext context)
{
var cancellationToken = context.CancellationToken;
cancellationToken.ThrowIfCancellationRequested();
// Find the symbol we want to search and the solution we want to search in.
var symbolAndProject = await FindUsagesHelpers.GetRelevantSymbolAndProjectAtPositionAsync(
document, position, cancellationToken).ConfigureAwait(false);
if (symbolAndProject == null)
{
return null;
}
var symbol = symbolAndProject?.symbol;
var project = symbolAndProject?.project;
context.SetSearchTitle(string.Format(EditorFeaturesResources._0_references,
FindUsagesHelpers.GetDisplayName(symbol)));
var progressAdapter = new ProgressAdapter(project.Solution, context);
// Now call into the underlying FAR engine to find reference. The FAR
// engine will push results into the 'progress' instance passed into it.
// We'll take those results, massage them, and forward them along to the
// FindReferencesContext instance we were given.
await SymbolFinder.FindReferencesAsync(
SymbolAndProjectId.Create(symbol, project.Id),
project.Solution,
progressAdapter,
documents: null,
cancellationToken: cancellationToken).ConfigureAwait(false);
return progressAdapter;
}
async Task IFindUsagesService.FindReferencesAsync(
Document document, int position, IFindUsagesContext context)
{
var definitionTrackingContext = new DefinitionTrackingContext(context);
// Need ConfigureAwait(true) here so we get back to the UI thread before calling
// GetThirdPartyDefinitions. We need to call that on the UI thread to match behavior
// of how the language service always worked in the past.
//
// Any async calls before GetThirdPartyDefinitions must be ConfigureAwait(true).
await FindLiteralOrSymbolReferencesAsync(
document, position, definitionTrackingContext).ConfigureAwait(true);
// After the FAR engine is done call into any third party extensions to see
// if they want to add results.
var thirdPartyDefinitions = GetThirdPartyDefinitions(
document.Project.Solution, definitionTrackingContext.GetDefinitions(), context.CancellationToken);
// From this point on we can do ConfigureAwait(false) as we're not calling back
// into third parties anymore.
foreach (var definition in thirdPartyDefinitions)
{
// Don't need ConfigureAwait(true) here
await context.OnDefinitionFoundAsync(definition).ConfigureAwait(false);
}
}
public async Task FindImplementationsAsync(Document document, int position, IFindUsagesContext context)
{
var tuple = await FindUsagesHelpers.FindImplementationsAsync(
document, position, context.CancellationToken).ConfigureAwait(false);
if (tuple == null)
{
context.ReportMessage(EditorFeaturesResources.Cannot_navigate_to_the_symbol_under_the_caret);
return;
}
var message = tuple.Value.message;
if (message != null)
{
context.ReportMessage(message);
return;
}
var project = tuple.Value.project;
foreach (var implementation in tuple.Value.implementations)
{
var definitionItem = implementation.ToDefinitionItem(
project.Solution, includeHiddenLocations: false);
await context.OnDefinitionFoundAsync(definitionItem).ConfigureAwait(false);
}
}
public static async Task FindImplementationsAsync(
ISymbol symbol, Project project, IFindUsagesContext context)
{
var cancellationToken = context.CancellationToken;
var solution = project.Solution;
var client = await RemoteHostClient.TryGetClientAsync(solution.Workspace, cancellationToken).ConfigureAwait(false);
if (client != null)
{
// Create a callback that we can pass to the server process to hear about the
// results as it finds them. When we hear about results we'll forward them to
// the 'progress' parameter which will then update the UI.
var serverCallback = new FindUsagesServerCallback(solution, context);
var symbolAndProjectId = SerializableSymbolAndProjectId.Create(symbol, project, cancellationToken);
await client.TryInvokeAsync <IRemoteFindUsagesService>(
solution,
(service, solutionInfo, cancellationToken) => service.FindImplementationsAsync(solutionInfo, symbolAndProjectId, cancellationToken),
serverCallback,
cancellationToken).ConfigureAwait(false);
}
else
{
// Couldn't effectively search in OOP. Perform the search in-process.
await FindImplementationsInCurrentProcessAsync(
symbol, project, context).ConfigureAwait(false);
}
}
public FindLiteralsProgressAdapter(
IFindUsagesContext context, DefinitionItem definition, ClassificationOptions classificationOptions)
{
_context = context;
_definition = definition;
_classificationOptions = classificationOptions;
}
public async Task FindImplementationsAsync(
Document document,
int position,
IFindUsagesContext context
)
{
var cancellationToken = context.CancellationToken;
// If this is a symbol from a metadata-as-source project, then map that symbol back to a symbol in the primary workspace.
var symbolAndProjectOpt = await FindUsagesHelpers
.GetRelevantSymbolAndProjectAtPositionAsync(document, position, cancellationToken)
.ConfigureAwait(false);
if (symbolAndProjectOpt == null)
{
await context
.ReportMessageAsync(
EditorFeaturesResources.Cannot_navigate_to_the_symbol_under_the_caret
)
.ConfigureAwait(false);
return;
}
var symbolAndProject = symbolAndProjectOpt.Value;
await FindImplementationsAsync(
symbolAndProject.symbol,
symbolAndProject.project,
context
)
.ConfigureAwait(false);
}
public async Task FindReferencesAsync(
Document document, int position, IFindUsagesContext context)
{
// NOTE: All ConFigureAwaits in this method need to pass 'true' so that
// we return to the caller's context. that's so the call to
// CallThirdPartyExtensionsAsync will happen on the UI thread. We need
// this to maintain the threading guarantee we had around that method
// from pre-Roslyn days.
var cancellationToken = context.CancellationToken;
cancellationToken.ThrowIfCancellationRequested();
// First, see if we're on a literal. If so search for literals in the solution with
// the same value.
var found = await TryFindLiteralReferencesAsync(document, position, context).ConfigureAwait(true);
if (found)
{
return;
}
var findReferencesProgress = await FindSymbolReferencesAsync(
document, position, context).ConfigureAwait(true);
if (findReferencesProgress == null)
{
return;
}
// After the FAR engine is done call into any third party extensions to see
// if they want to add results.
await findReferencesProgress.CallThirdPartyExtensionsAsync(
context.CancellationToken).ConfigureAwait(true);
}
private static async Task FindImplementationsInCurrentProcessAsync(
ISymbol symbol, Project project, IFindUsagesContext context)
{
var cancellationToken = context.CancellationToken;
var solution = project.Solution;
var(implementations, message) = await FindSourceImplementationsAsync(
solution, symbol, cancellationToken).ConfigureAwait(false);
if (message != null)
{
await context.ReportMessageAsync(message).ConfigureAwait(false);
return;
}
await context.SetSearchTitleAsync(
string.Format(EditorFeaturesResources._0_implementations,
FindUsagesHelpers.GetDisplayName(symbol))).ConfigureAwait(false);
foreach (var implementation in implementations)
{
var definitionItem = await implementation.ToClassifiedDefinitionItemAsync(
solution, isPrimary : true, includeHiddenLocations : false, FindReferencesSearchOptions.Default, cancellationToken).ConfigureAwait(false);
await context.OnDefinitionFoundAsync(definitionItem).ConfigureAwait(false);
}
}
public FindLiteralsProgressAdapter(
IFindUsagesContext context,
DefinitionItem definition
)
{
_context = context;
_definition = definition;
}
public Task FindReferencesAsync(Document document, int position, IFindUsagesContext context)
{
return(_service.FindReferencesAsync(
document,
position,
new FSharpFindUsagesContext(context)
));
}
Task IFindUsagesLSPService.FindReferencesAsync(
Document document, int position, IFindUsagesContext context)
{
// We don't need to get third party definitions when finding references in LSP.
// Currently, 3rd party definitions = XAML definitions, and XAML will provide
// references via LSP instead of hooking into Roslyn.
// This also means that we don't need to be on the UI thread.
return(FindLiteralOrSymbolReferencesAsync(document, position, new DefinitionTrackingContext(context)));
}
public FindReferencesProgressAdapter(
IThreadingContext threadingContext, Solution solution,
IFindUsagesContext context, FindReferencesSearchOptions options)
: base(threadingContext)
{
_solution = solution;
_context = context;
_options = options;
}
private static Task FindReferencesInCurrentProcessAsync(
IFindUsagesContext context,
ISymbol symbol,
Project project,
FindReferencesSearchOptions options)
{
var progress = new FindReferencesProgressAdapter(project.Solution, context, options);
return(SymbolFinder.FindReferencesAsync(
symbol, project.Solution, progress, documents: null, options, context.CancellationToken));
}
/// <summary>
/// Public helper that we use from features like ObjectBrowser which start with a symbol
/// and want to push all the references to it into the Streaming-Find-References window.
/// </summary>
public static async Task FindSymbolReferencesAsync(
IFindUsagesContext context, ISymbol symbol, Project project)
{
await context.SetSearchTitleAsync(string.Format(EditorFeaturesResources._0_references,
FindUsagesHelpers.GetDisplayName(symbol))).ConfigureAwait(false);
var options = FindReferencesSearchOptions.GetFeatureOptionsForStartingSymbol(symbol);
// Now call into the underlying FAR engine to find reference. The FAR
// engine will push results into the 'progress' instance passed into it.
// We'll take those results, massage them, and forward them along to the
// FindReferencesContext instance we were given.
await FindReferencesAsync(context, symbol, project, options).ConfigureAwait(false);
}
public async Task FindReferencesAsync(Document document, int position, IFindUsagesContext context)
{
var text = await document.GetTextAsync().ConfigureAwait(false);
var lspClient = _roslynLspClientServiceFactory.ActiveLanguageServerClient;
if (lspClient == null)
{
return;
}
var referenceParams = new LSP.ReferenceParams
{
Context = new LSP.ReferenceContext {
IncludeDeclaration = false
},
TextDocument = ProtocolConversions.DocumentToTextDocumentIdentifier(document),
Position = ProtocolConversions.LinePositionToPosition(text.Lines.GetLinePosition(position))
};
var locations = await lspClient.RequestAsync(LSP.Methods.TextDocumentReferences, referenceParams, context.CancellationToken).ConfigureAwait(false);
if (locations == null)
{
return;
}
// TODO: Need to get real definition data from the server.
var dummyDef = DefinitionItem.CreateNonNavigableItem(ImmutableArray <string> .Empty, ImmutableArray <TaggedText> .Empty);
await context.OnDefinitionFoundAsync(dummyDef).ConfigureAwait(false);
foreach (var location in locations)
{
var documentSpan = await _remoteLanguageServiceWorkspace.GetDocumentSpanFromLocation(location, context.CancellationToken).ConfigureAwait(false);
if (documentSpan == null)
{
continue;
}
#pragma warning disable CS0612 // Type or member is obsolete. TODO.
await context.OnReferenceFoundAsync(new SourceReferenceItem(dummyDef, documentSpan.Value, isWrittenTo : false)).ConfigureAwait(false);
#pragma warning restore CS0612 // Type or member is obsolete
}
}
private async Task FindLiteralOrSymbolReferencesAsync(
Document document, int position, IFindUsagesContext context)
{
// First, see if we're on a literal. If so search for literals in the solution with
// the same value.
var found = await TryFindLiteralReferencesAsync(
document, position, context).ConfigureAwait(false);
if (found)
{
return;
}
// Wasn't a literal. Try again as a symbol.
await FindSymbolReferencesAsync(
document, position, context).ConfigureAwait(false);
}
async Task IFindUsagesService.FindReferencesAsync(
IFindUsagesContext context, Document document, int position, CancellationToken cancellationToken)
{
var definitionTrackingContext = new DefinitionTrackingContext(context);
await FindLiteralOrSymbolReferencesAsync(
definitionTrackingContext, document, position, cancellationToken).ConfigureAwait(false);
// After the FAR engine is done call into any third party extensions to see
// if they want to add results.
var thirdPartyDefinitions = await GetThirdPartyDefinitionsAsync(
document.Project.Solution, definitionTrackingContext.GetDefinitions(), cancellationToken).ConfigureAwait(false);
foreach (var definition in thirdPartyDefinitions)
{
await context.OnDefinitionFoundAsync(definition, cancellationToken).ConfigureAwait(false);
}
}
private static async Task FindSymbolMonikerReferencesAsync(
IFindSymbolMonikerUsagesService monikerUsagesService,
ISymbol definition,
IFindUsagesContext context,
CancellationToken cancellationToken)
{
var moniker = SymbolMoniker.TryCreate(definition);
if (moniker == null)
{
return;
}
// Let the find-refs window know we have outstanding work
await using var _ = await context.ProgressTracker.AddSingleItemAsync().ConfigureAwait(false);
var displayParts = GetDisplayParts(definition).AddRange(new[]
{
new TaggedText(TextTags.Space, " "),
new TaggedText(TextTags.Text, EditorFeaturesResources.external),
});
var definitionItem = DefinitionItem.CreateNonNavigableItem(
tags: GlyphTags.GetTags(definition.GetGlyph()),
displayParts,
originationParts: DefinitionItem.GetOriginationParts(definition));
var monikers = ImmutableArray.Create(moniker);
var first = true;
await foreach (var referenceItem in monikerUsagesService.FindReferencesByMoniker(
definitionItem, monikers, context.ProgressTracker, cancellationToken))
{
if (first)
{
// found some results. Add the definition item to the context.
first = false;
await context.OnDefinitionFoundAsync(definitionItem).ConfigureAwait(false);
}
await context.OnExternalReferenceFoundAsync(referenceItem).ConfigureAwait(false);
}
}
private static async Task FindSymbolReferencesAsync(
IFindUsagesContext context, Document document, int position, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
// If this is a symbol from a metadata-as-source project, then map that symbol back to a symbol in the primary workspace.
var symbolAndProjectOpt = await FindUsagesHelpers.GetRelevantSymbolAndProjectAtPositionAsync(
document, position, cancellationToken).ConfigureAwait(false);
if (symbolAndProjectOpt == null)
{
return;
}
var(symbol, project) = symbolAndProjectOpt.Value;
await FindSymbolReferencesAsync(
context, symbol, project, cancellationToken).ConfigureAwait(false);
}
/// <summary>
/// Public helper that we use from features like ObjectBrowser which start with a symbol
/// and want to push all the references to it into the Streaming-Find-References window.
/// </summary>
public static async Task FindSymbolReferencesAsync(
IFindUsagesContext context, ISymbol symbol, Project project, CancellationToken cancellationToken)
{
await context.SetSearchTitleAsync(string.Format(EditorFeaturesResources._0_references,
FindUsagesHelpers.GetDisplayName(symbol))).ConfigureAwait(false);
var progressAdapter = new FindReferencesProgressAdapter(project.Solution, context);
// Now call into the underlying FAR engine to find reference. The FAR
// engine will push results into the 'progress' instance passed into it.
// We'll take those results, massage them, and forward them along to the
// FindReferencesContext instance we were given.
await SymbolFinder.FindReferencesAsync(
SymbolAndProjectId.Create(symbol, project.Id),
project.Solution,
progressAdapter,
documents : null,
cancellationToken : cancellationToken).ConfigureAwait(false);
}
private async Task FindSymbolReferencesAsync(
Document document, int position, IFindUsagesContext context)
{
var cancellationToken = context.CancellationToken;
cancellationToken.ThrowIfCancellationRequested();
// Find the symbol we want to search and the solution we want to search in.
var symbolAndProject = await FindUsagesHelpers.GetRelevantSymbolAndProjectAtPositionAsync(
document, position, cancellationToken).ConfigureAwait(false);
if (symbolAndProject == null)
{
return;
}
await FindSymbolReferencesAsync(
context, symbolAndProject?.symbol, symbolAndProject?.project, cancellationToken).ConfigureAwait(false);
}
public async Task FindReferencesAsync(
Document document, int position, IFindUsagesContext context)
{
// NOTE: All ConFigureAwaits in this method need to pass 'true' so that
// we return to the caller's context. that's so the call to
// CallThirdPartyExtensionsAsync will happen on the UI thread. We need
// this to maintain the threading guarantee we had around that method
// from pre-Roslyn days.
var findReferencesProgress = await FindReferencesWorkerAsync(
document, position, context).ConfigureAwait(true);
if (findReferencesProgress == null)
{
return;
}
// After the FAR engine is done call into any third party extensions to see
// if they want to add results.
await findReferencesProgress.CallThirdPartyExtensionsAsync().ConfigureAwait(true);
}
public async Task FindReferencesAsync(
Document document, int position, IFindUsagesContext context)
{
// NOTE: All ConFigureAwaits in this method need to pass 'true' so that
// we return to the caller's context. that's so the call to
// CallThirdPartyExtensionsAsync will happen on the UI thread. We need
// this to maintain the threading guarantee we had around that method
// from pre-Roslyn days.
var findReferencesProgress = await FindReferencesWorkerAsync(
document, position, context).ConfigureAwait(true);
if (findReferencesProgress == null)
{
return;
}
// After the FAR engine is done call into any third party extensions to see
// if they want to add results.
await findReferencesProgress.CallThirdPartyExtensionsAsync().ConfigureAwait(true);
}
private static async Task InspectInterfaceAsync(
IFindUsagesContext context, INamedTypeSymbol interfaceSymbol, INamedTypeSymbol namedTypeSymbol, Project project, CancellationToken cancellationToken)
{
foreach (var interfaceMember in interfaceSymbol.GetMembers())
{
if (cancellationToken.IsCancellationRequested)
{
return;
}
var impl = namedTypeSymbol.FindImplementationForInterfaceMember(interfaceMember);
if (impl == null)
{
continue;
}
var definitionItem = impl.ToNonClassifiedDefinitionItem(project.Solution, true);
await context.OnDefinitionFoundAsync(definitionItem, cancellationToken).ConfigureAwait(false);
}
}
public async Task FindImplementationsAsync(Document document, int position, IFindUsagesContext context)
{
var text = await document.GetTextAsync().ConfigureAwait(false);
var lspClient = _roslynLspClientServiceFactory.ActiveLanguageServerClient;
if (lspClient == null)
{
return;
}
var documentPositionParams = ProtocolConversions.PositionToTextDocumentPositionParams(position, text, document);
var response = await lspClient.RequestAsync(LiveShareProtocol.Methods.TextDocumentImplementations, documentPositionParams, context.CancellationToken).ConfigureAwait(false);
var locations = ((JToken)response)?.ToObject <LSP.Location[]>();
if (locations == null)
{
return;
}
foreach (var location in locations)
{
var documentSpan = await _remoteLanguageServiceWorkspace.GetDocumentSpanFromLocation(location, context.CancellationToken).ConfigureAwait(false);
if (documentSpan == null)
{
continue;
}
// Get the text for the line containing the definition to show in the UI.
var docText = await documentSpan.Value.Document.GetTextAsync(context.CancellationToken).ConfigureAwait(false);
var lineText = docText.GetSubText(docText.Lines[location.Range.Start.Line].Span).ToString();
await context.OnDefinitionFoundAsync(DefinitionItem.Create(ImmutableArray <string> .Empty,
ImmutableArray.Create(new TaggedText(TextTags.Text, lineText)), documentSpan.Value)).ConfigureAwait(false);
}
}
public async Task FindImplementationsAsync(
Document document, int position, IFindUsagesContext context)
{
var cancellationToken = context.CancellationToken;
var tuple = await FindUsagesHelpers.FindImplementationsAsync(
document, position, cancellationToken).ConfigureAwait(false);
if (tuple == null)
{
await context.ReportMessageAsync(
EditorFeaturesResources.Cannot_navigate_to_the_symbol_under_the_caret).ConfigureAwait(false);
return;
}
var message = tuple.Value.message;
if (message != null)
{
await context.ReportMessageAsync(message).ConfigureAwait(false);
return;
}
await context.SetSearchTitleAsync(
string.Format(EditorFeaturesResources._0_implementations,
FindUsagesHelpers.GetDisplayName(tuple.Value.symbol))).ConfigureAwait(false);
var project = tuple.Value.project;
foreach (var implementation in tuple.Value.implementations)
{
var definitionItem = await implementation.ToClassifiedDefinitionItemAsync(
project, includeHiddenLocations : false,
FindReferencesSearchOptions.Default, cancellationToken : cancellationToken).ConfigureAwait(false);
await context.OnDefinitionFoundAsync(definitionItem).ConfigureAwait(false);
}
}
private async Task <ProgressAdapter> FindReferencesWorkerAsync(
Document document, int position, IFindUsagesContext context)
{
var cancellationToken = context.CancellationToken;
cancellationToken.ThrowIfCancellationRequested();
// Find the symbol we want to search and the solution we want to search in.
var symbolAndProject = await FindUsagesHelpers.GetRelevantSymbolAndProjectAtPositionAsync(
document, position, cancellationToken).ConfigureAwait(false);
if (symbolAndProject == null)
{
return(null);
}
var symbol = symbolAndProject?.symbol;
var project = symbolAndProject?.project;
var displayName = AbstractFindReferencesService.GetDisplayName(symbol);
context.SetSearchLabel(displayName);
var progressAdapter = new ProgressAdapter(project.Solution, context);
// Now call into the underlying FAR engine to find reference. The FAR
// engine will push results into the 'progress' instance passed into it.
// We'll take those results, massage them, and forward them along to the
// FindReferencesContext instance we were given.
await SymbolFinder.FindReferencesAsync(
SymbolAndProjectId.Create(symbol, project.Id),
project.Solution,
progressAdapter,
documents : null,
cancellationToken : cancellationToken).ConfigureAwait(false);
return(progressAdapter);
}
public static async Task FindSymbolReferencesAsync(
IFindUsagesContext context, ISymbol symbol, Project project)
{
var solution = project.Solution;
var monikerUsagesService = solution.Workspace.Services.GetRequiredService <IFindSymbolMonikerUsagesService>();
await context.SetSearchTitleAsync(string.Format(EditorFeaturesResources._0_references,
FindUsagesHelpers.GetDisplayName(symbol))).ConfigureAwait(false);
var options = FindReferencesSearchOptions.GetFeatureOptionsForStartingSymbol(symbol);
// Now call into the underlying FAR engine to find reference. The FAR
// engine will push results into the 'progress' instance passed into it.
// We'll take those results, massage them, and forward them along to the
// FindReferencesContext instance we were given.
//
// Kick off work to search the online code index system in parallel.
//
// Do both in parallel so we can get all the results as soon as possible.
await Task.WhenAll(
FindReferencesAsync(context, symbol, project, options),
FindSymbolMonikerReferencesAsync(monikerUsagesService, symbol, context)).ConfigureAwait(false);
}
public ProgressAdapter(Solution solution, IFindUsagesContext context)
{
_solution = solution;
_context = context;
_definitionFactory = s => s.ToDefinitionItem(solution, includeHiddenLocations: false);
}
