[clang-format] Fix QualifierAlignment with global namespace qualified types.

[curdeius]

Summary

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

[curdeius]

If you can think of other cases that may misbehave, I'll be happy to test (and fix) these.

[MyDeveloperDay]

Brilliant thank you, LGTM

clang/lib/Format/QualifierAlignmentFixer.cpp

const FormatToken *LeftRightQualifierAlignmentFixer::analyzeRight(
   if (!Tok->is(QualifierType))
     return Tok;
   // Don't concern yourself if nothing follows the qualifier.
   if (!Tok->Next)
     return Tok;
   if (LeftRightQualifierAlignmentFixer::isPossibleMacro(Tok->Next))
     return Tok;
 
+  auto AnalyzeTemplate =
+      [&](const FormatToken *Tok,
+          const FormatToken *StartTemplate) -> const FormatToken * {
+    // Read from the TemplateOpener to TemplateCloser.
+    FormatToken *EndTemplate = StartTemplate->MatchingParen;
+    if (EndTemplate) {
+      // Move to the end of any template class members e.g.
+      // `Foo<int>::iterator`.
+      if (EndTemplate->startsSequence(TT_TemplateCloser, tok::coloncolon,
+                                      tok::identifier)) {
+        EndTemplate = EndTemplate->Next->Next;
+      }
+    }
+    if (EndTemplate && EndTemplate->Next &&
+        !EndTemplate->Next->isOneOf(tok::equal, tok::l_paren)) {
+      insertQualifierAfter(SourceMgr, Fixes, EndTemplate, Qualifier);
+      // Remove the qualifier.
+      removeToken(SourceMgr, Fixes, Tok);
+      return Tok;
+    }
+    return nullptr;
+  };
+
   FormatToken *Qual = Tok->Next;
   FormatToken *LastQual = Qual;
   while (Qual && isQualifierOrType(Qual, ConfiguredQualifierTokens)) {
     LastQual = Qual;
     Qual = Qual->Next;
   }
   if (LastQual && Qual != LastQual) {
     rotateTokens(SourceMgr, Fixes, Tok, LastQual, /*Left=*/false);
     Tok = LastQual;
   } else if (Tok->startsSequence(QualifierType, tok::identifier,
                                  TT_TemplateCloser)) {
     FormatToken *Closer = Tok->Next->Next;
     rotateTokens(SourceMgr, Fixes, Tok, Tok->Next, /*Left=*/false);
     Tok = Closer;
     return Tok;
   } else if (Tok->startsSequence(QualifierType, tok::identifier,
                                  TT_TemplateOpener)) {
-    // Read from the TemplateOpener to
-    // TemplateCloser as in const ArrayRef<int> a; const ArrayRef<int> &a;
-    FormatToken *EndTemplate = Tok->Next->Next->MatchingParen;
-    if (EndTemplate) {
-      // Move to the end of any template class members e.g.
-      // `Foo<int>::iterator`.
-      if (EndTemplate->startsSequence(TT_TemplateCloser, tok::coloncolon,
-                                      tok::identifier)) {
-        EndTemplate = EndTemplate->Next->Next;
-      }
-    }
-    if (EndTemplate && EndTemplate->Next &&
-        !EndTemplate->Next->isOneOf(tok::equal, tok::l_paren)) {
-      insertQualifierAfter(SourceMgr, Fixes, EndTemplate, Qualifier);
-      // Remove the qualifier.
-      removeToken(SourceMgr, Fixes, Tok);
-      return Tok;
-    }
-  } else if (Tok->startsSequence(QualifierType, tok::identifier)) {
+    // `const ArrayRef<int> a;`
+    // `const ArrayRef<int> &a;`
+    const FormatToken *NewTok = AnalyzeTemplate(Tok, Tok->Next->Next);
+    if (NewTok)
+      return NewTok;
+  } else if (Tok->startsSequence(QualifierType, tok::coloncolon,
+                                 tok::identifier, TT_TemplateOpener)) {
+    // `const ::ArrayRef<int> a;`
+    // `const ::ArrayRef<int> &a;`
+    const FormatToken *NewTok = AnalyzeTemplate(Tok, Tok->Next->Next->Next);
+    if (NewTok)
+      return NewTok;
+  } else if (Tok->startsSequence(QualifierType, tok::identifier) ||
+             Tok->startsSequence(QualifierType, tok::coloncolon,
     FormatToken *Next = Tok->Next;
     // The case  `const Foo` -> `Foo const`
+    // The case  `const ::Foo` -> `::Foo const`
     // The case  `const Foo *` -> `Foo const *`
     // The case  `const Foo &` -> `Foo const &`
     // The case  `const Foo &&` -> `Foo const &&`
     // The case  `const std::Foo &&` -> `std::Foo const &&`
     // The case  `const std::Foo<T> &&` -> `std::Foo<T> const &&`
     while (Next && Next->isOneOf(tok::identifier, tok::coloncolon))
       Next = Next->Next;
     if (Next && Next->is(TT_TemplateOpener)) {
if (Tok->Next->Next && Tok->Next->Next->isOneOf(tok::identifier, tok::star,
       Tok = Closer;
     }
   }
   if (Tok->is(TT_TemplateOpener) && Tok->Next &&
       (Tok->Next->is(tok::identifier) || Tok->Next->isSimpleTypeSpecifier()) &&
       Tok->Next->Next && Tok->Next->Next->is(QualifierType)) {
     rotateTokens(SourceMgr, Fixes, Tok->Next, Tok->Next->Next, /*Left=*/true);
   }
-  if (Tok->startsSequence(tok::identifier) && Tok->Next) {
+  if ((Tok->startsSequence(tok::coloncolon, tok::identifier) ||
+       Tok->is(tok::identifier)) &&
+      Tok->Next) {
     if (Tok->Previous &&
         Tok->Previous->isOneOf(tok::star, tok::ampamp, tok::amp)) {
       return Tok;
     }
     const FormatToken *Next = Tok->Next;
     // The case  `std::Foo<T> const` -> `const std::Foo<T> &&`
     while (Next && Next->isOneOf(tok::identifier, tok::coloncolon))
       Next = Next->Next;

clang/unittests/Format/QualifierFixerTest.cpp

TEST_F(QualifierFixerTest, RightQualifier) {
   verifyFormat("unsigned char const *a;", "const unsigned char *a;", Style);
   verifyFormat("vector<int, int const, int &, int const &> args1",
                "vector<int, const int, int &, const int &> args1", Style);
   verifyFormat("unsigned int const &get_nu() const",
                "const unsigned int &get_nu() const", Style);
   verifyFormat("Foo<int> const &a", "const Foo<int> &a", Style);
   verifyFormat("Foo<int>::iterator const &a", "const Foo<int>::iterator &a",
                Style);
+  verifyFormat("::Foo<int>::iterator const &a", "const ::Foo<int>::iterator &a",
+               Style);
 
   verifyFormat("Foo(int a, "
                "unsigned b, // c-style args\n"
                "    Bar const &c);",
                "Foo(int a, "
                "unsigned b, // c-style args\n"
                "    const Bar &c);",
                Style);
TEST_F(QualifierFixerTest, RightQualifier) {
   verifyFormat("Foo<Foo<int>> const *p;", "const Foo<Foo<int>> *p;", Style);
   verifyFormat(
       "Foo<Foo<int>> const *p = const_cast<Foo<Foo<int>> const *>(&ffi);",
       "const Foo<Foo<int>> *p = const_cast<const Foo<Foo<int>> *>(&ffi);",
       Style);
 
   verifyFormat("void fn(Foo<T> const &i);", "void fn(const Foo<T> &i);", Style);
   verifyFormat("void fns(ns::S const &s);", "void fns(const ns::S &s);", Style);
+  verifyFormat("void fns(::ns::S const &s);", "void fns(const ::ns::S &s);",
+               Style);
   verifyFormat("void fn(ns::Foo<T> const &i);", "void fn(const ns::Foo<T> &i);",
                Style);
   verifyFormat("void fns(ns::ns2::S const &s);",
                "void fns(const ns::ns2::S &s);", Style);
   verifyFormat("void fn(ns::Foo<Bar<T>> const &i);",
                "void fn(const ns::Foo<Bar<T>> &i);", Style);
   verifyFormat("void fn(ns::ns2::Foo<Bar<T>> const &i);",
                "void fn(const ns::ns2::Foo<Bar<T>> &i);", Style);
TEST_F(QualifierFixerTest, LeftQualifier) {
   verifyFormat("const char a[];", Style);
   verifyFormat("const auto v = get_value();", Style);
   verifyFormat("const long long &a;", Style);
   verifyFormat("const unsigned char *a;", Style);
   verifyFormat("const unsigned char *a;", "unsigned char const *a;", Style);
   verifyFormat("const Foo<int> &a", "Foo<int> const &a", Style);
   verifyFormat("const Foo<int>::iterator &a", "Foo<int>::iterator const &a",
                Style);
+  verifyFormat("const ::Foo<int>::iterator &a", "::Foo<int>::iterator const &a",
+               Style);
 
   verifyFormat("const int a;", "int const a;", Style);
   verifyFormat("const int *a;", "int const *a;", Style);
   verifyFormat("const int &a;", "int const &a;", Style);
   verifyFormat("foo(const int &a)", "foo(int const &a)", Style);
   verifyFormat("unsigned char *a;", "unsigned char *a;", Style);
   verifyFormat("const unsigned int &get_nu() const",
                "unsigned int const &get_nu() const", Style);
TEST_F(QualifierFixerTest, LeftQualifier) {
   verifyFormat("const Foo<Foo<int>> *p;", "Foo<Foo<int>> const *p;", Style);
   verifyFormat(
       "const Foo<Foo<int>> *p = const_cast<const Foo<Foo<int>> *>(&ffi);",
       "const Foo<Foo<int>> *p = const_cast<Foo<Foo<int>> const *>(&ffi);",
       Style);
 
   verifyFormat("void fn(const Foo<T> &i);", "void fn(Foo<T> const &i);", Style);
   verifyFormat("void fns(const ns::S &s);", "void fns(ns::S const &s);", Style);
+  verifyFormat("void fns(const ::ns::S &s);", "void fns(::ns::S const &s);",
+               Style);
   verifyFormat("void fn(const ns::Foo<T> &i);", "void fn(ns::Foo<T> const &i);",
                Style);
   verifyFormat("void fns(const ns::ns2::S &s);",
                "void fns(ns::ns2::S const &s);", Style);
   verifyFormat("void fn(const ns::Foo<Bar<T>> &i);",
                "void fn(ns::Foo<Bar<T>> const &i);", Style);
   verifyFormat("void fn(const ns::ns2::Foo<Bar<T>> &i);",
                "void fn(ns::ns2::Foo<Bar<T>> const &i);", Style);