internal async Task<IEnumerable<ISymbol>> GetMatchingNamespacesAsync(
Microsoft.CodeAnalysis.Project project,
SemanticModel semanticModel,
SyntaxNode simpleName,
CancellationToken cancellationToken)
{
if (simpleName.IsAttributeName())
{
return null;
}
string name;
int arity;
simpleName.GetNameAndArityOfSimpleName(out name, out arity);
if (cancellationToken.IsCancellationRequested)
{
return null;
}
var symbols = await SymbolFinder.FindDeclarationsAsync(project, name, this.IgnoreCase, SymbolFilter.Namespace, cancellationToken).ConfigureAwait(false);
var namespaces = symbols
.OfType<INamespaceSymbol>()
.Where(n => !n.IsGlobalNamespace &&
HasAccessibleTypes(n, semanticModel, cancellationToken));
return namespaces;
}
internal async Task<IEnumerable<ISymbol>> GetMatchingTypesAsync(
Microsoft.CodeAnalysis.Project project, SemanticModel semanticModel, SyntaxNode node, CancellationToken cancellationToken)
{
// Can't be on the right hand side of binary expression (like 'dot').
cancellationToken.ThrowIfCancellationRequested();
string name;
int arity;
node.GetNameAndArityOfSimpleName(out name, out arity);
var symbols = await SymbolFinder.FindDeclarationsAsync(project, name, this.IgnoreCase, SymbolFilter.Type, cancellationToken).ConfigureAwait(false);
// also lookup type symbols with the "Attribute" suffix.
var inAttributeContext = node.IsAttributeName();
if (inAttributeContext)
{
symbols = symbols.Concat(
await SymbolFinder.FindDeclarationsAsync(project, name + "Attribute", this.IgnoreCase, SymbolFilter.Type, cancellationToken).ConfigureAwait(false));
}
var accessibleTypeSymbols = symbols
.OfType<INamedTypeSymbol>()
.Where(s => (arity == 0 || s.GetArity() == arity)
&& s.IsAccessibleWithin(semanticModel.Compilation.Assembly)
&& (!inAttributeContext || s.IsAttribute())
&& HasValidContainer(s))
.ToList();
return accessibleTypeSymbols;
}
private static void CalculateContext(SyntaxNode node, out string name, out int arity, out bool inAttributeContext, out bool hasIncompleteParentMember)
{
// Has to be a simple identifier or generic name.
node.GetNameAndArityOfSimpleName(out name, out arity);
inAttributeContext = node.IsAttributeName();
hasIncompleteParentMember = node.HasIncompleteParentMember();
}
private async Task<IEnumerable<IMethodSymbol>> GetAddMethodsAsync(
Microsoft.CodeAnalysis.Project project,
Diagnostic diagnostic,
SyntaxNode node,
SemanticModel semanticModel,
ISet<INamespaceSymbol> namespacesInScope,
SyntaxNode expression,
CancellationToken cancellationToken)
{
string name;
int arity;
node.GetNameAndArityOfSimpleName(out name, out arity);
if (name != null)
{
return SpecializedCollections.EmptyEnumerable<IMethodSymbol>();
}
if (IsAddMethodContext(node, semanticModel))
{
var symbols = await SymbolFinder.FindDeclarationsAsync(project, "Add", this.IgnoreCase, SymbolFilter.Member, cancellationToken).ConfigureAwait(false);
return symbols
.OfType<IMethodSymbol>()
.Where(method => method.IsExtensionMethod &&
method.ContainingType?.IsAccessibleWithin(semanticModel.Compilation.Assembly) == true &&
IsViableExtensionMethod(method, expression, semanticModel, cancellationToken));
}
return SpecializedCollections.EmptyEnumerable<IMethodSymbol>();
}
private Task<IEnumerable<ISymbol>> GetSymbolsAsync(
Microsoft.CodeAnalysis.Project project,
SyntaxNode node,
SemanticModel semanticModel,
CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
// See if the name binds. If it does, there's nothing further we need to do.
if (ExpressionBinds(node, semanticModel, cancellationToken, checkForExtensionMethods: true))
{
return Task.FromResult (Enumerable.Empty<ISymbol>());
}
string name;
int arity;
node.GetNameAndArityOfSimpleName(out name, out arity);
if (name == null)
{
return Task.FromResult (Enumerable.Empty<ISymbol>());
}
return SymbolFinder.FindDeclarationsAsync(project, name, this.IgnoreCase, SymbolFilter.Member, cancellationToken);
}
private async Task<IEnumerable<INamespaceSymbol>> GetNamespacesForMatchingNamespacesAsync(
Microsoft.CodeAnalysis.Project project,
Diagnostic diagnostic,
SyntaxNode node,
SemanticModel semanticModel,
ISet<INamespaceSymbol> namespacesInScope,
CancellationToken cancellationToken)
{
if (!this.CanAddImportForNamespace(diagnostic, ref node))
{
return null;
}
string name;
int arity;
node.GetNameAndArityOfSimpleName(out name, out arity);
if (ExpressionBinds(node, semanticModel, cancellationToken))
{
return null;
}
var symbols = await SymbolFinder.FindDeclarationsAsync(
project, name, this.IgnoreCase, SymbolFilter.Namespace, cancellationToken).ConfigureAwait(false);
return GetProposedNamespaces(
symbols.OfType<INamespaceSymbol>().Select(n => n.ContainingNamespace),
semanticModel,
namespacesInScope);
}
