Beispiel #1
0
        public static void ComputeRefactoring(RefactoringContext context, MemberDeclarationListSelection selectedMembers)
        {
            if (selectedMembers.Count == 1)
            {
                return;
            }

            int start = selectedMembers.First().Span.End;

            SyntaxTree syntaxTree = selectedMembers.Parent.SyntaxTree;

            for (int i = selectedMembers.FirstIndex + 1; i <= selectedMembers.LastIndex; i++)
            {
                MemberDeclarationSyntax member = selectedMembers.UnderlyingList[i];

                SyntaxTrivia documentationCommentTrivia = member.GetDocumentationCommentTrivia();

                TextSpan span = (documentationCommentTrivia.IsDocumentationCommentTrivia())
                    ? documentationCommentTrivia.Span
                    : member.Span;

                if (syntaxTree.GetLineCount(TextSpan.FromBounds(start, span.Start), context.CancellationToken) != 2)
                {
                    return;
                }

                start = member.Span.End;
            }

            context.RegisterRefactoring(
                "Add empty line between declarations",
                ct => RefactorAsync(context.Document, selectedMembers, ct),
                RefactoringIdentifiers.AddEmptyLineBetweenDeclarations);
        }
        private static void Analyze(SyntaxNodeAnalysisContext context, SyntaxList <MemberDeclarationSyntax> members)
        {
            int count = members.Count;

            if (count <= 1)
            {
                return;
            }

            SyntaxTree tree = context.Node.SyntaxTree;

            bool?isPrevSingleLine = null;

            for (int i = 1; i < count; i++)
            {
                MemberDeclarationSyntax prevMember = members[i - 1];

                SyntaxTriviaList trailingTrivia = prevMember.GetTrailingTrivia();

                SyntaxTrivia lastTrailingTrivia = trailingTrivia.LastOrDefault();

                if (!lastTrailingTrivia.IsKind(SyntaxKind.EndOfLineTrivia))
                {
                    isPrevSingleLine = false;
                    continue;
                }

                MemberDeclarationSyntax member = members[i];

                SyntaxTrivia documentationCommentTrivia = member.GetDocumentationCommentTrivia();

                bool hasDocumentationComment = !documentationCommentTrivia.IsKind(SyntaxKind.None);

                if (!hasDocumentationComment)
                {
                    bool isSingleLine = tree.IsSingleLineSpan(member.Span, context.CancellationToken);

                    if (isSingleLine)
                    {
                        if (isPrevSingleLine == null)
                        {
                            isPrevSingleLine = tree.IsSingleLineSpan(prevMember.Span, context.CancellationToken);
                        }

                        if (isPrevSingleLine == true)
                        {
                            isPrevSingleLine = isSingleLine;
                            continue;
                        }
                    }

                    isPrevSingleLine = isSingleLine;
                }
                else
                {
                    isPrevSingleLine = null;
                }

                if (member
                    .GetLeadingTrivia()
                    .FirstOrDefault()
                    .IsKind(SyntaxKind.EndOfLineTrivia))
                {
                    continue;
                }

                int end = (hasDocumentationComment) ? documentationCommentTrivia.SpanStart : member.SpanStart;

                if (tree.GetLineCount(TextSpan.FromBounds(prevMember.Span.End, end), context.CancellationToken) == 2)
                {
                    DiagnosticHelpers.ReportDiagnostic(context,
                                                       DiagnosticDescriptors.AddEmptyLineBetweenDeclarations,
                                                       lastTrailingTrivia);
                }
            }
        }