[clang-format] Parse double-square attributes as pointer qualifiers

[arichardson]

Summary

Before: x = (foo *[[clang::attr]]) * v;
After: x = (foo *[[clang::attr]])*v;

[arichardson]

drop unnecesssary const

[aaron.ballman]

clang/unittests/Format/FormatTest.cpp

8071

Can you also add a test case for an attribute with an argument list, e.g.,

MACRO(A *[[clang::attr("foobar")]] a);

8141

Same for the casting case.

[arichardson]

add test case with argument

[aaron.ballman]

LGTM!

clang/lib/Format/TokenAnnotator.cpp

auto IsQualifiedPointerOrReference = [](FormatToken *T) {
       while (T) {
         if (T->is(TT_AttributeParen)) {
           // Handle `x = (foo *__attribute__((foo)))&v;`:
           if (T->MatchingParen && T->MatchingParen->Previous &&
               T->MatchingParen->Previous->is(tok::kw___attribute)) {
             T = T->MatchingParen->Previous->Previous;
             continue;
           }
+        } else if (T->is(TT_AttributeSquare)) {
+          // Handle `x = (foo *[[clang::foo]])&v;`:
+          if (T->MatchingParen && T->MatchingParen->Previous) {
+            T = T->MatchingParen->Previous;
+            continue;
+          }
         } else if (T->canBePointerOrReferenceQualifier()) {
           T = T->Previous;
           continue;
         }
         break;
       }
       return T && T->is(TT_PointerOrReference);
     };

clang/unittests/Format/FormatTest.cpp

TEST_F(FormatTest, UnderstandsUsesOfStarAndAmp) {
   verifyIndependentOfContext("MACRO(A *volatile a);");
   verifyIndependentOfContext("MACRO(A *__volatile a);");
   verifyIndependentOfContext("MACRO(A *__volatile__ a);");
   verifyIndependentOfContext("MACRO(A *_Nonnull a);");
   verifyIndependentOfContext("MACRO(A *_Nullable a);");
   verifyIndependentOfContext("MACRO(A *_Null_unspecified a);");
   verifyIndependentOfContext("MACRO(A *__attribute__((foo)) a);");
   verifyIndependentOfContext("MACRO(A *__attribute((foo)) a);");
+  verifyIndependentOfContext("MACRO(A *[[clang::attr]] a);");
   verifyIndependentOfContext("MACRO('0' <= c && c <= '9');");
   verifyFormat("void f() { f(float{1}, a * a); }");
   // FIXME: Is there a way to make this work?
   // verifyIndependentOfContext("MACRO(A *a);");
 
   verifyFormat("DatumHandle const *operator->() const { return input_; }");
   verifyFormat("return options != nullptr && operator==(*options);");
 
TEST_F(FormatTest, UnderstandsPointerQualifiersInCast) {
   verifyFormat("x = (foo *const)*v;");
   verifyFormat("x = (foo *volatile)*v;");
   verifyFormat("x = (foo *restrict)*v;");
   verifyFormat("x = (foo *__attribute__((foo)))*v;");
   verifyFormat("x = (foo *_Nonnull)*v;");
   verifyFormat("x = (foo *_Nullable)*v;");
   verifyFormat("x = (foo *_Null_unspecified)*v;");
   verifyFormat("x = (foo *_Nonnull)*v;");
+  verifyFormat("x = (foo *[[clang::attr]])*v;");
 
   // Check that we handle multiple trailing qualifiers and skip them all to
   // determine that the expression is a cast to a pointer type.
   FormatStyle LongPointerRight = getLLVMStyleWithColumns(999);
   FormatStyle LongPointerLeft = getLLVMStyleWithColumns(999);
   LongPointerLeft.PointerAlignment = FormatStyle::PAS_Left;
-  StringRef AllQualifiers = "const volatile restrict __attribute__((foo)) "
-                            "_Nonnull _Null_unspecified _Nonnull";
+  StringRef AllQualifiers =
+      "const volatile restrict __attribute__((foo)) _Nonnull _Null_unspecified "
+      "_Nonnull [[clang::attr]]";
   verifyFormat(("x = (foo *" + AllQualifiers + ")*v;").str(), LongPointerRight);
   verifyFormat(("x = (foo* " + AllQualifiers + ")*v;").str(), LongPointerLeft);
 
   // Also check that address-of is not parsed as a binary bitwise-and:
   verifyFormat("x = (foo *const)&v;");
   verifyFormat(("x = (foo *" + AllQualifiers + ")&v;").str(), LongPointerRight);
   verifyFormat(("x = (foo* " + AllQualifiers + ")&v;").str(), LongPointerLeft);
 }