private void Analyze(SyntaxNodeAnalysisContext context)
{
BlockSyntax blockSyntax = (BlockSyntax)context.Node;
if (blockSyntax.Statements == null || blockSyntax.Statements.Any())
{
return;
}
// Empty constructors are acceptable
if (blockSyntax.Parent is ConstructorDeclarationSyntax)
{
return;
}
// Empty public or protected methods are acceptable, as it could be part of an API, or an interface implementation
if (blockSyntax.Parent is MethodDeclarationSyntax methodSynxtax)
{
if (methodSynxtax.Modifiers.Any(SyntaxKind.PublicKeyword) || methodSynxtax.Modifiers.Any(SyntaxKind.ProtectedKeyword))
{
return;
}
}
// Empty catch blocks are a different type of code smell.
if (blockSyntax.Parent is CatchClauseSyntax)
{
Diagnostic emptyCatchDiagnostic = Diagnostic.Create(CatchRule, blockSyntax.GetLocation());
context.ReportDiagnostic(emptyCatchDiagnostic);
return;
}
// ParanthesizedLambdaExpressions are acceptable () => { }, until a pre-canned static "EmptyAction" is defined.
if (blockSyntax.Parent is ParenthesizedLambdaExpressionSyntax || blockSyntax.Parent is SimpleLambdaExpressionSyntax)
{
return;
}
// Empty lock blocks are acceptable. lock (x) {}
if (blockSyntax.Parent is LockStatementSyntax)
{
return;
}
Diagnostic diagnostic = Diagnostic.Create(StatementRule, blockSyntax.GetLocation());
context.ReportDiagnostic(diagnostic);
}
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 static void ReportDiagnostic(SyntaxNodeAnalysisContext context, BlockSyntax block, ExpressionSyntax expression)
{
context.ReportDiagnostic(
DiagnosticDescriptors.UseExpressionBodiedMember,
block.GetLocation());
SyntaxNode parent = expression.Parent;
if (parent.IsKind(SyntaxKind.ReturnStatement))
{
context.FadeOutToken(FadeOutDescriptor, ((ReturnStatementSyntax)parent).ReturnKeyword);
}
context.FadeOutBraces(FadeOutDescriptor, 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 == 0)
{
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.IsWhitespaceOrEndOfLine()))
{
return(false);
}
if (!returnStatement.IsSingleline())
{
return(false);
}
context.ReportDiagnostic(
DiagnosticDescriptors.UseExpressionBodiedMember,
block.GetLocation());
DiagnosticHelper.FadeOutToken(context, returnStatement.ReturnKeyword, DiagnosticDescriptors.UseExpressionBodiedMemberFadeOut);
DiagnosticHelper.FadeOutBraces(context, block, DiagnosticDescriptors.UseExpressionBodiedMemberFadeOut);
return(true);
}
public static void Analyze(SyntaxNodeAnalysisContext context, BlockSyntax block)
{
SyntaxList <StatementSyntax> statements = block.Statements;
if (!statements.Any() &&
!(block.Parent is AccessorDeclarationSyntax))
{
int startLine = block.OpenBraceToken.GetSpanStartLine();
int endLine = block.CloseBraceToken.GetSpanEndLine();
if ((endLine - startLine) != 1 &&
block
.DescendantTrivia(block.Span)
.All(f => f.IsWhitespaceOrEndOfLineTrivia()))
{
context.ReportDiagnostic(DiagnosticDescriptors.FormatEmptyBlock, block.GetLocation());
}
}
}
public override void VisitBlock(BlockSyntax node)
{
AddEntry("", node.GetLocation());
base.VisitBlock(node);
}
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);
}
}
