public static Task <Document> RefactorAsync(
Document document,
IfStatementSyntax ifStatement,
CancellationToken cancellationToken)
{
var statement = (ExpressionStatementSyntax)ifStatement.SingleNonBlockStatementOrDefault();
SimpleMemberInvocationStatementInfo invocationInfo = SyntaxInfo.SimpleMemberInvocationStatementInfo(statement);
int insertIndex = invocationInfo.Expression.Span.End - statement.FullSpan.Start;
StatementSyntax newStatement = SyntaxFactory.ParseStatement(statement.ToFullString().Insert(insertIndex, "?"));
IEnumerable <SyntaxTrivia> leading = ifStatement.DescendantTrivia(TextSpan.FromBounds(ifStatement.SpanStart, statement.SpanStart));
newStatement = (leading.All(f => f.IsWhitespaceOrEndOfLineTrivia()))
? newStatement.WithLeadingTrivia(ifStatement.GetLeadingTrivia())
: newStatement.WithLeadingTrivia(ifStatement.GetLeadingTrivia().Concat(leading));
IEnumerable <SyntaxTrivia> trailing = ifStatement.DescendantTrivia(TextSpan.FromBounds(statement.Span.End, ifStatement.Span.End));
newStatement = (leading.All(f => f.IsWhitespaceOrEndOfLineTrivia()))
? newStatement.WithTrailingTrivia(ifStatement.GetTrailingTrivia())
: newStatement.WithTrailingTrivia(trailing.Concat(ifStatement.GetTrailingTrivia()));
return(document.ReplaceNodeAsync(ifStatement, newStatement, cancellationToken));
}
private bool CanCleanupIF(IfStatementSyntax originalIfNode)
{
if (originalIfNode.DescendantTrivia(descendIntoTrivia: true).Any(t => t.IsKind(SyntaxKind.EndOfLineTrivia)) == false)
{
return(false);
}
return(true);
}
public static async Task <Document> RefactorAsync(
Document document,
IfStatementSyntax ifStatement,
CancellationToken cancellationToken)
{
var statement = (ExpressionStatementSyntax)ifStatement.SingleNonBlockStatementOrDefault();
StatementSyntax newStatement = statement;
NullCheckExpressionInfo nullCheck = SyntaxInfo.NullCheckExpressionInfo(ifStatement.Condition, NullCheckStyles.NotEqualsToNull);
SimpleMemberInvocationStatementInfo invocationInfo = SyntaxInfo.SimpleMemberInvocationStatementInfo(statement);
ExpressionSyntax expression = invocationInfo.Expression;
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
if (semanticModel.GetTypeSymbol(nullCheck.Expression, cancellationToken).IsNullableType())
{
var memberAccess = (MemberAccessExpressionSyntax)invocationInfo.Expression;
newStatement = statement.ReplaceNode(memberAccess, memberAccess.Expression.WithTrailingTrivia(memberAccess.GetTrailingTrivia()));
expression = memberAccess.Expression;
}
int insertIndex = expression.Span.End - statement.FullSpan.Start;
newStatement = SyntaxFactory.ParseStatement(newStatement.ToFullString().Insert(insertIndex, "?"));
IEnumerable <SyntaxTrivia> leading = ifStatement.DescendantTrivia(TextSpan.FromBounds(ifStatement.SpanStart, statement.SpanStart));
newStatement = (leading.All(f => f.IsWhitespaceOrEndOfLineTrivia()))
? newStatement.WithLeadingTrivia(ifStatement.GetLeadingTrivia())
: newStatement.WithLeadingTrivia(ifStatement.GetLeadingTrivia().Concat(leading));
IEnumerable <SyntaxTrivia> trailing = ifStatement.DescendantTrivia(TextSpan.FromBounds(statement.Span.End, ifStatement.Span.End));
newStatement = (leading.All(f => f.IsWhitespaceOrEndOfLineTrivia()))
? newStatement.WithTrailingTrivia(ifStatement.GetTrailingTrivia())
: newStatement.WithTrailingTrivia(trailing.Concat(ifStatement.GetTrailingTrivia()));
return(await document.ReplaceNodeAsync(ifStatement, newStatement, cancellationToken).ConfigureAwait(false));
}
SyntaxNode Cleanup(IfStatementSyntax originalIfNode)
{
if (originalIfNode.DescendantTrivia(descendIntoTrivia: true).HasNoneWhitespaceTrivia())
{
return(base.VisitIfStatement(originalIfNode));
}
var singleStatementInsideIf = GetInsideStatement(originalIfNode.Statement);
if (singleStatementInsideIf == null || singleStatementInsideIf is IfStatementSyntax)
{
return(base.VisitIfStatement(originalIfNode));
}
var newIf = GetNewIF(originalIfNode, singleStatementInsideIf);
if (newIf == originalIfNode)
{
return(base.VisitIfStatement(originalIfNode));
}
if (newIf.Else == null)
{
return(newIf);
}
var singleStatementInsideElse = GetInsideStatement(newIf.Else.Statement);
if (singleStatementInsideElse == null)
{
return(base.VisitIfStatement(originalIfNode));
}
if (singleStatementInsideElse is IfStatementSyntax ifSingleStatement)
{
singleStatementInsideElse = Cleanup(ifSingleStatement) as IfStatementSyntax;
}
newIf = newIf.WithElse(GetNewIfWithElse(newIf.Else, singleStatementInsideElse));
return(newIf);
}
private static bool CheckTrivia(IfStatementSyntax ifStatement, IfStatementSyntax nestedIf)
{
TextSpan span = TextSpan.FromBounds(
nestedIf.FullSpan.Start,
nestedIf.CloseParenToken.FullSpan.End);
if (nestedIf.DescendantTrivia(span).All(f => f.IsWhitespaceOrEndOfLineTrivia()))
{
if (ifStatement.Statement.IsKind(SyntaxKind.Block) &&
nestedIf.Statement.IsKind(SyntaxKind.Block))
{
var block = (BlockSyntax)nestedIf.Statement;
return(block.OpenBraceToken.GetLeadingAndTrailingTrivia().All(f => f.IsWhitespaceOrEndOfLineTrivia()) &&
block.CloseBraceToken.GetLeadingAndTrailingTrivia().All(f => f.IsWhitespaceOrEndOfLineTrivia()));
}
return(true);
}
return(false);
}
public static Task <Document> InlineLazyInitializationAsync(
Document document,
IfStatementSyntax ifStatement,
CancellationToken cancellationToken = default)
{
StatementListInfo statementsInfo = SyntaxInfo.StatementListInfo(ifStatement);
var assignmentStatement = (ExpressionStatementSyntax)ifStatement.SingleNonBlockStatementOrDefault();
SimpleAssignmentStatementInfo assignmentInfo = SyntaxInfo.SimpleAssignmentStatementInfo(assignmentStatement, walkDownParentheses: false);
ExpressionSyntax right = assignmentInfo.Right;
int index = statementsInfo.IndexOf(ifStatement);
var expressionStatement2 = (ExpressionStatementSyntax)statementsInfo[index + 1];
SimpleMemberInvocationStatementInfo invocationInfo = SyntaxInfo.SimpleMemberInvocationStatementInfo(expressionStatement2);
ExpressionSyntax expression = invocationInfo.Expression;
var newLeading = new List <SyntaxTrivia>(ifStatement.GetLeadingTrivia());
ExpressionSyntax coalesceExpression;
if (document.SupportsLanguageFeature(CSharpLanguageFeature.NullCoalescingAssignmentOperator))
{
AddTrivia(ifStatement.DescendantTrivia(TextSpan.FromBounds(ifStatement.SpanStart, right.SpanStart)).ToSyntaxTriviaList());
coalesceExpression = CoalesceAssignmentExpression(expression.WithoutTrivia(), right.WithoutTrivia());
}
else
{
AddTrivia(ifStatement.DescendantTrivia(TextSpan.FromBounds(ifStatement.SpanStart, assignmentInfo.AssignmentExpression.SpanStart)).ToSyntaxTriviaList());
coalesceExpression = CoalesceExpression(expression.WithoutTrivia(), ParenthesizedExpression(assignmentInfo.AssignmentExpression.WithoutTrivia()));
}
AddTrivia(ifStatement.DescendantTrivia(TextSpan.FromBounds(right.Span.End, ifStatement.Span.End)).ToSyntaxTriviaList());
AddTrivia(ifStatement.GetTrailingTrivia());
AddTrivia(expressionStatement2.GetLeadingTrivia());
ParenthesizedExpressionSyntax newExpression = ParenthesizedExpression(coalesceExpression)
.WithLeadingTrivia(newLeading)
.WithTrailingTrivia(expression.GetTrailingTrivia());
StatementSyntax newExpressionStatement = expressionStatement2.ReplaceNode(expression, newExpression);
StatementListInfo newStatements = statementsInfo
.Replace(expressionStatement2, newExpressionStatement)
.RemoveAt(index);
return(document.ReplaceStatementsAsync(statementsInfo, newStatements, cancellationToken));
void AddTrivia(SyntaxTriviaList trivia)
{
if (!trivia.IsEmptyOrWhitespace())
{
newLeading.AddRange(trivia);
}
}
}