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));
}
bool ExtractExpression(StatementSyntax statement, out ExpressionSyntax leftSide, out ExpressionSyntax rightSide)
{
leftSide = null;
rightSide = null;
if (statement == null || statement is EmptyStatementSyntax)
{
return(true);
}
switch (statement.Kind())
{
case SyntaxKind.ExpressionStatement:
var expression = ((ExpressionStatementSyntax)statement).Expression;
switch (expression?.Kind())
{
case SyntaxKind.AddAssignmentExpression:
leftSide = ((AssignmentExpressionSyntax)expression).Left;
rightSide = ((AssignmentExpressionSyntax)expression).Right;
return(true);
case SyntaxKind.SubtractAssignmentExpression:
leftSide = ((AssignmentExpressionSyntax)expression).Left;
rightSide = SyntaxFactory.PrefixUnaryExpression(SyntaxKind.UnaryMinusExpression, ((AssignmentExpressionSyntax)expression).Right);
return(true);
case SyntaxKind.PostDecrementExpression:
case SyntaxKind.PreDecrementExpression:
leftSide = expression.ExtractUnaryOperand();
rightSide = ComputeConstantValueCodeRefactoringProvider.GetLiteralExpression(-1);
return(true);
case SyntaxKind.PostIncrementExpression:
case SyntaxKind.PreIncrementExpression:
leftSide = expression.ExtractUnaryOperand();
rightSide = ComputeConstantValueCodeRefactoringProvider.GetLiteralExpression(1);
return(true);
}
return(false);
case SyntaxKind.Block:
var block = (BlockSyntax)statement;
foreach (StatementSyntax child in block.Statements)
{
ExpressionSyntax newLeft, newRight;
if (!ExtractExpression(child, out newLeft, out newRight))
{
return(false);
}
if (newLeft == null)
{
continue;
}
if (leftSide == null)
{
leftSide = newLeft;
rightSide = newRight;
}
else if (leftSide.IsEquivalentTo(newLeft))
{
rightSide = SyntaxFactory.BinaryExpression(
SyntaxKind.AddExpression,
CSharpUtil.AddParensIfRequired(rightSide),
CSharpUtil.AddParensIfRequired(newRight)
);
}
else
{
return(false);
}
}
return(true);
case SyntaxKind.IfStatement:
var condition = (IfStatementSyntax)statement;
ExpressionSyntax ifLeft, ifRight;
if (!ExtractExpression(condition.Statement, out ifLeft, out ifRight))
{
return(false);
}
ExpressionSyntax elseLeft, elseRight;
if (!ExtractExpression(condition.Else?.Statement, out elseLeft, out elseRight))
{
return(false);
}
if (ifLeft == null && elseLeft == null)
{
return(true);
}
if (ifLeft != null && elseLeft != null && !ifLeft.IsEquivalentTo(elseLeft))
{
return(false);
}
ifRight = ifRight ?? ComputeConstantValueCodeRefactoringProvider.GetLiteralExpression(0);
elseRight = elseRight ?? ComputeConstantValueCodeRefactoringProvider.GetLiteralExpression(0);
leftSide = ifLeft ?? elseLeft;
rightSide = SyntaxFactory.ConditionalExpression(condition.Condition, ifRight, elseRight);
return(true);
}
return(false);
}