clang/lib/Format/QualifierAlignmentFixer.cpp

   1 //===--- QualifierAlignmentFixer.cpp ----------------------------*- C++--*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 ///
   9 /// \file
  10 /// This file implements QualifierAlignmentFixer, a TokenAnalyzer that
  11 /// enforces either left or right const depending on the style.
  12 ///
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "QualifierAlignmentFixer.h"
  16 #include "FormatToken.h"
  17 #include "llvm/Support/Debug.h"
  18 #include "llvm/Support/Regex.h"
  19
  20 #include <algorithm>
  21 #include <optional>
  22
  23 #define DEBUG_TYPE "format-qualifier-alignment-fixer"
  24
  25 namespace clang {
  26 namespace format {
  27
  28 void addQualifierAlignmentFixerPasses(const FormatStyle &Style,
  29                                       SmallVectorImpl<AnalyzerPass> &Passes) {
  30   std::vector<std::string> LeftOrder;
  31   std::vector<std::string> RightOrder;
  32   std::vector<tok::TokenKind> ConfiguredQualifierTokens;
  33   prepareLeftRightOrderingForQualifierAlignmentFixer(
  34       Style.QualifierOrder, LeftOrder, RightOrder, ConfiguredQualifierTokens);
  35
  36   // Handle the left and right alignment separately.
  37   for (const auto &Qualifier : LeftOrder) {
  38     Passes.emplace_back(
  39         [&, Qualifier, ConfiguredQualifierTokens](const Environment &Env) {
  40           return LeftRightQualifierAlignmentFixer(Env, Style, Qualifier,
  41                                                   ConfiguredQualifierTokens,
  42                                                   /*RightAlign=*/false)
  43               .process();
  44         });
  45   }
  46   for (const auto &Qualifier : RightOrder) {
  47     Passes.emplace_back(
  48         [&, Qualifier, ConfiguredQualifierTokens](const Environment &Env) {
  49           return LeftRightQualifierAlignmentFixer(Env, Style, Qualifier,
  50                                                   ConfiguredQualifierTokens,
  51                                                   /*RightAlign=*/true)
  52               .process();
  53         });
  54   }
  55 }
  56
  57 static void replaceToken(const SourceManager &SourceMgr,
  58                          tooling::Replacements &Fixes,
  59                          const CharSourceRange &Range, std::string NewText) {
  60   auto Replacement = tooling::Replacement(SourceMgr, Range, NewText);
  61   auto Err = Fixes.add(Replacement);
  62
  63   if (Err) {
  64     llvm::errs() << "Error while rearranging Qualifier : "
  65                  << llvm::toString(std::move(Err)) << "\n";
  66   }
  67 }
  68
  69 static void removeToken(const SourceManager &SourceMgr,
  70                         tooling::Replacements &Fixes,
  71                         const FormatToken *First) {
  72   auto Range = CharSourceRange::getCharRange(First->getStartOfNonWhitespace(),
  73                                              First->Tok.getEndLoc());
  74   replaceToken(SourceMgr, Fixes, Range, "");
  75 }
  76
  77 static void insertQualifierAfter(const SourceManager &SourceMgr,
  78                                  tooling::Replacements &Fixes,
  79                                  const FormatToken *First,
  80                                  const std::string &Qualifier) {
  81   auto Range = CharSourceRange::getCharRange(First->Tok.getLocation(),
  82                                              First->Tok.getEndLoc());
  83
  84   std::string NewText{};
  85   NewText += First->TokenText;
  86   NewText += " " + Qualifier;
  87   replaceToken(SourceMgr, Fixes, Range, NewText);
  88 }
  89
  90 static void insertQualifierBefore(const SourceManager &SourceMgr,
  91                                   tooling::Replacements &Fixes,
  92                                   const FormatToken *First,
  93                                   const std::string &Qualifier) {
  94   auto Range = CharSourceRange::getCharRange(First->getStartOfNonWhitespace(),
  95                                              First->Tok.getEndLoc());
  96
  97   std::string NewText = " " + Qualifier + " ";
  98   NewText += First->TokenText;
  99
 100   replaceToken(SourceMgr, Fixes, Range, NewText);
 101 }
 102
 103 static bool endsWithSpace(const std::string &s) {
 104   if (s.empty())
 105     return false;
 106   return isspace(s.back());
 107 }
 108
 109 static bool startsWithSpace(const std::string &s) {
 110   if (s.empty())
 111     return false;
 112   return isspace(s.front());
 113 }
 114
 115 static void rotateTokens(const SourceManager &SourceMgr,
 116                          tooling::Replacements &Fixes, const FormatToken *First,
 117                          const FormatToken *Last, bool Left) {
 118   auto *End = Last;
 119   auto *Begin = First;
 120   if (!Left) {
 121     End = Last->Next;
 122     Begin = First->Next;
 123   }
 124
 125   std::string NewText;
 126   // If we are rotating to the left we move the Last token to the front.
 127   if (Left) {
 128     NewText += Last->TokenText;
 129     NewText += " ";
 130   }
 131
 132   // Then move through the other tokens.
 133   auto *Tok = Begin;
 134   while (Tok != End) {
 135     if (!NewText.empty() && !endsWithSpace(NewText))
 136       NewText += " ";
 137
 138     NewText += Tok->TokenText;
 139     Tok = Tok->Next;
 140   }
 141
 142   // If we are rotating to the right we move the first token to the back.
 143   if (!Left) {
 144     if (!NewText.empty() && !startsWithSpace(NewText))
 145       NewText += " ";
 146     NewText += First->TokenText;
 147   }
 148
 149   auto Range = CharSourceRange::getCharRange(First->getStartOfNonWhitespace(),
 150                                              Last->Tok.getEndLoc());
 151
 152   replaceToken(SourceMgr, Fixes, Range, NewText);
 153 }
 154
 155 static bool
 156 isConfiguredQualifier(const FormatToken *const Tok,
 157                       const std::vector<tok::TokenKind> &Qualifiers) {
 158   return Tok && llvm::is_contained(Qualifiers, Tok->Tok.getKind());
 159 }
 160
 161 static bool isQualifier(const FormatToken *const Tok) {
 162   if (!Tok)
 163     return false;
 164
 165   switch (Tok->Tok.getKind()) {
 166   case tok::kw_const:
 167   case tok::kw_volatile:
 168   case tok::kw_static:
 169   case tok::kw_inline:
 170   case tok::kw_constexpr:
 171   case tok::kw_restrict:
 172   case tok::kw_friend:
 173     return true;
 174   default:
 175     return false;
 176   }
 177 }
 178
 179 const FormatToken *LeftRightQualifierAlignmentFixer::analyzeRight(
 180     const SourceManager &SourceMgr, const AdditionalKeywords &Keywords,
 181     tooling::Replacements &Fixes, const FormatToken *const Tok,
 182     const std::string &Qualifier, tok::TokenKind QualifierType) {
 183   // We only need to think about streams that begin with a qualifier.
 184   if (Tok->isNot(QualifierType))
 185     return Tok;
 186   // Don't concern yourself if nothing follows the qualifier.
 187   if (!Tok->Next)
 188     return Tok;
 189
 190   // Skip qualifiers to the left to find what preceeds the qualifiers.
 191   // Use isQualifier rather than isConfiguredQualifier to cover all qualifiers.
 192   const FormatToken *PreviousCheck = Tok->getPreviousNonComment();
 193   while (isQualifier(PreviousCheck))
 194     PreviousCheck = PreviousCheck->getPreviousNonComment();
 195
 196   // Examples given in order of ['type', 'const', 'volatile']
 197   const bool IsRightQualifier = PreviousCheck && [PreviousCheck]() {
 198     // The cases:
 199     // `Foo() const` -> `Foo() const`
 200     // `Foo() const final` -> `Foo() const final`
 201     // `Foo() const override` -> `Foo() const final`
 202     // `Foo() const volatile override` -> `Foo() const volatile override`
 203     // `Foo() volatile const final` -> `Foo() const volatile final`
 204     if (PreviousCheck->is(tok::r_paren))
 205       return true;
 206
 207     // The cases:
 208     // `struct {} volatile const a;` -> `struct {} const volatile a;`
 209     // `class {} volatile const a;` -> `class {} const volatile a;`
 210     if (PreviousCheck->is(tok::r_brace))
 211       return true;
 212
 213     // The case:
 214     // `template <class T> const Bar Foo()` ->
 215     // `template <class T> Bar const Foo()`
 216     // The cases:
 217     // `Foo<int> const foo` -> `Foo<int> const foo`
 218     // `Foo<int> volatile const` -> `Foo<int> const volatile`
 219     // The case:
 220     // ```
 221     // template <class T>
 222     //   requires Concept1<T> && requires Concept2<T>
 223     // const Foo f();
 224     // ```
 225     // ->
 226     // ```
 227     // template <class T>
 228     //   requires Concept1<T> && requires Concept2<T>
 229     // Foo const f();
 230     // ```
 231     if (PreviousCheck->is(TT_TemplateCloser)) {
 232       // If the token closes a template<> or requires clause, then it is a left
 233       // qualifier and should be moved to the right.
 234       return !(PreviousCheck->ClosesTemplateDeclaration ||
 235                PreviousCheck->ClosesRequiresClause);
 236     }
 237
 238     // The case  `Foo* const` -> `Foo* const`
 239     // The case  `Foo* volatile const` -> `Foo* const volatile`
 240     // The case  `int32_t const` -> `int32_t const`
 241     // The case  `auto volatile const` -> `auto const volatile`
 242     if (PreviousCheck->isOneOf(TT_PointerOrReference, tok::identifier,
 243                                tok::kw_auto)) {
 244       return true;
 245     }
 246
 247     return false;
 248   }();
 249
 250   // Find the last qualifier to the right.
 251   const FormatToken *LastQual = Tok;
 252   while (isQualifier(LastQual->getNextNonComment()))
 253     LastQual = LastQual->getNextNonComment();
 254
 255   // If this qualifier is to the right of a type or pointer do a partial sort
 256   // and return.
 257   if (IsRightQualifier) {
 258     if (LastQual != Tok)
 259       rotateTokens(SourceMgr, Fixes, Tok, LastQual, /*Left=*/false);
 260     return Tok;
 261   }
 262
 263   const FormatToken *TypeToken = LastQual->getNextNonComment();
 264   if (!TypeToken)
 265     return Tok;
 266
 267   // Stay safe and don't move past macros, also don't bother with sorting.
 268   if (isPossibleMacro(TypeToken))
 269     return Tok;
 270
 271   // The case `const long long int volatile` -> `long long int const volatile`
 272   // The case `long const long int volatile` -> `long long int const volatile`
 273   // The case `long long volatile int const` -> `long long int const volatile`
 274   // The case `const long long volatile int` -> `long long int const volatile`
 275   if (TypeToken->isSimpleTypeSpecifier()) {
 276     // The case `const decltype(foo)` -> `const decltype(foo)`
 277     // The case `const typeof(foo)` -> `const typeof(foo)`
 278     // The case `const _Atomic(foo)` -> `const _Atomic(foo)`
 279     if (TypeToken->isOneOf(tok::kw_decltype, tok::kw_typeof, tok::kw__Atomic))
 280       return Tok;
 281
 282     const FormatToken *LastSimpleTypeSpecifier = TypeToken;
 283     while (isQualifierOrType(LastSimpleTypeSpecifier->getNextNonComment()))
 284       LastSimpleTypeSpecifier = LastSimpleTypeSpecifier->getNextNonComment();
 285
 286     rotateTokens(SourceMgr, Fixes, Tok, LastSimpleTypeSpecifier,
 287                  /*Left=*/false);
 288     return LastSimpleTypeSpecifier;
 289   }
 290
 291   // The case  `unsigned short const` -> `unsigned short const`
 292   // The case:
 293   // `unsigned short volatile const` -> `unsigned short const volatile`
 294   if (PreviousCheck && PreviousCheck->isSimpleTypeSpecifier()) {
 295     if (LastQual != Tok)
 296       rotateTokens(SourceMgr, Fixes, Tok, LastQual, /*Left=*/false);
 297     return Tok;
 298   }
 299
 300   // Skip the typename keyword.
 301   // The case `const typename C::type` -> `typename C::type const`
 302   if (TypeToken->is(tok::kw_typename))
 303     TypeToken = TypeToken->getNextNonComment();
 304
 305   // Skip the initial :: of a global-namespace type.
 306   // The case `const ::...` -> `::... const`
 307   if (TypeToken->is(tok::coloncolon)) {
 308     // The case `const ::template Foo...` -> `::template Foo... const`
 309     TypeToken = TypeToken->getNextNonComment();
 310     if (TypeToken && TypeToken->is(tok::kw_template))
 311       TypeToken = TypeToken->getNextNonComment();
 312   }
 313
 314   // Don't change declarations such as
 315   // `foo(const struct Foo a);` -> `foo(const struct Foo a);`
 316   // as they would currently change code such as
 317   // `const struct my_struct_t {} my_struct;` -> `struct my_struct_t const {}
 318   // my_struct;`
 319   if (TypeToken->isOneOf(tok::kw_struct, tok::kw_class))
 320     return Tok;
 321
 322   if (TypeToken->isOneOf(tok::kw_auto, tok::identifier)) {
 323     // The case  `const auto` -> `auto const`
 324     // The case  `const Foo` -> `Foo const`
 325     // The case  `const ::Foo` -> `::Foo const`
 326     // The case  `const Foo *` -> `Foo const *`
 327     // The case  `const Foo &` -> `Foo const &`
 328     // The case  `const Foo &&` -> `Foo const &&`
 329     // The case  `const std::Foo &&` -> `std::Foo const &&`
 330     // The case  `const std::Foo<T> &&` -> `std::Foo<T> const &&`
 331     // The case  `const ::template Foo` -> `::template Foo const`
 332     // The case  `const T::template Foo` -> `T::template Foo const`
 333     const FormatToken *Next = nullptr;
 334     while ((Next = TypeToken->getNextNonComment()) &&
 335            (Next->is(TT_TemplateOpener) ||
 336             Next->startsSequence(tok::coloncolon, tok::identifier) ||
 337             Next->startsSequence(tok::coloncolon, tok::kw_template,
 338                                  tok::identifier))) {
 339       if (Next->is(TT_TemplateOpener)) {
 340         assert(Next->MatchingParen && "Missing template closer");
 341         TypeToken = Next->MatchingParen;
 342       } else if (Next->startsSequence(tok::coloncolon, tok::identifier)) {
 343         TypeToken = Next->getNextNonComment();
 344       } else {
 345         TypeToken = Next->getNextNonComment()->getNextNonComment();
 346       }
 347     }
 348
 349     // Place the Qualifier at the end of the list of qualifiers.
 350     while (isQualifier(TypeToken->getNextNonComment())) {
 351       // The case `volatile Foo::iter const` -> `Foo::iter const volatile`
 352       TypeToken = TypeToken->getNextNonComment();
 353     }
 354
 355     insertQualifierAfter(SourceMgr, Fixes, TypeToken, Qualifier);
 356     // Remove token and following whitespace.
 357     auto Range = CharSourceRange::getCharRange(
 358         Tok->getStartOfNonWhitespace(), Tok->Next->getStartOfNonWhitespace());
 359     replaceToken(SourceMgr, Fixes, Range, "");
 360   }
 361
 362   return Tok;
 363 }
 364
 365 const FormatToken *LeftRightQualifierAlignmentFixer::analyzeLeft(
 366     const SourceManager &SourceMgr, const AdditionalKeywords &Keywords,
 367     tooling::Replacements &Fixes, const FormatToken *const Tok,
 368     const std::string &Qualifier, tok::TokenKind QualifierType) {
 369   // We only need to think about streams that begin with a qualifier.
 370   if (Tok->isNot(QualifierType))
 371     return Tok;
 372   // Don't concern yourself if nothing preceeds the qualifier.
 373   if (!Tok->getPreviousNonComment())
 374     return Tok;
 375
 376   // Skip qualifiers to the left to find what preceeds the qualifiers.
 377   const FormatToken *TypeToken = Tok->getPreviousNonComment();
 378   while (isQualifier(TypeToken))
 379     TypeToken = TypeToken->getPreviousNonComment();
 380
 381   // For left qualifiers preceeded by nothing, a template declaration, or *,&,&&
 382   // we only perform sorting.
 383   if (!TypeToken || TypeToken->isOneOf(tok::star, tok::amp, tok::ampamp) ||
 384       TypeToken->ClosesRequiresClause || TypeToken->ClosesTemplateDeclaration) {
 385
 386     // Don't sort past a non-configured qualifier token.
 387     const FormatToken *FirstQual = Tok;
 388     while (isConfiguredQualifier(FirstQual->getPreviousNonComment(),
 389                                  ConfiguredQualifierTokens)) {
 390       FirstQual = FirstQual->getPreviousNonComment();
 391     }
 392
 393     if (FirstQual != Tok)
 394       rotateTokens(SourceMgr, Fixes, FirstQual, Tok, /*Left=*/true);
 395     return Tok;
 396   }
 397
 398   // Stay safe and don't move past macros, also don't bother with sorting.
 399   if (isPossibleMacro(TypeToken))
 400     return Tok;
 401
 402   // Examples given in order of ['const', 'volatile', 'type']
 403
 404   // The case `volatile long long int const` -> `const volatile long long int`
 405   // The case `volatile long long const int` -> `const volatile long long int`
 406   // The case `const long long volatile int` -> `const volatile long long int`
 407   // The case `long volatile long int const` -> `const volatile long long int`
 408   if (TypeToken->isSimpleTypeSpecifier()) {
 409     const FormatToken *LastSimpleTypeSpecifier = TypeToken;
 410     while (isConfiguredQualifierOrType(
 411         LastSimpleTypeSpecifier->getPreviousNonComment(),
 412         ConfiguredQualifierTokens)) {
 413       LastSimpleTypeSpecifier =
 414           LastSimpleTypeSpecifier->getPreviousNonComment();
 415     }
 416
 417     rotateTokens(SourceMgr, Fixes, LastSimpleTypeSpecifier, Tok,
 418                  /*Left=*/true);
 419     return Tok;
 420   }
 421
 422   if (TypeToken->isOneOf(tok::kw_auto, tok::identifier, TT_TemplateCloser)) {
 423     const auto IsStartOfType = [](const FormatToken *const Tok) -> bool {
 424       if (!Tok)
 425         return true;
 426
 427       // A template closer is not the start of a type.
 428       // The case `?<> const` -> `const ?<>`
 429       if (Tok->is(TT_TemplateCloser))
 430         return false;
 431
 432       const FormatToken *const Previous = Tok->getPreviousNonComment();
 433       if (!Previous)
 434         return true;
 435
 436       // An identifier preceeded by :: is not the start of a type.
 437       // The case `?::Foo const` -> `const ?::Foo`
 438       if (Tok->is(tok::identifier) && Previous->is(tok::coloncolon))
 439         return false;
 440
 441       const FormatToken *const PrePrevious = Previous->getPreviousNonComment();
 442       // An identifier preceeded by ::template is not the start of a type.
 443       // The case `?::template Foo const` -> `const ?::template Foo`
 444       if (Tok->is(tok::identifier) && Previous->is(tok::kw_template) &&
 445           PrePrevious && PrePrevious->is(tok::coloncolon)) {
 446         return false;
 447       }
 448
 449       return true;
 450     };
 451
 452     while (!IsStartOfType(TypeToken)) {
 453       // The case `?<>`
 454       if (TypeToken->is(TT_TemplateCloser)) {
 455         assert(TypeToken->MatchingParen && "Missing template opener");
 456         TypeToken = TypeToken->MatchingParen->getPreviousNonComment();
 457       } else {
 458         // The cases
 459         // `::Foo`
 460         // `?>::Foo`
 461         // `?Bar::Foo`
 462         // `::template Foo`
 463         // `?>::template Foo`
 464         // `?Bar::template Foo`
 465         if (TypeToken->getPreviousNonComment()->is(tok::kw_template))
 466           TypeToken = TypeToken->getPreviousNonComment();
 467
 468         const FormatToken *const ColonColon =
 469             TypeToken->getPreviousNonComment();
 470         const FormatToken *const PreColonColon =
 471             ColonColon->getPreviousNonComment();
 472         if (PreColonColon &&
 473             PreColonColon->isOneOf(TT_TemplateCloser, tok::identifier)) {
 474           TypeToken = PreColonColon;
 475         } else {
 476           TypeToken = ColonColon;
 477         }
 478       }
 479     }
 480
 481     assert(TypeToken && "Should be auto or identifier");
 482
 483     // Place the Qualifier at the start of the list of qualifiers.
 484     const FormatToken *Previous = nullptr;
 485     while ((Previous = TypeToken->getPreviousNonComment()) &&
 486            (isConfiguredQualifier(Previous, ConfiguredQualifierTokens) ||
 487             Previous->is(tok::kw_typename))) {
 488       // The case `volatile Foo::iter const` -> `const volatile Foo::iter`
 489       // The case `typename C::type const` -> `const typename C::type`
 490       TypeToken = Previous;
 491     }
 492
 493     // Don't change declarations such as
 494     // `foo(struct Foo const a);` -> `foo(struct Foo const a);`
 495     if (!Previous || !Previous->isOneOf(tok::kw_struct, tok::kw_class)) {
 496       insertQualifierBefore(SourceMgr, Fixes, TypeToken, Qualifier);
 497       removeToken(SourceMgr, Fixes, Tok);
 498     }
 499   }
 500
 501   return Tok;
 502 }
 503
 504 tok::TokenKind LeftRightQualifierAlignmentFixer::getTokenFromQualifier(
 505     const std::string &Qualifier) {
 506   // Don't let 'type' be an identifier, but steal typeof token.
 507   return llvm::StringSwitch<tok::TokenKind>(Qualifier)
 508       .Case("type", tok::kw_typeof)
 509       .Case("const", tok::kw_const)
 510       .Case("volatile", tok::kw_volatile)
 511       .Case("static", tok::kw_static)
 512       .Case("inline", tok::kw_inline)
 513       .Case("constexpr", tok::kw_constexpr)
 514       .Case("restrict", tok::kw_restrict)
 515       .Case("friend", tok::kw_friend)
 516       .Default(tok::identifier);
 517 }
 518
 519 LeftRightQualifierAlignmentFixer::LeftRightQualifierAlignmentFixer(
 520     const Environment &Env, const FormatStyle &Style,
 521     const std::string &Qualifier,
 522     const std::vector<tok::TokenKind> &QualifierTokens, bool RightAlign)
 523     : TokenAnalyzer(Env, Style), Qualifier(Qualifier), RightAlign(RightAlign),
 524       ConfiguredQualifierTokens(QualifierTokens) {}
 525
 526 std::pair<tooling::Replacements, unsigned>
 527 LeftRightQualifierAlignmentFixer::analyze(
 528     TokenAnnotator & /*Annotator*/,
 529     SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
 530     FormatTokenLexer &Tokens) {
 531   tooling::Replacements Fixes;
 532   const AdditionalKeywords &Keywords = Tokens.getKeywords();
 533   const SourceManager &SourceMgr = Env.getSourceManager();
 534   AffectedRangeMgr.computeAffectedLines(AnnotatedLines);
 535
 536   tok::TokenKind QualifierToken = getTokenFromQualifier(Qualifier);
 537   assert(QualifierToken != tok::identifier && "Unrecognised Qualifier");
 538
 539   for (AnnotatedLine *Line : AnnotatedLines) {
 540     if (!Line->Affected || Line->InPPDirective)
 541       continue;
 542     FormatToken *First = Line->First;
 543     assert(First);
 544     if (First->Finalized)
 545       continue;
 546
 547     const auto *Last = Line->Last;
 548
 549     for (const auto *Tok = First; Tok && Tok != Last && Tok->Next;
 550          Tok = Tok->Next) {
 551       if (Tok->is(tok::comment))
 552         continue;
 553       if (RightAlign) {
 554         Tok = analyzeRight(SourceMgr, Keywords, Fixes, Tok, Qualifier,
 555                            QualifierToken);
 556       } else {
 557         Tok = analyzeLeft(SourceMgr, Keywords, Fixes, Tok, Qualifier,
 558                           QualifierToken);
 559       }
 560     }
 561   }
 562   return {Fixes, 0};
 563 }
 564
 565 void prepareLeftRightOrderingForQualifierAlignmentFixer(
 566     const std::vector<std::string> &Order, std::vector<std::string> &LeftOrder,
 567     std::vector<std::string> &RightOrder,
 568     std::vector<tok::TokenKind> &Qualifiers) {
 569
 570   // Depending on the position of type in the order you need
 571   // To iterate forward or backward through the order list as qualifier
 572   // can push through each other.
 573   // The Order list must define the position of "type" to signify
 574   assert(llvm::is_contained(Order, "type") &&
 575          "QualifierOrder must contain type");
 576   // Split the Order list by type and reverse the left side.
 577
 578   bool left = true;
 579   for (const auto &s : Order) {
 580     if (s == "type") {
 581       left = false;
 582       continue;
 583     }
 584
 585     tok::TokenKind QualifierToken =
 586         LeftRightQualifierAlignmentFixer::getTokenFromQualifier(s);
 587     if (QualifierToken != tok::kw_typeof && QualifierToken != tok::identifier)
 588       Qualifiers.push_back(QualifierToken);
 589
 590     if (left) {
 591       // Reverse the order for left aligned items.
 592       LeftOrder.insert(LeftOrder.begin(), s);
 593     } else {
 594       RightOrder.push_back(s);
 595     }
 596   }
 597 }
 598
 599 bool LeftRightQualifierAlignmentFixer::isQualifierOrType(
 600     const FormatToken *const Tok) {
 601   return Tok && (Tok->isSimpleTypeSpecifier() || Tok->is(tok::kw_auto) ||
 602                  isQualifier(Tok));
 603 }
 604
 605 bool LeftRightQualifierAlignmentFixer::isConfiguredQualifierOrType(
 606     const FormatToken *const Tok,
 607     const std::vector<tok::TokenKind> &Qualifiers) {
 608   return Tok && (Tok->isSimpleTypeSpecifier() || Tok->is(tok::kw_auto) ||
 609                  isConfiguredQualifier(Tok, Qualifiers));
 610 }
 611
 612 // If a token is an identifier and it's upper case, it could
 613 // be a macro and hence we need to be able to ignore it.
 614 bool LeftRightQualifierAlignmentFixer::isPossibleMacro(const FormatToken *Tok) {
 615   if (!Tok)
 616     return false;
 617   if (Tok->isNot(tok::identifier))
 618     return false;
 619   if (Tok->TokenText.upper() == Tok->TokenText.str()) {
 620     // T,K,U,V likely could be template arguments
 621     return Tok->TokenText.size() != 1;
 622   }
 623   return false;
 624 }
 625
 626 } // namespace format
 627 } // namespace clang