clang-format: Setting to control C++ attributes

See https://stackoverflow.com/questions/45740466/clang-format-setting-to-control-c-attributes

If we have e.g.

template <typename TChar>
[[gnu::always_inline]]
static ptr<TChar> within_limit(ptr<TChar> first, ptr<TChar> last);

template <typename TChar, typename FApply, typename... FApplyRest>
[[gnu::always_inline]]
static ptr<TChar> overflow(ptr<TChar> first, ptr<TChar> last, const FApply& apply, const FApplyRest&... apply_rest);

No matter how we tweak clang-format, the output is always something like this:

[[gnu::always_inline]] static ptr<TChar> within_limit(ptr<TChar> first, ptr<TChar> last);

[[gnu::always_inline]] static ptr<TChar>
overflow(ptr<TChar> first, ptr<TChar> last, const FApply& apply, const FApplyRest&... apply_rest);

There should be a way to configure clang-format not to move the attributes like that, as it complicates readability.

[llvmbot]

@llvm/issue-subscribers-clang-tidy

@EugeneZelenko this is related to clang-format. Should it be tagged as clang-tidy?

[llvmbot]

@llvm/issue-subscribers-clang-format

[EugeneZelenko]

@martingalvan-nordic: I'm sorry for my mistake.

[mydeveloperday]

I've looked into this once before with some sort of naive BreakAfterAttributes, but this then did strange things to

[[nodiscard]] bool foo();

which maybe I don't want as

[[nodiscard]] 
bool foo();

It would need some sort of subtle control.

Why wouldn't you want

[[nodiscard]] 
bool foo();

in this case? The idea is precisely that the attributes are on their own line, so that they're not interfering with the function signature.

[mydeveloperday]

I guess I mean you might want different behaviour for declaration and definition (like BreakReturnType)

but also you might want to allow "ShortFunctions" where you don't break.

that what I mean by my previous implementation being a little naive, it likely needs a more considered approach as to the options

AFAIK attributes only belong in the function declaration, not its defnition. But I might be wrong.

The idea behind this isn't that function declarations end up being too long, but that the attributes belong to a separate category of interest than the function signature. Same thing happens with e.g. template machinery, where you'll often want

template <typename T1, typename T2>
void f(T1 t1, T2 t2);

instead of

template <typename T1, typename T2> void f(T1 t1, T2 t2);

It's not about line length, but about separating different categories of information. For example, to me attributes are useless noise, so I'd prefer to move them out of the way when I'm reading a function signature. Conversely, template information is important enough that I want it to be visually separated from the rest of the signature.

In any case, just having an option for disabling any automatic placement of attributes would be a huge improvement IMHO. Let the users arrange them as they wish.

[AaronBallman]

AFAIK attributes only belong in the function declaration, not its defnition. But I might be wrong.

It depends on the syntax of the attribute and the particular attribute in question. For C++-style attributes, almost all of them can be written on the definition (and frequently are). For GNU-style attributes, that's a Clang extension.

Let the users arrange them as they wish.

In general, that's hard. e.g., these are equivalent and I don't think clang-format should have a formatting option to decide which style to use:

[[attr]] void func();
void func [[attr]] ();

[[attr]] int a, b;
int a [[attr]], b [[attr]];

However, for things like "on their own line" vs "squished together as tightly as possible", I think that's much more reasonable for formatting options.