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