How split statements to new lines

[sharpzilla]

I have that code for generating method IsEmpty:

internal static class IsEmptyMethod
{
    internal const string NAME = "IsEmpty";

    internal static MethodDeclarationSyntax DeclareMethod(bool customIsEmpty)
    {
        List<string> columns = new() { "arg1", "arg2", "arg3"};
        var parameters = new ParameterSyntax[columns.Count];

        for (int i = 0; i < columns.Count; i++)
        {
            parameters[i] = Declare.CreateParameter(Declare.TypeName(SyntaxKind.StringKeyword), NameHelpers.FirstCharToLower(columns[i]));
        }

        var methodDeclaration = Declare.Method(
            NAME,
            PredefinedType(SyntaxKind.BoolKeyword.Token()),
            AccessModifier.Public,
            isStatic: true,
            isPartial: customIsEmpty,
            parameters: parameters);

        if (customIsEmpty)
            return methodDeclaration;

        if (!columns.Any())
            return methodDeclaration
               .WithBody(Block());

        var conditions = new List<ExpressionSyntax>();

        foreach (var column in columns)
        {
            conditions.Add(
                InvocationExpression(
                    MemberAccessExpression(
                        SyntaxKind.SimpleMemberAccessExpression,
                        IdentifierName("string"),
                        IdentifierName(nameof(string.IsNullOrEmpty)))
                )
                .WithArgumentList(
                    ArgumentList(
                        SingletonSeparatedList(
                            Argument(IdentifierName(NameHelpers.FirstCharToLower(column)))
                        )
                    )
                )
            );
        }

        var combinedCondition = conditions.Aggregate((left, right) =>
            BinaryExpression(SyntaxKind.LogicalOrExpression, left, right)
        );

        return methodDeclaration.WithBody(Block(ReturnStatement(combinedCondition)));
    }
}

I'm using my local helper classes, but I think the logic of this method is very clear.
The output of that code is:

public static bool IsEmpty(string arg1, string arg2, string arg3)
{
    return string.IsNullOrEmpty(arg1) || string.IsNullOrEmpty(arg2) || string.IsNullOrEmpty(arg3);
}

The problem I'm trying to solve is how to format the return string so that each expression starts with a new line so that it is more readable for a human.
What I expect:

public static bool IsEmpty(string arg1, string arg2, string arg3)
{
    return string.IsNullOrEmpty(arg1) 
         || string.IsNullOrEmpty(arg2)
         || string.IsNullOrEmpty(arg3);
}

I tried, and result still the same one long row, and no new lines:

using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;
...
var lineFeed= ParseLeadingTrivia("\r\n" );

var combinedCondition = conditions.Aggregate((left, right) =>
    BinaryExpression(SyntaxKind.LogicalOrExpression, left, right).WithLeadingTrivia(lineFeed)
    //BinaryExpression(SyntaxKind.LogicalOrExpression, left, right).WithTrailingTrivia(lineFeed)
    //BinaryExpression(SyntaxKind.LogicalOrExpression, left, right).WithTrailingTrivia(CarriageReturn)
    //BinaryExpression(SyntaxKind.LogicalOrExpression, left, right).WithTrailingTrivia(ElasticLineFeed)
    //BinaryExpression(SyntaxKind.LogicalOrExpression, left, right).WithLeadingTrivia(LineFeed)
);

In my previous question I got obvious answer, but I can't figure it out how it should work.

[333fred]

I would highly suggest using a syntax visualizer, and something like https://roslynquoter.azurewebsites.net/, to look at examples of how syntax trees are constructed. That should help you figure out the answers to these types of questions.

[sharpzilla]

Wow that site is awesome. But I still can't get extra new line. I created simple reproducible example namespace with two classes.
What I need:

namespace TestLineFeed
{
    class class1
    {
    }

//there are two extra new lines


    class class2
    {
    }
}

Here is a code:

 var ns = NamespaceDeclaration
         (
             IdentifierName
             (
                 Identifier
                 (
                     TriviaList(),
                     "TestLineFeed",
                     TriviaList(CarriageReturnLineFeed)
                 )
             )
         )
         .WithNamespaceKeyword
         (
             Token
             (
                 TriviaList(),
                 SyntaxKind.NamespaceKeyword,
                 TriviaList(Space)
             )
         )
         .WithOpenBraceToken
         (
             Token
             (
                 TriviaList(),
                 SyntaxKind.OpenBraceToken,
                 TriviaList(CarriageReturnLineFeed)
             )
         )
         .WithMembers
         (
             List
             (
                 new MemberDeclarationSyntax[]
                 {
                     ClassDeclaration
                     (
                         Identifier
                         (
                             TriviaList(),
                             "class1",
                             TriviaList
                             (
                                 CarriageReturnLineFeed
                             )
                         )
                     )
                     .WithKeyword
                     (
                         Token
                         (
                             TriviaList(Whitespace("    ")),
                             SyntaxKind.ClassKeyword,
                             TriviaList(Space)
                         )
                     )
                     .WithOpenBraceToken
                     (
                         Token
                         (
                             TriviaList(Whitespace("    ")),
                             SyntaxKind.OpenBraceToken,
                             TriviaList(CarriageReturnLineFeed)
                         )
                     )
                     .WithCloseBraceToken
                     (
                         Token
                         (
                             TriviaList(Whitespace("    ")),
                             SyntaxKind.CloseBraceToken,
                             TriviaList(CarriageReturnLineFeed)
                         )
                     ),
                     ClassDeclaration
                     (
                         Identifier
                         (
                             TriviaList(),
                             "class2",
                             TriviaList(CarriageReturnLineFeed)
                         )
                     )
                     .WithKeyword
                     (
                         Token
                         (
                             TriviaList
                             (
                                 new []
                                 {
                                    //tried different line feeds
                                     LineFeed,
                                     ElasticCarriageReturn,
                                     ElasticCarriageReturnLineFeed,
                                     ElasticLineFeed,
                                     CarriageReturnLineFeed,                                            
                                     Whitespace("        ")
                                 }
                             ),
                             SyntaxKind.ClassKeyword,
                             TriviaList(Space)
                         )
                     )
                     .WithOpenBraceToken
                     (
                         Token
                         (
                             TriviaList(Whitespace("    ")),
                             SyntaxKind.OpenBraceToken,
                             TriviaList(CarriageReturnLineFeed)
                         )
                     )
                     .WithCloseBraceToken
                     (
                         Token
                         (
                             TriviaList(Whitespace("    ")),
                             SyntaxKind.CloseBraceToken,
                             TriviaList(CarriageReturnLineFeed)
                         )
                     )
                 }
             )
         );

var sourceText = ns.NormalizeWhitespace().ToFullString();
#if DEBUG
        File.WriteAllText("C:\\Users\\Sharpzilla\\Desktop\\debug.txt", sourceText);
#endif
context.AddSource($"{model.ClassName}.g.cs", sourceText);

What I noticed is when I drop NormalizeWhitespace(), my example with two classes in the same namespace looks like I expect, two extra lines between classes. But the source code that I use in the analyzer then sticks together into a one-line code with random line breaks.
Is it possible to leave using NormalizeWhitespace() while still being able to add new empty lines?

[333fred]

Is it possible to leave using NormalizeWhitespace() while still being able to add new empty lines?

No. The whole point of that method is to normalize all whitespace. Line breaks are whitespace. If you want to control whitespace, you cannot use that method.