clang-format: Fix namespace end comments for namespaces with attributes and macros

[thakis]

Summary

Fixes PR39247.

While here, also make C++20 namespace A::inline B::inline C nested
inline namespaced definitions work.

Before:

#define DEPRECATE_WOOF [[deprecated("meow")]]

namespace DEPRECATE_WOOF woof {
void f() {}
} // namespace DEPRECATE_WOOFwoof

namespace [[deprecated("meow")]] woof {
  void f() {}
} // namespace [[deprecated("meow")]]woof

namespace woof::inline bark {
  void f() {}
} // namespace woof::inlinebark

Now:

#define DEPRECATE_WOOF [[deprecated("meow")]]

namespace DEPRECATE_WOOF woof {
void f() {}
} // namespace woof

namespace [[deprecated("meow")]] woof {
void f() {}
} // namespace woof

namespace woof::inline bark {
void f() {}
} // namespace woof::inline bark

(In addition to the fixed namespace end comments, also note the correct
indent of the namespace contents.)

[klimek]

LG, thx!

cfe/trunk/lib/Format/NamespaceEndCommentsFixer.cpp

 std::string computeName(const FormatToken *NamespaceTok) {
   assert(NamespaceTok &&
          NamespaceTok->isOneOf(tok::kw_namespace, TT_NamespaceMacro) &&
          "expecting a namespace token");
   std::string name = "";
   const FormatToken *Tok = NamespaceTok->getNextNonComment();
   if (NamespaceTok->is(TT_NamespaceMacro)) {
     // Collects all the non-comment tokens between opening parenthesis
-    // and closing parenthesis or comma
+    // and closing parenthesis or comma.
     assert(Tok && Tok->is(tok::l_paren) && "expected an opening parenthesis");
     Tok = Tok->getNextNonComment();
     while (Tok && !Tok->isOneOf(tok::r_paren, tok::comma)) {
       name += Tok->TokenText;
       Tok = Tok->getNextNonComment();
     }
   } else {
-    // Collects all the non-comment tokens between 'namespace' and '{'.
+    // For `namespace [[foo]] A::B::inline C {` or
+    // `namespace MACRO1 MACRO2 A::B::inline C {`, returns "A::B::inline C".
+    // Peek for the first '::' (or '{') and then return all tokens from one
+    // token before that up until the '{'.
+    const FormatToken *FirstNSTok = Tok;
+    while (Tok && !Tok->is(tok::l_brace) && !Tok->is(tok::coloncolon)) {
+      FirstNSTok = Tok;
+      Tok = Tok->getNextNonComment();
+    }
+
+    Tok = FirstNSTok;
     while (Tok && !Tok->is(tok::l_brace)) {
       name += Tok->TokenText;
+      if (Tok->is(tok::kw_inline))
+        name += " ";
       Tok = Tok->getNextNonComment();
     }
   }
   return name;
 }
 
 std::string computeEndCommentText(StringRef NamespaceName, bool AddNewline,
                                   const FormatToken *NamespaceTok) {

cfe/trunk/lib/Format/UnwrappedLineParser.cpp

void UnwrappedLineParser::parseNamespace() {
   assert(FormatTok->isOneOf(tok::kw_namespace, TT_NamespaceMacro) &&
          "'namespace' expected");
 
   const FormatToken &InitialToken = *FormatTok;
   nextToken();
   if (InitialToken.is(TT_NamespaceMacro)) {
     parseParens();
   } else {
-    while (FormatTok->isOneOf(tok::identifier, tok::coloncolon))
+    while (FormatTok->isOneOf(tok::identifier, tok::coloncolon, tok::kw_inline,
+                              tok::l_square)) {
+      if (FormatTok->is(tok::l_square))
+        parseSquare();
+      else
         nextToken();
     }
+  }
   if (FormatTok->Tok.is(tok::l_brace)) {
     if (ShouldBreakBeforeBrace(Style, InitialToken))
       addUnwrappedLine();
 
     bool AddLevel = Style.NamespaceIndentation == FormatStyle::NI_All ||
                     (Style.NamespaceIndentation == FormatStyle::NI_Inner &&
                      DeclarationScopeStack.size() > 1);
     parseBlock(/*MustBeDeclaration=*/true, AddLevel);

cfe/trunk/unittests/Format/FormatTest.cpp

TEST_F(FormatTest, FormatsNamespaces) {
   FormatStyle LLVMWithNoNamespaceFix = getLLVMStyle();
   LLVMWithNoNamespaceFix.FixNamespaceComments = false;
 
   verifyFormat("namespace some_namespace {\n"
                "class A {};\n"
                "void f() { f(); }\n"
                "}",
                LLVMWithNoNamespaceFix);
+  verifyFormat("namespace N::inline D {\n"
+               "class A {};\n"
+               "void f() { f(); }\n"
+               "}",
+               LLVMWithNoNamespaceFix);
+  verifyFormat("namespace N::inline D::E {\n"
+               "class A {};\n"
+               "void f() { f(); }\n"
+               "}",
+               LLVMWithNoNamespaceFix);
+  verifyFormat("namespace [[deprecated(\"foo[bar\")]] some_namespace {\n"
+               "class A {};\n"
+               "void f() { f(); }\n"
+               "}",
+               LLVMWithNoNamespaceFix);
   verifyFormat("/* something */ namespace some_namespace {\n"
                "class A {};\n"
                "void f() { f(); }\n"
                "}",
                LLVMWithNoNamespaceFix);
   verifyFormat("namespace {\n"
                "class A {};\n"
                "void f() { f(); }\n"

cfe/trunk/unittests/Format/NamespaceEndCommentsFixerTest.cpp

TEST_F(NamespaceEndCommentsFixerTest, AddsEndComment) {
   EXPECT_EQ("inline namespace A {\n"
             "int i;\n"
             "int j;\n"
             "}// namespace A",
             fixNamespaceEndComments("inline namespace A {\n"
                                     "int i;\n"
                                     "int j;\n"
                                     "}"));
+
+  EXPECT_EQ("namespace [[deprecated(\"foo\")]] A::B {\n"
+            "int i;\n"
+            "int j;\n"
+            "}// namespace A::B",
+            fixNamespaceEndComments("namespace [[deprecated(\"foo\")]] A::B {\n"
+                                    "int i;\n"
+                                    "int j;\n"
+                                    "}"));
+
+  EXPECT_EQ("namespace [[deprecated(\"foo\")]] A::inline B::inline C {\n"
+            "int i;\n"
+            "int j;\n"
+            "}// namespace A::inline B::inline C",
+            fixNamespaceEndComments(
+                "namespace [[deprecated(\"foo\")]] A::inline B::inline C {\n"
+                "int i;\n"
+                "int j;\n"
+                "}"));
+
+  EXPECT_EQ("namespace DEPRECATED A::B {\n"
+            "int i;\n"
+            "int j;\n"
+            "}// namespace A::B",
+            fixNamespaceEndComments("namespace DEPRECATED A::B {\n"
+                                    "int i;\n"
+                                    "int j;\n"
+                                    "}"));
+
+  EXPECT_EQ("inline namespace [[deprecated]] A {\n"
+            "int i;\n"
+            "int j;\n"
+            "}// namespace A",
+            fixNamespaceEndComments("inline namespace [[deprecated]] A {\n"
+                                    "int i;\n"
+                                    "int j;\n"
+                                    "}"));
+
   EXPECT_EQ("namespace ::A {\n"
             "int i;\n"
             "int j;\n"
             "}// namespace ::A",
             fixNamespaceEndComments("namespace ::A {\n"
                                     "int i;\n"
                                     "int j;\n"
                                     "}"));
EXPECT_EQ("namespace A {\n"
             "};",
             fixNamespaceEndComments("namespace A {\n"
                                     "int i;\n"
                                     "};",
                                     // The range (16, 3) spans the 'int' above.
                                     /*Ranges=*/{1, tooling::Range(16, 3)}));
 }
 
-TEST_F(NamespaceEndCommentsFixerTest, DoesNotAddCommentAfterRBraceInPPDirective) {
+TEST_F(NamespaceEndCommentsFixerTest,
+       DoesNotAddCommentAfterRBraceInPPDirective) {
   EXPECT_EQ("#define SAD \\\n"
             "namespace A { \\\n"
             "int i; \\\n"
             "}",
             fixNamespaceEndComments("#define SAD \\\n"
                                     "namespace A { \\\n"
                                     "int i; \\\n"
                                     "}"));