private IEnumerable <SyntaxNode> VerifyElseBlock(ElseBlockSyntax elseBlock, SyntaxNode node)
{
if (!elseBlock.Statements.Any() && NoCommentsBefore(node))
{
yield return(elseBlock.ElseStatement);
}
}
public override SyntaxList <StatementSyntax> VisitIfStatement(CSS.IfStatementSyntax node)
{
IdentifierNameSyntax name;
List <ArgumentSyntax> arguments = new List <ArgumentSyntax>();
StatementSyntax stmt;
if (node.Else == null && TryConvertRaiseEvent(node, out name, arguments))
{
stmt = SyntaxFactory.RaiseEventStatement(name, SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList(arguments)));
return(SyntaxFactory.SingletonList(stmt));
}
var elseIfBlocks = new List <ElseIfBlockSyntax>();
ElseBlockSyntax elseBlock = null;
CollectElseBlocks(node, elseIfBlocks, ref elseBlock);
if (node.Statement is CSS.BlockSyntax)
{
stmt = SyntaxFactory.MultiLineIfBlock(
SyntaxFactory.IfStatement((ExpressionSyntax)node.Condition.Accept(_nodesVisitor)).WithThenKeyword(SyntaxFactory.Token(SyntaxKind.ThenKeyword)),
ConvertBlock(node.Statement),
SyntaxFactory.List(elseIfBlocks),
elseBlock
);
}
else
{
if (elseIfBlocks.Any() || elseBlock != null || !IsSimpleStatement(node.Statement))
{
stmt = SyntaxFactory.MultiLineIfBlock(
SyntaxFactory.IfStatement((ExpressionSyntax)node.Condition.Accept(_nodesVisitor)).WithThenKeyword(SyntaxFactory.Token(SyntaxKind.ThenKeyword)),
ConvertBlock(node.Statement),
SyntaxFactory.List(elseIfBlocks),
elseBlock
);
}
else
{
stmt = SyntaxFactory.SingleLineIfStatement(
(ExpressionSyntax)node.Condition.Accept(_nodesVisitor),
ConvertBlock(node.Statement),
null
).WithThenKeyword(SyntaxFactory.Token(SyntaxKind.ThenKeyword));
}
}
return(SyntaxFactory.SingletonList(stmt));
}
public override SyntaxList <StatementSyntax> VisitIfStatement(CSS.IfStatementSyntax node)
{
StatementSyntax stmt;
var elseIfBlocks = new List <ElseIfBlockSyntax>();
ElseBlockSyntax elseBlock = null;
CollectElseBlocks(node, elseIfBlocks, ref elseBlock);
if (node.Statement is CSS.BlockSyntax)
{
var b = (CSS.BlockSyntax)node.Statement;
stmt = SyntaxFactory.MultiLineIfBlock(
SyntaxFactory.IfStatement((ExpressionSyntax)node.Condition.Accept(nodesVisitor)).WithThenKeyword(SyntaxFactory.Token(SyntaxKind.ThenKeyword)),
SyntaxFactory.List(b.Statements.SelectMany(s => s.Accept(this))),
SyntaxFactory.List(elseIfBlocks),
elseBlock
);
}
else
{
if (elseIfBlocks.Any())
{
stmt = SyntaxFactory.MultiLineIfBlock(
SyntaxFactory.IfStatement((ExpressionSyntax)node.Condition.Accept(nodesVisitor)).WithThenKeyword(SyntaxFactory.Token(SyntaxKind.ThenKeyword)),
node.Statement.Accept(this),
SyntaxFactory.List(elseIfBlocks),
elseBlock
);
}
else
{
stmt = SyntaxFactory.SingleLineIfStatement(
(ExpressionSyntax)node.Condition.Accept(nodesVisitor),
node.Statement.Accept(this),
SyntaxFactory.SingleLineElseClause(elseBlock.Statements)
).WithThenKeyword(SyntaxFactory.Token(SyntaxKind.ThenKeyword));
}
}
return(SyntaxFactory.SingletonList <StatementSyntax>(stmt));
}
void CollectElseBlocks(CSS.IfStatementSyntax node, List <ElseIfBlockSyntax> elseIfBlocks, ref ElseBlockSyntax elseBlock)
{
if (node.Else == null)
{
return;
}
if (node.Else.Statement is CSS.IfStatementSyntax)
{
var elseIf = (CSS.IfStatementSyntax)node.Else.Statement;
elseIfBlocks.Add(
SyntaxFactory.ElseIfBlock(
SyntaxFactory.ElseIfStatement((ExpressionSyntax)elseIf.Condition.Accept(_nodesVisitor)).WithThenKeyword(SyntaxFactory.Token(SyntaxKind.ThenKeyword)),
ConvertBlock(elseIf.Statement)
)
);
CollectElseBlocks(elseIf, elseIfBlocks, ref elseBlock);
}
else
{
SyntaxList <StatementSyntax> statements = ConvertBlock(node.Else.Statement);
elseBlock = SyntaxFactory.ElseBlock(statements);
}
}
public override void VisitElseBlock(ElseBlockSyntax node)
{
LogicalLineCount++;
base.VisitElseBlock(node);
}
void CollectElseBlocks(CSS.IfStatementSyntax node, List <ElseIfBlockSyntax> elseIfBlocks, ref ElseBlockSyntax elseBlock)
{
if (node.Else == null)
{
return;
}
if (node.Else.Statement is CSS.IfStatementSyntax)
{
var elseIf = (CSS.IfStatementSyntax)node.Else.Statement;
if (elseIf.Statement is CSS.BlockSyntax)
{
var block = (CSS.BlockSyntax)elseIf.Statement;
elseIfBlocks.Add(
SyntaxFactory.ElseIfBlock(
SyntaxFactory.ElseIfStatement((ExpressionSyntax)elseIf.Condition.Accept(nodesVisitor)).WithThenKeyword(SyntaxFactory.Token(SyntaxKind.ThenKeyword)),
SyntaxFactory.List(block.Statements.SelectMany(s => s.Accept(this)))
)
);
}
else
{
elseIfBlocks.Add(
SyntaxFactory.ElseIfBlock(
SyntaxFactory.ElseIfStatement((ExpressionSyntax)elseIf.Condition.Accept(nodesVisitor)).WithThenKeyword(SyntaxFactory.Token(SyntaxKind.ThenKeyword)),
elseIf.Statement.Accept(this)
)
);
}
CollectElseBlocks(elseIf, elseIfBlocks, ref elseBlock);
}
else if (node.Else.Statement is CSS.BlockSyntax)
{
var block = (CSS.BlockSyntax)node.Else.Statement;
elseBlock = SyntaxFactory.ElseBlock(SyntaxFactory.List(block.Statements.SelectMany(s => s.Accept(this))));
}
else
{
elseBlock = SyntaxFactory.ElseBlock(SyntaxFactory.List(node.Else.Statement.Accept(this)));
}
}
public override async Task ComputeRefactoringsAsync(CodeRefactoringContext context)
{
var document = context.Document;
if (document.Project.Solution.Workspace.Kind == WorkspaceKind.MiscellaneousFiles)
{
return;
}
var span = context.Span;
if (!span.IsEmpty)
{
return;
}
var cancellationToken = context.CancellationToken;
if (cancellationToken.IsCancellationRequested)
{
return;
}
var model = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
if (model.IsFromGeneratedCode(cancellationToken))
{
return;
}
var root = await model.SyntaxTree.GetRootAsync(cancellationToken).ConfigureAwait(false);
var selectStatement = root.FindNode(span) as SelectStatementSyntax;
if (selectStatement == null)
{
return;
}
var node = selectStatement.Parent as SelectBlockSyntax;
if (node == null || node.CaseBlocks.Count == 0)
{
return;
}
if (node.CaseBlocks.Count == 1 && node.CaseBlocks[0].CaseStatement.Cases.OfType <ElseCaseClauseSyntax>().Any())
{
return;
}
foreach (var block in node.CaseBlocks)
{
var lastStatement = block.Statements.LastOrDefault() as ExitStatementSyntax;
if (HasNonTrailingExitSelects(block, lastStatement != null && lastStatement.BlockKeyword.IsKind(SyntaxKind.SelectKeyword) ? lastStatement : null))
{
return;
}
}
context.RegisterRefactoring(
CodeActionFactory.Create(
span,
DiagnosticSeverity.Info,
GettextCatalog.GetString("To 'if'"),
t2 =>
{
MultiLineIfBlockSyntax ifBlock = null;
List <ElseIfBlockSyntax> elseIfs = new List <ElseIfBlockSyntax>();
ElseBlockSyntax defaultElse = null;
foreach (var block in node.CaseBlocks)
{
var condition = CollectCondition(node.SelectStatement.Expression, block.CaseStatement.Cases.ToArray());
var statements = block.Statements;
var lastStatement = block.Statements.LastOrDefault() as ExitStatementSyntax;
if (lastStatement != null && lastStatement.BlockKeyword.IsKind(SyntaxKind.SelectKeyword))
{
statements = SyntaxFactory.List(statements.Take(statements.Count - 1));
}
if (condition == null)
{
defaultElse = SyntaxFactory.ElseBlock()
.AddStatements(statements.ToArray())
.WithLeadingTrivia(block.GetLeadingTrivia())
.WithTrailingTrivia(block.GetTrailingTrivia());
break;
}
else if (ifBlock == null)
{
ifBlock = SyntaxFactory.MultiLineIfBlock(SyntaxFactory.IfStatement(condition).WithThenKeyword(SyntaxFactory.Token(SyntaxKind.ThenKeyword)))
.WithStatements(statements);
}
else
{
elseIfs.Add(SyntaxFactory.ElseIfBlock(SyntaxFactory.ElseIfStatement(condition).WithThenKeyword(SyntaxFactory.Token(SyntaxKind.ThenKeyword)), statements));
}
}
ifBlock = ifBlock.WithElseIfBlocks(SyntaxFactory.List(elseIfs));
if (defaultElse != null)
{
ifBlock = ifBlock.WithElseBlock(defaultElse);
}
ifBlock = ifBlock.WithLeadingTrivia(node.GetLeadingTrivia().Concat(ifBlock.GetLeadingTrivia())).WithTrailingTrivia(node.GetTrailingTrivia())
.WithElseBlock(defaultElse).WithAdditionalAnnotations(Formatter.Annotation);
return(Task.FromResult(document.WithSyntaxRoot(root.ReplaceNode(node, ifBlock))));
})
);
}
