[clang-format cleanup] merge continuous deleted lines into one deletion.

[ioeric]

Summary

This cleans up "\n" among continuous lines when they are deleted.

[ioeric]

• Fixed a nit.

[ioeric]

post-vacation ping :)

[idlecode]

lib/Format/Format.cpp

1182

Could you add brackets around loop body?

1184

While you are here, could you get rid of Tokens vector too?
I believe iterating over DeletedTokensdirectly will do the job.

[idlecode]

Few other tests (ChangeNamespaceTest from extra repository) require update too.

lib/Format/Format.cpp

for (auto &Line : AnnotatedLines) {
         cleanupRight(Line->First, tok::l_paren, tok::comma);
         cleanupLeft(Line->First, tok::comma, tok::r_paren);
         cleanupLeft(Line->First, TT_CtorInitializerComma, tok::l_brace);
         cleanupLeft(Line->First, TT_CtorInitializerColon, tok::l_brace);
         cleanupLeft(Line->First, TT_CtorInitializerColon, tok::equal);
       }
     }
 
-    return generateFixes();
+    return generateFixes(AnnotatedLines);
   }
 
 private:
   bool containsOnlyComments(const AnnotatedLine &Line) {
     for (FormatToken *Tok = Line.First; Tok != nullptr; Tok = Tok->Next) {
       if (Tok->isNot(tok::comment))
         return false;
     }
private:
   }
 
   // Delete the given token.
   inline void deleteToken(FormatToken *Tok) {
     if (Tok)
       DeletedTokens.insert(Tok);
   }
 
-  tooling::Replacements generateFixes() {
+  tooling::Replacements
+  generateFixes(const SmallVectorImpl<AnnotatedLine *> &AnnotatedLines) {
+    // A map from the last token of a line to the first token of the next line
+    // if it exists.
+    std::map<FormatToken *, FormatToken *> LastToNextLineFirst;
+    for (auto I = AnnotatedLines.begin(), E = std::prev(AnnotatedLines.end());
+         I != E; ++I)
+      LastToNextLineFirst[(*I)->Last] = (*std::next(I))->First;
     tooling::Replacements Fixes;
     std::vector<FormatToken *> Tokens;
     std::copy(DeletedTokens.begin(), DeletedTokens.end(),
               std::back_inserter(Tokens));
 
+    auto NextTokenInFile = [&LastToNextLineFirst](FormatToken *Tok) {
+      return Tok->Next ? Tok->Next : LastToNextLineFirst[Tok];
+    };
     // Merge multiple continuous token deletions into one big deletion so that
     // the number of replacements can be reduced. This makes computing affected
     // ranges more efficient when we run reformat on the changed code.
+    // FIXME: delete trailing '\n' when deleting an entire line.
     unsigned Idx = 0;
     while (Idx < Tokens.size()) {
       unsigned St = Idx, End = Idx;
       while ((End + 1) < Tokens.size() &&
-             Tokens[End]->Next == Tokens[End + 1]) {
+             NextTokenInFile(Tokens[End]) == Tokens[End + 1]) {
         End++;
       }
       auto SR = CharSourceRange::getCharRange(Tokens[St]->Tok.getLocation(),
                                               Tokens[End]->Tok.getEndLoc());
       auto Err =
           Fixes.add(tooling::Replacement(Env.getSourceManager(), SR, ""));
       // FIXME: better error handling. for now just print error message and skip
       // for the release version.

unittests/Format/CleanupTest.cpp

std::string cleanupAroundOffsets(llvm::ArrayRef<unsigned> Offsets,
     return cleanup(Code, Ranges);
   }
 };
 
 TEST_F(CleanupTest, DeleteEmptyNamespaces) {
   std::string Code = "namespace A {\n"
                      "namespace B {\n"
                      "} // namespace B\n"
-                     "} // namespace A\n\n"
+                     "} // namespace A\n"
                      "namespace C {\n"
                      "namespace D { int i; }\n"
                      "inline namespace E { namespace { } }\n"
                      "}";
-  std::string Expected = "\n\n\n\n\nnamespace C {\n"
-                         "namespace D { int i; }\n   \n"
+  std::string Expected = "\nnamespace C {\n"
+                         "namespace D { int i; }\n\n"
                          "}";
   EXPECT_EQ(Expected, cleanupAroundOffsets({28, 91, 132}, Code));
 }
 
 TEST_F(CleanupTest, NamespaceWithSyntaxError) {
   std::string Code = "namespace A {\n"
                      "namespace B {\n" // missing r_brace
                      "} // namespace A\n\n"
                      "namespace C {\n"
                      "namespace D int i; }\n"
                      "inline namespace E { namespace { } }\n"
                      "}";
   std::string Expected = "namespace A {\n"
-                         "\n\n\nnamespace C {\n"
-                         "namespace D int i; }\n   \n"
+                         "\n\nnamespace C {\n"
+                         "namespace D int i; }\n\n"
                          "}";
   std::vector<tooling::Range> Ranges(1, tooling::Range(0, Code.size()));
   EXPECT_EQ(Expected, cleanup(Code, Ranges));
 }
 
 TEST_F(CleanupTest, EmptyNamespaceNotAffected) {
   std::string Code = "namespace A {\n\n"
                      "namespace {\n\n}}";
   // Even though the namespaces are empty, but the inner most empty namespace
   // block is not affected by the changed ranges.
   std::string Expected = "namespace A {\n\n"
                          "namespace {\n\n}}";
   // Set the changed range to be the second "\n".
   EXPECT_EQ(Expected, cleanupAroundOffsets({14}, Code));
 }
 
 TEST_F(CleanupTest, EmptyNamespaceWithCommentsNoBreakBeforeBrace) {
   std::string Code = "namespace A {\n"
                      "namespace B {\n"
                      "// Yo\n"
                      "} // namespace B\n"
                      "} // namespace A\n"
                      "namespace C { // Yo\n"
                      "}";
-  std::string Expected = "\n\n\n\n\n\n";
+  std::string Expected = "";
   std::vector<tooling::Range> Ranges(1, tooling::Range(0, Code.size()));
   std::string Result = cleanup(Code, Ranges);
   EXPECT_EQ(Expected, Result);
 }
 
 TEST_F(CleanupTest, EmptyNamespaceWithCommentsBreakBeforeBrace) {
   std::string Code = "namespace A\n"
                      "/* Yo */ {\n"
                      "namespace B\n"
                      "{\n"
                      "// Yo\n"
                      "} // namespace B\n"
                      "} // namespace A\n"
                      "namespace C\n"
                      "{ // Yo\n"
                      "}\n";
-  std::string Expected = "\n\n\n\n\n\n\n\n\n\n";
+  std::string Expected = "\n";
   std::vector<tooling::Range> Ranges(1, tooling::Range(0, Code.size()));
   FormatStyle Style = getLLVMStyle();
   Style.BraceWrapping.AfterNamespace = true;
   std::string Result = cleanup(Code, Ranges, Style);
   EXPECT_EQ(Expected, Result);
 }
 
 TEST_F(CleanupTest, EmptyNamespaceAroundConditionalCompilation) {
TEST_F(CleanupTest, CtorInitializerInNamespace) {
   std::string Code = "namespace A {\n"
                      "namespace B {\n" // missing r_brace
                      "} // namespace A\n\n"
                      "namespace C {\n"
                      "class A { A() : x(0),, {} };\n"
                      "inline namespace E { namespace { } }\n"
                      "}";
   std::string Expected = "namespace A {\n"
-                         "\n\n\nnamespace C {\n"
-                         "class A { A() : x(0) {} };\n   \n"
+                         "\n\nnamespace C {\n"
+                         "class A { A() : x(0) {} };\n\n"
                          "}";
   std::vector<tooling::Range> Ranges(1, tooling::Range(0, Code.size()));
   std::string Result = cleanup(Code, Ranges);
   EXPECT_EQ(Expected, Result);
 }
 
 class CleanUpReplacementsTest : public ReplacementTest {
 protected: