private static void AnalyzeBraces(SyntaxNodeAnalysisContext context, IfStatementSyntax ifStatement)
{
if (!ifStatement.IsParentKind(SyntaxKind.ElseClause) &&
ifStatement.Else != null)
{
BracesAnalysisResult result = CSharpAnalysis.AnalyzeBraces(ifStatement);
if ((result & BracesAnalysisResult.AddBraces) != 0)
{
context.ReportDiagnostic(DiagnosticDescriptors.AddBracesToIfElse, ifStatement.GetLocation());
}
if ((result & BracesAnalysisResult.RemoveBraces) != 0)
{
context.ReportDiagnostic(DiagnosticDescriptors.RemoveBracesFromIfElse, ifStatement.GetLocation());
foreach (SyntaxNode node in ifStatement.DescendantNodes())
{
if (node.IsKind(SyntaxKind.Block))
{
context.FadeOutBraces(DiagnosticDescriptors.RemoveBracesFromIfElseFadeOut, (BlockSyntax)node);
}
}
}
}
}
public static void Analyze(SyntaxNodeAnalysisContext context, ElseClauseSyntax elseClause)
{
StatementSyntax statement = elseClause.Statement;
if (statement?.IsKind(SyntaxKind.Block) == true)
{
var block = (BlockSyntax)statement;
SyntaxList <StatementSyntax> statements = block.Statements;
if (statements.Count == 1 &&
statements[0].IsKind(SyntaxKind.IfStatement))
{
var ifStatement = (IfStatementSyntax)statements[0];
if (ifStatement.Else == null &&
CheckTrivia(elseClause, ifStatement))
{
context.ReportDiagnostic(
DiagnosticDescriptors.MergeElseClauseWithNestedIfStatement,
block.GetLocation());
context.FadeOutBraces(
DiagnosticDescriptors.MergeElseClauseWithNestedIfStatementFadeOut,
block);
}
}
}
}
private void AnalyzeStatement(SyntaxNodeAnalysisContext context)
{
if (GeneratedCodeAnalyzer?.IsGeneratedCode(context) == true)
{
return;
}
if (!context.Node.IsKind(SyntaxKind.IfStatement) ||
IfElseAnalysis.IsIsolatedIf((IfStatementSyntax)context.Node))
{
BlockSyntax block = EmbeddedStatementAnalysis.GetBlockThatCanBeEmbeddedStatement(context.Node);
if (block != null &&
!block.OpenBraceToken.IsMissing &&
!block.CloseBraceToken.IsMissing &&
block.OpenBraceToken.LeadingTrivia.All(f => f.IsWhitespaceOrEndOfLineTrivia()) &&
block.OpenBraceToken.TrailingTrivia.All(f => f.IsWhitespaceOrEndOfLineTrivia()) &&
block.CloseBraceToken.LeadingTrivia.All(f => f.IsWhitespaceOrEndOfLineTrivia()) &&
block.CloseBraceToken.TrailingTrivia.All(f => f.IsWhitespaceOrEndOfLineTrivia()))
{
context.ReportDiagnostic(
DiagnosticDescriptors.RemoveBraces,
block.GetLocation(),
SyntaxHelper.GetNodeTitle(context.Node));
context.FadeOutBraces(DiagnosticDescriptors.RemoveBracesFadeOut, block);
}
}
}
public static void Analyze(SyntaxNodeAnalysisContext context)
{
SyntaxNode node = context.Node;
if (!node.IsKind(SyntaxKind.IfStatement) ||
!IfElseChain.IsPartOfChain((IfStatementSyntax)node))
{
BlockSyntax block = GetBlockThatCanBeEmbeddedStatement(node);
if (block != null)
{
SyntaxToken openBrace = block.OpenBraceToken;
SyntaxToken closeBrace = block.CloseBraceToken;
if (!openBrace.IsMissing &&
!closeBrace.IsMissing &&
openBrace.GetLeadingAndTrailingTrivia().All(f => f.IsWhitespaceOrEndOfLineTrivia()) &&
closeBrace.GetLeadingAndTrailingTrivia().All(f => f.IsWhitespaceOrEndOfLineTrivia()))
{
context.ReportDiagnostic(
DiagnosticDescriptors.RemoveBraces,
block.GetLocation(),
GetName(node));
context.FadeOutBraces(DiagnosticDescriptors.RemoveBracesFadeOut, block);
}
}
}
}
private void AnalyzeSyntaxNode(SyntaxNodeAnalysisContext context)
{
if (GeneratedCodeAnalyzer?.IsGeneratedCode(context) == true)
{
return;
}
var elseClause = (ElseClauseSyntax)context.Node;
StatementSyntax statement = elseClause.Statement;
if (statement != null)
{
if (!statement.IsKind(SyntaxKind.Block) &&
!statement.IsKind(SyntaxKind.IfStatement) &&
elseClause.ElseKeyword.GetSpanStartLine() == statement.GetSpanStartLine())
{
context.ReportDiagnostic(
DiagnosticDescriptors.FormatEmbeddedStatementOnSeparateLine,
statement.GetLocation());
}
if (statement.IsKind(SyntaxKind.Block))
{
var block = (BlockSyntax)statement;
if (block.Statements.Count == 0)
{
if (elseClause
.DescendantTrivia(elseClause.Span)
.All(f => f.IsWhitespaceOrEndOfLineTrivia()))
{
context.ReportDiagnostic(
DiagnosticDescriptors.RemoveEmptyElseClause,
elseClause.GetLocation());
}
}
else if (block.Statements.Count == 1)
{
if (block.Statements[0].IsKind(SyntaxKind.IfStatement))
{
var ifStatement = (IfStatementSyntax)block.Statements[0];
if (ifStatement.Else == null &&
CheckTrivia(elseClause, ifStatement))
{
context.ReportDiagnostic(
DiagnosticDescriptors.MergeElseClauseWithNestedIfStatement,
block.GetLocation());
context.FadeOutBraces(
DiagnosticDescriptors.MergeElseClauseWithNestedIfStatementFadeOut,
block);
}
}
}
}
}
}
private static void FadeOut(SyntaxNodeAnalysisContext context, BlockSyntax block)
{
context.FadeOutBraces(DiagnosticDescriptors.SimplifyLambdaExpressionFadeOut, block);
if (block.Statements[0].IsKind(SyntaxKind.ReturnStatement))
{
context.FadeOutToken(DiagnosticDescriptors.SimplifyLambdaExpressionFadeOut, ((ReturnStatementSyntax)block.Statements[0]).ReturnKeyword);
}
}
public static void Analyze(SyntaxNodeAnalysisContext context, BlockSyntax block)
{
if (block.IsParentKind(SyntaxKind.Block) &&
block.Statements.Any())
{
context.ReportDiagnostic(DiagnosticDescriptors.RemoveRedundantBraces, block.GetLocation());
context.FadeOutBraces(DiagnosticDescriptors.RemoveRedundantBracesFadeOut, block);
}
}
private static void RemoveBracesFromIfElseFadeOut(SyntaxNodeAnalysisContext context, IfStatementSyntax ifStatement)
{
foreach (SyntaxNode node in ifStatement.DescendantNodes())
{
if (node.IsKind(SyntaxKind.Block))
{
context.FadeOutBraces(
DiagnosticDescriptors.RemoveBracesFromIfElseFadeOut,
(BlockSyntax)node);
}
}
}
private static void FadeOut(
SyntaxNodeAnalysisContext context,
IfStatementSyntax ifStatement,
IfStatementSyntax nestedIf)
{
context.FadeOutToken(DiagnosticDescriptors.MergeIfStatementWithNestedIfStatementFadeOut, nestedIf.IfKeyword);
context.FadeOutToken(DiagnosticDescriptors.MergeIfStatementWithNestedIfStatementFadeOut, nestedIf.OpenParenToken);
context.FadeOutToken(DiagnosticDescriptors.MergeIfStatementWithNestedIfStatementFadeOut, nestedIf.CloseParenToken);
if (ifStatement.Statement.IsKind(SyntaxKind.Block) &&
nestedIf.Statement.IsKind(SyntaxKind.Block))
{
context.FadeOutBraces(DiagnosticDescriptors.MergeIfStatementWithNestedIfStatementFadeOut, (BlockSyntax)nestedIf.Statement);
}
}
private static void ReportDiagnostic(SyntaxNodeAnalysisContext context, AccessorListSyntax accessorList, ExpressionSyntax expression)
{
context.ReportDiagnostic(
DiagnosticDescriptors.UseExpressionBodiedMember,
accessorList.GetLocation());
SyntaxNode parent = expression.Parent;
if (parent.IsKind(SyntaxKind.ReturnStatement))
{
context.FadeOutToken(FadeOutDescriptor, ((ReturnStatementSyntax)parent).ReturnKeyword);
}
context.FadeOutBraces(FadeOutDescriptor, accessorList);
}
public static void Analyze(SyntaxNodeAnalysisContext context, UsingStatementSyntax usingStatement)
{
if (ContainsEmbeddableUsingStatement(usingStatement) &&
!usingStatement
.Ancestors()
.Any(f => f.IsKind(SyntaxKind.UsingStatement) && ContainsEmbeddableUsingStatement((UsingStatementSyntax)f)))
{
var block = (BlockSyntax)usingStatement.Statement;
context.ReportDiagnostic(
DiagnosticDescriptors.SimplifyNestedUsingStatement,
block.GetLocation());
context.FadeOutBraces(DiagnosticDescriptors.SimplifyNestedUsingStatementFadeOut, block);
}
}
private static bool AnalyzeBlock(SyntaxNodeAnalysisContext context, BlockSyntax block, bool checkTrivia = true)
{
if (block == null)
{
return(false);
}
SyntaxList <StatementSyntax> statements = block.Statements;
if (statements.Count != 1)
{
return(false);
}
var returnStatement = statements[0] as ReturnStatementSyntax;
if (returnStatement == null)
{
return(false);
}
if (returnStatement.Expression == null)
{
return(false);
}
if (checkTrivia && block
.DescendantTrivia(descendIntoTrivia: true)
.Any(f => !f.IsWhitespaceOrEndOfLineTrivia()))
{
return(false);
}
if (!returnStatement.IsSingleLine())
{
return(false);
}
context.ReportDiagnostic(
DiagnosticDescriptors.UseExpressionBodiedMember,
block.GetLocation());
context.FadeOutToken(DiagnosticDescriptors.UseExpressionBodiedMemberFadeOut, returnStatement.ReturnKeyword);
context.FadeOutBraces(DiagnosticDescriptors.UseExpressionBodiedMemberFadeOut, block);
return(true);
}
private void AnalyzeBlock(SyntaxNodeAnalysisContext context)
{
if (GeneratedCodeAnalyzer?.IsGeneratedCode(context) == true)
{
return;
}
var block = (BlockSyntax)context.Node;
if (block.Statements.Count != 1)
{
return;
}
if (!block.Statements[0].IsKind(SyntaxKind.Block))
{
return;
}
var block2 = (BlockSyntax)block.Statements[0];
if (block.OpenBraceToken.TrailingTrivia.Any(f => !f.IsWhitespaceOrEndOfLineTrivia()))
{
return;
}
if (block.CloseBraceToken.LeadingTrivia.Any(f => !f.IsWhitespaceOrEndOfLineTrivia()))
{
return;
}
if (block2.OpenBraceToken.LeadingTrivia.Any(f => !f.IsWhitespaceOrEndOfLineTrivia()))
{
return;
}
if (block2.CloseBraceToken.TrailingTrivia.Any(f => !f.IsWhitespaceOrEndOfLineTrivia()))
{
return;
}
context.ReportDiagnostic(
DiagnosticDescriptors.RemoveRedundantBraces,
block2.GetLocation());
context.FadeOutBraces(DiagnosticDescriptors.RemoveRedundantBracesFadeOut, block2);
}
private static void AnalyzeAccessorList(SyntaxNodeAnalysisContext context, AccessorListSyntax accessorList)
{
if (accessorList == null)
{
return;
}
SyntaxList <AccessorDeclarationSyntax> accessors = accessorList.Accessors;
if (accessors.Count != 1)
{
return;
}
AccessorDeclarationSyntax accessor = accessors[0];
if (accessor.Body == null)
{
return;
}
if (!accessor.IsKind(SyntaxKind.GetAccessorDeclaration))
{
return;
}
if (accessor.AttributeLists.Count != 0)
{
return;
}
if (accessor.Body
.DescendantTrivia(descendIntoTrivia: true)
.Any(f => !f.IsWhitespaceOrEndOfLineTrivia()))
{
return;
}
if (AnalyzeBlock(context, accessor.Body, checkTrivia: false))
{
context.FadeOutToken(DiagnosticDescriptors.UseExpressionBodiedMemberFadeOut, accessor.Keyword);
context.FadeOutBraces(DiagnosticDescriptors.UseExpressionBodiedMemberFadeOut, accessorList);
}
}
private void AnalyzeSyntaxNode(SyntaxNodeAnalysisContext context)
{
if (GeneratedCodeAnalyzer?.IsGeneratedCode(context) == true)
{
return;
}
var usingStatement = (UsingStatementSyntax)context.Node;
if (RemoveBracesFromUsingStatementRefactoring.CanRefactor(usingStatement))
{
var block = (BlockSyntax)usingStatement.Statement;
context.ReportDiagnostic(
DiagnosticDescriptors.SimplifyNestedUsingStatement,
block.GetLocation());
context.FadeOutBraces(DiagnosticDescriptors.SimplifyNestedUsingStatementFadeOut, block);
}
}
private void AnalyzeAccessorDeclaration(SyntaxNodeAnalysisContext context)
{
var accessor = (AccessorDeclarationSyntax)context.Node;
if (accessor.ExpressionBody == null &&
!accessor.AttributeLists.Any())
{
BlockSyntax body = accessor.Body;
ExpressionSyntax expression = UseExpressionBodiedMemberRefactoring.GetExpression(body);
if (expression != null &&
expression.IsSingleLine())
{
var accessorList = accessor.Parent as AccessorListSyntax;
if (accessorList != null)
{
SyntaxList <AccessorDeclarationSyntax> accessors = accessorList.Accessors;
if (accessors.Count == 1 &&
accessors.First().IsKind(SyntaxKind.GetAccessorDeclaration))
{
if (accessorList.DescendantTrivia().All(f => f.IsWhitespaceOrEndOfLineTrivia()))
{
ReportDiagnostic(context, accessorList, expression);
context.FadeOutToken(FadeOutDescriptor, accessor.Keyword);
context.FadeOutBraces(FadeOutDescriptor, body);
}
return;
}
}
if (accessor.DescendantTrivia().All(f => f.IsWhitespaceOrEndOfLineTrivia()))
{
ReportDiagnostic(context, body, expression);
}
}
}
}
private void AnalyzeLambdaExpression(SyntaxNodeAnalysisContext context)
{
var lambda = (LambdaExpressionSyntax)context.Node;
if (SimplifyLambdaExpressionRefactoring.CanRefactor(lambda))
{
CSharpSyntaxNode body = lambda.Body;
context.ReportDiagnostic(DiagnosticDescriptors.SimplifyLambdaExpression, body.GetLocation());
var block = (BlockSyntax)body;
context.FadeOutBraces(DiagnosticDescriptors.SimplifyLambdaExpressionFadeOut, block);
StatementSyntax statement = block.Statements[0];
if (statement.IsKind(SyntaxKind.ReturnStatement))
{
context.FadeOutToken(DiagnosticDescriptors.SimplifyLambdaExpressionFadeOut, ((ReturnStatementSyntax)statement).ReturnKeyword);
}
}
}
private static void FadeOut(SyntaxNodeAnalysisContext context, AnonymousMethodExpressionSyntax anonymousMethod)
{
DiagnosticDescriptor descriptor = DiagnosticDescriptors.ReplaceAnonymousMethodWithLambdaExpressionFadeOut;
context.FadeOutToken(descriptor, anonymousMethod.DelegateKeyword);
BlockSyntax block = anonymousMethod.Block;
if (block.Statements.Count == 1 && block.IsSingleLine())
{
StatementSyntax statement = block.Statements[0];
if (statement.IsKind(SyntaxKind.ReturnStatement, SyntaxKind.ExpressionStatement))
{
context.FadeOutBraces(descriptor, block);
if (statement.IsKind(SyntaxKind.ReturnStatement))
{
context.FadeOutToken(descriptor, ((ReturnStatementSyntax)statement).ReturnKeyword);
}
}
}
}
