[clang-format][NFC] Group QualifierAlignment with other C++ passes

[owenpan]

Summary

Also increases the initial size of Passes to 8.

[owenpan]

Swapped the order of the definitions of BracesRemover and BracesInserter.

clang/lib/Format/Format.cpp

 
 llvm::Optional<FormatStyle>
 FormatStyle::GetLanguageStyle(FormatStyle::LanguageKind Language) const {
   return StyleSet.Get(Language);
 }
 
 namespace {
 
-class BracesRemover : public TokenAnalyzer {
+class BracesInserter : public TokenAnalyzer {
 public:
-  BracesRemover(const Environment &Env, const FormatStyle &Style)
+  BracesInserter(const Environment &Env, const FormatStyle &Style)
       : TokenAnalyzer(Env, Style) {}
 
   std::pair<tooling::Replacements, unsigned>
   analyze(TokenAnnotator &Annotator,
           SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
           FormatTokenLexer &Tokens) override {
     AffectedRangeMgr.computeAffectedLines(AnnotatedLines);
     tooling::Replacements Result;
-    removeBraces(AnnotatedLines, Result);
+    insertBraces(AnnotatedLines, Result);
     return {Result, 0};
   }
 
 private:
-  void removeBraces(SmallVectorImpl<AnnotatedLine *> &Lines,
+  void insertBraces(SmallVectorImpl<AnnotatedLine *> &Lines,
                     tooling::Replacements &Result) {
     const auto &SourceMgr = Env.getSourceManager();
     for (AnnotatedLine *Line : Lines) {
-      removeBraces(Line->Children, Result);
+      insertBraces(Line->Children, Result);
       if (!Line->Affected)
         continue;
       for (FormatToken *Token = Line->First; Token && !Token->Finalized;
            Token = Token->Next) {
-        if (!Token->Optional)
+        if (Token->BraceCount == 0)
           continue;
-        assert(Token->isOneOf(tok::l_brace, tok::r_brace));
-        assert(Token->Next || Token == Line->Last);
-        const auto Start =
-            Token == Line->Last || (Token->Next->is(tok::kw_else) &&
-                                    Token->Next->NewlinesBefore > 0)
-                ? Token->WhitespaceRange.getBegin()
-                : Token->Tok.getLocation();
-        const auto Range =
-            CharSourceRange::getCharRange(Start, Token->Tok.getEndLoc());
-        cantFail(Result.add(tooling::Replacement(SourceMgr, Range, "")));
+        std::string Brace;
+        if (Token->BraceCount < 0) {
+          assert(Token->BraceCount == -1);
+          Brace = '{';
+        } else {
+          Brace = '\n' + std::string(Token->BraceCount, '}');
+        }
+        Token->BraceCount = 0;
+        const auto Start = Token->Tok.getEndLoc();
+        cantFail(Result.add(tooling::Replacement(SourceMgr, Start, 0, Brace)));
       }
     }
   }
 };
 
-class BracesInserter : public TokenAnalyzer {
+class BracesRemover : public TokenAnalyzer {
 public:
-  BracesInserter(const Environment &Env, const FormatStyle &Style)
+  BracesRemover(const Environment &Env, const FormatStyle &Style)
       : TokenAnalyzer(Env, Style) {}
 
   std::pair<tooling::Replacements, unsigned>
   analyze(TokenAnnotator &Annotator,
           SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
           FormatTokenLexer &Tokens) override {
     AffectedRangeMgr.computeAffectedLines(AnnotatedLines);
     tooling::Replacements Result;
-    insertBraces(AnnotatedLines, Result);
+    removeBraces(AnnotatedLines, Result);
     return {Result, 0};
   }
 
 private:
-  void insertBraces(SmallVectorImpl<AnnotatedLine *> &Lines,
+  void removeBraces(SmallVectorImpl<AnnotatedLine *> &Lines,
                     tooling::Replacements &Result) {
     const auto &SourceMgr = Env.getSourceManager();
     for (AnnotatedLine *Line : Lines) {
-      insertBraces(Line->Children, Result);
+      removeBraces(Line->Children, Result);
       if (!Line->Affected)
         continue;
       for (FormatToken *Token = Line->First; Token && !Token->Finalized;
            Token = Token->Next) {
-        if (Token->BraceCount == 0)
+        if (!Token->Optional)
           continue;
-        std::string Brace;
-        if (Token->BraceCount < 0) {
-          assert(Token->BraceCount == -1);
-          Brace = '{';
-        } else {
-          Brace = '\n' + std::string(Token->BraceCount, '}');
-        }
-        Token->BraceCount = 0;
-        const auto Start = Token->Tok.getEndLoc();
-        cantFail(Result.add(tooling::Replacement(SourceMgr, Start, 0, Brace)));
+        assert(Token->isOneOf(tok::l_brace, tok::r_brace));
+        assert(Token->Next || Token == Line->Last);
+        const auto Start =
+            Token == Line->Last || (Token->Next->is(tok::kw_else) &&
+                                    Token->Next->NewlinesBefore > 0)
+                ? Token->WhitespaceRange.getBegin()
+                : Token->Tok.getLocation();
+        const auto Range =
+            CharSourceRange::getCharRange(Start, Token->Tok.getEndLoc());
+        cantFail(Result.add(tooling::Replacement(SourceMgr, Range, "")));
       }
     }
   }
 };
 
 class JavaScriptRequoter : public TokenAnalyzer {
 public:
   JavaScriptRequoter(const Environment &Env, const FormatStyle &Style)
if (!Replaces.add(tooling::Replacement(FileName, 0, 4, ""))) {
         return {Replaces, 0};
     }
     return {tooling::Replacements(), 0};
   }
 
   typedef std::function<std::pair<tooling::Replacements, unsigned>(
       const Environment &)>
       AnalyzerPass;
-  SmallVector<AnalyzerPass, 4> Passes;
+  SmallVector<AnalyzerPass, 8> Passes;
 
-  if (Style.isCpp() && Style.QualifierAlignment != FormatStyle::QAS_Leave) {
+  if (Style.isCpp()) {
+    if (Style.QualifierAlignment != FormatStyle::QAS_Leave) {
       Passes.emplace_back([&](const Environment &Env) {
         return QualifierAlignmentFixer(Env, Expanded, Code, Ranges,
                                        FirstStartColumn, NextStartColumn,
                                        LastStartColumn, FileName)
             .process();
       });
     }
 
-  if (Style.isCpp()) {
     if (Style.InsertBraces)
       Passes.emplace_back([&](const Environment &Env) {
         return BracesInserter(Env, Expanded).process();
       });
 
     if (Style.RemoveBracesLLVM)
       Passes.emplace_back([&](const Environment &Env) {
         return BracesRemover(Env, Expanded).process();