From 1a925bce18ea691d9bc7b2810715f37657ca8f51 Mon Sep 17 00:00:00 2001
From: Daniel Jasper <djasper@google.com>
Date: Thu, 5 Sep 2013 10:48:50 +0000
Subject: [PATCH] Address post-commit review comments from r190038.

Mostly additional comments :-).

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@190042 91177308-0d34-0410-b5e6-96231b3b80d8
---
 lib/Format/ContinuationIndenter.cpp | 17 +++++++++++++++++
 lib/Format/Format.cpp               |  9 +++++----
 lib/Format/TokenAnnotator.h         |  1 -
 3 files changed, 22 insertions(+), 5 deletions(-)

diff --git a/lib/Format/ContinuationIndenter.cpp b/lib/Format/ContinuationIndenter.cpp
index c47d799f44..c894a4b29e 100644
--- a/lib/Format/ContinuationIndenter.cpp
+++ b/lib/Format/ContinuationIndenter.cpp
@@ -511,6 +511,21 @@ unsigned ContinuationIndenter::moveStateToNextToken(LineState &State,
     bool AvoidBinPacking;
     if (Current.is(tok::l_brace)) {
       if (Current.MatchingParen && Current.BlockKind == BK_Block) {
+        // If this is an l_brace starting a nested block, we pretend (wrt. to
+        // indentation) that we already consumed the corresponding r_brace.
+        // Thus, we remove all ParenStates caused bake fake parentheses that end
+        // at the r_brace. The net effect of this is that we don't indent
+        // relative to the l_brace, if the nested block is the last parameter of
+        // a function. For example, this formats:
+        //
+        //   SomeFunction(a, [] {
+        //     f();  // break
+        //   });
+        //
+        // instead of:
+        //   SomeFunction(a, [] {
+        //                        f();  // break
+        //                      });
         for (unsigned i = 0; i != Current.MatchingParen->FakeRParens; ++i)
           State.Stack.pop_back();
         NewIndent = State.Stack.back().LastSpace;
@@ -565,6 +580,8 @@ unsigned ContinuationIndenter::moveStateToNextToken(LineState &State,
   // Remove scopes created by fake parenthesis.
   if (Current.isNot(tok::r_brace) ||
       (Current.MatchingParen && Current.MatchingParen->BlockKind != BK_Block)) {
+    // Don't remove FakeRParens attached to r_braces that surround nested blocks
+    // as they will have been removed early (see above).
     for (unsigned i = 0, e = Current.FakeRParens; i != e; ++i) {
       unsigned VariablePos = State.Stack.back().VariablePos;
       State.Stack.pop_back();
diff --git a/lib/Format/Format.cpp b/lib/Format/Format.cpp
index 512f99f5e7..c482c402ec 100644
--- a/lib/Format/Format.cpp
+++ b/lib/Format/Format.cpp
@@ -489,8 +489,8 @@ private:
     ++Count;
   }
 
-  /// \brief Format all children of \p Tok assuming the parent is indented to
-  /// \p ParentIndent.
+  /// \brief If the \p State's next token is an r_brace closing a nested block,
+  /// format the nested block before it.
   ///
   /// Returns \c true if all children could be placed successfully and adapts
   /// \p Penalty as well as \p State. If \p DryRun is false, also directly
@@ -514,7 +514,9 @@ private:
     const FormatToken &LBrace = *State.NextToken->Previous;
     if (LBrace.isNot(tok::l_brace) || LBrace.BlockKind != BK_Block ||
         LBrace.Children.size() == 0)
-      return true; // The previous token does not open a block. Nothing to do.
+      // The previous token does not open a block. Nothing to do. We don't
+      // assert so that we can simply call this function for all tokens.
+      return true; 
 
     if (NewLine) {
       unsigned ParentIndent = State.Stack.back().Indent;
@@ -734,7 +736,6 @@ public:
     for (unsigned i = 0, e = AnnotatedLines.size(); i != e; ++i) {
       delete AnnotatedLines[i];
     }
-    AnnotatedLines.clear();
   }
 
   tooling::Replacements format() {
diff --git a/lib/Format/TokenAnnotator.h b/lib/Format/TokenAnnotator.h
index 8e8d076819..5546cdc49d 100644
--- a/lib/Format/TokenAnnotator.h
+++ b/lib/Format/TokenAnnotator.h
@@ -66,7 +66,6 @@ public:
     for (unsigned i = 0, e = Children.size(); i != e; ++i) {
       delete Children[i];
     }
-    Children.clear();
   }
 
   FormatToken *First;
-- 
2.40.0