public override Task OnDefinitionFoundAsync(DefinitionItem definition)
{
lock (_gate)
{
_definitionItems.Add(definition);
}
return SpecializedTasks.EmptyTask;
}
public DefinitionTreeItem(
DefinitionItem definitionItem,
ImmutableArray<SourceReferenceTreeItem> referenceItems)
: base(definitionItem.Tags.GetGlyph().GetGlyphIndex())
{
_definitionItem = definitionItem;
this.Children.AddRange(referenceItems);
this.DisplayText = CreateDisplayText();
}
public RoslynDefinitionBucket(
StreamingFindUsagesPresenter presenter,
TableDataSourceFindUsagesContext context,
DefinitionItem definitionItem)
: base(name: definitionItem.DisplayParts.JoinText() + " " + definitionItem.GetHashCode(),
sourceTypeIdentifier: context.SourceTypeIdentifier,
identifier: context.Identifier)
{
_presenter = presenter;
_context = context;
DefinitionItem = definitionItem;
}
private ImmutableArray<SourceReferenceTreeItem> CreateReferenceItems(
DefinitionItem definitionItem,
DefinitionsAndReferences definitionsAndReferences,
int commonPathElements)
{
var result = ImmutableArray.CreateBuilder<SourceReferenceTreeItem>();
var definitionGlyph = definitionItem.Tags.GetGlyph();
// Skip the first definition. We'll present it in the definition item.
var definitionLocationsAndGlyphs =
from loc in definitionItem.SourceSpans.Skip(1)
select ValueTuple.Create(loc, definitionGlyph);
var referenceLocationsAndGlyphs =
from r in definitionsAndReferences.References
where r.Definition == definitionItem
select ValueTuple.Create(r.SourceSpan, Glyph.Reference);
var allLocationsAndGlyphs = definitionLocationsAndGlyphs.Concat(referenceLocationsAndGlyphs);
foreach (var locationAndGlyph in allLocationsAndGlyphs)
{
var documentLocation = locationAndGlyph.Item1;
var glyph = locationAndGlyph.Item2;
result.Add(new SourceReferenceTreeItem(
documentLocation.Document,
documentLocation.SourceSpan,
glyph.GetGlyphIndex(),
commonPathElements));
}
var linkedReferences = result.GroupBy(r => r.DisplayText.ToLowerInvariant()).Where(g => g.Count() > 1).SelectMany(g => g);
foreach (var linkedReference in linkedReferences)
{
linkedReference.AddProjectNameDisambiguator();
}
result.Sort();
return result.ToImmutable();
}
private async Task AddDeclarationEntriesAsync(DefinitionItem definition)
{
CancellationToken.ThrowIfCancellationRequested();
// Don't do anything if we already have declaration entries for this definition
// (i.e. another thread beat us to this).
if (HasDeclarationEntries(definition))
{
return;
}
var definitionBucket = GetOrCreateDefinitionBucket(definition);
// We could do this inside the lock. but that would mean async activity in a
// lock, and i'd like to avoid that. That does mean that we might do extra
// work if multiple threads end up down htis path. But only one of them will
// win when we access the lock below.
var declarations = ArrayBuilder<Entry>.GetInstance();
foreach (var declarationLocation in definition.SourceSpans)
{
var definitionEntry = await CreateDocumentLocationEntryAsync(
definitionBucket, declarationLocation, isDefinitionLocation: true).ConfigureAwait(false);
if (definitionEntry != null)
{
declarations.Add(definitionEntry);
}
}
lock (_gate)
{
// Do one final check to ensure that no other thread beat us here.
if (!HasDeclarationEntries(definition))
{
// We only include declaration entries in the entries we show when
// not grouping by definition.
_entriesWithDeclarations = _entriesWithDeclarations.AddRange(declarations);
CurrentVersionNumber++;
}
}
declarations.Free();
// Let all our subscriptions know that we've updated.
_tableDataSink.FactorySnapshotChanged(this);
}
private bool HasDeclarationEntries(DefinitionItem definition)
{
lock (_gate)
{
return _entriesWithDeclarations.Any(e => e.DefinitionBucket.DefinitionItem == definition);
}
}
public override async Task OnDefinitionFoundAsync(DefinitionItem definition)
{
lock (_gate)
{
_definitions.Add(definition);
}
// If this is a definition we always want to show, then create entries
// for all the declaration locations immediately. Otherwise, we'll
// create them on demand when we hear about references for this definition.
if (definition.DisplayIfNoReferences)
{
await AddDeclarationEntriesAsync(definition).ConfigureAwait(false);
}
}
// Used by TypeScript
internal SourceReferenceItem(DefinitionItem definition, DocumentSpan sourceSpan, SymbolUsageInfo symbolUsageInfo)
: this(definition, sourceSpan, symbolUsageInfo, additionalProperties : ImmutableDictionary <string, string> .Empty)
{
}
public static SourceReferenceItem TryCreateSourceReferenceItem(
this ReferenceLocation referenceLocation,
DefinitionItem definitionItem,
bool includeHiddenLocations)
{
var location = referenceLocation.Location;
Debug.Assert(location.IsInSource);
if (!location.IsVisibleSourceLocation() &&
!includeHiddenLocations)
{
return null;
}
return new SourceReferenceItem(definitionItem,
new DocumentSpan(referenceLocation.Document, location.SourceSpan));
}
public SourceReferenceItem(DefinitionItem definition, DocumentSpan sourceSpan)
{
Definition = definition;
SourceSpan = sourceSpan;
}
public override async Task OnDefinitionFoundAsync(DefinitionItem definition)
{
lock (_gate)
{
_definitions.Add(definition);
}
// If this is a definition we always want to show, then create entries
// for all the definition locations immediately.
if (definition.DisplayIfNoReferences)
{
await AddDefinitionEntriesAsync(definition).ConfigureAwait(false);
}
}
public virtual Task OnDefinitionFoundAsync(DefinitionItem definition) => Task.CompletedTask;
public virtual Task OnDefinitionFoundAsync(DefinitionItem definition) => SpecializedTasks.EmptyTask;
public FindLiteralsProgressAdapter(
IFindUsagesContext context, DefinitionItem definition)
{
_context = context;
_definition = definition;
}
internal SourceReferenceItem(DefinitionItem definition, DocumentSpan sourceSpan, SymbolUsageInfo symbolUsageInfo, ImmutableDictionary <string, string> additionalProperties)
: this(definition, sourceSpan, symbolUsageInfo, additionalProperties, isWrittenTo : symbolUsageInfo.IsWrittenTo())
{
}
private async Task OnEntryFoundAsync(
DefinitionItem definition,
Func<RoslynDefinitionBucket, Task<Entry>> createEntryAsync,
bool addToEntriesWithDeclarations,
bool addToEntriesWithoutDeclarations)
{
Debug.Assert(addToEntriesWithDeclarations || addToEntriesWithoutDeclarations);
CancellationToken.ThrowIfCancellationRequested();
// First find the bucket corresponding to our definition.
var definitionBucket = GetOrCreateDefinitionBucket(definition);
var entry = await createEntryAsync(definitionBucket).ConfigureAwait(false);
// Ok, we got a *reference* to some definition item. This may have been
// a reference for some definition that we haven't created any declaration
// entries for (i.e. becuase it had DisplayIfNoReferences = false). Because
// we've now found a reference, we want to make sure all its declaration
// entries are added.
await AddDeclarationEntriesAsync(definition).ConfigureAwait(false);
lock (_gate)
{
// Once we can make the new entry, add it to the appropriate list.
if (addToEntriesWithDeclarations)
{
_entriesWithDeclarations = _entriesWithDeclarations.Add(entry);
}
if (addToEntriesWithoutDeclarations)
{
_entriesWithoutDeclarations = _entriesWithoutDeclarations.Add(entry);
}
CurrentVersionNumber++;
}
// Let all our subscriptions know that we've updated.
_tableDataSink.FactorySnapshotChanged(this);
}
private RoslynDefinitionBucket GetOrCreateDefinitionBucket(DefinitionItem definition)
{
lock (_gate)
{
if (!_definitionToBucket.TryGetValue(definition, out var bucket))
{
bucket = new RoslynDefinitionBucket(Presenter, this, definition);
_definitionToBucket.Add(definition, bucket);
}
return bucket;
}
}
private async Task AddDefinitionEntriesAsync(DefinitionItem definition)
{
CancellationToken.ThrowIfCancellationRequested();
// Don't do anything if we already have entries for this definition
// (i.e. another thread beat us to this).
if (HasEntriesForDefinition(definition))
{
return;
}
// First find the bucket corresponding to our definition. If we can't find/create
// one, then don't do anything for this reference.
var definitionBucket = GetOrCreateDefinitionBucket(definition);
if (definitionBucket == null)
{
return;
}
// We could do this inside the lock. but that would mean async activity in a
// lock, and i'd like to avoid that. That does mean that we might do extra
// work if multiple threads end up down htis path. But only one of them will
// win when we access the lock below.
var builder = ImmutableArray.CreateBuilder<Entry>();
foreach (var definitionLocation in definition.SourceSpans)
{
var definitionEntry = await CreateDocumentLocationEntryAsync(
definitionBucket, definitionLocation, isDefinitionLocation: true).ConfigureAwait(false);
if (definitionEntry != null)
{
builder.Add(definitionEntry);
}
}
lock (_gate)
{
// Do one final check to ensure that no other thread beat us here.
if (!HasEntriesForDefinition(definition))
{
_entries = _entries.AddRange(builder);
CurrentVersionNumber++;
}
}
// Let all our subscriptions know that we've updated.
_tableDataSink.FactorySnapshotChanged(this);
}
private async Task OnEntryFoundAsync(
DefinitionItem definition,
Func<RoslynDefinitionBucket, Task<Entry>> createEntryAsync)
{
CancellationToken.ThrowIfCancellationRequested();
// First find the bucket corresponding to our definition. If we can't find/create
// one, then don't do anything for this reference.
var definitionBucket = GetOrCreateDefinitionBucket(definition);
if (definitionBucket == null)
{
return;
}
var entry = await createEntryAsync(definitionBucket).ConfigureAwait(false);
if (entry == null)
{
return;
}
// Ok, we got a *reference* to some definition item. This may have been
// a reference for some definition that we haven't created any definition
// entries for (i.e. becuase it had DisplayIfNoReferences = false). Because
// we've now found a reference, we want to make sure all tis definition
// entries are added.
await AddDefinitionEntriesAsync(definition).ConfigureAwait(false);
lock (_gate)
{
// Once we can make the new entry, add it to our list.
_entries = _entries.Add(entry);
CurrentVersionNumber++;
}
// Let all our subscriptions know that we've updated.
_tableDataSink.FactorySnapshotChanged(this);
}
private bool HasEntriesForDefinition(DefinitionItem definition)
{
lock (_gate)
{
return _entries.Any(e => e.DefinitionBucket.DefinitionItem == definition);
}
}
private static void CreateReferences(
ReferencedSymbol referencedSymbol,
ArrayBuilder<SourceReferenceItem> references,
DefinitionItem definitionItem,
bool includeHiddenLocations,
HashSet<DocumentSpan> uniqueSpans)
{
foreach (var referenceLocation in referencedSymbol.Locations)
{
var sourceReferenceItem = referenceLocation.TryCreateSourceReferenceItem(
definitionItem, includeHiddenLocations);
if (sourceReferenceItem == null)
{
continue;
}
if (uniqueSpans.Add(sourceReferenceItem.SourceSpan))
{
references.Add(sourceReferenceItem);
}
}
}
private static string GetMessage(DefinitionItem definition)
{
if (definition.IsExternal)
{
return ServicesVisualStudioNextResources.External_reference_found;
}
return string.Format(
ServicesVisualStudioNextResources.No_references_found_to_0,
definition.NameDisplayParts.JoinText());
}
public virtual Task OnDefinitionFoundAsync(DefinitionItem definition) => SpecializedTasks.EmptyTask;
// Used by F#
internal SourceReferenceItem(DefinitionItem definition, DocumentSpan sourceSpan)
: this(definition, sourceSpan, SymbolUsageInfo.None)
{
}
