protected BinaryExpressionSyntax CreateCoalesceExpression(SemanticModel semanticModel, CancellationToken cancellationToken)
{
int position = IfStatement.SpanStart;
return(RefactoringHelper.CreateCoalesceExpression(
GetTargetType(position, semanticModel, cancellationToken),
Left.WithoutTrivia(),
Right.WithoutTrivia(),
position,
semanticModel));
}
public override async Task <Document> RefactorAsync(Document document, CancellationToken cancellationToken = default(CancellationToken))
{
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
BinaryExpressionSyntax coalesceExpression = RefactoringHelper.CreateCoalesceExpression(
semanticModel.GetTypeSymbol(Left, cancellationToken),
Right1.WithoutTrivia(),
Right2.WithoutTrivia(),
IfStatement.SpanStart,
semanticModel);
ExpressionStatementSyntax newNode = SimpleAssignmentStatement(Left.WithoutTrivia(), coalesceExpression)
.WithTriviaFrom(IfStatement)
.WithFormatterAnnotation();
return(await document.ReplaceNodeAsync(IfStatement, newNode, cancellationToken).ConfigureAwait(false));
}
public override async Task <Document> RefactorAsync(Document document, CancellationToken cancellationToken = default(CancellationToken))
{
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
int position = IfStatement.SpanStart;
ITypeSymbol targetType = GetTargetType(position, semanticModel, cancellationToken);
BinaryExpressionSyntax coalesceExpression = RefactoringHelper.CreateCoalesceExpression(
targetType,
Left.WithoutTrivia(),
Right.WithoutTrivia(),
position,
semanticModel);
StatementSyntax statement = CreateStatement(coalesceExpression);
if (IfStatement.IsSimpleIf())
{
StatementsInfo statementsInfo = SyntaxInfo.StatementsInfo(IfStatement);
SyntaxList <StatementSyntax> statements = statementsInfo.Statements;
int index = statements.IndexOf(IfStatement);
StatementSyntax newNode = statement
.WithLeadingTrivia(IfStatement.GetLeadingTrivia())
.WithTrailingTrivia(statements[index + 1].GetTrailingTrivia())
.WithFormatterAnnotation();
SyntaxList <StatementSyntax> newStatements = statements
.RemoveAt(index)
.ReplaceAt(index, newNode);
return(await document.ReplaceStatementsAsync(statementsInfo, newStatements, cancellationToken).ConfigureAwait(false));
}
else
{
StatementSyntax newNode = statement
.WithTriviaFrom(IfStatement)
.WithFormatterAnnotation();
return(await document.ReplaceNodeAsync(IfStatement, newNode, cancellationToken).ConfigureAwait(false));
}
}
private static Task <Document> RefactorAsync(
Document document,
StatementSyntax statement,
IfStatementSyntax ifStatement,
int statementIndex,
StatementContainer container,
ExpressionSyntax expression,
SemanticModel semanticModel,
CancellationToken cancellationToken)
{
var expressionStatement = (ExpressionStatementSyntax)ifStatement.GetSingleStatementOrDefault();
var assignment = (AssignmentExpressionSyntax)expressionStatement.Expression;
BinaryExpressionSyntax newNode = RefactoringHelper.CreateCoalesceExpression(
semanticModel.GetTypeSymbol(assignment.Left, cancellationToken),
expression.WithoutTrailingTrivia(),
assignment.Right.WithTrailingTrivia(expression.GetTrailingTrivia()),
statement.SpanStart,
semanticModel);
StatementSyntax newStatement = statement.ReplaceNode(expression, newNode);
IEnumerable <SyntaxTrivia> trivia = container.Node.DescendantTrivia(TextSpan.FromBounds(statement.Span.End, ifStatement.Span.End));
if (!trivia.All(f => f.IsWhitespaceOrEndOfLineTrivia()))
{
newStatement = newStatement.WithTrailingTrivia(trivia);
newStatement = newStatement.AppendToTrailingTrivia(ifStatement.GetTrailingTrivia());
}
else
{
newStatement = newStatement.WithTrailingTrivia(ifStatement.GetTrailingTrivia());
}
SyntaxList <StatementSyntax> newStatements = container.Statements
.Remove(ifStatement)
.ReplaceAt(statementIndex, newStatement);
return(document.ReplaceNodeAsync(container.Node, container.NodeWithStatements(newStatements), cancellationToken));
}
public static async Task <Document> RefactorAsync(
Document document,
StatementSyntax statement,
CancellationToken cancellationToken)
{
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
StatementContainer container = StatementContainer.Create(statement);
SyntaxList <StatementSyntax> statements = container.Statements;
int index = statements.IndexOf(statement);
switch (statement.Kind())
{
case SyntaxKind.IfStatement:
{
var ifStatement = (IfStatementSyntax)statement;
var expressionStatement = (ExpressionStatementSyntax)ifStatement.GetSingleStatementOrDefault();
var assignment = (AssignmentExpressionSyntax)expressionStatement.Expression;
ExpressionSyntax left = assignment.Left;
ExpressionSyntax right = assignment.Right;
BinaryExpressionSyntax coalesceExpression = RefactoringHelper.CreateCoalesceExpression(
semanticModel.GetTypeSymbol(left, cancellationToken),
left.WithoutLeadingTrivia().WithTrailingTrivia(Space),
right.WithLeadingTrivia(Space),
ifStatement.SpanStart,
semanticModel);
AssignmentExpressionSyntax newAssignment = assignment.WithRight(coalesceExpression.WithTriviaFrom(right));
ExpressionStatementSyntax newNode = expressionStatement.WithExpression(newAssignment);
IEnumerable <SyntaxTrivia> trivia = ifStatement.DescendantTrivia(TextSpan.FromBounds(ifStatement.SpanStart, expressionStatement.SpanStart));
if (trivia.All(f => f.IsWhitespaceOrEndOfLineTrivia()))
{
newNode = newNode.WithLeadingTrivia(ifStatement.GetLeadingTrivia());
}
else
{
newNode = newNode
.WithLeadingTrivia(ifStatement.GetLeadingTrivia().Concat(trivia))
.WithFormatterAnnotation();
}
return(await document.ReplaceNodeAsync(ifStatement, newNode, cancellationToken).ConfigureAwait(false));
}
case SyntaxKind.ExpressionStatement:
{
var expressionStatement = (ExpressionStatementSyntax)statement;
var assignment = (AssignmentExpressionSyntax)expressionStatement.Expression;
return(await RefactorAsync(document, expressionStatement, (IfStatementSyntax)statements[index + 1], index, container, assignment.Right, semanticModel, cancellationToken).ConfigureAwait(false));
}
case SyntaxKind.LocalDeclarationStatement:
{
var localDeclaration = (LocalDeclarationStatementSyntax)statement;
ExpressionSyntax value = localDeclaration
.Declaration
.Variables
.First()
.Initializer
.Value;
return(await RefactorAsync(document, localDeclaration, (IfStatementSyntax)statements[index + 1], index, container, value, semanticModel, cancellationToken).ConfigureAwait(false));
}
default:
{
Debug.Fail(statement.Kind().ToString());
return(document);
}
}
}