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