Home | History | Annotate | Download | only in Format 
      1 //===--- ContinuationIndenter.cpp - Format C++ code -----------------------===//
      2 //
      3 //                     The LLVM Compiler Infrastructure
      4 //
      5 // This file is distributed under the University of Illinois Open Source
      6 // License. See LICENSE.TXT for details.
      7 //
      8 //===----------------------------------------------------------------------===//
      9 ///
     10 /// \file
     11 /// \brief This file implements the continuation indenter.
     12 ///
     13 //===----------------------------------------------------------------------===//
     14 
     15 #include "BreakableToken.h"
     16 #include "ContinuationIndenter.h"
     17 #include "WhitespaceManager.h"
     18 #include "clang/Basic/OperatorPrecedence.h"
     19 #include "clang/Basic/SourceManager.h"
     20 #include "clang/Format/Format.h"
     21 #include "llvm/Support/Debug.h"
     22 #include <string>
     23 
     24 #define DEBUG_TYPE "format-formatter"
     25 
     26 namespace clang {
     27 namespace format {
     28 
     29 // Returns the length of everything up to the first possible line break after
     30 // the ), ], } or > matching \c Tok.
     31 static unsigned getLengthToMatchingParen(const FormatToken &Tok) {
     32   if (!Tok.MatchingParen)
     33     return 0;
     34   FormatToken *End = Tok.MatchingParen;
     35   while (End->Next && !End->Next->CanBreakBefore) {
     36     End = End->Next;
     37   }
     38   return End->TotalLength - Tok.TotalLength + 1;
     39 }
     40 
     41 static unsigned getLengthToNextOperator(const FormatToken &Tok) {
     42   if (!Tok.NextOperator)
     43     return 0;
     44   return Tok.NextOperator->TotalLength - Tok.TotalLength;
     45 }
     46 
     47 // Returns \c true if \c Tok is the "." or "->" of a call and starts the next
     48 // segment of a builder type call.
     49 static bool startsSegmentOfBuilderTypeCall(const FormatToken &Tok) {
     50   return Tok.isMemberAccess() && Tok.Previous && Tok.Previous->closesScope();
     51 }
     52 
     53 // Returns \c true if \c Current starts a new parameter.
     54 static bool startsNextParameter(const FormatToken &Current,
     55                                 const FormatStyle &Style) {
     56   const FormatToken &Previous = *Current.Previous;
     57   if (Current.is(TT_CtorInitializerComma) &&
     58       Style.BreakConstructorInitializersBeforeComma)
     59     return true;
     60   return Previous.is(tok::comma) && !Current.isTrailingComment() &&
     61          (Previous.isNot(TT_CtorInitializerComma) ||
     62           !Style.BreakConstructorInitializersBeforeComma);
     63 }
     64 
     65 ContinuationIndenter::ContinuationIndenter(const FormatStyle &Style,
     66                                            const AdditionalKeywords &Keywords,
     67                                            const SourceManager &SourceMgr,
     68                                            WhitespaceManager &Whitespaces,
     69                                            encoding::Encoding Encoding,
     70                                            bool BinPackInconclusiveFunctions)
     71     : Style(Style), Keywords(Keywords), SourceMgr(SourceMgr),
     72       Whitespaces(Whitespaces), Encoding(Encoding),
     73       BinPackInconclusiveFunctions(BinPackInconclusiveFunctions),
     74       CommentPragmasRegex(Style.CommentPragmas) {}
     75 
     76 LineState ContinuationIndenter::getInitialState(unsigned FirstIndent,
     77                                                 const AnnotatedLine *Line,
     78                                                 bool DryRun) {
     79   LineState State;
     80   State.FirstIndent = FirstIndent;
     81   State.Column = FirstIndent;
     82   State.Line = Line;
     83   State.NextToken = Line->First;
     84   State.Stack.push_back(ParenState(FirstIndent, Line->Level, FirstIndent,
     85                                    /*AvoidBinPacking=*/false,
     86                                    /*NoLineBreak=*/false));
     87   State.LineContainsContinuedForLoopSection = false;
     88   State.StartOfStringLiteral = 0;
     89   State.StartOfLineLevel = 0;
     90   State.LowestLevelOnLine = 0;
     91   State.IgnoreStackForComparison = false;
     92 
     93   // The first token has already been indented and thus consumed.
     94   moveStateToNextToken(State, DryRun, /*Newline=*/false);
     95   return State;
     96 }
     97 
     98 bool ContinuationIndenter::canBreak(const LineState &State) {
     99   const FormatToken &Current = *State.NextToken;
    100   const FormatToken &Previous = *Current.Previous;
    101   assert(&Previous == Current.Previous);
    102   if (!Current.CanBreakBefore &&
    103       !(State.Stack.back().BreakBeforeClosingBrace &&
    104         Current.closesBlockOrBlockTypeList(Style)))
    105     return false;
    106   // The opening "{" of a braced list has to be on the same line as the first
    107   // element if it is nested in another braced init list or function call.
    108   if (!Current.MustBreakBefore && Previous.is(tok::l_brace) &&
    109       Previous.isNot(TT_DictLiteral) && Previous.BlockKind == BK_BracedInit &&
    110       Previous.Previous &&
    111       Previous.Previous->isOneOf(tok::l_brace, tok::l_paren, tok::comma))
    112     return false;
    113   // This prevents breaks like:
    114   //   ...
    115   //   SomeParameter, OtherParameter).DoSomething(
    116   //   ...
    117   // As they hide "DoSomething" and are generally bad for readability.
    118   if (Previous.opensScope() && Previous.isNot(tok::l_brace) &&
    119       State.LowestLevelOnLine < State.StartOfLineLevel &&
    120       State.LowestLevelOnLine < Current.NestingLevel)
    121     return false;
    122   if (Current.isMemberAccess() && State.Stack.back().ContainsUnwrappedBuilder)
    123     return false;
    124 
    125   // Don't create a 'hanging' indent if there are multiple blocks in a single
    126   // statement.
    127   if (Previous.is(tok::l_brace) && State.Stack.size() > 1 &&
    128       State.Stack[State.Stack.size() - 2].NestedBlockInlined &&
    129       State.Stack[State.Stack.size() - 2].HasMultipleNestedBlocks)
    130     return false;
    131 
    132   // Don't break after very short return types (e.g. "void") as that is often
    133   // unexpected.
    134   if (Current.is(TT_FunctionDeclarationName) && State.Column < 6) {
    135     if (Style.AlwaysBreakAfterReturnType == FormatStyle::RTBS_None)
    136       return false;
    137   }
    138 
    139   return !State.Stack.back().NoLineBreak;
    140 }
    141 
    142 bool ContinuationIndenter::mustBreak(const LineState &State) {
    143   const FormatToken &Current = *State.NextToken;
    144   const FormatToken &Previous = *Current.Previous;
    145   if (Current.MustBreakBefore || Current.is(TT_InlineASMColon))
    146     return true;
    147   if (State.Stack.back().BreakBeforeClosingBrace &&
    148       Current.closesBlockOrBlockTypeList(Style))
    149     return true;
    150   if (Previous.is(tok::semi) && State.LineContainsContinuedForLoopSection)
    151     return true;
    152   if ((startsNextParameter(Current, Style) || Previous.is(tok::semi) ||
    153        (Previous.is(TT_TemplateCloser) && Current.is(TT_StartOfName) &&
    154         Style.Language == FormatStyle::LK_Cpp &&
    155         // FIXME: This is a temporary workaround for the case where clang-format
    156         // sets BreakBeforeParameter to avoid bin packing and this creates a
    157         // completely unnecessary line break after a template type that isn't
    158         // line-wrapped.
    159         (Previous.NestingLevel == 1 || Style.BinPackParameters)) ||
    160        (Style.BreakBeforeTernaryOperators && Current.is(TT_ConditionalExpr) &&
    161         Previous.isNot(tok::question)) ||
    162        (!Style.BreakBeforeTernaryOperators &&
    163         Previous.is(TT_ConditionalExpr))) &&
    164       State.Stack.back().BreakBeforeParameter && !Current.isTrailingComment() &&
    165       !Current.isOneOf(tok::r_paren, tok::r_brace))
    166     return true;
    167   if (((Previous.is(TT_DictLiteral) && Previous.is(tok::l_brace)) ||
    168        (Previous.is(TT_ArrayInitializerLSquare) &&
    169         Previous.ParameterCount > 1)) &&
    170       Style.ColumnLimit > 0 &&
    171       getLengthToMatchingParen(Previous) + State.Column - 1 >
    172           getColumnLimit(State))
    173     return true;
    174   if (Current.is(TT_CtorInitializerColon) &&
    175       (State.Column + State.Line->Last->TotalLength - Current.TotalLength + 2 >
    176            getColumnLimit(State) ||
    177        State.Stack.back().BreakBeforeParameter) &&
    178       ((Style.AllowShortFunctionsOnASingleLine != FormatStyle::SFS_All) ||
    179        Style.BreakConstructorInitializersBeforeComma || Style.ColumnLimit != 0))
    180     return true;
    181   if (Current.is(TT_SelectorName) && State.Stack.back().ObjCSelectorNameFound &&
    182       State.Stack.back().BreakBeforeParameter)
    183     return true;
    184 
    185   unsigned NewLineColumn = getNewLineColumn(State);
    186   if (Current.isMemberAccess() && Style.ColumnLimit != 0 &&
    187       State.Column + getLengthToNextOperator(Current) > Style.ColumnLimit &&
    188       (State.Column > NewLineColumn ||
    189        Current.NestingLevel < State.StartOfLineLevel))
    190     return true;
    191 
    192   if (State.Column <= NewLineColumn)
    193     return false;
    194 
    195   if (Style.AlwaysBreakBeforeMultilineStrings &&
    196       (NewLineColumn == State.FirstIndent + Style.ContinuationIndentWidth ||
    197        Previous.is(tok::comma) || Current.NestingLevel < 2) &&
    198       !Previous.isOneOf(tok::kw_return, tok::lessless, tok::at) &&
    199       !Previous.isOneOf(TT_InlineASMColon, TT_ConditionalExpr) &&
    200       nextIsMultilineString(State))
    201     return true;
    202 
    203   // Using CanBreakBefore here and below takes care of the decision whether the
    204   // current style uses wrapping before or after operators for the given
    205   // operator.
    206   if (Previous.is(TT_BinaryOperator) && Current.CanBreakBefore) {
    207     // If we need to break somewhere inside the LHS of a binary expression, we
    208     // should also break after the operator. Otherwise, the formatting would
    209     // hide the operator precedence, e.g. in:
    210     //   if (aaaaaaaaaaaaaa ==
    211     //           bbbbbbbbbbbbbb && c) {..
    212     // For comparisons, we only apply this rule, if the LHS is a binary
    213     // expression itself as otherwise, the line breaks seem superfluous.
    214     // We need special cases for ">>" which we have split into two ">" while
    215     // lexing in order to make template parsing easier.
    216     bool IsComparison = (Previous.getPrecedence() == prec::Relational ||
    217                          Previous.getPrecedence() == prec::Equality) &&
    218                         Previous.Previous &&
    219                         Previous.Previous->isNot(TT_BinaryOperator); // For >>.
    220     bool LHSIsBinaryExpr =
    221         Previous.Previous && Previous.Previous->EndsBinaryExpression;
    222     if ((!IsComparison || LHSIsBinaryExpr) && !Current.isTrailingComment() &&
    223         Previous.getPrecedence() != prec::Assignment &&
    224         State.Stack.back().BreakBeforeParameter)
    225       return true;
    226   } else if (Current.is(TT_BinaryOperator) && Current.CanBreakBefore &&
    227              State.Stack.back().BreakBeforeParameter) {
    228     return true;
    229   }
    230 
    231   // Same as above, but for the first "<<" operator.
    232   if (Current.is(tok::lessless) && Current.isNot(TT_OverloadedOperator) &&
    233       State.Stack.back().BreakBeforeParameter &&
    234       State.Stack.back().FirstLessLess == 0)
    235     return true;
    236 
    237   if (Current.NestingLevel == 0 && !Current.isTrailingComment()) {
    238     // Always break after "template <...>" and leading annotations. This is only
    239     // for cases where the entire line does not fit on a single line as a
    240     // different LineFormatter would be used otherwise.
    241     if (Previous.ClosesTemplateDeclaration)
    242       return true;
    243     if (Previous.is(TT_FunctionAnnotationRParen))
    244       return true;
    245     if (Previous.is(TT_LeadingJavaAnnotation) && Current.isNot(tok::l_paren) &&
    246         Current.isNot(TT_LeadingJavaAnnotation))
    247       return true;
    248   }
    249 
    250   // If the return type spans multiple lines, wrap before the function name.
    251   if ((Current.is(TT_FunctionDeclarationName) ||
    252        (Current.is(tok::kw_operator) && !Previous.is(tok::coloncolon))) &&
    253       !Previous.is(tok::kw_template) && State.Stack.back().BreakBeforeParameter)
    254     return true;
    255 
    256   if (startsSegmentOfBuilderTypeCall(Current) &&
    257       (State.Stack.back().CallContinuation != 0 ||
    258        State.Stack.back().BreakBeforeParameter))
    259     return true;
    260 
    261   // The following could be precomputed as they do not depend on the state.
    262   // However, as they should take effect only if the UnwrappedLine does not fit
    263   // into the ColumnLimit, they are checked here in the ContinuationIndenter.
    264   if (Style.ColumnLimit != 0 && Previous.BlockKind == BK_Block &&
    265       Previous.is(tok::l_brace) && !Current.isOneOf(tok::r_brace, tok::comment))
    266     return true;
    267 
    268   if (Current.is(tok::lessless) &&
    269       ((Previous.is(tok::identifier) && Previous.TokenText == "endl") ||
    270        (Previous.Tok.isLiteral() && (Previous.TokenText.endswith("\\n\"") ||
    271                                      Previous.TokenText == "\'\\n\'"))))
    272     return true;
    273 
    274   return false;
    275 }
    276 
    277 unsigned ContinuationIndenter::addTokenToState(LineState &State, bool Newline,
    278                                                bool DryRun,
    279                                                unsigned ExtraSpaces) {
    280   const FormatToken &Current = *State.NextToken;
    281 
    282   assert(!State.Stack.empty());
    283   if ((Current.is(TT_ImplicitStringLiteral) &&
    284        (Current.Previous->Tok.getIdentifierInfo() == nullptr ||
    285         Current.Previous->Tok.getIdentifierInfo()->getPPKeywordID() ==
    286             tok::pp_not_keyword))) {
    287     unsigned EndColumn =
    288         SourceMgr.getSpellingColumnNumber(Current.WhitespaceRange.getEnd());
    289     if (Current.LastNewlineOffset != 0) {
    290       // If there is a newline within this token, the final column will solely
    291       // determined by the current end column.
    292       State.Column = EndColumn;
    293     } else {
    294       unsigned StartColumn =
    295           SourceMgr.getSpellingColumnNumber(Current.WhitespaceRange.getBegin());
    296       assert(EndColumn >= StartColumn);
    297       State.Column += EndColumn - StartColumn;
    298     }
    299     moveStateToNextToken(State, DryRun, /*Newline=*/false);
    300     return 0;
    301   }
    302 
    303   unsigned Penalty = 0;
    304   if (Newline)
    305     Penalty = addTokenOnNewLine(State, DryRun);
    306   else
    307     addTokenOnCurrentLine(State, DryRun, ExtraSpaces);
    308 
    309   return moveStateToNextToken(State, DryRun, Newline) + Penalty;
    310 }
    311 
    312 void ContinuationIndenter::addTokenOnCurrentLine(LineState &State, bool DryRun,
    313                                                  unsigned ExtraSpaces) {
    314   FormatToken &Current = *State.NextToken;
    315   const FormatToken &Previous = *State.NextToken->Previous;
    316   if (Current.is(tok::equal) &&
    317       (State.Line->First->is(tok::kw_for) || Current.NestingLevel == 0) &&
    318       State.Stack.back().VariablePos == 0) {
    319     State.Stack.back().VariablePos = State.Column;
    320     // Move over * and & if they are bound to the variable name.
    321     const FormatToken *Tok = &Previous;
    322     while (Tok && State.Stack.back().VariablePos >= Tok->ColumnWidth) {
    323       State.Stack.back().VariablePos -= Tok->ColumnWidth;
    324       if (Tok->SpacesRequiredBefore != 0)
    325         break;
    326       Tok = Tok->Previous;
    327     }
    328     if (Previous.PartOfMultiVariableDeclStmt)
    329       State.Stack.back().LastSpace = State.Stack.back().VariablePos;
    330   }
    331 
    332   unsigned Spaces = Current.SpacesRequiredBefore + ExtraSpaces;
    333 
    334   if (!DryRun)
    335     Whitespaces.replaceWhitespace(Current, /*Newlines=*/0, /*IndentLevel=*/0,
    336                                   Spaces, State.Column + Spaces);
    337 
    338   if (Current.is(TT_SelectorName) &&
    339       !State.Stack.back().ObjCSelectorNameFound) {
    340     unsigned MinIndent =
    341         std::max(State.FirstIndent + Style.ContinuationIndentWidth,
    342                  State.Stack.back().Indent);
    343     unsigned FirstColonPos = State.Column + Spaces + Current.ColumnWidth;
    344     if (Current.LongestObjCSelectorName == 0)
    345       State.Stack.back().AlignColons = false;
    346     else if (MinIndent + Current.LongestObjCSelectorName > FirstColonPos)
    347       State.Stack.back().ColonPos = MinIndent + Current.LongestObjCSelectorName;
    348     else
    349       State.Stack.back().ColonPos = FirstColonPos;
    350   }
    351 
    352   // In "AlwaysBreak" mode, enforce wrapping directly after the parenthesis by
    353   // disallowing any further line breaks if there is no line break after the
    354   // opening parenthesis. Don't break if it doesn't conserve columns.
    355   if (Style.AlignAfterOpenBracket == FormatStyle::BAS_AlwaysBreak &&
    356       Previous.isOneOf(tok::l_paren, TT_TemplateOpener, tok::l_square) &&
    357       State.Column > getNewLineColumn(State) &&
    358       (!Previous.Previous ||
    359        !Previous.Previous->isOneOf(tok::kw_for, tok::kw_while,
    360                                    tok::kw_switch)) &&
    361       // Don't do this for simple (no expressions) one-argument function calls
    362       // as that feels like needlessly wasting whitespace, e.g.:
    363       //
    364       //   caaaaaaaaaaaall(
    365       //       caaaaaaaaaaaall(
    366       //           caaaaaaaaaaaall(
    367       //               caaaaaaaaaaaaaaaaaaaaaaall(aaaaaaaaaaaaaa, aaaaaaaaa))));
    368       Current.FakeLParens.size() > 0 &&
    369       Current.FakeLParens.back() > prec::Unknown)
    370     State.Stack.back().NoLineBreak = true;
    371 
    372   if (Style.AlignAfterOpenBracket != FormatStyle::BAS_DontAlign &&
    373       Previous.opensScope() && Previous.isNot(TT_ObjCMethodExpr) &&
    374       (Current.isNot(TT_LineComment) || Previous.BlockKind == BK_BracedInit))
    375     State.Stack.back().Indent = State.Column + Spaces;
    376   if (State.Stack.back().AvoidBinPacking && startsNextParameter(Current, Style))
    377     State.Stack.back().NoLineBreak = true;
    378   if (startsSegmentOfBuilderTypeCall(Current) &&
    379       State.Column > getNewLineColumn(State))
    380     State.Stack.back().ContainsUnwrappedBuilder = true;
    381 
    382   if (Current.is(TT_LambdaArrow) && Style.Language == FormatStyle::LK_Java)
    383     State.Stack.back().NoLineBreak = true;
    384   if (Current.isMemberAccess() && Previous.is(tok::r_paren) &&
    385       (Previous.MatchingParen &&
    386        (Previous.TotalLength - Previous.MatchingParen->TotalLength > 10))) {
    387     // If there is a function call with long parameters, break before trailing
    388     // calls. This prevents things like:
    389     //   EXPECT_CALL(SomeLongParameter).Times(
    390     //       2);
    391     // We don't want to do this for short parameters as they can just be
    392     // indexes.
    393     State.Stack.back().NoLineBreak = true;
    394   }
    395 
    396   State.Column += Spaces;
    397   if (Current.isNot(tok::comment) && Previous.is(tok::l_paren) &&
    398       Previous.Previous &&
    399       Previous.Previous->isOneOf(tok::kw_if, tok::kw_for)) {
    400     // Treat the condition inside an if as if it was a second function
    401     // parameter, i.e. let nested calls have a continuation indent.
    402     State.Stack.back().LastSpace = State.Column;
    403     State.Stack.back().NestedBlockIndent = State.Column;
    404   } else if (!Current.isOneOf(tok::comment, tok::caret) &&
    405              ((Previous.is(tok::comma) &&
    406                !Previous.is(TT_OverloadedOperator)) ||
    407               (Previous.is(tok::colon) && Previous.is(TT_ObjCMethodExpr)))) {
    408     State.Stack.back().LastSpace = State.Column;
    409   } else if ((Previous.isOneOf(TT_BinaryOperator, TT_ConditionalExpr,
    410                                TT_CtorInitializerColon)) &&
    411              ((Previous.getPrecedence() != prec::Assignment &&
    412                (Previous.isNot(tok::lessless) || Previous.OperatorIndex != 0 ||
    413                 Previous.NextOperator)) ||
    414               Current.StartsBinaryExpression)) {
    415     // Indent relative to the RHS of the expression unless this is a simple
    416     // assignment without binary expression on the RHS. Also indent relative to
    417     // unary operators and the colons of constructor initializers.
    418     State.Stack.back().LastSpace = State.Column;
    419   } else if (Previous.is(TT_InheritanceColon)) {
    420     State.Stack.back().Indent = State.Column;
    421     State.Stack.back().LastSpace = State.Column;
    422   } else if (Previous.opensScope()) {
    423     // If a function has a trailing call, indent all parameters from the
    424     // opening parenthesis. This avoids confusing indents like:
    425     //   OuterFunction(InnerFunctionCall( // break
    426     //       ParameterToInnerFunction))   // break
    427     //       .SecondInnerFunctionCall();
    428     bool HasTrailingCall = false;
    429     if (Previous.MatchingParen) {
    430       const FormatToken *Next = Previous.MatchingParen->getNextNonComment();
    431       HasTrailingCall = Next && Next->isMemberAccess();
    432     }
    433     if (HasTrailingCall && State.Stack.size() > 1 &&
    434         State.Stack[State.Stack.size() - 2].CallContinuation == 0)
    435       State.Stack.back().LastSpace = State.Column;
    436   }
    437 }
    438 
    439 unsigned ContinuationIndenter::addTokenOnNewLine(LineState &State,
    440                                                  bool DryRun) {
    441   FormatToken &Current = *State.NextToken;
    442   const FormatToken &Previous = *State.NextToken->Previous;
    443 
    444   // Extra penalty that needs to be added because of the way certain line
    445   // breaks are chosen.
    446   unsigned Penalty = 0;
    447 
    448   const FormatToken *PreviousNonComment = Current.getPreviousNonComment();
    449   const FormatToken *NextNonComment = Previous.getNextNonComment();
    450   if (!NextNonComment)
    451     NextNonComment = &Current;
    452   // The first line break on any NestingLevel causes an extra penalty in order
    453   // prefer similar line breaks.
    454   if (!State.Stack.back().ContainsLineBreak)
    455     Penalty += 15;
    456   State.Stack.back().ContainsLineBreak = true;
    457 
    458   Penalty += State.NextToken->SplitPenalty;
    459 
    460   // Breaking before the first "<<" is generally not desirable if the LHS is
    461   // short. Also always add the penalty if the LHS is split over mutliple lines
    462   // to avoid unnecessary line breaks that just work around this penalty.
    463   if (NextNonComment->is(tok::lessless) &&
    464       State.Stack.back().FirstLessLess == 0 &&
    465       (State.Column <= Style.ColumnLimit / 3 ||
    466        State.Stack.back().BreakBeforeParameter))
    467     Penalty += Style.PenaltyBreakFirstLessLess;
    468 
    469   State.Column = getNewLineColumn(State);
    470 
    471   // Indent nested blocks relative to this column, unless in a very specific
    472   // JavaScript special case where:
    473   //
    474   //   var loooooong_name =
    475   //       function() {
    476   //     // code
    477   //   }
    478   //
    479   // is common and should be formatted like a free-standing function. The same
    480   // goes for wrapping before the lambda return type arrow.
    481   if (!Current.is(TT_LambdaArrow) &&
    482       (Style.Language != FormatStyle::LK_JavaScript ||
    483        Current.NestingLevel != 0 || !PreviousNonComment ||
    484        !PreviousNonComment->is(tok::equal) ||
    485        !Current.isOneOf(Keywords.kw_async, Keywords.kw_function)))
    486     State.Stack.back().NestedBlockIndent = State.Column;
    487 
    488   if (NextNonComment->isMemberAccess()) {
    489     if (State.Stack.back().CallContinuation == 0)
    490       State.Stack.back().CallContinuation = State.Column;
    491   } else if (NextNonComment->is(TT_SelectorName)) {
    492     if (!State.Stack.back().ObjCSelectorNameFound) {
    493       if (NextNonComment->LongestObjCSelectorName == 0) {
    494         State.Stack.back().AlignColons = false;
    495       } else {
    496         State.Stack.back().ColonPos =
    497             (Style.IndentWrappedFunctionNames
    498                  ? std::max(State.Stack.back().Indent,
    499                             State.FirstIndent + Style.ContinuationIndentWidth)
    500                  : State.Stack.back().Indent) +
    501             NextNonComment->LongestObjCSelectorName;
    502       }
    503     } else if (State.Stack.back().AlignColons &&
    504                State.Stack.back().ColonPos <= NextNonComment->ColumnWidth) {
    505       State.Stack.back().ColonPos = State.Column + NextNonComment->ColumnWidth;
    506     }
    507   } else if (PreviousNonComment && PreviousNonComment->is(tok::colon) &&
    508              PreviousNonComment->isOneOf(TT_ObjCMethodExpr, TT_DictLiteral)) {
    509     // FIXME: This is hacky, find a better way. The problem is that in an ObjC
    510     // method expression, the block should be aligned to the line starting it,
    511     // e.g.:
    512     //   [aaaaaaaaaaaaaaa aaaaaaaaa: \\ break for some reason
    513     //                        ^(int *i) {
    514     //                            // ...
    515     //                        }];
    516     // Thus, we set LastSpace of the next higher NestingLevel, to which we move
    517     // when we consume all of the "}"'s FakeRParens at the "{".
    518     if (State.Stack.size() > 1)
    519       State.Stack[State.Stack.size() - 2].LastSpace =
    520           std::max(State.Stack.back().LastSpace, State.Stack.back().Indent) +
    521           Style.ContinuationIndentWidth;
    522   }
    523 
    524   if ((Previous.isOneOf(tok::comma, tok::semi) &&
    525        !State.Stack.back().AvoidBinPacking) ||
    526       Previous.is(TT_BinaryOperator))
    527     State.Stack.back().BreakBeforeParameter = false;
    528   if (Previous.isOneOf(TT_TemplateCloser, TT_JavaAnnotation) &&
    529       Current.NestingLevel == 0)
    530     State.Stack.back().BreakBeforeParameter = false;
    531   if (NextNonComment->is(tok::question) ||
    532       (PreviousNonComment && PreviousNonComment->is(tok::question)))
    533     State.Stack.back().BreakBeforeParameter = true;
    534   if (Current.is(TT_BinaryOperator) && Current.CanBreakBefore)
    535     State.Stack.back().BreakBeforeParameter = false;
    536 
    537   if (!DryRun) {
    538     unsigned Newlines = std::max(
    539         1u, std::min(Current.NewlinesBefore, Style.MaxEmptyLinesToKeep + 1));
    540     Whitespaces.replaceWhitespace(Current, Newlines,
    541                                   State.Stack.back().IndentLevel, State.Column,
    542                                   State.Column, State.Line->InPPDirective);
    543   }
    544 
    545   if (!Current.isTrailingComment())
    546     State.Stack.back().LastSpace = State.Column;
    547   if (Current.is(tok::lessless))
    548     // If we are breaking before a "<<", we always want to indent relative to
    549     // RHS. This is necessary only for "<<", as we special-case it and don't
    550     // always indent relative to the RHS.
    551     State.Stack.back().LastSpace += 3; // 3 -> width of "<< ".
    552 
    553   State.StartOfLineLevel = Current.NestingLevel;
    554   State.LowestLevelOnLine = Current.NestingLevel;
    555 
    556   // Any break on this level means that the parent level has been broken
    557   // and we need to avoid bin packing there.
    558   bool NestedBlockSpecialCase =
    559       Style.Language != FormatStyle::LK_Cpp &&
    560       Current.is(tok::r_brace) && State.Stack.size() > 1 &&
    561       State.Stack[State.Stack.size() - 2].NestedBlockInlined;
    562   if (!NestedBlockSpecialCase)
    563     for (unsigned i = 0, e = State.Stack.size() - 1; i != e; ++i)
    564       State.Stack[i].BreakBeforeParameter = true;
    565 
    566   if (PreviousNonComment &&
    567       !PreviousNonComment->isOneOf(tok::comma, tok::semi) &&
    568       (PreviousNonComment->isNot(TT_TemplateCloser) ||
    569        Current.NestingLevel != 0) &&
    570       !PreviousNonComment->isOneOf(
    571           TT_BinaryOperator, TT_FunctionAnnotationRParen, TT_JavaAnnotation,
    572           TT_LeadingJavaAnnotation) &&
    573       Current.isNot(TT_BinaryOperator) && !PreviousNonComment->opensScope())
    574     State.Stack.back().BreakBeforeParameter = true;
    575 
    576   // If we break after { or the [ of an array initializer, we should also break
    577   // before the corresponding } or ].
    578   if (PreviousNonComment &&
    579       (PreviousNonComment->isOneOf(tok::l_brace, TT_ArrayInitializerLSquare)))
    580     State.Stack.back().BreakBeforeClosingBrace = true;
    581 
    582   if (State.Stack.back().AvoidBinPacking) {
    583     // If we are breaking after '(', '{', '<', this is not bin packing
    584     // unless AllowAllParametersOfDeclarationOnNextLine is false or this is a
    585     // dict/object literal.
    586     if (!Previous.isOneOf(tok::l_paren, tok::l_brace, TT_BinaryOperator) ||
    587         (!Style.AllowAllParametersOfDeclarationOnNextLine &&
    588          State.Line->MustBeDeclaration) ||
    589         Previous.is(TT_DictLiteral))
    590       State.Stack.back().BreakBeforeParameter = true;
    591   }
    592 
    593   return Penalty;
    594 }
    595 
    596 unsigned ContinuationIndenter::getNewLineColumn(const LineState &State) {
    597   if (!State.NextToken || !State.NextToken->Previous)
    598     return 0;
    599   FormatToken &Current = *State.NextToken;
    600   const FormatToken &Previous = *Current.Previous;
    601   // If we are continuing an expression, we want to use the continuation indent.
    602   unsigned ContinuationIndent =
    603       std::max(State.Stack.back().LastSpace, State.Stack.back().Indent) +
    604       Style.ContinuationIndentWidth;
    605   const FormatToken *PreviousNonComment = Current.getPreviousNonComment();
    606   const FormatToken *NextNonComment = Previous.getNextNonComment();
    607   if (!NextNonComment)
    608     NextNonComment = &Current;
    609 
    610   // Java specific bits.
    611   if (Style.Language == FormatStyle::LK_Java &&
    612       Current.isOneOf(Keywords.kw_implements, Keywords.kw_extends))
    613     return std::max(State.Stack.back().LastSpace,
    614                     State.Stack.back().Indent + Style.ContinuationIndentWidth);
    615 
    616   if (NextNonComment->is(tok::l_brace) && NextNonComment->BlockKind == BK_Block)
    617     return Current.NestingLevel == 0 ? State.FirstIndent
    618                                      : State.Stack.back().Indent;
    619   if (Current.isOneOf(tok::r_brace, tok::r_square) && State.Stack.size() > 1) {
    620     if (Current.closesBlockOrBlockTypeList(Style))
    621       return State.Stack[State.Stack.size() - 2].NestedBlockIndent;
    622     if (Current.MatchingParen &&
    623         Current.MatchingParen->BlockKind == BK_BracedInit)
    624       return State.Stack[State.Stack.size() - 2].LastSpace;
    625     return State.FirstIndent;
    626   }
    627   if (Current.is(tok::identifier) && Current.Next &&
    628       Current.Next->is(TT_DictLiteral))
    629     return State.Stack.back().Indent;
    630   if (NextNonComment->isStringLiteral() && State.StartOfStringLiteral != 0)
    631     return State.StartOfStringLiteral;
    632   if (NextNonComment->is(TT_ObjCStringLiteral) &&
    633       State.StartOfStringLiteral != 0)
    634     return State.StartOfStringLiteral - 1;
    635   if (NextNonComment->is(tok::lessless) &&
    636       State.Stack.back().FirstLessLess != 0)
    637     return State.Stack.back().FirstLessLess;
    638   if (NextNonComment->isMemberAccess()) {
    639     if (State.Stack.back().CallContinuation == 0)
    640       return ContinuationIndent;
    641     return State.Stack.back().CallContinuation;
    642   }
    643   if (State.Stack.back().QuestionColumn != 0 &&
    644       ((NextNonComment->is(tok::colon) &&
    645         NextNonComment->is(TT_ConditionalExpr)) ||
    646        Previous.is(TT_ConditionalExpr)))
    647     return State.Stack.back().QuestionColumn;
    648   if (Previous.is(tok::comma) && State.Stack.back().VariablePos != 0)
    649     return State.Stack.back().VariablePos;
    650   if ((PreviousNonComment &&
    651        (PreviousNonComment->ClosesTemplateDeclaration ||
    652         PreviousNonComment->isOneOf(
    653             TT_AttributeParen, TT_FunctionAnnotationRParen, TT_JavaAnnotation,
    654             TT_LeadingJavaAnnotation))) ||
    655       (!Style.IndentWrappedFunctionNames &&
    656        NextNonComment->isOneOf(tok::kw_operator, TT_FunctionDeclarationName)))
    657     return std::max(State.Stack.back().LastSpace, State.Stack.back().Indent);
    658   if (NextNonComment->is(TT_SelectorName)) {
    659     if (!State.Stack.back().ObjCSelectorNameFound) {
    660       if (NextNonComment->LongestObjCSelectorName == 0)
    661         return State.Stack.back().Indent;
    662       return (Style.IndentWrappedFunctionNames
    663                   ? std::max(State.Stack.back().Indent,
    664                              State.FirstIndent + Style.ContinuationIndentWidth)
    665                   : State.Stack.back().Indent) +
    666              NextNonComment->LongestObjCSelectorName -
    667              NextNonComment->ColumnWidth;
    668     }
    669     if (!State.Stack.back().AlignColons)
    670       return State.Stack.back().Indent;
    671     if (State.Stack.back().ColonPos > NextNonComment->ColumnWidth)
    672       return State.Stack.back().ColonPos - NextNonComment->ColumnWidth;
    673     return State.Stack.back().Indent;
    674   }
    675   if (NextNonComment->is(TT_ArraySubscriptLSquare)) {
    676     if (State.Stack.back().StartOfArraySubscripts != 0)
    677       return State.Stack.back().StartOfArraySubscripts;
    678     return ContinuationIndent;
    679   }
    680 
    681   // This ensure that we correctly format ObjC methods calls without inputs,
    682   // i.e. where the last element isn't selector like: [callee method];
    683   if (NextNonComment->is(tok::identifier) && NextNonComment->FakeRParens == 0 &&
    684       NextNonComment->Next && NextNonComment->Next->is(TT_ObjCMethodExpr))
    685     return State.Stack.back().Indent;
    686 
    687   if (NextNonComment->isOneOf(TT_StartOfName, TT_PointerOrReference) ||
    688       Previous.isOneOf(tok::coloncolon, tok::equal, TT_JsTypeColon))
    689     return ContinuationIndent;
    690   if (PreviousNonComment && PreviousNonComment->is(tok::colon) &&
    691       PreviousNonComment->isOneOf(TT_ObjCMethodExpr, TT_DictLiteral))
    692     return ContinuationIndent;
    693   if (NextNonComment->is(TT_CtorInitializerColon))
    694     return State.FirstIndent + Style.ConstructorInitializerIndentWidth;
    695   if (NextNonComment->is(TT_CtorInitializerComma))
    696     return State.Stack.back().Indent;
    697   if (Previous.is(tok::r_paren) && !Current.isBinaryOperator() &&
    698       !Current.isOneOf(tok::colon, tok::comment))
    699     return ContinuationIndent;
    700   if (State.Stack.back().Indent == State.FirstIndent && PreviousNonComment &&
    701       PreviousNonComment->isNot(tok::r_brace))
    702     // Ensure that we fall back to the continuation indent width instead of
    703     // just flushing continuations left.
    704     return State.Stack.back().Indent + Style.ContinuationIndentWidth;
    705   return State.Stack.back().Indent;
    706 }
    707 
    708 unsigned ContinuationIndenter::moveStateToNextToken(LineState &State,
    709                                                     bool DryRun, bool Newline) {
    710   assert(State.Stack.size());
    711   const FormatToken &Current = *State.NextToken;
    712 
    713   if (Current.is(TT_InheritanceColon))
    714     State.Stack.back().AvoidBinPacking = true;
    715   if (Current.is(tok::lessless) && Current.isNot(TT_OverloadedOperator)) {
    716     if (State.Stack.back().FirstLessLess == 0)
    717       State.Stack.back().FirstLessLess = State.Column;
    718     else
    719       State.Stack.back().LastOperatorWrapped = Newline;
    720   }
    721   if ((Current.is(TT_BinaryOperator) && Current.isNot(tok::lessless)) ||
    722       Current.is(TT_ConditionalExpr))
    723     State.Stack.back().LastOperatorWrapped = Newline;
    724   if (Current.is(TT_ArraySubscriptLSquare) &&
    725       State.Stack.back().StartOfArraySubscripts == 0)
    726     State.Stack.back().StartOfArraySubscripts = State.Column;
    727   if (Style.BreakBeforeTernaryOperators && Current.is(tok::question))
    728     State.Stack.back().QuestionColumn = State.Column;
    729   if (!Style.BreakBeforeTernaryOperators && Current.isNot(tok::colon)) {
    730     const FormatToken *Previous = Current.Previous;
    731     while (Previous && Previous->isTrailingComment())
    732       Previous = Previous->Previous;
    733     if (Previous && Previous->is(tok::question))
    734       State.Stack.back().QuestionColumn = State.Column;
    735   }
    736   if (!Current.opensScope() && !Current.closesScope())
    737     State.LowestLevelOnLine =
    738         std::min(State.LowestLevelOnLine, Current.NestingLevel);
    739   if (Current.isMemberAccess())
    740     State.Stack.back().StartOfFunctionCall =
    741         !Current.NextOperator ? 0 : State.Column;
    742   if (Current.is(TT_SelectorName)) {
    743     State.Stack.back().ObjCSelectorNameFound = true;
    744     if (Style.IndentWrappedFunctionNames) {
    745       State.Stack.back().Indent =
    746           State.FirstIndent + Style.ContinuationIndentWidth;
    747     }
    748   }
    749   if (Current.is(TT_CtorInitializerColon)) {
    750     // Indent 2 from the column, so:
    751     // SomeClass::SomeClass()
    752     //     : First(...), ...
    753     //       Next(...)
    754     //       ^ line up here.
    755     State.Stack.back().Indent =
    756         State.Column + (Style.BreakConstructorInitializersBeforeComma ? 0 : 2);
    757     State.Stack.back().NestedBlockIndent = State.Stack.back().Indent;
    758     if (Style.ConstructorInitializerAllOnOneLineOrOnePerLine)
    759       State.Stack.back().AvoidBinPacking = true;
    760     State.Stack.back().BreakBeforeParameter = false;
    761   }
    762   if (Current.isOneOf(TT_BinaryOperator, TT_ConditionalExpr) && Newline)
    763     State.Stack.back().NestedBlockIndent =
    764         State.Column + Current.ColumnWidth + 1;
    765 
    766   // Insert scopes created by fake parenthesis.
    767   const FormatToken *Previous = Current.getPreviousNonComment();
    768 
    769   // Add special behavior to support a format commonly used for JavaScript
    770   // closures:
    771   //   SomeFunction(function() {
    772   //     foo();
    773   //     bar();
    774   //   }, a, b, c);
    775   if (Current.isNot(tok::comment) && Previous &&
    776       Previous->isOneOf(tok::l_brace, TT_ArrayInitializerLSquare) &&
    777       !Previous->is(TT_DictLiteral) && State.Stack.size() > 1) {
    778     if (State.Stack[State.Stack.size() - 2].NestedBlockInlined && Newline)
    779       for (unsigned i = 0, e = State.Stack.size() - 1; i != e; ++i)
    780         State.Stack[i].NoLineBreak = true;
    781     State.Stack[State.Stack.size() - 2].NestedBlockInlined = false;
    782   }
    783   if (Previous && (Previous->isOneOf(tok::l_paren, tok::comma, tok::colon) ||
    784                    Previous->isOneOf(TT_BinaryOperator, TT_ConditionalExpr)) &&
    785       !Previous->isOneOf(TT_DictLiteral, TT_ObjCMethodExpr)) {
    786     State.Stack.back().NestedBlockInlined =
    787         !Newline &&
    788         (Previous->isNot(tok::l_paren) || Previous->ParameterCount > 1);
    789   }
    790 
    791   moveStatePastFakeLParens(State, Newline);
    792   moveStatePastScopeOpener(State, Newline);
    793   moveStatePastScopeCloser(State);
    794   moveStatePastFakeRParens(State);
    795 
    796   if (Current.isStringLiteral() && State.StartOfStringLiteral == 0)
    797     State.StartOfStringLiteral = State.Column;
    798   if (Current.is(TT_ObjCStringLiteral) && State.StartOfStringLiteral == 0)
    799     State.StartOfStringLiteral = State.Column + 1;
    800   else if (!Current.isOneOf(tok::comment, tok::identifier, tok::hash) &&
    801            !Current.isStringLiteral())
    802     State.StartOfStringLiteral = 0;
    803 
    804   State.Column += Current.ColumnWidth;
    805   State.NextToken = State.NextToken->Next;
    806   unsigned Penalty = breakProtrudingToken(Current, State, DryRun);
    807   if (State.Column > getColumnLimit(State)) {
    808     unsigned ExcessCharacters = State.Column - getColumnLimit(State);
    809     Penalty += Style.PenaltyExcessCharacter * ExcessCharacters;
    810   }
    811 
    812   if (Current.Role)
    813     Current.Role->formatFromToken(State, this, DryRun);
    814   // If the previous has a special role, let it consume tokens as appropriate.
    815   // It is necessary to start at the previous token for the only implemented
    816   // role (comma separated list). That way, the decision whether or not to break
    817   // after the "{" is already done and both options are tried and evaluated.
    818   // FIXME: This is ugly, find a better way.
    819   if (Previous && Previous->Role)
    820     Penalty += Previous->Role->formatAfterToken(State, this, DryRun);
    821 
    822   return Penalty;
    823 }
    824 
    825 void ContinuationIndenter::moveStatePastFakeLParens(LineState &State,
    826                                                     bool Newline) {
    827   const FormatToken &Current = *State.NextToken;
    828   const FormatToken *Previous = Current.getPreviousNonComment();
    829 
    830   // Don't add extra indentation for the first fake parenthesis after
    831   // 'return', assignments or opening <({[. The indentation for these cases
    832   // is special cased.
    833   bool SkipFirstExtraIndent =
    834       (Previous && (Previous->opensScope() ||
    835                     Previous->isOneOf(tok::semi, tok::kw_return) ||
    836                     (Previous->getPrecedence() == prec::Assignment &&
    837                      Style.AlignOperands) ||
    838                     Previous->is(TT_ObjCMethodExpr)));
    839   for (SmallVectorImpl<prec::Level>::const_reverse_iterator
    840            I = Current.FakeLParens.rbegin(),
    841            E = Current.FakeLParens.rend();
    842        I != E; ++I) {
    843     ParenState NewParenState = State.Stack.back();
    844     NewParenState.ContainsLineBreak = false;
    845 
    846     // Indent from 'LastSpace' unless these are fake parentheses encapsulating
    847     // a builder type call after 'return' or, if the alignment after opening
    848     // brackets is disabled.
    849     if (!Current.isTrailingComment() &&
    850         (Style.AlignOperands || *I < prec::Assignment) &&
    851         (!Previous || Previous->isNot(tok::kw_return) ||
    852          (Style.Language != FormatStyle::LK_Java && *I > 0)) &&
    853         (Style.AlignAfterOpenBracket != FormatStyle::BAS_DontAlign ||
    854          *I != prec::Comma || Current.NestingLevel == 0))
    855       NewParenState.Indent =
    856           std::max(std::max(State.Column, NewParenState.Indent),
    857                    State.Stack.back().LastSpace);
    858 
    859     // Don't allow the RHS of an operator to be split over multiple lines unless
    860     // there is a line-break right after the operator.
    861     // Exclude relational operators, as there, it is always more desirable to
    862     // have the LHS 'left' of the RHS.
    863     if (Previous && Previous->getPrecedence() != prec::Assignment &&
    864         Previous->isOneOf(TT_BinaryOperator, TT_ConditionalExpr) &&
    865         Previous->getPrecedence() != prec::Relational) {
    866       bool BreakBeforeOperator =
    867           Previous->is(tok::lessless) ||
    868           (Previous->is(TT_BinaryOperator) &&
    869            Style.BreakBeforeBinaryOperators != FormatStyle::BOS_None) ||
    870           (Previous->is(TT_ConditionalExpr) &&
    871            Style.BreakBeforeTernaryOperators);
    872       if ((!Newline && !BreakBeforeOperator) ||
    873           (!State.Stack.back().LastOperatorWrapped && BreakBeforeOperator))
    874         NewParenState.NoLineBreak = true;
    875     }
    876 
    877     // Do not indent relative to the fake parentheses inserted for "." or "->".
    878     // This is a special case to make the following to statements consistent:
    879     //   OuterFunction(InnerFunctionCall( // break
    880     //       ParameterToInnerFunction));
    881     //   OuterFunction(SomeObject.InnerFunctionCall( // break
    882     //       ParameterToInnerFunction));
    883     if (*I > prec::Unknown)
    884       NewParenState.LastSpace = std::max(NewParenState.LastSpace, State.Column);
    885     if (*I != prec::Conditional && !Current.is(TT_UnaryOperator) &&
    886         Style.AlignAfterOpenBracket != FormatStyle::BAS_DontAlign)
    887       NewParenState.StartOfFunctionCall = State.Column;
    888 
    889     // Always indent conditional expressions. Never indent expression where
    890     // the 'operator' is ',', ';' or an assignment (i.e. *I <=
    891     // prec::Assignment) as those have different indentation rules. Indent
    892     // other expression, unless the indentation needs to be skipped.
    893     if (*I == prec::Conditional ||
    894         (!SkipFirstExtraIndent && *I > prec::Assignment &&
    895          !Current.isTrailingComment()))
    896       NewParenState.Indent += Style.ContinuationIndentWidth;
    897     if ((Previous && !Previous->opensScope()) || *I != prec::Comma)
    898       NewParenState.BreakBeforeParameter = false;
    899     State.Stack.push_back(NewParenState);
    900     SkipFirstExtraIndent = false;
    901   }
    902 }
    903 
    904 void ContinuationIndenter::moveStatePastFakeRParens(LineState &State) {
    905   for (unsigned i = 0, e = State.NextToken->FakeRParens; i != e; ++i) {
    906     unsigned VariablePos = State.Stack.back().VariablePos;
    907     if (State.Stack.size() == 1) {
    908       // Do not pop the last element.
    909       break;
    910     }
    911     State.Stack.pop_back();
    912     State.Stack.back().VariablePos = VariablePos;
    913   }
    914 }
    915 
    916 void ContinuationIndenter::moveStatePastScopeOpener(LineState &State,
    917                                                     bool Newline) {
    918   const FormatToken &Current = *State.NextToken;
    919   if (!Current.opensScope())
    920     return;
    921 
    922   if (Current.MatchingParen && Current.BlockKind == BK_Block) {
    923     moveStateToNewBlock(State);
    924     return;
    925   }
    926 
    927   unsigned NewIndent;
    928   unsigned NewIndentLevel = State.Stack.back().IndentLevel;
    929   unsigned LastSpace = State.Stack.back().LastSpace;
    930   bool AvoidBinPacking;
    931   bool BreakBeforeParameter = false;
    932   unsigned NestedBlockIndent = std::max(State.Stack.back().StartOfFunctionCall,
    933                                         State.Stack.back().NestedBlockIndent);
    934   if (Current.isOneOf(tok::l_brace, TT_ArrayInitializerLSquare)) {
    935     if (Current.opensBlockOrBlockTypeList(Style)) {
    936       NewIndent = State.Stack.back().NestedBlockIndent + Style.IndentWidth;
    937       NewIndent = std::min(State.Column + 2, NewIndent);
    938       ++NewIndentLevel;
    939     } else {
    940       NewIndent = State.Stack.back().LastSpace + Style.ContinuationIndentWidth;
    941     }
    942     const FormatToken *NextNoComment = Current.getNextNonComment();
    943     bool EndsInComma = Current.MatchingParen &&
    944                        Current.MatchingParen->Previous &&
    945                        Current.MatchingParen->Previous->is(tok::comma);
    946     AvoidBinPacking =
    947         (Current.is(TT_ArrayInitializerLSquare) && EndsInComma) ||
    948         Current.is(TT_DictLiteral) ||
    949         Style.Language == FormatStyle::LK_Proto || !Style.BinPackArguments ||
    950         (NextNoComment && NextNoComment->is(TT_DesignatedInitializerPeriod));
    951     if (Current.ParameterCount > 1)
    952       NestedBlockIndent = std::max(NestedBlockIndent, State.Column + 1);
    953   } else {
    954     NewIndent = Style.ContinuationIndentWidth +
    955                 std::max(State.Stack.back().LastSpace,
    956                          State.Stack.back().StartOfFunctionCall);
    957 
    958     // Ensure that different different brackets force relative alignment, e.g.:
    959     // void SomeFunction(vector<  // break
    960     //                       int> v);
    961     // FIXME: We likely want to do this for more combinations of brackets.
    962     // Verify that it is wanted for ObjC, too.
    963     if (Current.Tok.getKind() == tok::less &&
    964         Current.ParentBracket == tok::l_paren) {
    965       NewIndent = std::max(NewIndent, State.Stack.back().Indent);
    966       LastSpace = std::max(LastSpace, State.Stack.back().Indent);
    967     }
    968 
    969     AvoidBinPacking =
    970         (State.Line->MustBeDeclaration && !Style.BinPackParameters) ||
    971         (!State.Line->MustBeDeclaration && !Style.BinPackArguments) ||
    972         (Style.ExperimentalAutoDetectBinPacking &&
    973          (Current.PackingKind == PPK_OnePerLine ||
    974           (!BinPackInconclusiveFunctions &&
    975            Current.PackingKind == PPK_Inconclusive)));
    976     if (Current.is(TT_ObjCMethodExpr) && Current.MatchingParen) {
    977       if (Style.ColumnLimit) {
    978         // If this '[' opens an ObjC call, determine whether all parameters fit
    979         // into one line and put one per line if they don't.
    980         if (getLengthToMatchingParen(Current) + State.Column >
    981             getColumnLimit(State))
    982           BreakBeforeParameter = true;
    983       } else {
    984         // For ColumnLimit = 0, we have to figure out whether there is or has to
    985         // be a line break within this call.
    986         for (const FormatToken *Tok = &Current;
    987              Tok && Tok != Current.MatchingParen; Tok = Tok->Next) {
    988           if (Tok->MustBreakBefore ||
    989               (Tok->CanBreakBefore && Tok->NewlinesBefore > 0)) {
    990             BreakBeforeParameter = true;
    991             break;
    992           }
    993         }
    994       }
    995     }
    996   }
    997   // Generally inherit NoLineBreak from the current scope to nested scope.
    998   // However, don't do this for non-empty nested blocks, dict literals and
    999   // array literals as these follow different indentation rules.
   1000   bool NoLineBreak =
   1001       Current.Children.empty() &&
   1002       !Current.isOneOf(TT_DictLiteral, TT_ArrayInitializerLSquare) &&
   1003       (State.Stack.back().NoLineBreak ||
   1004        (Current.is(TT_TemplateOpener) &&
   1005         State.Stack.back().ContainsUnwrappedBuilder));
   1006   State.Stack.push_back(ParenState(NewIndent, NewIndentLevel, LastSpace,
   1007                                    AvoidBinPacking, NoLineBreak));
   1008   State.Stack.back().NestedBlockIndent = NestedBlockIndent;
   1009   State.Stack.back().BreakBeforeParameter = BreakBeforeParameter;
   1010   State.Stack.back().HasMultipleNestedBlocks = Current.BlockParameterCount > 1;
   1011 }
   1012 
   1013 void ContinuationIndenter::moveStatePastScopeCloser(LineState &State) {
   1014   const FormatToken &Current = *State.NextToken;
   1015   if (!Current.closesScope())
   1016     return;
   1017 
   1018   // If we encounter a closing ), ], } or >, we can remove a level from our
   1019   // stacks.
   1020   if (State.Stack.size() > 1 &&
   1021       (Current.isOneOf(tok::r_paren, tok::r_square) ||
   1022        (Current.is(tok::r_brace) && State.NextToken != State.Line->First) ||
   1023        State.NextToken->is(TT_TemplateCloser)))
   1024     State.Stack.pop_back();
   1025 
   1026   if (Current.is(tok::r_square)) {
   1027     // If this ends the array subscript expr, reset the corresponding value.
   1028     const FormatToken *NextNonComment = Current.getNextNonComment();
   1029     if (NextNonComment && NextNonComment->isNot(tok::l_square))
   1030       State.Stack.back().StartOfArraySubscripts = 0;
   1031   }
   1032 }
   1033 
   1034 void ContinuationIndenter::moveStateToNewBlock(LineState &State) {
   1035   unsigned NestedBlockIndent = State.Stack.back().NestedBlockIndent;
   1036   // ObjC block sometimes follow special indentation rules.
   1037   unsigned NewIndent =
   1038       NestedBlockIndent + (State.NextToken->is(TT_ObjCBlockLBrace)
   1039                                ? Style.ObjCBlockIndentWidth
   1040                                : Style.IndentWidth);
   1041   State.Stack.push_back(ParenState(
   1042       NewIndent, /*NewIndentLevel=*/State.Stack.back().IndentLevel + 1,
   1043       State.Stack.back().LastSpace, /*AvoidBinPacking=*/true,
   1044       /*NoLineBreak=*/false));
   1045   State.Stack.back().NestedBlockIndent = NestedBlockIndent;
   1046   State.Stack.back().BreakBeforeParameter = true;
   1047 }
   1048 
   1049 unsigned ContinuationIndenter::addMultilineToken(const FormatToken &Current,
   1050                                                  LineState &State) {
   1051   if (!Current.IsMultiline)
   1052     return 0;
   1053 
   1054   // Break before further function parameters on all levels.
   1055   for (unsigned i = 0, e = State.Stack.size(); i != e; ++i)
   1056     State.Stack[i].BreakBeforeParameter = true;
   1057 
   1058   unsigned ColumnsUsed = State.Column;
   1059   // We can only affect layout of the first and the last line, so the penalty
   1060   // for all other lines is constant, and we ignore it.
   1061   State.Column = Current.LastLineColumnWidth;
   1062 
   1063   if (ColumnsUsed > getColumnLimit(State))
   1064     return Style.PenaltyExcessCharacter * (ColumnsUsed - getColumnLimit(State));
   1065   return 0;
   1066 }
   1067 
   1068 unsigned ContinuationIndenter::breakProtrudingToken(const FormatToken &Current,
   1069                                                     LineState &State,
   1070                                                     bool DryRun) {
   1071   // Don't break multi-line tokens other than block comments. Instead, just
   1072   // update the state.
   1073   if (Current.isNot(TT_BlockComment) && Current.IsMultiline)
   1074     return addMultilineToken(Current, State);
   1075 
   1076   // Don't break implicit string literals or import statements.
   1077   if (Current.is(TT_ImplicitStringLiteral) ||
   1078       State.Line->Type == LT_ImportStatement)
   1079     return 0;
   1080 
   1081   if (!Current.isStringLiteral() && !Current.is(tok::comment))
   1082     return 0;
   1083 
   1084   std::unique_ptr<BreakableToken> Token;
   1085   unsigned StartColumn = State.Column - Current.ColumnWidth;
   1086   unsigned ColumnLimit = getColumnLimit(State);
   1087 
   1088   if (Current.isStringLiteral()) {
   1089     // FIXME: String literal breaking is currently disabled for Java and JS, as
   1090     // it requires strings to be merged using "+" which we don't support.
   1091     if (Style.Language == FormatStyle::LK_Java ||
   1092         Style.Language == FormatStyle::LK_JavaScript ||
   1093         !Style.BreakStringLiterals)
   1094       return 0;
   1095 
   1096     // Don't break string literals inside preprocessor directives (except for
   1097     // #define directives, as their contents are stored in separate lines and
   1098     // are not affected by this check).
   1099     // This way we avoid breaking code with line directives and unknown
   1100     // preprocessor directives that contain long string literals.
   1101     if (State.Line->Type == LT_PreprocessorDirective)
   1102       return 0;
   1103     // Exempts unterminated string literals from line breaking. The user will
   1104     // likely want to terminate the string before any line breaking is done.
   1105     if (Current.IsUnterminatedLiteral)
   1106       return 0;
   1107 
   1108     StringRef Text = Current.TokenText;
   1109     StringRef Prefix;
   1110     StringRef Postfix;
   1111     bool IsNSStringLiteral = false;
   1112     // FIXME: Handle whitespace between '_T', '(', '"..."', and ')'.
   1113     // FIXME: Store Prefix and Suffix (or PrefixLength and SuffixLength to
   1114     // reduce the overhead) for each FormatToken, which is a string, so that we
   1115     // don't run multiple checks here on the hot path.
   1116     if (Text.startswith("\"") && Current.Previous &&
   1117         Current.Previous->is(tok::at)) {
   1118       IsNSStringLiteral = true;
   1119       Prefix = "@\"";
   1120     }
   1121     if ((Text.endswith(Postfix = "\"") &&
   1122          (IsNSStringLiteral || Text.startswith(Prefix = "\"") ||
   1123           Text.startswith(Prefix = "u\"") || Text.startswith(Prefix = "U\"") ||
   1124           Text.startswith(Prefix = "u8\"") ||
   1125           Text.startswith(Prefix = "L\""))) ||
   1126         (Text.startswith(Prefix = "_T(\"") && Text.endswith(Postfix = "\")"))) {
   1127       Token.reset(new BreakableStringLiteral(
   1128           Current, State.Line->Level, StartColumn, Prefix, Postfix,
   1129           State.Line->InPPDirective, Encoding, Style));
   1130     } else {
   1131       return 0;
   1132     }
   1133   } else if (Current.is(TT_BlockComment)) {
   1134     if (!Current.isTrailingComment() || !Style.ReflowComments ||
   1135         CommentPragmasRegex.match(Current.TokenText.substr(2)))
   1136       return addMultilineToken(Current, State);
   1137     Token.reset(new BreakableBlockComment(
   1138         Current, State.Line->Level, StartColumn, Current.OriginalColumn,
   1139         !Current.Previous, State.Line->InPPDirective, Encoding, Style));
   1140   } else if (Current.is(TT_LineComment) &&
   1141              (Current.Previous == nullptr ||
   1142               Current.Previous->isNot(TT_ImplicitStringLiteral))) {
   1143     if (!Style.ReflowComments ||
   1144         CommentPragmasRegex.match(Current.TokenText.substr(2)))
   1145       return 0;
   1146     Token.reset(new BreakableLineComment(Current, State.Line->Level,
   1147                                          StartColumn, /*InPPDirective=*/false,
   1148                                          Encoding, Style));
   1149     // We don't insert backslashes when breaking line comments.
   1150     ColumnLimit = Style.ColumnLimit;
   1151   } else {
   1152     return 0;
   1153   }
   1154   if (Current.UnbreakableTailLength >= ColumnLimit)
   1155     return 0;
   1156 
   1157   unsigned RemainingSpace = ColumnLimit - Current.UnbreakableTailLength;
   1158   bool BreakInserted = false;
   1159   unsigned Penalty = 0;
   1160   unsigned RemainingTokenColumns = 0;
   1161   for (unsigned LineIndex = 0, EndIndex = Token->getLineCount();
   1162        LineIndex != EndIndex; ++LineIndex) {
   1163     if (!DryRun)
   1164       Token->replaceWhitespaceBefore(LineIndex, Whitespaces);
   1165     unsigned TailOffset = 0;
   1166     RemainingTokenColumns =
   1167         Token->getLineLengthAfterSplit(LineIndex, TailOffset, StringRef::npos);
   1168     while (RemainingTokenColumns > RemainingSpace) {
   1169       BreakableToken::Split Split =
   1170           Token->getSplit(LineIndex, TailOffset, ColumnLimit);
   1171       if (Split.first == StringRef::npos) {
   1172         // The last line's penalty is handled in addNextStateToQueue().
   1173         if (LineIndex < EndIndex - 1)
   1174           Penalty += Style.PenaltyExcessCharacter *
   1175                      (RemainingTokenColumns - RemainingSpace);
   1176         break;
   1177       }
   1178       assert(Split.first != 0);
   1179       unsigned NewRemainingTokenColumns = Token->getLineLengthAfterSplit(
   1180           LineIndex, TailOffset + Split.first + Split.second, StringRef::npos);
   1181 
   1182       // We can remove extra whitespace instead of breaking the line.
   1183       if (RemainingTokenColumns + 1 - Split.second <= RemainingSpace) {
   1184         RemainingTokenColumns = 0;
   1185         if (!DryRun)
   1186           Token->replaceWhitespace(LineIndex, TailOffset, Split, Whitespaces);
   1187         break;
   1188       }
   1189 
   1190       // When breaking before a tab character, it may be moved by a few columns,
   1191       // but will still be expanded to the next tab stop, so we don't save any
   1192       // columns.
   1193       if (NewRemainingTokenColumns == RemainingTokenColumns)
   1194         break;
   1195 
   1196       assert(NewRemainingTokenColumns < RemainingTokenColumns);
   1197       if (!DryRun)
   1198         Token->insertBreak(LineIndex, TailOffset, Split, Whitespaces);
   1199       Penalty += Current.SplitPenalty;
   1200       unsigned ColumnsUsed =
   1201           Token->getLineLengthAfterSplit(LineIndex, TailOffset, Split.first);
   1202       if (ColumnsUsed > ColumnLimit) {
   1203         Penalty += Style.PenaltyExcessCharacter * (ColumnsUsed - ColumnLimit);
   1204       }
   1205       TailOffset += Split.first + Split.second;
   1206       RemainingTokenColumns = NewRemainingTokenColumns;
   1207       BreakInserted = true;
   1208     }
   1209   }
   1210 
   1211   State.Column = RemainingTokenColumns;
   1212 
   1213   if (BreakInserted) {
   1214     // If we break the token inside a parameter list, we need to break before
   1215     // the next parameter on all levels, so that the next parameter is clearly
   1216     // visible. Line comments already introduce a break.
   1217     if (Current.isNot(TT_LineComment)) {
   1218       for (unsigned i = 0, e = State.Stack.size(); i != e; ++i)
   1219         State.Stack[i].BreakBeforeParameter = true;
   1220     }
   1221 
   1222     Penalty += Current.isStringLiteral() ? Style.PenaltyBreakString
   1223                                          : Style.PenaltyBreakComment;
   1224 
   1225     State.Stack.back().LastSpace = StartColumn;
   1226   }
   1227   return Penalty;
   1228 }
   1229 
   1230 unsigned ContinuationIndenter::getColumnLimit(const LineState &State) const {
   1231   // In preprocessor directives reserve two chars for trailing " \"
   1232   return Style.ColumnLimit - (State.Line->InPPDirective ? 2 : 0);
   1233 }
   1234 
   1235 bool ContinuationIndenter::nextIsMultilineString(const LineState &State) {
   1236   const FormatToken &Current = *State.NextToken;
   1237   if (!Current.isStringLiteral() || Current.is(TT_ImplicitStringLiteral))
   1238     return false;
   1239   // We never consider raw string literals "multiline" for the purpose of
   1240   // AlwaysBreakBeforeMultilineStrings implementation as they are special-cased
   1241   // (see TokenAnnotator::mustBreakBefore().
   1242   if (Current.TokenText.startswith("R\""))
   1243     return false;
   1244   if (Current.IsMultiline)
   1245     return true;
   1246   if (Current.getNextNonComment() &&
   1247       Current.getNextNonComment()->isStringLiteral())
   1248     return true; // Implicit concatenation.
   1249   if (Style.ColumnLimit != 0 &&
   1250       State.Column + Current.ColumnWidth + Current.UnbreakableTailLength >
   1251           Style.ColumnLimit)
   1252     return true; // String will be split.
   1253   return false;
   1254 }
   1255 
   1256 } // namespace format
   1257 } // namespace clang
   1258