> GetReferencesForMatchingNamespacesAsync(SearchScope searchScope)
{
searchScope.CancellationToken.ThrowIfCancellationRequested();
if (_owner.CanAddImportForNamespace(_diagnosticId, _node, out var nameNode))
{
_syntaxFacts.GetNameAndArityOfSimpleName(nameNode, out var name, out var arity);
if (
arity == 0 &&
!ExpressionBinds(
nameNode,
checkForExtensionMethods: false,
cancellationToken: searchScope.CancellationToken
)
)
{
var symbols = await searchScope
.FindDeclarationsAsync(name, nameNode, SymbolFilter.Namespace)
.ConfigureAwait(false);
var namespaceSymbols = OfType <INamespaceSymbol>(symbols);
var containingNamespaceSymbols = OfType <INamespaceSymbol>(symbols)
.SelectAsArray(s => s.WithSymbol(s.Symbol.ContainingNamespace));
return(GetNamespaceSymbolReferences(
searchScope,
containingNamespaceSymbols
));
}
}
return(ImmutableArray <SymbolReference> .Empty);
}
private async Task <IList <SymbolReference> > GetNamespacesForMatchingNamespacesAsync(
SearchScope searchScope)
{
searchScope.CancellationToken.ThrowIfCancellationRequested();
TSimpleNameSyntax nameNode;
if (!_owner.CanAddImportForNamespace(_diagnostic, _node, out nameNode))
{
return(null);
}
string name;
int arity;
_syntaxFacts.GetNameAndArityOfSimpleName(nameNode, out name, out arity);
if (arity > 0)
{
return(null);
}
if (ExpressionBinds(searchScope, nameNode, checkForExtensionMethods: false))
{
return(null);
}
var symbols = await searchScope.FindDeclarationsAsync(name, nameNode, SymbolFilter.Namespace).ConfigureAwait(false);
return(GetProposedNamespaces(
searchScope, OfType <INamespaceSymbol>(symbols).Select(s => s.WithSymbol(s.Symbol.ContainingNamespace))));
}
private async Task <IEnumerable <IMethodSymbol> > GetAddMethodsAsync(
Project project,
Diagnostic diagnostic,
SyntaxNode node,
SemanticModel semanticModel,
ISet <INamespaceSymbol> namespacesInScope,
ISyntaxFactsService syntaxFacts,
SyntaxNode expression,
CancellationToken cancellationToken)
{
string name;
int arity;
syntaxFacts.GetNameAndArityOfSimpleName(node, 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.IsAccessibleWithin(semanticModel.Compilation.Assembly) == true &&
IsViableExtensionMethod(method, expression, semanticModel, syntaxFacts, cancellationToken)));
}
return(SpecializedCollections.EmptyEnumerable <IMethodSymbol>());
}
private Task <IEnumerable <ISymbol> > GetSymbolsAsync(
Project project,
SyntaxNode node,
SemanticModel semanticModel,
ISyntaxFactsService syntaxFacts,
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(SpecializedTasks.EmptyEnumerable <ISymbol>());
}
string name;
int arity;
syntaxFacts.GetNameAndArityOfSimpleName(node, out name, out arity);
if (name == null)
{
return(SpecializedTasks.EmptyEnumerable <ISymbol>());
}
return(SymbolFinder.FindDeclarationsAsync(project, name, this.IgnoreCase, SymbolFilter.Member, cancellationToken));
}
private async Task <IEnumerable <INamespaceSymbol> > GetNamespacesForMatchingNamespacesAsync(
Project project,
Diagnostic diagnostic,
SyntaxNode node,
SemanticModel semanticModel,
ISet <INamespaceSymbol> namespacesInScope,
ISyntaxFactsService syntaxFacts,
CancellationToken cancellationToken)
{
if (!this.CanAddImportForNamespace(diagnostic, ref node))
{
return(null);
}
string name;
int arity;
syntaxFacts.GetNameAndArityOfSimpleName(node, 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));
}
private static void CalculateContext(SyntaxNode node, ISyntaxFactsService syntaxFacts, out string name, out int arity, out bool inAttributeContext, out bool hasIncompleteParentMember)
{
// Has to be a simple identifier or generic name.
syntaxFacts.GetNameAndArityOfSimpleName(node, out name, out arity);
inAttributeContext = syntaxFacts.IsAttributeName(node);
hasIncompleteParentMember = syntaxFacts.HasIncompleteParentMember(node);
}
private static bool TryAnalyzeInvocationCondition(
SyntaxNodeAnalysisContext context,
ISyntaxFactsService syntaxFacts,
IMethodSymbol?referenceEqualsMethodOpt,
TInvocationExpression invocation,
[NotNullWhen(true)] out SyntaxNode?conditionPartToCheck,
out bool isEquals)
{
conditionPartToCheck = null;
isEquals = true;
var expression = syntaxFacts.GetExpressionOfInvocationExpression(invocation);
var nameNode = syntaxFacts.IsIdentifierName(expression)
? expression
: syntaxFacts.IsSimpleMemberAccessExpression(expression)
? syntaxFacts.GetNameOfMemberAccessExpression(expression)
: null;
if (!syntaxFacts.IsIdentifierName(nameNode))
{
return(false);
}
syntaxFacts.GetNameAndArityOfSimpleName(nameNode, out var name, out _);
if (!syntaxFacts.StringComparer.Equals(name, nameof(ReferenceEquals)))
{
return(false);
}
var arguments = syntaxFacts.GetArgumentsOfInvocationExpression(invocation);
if (arguments.Count != 2)
{
return(false);
}
var conditionLeft = syntaxFacts.GetExpressionOfArgument(arguments[0]);
var conditionRight = syntaxFacts.GetExpressionOfArgument(arguments[1]);
if (conditionLeft == null || conditionRight == null)
{
return(false);
}
conditionPartToCheck = GetConditionPartToCheck(syntaxFacts, conditionLeft, conditionRight);
if (conditionPartToCheck == null)
{
return(false);
}
var semanticModel = context.SemanticModel;
var cancellationToken = context.CancellationToken;
var symbol = semanticModel.GetSymbolInfo(invocation, cancellationToken).Symbol;
return(referenceEqualsMethodOpt != null && referenceEqualsMethodOpt.Equals(symbol));
}
private bool TryAnalyzeAddInvocation(
TExpressionStatementSyntax statement,
out SyntaxNode instance)
{
instance = null;
var invocationExpression = _syntaxFacts.GetExpressionOfExpressionStatement(statement) as TInvocationExpressionSyntax;
if (invocationExpression == null)
{
return(false);
}
var arguments = _syntaxFacts.GetArgumentsOfInvocationExpression(invocationExpression);
if (arguments.Count < 1)
{
return(false);
}
foreach (var argument in arguments)
{
if (!_syntaxFacts.IsSimpleArgument(argument))
{
return(false);
}
}
var memberAccess = _syntaxFacts.GetExpressionOfInvocationExpression(invocationExpression) as TMemberAccessExpressionSyntax;
if (memberAccess == null)
{
return(false);
}
if (!_syntaxFacts.IsSimpleMemberAccessExpression(memberAccess))
{
return(false);
}
SyntaxNode memberName;
_syntaxFacts.GetPartsOfMemberAccessExpression(memberAccess, out instance, out memberName);
string name;
int arity;
_syntaxFacts.GetNameAndArityOfSimpleName(memberName, out name, out arity);
if (arity != 0 || !name.Equals(nameof(IList.Add)))
{
return(false);
}
return(true);
}
private void CalculateContext(
TSimpleNameSyntax nameNode, ISyntaxFactsService syntaxFacts, out string name, out int arity,
out bool inAttributeContext, out bool hasIncompleteParentMember, out bool looksGeneric)
{
// Has to be a simple identifier or generic name.
syntaxFacts.GetNameAndArityOfSimpleName(nameNode, out name, out arity);
inAttributeContext = syntaxFacts.IsAttributeName(nameNode);
hasIncompleteParentMember = syntaxFacts.HasIncompleteParentMember(nameNode);
looksGeneric = syntaxFacts.LooksGeneric(nameNode);
}
private async Task <IList <SymbolReference> > GetNamespacesForMatchingNamespacesAsync(SearchScope searchScope)
{
if (!_owner.CanAddImportForNamespace(_diagnostic, ref _node))
{
return(null);
}
string name;
int arity;
_syntaxFacts.GetNameAndArityOfSimpleName(_node, out name, out arity);
if (ExpressionBinds(checkForExtensionMethods: false))
{
return(null);
}
var symbols = await searchScope.FindDeclarationsAsync(name, SymbolFilter.Namespace).ConfigureAwait(false);
return(GetProposedNamespaces(
searchScope, symbols.OfType <INamespaceSymbol>().Select(n => n.ContainingNamespace)));
}
private async Task <IEnumerable <INamespaceSymbol> > GetNamespacesForMatchingExtensionMethodsAsync(
Project project,
Diagnostic diagnostic,
SyntaxNode node,
SemanticModel semanticModel,
ISet <INamespaceSymbol> namespacesInScope,
ISyntaxFactsService syntaxFacts,
CancellationToken cancellationToken)
{
if (!this.CanAddImportForMethod(diagnostic, syntaxFacts, ref node))
{
return(null);
}
var expression = node.Parent;
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(null);
}
string name;
int arity;
syntaxFacts.GetNameAndArityOfSimpleName(node, out name, out arity);
var symbols = await SymbolFinder.FindDeclarationsAsync(project, name, this.IgnoreCase, SymbolFilter.Member, cancellationToken).ConfigureAwait(false);
var extensionMethodSymbols = symbols
.OfType <IMethodSymbol>()
.Where(method => method.IsExtensionMethod &&
method.ContainingType?.IsAccessibleWithin(semanticModel.Compilation.Assembly) == true &&
IsViableExtensionMethod(method, expression, semanticModel, syntaxFacts, cancellationToken))
.ToList();
return(GetProposedNamespaces(
extensionMethodSymbols.Select(s => s.ContainingNamespace),
semanticModel,
namespacesInScope));
}
private static void CalculateContext(SyntaxNode node, ISyntaxFactsService syntaxFacts, out string name, out int arity, out bool inAttributeContext, out bool hasIncompleteParentMember)
{
// Has to be a simple identifier or generic name.
syntaxFacts.GetNameAndArityOfSimpleName(node, out name, out arity);
inAttributeContext = syntaxFacts.IsAttributeName(node);
hasIncompleteParentMember = syntaxFacts.HasIncompleteParentMember(node);
}
private async Task<IEnumerable<IMethodSymbol>> GetAddMethodsAsync(
Project project,
Diagnostic diagnostic,
SyntaxNode node,
SemanticModel semanticModel,
ISet<INamespaceSymbol> namespacesInScope,
ISyntaxFactsService syntaxFacts,
SyntaxNode expression,
CancellationToken cancellationToken)
{
string name;
int arity;
syntaxFacts.GetNameAndArityOfSimpleName(node, 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, syntaxFacts, cancellationToken));
}
return SpecializedCollections.EmptyEnumerable<IMethodSymbol>();
}
private Task<IEnumerable<ISymbol>> GetSymbolsAsync(
Project project,
SyntaxNode node,
SemanticModel semanticModel,
ISyntaxFactsService syntaxFacts,
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 SpecializedTasks.EmptyEnumerable<ISymbol>();
}
string name;
int arity;
syntaxFacts.GetNameAndArityOfSimpleName(node, out name, out arity);
if (name == null)
{
return SpecializedTasks.EmptyEnumerable<ISymbol>();
}
return SymbolFinder.FindDeclarationsAsync(project, name, this.IgnoreCase, SymbolFilter.Member, cancellationToken);
}
private async Task<IEnumerable<INamespaceSymbol>> GetNamespacesForMatchingNamespacesAsync(
Project project,
Diagnostic diagnostic,
SyntaxNode node,
SemanticModel semanticModel,
ISet<INamespaceSymbol> namespacesInScope,
ISyntaxFactsService syntaxFacts,
CancellationToken cancellationToken)
{
if (!this.CanAddImportForNamespace(diagnostic, ref node))
{
return null;
}
string name;
int arity;
syntaxFacts.GetNameAndArityOfSimpleName(node, 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);
}