[clang-format] Fix lambda formatting in conditional

[HazardyKnusperkeks]

Summary

Without the patch UnwrappedLineFormatter::analyzeSolutionSpace just ran out of possible formattings and would put everything just on one line. The problem was that the the line break was forbidden, but putting the conditional colon on the same line is also forbidden.

[HazardyKnusperkeks]

Fun fact, there is one instance of such a case within the clang-format code. I can't remember where (I stumbled upon this in January, and tried to fix it ever since), should that be reformatted with this patch, or with a follow up?

clang/lib/Format/ContinuationIndenter.cpp

1412–1417

Someone put that in on purpose, but is that only intended for java script, then we could add the language check.
As one can see I also had to disable it for requires clauses. Because I think it is a very hard thing to disable line breaks for all the scopes.

1423

Or should we limit that to lambdas in a conditional? That would be even messier to detect.

[owenpan]

In D135918#3857711, @HazardyKnusperkeks wrote:

Fun fact, there is one instance of such a case within the clang-format code. I can't remember where (I stumbled upon this in January, and tried to fix it ever since), should that be reformatted with this patch, or with a follow up?

Perhaps with a follow-up in which we can reformat the entire directory.

clang/lib/Format/ContinuationIndenter.cpp

333

Return true if Current is a conditional colon preceded by a lambda r_brace that is followed by a pair of (possibly empty) parentheses.

1412–1417

Someone put that in on purpose, but is that only intended for java script, then we could add the language check.

It started as a JavaScript-only behavior but was later extended to cover all languages.

1423

Or should we limit that to lambdas in a conditional?

IMO we should, and it might not be too bad if you override NoLineBreak in canBreak() instead. See line 333 above.

[HazardyKnusperkeks]

Override in canBreak().

[owenpan]

clang/lib/Format/ContinuationIndenter.cpp

336

We can delete this line.

[HazardyKnusperkeks]

clang/lib/Format/ContinuationIndenter.cpp

336

Added an assert, just to be safe.

clang/lib/Format/ContinuationIndenter.cpp

bool ContinuationIndenter::canBreak(const LineState &State) {
   // styles of constructor initializers), that's always ok.
   if (!Current.isOneOf(TT_BinaryOperator, tok::comma) &&
       CurrentState.NoLineBreakInOperand) {
     return false;
   }
 
   if (Previous.is(tok::l_square) && Previous.is(TT_ObjCMethodExpr))
     return false;
 
   return !CurrentState.NoLineBreak;
 }
 
 bool ContinuationIndenter::mustBreak(const LineState &State) {
   const FormatToken &Current = *State.NextToken;
   const FormatToken &Previous = *Current.Previous;
   const auto &CurrentState = State.Stack.back();
   if (Style.BraceWrapping.BeforeLambdaBody && Current.CanBreakBefore &&
       Current.is(TT_LambdaLBrace) && Previous.isNot(TT_LineComment)) {
     auto LambdaBodyLength = getLengthToMatchingParen(Current, State.Stack);
     return LambdaBodyLength > getColumnLimit(State);
unsigned ContinuationIndenter::moveStateToNextToken(LineState &State,
   if (Current.isOneOf(TT_LambdaLSquare, TT_LambdaArrow))
     CurrentState.LastSpace = State.Column;
   if (Current.is(TT_RequiresExpression))
     CurrentState.NestedBlockIndent = State.Column;
 
   // Insert scopes created by fake parenthesis.
   const FormatToken *Previous = Current.getPreviousNonComment();
 
   // Add special behavior to support a format commonly used for JavaScript
   // closures:
   //   SomeFunction(function() {
   //     foo();
   //     bar();
   //   }, a, b, c);
   if (Current.isNot(tok::comment) && !Current.ClosesRequiresClause &&
       Previous && Previous->isOneOf(tok::l_brace, TT_ArrayInitializerLSquare) &&
       !Previous->is(TT_DictLiteral) && State.Stack.size() > 1 &&
       !CurrentState.HasMultipleNestedBlocks) {
-    if (State.Stack[State.Stack.size() - 2].NestedBlockInlined && Newline)
+    if (State.Stack[State.Stack.size() - 2].NestedBlockInlined && Newline &&
+        // Do not forbid line breaks for directly invoced lambdas.
+        (!Current.MatchingParen ||
+         Current.MatchingParen->isNot(TT_LambdaLBrace) || !Current.Next ||
+         Current.Next->isNot(tok::l_paren))) {
       for (ParenState &PState : llvm::drop_end(State.Stack))
         PState.NoLineBreak = true;
+    }
     State.Stack[State.Stack.size() - 2].NestedBlockInlined = false;
   }
   if (Previous && (Previous->isOneOf(TT_BinaryOperator, TT_ConditionalExpr) ||
                    (Previous->isOneOf(tok::l_paren, tok::comma, tok::colon) &&
                     !Previous->isOneOf(TT_DictLiteral, TT_ObjCMethodExpr)))) {
     CurrentState.NestedBlockInlined =
         !Newline && hasNestedBlockInlined(Previous, Current, Style);
   }

clang/unittests/Format/FormatTest.cpp

verifyFormat("for (int &i : chars)\n"
                "  ++i;",
                "for (int &i : chars)\n"
                "{\n"
                "  ++i;\n"
                "}",
                Style);
 }
 
+TEST_F(FormatTest, MultilineLambdaInConditional) {
+  auto Style = getLLVMStyleWithColumns(70);
+  verifyFormat("auto aLengthyIdentifier = oneExpressionSoThatWeBreak ? []() {\n"
+               "  ;\n"
+               "  return 5;\n"
+               "}()\n"
+               "                                                     : 2;",
+               Style);
+
+  Style = getLLVMStyleWithColumns(60);
+  verifyFormat("auto aLengthyIdentifier = oneExpressionSoThatWeBreak\n"
+               "                              ? []() {\n"
+               "                                  ;\n"
+               "                                  return 5;\n"
+               "                                }()\n"
+               "                              : 2;",
+               Style);
+
+  Style = getLLVMStyleWithColumns(40);
+  verifyFormat("auto aLengthyIdentifier =\n"
+               "    oneExpressionSoThatWeBreak ? []() {\n"
+               "      ;\n"
+               "      return 5;\n"
+               "    }()\n"
+               "                               : 2;", Style);
+}
+
 TEST_F(FormatTest, AlignAfterOpenBracketBlockIndent) {
   auto Style = getLLVMStyle();
 
   StringRef Short = "functionCall(paramA, paramB, paramC);\n"
                     "void functionDecl(int a, int b, int c);";
 
   StringRef Medium = "functionCall(paramA, paramB, paramC, paramD, paramE, "
                      "paramF, paramG, paramH, paramI);\n"