Пример #1
0
        private static IEnumerable <EventFieldDeclarationSyntax> SplitEventFieldDeclaration(EventFieldDeclarationSyntax fieldDeclaration)
        {
            SeparatedSyntaxList <VariableDeclaratorSyntax> variables = fieldDeclaration.Declaration.Variables;

            EventFieldDeclarationSyntax fieldDeclaration2 = fieldDeclaration.WithoutTrivia();

            for (int i = 0; i < variables.Count; i++)
            {
                EventFieldDeclarationSyntax newDeclaration = EventFieldDeclaration(
                    fieldDeclaration2.AttributeLists,
                    fieldDeclaration2.Modifiers,
                    VariableDeclaration(
                        fieldDeclaration2.Declaration.Type,
                        SingletonSeparatedList(variables[i])));

                if (i == 0)
                {
                    newDeclaration = newDeclaration.WithLeadingTrivia(fieldDeclaration.GetLeadingTrivia());
                }

                if (i == variables.Count - 1)
                {
                    newDeclaration = newDeclaration.WithTrailingTrivia(fieldDeclaration.GetTrailingTrivia());
                }

                yield return(newDeclaration.WithFormatterAnnotation());
            }
        }
        private static Task <Document> RefactorAsync(
            Document document,
            SyntaxNode node,
            CancellationToken cancellationToken)
        {
            switch (node.Kind())
            {
            case SyntaxKind.MethodDeclaration:
            {
                var methodDeclaration = (MethodDeclarationSyntax)node;

                MethodDeclarationSyntax newNode = methodDeclaration
                                                  .WithBody(null)
                                                  .WithExpressionBody(null)
                                                  .WithSemicolonToken(SemicolonToken())
                                                  .WithFormatterAnnotation();

                return(document.ReplaceNodeAsync(methodDeclaration, newNode, cancellationToken));
            }

            case SyntaxKind.PropertyDeclaration:
            {
                var propertyDeclaration = (PropertyDeclarationSyntax)node;
                ArrowExpressionClauseSyntax expressionBody = propertyDeclaration.ExpressionBody;

                PropertyDeclarationSyntax newNode = propertyDeclaration
                                                    .WithExpressionBody(null)
                                                    .WithSemicolonToken(default(SyntaxToken))
                                                    .WithAccessorList(AccessorList(AutoGetAccessorDeclaration()).WithTriviaFrom(expressionBody))
                                                    .WithFormatterAnnotation();

                return(document.ReplaceNodeAsync(propertyDeclaration, newNode, cancellationToken));
            }

            case SyntaxKind.IndexerDeclaration:
            {
                var indexerDeclaration = (IndexerDeclarationSyntax)node;
                ArrowExpressionClauseSyntax expressionBody = indexerDeclaration.ExpressionBody;

                IndexerDeclarationSyntax newNode = indexerDeclaration
                                                   .WithExpressionBody(null)
                                                   .WithSemicolonToken(default(SyntaxToken))
                                                   .WithAccessorList(AccessorList(AutoGetAccessorDeclaration()).WithTriviaFrom(expressionBody))
                                                   .WithFormatterAnnotation();

                return(document.ReplaceNodeAsync(indexerDeclaration, newNode, cancellationToken));
            }

            case SyntaxKind.EventDeclaration:
            {
                var eventDeclaration = (EventDeclarationSyntax)node;

                EventFieldDeclarationSyntax eventFieldDeclaration = EventFieldDeclaration(
                    eventDeclaration.AttributeLists,
                    eventDeclaration.Modifiers,
                    eventDeclaration.EventKeyword,
                    VariableDeclaration(eventDeclaration.Type, VariableDeclarator(eventDeclaration.Identifier)),
                    SemicolonToken());

                eventFieldDeclaration = eventFieldDeclaration.WithFormatterAnnotation();

                return(document.ReplaceNodeAsync(eventDeclaration, eventFieldDeclaration, cancellationToken));
            }

            case SyntaxKind.GetAccessorDeclaration:
            case SyntaxKind.SetAccessorDeclaration:
            {
                var accessor = (AccessorDeclarationSyntax)node;

                AccessorDeclarationSyntax newAccessor = accessor
                                                        .WithBody(null)
                                                        .WithExpressionBody(null)
                                                        .WithSemicolonToken(SemicolonToken())
                                                        .WithTrailingTrivia(
                    accessor.DescendantTrivia(
                        TextSpan.FromBounds(
                            accessor.BodyOrExpressionBody().SpanStart,
                            accessor.Span.End)))
                                                        .WithFormatterAnnotation();

                return(document.ReplaceNodeAsync(accessor, newAccessor, cancellationToken));
            }
            }

            Debug.Fail("");

            return(Task.FromResult(document));
        }