clang-format: When a line is formatted, also format subsequence lines if their indent is off.

[djasper]

Summary

This is especially important so that if a change is solely inserting a block around a few statements, clang-format-diff.py will still clean up and add indentation to the inner parts.

[klimek]

lg

lib/Format/UnwrappedLineFormatter.cpp

if (DryRun && CacheIt != PenaltyCache.end())
     return CacheIt->second;
 
   assert(!Lines.empty());
   unsigned Penalty = 0;
   LevelIndentTracker IndentTracker(Style, Keywords, Lines[0]->Level,
                                    AdditionalIndent);
   const AnnotatedLine *PreviousLine = nullptr;
   const AnnotatedLine *NextLine = nullptr;
+  bool PreviousLineFormatted = false;
   for (const AnnotatedLine *Line =
            Joiner.getNextMergedLine(DryRun, IndentTracker);
        Line; Line = NextLine) {
     const AnnotatedLine &TheLine = *Line;
     unsigned Indent = IndentTracker.getIndent();
-    bool FixIndentation =
-        FixBadIndentation && (Indent != TheLine.First->OriginalColumn);
+    bool FixIndentation = (FixBadIndentation || PreviousLineFormatted) &&
+                          Indent != TheLine.First->OriginalColumn;
     bool ShouldFormat = TheLine.Affected || FixIndentation;
     // We cannot format this line; if the reason is that the line had a
     // parsing error, remember that.
     if (ShouldFormat && TheLine.Type == LT_Invalid && IncompleteFormat)
       *IncompleteFormat = true;
 
     if (ShouldFormat && TheLine.Type != LT_Invalid) {
       if (!DryRun)
if (ShouldFormat && TheLine.Type != LT_Invalid) {
         NoColumnLimitLineFormatter(Indenter, Whitespaces, Style, this)
             .formatLine(TheLine, Indent, DryRun);
       else if (FitsIntoOneLine)
         Penalty += NoLineBreakFormatter(Indenter, Whitespaces, Style, this)
                        .formatLine(TheLine, Indent, DryRun);
       else
         Penalty += OptimizingLineFormatter(Indenter, Whitespaces, Style, this)
                        .formatLine(TheLine, Indent, DryRun);
+      PreviousLineFormatted = true;
     } else {
       // If no token in the current line is affected, we still need to format
       // affected children.
       if (TheLine.ChildrenAffected)
         format(TheLine.Children, DryRun);
 
       // Adapt following lines on the current indent level to the same level
       // unless the current \c AnnotatedLine is not at the beginning of a line.
if (ShouldFormat && TheLine.Type != LT_Invalid) {
           Whitespaces->addUntouchableToken(*TheLine.First,
                                            TheLine.InPPDirective);
 
         // Notify the WhitespaceManager about the unchanged whitespace.
         for (FormatToken *Tok = TheLine.First->Next; Tok; Tok = Tok->Next)
           Whitespaces->addUntouchableToken(*Tok, TheLine.InPPDirective);
       }
       NextLine = Joiner.getNextMergedLine(DryRun, IndentTracker);
+      PreviousLineFormatted = false;
     }
     if (!DryRun)
       markFinalized(TheLine.First);
     PreviousLine = &TheLine;
   }
   PenaltyCache[CacheKey] = Penalty;
   return Penalty;
 }

test/Format/adjust-indent.cpp

+// RUN: grep -Ev "// *[A-Z-]+:" %s | clang-format -lines=2:2 \
+// RUN:   | FileCheck -strict-whitespace %s
+
+void  f() {
+// CHECK: void f() {
+int i;
+// CHECK: {{^  int\ i;}}
+ int j;
+// CHECK: {{^  int\ j;}}
+}

test/Format/line-ranges.cpp

 // RUN: grep -Ev "// *[A-Z-]+:" %s \
 // RUN:   | clang-format -style=LLVM -lines=1:1 -lines=5:5 \
 // RUN:   | FileCheck -strict-whitespace %s
 // CHECK: {{^int\ \*i;$}}
   int*i;
 
-// CHECK: {{^\ \ int\ \ \*\ \ i;$}}
-  int  *  i; 
+// CHECK: {{^int\ \ \*\ \ i;$}}
 
-// CHECK: {{^\ \ int\ \*i;$}}
-  int   *   i;
+// CHECK: {{^int\ \*i;$}}

test/Format/ranges.cpp

 // RUN: grep -Ev "// *[A-Z-]+:" %s \
 // RUN:   | clang-format -style=LLVM -offset=2 -length=0 -offset=28 -length=0 \
 // RUN:   | FileCheck -strict-whitespace %s
 // CHECK: {{^int\ \*i;$}}
-  int*i;
 
-// CHECK: {{^\ \ int\ \ \*\ \ i;$}}
-  int  *  i; 
+// CHECK: {{^int\ \ \*\ \ i;$}}
 
-// CHECK: {{^\ \ int\ \*i;$}}
-  int   *   i;
+// CHECK: {{^int\ \*i;$}}

unittests/Format/FormatTestSelective.cpp

 TEST_F(FormatTestSelective, RemovesTrailingWhitespaceOfFormattedLine) {
   EXPECT_EQ("int a;\nint b;", format("int a; \nint b;", 0, 0));
   EXPECT_EQ("int a;", format("int a;         ", 0, 0));
   EXPECT_EQ("int a;\n", format("int a;  \n   \n   \n ", 0, 0));
   EXPECT_EQ("int a;\nint b;    ", format("int a;  \nint b;    ", 0, 0));
 }
 
 TEST_F(FormatTestSelective, FormatsCorrectRegionForLeadingWhitespace) {
-  EXPECT_EQ("int b;\nint a;", format("int b;\n   int a;", 7, 0));
-  EXPECT_EQ("int b;\n   int a;", format("int b;\n   int a;", 6, 0));
+  EXPECT_EQ("{int b;\n"
+            "  int a;\n"
+            "}",
+            format("{int b;\n  int  a;}", 8, 0));
+  EXPECT_EQ("{\n"
+            "  int b;\n"
+            "  int  a;}",
+            format("{int b;\n  int  a;}", 7, 0));
 
   Style.ColumnLimit = 12;
   EXPECT_EQ("#define A  \\\n"
             "  int a;   \\\n"
             "  int b;",
             format("#define A  \\\n"
                    "  int a;   \\\n"
                    "    int b;",
TEST_F(FormatTestSelective, RemovesWhitespaceWhenTriggeredOnEmptyLine) {
   EXPECT_EQ("int  a;\n\n int b;", format("int  a;\n  \n\n int b;", 9, 0));
 }
 
 TEST_F(FormatTestSelective, ReformatsMovedLines) {
   EXPECT_EQ(
       "template <typename T> T *getFETokenInfo() const {\n"
       "  return static_cast<T *>(FETokenInfo);\n"
       "}\n"
-      "  int a; // <- Should not be formatted",
+      "int  a; // <- Should not be formatted",
       format(
           "template<typename T>\n"
           "T *getFETokenInfo() const { return static_cast<T*>(FETokenInfo); }\n"
-          "  int a; // <- Should not be formatted",
+          "int  a; // <- Should not be formatted",
           9, 5));
 }
 
 TEST_F(FormatTestSelective, FormatsIfWithoutCompoundStatement) {
   Style.AllowShortIfStatementsOnASingleLine = true;
   EXPECT_EQ("if (a) return;", format("if(a)\nreturn;", 7, 1));
   EXPECT_EQ("if (a) return; // comment",
             format("if(a)\nreturn; // comment", 20, 1));
EXPECT_EQ("int a; // This\n"
                    "     // a\n"
                    "// This is b\n"
                    "int b;",
                    0, 0));
   EXPECT_EQ("int a; // This\n"
             "       // is\n"
             "       // a\n"
             "\n"
-            "  // This is unrelated",
+            "//This is unrelated",
             format("int a; // This\n"
                    "     // is\n"
                    "     // a\n"
                    "\n"
-                   "  // This is unrelated",
+                   "//This is unrelated",
                    0, 0));
   EXPECT_EQ("int a;\n"
             "// This is\n"
             "// not formatted.   ",
             format("int a;\n"
                    "// This is\n"
                    "// not formatted.   ",
                    0, 0));
EXPECT_EQ("{\n"
                    "a;\n"
                    "     b;\n"
                    "}\n"
                    "}",
                    13, 2));
   EXPECT_EQ("{\n"
             "{\n"
             "  a;\n"
-            "b;\n"
+            "  b;\n"
+            "  c;\n"
+            " d;\n"
             "}\n"
             "}",
             format("{\n"
                    "{\n"
                    "     a;\n"
-                   "b;\n"
+                   "   b;\n"
+                   "  c;\n"
+                   " d;\n"
                    "}\n"
                    "}",
                    9, 2));
   EXPECT_EQ("{\n"
             "{\n"
             "public:\n"
             "  b;\n"
             "}\n"