private bool TryFindInvocation(
TextSpan span,
SyntaxNode root,
SemanticModel semanticModel,
ImmutableArray <IMethodSymbol> formatMethods,
ISyntaxFactsService syntaxFactsService,
CancellationToken cancellationToken,
out TInvocationExpressionSyntax invocation,
out ISymbol invocationSymbol)
{
invocationSymbol = null;
invocation = root.FindNode(span, getInnermostNodeForTie: true)?.FirstAncestorOrSelf <TInvocationExpressionSyntax>();
while (invocation != null)
{
var arguments = syntaxFactsService.GetArgumentsOfInvocationExpression(invocation);
if (arguments.Count >= 2)
{
var firstArgumentExpression = syntaxFactsService.GetExpressionOfArgument(arguments[0]) as TLiteralExpressionSyntax;
if (firstArgumentExpression != null && syntaxFactsService.IsStringLiteral(firstArgumentExpression.GetFirstToken()))
{
invocationSymbol = semanticModel.GetSymbolInfo(invocation, cancellationToken).Symbol;
if (formatMethods.Contains(invocationSymbol))
{
break;
}
}
}
invocation = invocation.Parent?.FirstAncestorOrSelf <TInvocationExpressionSyntax>();
}
return(invocation != null);
}
private static RegisterFixData <TArgumentSyntax> TryGetInvocationExpressionFixInfo(
SemanticModel semanticModel,
ISyntaxFactsService syntaxFacts,
SyntaxNode node,
CancellationToken cancellationToken
)
{
if (node is TInvocationExpressionSyntax invocationExpression)
{
var expression = syntaxFacts.GetExpressionOfInvocationExpression(
invocationExpression
);
var candidates = semanticModel
.GetMemberGroup(expression, cancellationToken)
.OfType <IMethodSymbol>()
.ToImmutableArray();
var arguments =
(SeparatedSyntaxList <TArgumentSyntax>)syntaxFacts.GetArgumentsOfInvocationExpression(
invocationExpression
);
// In VB a constructor calls other constructor overloads via a Me.New(..) invocation.
// If the candidates are MethodKind.Constructor than these are the equivalent the a C# ConstructorInitializer.
var isConstructorInitializer = candidates.All(
m => m.MethodKind == MethodKind.Constructor
);
return(new RegisterFixData <TArgumentSyntax>(
arguments,
candidates,
isConstructorInitializer
));
}
return(null);
}
static bool IsValidPlaceholderToInterpolatedString(TInvocationExpressionSyntax invocation,
ISyntaxFactsService syntaxFactsService,
SemanticModel semanticModel,
ImmutableArray <IMethodSymbol> formatMethods,
AbstractConvertPlaceholderToInterpolatedStringRefactoringProvider <
TInvocationExpressionSyntax, TExpressionSyntax,
TArgumentSyntax, TLiteralExpressionSyntax,
TArgumentListExpressionSyntax> thisInstance,
CancellationToken cancellationToken)
{
var arguments = syntaxFactsService.GetArgumentsOfInvocationExpression(invocation);
if (arguments.Count >= 2)
{
if (syntaxFactsService.GetExpressionOfArgument(thisInstance.GetFormatArgument(arguments, syntaxFactsService)) is TLiteralExpressionSyntax firstArgumentExpression &&
syntaxFactsService.IsStringLiteral(firstArgumentExpression.GetFirstToken()))
{
var invocationSymbol = semanticModel.GetSymbolInfo(invocation, cancellationToken).Symbol;
if (formatMethods.Contains(invocationSymbol))
{
return(true);
}
}
}
return(false);
}
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 async Task <Document> CreateInterpolatedString(
TInvocationExpressionSyntax invocation,
Document document,
ISyntaxFactsService syntaxFactsService,
CancellationToken cancellationToken)
{
var semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
var arguments = syntaxFactsService.GetArgumentsOfInvocationExpression(invocation);
var literalExpression = syntaxFactsService.GetExpressionOfArgument(arguments[0]) as TLiteralExpressionSyntax;
var text = literalExpression.GetFirstToken().ToString();
var syntaxGenerator = document.Project.LanguageServices.GetService <SyntaxGenerator>();
var expandedArguments = GetExpandedArguments(semanticModel, arguments, syntaxGenerator, syntaxFactsService);
var interpolatedString = GetInterpolatedString(text);
var newInterpolatedString = VisitArguments(expandedArguments, interpolatedString, syntaxFactsService);
var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
var newRoot = root.ReplaceNode(invocation, newInterpolatedString.WithTriviaFrom(invocation));
return(document.WithSyntaxRoot(newRoot));
}
