private static void AnalyzeYieldBreakStatement(SyntaxNodeAnalysisContext context)
{
if (context.Node.SpanContainsDirectives())
{
return;
}
var yieldBreakStatement = (YieldStatementSyntax)context.Node;
if (!RemoveRedundantStatementAnalysis.IsFixable(yieldBreakStatement))
{
return;
}
DiagnosticHelpers.ReportDiagnostic(context, DiagnosticRules.RemoveRedundantStatement, yieldBreakStatement);
}
private static void AnalyzeReturnStatement(SyntaxNodeAnalysisContext context)
{
if (context.Node.SpanContainsDirectives())
{
return;
}
var returnStatement = (ReturnStatementSyntax)context.Node;
if (!RemoveRedundantStatementAnalysis.IsFixable(returnStatement))
{
return;
}
DiagnosticHelpers.ReportDiagnostic(context, DiagnosticDescriptors.RemoveRedundantStatement, returnStatement);
}
private static void AnalyzeContinueStatement(SyntaxNodeAnalysisContext context)
{
if (context.Node.SpanContainsDirectives())
{
return;
}
var continueStatement = (ContinueStatementSyntax)context.Node;
if (!RemoveRedundantStatementAnalysis.IsFixable(continueStatement))
{
return;
}
context.ReportDiagnostic(DiagnosticDescriptors.RemoveRedundantStatement, continueStatement);
}
public static async Task <Document> InvertIfAsync(
Document document,
IfStatementSyntax ifStatement,
bool recursive = false,
CancellationToken cancellationToken = default(CancellationToken))
{
cancellationToken.ThrowIfCancellationRequested();
StatementSyntax statement = ifStatement.Statement;
StatementListInfo statementsInfo = SyntaxInfo.StatementListInfo(ifStatement);
SyntaxList <StatementSyntax> statements = statementsInfo.Statements;
InvertIfAnalysis analysis = InvertIfAnalysis.Create(ifStatement, statement);
int ifStatementIndex = statements.IndexOf(ifStatement);
StatementSyntax lastStatement = analysis.LastStatement;
int lastStatementIndex = statements.IndexOf(lastStatement);
bool isLastStatementRedundant = IsLastStatementRedundant();
bool shouldUseElseClause = !CSharpFacts.IsJumpStatement(lastStatement.Kind());
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
SyntaxList <StatementSyntax> newStatements = statements;
if (!recursive)
{
Refactor();
}
else
{
IfStatementSyntax lastIfStatement;
InvertIfAnalysis a = analysis.AnalyzeNextStatement();
do
{
lastIfStatement = a.IfStatement;
a = a.AnalyzeNextStatement();
} while (a.Success);
int firstLastStatementIndex = lastStatementIndex;
int index = statements.IndexOf(lastIfStatement);
int firstIndex = ifStatementIndex;
while (index >= firstIndex)
{
ifStatementIndex = index;
ifStatement = (IfStatementSyntax)statements[ifStatementIndex];
statement = ifStatement.Statement;
Refactor();
lastStatementIndex = firstLastStatementIndex + newStatements.Count - statements.Count;
lastStatement = (statement is BlockSyntax block) ? block.Statements.Last() : statement;
index--;
}
}
return(await document.ReplaceStatementsAsync(statementsInfo, newStatements, cancellationToken).ConfigureAwait(false));
void Refactor()
{
cancellationToken.ThrowIfCancellationRequested();
SyntaxList <StatementSyntax> nextStatements = newStatements
.Skip(ifStatementIndex + 1)
.Take(lastStatementIndex - ifStatementIndex)
.ToSyntaxList()
.TrimTrivia();
BlockSyntax newStatement;
SyntaxList <StatementSyntax> newNextStatements;
if (statement is BlockSyntax block)
{
newStatement = block.WithStatements(nextStatements);
newNextStatements = block.Statements;
}
else
{
newStatement = Block(nextStatements);
newNextStatements = SingletonList(statement);
}
if (isLastStatementRedundant)
{
newNextStatements = newNextStatements.RemoveAt(newNextStatements.Count - 1);
}
ElseClauseSyntax elseClause = null;
if (newNextStatements.Any() &&
shouldUseElseClause)
{
elseClause = ElseClause(Block(newNextStatements));
newNextStatements = default;
}
IfStatementSyntax newIfStatement = ifStatement.Update(
ifKeyword: ifStatement.IfKeyword,
openParenToken: ifStatement.OpenParenToken,
condition: SyntaxInverter.LogicallyInvert(ifStatement.Condition, semanticModel, cancellationToken),
closeParenToken: ifStatement.CloseParenToken,
statement: newStatement,
@else: elseClause);
newIfStatement = newIfStatement.WithFormatterAnnotation();
SyntaxList <StatementSyntax> newNodes = newNextStatements.Insert(0, newIfStatement);
newStatements = newStatements.ReplaceRange(ifStatementIndex, lastStatementIndex - ifStatementIndex + 1, newNodes);
}
bool IsLastStatementRedundant()
{
StatementSyntax jumpStatement = analysis.JumpStatement;
switch (jumpStatement.Kind())
{
case SyntaxKind.ReturnStatement:
{
if (((ReturnStatementSyntax)jumpStatement).Expression == null &&
RemoveRedundantStatementAnalysis.IsFixable(lastStatement, SyntaxKind.ReturnStatement))
{
return(true);
}
break;
}
case SyntaxKind.ContinueStatement:
{
if (RemoveRedundantStatementAnalysis.IsFixable(lastStatement, SyntaxKind.ContinueStatement))
{
return(true);
}
break;
}
}
return(false);
}
}