public static Task <Document> RefactorAsync(
Document document,
BlockSyntax block,
CancellationToken cancellationToken)
{
SyntaxList <StatementSyntax> statements = block.Statements;
var ifStatement = (IfStatementSyntax)statements[0];
var returnStatement = (ReturnStatementSyntax)statements[1];
var expressionStatement = (ExpressionStatementSyntax)ifStatement.GetSingleStatementOrDefault();
var assignment = (AssignmentExpressionSyntax)expressionStatement.Expression;
ExpressionSyntax expression = returnStatement.Expression.WithoutTrivia();
BinaryExpressionSyntax coalesceExpression = CSharpFactory.CoalesceExpression(
expression,
CSharpFactory.SimpleAssignmentExpression(expression, assignment.Right.WithoutTrivia()).Parenthesize());
ReturnStatementSyntax newReturnStatement = returnStatement
.WithExpression(coalesceExpression)
.WithLeadingTrivia(ifStatement.GetLeadingTrivia());
SyntaxList <StatementSyntax> newStatements = statements
.Replace(returnStatement, newReturnStatement)
.RemoveAt(0);
BlockSyntax newBlock = block.WithStatements(newStatements);
return(document.ReplaceNodeAsync(block, newBlock, cancellationToken));
}
public static async Task <Document> RefactorAsync(
Document document,
ConditionalExpressionSyntax conditionalExpressionSyntax,
CancellationToken cancellationToken)
{
ConditionalExpressionInfo conditionalExpression;
if (ConditionalExpressionInfo.TryCreate(conditionalExpressionSyntax, out conditionalExpression))
{
SemanticModel semanticModel = await document.GetSemanticModelAsync().ConfigureAwait(false);
NullCheckExpression nullCheck;
if (NullCheckExpression.TryCreate(conditionalExpression.Condition, semanticModel, out nullCheck, cancellationToken))
{
ExpressionSyntax whenNotNull = (nullCheck.IsCheckingNotNull)
? conditionalExpression.WhenTrue
: conditionalExpression.WhenFalse;
ExpressionSyntax whenNull = (nullCheck.IsCheckingNull)
? conditionalExpression.WhenTrue
: conditionalExpression.WhenFalse;
ExpressionSyntax expression = FindExpressionThatCanBeConditionallyAccessed(nullCheck.Expression, whenNotNull);
ExpressionSyntax newNode;
if (expression.Parent == whenNotNull &&
whenNotNull.IsKind(SyntaxKind.SimpleMemberAccessExpression) &&
SemanticUtilities.IsPropertyOfNullableOfT(whenNotNull, "Value", semanticModel, cancellationToken))
{
newNode = expression;
}
else
{
newNode = SyntaxFactory.ParseExpression(whenNotNull.ToString().Insert(expression.Span.End - whenNotNull.SpanStart, "?"));
}
if (!semanticModel.GetTypeSymbol(whenNotNull, cancellationToken).IsReferenceType)
{
newNode = CSharpFactory.CoalesceExpression(newNode.Parenthesize(), whenNull.Parenthesize());
}
newNode = newNode
.WithTriviaFrom(conditionalExpressionSyntax)
.Parenthesize();
return(await document.ReplaceNodeAsync(conditionalExpressionSyntax, newNode, cancellationToken).ConfigureAwait(false));
}
}
Debug.Fail(conditionalExpressionSyntax.ToString());
return(document);
}
private static Task <Document> RefactorAsync(
Document document,
StatementSyntax statement,
IfStatementSyntax ifStatement,
int statementIndex,
IStatementContainer container,
ExpressionSyntax expression,
CancellationToken cancellationToken)
{
var expressionStatement = (ExpressionStatementSyntax)ifStatement.GetSingleStatementOrDefault();
var assignment = (AssignmentExpressionSyntax)expressionStatement.Expression;
ExpressionSyntax left = expression
.WithoutTrailingTrivia()
.Parenthesize(moveTrivia: true)
.WithSimplifierAnnotation();
ExpressionSyntax right = assignment.Right
.WithTrailingTrivia(expression.GetTrailingTrivia())
.Parenthesize(moveTrivia: true)
.WithSimplifierAnnotation();
BinaryExpressionSyntax newNode = CSharpFactory.CoalesceExpression(left, right);
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));
}
private static BinaryExpressionSyntax CreateCoalesceExpression(
ExpressionSyntax left,
ExpressionSyntax right,
ITypeSymbol targetType,
int position,
SemanticModel semanticModel)
{
if (targetType?.SupportsExplicitDeclaration() == true)
{
right = CastExpression(
targetType.ToMinimalTypeSyntax(semanticModel, position),
right.Parenthesize()).WithSimplifierAnnotation();
}
return(CSharpFactory.CoalesceExpression(
left.Parenthesize(),
right.Parenthesize()));
}
public static Task <Document> RefactorAsync(
Document document,
IfStatementSyntax ifStatement,
CancellationToken cancellationToken = default)
{
StatementListInfo statementsInfo = SyntaxInfo.StatementListInfo(ifStatement);
SyntaxList <StatementSyntax> statements = statementsInfo.Statements;
int index = statements.IndexOf(ifStatement);
StatementSyntax expressionStatement = (ExpressionStatementSyntax)statements[index + 1];
SimpleMemberInvocationStatementInfo invocationInfo = SyntaxInfo.SimpleMemberInvocationStatementInfo((ExpressionStatementSyntax)expressionStatement);
ExpressionSyntax expression = invocationInfo.Expression;
SimpleAssignmentStatementInfo assignmentInfo = SyntaxInfo.SimpleAssignmentStatementInfo((ExpressionStatementSyntax)ifStatement.SingleNonBlockStatementOrDefault());
BinaryExpressionSyntax coalesceExpression = CSharpFactory.CoalesceExpression(expression.WithoutTrivia(), ParenthesizedExpression(assignmentInfo.AssignmentExpression));
ParenthesizedExpressionSyntax newExpression = ParenthesizedExpression(coalesceExpression)
.WithTriviaFrom(expression);
StatementSyntax newExpressionStatement = expressionStatement.ReplaceNode(expression, newExpression);
IEnumerable <SyntaxTrivia> trivia = statementsInfo.Parent.DescendantTrivia(TextSpan.FromBounds(ifStatement.FullSpan.Start, expressionStatement.FullSpan.Start));
if (trivia.Any(f => !f.IsWhitespaceOrEndOfLineTrivia()))
{
newExpressionStatement = newExpressionStatement.PrependToLeadingTrivia(trivia);
}
SyntaxList <StatementSyntax> newStatements = statements
.Replace(expressionStatement, newExpressionStatement)
.RemoveAt(index);
return(document.ReplaceStatementsAsync(statementsInfo, newStatements, cancellationToken));
}
public static Task <Document> InlineLazyInitializationAsync(
Document document,
IfStatementSyntax ifStatement,
CancellationToken cancellationToken)
{
StatementContainer container = StatementContainer.Create(ifStatement);
SyntaxList <StatementSyntax> statements = container.Statements;
int index = statements.IndexOf(ifStatement);
StatementSyntax expressionStatement = (ExpressionStatementSyntax)statements[index + 1];
MemberInvocationStatement invocation = MemberInvocationStatement.Create((ExpressionStatementSyntax)expressionStatement);
ExpressionSyntax expression = invocation.Expression;
SimpleAssignmentStatement assignment = SimpleAssignmentStatement.Create((ExpressionStatementSyntax)ifStatement.GetSingleStatementOrDefault());
BinaryExpressionSyntax coalesceExpression = CSharpFactory.CoalesceExpression(expression.WithoutTrivia(), ParenthesizedExpression(assignment.AssignmentExpression));
ParenthesizedExpressionSyntax newExpression = ParenthesizedExpression(coalesceExpression)
.WithTriviaFrom(expression);
StatementSyntax newExpressionStatement = expressionStatement.ReplaceNode(expression, newExpression);
IEnumerable <SyntaxTrivia> trivia = container.Node.DescendantTrivia(TextSpan.FromBounds(ifStatement.FullSpan.Start, expressionStatement.FullSpan.Start));
if (trivia.Any(f => !f.IsWhitespaceOrEndOfLineTrivia()))
{
newExpressionStatement = newExpressionStatement.PrependToLeadingTrivia(trivia);
}
SyntaxList <StatementSyntax> newStatements = statements
.Replace(expressionStatement, newExpressionStatement)
.RemoveAt(index);
return(document.ReplaceNodeAsync(container.Node, container.NodeWithStatements(newStatements), cancellationToken));
}
public static Task <Document> RefactorAsync(
Document document,
ConditionalExpressionSyntax conditionalExpression,
CancellationToken cancellationToken)
{
var binaryExpression = (BinaryExpressionSyntax)conditionalExpression.Condition.WalkDownParentheses();
ExpressionSyntax left = (binaryExpression.IsKind(SyntaxKind.EqualsExpression))
? conditionalExpression.WhenFalse
: conditionalExpression.WhenTrue;
ExpressionSyntax right = (binaryExpression.IsKind(SyntaxKind.EqualsExpression))
? conditionalExpression.WhenTrue
: conditionalExpression.WhenFalse;
BinaryExpressionSyntax newNode = CSharpFactory.CoalesceExpression(
left.WithoutTrivia().Parenthesize().WithSimplifierAnnotation(),
right.WithoutTrivia().Parenthesize().WithSimplifierAnnotation());
return(document.ReplaceNodeAsync(
conditionalExpression,
newNode.WithTriviaFrom(conditionalExpression),
cancellationToken));
}
public static async Task <Document> RefactorAsync(
Document document,
StatementSyntax statement,
CancellationToken cancellationToken)
{
IStatementContainer container;
if (StatementContainer.TryCreate(statement, out container))
{
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;
ParenthesizedExpressionSyntax newLeft = left
.WithoutLeadingTrivia()
.WithTrailingTrivia(Space)
.Parenthesize(moveTrivia: true)
.WithSimplifierAnnotation();
ParenthesizedExpressionSyntax newRight = right
.WithLeadingTrivia(Space)
.Parenthesize(moveTrivia: true)
.WithSimplifierAnnotation();
BinaryExpressionSyntax coalesceExpression = CSharpFactory.CoalesceExpression(newLeft, newRight);
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, 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, cancellationToken).ConfigureAwait(false));
}
}
}
Debug.Assert(false, statement.Kind().ToString());
return(document);
}
