[clang-format] Improve QualifierAlignment

[AlexanderHederstaf]

Summary

Qualifiers were not moved for non-pointer non-simple types.
Add additional support for many special cases such as templates,
requires clauses, long qualified names.

Fixes https://github.com/llvm/llvm-project/issues/57154 and
https://github.com/llvm/llvm-project/issues/60898

[AlexanderHederstaf]

I tried to refactor QualifierAlignmentFixer to handle more types, notably removing the *,&,&& requirement as e.g. const Foo did not work. To avoid moving qualifiers too far, a test for "already east const" is introduced. However, to get the correct order for the east qualifiers Clang-Format must be used twice. I assume it's related to how fixes/replacements are handled. Would you like to have a look and perhaps suggest any improvements?

As it must be used twice, some tests related to volatile/const order fail, but I noticed most of them would also fails previously if the type is not simple.

[MyDeveloperDay]

Can you please add unit tests for the cases you added, can you please add a link to the github issue you are trying to resolve, or log one if there isn't one.

Also all the existing tests need to pass, otherwise its a mute point.

When I added this, I knew that there were limitations, there is just sometimes things that can't be determined and so to air on the side of caution we don't fixup those

but please bring specific examples to the table so we can review them

[AlexanderHederstaf]

I will add new tests / examples as well as look into the volatile/const ordering.

[AlexanderHederstaf]

Fixed the const/volatile placement. Added a few tests.

[AlexanderHederstaf]

Add test with advanced type that would not work before.
Add pointer to member.

[HazardyKnusperkeks]

In D144709#4149737, @AlexanderHederstaf wrote:

I tried to refactor QualifierAlignmentFixer to handle more types, notably removing the *,&,&& requirement as e.g. const Foo did not work. To avoid moving qualifiers too far, a test for "already east const" is introduced. However, to get the correct order for the east qualifiers Clang-Format must be used twice. I assume it's related to how fixes/replacements are handled. Would you like to have a look and perhaps suggest any improvements?

As it must be used twice, some tests related to volatile/const order fail, but I noticed most of them would also fails previously if the type is not simple.

Highlight by me. That is not acceptable, running the output of clang-format through clang-format shall not result in any change. In that case it's better to not touch it in any way.

clang/lib/Format/QualifierAlignmentFixer.cpp

293

In the initial commit concerns were raised that East and West are westcentric terms and should not be used. Thus you should stick here to Left and Right the same terms we use in the configuration.

295

Could you add comments what kind of source code we would have here?

296

No else after return.

297

That may be null, or not?

[AlexanderHederstaf]

Highlight by me. That is not acceptable, running the output of clang-format through clang-format shall not result in any change. In that case it's better to not touch it in any way.

That is no longer an issue in the latest patch.

[rymiel]

just as a heads up, I'm applying https://reviews.llvm.org/D144537 since it's a quick bug fix; this patch *would* replace that one, but may need more time. (also conflicts may appear)

[AlexanderHederstaf]

Add comments for different cases.
Add more tests.
Fix whitespace issue.

[AlexanderHederstaf]

Thanks for the review so far!

Passes all tests and works in one shot on my test files as well as 3k+ files repository, i.e. it does not have to be run twice.

As one use-case of this rule is to be able to checkout code and freely swap between left/right. Then the left alignment would also need to handle the same cases as right alignment.

I should also make templates with requires work, though I am not familiar with the variations that syntax may have.

@rymiel Good, this might take a few more iterations.

clang/lib/Format/QualifierAlignmentFixer.cpp

293

Replaced with right/left

295

Added comments for the different source code we may have.

296

removed 'else' preceeding return.

297

I assumed that if the token is identified as a template closer then there will exist an opener. As far as I am aware, something must preceed that opener.

[MyDeveloperDay]

when I originally did this work, I checked out the whole fresh area of LLVM and applied the both east then back to west const and built both to ensure I didn't break anything. Please ensure you do the same, I'm going to be honest you are changing it massively, I'm going to need some time to understand the changes.

[MyDeveloperDay]

can you rebase please

[HazardyKnusperkeks]

In D144709#4151546, @AlexanderHederstaf wrote:

Highlight by me. That is not acceptable, running the output of clang-format through clang-format shall not result in any change. In that case it's better to not touch it in any way.

That is no longer an issue in the latest patch.

Great!

Please mark comments as done.

In D144709#4152393, @MyDeveloperDay wrote:

when I originally did this work, I checked out the whole fresh area of LLVM and applied the both east then back to west const and built both to ensure I didn't break anything. Please ensure you do the same, I'm going to be honest you are changing it massively, I'm going to need some time to understand the changes.

From my point this looks okay, but I did not look very deeply into it, I'll let @MyDeveloperDay do that.

clang/lib/Format/QualifierAlignmentFixer.cpp

252–253

clang-format did wrap your comment ;)

297

Then please add an assertion. So we would get a nice message if your assumption is wrong.

[AlexanderHederstaf]

Rebase after change to pointer to member was merged.
Add case for typename used for nested dependent names.
Add assertions for template closers/openers.

Add commented-out tests for two cases where right to left
produces code that does not compile.

[AlexanderHederstaf]

Fixed comments and rebased. Tested right to left on the output of left to right and discovered two cases where the output code would not compile. Added new tests for those cases and I am working on improvements for right to left.

clang/lib/Format/QualifierAlignmentFixer.cpp

252–253

Re-arranged the comments.

297

Added assertions.

[AlexanderHederstaf]

Fix simple types not moving all the way right.

[AlexanderHederstaf]

Update right to left analyzer
Add support for requires clauses
Ignore usages of struct/class keyword

Add new, and uncomment old tests
Fix invalid tests with 'const Foo b* const;'

[AlexanderHederstaf]

There are a lot of complicated cases when trying to extend this functionality. I addressed a few more and thought that it might be acceptable to avoid adjusting the qualifiers for variable declared as

struct Foo const; -> const struct Foo;
const struct Foo; -> struct Foo const;

const struct {
  int a;
} foo = {5};
 -> 
struct {
  int a;
} const foo = {5};

as they are difficult to distinguish from

const struct Foo {
  int a;
} foo = {5};

where this is not valid code

struct const Foo {
  int a;
} foo = {5};
struct Foo const {
  int a;
} foo = {5};

I have still not tested left->right->left on the llvm codebase, I'll update you when it's done.

[AlexanderHederstaf]

Update commit message

[AlexanderHederstaf]

Simplify insertQualifierAfter.
Ignore decltype, typeof, and _Atomic.
Set length of TT_TemplateCloser to 1.

[AlexanderHederstaf]

Discovered incorrect code generation for llvm/include/llvm/ADT/StringMap.h.

using base = StringMapIterBase<StringMapConstIterator<ValueTy>,
                               const StringMapEntry<ValueTy>>;

was converted to, removing two characters. I checked the Token length in InsertQualifierAfter and found that it was not 1. How should I proceed with this particular issue @MyDeveloperDay

using base = StringMapIterBase<StringMapConstIterator<ValueTy>,
                               StringMapEntry<ValueTy> const

I commited the change to SetLength(1) but that looks a bit much like a hack, perhaps anyone more familiar with the codebase can have a look at this issue.

[rymiel]

In D144709#4158555, @AlexanderHederstaf wrote:

Discovered incorrect code generation for llvm/include/llvm/ADT/StringMap.h.

using base = StringMapIterBase<StringMapConstIterator<ValueTy>,
                               const StringMapEntry<ValueTy>>;

was converted to, removing two characters. I checked the Token length in InsertQualifierAfter and found that it was not 1. How should I proceed with this particular issue @MyDeveloperDay

using base = StringMapIterBase<StringMapConstIterator<ValueTy>,
                               StringMapEntry<ValueTy> const

I commited the change to SetLength(1) but that looks a bit much like a hack, perhaps anyone more familiar with the codebase can have a look at this issue.

Looks like https://github.com/llvm/llvm-project/issues/56111

[MyDeveloperDay]

As tests currently fail can you set it to "planned changes" until they pass

[  FAILED  ] 5 tests, listed below:
[  FAILED  ] QualifierFixerTest.RightQualifier
[  FAILED  ] QualifierFixerTest.LeftQualifier
[  FAILED  ] QualifierFixerTest.ConstVolatileQualifiersOrder
[  FAILED  ] QualifierFixerTest.MoveConstBeyondType
[  FAILED  ] QualifierFixerTest.TemplatesRight

[AlexanderHederstaf]

Distinguish configured qualifiers from other qualifiers.

[AlexanderHederstaf]

This code from llvm/tools/llvm-exegesis/lib/SerialSnippetGenerator.cpp failed with Right but without a full list of specifiers. As static was not configured, the } was not discovered by IsRightQualifier. Changed some of the qualifier tests to check against the full list instead.

struct ExecutionClass {
  ExecutionMode Mask;
  const char *Description;
} static const kExecutionClasses[] = {
    {ExecutionMode::ALWAYS_SERIAL_IMPLICIT_REGS_ALIAS |
         ExecutionMode::ALWAYS_SERIAL_TIED_REGS_ALIAS,
     "Repeating a single implicitly serial instruction"},
    {ExecutionMode::SERIAL_VIA_EXPLICIT_REGS,
     "Repeating a single explicitly serial instruction"},
    {ExecutionMode::SERIAL_VIA_MEMORY_INSTR |
         ExecutionMode::SERIAL_VIA_NON_MEMORY_INSTR,
     "Repeating two instructions"},
};

Resulted in

} static kExecutionClasses const[] = {

Which is now fixed. This struct will be left unchanged as with other structs.

I used clang-format on all files in clang/ and llvm/, where I had added QualifierAlignment: Right to any .clang-format. I built with

cmake -S llvm -B build -G Ninja -DCMAKE_BUILD_TYPE=Release -DLLVM_ENABLE_PROJECTS="clang"
cmake --build build

Is that sufficient or did you imagine some other build?

[AlexanderHederstaf]

In D144709#4160820, @MyDeveloperDay wrote:

As tests currently fail can you set it to "planned changes" until they pass

[  FAILED  ] 5 tests, listed below:
[  FAILED  ] QualifierFixerTest.RightQualifier
[  FAILED  ] QualifierFixerTest.LeftQualifier
[  FAILED  ] QualifierFixerTest.ConstVolatileQualifiersOrder
[  FAILED  ] QualifierFixerTest.MoveConstBeyondType
[  FAILED  ] QualifierFixerTest.TemplatesRight

Tests should pass now, but how/where do I set that setting?

[AlexanderHederstaf]

Change order for typename and :: as
const typename ::Bar b; is valid code.

Add code for handling ::template.

[AlexanderHederstaf]

I used clang-format on all files in clang/ and llvm/, where I had added QualifierAlignment: Right to any .clang-format. I built with

cmake -S llvm -B build -G Ninja -DCMAKE_BUILD_TYPE=Release -DLLVM_ENABLE_PROJECTS="clang"
cmake --build build

Is that sufficient or did you imagine some other build?

Performed the test for
Original -> Right -> compiles
Right -> Left -> compiles

[HazardyKnusperkeks]

In D144709#4160940, @AlexanderHederstaf wrote:

In D144709#4160820, @MyDeveloperDay wrote:

As tests currently fail can you set it to "planned changes" until they pass

[  FAILED  ] 5 tests, listed below:
[  FAILED  ] QualifierFixerTest.RightQualifier
[  FAILED  ] QualifierFixerTest.LeftQualifier
[  FAILED  ] QualifierFixerTest.ConstVolatileQualifiersOrder
[  FAILED  ] QualifierFixerTest.MoveConstBeyondType
[  FAILED  ] QualifierFixerTest.TemplatesRight

Tests should pass now, but how/where do I set that setting?

Right down here where you post your reply. The "Add Action..." has "Plan Changes" to set the state.

[MyDeveloperDay]

Firstly let me say thank you for this review, your perseverance demonstrates to me that there is a desire to make this capability better, which tells me that a feature that ultimately took 1+ year to get landed in the first place was perhaps worth it. My hope is that these changes will help to further demonstrate that its ok for clang-format to make modifications (which was a major discussion point at the time it first landed)

From a personal perspective I feel you've heavily changed my original implementation quite a bit. ( Its ok I'm not precious ), but I feel you've commented this code nicely and I feel that likely this is now easier to read. For which I thank you.

I also appreciate the extensive testing and the efforts you've made to fix other issue that were ultimately contained originally.

I'm inclined to accept the revision , get it into trunk so it can live for sometime before the next branch. (i.e. it wouldn't land in mainstream releases until 17.0 which could be ~6 months away)

[AlexanderHederstaf]

Thanks for the comments and help on this review. There are a lot of special cases I had not considered before, and while it works on the clang/ and llvm/ subfolders as well as tests and the other repository I tested on, I suppose there could still be some hidden issues. Allowing any identifier without the requirement that it is a pointer type adds a lot of complexity.

It sounds good to close the existing issues, let this version live some time and watch out for new issues.

[rymiel]

This patch also fixes: https://github.com/llvm/llvm-project/issues/56111, https://github.com/llvm/llvm-project/issues/58696, and https://github.com/llvm/llvm-project/issues/54730 (some of those could probably be made duplicates but it seems they're all going down in one blow anyway)

In D144709#4165962, @MyDeveloperDay wrote:

Firstly let me say thank you for this review, your perseverance demonstrates to me that there is a desire to make this capability better

+1, I certainly wouldn't have such perseverance, which is why I stick to bug reports

[rymiel]

clang/unittests/Format/QualifierFixerTest.cpp

438

(see below)

730

This... isn't valid syntax? an opening < is missing.
Perhaps you could adapt https://github.com/llvm/llvm-project/issues/56111 into a test, it seems to be fixed by the patch, but there might still be corner-cases

[MyDeveloperDay]

In D144709#4169219, @rymiel wrote:

This patch also fixes: https://github.com/llvm/llvm-project/issues/56111, https://github.com/llvm/llvm-project/issues/58696, and https://github.com/llvm/llvm-project/issues/54730 (some of those could probably be made duplicates but it seems they're all going down in one blow anyway)

In D144709#4165962, @MyDeveloperDay wrote:

Firstly let me say thank you for this review, your perseverance demonstrates to me that there is a desire to make this capability better

+1, I certainly wouldn't have such perseverance, which is why I stick to bug reports

and @rymiel we thank you for those efforts too! it just as important.

[AlexanderHederstaf]

clang/unittests/Format/QualifierFixerTest.cpp

730

Right, I must've focused too much on the missing right >. What is the procedure now that the review is accepted. Can I still upload a fix to this and to include that issue in the tests?

[rymiel]

clang/unittests/Format/QualifierFixerTest.cpp

730

What is the procedure now that the review is accepted

No different to the usual! The patch will stay accepted, and reviewers can just re-approve anyways.

[AlexanderHederstaf]

Add extra tests based on https://github.com/llvm/llvm-project/issues/56111

[AlexanderHederstaf]

Missed right->left in the fix. Also looking a bit at comments, e.g.

ns::/*ns2::*/vector v;

[AlexanderHederstaf]

Handle /*c*/ comments inside types.
Add >> test to right->left.

[MyDeveloperDay]

I might have been tempted to handle the comments in a separate commit, I don't like to do too much in one go or the review gets hard to manage.

[AlexanderHederstaf]

In D144709#4171029, @MyDeveloperDay wrote:

I might have been tempted to handle the comments in a separate commit, I don't like to do too much in one go or the review gets hard to manage.

I had the same thought but as the comments change is not only an extension of the capability I included it to be safe. Without the change it would lead to code that doesn't compile.

[AlexanderHederstaf]

What is the next step in the process? Anything I should do?

[MyDeveloperDay]

In D144709#4188921, @AlexanderHederstaf wrote:

What is the next step in the process? Anything I should do?

If you have commit access you can go ahead and commit, if not and you want one of us to do it, we need your name and email address

[AlexanderHederstaf]

In D144709#4193603, @MyDeveloperDay wrote:

In D144709#4188921, @AlexanderHederstaf wrote:

What is the next step in the process? Anything I should do?

If you have commit access you can go ahead and commit, if not and you want one of us to do it, we need your name and email address

I don't have commit access. Please go ahead if you'd wish to do it for me. Should I share my email in some other forum than posting it in this comment section?

[HazardyKnusperkeks]

In D144709#4196738, @AlexanderHederstaf wrote:

In D144709#4193603, @MyDeveloperDay wrote:

In D144709#4188921, @AlexanderHederstaf wrote:

What is the next step in the process? Anything I should do?

If you have commit access you can go ahead and commit, if not and you want one of us to do it, we need your name and email address

I don't have commit access. Please go ahead if you'd wish to do it for me. Should I share my email in some other forum than posting it in this comment section?

It will be public on GitHub (and any fork), so you should choose one you are comfortable to share here. ;)
(And in contrast to some other lists where I put my mail, I didn't notice any more spam after becoming active here.)

[AlexanderHederstaf]

Okay thanks. If the + options works let's go with
[e-mail]

Thanks again for the review and answers.

clang/docs/ReleaseNotes.rst

 
 clang-format
 ------------
 
 - Add ``NextLineOnly`` style to option ``PackConstructorInitializers``.
   Compared to ``NextLine`` style, ``NextLineOnly`` style will not try to
   put the initializers on the current line first, instead, it will try to
   put the initializers on the next line only.
+- Add additional Qualifier Ordering support for special cases such
+  as templates, requires clauses, long qualified names.
 
 libclang
 --------
 
 - Introduced the new function ``clang_CXXMethod_isExplicit``,
   which identifies whether a constructor or conversion function cursor
   was marked with the explicit identifier.
 

clang/lib/Format/QualifierAlignmentFixer.h

public:
 
   const FormatToken *analyzeLeft(const SourceManager &SourceMgr,
                                  const AdditionalKeywords &Keywords,
                                  tooling::Replacements &Fixes,
                                  const FormatToken *Tok,
                                  const std::string &Qualifier,
                                  tok::TokenKind QualifierType);
 
-  // is the Token a simple or qualifier type
-  static bool isQualifierOrType(const FormatToken *Tok,
-                                const std::vector<tok::TokenKind> &Qualifiers);
+  // Is the Token a simple or qualifier type
+  static bool isQualifierOrType(const FormatToken *Tok);
+  static bool
+  isConfiguredQualifierOrType(const FormatToken *Tok,
 
-  // is the Token likely a Macro
+  // Is the Token likely a Macro
   static bool isPossibleMacro(const FormatToken *Tok);
 };
 
 } // end namespace format
 } // end namespace clang
 
 #endif

clang/lib/Format/QualifierAlignmentFixer.cpp

auto Range = CharSourceRange::getCharRange(First->getStartOfNonWhitespace(),
                                              First->Tok.getEndLoc());
   replaceToken(SourceMgr, Fixes, Range, "");
 }
 
 static void insertQualifierAfter(const SourceManager &SourceMgr,
                                  tooling::Replacements &Fixes,
                                  const FormatToken *First,
                                  const std::string &Qualifier) {
-  FormatToken *Next = First->Next;
-  if (!Next)
-    return;
-  auto Range = CharSourceRange::getCharRange(Next->getStartOfNonWhitespace(),
-                                             Next->Tok.getEndLoc());
+  auto Range = CharSourceRange::getCharRange(First->Tok.getLocation(),
+                                             First->Tok.getEndLoc());
 
-  std::string NewText = " " + Qualifier + " ";
-  NewText += Next->TokenText;
+  std::string NewText{};
+  NewText += First->TokenText;
+  NewText += " " + Qualifier;
   replaceToken(SourceMgr, Fixes, Range, NewText);
 }
 
 static void insertQualifierBefore(const SourceManager &SourceMgr,
                                   tooling::Replacements &Fixes,
                                   const FormatToken *First,
                                   const std::string &Qualifier) {
   auto Range = CharSourceRange::getCharRange(First->getStartOfNonWhitespace(),
static void rotateTokens(const SourceManager &SourceMgr,
   }
 
   auto Range = CharSourceRange::getCharRange(First->getStartOfNonWhitespace(),
                                              Last->Tok.getEndLoc());
 
   replaceToken(SourceMgr, Fixes, Range, NewText);
 }
 
+static bool
+isConfiguredQualifier(const FormatToken *const Tok,
+                      const std::vector<tok::TokenKind> &Qualifiers) {
+  return Tok && llvm::is_contained(Qualifiers, Tok->Tok.getKind());
+}
+
+static bool isQualifier(const FormatToken *const Tok) {
+  if (!Tok)
+    return false;
+
+  switch (Tok->Tok.getKind()) {
+  case tok::kw_const:
+  case tok::kw_volatile:
+  case tok::kw_static:
+  case tok::kw_inline:
+  case tok::kw_constexpr:
+  case tok::kw_restrict:
+  case tok::kw_friend:
+    return true;
+  default:
+    return false;
+  }
+}
+
 const FormatToken *LeftRightQualifierAlignmentFixer::analyzeRight(
     const SourceManager &SourceMgr, const AdditionalKeywords &Keywords,
-    tooling::Replacements &Fixes, const FormatToken *Tok,
+    tooling::Replacements &Fixes, const FormatToken *const Tok,
     const std::string &Qualifier, tok::TokenKind QualifierType) {
   // We only need to think about streams that begin with a qualifier.
   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;
-  };
+  // Skip qualifiers to the left to find what preceeds the qualifiers.
+  // Use isQualifier rather than isConfiguredQualifier to cover all qualifiers.
+  const FormatToken *PreviousCheck = Tok->getPreviousNonComment();
+  while (isQualifier(PreviousCheck))
+    PreviousCheck = PreviousCheck->getPreviousNonComment();
+
+  // Examples given in order of ['type', 'const', 'volatile']
+  const bool IsRightQualifier = PreviousCheck && [PreviousCheck]() {
+    // The cases:
+    // `Foo() const` -> `Foo() const`
+    // `Foo() const final` -> `Foo() const final`
+    // `Foo() const override` -> `Foo() const final`
+    // `Foo() const volatile override` -> `Foo() const volatile override`
+    // `Foo() volatile const final` -> `Foo() const volatile final`
+    if (PreviousCheck->is(tok::r_paren))
+      return true;
+
+    // The cases:
+    // `struct {} volatile const a;` -> `struct {} const volatile a;`
+    // `class {} volatile const a;` -> `class {} const volatile a;`
+    if (PreviousCheck->is(tok::r_brace))
+      return true;
+
+    // The case:
+    // `template <class T> const Bar Foo()` ->
+    // `template <class T> Bar const Foo()`
+    // The cases:
+    // `Foo<int> const foo` -> `Foo<int> const foo`
+    // `Foo<int> volatile const` -> `Foo<int> const volatile`
+    // The case:
+    // ```
+    // template <class T>
+    //   requires Concept1<T> && requires Concept2<T>
+    // const Foo f();
+    // ```
+    // ->
+    // ```
+    // template <class T>
+    //   requires Concept1<T> && requires Concept2<T>
+    // Foo const f();
+    // ```
+    if (PreviousCheck->is(TT_TemplateCloser)) {
+      // If the token closes a template<> or requires clause, then it is a left
+      // qualifier and should be moved to the right.
+      return !(PreviousCheck->ClosesTemplateDeclaration ||
+               PreviousCheck->ClosesRequiresClause);
+    }
+
+    // The case  `Foo* const` -> `Foo* const`
+    // The case  `Foo* volatile const` -> `Foo* const volatile`
+    // The case  `int32_t const` -> `int32_t const`
+    // The case  `auto volatile const` -> `auto const volatile`
+    if (PreviousCheck->isOneOf(TT_PointerOrReference, tok::identifier,
+                               tok::kw_auto)) {
+      return true;
+    }
+
+    return false;
+  }();
+
+  // Find the last qualifier to the right.
+  const FormatToken *LastQual = Tok;
+  while (isQualifier(LastQual->getNextNonComment()))
+    LastQual = LastQual->getNextNonComment();
+
+  // If this qualifier is to the right of a type or pointer do a partial sort
+  // and return.
+  if (IsRightQualifier) {
+    if (LastQual != Tok)
+      rotateTokens(SourceMgr, Fixes, Tok, LastQual, /*Left=*/false);
 
-  FormatToken *Qual = Tok->Next;
-  FormatToken *LastQual = Qual;
-  while (Qual && isQualifierOrType(Qual, ConfiguredQualifierTokens)) {
-    LastQual = Qual;
-    Qual = Qual->Next;
+  const FormatToken *TypeToken = LastQual->getNextNonComment();
+  if (!TypeToken)
+    return Tok;
+
+  // Stay safe and don't move past macros, also don't bother with sorting.
+  if (isPossibleMacro(TypeToken))
+    return Tok;
+
+  // The case `const long long int volatile` -> `long long int const volatile`
+  // The case `long const long int volatile` -> `long long int const volatile`
+  // The case `long long volatile int const` -> `long long int const volatile`
+  // The case `const long long volatile int` -> `long long int const volatile`
+  if (TypeToken->isSimpleTypeSpecifier()) {
+    // The case `const decltype(foo)` -> `const decltype(foo)`
+    // The case `const typeof(foo)` -> `const typeof(foo)`
+    // The case `const _Atomic(foo)` -> `const _Atomic(foo)`
+    if (TypeToken->isOneOf(tok::kw_decltype, tok::kw_typeof, tok::kw__Atomic))
+      return Tok;
+
+    const FormatToken *LastSimpleTypeSpecifier = TypeToken;
+    while (isQualifierOrType(LastSimpleTypeSpecifier->getNextNonComment()))
+      LastSimpleTypeSpecifier = LastSimpleTypeSpecifier->getNextNonComment();
+
+    rotateTokens(SourceMgr, Fixes, Tok, LastSimpleTypeSpecifier,
+                 /*Left=*/false);
+    return LastSimpleTypeSpecifier;
   }
-  if (LastQual && Qual != LastQual) {
+
+  // The case  `unsigned short const` -> `unsigned short const`
+  // The case:
+  // `unsigned short volatile const` -> `unsigned short const volatile`
+  if (PreviousCheck && PreviousCheck->isSimpleTypeSpecifier()) {
+    if (LastQual != Tok)
       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)) {
-    // `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,
-                                 tok::identifier)) {
-    FormatToken *Next = Tok->Next;
+    return Tok;
+  }
+
+  // Skip the typename keyword.
+  // The case `const typename C::type` -> `typename C::type const`
+  if (TypeToken->is(tok::kw_typename))
+    TypeToken = TypeToken->getNextNonComment();
+
+  // Skip the initial :: of a global-namespace type.
+  // The case `const ::...` -> `::... const`
+  if (TypeToken->is(tok::coloncolon)) {
+    // The case `const ::template Foo...` -> `::template Foo... const`
+    TypeToken = TypeToken->getNextNonComment();
+    if (TypeToken && TypeToken->is(tok::kw_template))
+      TypeToken = TypeToken->getNextNonComment();
+  }
+
+  // Don't change declarations such as
+  // `foo(const struct Foo a);` -> `foo(const struct Foo a);`
+  // as they would currently change code such as
+  // `const struct my_struct_t {} my_struct;` -> `struct my_struct_t const {}
+  // my_struct;`
+  if (TypeToken->isOneOf(tok::kw_struct, tok::kw_class))
+    return Tok;
+
+  if (TypeToken->isOneOf(tok::kw_auto, tok::identifier)) {
+    // The case  `const auto` -> `auto 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 Foo &&` -> `Foo const &&`
     // The case  `const std::Foo &&` -> `std::Foo const &&`
     // The case  `const std::Foo<T> &&` -> `std::Foo<T> const &&`
-    // However,  `const Bar::*` remains the same.
-    while (Next && Next->isOneOf(tok::identifier, tok::coloncolon) &&
-           !Next->startsSequence(tok::coloncolon, tok::star)) {
-      Next = Next->Next;
-    }
-    if (Next && Next->is(TT_TemplateOpener)) {
-      Next = Next->MatchingParen;
-      // Move to the end of any template class members e.g.
-      // `Foo<int>::iterator`.
-      if (Next && Next->startsSequence(TT_TemplateCloser, tok::coloncolon,
-                                       tok::identifier)) {
-        return Tok;
-      }
-      assert(Next && "Missing template opener");
-      Next = Next->Next;
-    }
-    if (Next && Next->isOneOf(tok::star, tok::amp, tok::ampamp) &&
-        !Tok->Next->isOneOf(Keywords.kw_override, Keywords.kw_final)) {
-      if (Next->Previous && !Next->Previous->is(QualifierType)) {
-        insertQualifierAfter(SourceMgr, Fixes, Next->Previous, Qualifier);
-        removeToken(SourceMgr, Fixes, Tok);
+    // The case  `const ::template Foo` -> `::template Foo const`
+    // The case  `const T::template Foo` -> `T::template Foo const`
+    const FormatToken *Next = nullptr;
+    while ((Next = TypeToken->getNextNonComment()) &&
+           (Next->is(TT_TemplateOpener) ||
+            Next->startsSequence(tok::coloncolon, tok::identifier) ||
+            Next->startsSequence(tok::coloncolon, tok::kw_template,
+                                 tok::identifier))) {
+      if (Next->is(TT_TemplateOpener)) {
+        assert(Next->MatchingParen && "Missing template closer");
+        TypeToken = Next->MatchingParen;
+      } else if (Next->startsSequence(tok::coloncolon, tok::identifier)) {
+        TypeToken = Next->getNextNonComment();
+      } else {
+        TypeToken = Next->getNextNonComment()->getNextNonComment();
       }
-      return Next;
     }
+
+    // Place the Qualifier at the end of the list of qualifiers.
+    while (isQualifier(TypeToken->getNextNonComment())) {
+      // The case `volatile Foo::iter const` -> `Foo::iter const volatile`
+      TypeToken = TypeToken->getNextNonComment();
+    }
+
+    insertQualifierAfter(SourceMgr, Fixes, TypeToken, Qualifier);
+    // Remove token and following whitespace.
+    auto Range = CharSourceRange::getCharRange(
+        Tok->getStartOfNonWhitespace(), Tok->Next->getStartOfNonWhitespace());
+    replaceToken(SourceMgr, Fixes, Range, "");
   }
 
   return Tok;
 }
 
 const FormatToken *LeftRightQualifierAlignmentFixer::analyzeLeft(
     const SourceManager &SourceMgr, const AdditionalKeywords &Keywords,
-    tooling::Replacements &Fixes, const FormatToken *Tok,
+    tooling::Replacements &Fixes, const FormatToken *const Tok,
     const std::string &Qualifier, tok::TokenKind QualifierType) {
-  // if Tok is an identifier and possibly a macro then don't convert.
-  if (LeftRightQualifierAlignmentFixer::isPossibleMacro(Tok))
+  // We only need to think about streams that begin with a qualifier.
+  if (!Tok->is(QualifierType))
+    return Tok;
+  // Don't concern yourself if nothing preceeds the qualifier.
+  if (!Tok->getPreviousNonComment())
     return Tok;
 
-  const FormatToken *Qual = Tok;
-  const FormatToken *LastQual = Qual;
-  while (Qual && isQualifierOrType(Qual, ConfiguredQualifierTokens)) {
-    LastQual = Qual;
-    Qual = Qual->Next;
-    if (Qual && Qual->is(QualifierType))
-      break;
-  }
-
-  if (!Qual)
-    return Tok;
-
-  if (LastQual && Qual != LastQual && Qual->is(QualifierType)) {
-    rotateTokens(SourceMgr, Fixes, Tok, Qual, /*Left=*/true);
-    if (!Qual->Next)
-      return Tok;
-    Tok = Qual->Next;
-  } else if (Tok->startsSequence(tok::identifier, QualifierType)) {
-    if (Tok->Next->Next && Tok->Next->Next->isOneOf(tok::identifier, tok::star,
-                                                    tok::amp, tok::ampamp)) {
-      // Don't swap `::iterator const` to `::const iterator`.
-      if (!Tok->Previous ||
-          (Tok->Previous && !Tok->Previous->is(tok::coloncolon))) {
-        rotateTokens(SourceMgr, Fixes, Tok, Tok->Next, /*Left=*/true);
-        Tok = Tok->Next;
-      }
-    } else if (Tok->startsSequence(tok::identifier, QualifierType,
-                                   TT_TemplateCloser)) {
-      FormatToken *Closer = Tok->Next->Next;
-      rotateTokens(SourceMgr, Fixes, Tok, Tok->Next, /*Left=*/true);
-      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::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;
-    if (Next && Next->Previous &&
-        Next->Previous->startsSequence(tok::identifier, TT_TemplateOpener)) {
-      // Read from to the end of the TemplateOpener to
-      // TemplateCloser const ArrayRef<int> a; const ArrayRef<int> &a;
-      if (Next->is(tok::comment) && Next->getNextNonComment())
-        Next = Next->getNextNonComment();
-      assert(Next->MatchingParen && "Missing template closer");
-      Next = Next->MatchingParen;
+  // Skip qualifiers to the left to find what preceeds the qualifiers.
+  const FormatToken *TypeToken = Tok->getPreviousNonComment();
+  while (isQualifier(TypeToken))
+    TypeToken = TypeToken->getPreviousNonComment();
+
+  // For left qualifiers preceeded by nothing, a template declaration, or *,&,&&
+  // we only perform sorting.
+  if (!TypeToken || TypeToken->isOneOf(tok::star, tok::amp, tok::ampamp) ||
+      TypeToken->ClosesRequiresClause || TypeToken->ClosesTemplateDeclaration) {
+
+    // Don't sort past a non-configured qualifier token.
+    const FormatToken *FirstQual = Tok;
+    while (isConfiguredQualifier(FirstQual->getPreviousNonComment(),
+                                 ConfiguredQualifierTokens)) {
+      FirstQual = FirstQual->getPreviousNonComment();
 
-      // If the template closer is closing the requires clause,
-      // then stop and go back to the TemplateOpener and do whatever is
-      // inside the <>.
-      if (Next->ClosesRequiresClause)
-        return Next->MatchingParen;
-      Next = Next->Next;
-
-      // Move to the end of any template class members e.g.
-      // `Foo<int>::iterator`.
-      if (Next && Next->startsSequence(tok::coloncolon, tok::identifier))
-        Next = Next->Next->Next;
-      if (Next && Next->is(QualifierType)) {
-        // Move the qualifier.
-        insertQualifierBefore(SourceMgr, Fixes, Tok, Qualifier);
-        removeToken(SourceMgr, Fixes, Next);
-        return Next;
-      }
-    }
-    if (Next && Next->Next &&
-        Next->Next->isOneOf(tok::amp, tok::ampamp, tok::star)) {
-      if (Next->is(QualifierType)) {
-        // Move the qualifier.
-        insertQualifierBefore(SourceMgr, Fixes, Tok, Qualifier);
-        removeToken(SourceMgr, Fixes, Next);
-        return Next;
-      }
+    if (FirstQual != Tok)
+      rotateTokens(SourceMgr, Fixes, FirstQual, Tok, /*Left=*/true);
+    return Tok;
+
+  // Stay safe and don't move past macros, also don't bother with sorting.
+  if (isPossibleMacro(TypeToken))
+    return Tok;
+
+  // Examples given in order of ['const', 'volatile', 'type']
+
+  // The case `volatile long long int const` -> `const volatile long long int`
+  // The case `volatile long long const int` -> `const volatile long long int`
+  // The case `const long long volatile int` -> `const volatile long long int`
+  // The case `long volatile long int const` -> `const volatile long long int`
+  if (TypeToken->isSimpleTypeSpecifier()) {
+    const FormatToken *LastSimpleTypeSpecifier = TypeToken;
+    while (isConfiguredQualifierOrType(
+        LastSimpleTypeSpecifier->getPreviousNonComment(),
+        ConfiguredQualifierTokens)) {
+      LastSimpleTypeSpecifier =
+          LastSimpleTypeSpecifier->getPreviousNonComment();
     }
+
+    rotateTokens(SourceMgr, Fixes, LastSimpleTypeSpecifier, Tok,
+                 /*Left=*/true);
+    return Tok;
   }
+
+  if (TypeToken->isOneOf(tok::kw_auto, tok::identifier, TT_TemplateCloser)) {
+    const auto IsStartOfType = [](const FormatToken *const Tok) -> bool {
+      if (!Tok)
+        return true;
+
+      // A template closer is not the start of a type.
+      // The case `?<> const` -> `const ?<>`
+      if (Tok->is(TT_TemplateCloser))
+        return false;
+
+      const FormatToken *const Previous = Tok->getPreviousNonComment();
+      if (!Previous)
+        return true;
+
+      // An identifier preceeded by :: is not the start of a type.
+      // The case `?::Foo const` -> `const ?::Foo`
+      if (Tok->is(tok::identifier) && Previous->is(tok::coloncolon))
+        return false;
+
+      const FormatToken *const PrePrevious = Previous->getPreviousNonComment();
+      // An identifier preceeded by ::template is not the start of a type.
+      // The case `?::template Foo const` -> `const ?::template Foo`
+      if (Tok->is(tok::identifier) && Previous->is(tok::kw_template) &&
+          PrePrevious && PrePrevious->is(tok::coloncolon)) {
+        return false;
+      }
+
+      return true;
+    };
+
+    while (!IsStartOfType(TypeToken)) {
+      // The case `?<>`
+      if (TypeToken->is(TT_TemplateCloser)) {
+        assert(TypeToken->MatchingParen && "Missing template opener");
+        TypeToken = TypeToken->MatchingParen->getPreviousNonComment();
+      } else {
+        // The cases
+        // `::Foo`
+        // `?>::Foo`
+        // `?Bar::Foo`
+        // `::template Foo`
+        // `?>::template Foo`
+        // `?Bar::template Foo`
+        if (TypeToken->getPreviousNonComment()->is(tok::kw_template))
+          TypeToken = TypeToken->getPreviousNonComment();
+
+        const FormatToken *const ColonColon =
+            TypeToken->getPreviousNonComment();
+        const FormatToken *const PreColonColon =
+            ColonColon->getPreviousNonComment();
+        if (PreColonColon &&
+            PreColonColon->isOneOf(TT_TemplateCloser, tok::identifier)) {
+          TypeToken = PreColonColon;
+        } else {
+          TypeToken = ColonColon;
+        }
+      }
+    }
+
+    assert(TypeToken && "Should be auto or identifier");
+
+    // Place the Qualifier at the start of the list of qualifiers.
+    const FormatToken *Previous = nullptr;
+    while ((Previous = TypeToken->getPreviousNonComment()) &&
+           (isConfiguredQualifier(Previous, ConfiguredQualifierTokens) ||
+            Previous->is(tok::kw_typename))) {
+      // The case `volatile Foo::iter const` -> `const volatile Foo::iter`
+      // The case `typename C::type const` -> `const typename C::type`
+      TypeToken = Previous;
+    }
+
+    // Don't change declarations such as
+    // `foo(struct Foo const a);` -> `foo(struct Foo const a);`
+    if (!Previous || !Previous->isOneOf(tok::kw_struct, tok::kw_class)) {
+      insertQualifierBefore(SourceMgr, Fixes, TypeToken, Qualifier);
+      removeToken(SourceMgr, Fixes, Tok);
+    }
+  }
+
   return Tok;
 }
 
 tok::TokenKind LeftRightQualifierAlignmentFixer::getTokenFromQualifier(
     const std::string &Qualifier) {
   // Don't let 'type' be an identifier, but steal typeof token.
   return llvm::StringSwitch<tok::TokenKind>(Qualifier)
       .Case("type", tok::kw_typeof)
if (left) {
       LeftOrder.insert(LeftOrder.begin(), s);
     } else {
       RightOrder.push_back(s);
     }
   }
 }
 
 bool LeftRightQualifierAlignmentFixer::isQualifierOrType(
-    const FormatToken *Tok, const std::vector<tok::TokenKind> &specifiedTypes) {
+    const FormatToken *const Tok) {
+  return Tok && (Tok->isSimpleTypeSpecifier() || Tok->is(tok::kw_auto) ||
+                 isQualifier(Tok));
+}
+
+bool LeftRightQualifierAlignmentFixer::isConfiguredQualifierOrType(
+    const FormatToken *const Tok,
+    const std::vector<tok::TokenKind> &Qualifiers) {
   return Tok && (Tok->isSimpleTypeSpecifier() || Tok->is(tok::kw_auto) ||
-                 llvm::is_contained(specifiedTypes, Tok->Tok.getKind()));
+                 isConfiguredQualifier(Tok, Qualifiers));
 }
 
 // If a token is an identifier and it's upper case, it could
 // be a macro and hence we need to be able to ignore it.
 bool LeftRightQualifierAlignmentFixer::isPossibleMacro(const FormatToken *Tok) {
   if (!Tok)
     return false;
   if (!Tok->is(tok::identifier))

clang/lib/Format/TokenAnnotator.cpp

while (CurrentToken) {
         //   msg: < item: data >
         // In TT_TextProto, map<key, value> does not occur.
         if (Style.Language == FormatStyle::LK_TextProto ||
             (Style.Language == FormatStyle::LK_Proto && Left->Previous &&
              Left->Previous->isOneOf(TT_SelectorName, TT_DictLiteral))) {
           CurrentToken->setType(TT_DictLiteral);
         } else {
           CurrentToken->setType(TT_TemplateCloser);
+          CurrentToken->Tok.setLength(1);
         }
         if (CurrentToken->Next && CurrentToken->Next->Tok.isLiteral())
           return false;
         next();
         return true;
       }
       if (CurrentToken->is(tok::question) &&
           Style.Language == FormatStyle::LK_Java) {

clang/unittests/Format/QualifierFixerTest.cpp

TEST_F(QualifierFixerTest, LeftRightQualifier) {
   verifyFormat("const int a;", Style);
   verifyFormat("const int *a;", Style);
   verifyFormat("const int &a;", Style);
   verifyFormat("const int &&a;", Style);
   verifyFormat("int const b;", Style);
   verifyFormat("int const *b;", Style);
   verifyFormat("int const &b;", Style);
   verifyFormat("int const &&b;", Style);
-  verifyFormat("int const *b const;", Style);
+  verifyFormat("int const *const b;", Style);
   verifyFormat("int *const c;", Style);
 
   verifyFormat("const Foo a;", Style);
   verifyFormat("const Foo *a;", Style);
   verifyFormat("const Foo &a;", Style);
   verifyFormat("const Foo &&a;", Style);
   verifyFormat("Foo const b;", Style);
   verifyFormat("Foo const *b;", Style);
   verifyFormat("Foo const &b;", Style);
   verifyFormat("Foo const &&b;", Style);
-  verifyFormat("Foo const *b const;", Style);
+  verifyFormat("Foo const *const b;", Style);
 
   verifyFormat("LLVM_NODISCARD const int &Foo();", Style);
   verifyFormat("LLVM_NODISCARD int const &Foo();", Style);
 
   verifyFormat("volatile const int *restrict;", Style);
   verifyFormat("const volatile int *restrict;", Style);
   verifyFormat("const int volatile *restrict;", Style);
 }
 
 TEST_F(QualifierFixerTest, RightQualifier) {
   FormatStyle Style = getLLVMStyle();
   Style.QualifierAlignment = FormatStyle::QAS_Right;
   Style.QualifierOrder = {"type", "const", "volatile"};
 
   verifyFormat("int const a;", Style);
   verifyFormat("int const *a;", Style);
   verifyFormat("int const &a;", Style);
   verifyFormat("int const &&a;", Style);
   verifyFormat("int const b;", Style);
   verifyFormat("int const *b;", Style);
   verifyFormat("int const &b;", Style);
   verifyFormat("int const &&b;", Style);
-  verifyFormat("int const *b const;", Style);
+  verifyFormat("int const *const b;", Style);
   verifyFormat("int *const c;", Style);
 
   verifyFormat("Foo const a;", Style);
   verifyFormat("Foo const *a;", Style);
   verifyFormat("Foo const &a;", Style);
   verifyFormat("Foo const &&a;", Style);
   verifyFormat("Foo const b;", Style);
   verifyFormat("Foo const *b;", Style);
   verifyFormat("Foo const &b;", Style);
   verifyFormat("Foo const &&b;", Style);
-  verifyFormat("Foo const *b const;", Style);
+  verifyFormat("Foo const *const b;", Style);
   verifyFormat("Foo *const b;", Style);
   verifyFormat("Foo const *const b;", Style);
   verifyFormat("auto const v = get_value();", Style);
   verifyFormat("long long const &a;", Style);
   verifyFormat("unsigned char const *a;", Style);
   verifyFormat("int main(int const argc, char const *const *const argv)",
                Style);
 
   verifyFormat("LLVM_NODISCARD int const &Foo();", Style);
   verifyFormat("SourceRange getSourceRange() const override LLVM_READONLY",
                Style);
   verifyFormat("void foo() const override;", Style);
   verifyFormat("void foo() const override LLVM_READONLY;", Style);
   verifyFormat("void foo() const final;", Style);
   verifyFormat("void foo() const final LLVM_READONLY;", Style);
   verifyFormat("void foo() const LLVM_READONLY;", Style);
+  verifyFormat("void foo() const volatile override;", Style);
+  verifyFormat("void foo() const volatile override LLVM_READONLY;", Style);
+  verifyFormat("void foo() const volatile final;", Style);
+  verifyFormat("void foo() const volatile final LLVM_READONLY;", Style);
+  verifyFormat("void foo() const volatile LLVM_READONLY;", Style);
 
   verifyFormat(
       "template <typename Func> explicit Action(Action<Func> const &action);",
       Style);
   verifyFormat(
       "template <typename Func> explicit Action(Action<Func> const &action);",
       "template <typename Func> explicit Action(const Action<Func>& action);",
       Style);
verifyFormat("Foo(int a, "
                "Foo(int a, "
                "unsigned b, // c-style args\n"
                "    const Bar &c);",
                Style);
 
   verifyFormat("int const volatile;", "volatile const int;", Style);
   verifyFormat("int const volatile;", "const volatile int;", Style);
   verifyFormat("int const volatile;", "const int volatile;", Style);
+
   verifyFormat("int const volatile *restrict;", "volatile const int *restrict;",
                Style);
   verifyFormat("int const volatile *restrict;", "const volatile int *restrict;",
                Style);
   verifyFormat("int const volatile *restrict;", "const int volatile *restrict;",
                Style);
 
+  verifyFormat("long long int const volatile;", "const long long int volatile;",
+               Style);
+  verifyFormat("long long int const volatile;", "long const long int volatile;",
+               Style);
+  verifyFormat("long long int const volatile;", "long long volatile int const;",
+               Style);
+  verifyFormat("long long int const volatile;", "long volatile long const int;",
+               Style);
+  verifyFormat("long long int const volatile;", "const long long volatile int;",
+               Style);
+
   verifyFormat("static int const bat;", "static const int bat;", Style);
   verifyFormat("static int const bat;", "static int const bat;", Style);
 
+  // static is not configured, unchanged on the left of the right hand
+  // qualifiers.
+  verifyFormat("int static const volatile;", "volatile const int static;",
+               Style);
+  verifyFormat("int static const volatile;", "const volatile int static;",
+               Style);
+  verifyFormat("int static const volatile;", "const int volatile static;",
+               Style);
+  verifyFormat("Foo static const volatile;", "volatile const Foo static;",
+               Style);
+  verifyFormat("Foo static const volatile;", "const volatile Foo static;",
+               Style);
+  verifyFormat("Foo static const volatile;", "const Foo volatile static;",
+               Style);
+
+  verifyFormat("Foo inline static const;", "const Foo inline static;", Style);
+  verifyFormat("Foo inline static const;", "Foo const inline static;", Style);
+  verifyFormat("Foo inline static const;", "Foo inline const static;", Style);
+  verifyFormat("Foo inline static const;", "Foo inline static const;", Style);
+
+  verifyFormat("Foo<T volatile>::Bar<Type const, 5> const volatile A::*;",
+               "volatile const Foo<volatile T>::Bar<const Type, 5> A::*;",
+               Style);
+
   verifyFormat("int const Foo<int>::bat = 0;", "const int Foo<int>::bat = 0;",
                Style);
   verifyFormat("int const Foo<int>::bat = 0;", "int const Foo<int>::bat = 0;",
                Style);
   verifyFormat("void fn(Foo<T> const &i);", "void fn(const Foo<T> &i);", Style);
   verifyFormat("int const Foo<int>::fn() {", "int const Foo<int>::fn() {",
                Style);
   verifyFormat("Foo<Foo<int>> const *p;", "const Foo<Foo<int>> *p;", Style);
TEST_F(QualifierFixerTest, RightQualifier) {
 
   verifyFormat("int const P;\n#if 0\n#else\n#endif",
                "const int P;\n#if 0\n#else\n#endif", Style);
 
   verifyFormat("unsigned long const a;", "const unsigned long a;", Style);
   verifyFormat("unsigned long long const a;", "const unsigned long long a;",
                Style);
 
-  // don't adjust macros
+  // Multiple template parameters.
+  verifyFormat("Bar<std::Foo const, 32>", "Bar<const std::Foo, 32>", Style);
+  // Variable declaration based on template type.
+  verifyFormat("Bar<std::Foo const> bar", "Bar<const std::Foo> bar", Style);
+
+  // Using typename for a nested dependent type name.
+  verifyFormat("typename Foo::iterator const;", "const typename Foo::iterator;",
+               Style);
+
+  // Don't move past C-style struct/class.
+  verifyFormat("void foo(const struct A a);", "void foo(const struct A a);",
+               Style);
+  verifyFormat("void foo(const class A a);", "void foo(const class A a);",
+               Style);
+
+  // Don't move past struct/class combined declaration and variable
+  // definition.
+  verifyFormat("const struct {\n} var;", "const struct {\n} var;", Style);
+  verifyFormat("struct {\n} const var;", "struct {\n} const var;", Style);
+  verifyFormat("const class {\n} var;", "const class {\n} var;", Style);
+  verifyFormat("class {\n} const var;", "class {\n} const var;", Style);
+
+  // Leave left qualifers unchanged for combined declaration and variable
+  // definition.
+  verifyFormat("volatile const class {\n} var;",
+               "volatile const class {\n} var;", Style);
+  verifyFormat("const volatile class {\n} var;",
+               "const volatile class {\n} var;", Style);
+  // Also do no sorting with respect to not-configured tokens.
+  verifyFormat("const static volatile class {\n} var;",
+               "const static volatile class {\n} var;", Style);
+  // Sort right qualifiers for combined declaration and variable definition.
+  verifyFormat("class {\n} const volatile var;",
+               "class {\n} const volatile var;", Style);
+  verifyFormat("class {\n} const volatile var;",
+               "class {\n} volatile const var;", Style);
+  // Static keyword is not configured, should end up on the left of the right
+  // side.
+  verifyFormat("class {\n} static const volatile var;",
+               "class {\n} static const volatile var;", Style);
+  verifyFormat("class {\n} static const volatile var;",
+               "class {\n} volatile static const var;", Style);
+
+  // ::template for dependent names
+  verifyFormat("::template Foo<T> const volatile var;",
+               "const volatile ::template Foo<T> var;", Style);
+  verifyFormat("typename ::template Foo<T> const volatile var;",
+               "const volatile typename ::template Foo<T> var;", Style);
+  verifyFormat("typename Bar::template Foo<T>::T const;",
+               "const typename Bar::template Foo<T>::T;", Style);
+  verifyFormat("typename Bar::template Foo<T>::T const volatile;",
+               "const volatile typename Bar::template Foo<T>::T;", Style);
+
+  // typename ::
+  verifyFormat("typename ::Bar<int> const;", "const typename ::Bar<int>;",
+               Style);
+  // typename ::template
+  verifyFormat("typename ::template Bar<int> const;",
+               "const typename ::template Bar<int>;", Style);
+
+  verifyFormat("foo<Bar<Baz> const>();", "foo<const Bar<Baz>>();", Style);
+  verifyFormat("foo<Bar<Baz> const>();", "foo<const Bar<Baz> >();", Style);
+  verifyFormat("Bar<32, Foo<25> const>;", "Bar<32, const Foo<25>>;", Style);
+  verifyFormat("A<B<C<D> const> const>;", "A<const B<const C<D>>>;", Style);
+  verifyFormat("A<B<C<D const> const> const>;", "A<const B<const C<const D>>>;",
+               Style);
+
+  // Don't move past decltype, typeof, or _Atomic.
+  verifyFormat("const decltype(foo)", "const decltype(foo)", Style);
+  verifyFormat("const typeof(foo)", "const typeof(foo)", Style);
+  verifyFormat("const _Atomic(foo)", "const _Atomic(foo)", Style);
+
+  // Comments
+  const int ColumnLimit = Style.ColumnLimit;
+  Style.ColumnLimit = 200;
+  verifyFormat("/*c*/ Foo const *foo;", "const /*c*/ Foo *foo;", Style);
+  verifyFormat("Foo const /*c*/ *foo;", "const Foo /*c*/ *foo;", Style);
+  verifyFormat("Foo const * /*c*/ foo;", "const Foo * /*c*/ foo;", Style);
+
+  verifyFormat("/*comment*/ std::vector<int> const v;",
+               "const /*comment*/ std::vector<int> v;", Style);
+  verifyFormat("std /*comment*/ ::vector<int> const v;",
+               "const std /*comment*/ ::vector<int> v;", Style);
+  verifyFormat("std::/*comment*/ vector<int> const v;",
+               "const std::/*comment*/ vector<int> v;", Style);
+  verifyFormat("std::vector /*comment*/<int> const v;",
+               "const std::vector /*comment*/ <int> v;", Style);
+  verifyFormat("std::vector</*comment*/ int> const v;",
+               "const std::vector</*comment*/ int> v;", Style);
+  verifyFormat("std::vector<int /*comment*/> const v;",
+               "const std::vector<int /*comment*/> v;", Style);
+  verifyFormat("std::vector<int> const /*comment*/ v;",
+               "const std::vector<int> /*comment*/ v;", Style);
+
+  verifyFormat("std::vector</*comment*/ int const> v;",
+               "std::vector</*comment*/ const int> v;", Style);
+  verifyFormat("std::vector</*comment*/ int const> v;",
+               "std::vector<const /*comment*/ int> v;", Style);
+  verifyFormat("std::vector<int const /*comment*/> v;",
+               "std::vector<const int /*comment*/> v;", Style);
+  verifyFormat("std::vector</*comment*/ Foo const> v;",
+               "std::vector</*comment*/ const Foo> v;", Style);
+  verifyFormat("std::vector</*comment*/ Foo const> v;",
+               "std::vector<const /*comment*/ Foo> v;", Style);
+  verifyFormat("std::vector<Foo const /*comment*/> v;",
+               "std::vector<const Foo /*comment*/> v;", Style);
+
+  verifyFormat("typename C<T>::template B<T> const;",
+               "const typename C<T>::template B<T>;", Style);
+  verifyFormat("/*c*/ typename C<T>::template B<T> const;",
+               "const /*c*/ typename C<T>::template B<T>;", Style);
+  verifyFormat("typename /*c*/ C<T>::template B<T> const;",
+               "const typename /*c*/ C<T>::template B<T>;", Style);
+  verifyFormat("typename C /*c*/<T>::template B<T> const;",
+               "const typename C /*c*/<T>::template B<T>;", Style);
+  verifyFormat("typename C<T> /*c*/ ::template B<T> const;",
+               "const typename C<T> /*c*/ ::template B<T>;", Style);
+  verifyFormat("typename C<T>::/*c*/ template B<T> const;",
+               "const typename C<T>::/*c*/ template B<T>;", Style);
+  verifyFormat("typename C<T>::template /*c*/ B<T> const;",
+               "const typename C<T>::template /*c*/B<T>;", Style);
+  verifyFormat("typename C<T>::template B<T> const /*c*/;",
+               "const typename C<T>::template B<T>/*c*/;", Style);
+
+  verifyFormat("/*c*/ /*c*/ typename /*c*/ C /*c*/<T> /*c*/ ::/*c*/ template "
+               "/*c*/ B /*c*/<T> const /*c*/ v;",
+               "/*c*/ const /*c*/ typename /*c*/ C /*c*/<T> /*c*/ "
+               "::/*c*/template /*c*/ B /*c*/<T> /*c*/ v;",
+               Style);
+
+  verifyFormat("/*c*/ unsigned /*c*/ long const /*c*/ a;",
+               "const /*c*/ unsigned /*c*/ long /*c*/ a;", Style);
+  verifyFormat("unsigned /*c*/ long /*c*/ long const a;",
+               "const unsigned /*c*/ long /*c*/ long a;", Style);
+
+  // Not changed
+  verifyFormat("foo() /*c*/ const", "foo() /*c*/ const", Style);
+  verifyFormat("const /*c*/ struct a;", "const /*c*/ struct a;", Style);
+  verifyFormat("const /*c*/ class a;", "const /*c*/ class a;", Style);
+  verifyFormat("const /*c*/ decltype(v) a;", "const /*c*/ decltype(v) a;",
+               Style);
+  verifyFormat("const /*c*/ typeof(v) a;", "const /*c*/ typeof(v) a;", Style);
+  verifyFormat("const /*c*/ _Atomic(v) a;", "const /*c*/ _Atomic(v) a;", Style);
+  verifyFormat("const decltype /*c*/ (v) a;", "const decltype /*c*/ (v) a;",
+               Style);
+  verifyFormat("const /*c*/ class {\n} volatile /*c*/ foo = {};",
+               "const /*c*/ class {\n} volatile /*c*/ foo = {};", Style);
+
+  Style.ColumnLimit = ColumnLimit;
+
+  // Don't adjust macros
   verifyFormat("const INTPTR a;", "const INTPTR a;", Style);
 
   // Pointers to members
   verifyFormat("int S::*a;", Style);
   verifyFormat("int const S::*a;", "const int S:: *a;", Style);
   verifyFormat("int const S::*const a;", "const int S::* const a;", Style);
   verifyFormat("int A::*const A::*p1;", Style);
   verifyFormat("float (C::*p)(int);", Style);
TEST_F(QualifierFixerTest, LeftQualifier) {
   verifyFormat("const int a;", Style);
   verifyFormat("const int *a;", Style);
   verifyFormat("const int &a;", Style);
   verifyFormat("const int &&a;", Style);
   verifyFormat("const int b;", Style);
   verifyFormat("const int *b;", Style);
   verifyFormat("const int &b;", Style);
   verifyFormat("const int &&b;", Style);
-  verifyFormat("const int *b const;", Style);
+  verifyFormat("const int *const b;", Style);
   verifyFormat("int *const c;", Style);
 
   verifyFormat("const Foo a;", Style);
   verifyFormat("const Foo *a;", Style);
   verifyFormat("const Foo &a;", Style);
   verifyFormat("const Foo &&a;", Style);
   verifyFormat("const Foo b;", Style);
   verifyFormat("const Foo *b;", Style);
   verifyFormat("const Foo &b;", Style);
   verifyFormat("const Foo &&b;", Style);
-  verifyFormat("const Foo *b const;", Style);
+  verifyFormat("const Foo *const b;", Style);
   verifyFormat("Foo *const b;", Style);
   verifyFormat("const Foo *const b;", Style);
 
   verifyFormat("LLVM_NODISCARD const int &Foo();", Style);
 
   verifyFormat("const char a[];", Style);
   verifyFormat("const auto v = get_value();", Style);
   verifyFormat("const long long &a;", Style);
TEST_F(QualifierFixerTest, LeftQualifier) {
 
   verifyFormat("const volatile int *restrict;", "volatile const int *restrict;",
                Style);
   verifyFormat("const volatile int *restrict;", "const volatile int *restrict;",
                Style);
   verifyFormat("const volatile int *restrict;", "const int volatile *restrict;",
                Style);
 
+  verifyFormat("const volatile long long int;", "volatile long long int const;",
+               Style);
+  verifyFormat("const volatile long long int;", "volatile long long const int;",
+               Style);
+  verifyFormat("const volatile long long int;", "long long volatile int const;",
+               Style);
+  verifyFormat("const volatile long long int;", "long volatile long int const;",
+               Style);
+  verifyFormat("const volatile long long int;", "const long long volatile int;",
+               Style);
+
   verifyFormat("SourceRange getSourceRange() const override LLVM_READONLY;",
                Style);
 
   verifyFormat("void foo() const override;", Style);
   verifyFormat("void foo() const override LLVM_READONLY;", Style);
   verifyFormat("void foo() const final;", Style);
   verifyFormat("void foo() const final LLVM_READONLY;", Style);
   verifyFormat("void foo() const LLVM_READONLY;", Style);
TEST_F(QualifierFixerTest, LeftQualifier) {
   verifyFormat("const long long unsigned a;", "long const long unsigned a;",
                Style);
 
   verifyFormat("const std::Foo", "const std::Foo", Style);
   verifyFormat("const std::Foo<>", "const std::Foo<>", Style);
   verifyFormat("const std::Foo < int", "const std::Foo<int", Style);
   verifyFormat("const std::Foo<int>", "const std::Foo<int>", Style);
 
-  // don't adjust macros
+  // Multiple template parameters.
+  verifyFormat("Bar<const std::Foo, 32>;", "Bar<std::Foo const, 32>;", Style);
+
+  // Variable declaration based on template type.
+  verifyFormat("Bar<const std::Foo> bar;", "Bar<std::Foo const> bar;", Style);
+
+  // Using typename for a dependent name.
+  verifyFormat("const typename Foo::iterator;", "typename Foo::iterator const;",
+               Style);
+
+  // Don't move past C-style struct/class.
+  verifyFormat("void foo(struct A const a);", "void foo(struct A const a);",
+               Style);
+  verifyFormat("void foo(class A const a);", "void foo(class A const a);",
+               Style);
+
+  // Don't move past struct/class combined declaration and variable
+  // definition.
+  verifyFormat("const struct {\n} var;", "const struct {\n} var;", Style);
+  verifyFormat("struct {\n} const var;", "struct {\n} const var;", Style);
+  verifyFormat("const class {\n} var;", "const class {\n} var;", Style);
+  verifyFormat("class {\n} const var;", "class {\n} const var;", Style);
+
+  // Sort left qualifiers for struct/class combined declaration and variable
+  // definition.
+  verifyFormat("const volatile class {\n} var;",
+               "const volatile class {\n} var;", Style);
+  verifyFormat("const volatile class {\n} var;",
+               "volatile const class {\n} var;", Style);
+  // Leave right qualifers unchanged for struct/class combined declaration and
+  // variable definition.
+  verifyFormat("class {\n} const volatile var;",
+               "class {\n} const volatile var;", Style);
+  verifyFormat("class {\n} volatile const var;",
+               "class {\n} volatile const var;", Style);
+
+  verifyFormat("foo<const Bar<Baz<T>>>();", "foo<Bar<Baz<T>> const>();", Style);
+  verifyFormat("foo<const Bar<Baz<T>>>();", "foo<Bar<Baz<T> > const>();",
+               Style);
+  verifyFormat("Bar<32, const Foo<25>>;", "Bar<32, Foo<25> const>;", Style);
+  verifyFormat("A<const B<const C<D>>>;", "A<B<C<D> const> const>;", Style);
+  verifyFormat("A<const B<const C<const D>>>;", "A<B<C<D const> const> const>;",
+               Style);
+
+  // Don't move past decltype, typeof, or _Atomic.
+  verifyFormat("decltype(foo) const", "decltype(foo) const", Style);
+  verifyFormat("typeof(foo) const", "typeof(foo) const", Style);
+  verifyFormat("_Atomic(foo) const", "_Atomic(foo) const", Style);
+
+  // ::template for dependent names
+  verifyFormat("const volatile ::template Foo<T> var;",
+               "::template Foo<T> const volatile var;", Style);
+  verifyFormat("const volatile typename ::template Foo<T> var;",
+               "typename ::template Foo<T> const volatile var;", Style);
+  verifyFormat("const typename Bar::template Foo<T>::T;",
+               "typename Bar::template Foo<T>::T const;", Style);
+  verifyFormat("const volatile typename Bar::template Foo<T>::T;",
+               "typename Bar::template Foo<T>::T const volatile;", Style);
+
+  // typename ::
+  verifyFormat("const typename ::Bar<int>;", "typename ::Bar<int> const;",
+               Style);
+  // typename ::template
+  verifyFormat("const typename ::template Bar<int>;",
+               "typename ::template Bar<int> const;", Style);
+
+  // Comments
+  const int ColumnLimit = Style.ColumnLimit;
+  Style.ColumnLimit = 200;
+  verifyFormat("/*c*/ const Foo *foo;", "/*c*/ Foo const *foo;", Style);
+  verifyFormat("const Foo /*c*/ *foo;", "Foo const /*c*/ *foo;", Style);
+  verifyFormat("const Foo * /*c*/ foo;", "Foo const * /*c*/ foo;", Style);
+
+  verifyFormat("/*comment*/ const std::vector<int> v;",
+               "/*comment*/ std::vector<int> const v;", Style);
+  verifyFormat("const std /*comment*/ ::vector<int> v;",
+               "std /*comment*/ ::vector<int> const v;", Style);
+  verifyFormat("const std::/*comment*/ vector<int> v;",
+               "std::/*comment*/ vector<int> const v;", Style);
+  verifyFormat("const std::vector /*comment*/<int> v;",
+               "std::vector /*comment*/<int> const v;", Style);
+  verifyFormat("const std::vector</*comment*/ int> v;",
+               "std::vector</*comment*/ int> const v;", Style);
+  verifyFormat("const std::vector<int /*comment*/> v;",
+               "std::vector<int /*comment*/> const v;", Style);
+  verifyFormat("const std::vector<int> /*comment*/ v;",
+               "std::vector<int> /*comment*/ const v;", Style);
+
+  verifyFormat("std::vector</*comment*/ const int> v;",
+               "std::vector</*comment*/ int const> v;", Style);
+  verifyFormat("std::vector<const int /*comment*/> v;",
+               "std::vector<int /*comment*/ const> v;", Style);
+  verifyFormat("std::vector<const int /*comment*/> v;",
+               "std::vector<int const /*comment*/> v;", Style);
+  verifyFormat("std::vector</*comment*/ const Foo> v;",
+               "std::vector</*comment*/ Foo const> v;", Style);
+  verifyFormat("std::vector<const Foo /*comment*/> v;",
+               "std::vector<Foo /*comment*/ const> v;", Style);
+  verifyFormat("std::vector<const Foo /*comment*/> v;",
+               "std::vector<Foo const /*comment*/> v;", Style);
+
+  verifyFormat("const typename C<T>::template B<T>;",
+               "typename C<T>::template B<T> const;", Style);
+  verifyFormat("/*c*/ const typename C<T>::template B<T>;",
+               "/*c*/ typename C<T>::template B<T> const;", Style);
+  verifyFormat("const typename /*c*/ C<T>::template B<T>;",
+               "typename /*c*/ C<T>::template B<T> const;", Style);
+  verifyFormat("const typename C /*c*/<T>::template B<T>;",
+               "typename C /*c*/<T>::template B<T> const;", Style);
+  verifyFormat("const typename C<T> /*c*/ ::template B<T>;",
+               "typename C<T> /*c*/ ::template B<T> const;", Style);
+  verifyFormat("const typename C<T>::/*c*/ template B<T>;",
+               "typename C<T>::/*c*/ template B<T> const;", Style);
+  verifyFormat("const typename C<T>::template /*c*/ B<T>;",
+               "typename C<T>::template /*c*/ B<T> const;", Style);
+  verifyFormat("const typename C<T>::template B<T> /*c*/;",
+               "typename C<T>::template B<T> /*c*/ const;", Style);
+
+  verifyFormat("/*c*/ const typename /*c*/ C /*c*/<T> /*c*/ ::/*c*/ template "
+               "/*c*/ B /*c*/<T> /*c*/ v;",
+               "/*c*/ typename /*c*/ C /*c*/<T> /*c*/ ::/*c*/ template /*c*/ B "
+               "/*c*/<T> /*c*/ const v;",
+               Style);
+
+  verifyFormat("const unsigned /*c*/ long /*c*/ a;",
+               "unsigned /*c*/ long /*c*/ const a;", Style);
+  verifyFormat("const unsigned /*c*/ long /*c*/ long a;",
+               "unsigned /*c*/ long /*c*/ long const a;", Style);
+
+  // Not changed
+  verifyFormat("foo() /*c*/ const", "foo() /*c*/ const", Style);
+  verifyFormat("struct /*c*/ const a;", "struct /*c*/ const a;", Style);
+  verifyFormat("class /*c*/ const a;", "class /*c*/ const a;", Style);
+  verifyFormat("decltype(v) /*c*/ const a;", "decltype(v) /*c*/ const a;",
+               Style);
+  verifyFormat("typeof(v) /*c*/ const a;", "typeof(v) /*c*/ const a;", Style);
+  verifyFormat("_Atomic(v) /*c*/ const a;", "_Atomic(v) /*c*/ const a;", Style);
+  verifyFormat("decltype /*c*/ (v) const a;", "decltype /*c*/ (v) const a;",
+               Style);
+  verifyFormat("const /*c*/ class {\n} /*c*/ volatile /*c*/ foo = {};",
+               "const /*c*/ class {\n} /*c*/ volatile /*c*/ foo = {};", Style);
+
+  Style.ColumnLimit = ColumnLimit;
+
+  // Don't adjust macros
   verifyFormat("INTPTR const a;", "INTPTR const a;", Style);
 
   // Pointers to members
   verifyFormat("int S::*a;", Style);
   verifyFormat("const int S::*a;", "int const S:: *a;", Style);
   verifyFormat("const int S::*const a;", "int const S::* const a;", Style);
   verifyFormat("int A::*const A::*p1;", Style);
   verifyFormat("float (C::*p)(int);", Style);
TEST_F(QualifierFixerTest, ConstVolatileQualifiersOrder) {
   EXPECT_EQ(Style.QualifierOrder.size(), (size_t)5);
 
   verifyFormat("const volatile int a;", "const volatile int a;", Style);
   verifyFormat("const volatile int a;", "volatile const int a;", Style);
   verifyFormat("const volatile int a;", "int const volatile a;", Style);
   verifyFormat("const volatile int a;", "int volatile const a;", Style);
   verifyFormat("const volatile int a;", "const int volatile a;", Style);
 
+  verifyFormat("const volatile Foo a;", "const volatile Foo a;", Style);
+  verifyFormat("const volatile Foo a;", "volatile const Foo a;", Style);
+  verifyFormat("const volatile Foo a;", "Foo const volatile a;", Style);
+  verifyFormat("const volatile Foo a;", "Foo volatile const a;", Style);
+  verifyFormat("const volatile Foo a;", "const Foo volatile a;", Style);
+
   Style.QualifierAlignment = FormatStyle::QAS_Right;
   Style.QualifierOrder = {"type", "const", "volatile"};
 
   verifyFormat("int const volatile a;", "const volatile int a;", Style);
   verifyFormat("int const volatile a;", "volatile const int a;", Style);
   verifyFormat("int const volatile a;", "int const volatile a;", Style);
   verifyFormat("int const volatile a;", "int volatile const a;", Style);
   verifyFormat("int const volatile a;", "const int volatile a;", Style);
 
+  verifyFormat("Foo const volatile a;", "const volatile Foo a;", Style);
+  verifyFormat("Foo const volatile a;", "volatile const Foo a;", Style);
+  verifyFormat("Foo const volatile a;", "Foo const volatile a;", Style);
+  verifyFormat("Foo const volatile a;", "Foo volatile const a;", Style);
+  verifyFormat("Foo const volatile a;", "const Foo volatile a;", Style);
+
   Style.QualifierAlignment = FormatStyle::QAS_Left;
   Style.QualifierOrder = {"volatile", "const", "type"};
 
   verifyFormat("volatile const int a;", "const volatile int a;", Style);
   verifyFormat("volatile const int a;", "volatile const int a;", Style);
   verifyFormat("volatile const int a;", "int const volatile a;", Style);
   verifyFormat("volatile const int a;", "int volatile const a;", Style);
   verifyFormat("volatile const int a;", "const int volatile a;", Style);
 
+  verifyFormat("volatile const Foo a;", "const volatile Foo a;", Style);
+  verifyFormat("volatile const Foo a;", "volatile const Foo a;", Style);
+  verifyFormat("volatile const Foo a;", "Foo const volatile a;", Style);
+  verifyFormat("volatile const Foo a;", "Foo volatile const a;", Style);
+  verifyFormat("volatile const Foo a;", "const Foo volatile a;", Style);
+
   Style.QualifierAlignment = FormatStyle::QAS_Right;
   Style.QualifierOrder = {"type", "volatile", "const"};
 
   verifyFormat("int volatile const a;", "const volatile int a;", Style);
   verifyFormat("int volatile const a;", "volatile const int a;", Style);
   verifyFormat("int volatile const a;", "int const volatile a;", Style);
   verifyFormat("int volatile const a;", "int volatile const a;", Style);
   verifyFormat("int volatile const a;", "const int volatile a;", Style);
 
+  verifyFormat("Foo volatile const a;", "const volatile Foo a;", Style);
+  verifyFormat("Foo volatile const a;", "volatile const Foo a;", Style);
+  verifyFormat("Foo volatile const a;", "Foo const volatile a;", Style);
+  verifyFormat("Foo volatile const a;", "Foo volatile const a;", Style);
+  verifyFormat("Foo volatile const a;", "const Foo volatile a;", Style);
+
   Style.QualifierAlignment = FormatStyle::QAS_Custom;
   Style.QualifierOrder = {"type", "volatile", "const"};
 
   verifyFormat("int volatile const a;", "const volatile int a;", Style);
   verifyFormat("int volatile const a;", "volatile const int a;", Style);
   verifyFormat("int volatile const a;", "int const volatile a;", Style);
   verifyFormat("int volatile const a;", "int volatile const a;", Style);
   verifyFormat("int volatile const a;", "const int volatile a;", Style);
+
+  verifyFormat("Foo volatile const a;", "const volatile Foo a;", Style);
+  verifyFormat("Foo volatile const a;", "volatile const Foo a;", Style);
+  verifyFormat("Foo volatile const a;", "Foo const volatile a;", Style);
+  verifyFormat("Foo volatile const a;", "Foo volatile const a;", Style);
+  verifyFormat("Foo volatile const a;", "const Foo volatile a;", Style);
 }
 
 TEST_F(QualifierFixerTest, InlineStatics) {
   FormatStyle Style = getLLVMStyle();
   Style.QualifierAlignment = FormatStyle::QAS_Left;
   Style.QualifierOrder = {"inline", "static", "const", "volatile", "type"};
   EXPECT_EQ(Style.QualifierOrder.size(), (size_t)5);
 
TEST_F(QualifierFixerTest, MoveConstBeforeTypeSmall) {
 
   FormatStyle Style = getLLVMStyle();
   Style.QualifierAlignment = FormatStyle::QAS_Custom;
   Style.QualifierOrder = {"const", "type"};
   EXPECT_EQ(Style.QualifierOrder.size(), (size_t)2);
 
   verifyFormat("const int a;", "int const a;", Style);
   verifyFormat("const int *a;", "int const *a;", Style);
-  verifyFormat("const int *a const;", "int const *a const;", Style);
+  verifyFormat("const int *const a;", "int const *const a;", Style);
 
   verifyFormat("const int a = foo();", "int const a = foo();", Style);
   verifyFormat("const int *a = foo();", "int const *a = foo();", Style);
-  verifyFormat("const int *a const = foo();", "int const *a const = foo();",
+  verifyFormat("const int *const a = foo();", "int const *const a = foo();",
                Style);
 
   verifyFormat("const auto a = foo();", "auto const a = foo();", Style);
   verifyFormat("const auto *a = foo();", "auto const *a = foo();", Style);
-  verifyFormat("const auto *a const = foo();", "auto const *a const = foo();",
+  verifyFormat("const auto *const a = foo();", "auto const *const a = foo();",
                Style);
 }
 
 TEST_F(QualifierFixerTest, MoveConstBeyondType) {
 
   FormatStyle Style = getLLVMStyle();
   Style.QualifierAlignment = FormatStyle::QAS_Custom;
   Style.QualifierOrder = {"static", "inline", "type", "const", "volatile"};
   EXPECT_EQ(Style.QualifierOrder.size(), (size_t)5);
 
   verifyFormat("static inline int const volatile a;",
                "const inline static volatile int a;", Style);
   verifyFormat("static inline int const volatile a;",
                "volatile inline static const int a;", Style);
   verifyFormat("static inline int const volatile a;",
                "int const inline static  volatile a;", Style);
   verifyFormat("static inline int const volatile a;",
                "int volatile inline static  const a;", Style);
   verifyFormat("static inline int const volatile a;",
                "const int inline static  volatile a;", Style);
 
-  verifyFormat("static inline int const volatile *a const;",
-               "const int inline static  volatile *a const;", Style);
+  verifyFormat("static inline int const volatile *const a;",
+               "const int inline static  volatile *const a;", Style);
+
+  verifyFormat("static inline Foo const volatile a;",
+               "const inline static volatile Foo a;", Style);
+  verifyFormat("static inline Foo const volatile a;",
+               "volatile inline static const Foo a;", Style);
+  verifyFormat("static inline Foo const volatile a;",
+               "Foo const inline static  volatile a;", Style);
+  verifyFormat("static inline Foo const volatile a;",
+               "Foo volatile inline static  const a;", Style);
+  verifyFormat("static inline Foo const volatile a;",
+               "const Foo inline static  volatile a;", Style);
+
+  verifyFormat("static inline Foo const volatile *const a;",
+               "const Foo inline static volatile *const a;", Style);
 }
 
 TEST_F(QualifierFixerTest, PrepareLeftRightOrdering) {
   FormatStyle Style = getLLVMStyle();
   Style.QualifierAlignment = FormatStyle::QAS_Custom;
   Style.QualifierOrder = {"static", "inline", "type", "const", "volatile"};
 
   std::vector<std::string> Left;
TEST_F(QualifierFixerTest, IsQualifierType) {
   ConfiguredTokens.push_back(tok::kw_inline);
   ConfiguredTokens.push_back(tok::kw_restrict);
   ConfiguredTokens.push_back(tok::kw_constexpr);
   ConfiguredTokens.push_back(tok::kw_friend);
 
   auto Tokens = annotate(
       "const static inline auto restrict int double long constexpr friend");
 
-  EXPECT_TRUE(LeftRightQualifierAlignmentFixer::isQualifierOrType(
+  EXPECT_TRUE(LeftRightQualifierAlignmentFixer::isConfiguredQualifierOrType(
       Tokens[0], ConfiguredTokens));
-  EXPECT_TRUE(LeftRightQualifierAlignmentFixer::isQualifierOrType(
+  EXPECT_TRUE(LeftRightQualifierAlignmentFixer::isConfiguredQualifierOrType(
       Tokens[1], ConfiguredTokens));
-  EXPECT_TRUE(LeftRightQualifierAlignmentFixer::isQualifierOrType(
+  EXPECT_TRUE(LeftRightQualifierAlignmentFixer::isConfiguredQualifierOrType(
       Tokens[2], ConfiguredTokens));
-  EXPECT_TRUE(LeftRightQualifierAlignmentFixer::isQualifierOrType(
+  EXPECT_TRUE(LeftRightQualifierAlignmentFixer::isConfiguredQualifierOrType(
       Tokens[3], ConfiguredTokens));
-  EXPECT_TRUE(LeftRightQualifierAlignmentFixer::isQualifierOrType(
+  EXPECT_TRUE(LeftRightQualifierAlignmentFixer::isConfiguredQualifierOrType(
       Tokens[4], ConfiguredTokens));
-  EXPECT_TRUE(LeftRightQualifierAlignmentFixer::isQualifierOrType(
+  EXPECT_TRUE(LeftRightQualifierAlignmentFixer::isConfiguredQualifierOrType(
       Tokens[5], ConfiguredTokens));
-  EXPECT_TRUE(LeftRightQualifierAlignmentFixer::isQualifierOrType(
+  EXPECT_TRUE(LeftRightQualifierAlignmentFixer::isConfiguredQualifierOrType(
       Tokens[6], ConfiguredTokens));
-  EXPECT_TRUE(LeftRightQualifierAlignmentFixer::isQualifierOrType(
+  EXPECT_TRUE(LeftRightQualifierAlignmentFixer::isConfiguredQualifierOrType(
       Tokens[7], ConfiguredTokens));
-  EXPECT_TRUE(LeftRightQualifierAlignmentFixer::isQualifierOrType(
+  EXPECT_TRUE(LeftRightQualifierAlignmentFixer::isConfiguredQualifierOrType(
       Tokens[8], ConfiguredTokens));
-  EXPECT_TRUE(LeftRightQualifierAlignmentFixer::isQualifierOrType(
+  EXPECT_TRUE(LeftRightQualifierAlignmentFixer::isConfiguredQualifierOrType(
       Tokens[9], ConfiguredTokens));
 
+  EXPECT_TRUE(LeftRightQualifierAlignmentFixer::isQualifierOrType(Tokens[0]));
+  EXPECT_TRUE(LeftRightQualifierAlignmentFixer::isQualifierOrType(Tokens[1]));
+  EXPECT_TRUE(LeftRightQualifierAlignmentFixer::isQualifierOrType(Tokens[2]));
+  EXPECT_TRUE(LeftRightQualifierAlignmentFixer::isQualifierOrType(Tokens[3]));
+  EXPECT_TRUE(LeftRightQualifierAlignmentFixer::isQualifierOrType(Tokens[4]));
+  EXPECT_TRUE(LeftRightQualifierAlignmentFixer::isQualifierOrType(Tokens[5]));
+  EXPECT_TRUE(LeftRightQualifierAlignmentFixer::isQualifierOrType(Tokens[6]));
+  EXPECT_TRUE(LeftRightQualifierAlignmentFixer::isQualifierOrType(Tokens[7]));
+  EXPECT_TRUE(LeftRightQualifierAlignmentFixer::isQualifierOrType(Tokens[8]));
+  EXPECT_TRUE(LeftRightQualifierAlignmentFixer::isQualifierOrType(Tokens[9]));
+
   auto NotTokens = annotate("for while do Foo Bar ");
 
-  EXPECT_FALSE(LeftRightQualifierAlignmentFixer::isQualifierOrType(
+  EXPECT_FALSE(LeftRightQualifierAlignmentFixer::isConfiguredQualifierOrType(
       NotTokens[0], ConfiguredTokens));
-  EXPECT_FALSE(LeftRightQualifierAlignmentFixer::isQualifierOrType(
+  EXPECT_FALSE(LeftRightQualifierAlignmentFixer::isConfiguredQualifierOrType(
       NotTokens[1], ConfiguredTokens));
-  EXPECT_FALSE(LeftRightQualifierAlignmentFixer::isQualifierOrType(
+  EXPECT_FALSE(LeftRightQualifierAlignmentFixer::isConfiguredQualifierOrType(
       NotTokens[2], ConfiguredTokens));
-  EXPECT_FALSE(LeftRightQualifierAlignmentFixer::isQualifierOrType(
+  EXPECT_FALSE(LeftRightQualifierAlignmentFixer::isConfiguredQualifierOrType(
       NotTokens[3], ConfiguredTokens));
-  EXPECT_FALSE(LeftRightQualifierAlignmentFixer::isQualifierOrType(
+  EXPECT_FALSE(LeftRightQualifierAlignmentFixer::isConfiguredQualifierOrType(
       NotTokens[4], ConfiguredTokens));
-  EXPECT_FALSE(LeftRightQualifierAlignmentFixer::isQualifierOrType(
+  EXPECT_FALSE(LeftRightQualifierAlignmentFixer::isConfiguredQualifierOrType(
       NotTokens[5], ConfiguredTokens));
+
+  EXPECT_FALSE(
+      LeftRightQualifierAlignmentFixer::isQualifierOrType(NotTokens[0]));
+  EXPECT_FALSE(
+      LeftRightQualifierAlignmentFixer::isQualifierOrType(NotTokens[1]));
+  EXPECT_FALSE(
+      LeftRightQualifierAlignmentFixer::isQualifierOrType(NotTokens[2]));
+  EXPECT_FALSE(
+      LeftRightQualifierAlignmentFixer::isQualifierOrType(NotTokens[3]));
+  EXPECT_FALSE(
+      LeftRightQualifierAlignmentFixer::isQualifierOrType(NotTokens[4]));
+  EXPECT_FALSE(
+      LeftRightQualifierAlignmentFixer::isQualifierOrType(NotTokens[5]));
 }
 
 TEST_F(QualifierFixerTest, IsMacro) {
 
   auto Tokens = annotate("INT INTPR Foo int");
 
   EXPECT_TRUE(LeftRightQualifierAlignmentFixer::isPossibleMacro(Tokens[0]));
   EXPECT_TRUE(LeftRightQualifierAlignmentFixer::isPossibleMacro(Tokens[1]));
TEST_F(QualifierFixerTest, OverlappingQualifier) {
 
   verifyFormat("Foo(const Bar &name);", "Foo(Bar const &name);", Style);
 }
 
 TEST_F(QualifierFixerTest, DontPushQualifierThroughNonSpecifiedTypes) {
 
   FormatStyle Style = getLLVMStyle();
   Style.QualifierAlignment = FormatStyle::QAS_Left;
-  Style.QualifierOrder = {"const", "type"};
+  Style.QualifierOrder = {"const", "volatile", "type"};
 
   verifyFormat("inline static const int a;", Style);
 
   Style.QualifierOrder = {"static", "const", "type"};
 
   verifyFormat("inline static const int a;", Style);
   verifyFormat("static inline const int a;", "static inline const int a;",
                Style);
 
   verifyFormat("static const int a;", "const static int a;", Style);
+
+  Style.QualifierOrder = {"const", "volatile", "type"};
+  // static is not configured, unchanged at right hand qualifiers.
+  verifyFormat("const volatile int static;", "int volatile static const;",
+               Style);
+  verifyFormat("const volatile int static;", "int const static volatile;",
+               Style);
+  verifyFormat("const volatile int static;", "const int static volatile;",
+               Style);
+  verifyFormat("const volatile Foo static;", "Foo volatile static const;",
+               Style);
+  verifyFormat("const volatile Foo static;", "Foo const static volatile;",
+               Style);
+  verifyFormat("const volatile Foo static;", "const Foo static volatile;",
+               Style);
+
+  verifyFormat("inline static const Foo;", "inline static Foo const;", Style);
+  verifyFormat("inline static const Foo;", "inline static const Foo;", Style);
+
+  // Don't move qualifiers to the right for aestethics only.
+  verifyFormat("inline const static Foo;", "inline const static Foo;", Style);
+  verifyFormat("const inline static Foo;", "const inline static Foo;", Style);
 }
 
 TEST_F(QualifierFixerTest, UnsignedQualifier) {
 
   FormatStyle Style = getLLVMStyle();
   Style.QualifierAlignment = FormatStyle::QAS_Left;
   Style.QualifierOrder = {"const", "type"};
 
verifyFormat("// clang-format off\n"
                Style);
 }
 
 TEST_F(QualifierFixerTest, TemplatesRight) {
   FormatStyle Style = getLLVMStyle();
   Style.QualifierAlignment = FormatStyle::QAS_Custom;
   Style.QualifierOrder = {"type", "const"};
 
+  verifyFormat("template <typename T> Foo const f();",
+               "template <typename T> const Foo f();", Style);
+  verifyFormat("template <typename T> int const f();",
+               "template <typename T> const int f();", Style);
+
+  verifyFormat("template <T const> t;", "template <const T> t;", Style);
   verifyFormat("template <typename T>\n"
                "  requires Concept<T const>\n"
-               "void f();",
+               "Foo const f();",
                "template <typename T>\n"
                "  requires Concept<const T>\n"
-               "void f();",
+               "const Foo f();",
                Style);
   verifyFormat("TemplateType<T const> t;", "TemplateType<const T> t;", Style);
   verifyFormat("TemplateType<Container const> t;",
                "TemplateType<const Container> t;", Style);
 }
 
 TEST_F(QualifierFixerTest, TemplatesLeft) {
   FormatStyle Style = getLLVMStyle();
   Style.QualifierAlignment = FormatStyle::QAS_Custom;
-  Style.QualifierOrder = {"const", "type"};
+  Style.QualifierOrder = {"const", "volatile", "type"};
+
+  verifyFormat("template <typename T> const Foo f();",
+               "template <typename T> Foo const f();", Style);
+  verifyFormat("template <typename T> const int f();",
+               "template <typename T> int const f();", Style);
 
   verifyFormat("template <const T> t;", "template <T const> t;", Style);
   verifyFormat("template <typename T>\n"
                "  requires Concept<const T>\n"
-               "void f();",
+               "const Foo f();",
+               "template <typename T>\n"
+               "  requires Concept<T const>\n"
+               "Foo const f();",
+               Style);
+  verifyFormat("template <typename T>\n"
+               "  requires Concept<const T>\n"
+               "const volatile Foo f();",
                "template <typename T>\n"
                "  requires Concept<T const>\n"
-               "void f();",
+               "volatile const Foo f();",
                Style);
   verifyFormat("TemplateType<const T> t;", "TemplateType<T const> t;", Style);
   verifyFormat("TemplateType<const Container> t;",
                "TemplateType<Container const> t;", Style);
 }
 
 } // namespace
 } // namespace test
 } // namespace format
 } // namespace clang