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())); }