[clang-format] Fix BreakBeforeBraces: Attach ignored with trailing requires-expression of function.

[curdeius]

Summary

Fixes https://github.com/llvm/llvm-project/issues/48312.

[owenpan]

LGTM

[JohelEGP]

Thank you for doing this.

With the patch, I get this diff:

diff
diff --git a/sources/details/waarudo.details.utilities.cpp b/sources/details/waarudo.details.utilities.cpp
index 0b3680e..6e234ac 100644
--- a/sources/details/waarudo.details.utilities.cpp
+++ b/sources/details/waarudo.details.utilities.cpp
@@ -7,8 +7,8 @@ namespace waarudo {
 
 export template<class T, template<class...> class U> concept specialization_of = //
   (requires(T v) {
-    []<class... V>(U<V...>) requires std::same_as<T, U<V...>> { }
-    (v);
+    []<class... V>(U<V...>) requires std::same_as<T, U<V...>> {
+    }(v);
   });
 
 template<class T, class U> concept value_trait_for = //
diff --git a/sources/waarudo.quantities.cpp b/sources/waarudo.quantities.cpp
index 83a17db..fdc4c53 100644
--- a/sources/waarudo.quantities.cpp
+++ b/sources/waarudo.quantities.cpp
@@ -52,12 +52,20 @@ export template<class Id, number Number> struct quantity {
     requires std::convertible_to<const Number&, Number2>
   [[nodiscard]] constexpr operator quantity<Id, Number2>() const { return {number}; }
 
-  constexpr quantity& operator++() & requires ordered_number<Number> { return ++number, *this; }
-  constexpr quantity& operator--() & requires ordered_number<Number> { return --number, *this; }
-  [[nodiscard]] constexpr quantity operator++(int) & requires ordered_number<Number> { return {number++}; }
-  [[nodiscard]] constexpr quantity operator--(int) & requires ordered_number<Number> { return {number--}; }
+  constexpr quantity& operator++() & requires ordered_number<Number> {
+    return ++number, *this;
+  } constexpr quantity& operator--() & requires ordered_number<Number> {
+    return --number, *this;
+  } [[nodiscard]] constexpr quantity operator++(int) & requires ordered_number<Number> {
+    return {number++};
+  } [[nodiscard]] constexpr quantity operator--(int) & requires ordered_number<Number> {
+    return {number--};
+  }
 
-  constexpr quantity& operator+=(const relative_quantity_for<quantity> auto& d) & { return number += d.number, *this; }
+  constexpr quantity&
+  operator+=(const relative_quantity_for<quantity> auto& d) & {
+    return number += d.number, *this;
+  }
   constexpr quantity& operator-=(const relative_quantity_for<quantity> auto& d) & { return number -= d.number, *this; }
 
   template<relative_quantity_for<quantity> Q>

Here's how it looks without the patch:

namespace waarudo {

export template<class T, template<class...> class U> concept specialization_of = //
  (requires(T v) {
    []<class... V>(U<V...>) requires std::same_as<T, U<V...>> { }
    (v);
  });

struct x {
  constexpr quantity& operator++() & requires ordered_number<Number> { return ++number, *this; }
  constexpr quantity& operator--() & requires ordered_number<Number> { return --number, *this; }
  [[nodiscard]] constexpr quantity operator++(int) & requires ordered_number<Number> { return {number++}; }
  [[nodiscard]] constexpr quantity operator--(int) & requires ordered_number<Number> { return {number--}; }

  constexpr quantity& operator+=(const relative_quantity_for<quantity> auto& d) & { return number += d.number, *this; }
  constexpr quantity& operator-=(const relative_quantity_for<quantity> auto& d) & { return number -= d.number, *this; }
};

} // namespace waarudo

Here's my .clang-format:

AccessModifierOffset: -2
AlignAfterOpenBracket: AlwaysBreak
AlignArrayOfStructures: None
AlignConsecutiveAssignments: Consecutive
AlignConsecutiveBitFields: true
AlignConsecutiveDeclarations: false
AlignEscapedNewlines: Right
AlignOperands: Align
AlignTrailingComments: true
AllowAllArgumentsOnNextLine: true
AllowAllConstructorInitializersOnNextLine: true
AllowAllParametersOfDeclarationOnNextLine: true
AllowShortBlocksOnASingleLine: Always
AllowShortCaseLabelsOnASingleLine: true
AllowShortEnumsOnASingleLine: true
AllowShortFunctionsOnASingleLine: All
AllowShortIfStatementsOnASingleLine: AllIfsAndElse
AllowShortLambdasOnASingleLine: All
AllowShortLoopsOnASingleLine: true
AlwaysBreakAfterReturnType: None
AlwaysBreakBeforeMultilineStrings: false
AlwaysBreakTemplateDeclarations: No
BinPackArguments: true
BinPackParameters: true
BitFieldColonSpacing: Both
BreakBeforeBinaryOperators: None
BreakBeforeBraces: Attach
BreakBeforeConceptDeclarations: false
BreakBeforeTernaryOperators: true
BreakConstructorInitializers: BeforeColon
BreakInheritanceList: BeforeColon
BreakStringLiterals: true
ColumnLimit: 120
ConstructorInitializerAllOnOneLineOrOnePerLine: true
ConstructorInitializerIndentWidth: 2
ContinuationIndentWidth: 2
Cpp11BracedListStyle: true
DeriveLineEnding: false
DerivePointerAlignment: false
DisableFormat: false
EmptyLineAfterAccessModifier: Never
EmptyLineBeforeAccessModifier: Always
FixNamespaceComments: true
IncludeBlocks: Preserve
IncludeCategories:
  - Regex:      '<(experimental/)?[a-z_]+>' # C++ standard library
    Priority:   1
IndentAccessModifiers: false
IndentCaseBlocks: false
IndentCaseLabels: false
IndentPPDirectives: AfterHash
IndentRequires: true
IndentWidth: 2
IndentWrappedFunctionNames: false
KeepEmptyLinesAtTheStartOfBlocks: false
Language: Cpp
MaxEmptyLinesToKeep: 1
NamespaceIndentation: Inner
PointerAlignment: Left
PPIndentWidth: -1
ReflowComments: true
ShortNamespaceLines: 0
SortIncludes: CaseInsensitive
SortUsingDeclarations: true
SpaceAfterLogicalNot: true
SpaceAfterTemplateKeyword: false
SpaceBeforeAssignmentOperators: true
SpaceBeforeCaseColon: false
SpaceBeforeCpp11BracedList: false
SpaceBeforeCtorInitializerColon: true
SpaceBeforeInheritanceColon: true
SpaceBeforeParens: ControlStatements
SpaceBeforeRangeBasedForLoopColon: true
SpaceBeforeSquareBrackets: false
SpaceInEmptyBlock: true
SpaceInEmptyParentheses: false
SpacesBeforeTrailingComments: 1
SpacesInAngles: false
SpacesInConditionalStatement: false
SpacesInLineCommentPrefix:
  Minimum: 1
  Maximum: 1
SpacesInParentheses: false
SpacesInSquareBrackets: false
Standard: Latest
TabWidth: 2
UseCRLF: false
UseTab: Never

The second file in the diff, sources/waarudo.quantities.cpp, has a problem. The problem is that I've built my .clang-format to minimize line breaks, but for some reason, what fit on a line before, now doesn't.
On inspection, its first diff does not insert a line break before the start of new functions. Its second diff changes just the first function. If I remove the lines in the previous diff so that x only has operators += and -=, they remain unchanged.

[curdeius]

Ok, I'll have a look on it. Thanks for reporting.

clang/lib/Format/UnwrappedLineParser.h

private:
   void parseNamespace();
   void parseModuleImport();
   void parseNew();
   void parseAccessSpecifier();
   bool parseEnum();
   bool parseStructLike();
   void parseConcept();
   void parseRequires();
-  void parseRequiresExpression(unsigned int OriginalLevel);
-  void parseConstraintExpression(unsigned int OriginalLevel);
+  void parseRequiresExpression(unsigned int OriginalLevel,
+                               bool InTrailingRequire = false);
+  void parseConstraintExpression(unsigned int OriginalLevel,
+                                 bool InTrailingRequire = false);
   void parseJavaEnumBody();
   // Parses a record (aka class) as a top level element. If ParseAsExpr is true,
   // parses the record as a child block, i.e. if the class declaration is an
   // expression.
   void parseRecord(bool ParseAsExpr = false);
   void parseObjCLightweightGenerics();
   void parseObjCMethod();
   void parseObjCProtocolList();

clang/lib/Format/UnwrappedLineParser.cpp

void UnwrappedLineParser::parseConcept() {
   if (FormatTok->Tok.is(tok::kw_requires)) {
     nextToken();
     parseRequiresExpression(Line->Level);
   } else {
     parseConstraintExpression(Line->Level);
   }
 }
 
-void UnwrappedLineParser::parseRequiresExpression(unsigned int OriginalLevel) {
+void UnwrappedLineParser::parseRequiresExpression(unsigned int OriginalLevel,
+                                                  bool InTrailingRequire) {
   // requires (R range)
   if (FormatTok->Tok.is(tok::l_paren)) {
     parseParens();
     if (Style.IndentRequires && OriginalLevel != Line->Level) {
       addUnwrappedLine();
       --Line->Level;
     }
   }
 
   if (FormatTok->Tok.is(tok::l_brace)) {
     if (Style.BraceWrapping.AfterFunction)
       addUnwrappedLine();
     FormatTok->setType(TT_FunctionLBrace);
     parseBlock();
     addUnwrappedLine();
   } else {
-    parseConstraintExpression(OriginalLevel);
+    parseConstraintExpression(OriginalLevel, InTrailingRequire);
   }
 }
 
-void UnwrappedLineParser::parseConstraintExpression(
-    unsigned int OriginalLevel) {
+void UnwrappedLineParser::parseConstraintExpression(unsigned int OriginalLevel,
+                                                    bool InTrailingRequire) {
   // requires Id<T> && Id<T> || Id<T>
   while (
       FormatTok->isOneOf(tok::identifier, tok::kw_requires, tok::coloncolon)) {
     nextToken();
     while (FormatTok->isOneOf(tok::identifier, tok::coloncolon, tok::less,
                               tok::greater, tok::comma, tok::ellipsis)) {
       if (FormatTok->Tok.is(tok::less)) {
         parseBracedList(/*ContinueOnSemicolons=*/false, /*IsEnum=*/false,
if (FormatTok->Tok.is(tok::semi)) {
       // Eat any trailing semi.
       nextToken();
       addUnwrappedLine();
     }
     if (FormatTok->Tok.is(tok::colon)) {
       return;
     }
     if (!FormatTok->Tok.isOneOf(tok::ampamp, tok::pipepipe)) {
-      if (FormatTok->Previous &&
+      if (FormatTok->Previous) {
+        bool AddLine =
             !FormatTok->Previous->isOneOf(tok::identifier, tok::kw_requires,
-                                        tok::coloncolon)) {
+                                          tok::coloncolon) &&
+            !(InTrailingRequire && FormatTok->Previous->is(tok::r_brace));
+        if (AddLine)
           addUnwrappedLine();
       }
       if (Style.IndentRequires && OriginalLevel != Line->Level) {
         --Line->Level;
       }
       break;
     } else {
       FormatTok->setType(TT_ConstraintJunctions);
     }
 
     nextToken();
   }
 }
 
 void UnwrappedLineParser::parseRequires() {
   assert(FormatTok->Tok.is(tok::kw_requires) && "'requires' expected");
 
   unsigned OriginalLevel = Line->Level;
-  if (FormatTok->Previous && FormatTok->Previous->is(tok::greater)) {
+  bool InTrailingRequire =
+      !(FormatTok->Previous && FormatTok->Previous->is(tok::greater));
+  if (!InTrailingRequire) {
     addUnwrappedLine();
     if (Style.IndentRequires) {
       Line->Level++;
     }
   }
   nextToken();
 
-  parseRequiresExpression(OriginalLevel);
+  parseRequiresExpression(OriginalLevel, InTrailingRequire);
 }
 
 bool UnwrappedLineParser::parseEnum() {
   // Won't be 'enum' for NS_ENUMs.
   if (FormatTok->Tok.is(tok::kw_enum))
     nextToken();
 
   const FormatToken &InitialToken = *FormatTok;

clang/unittests/Format/FormatTest.cpp

verifyFormat("void foo4(void) {\n"
                "  A    B       = {.one_foooooooooooooooo = 2,\n"
                "                  .two_fooooooooooooo    = 3,\n"
                "                  .three_fooooooooooooo  = 4};\n"
                "  BYTE payload = 2;\n"
                "}",
                Style);
 }
 
+TEST_F(FormatTest, AttachBraceBreaking) {
+  FormatStyle BraceStyle = getLLVMStyle();
+  BraceStyle.BreakBeforeBraces = FormatStyle::BS_Attach;
+  verifyFormat("namespace a {\n"
+               "class A {\n"
+               "  void f() {\n"
+               "    if (true) {\n"
+               "      a();\n"
+               "      b();\n"
+               "    } else {\n"
+               "      a();\n"
+               "    }\n"
+               "  }\n"
+               "  void g() { return; }\n"
+               "};\n"
+               "struct B {\n"
+               "  int x;\n"
+               "};\n"
+               "} // namespace a\n",
+               BraceStyle);
+  verifyFormat("enum X {\n"
+               "  Y = 0,\n"
+               "}\n",
+               BraceStyle);
+  verifyFormat("struct S {\n"
+               "  int Type;\n"
+               "  union {\n"
+               "    int x;\n"
+               "    double y;\n"
+               "  } Value;\n"
+               "  class C {\n"
+               "    MyFavoriteType Value;\n"
+               "  } Class;\n"
+               "}\n",
+               BraceStyle);
+  // https://llvm.org/PR48968
+  verifyFormat("void f() requires requires { a; } {\n"
+               "  a();\n"
+               "  b();\n"
+               "}\n",
+               BraceStyle);
+}
+
 TEST_F(FormatTest, LinuxBraceBreaking) {
   FormatStyle LinuxBraceStyle = getLLVMStyle();
   LinuxBraceStyle.BreakBeforeBraces = FormatStyle::BS_Linux;
   verifyFormat("namespace a\n"
                "{\n"
                "class A\n"
                "{\n"
                "  void f()\n"
TEST_F(FormatTest, AllmanBraceBreaking) {
   verifyFormat("void f(bool b)\n"
                "{\n"
                "  while (b)\n"
                "  {\n"
                "    return;\n"
                "  }\n"
                "}\n",
                BreakBeforeBraceShortIfs);
+  // https://llvm.org/PR48968
+  verifyFormat("void f() requires requires { a; }\n"
+               "{\n"
+               "  a();\n"
+               "  b();\n"
+               "}\n",
+               BreakBeforeBraceShortIfs);
 }
 
 TEST_F(FormatTest, WhitesmithsBraceBreaking) {
   FormatStyle WhitesmithsBraceStyle = getLLVMStyle();
   WhitesmithsBraceStyle.BreakBeforeBraces = FormatStyle::BS_Whitesmiths;
 
   // Make a few changes to the style for testing purposes
   WhitesmithsBraceStyle.AllowShortFunctionsOnASingleLine =
verifyFormat("template <typename T>\n"
                "concept Tree = true;",
                Style);
 
   verifyFormat("template <typename T> int g(T i) requires Concept1<I> {\n"
                "  //...\n"
                "}",
                Style);
 
+  // https://llvm.org/PR48968
+  verifyFormat("void f() requires requires {\n"
+               "  a;\n"
+               "} {\n"
+               "  a();\n"
+               "  b();\n"
+               "}\n",
+               Style);
+
   verifyFormat(
       "template <typename T> int g(T i) requires Concept1<I> && Concept2<I> {\n"
       "  //...\n"
       "}",
       Style);
 
   verifyFormat(
       "template <typename T> int g(T i) requires Concept1<I> || Concept2<I> {\n"