[clang-format] Add AlignAfterOpenBracketOptions

clang/docs/ReleaseNotes.rst

@@ -747,6 +747,7 @@ clang-format
 - Add ``EnumTrailingComma`` option for inserting/removing commas at the end of
   ``enum`` enumerator lists.
 - Add ``OneLineFormatOffRegex`` option for turning formatting off for one line.
+- Adds ``AlignAfterControlStatement`` option.
 
 libclang
 --------

clang/include/clang/Format/Format.h

@@ -62,6 +62,22 @@ struct FormatStyle {
   /// \version 3.3
   int AccessModifierOffset;
 
+  /// Different styles for breaking the parenthesis after a control statement
+  /// (``if/switch/while/for ...``).
+  /// \version 21
+  enum BreakAfterControlStatementStyle : int8_t {
+    /// Use the default behavior.
+    BACSS_Default,
+    /// Force break after the left parenthesis of a control statement only
+    /// when the expression exceeds the column limit, and align on the
+    /// ``ContinuationIndentWidth``.
+    BACSS_MultiLine,
+    /// Do not force a break after the control statment.
+    BACSS_No,
+  };
+
+  BreakAfterControlStatementStyle AlignAfterControlStatement;
+
   /// Different styles for aligning after open brackets.
   enum BracketAlignmentStyle : int8_t {
     /// Align parameters on the open bracket, e.g.:
@@ -5303,6 +5319,7 @@ struct FormatStyle {
 
   bool operator==(const FormatStyle &R) const {
     return AccessModifierOffset == R.AccessModifierOffset &&
+           AlignAfterControlStatement == R.AlignAfterControlStatement &&
            AlignAfterOpenBracket == R.AlignAfterOpenBracket &&
            AlignArrayOfStructures == R.AlignArrayOfStructures &&
            AlignConsecutiveAssignments == R.AlignConsecutiveAssignments &&

clang/lib/Format/ContinuationIndenter.cpp

@@ -814,6 +814,11 @@ void ContinuationIndenter::addTokenOnCurrentLine(LineState &State, bool DryRun,
   // 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.
+  auto IsOtherConditional = [&](const FormatToken &Tok) {
+    return Tok.isOneOf(tok::kw_for, tok::kw_while, tok::kw_switch) ||
+           (Style.isJavaScript() && Tok.is(Keywords.kw_await) && Tok.Previous &&
+            Tok.Previous->is(tok::kw_for));
+  };
   auto IsOpeningBracket = [&](const FormatToken &Tok) {
     auto IsStartOfBracedList = [&]() {
       return Tok.is(tok::l_brace) && Tok.isNot(BK_Block) &&
@@ -825,26 +830,36 @@ void ContinuationIndenter::addTokenOnCurrentLine(LineState &State, bool DryRun,
     }
     if (!Tok.Previous)
       return true;
-    if (Tok.Previous->isIf())
-      return Style.AlignAfterOpenBracket == FormatStyle::BAS_AlwaysBreak;
-    return !Tok.Previous->isOneOf(TT_CastRParen, tok::kw_for, tok::kw_while,
-                                  tok::kw_switch) &&
-           !(Style.isJavaScript() && Tok.Previous->is(Keywords.kw_await));
+    if (Tok.Previous->isIf()) {
+      /* For backward compatibility, use AlignAfterOpenBracket
+       * in case AlignAfterControlStatement is not initialized */
+      return Style.AlignAfterControlStatement == FormatStyle::BACSS_MultiLine ||
+             (Style.AlignAfterControlStatement == FormatStyle::BACSS_Default &&
+              Style.AlignAfterOpenBracket == FormatStyle::BAS_AlwaysBreak);
+    }
+    if (IsOtherConditional(*Tok.Previous))
+      return Style.AlignAfterControlStatement == FormatStyle::BACSS_MultiLine;
+    if (Style.AlignAfterOpenBracket == FormatStyle::BAS_AlwaysBreak ||
+        Style.AlignAfterOpenBracket == FormatStyle::BAS_BlockIndent) {
+      return !Tok.Previous->is(TT_CastRParen) &&
+             !(Style.isJavaScript() && Tok.is(Keywords.kw_await));
+    }
+    return false;
   };
   auto IsFunctionCallParen = [](const FormatToken &Tok) {
     return Tok.is(tok::l_paren) && Tok.ParameterCount > 0 && Tok.Previous &&
            Tok.Previous->is(tok::identifier);
   };
-  auto IsInTemplateString = [this](const FormatToken &Tok) {
+  auto IsInTemplateString = [this](const FormatToken &Tok, bool NestBlocks) {
     if (!Style.isJavaScript())
       return false;
     for (const auto *Prev = &Tok; Prev; Prev = Prev->Previous) {
       if (Prev->is(TT_TemplateString) && Prev->opensScope())
         return true;
-      if (Prev->opensScope() ||
-          (Prev->is(TT_TemplateString) && Prev->closesScope())) {
-        break;
-      }
+      if (Prev->opensScope() && !NestBlocks)
+        return false;
+      if (Prev->is(TT_TemplateString) && Prev->closesScope())
+        return false;
     }
     return false;
   };
@@ -866,21 +881,24 @@ void ContinuationIndenter::addTokenOnCurrentLine(LineState &State, bool DryRun,
          Tok.isOneOf(tok::ellipsis, Keywords.kw_await))) {
       return true;
     }
-    const auto *Previous = Tok.Previous;
-    if (!Previous || (!Previous->isOneOf(TT_FunctionDeclarationLParen,
-                                         TT_LambdaDefinitionLParen) &&
-                      !IsFunctionCallParen(*Previous))) {
+    const auto *Previous = TokAfterLParen.Previous;
+    assert(Previous); // IsOpeningBracket(Previous)
+    if (Previous->Previous && (Previous->Previous->isIf() ||
+                               IsOtherConditional(*Previous->Previous))) {
+      return false;
+    }
+    if (!Previous->isOneOf(TT_FunctionDeclarationLParen,
+                           TT_LambdaDefinitionLParen) &&
+        !IsFunctionCallParen(*Previous)) {
       return true;
     }
-    if (IsOpeningBracket(Tok) || IsInTemplateString(Tok))
+    if (IsOpeningBracket(Tok) || IsInTemplateString(Tok, true))
       return true;
     const auto *Next = Tok.Next;
     return !Next || Next->isMemberAccess() ||
            Next->is(TT_FunctionDeclarationLParen) || IsFunctionCallParen(*Next);
   };
-  if ((Style.AlignAfterOpenBracket == FormatStyle::BAS_AlwaysBreak ||
-       Style.AlignAfterOpenBracket == FormatStyle::BAS_BlockIndent) &&
-      IsOpeningBracket(Previous) && State.Column > getNewLineColumn(State) &&
+  if (IsOpeningBracket(Previous) && State.Column > getNewLineColumn(State) &&
       // Don't do this for simple (no expressions) one-argument function calls
       // as that feels like needlessly wasting whitespace, e.g.:
       //
@@ -910,7 +928,7 @@ void ContinuationIndenter::addTokenOnCurrentLine(LineState &State, bool DryRun,
       !(Current.MacroParent && Previous.MacroParent) &&
       (Current.isNot(TT_LineComment) ||
        Previous.isOneOf(BK_BracedInit, TT_VerilogMultiLineListLParen)) &&
-      !IsInTemplateString(Current)) {
+      !IsInTemplateString(Current, false)) {
     CurrentState.Indent = State.Column + Spaces;
     CurrentState.IsAligned = true;
   }
@@ -1247,8 +1265,17 @@ unsigned ContinuationIndenter::addTokenOnNewLine(LineState &State,
   }
 
   if (PreviousNonComment && PreviousNonComment->is(tok::l_paren)) {
-    CurrentState.BreakBeforeClosingParen =
-        Style.AlignAfterOpenBracket == FormatStyle::BAS_BlockIndent;
+    auto Previous = PreviousNonComment->Previous;
+    if (Previous &&
+        (Previous->isIf() ||
+         Previous->isOneOf(tok::kw_for, tok::kw_while, tok::kw_switch))) {
+      CurrentState.BreakBeforeClosingParen =
+          Style.AlignAfterControlStatement == FormatStyle::BACSS_MultiLine &&
+          Style.AlignAfterOpenBracket == FormatStyle::BAS_BlockIndent;
+    } else {
+      CurrentState.BreakBeforeClosingParen =
+          Style.AlignAfterOpenBracket == FormatStyle::BAS_BlockIndent;
+    }
   }
 
   if (PreviousNonComment && PreviousNonComment->is(TT_TemplateOpener))

clang/lib/Format/Format.cpp

@@ -202,6 +202,16 @@ template <> struct MappingTraits<FormatStyle::BraceWrappingFlags> {
   }
 };
 
+template <>
+struct ScalarEnumerationTraits<FormatStyle::BreakAfterControlStatementStyle> {
+  static void enumeration(IO &IO,
+                          FormatStyle::BreakAfterControlStatementStyle &Value) {
+    IO.enumCase(Value, "Default", FormatStyle::BACSS_Default);
+    IO.enumCase(Value, "MultiLine", FormatStyle::BACSS_MultiLine);
+    IO.enumCase(Value, "No", FormatStyle::BACSS_No);
+  }
+};
+
 template <> struct ScalarEnumerationTraits<FormatStyle::BracketAlignmentStyle> {
   static void enumeration(IO &IO, FormatStyle::BracketAlignmentStyle &Value) {
     IO.enumCase(Value, "Align", FormatStyle::BAS_Align);
@@ -954,6 +964,8 @@ template <> struct MappingTraits<FormatStyle> {
 
     IO.mapOptional("AccessModifierOffset", Style.AccessModifierOffset);
     IO.mapOptional("AlignAfterOpenBracket", Style.AlignAfterOpenBracket);
+    IO.mapOptional("AlignAfterControlStatement",
+                   Style.AlignAfterControlStatement);
     IO.mapOptional("AlignArrayOfStructures", Style.AlignArrayOfStructures);
     IO.mapOptional("AlignConsecutiveAssignments",
                    Style.AlignConsecutiveAssignments);
@@ -1486,6 +1498,7 @@ static void expandPresetsSpacesInParens(FormatStyle &Expanded) {
 FormatStyle getLLVMStyle(FormatStyle::LanguageKind Language) {
   FormatStyle LLVMStyle;
   LLVMStyle.AccessModifierOffset = -2;
+  LLVMStyle.AlignAfterControlStatement = FormatStyle::BACSS_Default;
   LLVMStyle.AlignAfterOpenBracket = FormatStyle::BAS_Align;
   LLVMStyle.AlignArrayOfStructures = FormatStyle::AIAS_None;
   LLVMStyle.AlignConsecutiveAssignments = {};

clang/lib/Format/TokenAnnotator.cpp

@@ -6224,7 +6224,13 @@ bool TokenAnnotator::canBreakBefore(const AnnotatedLine &Line,
     if (Next && Next->is(tok::l_paren))
       return false;
     const FormatToken *Previous = Right.MatchingParen->Previous;
-    return !(Previous && (Previous->is(tok::kw_for) || Previous->isIf()));
+    if (!Previous)
+      return true;
+    if (Previous->isIf() ||
+        Previous->isOneOf(tok::kw_for, tok::kw_while, tok::kw_switch)) {
+      return Style.AlignAfterControlStatement == FormatStyle::BACSS_MultiLine;
+    }
+    return true;
   }
 
   if (Left.isOneOf(tok::r_paren, TT_TrailingAnnotation) &&

clang/unittests/Format/ConfigParseTest.cpp

@@ -529,6 +529,14 @@ TEST(ConfigParseTest, ParsesConfiguration) {
   CHECK_PARSE("EnumTrailingComma: Remove", EnumTrailingComma,
               FormatStyle::ETC_Remove);
 
+  Style.AlignAfterControlStatement = FormatStyle::BACSS_Default;
+  CHECK_PARSE("AlignAfterControlStatement: MultiLine",
+              AlignAfterControlStatement, FormatStyle::BACSS_MultiLine);
+  CHECK_PARSE("AlignAfterControlStatement: No", AlignAfterControlStatement,
+              FormatStyle::BACSS_No);
+  CHECK_PARSE("AlignAfterControlStatement: Default", AlignAfterControlStatement,
+              FormatStyle::BACSS_Default);
+
   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
   CHECK_PARSE("AlignAfterOpenBracket: Align", AlignAfterOpenBracket,
               FormatStyle::BAS_Align);