private static async Task <IEnumerable <INamedTypeSymbol> > FindImmediatelyInheritingTypesInDocumentAsync(
Document document,
HashSet <INamedTypeSymbol> typesToSearchFor,
InheritanceQuery inheritanceQuery,
ConcurrentSet <SemanticModel> cachedModels,
ConcurrentSet <IDeclarationInfo> cachedInfos,
Func <HashSet <INamedTypeSymbol>, INamedTypeSymbol, bool> typeImmediatelyMatches,
CancellationToken cancellationToken)
{
var declarationInfo = await document.GetDeclarationInfoAsync(cancellationToken).ConfigureAwait(false);
cachedInfos.Add(declarationInfo);
HashSet <INamedTypeSymbol> result = null;
foreach (var symbolInfo in declarationInfo.DeclaredSymbolInfos)
{
result = await ProcessSymbolInfo(
document, symbolInfo,
typesToSearchFor,
inheritanceQuery, cachedModels,
typeImmediatelyMatches, result, cancellationToken).ConfigureAwait(false);
}
return(result);
}
private static async Task <SymbolAndProjectIdSet> FindImmediatelyInheritingTypesInDocumentAsync(
Document document,
SymbolAndProjectIdSet typesToSearchFor,
InheritanceQuery inheritanceQuery,
ConcurrentSet <SemanticModel> cachedModels,
ConcurrentSet <SyntaxTreeIndex> cachedInfos,
Func <SymbolAndProjectIdSet, INamedTypeSymbol, bool> typeImmediatelyMatches,
CancellationToken cancellationToken)
{
var declarationInfo = await document.GetSyntaxTreeIndexAsync(cancellationToken).ConfigureAwait(false);
cachedInfos.Add(declarationInfo);
var result = CreateSymbolAndProjectIdSet();
foreach (var symbolInfo in declarationInfo.DeclaredSymbolInfos)
{
await ProcessSymbolInfo(
document, symbolInfo,
typesToSearchFor,
inheritanceQuery, cachedModels,
typeImmediatelyMatches, result, cancellationToken).ConfigureAwait(false);
}
return(result);
}
private static async Task <SymbolAndProjectIdSet> ProcessSymbolInfo(
Document document,
DeclaredSymbolInfo info,
SymbolAndProjectIdSet typesToSearchFor,
InheritanceQuery inheritanceQuery,
ConcurrentSet <SemanticModel> cachedModels,
Func <SymbolAndProjectIdSet, INamedTypeSymbol, bool> typeImmediatelyMatches,
SymbolAndProjectIdSet result,
CancellationToken cancellationToken)
{
var projectId = document.Project.Id;
// If we're searching for enums/structs/delegates, then we can just look at the kind of
// the info to see if we have a match.
if ((inheritanceQuery.DerivesFromSystemEnum && info.Kind == DeclaredSymbolInfoKind.Enum) ||
(inheritanceQuery.DerivesFromSystemValueType && info.Kind == DeclaredSymbolInfoKind.Struct) ||
(inheritanceQuery.DerivesFromSystemMulticastDelegate && info.Kind == DeclaredSymbolInfoKind.Delegate))
{
var symbol = await ResolveAsync(document, info, cachedModels, cancellationToken).ConfigureAwait(false) as INamedTypeSymbol;
if (symbol != null)
{
result = result ?? CreateSymbolAndProjectIdSet();
result.Add(SymbolAndProjectId.Create(symbol, projectId));
}
}
else if (inheritanceQuery.DerivesFromSystemObject && info.Kind == DeclaredSymbolInfoKind.Class)
{
// Searching for types derived from 'Object' needs to be handled specially.
// There may be no indication in source what the type actually derives from.
// Also, we can't just look for an empty inheritance list. We may have
// something like: "class C : IFoo". This type derives from object, despite
// having a non-empty list.
var symbol = await ResolveAsync(document, info, cachedModels, cancellationToken).ConfigureAwait(false) as INamedTypeSymbol;
if (symbol?.BaseType?.SpecialType == SpecialType.System_Object)
{
result = result ?? CreateSymbolAndProjectIdSet();
result.Add(SymbolAndProjectId.Create(symbol, projectId));
}
}
else if (AnyInheritanceNamesMatch(info, inheritanceQuery.TypeNames))
{
// Looks like we have a potential match. Actually check if the symbol is viable.
var symbol = await ResolveAsync(document, info, cachedModels, cancellationToken).ConfigureAwait(false) as INamedTypeSymbol;
if (symbol != null)
{
if (typeImmediatelyMatches(typesToSearchFor, symbol))
{
result = result ?? CreateSymbolAndProjectIdSet();
result.Add(SymbolAndProjectId.Create(symbol, projectId));
}
}
}
return(result);
}
private static async Task AddSourceTypesInProjectAsync(
SymbolAndProjectIdSet sourceAndMetadataTypes,
Project project,
Func <SymbolAndProjectIdSet, INamedTypeSymbol, bool> sourceTypeImmediatelyMatches,
Func <INamedTypeSymbol, bool> shouldContinueSearching,
bool transitive,
SymbolAndProjectIdSet finalResult,
CancellationToken cancellationToken)
{
// We're going to be sweeping over this project over and over until we reach a
// fixed point. In order to limit GC and excess work, we cache all the sematic
// models and DeclaredSymbolInfo for hte documents we look at.
// Because we're only processing a project at a time, this is not an issue.
var cachedModels = new ConcurrentSet <SemanticModel>();
var cachedInfos = new ConcurrentSet <SyntaxTreeIndex>();
var typesToSearchFor = CreateSymbolAndProjectIdSet();
typesToSearchFor.AddAll(sourceAndMetadataTypes);
var comparer = project.LanguageServices.GetService <ISyntaxFactsService>().StringComparer;
var inheritanceQuery = new InheritanceQuery(sourceAndMetadataTypes, comparer);
var schedulerPair = new ConcurrentExclusiveSchedulerPair(
TaskScheduler.Default, maxConcurrencyLevel: Math.Max(1, Environment.ProcessorCount));
// As long as there are new types to search for, keep looping.
while (typesToSearchFor.Count > 0)
{
// Compute the set of names to look for in the base/interface lists.
inheritanceQuery.TypeNames.AddRange(typesToSearchFor.Select(c => c.Symbol.Name));
// Search all the documents of this project in parallel.
var tasks = project.Documents.Select(
d => Task.Factory.StartNew(
() => FindImmediatelyInheritingTypesInDocumentAsync(
d, typesToSearchFor, inheritanceQuery, cachedModels,
cachedInfos, sourceTypeImmediatelyMatches, cancellationToken),
cancellationToken,
TaskCreationOptions.None,
schedulerPair.ConcurrentScheduler).Unwrap()).ToArray();
await Task.WhenAll(tasks).ConfigureAwait(false);
// Clear out the information about the types we're looking for. We'll
// fill these in if we discover any more types that we need to keep searching
// for.
typesToSearchFor.Clear();
inheritanceQuery.TypeNames.Clear();
foreach (var task in tasks)
{
var result = await task.ConfigureAwait(false);
foreach (var derivedType in result)
{
if (finalResult.Add(derivedType))
{
if (transitive && shouldContinueSearching(derivedType.Symbol))
{
typesToSearchFor.Add(derivedType);
}
}
}
s_setPool.ClearAndFree(result);
}
}
}
private static async Task <IEnumerable <SymbolAndProjectId <INamedTypeSymbol> > > FindSourceTypesInProjectAsync(
SymbolAndProjectIdSet sourceAndMetadataTypes,
Project project,
Func <SymbolAndProjectIdSet, INamedTypeSymbol, bool> sourceTypeImmediatelyMatches,
Func <INamedTypeSymbol, bool> shouldContinueSearching,
bool transitive,
CancellationToken cancellationToken)
{
// We're going to be sweeping over this project over and over until we reach a
// fixed point. In order to limit GC and excess work, we cache all the sematic
// models and DeclaredSymbolInfo for hte documents we look at.
// Because we're only processing a project at a time, this is not an issue.
var cachedModels = new ConcurrentSet <SemanticModel>();
var cachedInfos = new ConcurrentSet <IDeclarationInfo>();
var finalResult = CreateSymbolAndProjectIdSet();
var typesToSearchFor = CreateSymbolAndProjectIdSet();
typesToSearchFor.AddAll(sourceAndMetadataTypes);
var inheritanceQuery = new InheritanceQuery(sourceAndMetadataTypes);
// As long as there are new types to search for, keep looping.
while (typesToSearchFor.Count > 0)
{
// Compute the set of names to look for in the base/interface lists.
inheritanceQuery.TypeNames.AddRange(typesToSearchFor.Select(c => c.Symbol.Name));
// Search all the documents of this project in parallel.
var tasks = project.Documents.Select(d => FindImmediatelyInheritingTypesInDocumentAsync(
d, typesToSearchFor, inheritanceQuery,
cachedModels, cachedInfos,
sourceTypeImmediatelyMatches, cancellationToken)).ToArray();
await Task.WhenAll(tasks).ConfigureAwait(false);
// Clear out the information about the types we're looking for. We'll
// fill these in if we discover any more types that we need to keep searching
// for.
typesToSearchFor.Clear();
inheritanceQuery.TypeNames.Clear();
foreach (var task in tasks)
{
if (task.Result != null)
{
foreach (var derivedType in task.Result)
{
if (finalResult.Add(derivedType))
{
if (transitive && shouldContinueSearching(derivedType.Symbol))
{
typesToSearchFor.Add(derivedType);
}
}
}
}
}
}
return(finalResult);
}
private static async Task<HashSet<INamedTypeSymbol>> ProcessSymbolInfo(
Document document,
DeclaredSymbolInfo info,
HashSet<INamedTypeSymbol> typesToSearchFor,
InheritanceQuery inheritanceQuery,
ConcurrentSet<SemanticModel> cachedModels,
Func<HashSet<INamedTypeSymbol>, INamedTypeSymbol, bool> typeImmediatelyMatches,
HashSet<INamedTypeSymbol> result,
CancellationToken cancellationToken)
{
// If we're searching for enums/structs/delegates, then we can just look at the kind of
// the info to see if we have a match.
if ((inheritanceQuery.DerivesFromSystemEnum && info.Kind == DeclaredSymbolInfoKind.Enum) ||
(inheritanceQuery.DerivesFromSystemValueType && info.Kind == DeclaredSymbolInfoKind.Struct) ||
(inheritanceQuery.DerivesFromSystemMulticastDelegate && info.Kind == DeclaredSymbolInfoKind.Delegate))
{
var symbol = await ResolveAsync(document, info, cachedModels, cancellationToken).ConfigureAwait(false) as INamedTypeSymbol;
if (symbol != null)
{
result = result ?? new HashSet<INamedTypeSymbol>();
result.Add(symbol);
}
}
else if (inheritanceQuery.DerivesFromSystemObject && info.Kind == DeclaredSymbolInfoKind.Class)
{
// Searching for types derived from 'Object' needs to be handled specially.
// There may be no indication in source what the type actually derives from.
// Also, we can't just look for an empty inheritance list. We may have
// something like: "class C : IFoo". This type derives from object, despite
// having a non-empty list.
var symbol = await ResolveAsync(document, info, cachedModels, cancellationToken).ConfigureAwait(false) as INamedTypeSymbol;
if (symbol?.BaseType?.SpecialType == SpecialType.System_Object)
{
result = result ?? new HashSet<INamedTypeSymbol>();
result.Add(symbol);
}
}
else if (AnyInheritanceNamesMatch(info, inheritanceQuery.TypeNames))
{
// Looks like we have a potential match. Actually check if the symbol is viable.
var symbol = await ResolveAsync(document, info, cachedModels, cancellationToken).ConfigureAwait(false) as INamedTypeSymbol;
if (symbol != null)
{
if (typeImmediatelyMatches(typesToSearchFor, symbol))
{
result = result ?? new HashSet<INamedTypeSymbol>();
result.Add(symbol);
}
}
}
return result;
}
private static async Task<IEnumerable<INamedTypeSymbol>> FindImmediatelyInheritingTypesInDocumentAsync(
Document document,
HashSet<INamedTypeSymbol> typesToSearchFor,
InheritanceQuery inheritanceQuery,
ConcurrentSet<SemanticModel> cachedModels,
ConcurrentSet<IDeclarationInfo> cachedInfos,
Func<HashSet<INamedTypeSymbol>, INamedTypeSymbol, bool> typeImmediatelyMatches,
CancellationToken cancellationToken)
{
var declarationInfo = await document.GetDeclarationInfoAsync(cancellationToken).ConfigureAwait(false);
cachedInfos.Add(declarationInfo);
HashSet<INamedTypeSymbol> result = null;
foreach (var symbolInfo in declarationInfo.DeclaredSymbolInfos)
{
result = await ProcessSymbolInfo(
document, symbolInfo,
typesToSearchFor,
inheritanceQuery, cachedModels,
typeImmediatelyMatches, result, cancellationToken).ConfigureAwait(false);
}
return result;
}
private static async Task<IEnumerable<INamedTypeSymbol>> FindSourceTypesInProjectAsync(
HashSet<INamedTypeSymbol> sourceAndMetadataTypes,
Project project,
Func<HashSet<INamedTypeSymbol>, INamedTypeSymbol, bool> sourceTypeImmediatelyMatches,
Func<INamedTypeSymbol, bool> shouldContinueSearching,
bool transitive,
CancellationToken cancellationToken)
{
// We're going to be sweeping over this project over and over until we reach a
// fixed point. In order to limit GC and excess work, we cache all the sematic
// models and DeclaredSymbolInfo for hte documents we look at.
// Because we're only processing a project at a time, this is not an issue.
var cachedModels = new ConcurrentSet<SemanticModel>();
var cachedInfos = new ConcurrentSet<IDeclarationInfo>();
var finalResult = new HashSet<INamedTypeSymbol>(SymbolEquivalenceComparer.Instance);
var typesToSearchFor = new HashSet<INamedTypeSymbol>(SymbolEquivalenceComparer.Instance);
typesToSearchFor.AddAll(sourceAndMetadataTypes);
var inheritanceQuery = new InheritanceQuery(sourceAndMetadataTypes);
// As long as there are new types to search for, keep looping.
while (typesToSearchFor.Count > 0)
{
// Compute the set of names to look for in the base/interface lists.
inheritanceQuery.TypeNames.AddRange(typesToSearchFor.Select(c => c.Name));
// Search all the documents of this project in parallel.
var tasks = project.Documents.Select(d => FindImmediatelyInheritingTypesInDocumentAsync(
d, typesToSearchFor, inheritanceQuery,
cachedModels, cachedInfos,
sourceTypeImmediatelyMatches, cancellationToken)).ToArray();
await Task.WhenAll(tasks).ConfigureAwait(false);
// Clear out the information about the types we're looking for. We'll
// fill these in if we discover any more types that we need to keep searching
// for.
typesToSearchFor.Clear();
inheritanceQuery.TypeNames.Clear();
foreach (var task in tasks)
{
if (task.Result != null)
{
foreach (var derivedType in task.Result)
{
if (finalResult.Add(derivedType))
{
if (transitive && shouldContinueSearching(derivedType))
{
typesToSearchFor.Add(derivedType);
}
}
}
}
}
}
return finalResult;
}
private static async Task<ImmutableArray<SymbolAndProjectId<INamedTypeSymbol>>> FindImmediatelyInheritingTypesInDocumentAsync(
Document document,
SymbolAndProjectIdSet typesToSearchFor,
InheritanceQuery inheritanceQuery,
ConcurrentSet<SemanticModel> cachedModels,
ConcurrentSet<IDeclarationInfo> cachedInfos,
Func<SymbolAndProjectIdSet, INamedTypeSymbol, bool> typeImmediatelyMatches,
CancellationToken cancellationToken)
{
var declarationInfo = await document.GetDeclarationInfoAsync(cancellationToken).ConfigureAwait(false);
cachedInfos.Add(declarationInfo);
var result = CreateSymbolAndProjectIdSet();
foreach (var symbolInfo in declarationInfo.DeclaredSymbolInfos)
{
await ProcessSymbolInfo(
document, symbolInfo,
typesToSearchFor,
inheritanceQuery, cachedModels,
typeImmediatelyMatches, result, cancellationToken).ConfigureAwait(false);
}
return ToImmutableAndFree(result);
}