clang  3.9.0
ContinuationIndenter.cpp
Go to the documentation of this file.
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"
20 #include "clang/Format/Format.h"
21 #include "llvm/Support/Debug.h"
22 #include <string>
23 
24 #define DEBUG_TYPE "format-formatter"
25 
26 namespace clang {
27 namespace format {
28 
29 // Returns the length of everything up to the first possible line break after
30 // the ), ], } or > matching \c Tok.
31 static unsigned getLengthToMatchingParen(const FormatToken &Tok) {
32  if (!Tok.MatchingParen)
33  return 0;
35  while (End->Next && !End->Next->CanBreakBefore) {
36  End = End->Next;
37  }
38  return End->TotalLength - Tok.TotalLength + 1;
39 }
40 
41 static unsigned getLengthToNextOperator(const FormatToken &Tok) {
42  if (!Tok.NextOperator)
43  return 0;
44  return Tok.NextOperator->TotalLength - Tok.TotalLength;
45 }
46 
47 // Returns \c true if \c Tok is the "." or "->" of a call and starts the next
48 // segment of a builder type call.
50  return Tok.isMemberAccess() && Tok.Previous && Tok.Previous->closesScope();
51 }
52 
53 // Returns \c true if \c Current starts a new parameter.
55  const FormatStyle &Style) {
56  const FormatToken &Previous = *Current.Previous;
57  if (Current.is(TT_CtorInitializerComma) &&
59  return true;
60  return Previous.is(tok::comma) && !Current.isTrailingComment() &&
61  (Previous.isNot(TT_CtorInitializerComma) ||
63 }
64 
67  const SourceManager &SourceMgr,
71  : Style(Style), Keywords(Keywords), SourceMgr(SourceMgr),
72  Whitespaces(Whitespaces), Encoding(Encoding),
73  BinPackInconclusiveFunctions(BinPackInconclusiveFunctions),
74  CommentPragmasRegex(Style.CommentPragmas) {}
75 
77  const AnnotatedLine *Line,
78  bool DryRun) {
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));
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 
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) {
136  return false;
137  }
138 
139  return !State.Stack.back().NoLineBreak;
140 }
141 
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) &&
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 
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 
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 ||
286  tok::pp_not_keyword))) {
287  unsigned EndColumn =
288  SourceMgr.getSpellingColumnNumber(Current.WhitespaceRange.getEnd());
289  if (Current.LastNewlineOffset != 0) {
290  // If there is a newline within this token, the final column will solely
291  // determined by the current end column.
292  State.Column = EndColumn;
293  } else {
294  unsigned StartColumn =
295  SourceMgr.getSpellingColumnNumber(Current.WhitespaceRange.getBegin());
296  assert(EndColumn >= StartColumn);
297  State.Column += EndColumn - StartColumn;
298  }
299  moveStateToNextToken(State, DryRun, /*Newline=*/false);
300  return 0;
301  }
302 
303  unsigned Penalty = 0;
304  if (Newline)
305  Penalty = addTokenOnNewLine(State, DryRun);
306  else
307  addTokenOnCurrentLine(State, DryRun, ExtraSpaces);
308 
309  return moveStateToNextToken(State, DryRun, Newline) + Penalty;
310 }
311 
312 void ContinuationIndenter::addTokenOnCurrentLine(LineState &State, bool DryRun,
313  unsigned ExtraSpaces) {
314  FormatToken &Current = *State.NextToken;
315  const FormatToken &Previous = *State.NextToken->Previous;
316  if (Current.is(tok::equal) &&
317  (State.Line->First->is(tok::kw_for) || Current.NestingLevel == 0) &&
318  State.Stack.back().VariablePos == 0) {
319  State.Stack.back().VariablePos = State.Column;
320  // Move over * and & if they are bound to the variable name.
321  const FormatToken *Tok = &Previous;
322  while (Tok && State.Stack.back().VariablePos >= Tok->ColumnWidth) {
323  State.Stack.back().VariablePos -= Tok->ColumnWidth;
324  if (Tok->SpacesRequiredBefore != 0)
325  break;
326  Tok = Tok->Previous;
327  }
328  if (Previous.PartOfMultiVariableDeclStmt)
329  State.Stack.back().LastSpace = State.Stack.back().VariablePos;
330  }
331 
332  unsigned Spaces = Current.SpacesRequiredBefore + ExtraSpaces;
333 
334  if (!DryRun)
335  Whitespaces.replaceWhitespace(Current, /*Newlines=*/0, /*IndentLevel=*/0,
336  Spaces, State.Column + Spaces);
337 
338  if (Current.is(TT_SelectorName) &&
339  !State.Stack.back().ObjCSelectorNameFound) {
340  unsigned MinIndent =
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.
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 
373  Previous.opensScope() && Previous.isNot(TT_ObjCMethodExpr) &&
374  (Current.isNot(TT_LineComment) || Previous.BlockKind == BK_BracedInit))
375  State.Stack.back().Indent = State.Column + Spaces;
376  if (State.Stack.back().AvoidBinPacking && startsNextParameter(Current, Style))
377  State.Stack.back().NoLineBreak = true;
378  if (startsSegmentOfBuilderTypeCall(Current) &&
379  State.Column > getNewLineColumn(State))
380  State.Stack.back().ContainsUnwrappedBuilder = true;
381 
382  if (Current.is(TT_LambdaArrow) && Style.Language == FormatStyle::LK_Java)
383  State.Stack.back().NoLineBreak = true;
384  if (Current.isMemberAccess() && Previous.is(tok::r_paren) &&
385  (Previous.MatchingParen &&
386  (Previous.TotalLength - Previous.MatchingParen->TotalLength > 10))) {
387  // If there is a function call with long parameters, break before trailing
388  // calls. This prevents things like:
389  // EXPECT_CALL(SomeLongParameter).Times(
390  // 2);
391  // We don't want to do this for short parameters as they can just be
392  // indexes.
393  State.Stack.back().NoLineBreak = true;
394  }
395 
396  State.Column += Spaces;
397  if (Current.isNot(tok::comment) && Previous.is(tok::l_paren) &&
398  Previous.Previous &&
399  Previous.Previous->isOneOf(tok::kw_if, tok::kw_for)) {
400  // Treat the condition inside an if as if it was a second function
401  // parameter, i.e. let nested calls have a continuation indent.
402  State.Stack.back().LastSpace = State.Column;
403  State.Stack.back().NestedBlockIndent = State.Column;
404  } else if (!Current.isOneOf(tok::comment, tok::caret) &&
405  ((Previous.is(tok::comma) &&
406  !Previous.is(TT_OverloadedOperator)) ||
407  (Previous.is(tok::colon) && Previous.is(TT_ObjCMethodExpr)))) {
408  State.Stack.back().LastSpace = State.Column;
409  } else if ((Previous.isOneOf(TT_BinaryOperator, TT_ConditionalExpr,
410  TT_CtorInitializerColon)) &&
411  ((Previous.getPrecedence() != prec::Assignment &&
412  (Previous.isNot(tok::lessless) || Previous.OperatorIndex != 0 ||
413  Previous.NextOperator)) ||
414  Current.StartsBinaryExpression)) {
415  // Indent relative to the RHS of the expression unless this is a simple
416  // assignment without binary expression on the RHS. Also indent relative to
417  // unary operators and the colons of constructor initializers.
418  State.Stack.back().LastSpace = State.Column;
419  } else if (Previous.is(TT_InheritanceColon)) {
420  State.Stack.back().Indent = State.Column;
421  State.Stack.back().LastSpace = State.Column;
422  } else if (Previous.opensScope()) {
423  // If a function has a trailing call, indent all parameters from the
424  // opening parenthesis. This avoids confusing indents like:
425  // OuterFunction(InnerFunctionCall( // break
426  // ParameterToInnerFunction)) // break
427  // .SecondInnerFunctionCall();
428  bool HasTrailingCall = false;
429  if (Previous.MatchingParen) {
430  const FormatToken *Next = Previous.MatchingParen->getNextNonComment();
431  HasTrailingCall = Next && Next->isMemberAccess();
432  }
433  if (HasTrailingCall && State.Stack.size() > 1 &&
434  State.Stack[State.Stack.size() - 2].CallContinuation == 0)
435  State.Stack.back().LastSpace = State.Column;
436  }
437 }
438 
439 unsigned ContinuationIndenter::addTokenOnNewLine(LineState &State,
440  bool DryRun) {
441  FormatToken &Current = *State.NextToken;
442  const FormatToken &Previous = *State.NextToken->Previous;
443 
444  // Extra penalty that needs to be added because of the way certain line
445  // breaks are chosen.
446  unsigned Penalty = 0;
447 
448  const FormatToken *PreviousNonComment = Current.getPreviousNonComment();
449  const FormatToken *NextNonComment = Previous.getNextNonComment();
450  if (!NextNonComment)
451  NextNonComment = &Current;
452  // The first line break on any NestingLevel causes an extra penalty in order
453  // prefer similar line breaks.
454  if (!State.Stack.back().ContainsLineBreak)
455  Penalty += 15;
456  State.Stack.back().ContainsLineBreak = true;
457 
458  Penalty += State.NextToken->SplitPenalty;
459 
460  // Breaking before the first "<<" is generally not desirable if the LHS is
461  // short. Also always add the penalty if the LHS is split over mutliple lines
462  // to avoid unnecessary line breaks that just work around this penalty.
463  if (NextNonComment->is(tok::lessless) &&
464  State.Stack.back().FirstLessLess == 0 &&
465  (State.Column <= Style.ColumnLimit / 3 ||
466  State.Stack.back().BreakBeforeParameter))
467  Penalty += Style.PenaltyBreakFirstLessLess;
468 
469  State.Column = getNewLineColumn(State);
470 
471  // Indent nested blocks relative to this column, unless in a very specific
472  // JavaScript special case where:
473  //
474  // var loooooong_name =
475  // function() {
476  // // code
477  // }
478  //
479  // is common and should be formatted like a free-standing function. The same
480  // goes for wrapping before the lambda return type arrow.
481  if (!Current.is(TT_LambdaArrow) &&
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 =
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) +
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) ||
588  State.Line->MustBeDeclaration) ||
589  Previous.is(TT_DictLiteral))
590  State.Stack.back().BreakBeforeParameter = true;
591  }
592 
593  return Penalty;
594 }
595 
596 unsigned ContinuationIndenter::getNewLineColumn(const LineState &State) {
597  if (!State.NextToken || !State.NextToken->Previous)
598  return 0;
599  FormatToken &Current = *State.NextToken;
600  const FormatToken &Previous = *Current.Previous;
601  // If we are continuing an expression, we want to use the continuation indent.
602  unsigned ContinuationIndent =
603  std::max(State.Stack.back().LastSpace, State.Stack.back().Indent) +
605  const FormatToken *PreviousNonComment = Current.getPreviousNonComment();
606  const FormatToken *NextNonComment = Previous.getNextNonComment();
607  if (!NextNonComment)
608  NextNonComment = &Current;
609 
610  // Java specific bits.
611  if (Style.Language == FormatStyle::LK_Java &&
612  Current.isOneOf(Keywords.kw_implements, Keywords.kw_extends))
613  return std::max(State.Stack.back().LastSpace,
614  State.Stack.back().Indent + Style.ContinuationIndentWidth);
615 
616  if (NextNonComment->is(tok::l_brace) && NextNonComment->BlockKind == BK_Block)
617  return Current.NestingLevel == 0 ? State.FirstIndent
618  : State.Stack.back().Indent;
619  if (Current.isOneOf(tok::r_brace, tok::r_square) && State.Stack.size() > 1) {
620  if (Current.closesBlockOrBlockTypeList(Style))
621  return State.Stack[State.Stack.size() - 2].NestedBlockIndent;
622  if (Current.MatchingParen &&
623  Current.MatchingParen->BlockKind == BK_BracedInit)
624  return State.Stack[State.Stack.size() - 2].LastSpace;
625  return State.FirstIndent;
626  }
627  if (Current.is(tok::identifier) && Current.Next &&
628  Current.Next->is(TT_DictLiteral))
629  return State.Stack.back().Indent;
630  if (NextNonComment->isStringLiteral() && State.StartOfStringLiteral != 0)
631  return State.StartOfStringLiteral;
632  if (NextNonComment->is(TT_ObjCStringLiteral) &&
633  State.StartOfStringLiteral != 0)
634  return State.StartOfStringLiteral - 1;
635  if (NextNonComment->is(tok::lessless) &&
636  State.Stack.back().FirstLessLess != 0)
637  return State.Stack.back().FirstLessLess;
638  if (NextNonComment->isMemberAccess()) {
639  if (State.Stack.back().CallContinuation == 0)
640  return ContinuationIndent;
641  return State.Stack.back().CallContinuation;
642  }
643  if (State.Stack.back().QuestionColumn != 0 &&
644  ((NextNonComment->is(tok::colon) &&
645  NextNonComment->is(TT_ConditionalExpr)) ||
646  Previous.is(TT_ConditionalExpr)))
647  return State.Stack.back().QuestionColumn;
648  if (Previous.is(tok::comma) && State.Stack.back().VariablePos != 0)
649  return State.Stack.back().VariablePos;
650  if ((PreviousNonComment &&
651  (PreviousNonComment->ClosesTemplateDeclaration ||
652  PreviousNonComment->isOneOf(
653  TT_AttributeParen, TT_FunctionAnnotationRParen, TT_JavaAnnotation,
654  TT_LeadingJavaAnnotation))) ||
655  (!Style.IndentWrappedFunctionNames &&
656  NextNonComment->isOneOf(tok::kw_operator, TT_FunctionDeclarationName)))
657  return std::max(State.Stack.back().LastSpace, State.Stack.back().Indent);
658  if (NextNonComment->is(TT_SelectorName)) {
659  if (!State.Stack.back().ObjCSelectorNameFound) {
660  if (NextNonComment->LongestObjCSelectorName == 0)
661  return State.Stack.back().Indent;
662  return (Style.IndentWrappedFunctionNames
663  ? std::max(State.Stack.back().Indent,
664  State.FirstIndent + Style.ContinuationIndentWidth)
665  : State.Stack.back().Indent) +
666  NextNonComment->LongestObjCSelectorName -
667  NextNonComment->ColumnWidth;
668  }
669  if (!State.Stack.back().AlignColons)
670  return State.Stack.back().Indent;
671  if (State.Stack.back().ColonPos > NextNonComment->ColumnWidth)
672  return State.Stack.back().ColonPos - NextNonComment->ColumnWidth;
673  return State.Stack.back().Indent;
674  }
675  if (NextNonComment->is(TT_ArraySubscriptLSquare)) {
676  if (State.Stack.back().StartOfArraySubscripts != 0)
677  return State.Stack.back().StartOfArraySubscripts;
678  return ContinuationIndent;
679  }
680 
681  // This ensure that we correctly format ObjC methods calls without inputs,
682  // i.e. where the last element isn't selector like: [callee method];
683  if (NextNonComment->is(tok::identifier) && NextNonComment->FakeRParens == 0 &&
684  NextNonComment->Next && NextNonComment->Next->is(TT_ObjCMethodExpr))
685  return State.Stack.back().Indent;
686 
687  if (NextNonComment->isOneOf(TT_StartOfName, TT_PointerOrReference) ||
688  Previous.isOneOf(tok::coloncolon, tok::equal, TT_JsTypeColon))
689  return ContinuationIndent;
690  if (PreviousNonComment && PreviousNonComment->is(tok::colon) &&
691  PreviousNonComment->isOneOf(TT_ObjCMethodExpr, TT_DictLiteral))
692  return ContinuationIndent;
693  if (NextNonComment->is(TT_CtorInitializerColon))
694  return State.FirstIndent + Style.ConstructorInitializerIndentWidth;
695  if (NextNonComment->is(TT_CtorInitializerComma))
696  return State.Stack.back().Indent;
697  if (Previous.is(tok::r_paren) && !Current.isBinaryOperator() &&
698  !Current.isOneOf(tok::colon, tok::comment))
699  return ContinuationIndent;
700  if (State.Stack.back().Indent == State.FirstIndent && PreviousNonComment &&
701  PreviousNonComment->isNot(tok::r_brace))
702  // Ensure that we fall back to the continuation indent width instead of
703  // just flushing continuations left.
704  return State.Stack.back().Indent + Style.ContinuationIndentWidth;
705  return State.Stack.back().Indent;
706 }
707 
708 unsigned ContinuationIndenter::moveStateToNextToken(LineState &State,
709  bool DryRun, bool Newline) {
710  assert(State.Stack.size());
711  const FormatToken &Current = *State.NextToken;
712 
713  if (Current.is(TT_InheritanceColon))
714  State.Stack.back().AvoidBinPacking = true;
715  if (Current.is(tok::lessless) && Current.isNot(TT_OverloadedOperator)) {
716  if (State.Stack.back().FirstLessLess == 0)
717  State.Stack.back().FirstLessLess = State.Column;
718  else
719  State.Stack.back().LastOperatorWrapped = Newline;
720  }
721  if ((Current.is(TT_BinaryOperator) && Current.isNot(tok::lessless)) ||
722  Current.is(TT_ConditionalExpr))
723  State.Stack.back().LastOperatorWrapped = Newline;
724  if (Current.is(TT_ArraySubscriptLSquare) &&
725  State.Stack.back().StartOfArraySubscripts == 0)
726  State.Stack.back().StartOfArraySubscripts = State.Column;
727  if (Style.BreakBeforeTernaryOperators && Current.is(tok::question))
728  State.Stack.back().QuestionColumn = State.Column;
729  if (!Style.BreakBeforeTernaryOperators && Current.isNot(tok::colon)) {
730  const FormatToken *Previous = Current.Previous;
731  while (Previous && Previous->isTrailingComment())
732  Previous = Previous->Previous;
733  if (Previous && Previous->is(tok::question))
734  State.Stack.back().QuestionColumn = State.Column;
735  }
736  if (!Current.opensScope() && !Current.closesScope())
737  State.LowestLevelOnLine =
738  std::min(State.LowestLevelOnLine, Current.NestingLevel);
739  if (Current.isMemberAccess())
740  State.Stack.back().StartOfFunctionCall =
741  !Current.NextOperator ? 0 : State.Column;
742  if (Current.is(TT_SelectorName)) {
743  State.Stack.back().ObjCSelectorNameFound = true;
744  if (Style.IndentWrappedFunctionNames) {
745  State.Stack.back().Indent =
746  State.FirstIndent + Style.ContinuationIndentWidth;
747  }
748  }
749  if (Current.is(TT_CtorInitializerColon)) {
750  // Indent 2 from the column, so:
751  // SomeClass::SomeClass()
752  // : First(...), ...
753  // Next(...)
754  // ^ line up here.
755  State.Stack.back().Indent =
756  State.Column + (Style.BreakConstructorInitializersBeforeComma ? 0 : 2);
757  State.Stack.back().NestedBlockIndent = State.Stack.back().Indent;
759  State.Stack.back().AvoidBinPacking = true;
760  State.Stack.back().BreakBeforeParameter = false;
761  }
762  if (Current.isOneOf(TT_BinaryOperator, TT_ConditionalExpr) && Newline)
763  State.Stack.back().NestedBlockIndent =
764  State.Column + Current.ColumnWidth + 1;
765 
766  // Insert scopes created by fake parenthesis.
767  const FormatToken *Previous = Current.getPreviousNonComment();
768 
769  // Add special behavior to support a format commonly used for JavaScript
770  // closures:
771  // SomeFunction(function() {
772  // foo();
773  // bar();
774  // }, a, b, c);
775  if (Current.isNot(tok::comment) && Previous &&
776  Previous->isOneOf(tok::l_brace, TT_ArrayInitializerLSquare) &&
777  !Previous->is(TT_DictLiteral) && State.Stack.size() > 1) {
778  if (State.Stack[State.Stack.size() - 2].NestedBlockInlined && Newline)
779  for (unsigned i = 0, e = State.Stack.size() - 1; i != e; ++i)
780  State.Stack[i].NoLineBreak = true;
781  State.Stack[State.Stack.size() - 2].NestedBlockInlined = false;
782  }
783  if (Previous && (Previous->isOneOf(tok::l_paren, tok::comma, tok::colon) ||
784  Previous->isOneOf(TT_BinaryOperator, TT_ConditionalExpr)) &&
785  !Previous->isOneOf(TT_DictLiteral, TT_ObjCMethodExpr)) {
786  State.Stack.back().NestedBlockInlined =
787  !Newline &&
788  (Previous->isNot(tok::l_paren) || Previous->ParameterCount > 1);
789  }
790 
791  moveStatePastFakeLParens(State, Newline);
792  moveStatePastScopeOpener(State, Newline);
793  moveStatePastScopeCloser(State);
794  moveStatePastFakeRParens(State);
795 
796  if (Current.isStringLiteral() && State.StartOfStringLiteral == 0)
797  State.StartOfStringLiteral = State.Column;
798  if (Current.is(TT_ObjCStringLiteral) && State.StartOfStringLiteral == 0)
799  State.StartOfStringLiteral = State.Column + 1;
800  else if (!Current.isOneOf(tok::comment, tok::identifier, tok::hash) &&
801  !Current.isStringLiteral())
802  State.StartOfStringLiteral = 0;
803 
804  State.Column += Current.ColumnWidth;
805  State.NextToken = State.NextToken->Next;
806  unsigned Penalty = breakProtrudingToken(Current, State, DryRun);
807  if (State.Column > getColumnLimit(State)) {
808  unsigned ExcessCharacters = State.Column - getColumnLimit(State);
809  Penalty += Style.PenaltyExcessCharacter * ExcessCharacters;
810  }
811 
812  if (Current.Role)
813  Current.Role->formatFromToken(State, this, DryRun);
814  // If the previous has a special role, let it consume tokens as appropriate.
815  // It is necessary to start at the previous token for the only implemented
816  // role (comma separated list). That way, the decision whether or not to break
817  // after the "{" is already done and both options are tried and evaluated.
818  // FIXME: This is ugly, find a better way.
819  if (Previous && Previous->Role)
820  Penalty += Previous->Role->formatAfterToken(State, this, DryRun);
821 
822  return Penalty;
823 }
824 
825 void ContinuationIndenter::moveStatePastFakeLParens(LineState &State,
826  bool Newline) {
827  const FormatToken &Current = *State.NextToken;
828  const FormatToken *Previous = Current.getPreviousNonComment();
829 
830  // Don't add extra indentation for the first fake parenthesis after
831  // 'return', assignments or opening <({[. The indentation for these cases
832  // is special cased.
833  bool SkipFirstExtraIndent =
834  (Previous && (Previous->opensScope() ||
835  Previous->isOneOf(tok::semi, tok::kw_return) ||
836  (Previous->getPrecedence() == prec::Assignment &&
837  Style.AlignOperands) ||
838  Previous->is(TT_ObjCMethodExpr)));
839  for (SmallVectorImpl<prec::Level>::const_reverse_iterator
840  I = Current.FakeLParens.rbegin(),
841  E = Current.FakeLParens.rend();
842  I != E; ++I) {
843  ParenState NewParenState = State.Stack.back();
844  NewParenState.ContainsLineBreak = false;
845 
846  // Indent from 'LastSpace' unless these are fake parentheses encapsulating
847  // a builder type call after 'return' or, if the alignment after opening
848  // brackets is disabled.
849  if (!Current.isTrailingComment() &&
850  (Style.AlignOperands || *I < prec::Assignment) &&
851  (!Previous || Previous->isNot(tok::kw_return) ||
852  (Style.Language != FormatStyle::LK_Java && *I > 0)) &&
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) &&
870  (Previous->is(TT_ConditionalExpr) &&
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) &&
887  NewParenState.StartOfFunctionCall = State.Column;
888 
889  // Always indent conditional expressions. Never indent expression where
890  // the 'operator' is ',', ';' or an assignment (i.e. *I <=
891  // prec::Assignment) as those have different indentation rules. Indent
892  // other expression, unless the indentation needs to be skipped.
893  if (*I == prec::Conditional ||
894  (!SkipFirstExtraIndent && *I > prec::Assignment &&
895  !Current.isTrailingComment()))
896  NewParenState.Indent += Style.ContinuationIndentWidth;
897  if ((Previous && !Previous->opensScope()) || *I != prec::Comma)
898  NewParenState.BreakBeforeParameter = false;
899  State.Stack.push_back(NewParenState);
900  SkipFirstExtraIndent = false;
901  }
902 }
903 
904 void ContinuationIndenter::moveStatePastFakeRParens(LineState &State) {
905  for (unsigned i = 0, e = State.NextToken->FakeRParens; i != e; ++i) {
906  unsigned VariablePos = State.Stack.back().VariablePos;
907  if (State.Stack.size() == 1) {
908  // Do not pop the last element.
909  break;
910  }
911  State.Stack.pop_back();
912  State.Stack.back().VariablePos = VariablePos;
913  }
914 }
915 
916 void ContinuationIndenter::moveStatePastScopeOpener(LineState &State,
917  bool Newline) {
918  const FormatToken &Current = *State.NextToken;
919  if (!Current.opensScope())
920  return;
921 
922  if (Current.MatchingParen && Current.BlockKind == BK_Block) {
923  moveStateToNewBlock(State);
924  return;
925  }
926 
927  unsigned NewIndent;
928  unsigned NewIndentLevel = State.Stack.back().IndentLevel;
929  unsigned LastSpace = State.Stack.back().LastSpace;
930  bool AvoidBinPacking;
931  bool BreakBeforeParameter = false;
932  unsigned NestedBlockIndent = std::max(State.Stack.back().StartOfFunctionCall,
933  State.Stack.back().NestedBlockIndent);
934  if (Current.isOneOf(tok::l_brace, TT_ArrayInitializerLSquare)) {
935  if (Current.opensBlockOrBlockTypeList(Style)) {
936  NewIndent = State.Stack.back().NestedBlockIndent + Style.IndentWidth;
937  NewIndent = std::min(State.Column + 2, NewIndent);
938  ++NewIndentLevel;
939  } else {
940  NewIndent = State.Stack.back().LastSpace + Style.ContinuationIndentWidth;
941  }
942  const FormatToken *NextNoComment = Current.getNextNonComment();
943  bool EndsInComma = Current.MatchingParen &&
944  Current.MatchingParen->Previous &&
945  Current.MatchingParen->Previous->is(tok::comma);
946  AvoidBinPacking =
947  (Current.is(TT_ArrayInitializerLSquare) && EndsInComma) ||
948  Current.is(TT_DictLiteral) ||
949  Style.Language == FormatStyle::LK_Proto || !Style.BinPackArguments ||
950  (NextNoComment && NextNoComment->is(TT_DesignatedInitializerPeriod));
951  if (Current.ParameterCount > 1)
952  NestedBlockIndent = std::max(NestedBlockIndent, State.Column + 1);
953  } else {
954  NewIndent = Style.ContinuationIndentWidth +
955  std::max(State.Stack.back().LastSpace,
956  State.Stack.back().StartOfFunctionCall);
957 
958  // Ensure that different different brackets force relative alignment, e.g.:
959  // void SomeFunction(vector< // break
960  // int> v);
961  // FIXME: We likely want to do this for more combinations of brackets.
962  // Verify that it is wanted for ObjC, too.
963  if (Current.Tok.getKind() == tok::less &&
964  Current.ParentBracket == tok::l_paren) {
965  NewIndent = std::max(NewIndent, State.Stack.back().Indent);
966  LastSpace = std::max(LastSpace, State.Stack.back().Indent);
967  }
968 
969  AvoidBinPacking =
970  (State.Line->MustBeDeclaration && !Style.BinPackParameters) ||
971  (!State.Line->MustBeDeclaration && !Style.BinPackArguments) ||
973  (Current.PackingKind == PPK_OnePerLine ||
974  (!BinPackInconclusiveFunctions &&
975  Current.PackingKind == PPK_Inconclusive)));
976  if (Current.is(TT_ObjCMethodExpr) && Current.MatchingParen) {
977  if (Style.ColumnLimit) {
978  // If this '[' opens an ObjC call, determine whether all parameters fit
979  // into one line and put one per line if they don't.
980  if (getLengthToMatchingParen(Current) + State.Column >
981  getColumnLimit(State))
982  BreakBeforeParameter = true;
983  } else {
984  // For ColumnLimit = 0, we have to figure out whether there is or has to
985  // be a line break within this call.
986  for (const FormatToken *Tok = &Current;
987  Tok && Tok != Current.MatchingParen; Tok = Tok->Next) {
988  if (Tok->MustBreakBefore ||
989  (Tok->CanBreakBefore && Tok->NewlinesBefore > 0)) {
990  BreakBeforeParameter = true;
991  break;
992  }
993  }
994  }
995  }
996  }
997  // Generally inherit NoLineBreak from the current scope to nested scope.
998  // However, don't do this for non-empty nested blocks, dict literals and
999  // array literals as these follow different indentation rules.
1000  bool NoLineBreak =
1001  Current.Children.empty() &&
1002  !Current.isOneOf(TT_DictLiteral, TT_ArrayInitializerLSquare) &&
1003  (State.Stack.back().NoLineBreak ||
1004  (Current.is(TT_TemplateOpener) &&
1005  State.Stack.back().ContainsUnwrappedBuilder));
1006  State.Stack.push_back(ParenState(NewIndent, NewIndentLevel, LastSpace,
1007  AvoidBinPacking, NoLineBreak));
1008  State.Stack.back().NestedBlockIndent = NestedBlockIndent;
1009  State.Stack.back().BreakBeforeParameter = BreakBeforeParameter;
1010  State.Stack.back().HasMultipleNestedBlocks = Current.BlockParameterCount > 1;
1011 }
1012 
1013 void ContinuationIndenter::moveStatePastScopeCloser(LineState &State) {
1014  const FormatToken &Current = *State.NextToken;
1015  if (!Current.closesScope())
1016  return;
1017 
1018  // If we encounter a closing ), ], } or >, we can remove a level from our
1019  // stacks.
1020  if (State.Stack.size() > 1 &&
1021  (Current.isOneOf(tok::r_paren, tok::r_square) ||
1022  (Current.is(tok::r_brace) && State.NextToken != State.Line->First) ||
1023  State.NextToken->is(TT_TemplateCloser)))
1024  State.Stack.pop_back();
1025 
1026  if (Current.is(tok::r_square)) {
1027  // If this ends the array subscript expr, reset the corresponding value.
1028  const FormatToken *NextNonComment = Current.getNextNonComment();
1029  if (NextNonComment && NextNonComment->isNot(tok::l_square))
1030  State.Stack.back().StartOfArraySubscripts = 0;
1031  }
1032 }
1033 
1034 void ContinuationIndenter::moveStateToNewBlock(LineState &State) {
1035  unsigned NestedBlockIndent = State.Stack.back().NestedBlockIndent;
1036  // ObjC block sometimes follow special indentation rules.
1037  unsigned NewIndent =
1038  NestedBlockIndent + (State.NextToken->is(TT_ObjCBlockLBrace)
1039  ? Style.ObjCBlockIndentWidth
1040  : Style.IndentWidth);
1041  State.Stack.push_back(ParenState(
1042  NewIndent, /*NewIndentLevel=*/State.Stack.back().IndentLevel + 1,
1043  State.Stack.back().LastSpace, /*AvoidBinPacking=*/true,
1044  /*NoLineBreak=*/false));
1045  State.Stack.back().NestedBlockIndent = NestedBlockIndent;
1046  State.Stack.back().BreakBeforeParameter = true;
1047 }
1048 
1049 unsigned ContinuationIndenter::addMultilineToken(const FormatToken &Current,
1050  LineState &State) {
1051  if (!Current.IsMultiline)
1052  return 0;
1053 
1054  // Break before further function parameters on all levels.
1055  for (unsigned i = 0, e = State.Stack.size(); i != e; ++i)
1056  State.Stack[i].BreakBeforeParameter = true;
1057 
1058  unsigned ColumnsUsed = State.Column;
1059  // We can only affect layout of the first and the last line, so the penalty
1060  // for all other lines is constant, and we ignore it.
1061  State.Column = Current.LastLineColumnWidth;
1062 
1063  if (ColumnsUsed > getColumnLimit(State))
1064  return Style.PenaltyExcessCharacter * (ColumnsUsed - getColumnLimit(State));
1065  return 0;
1066 }
1067 
1068 unsigned ContinuationIndenter::breakProtrudingToken(const FormatToken &Current,
1069  LineState &State,
1070  bool DryRun) {
1071  // Don't break multi-line tokens other than block comments. Instead, just
1072  // update the state.
1073  if (Current.isNot(TT_BlockComment) && Current.IsMultiline)
1074  return addMultilineToken(Current, State);
1075 
1076  // Don't break implicit string literals or import statements.
1077  if (Current.is(TT_ImplicitStringLiteral) ||
1078  State.Line->Type == LT_ImportStatement)
1079  return 0;
1080 
1081  if (!Current.isStringLiteral() && !Current.is(tok::comment))
1082  return 0;
1083 
1084  std::unique_ptr<BreakableToken> Token;
1085  unsigned StartColumn = State.Column - Current.ColumnWidth;
1086  unsigned ColumnLimit = getColumnLimit(State);
1087 
1088  if (Current.isStringLiteral()) {
1089  // FIXME: String literal breaking is currently disabled for Java and JS, as
1090  // it requires strings to be merged using "+" which we don't support.
1091  if (Style.Language == FormatStyle::LK_Java ||
1093  !Style.BreakStringLiterals)
1094  return 0;
1095 
1096  // Don't break string literals inside preprocessor directives (except for
1097  // #define directives, as their contents are stored in separate lines and
1098  // are not affected by this check).
1099  // This way we avoid breaking code with line directives and unknown
1100  // preprocessor directives that contain long string literals.
1101  if (State.Line->Type == LT_PreprocessorDirective)
1102  return 0;
1103  // Exempts unterminated string literals from line breaking. The user will
1104  // likely want to terminate the string before any line breaking is done.
1105  if (Current.IsUnterminatedLiteral)
1106  return 0;
1107 
1108  StringRef Text = Current.TokenText;
1109  StringRef Prefix;
1110  StringRef Postfix;
1111  bool IsNSStringLiteral = false;
1112  // FIXME: Handle whitespace between '_T', '(', '"..."', and ')'.
1113  // FIXME: Store Prefix and Suffix (or PrefixLength and SuffixLength to
1114  // reduce the overhead) for each FormatToken, which is a string, so that we
1115  // don't run multiple checks here on the hot path.
1116  if (Text.startswith("\"") && Current.Previous &&
1117  Current.Previous->is(tok::at)) {
1118  IsNSStringLiteral = true;
1119  Prefix = "@\"";
1120  }
1121  if ((Text.endswith(Postfix = "\"") &&
1122  (IsNSStringLiteral || Text.startswith(Prefix = "\"") ||
1123  Text.startswith(Prefix = "u\"") || Text.startswith(Prefix = "U\"") ||
1124  Text.startswith(Prefix = "u8\"") ||
1125  Text.startswith(Prefix = "L\""))) ||
1126  (Text.startswith(Prefix = "_T(\"") && Text.endswith(Postfix = "\")"))) {
1127  Token.reset(new BreakableStringLiteral(
1128  Current, State.Line->Level, StartColumn, Prefix, Postfix,
1129  State.Line->InPPDirective, Encoding, Style));
1130  } else {
1131  return 0;
1132  }
1133  } else if (Current.is(TT_BlockComment)) {
1134  if (!Current.isTrailingComment() || !Style.ReflowComments ||
1135  CommentPragmasRegex.match(Current.TokenText.substr(2)))
1136  return addMultilineToken(Current, State);
1137  Token.reset(new BreakableBlockComment(
1138  Current, State.Line->Level, StartColumn, Current.OriginalColumn,
1139  !Current.Previous, State.Line->InPPDirective, Encoding, Style));
1140  } else if (Current.is(TT_LineComment) &&
1141  (Current.Previous == nullptr ||
1142  Current.Previous->isNot(TT_ImplicitStringLiteral))) {
1143  if (!Style.ReflowComments ||
1144  CommentPragmasRegex.match(Current.TokenText.substr(2)))
1145  return 0;
1146  Token.reset(new BreakableLineComment(Current, State.Line->Level,
1147  StartColumn, /*InPPDirective=*/false,
1148  Encoding, Style));
1149  // We don't insert backslashes when breaking line comments.
1150  ColumnLimit = Style.ColumnLimit;
1151  } else {
1152  return 0;
1153  }
1154  if (Current.UnbreakableTailLength >= ColumnLimit)
1155  return 0;
1156 
1157  unsigned RemainingSpace = ColumnLimit - Current.UnbreakableTailLength;
1158  bool BreakInserted = false;
1159  unsigned Penalty = 0;
1160  unsigned RemainingTokenColumns = 0;
1161  for (unsigned LineIndex = 0, EndIndex = Token->getLineCount();
1162  LineIndex != EndIndex; ++LineIndex) {
1163  if (!DryRun)
1164  Token->replaceWhitespaceBefore(LineIndex, Whitespaces);
1165  unsigned TailOffset = 0;
1166  RemainingTokenColumns =
1167  Token->getLineLengthAfterSplit(LineIndex, TailOffset, StringRef::npos);
1168  while (RemainingTokenColumns > RemainingSpace) {
1169  BreakableToken::Split Split =
1170  Token->getSplit(LineIndex, TailOffset, ColumnLimit);
1171  if (Split.first == StringRef::npos) {
1172  // The last line's penalty is handled in addNextStateToQueue().
1173  if (LineIndex < EndIndex - 1)
1174  Penalty += Style.PenaltyExcessCharacter *
1175  (RemainingTokenColumns - RemainingSpace);
1176  break;
1177  }
1178  assert(Split.first != 0);
1179  unsigned NewRemainingTokenColumns = Token->getLineLengthAfterSplit(
1180  LineIndex, TailOffset + Split.first + Split.second, StringRef::npos);
1181 
1182  // We can remove extra whitespace instead of breaking the line.
1183  if (RemainingTokenColumns + 1 - Split.second <= RemainingSpace) {
1184  RemainingTokenColumns = 0;
1185  if (!DryRun)
1186  Token->replaceWhitespace(LineIndex, TailOffset, Split, Whitespaces);
1187  break;
1188  }
1189 
1190  // When breaking before a tab character, it may be moved by a few columns,
1191  // but will still be expanded to the next tab stop, so we don't save any
1192  // columns.
1193  if (NewRemainingTokenColumns == RemainingTokenColumns)
1194  break;
1195 
1196  assert(NewRemainingTokenColumns < RemainingTokenColumns);
1197  if (!DryRun)
1198  Token->insertBreak(LineIndex, TailOffset, Split, Whitespaces);
1199  Penalty += Current.SplitPenalty;
1200  unsigned ColumnsUsed =
1201  Token->getLineLengthAfterSplit(LineIndex, TailOffset, Split.first);
1202  if (ColumnsUsed > ColumnLimit) {
1203  Penalty += Style.PenaltyExcessCharacter * (ColumnsUsed - ColumnLimit);
1204  }
1205  TailOffset += Split.first + Split.second;
1206  RemainingTokenColumns = NewRemainingTokenColumns;
1207  BreakInserted = true;
1208  }
1209  }
1210 
1211  State.Column = RemainingTokenColumns;
1212 
1213  if (BreakInserted) {
1214  // If we break the token inside a parameter list, we need to break before
1215  // the next parameter on all levels, so that the next parameter is clearly
1216  // visible. Line comments already introduce a break.
1217  if (Current.isNot(TT_LineComment)) {
1218  for (unsigned i = 0, e = State.Stack.size(); i != e; ++i)
1219  State.Stack[i].BreakBeforeParameter = true;
1220  }
1221 
1222  Penalty += Current.isStringLiteral() ? Style.PenaltyBreakString
1223  : Style.PenaltyBreakComment;
1224 
1225  State.Stack.back().LastSpace = StartColumn;
1226  }
1227  return Penalty;
1228 }
1229 
1230 unsigned ContinuationIndenter::getColumnLimit(const LineState &State) const {
1231  // In preprocessor directives reserve two chars for trailing " \"
1232  return Style.ColumnLimit - (State.Line->InPPDirective ? 2 : 0);
1233 }
1234 
1235 bool ContinuationIndenter::nextIsMultilineString(const LineState &State) {
1236  const FormatToken &Current = *State.NextToken;
1237  if (!Current.isStringLiteral() || Current.is(TT_ImplicitStringLiteral))
1238  return false;
1239  // We never consider raw string literals "multiline" for the purpose of
1240  // AlwaysBreakBeforeMultilineStrings implementation as they are special-cased
1241  // (see TokenAnnotator::mustBreakBefore().
1242  if (Current.TokenText.startswith("R\""))
1243  return false;
1244  if (Current.IsMultiline)
1245  return true;
1246  if (Current.getNextNonComment() &&
1247  Current.getNextNonComment()->isStringLiteral())
1248  return true; // Implicit concatenation.
1249  if (Style.ColumnLimit != 0 &&
1250  State.Column + Current.ColumnWidth + Current.UnbreakableTailLength >
1251  Style.ColumnLimit)
1252  return true; // String will be split.
1253  return false;
1254 }
1255 
1256 } // namespace format
1257 } // namespace clang
static bool startsSegmentOfBuilderTypeCall(const FormatToken &Tok)
SourceLocation getEnd() const
std::pair< StringRef::size_type, unsigned > Split
Contains starting character index and length of split.
unsigned LowestLevelOnLine
The lowest NestingLevel on the current line.
unsigned NestingLevel
The nesting level of this token, i.e.
Definition: FormatToken.h:221
bool AlwaysBreakBeforeMultilineStrings
If true, always break before multiline string literals.
Definition: Format.h:195
Token Tok
The Token.
Definition: FormatToken.h:117
Should be used for Protocol Buffers (https://developers.google.com/protocol-buffers/).
Definition: Format.h:470
Defines the SourceManager interface.
unsigned IndentWidth
The number of columns to use for indentation.
Definition: Format.h:428
Declares BreakableToken, BreakableStringLiteral, and BreakableBlockComment classes, that contain token type-specific logic to break long lines in tokens.
bool isOneOf(A K1, B K2) const
Definition: FormatToken.h:291
FormatToken * getPreviousNonComment() const
Returns the previous token ignoring comments.
Definition: FormatToken.h:413
Should be used for C, C++, ObjectiveC, ObjectiveC++.
Definition: Format.h:463
bool IsMultiline
Whether the token text contains newlines (escaped or not).
Definition: FormatToken.h:146
unsigned PenaltyBreakFirstLessLess
The penalty for breaking before the first <<.
Definition: Format.h:518
bool isNot(T Kind) const
Definition: FormatToken.h:298
bool EndsBinaryExpression
true if this token ends a binary expression.
Definition: FormatToken.h:246
unsigned TotalLength
The total length of the unwrapped line up to and including this token.
Definition: FormatToken.h:204
unsigned NewlinesBefore
The number of newlines immediately before the Token.
Definition: FormatToken.h:123
FormatToken * Next
The next token in the unwrapped line.
Definition: FormatToken.h:268
Break after operators.
Definition: Format.h:212
unsigned UnbreakableTailLength
The length of following tokens until the next natural split point, or the next token that can be brok...
Definition: FormatToken.h:212
unsigned ParameterCount
Number of parameters, if this is "(", "[" or "<".
Definition: FormatToken.h:185
bool ExperimentalAutoDetectBinPacking
If true, clang-format detects whether function calls and definitions are formatted with one parameter...
Definition: Format.h:350
LineState State
bool CanBreakBefore
true if it is allowed to break before this token.
Definition: FormatToken.h:175
unsigned Column
The number of used columns in the current line.
Should be used for Java.
Definition: Format.h:465
FormatToken * Previous
The previous token in the unwrapped line.
Definition: FormatToken.h:265
const FormatToken * getNextNonComment() const
Returns the next token ignoring comments.
Definition: FormatToken.h:421
bool StartsBinaryExpression
true if this token starts a binary expression, i.e.
Definition: FormatToken.h:244
unsigned LongestObjCSelectorName
If this is the first ObjC selector name in an ObjC method definition or call, this contains the lengt...
Definition: FormatToken.h:231
Manages the whitespaces around tokens and their replacements.
bool ConstructorInitializerAllOnOneLineOrOnePerLine
If the constructor initializers don't fit on a line, put each initializer on its own line...
Definition: Format.h:308
unsigned PenaltyBreakComment
The penalty for each line break introduced inside a comment.
Definition: Format.h:515
unsigned OperatorIndex
Is this is an operator (or "."/"->") in a sequence of operators with the same precedence, contains the 0-based operator index.
Definition: FormatToken.h:250
unsigned SpacesRequiredBefore
The number of spaces that should be inserted before this token.
Definition: FormatToken.h:172
bool IndentWrappedFunctionNames
Indent if a function definition or declaration is wrapped after the type.
Definition: Format.h:432
Always break after an open bracket, if the parameters don't fit on a single line, e...
Definition: Format.h:70
static unsigned getLengthToNextOperator(const FormatToken &Tok)
bool closesScope() const
Returns whether Tok is )]} or a template closing >.
Definition: FormatToken.h:341
ReturnTypeBreakingStyle AlwaysBreakAfterReturnType
The function declaration return type breaking style to use.
Definition: Format.h:187
void replaceWhitespace(FormatToken &Tok, unsigned Newlines, unsigned IndentLevel, unsigned Spaces, unsigned StartOfTokenColumn, bool InPPDirective=false)
Replaces the whitespace in front of Tok.
bool closesBlockOrBlockTypeList(const FormatStyle &Style) const
Same as opensBlockOrBlockTypeList, but for the closing token.
Definition: FormatToken.h:438
bool BreakConstructorInitializersBeforeComma
Always break constructor initializers before commas and align the commas with the colon...
Definition: Format.h:287
const AnnotatedLine * Line
The line that is being formatted.
bool isStringLiteral() const
Definition: FormatToken.h:314
bool BinPackArguments
If false, a function call's arguments will either be all on the same line or will have one line each...
Definition: Format.h:203
unsigned ObjCBlockIndentWidth
The number of characters to use for indentation of ObjC blocks.
Definition: Format.h:501
WhitespaceManager * Whitespaces
bool LineContainsContinuedForLoopSection
true if this line contains a continued for-loop section.
detail::InMemoryDirectory::const_iterator I
unsigned ColumnLimit
The column limit.
Definition: Format.h:300
BracketAlignmentStyle AlignAfterOpenBracket
If true, horizontally aligns arguments after an open bracket.
Definition: Format.h:77
const FormatStyle & Style
Definition: Format.cpp:1311
The current state when indenting a unwrapped line.
const SmallVectorImpl< AnnotatedLine * >::const_iterator End
Break after return type automatically.
Definition: Format.h:171
WhitespaceManager class manages whitespace around tokens and their replacements.
Should be used for JavaScript.
Definition: Format.h:467
StateNode * Previous
bool AlignOperands
If true, horizontally align operands of binary and ternary expressions.
Definition: Format.h:114
A wrapper around a Token storing information about the whitespace characters preceding it...
Definition: FormatToken.h:113
FormatToken * Token
char __ovld __cnfn min(char x, char y)
Returns y if y < x, otherwise it returns x.
Defines and computes precedence levels for binary/ternary operators.
static bool startsNextParameter(const FormatToken &Current, const FormatStyle &Style)
unsigned LastNewlineOffset
The offset just past the last ' ' in this token's leading whitespace (relative to WhiteSpaceStart)...
Definition: FormatToken.h:134
Don't align, instead use ContinuationIndentWidth, e.g.
Definition: Format.h:63
std::vector< ParenState > Stack
A stack keeping track of properties applying to parenthesis levels.
unsigned PenaltyBreakString
The penalty for each line break introduced inside a string literal.
Definition: Format.h:521
bool isTrailingComment() const
Definition: FormatToken.h:374
unsigned PenaltyExcessCharacter
The penalty for each character outside of the column limit.
Definition: Format.h:524
SmallVectorImpl< AnnotatedLine * >::const_iterator Next
AnnotatedLine & Line
Various functions to configurably format source code.
bool ReflowComments
If true, clang-format will attempt to re-flow comments.
Definition: Format.h:544
unsigned getSpellingColumnNumber(SourceLocation Loc, bool *Invalid=nullptr) const
bool BreakBeforeTernaryOperators
If true, ternary operators will be placed after line breaks.
Definition: Format.h:283
Encapsulates keywords that are context sensitive or for languages not properly supported by Clang's l...
Definition: FormatToken.h:569
SourceRange WhitespaceRange
The range of the whitespace immediately preceding the Token.
Definition: FormatToken.h:130
unsigned ContinuationIndentWidth
Indent width for line continuations.
Definition: Format.h:315
bool IgnoreStackForComparison
Ignore the stack of ParenStates for state comparison.
StringRef TokenText
The raw text of the token.
Definition: FormatToken.h:161
SourceLocation getBegin() const
SmallVector< prec::Level, 4 > FakeLParens
Stores the number of required fake parentheses and the corresponding operator precedence.
Definition: FormatToken.h:238
unsigned addTokenToState(LineState &State, bool Newline, bool DryRun, unsigned ExtraSpaces=0)
Appends the next token to State and updates information necessary for indentation.
unsigned getColumnLimit(const LineState &State) const
Get the column limit for this line.
The FormatStyle is used to configure the formatting to follow specific guidelines.
Definition: Format.h:46
LanguageKind Language
Language, this format style is targeted at.
Definition: Format.h:476
if(T->getSizeExpr()) TRY_TO(TraverseStmt(T-> getSizeExpr()))
ShortFunctionStyle AllowShortFunctionsOnASingleLine
Dependent on the value, int f() { return 0; } can be put on a single line.
Definition: Format.h:146
unsigned ColumnWidth
The width of the non-whitespace parts of the token (or its first line for multi-line tokens) in colum...
Definition: FormatToken.h:139
const AdditionalKeywords & Keywords
static unsigned getLengthToMatchingParen(const FormatToken &Tok)
unsigned FirstIndent
The indent of the first token.
detail::InMemoryDirectory::const_iterator E
bool BreakStringLiterals
Allow breaking string literals when formatting.
Definition: Format.h:293
Merge all functions fitting on a single line.
Definition: Format.h:141
bool isLiteral() const
Return true if this is a "literal", like a numeric constant, string, etc.
Definition: Token.h:112
bool canBreak(const LineState &State)
Returns true, if a line break after State is allowed.
bool opensScope() const
Returns whether Tok is ([{ or a template opening <.
Definition: FormatToken.h:336
bool AllowAllParametersOfDeclarationOnNextLine
Allow putting all parameters of a function declaration onto the next line even if BinPackParameters i...
Definition: Format.h:121
bool is(tok::TokenKind Kind) const
Definition: FormatToken.h:282
bool mustBreak(const LineState &State)
Returns true, if a line break after State is mandatory.
ContinuationIndenter(const FormatStyle &Style, const AdditionalKeywords &Keywords, const SourceManager &SourceMgr, WhitespaceManager &Whitespaces, encoding::Encoding Encoding, bool BinPackInconclusiveFunctions)
Constructs a ContinuationIndenter to format Line starting in column FirstIndent.
bool BinPackInconclusiveFunctions
Definition: Format.cpp:978
LineState getInitialState(unsigned FirstIndent, const AnnotatedLine *Line, bool DryRun)
Get the initial state, i.e.
FormatToken * NextOperator
If this is an operator (or "."/"->") in a sequence of operators with the same precedence, points to the next operator.
Definition: FormatToken.h:254
char __ovld __cnfn max(char x, char y)
Returns y if x < y, otherwise it returns x.
prec::Level getPrecedence() const
Definition: FormatToken.h:408
bool ClosesTemplateDeclaration
true if this is the ">" of "template<..>".
Definition: FormatToken.h:178
FormatToken * MatchingParen
If this is a bracket, this points to the matching one.
Definition: FormatToken.h:262
FormatToken * Current
unsigned ConstructorInitializerIndentWidth
The number of characters to use for indentation of constructor initializer lists. ...
Definition: Format.h:312
bool isMemberAccess() const
Returns true if this is a "." or "->" accessing a member.
Definition: FormatToken.h:347
BinaryOperatorStyle BreakBeforeBinaryOperators
The way to wrap binary operators.
Definition: Format.h:220
bool MustBreakBefore
Whether there must be a line break before this token.
Definition: FormatToken.h:155
unsigned StartOfLineLevel
The NestingLevel at the start of this line.
unsigned StartOfStringLiteral
The start column of the string literal, if we're in a string literal sequence, 0 otherwise.
StringRef Text
Definition: Format.cpp:1195
FormatToken * NextToken
The token that needs to be next formatted.
This file implements an indenter that manages the indentation of continuations.
unsigned MaxEmptyLinesToKeep
The maximum number of consecutive empty lines to keep.
Definition: Format.h:485
BraceBlockKind BlockKind
Contains the kind of block if this token is a brace.
Definition: FormatToken.h:167
bool PartOfMultiVariableDeclStmt
Is this token part of a DeclStmt defining multiple variables?
Definition: FormatToken.h:259
This class handles loading and caching of source files into memory.
IdentifierInfo * getIdentifierInfo() const
Definition: Token.h:176
bool BinPackParameters
If false, a function declaration's or function definition's parameters will either all be on the same...
Definition: Format.h:207
tok::PPKeywordKind getPPKeywordID() const
Return the preprocessor keyword ID for this identifier.