So, the main thing that I'd want is deterministic output based on the code structure (thus no respectsExistingLineBreaks), but without the "squishing" that comes with a line limit of 120 (pretty typical for iOS) for simple classes, extensions, etc.

But, I don't know that nested braces alone get exactly my ideal formatting. It's pretty subjective, but single-line functions:

func example(arg: Int) -> Int { return arg }

and single line if:

if something { print("something!") }

Don't feel "normal" (whereas single-line computed var and guard/else do... can't explain it!). Maybe the former is different with implicit single-expression returns from func being allowed now though!

But, it's less important than avoiding the excessive squishing. I think overall I prefer the result of this, but:

1. If the complexity of special-casing so many constructs is too much, a simpler approach is definitely valid, and will get most of the way there.
2. I made them all separate settings, just going off everything existing being a pretty small config option. But, to reduce complexity somewhat (in config, not so much in the implementation), they could just be one "more line breaks!" option to reduce the number of variations in outputs. Depends whether you value consistency or flexibility in swift-format (e.g. black is very inflexible, clang-format is very flexible).

Currently, when respectsExistingLineBreaks is set to false, swift-format squishes most of code onto single lines when it will fit under the line length limit. I'd like to use respectsExistingLineBreaks so that output is fully deterministic based on the source code structure, but I've found readability is negative impacted by formatting like this:

func foo(bar: Bool) { if bar { print("Bar!") } }

Instead, I'd prefer more line breaks:

func foo(bar: Bool) {
    if bar {
        print("Bar!")
    }
}

So, I want to add more options to force the addition of line breaks. Specifically, the ones that I'm currently looking at are:

• lineBreakBeforeEachFuncBody: after the opening { of a func, always use a line break.
• lineBreakBeforeEachIfElseBody: after the { following if or else, always use a line break.
• lineBreakBeforeEachLoopBody: same, but for loops.
  • This could be configurable per-loop-type, but would anyone want that?
• lineBreakBeforeEachSwitchCaseOrDefaultBody: after case ...: or default:, always use a line break.

The other constructs I can think of are guard and var. I don't need these, as I think the squished style is more typical for simple, short cases of these, but they could be added as well for the sake of completeness.

I think that this is basically https://bugs.swift.org/browse/SR-13458, though these changes won't add more flexibility, only more required line breaks.

I'm putting this up with just lineBreakBeforeEachSwitchCaseOrDefaultBody so that the idea and the implementation can be discussed, if moving forward, I'll stack the other commits and also add tests (testing locally by formatting my Swift code, it appears to work).

I'm also currently targeting the swift-5.3-branch because I'm using Xcode 12 locally, but I expect later on I'll need to rebase to target the main branch?

I also noticed that running the compiled swift-format, like this:

find Sources -name '*.swift' | xargs ./.build/debug/swift-format -i

...against all of the Swift files made a lot of changes, so I manually formatted the code (just the now-long after call). Is swift-format being used on the repo, and if so, how should I run it?