[clang-format] Add an option for breaking after C++11 attributes

[owenpan]

Summary

This patch only handles C++11 attributes before a function declaration/definition name. It doesn't cover attributes in variable declarations, which may be supported in the future.

Fixes:
https://github.com/llvm/llvm-project/issues/45968
https://github.com/llvm/llvm-project/issues/54265
https://github.com/llvm/llvm-project/issues/58102

[owenpan]

clang/lib/Format/FormatToken.h

323

Can be removed.

[MyDeveloperDay]

This LGTM

Should we care about other forms of attributes like __stdcall etc..? I personally don't, just I assume from the tests this isn't covered (maybe just add that limitation to the doc if it is indeed a limitation)

[owenpan]

• Delete the unused StartsCppAttribute.
• Strengthen test cases by covering nested C++11 attributes.
• Update documentation to make it clear that this option only applies to C++11 attributes.

[owenpan]

In D140956#4025614, @MyDeveloperDay wrote:

Should we care about other forms of attributes like __stdcall etc..? I personally don't, just I assume from the tests this isn't covered (maybe just add that limitation to the doc if it is indeed a limitation)

This option only handles C++11 attributes as mentioned in the summary. I've updated the doc to make it clear.

[MyDeveloperDay]

I'm good with that. I like small pieces of contained work and not open ended reviews that try to cover everything. If someone wants to extend this to include the old form, then that can be a completely different review. But this is a great start (especially as I heavily use [[nodiscard]])

Go for it..

[owenpan]

In D140956#4028147, @MyDeveloperDay wrote:

If someone wants to extend this to include the old form, then that can be a completely different review.

Better yet, use another tool like clang-tidy to replace the old with the new.

[MyDeveloperDay]

In D140956#4028288, @owenpan wrote:

In D140956#4028147, @MyDeveloperDay wrote:

If someone wants to extend this to include the old form, then that can be a completely different review.

Better yet, use another tool like clang-tidy to replace the old with the new.

indeed

[krasimir]

It looks like this regressed the following example:

% cat test.cc  # formatted with older clang-format
aaaaaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbb>
    &cccccccccccccccccccccccccccccccccccccc() {
  return 1;
}
% clang-format --version
clang-format version 16.0.0 (https://github.com/llvm/llvm-project.git a28f0747c2f3728bd8a6f64f7c8ba80b4e0cda9f)
% clang-format -style=google test.cc
aaaaaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbb> &
cccccccccccccccccccccccccccccccccccccc() {
  return 1;
}
%

@owenpan, I'm planning to temporarily revert this until you have a chance to investigate.

[MyDeveloperDay]

Before

M=0 C=0 T=Unknown S=1 F=0 B=0 BK=0 P=0 Name=identifier L=25 PPK=2 FakeLParens= FakeRParens=0 II=0x1aa92d99900 Text='aaaaaaaaaaaaaaaaaaaaaaaaa'
M=0 C=0 T=TemplateOpener S=0 F=0 B=0 BK=0 P=30 Name=less L=26 PPK=2 FakeLParens= FakeRParens=0 II=0x0 Text='<'
M=0 C=1 T=Unknown S=0 F=0 B=0 BK=0 P=360 Name=identifier L=37 PPK=2 FakeLParens= FakeRParens=0 II=0x1aa92d99938 Text='bbbbbbbbbbb'
M=0 C=0 T=TemplateCloser S=0 F=0 B=0 BK=0 P=270 Name=greater L=38 PPK=2 FakeLParens= FakeRParens=0 II=0x0 Text='>'
M=0 C=1 T=PointerOrReference S=1 F=0 B=0 BK=0 P=210 Name=amp L=40 PPK=2 FakeLParens= FakeRParens=0 II=0x0 Text='&'
M=0 C=1 T=FunctionDeclarationName S=0 F=0 B=0 BK=0 P=220 Name=identifier L=78 PPK=2 FakeLParens= FakeRParens=0 II=0x1aa92d99988 Text='cccccccccccccccccccccccccccccccccccccc'

After

M=0 C=0 T=Unknown S=1 F=0 B=0 BK=0 P=0 Name=identifier L=25 PPK=2 FakeLParens= FakeRParens=0 II=0x206f1adc870 Text='aaaaaaaaaaaaaaaaaaaaaaaaa'
M=0 C=0 T=TemplateOpener S=0 F=0 B=0 BK=0 P=30 Name=less L=26 PPK=2 FakeLParens= FakeRParens=0 II=0x0 Text='<'
M=0 C=1 T=Unknown S=0 F=0 B=0 BK=0 P=360 Name=identifier L=37 PPK=2 FakeLParens= FakeRParens=0 II=0x206f1adc8a8 Text='bbbbbbbbbbb'
M=0 C=0 T=TemplateCloser S=0 F=0 B=0 BK=0 P=270 Name=greater L=38 PPK=2 FakeLParens= FakeRParens=0 II=0x0 Text='>'
M=0 C=0 T=PointerOrReference S=1 F=0 B=0 BK=0 P=210 Name=amp L=40 PPK=2 FakeLParens= FakeRParens=0 II=0x0 Text='&'
M=0 C=1 T=FunctionDeclarationName S=0 F=0 B=0 BK=0 P=220 Name=identifier L=78 PPK=2 FakeLParens= FakeRParens=0 II=0x206f1adc8f8 Text='cccccccccccccccccccccccccccccccccccccc'

Looks like the "C" (Can Break?) goes from 1->0

"M=0 C=0 T=PointerOrReference"

[owenpan]

In D140956#4038988, @krasimir wrote:

It looks like this regressed the following example:

% cat test.cc  # formatted with older clang-format
aaaaaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbb>
    &cccccccccccccccccccccccccccccccccccccc() {
  return 1;
}
% clang-format --version
clang-format version 16.0.0 (https://github.com/llvm/llvm-project.git a28f0747c2f3728bd8a6f64f7c8ba80b4e0cda9f)
% clang-format -style=google test.cc
aaaaaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbb> &
cccccccccccccccccccccccccccccccccccccc() {
  return 1;
}
%

@owenpan, I'm planning to temporarily revert this until you have a chance to investigate.

Was it actually a regression or did this patch also fix a bug? It seems that the continuation indent before the & in your example is inconsistent with other similar function declarations.

Before this patch:

% cat test-all.cc
aaaaaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbb>
    &cccccccccccccccccccccccccccccccccccccc() {
  return 1;
}
aaaaaaaaaaaaaaaaaaaaaaaaa_bbbbbbbbbbb_
    &cccccccccccccccccccccccccccccccccccccc() {
  return 1;
}
aaaaaaaaaaaaaaaaaaaaaaaaa_bbbbbbbbbbb_
    _cccccccccccccccccccccccccccccccccccccc() {
  return 1;
}
aaaaaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbb>
    _cccccccccccccccccccccccccccccccccccccc() {
  return 1;
}

aaaaaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbb>
    &cccccccccccccccccccccccccccccccccccccc();
aaaaaaaaaaaaaaaaaaaaaaaaa_bbbbbbbbbbb_
    &cccccccccccccccccccccccccccccccccccccc();
aaaaaaaaaaaaaaaaaaaaaaaaa_bbbbbbbbbbb_
    _cccccccccccccccccccccccccccccccccccccc();
aaaaaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbb>
    _cccccccccccccccccccccccccccccccccccccc();
% clang-format -version
clang-format version 16.0.0 (https://github.com/llvm/llvm-project f2891086f4b64434ecf471960b6daf6f29fd4328)
% clang-format -style=google test-all.cc
aaaaaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbb>
    &cccccccccccccccccccccccccccccccccccccc() {
  return 1;
}
aaaaaaaaaaaaaaaaaaaaaaaaa_bbbbbbbbbbb_ &
cccccccccccccccccccccccccccccccccccccc() {
  return 1;
}
aaaaaaaaaaaaaaaaaaaaaaaaa_bbbbbbbbbbb_
_cccccccccccccccccccccccccccccccccccccc() {
  return 1;
}
aaaaaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbb>
_cccccccccccccccccccccccccccccccccccccc() {
  return 1;
}

aaaaaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbb>
    &cccccccccccccccccccccccccccccccccccccc();
aaaaaaaaaaaaaaaaaaaaaaaaa_bbbbbbbbbbb_ &
cccccccccccccccccccccccccccccccccccccc();
aaaaaaaaaaaaaaaaaaaaaaaaa_bbbbbbbbbbb_
_cccccccccccccccccccccccccccccccccccccc();
aaaaaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbb>
_cccccccccccccccccccccccccccccccccccccc();

After this patch:

% cf -version
clang-format version 16.0.0 (https://github.com/llvm/llvm-project a28f0747c2f3728bd8a6f64f7c8ba80b4e0cda9f)
% cf -style=google test-all.cc
aaaaaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbb> &
cccccccccccccccccccccccccccccccccccccc() {
  return 1;
}
aaaaaaaaaaaaaaaaaaaaaaaaa_bbbbbbbbbbb_ &
cccccccccccccccccccccccccccccccccccccc() {
  return 1;
}
aaaaaaaaaaaaaaaaaaaaaaaaa_bbbbbbbbbbb_
_cccccccccccccccccccccccccccccccccccccc() {
  return 1;
}
aaaaaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbb>
_cccccccccccccccccccccccccccccccccccccc() {
  return 1;
}

aaaaaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbb> &
cccccccccccccccccccccccccccccccccccccc();
aaaaaaaaaaaaaaaaaaaaaaaaa_bbbbbbbbbbb_ &
cccccccccccccccccccccccccccccccccccccc();
aaaaaaaaaaaaaaaaaaaaaaaaa_bbbbbbbbbbb_
_cccccccccccccccccccccccccccccccccccccc();
aaaaaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbb>
_cccccccccccccccccccccccccccccccccccccc();

[krasimir]

Was it actually a regression or did this patch also fix a bug? It seems that the continuation indent before the & in your example is inconsistent with other similar function declarations.

Nice catch! I fully agree with you!
Thank you for looking into this, sorry for the false alarm!

I'll go ahead and revert my revert.

[owenpan]

In D140956#4042990, @krasimir wrote:

Was it actually a regression or did this patch also fix a bug? It seems that the continuation indent before the & in your example is inconsistent with other similar function declarations.

Nice catch! I fully agree with you!
Thank you for looking into this, sorry for the false alarm!

Np!

clang/docs/ClangFormatStyleOptions.rst

* ``bool SplitEmptyNamespace`` If ``false``, empty namespace body can be put on a single line.
     .. code-block:: c++
 
       false:               true:
       namespace Foo   vs.  namespace Foo
       {}                   {
                            }
 
 
+**BreakAfterAttributes** (``AttributeBreakingStyle``) :versionbadge:`clang-format 16`
+  Break after a group of C++11 attributes before a function
+  declaration/definition name.
+
+  Possible values:
+
+  * ``ABS_Always`` (in configuration: ``Always``)
+    Always break after attributes.
+
+    .. code-block:: c++
+
+      [[nodiscard]]
+      inline int f();
+      [[gnu::const]] [[nodiscard]]
+      int g();
+
+  * ``ABS_Leave`` (in configuration: ``Leave``)
+    Leave the line breaking after attributes as is.
+
+    .. code-block:: c++
+
+      [[nodiscard]] inline int f();
+      [[gnu::const]] [[nodiscard]]
+      int g();
+
+  * ``ABS_Never`` (in configuration: ``Never``)
+    Never break after attributes.
+
+    .. code-block:: c++
+
+      [[nodiscard]] inline int f();
+      [[gnu::const]] [[nodiscard]] int g();
+
+
+
 **BreakAfterJavaFieldAnnotations** (``Boolean``) :versionbadge:`clang-format 3.8`
   Break after each annotation on a field in Java files.
 
   .. code-block:: java
 
      true:                                  false:
      @Partial                       vs.     @Partial @Mock DataLoad loader;
      @Mock

clang/docs/ReleaseNotes.rst

 clang-format
 ------------
 - Add ``RemoveSemicolon`` option for removing ``;`` after a non-empty function definition.
 - Add ``RequiresExpressionIndentation`` option for configuring the alignment of requires-expressions.
   The default value of this option is ``OuterScope``, which differs in behavior from clang-format 15.
   To match the default behavior of clang-format 15, use the ``Keyword`` value.
 - Add ``IntegerLiteralSeparator`` option for fixing integer literal separators
   in C++, C#, Java, and JavaScript.
+- Add ``BreakAfterAttributes`` option for breaking after a group of C++11
+  attributes before a function declaration/definition name.
 
 clang-extdef-mapping
 --------------------
 
 libclang
 --------
 - Introduced the new function ``clang_getUnqualifiedType``, which mimics
   the behavior of ``QualType::getUnqualifiedType`` for ``CXType``.

clang/include/clang/Format/Format.h

   ///   BraceWrapping:
   ///     AfterEnum: true
   ///     AfterStruct: false
   ///     SplitEmptyFunction: false
   /// \endcode
   /// \version 3.8
   BraceWrappingFlags BraceWrapping;
 
+  /// Different ways to break after attributes.
+  enum AttributeBreakingStyle : int8_t {
+    /// Always break after attributes.
+    /// \code
+    ///   [[nodiscard]]
+    ///   inline int f();
+    ///   [[gnu::const]] [[nodiscard]]
+    ///   int g();
+    /// \endcode
+    ABS_Always,
+    /// Leave the line breaking after attributes as is.
+    /// \code
+    ///   [[nodiscard]] inline int f();
+    ///   [[gnu::const]] [[nodiscard]]
+    ///   int g();
+    /// \endcode
+    ABS_Leave,
+    /// Never break after attributes.
+    /// \code
+    ///   [[nodiscard]] inline int f();
+    ///   [[gnu::const]] [[nodiscard]] int g();
+    /// \endcode
+    ABS_Never,
+  };
+
+  /// Break after a group of C++11 attributes before a function
+  /// declaration/definition name.
+  /// \version 16
+  AttributeBreakingStyle BreakAfterAttributes;
+
   /// If ``true``, clang-format will always break after a Json array `[`
   /// otherwise it will scan until the closing `]` to determine if it should add
   /// newlines between elements (prettier compatible).
   ///
   /// NOTE: This is currently only for formatting JSON.
   /// \code
   ///    true:                                  false:
   ///    [                          vs.      [1, 2, 3, 4]
return AccessModifierOffset == R.AccessModifierOffset &&
            AlwaysBreakBeforeMultilineStrings ==
                R.AlwaysBreakBeforeMultilineStrings &&
            AlwaysBreakTemplateDeclarations ==
                R.AlwaysBreakTemplateDeclarations &&
            AttributeMacros == R.AttributeMacros &&
            BinPackArguments == R.BinPackArguments &&
            BinPackParameters == R.BinPackParameters &&
            BitFieldColonSpacing == R.BitFieldColonSpacing &&
+           BreakAfterAttributes == R.BreakAfterAttributes &&
            BreakAfterJavaFieldAnnotations == R.BreakAfterJavaFieldAnnotations &&
            BreakArrays == R.BreakArrays &&
            BreakBeforeBinaryOperators == R.BreakBeforeBinaryOperators &&
            BreakBeforeBraces == R.BreakBeforeBraces &&
            BreakBeforeConceptDeclarations == R.BreakBeforeConceptDeclarations &&
            BreakBeforeInlineASMColon == R.BreakBeforeInlineASMColon &&
            BreakBeforeTernaryOperators == R.BreakBeforeTernaryOperators &&
            BreakConstructorInitializers == R.BreakConstructorInitializers &&

clang/lib/Format/ContinuationIndenter.cpp

if (Style.isJavaScript() && Previous.is(tok::r_paren) &&
     static const llvm::StringSet<> BreakBeforeDecoratedTokens = {"get", "set",
                                                                  "function"};
     if (BreakBeforeDecoratedTokens.contains(Current.TokenText))
       return true;
   }
 
   // If the return type spans multiple lines, wrap before the function name.
   if (((Current.is(TT_FunctionDeclarationName) &&
+        !State.Line->ReturnTypeWrapped &&
         // Don't break before a C# function when no break after return type.
         (!Style.isCSharp() ||
          Style.AlwaysBreakAfterReturnType != FormatStyle::RTBS_None) &&
         // Don't always break between a JavaScript `function` and the function
         // name.
         !Style.isJavaScript()) ||
        (Current.is(tok::kw_operator) && !Previous.is(tok::coloncolon))) &&
       !Previous.is(tok::kw_template) && CurrentState.BreakBeforeParameter) {

clang/lib/Format/Format.cpp

static void mapping(IO &IO, FormatStyle::AlignConsecutiveStyle &Value) {
     IO.mapOptional("AcrossEmptyLines", Value.AcrossEmptyLines);
     IO.mapOptional("AcrossComments", Value.AcrossComments);
     IO.mapOptional("AlignCompound", Value.AlignCompound);
     IO.mapOptional("PadOperators", Value.PadOperators);
   }
 };
 
 template <>
+struct ScalarEnumerationTraits<FormatStyle::AttributeBreakingStyle> {
+  static void enumeration(IO &IO, FormatStyle::AttributeBreakingStyle &Value) {
+    IO.enumCase(Value, "Always", FormatStyle::ABS_Always);
+    IO.enumCase(Value, "Leave", FormatStyle::ABS_Leave);
+    IO.enumCase(Value, "Never", FormatStyle::ABS_Never);
+  }
+};
+
+template <>
 struct ScalarEnumerationTraits<FormatStyle::ArrayInitializerAlignmentStyle> {
   static void enumeration(IO &IO,
                           FormatStyle::ArrayInitializerAlignmentStyle &Value) {
     IO.enumCase(Value, "None", FormatStyle::AIAS_None);
     IO.enumCase(Value, "Left", FormatStyle::AIAS_Left);
     IO.enumCase(Value, "Right", FormatStyle::AIAS_Right);
   }
 };
IO.mapOptional("AlwaysBreakBeforeMultilineStrings",
                    Style.AlwaysBreakBeforeMultilineStrings);
     IO.mapOptional("AlwaysBreakTemplateDeclarations",
                    Style.AlwaysBreakTemplateDeclarations);
     IO.mapOptional("AttributeMacros", Style.AttributeMacros);
     IO.mapOptional("BinPackArguments", Style.BinPackArguments);
     IO.mapOptional("BinPackParameters", Style.BinPackParameters);
     IO.mapOptional("BitFieldColonSpacing", Style.BitFieldColonSpacing);
     IO.mapOptional("BraceWrapping", Style.BraceWrapping);
+    IO.mapOptional("BreakAfterAttributes", Style.BreakAfterAttributes);
     IO.mapOptional("BreakAfterJavaFieldAnnotations",
                    Style.BreakAfterJavaFieldAnnotations);
     IO.mapOptional("BreakArrays", Style.BreakArrays);
     IO.mapOptional("BreakBeforeBinaryOperators",
                    Style.BreakBeforeBinaryOperators);
     IO.mapOptional("BreakBeforeConceptDeclarations",
                    Style.BreakBeforeConceptDeclarations);
     IO.mapOptional("BreakBeforeBraces", Style.BreakBeforeBraces);
LLVMStyle.BraceWrapping = {/*AfterCaseLabel=*/false,
                              /*BeforeCatch=*/false,
                              /*BeforeElse=*/false,
                              /*BeforeLambdaBody=*/false,
                              /*BeforeWhile=*/false,
                              /*IndentBraces=*/false,
                              /*SplitEmptyFunction=*/true,
                              /*SplitEmptyRecord=*/true,
                              /*SplitEmptyNamespace=*/true};
+  LLVMStyle.BreakAfterAttributes = FormatStyle::ABS_Never;
   LLVMStyle.BreakAfterJavaFieldAnnotations = false;
   LLVMStyle.BreakArrays = true;
   LLVMStyle.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
   LLVMStyle.BreakBeforeBraces = FormatStyle::BS_Attach;
   LLVMStyle.BreakBeforeConceptDeclarations = FormatStyle::BBCDS_Always;
   LLVMStyle.BreakBeforeInlineASMColon = FormatStyle::BBIAS_OnlyMultiline;
   LLVMStyle.BreakBeforeTernaryOperators = true;
   LLVMStyle.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon;

clang/lib/Format/FormatToken.h

 /// whitespace characters preceding it.
 struct FormatToken {
   FormatToken()
       : HasUnescapedNewline(false), IsMultiline(false), IsFirst(false),
         MustBreakBefore(false), IsUnterminatedLiteral(false),
         CanBreakBefore(false), ClosesTemplateDeclaration(false),
         StartsBinaryExpression(false), EndsBinaryExpression(false),
         PartOfMultiVariableDeclStmt(false), ContinuesLineCommentSection(false),
-        Finalized(false), ClosesRequiresClause(false), BlockKind(BK_Unknown),
+        Finalized(false), ClosesRequiresClause(false),
+        EndsCppAttributeGroup(false), BlockKind(BK_Unknown),
         Decision(FD_Unformatted), PackingKind(PPK_Inconclusive),
         TypeIsFinalized(false), Type(TT_Unknown) {}
 
   /// The \c Token.
   Token Tok;
 
   /// The raw text of the token.
   ///
struct FormatToken {
   /// If \c true, this token has been fully formatted (indented and
   /// potentially re-formatted inside), and we do not allow further formatting
   /// changes.
   unsigned Finalized : 1;
 
   /// \c true if this is the last token within requires clause.
   unsigned ClosesRequiresClause : 1;
 
+  /// \c true if this token ends a group of C++ attributes.
+  unsigned EndsCppAttributeGroup : 1;
+
 private:
   /// Contains the kind of block if this token is a brace.
   unsigned BlockKind : 2;
 
 public:
   BraceBlockKind getBlockKind() const {
     return static_cast<BraceBlockKind>(BlockKind);
   }

clang/lib/Format/TokenAnnotator.h

AnnotatedLine(const UnwrappedLine &Line)
         MatchingOpeningBlockLineIndex(Line.MatchingOpeningBlockLineIndex),
         MatchingClosingBlockLineIndex(Line.MatchingClosingBlockLineIndex),
         InPPDirective(Line.InPPDirective),
         InPragmaDirective(Line.InPragmaDirective),
         InMacroBody(Line.InMacroBody),
         MustBeDeclaration(Line.MustBeDeclaration), MightBeFunctionDecl(false),
         IsMultiVariableDeclStmt(false), Affected(false),
         LeadingEmptyLinesAffected(false), ChildrenAffected(false),
-        IsContinuation(Line.IsContinuation),
+        ReturnTypeWrapped(false), IsContinuation(Line.IsContinuation),
         FirstStartColumn(Line.FirstStartColumn) {
     assert(!Line.Tokens.empty());
 
     // Calculate Next and Previous for all tokens. Note that we must overwrite
     // Next and Previous for every token, as previous formatting runs might have
     // left them in a different state.
     First->Previous = nullptr;
     FormatToken *Current = First;
public:
 
   /// \c True if the leading empty lines of this line intersect with one of the
   /// input ranges.
   bool LeadingEmptyLinesAffected;
 
   /// \c True if one of this line's children intersects with an input range.
   bool ChildrenAffected;
 
+  /// \c True if breaking after last attribute group in function return type.
+  bool ReturnTypeWrapped;
+
   /// \c True if this line should be indented by ContinuationIndent in addition
   /// to the normal indention level.
   bool IsContinuation;
 
   unsigned FirstStartColumn;
 
 private:
   // Disallow copying.

clang/lib/Format/TokenAnnotator.cpp

bool parseSquare() {
     // Cases where '>' is followed by '['.
     // In C++, this can happen either in array of templates (foo<int>[10])
     // or when array is a nested template type (unique_ptr<type1<type2>[]>).
     bool CppArrayTemplates =
         Style.isCpp() && Parent && Parent->is(TT_TemplateCloser) &&
         (Contexts.back().CanBeExpression || Contexts.back().IsExpression ||
          Contexts.back().ContextType == Context::TemplateArgument);
 
-    bool IsCpp11AttributeSpecifier = isCpp11AttributeSpecifier(*Left) ||
-                                     Contexts.back().InCpp11AttributeSpecifier;
+    const bool IsInnerSquare = Contexts.back().InCpp11AttributeSpecifier;
+    const bool IsCpp11AttributeSpecifier =
+        isCpp11AttributeSpecifier(*Left) || IsInnerSquare;
 
     // Treat C# Attributes [STAThread] much like C++ attributes [[...]].
     bool IsCSharpAttributeSpecifier =
         isCSharpAttributeSpecifier(*Left) ||
         Contexts.back().InCSharpAttributeSpecifier;
 
     bool InsideInlineASM = Line.startsWith(tok::kw_asm);
     bool IsCppStructuredBinding = Left->isCppStructuredBinding(Style);
if (IsCppStructuredBinding) {
       Left->setType(TT_StructuredBindingLSquare);
     } else if (Left->is(TT_Unknown)) {
       if (StartsObjCMethodExpr) {
         Left->setType(TT_ObjCMethodExpr);
       } else if (InsideInlineASM) {
         Left->setType(TT_InlineASMSymbolicNameLSquare);
       } else if (IsCpp11AttributeSpecifier) {
         Left->setType(TT_AttributeSquare);
+        if (!IsInnerSquare && Left->Previous)
+          Left->Previous->EndsCppAttributeGroup = false;
       } else if (Style.isJavaScript() && Parent &&
                  Contexts.back().ContextKind == tok::l_brace &&
                  Parent->isOneOf(tok::l_brace, tok::comma)) {
         Left->setType(TT_JsComputedPropertyName);
       } else if (Style.isCpp() && Contexts.back().ContextKind == tok::l_brace &&
                  Parent && Parent->isOneOf(tok::l_brace, tok::comma)) {
         Left->setType(TT_DesignatedInitializerLSquare);
       } else if (IsCSharpAttributeSpecifier) {
if (Style.isJavaScript() && Parent && Parent->is(TT_JsTypeColon))
       Contexts.back().IsExpression = false;
 
     Contexts.back().ColonIsObjCMethodExpr = StartsObjCMethodExpr;
     Contexts.back().InCpp11AttributeSpecifier = IsCpp11AttributeSpecifier;
     Contexts.back().InCSharpAttributeSpecifier = IsCSharpAttributeSpecifier;
 
     while (CurrentToken) {
       if (CurrentToken->is(tok::r_square)) {
-        if (IsCpp11AttributeSpecifier)
+        if (IsCpp11AttributeSpecifier) {
           CurrentToken->setType(TT_AttributeSquare);
+          if (!IsInnerSquare)
+            CurrentToken->EndsCppAttributeGroup = true;
+        }
         if (IsCSharpAttributeSpecifier) {
           CurrentToken->setType(TT_AttributeSquare);
         } else if (((CurrentToken->Next &&
                      CurrentToken->Next->is(tok::l_paren)) ||
                     (CurrentToken->Previous &&
                      CurrentToken->Previous->Previous == Left)) &&
                    Left->is(TT_ObjCMethodExpr)) {
           // An ObjC method call is rarely followed by an open parenthesis. It
bool TokenAnnotator::mustBreakForReturnType(const AnnotatedLine &Line) const {
   case FormatStyle::RTBS_AllDefinitions:
   case FormatStyle::RTBS_TopLevelDefinitions:
     return Line.mightBeFunctionDefinition();
   }
 
   return false;
 }
 
+static bool mustBreakAfterAttributes(const FormatToken &Tok,
+                                     const FormatStyle &Style) {
+  switch (Style.BreakAfterAttributes) {
+  case FormatStyle::ABS_Always:
+    return true;
+  case FormatStyle::ABS_Leave:
+    return Tok.NewlinesBefore > 0;
+  default:
+    return false;
+  }
+}
+
 void TokenAnnotator::calculateFormattingInformation(AnnotatedLine &Line) const {
   for (AnnotatedLine *ChildLine : Line.Children)
     calculateFormattingInformation(*ChildLine);
 
   Line.First->TotalLength =
       Line.First->IsMultiline ? Style.ColumnLimit
                               : Line.FirstStartColumn + Line.First->ColumnWidth;
   FormatToken *Current = Line.First->Next;
   bool InFunctionDecl = Line.MightBeFunctionDecl;
   bool AlignArrayOfStructures =
       (Style.AlignArrayOfStructures != FormatStyle::AIAS_None &&
        Line.Type == LT_ArrayOfStructInitializer);
   if (AlignArrayOfStructures)
     calculateArrayInitializerColumnList(Line);
 
+  for (FormatToken *Tok = Current, *AfterLastAttribute = nullptr; Tok;
+       Tok = Tok->Next) {
+    if (isFunctionDeclarationName(Style.isCpp(), *Tok, Line)) {
+      Tok->setType(TT_FunctionDeclarationName);
+      if (AfterLastAttribute &&
+          mustBreakAfterAttributes(*AfterLastAttribute, Style)) {
+        AfterLastAttribute->MustBreakBefore = true;
+        Line.ReturnTypeWrapped = true;
+      }
+      break;
+    }
+    if (Tok->Previous->EndsCppAttributeGroup)
+      AfterLastAttribute = Tok;
+  }
+
   while (Current) {
-    if (isFunctionDeclarationName(Style.isCpp(), *Current, Line))
-      Current->setType(TT_FunctionDeclarationName);
     const FormatToken *Prev = Current->Previous;
     if (Current->is(TT_LineComment)) {
       if (Prev->is(BK_BracedInit) && Prev->opensScope()) {
         Current->SpacesRequiredBefore =
             (Style.Cpp11BracedListStyle && !Style.SpacesInParentheses) ? 0 : 1;
       } else {
         Current->SpacesRequiredBefore = Style.SpacesBeforeTrailingComments;
       }

clang/unittests/Format/ConfigParseTest.cpp

CHECK_PARSE("BreakBeforeConceptDeclarations: Always",
               BreakBeforeConceptDeclarations, FormatStyle::BBCDS_Always);
   CHECK_PARSE("BreakBeforeConceptDeclarations: Allowed",
               BreakBeforeConceptDeclarations, FormatStyle::BBCDS_Allowed);
   // For backward compatibility:
   CHECK_PARSE("BreakBeforeConceptDeclarations: true",
               BreakBeforeConceptDeclarations, FormatStyle::BBCDS_Always);
   CHECK_PARSE("BreakBeforeConceptDeclarations: false",
               BreakBeforeConceptDeclarations, FormatStyle::BBCDS_Allowed);
+
+  CHECK_PARSE("BreakAfterAttributes: Always", BreakAfterAttributes,
+              FormatStyle::ABS_Always);
+  CHECK_PARSE("BreakAfterAttributes: Leave", BreakAfterAttributes,
+              FormatStyle::ABS_Leave);
+  CHECK_PARSE("BreakAfterAttributes: Never", BreakAfterAttributes,
+              FormatStyle::ABS_Never);
 }
 
 TEST(ConfigParseTest, ParsesConfigurationWithLanguages) {
   FormatStyle Style = {};
   Style.Language = FormatStyle::LK_Cpp;
   CHECK_PARSE("Language: Cpp\n"
               "IndentWidth: 12",
               IndentWidth, 12u);

clang/unittests/Format/FormatTest.cpp

#if 0
   verifyFormat("void foo() {} //\n"
                "int bar;",
                "void foo() {}; //\n"
                "; int bar;",
                Style);
 #endif
 }
 
+TEST_F(FormatTest, BreakAfterAttributes) {
+  FormatStyle Style = getLLVMStyle();
+  EXPECT_EQ(Style.BreakAfterAttributes, FormatStyle::ABS_Never);
+
+  const StringRef Code("[[nodiscard]] inline int f(int &i);\n"
+                       "[[foo([[]])]] [[nodiscard]]\n"
+                       "int g(int &i);\n"
+                       "[[nodiscard]]\n"
+                       "inline int f(int &i) {\n"
+                       "  i = 1;\n"
+                       "  return 0;\n"
+                       "}\n"
+                       "[[foo([[]])]] [[nodiscard]] int g(int &i) {\n"
+                       "  i = 0;\n"
+                       "  return 1;\n"
+                       "}");
+
+  verifyFormat("[[nodiscard]] inline int f(int &i);\n"
+               "[[foo([[]])]] [[nodiscard]] int g(int &i);\n"
+               "[[nodiscard]] inline int f(int &i) {\n"
+               "  i = 1;\n"
+               "  return 0;\n"
+               "}\n"
+               "[[foo([[]])]] [[nodiscard]] int g(int &i) {\n"
+               "  i = 0;\n"
+               "  return 1;\n"
+               "}",
+               Code, Style);
+
+  Style.BreakAfterAttributes = FormatStyle::ABS_Always;
+  verifyFormat("[[nodiscard]]\n"
+               "inline int f(int &i);\n"
+               "[[foo([[]])]] [[nodiscard]]\n"
+               "int g(int &i);\n"
+               "[[nodiscard]]\n"
+               "inline int f(int &i) {\n"
+               "  i = 1;\n"
+               "  return 0;\n"
+               "}\n"
+               "[[foo([[]])]] [[nodiscard]]\n"
+               "int g(int &i) {\n"
+               "  i = 0;\n"
+               "  return 1;\n"
+               "}",
+               Code, Style);
+
+  Style.BreakAfterAttributes = FormatStyle::ABS_Leave;
+  EXPECT_EQ(Code, format(Code, Style));
+}
+
 } // namespace
 } // namespace format
 } // namespace clang