AllowShortFunctionsOnASingleLine与AlwaysBreakAfterReturnType是否兼容？

Hey there! Let's sort out this Clang Format setup issue you're dealing with. The good news is: your desired style (short functions on a single line, long functions with return types wrapped to their own line) is fully compatible—you just need to combine the right configuration options correctly.

Core Configuration Options to Use #

Here's the minimal .clang-format config that will get you the behavior you want:

# Controls when return types break to a new line
BreakBeforeReturnType: All
# Allows short functions to stay on a single line, overriding the above rule
AllowShortFunctionsOnASingleLine: All
# Optional: Set your preferred line length threshold (adjust based on your team's standard)
ColumnLimit: 80
# Optional: Keep return types left-aligned (adjust to "Indent" if you want them indented)
ReturnTypeIndentation: None

What Each Option Does #

• BreakBeforeReturnType: All: This tells Clang Format to put all function return types on their own line by default.
• AllowShortFunctionsOnASingleLine: All: This acts as an exception to the above rule—any function that's short enough to fit within your ColumnLimit (and meets Clang Format's definition of "short") will stay condensed onto a single line.

Example Behavior #

Let's test this with sample code:

Before Formatting

// Short function we want to keep on one line
int add(int a, int b) { return a + b; }

// Long function where we want the return type wrapped
VeryLongReturnTypeWithMultipleWords process_large_data(const std::vector<int>& input, bool validate, int timeout) {
    // Function body logic
    return {};
}

After Formatting (With the Config Above)

int add(int a, int b) { return a + b; }

VeryLongReturnTypeWithMultipleWords
process_large_data(const std::vector<int>& input, bool validate, int timeout) {
    // Function body logic
    return {};
}

Common Pitfalls That Might Have Caused Your Failure #

If you weren't seeing the expected result, check for these mistakes:

• Setting BreakBeforeReturnType to NonEmpty instead of All: NonEmpty only breaks return types if the function definition can't fit on one line, which clashes with your requirement to force wrapping for long return types even if the rest fits.
• Setting AllowShortFunctionsOnASingleLine to InlineOnly or None: InlineOnly only applies to inline functions, while None disables all single-line short functions—neither will give you the full exception you need.
• Forgetting to set a reasonable ColumnLimit: If your limit is set too high, even longer functions might be forced onto a single line. Adjust this to match your team's definition of "short" vs "long".

内容的提问来源于stack exchange，提问作者Justin