public override SyntaxNode VisitInvocationExpression(InvocationExpressionSyntax node)
{
if (node.Expression is IdentifierNameSyntax ins && this.FileContains(ins.Identifier.ValueText))
{
var updated = node.AddArgumentListArguments(Argument(IdentifierName(TokenName)));
return(base.VisitInvocationExpression(node.ReplaceNode(node, updated).NormalizeWhitespace()));
}
protected override async Task <SyntaxNodeReplacementPair> ConstructInvocationPairAsync(Document document, InvocationExpressionSyntax syntaxDeclaration, CancellationToken cancellationToken)
{
ArgumentSyntax newArgument = CreateArgument();
InvocationExpressionSyntax updatedMethodInvocation = syntaxDeclaration.AddArgumentListArguments(newArgument);
SyntaxNode root = await GetRootAsync(document, cancellationToken).ConfigureAwait(false);
return(new SyntaxNodeReplacementPair(document, root, syntaxDeclaration, updatedMethodInvocation));
}
/// <summary>
/// Generates a sequence of aggregate <see cref="StatementSyntax"/> for the specified sequence of <see cref="CommandElement"/>.
/// </summary>
/// <param name="commands">The sequence of <see cref="CommandElement"/> for which to generate the code.</param>
/// <returns>The sequence of generated <see cref="StatementSyntax"/>.</returns>
private static IEnumerable <StatementSyntax> GenerateAggregateStatements(IEnumerable <CommandElement> commands)
{
InvocationExpressionSyntax invocation = SyntaxFactory.InvocationExpression(SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName(Parameter2Name), SyntaxFactory.IdentifierName(nameof(ICollection <ICommand> .Add))));
foreach (CommandElement command in commands)
{
yield return(SyntaxFactory.ExpressionStatement(invocation.AddArgumentListArguments(SyntaxFactory.Argument(SyntaxFactory.IdentifierName(command.Identifier)))));
}
}
private static ExpressionSyntax CreateNewExpression(
InvocationExpressionSyntax invocationExpression,
ExpressionSyntax expression)
{
InvocationExpressionSyntax newExpression = ChangeInvokedMethodName(invocationExpression, "Skip");
newExpression = newExpression.AddArgumentListArguments(Argument(expression));
return(SimpleMemberInvocationExpression(newExpression, IdentifierName("Any")));
}
/// <summary>
/// Generates a sequence of initialize <see cref="StatementSyntax"/> for the specified sequence of <see cref="CommandElement"/>.
/// </summary>
/// <param name="commands">The sequence of <see cref="CommandElement"/> for which to generate the code.</param>
/// <returns>The sequence of generated <see cref="StatementSyntax"/>.</returns>
private static IEnumerable <StatementSyntax> GenerateInitializeStatements(IEnumerable <CommandElement> commands)
{
if (SyntaxFactory.ParseTypeName(DelegateCommand) is QualifiedNameSyntax typeName)
{
IdentifierNameSyntax parameterName = SyntaxFactory.IdentifierName(Parameter1Name);
NameSyntax actionLeft = SyntaxFactory.ParseName(typeof(Action <object>).Namespace);
GenericNameSyntax actionRight = SyntaxFactory.GenericName(nameof(Action <object>));
NameSyntax funcLeft = SyntaxFactory.ParseName(typeof(Func <object, bool>).Namespace);
GenericNameSyntax funcRight = SyntaxFactory.GenericName(nameof(Func <object, bool>));
PredefinedTypeSyntax boolType = SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.BoolKeyword));
InvocationExpressionSyntax name = SyntaxFactory.InvocationExpression(SyntaxFactory.IdentifierName(SyntaxFactory.ParseToken(SyntaxFactory.Token(SyntaxKind.NameOfKeyword).ValueText)));
foreach (CommandElement command in commands)
{
List <ArgumentSyntax> arguments = new List <ArgumentSyntax>();
arguments.Add(
SyntaxFactory.Argument(
SyntaxFactory.ObjectCreationExpression(SyntaxFactory.QualifiedName(actionLeft, actionRight.AddTypeArgumentListArguments(command.ParameterType))).AddArgumentListArguments(
SyntaxFactory.Argument(SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, parameterName, SyntaxFactory.IdentifierName(command.Execute)))
)
)
);
if (command.CanExecute.HasValue)
{
arguments.Add(
SyntaxFactory.Argument(
SyntaxFactory.ObjectCreationExpression(SyntaxFactory.QualifiedName(funcLeft, funcRight.AddTypeArgumentListArguments(command.ParameterType, boolType))).AddArgumentListArguments(
SyntaxFactory.Argument(SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, parameterName, SyntaxFactory.IdentifierName(command.CanExecute.Value)))
)
)
);
}
arguments.Add(SyntaxFactory.Argument(name.AddArgumentListArguments(SyntaxFactory.Argument(SyntaxFactory.IdentifierName(command.Identifier)))));
TypeSyntax type = typeName.WithRight(SyntaxFactory.GenericName(typeName.Right.Identifier).AddTypeArgumentListArguments(command.ParameterType));
yield return(SyntaxFactory.ExpressionStatement(
SyntaxFactory.AssignmentExpression(
SyntaxKind.SimpleAssignmentExpression,
SyntaxFactory.IdentifierName(command.Identifier),
SyntaxFactory.InvocationExpression(SyntaxFactory.ObjectCreationExpression(type)).AddArgumentListArguments(arguments.ToArray())
)
));
}
}
}
private static InvocationExpressionSyntax AddXunitIgnoreCase(InvocationExpressionSyntax convertedExpression)
{
var ignoreCaseComparison = Argument(
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
IdentifierName("StringComparison"),
IdentifierName("OrdinalIgnoreCase")
)
);
return(convertedExpression.AddArgumentListArguments(ignoreCaseComparison));
}
private async Task <Document> CollapseMethodCalls(Document document, InvocationExpressionSyntax typeDecl, CancellationToken cancellationToken)
{
InvocationExpressionSyntax grandParent = typeDecl.Parent.Parent as InvocationExpressionSyntax;
InvocationExpressionSyntax newLocal = typeDecl.AddArgumentListArguments(grandParent.ArgumentList.Arguments.ToArray());
InvocationExpressionSyntax formattedLocal = newLocal.WithAdditionalAnnotations(Formatter.Annotation);
SyntaxNode oldRoot = await document.GetSyntaxRootAsync(cancellationToken);
SyntaxNode newRoot = oldRoot.ReplaceNode(grandParent, formattedLocal);
// Return document with transformed tree.
return(document.WithSyntaxRoot(newRoot));
}
protected override async Task <SyntaxNodeReplacementPair> ConstructInvocationPairAsync(Document document, InvocationExpressionSyntax syntaxDeclaration, CancellationToken cancellationToken)
{
SyntaxNode root = await GetRootAsync(document, cancellationToken).ConfigureAwait(false);
BaseMethodDeclarationSyntax parentMethodSyntax = GetSyntaxes <BaseMethodDeclarationSyntax>(root, syntaxDeclaration.Span)
.FirstOrDefault();
if (parentMethodSyntax == null)
{
return(null);
}
List <ParameterSyntax> parameters = parentMethodSyntax.ParameterList.Parameters.ToList();
ParameterSyntax cancellationTokenParameter = parameters.FirstOrDefault(CompareParameter);
ArgumentSyntax newArgument = CreateArgument(cancellationTokenParameter);
InvocationExpressionSyntax updatedMethodInvocation = syntaxDeclaration.AddArgumentListArguments(newArgument);
return(new SyntaxNodeReplacementPair(document, root, syntaxDeclaration, updatedMethodInvocation));
}
protected override async Task <Document> FixIdentifierName(Document document, SyntaxGenerator generator, SyntaxNode root, SyntaxNode identifier, CancellationToken cancellationToken)
{
InvocationExpressionSyntax invokeParent = identifier?.Parent?.FirstAncestorOrSelf <InvocationExpressionSyntax>();
if (invokeParent != null)
{
SemanticModel model = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
if (model.GetSymbolInfo((IdentifierNameSyntax)identifier, cancellationToken).Symbol is IMethodSymbol methodSymbol && CanAddStringComparison(methodSymbol, model))
{
// append a new StringComparison.Ordinal argument
SyntaxNode newArg = generator.Argument(CreateOrdinalMemberAccess(generator, model))
.WithAdditionalAnnotations(Formatter.Annotation);
InvocationExpressionSyntax newInvoke = invokeParent.AddArgumentListArguments((ArgumentSyntax)newArg).WithAdditionalAnnotations(Formatter.Annotation);
SyntaxNode newRoot = root.ReplaceNode(invokeParent, newInvoke);
return(document.WithSyntaxRoot(newRoot));
}
}
return(document);
}
private static ExpressionSyntax BuildFieldEqualityCall(ISymbol fieldSymbol)
{
ITypeSymbol fieldType = (fieldSymbol as IFieldSymbol)?.Type ?? (fieldSymbol as IPropertySymbol).Type;
bool declaresEqualityOperator = fieldType
.GetMembers()
.OfType <IMethodSymbol>()
.Where(m => m.MethodKind == MethodKind.BuiltinOperator || m.MethodKind == MethodKind.UserDefinedOperator)
.Where(m => m.Name == "op_Equality")
.Any();
// If the field type declares == operator, we can safely use it.
// This provides better readability in a lot of cases.
if (declaresEqualityOperator)
{
return(BinaryExpression
(
SyntaxKind.EqualsExpression,
MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, ThisExpression(), IdentifierName(fieldSymbol.Name)),
MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, IdentifierName(_otherArg), IdentifierName(fieldSymbol.Name))
));
}
// Otherwise, we have to resort to EqualityComparer<T>.Default.Equals( this._field, other._field )
MemberAccessExpressionSyntax defaultProperty = DefaultEqualityComparer.AccessExpression(fieldType);
MemberAccessExpressionSyntax equalsMethod = MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, defaultProperty, IdentifierName("Equals"));
InvocationExpressionSyntax invocation = InvocationExpression(equalsMethod);
invocation = invocation
.AddArgumentListArguments
(
Argument(MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, ThisExpression(), IdentifierName(fieldSymbol.Name))),
Argument(MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, IdentifierName(_otherArg), IdentifierName(fieldSymbol.Name)))
);
return(invocation);
}
public static InvocationExpressionSyntax AddArgumentListArguments(this InvocationExpressionSyntax syntax, IEnumerable <ArgumentSyntax> arguments)
{
return(syntax.AddArgumentListArguments(arguments.ToArray()));
}
