clang  8.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 /// This file implements the continuation indenter.
12 ///
13 //===----------------------------------------------------------------------===//
14 
15 #include "ContinuationIndenter.h"
16 #include "BreakableToken.h"
17 #include "FormatInternal.h"
18 #include "WhitespaceManager.h"
21 #include "clang/Format/Format.h"
22 #include "llvm/Support/Debug.h"
23 
24 #define DEBUG_TYPE "format-indenter"
25 
26 namespace clang {
27 namespace format {
28 
29 // Returns true if a TT_SelectorName should be indented when wrapped,
30 // false otherwise.
33  return Style.IndentWrappedFunctionNames || LineType == LT_ObjCMethodDecl;
34 }
35 
36 // Returns the length of everything up to the first possible line break after
37 // the ), ], } or > matching \c Tok.
38 static unsigned getLengthToMatchingParen(const FormatToken &Tok,
39  const std::vector<ParenState> &Stack) {
40  // Normally whether or not a break before T is possible is calculated and
41  // stored in T.CanBreakBefore. Braces, array initializers and text proto
42  // messages like `key: < ... >` are an exception: a break is possible
43  // before a closing brace R if a break was inserted after the corresponding
44  // opening brace. The information about whether or not a break is needed
45  // before a closing brace R is stored in the ParenState field
46  // S.BreakBeforeClosingBrace where S is the state that R closes.
47  //
48  // In order to decide whether there can be a break before encountered right
49  // braces, this implementation iterates over the sequence of tokens and over
50  // the paren stack in lockstep, keeping track of the stack level which visited
51  // right braces correspond to in MatchingStackIndex.
52  //
53  // For example, consider:
54  // L. <- line number
55  // 1. {
56  // 2. {1},
57  // 3. {2},
58  // 4. {{3}}}
59  // ^ where we call this method with this token.
60  // The paren stack at this point contains 3 brace levels:
61  // 0. { at line 1, BreakBeforeClosingBrace: true
62  // 1. first { at line 4, BreakBeforeClosingBrace: false
63  // 2. second { at line 4, BreakBeforeClosingBrace: false,
64  // where there might be fake parens levels in-between these levels.
65  // The algorithm will start at the first } on line 4, which is the matching
66  // brace of the initial left brace and at level 2 of the stack. Then,
67  // examining BreakBeforeClosingBrace: false at level 2, it will continue to
68  // the second } on line 4, and will traverse the stack downwards until it
69  // finds the matching { on level 1. Then, examining BreakBeforeClosingBrace:
70  // false at level 1, it will continue to the third } on line 4 and will
71  // traverse the stack downwards until it finds the matching { on level 0.
72  // Then, examining BreakBeforeClosingBrace: true at level 0, the algorithm
73  // will stop and will use the second } on line 4 to determine the length to
74  // return, as in this example the range will include the tokens: {3}}
75  //
76  // The algorithm will only traverse the stack if it encounters braces, array
77  // initializer squares or text proto angle brackets.
78  if (!Tok.MatchingParen)
79  return 0;
81  // Maintains a stack level corresponding to the current End token.
82  int MatchingStackIndex = Stack.size() - 1;
83  // Traverses the stack downwards, looking for the level to which LBrace
84  // corresponds. Returns either a pointer to the matching level or nullptr if
85  // LParen is not found in the initial portion of the stack up to
86  // MatchingStackIndex.
87  auto FindParenState = [&](const FormatToken *LBrace) -> const ParenState * {
88  while (MatchingStackIndex >= 0 && Stack[MatchingStackIndex].Tok != LBrace)
89  --MatchingStackIndex;
90  return MatchingStackIndex >= 0 ? &Stack[MatchingStackIndex] : nullptr;
91  };
92  for (; End->Next; End = End->Next) {
93  if (End->Next->CanBreakBefore)
94  break;
95  if (!End->Next->closesScope())
96  continue;
97  if (End->Next->MatchingParen &&
98  End->Next->MatchingParen->isOneOf(
99  tok::l_brace, TT_ArrayInitializerLSquare, tok::less)) {
100  const ParenState *State = FindParenState(End->Next->MatchingParen);
101  if (State && State->BreakBeforeClosingBrace)
102  break;
103  }
104  }
105  return End->TotalLength - Tok.TotalLength + 1;
106 }
107 
108 static unsigned getLengthToNextOperator(const FormatToken &Tok) {
109  if (!Tok.NextOperator)
110  return 0;
111  return Tok.NextOperator->TotalLength - Tok.TotalLength;
112 }
113 
114 // Returns \c true if \c Tok is the "." or "->" of a call and starts the next
115 // segment of a builder type call.
117  return Tok.isMemberAccess() && Tok.Previous && Tok.Previous->closesScope();
118 }
119 
120 // Returns \c true if \c Current starts a new parameter.
121 static bool startsNextParameter(const FormatToken &Current,
122  const FormatStyle &Style) {
123  const FormatToken &Previous = *Current.Previous;
124  if (Current.is(TT_CtorInitializerComma) &&
126  return true;
127  if (Style.Language == FormatStyle::LK_Proto && Current.is(TT_SelectorName))
128  return true;
129  return Previous.is(tok::comma) && !Current.isTrailingComment() &&
130  ((Previous.isNot(TT_CtorInitializerComma) ||
133  (Previous.isNot(TT_InheritanceComma) ||
135 }
136 
137 static bool opensProtoMessageField(const FormatToken &LessTok,
138  const FormatStyle &Style) {
139  if (LessTok.isNot(tok::less))
140  return false;
141  return Style.Language == FormatStyle::LK_TextProto ||
142  (Style.Language == FormatStyle::LK_Proto &&
143  (LessTok.NestingLevel > 0 ||
144  (LessTok.Previous && LessTok.Previous->is(tok::equal))));
145 }
146 
147 // Returns the delimiter of a raw string literal, or None if TokenText is not
148 // the text of a raw string literal. The delimiter could be the empty string.
149 // For example, the delimiter of R"deli(cont)deli" is deli.
151  if (TokenText.size() < 5 // The smallest raw string possible is 'R"()"'.
152  || !TokenText.startswith("R\"") || !TokenText.endswith("\""))
153  return None;
154 
155  // A raw string starts with 'R"<delimiter>(' and delimiter is ascii and has
156  // size at most 16 by the standard, so the first '(' must be among the first
157  // 19 bytes.
158  size_t LParenPos = TokenText.substr(0, 19).find_first_of('(');
159  if (LParenPos == StringRef::npos)
160  return None;
161  StringRef Delimiter = TokenText.substr(2, LParenPos - 2);
162 
163  // Check that the string ends in ')Delimiter"'.
164  size_t RParenPos = TokenText.size() - Delimiter.size() - 2;
165  if (TokenText[RParenPos] != ')')
166  return None;
167  if (!TokenText.substr(RParenPos + 1).startswith(Delimiter))
168  return None;
169  return Delimiter;
170 }
171 
172 // Returns the canonical delimiter for \p Language, or the empty string if no
173 // canonical delimiter is specified.
174 static StringRef
176  FormatStyle::LanguageKind Language) {
177  for (const auto &Format : Style.RawStringFormats) {
178  if (Format.Language == Language)
179  return StringRef(Format.CanonicalDelimiter);
180  }
181  return "";
182 }
183 
185  const FormatStyle &CodeStyle) {
186  for (const auto &RawStringFormat : CodeStyle.RawStringFormats) {
187  llvm::Optional<FormatStyle> LanguageStyle =
188  CodeStyle.GetLanguageStyle(RawStringFormat.Language);
189  if (!LanguageStyle) {
190  FormatStyle PredefinedStyle;
191  if (!getPredefinedStyle(RawStringFormat.BasedOnStyle,
192  RawStringFormat.Language, &PredefinedStyle)) {
193  PredefinedStyle = getLLVMStyle();
194  PredefinedStyle.Language = RawStringFormat.Language;
195  }
196  LanguageStyle = PredefinedStyle;
197  }
198  LanguageStyle->ColumnLimit = CodeStyle.ColumnLimit;
199  for (StringRef Delimiter : RawStringFormat.Delimiters) {
200  DelimiterStyle.insert({Delimiter, *LanguageStyle});
201  }
202  for (StringRef EnclosingFunction : RawStringFormat.EnclosingFunctions) {
203  EnclosingFunctionStyle.insert({EnclosingFunction, *LanguageStyle});
204  }
205  }
206 }
207 
210  auto It = DelimiterStyle.find(Delimiter);
211  if (It == DelimiterStyle.end())
212  return None;
213  return It->second;
214 }
215 
218  StringRef EnclosingFunction) const {
219  auto It = EnclosingFunctionStyle.find(EnclosingFunction);
220  if (It == EnclosingFunctionStyle.end())
221  return None;
222  return It->second;
223 }
224 
226  const AdditionalKeywords &Keywords,
227  const SourceManager &SourceMgr,
228  WhitespaceManager &Whitespaces,
230  bool BinPackInconclusiveFunctions)
231  : Style(Style), Keywords(Keywords), SourceMgr(SourceMgr),
232  Whitespaces(Whitespaces), Encoding(Encoding),
233  BinPackInconclusiveFunctions(BinPackInconclusiveFunctions),
234  CommentPragmasRegex(Style.CommentPragmas), RawStringFormats(Style) {}
235 
237  unsigned FirstStartColumn,
238  const AnnotatedLine *Line,
239  bool DryRun) {
241  State.FirstIndent = FirstIndent;
242  if (FirstStartColumn && Line->First->NewlinesBefore == 0)
243  State.Column = FirstStartColumn;
244  else
245  State.Column = FirstIndent;
246  // With preprocessor directive indentation, the line starts on column 0
247  // since it's indented after the hash, but FirstIndent is set to the
248  // preprocessor indent.
250  (Line->Type == LT_PreprocessorDirective ||
251  Line->Type == LT_ImportStatement))
252  State.Column = 0;
253  State.Line = Line;
254  State.NextToken = Line->First;
255  State.Stack.push_back(ParenState(/*Tok=*/nullptr, FirstIndent, FirstIndent,
256  /*AvoidBinPacking=*/false,
257  /*NoLineBreak=*/false));
259  State.NoContinuation = false;
260  State.StartOfStringLiteral = 0;
261  State.StartOfLineLevel = 0;
262  State.LowestLevelOnLine = 0;
263  State.IgnoreStackForComparison = false;
264 
265  if (Style.Language == FormatStyle::LK_TextProto) {
266  // We need this in order to deal with the bin packing of text fields at
267  // global scope.
268  State.Stack.back().AvoidBinPacking = true;
269  State.Stack.back().BreakBeforeParameter = true;
270  State.Stack.back().AlignColons = false;
271  }
272 
273  // The first token has already been indented and thus consumed.
274  moveStateToNextToken(State, DryRun, /*Newline=*/false);
275  return State;
276 }
277 
279  const FormatToken &Current = *State.NextToken;
280  const FormatToken &Previous = *Current.Previous;
281  assert(&Previous == Current.Previous);
282  if (!Current.CanBreakBefore && !(State.Stack.back().BreakBeforeClosingBrace &&
283  Current.closesBlockOrBlockTypeList(Style)))
284  return false;
285  // The opening "{" of a braced list has to be on the same line as the first
286  // element if it is nested in another braced init list or function call.
287  if (!Current.MustBreakBefore && Previous.is(tok::l_brace) &&
288  Previous.isNot(TT_DictLiteral) && Previous.BlockKind == BK_BracedInit &&
289  Previous.Previous &&
290  Previous.Previous->isOneOf(tok::l_brace, tok::l_paren, tok::comma))
291  return false;
292  // This prevents breaks like:
293  // ...
294  // SomeParameter, OtherParameter).DoSomething(
295  // ...
296  // As they hide "DoSomething" and are generally bad for readability.
297  if (Previous.opensScope() && Previous.isNot(tok::l_brace) &&
298  State.LowestLevelOnLine < State.StartOfLineLevel &&
299  State.LowestLevelOnLine < Current.NestingLevel)
300  return false;
301  if (Current.isMemberAccess() && State.Stack.back().ContainsUnwrappedBuilder)
302  return false;
303 
304  // Don't create a 'hanging' indent if there are multiple blocks in a single
305  // statement.
306  if (Previous.is(tok::l_brace) && State.Stack.size() > 1 &&
307  State.Stack[State.Stack.size() - 2].NestedBlockInlined &&
308  State.Stack[State.Stack.size() - 2].HasMultipleNestedBlocks)
309  return false;
310 
311  // Don't break after very short return types (e.g. "void") as that is often
312  // unexpected.
313  if (Current.is(TT_FunctionDeclarationName) && State.Column < 6) {
315  return false;
316  }
317 
318  // If binary operators are moved to the next line (including commas for some
319  // styles of constructor initializers), that's always ok.
320  if (!Current.isOneOf(TT_BinaryOperator, tok::comma) &&
321  State.Stack.back().NoLineBreakInOperand)
322  return false;
323 
324  if (Previous.is(tok::l_square) && Previous.is(TT_ObjCMethodExpr))
325  return false;
326 
327  return !State.Stack.back().NoLineBreak;
328 }
329 
331  const FormatToken &Current = *State.NextToken;
332  const FormatToken &Previous = *Current.Previous;
333  if (Current.MustBreakBefore || Current.is(TT_InlineASMColon))
334  return true;
335  if (State.Stack.back().BreakBeforeClosingBrace &&
336  Current.closesBlockOrBlockTypeList(Style))
337  return true;
338  if (Previous.is(tok::semi) && State.LineContainsContinuedForLoopSection)
339  return true;
340  if (Style.Language == FormatStyle::LK_ObjC &&
341  Current.ObjCSelectorNameParts > 1 &&
342  Current.startsSequence(TT_SelectorName, tok::colon, tok::caret)) {
343  return true;
344  }
345  if ((startsNextParameter(Current, Style) || Previous.is(tok::semi) ||
346  (Previous.is(TT_TemplateCloser) && Current.is(TT_StartOfName) &&
347  Style.isCpp() &&
348  // FIXME: This is a temporary workaround for the case where clang-format
349  // sets BreakBeforeParameter to avoid bin packing and this creates a
350  // completely unnecessary line break after a template type that isn't
351  // line-wrapped.
352  (Previous.NestingLevel == 1 || Style.BinPackParameters)) ||
353  (Style.BreakBeforeTernaryOperators && Current.is(TT_ConditionalExpr) &&
354  Previous.isNot(tok::question)) ||
355  (!Style.BreakBeforeTernaryOperators &&
356  Previous.is(TT_ConditionalExpr))) &&
357  State.Stack.back().BreakBeforeParameter && !Current.isTrailingComment() &&
358  !Current.isOneOf(tok::r_paren, tok::r_brace))
359  return true;
360  if (((Previous.is(TT_DictLiteral) && Previous.is(tok::l_brace)) ||
361  (Previous.is(TT_ArrayInitializerLSquare) &&
362  Previous.ParameterCount > 1) ||
363  opensProtoMessageField(Previous, Style)) &&
364  Style.ColumnLimit > 0 &&
365  getLengthToMatchingParen(Previous, State.Stack) + State.Column - 1 >
366  getColumnLimit(State))
367  return true;
368 
369  const FormatToken &BreakConstructorInitializersToken =
371  ? Previous
372  : Current;
373  if (BreakConstructorInitializersToken.is(TT_CtorInitializerColon) &&
374  (State.Column + State.Line->Last->TotalLength - Previous.TotalLength >
375  getColumnLimit(State) ||
376  State.Stack.back().BreakBeforeParameter) &&
379  Style.ColumnLimit != 0))
380  return true;
381 
382  if (Current.is(TT_ObjCMethodExpr) && !Previous.is(TT_SelectorName) &&
383  State.Line->startsWith(TT_ObjCMethodSpecifier))
384  return true;
385  if (Current.is(TT_SelectorName) && !Previous.is(tok::at) &&
386  State.Stack.back().ObjCSelectorNameFound &&
387  State.Stack.back().BreakBeforeParameter)
388  return true;
389 
390  unsigned NewLineColumn = getNewLineColumn(State);
391  if (Current.isMemberAccess() && Style.ColumnLimit != 0 &&
392  State.Column + getLengthToNextOperator(Current) > Style.ColumnLimit &&
393  (State.Column > NewLineColumn ||
394  Current.NestingLevel < State.StartOfLineLevel))
395  return true;
396 
397  if (startsSegmentOfBuilderTypeCall(Current) &&
398  (State.Stack.back().CallContinuation != 0 ||
399  State.Stack.back().BreakBeforeParameter) &&
400  // JavaScript is treated different here as there is a frequent pattern:
401  // SomeFunction(function() {
402  // ...
403  // }.bind(...));
404  // FIXME: We should find a more generic solution to this problem.
405  !(State.Column <= NewLineColumn &&
407  !(Previous.closesScopeAfterBlock() &&
408  State.Column <= NewLineColumn))
409  return true;
410 
411  // If the template declaration spans multiple lines, force wrap before the
412  // function/class declaration
413  if (Previous.ClosesTemplateDeclaration &&
414  State.Stack.back().BreakBeforeParameter && Current.CanBreakBefore)
415  return true;
416 
417  if (State.Column <= NewLineColumn)
418  return false;
419 
421  (NewLineColumn == State.FirstIndent + Style.ContinuationIndentWidth ||
422  Previous.is(tok::comma) || Current.NestingLevel < 2) &&
423  !Previous.isOneOf(tok::kw_return, tok::lessless, tok::at) &&
424  !Previous.isOneOf(TT_InlineASMColon, TT_ConditionalExpr) &&
425  nextIsMultilineString(State))
426  return true;
427 
428  // Using CanBreakBefore here and below takes care of the decision whether the
429  // current style uses wrapping before or after operators for the given
430  // operator.
431  if (Previous.is(TT_BinaryOperator) && Current.CanBreakBefore) {
432  // If we need to break somewhere inside the LHS of a binary expression, we
433  // should also break after the operator. Otherwise, the formatting would
434  // hide the operator precedence, e.g. in:
435  // if (aaaaaaaaaaaaaa ==
436  // bbbbbbbbbbbbbb && c) {..
437  // For comparisons, we only apply this rule, if the LHS is a binary
438  // expression itself as otherwise, the line breaks seem superfluous.
439  // We need special cases for ">>" which we have split into two ">" while
440  // lexing in order to make template parsing easier.
441  bool IsComparison = (Previous.getPrecedence() == prec::Relational ||
442  Previous.getPrecedence() == prec::Equality ||
443  Previous.getPrecedence() == prec::Spaceship) &&
444  Previous.Previous &&
445  Previous.Previous->isNot(TT_BinaryOperator); // For >>.
446  bool LHSIsBinaryExpr =
447  Previous.Previous && Previous.Previous->EndsBinaryExpression;
448  if ((!IsComparison || LHSIsBinaryExpr) && !Current.isTrailingComment() &&
449  Previous.getPrecedence() != prec::Assignment &&
450  State.Stack.back().BreakBeforeParameter)
451  return true;
452  } else if (Current.is(TT_BinaryOperator) && Current.CanBreakBefore &&
453  State.Stack.back().BreakBeforeParameter) {
454  return true;
455  }
456 
457  // Same as above, but for the first "<<" operator.
458  if (Current.is(tok::lessless) && Current.isNot(TT_OverloadedOperator) &&
459  State.Stack.back().BreakBeforeParameter &&
460  State.Stack.back().FirstLessLess == 0)
461  return true;
462 
463  if (Current.NestingLevel == 0 && !Current.isTrailingComment()) {
464  // Always break after "template <...>" and leading annotations. This is only
465  // for cases where the entire line does not fit on a single line as a
466  // different LineFormatter would be used otherwise.
467  if (Previous.ClosesTemplateDeclaration)
469  if (Previous.is(TT_FunctionAnnotationRParen))
470  return true;
471  if (Previous.is(TT_LeadingJavaAnnotation) && Current.isNot(tok::l_paren) &&
472  Current.isNot(TT_LeadingJavaAnnotation))
473  return true;
474  }
475 
476  // If the return type spans multiple lines, wrap before the function name.
477  if ((Current.is(TT_FunctionDeclarationName) ||
478  (Current.is(tok::kw_operator) && !Previous.is(tok::coloncolon))) &&
479  !Previous.is(tok::kw_template) && State.Stack.back().BreakBeforeParameter)
480  return true;
481 
482  // The following could be precomputed as they do not depend on the state.
483  // However, as they should take effect only if the UnwrappedLine does not fit
484  // into the ColumnLimit, they are checked here in the ContinuationIndenter.
485  if (Style.ColumnLimit != 0 && Previous.BlockKind == BK_Block &&
486  Previous.is(tok::l_brace) && !Current.isOneOf(tok::r_brace, tok::comment))
487  return true;
488 
489  if (Current.is(tok::lessless) &&
490  ((Previous.is(tok::identifier) && Previous.TokenText == "endl") ||
491  (Previous.Tok.isLiteral() && (Previous.TokenText.endswith("\\n\"") ||
492  Previous.TokenText == "\'\\n\'"))))
493  return true;
494 
495  if (Previous.is(TT_BlockComment) && Previous.IsMultiline)
496  return true;
497 
498  if (State.NoContinuation)
499  return true;
500 
501  return false;
502 }
503 
505  bool DryRun,
506  unsigned ExtraSpaces) {
507  const FormatToken &Current = *State.NextToken;
508 
509  assert(!State.Stack.empty());
510  State.NoContinuation = false;
511 
512  if ((Current.is(TT_ImplicitStringLiteral) &&
513  (Current.Previous->Tok.getIdentifierInfo() == nullptr ||
515  tok::pp_not_keyword))) {
516  unsigned EndColumn =
517  SourceMgr.getSpellingColumnNumber(Current.WhitespaceRange.getEnd());
518  if (Current.LastNewlineOffset != 0) {
519  // If there is a newline within this token, the final column will solely
520  // determined by the current end column.
521  State.Column = EndColumn;
522  } else {
523  unsigned StartColumn =
524  SourceMgr.getSpellingColumnNumber(Current.WhitespaceRange.getBegin());
525  assert(EndColumn >= StartColumn);
526  State.Column += EndColumn - StartColumn;
527  }
528  moveStateToNextToken(State, DryRun, /*Newline=*/false);
529  return 0;
530  }
531 
532  unsigned Penalty = 0;
533  if (Newline)
534  Penalty = addTokenOnNewLine(State, DryRun);
535  else
536  addTokenOnCurrentLine(State, DryRun, ExtraSpaces);
537 
538  return moveStateToNextToken(State, DryRun, Newline) + Penalty;
539 }
540 
541 void ContinuationIndenter::addTokenOnCurrentLine(LineState &State, bool DryRun,
542  unsigned ExtraSpaces) {
543  FormatToken &Current = *State.NextToken;
544  const FormatToken &Previous = *State.NextToken->Previous;
545  if (Current.is(tok::equal) &&
546  (State.Line->First->is(tok::kw_for) || Current.NestingLevel == 0) &&
547  State.Stack.back().VariablePos == 0) {
548  State.Stack.back().VariablePos = State.Column;
549  // Move over * and & if they are bound to the variable name.
550  const FormatToken *Tok = &Previous;
551  while (Tok && State.Stack.back().VariablePos >= Tok->ColumnWidth) {
552  State.Stack.back().VariablePos -= Tok->ColumnWidth;
553  if (Tok->SpacesRequiredBefore != 0)
554  break;
555  Tok = Tok->Previous;
556  }
557  if (Previous.PartOfMultiVariableDeclStmt)
558  State.Stack.back().LastSpace = State.Stack.back().VariablePos;
559  }
560 
561  unsigned Spaces = Current.SpacesRequiredBefore + ExtraSpaces;
562 
563  // Indent preprocessor directives after the hash if required.
564  int PPColumnCorrection = 0;
566  Previous.is(tok::hash) && State.FirstIndent > 0 &&
567  (State.Line->Type == LT_PreprocessorDirective ||
568  State.Line->Type == LT_ImportStatement)) {
569  Spaces += State.FirstIndent;
570 
571  // For preprocessor indent with tabs, State.Column will be 1 because of the
572  // hash. This causes second-level indents onward to have an extra space
573  // after the tabs. We avoid this misalignment by subtracting 1 from the
574  // column value passed to replaceWhitespace().
575  if (Style.UseTab != FormatStyle::UT_Never)
576  PPColumnCorrection = -1;
577  }
578 
579  if (!DryRun)
580  Whitespaces.replaceWhitespace(Current, /*Newlines=*/0, Spaces,
581  State.Column + Spaces + PPColumnCorrection);
582 
583  // If "BreakBeforeInheritanceComma" mode, don't break within the inheritance
584  // declaration unless there is multiple inheritance.
586  Current.is(TT_InheritanceColon))
587  State.Stack.back().NoLineBreak = true;
589  Previous.is(TT_InheritanceColon))
590  State.Stack.back().NoLineBreak = true;
591 
592  if (Current.is(TT_SelectorName) &&
593  !State.Stack.back().ObjCSelectorNameFound) {
594  unsigned MinIndent =
596  State.Stack.back().Indent);
597  unsigned FirstColonPos = State.Column + Spaces + Current.ColumnWidth;
598  if (Current.LongestObjCSelectorName == 0)
599  State.Stack.back().AlignColons = false;
600  else if (MinIndent + Current.LongestObjCSelectorName > FirstColonPos)
601  State.Stack.back().ColonPos = MinIndent + Current.LongestObjCSelectorName;
602  else
603  State.Stack.back().ColonPos = FirstColonPos;
604  }
605 
606  // In "AlwaysBreak" mode, enforce wrapping directly after the parenthesis by
607  // disallowing any further line breaks if there is no line break after the
608  // opening parenthesis. Don't break if it doesn't conserve columns.
610  Previous.isOneOf(tok::l_paren, TT_TemplateOpener, tok::l_square) &&
611  State.Column > getNewLineColumn(State) &&
612  (!Previous.Previous || !Previous.Previous->isOneOf(
613  tok::kw_for, tok::kw_while, tok::kw_switch)) &&
614  // Don't do this for simple (no expressions) one-argument function calls
615  // as that feels like needlessly wasting whitespace, e.g.:
616  //
617  // caaaaaaaaaaaall(
618  // caaaaaaaaaaaall(
619  // caaaaaaaaaaaall(
620  // caaaaaaaaaaaaaaaaaaaaaaall(aaaaaaaaaaaaaa, aaaaaaaaa))));
621  Current.FakeLParens.size() > 0 &&
622  Current.FakeLParens.back() > prec::Unknown)
623  State.Stack.back().NoLineBreak = true;
624  if (Previous.is(TT_TemplateString) && Previous.opensScope())
625  State.Stack.back().NoLineBreak = true;
626 
628  Previous.opensScope() && Previous.isNot(TT_ObjCMethodExpr) &&
629  (Current.isNot(TT_LineComment) || Previous.BlockKind == BK_BracedInit))
630  State.Stack.back().Indent = State.Column + Spaces;
631  if (State.Stack.back().AvoidBinPacking && startsNextParameter(Current, Style))
632  State.Stack.back().NoLineBreak = true;
633  if (startsSegmentOfBuilderTypeCall(Current) &&
634  State.Column > getNewLineColumn(State))
635  State.Stack.back().ContainsUnwrappedBuilder = true;
636 
637  if (Current.is(TT_LambdaArrow) && Style.Language == FormatStyle::LK_Java)
638  State.Stack.back().NoLineBreak = true;
639  if (Current.isMemberAccess() && Previous.is(tok::r_paren) &&
640  (Previous.MatchingParen &&
641  (Previous.TotalLength - Previous.MatchingParen->TotalLength > 10)))
642  // If there is a function call with long parameters, break before trailing
643  // calls. This prevents things like:
644  // EXPECT_CALL(SomeLongParameter).Times(
645  // 2);
646  // We don't want to do this for short parameters as they can just be
647  // indexes.
648  State.Stack.back().NoLineBreak = true;
649 
650  // Don't allow the RHS of an operator to be split over multiple lines unless
651  // there is a line-break right after the operator.
652  // Exclude relational operators, as there, it is always more desirable to
653  // have the LHS 'left' of the RHS.
654  const FormatToken *P = Current.getPreviousNonComment();
655  if (!Current.is(tok::comment) && P &&
656  (P->isOneOf(TT_BinaryOperator, tok::comma) ||
657  (P->is(TT_ConditionalExpr) && P->is(tok::colon))) &&
658  !P->isOneOf(TT_OverloadedOperator, TT_CtorInitializerComma) &&
661  P->getPrecedence() != prec::Spaceship) {
662  bool BreakBeforeOperator =
663  P->MustBreakBefore || P->is(tok::lessless) ||
664  (P->is(TT_BinaryOperator) &&
666  (P->is(TT_ConditionalExpr) && Style.BreakBeforeTernaryOperators);
667  // Don't do this if there are only two operands. In these cases, there is
668  // always a nice vertical separation between them and the extra line break
669  // does not help.
670  bool HasTwoOperands =
671  P->OperatorIndex == 0 && !P->NextOperator && !P->is(TT_ConditionalExpr);
672  if ((!BreakBeforeOperator && !(HasTwoOperands && Style.AlignOperands)) ||
673  (!State.Stack.back().LastOperatorWrapped && BreakBeforeOperator))
674  State.Stack.back().NoLineBreakInOperand = true;
675  }
676 
677  State.Column += Spaces;
678  if (Current.isNot(tok::comment) && Previous.is(tok::l_paren) &&
679  Previous.Previous &&
680  (Previous.Previous->isOneOf(tok::kw_if, tok::kw_for) ||
681  Previous.Previous->endsSequence(tok::kw_constexpr, tok::kw_if))) {
682  // Treat the condition inside an if as if it was a second function
683  // parameter, i.e. let nested calls have a continuation indent.
684  State.Stack.back().LastSpace = State.Column;
685  State.Stack.back().NestedBlockIndent = State.Column;
686  } else if (!Current.isOneOf(tok::comment, tok::caret) &&
687  ((Previous.is(tok::comma) &&
688  !Previous.is(TT_OverloadedOperator)) ||
689  (Previous.is(tok::colon) && Previous.is(TT_ObjCMethodExpr)))) {
690  State.Stack.back().LastSpace = State.Column;
691  } else if (Previous.is(TT_CtorInitializerColon) &&
694  State.Stack.back().Indent = State.Column;
695  State.Stack.back().LastSpace = State.Column;
696  } else if ((Previous.isOneOf(TT_BinaryOperator, TT_ConditionalExpr,
697  TT_CtorInitializerColon)) &&
698  ((Previous.getPrecedence() != prec::Assignment &&
699  (Previous.isNot(tok::lessless) || Previous.OperatorIndex != 0 ||
700  Previous.NextOperator)) ||
701  Current.StartsBinaryExpression)) {
702  // Indent relative to the RHS of the expression unless this is a simple
703  // assignment without binary expression on the RHS. Also indent relative to
704  // unary operators and the colons of constructor initializers.
706  State.Stack.back().LastSpace = State.Column;
707  } else if (Previous.is(TT_InheritanceColon)) {
708  State.Stack.back().Indent = State.Column;
709  State.Stack.back().LastSpace = State.Column;
710  } else if (Previous.opensScope()) {
711  // If a function has a trailing call, indent all parameters from the
712  // opening parenthesis. This avoids confusing indents like:
713  // OuterFunction(InnerFunctionCall( // break
714  // ParameterToInnerFunction)) // break
715  // .SecondInnerFunctionCall();
716  bool HasTrailingCall = false;
717  if (Previous.MatchingParen) {
718  const FormatToken *Next = Previous.MatchingParen->getNextNonComment();
719  HasTrailingCall = Next && Next->isMemberAccess();
720  }
721  if (HasTrailingCall && State.Stack.size() > 1 &&
722  State.Stack[State.Stack.size() - 2].CallContinuation == 0)
723  State.Stack.back().LastSpace = State.Column;
724  }
725 }
726 
727 unsigned ContinuationIndenter::addTokenOnNewLine(LineState &State,
728  bool DryRun) {
729  FormatToken &Current = *State.NextToken;
730  const FormatToken &Previous = *State.NextToken->Previous;
731 
732  // Extra penalty that needs to be added because of the way certain line
733  // breaks are chosen.
734  unsigned Penalty = 0;
735 
736  const FormatToken *PreviousNonComment = Current.getPreviousNonComment();
737  const FormatToken *NextNonComment = Previous.getNextNonComment();
738  if (!NextNonComment)
739  NextNonComment = &Current;
740  // The first line break on any NestingLevel causes an extra penalty in order
741  // prefer similar line breaks.
742  if (!State.Stack.back().ContainsLineBreak)
743  Penalty += 15;
744  State.Stack.back().ContainsLineBreak = true;
745 
746  Penalty += State.NextToken->SplitPenalty;
747 
748  // Breaking before the first "<<" is generally not desirable if the LHS is
749  // short. Also always add the penalty if the LHS is split over multiple lines
750  // to avoid unnecessary line breaks that just work around this penalty.
751  if (NextNonComment->is(tok::lessless) &&
752  State.Stack.back().FirstLessLess == 0 &&
753  (State.Column <= Style.ColumnLimit / 3 ||
754  State.Stack.back().BreakBeforeParameter))
755  Penalty += Style.PenaltyBreakFirstLessLess;
756 
757  State.Column = getNewLineColumn(State);
758 
759  // Indent nested blocks relative to this column, unless in a very specific
760  // JavaScript special case where:
761  //
762  // var loooooong_name =
763  // function() {
764  // // code
765  // }
766  //
767  // is common and should be formatted like a free-standing function. The same
768  // goes for wrapping before the lambda return type arrow.
769  if (!Current.is(TT_LambdaArrow) &&
771  Current.NestingLevel != 0 || !PreviousNonComment ||
772  !PreviousNonComment->is(tok::equal) ||
773  !Current.isOneOf(Keywords.kw_async, Keywords.kw_function)))
774  State.Stack.back().NestedBlockIndent = State.Column;
775 
776  if (NextNonComment->isMemberAccess()) {
777  if (State.Stack.back().CallContinuation == 0)
778  State.Stack.back().CallContinuation = State.Column;
779  } else if (NextNonComment->is(TT_SelectorName)) {
780  if (!State.Stack.back().ObjCSelectorNameFound) {
781  if (NextNonComment->LongestObjCSelectorName == 0) {
782  State.Stack.back().AlignColons = false;
783  } else {
784  State.Stack.back().ColonPos =
786  ? std::max(State.Stack.back().Indent,
787  State.FirstIndent + Style.ContinuationIndentWidth)
788  : State.Stack.back().Indent) +
789  std::max(NextNonComment->LongestObjCSelectorName,
790  NextNonComment->ColumnWidth);
791  }
792  } else if (State.Stack.back().AlignColons &&
793  State.Stack.back().ColonPos <= NextNonComment->ColumnWidth) {
794  State.Stack.back().ColonPos = State.Column + NextNonComment->ColumnWidth;
795  }
796  } else if (PreviousNonComment && PreviousNonComment->is(tok::colon) &&
797  PreviousNonComment->isOneOf(TT_ObjCMethodExpr, TT_DictLiteral)) {
798  // FIXME: This is hacky, find a better way. The problem is that in an ObjC
799  // method expression, the block should be aligned to the line starting it,
800  // e.g.:
801  // [aaaaaaaaaaaaaaa aaaaaaaaa: \\ break for some reason
802  // ^(int *i) {
803  // // ...
804  // }];
805  // Thus, we set LastSpace of the next higher NestingLevel, to which we move
806  // when we consume all of the "}"'s FakeRParens at the "{".
807  if (State.Stack.size() > 1)
808  State.Stack[State.Stack.size() - 2].LastSpace =
809  std::max(State.Stack.back().LastSpace, State.Stack.back().Indent) +
811  }
812 
813  if ((PreviousNonComment &&
814  PreviousNonComment->isOneOf(tok::comma, tok::semi) &&
815  !State.Stack.back().AvoidBinPacking) ||
816  Previous.is(TT_BinaryOperator))
817  State.Stack.back().BreakBeforeParameter = false;
818  if (PreviousNonComment &&
819  PreviousNonComment->isOneOf(TT_TemplateCloser, TT_JavaAnnotation) &&
820  Current.NestingLevel == 0)
821  State.Stack.back().BreakBeforeParameter = false;
822  if (NextNonComment->is(tok::question) ||
823  (PreviousNonComment && PreviousNonComment->is(tok::question)))
824  State.Stack.back().BreakBeforeParameter = true;
825  if (Current.is(TT_BinaryOperator) && Current.CanBreakBefore)
826  State.Stack.back().BreakBeforeParameter = false;
827 
828  if (!DryRun) {
829  unsigned MaxEmptyLinesToKeep = Style.MaxEmptyLinesToKeep + 1;
830  if (Current.is(tok::r_brace) && Current.MatchingParen &&
831  // Only strip trailing empty lines for l_braces that have children, i.e.
832  // for function expressions (lambdas, arrows, etc).
833  !Current.MatchingParen->Children.empty()) {
834  // lambdas and arrow functions are expressions, thus their r_brace is not
835  // on its own line, and thus not covered by UnwrappedLineFormatter's logic
836  // about removing empty lines on closing blocks. Special case them here.
837  MaxEmptyLinesToKeep = 1;
838  }
839  unsigned Newlines = std::max(
840  1u, std::min(Current.NewlinesBefore, MaxEmptyLinesToKeep));
841  bool ContinuePPDirective =
842  State.Line->InPPDirective && State.Line->Type != LT_ImportStatement;
843  Whitespaces.replaceWhitespace(Current, Newlines, State.Column, State.Column,
844  ContinuePPDirective);
845  }
846 
847  if (!Current.isTrailingComment())
848  State.Stack.back().LastSpace = State.Column;
849  if (Current.is(tok::lessless))
850  // If we are breaking before a "<<", we always want to indent relative to
851  // RHS. This is necessary only for "<<", as we special-case it and don't
852  // always indent relative to the RHS.
853  State.Stack.back().LastSpace += 3; // 3 -> width of "<< ".
854 
855  State.StartOfLineLevel = Current.NestingLevel;
856  State.LowestLevelOnLine = Current.NestingLevel;
857 
858  // Any break on this level means that the parent level has been broken
859  // and we need to avoid bin packing there.
860  bool NestedBlockSpecialCase =
861  !Style.isCpp() && Current.is(tok::r_brace) && State.Stack.size() > 1 &&
862  State.Stack[State.Stack.size() - 2].NestedBlockInlined;
863  if (!NestedBlockSpecialCase)
864  for (unsigned i = 0, e = State.Stack.size() - 1; i != e; ++i)
865  State.Stack[i].BreakBeforeParameter = true;
866 
867  if (PreviousNonComment &&
868  !PreviousNonComment->isOneOf(tok::comma, tok::colon, tok::semi) &&
869  (PreviousNonComment->isNot(TT_TemplateCloser) ||
870  Current.NestingLevel != 0) &&
871  !PreviousNonComment->isOneOf(
872  TT_BinaryOperator, TT_FunctionAnnotationRParen, TT_JavaAnnotation,
873  TT_LeadingJavaAnnotation) &&
874  Current.isNot(TT_BinaryOperator) && !PreviousNonComment->opensScope())
875  State.Stack.back().BreakBeforeParameter = true;
876 
877  // If we break after { or the [ of an array initializer, we should also break
878  // before the corresponding } or ].
879  if (PreviousNonComment &&
880  (PreviousNonComment->isOneOf(tok::l_brace, TT_ArrayInitializerLSquare) ||
881  opensProtoMessageField(*PreviousNonComment, Style)))
882  State.Stack.back().BreakBeforeClosingBrace = true;
883 
884  if (State.Stack.back().AvoidBinPacking) {
885  // If we are breaking after '(', '{', '<', this is not bin packing
886  // unless AllowAllParametersOfDeclarationOnNextLine is false or this is a
887  // dict/object literal.
888  if (!Previous.isOneOf(tok::l_paren, tok::l_brace, TT_BinaryOperator) ||
890  State.Line->MustBeDeclaration) ||
891  Previous.is(TT_DictLiteral))
892  State.Stack.back().BreakBeforeParameter = true;
893  }
894 
895  return Penalty;
896 }
897 
898 unsigned ContinuationIndenter::getNewLineColumn(const LineState &State) {
899  if (!State.NextToken || !State.NextToken->Previous)
900  return 0;
901  FormatToken &Current = *State.NextToken;
902  const FormatToken &Previous = *Current.Previous;
903  // If we are continuing an expression, we want to use the continuation indent.
904  unsigned ContinuationIndent =
905  std::max(State.Stack.back().LastSpace, State.Stack.back().Indent) +
907  const FormatToken *PreviousNonComment = Current.getPreviousNonComment();
908  const FormatToken *NextNonComment = Previous.getNextNonComment();
909  if (!NextNonComment)
910  NextNonComment = &Current;
911 
912  // Java specific bits.
913  if (Style.Language == FormatStyle::LK_Java &&
914  Current.isOneOf(Keywords.kw_implements, Keywords.kw_extends))
915  return std::max(State.Stack.back().LastSpace,
916  State.Stack.back().Indent + Style.ContinuationIndentWidth);
917 
918  if (NextNonComment->is(tok::l_brace) && NextNonComment->BlockKind == BK_Block)
919  return Current.NestingLevel == 0 ? State.FirstIndent
920  : State.Stack.back().Indent;
921  if ((Current.isOneOf(tok::r_brace, tok::r_square) ||
922  (Current.is(tok::greater) &&
923  (Style.Language == FormatStyle::LK_Proto ||
924  Style.Language == FormatStyle::LK_TextProto))) &&
925  State.Stack.size() > 1) {
926  if (Current.closesBlockOrBlockTypeList(Style))
927  return State.Stack[State.Stack.size() - 2].NestedBlockIndent;
928  if (Current.MatchingParen &&
930  return State.Stack[State.Stack.size() - 2].LastSpace;
931  return State.FirstIndent;
932  }
933  // Indent a closing parenthesis at the previous level if followed by a semi or
934  // opening brace. This allows indentations such as:
935  // foo(
936  // a,
937  // );
938  // function foo(
939  // a,
940  // ) {
941  // code(); //
942  // }
943  if (Current.is(tok::r_paren) && State.Stack.size() > 1 &&
944  (!Current.Next || Current.Next->isOneOf(tok::semi, tok::l_brace)))
945  return State.Stack[State.Stack.size() - 2].LastSpace;
946  if (NextNonComment->is(TT_TemplateString) && NextNonComment->closesScope())
947  return State.Stack[State.Stack.size() - 2].LastSpace;
948  if (Current.is(tok::identifier) && Current.Next &&
949  (Current.Next->is(TT_DictLiteral) ||
950  ((Style.Language == FormatStyle::LK_Proto ||
952  Current.Next->isOneOf(tok::less, tok::l_brace))))
953  return State.Stack.back().Indent;
954  if (NextNonComment->is(TT_ObjCStringLiteral) &&
955  State.StartOfStringLiteral != 0)
956  return State.StartOfStringLiteral - 1;
957  if (NextNonComment->isStringLiteral() && State.StartOfStringLiteral != 0)
958  return State.StartOfStringLiteral;
959  if (NextNonComment->is(tok::lessless) &&
960  State.Stack.back().FirstLessLess != 0)
961  return State.Stack.back().FirstLessLess;
962  if (NextNonComment->isMemberAccess()) {
963  if (State.Stack.back().CallContinuation == 0)
964  return ContinuationIndent;
965  return State.Stack.back().CallContinuation;
966  }
967  if (State.Stack.back().QuestionColumn != 0 &&
968  ((NextNonComment->is(tok::colon) &&
969  NextNonComment->is(TT_ConditionalExpr)) ||
970  Previous.is(TT_ConditionalExpr)))
971  return State.Stack.back().QuestionColumn;
972  if (Previous.is(tok::comma) && State.Stack.back().VariablePos != 0)
973  return State.Stack.back().VariablePos;
974  if ((PreviousNonComment &&
975  (PreviousNonComment->ClosesTemplateDeclaration ||
976  PreviousNonComment->isOneOf(
977  TT_AttributeParen, TT_AttributeSquare, TT_FunctionAnnotationRParen,
978  TT_JavaAnnotation, TT_LeadingJavaAnnotation))) ||
979  (!Style.IndentWrappedFunctionNames &&
980  NextNonComment->isOneOf(tok::kw_operator, TT_FunctionDeclarationName)))
981  return std::max(State.Stack.back().LastSpace, State.Stack.back().Indent);
982  if (NextNonComment->is(TT_SelectorName)) {
983  if (!State.Stack.back().ObjCSelectorNameFound) {
984  unsigned MinIndent = State.Stack.back().Indent;
985  if (shouldIndentWrappedSelectorName(Style, State.Line->Type))
986  MinIndent = std::max(MinIndent,
987  State.FirstIndent + Style.ContinuationIndentWidth);
988  // If LongestObjCSelectorName is 0, we are indenting the first
989  // part of an ObjC selector (or a selector component which is
990  // not colon-aligned due to block formatting).
991  //
992  // Otherwise, we are indenting a subsequent part of an ObjC
993  // selector which should be colon-aligned to the longest
994  // component of the ObjC selector.
995  //
996  // In either case, we want to respect Style.IndentWrappedFunctionNames.
997  return MinIndent +
998  std::max(NextNonComment->LongestObjCSelectorName,
999  NextNonComment->ColumnWidth) -
1000  NextNonComment->ColumnWidth;
1001  }
1002  if (!State.Stack.back().AlignColons)
1003  return State.Stack.back().Indent;
1004  if (State.Stack.back().ColonPos > NextNonComment->ColumnWidth)
1005  return State.Stack.back().ColonPos - NextNonComment->ColumnWidth;
1006  return State.Stack.back().Indent;
1007  }
1008  if (NextNonComment->is(tok::colon) && NextNonComment->is(TT_ObjCMethodExpr))
1009  return State.Stack.back().ColonPos;
1010  if (NextNonComment->is(TT_ArraySubscriptLSquare)) {
1011  if (State.Stack.back().StartOfArraySubscripts != 0)
1012  return State.Stack.back().StartOfArraySubscripts;
1013  return ContinuationIndent;
1014  }
1015 
1016  // This ensure that we correctly format ObjC methods calls without inputs,
1017  // i.e. where the last element isn't selector like: [callee method];
1018  if (NextNonComment->is(tok::identifier) && NextNonComment->FakeRParens == 0 &&
1019  NextNonComment->Next && NextNonComment->Next->is(TT_ObjCMethodExpr))
1020  return State.Stack.back().Indent;
1021 
1022  if (NextNonComment->isOneOf(TT_StartOfName, TT_PointerOrReference) ||
1023  Previous.isOneOf(tok::coloncolon, tok::equal, TT_JsTypeColon))
1024  return ContinuationIndent;
1025  if (PreviousNonComment && PreviousNonComment->is(tok::colon) &&
1026  PreviousNonComment->isOneOf(TT_ObjCMethodExpr, TT_DictLiteral))
1027  return ContinuationIndent;
1028  if (NextNonComment->is(TT_CtorInitializerComma))
1029  return State.Stack.back().Indent;
1030  if (PreviousNonComment && PreviousNonComment->is(TT_CtorInitializerColon) &&
1032  return State.Stack.back().Indent;
1033  if (PreviousNonComment && PreviousNonComment->is(TT_InheritanceColon) &&
1035  return State.Stack.back().Indent;
1036  if (NextNonComment->isOneOf(TT_CtorInitializerColon, TT_InheritanceColon,
1037  TT_InheritanceComma))
1038  return State.FirstIndent + Style.ConstructorInitializerIndentWidth;
1039  if (Previous.is(tok::r_paren) && !Current.isBinaryOperator() &&
1040  !Current.isOneOf(tok::colon, tok::comment))
1041  return ContinuationIndent;
1042  if (Current.is(TT_ProtoExtensionLSquare))
1043  return State.Stack.back().Indent;
1044  if (State.Stack.back().Indent == State.FirstIndent && PreviousNonComment &&
1045  PreviousNonComment->isNot(tok::r_brace))
1046  // Ensure that we fall back to the continuation indent width instead of
1047  // just flushing continuations left.
1048  return State.Stack.back().Indent + Style.ContinuationIndentWidth;
1049  return State.Stack.back().Indent;
1050 }
1051 
1052 unsigned ContinuationIndenter::moveStateToNextToken(LineState &State,
1053  bool DryRun, bool Newline) {
1054  assert(State.Stack.size());
1055  const FormatToken &Current = *State.NextToken;
1056 
1057  if (Current.isOneOf(tok::comma, TT_BinaryOperator))
1058  State.Stack.back().NoLineBreakInOperand = false;
1059  if (Current.is(TT_InheritanceColon))
1060  State.Stack.back().AvoidBinPacking = true;
1061  if (Current.is(tok::lessless) && Current.isNot(TT_OverloadedOperator)) {
1062  if (State.Stack.back().FirstLessLess == 0)
1063  State.Stack.back().FirstLessLess = State.Column;
1064  else
1065  State.Stack.back().LastOperatorWrapped = Newline;
1066  }
1067  if (Current.is(TT_BinaryOperator) && Current.isNot(tok::lessless))
1068  State.Stack.back().LastOperatorWrapped = Newline;
1069  if (Current.is(TT_ConditionalExpr) && Current.Previous &&
1070  !Current.Previous->is(TT_ConditionalExpr))
1071  State.Stack.back().LastOperatorWrapped = Newline;
1072  if (Current.is(TT_ArraySubscriptLSquare) &&
1073  State.Stack.back().StartOfArraySubscripts == 0)
1074  State.Stack.back().StartOfArraySubscripts = State.Column;
1075  if (Style.BreakBeforeTernaryOperators && Current.is(tok::question))
1076  State.Stack.back().QuestionColumn = State.Column;
1077  if (!Style.BreakBeforeTernaryOperators && Current.isNot(tok::colon)) {
1078  const FormatToken *Previous = Current.Previous;
1079  while (Previous && Previous->isTrailingComment())
1080  Previous = Previous->Previous;
1081  if (Previous && Previous->is(tok::question))
1082  State.Stack.back().QuestionColumn = State.Column;
1083  }
1084  if (!Current.opensScope() && !Current.closesScope() &&
1085  !Current.is(TT_PointerOrReference))
1086  State.LowestLevelOnLine =
1087  std::min(State.LowestLevelOnLine, Current.NestingLevel);
1088  if (Current.isMemberAccess())
1089  State.Stack.back().StartOfFunctionCall =
1090  !Current.NextOperator ? 0 : State.Column;
1091  if (Current.is(TT_SelectorName))
1092  State.Stack.back().ObjCSelectorNameFound = true;
1093  if (Current.is(TT_CtorInitializerColon) &&
1095  // Indent 2 from the column, so:
1096  // SomeClass::SomeClass()
1097  // : First(...), ...
1098  // Next(...)
1099  // ^ line up here.
1100  State.Stack.back().Indent =
1101  State.Column +
1103  ? 0
1104  : 2);
1105  State.Stack.back().NestedBlockIndent = State.Stack.back().Indent;
1107  State.Stack.back().AvoidBinPacking = true;
1108  State.Stack.back().BreakBeforeParameter = false;
1109  }
1110  if (Current.is(TT_CtorInitializerColon) &&
1112  State.Stack.back().Indent =
1114  State.Stack.back().NestedBlockIndent = State.Stack.back().Indent;
1116  State.Stack.back().AvoidBinPacking = true;
1117  }
1118  if (Current.is(TT_InheritanceColon))
1119  State.Stack.back().Indent =
1121  if (Current.isOneOf(TT_BinaryOperator, TT_ConditionalExpr) && Newline)
1122  State.Stack.back().NestedBlockIndent =
1123  State.Column + Current.ColumnWidth + 1;
1124  if (Current.isOneOf(TT_LambdaLSquare, TT_LambdaArrow))
1125  State.Stack.back().LastSpace = State.Column;
1126 
1127  // Insert scopes created by fake parenthesis.
1128  const FormatToken *Previous = Current.getPreviousNonComment();
1129 
1130  // Add special behavior to support a format commonly used for JavaScript
1131  // closures:
1132  // SomeFunction(function() {
1133  // foo();
1134  // bar();
1135  // }, a, b, c);
1136  if (Current.isNot(tok::comment) && Previous &&
1137  Previous->isOneOf(tok::l_brace, TT_ArrayInitializerLSquare) &&
1138  !Previous->is(TT_DictLiteral) && State.Stack.size() > 1) {
1139  if (State.Stack[State.Stack.size() - 2].NestedBlockInlined && Newline)
1140  for (unsigned i = 0, e = State.Stack.size() - 1; i != e; ++i)
1141  State.Stack[i].NoLineBreak = true;
1142  State.Stack[State.Stack.size() - 2].NestedBlockInlined = false;
1143  }
1144  if (Previous &&
1145  (Previous->isOneOf(tok::l_paren, tok::comma, tok::colon) ||
1146  Previous->isOneOf(TT_BinaryOperator, TT_ConditionalExpr)) &&
1147  !Previous->isOneOf(TT_DictLiteral, TT_ObjCMethodExpr)) {
1148  State.Stack.back().NestedBlockInlined =
1149  !Newline &&
1150  (Previous->isNot(tok::l_paren) || Previous->ParameterCount > 1);
1151  }
1152 
1153  moveStatePastFakeLParens(State, Newline);
1154  moveStatePastScopeCloser(State);
1155  bool AllowBreak = !State.Stack.back().NoLineBreak &&
1156  !State.Stack.back().NoLineBreakInOperand;
1157  moveStatePastScopeOpener(State, Newline);
1158  moveStatePastFakeRParens(State);
1159 
1160  if (Current.is(TT_ObjCStringLiteral) && State.StartOfStringLiteral == 0)
1161  State.StartOfStringLiteral = State.Column + 1;
1162  else if (Current.isStringLiteral() && State.StartOfStringLiteral == 0)
1163  State.StartOfStringLiteral = State.Column;
1164  else if (!Current.isOneOf(tok::comment, tok::identifier, tok::hash) &&
1165  !Current.isStringLiteral())
1166  State.StartOfStringLiteral = 0;
1167 
1168  State.Column += Current.ColumnWidth;
1169  State.NextToken = State.NextToken->Next;
1170 
1171  unsigned Penalty =
1172  handleEndOfLine(Current, State, DryRun, AllowBreak);
1173 
1174  if (Current.Role)
1175  Current.Role->formatFromToken(State, this, DryRun);
1176  // If the previous has a special role, let it consume tokens as appropriate.
1177  // It is necessary to start at the previous token for the only implemented
1178  // role (comma separated list). That way, the decision whether or not to break
1179  // after the "{" is already done and both options are tried and evaluated.
1180  // FIXME: This is ugly, find a better way.
1181  if (Previous && Previous->Role)
1182  Penalty += Previous->Role->formatAfterToken(State, this, DryRun);
1183 
1184  return Penalty;
1185 }
1186 
1187 void ContinuationIndenter::moveStatePastFakeLParens(LineState &State,
1188  bool Newline) {
1189  const FormatToken &Current = *State.NextToken;
1190  const FormatToken *Previous = Current.getPreviousNonComment();
1191 
1192  // Don't add extra indentation for the first fake parenthesis after
1193  // 'return', assignments or opening <({[. The indentation for these cases
1194  // is special cased.
1195  bool SkipFirstExtraIndent =
1196  (Previous && (Previous->opensScope() ||
1197  Previous->isOneOf(tok::semi, tok::kw_return) ||
1198  (Previous->getPrecedence() == prec::Assignment &&
1199  Style.AlignOperands) ||
1200  Previous->is(TT_ObjCMethodExpr)));
1202  I = Current.FakeLParens.rbegin(),
1203  E = Current.FakeLParens.rend();
1204  I != E; ++I) {
1205  ParenState NewParenState = State.Stack.back();
1206  NewParenState.Tok = nullptr;
1207  NewParenState.ContainsLineBreak = false;
1208  NewParenState.LastOperatorWrapped = true;
1209  NewParenState.NoLineBreak =
1210  NewParenState.NoLineBreak || State.Stack.back().NoLineBreakInOperand;
1211 
1212  // Don't propagate AvoidBinPacking into subexpressions of arg/param lists.
1213  if (*I > prec::Comma)
1214  NewParenState.AvoidBinPacking = false;
1215 
1216  // Indent from 'LastSpace' unless these are fake parentheses encapsulating
1217  // a builder type call after 'return' or, if the alignment after opening
1218  // brackets is disabled.
1219  if (!Current.isTrailingComment() &&
1220  (Style.AlignOperands || *I < prec::Assignment) &&
1221  (!Previous || Previous->isNot(tok::kw_return) ||
1222  (Style.Language != FormatStyle::LK_Java && *I > 0)) &&
1224  *I != prec::Comma || Current.NestingLevel == 0))
1225  NewParenState.Indent =
1226  std::max(std::max(State.Column, NewParenState.Indent),
1227  State.Stack.back().LastSpace);
1228 
1229  // Do not indent relative to the fake parentheses inserted for "." or "->".
1230  // This is a special case to make the following to statements consistent:
1231  // OuterFunction(InnerFunctionCall( // break
1232  // ParameterToInnerFunction));
1233  // OuterFunction(SomeObject.InnerFunctionCall( // break
1234  // ParameterToInnerFunction));
1235  if (*I > prec::Unknown)
1236  NewParenState.LastSpace = std::max(NewParenState.LastSpace, State.Column);
1237  if (*I != prec::Conditional && !Current.is(TT_UnaryOperator) &&
1239  NewParenState.StartOfFunctionCall = State.Column;
1240 
1241  // Always indent conditional expressions. Never indent expression where
1242  // the 'operator' is ',', ';' or an assignment (i.e. *I <=
1243  // prec::Assignment) as those have different indentation rules. Indent
1244  // other expression, unless the indentation needs to be skipped.
1245  if (*I == prec::Conditional ||
1246  (!SkipFirstExtraIndent && *I > prec::Assignment &&
1247  !Current.isTrailingComment()))
1248  NewParenState.Indent += Style.ContinuationIndentWidth;
1249  if ((Previous && !Previous->opensScope()) || *I != prec::Comma)
1250  NewParenState.BreakBeforeParameter = false;
1251  State.Stack.push_back(NewParenState);
1252  SkipFirstExtraIndent = false;
1253  }
1254 }
1255 
1256 void ContinuationIndenter::moveStatePastFakeRParens(LineState &State) {
1257  for (unsigned i = 0, e = State.NextToken->FakeRParens; i != e; ++i) {
1258  unsigned VariablePos = State.Stack.back().VariablePos;
1259  if (State.Stack.size() == 1) {
1260  // Do not pop the last element.
1261  break;
1262  }
1263  State.Stack.pop_back();
1264  State.Stack.back().VariablePos = VariablePos;
1265  }
1266 }
1267 
1268 void ContinuationIndenter::moveStatePastScopeOpener(LineState &State,
1269  bool Newline) {
1270  const FormatToken &Current = *State.NextToken;
1271  if (!Current.opensScope())
1272  return;
1273 
1274  if (Current.MatchingParen && Current.BlockKind == BK_Block) {
1275  moveStateToNewBlock(State);
1276  return;
1277  }
1278 
1279  unsigned NewIndent;
1280  unsigned LastSpace = State.Stack.back().LastSpace;
1281  bool AvoidBinPacking;
1282  bool BreakBeforeParameter = false;
1283  unsigned NestedBlockIndent = std::max(State.Stack.back().StartOfFunctionCall,
1284  State.Stack.back().NestedBlockIndent);
1285  if (Current.isOneOf(tok::l_brace, TT_ArrayInitializerLSquare) ||
1286  opensProtoMessageField(Current, Style)) {
1287  if (Current.opensBlockOrBlockTypeList(Style)) {
1288  NewIndent = Style.IndentWidth +
1289  std::min(State.Column, State.Stack.back().NestedBlockIndent);
1290  } else {
1291  NewIndent = State.Stack.back().LastSpace + Style.ContinuationIndentWidth;
1292  }
1293  const FormatToken *NextNoComment = Current.getNextNonComment();
1294  bool EndsInComma = Current.MatchingParen &&
1295  Current.MatchingParen->Previous &&
1296  Current.MatchingParen->Previous->is(tok::comma);
1297  AvoidBinPacking = EndsInComma || Current.is(TT_DictLiteral) ||
1298  Style.Language == FormatStyle::LK_Proto ||
1300  !Style.BinPackArguments ||
1301  (NextNoComment &&
1302  NextNoComment->isOneOf(TT_DesignatedInitializerPeriod,
1303  TT_DesignatedInitializerLSquare));
1304  BreakBeforeParameter = EndsInComma;
1305  if (Current.ParameterCount > 1)
1306  NestedBlockIndent = std::max(NestedBlockIndent, State.Column + 1);
1307  } else {
1308  NewIndent = Style.ContinuationIndentWidth +
1309  std::max(State.Stack.back().LastSpace,
1310  State.Stack.back().StartOfFunctionCall);
1311 
1312  // Ensure that different different brackets force relative alignment, e.g.:
1313  // void SomeFunction(vector< // break
1314  // int> v);
1315  // FIXME: We likely want to do this for more combinations of brackets.
1316  if (Current.is(tok::less) && Current.ParentBracket == tok::l_paren) {
1317  NewIndent = std::max(NewIndent, State.Stack.back().Indent);
1318  LastSpace = std::max(LastSpace, State.Stack.back().Indent);
1319  }
1320 
1321  bool EndsInComma =
1322  Current.MatchingParen &&
1323  Current.MatchingParen->getPreviousNonComment() &&
1324  Current.MatchingParen->getPreviousNonComment()->is(tok::comma);
1325 
1326  // If ObjCBinPackProtocolList is unspecified, fall back to BinPackParameters
1327  // for backwards compatibility.
1328  bool ObjCBinPackProtocolList =
1330  Style.BinPackParameters) ||
1332 
1333  bool BinPackDeclaration =
1334  (State.Line->Type != LT_ObjCDecl && Style.BinPackParameters) ||
1335  (State.Line->Type == LT_ObjCDecl && ObjCBinPackProtocolList);
1336 
1337  AvoidBinPacking =
1338  (Style.Language == FormatStyle::LK_JavaScript && EndsInComma) ||
1339  (State.Line->MustBeDeclaration && !BinPackDeclaration) ||
1340  (!State.Line->MustBeDeclaration && !Style.BinPackArguments) ||
1342  (Current.PackingKind == PPK_OnePerLine ||
1343  (!BinPackInconclusiveFunctions &&
1344  Current.PackingKind == PPK_Inconclusive)));
1345 
1346  if (Current.is(TT_ObjCMethodExpr) && Current.MatchingParen) {
1347  if (Style.ColumnLimit) {
1348  // If this '[' opens an ObjC call, determine whether all parameters fit
1349  // into one line and put one per line if they don't.
1350  if (getLengthToMatchingParen(Current, State.Stack) + State.Column >
1351  getColumnLimit(State))
1352  BreakBeforeParameter = true;
1353  } else {
1354  // For ColumnLimit = 0, we have to figure out whether there is or has to
1355  // be a line break within this call.
1356  for (const FormatToken *Tok = &Current;
1357  Tok && Tok != Current.MatchingParen; Tok = Tok->Next) {
1358  if (Tok->MustBreakBefore ||
1359  (Tok->CanBreakBefore && Tok->NewlinesBefore > 0)) {
1360  BreakBeforeParameter = true;
1361  break;
1362  }
1363  }
1364  }
1365  }
1366 
1367  if (Style.Language == FormatStyle::LK_JavaScript && EndsInComma)
1368  BreakBeforeParameter = true;
1369  }
1370  // Generally inherit NoLineBreak from the current scope to nested scope.
1371  // However, don't do this for non-empty nested blocks, dict literals and
1372  // array literals as these follow different indentation rules.
1373  bool NoLineBreak =
1374  Current.Children.empty() &&
1375  !Current.isOneOf(TT_DictLiteral, TT_ArrayInitializerLSquare) &&
1376  (State.Stack.back().NoLineBreak ||
1377  State.Stack.back().NoLineBreakInOperand ||
1378  (Current.is(TT_TemplateOpener) &&
1379  State.Stack.back().ContainsUnwrappedBuilder));
1380  State.Stack.push_back(
1381  ParenState(&Current, NewIndent, LastSpace, AvoidBinPacking, NoLineBreak));
1382  State.Stack.back().NestedBlockIndent = NestedBlockIndent;
1383  State.Stack.back().BreakBeforeParameter = BreakBeforeParameter;
1384  State.Stack.back().HasMultipleNestedBlocks = Current.BlockParameterCount > 1;
1385  State.Stack.back().IsInsideObjCArrayLiteral =
1386  Current.is(TT_ArrayInitializerLSquare) && Current.Previous &&
1387  Current.Previous->is(tok::at);
1388 }
1389 
1390 void ContinuationIndenter::moveStatePastScopeCloser(LineState &State) {
1391  const FormatToken &Current = *State.NextToken;
1392  if (!Current.closesScope())
1393  return;
1394 
1395  // If we encounter a closing ), ], } or >, we can remove a level from our
1396  // stacks.
1397  if (State.Stack.size() > 1 &&
1398  (Current.isOneOf(tok::r_paren, tok::r_square, TT_TemplateString) ||
1399  (Current.is(tok::r_brace) && State.NextToken != State.Line->First) ||
1400  State.NextToken->is(TT_TemplateCloser) ||
1401  (Current.is(tok::greater) && Current.is(TT_DictLiteral))))
1402  State.Stack.pop_back();
1403 
1404  // Reevaluate whether ObjC message arguments fit into one line.
1405  // If a receiver spans multiple lines, e.g.:
1406  // [[object block:^{
1407  // return 42;
1408  // }] a:42 b:42];
1409  // BreakBeforeParameter is calculated based on an incorrect assumption
1410  // (it is checked whether the whole expression fits into one line without
1411  // considering a line break inside a message receiver).
1412  // We check whether arguements fit after receiver scope closer (into the same
1413  // line).
1414  if (State.Stack.back().BreakBeforeParameter && Current.MatchingParen &&
1415  Current.MatchingParen->Previous) {
1416  const FormatToken &CurrentScopeOpener = *Current.MatchingParen->Previous;
1417  if (CurrentScopeOpener.is(TT_ObjCMethodExpr) &&
1418  CurrentScopeOpener.MatchingParen) {
1419  int NecessarySpaceInLine =
1420  getLengthToMatchingParen(CurrentScopeOpener, State.Stack) +
1421  CurrentScopeOpener.TotalLength - Current.TotalLength - 1;
1422  if (State.Column + Current.ColumnWidth + NecessarySpaceInLine <=
1423  Style.ColumnLimit)
1424  State.Stack.back().BreakBeforeParameter = false;
1425  }
1426  }
1427 
1428  if (Current.is(tok::r_square)) {
1429  // If this ends the array subscript expr, reset the corresponding value.
1430  const FormatToken *NextNonComment = Current.getNextNonComment();
1431  if (NextNonComment && NextNonComment->isNot(tok::l_square))
1432  State.Stack.back().StartOfArraySubscripts = 0;
1433  }
1434 }
1435 
1436 void ContinuationIndenter::moveStateToNewBlock(LineState &State) {
1437  unsigned NestedBlockIndent = State.Stack.back().NestedBlockIndent;
1438  // ObjC block sometimes follow special indentation rules.
1439  unsigned NewIndent =
1440  NestedBlockIndent + (State.NextToken->is(TT_ObjCBlockLBrace)
1441  ? Style.ObjCBlockIndentWidth
1442  : Style.IndentWidth);
1443  State.Stack.push_back(ParenState(State.NextToken, NewIndent,
1444  State.Stack.back().LastSpace,
1445  /*AvoidBinPacking=*/true,
1446  /*NoLineBreak=*/false));
1447  State.Stack.back().NestedBlockIndent = NestedBlockIndent;
1448  State.Stack.back().BreakBeforeParameter = true;
1449 }
1450 
1451 static unsigned getLastLineEndColumn(StringRef Text, unsigned StartColumn,
1452  unsigned TabWidth,
1453  encoding::Encoding Encoding) {
1454  size_t LastNewlinePos = Text.find_last_of("\n");
1455  if (LastNewlinePos == StringRef::npos) {
1456  return StartColumn +
1457  encoding::columnWidthWithTabs(Text, StartColumn, TabWidth, Encoding);
1458  } else {
1459  return encoding::columnWidthWithTabs(Text.substr(LastNewlinePos),
1460  /*StartColumn=*/0, TabWidth, Encoding);
1461  }
1462 }
1463 
1464 unsigned ContinuationIndenter::reformatRawStringLiteral(
1465  const FormatToken &Current, LineState &State,
1466  const FormatStyle &RawStringStyle, bool DryRun) {
1467  unsigned StartColumn = State.Column - Current.ColumnWidth;
1468  StringRef OldDelimiter = *getRawStringDelimiter(Current.TokenText);
1469  StringRef NewDelimiter =
1470  getCanonicalRawStringDelimiter(Style, RawStringStyle.Language);
1471  if (NewDelimiter.empty() || OldDelimiter.empty())
1472  NewDelimiter = OldDelimiter;
1473  // The text of a raw string is between the leading 'R"delimiter(' and the
1474  // trailing 'delimiter)"'.
1475  unsigned OldPrefixSize = 3 + OldDelimiter.size();
1476  unsigned OldSuffixSize = 2 + OldDelimiter.size();
1477  // We create a virtual text environment which expects a null-terminated
1478  // string, so we cannot use StringRef.
1479  std::string RawText =
1480  Current.TokenText.substr(OldPrefixSize).drop_back(OldSuffixSize);
1481  if (NewDelimiter != OldDelimiter) {
1482  // Don't update to the canonical delimiter 'deli' if ')deli"' occurs in the
1483  // raw string.
1484  std::string CanonicalDelimiterSuffix = (")" + NewDelimiter + "\"").str();
1485  if (StringRef(RawText).contains(CanonicalDelimiterSuffix))
1486  NewDelimiter = OldDelimiter;
1487  }
1488 
1489  unsigned NewPrefixSize = 3 + NewDelimiter.size();
1490  unsigned NewSuffixSize = 2 + NewDelimiter.size();
1491 
1492  // The first start column is the column the raw text starts after formatting.
1493  unsigned FirstStartColumn = StartColumn + NewPrefixSize;
1494 
1495  // The next start column is the intended indentation a line break inside
1496  // the raw string at level 0. It is determined by the following rules:
1497  // - if the content starts on newline, it is one level more than the current
1498  // indent, and
1499  // - if the content does not start on a newline, it is the first start
1500  // column.
1501  // These rules have the advantage that the formatted content both does not
1502  // violate the rectangle rule and visually flows within the surrounding
1503  // source.
1504  bool ContentStartsOnNewline = Current.TokenText[OldPrefixSize] == '\n';
1505  unsigned NextStartColumn =
1506  ContentStartsOnNewline
1507  ? State.Stack.back().NestedBlockIndent + Style.IndentWidth
1508  : FirstStartColumn;
1509 
1510  // The last start column is the column the raw string suffix starts if it is
1511  // put on a newline.
1512  // The last start column is the intended indentation of the raw string postfix
1513  // if it is put on a newline. It is determined by the following rules:
1514  // - if the raw string prefix starts on a newline, it is the column where
1515  // that raw string prefix starts, and
1516  // - if the raw string prefix does not start on a newline, it is the current
1517  // indent.
1518  unsigned LastStartColumn = Current.NewlinesBefore
1519  ? FirstStartColumn - NewPrefixSize
1520  : State.Stack.back().NestedBlockIndent;
1521 
1522  std::pair<tooling::Replacements, unsigned> Fixes = internal::reformat(
1523  RawStringStyle, RawText, {tooling::Range(0, RawText.size())},
1524  FirstStartColumn, NextStartColumn, LastStartColumn, "<stdin>",
1525  /*Status=*/nullptr);
1526 
1527  auto NewCode = applyAllReplacements(RawText, Fixes.first);
1528  tooling::Replacements NoFixes;
1529  if (!NewCode) {
1530  State.Column += Current.ColumnWidth;
1531  return 0;
1532  }
1533  if (!DryRun) {
1534  if (NewDelimiter != OldDelimiter) {
1535  // In 'R"delimiter(...', the delimiter starts 2 characters after the start
1536  // of the token.
1537  SourceLocation PrefixDelimiterStart =
1538  Current.Tok.getLocation().getLocWithOffset(2);
1539  auto PrefixErr = Whitespaces.addReplacement(tooling::Replacement(
1540  SourceMgr, PrefixDelimiterStart, OldDelimiter.size(), NewDelimiter));
1541  if (PrefixErr) {
1542  llvm::errs()
1543  << "Failed to update the prefix delimiter of a raw string: "
1544  << llvm::toString(std::move(PrefixErr)) << "\n";
1545  }
1546  // In 'R"delimiter(...)delimiter"', the suffix delimiter starts at
1547  // position length - 1 - |delimiter|.
1548  SourceLocation SuffixDelimiterStart =
1549  Current.Tok.getLocation().getLocWithOffset(Current.TokenText.size() -
1550  1 - OldDelimiter.size());
1551  auto SuffixErr = Whitespaces.addReplacement(tooling::Replacement(
1552  SourceMgr, SuffixDelimiterStart, OldDelimiter.size(), NewDelimiter));
1553  if (SuffixErr) {
1554  llvm::errs()
1555  << "Failed to update the suffix delimiter of a raw string: "
1556  << llvm::toString(std::move(SuffixErr)) << "\n";
1557  }
1558  }
1559  SourceLocation OriginLoc =
1560  Current.Tok.getLocation().getLocWithOffset(OldPrefixSize);
1561  for (const tooling::Replacement &Fix : Fixes.first) {
1562  auto Err = Whitespaces.addReplacement(tooling::Replacement(
1563  SourceMgr, OriginLoc.getLocWithOffset(Fix.getOffset()),
1564  Fix.getLength(), Fix.getReplacementText()));
1565  if (Err) {
1566  llvm::errs() << "Failed to reformat raw string: "
1567  << llvm::toString(std::move(Err)) << "\n";
1568  }
1569  }
1570  }
1571  unsigned RawLastLineEndColumn = getLastLineEndColumn(
1572  *NewCode, FirstStartColumn, Style.TabWidth, Encoding);
1573  State.Column = RawLastLineEndColumn + NewSuffixSize;
1574  // Since we're updating the column to after the raw string literal here, we
1575  // have to manually add the penalty for the prefix R"delim( over the column
1576  // limit.
1577  unsigned PrefixExcessCharacters =
1578  StartColumn + NewPrefixSize > Style.ColumnLimit ?
1579  StartColumn + NewPrefixSize - Style.ColumnLimit : 0;
1580  return Fixes.second + PrefixExcessCharacters * Style.PenaltyExcessCharacter;
1581 }
1582 
1583 unsigned ContinuationIndenter::addMultilineToken(const FormatToken &Current,
1584  LineState &State) {
1585  // Break before further function parameters on all levels.
1586  for (unsigned i = 0, e = State.Stack.size(); i != e; ++i)
1587  State.Stack[i].BreakBeforeParameter = true;
1588 
1589  unsigned ColumnsUsed = State.Column;
1590  // We can only affect layout of the first and the last line, so the penalty
1591  // for all other lines is constant, and we ignore it.
1592  State.Column = Current.LastLineColumnWidth;
1593 
1594  if (ColumnsUsed > getColumnLimit(State))
1595  return Style.PenaltyExcessCharacter * (ColumnsUsed - getColumnLimit(State));
1596  return 0;
1597 }
1598 
1599 unsigned ContinuationIndenter::handleEndOfLine(const FormatToken &Current,
1600  LineState &State, bool DryRun,
1601  bool AllowBreak) {
1602  unsigned Penalty = 0;
1603  // Compute the raw string style to use in case this is a raw string literal
1604  // that can be reformatted.
1605  auto RawStringStyle = getRawStringStyle(Current, State);
1606  if (RawStringStyle && !Current.Finalized) {
1607  Penalty = reformatRawStringLiteral(Current, State, *RawStringStyle, DryRun);
1608  } else if (Current.IsMultiline && Current.isNot(TT_BlockComment)) {
1609  // Don't break multi-line tokens other than block comments and raw string
1610  // literals. Instead, just update the state.
1611  Penalty = addMultilineToken(Current, State);
1612  } else if (State.Line->Type != LT_ImportStatement) {
1613  // We generally don't break import statements.
1614  LineState OriginalState = State;
1615 
1616  // Whether we force the reflowing algorithm to stay strictly within the
1617  // column limit.
1618  bool Strict = false;
1619  // Whether the first non-strict attempt at reflowing did intentionally
1620  // exceed the column limit.
1621  bool Exceeded = false;
1622  std::tie(Penalty, Exceeded) = breakProtrudingToken(
1623  Current, State, AllowBreak, /*DryRun=*/true, Strict);
1624  if (Exceeded) {
1625  // If non-strict reflowing exceeds the column limit, try whether strict
1626  // reflowing leads to an overall lower penalty.
1627  LineState StrictState = OriginalState;
1628  unsigned StrictPenalty =
1629  breakProtrudingToken(Current, StrictState, AllowBreak,
1630  /*DryRun=*/true, /*Strict=*/true)
1631  .first;
1632  Strict = StrictPenalty <= Penalty;
1633  if (Strict) {
1634  Penalty = StrictPenalty;
1635  State = StrictState;
1636  }
1637  }
1638  if (!DryRun) {
1639  // If we're not in dry-run mode, apply the changes with the decision on
1640  // strictness made above.
1641  breakProtrudingToken(Current, OriginalState, AllowBreak, /*DryRun=*/false,
1642  Strict);
1643  }
1644  }
1645  if (State.Column > getColumnLimit(State)) {
1646  unsigned ExcessCharacters = State.Column - getColumnLimit(State);
1647  Penalty += Style.PenaltyExcessCharacter * ExcessCharacters;
1648  }
1649  return Penalty;
1650 }
1651 
1652 // Returns the enclosing function name of a token, or the empty string if not
1653 // found.
1654 static StringRef getEnclosingFunctionName(const FormatToken &Current) {
1655  // Look for: 'function(' or 'function<templates>(' before Current.
1656  auto Tok = Current.getPreviousNonComment();
1657  if (!Tok || !Tok->is(tok::l_paren))
1658  return "";
1660  if (!Tok)
1661  return "";
1662  if (Tok->is(TT_TemplateCloser)) {
1663  Tok = Tok->MatchingParen;
1664  if (Tok)
1666  }
1667  if (!Tok || !Tok->is(tok::identifier))
1668  return "";
1669  return Tok->TokenText;
1670 }
1671 
1673 ContinuationIndenter::getRawStringStyle(const FormatToken &Current,
1674  const LineState &State) {
1675  if (!Current.isStringLiteral())
1676  return None;
1677  auto Delimiter = getRawStringDelimiter(Current.TokenText);
1678  if (!Delimiter)
1679  return None;
1680  auto RawStringStyle = RawStringFormats.getDelimiterStyle(*Delimiter);
1681  if (!RawStringStyle && Delimiter->empty())
1682  RawStringStyle = RawStringFormats.getEnclosingFunctionStyle(
1683  getEnclosingFunctionName(Current));
1684  if (!RawStringStyle)
1685  return None;
1686  RawStringStyle->ColumnLimit = getColumnLimit(State);
1687  return RawStringStyle;
1688 }
1689 
1690 std::unique_ptr<BreakableToken> ContinuationIndenter::createBreakableToken(
1691  const FormatToken &Current, LineState &State, bool AllowBreak) {
1692  unsigned StartColumn = State.Column - Current.ColumnWidth;
1693  if (Current.isStringLiteral()) {
1694  // FIXME: String literal breaking is currently disabled for Java and JS, as
1695  // it requires strings to be merged using "+" which we don't support.
1696  if (Style.Language == FormatStyle::LK_Java ||
1698  !Style.BreakStringLiterals ||
1699  !AllowBreak)
1700  return nullptr;
1701 
1702  // Don't break string literals inside preprocessor directives (except for
1703  // #define directives, as their contents are stored in separate lines and
1704  // are not affected by this check).
1705  // This way we avoid breaking code with line directives and unknown
1706  // preprocessor directives that contain long string literals.
1707  if (State.Line->Type == LT_PreprocessorDirective)
1708  return nullptr;
1709  // Exempts unterminated string literals from line breaking. The user will
1710  // likely want to terminate the string before any line breaking is done.
1711  if (Current.IsUnterminatedLiteral)
1712  return nullptr;
1713  // Don't break string literals inside Objective-C array literals (doing so
1714  // raises the warning -Wobjc-string-concatenation).
1715  if (State.Stack.back().IsInsideObjCArrayLiteral) {
1716  return nullptr;
1717  }
1718 
1719  StringRef Text = Current.TokenText;
1720  StringRef Prefix;
1721  StringRef Postfix;
1722  // FIXME: Handle whitespace between '_T', '(', '"..."', and ')'.
1723  // FIXME: Store Prefix and Suffix (or PrefixLength and SuffixLength to
1724  // reduce the overhead) for each FormatToken, which is a string, so that we
1725  // don't run multiple checks here on the hot path.
1726  if ((Text.endswith(Postfix = "\"") &&
1727  (Text.startswith(Prefix = "@\"") || Text.startswith(Prefix = "\"") ||
1728  Text.startswith(Prefix = "u\"") || Text.startswith(Prefix = "U\"") ||
1729  Text.startswith(Prefix = "u8\"") ||
1730  Text.startswith(Prefix = "L\""))) ||
1731  (Text.startswith(Prefix = "_T(\"") && Text.endswith(Postfix = "\")"))) {
1732  // We need this to address the case where there is an unbreakable tail
1733  // only if certain other formatting decisions have been taken. The
1734  // UnbreakableTailLength of Current is an overapproximation is that case
1735  // and we need to be correct here.
1736  unsigned UnbreakableTailLength = (State.NextToken && canBreak(State))
1737  ? 0
1738  : Current.UnbreakableTailLength;
1739  return llvm::make_unique<BreakableStringLiteral>(
1740  Current, StartColumn, Prefix, Postfix, UnbreakableTailLength,
1741  State.Line->InPPDirective, Encoding, Style);
1742  }
1743  } else if (Current.is(TT_BlockComment)) {
1744  if (!Style.ReflowComments ||
1745  // If a comment token switches formatting, like
1746  // /* clang-format on */, we don't want to break it further,
1747  // but we may still want to adjust its indentation.
1748  switchesFormatting(Current)) {
1749  return nullptr;
1750  }
1751  return llvm::make_unique<BreakableBlockComment>(
1752  Current, StartColumn, Current.OriginalColumn, !Current.Previous,
1753  State.Line->InPPDirective, Encoding, Style);
1754  } else if (Current.is(TT_LineComment) &&
1755  (Current.Previous == nullptr ||
1756  Current.Previous->isNot(TT_ImplicitStringLiteral))) {
1757  if (!Style.ReflowComments ||
1758  CommentPragmasRegex.match(Current.TokenText.substr(2)) ||
1759  switchesFormatting(Current))
1760  return nullptr;
1761  return llvm::make_unique<BreakableLineCommentSection>(
1762  Current, StartColumn, Current.OriginalColumn, !Current.Previous,
1763  /*InPPDirective=*/false, Encoding, Style);
1764  }
1765  return nullptr;
1766 }
1767 
1768 std::pair<unsigned, bool>
1769 ContinuationIndenter::breakProtrudingToken(const FormatToken &Current,
1770  LineState &State, bool AllowBreak,
1771  bool DryRun, bool Strict) {
1772  std::unique_ptr<const BreakableToken> Token =
1773  createBreakableToken(Current, State, AllowBreak);
1774  if (!Token)
1775  return {0, false};
1776  assert(Token->getLineCount() > 0);
1777  unsigned ColumnLimit = getColumnLimit(State);
1778  if (Current.is(TT_LineComment)) {
1779  // We don't insert backslashes when breaking line comments.
1780  ColumnLimit = Style.ColumnLimit;
1781  }
1782  if (Current.UnbreakableTailLength >= ColumnLimit)
1783  return {0, false};
1784  // ColumnWidth was already accounted into State.Column before calling
1785  // breakProtrudingToken.
1786  unsigned StartColumn = State.Column - Current.ColumnWidth;
1787  unsigned NewBreakPenalty = Current.isStringLiteral()
1788  ? Style.PenaltyBreakString
1789  : Style.PenaltyBreakComment;
1790  // Stores whether we intentionally decide to let a line exceed the column
1791  // limit.
1792  bool Exceeded = false;
1793  // Stores whether we introduce a break anywhere in the token.
1794  bool BreakInserted = Token->introducesBreakBeforeToken();
1795  // Store whether we inserted a new line break at the end of the previous
1796  // logical line.
1797  bool NewBreakBefore = false;
1798  // We use a conservative reflowing strategy. Reflow starts after a line is
1799  // broken or the corresponding whitespace compressed. Reflow ends as soon as a
1800  // line that doesn't get reflown with the previous line is reached.
1801  bool Reflow = false;
1802  // Keep track of where we are in the token:
1803  // Where we are in the content of the current logical line.
1804  unsigned TailOffset = 0;
1805  // The column number we're currently at.
1806  unsigned ContentStartColumn =
1807  Token->getContentStartColumn(0, /*Break=*/false);
1808  // The number of columns left in the current logical line after TailOffset.
1809  unsigned RemainingTokenColumns =
1810  Token->getRemainingLength(0, TailOffset, ContentStartColumn);
1811  // Adapt the start of the token, for example indent.
1812  if (!DryRun)
1813  Token->adaptStartOfLine(0, Whitespaces);
1814 
1815  unsigned ContentIndent = 0;
1816  unsigned Penalty = 0;
1817  LLVM_DEBUG(llvm::dbgs() << "Breaking protruding token at column "
1818  << StartColumn << ".\n");
1819  for (unsigned LineIndex = 0, EndIndex = Token->getLineCount();
1820  LineIndex != EndIndex; ++LineIndex) {
1821  LLVM_DEBUG(llvm::dbgs()
1822  << " Line: " << LineIndex << " (Reflow: " << Reflow << ")\n");
1823  NewBreakBefore = false;
1824  // If we did reflow the previous line, we'll try reflowing again. Otherwise
1825  // we'll start reflowing if the current line is broken or whitespace is
1826  // compressed.
1827  bool TryReflow = Reflow;
1828  // Break the current token until we can fit the rest of the line.
1829  while (ContentStartColumn + RemainingTokenColumns > ColumnLimit) {
1830  LLVM_DEBUG(llvm::dbgs() << " Over limit, need: "
1831  << (ContentStartColumn + RemainingTokenColumns)
1832  << ", space: " << ColumnLimit
1833  << ", reflown prefix: " << ContentStartColumn
1834  << ", offset in line: " << TailOffset << "\n");
1835  // If the current token doesn't fit, find the latest possible split in the
1836  // current line so that breaking at it will be under the column limit.
1837  // FIXME: Use the earliest possible split while reflowing to correctly
1838  // compress whitespace within a line.
1839  BreakableToken::Split Split =
1840  Token->getSplit(LineIndex, TailOffset, ColumnLimit,
1841  ContentStartColumn, CommentPragmasRegex);
1842  if (Split.first == StringRef::npos) {
1843  // No break opportunity - update the penalty and continue with the next
1844  // logical line.
1845  if (LineIndex < EndIndex - 1)
1846  // The last line's penalty is handled in addNextStateToQueue() or when
1847  // calling replaceWhitespaceAfterLastLine below.
1848  Penalty += Style.PenaltyExcessCharacter *
1849  (ContentStartColumn + RemainingTokenColumns - ColumnLimit);
1850  LLVM_DEBUG(llvm::dbgs() << " No break opportunity.\n");
1851  break;
1852  }
1853  assert(Split.first != 0);
1854 
1855  if (Token->supportsReflow()) {
1856  // Check whether the next natural split point after the current one can
1857  // still fit the line, either because we can compress away whitespace,
1858  // or because the penalty the excess characters introduce is lower than
1859  // the break penalty.
1860  // We only do this for tokens that support reflowing, and thus allow us
1861  // to change the whitespace arbitrarily (e.g. comments).
1862  // Other tokens, like string literals, can be broken on arbitrary
1863  // positions.
1864 
1865  // First, compute the columns from TailOffset to the next possible split
1866  // position.
1867  // For example:
1868  // ColumnLimit: |
1869  // // Some text that breaks
1870  // ^ tail offset
1871  // ^-- split
1872  // ^-------- to split columns
1873  // ^--- next split
1874  // ^--------------- to next split columns
1875  unsigned ToSplitColumns = Token->getRangeLength(
1876  LineIndex, TailOffset, Split.first, ContentStartColumn);
1877  LLVM_DEBUG(llvm::dbgs() << " ToSplit: " << ToSplitColumns << "\n");
1878 
1879  BreakableToken::Split NextSplit = Token->getSplit(
1880  LineIndex, TailOffset + Split.first + Split.second, ColumnLimit,
1881  ContentStartColumn + ToSplitColumns + 1, CommentPragmasRegex);
1882  // Compute the columns necessary to fit the next non-breakable sequence
1883  // into the current line.
1884  unsigned ToNextSplitColumns = 0;
1885  if (NextSplit.first == StringRef::npos) {
1886  ToNextSplitColumns = Token->getRemainingLength(LineIndex, TailOffset,
1887  ContentStartColumn);
1888  } else {
1889  ToNextSplitColumns = Token->getRangeLength(
1890  LineIndex, TailOffset,
1891  Split.first + Split.second + NextSplit.first, ContentStartColumn);
1892  }
1893  // Compress the whitespace between the break and the start of the next
1894  // unbreakable sequence.
1895  ToNextSplitColumns =
1896  Token->getLengthAfterCompression(ToNextSplitColumns, Split);
1897  LLVM_DEBUG(llvm::dbgs()
1898  << " ContentStartColumn: " << ContentStartColumn << "\n");
1899  LLVM_DEBUG(llvm::dbgs()
1900  << " ToNextSplit: " << ToNextSplitColumns << "\n");
1901  // If the whitespace compression makes us fit, continue on the current
1902  // line.
1903  bool ContinueOnLine =
1904  ContentStartColumn + ToNextSplitColumns <= ColumnLimit;
1905  unsigned ExcessCharactersPenalty = 0;
1906  if (!ContinueOnLine && !Strict) {
1907  // Similarly, if the excess characters' penalty is lower than the
1908  // penalty of introducing a new break, continue on the current line.
1909  ExcessCharactersPenalty =
1910  (ContentStartColumn + ToNextSplitColumns - ColumnLimit) *
1911  Style.PenaltyExcessCharacter;
1912  LLVM_DEBUG(llvm::dbgs()
1913  << " Penalty excess: " << ExcessCharactersPenalty
1914  << "\n break : " << NewBreakPenalty << "\n");
1915  if (ExcessCharactersPenalty < NewBreakPenalty) {
1916  Exceeded = true;
1917  ContinueOnLine = true;
1918  }
1919  }
1920  if (ContinueOnLine) {
1921  LLVM_DEBUG(llvm::dbgs() << " Continuing on line...\n");
1922  // The current line fits after compressing the whitespace - reflow
1923  // the next line into it if possible.
1924  TryReflow = true;
1925  if (!DryRun)
1926  Token->compressWhitespace(LineIndex, TailOffset, Split,
1927  Whitespaces);
1928  // When we continue on the same line, leave one space between content.
1929  ContentStartColumn += ToSplitColumns + 1;
1930  Penalty += ExcessCharactersPenalty;
1931  TailOffset += Split.first + Split.second;
1932  RemainingTokenColumns = Token->getRemainingLength(
1933  LineIndex, TailOffset, ContentStartColumn);
1934  continue;
1935  }
1936  }
1937  LLVM_DEBUG(llvm::dbgs() << " Breaking...\n");
1938  // Update the ContentIndent only if the current line was not reflown with
1939  // the previous line, since in that case the previous line should still
1940  // determine the ContentIndent. Also never intent the last line.
1941  if (!Reflow)
1942  ContentIndent = Token->getContentIndent(LineIndex);
1943  LLVM_DEBUG(llvm::dbgs()
1944  << " ContentIndent: " << ContentIndent << "\n");
1945  ContentStartColumn = ContentIndent + Token->getContentStartColumn(
1946  LineIndex, /*Break=*/true);
1947 
1948  unsigned NewRemainingTokenColumns = Token->getRemainingLength(
1949  LineIndex, TailOffset + Split.first + Split.second,
1950  ContentStartColumn);
1951  if (NewRemainingTokenColumns == 0) {
1952  // No content to indent.
1953  ContentIndent = 0;
1954  ContentStartColumn =
1955  Token->getContentStartColumn(LineIndex, /*Break=*/true);
1956  NewRemainingTokenColumns = Token->getRemainingLength(
1957  LineIndex, TailOffset + Split.first + Split.second,
1958  ContentStartColumn);
1959  }
1960 
1961  // When breaking before a tab character, it may be moved by a few columns,
1962  // but will still be expanded to the next tab stop, so we don't save any
1963  // columns.
1964  if (NewRemainingTokenColumns == RemainingTokenColumns) {
1965  // FIXME: Do we need to adjust the penalty?
1966  break;
1967  }
1968  assert(NewRemainingTokenColumns < RemainingTokenColumns);
1969 
1970  LLVM_DEBUG(llvm::dbgs() << " Breaking at: " << TailOffset + Split.first
1971  << ", " << Split.second << "\n");
1972  if (!DryRun)
1973  Token->insertBreak(LineIndex, TailOffset, Split, ContentIndent,
1974  Whitespaces);
1975 
1976  Penalty += NewBreakPenalty;
1977  TailOffset += Split.first + Split.second;
1978  RemainingTokenColumns = NewRemainingTokenColumns;
1979  BreakInserted = true;
1980  NewBreakBefore = true;
1981  }
1982  // In case there's another line, prepare the state for the start of the next
1983  // line.
1984  if (LineIndex + 1 != EndIndex) {
1985  unsigned NextLineIndex = LineIndex + 1;
1986  if (NewBreakBefore)
1987  // After breaking a line, try to reflow the next line into the current
1988  // one once RemainingTokenColumns fits.
1989  TryReflow = true;
1990  if (TryReflow) {
1991  // We decided that we want to try reflowing the next line into the
1992  // current one.
1993  // We will now adjust the state as if the reflow is successful (in
1994  // preparation for the next line), and see whether that works. If we
1995  // decide that we cannot reflow, we will later reset the state to the
1996  // start of the next line.
1997  Reflow = false;
1998  // As we did not continue breaking the line, RemainingTokenColumns is
1999  // known to fit after ContentStartColumn. Adapt ContentStartColumn to
2000  // the position at which we want to format the next line if we do
2001  // actually reflow.
2002  // When we reflow, we need to add a space between the end of the current
2003  // line and the next line's start column.
2004  ContentStartColumn += RemainingTokenColumns + 1;
2005  // Get the split that we need to reflow next logical line into the end
2006  // of the current one; the split will include any leading whitespace of
2007  // the next logical line.
2008  BreakableToken::Split SplitBeforeNext =
2009  Token->getReflowSplit(NextLineIndex, CommentPragmasRegex);
2010  LLVM_DEBUG(llvm::dbgs()
2011  << " Size of reflown text: " << ContentStartColumn
2012  << "\n Potential reflow split: ");
2013  if (SplitBeforeNext.first != StringRef::npos) {
2014  LLVM_DEBUG(llvm::dbgs() << SplitBeforeNext.first << ", "
2015  << SplitBeforeNext.second << "\n");
2016  TailOffset = SplitBeforeNext.first + SplitBeforeNext.second;
2017  // If the rest of the next line fits into the current line below the
2018  // column limit, we can safely reflow.
2019  RemainingTokenColumns = Token->getRemainingLength(
2020  NextLineIndex, TailOffset, ContentStartColumn);
2021  Reflow = true;
2022  if (ContentStartColumn + RemainingTokenColumns > ColumnLimit) {
2023  LLVM_DEBUG(llvm::dbgs()
2024  << " Over limit after reflow, need: "
2025  << (ContentStartColumn + RemainingTokenColumns)
2026  << ", space: " << ColumnLimit
2027  << ", reflown prefix: " << ContentStartColumn
2028  << ", offset in line: " << TailOffset << "\n");
2029  // If the whole next line does not fit, try to find a point in
2030  // the next line at which we can break so that attaching the part
2031  // of the next line to that break point onto the current line is
2032  // below the column limit.
2033  BreakableToken::Split Split =
2034  Token->getSplit(NextLineIndex, TailOffset, ColumnLimit,
2035  ContentStartColumn, CommentPragmasRegex);
2036  if (Split.first == StringRef::npos) {
2037  LLVM_DEBUG(llvm::dbgs() << " Did not find later break\n");
2038  Reflow = false;
2039  } else {
2040  // Check whether the first split point gets us below the column
2041  // limit. Note that we will execute this split below as part of
2042  // the normal token breaking and reflow logic within the line.
2043  unsigned ToSplitColumns = Token->getRangeLength(
2044  NextLineIndex, TailOffset, Split.first, ContentStartColumn);
2045  if (ContentStartColumn + ToSplitColumns > ColumnLimit) {
2046  LLVM_DEBUG(llvm::dbgs() << " Next split protrudes, need: "
2047  << (ContentStartColumn + ToSplitColumns)
2048  << ", space: " << ColumnLimit);
2049  unsigned ExcessCharactersPenalty =
2050  (ContentStartColumn + ToSplitColumns - ColumnLimit) *
2051  Style.PenaltyExcessCharacter;
2052  if (NewBreakPenalty < ExcessCharactersPenalty) {
2053  Reflow = false;
2054  }
2055  }
2056  }
2057  }
2058  } else {
2059  LLVM_DEBUG(llvm::dbgs() << "not found.\n");
2060  }
2061  }
2062  if (!Reflow) {
2063  // If we didn't reflow into the next line, the only space to consider is
2064  // the next logical line. Reset our state to match the start of the next
2065  // line.
2066  TailOffset = 0;
2067  ContentStartColumn =
2068  Token->getContentStartColumn(NextLineIndex, /*Break=*/false);
2069  RemainingTokenColumns = Token->getRemainingLength(
2070  NextLineIndex, TailOffset, ContentStartColumn);
2071  // Adapt the start of the token, for example indent.
2072  if (!DryRun)
2073  Token->adaptStartOfLine(NextLineIndex, Whitespaces);
2074  } else {
2075  // If we found a reflow split and have added a new break before the next
2076  // line, we are going to remove the line break at the start of the next
2077  // logical line. For example, here we'll add a new line break after
2078  // 'text', and subsequently delete the line break between 'that' and
2079  // 'reflows'.
2080  // // some text that
2081  // // reflows
2082  // ->
2083  // // some text
2084  // // that reflows
2085  // When adding the line break, we also added the penalty for it, so we
2086  // need to subtract that penalty again when we remove the line break due
2087  // to reflowing.
2088  if (NewBreakBefore) {
2089  assert(Penalty >= NewBreakPenalty);
2090  Penalty -= NewBreakPenalty;
2091  }
2092  if (!DryRun)
2093  Token->reflow(NextLineIndex, Whitespaces);
2094  }
2095  }
2096  }
2097 
2098  BreakableToken::Split SplitAfterLastLine =
2099  Token->getSplitAfterLastLine(TailOffset);
2100  if (SplitAfterLastLine.first != StringRef::npos) {
2101  LLVM_DEBUG(llvm::dbgs() << "Replacing whitespace after last line.\n");
2102 
2103  // We add the last line's penalty here, since that line is going to be split
2104  // now.
2105  Penalty += Style.PenaltyExcessCharacter *
2106  (ContentStartColumn + RemainingTokenColumns - ColumnLimit);
2107 
2108  if (!DryRun)
2109  Token->replaceWhitespaceAfterLastLine(TailOffset, SplitAfterLastLine,
2110  Whitespaces);
2111  ContentStartColumn =
2112  Token->getContentStartColumn(Token->getLineCount() - 1, /*Break=*/true);
2113  RemainingTokenColumns = Token->getRemainingLength(
2114  Token->getLineCount() - 1,
2115  TailOffset + SplitAfterLastLine.first + SplitAfterLastLine.second,
2116  ContentStartColumn);
2117  }
2118 
2119  State.Column = ContentStartColumn + RemainingTokenColumns -
2120  Current.UnbreakableTailLength;
2121 
2122  if (BreakInserted) {
2123  // If we break the token inside a parameter list, we need to break before
2124  // the next parameter on all levels, so that the next parameter is clearly
2125  // visible. Line comments already introduce a break.
2126  if (Current.isNot(TT_LineComment)) {
2127  for (unsigned i = 0, e = State.Stack.size(); i != e; ++i)
2128  State.Stack[i].BreakBeforeParameter = true;
2129  }
2130 
2131  if (Current.is(TT_BlockComment))
2132  State.NoContinuation = true;
2133 
2134  State.Stack.back().LastSpace = StartColumn;
2135  }
2136 
2137  Token->updateNextToken(State);
2138 
2139  return {Penalty, Exceeded};
2140 }
2141 
2142 unsigned ContinuationIndenter::getColumnLimit(const LineState &State) const {
2143  // In preprocessor directives reserve two chars for trailing " \"
2144  return Style.ColumnLimit - (State.Line->InPPDirective ? 2 : 0);
2145 }
2146 
2147 bool ContinuationIndenter::nextIsMultilineString(const LineState &State) {
2148  const FormatToken &Current = *State.NextToken;
2149  if (!Current.isStringLiteral() || Current.is(TT_ImplicitStringLiteral))
2150  return false;
2151  // We never consider raw string literals "multiline" for the purpose of
2152  // AlwaysBreakBeforeMultilineStrings implementation as they are special-cased
2153  // (see TokenAnnotator::mustBreakBefore().
2154  if (Current.TokenText.startswith("R\""))
2155  return false;
2156  if (Current.IsMultiline)
2157  return true;
2158  if (Current.getNextNonComment() &&
2159  Current.getNextNonComment()->isStringLiteral())
2160  return true; // Implicit concatenation.
2161  if (Style.ColumnLimit != 0 && Style.BreakStringLiterals &&
2162  State.Column + Current.ColumnWidth + Current.UnbreakableTailLength >
2163  Style.ColumnLimit)
2164  return true; // String will be split.
2165  return false;
2166 }
2167 
2168 } // namespace format
2169 } // namespace clang
static bool startsSegmentOfBuilderTypeCall(const FormatToken &Tok)
static bool shouldIndentWrappedSelectorName(const FormatStyle &Style, LineType LineType)
static StringRef getEnclosingFunctionName(const FormatToken &Current)
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:343
SourceLocation getLocWithOffset(int Offset) const
Return a source location with the specified offset from this SourceLocation.
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.
Break inheritance list after the colon and commas.
Definition: Format.h:924
bool AlwaysBreakBeforeMultilineStrings
If true, always break before multiline string literals.
Definition: Format.h:354
Token Tok
The Token.
Definition: FormatToken.h:128
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:1232
Defines the SourceManager interface.
unsigned IndentWidth
The number of columns to use for indentation.
Definition: Format.h:1120
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:857
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:391
Declares BreakableToken, BreakableStringLiteral, BreakableComment, BreakableBlockComment and Breakabl...
StringRef P
static unsigned getLastLineEndColumn(StringRef Text, unsigned StartColumn, unsigned TabWidth, encoding::Encoding Encoding)
bool BreakBeforeClosingBrace
Whether a newline needs to be inserted before the block&#39;s closing brace.
const FormatToken * getNextNonComment() const
Returns the next token ignoring comments.
Definition: FormatToken.h:481
Maintains a set of replacements that are conflict-free.
Definition: Replacement.h:210
bool IsMultiline
Whether the token text contains newlines (escaped or not).
Definition: FormatToken.h:157
unsigned ObjCSelectorNameParts
If this is the first ObjC selector name in an ObjC method definition or call, this contains the numbe...
Definition: FormatToken.h:246
unsigned PenaltyBreakFirstLessLess
The penalty for breaking before the first <<.
Definition: Format.h:1385
LanguageKind
Supported languages.
Definition: Format.h:1219
LineState getInitialState(unsigned FirstIndent, unsigned FirstStartColumn, const AnnotatedLine *Line, bool DryRun)
Get the initial state, i.e.
bool EndsBinaryExpression
true if this token ends a binary expression.
Definition: FormatToken.h:266
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:413
PPDirectiveIndentStyle IndentPPDirectives
The preprocessor directive indenting style to use.
Definition: Format.h:1107
unsigned NewlinesBefore
The number of newlines immediately before the Token.
Definition: FormatToken.h:134
FormatToken * Next
The next token in the unwrapped line.
Definition: FormatToken.h:293
Break after operators.
Definition: Format.h:451
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:849
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 closing > of a template or in protos.
Definition: FormatToken.h:381
bool applyAllReplacements(const Replacements &Replaces, Rewriter &Rewrite)
Apply all replacements in Replaces to the Rewriter Rewrite.
unsigned SplitPenalty
Penalty for inserting a line break before this token.
Definition: FormatToken.h:234
prec::Level getPrecedence() const
Definition: FormatToken.h:467
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:260
bool ExperimentalAutoDetectBinPacking
If true, clang-format detects whether function calls and definitions are formatted with one parameter...
Definition: Format.h:1027
Always bin-pack parameters.
Definition: Format.h:433
LineState State
bool CanBreakBefore
true if it is allowed to break before this token.
Definition: FormatToken.h:186
This file declares Format APIs to be used internally by the formatting library implementation.
unsigned Column
The number of used columns in the current line.
bool NoContinuation
true if NextToken should not continue this line.
Should be used for Java.
Definition: Format.h:1225
FormatToken * Previous
The previous token in the unwrapped line.
Definition: FormatToken.h:290
bool StartsBinaryExpression
true if this token starts a binary expression, i.e.
Definition: FormatToken.h:264
std::pair< tooling::Replacements, unsigned > reformat(const FormatStyle &Style, StringRef Code, ArrayRef< tooling::Range > Ranges, unsigned FirstStartColumn, unsigned NextStartColumn, unsigned LastStartColumn, StringRef FileName, FormattingAttemptStatus *Status)
Reformats the given Ranges in the code fragment Code.
Definition: Format.cpp:2142
Token - This structure provides full information about a lexed token.
Definition: Token.h:35
unsigned columnWidthWithTabs(StringRef Text, unsigned StartColumn, unsigned TabWidth, Encoding Encoding)
Returns the number of columns required to display the Text, starting from the StartColumn on a termin...
Definition: Encoding.h:62
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:969
unsigned PenaltyBreakComment
The penalty for each line break introduced inside a comment.
Definition: Format.h:1382
unsigned OperatorIndex
If this is an operator (or "."/"->") in a sequence of operators with the same precedence, contains the 0-based operator index.
Definition: FormatToken.h:270
unsigned SpacesRequiredBefore
The number of spaces that should be inserted before this token.
Definition: FormatToken.h:183
bool IndentWrappedFunctionNames
Indent if a function definition or declaration is wrapped after the type.
Definition: Format.h:1133
const FormatToken * Tok
The token opening this parenthesis level, or nullptr if this level is opened by fake parenthesis...
unsigned Indent
The position to which a specific parenthesis level needs to be indented.
bool isNot(T Kind) const
Definition: FormatToken.h:323
Always break after an open bracket, if the parameters don&#39;t fit on a single line, e...
Definition: Format.h:74
static unsigned getLengthToNextOperator(const FormatToken &Tok)
bool closesBlockOrBlockTypeList(const FormatStyle &Style) const
Same as opensBlockOrBlockTypeList, but for the closing token.
Definition: FormatToken.h:516
const FormatToken & Tok
ReturnTypeBreakingStyle AlwaysBreakAfterReturnType
The function declaration return type breaking style to use.
Definition: Format.h:340
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:411
unsigned ObjCBlockIndentWidth
The number of characters to use for indentation of ObjC blocks.
Definition: Format.h:1365
bool LineContainsContinuedForLoopSection
true if this line contains a continued for-loop section.
unsigned ColumnLimit
The column limit.
Definition: Format.h:887
bool LastOperatorWrapped
True if the last binary operator on this level was wrapped to the next line.
llvm::Optional< FormatStyle > getEnclosingFunctionStyle(StringRef EnclosingFunction) const
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:473
BracketAlignmentStyle AlignAfterOpenBracket
If true, horizontally aligns arguments after an open bracket.
Definition: Format.h:81
return Out str()
bool isOneOf(A K1, B K2) const
Definition: FormatToken.h:316
A text replacement.
Definition: Replacement.h:84
UseTabStyle UseTab
The way to use tab characters in the resulting file.
Definition: Format.h:1714
A source range independent of the SourceManager.
Definition: Replacement.h:45
FormatStyle getLLVMStyle()
Returns a format style complying with the LLVM coding standards: http://llvm.org/docs/CodingStandards...
Definition: Format.cpp:622
The current state when indenting a unwrapped line.
Break after return type automatically.
Definition: Format.h:276
WhitespaceManager class manages whitespace around tokens and their replacements.
SourceLocation End
llvm::Error addReplacement(const tooling::Replacement &Replacement)
Should be used for JavaScript.
Definition: Format.h:1227
const AnnotatedLine * Line
StateNode * Previous
ParameterPackingKind PackingKind
If this is an opening parenthesis, how are the parameters packed?
Definition: FormatToken.h:207
SourceLocation getLocation() const
Return a source location identifier for the specified offset in the current file. ...
Definition: Token.h:124
bool AlignOperands
If true, horizontally align operands of binary and ternary expressions.
Definition: Format.h:148
A wrapper around a Token storing information about the whitespace characters preceding it...
Definition: FormatToken.h:124
Defines and computes precedence levels for binary/ternary operators.
SourceLocation getEnd() const
bool isTrailingComment() const
Definition: FormatToken.h:418
llvm::StringMap< FormatStyle > DelimiterStyle
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:145
Don&#39;t align, instead use ContinuationIndentWidth, e.g.
Definition: Format.h:67
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:1388
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:1394
Encodes a location in the source.
bool closesScopeAfterBlock() const
Definition: FormatToken.h:325
bool is(tok::TokenKind Kind) const
Definition: FormatToken.h:307
Various functions to configurably format source code.
bool ReflowComments
If true, clang-format will attempt to re-flow comments.
Definition: Format.h:1493
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:864
bool BreakBeforeTernaryOperators
If true, ternary operators will be placed after line breaks.
Definition: Format.h:839
Encapsulates keywords that are context sensitive or for languages not properly supported by Clang&#39;s l...
Definition: FormatToken.h:660
SourceRange WhitespaceRange
The range of the whitespace immediately preceding the Token.
Definition: FormatToken.h:141
unsigned ContinuationIndentWidth
Indent width for line continuations.
Definition: Format.h:983
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:175
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:172
Automatically determine parameter bin-packing behavior.
Definition: Format.h:431
SmallVector< prec::Level, 4 > FakeLParens
Stores the number of required fake parentheses and the corresponding operator precedence.
Definition: FormatToken.h:258
unsigned addTokenToState(LineState &State, bool Newline, bool DryRun, unsigned ExtraSpaces=0)
Appends the next token to State and updates information necessary for indentation.
BreakTemplateDeclarationsStyle AlwaysBreakTemplateDeclarations
The template declaration breaking style to use.
Definition: Format.h:393
unsigned getLength() const
Definition: Replacement.h:123
The FormatStyle is used to configure the formatting to follow specific guidelines.
Definition: Format.h:50
RawStringFormatStyleManager(const FormatStyle &CodeStyle)
static unsigned getLengthToMatchingParen(const FormatToken &Tok, const std::vector< ParenState > &Stack)
LanguageKind Language
Language, this format style is targeted at.
Definition: Format.h:1242
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:243
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:150
unsigned getOffset() const
Definition: Replacement.h:122
bool Finalized
If true, this token has been fully formatted (indented and potentially re-formatted inside)...
Definition: FormatToken.h:305
BreakInheritanceListStyle BreakInheritanceList
The inheritance list style to use.
Definition: Format.h:928
llvm::Optional< FormatStyle > getDelimiterStyle(StringRef Delimiter) const
unsigned FirstIndent
The indent of the first token.
tok::PPKeywordKind getPPKeywordID() const
Return the preprocessor keyword ID for this identifier.
static StringRef getCanonicalRawStringDelimiter(const FormatStyle &Style, FormatStyle::LanguageKind Language)
bool BreakStringLiterals
Allow breaking string literals when formatting.
Definition: Format.h:880
Merge all functions fitting on a single line.
Definition: Format.h:238
std::string toString(const til::SExpr *E)
Break inheritance list before the colon and commas, and align the commas with the colon...
Definition: Format.h:916
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:173
bool AvoidBinPacking
Avoid bin packing, i.e.
bool getPredefinedStyle(StringRef Name, FormatStyle::LanguageKind Language, FormatStyle *Style)
Gets a predefined style for the specified language by name.
Definition: Format.cpp:951
unsigned TabWidth
The number of columns used for tab stops.
Definition: Format.h:1698
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.
Should be used for Objective-C, Objective-C++.
Definition: Format.h:1229
BinPackStyle ObjCBinPackProtocolList
Controls bin-packing Objective-C protocol conformance list items into as few lines as possible when t...
Definition: Format.h:1355
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:274
BreakConstructorInitializersStyle BreakConstructorInitializers
The constructor initializers style to use.
Definition: Format.h:868
bool ClosesTemplateDeclaration
true if this is the ">" of "template<..>".
Definition: FormatToken.h:189
FormatToken * MatchingParen
If this is a bracket, this points to the matching one.
Definition: FormatToken.h:287
std::vector< RawStringFormat > RawStringFormats
Defines hints for detecting supported languages code blocks in raw strings.
Definition: Format.h:1479
SmallVector< AnnotatedLine *, 1 > Children
If this token starts a block, this contains all the unwrapped lines in it.
Definition: FormatToken.h:297
bool startsSequence(A K1, Ts... Tokens) const
true if this token starts a sequence with the given tokens in order, following the Next pointers...
Definition: FormatToken.h:336
unsigned ConstructorInitializerIndentWidth
The number of characters to use for indentation of constructor initializer lists as well as inheritan...
Definition: Format.h:973
BinaryOperatorStyle BreakBeforeBinaryOperators
The way to wrap binary operators.
Definition: Format.h:479
bool opensBlockOrBlockTypeList(const FormatStyle &Style) const
Returns true if this tokens starts a block-type list, i.e.
Definition: FormatToken.h:490
Indents directives after the hash.
Definition: Format.h:1103
llvm::Optional< FormatStyle > GetLanguageStyle(LanguageKind Language) const
Definition: Format.cpp:1068
bool opensScope() const
Returns whether Tok is ([{ or an opening < of a template or in protos.
Definition: FormatToken.h:371
bool MustBreakBefore
Whether there must be a line break before this token.
Definition: FormatToken.h:166
unsigned StartOfLineLevel
The NestingLevel at the start of this line.
__DEVICE__ int max(int __a, int __b)
Should be used for Protocol Buffer messages in text format (https://developers.google.com/protocol-buffers/).
Definition: Format.h:1237
__DEVICE__ int min(int __a, int __b)
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:1621
llvm::StringMap< FormatStyle > EnclosingFunctionStyle
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.
StringRef getReplacementText() const
Definition: Replacement.h:124
bool isStringLiteral() const
Definition: FormatToken.h:347
SourceLocation getBegin() const
unsigned MaxEmptyLinesToKeep
The maximum number of consecutive empty lines to keep.
Definition: Format.h:1286
BraceBlockKind BlockKind
Contains the kind of block if this token is a brace.
Definition: FormatToken.h:178
bool PartOfMultiVariableDeclStmt
Is this token part of a DeclStmt defining multiple variables?
Definition: FormatToken.h:279
This class handles loading and caching of source files into memory.
static llvm::Optional< StringRef > getRawStringDelimiter(StringRef TokenText)
Do not force break before declaration.
Definition: Format.h:367
unsigned LastLineColumnWidth
Contains the width in columns of the last line of a multi-line token.
Definition: FormatToken.h:154
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:425