private static ArgumentSyntax AddParameterName( ArgumentSyntax argument, SemanticModel semanticModel, CancellationToken cancellationToken = default(CancellationToken)) { if (argument.NameColon == null || argument.NameColon.IsMissing) { IParameterSymbol parameterSymbol = CSharpAnalysis.DetermineParameter( argument, semanticModel, allowParams: false, cancellationToken: cancellationToken); if (parameterSymbol != null) { return(argument .WithNameColon( NameColon(parameterSymbol.ToDisplayString(_symbolDisplayFormat)) .WithTrailingSpace()) .WithTriviaFrom(argument)); } } return(argument); }
private ArgumentSyntax FixArgumentIfNeeded(ArgumentSyntax argument, string paramName) { if (argument.NameColon != null) { return(argument); } return(argument.WithNameColon(SyntaxFactory.NameColon(paramName))); }
private ArgumentSyntax SimplifyTupleName(ArgumentSyntax node, SemanticModel semanticModel, OptionSet optionSet, CancellationToken cancellationToken) { if (CanSimplifyTupleElementName(node, this.ParseOptions)) { return(node.WithNameColon(null).WithTriviaFrom(node)); } return(node); }
private ArgumentSyntax FixArgumentIfNeeded(ArgumentSyntax argument, ParameterSyntax param) { if (argument.NameColon != null) { return(argument); } return(argument.WithNameColon(SyntaxFactory.NameColon(param.Identifier.Text))); }
public override SyntaxNode VisitArgument(ArgumentSyntax node) { if (node == null) { throw new ArgumentNullException(nameof(node)); } return(node .WithNameColon(null) .WithTriviaFrom(node)); }
public override SyntaxNode VisitArgument(ArgumentSyntax node) { if (node.NameColon != null) { return(node .WithNameColon(node.NameColon.AppendToLeadingTrivia(TriviaList(NewLine(), Whitespace(new string(' ', 4 * (2 + _classDeclarationDepth)))))) .WithExpression(node.Expression.PrependToLeadingTrivia(Whitespace(new string(' ', 18 - node.NameColon.Name.Identifier.ValueText.Length))))); } return(node); }
public override SyntaxNode VisitArgument(ArgumentSyntax node) { if (_arguments == null || _arguments.Contains(node)) { return(node .WithNameColon(null) .WithTriviaFrom(node)); } return(base.VisitArgument(node)); }
private ArgumentSyntax ArgumentWithNameColon(ArgumentSyntax argument, int argumentIndex) { if (argumentIndex >= _argumentIndex) { var parameterName = _methodSymbol.Parameters[argumentIndex].Name; return(argument.WithNameColon(parameterName)); } else { return(argument); } }
public override SyntaxNode VisitArgument(ArgumentSyntax node) { ExpressionSyntax newExpression = node.Expression.PrependToLeadingTrivia(Whitespace(new string(' ', 18 - node.NameColon?.Name.Identifier.ValueText.Length ?? 0))); if (node.NameColon != null) { node = node.WithNameColon(node.NameColon.AppendToLeadingTrivia(TriviaList(NewLine(), Whitespace(" ")))); } else { newExpression = newExpression.AppendToLeadingTrivia(TriviaList(NewLine(), Whitespace(" "))); } return(node.WithExpression(newExpression)); }
private static async Task <Document> RemoveParameterNameAsync( Document document, ArgumentSyntax argument, CancellationToken cancellationToken) { SyntaxNode oldRoot = await document.GetSyntaxRootAsync(cancellationToken); ArgumentSyntax newArgument = argument .WithNameColon(null) .WithTriviaFrom(argument) .WithAdditionalAnnotations(Formatter.Annotation); SyntaxNode newRoot = oldRoot.ReplaceNode(argument, newArgument); return(document.WithSyntaxRoot(newRoot)); }
private static async Task <Document> AddParameterNameAsync( Document document, ArgumentSyntax argument, IParameterSymbol parameterSymbol, CancellationToken cancellationToken) { SyntaxNode oldRoot = await document.GetSyntaxRootAsync(cancellationToken); ArgumentSyntax newNode = argument .WithNameColon(NameColon(parameterSymbol.ToDisplayString(_symbolDisplayFormat))) .WithTriviaFrom(argument) .WithAdditionalAnnotations(Formatter.Annotation); SyntaxNode newRoot = oldRoot.ReplaceNode(argument, newNode); return(document.WithSyntaxRoot(newRoot)); }
private static ArgumentSyntax SimplifyTupleName(ArgumentSyntax node, SemanticModel semanticModel, OptionSet optionSet, CancellationToken cancellationToken) { // Tuple elements are arguments in a tuple expression if (node.NameColon == null || !node.IsParentKind(SyntaxKind.TupleExpression)) { return(node); } var inferredName = node.Expression.TryGetInferredMemberName(); if (inferredName == null || inferredName != node.NameColon.Name.Identifier.ValueText) { return(node); } return(node.WithNameColon(null).WithTriviaFrom(node)); }
static InvocationExpressionSyntax AddArgument(InvocationExpressionSyntax invocationExpression, IParameterSymbol parameterToAdd, bool isNextInSequence) { ExpressionSyntax defaultValue; if (parameterToAdd.HasExplicitDefaultValue) { defaultValue = ComputeConstantValueCodeRefactoringProvider.GetLiteralExpression(parameterToAdd.ExplicitDefaultValue); } else { return(invocationExpression); } ArgumentSyntax newArgument = SyntaxFactory.Argument(defaultValue); if (invocationExpression.ArgumentList.Arguments.Any(argument => argument.NameColon != null) || !isNextInSequence) { newArgument = newArgument.WithNameColon(SyntaxFactory.NameColon(parameterToAdd.Name)); } var newArguments = invocationExpression.ArgumentList.AddArguments(newArgument); return(invocationExpression.WithArgumentList(newArguments)); }
private static ArgumentSyntax AddParameterName( ArgumentSyntax argument, SemanticModel semanticModel, CancellationToken cancellationToken = default) { if (argument.NameColon?.IsMissing != false) { IParameterSymbol parameterSymbol = semanticModel.DetermineParameter( argument, allowParams: false, cancellationToken: cancellationToken); if (parameterSymbol != null) { return(argument .WithNameColon( NameColon(parameterSymbol.ToDisplayString(_symbolDisplayFormat)) .WithTrailingTrivia(Space)) .WithTriviaFrom(argument)); } } return(argument); }
public static ArgumentSyntax AddParameterName( ArgumentSyntax argument, SemanticModel semanticModel, CancellationToken cancellationToken = default(CancellationToken)) { if (argument == null) { throw new ArgumentNullException(nameof(argument)); } if (semanticModel == null) { throw new ArgumentNullException(nameof(semanticModel)); } if (argument.NameColon != null && !argument.NameColon.IsMissing) { return(argument); } IParameterSymbol parameterSymbol = argument.DetermineParameter( semanticModel, allowParams: false, cancellationToken: cancellationToken); if (parameterSymbol == null) { return(argument); } return(argument .WithNameColon( NameColon(parameterSymbol.ToDisplayString(_symbolDisplayFormat)) .WithTrailingTrivia(Space)) .WithTriviaFrom(argument)); }
public static ArgumentSyntax WithNameColon(this ArgumentSyntax argument, string nameColon) { return(argument.WithNameColon(NameColon(nameColon))); }
private ArgumentListSyntax CreateNewArgumentList(ArgumentListSyntax argumentList) { // Create ObjectCreationExpression for ParameterObject // Considers: // foo(a, >b, c,< d) -> foo(a, new ParameterObject(b, c), d) // Split arguments into two lists: one for ObjectCreationExpression and another for InvocationExpression SeparatedSyntaxList <ArgumentSyntax> ctorArguments = Syntax.SeparatedList <ArgumentSyntax>(); SeparatedSyntaxList <ArgumentSyntax> invocationArguments = Syntax.SeparatedList <ArgumentSyntax>(); // Note: Pre-order visiting argument, as it may also contain method call // Considers: // foo(a, b, foo(1, 2, 3, 4), d) -> foo(a, new ParameterObject(b, foo(1, new ParameterObject(2, 3), 4)), d) for (int i = 0; i < argumentList.Arguments.Count; ++i) { ArgumentSyntax argument = argumentList.Arguments[i]; if (IsCompressedArgument(argument, i)) { ArgumentSyntax processedArgument = (ArgumentSyntax)base.VisitArgument(argument); ctorArguments = ctorArguments.Add(processedArgument); } } // TODO: Hard-coded type name! ObjectCreationExpressionSyntax creationExpression = Syntax.ObjectCreationExpression(Syntax.ParseTypeName("ParameterObject")) .WithArgumentList(Syntax.ArgumentList(ctorArguments)); bool isParameterObjectAdded = false; for (int i = 0; i < argumentList.Arguments.Count; ++i) { ArgumentSyntax argument = argumentList.Arguments[i]; if (!IsCompressedArgument(argument, i)) { ArgumentSyntax processedArgument = (ArgumentSyntax)base.VisitArgument(argument); invocationArguments = invocationArguments.Add(processedArgument); } else if (!isParameterObjectAdded) { // The first occurrence of compressed argument should be replaced with invocation expression ArgumentSyntax processedArgument = (ArgumentSyntax)base.VisitArgument(argument); ArgumentSyntax objectCreationArgument = processedArgument.WithExpression(creationExpression) .WithAdditionalAnnotations(CodeAnnotations.Formatting); if (argument.NameColon != null) { objectCreationArgument = objectCreationArgument.WithNameColon(Syntax.NameColon(Syntax.IdentifierName(this.parameterObjectName))); } invocationArguments = invocationArguments.Add(objectCreationArgument); isParameterObjectAdded = true; } } ArgumentListSyntax newArgumentList = Syntax.ArgumentList(invocationArguments); return(newArgumentList); }