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