public static PropertyDeclarationSyntax CreateAutoProperty(PropertyDeclarationSyntax propertyDeclaration, EqualsValueClauseSyntax initializer)
        {
            AccessorListSyntax accessorList = CreateAccessorList(propertyDeclaration);

            if (accessorList
                .DescendantTrivia()
                .All(f => f.IsWhitespaceOrEndOfLineTrivia()))
            {
                accessorList = accessorList.RemoveWhitespaceOrEndOfLineTrivia();
            }

            PropertyDeclarationSyntax newProperty = propertyDeclaration
                                                    .WithIdentifier(propertyDeclaration.Identifier.WithTrailingTrivia(Space))
                                                    .WithExpressionBody(null)
                                                    .WithAccessorList(accessorList);

            if (initializer != null)
            {
                newProperty = newProperty
                              .WithInitializer(initializer)
                              .WithSemicolonToken(SemicolonToken());
            }
            else
            {
                newProperty = newProperty.WithoutSemicolonToken();
            }

            return(newProperty
                   .WithTriviaFrom(propertyDeclaration)
                   .WithFormatterAnnotation());
        }
        private static AccessorListSyntax GetNewAccessorList(AccessorListSyntax accessorList)
        {
            if (accessorList.IsSingleLine(includeExteriorTrivia: false))
            {
                SyntaxTriviaList triviaList = accessorList
                                              .CloseBraceToken
                                              .LeadingTrivia
                                              .Add(NewLine());

                return(accessorList
                       .RemoveWhitespaceOrEndOfLineTrivia()
                       .WithCloseBraceToken(accessorList.CloseBraceToken.WithLeadingTrivia(triviaList)));
            }
            else
            {
                return(accessorList.ReplaceNodes(accessorList.Accessors, (f, g) =>
                {
                    if (ShouldBeFormatted(f))
                    {
                        return f.RemoveWhitespaceOrEndOfLineTrivia(f.Span);
                    }
                    else
                    {
                        return g;
                    }
                }));
            }
        }
Beispiel #3
0
        private static AccessorListSyntax CreateAccessorList(BlockSyntax block, bool singleline)
        {
            AccessorListSyntax accessorList = AccessorList(GetAccessorDeclaration(block));

            if (singleline)
            {
                accessorList = accessorList.RemoveWhitespaceOrEndOfLineTrivia();
            }

            return(accessorList);
        }
        public static AccessorListSyntax ExpandAccessorList(AccessorListSyntax accessorList)
        {
            IEnumerable <AccessorDeclarationSyntax> accessors = accessorList
                                                                .Accessors
                                                                .Select(f => f.WithBody(Block()).WithoutSemicolonToken());

            AccessorListSyntax newAccessorList = AccessorList(List(accessors));

            return(newAccessorList
                   .RemoveWhitespaceOrEndOfLineTrivia()
                   .WithCloseBraceToken(newAccessorList.CloseBraceToken.WithLeadingTrivia(NewLine())));
        }
        private static PropertyDeclarationSyntax ExpandProperty(PropertyDeclarationSyntax propertyDeclaration)
        {
            AccessorListSyntax accessorList = AccessorList(List(CreateAccessors(propertyDeclaration)));

            accessorList = accessorList
                           .RemoveWhitespaceOrEndOfLineTrivia()
                           .WithCloseBraceToken(accessorList.CloseBraceToken.WithLeadingTrivia(CSharpFactory.NewLine()));

            return(propertyDeclaration
                   .WithInitializer(null)
                   .WithoutSemicolonToken()
                   .WithAccessorList(accessorList));
        }
        private static AccessorListSyntax CreateAccessorList(ExpressionSyntax expression, SyntaxToken semicolon)
        {
            BlockSyntax block = CreateBlock(expression, semicolon);

            AccessorListSyntax accessorList = AccessorList(GetAccessorDeclaration(block));

            if (expression.IsSingleLine())
            {
                accessorList = accessorList
                               .RemoveWhitespaceOrEndOfLineTrivia()
                               .WithCloseBraceToken(accessorList.CloseBraceToken.WithLeadingTrivia(NewLine()));
            }

            return(accessorList);
        }
Beispiel #7
0
        private static IndexerDeclarationSyntax ExpandIndexer(IndexerDeclarationSyntax indexerDeclaration)
        {
            IEnumerable <AccessorDeclarationSyntax> accessors = indexerDeclaration
                                                                .AccessorList
                                                                .Accessors
                                                                .Select(f => f.WithBody(Block()).WithoutSemicolonToken());

            AccessorListSyntax accessorList = AccessorList(List(accessors));

            accessorList = accessorList
                           .RemoveWhitespaceOrEndOfLineTrivia()
                           .WithCloseBraceToken(accessorList.CloseBraceToken.WithLeadingTrivia(NewLine()));

            return(indexerDeclaration
                   .WithSemicolonToken(default(SyntaxToken))
                   .WithAccessorList(accessorList));
        }
Beispiel #8
0
        private static EventDeclarationSyntax ExpandEvent(EventFieldDeclarationSyntax eventDeclaration)
        {
            AccessorListSyntax accessorList = AccessorList(
                AddAccessorDeclaration(Block()),
                RemoveAccessorDeclaration(Block()));

            accessorList = accessorList
                           .RemoveWhitespaceOrEndOfLineTrivia()
                           .WithCloseBraceToken(accessorList.CloseBraceToken.WithLeadingTrivia(NewLine()));

            VariableDeclaratorSyntax declarator = eventDeclaration.Declaration.Variables[0];

            return(EventDeclaration(
                       eventDeclaration.AttributeLists,
                       eventDeclaration.Modifiers,
                       eventDeclaration.Declaration.Type,
                       default(ExplicitInterfaceSpecifierSyntax),
                       declarator.Identifier,
                       accessorList));
        }