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);
}
}
}
private void AnalyzeStatement(SyntaxNodeAnalysisContext context)
{
if (GeneratedCodeAnalyzer?.IsGeneratedCode(context) == true)
{
return;
}
AnalyzeEmbeddedStatement(context);
if (context.Node.IsKind(SyntaxKind.IfStatement) &&
!IfElseAnalysis.IsIsolatedIf((IfStatementSyntax)context.Node))
{
return;
}
StatementSyntax statement = EmbeddedStatementAnalysis.GetEmbeddedStatementThatShouldBeInsideBlock(context.Node);
if (statement != null)
{
context.ReportDiagnostic(
DiagnosticDescriptors.AddBraces,
statement.GetLocation(),
SyntaxHelper.GetNodeTitle(context.Node));
}
}
public static bool CanRefactor(StatementSyntax statement)
{
if (statement == null)
{
throw new ArgumentNullException(nameof(statement));
}
return(EmbeddedStatementAnalysis.IsEmbeddableStatement(statement));
}
private static bool CanRefactor(RefactoringContext context, BlockSyntax block)
{
if (context.Span.IsEmptyOrBetweenSpans(block) &&
EmbeddedStatementAnalysis.IsEmbeddableBlock(block))
{
StatementSyntax statement = EmbeddedStatementAnalysis.GetEmbeddedStatement(block.Statements[0]);
return(statement == null ||
!statement.FullSpan.Contains(context.Span));
}
return(false);
}
private void AnalyzeStatement(SyntaxNodeAnalysisContext context)
{
if (GeneratedCodeAnalyzer?.IsGeneratedCode(context) == true)
{
return;
}
StatementSyntax statement = EmbeddedStatementAnalysis.GetEmbeddedStatement(context.Node);
if (statement != null)
{
context.ReportDiagnostic(DiagnosticDescriptors.AvoidEmbeddedStatement, statement.GetLocation());
}
}
private static bool CanRefactorIfElse(BlockSyntax selectedBlock, IfStatementSyntax topmostIf)
{
bool success = false;
foreach (BlockSyntax block in GetBlocks(topmostIf))
{
if (block == selectedBlock)
{
continue;
}
else if (EmbeddedStatementAnalysis.IsEmbeddableBlock(block))
{
success = true;
}
else
{
return(false);
}
}
return(success);
}
private void AnalyzeSyntaxNode(SyntaxNodeAnalysisContext context)
{
if (GeneratedCodeAnalyzer?.IsGeneratedCode(context) == true)
{
return;
}
if (context.Node.Parent == null)
{
return;
}
if (EmbeddedStatementAnalysis.SupportsEmbeddedStatement(context.Node.Parent))
{
return;
}
Diagnostic diagnostic = Diagnostic.Create(
DiagnosticDescriptors.RemoveEmptyStatement,
context.Node.GetLocation());
context.ReportDiagnostic(diagnostic);
}
public static void ComputeRefactoring(RefactoringContext context, BlockSyntax block)
{
if (context.IsAnyRefactoringEnabled(
RefactoringIdentifiers.RemoveStatement,
RefactoringIdentifiers.DuplicateStatement,
RefactoringIdentifiers.CommentOutStatement))
{
StatementSyntax statement = GetStatement(context, block, block.Parent);
if (statement != null)
{
if (!EmbeddedStatementAnalysis.IsEmbeddedStatement(statement) &&
statement.Parent?.IsKind(SyntaxKind.Block) == true)
{
RegisterRefactoring(context, statement);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.CommentOutStatement))
{
CommentOutRefactoring.RegisterRefactoring(context, statement);
}
}
}
}
public static bool CanRefactor(StatementSyntax statement)
{
return(EmbeddedStatementAnalysis.IsEmbeddedStatement(statement));
}
private static bool CanRefactor(RefactoringContext context, StatementSyntax statement)
{
return(context.Span.IsEmptyOrBetweenSpans(statement) &&
EmbeddedStatementAnalysis.IsEmbeddedStatement(statement));
}
