[clang-format] Fix formatting of if statements with BlockIndent

[gedare]

Summary

A bug with BlockIndent prevents line breaks within if (and else if) clauses.
While fixing this bug, it appears that AlignAfterOpenBracket is not designed
to work with loop and if statements, but AlwaysBreak works on if clauses.
The documentation and tests are not clear on whether or not this is intended.
This patch preserves the AlwaysBreak behavior but does not use BlockIndent on if
clauses.

It may be reasonable to create a new style option for alignment of if (and loop) clauses intentionally so AlwaysBreak and BlockIndent can be enabled or disabled for conditional blocks.

Fixes #54663.

[gedare]

Although I chose to preserve the existing behavior of AlwaysBreak and to mimic it for BlockIndent, I think it would be best to choose a consistent approach and document it. I also have a patch that does not apply the AlignAfterOpenBracket for if clauses, which could be done for only BlockIndent, or it could be done for AlwaysBreak too but that will cause some backward compatibility problems.

[gedare]

Ping.

[MyDeveloperDay]

clang/unittests/Format/FormatTest.cpp

25795

Why remove?

[gedare]

Revert deleted line in test.

clang/unittests/Format/FormatTest.cpp

25795

oops. that's a spurious change. I have reverted it.

[MyDeveloperDay]

It looks like this was added in D109557: Adds a BlockIndent option to AlignAfterOpenBracket I'm trying to understand what bad stuff happens if you remove the "if" from

return !(Previous && Previous->is(tok::kw_for));

@csmulhern any thoughts? (if you are still around?)

[MyDeveloperDay]

clang/unittests/Format/FormatTest.cpp

25805–25843

you can't remove a test and just call it good... the original author put this test in for a reason I assume?

25813

we don't do this.

25815

isn't the breaking of if ( and } else if (\n inconsistent?

[gedare]

clang/unittests/Format/FormatTest.cpp

25805–25843

understood, although it seems that the original author may not have considered if statements as legitimately to be used in BlockIndented formats, since this test case does not block indent. So, the test case will have to change anyway, if the if should be blockindented.

25813

OK, I'll move that other bug up my priority list, as the behavior of this test case involves both. That bug prevents breaking the line after the operand, I think there's some off-by-1 error somewhere in calculating the columns for blockindent breaks. Otherwise, this patch reveals that bug as a regression in this test case.

25815

The breaking is dependent on what ends up exceeding the ColumnLimit. since if ( is shorter than } else if ( by about 5 characters, you can get different breaks. As far as I can tell, the behavior of AlwaysBreak and BlockIndent will only break after the opening parens if the first "argument" doesn't fit. From what I understand, the penalties and desirable breaks come into play then, based on breaking around commas or boolean operators. With this patch, the behavior here is now consistent for both AlwaysBreak and BlockIndent.

This behavior is undocumented and I do not know the intention. I would think it is better for the two options to behave consistently, but I'm also willing to treat them differently for backward compatibility while fixing this bug.

[gedare]

I guess since the current behavior does not treat if with block indentation, this bug fix should instead prefer to maintain the current behavior, and if someone wants to have block indentation of if it would need to be added as a new style option. Otherwise, this will introduce regressions like that test case.

[gedare]

Do not apply BlockIndent to if conditionals. Address other comments.

[gedare]

I have fixed the bug in a different way that avoids using BlockIndent on if conditionals. AlwaysBreak will continue to apply to if conditionals by default. I may propose a style option to control that behavior later.

[gedare]

Rebase to main

[gedare]

@MyDeveloperDay ping

I have rebased to main without any problems. This patch fixes the bug.

[owenpan]

clang/lib/Format/ContinuationIndenter.cpp

773–792

This is getting out of hand. Consider writing a lambda with early returns.

[owenpan]

clang/unittests/Format/FormatTest.cpp

25814–25824

Please use camel case.

[gedare]

Use cameLCAse in test

[gedare]

clang/lib/Format/ContinuationIndenter.cpp

773–792

I would probably not get to refactoring this until January.

clang/lib/Format/ContinuationIndenter.cpp

if (Current.is(TT_SelectorName) && !CurrentState.ObjCSelectorNameFound) {
     else
       CurrentState.ColonPos = FirstColonPos;
   }
 
   // In "AlwaysBreak" or "BlockIndent" mode, enforce wrapping directly after the
   // parenthesis by disallowing any further line breaks if there is no line
   // break after the opening parenthesis. Don't break if it doesn't conserve
   // columns.
   if ((Style.AlignAfterOpenBracket == FormatStyle::BAS_AlwaysBreak ||
        Style.AlignAfterOpenBracket == FormatStyle::BAS_BlockIndent) &&
       (Previous.isOneOf(tok::l_paren, TT_TemplateOpener, tok::l_square) ||
        (Previous.is(tok::l_brace) && Previous.isNot(BK_Block) &&
         Style.Cpp11BracedListStyle)) &&
       State.Column > getNewLineColumn(State) &&
       (!Previous.Previous ||
-       !Previous.Previous->isOneOf(TT_CastRParen, tok::kw_for, tok::kw_while,
-                                   tok::kw_switch)) &&
+       !(Previous.Previous->isOneOf(TT_CastRParen, tok::kw_for, tok::kw_while,
+                                    tok::kw_switch) ||
+         (Style.AlignAfterOpenBracket == FormatStyle::BAS_BlockIndent &&
+          Previous.Previous->isIf()))) &&
       // Don't do this for simple (no expressions) one-argument function calls
       // as that feels like needlessly wasting whitespace, e.g.:
       //
       //   caaaaaaaaaaaall(
       //       caaaaaaaaaaaall(
       //           caaaaaaaaaaaall(
       //               caaaaaaaaaaaaaaaaaaaaaaall(aaaaaaaaaaaaaa, aaaaaaaaa))));
       Current.FakeLParens.size() > 0 &&
       Current.FakeLParens.back() > prec::Unknown) {
     CurrentState.NoLineBreak = true;
   }
   if (Previous.is(TT_TemplateString) && Previous.opensScope())
     CurrentState.NoLineBreak = true;
 
   // Align following lines within parentheses / brackets if configured.
   // Note: This doesn't apply to macro expansion lines, which are MACRO( , , )
   // with args as children of the '(' and ',' tokens. It does not make sense to

clang/unittests/Format/FormatTest.cpp

 TEST_F(FormatTest, AlignAfterOpenBracketBlockIndentIfStatement) {
   auto Style = getLLVMStyle();
 
   verifyFormat("if (foo()) {\n"
                "  return;\n"
                "}",
                Style);
 
-  verifyFormat("if (quitelongarg !=\n"
-               "    (alsolongarg - 1)) { // ABC is a very longgggggggggggg "
+  verifyFormat("if (quiteLongArg !=\n"
+               "    (alsoLongArg - 1)) { // ABC is a very longgggggggggggg "
                "comment\n"
                "  return;\n"
                "}",
                Style);
 
   Style.AlignAfterOpenBracket = FormatStyle::BAS_BlockIndent;
 
   verifyFormat("if (foo()) {\n"
                "  return;\n"
                "}",
                Style);
 
-  verifyFormat("if (quitelongarg !=\n"
-               "    (alsolongarg - 1)) { // ABC is a very longgggggggggggg "
+  verifyFormat("if (quiteLongArg !=\n"
+               "    (alsoLongArg - 1)) { // ABC is a very longgggggggggggg "
                "comment\n"
                "  return;\n"
                "}",
                Style);
+
+  verifyFormat("void foo() {\n"
+               "  if (camelCaseName < alsoLongName ||\n"
+               "      anotherEvenLongerName <=\n"
+               "          thisReallyReallyReallyReallyReallyReallyLongerName ||"
+               "\n"
+               "      otherName < thisLastName) {\n"
+               "    return;\n"
+               "  } else if (quiteLongName < alsoLongName ||\n"
+               "             anotherEvenLongerName <=\n"
+               "                 thisReallyReallyReallyReallyReallyReallyLonger"
+               "Name ||\n"
+               "             otherName < thisLastName) {\n"
+               "    return;\n"
+               "  }\n"
+               "}",
+               Style);
+
+  Style.ContinuationIndentWidth = 2;
+  verifyFormat("void foo() {\n"
+               "  if (ThisIsRatherALongIfClause && thatIExpectToBeBroken ||\n"
+               "      ontoMultipleLines && whenFormattedCorrectly) {\n"
+               "    if (false) {\n"
+               "      return;\n"
+               "    } else if (thisIsRatherALongIfClause && "
+               "thatIExpectToBeBroken ||\n"
+               "               ontoMultipleLines && whenFormattedCorrectly) {\n"
+               "      return;\n"
+               "    }\n"
+               "  }\n"
+               "}",
+               Style);
 }
 
 TEST_F(FormatTest, AlignAfterOpenBracketBlockIndentForStatement) {
   auto Style = getLLVMStyle();
 
   verifyFormat("for (int i = 0; i < 5; ++i) {\n"
                "  doSomething();\n"
                "}",