[clang-format] AlignConsecutiveDeclarations fails with attributes

[MyDeveloperDay]

Summary

Addresses http://llvm.org/PR40418

When using AlignConsecutiveDeclarations: true

variables with Attributes would not be aligned correctly

void f(int  extremlylongparameternamexxxxxxxx1,
       long extremlylongparameternamexxxxxxxx2,
       int[[clang::nodiscard]] extremlylongparameternamexxxxxxxx3,
       int __attribute__((clang::nodiscard)) extremlylongparameternamexxxxxxxx4) {
  int           a;
  unsigned long b;
  int[[clang::nodiscard]] c;
  int __attribute__((clang::nodiscard)) d;
}

following this change, both parameters and variables with attributes will be aligned (space permitting)

void f(int              extremlylongparameternamexxxxxxxx1,
       long             extremlylongparameternamexxxxxxxx2,
       int              [[clang::nodiscard]] extremlylongparameternamexxxxxxxx3,
       int __attribute__((clang::nodiscard)) extremlylongparameternamexxxxxxxx4) {
  int              a;
  unsigned long    b;
  int              [[clang::nodiscard]] c;
  int __attribute__((clang::nodiscard)) d;
}

[klimek]

clang/lib/Format/WhitespaceManager.cpp

468

Can you add a comment explaining the newly added startsSequences, or perhaps even pull out a function?

clang/lib/Format/WhitespaceManager.cpp

 //===----------------------------------------------------------------------===//
 
 #include "WhitespaceManager.h"
 #include "llvm/ADT/STLExtras.h"
 
 namespace clang {
 namespace format {
 
-bool WhitespaceManager::Change::IsBeforeInFile::
-operator()(const Change &C1, const Change &C2) const {
+bool WhitespaceManager::Change::IsBeforeInFile::operator()(
+    const Change &C1, const Change &C2) const {
   return SourceMgr.isBeforeInTranslationUnit(
       C1.OriginalWhitespaceRange.getBegin(),
       C2.OriginalWhitespaceRange.getBegin());
 }
 
 WhitespaceManager::Change::Change(const FormatToken &Tok,
                                   bool CreateReplacement,
                                   SourceRange OriginalWhitespaceRange,
void WhitespaceManager::alignConsecutiveDeclarations() {
   //   SomeVeryLongType const& v3;
   AlignTokens(
       Style,
       [](Change const &C) {
         // tok::kw_operator is necessary for aligning operator overload
         // definitions.
         return C.Tok->is(TT_StartOfName) ||
                C.Tok->is(TT_FunctionDeclarationName) ||
+               C.Tok->startsSequence(
+                   tok::l_paren, tok::l_paren, tok::identifier, tok::coloncolon,
+                   tok::identifier, tok::r_paren, tok::r_paren) ||
+               C.Tok->startsSequence(tok::l_square, tok::l_square,
+                                     tok::identifier, tok::coloncolon,
+                                     tok::identifier, tok::r_square,
+                                     tok::r_square) ||
+               C.Tok->startsSequence(tok::l_square, tok::l_square,
+                                     tok::identifier, tok::r_square,
+                                     tok::r_square) ||
+               C.Tok->startsSequence(tok::l_paren, tok::l_paren,
+                                     tok::identifier, tok::r_paren,
+                                     tok::r_paren) ||
                C.Tok->is(tok::kw_operator);
       },
       Changes, /*StartAt=*/0);
 }
 
 void WhitespaceManager::alignTrailingComments() {
   unsigned MinColumn = 0;
   unsigned MaxColumn = UINT_MAX;

clang/unittests/Format/FormatTest.cpp

TEST_F(FormatTest, AlignConsecutiveDeclarations) {
 
   // See llvm.org/PR35641
   Alignment.AlignConsecutiveDeclarations = true;
   verifyFormat("int func() { //\n"
                "  int      b;\n"
                "  unsigned c;\n"
                "}",
                Alignment);
+
+  // See llvm.org/PR40418
+  verifyFormat(
+      "void f(int              extremlylongparameternamexxxxxxxx1,\n"
+      "       long             extremlylongparameternamexxxxxxxx2,\n"
+      "       int              [[a::b]] extremlylongparameternamexxxxxxxx3,\n"
+      "       int __attribute__((a::b)) extremlylongparameternamexxxxxxxx4) "
+      "{}\n",
+      Alignment);
+
+  verifyFormat("void f(int              extremlylongparameternamexxxxxxxx1,\n"
+               "       long             extremlylongparameternamexxxxxxxx2,\n"
+               "       int              [[deprecated]] "
+               "extremlylongparameternamexxxxxxxx3,\n"
+               "       int __attribute__((deprecated)) "
+               "extremlylongparameternamexxxxxxxx4) "
+               "{}\n",
+               Alignment);
+
+  verifyFormat("int              a;\n"
+               "unsigned long    b;\n"
+               "int __attribute__((a::b)) d;\n"
+               "int              [[a::b]] c;\n"
+               "int __attribute__((a::b)) e;\n"
+               "int __attribute__((depreciated)) f;\n"
+               "int __attribute__((aligned(16))) g;\n",
+               Alignment);
+
+  verifyFormat("int              a;\n"
+               "unsigned long    b;\n"
+               "int __attribute__((a::b)) d;\n"
+               "int              [[deprecated]] c;\n"
+               "int __attribute__((a::b)) e;\n",
+               Alignment);
+
+  verifyFormat("int              a;\n"
+               "unsigned long    b;\n"
+               "int __attribute__((deprecated)) de;\n"
+               "int              [[deprecated]] c;\n"
+               "int __attribute__((a::b)) e;\n",
+               Alignment);
 }
 
 TEST_F(FormatTest, LinuxBraceBreaking) {
   FormatStyle LinuxBraceStyle = getLLVMStyle();
   LinuxBraceStyle.BreakBeforeBraces = FormatStyle::BS_Linux;
   verifyFormat("namespace a\n"
                "{\n"
                "class A\n"