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