• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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.
getLengthToMatchingParen(const FormatToken & 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 
getLengthToNextOperator(const FormatToken & Tok)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.
startsSegmentOfBuilderTypeCall(const FormatToken & Tok)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.
startsNextParameter(const FormatToken & Current,const FormatStyle & Style)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 
ContinuationIndenter(const FormatStyle & Style,const AdditionalKeywords & Keywords,const SourceManager & SourceMgr,WhitespaceManager & Whitespaces,encoding::Encoding Encoding,bool BinPackInconclusiveFunctions)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 
getInitialState(unsigned FirstIndent,const AnnotatedLine * Line,bool DryRun)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 
canBreak(const LineState & State)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 
mustBreak(const LineState & State)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 
addTokenToState(LineState & State,bool Newline,bool DryRun,unsigned ExtraSpaces)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 
addTokenOnCurrentLine(LineState & State,bool DryRun,unsigned ExtraSpaces)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 
addTokenOnNewLine(LineState & State,bool DryRun)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 
getNewLineColumn(const LineState & State)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 
moveStateToNextToken(LineState & State,bool DryRun,bool Newline)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 
moveStatePastFakeLParens(LineState & State,bool Newline)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 
moveStatePastFakeRParens(LineState & State)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 
moveStatePastScopeOpener(LineState & State,bool Newline)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 
moveStatePastScopeCloser(LineState & State)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 
moveStateToNewBlock(LineState & State)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 
addMultilineToken(const FormatToken & Current,LineState & State)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 
breakProtrudingToken(const FormatToken & Current,LineState & State,bool DryRun)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 
getColumnLimit(const LineState & State) const1230 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 
nextIsMultilineString(const LineState & State)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