[llvm-dev] Change coding style for argument alignment?

[Mehdi AMINI via llvm-dev]

On Thu, Dec 3, 2020 at 1:01 PM Nikita Popov via llvm-dev <
llvm-dev at lists.llvm.org> wrote:

> Hi,
>
> LLVM currently uses a coding style where arguments and parameters need to
> be aligned to the opening parenthesis "(".
>
>     someFunctionCall(Arg1, Arg2,
>                      Arg3, Arg4);
>
> This style guideline is unfortunate for a couple of reasons:
>
> 1. If a function is renamed, it is necessary to also reindent the
> arguments at all call-sites. For functions with many or complex arguments,
> this may require significant reflow.
>

Why is this a problem though? This is all automated by clang-format in
practice.


>
> 2. It causes significant right-ward drift. Especially for declarations,
> it's somewhat common for code ending up like this...
>
>    Foo SomeClassName::someMethodName(Bar &Arg1,
>                                       Bar &Arg2,
>                                       Bar &Arg3,
>                                       Bar &Arg4) {
>
> ... because there is just enough space to fit each argument individually,
> but still a need to break each one out on a separate line. Closure
> arguments are another common case of very awkward formatting.
>

Seems like clang-format has some heuristics for this, I wrote this in a
file:

Foo SomeClassName::someveryveryveryveryverylongMethodName(Bar &Arg1, Bar
&Arg2, Bar &Arg3, Bar &Arg4, Bar &Arg5, Bar &Arg6, Bar &Arg7, Bar &Arg8) {}
Foo SomeClassName::someveryveryveryveryveryverylongMethodName(Bar &Arg1,
Bar &Arg2, Bar &Arg3, Bar &Arg4, Bar &Arg5, Bar &Arg6, Bar &Arg7, Bar
&Arg8) {}
Foo SomeClassName::someMethodName(Bar &Arg1, Bar &Arg2, Bar &Arg3, Bar
&Arg4, Bar &Arg5, Bar &Arg6, Bar &Arg7, Bar &Arg8) {}

and clang-format print it this way:


Foo SomeClassName::someveryveryveryveryverylongMethodName(Bar &Arg1, Bar
&Arg2,
                                                          Bar &Arg3, Bar
&Arg4,
                                                          Bar &Arg5, Bar
&Arg6,
                                                          Bar &Arg7,
                                                          Bar &Arg8) {}
Foo SomeClassName::someveryveryveryveryveryverylongMethodName(
    Bar &Arg1, Bar &Arg2, Bar &Arg3, Bar &Arg4, Bar &Arg5, Bar &Arg6, Bar
&Arg7,
    Bar &Arg8) {}
Foo SomeClassName::someMethodName(Bar &Arg1, Bar &Arg2, Bar &Arg3, Bar
&Arg4,
                                  Bar &Arg5, Bar &Arg6, Bar &Arg7, Bar
&Arg8) {}



>
> 3. There are some arcane rules about when this is not the preferred style
> and you're supposed to indent arguments on the following line instead.
>
> Is there any chance that the style could be changed towards indenting (but
> not aligning) the following line instead?
>
>     someFunctionCall(
>         Arg1, Arg2, Arg3, Arg4);
>

Is there an existing clang-format setting to hook up to already?


>
> This is unaffected by renames, does not cause rightward drift and results
> in very predictable formatting.
>
> Based on past discussions, LLVM seems to be open to improving coding style
> for the better, so I thought I'd give this a shot, as this is a continuous
> source of friction for me.
>
> Regards,
> Nikita
> _______________________________________________
> LLVM Developers mailing list
> llvm-dev at lists.llvm.org
> https://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-dev
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/llvm-dev/attachments/20201203/be772886/attachment.html>