private static void Analyze(SyntaxNodeAnalysisContext context, SyntaxList <StatementSyntax> statements)
        {
            if (statements.Count <= 1)
            {
                return;
            }

            int previousEndLine = statements[0].GetSpanEndLine();

            for (int i = 1; i < statements.Count; i++)
            {
                StatementSyntax statement = statements[i];

                if (!statement.IsKind(SyntaxKind.Block, SyntaxKind.EmptyStatement) &&
                    statement.GetSpanStartLine() == previousEndLine)
                {
                    DiagnosticHelpers.ReportDiagnostic(
                        context,
                        DiagnosticDescriptors.AddNewLineBeforeStatement,
                        Location.Create(statement.SyntaxTree, statement.Span.WithLength(0)));
                }

                previousEndLine = statement.GetSpanEndLine();
            }
        }
Exemple #2
0
        private static void AnalyzeEmbeddedStatement(SyntaxNodeAnalysisContext context)
        {
            SyntaxToken token = GetToken(context.Node);

            if (token.IsMissing)
            {
                return;
            }

            StatementSyntax statement = GetStatement(context.Node);

            if (statement.IsKind(SyntaxKind.Block))
            {
                return;
            }

            if (statement.IsKind(SyntaxKind.EmptyStatement))
            {
                return;
            }

            if (token.GetSpanStartLine() == statement.GetSpanStartLine())
            {
                context.ReportDiagnostic(
                    DiagnosticDescriptors.FormatEmbeddedStatementOnSeparateLine,
                    statement.GetLocation());
            }
            else
            {
                var parentStatement = (StatementSyntax)context.Node;

                var block = parentStatement.Parent as BlockSyntax;
                if (block == null)
                {
                    return;
                }

                int index = block.Statements.IndexOf(parentStatement);

                if (index == block.Statements.Count - 1)
                {
                    return;
                }

                int diff = block.Statements[index + 1].GetSpanStartLine() - statement.GetSpanEndLine();

                if (diff < 2)
                {
                    context.ReportDiagnostic(
                        DiagnosticDescriptors.AddEmptyLineAfterEmbeddedStatement,
                        statement.GetLocation());
                }
            }
        }
Exemple #3
0
        public static void Analyze(SyntaxNodeAnalysisContext context, DoStatementSyntax doStatement)
        {
            StatementSyntax statement = doStatement.Statement;

            if (statement?.IsKind(SyntaxKind.Block) == true)
            {
                var block = (BlockSyntax)statement;

                SyntaxList <StatementSyntax> statements = block.Statements;

                if (statements.Any())
                {
                    SyntaxToken closeBrace = block.CloseBraceToken;

                    if (!closeBrace.IsMissing)
                    {
                        SyntaxToken whileKeyword = doStatement.WhileKeyword;

                        if (!whileKeyword.IsMissing)
                        {
                            int closeBraceLine = closeBrace.GetSpanEndLine();

                            if (closeBraceLine == whileKeyword.GetSpanStartLine())
                            {
                                StatementSyntax last = statements.Last();

                                int line = last.GetSpanEndLine(context.CancellationToken);

                                if (closeBraceLine - line == 1)
                                {
                                    SyntaxTrivia trivia = last
                                                          .GetTrailingTrivia()
                                                          .FirstOrDefault(f => f.IsEndOfLineTrivia());

                                    if (trivia.IsKind(SyntaxKind.EndOfLineTrivia))
                                    {
                                        context.ReportDiagnostic(
                                            DiagnosticDescriptors.AddEmptyLineAfterLastStatementInDoStatement,
                                            Location.Create(doStatement.SyntaxTree, trivia.Span));
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
Exemple #4
0
        private static void Analyze(SyntaxNodeAnalysisContext context, SyntaxList <StatementSyntax> statements)
        {
            if (statements.Count > 1)
            {
                int previousEndLine = statements[0].GetSpanEndLine();

                for (int i = 1; i < statements.Count; i++)
                {
                    StatementSyntax statement = statements[i];

                    if (!statement.IsKind(SyntaxKind.Block, SyntaxKind.EmptyStatement) &&
                        statement.GetSpanStartLine() == previousEndLine)
                    {
                        context.ReportDiagnostic(DiagnosticDescriptors.FormatEachStatementOnSeparateLine, statement);
                    }

                    previousEndLine = statement.GetSpanEndLine();
                }
            }
        }
        private static void AnalyzeDoStatement(SyntaxNodeAnalysisContext context)
        {
            var doStatement = (DoStatementSyntax)context.Node;

            StatementSyntax statement = doStatement.Statement;

            if (statement?.Kind() != SyntaxKind.Block)
            {
                return;
            }

            var block = (BlockSyntax)statement;

            StatementSyntax lastStatement = block.Statements.LastOrDefault();

            if (lastStatement == null)
            {
                return;
            }

            SyntaxToken closeBrace = block.CloseBraceToken;

            if (closeBrace.IsMissing)
            {
                return;
            }

            SyntaxToken whileKeyword = doStatement.WhileKeyword;

            if (whileKeyword.IsMissing)
            {
                return;
            }

            int closeBraceLine = closeBrace.GetSpanEndLine();

            if (closeBraceLine != whileKeyword.GetSpanStartLine())
            {
                return;
            }

            int line = lastStatement.GetSpanEndLine(context.CancellationToken);

            if (closeBraceLine - line != 1)
            {
                return;
            }

            SyntaxTrivia trivia = lastStatement
                                  .GetTrailingTrivia()
                                  .FirstOrDefault(f => f.IsEndOfLineTrivia());

            if (!trivia.IsEndOfLineTrivia())
            {
                return;
            }

            DiagnosticHelpers.ReportDiagnostic(context,
                                               DiagnosticDescriptors.AddEmptyLineBeforeWhileInDoStatement,
                                               Location.Create(doStatement.SyntaxTree, trivia.Span));
        }