clang-format: Indent relative to unary operators.

Before:
  if (!aaaaaaaaaa(  // break
          aaaaa)) {
  }

After:
  if (!aaaaaaaaaa(  // break
           aaaaa)) {
  }

Also cleaned up formatting using clang-format.

llvm-svn: 188891

clang/lib/Format/ContinuationIndenter.cpp

@@ -365,11 +365,13 @@ unsigned ContinuationIndenter::addTokenToState(LineState &State, bool Newline,
       State.Stack.back().LastSpace = State.Column;
     else if ((Previous.Type == TT_BinaryOperator ||
               Previous.Type == TT_ConditionalExpr ||
+              Previous.Type == TT_UnaryOperator ||
               Previous.Type == TT_CtorInitializerColon) &&
              !(Previous.getPrecedence() == prec::Assignment &&
                Current.FakeLParens.empty()))
       // Always indent relative to the RHS of the expression unless this is a
-      // simple assignment without binary expression on the RHS.
+      // simple assignment without binary expression on the RHS. Also indent
+      // relative to unary operators and the colons of constructor initializers.
       State.Stack.back().LastSpace = State.Column;
     else if (Previous.Type == TT_InheritanceColon)
       State.Stack.back().Indent = State.Column;

clang/lib/Format/Format.cpp

@@ -138,8 +138,7 @@ template <> struct MappingTraits<clang::format::FormatStyle> {
     IO.mapOptional("IndentFunctionDeclarationAfterType",
                    Style.IndentFunctionDeclarationAfterType);
     IO.mapOptional("SpacesInParentheses", Style.SpacesInParentheses);
-    IO.mapOptional("SpaceInEmptyParentheses",
-                   Style.SpaceInEmptyParentheses);
+    IO.mapOptional("SpaceInEmptyParentheses", Style.SpaceInEmptyParentheses);
     IO.mapOptional("SpacesInCStyleCastParentheses",
                    Style.SpacesInCStyleCastParentheses);
     IO.mapOptional("SpaceAfterControlStatementKeyword",
@@ -318,8 +317,7 @@ namespace {
 
 class NoColumnLimitFormatter {
 public:
-  NoColumnLimitFormatter(ContinuationIndenter *Indenter)
-      : Indenter(Indenter) {}
+  NoColumnLimitFormatter(ContinuationIndenter *Indenter) : Indenter(Indenter) {}
 
   /// \brief Formats the line starting at \p State, simply keeping all of the
   /// input's line breaking decisions.
@@ -332,6 +330,7 @@ public:
       Indenter->addTokenToState(State, Newline, /*DryRun=*/false);
     }
   }
+
 private:
   ContinuationIndenter *Indenter;
 };

clang/lib/Format/TokenAnnotator.cpp

@@ -1123,8 +1123,8 @@ bool TokenAnnotator::spaceRequiredBetween(const AnnotatedLine &Line,
   if (Left.is(tok::l_paren) && Right.is(tok::r_paren))
     return Style.SpaceInEmptyParentheses;
   if (Left.is(tok::l_paren) || Right.is(tok::r_paren))
-    return Right.Type == TT_CastRParen ||
-           (Left.MatchingParen && Left.MatchingParen->Type == TT_CastRParen)
+    return (Right.Type == TT_CastRParen ||
+            (Left.MatchingParen && Left.MatchingParen->Type == TT_CastRParen))
                ? Style.SpacesInCStyleCastParentheses
                : Style.SpacesInParentheses;
   if (Right.isOneOf(tok::semi, tok::comma))
@@ -1181,11 +1181,11 @@ bool TokenAnnotator::spaceRequiredBetween(const AnnotatedLine &Line,
         Left.MatchingParen->Previous->is(tok::kw___attribute))
       return true;
     return Line.Type == LT_ObjCDecl ||
-        Left.isOneOf(tok::kw_return, tok::kw_new,
-                     tok::kw_delete, tok::semi) ||
-        (Style.SpaceAfterControlStatementKeyword &&
-         Left.isOneOf(tok::kw_if, tok::kw_for, tok::kw_while, tok::kw_switch,
-                      tok::kw_catch));
+           Left.isOneOf(tok::kw_return, tok::kw_new, tok::kw_delete,
+                        tok::semi) ||
+           (Style.SpaceAfterControlStatementKeyword &&
+            Left.isOneOf(tok::kw_if, tok::kw_for, tok::kw_while, tok::kw_switch,
+                         tok::kw_catch));
   }
   if (Left.is(tok::at) && Right.Tok.getObjCKeywordID() != tok::objc_not_keyword)
     return false;

clang/unittests/Format/FormatTest.cpp

@@ -3528,6 +3528,14 @@ TEST_F(FormatTest, UnderstandsUnaryOperators) {
   verifyFormat("int a = i /* confusing comment */++;");
 }
 
+TEST_F(FormatTest, IndentsRelativeToUnaryOperators) {
+  verifyFormat("if (!aaaaaaaaaa( // break\n"
+               "         aaaaa)) {\n"
+               "}");
+  verifyFormat("aaaaaaaaaa(!aaaaaaaaaa( // break\n"
+               "                aaaaa));");
+}
+
 TEST_F(FormatTest, UndestandsOverloadedOperators) {
   verifyFormat("bool operator<();");
   verifyFormat("bool operator>();");