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