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