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  !State.Stack.back().HasMultipleNestedBlocks) {
1140  if (State.Stack[State.Stack.size() - 2].NestedBlockInlined && Newline)
1141  for (unsigned i = 0, e = State.Stack.size() - 1; i != e; ++i)
1142  State.Stack[i].NoLineBreak = true;
1143  State.Stack[State.Stack.size() - 2].NestedBlockInlined = false;
1144  }
1145  if (Previous &&
1146  (Previous->isOneOf(tok::l_paren, tok::comma, tok::colon) ||
1147  Previous->isOneOf(TT_BinaryOperator, TT_ConditionalExpr)) &&
1148  !Previous->isOneOf(TT_DictLiteral, TT_ObjCMethodExpr)) {
1149  State.Stack.back().NestedBlockInlined =
1150  !Newline &&
1151  (Previous->isNot(tok::l_paren) || Previous->ParameterCount > 1);
1152  }
1153 
1154  moveStatePastFakeLParens(State, Newline);
1155  moveStatePastScopeCloser(State);
1156  bool AllowBreak = !State.Stack.back().NoLineBreak &&
1157  !State.Stack.back().NoLineBreakInOperand;
1158  moveStatePastScopeOpener(State, Newline);
1159  moveStatePastFakeRParens(State);
1160 
1161  if (Current.is(TT_ObjCStringLiteral) && State.StartOfStringLiteral == 0)
1162  State.StartOfStringLiteral = State.Column + 1;
1163  else if (Current.isStringLiteral() && State.StartOfStringLiteral == 0)
1164  State.StartOfStringLiteral = State.Column;
1165  else if (!Current.isOneOf(tok::comment, tok::identifier, tok::hash) &&
1166  !Current.isStringLiteral())
1167  State.StartOfStringLiteral = 0;
1168 
1169  State.Column += Current.ColumnWidth;
1170  State.NextToken = State.NextToken->Next;
1171 
1172  unsigned Penalty =
1173  handleEndOfLine(Current, State, DryRun, AllowBreak);
1174 
1175  if (Current.Role)
1176  Current.Role->formatFromToken(State, this, DryRun);
1177  // If the previous has a special role, let it consume tokens as appropriate.
1178  // It is necessary to start at the previous token for the only implemented
1179  // role (comma separated list). That way, the decision whether or not to break
1180  // after the "{" is already done and both options are tried and evaluated.
1181  // FIXME: This is ugly, find a better way.
1182  if (Previous && Previous->Role)
1183  Penalty += Previous->Role->formatAfterToken(State, this, DryRun);
1184 
1185  return Penalty;
1186 }
1187 
1188 void ContinuationIndenter::moveStatePastFakeLParens(LineState &State,
1189  bool Newline) {
1190  const FormatToken &Current = *State.NextToken;
1191  const FormatToken *Previous = Current.getPreviousNonComment();
1192 
1193  // Don't add extra indentation for the first fake parenthesis after
1194  // 'return', assignments or opening <({[. The indentation for these cases
1195  // is special cased.
1196  bool SkipFirstExtraIndent =
1197  (Previous && (Previous->opensScope() ||
1198  Previous->isOneOf(tok::semi, tok::kw_return) ||
1199  (Previous->getPrecedence() == prec::Assignment &&
1200  Style.AlignOperands) ||
1201  Previous->is(TT_ObjCMethodExpr)));
1203  I = Current.FakeLParens.rbegin(),
1204  E = Current.FakeLParens.rend();
1205  I != E; ++I) {
1206  ParenState NewParenState = State.Stack.back();
1207  NewParenState.Tok = nullptr;
1208  NewParenState.ContainsLineBreak = false;
1209  NewParenState.LastOperatorWrapped = true;
1210  NewParenState.NoLineBreak =
1211  NewParenState.NoLineBreak || State.Stack.back().NoLineBreakInOperand;
1212 
1213  // Don't propagate AvoidBinPacking into subexpressions of arg/param lists.
1214  if (*I > prec::Comma)
1215  NewParenState.AvoidBinPacking = false;
1216 
1217  // Indent from 'LastSpace' unless these are fake parentheses encapsulating
1218  // a builder type call after 'return' or, if the alignment after opening
1219  // brackets is disabled.
1220  if (!Current.isTrailingComment() &&
1221  (Style.AlignOperands || *I < prec::Assignment) &&
1222  (!Previous || Previous->isNot(tok::kw_return) ||
1223  (Style.Language != FormatStyle::LK_Java && *I > 0)) &&
1225  *I != prec::Comma || Current.NestingLevel == 0))
1226  NewParenState.Indent =
1227  std::max(std::max(State.Column, NewParenState.Indent),
1228  State.Stack.back().LastSpace);
1229 
1230  // Do not indent relative to the fake parentheses inserted for "." or "->".
1231  // This is a special case to make the following to statements consistent:
1232  // OuterFunction(InnerFunctionCall( // break
1233  // ParameterToInnerFunction));
1234  // OuterFunction(SomeObject.InnerFunctionCall( // break
1235  // ParameterToInnerFunction));
1236  if (*I > prec::Unknown)
1237  NewParenState.LastSpace = std::max(NewParenState.LastSpace, State.Column);
1238  if (*I != prec::Conditional && !Current.is(TT_UnaryOperator) &&
1240  NewParenState.StartOfFunctionCall = State.Column;
1241 
1242  // Always indent conditional expressions. Never indent expression where
1243  // the 'operator' is ',', ';' or an assignment (i.e. *I <=
1244  // prec::Assignment) as those have different indentation rules. Indent
1245  // other expression, unless the indentation needs to be skipped.
1246  if (*I == prec::Conditional ||
1247  (!SkipFirstExtraIndent && *I > prec::Assignment &&
1248  !Current.isTrailingComment()))
1249  NewParenState.Indent += Style.ContinuationIndentWidth;
1250  if ((Previous && !Previous->opensScope()) || *I != prec::Comma)
1251  NewParenState.BreakBeforeParameter = false;
1252  State.Stack.push_back(NewParenState);
1253  SkipFirstExtraIndent = false;
1254  }
1255 }
1256 
1257 void ContinuationIndenter::moveStatePastFakeRParens(LineState &State) {
1258  for (unsigned i = 0, e = State.NextToken->FakeRParens; i != e; ++i) {
1259  unsigned VariablePos = State.Stack.back().VariablePos;
1260  if (State.Stack.size() == 1) {
1261  // Do not pop the last element.
1262  break;
1263  }
1264  State.Stack.pop_back();
1265  State.Stack.back().VariablePos = VariablePos;
1266  }
1267 }
1268 
1269 void ContinuationIndenter::moveStatePastScopeOpener(LineState &State,
1270  bool Newline) {
1271  const FormatToken &Current = *State.NextToken;
1272  if (!Current.opensScope())
1273  return;
1274 
1275  if (Current.MatchingParen && Current.BlockKind == BK_Block) {
1276  moveStateToNewBlock(State);
1277  return;
1278  }
1279 
1280  unsigned NewIndent;
1281  unsigned LastSpace = State.Stack.back().LastSpace;
1282  bool AvoidBinPacking;
1283  bool BreakBeforeParameter = false;
1284  unsigned NestedBlockIndent = std::max(State.Stack.back().StartOfFunctionCall,
1285  State.Stack.back().NestedBlockIndent);
1286  if (Current.isOneOf(tok::l_brace, TT_ArrayInitializerLSquare) ||
1287  opensProtoMessageField(Current, Style)) {
1288  if (Current.opensBlockOrBlockTypeList(Style)) {
1289  NewIndent = Style.IndentWidth +
1290  std::min(State.Column, State.Stack.back().NestedBlockIndent);
1291  } else {
1292  NewIndent = State.Stack.back().LastSpace + Style.ContinuationIndentWidth;
1293  }
1294  const FormatToken *NextNoComment = Current.getNextNonComment();
1295  bool EndsInComma = Current.MatchingParen &&
1296  Current.MatchingParen->Previous &&
1297  Current.MatchingParen->Previous->is(tok::comma);
1298  AvoidBinPacking = EndsInComma || Current.is(TT_DictLiteral) ||
1299  Style.Language == FormatStyle::LK_Proto ||
1301  !Style.BinPackArguments ||
1302  (NextNoComment &&
1303  NextNoComment->isOneOf(TT_DesignatedInitializerPeriod,
1304  TT_DesignatedInitializerLSquare));
1305  BreakBeforeParameter = EndsInComma;
1306  if (Current.ParameterCount > 1)
1307  NestedBlockIndent = std::max(NestedBlockIndent, State.Column + 1);
1308  } else {
1309  NewIndent = Style.ContinuationIndentWidth +
1310  std::max(State.Stack.back().LastSpace,
1311  State.Stack.back().StartOfFunctionCall);
1312 
1313  // Ensure that different different brackets force relative alignment, e.g.:
1314  // void SomeFunction(vector< // break
1315  // int> v);
1316  // FIXME: We likely want to do this for more combinations of brackets.
1317  if (Current.is(tok::less) && Current.ParentBracket == tok::l_paren) {
1318  NewIndent = std::max(NewIndent, State.Stack.back().Indent);
1319  LastSpace = std::max(LastSpace, State.Stack.back().Indent);
1320  }
1321 
1322  bool EndsInComma =
1323  Current.MatchingParen &&
1324  Current.MatchingParen->getPreviousNonComment() &&
1325  Current.MatchingParen->getPreviousNonComment()->is(tok::comma);
1326 
1327  // If ObjCBinPackProtocolList is unspecified, fall back to BinPackParameters
1328  // for backwards compatibility.
1329  bool ObjCBinPackProtocolList =
1331  Style.BinPackParameters) ||
1333 
1334  bool BinPackDeclaration =
1335  (State.Line->Type != LT_ObjCDecl && Style.BinPackParameters) ||
1336  (State.Line->Type == LT_ObjCDecl && ObjCBinPackProtocolList);
1337 
1338  AvoidBinPacking =
1339  (Style.Language == FormatStyle::LK_JavaScript && EndsInComma) ||
1340  (State.Line->MustBeDeclaration && !BinPackDeclaration) ||
1341  (!State.Line->MustBeDeclaration && !Style.BinPackArguments) ||
1343  (Current.PackingKind == PPK_OnePerLine ||
1344  (!BinPackInconclusiveFunctions &&
1345  Current.PackingKind == PPK_Inconclusive)));
1346 
1347  if (Current.is(TT_ObjCMethodExpr) && Current.MatchingParen) {
1348  if (Style.ColumnLimit) {
1349  // If this '[' opens an ObjC call, determine whether all parameters fit
1350  // into one line and put one per line if they don't.
1351  if (getLengthToMatchingParen(Current, State.Stack) + State.Column >
1352  getColumnLimit(State))
1353  BreakBeforeParameter = true;
1354  } else {
1355  // For ColumnLimit = 0, we have to figure out whether there is or has to
1356  // be a line break within this call.
1357  for (const FormatToken *Tok = &Current;
1358  Tok && Tok != Current.MatchingParen; Tok = Tok->Next) {
1359  if (Tok->MustBreakBefore ||
1360  (Tok->CanBreakBefore && Tok->NewlinesBefore > 0)) {
1361  BreakBeforeParameter = true;
1362  break;
1363  }
1364  }
1365  }
1366  }
1367 
1368  if (Style.Language == FormatStyle::LK_JavaScript && EndsInComma)
1369  BreakBeforeParameter = true;
1370  }
1371  // Generally inherit NoLineBreak from the current scope to nested scope.
1372  // However, don't do this for non-empty nested blocks, dict literals and
1373  // array literals as these follow different indentation rules.
1374  bool NoLineBreak =
1375  Current.Children.empty() &&
1376  !Current.isOneOf(TT_DictLiteral, TT_ArrayInitializerLSquare) &&
1377  (State.Stack.back().NoLineBreak ||
1378  State.Stack.back().NoLineBreakInOperand ||
1379  (Current.is(TT_TemplateOpener) &&
1380  State.Stack.back().ContainsUnwrappedBuilder));
1381  State.Stack.push_back(
1382  ParenState(&Current, NewIndent, LastSpace, AvoidBinPacking, NoLineBreak));
1383  State.Stack.back().NestedBlockIndent = NestedBlockIndent;
1384  State.Stack.back().BreakBeforeParameter = BreakBeforeParameter;
1385  State.Stack.back().HasMultipleNestedBlocks = Current.BlockParameterCount > 1;
1386  State.Stack.back().IsInsideObjCArrayLiteral =
1387  Current.is(TT_ArrayInitializerLSquare) && Current.Previous &&
1388  Current.Previous->is(tok::at);
1389 }
1390 
1391 void ContinuationIndenter::moveStatePastScopeCloser(LineState &State) {
1392  const FormatToken &Current = *State.NextToken;
1393  if (!Current.closesScope())
1394  return;
1395 
1396  // If we encounter a closing ), ], } or >, we can remove a level from our
1397  // stacks.
1398  if (State.Stack.size() > 1 &&
1399  (Current.isOneOf(tok::r_paren, tok::r_square, TT_TemplateString) ||
1400  (Current.is(tok::r_brace) && State.NextToken != State.Line->First) ||
1401  State.NextToken->is(TT_TemplateCloser) ||
1402  (Current.is(tok::greater) && Current.is(TT_DictLiteral))))
1403  State.Stack.pop_back();
1404 
1405  // Reevaluate whether ObjC message arguments fit into one line.
1406  // If a receiver spans multiple lines, e.g.:
1407  // [[object block:^{
1408  // return 42;
1409  // }] a:42 b:42];
1410  // BreakBeforeParameter is calculated based on an incorrect assumption
1411  // (it is checked whether the whole expression fits into one line without
1412  // considering a line break inside a message receiver).
1413  // We check whether arguements fit after receiver scope closer (into the same
1414  // line).
1415  if (State.Stack.back().BreakBeforeParameter && Current.MatchingParen &&
1416  Current.MatchingParen->Previous) {
1417  const FormatToken &CurrentScopeOpener = *Current.MatchingParen->Previous;
1418  if (CurrentScopeOpener.is(TT_ObjCMethodExpr) &&
1419  CurrentScopeOpener.MatchingParen) {
1420  int NecessarySpaceInLine =
1421  getLengthToMatchingParen(CurrentScopeOpener, State.Stack) +
1422  CurrentScopeOpener.TotalLength - Current.TotalLength - 1;
1423  if (State.Column + Current.ColumnWidth + NecessarySpaceInLine <=
1424  Style.ColumnLimit)
1425  State.Stack.back().BreakBeforeParameter = false;
1426  }
1427  }
1428 
1429  if (Current.is(tok::r_square)) {
1430  // If this ends the array subscript expr, reset the corresponding value.
1431  const FormatToken *NextNonComment = Current.getNextNonComment();
1432  if (NextNonComment && NextNonComment->isNot(tok::l_square))
1433  State.Stack.back().StartOfArraySubscripts = 0;
1434  }
1435 }
1436 
1437 void ContinuationIndenter::moveStateToNewBlock(LineState &State) {
1438  unsigned NestedBlockIndent = State.Stack.back().NestedBlockIndent;
1439  // ObjC block sometimes follow special indentation rules.
1440  unsigned NewIndent =
1441  NestedBlockIndent + (State.NextToken->is(TT_ObjCBlockLBrace)
1442  ? Style.ObjCBlockIndentWidth
1443  : Style.IndentWidth);
1444  State.Stack.push_back(ParenState(State.NextToken, NewIndent,
1445  State.Stack.back().LastSpace,
1446  /*AvoidBinPacking=*/true,
1447  /*NoLineBreak=*/false));
1448  State.Stack.back().NestedBlockIndent = NestedBlockIndent;
1449  State.Stack.back().BreakBeforeParameter = true;
1450 }
1451 
1452 static unsigned getLastLineEndColumn(StringRef Text, unsigned StartColumn,
1453  unsigned TabWidth,
1454  encoding::Encoding Encoding) {
1455  size_t LastNewlinePos = Text.find_last_of("\n");
1456  if (LastNewlinePos == StringRef::npos) {
1457  return StartColumn +
1458  encoding::columnWidthWithTabs(Text, StartColumn, TabWidth, Encoding);
1459  } else {
1460  return encoding::columnWidthWithTabs(Text.substr(LastNewlinePos),
1461  /*StartColumn=*/0, TabWidth, Encoding);
1462  }
1463 }
1464 
1465 unsigned ContinuationIndenter::reformatRawStringLiteral(
1466  const FormatToken &Current, LineState &State,
1467  const FormatStyle &RawStringStyle, bool DryRun) {
1468  unsigned StartColumn = State.Column - Current.ColumnWidth;
1469  StringRef OldDelimiter = *getRawStringDelimiter(Current.TokenText);
1470  StringRef NewDelimiter =
1471  getCanonicalRawStringDelimiter(Style, RawStringStyle.Language);
1472  if (NewDelimiter.empty() || OldDelimiter.empty())
1473  NewDelimiter = OldDelimiter;
1474  // The text of a raw string is between the leading 'R"delimiter(' and the
1475  // trailing 'delimiter)"'.
1476  unsigned OldPrefixSize = 3 + OldDelimiter.size();
1477  unsigned OldSuffixSize = 2 + OldDelimiter.size();
1478  // We create a virtual text environment which expects a null-terminated
1479  // string, so we cannot use StringRef.
1480  std::string RawText =
1481  Current.TokenText.substr(OldPrefixSize).drop_back(OldSuffixSize);
1482  if (NewDelimiter != OldDelimiter) {
1483  // Don't update to the canonical delimiter 'deli' if ')deli"' occurs in the
1484  // raw string.
1485  std::string CanonicalDelimiterSuffix = (")" + NewDelimiter + "\"").str();
1486  if (StringRef(RawText).contains(CanonicalDelimiterSuffix))
1487  NewDelimiter = OldDelimiter;
1488  }
1489 
1490  unsigned NewPrefixSize = 3 + NewDelimiter.size();
1491  unsigned NewSuffixSize = 2 + NewDelimiter.size();
1492 
1493  // The first start column is the column the raw text starts after formatting.
1494  unsigned FirstStartColumn = StartColumn + NewPrefixSize;
1495 
1496  // The next start column is the intended indentation a line break inside
1497  // the raw string at level 0. It is determined by the following rules:
1498  // - if the content starts on newline, it is one level more than the current
1499  // indent, and
1500  // - if the content does not start on a newline, it is the first start
1501  // column.
1502  // These rules have the advantage that the formatted content both does not
1503  // violate the rectangle rule and visually flows within the surrounding
1504  // source.
1505  bool ContentStartsOnNewline = Current.TokenText[OldPrefixSize] == '\n';
1506  // If this token is the last parameter (checked by looking if it's followed by
1507  // `)`, the base the indent off the line's nested block indent. Otherwise,
1508  // base the indent off the arguments indent, so we can achieve:
1509  // fffffffffff(1, 2, 3, R"pb(
1510  // key1: 1 #
1511  // key2: 2)pb");
1512  //
1513  // fffffffffff(1, 2, 3,
1514  // R"pb(
1515  // key1: 1 #
1516  // key2: 2
1517  // )pb",
1518  // 5);
1519  unsigned CurrentIndent = (Current.Next && Current.Next->is(tok::r_paren))
1520  ? State.Stack.back().NestedBlockIndent
1521  : State.Stack.back().Indent;
1522  unsigned NextStartColumn = ContentStartsOnNewline
1523  ? CurrentIndent + Style.IndentWidth
1524  : FirstStartColumn;
1525 
1526  // The last start column is the column the raw string suffix starts if it is
1527  // put on a newline.
1528  // The last start column is the intended indentation of the raw string postfix
1529  // if it is put on a newline. It is determined by the following rules:
1530  // - if the raw string prefix starts on a newline, it is the column where
1531  // that raw string prefix starts, and
1532  // - if the raw string prefix does not start on a newline, it is the current
1533  // indent.
1534  unsigned LastStartColumn = Current.NewlinesBefore
1535  ? FirstStartColumn - NewPrefixSize
1536  : CurrentIndent;
1537 
1538  std::pair<tooling::Replacements, unsigned> Fixes = internal::reformat(
1539  RawStringStyle, RawText, {tooling::Range(0, RawText.size())},
1540  FirstStartColumn, NextStartColumn, LastStartColumn, "<stdin>",
1541  /*Status=*/nullptr);
1542 
1543  auto NewCode = applyAllReplacements(RawText, Fixes.first);
1544  tooling::Replacements NoFixes;
1545  if (!NewCode) {
1546  return addMultilineToken(Current, State);
1547  }
1548  if (!DryRun) {
1549  if (NewDelimiter != OldDelimiter) {
1550  // In 'R"delimiter(...', the delimiter starts 2 characters after the start
1551  // of the token.
1552  SourceLocation PrefixDelimiterStart =
1553  Current.Tok.getLocation().getLocWithOffset(2);
1554  auto PrefixErr = Whitespaces.addReplacement(tooling::Replacement(
1555  SourceMgr, PrefixDelimiterStart, OldDelimiter.size(), NewDelimiter));
1556  if (PrefixErr) {
1557  llvm::errs()
1558  << "Failed to update the prefix delimiter of a raw string: "
1559  << llvm::toString(std::move(PrefixErr)) << "\n";
1560  }
1561  // In 'R"delimiter(...)delimiter"', the suffix delimiter starts at
1562  // position length - 1 - |delimiter|.
1563  SourceLocation SuffixDelimiterStart =
1564  Current.Tok.getLocation().getLocWithOffset(Current.TokenText.size() -
1565  1 - OldDelimiter.size());
1566  auto SuffixErr = Whitespaces.addReplacement(tooling::Replacement(
1567  SourceMgr, SuffixDelimiterStart, OldDelimiter.size(), NewDelimiter));
1568  if (SuffixErr) {
1569  llvm::errs()
1570  << "Failed to update the suffix delimiter of a raw string: "
1571  << llvm::toString(std::move(SuffixErr)) << "\n";
1572  }
1573  }
1574  SourceLocation OriginLoc =
1575  Current.Tok.getLocation().getLocWithOffset(OldPrefixSize);
1576  for (const tooling::Replacement &Fix : Fixes.first) {
1577  auto Err = Whitespaces.addReplacement(tooling::Replacement(
1578  SourceMgr, OriginLoc.getLocWithOffset(Fix.getOffset()),
1579  Fix.getLength(), Fix.getReplacementText()));
1580  if (Err) {
1581  llvm::errs() << "Failed to reformat raw string: "
1582  << llvm::toString(std::move(Err)) << "\n";
1583  }
1584  }
1585  }
1586  unsigned RawLastLineEndColumn = getLastLineEndColumn(
1587  *NewCode, FirstStartColumn, Style.TabWidth, Encoding);
1588  State.Column = RawLastLineEndColumn + NewSuffixSize;
1589  // Since we're updating the column to after the raw string literal here, we
1590  // have to manually add the penalty for the prefix R"delim( over the column
1591  // limit.
1592  unsigned PrefixExcessCharacters =
1593  StartColumn + NewPrefixSize > Style.ColumnLimit ?
1594  StartColumn + NewPrefixSize - Style.ColumnLimit : 0;
1595  bool IsMultiline =
1596  ContentStartsOnNewline || (NewCode->find('\n') != std::string::npos);
1597  if (IsMultiline) {
1598  // Break before further function parameters on all levels.
1599  for (unsigned i = 0, e = State.Stack.size(); i != e; ++i)
1600  State.Stack[i].BreakBeforeParameter = true;
1601  }
1602  return Fixes.second + PrefixExcessCharacters * Style.PenaltyExcessCharacter;
1603 }
1604 
1605 unsigned ContinuationIndenter::addMultilineToken(const FormatToken &Current,
1606  LineState &State) {
1607  // Break before further function parameters on all levels.
1608  for (unsigned i = 0, e = State.Stack.size(); i != e; ++i)
1609  State.Stack[i].BreakBeforeParameter = true;
1610 
1611  unsigned ColumnsUsed = State.Column;
1612  // We can only affect layout of the first and the last line, so the penalty
1613  // for all other lines is constant, and we ignore it.
1614  State.Column = Current.LastLineColumnWidth;
1615 
1616  if (ColumnsUsed > getColumnLimit(State))
1617  return Style.PenaltyExcessCharacter * (ColumnsUsed - getColumnLimit(State));
1618  return 0;
1619 }
1620 
1621 unsigned ContinuationIndenter::handleEndOfLine(const FormatToken &Current,
1622  LineState &State, bool DryRun,
1623  bool AllowBreak) {
1624  unsigned Penalty = 0;
1625  // Compute the raw string style to use in case this is a raw string literal
1626  // that can be reformatted.
1627  auto RawStringStyle = getRawStringStyle(Current, State);
1628  if (RawStringStyle && !Current.Finalized) {
1629  Penalty = reformatRawStringLiteral(Current, State, *RawStringStyle, DryRun);
1630  } else if (Current.IsMultiline && Current.isNot(TT_BlockComment)) {
1631  // Don't break multi-line tokens other than block comments and raw string
1632  // literals. Instead, just update the state.
1633  Penalty = addMultilineToken(Current, State);
1634  } else if (State.Line->Type != LT_ImportStatement) {
1635  // We generally don't break import statements.
1636  LineState OriginalState = State;
1637 
1638  // Whether we force the reflowing algorithm to stay strictly within the
1639  // column limit.
1640  bool Strict = false;
1641  // Whether the first non-strict attempt at reflowing did intentionally
1642  // exceed the column limit.
1643  bool Exceeded = false;
1644  std::tie(Penalty, Exceeded) = breakProtrudingToken(
1645  Current, State, AllowBreak, /*DryRun=*/true, Strict);
1646  if (Exceeded) {
1647  // If non-strict reflowing exceeds the column limit, try whether strict
1648  // reflowing leads to an overall lower penalty.
1649  LineState StrictState = OriginalState;
1650  unsigned StrictPenalty =
1651  breakProtrudingToken(Current, StrictState, AllowBreak,
1652  /*DryRun=*/true, /*Strict=*/true)
1653  .first;
1654  Strict = StrictPenalty <= Penalty;
1655  if (Strict) {
1656  Penalty = StrictPenalty;
1657  State = StrictState;
1658  }
1659  }
1660  if (!DryRun) {
1661  // If we're not in dry-run mode, apply the changes with the decision on
1662  // strictness made above.
1663  breakProtrudingToken(Current, OriginalState, AllowBreak, /*DryRun=*/false,
1664  Strict);
1665  }
1666  }
1667  if (State.Column > getColumnLimit(State)) {
1668  unsigned ExcessCharacters = State.Column - getColumnLimit(State);
1669  Penalty += Style.PenaltyExcessCharacter * ExcessCharacters;
1670  }
1671  return Penalty;
1672 }
1673 
1674 // Returns the enclosing function name of a token, or the empty string if not
1675 // found.
1676 static StringRef getEnclosingFunctionName(const FormatToken &Current) {
1677  // Look for: 'function(' or 'function<templates>(' before Current.
1678  auto Tok = Current.getPreviousNonComment();
1679  if (!Tok || !Tok->is(tok::l_paren))
1680  return "";
1682  if (!Tok)
1683  return "";
1684  if (Tok->is(TT_TemplateCloser)) {
1685  Tok = Tok->MatchingParen;
1686  if (Tok)
1688  }
1689  if (!Tok || !Tok->is(tok::identifier))
1690  return "";
1691  return Tok->TokenText;
1692 }
1693 
1695 ContinuationIndenter::getRawStringStyle(const FormatToken &Current,
1696  const LineState &State) {
1697  if (!Current.isStringLiteral())
1698  return None;
1699  auto Delimiter = getRawStringDelimiter(Current.TokenText);
1700  if (!Delimiter)
1701  return None;
1702  auto RawStringStyle = RawStringFormats.getDelimiterStyle(*Delimiter);
1703  if (!RawStringStyle && Delimiter->empty())
1704  RawStringStyle = RawStringFormats.getEnclosingFunctionStyle(
1705  getEnclosingFunctionName(Current));
1706  if (!RawStringStyle)
1707  return None;
1708  RawStringStyle->ColumnLimit = getColumnLimit(State);
1709  return RawStringStyle;
1710 }
1711 
1712 std::unique_ptr<BreakableToken> ContinuationIndenter::createBreakableToken(
1713  const FormatToken &Current, LineState &State, bool AllowBreak) {
1714  unsigned StartColumn = State.Column - Current.ColumnWidth;
1715  if (Current.isStringLiteral()) {
1716  // FIXME: String literal breaking is currently disabled for Java and JS, as
1717  // it requires strings to be merged using "+" which we don't support.
1718  if (Style.Language == FormatStyle::LK_Java ||
1720  !Style.BreakStringLiterals ||
1721  !AllowBreak)
1722  return nullptr;
1723 
1724  // Don't break string literals inside preprocessor directives (except for
1725  // #define directives, as their contents are stored in separate lines and
1726  // are not affected by this check).
1727  // This way we avoid breaking code with line directives and unknown
1728  // preprocessor directives that contain long string literals.
1729  if (State.Line->Type == LT_PreprocessorDirective)
1730  return nullptr;
1731  // Exempts unterminated string literals from line breaking. The user will
1732  // likely want to terminate the string before any line breaking is done.
1733  if (Current.IsUnterminatedLiteral)
1734  return nullptr;
1735  // Don't break string literals inside Objective-C array literals (doing so
1736  // raises the warning -Wobjc-string-concatenation).
1737  if (State.Stack.back().IsInsideObjCArrayLiteral) {
1738  return nullptr;
1739  }
1740 
1741  StringRef Text = Current.TokenText;
1742  StringRef Prefix;
1743  StringRef Postfix;
1744  // FIXME: Handle whitespace between '_T', '(', '"..."', and ')'.
1745  // FIXME: Store Prefix and Suffix (or PrefixLength and SuffixLength to
1746  // reduce the overhead) for each FormatToken, which is a string, so that we
1747  // don't run multiple checks here on the hot path.
1748  if ((Text.endswith(Postfix = "\"") &&
1749  (Text.startswith(Prefix = "@\"") || Text.startswith(Prefix = "\"") ||
1750  Text.startswith(Prefix = "u\"") || Text.startswith(Prefix = "U\"") ||
1751  Text.startswith(Prefix = "u8\"") ||
1752  Text.startswith(Prefix = "L\""))) ||
1753  (Text.startswith(Prefix = "_T(\"") && Text.endswith(Postfix = "\")"))) {
1754  // We need this to address the case where there is an unbreakable tail
1755  // only if certain other formatting decisions have been taken. The
1756  // UnbreakableTailLength of Current is an overapproximation is that case
1757  // and we need to be correct here.
1758  unsigned UnbreakableTailLength = (State.NextToken && canBreak(State))
1759  ? 0
1760  : Current.UnbreakableTailLength;
1761  return llvm::make_unique<BreakableStringLiteral>(
1762  Current, StartColumn, Prefix, Postfix, UnbreakableTailLength,
1763  State.Line->InPPDirective, Encoding, Style);
1764  }
1765  } else if (Current.is(TT_BlockComment)) {
1766  if (!Style.ReflowComments ||
1767  // If a comment token switches formatting, like
1768  // /* clang-format on */, we don't want to break it further,
1769  // but we may still want to adjust its indentation.
1770  switchesFormatting(Current)) {
1771  return nullptr;
1772  }
1773  return llvm::make_unique<BreakableBlockComment>(
1774  Current, StartColumn, Current.OriginalColumn, !Current.Previous,
1775  State.Line->InPPDirective, Encoding, Style);
1776  } else if (Current.is(TT_LineComment) &&
1777  (Current.Previous == nullptr ||
1778  Current.Previous->isNot(TT_ImplicitStringLiteral))) {
1779  if (!Style.ReflowComments ||
1780  CommentPragmasRegex.match(Current.TokenText.substr(2)) ||
1781  switchesFormatting(Current))
1782  return nullptr;
1783  return llvm::make_unique<BreakableLineCommentSection>(
1784  Current, StartColumn, Current.OriginalColumn, !Current.Previous,
1785  /*InPPDirective=*/false, Encoding, Style);
1786  }
1787  return nullptr;
1788 }
1789 
1790 std::pair<unsigned, bool>
1791 ContinuationIndenter::breakProtrudingToken(const FormatToken &Current,
1792  LineState &State, bool AllowBreak,
1793  bool DryRun, bool Strict) {
1794  std::unique_ptr<const BreakableToken> Token =
1795  createBreakableToken(Current, State, AllowBreak);
1796  if (!Token)
1797  return {0, false};
1798  assert(Token->getLineCount() > 0);
1799  unsigned ColumnLimit = getColumnLimit(State);
1800  if (Current.is(TT_LineComment)) {
1801  // We don't insert backslashes when breaking line comments.
1802  ColumnLimit = Style.ColumnLimit;
1803  }
1804  if (Current.UnbreakableTailLength >= ColumnLimit)
1805  return {0, false};
1806  // ColumnWidth was already accounted into State.Column before calling
1807  // breakProtrudingToken.
1808  unsigned StartColumn = State.Column - Current.ColumnWidth;
1809  unsigned NewBreakPenalty = Current.isStringLiteral()
1810  ? Style.PenaltyBreakString
1811  : Style.PenaltyBreakComment;
1812  // Stores whether we intentionally decide to let a line exceed the column
1813  // limit.
1814  bool Exceeded = false;
1815  // Stores whether we introduce a break anywhere in the token.
1816  bool BreakInserted = Token->introducesBreakBeforeToken();
1817  // Store whether we inserted a new line break at the end of the previous
1818  // logical line.
1819  bool NewBreakBefore = false;
1820  // We use a conservative reflowing strategy. Reflow starts after a line is
1821  // broken or the corresponding whitespace compressed. Reflow ends as soon as a
1822  // line that doesn't get reflown with the previous line is reached.
1823  bool Reflow = false;
1824  // Keep track of where we are in the token:
1825  // Where we are in the content of the current logical line.
1826  unsigned TailOffset = 0;
1827  // The column number we're currently at.
1828  unsigned ContentStartColumn =
1829  Token->getContentStartColumn(0, /*Break=*/false);
1830  // The number of columns left in the current logical line after TailOffset.
1831  unsigned RemainingTokenColumns =
1832  Token->getRemainingLength(0, TailOffset, ContentStartColumn);
1833  // Adapt the start of the token, for example indent.
1834  if (!DryRun)
1835  Token->adaptStartOfLine(0, Whitespaces);
1836 
1837  unsigned ContentIndent = 0;
1838  unsigned Penalty = 0;
1839  LLVM_DEBUG(llvm::dbgs() << "Breaking protruding token at column "
1840  << StartColumn << ".\n");
1841  for (unsigned LineIndex = 0, EndIndex = Token->getLineCount();
1842  LineIndex != EndIndex; ++LineIndex) {
1843  LLVM_DEBUG(llvm::dbgs()
1844  << " Line: " << LineIndex << " (Reflow: " << Reflow << ")\n");
1845  NewBreakBefore = false;
1846  // If we did reflow the previous line, we'll try reflowing again. Otherwise
1847  // we'll start reflowing if the current line is broken or whitespace is
1848  // compressed.
1849  bool TryReflow = Reflow;
1850  // Break the current token until we can fit the rest of the line.
1851  while (ContentStartColumn + RemainingTokenColumns > ColumnLimit) {
1852  LLVM_DEBUG(llvm::dbgs() << " Over limit, need: "
1853  << (ContentStartColumn + RemainingTokenColumns)
1854  << ", space: " << ColumnLimit
1855  << ", reflown prefix: " << ContentStartColumn
1856  << ", offset in line: " << TailOffset << "\n");
1857  // If the current token doesn't fit, find the latest possible split in the
1858  // current line so that breaking at it will be under the column limit.
1859  // FIXME: Use the earliest possible split while reflowing to correctly
1860  // compress whitespace within a line.
1861  BreakableToken::Split Split =
1862  Token->getSplit(LineIndex, TailOffset, ColumnLimit,
1863  ContentStartColumn, CommentPragmasRegex);
1864  if (Split.first == StringRef::npos) {
1865  // No break opportunity - update the penalty and continue with the next
1866  // logical line.
1867  if (LineIndex < EndIndex - 1)
1868  // The last line's penalty is handled in addNextStateToQueue() or when
1869  // calling replaceWhitespaceAfterLastLine below.
1870  Penalty += Style.PenaltyExcessCharacter *
1871  (ContentStartColumn + RemainingTokenColumns - ColumnLimit);
1872  LLVM_DEBUG(llvm::dbgs() << " No break opportunity.\n");
1873  break;
1874  }
1875  assert(Split.first != 0);
1876 
1877  if (Token->supportsReflow()) {
1878  // Check whether the next natural split point after the current one can
1879  // still fit the line, either because we can compress away whitespace,
1880  // or because the penalty the excess characters introduce is lower than
1881  // the break penalty.
1882  // We only do this for tokens that support reflowing, and thus allow us
1883  // to change the whitespace arbitrarily (e.g. comments).
1884  // Other tokens, like string literals, can be broken on arbitrary
1885  // positions.
1886 
1887  // First, compute the columns from TailOffset to the next possible split
1888  // position.
1889  // For example:
1890  // ColumnLimit: |
1891  // // Some text that breaks
1892  // ^ tail offset
1893  // ^-- split
1894  // ^-------- to split columns
1895  // ^--- next split
1896  // ^--------------- to next split columns
1897  unsigned ToSplitColumns = Token->getRangeLength(
1898  LineIndex, TailOffset, Split.first, ContentStartColumn);
1899  LLVM_DEBUG(llvm::dbgs() << " ToSplit: " << ToSplitColumns << "\n");
1900 
1901  BreakableToken::Split NextSplit = Token->getSplit(
1902  LineIndex, TailOffset + Split.first + Split.second, ColumnLimit,
1903  ContentStartColumn + ToSplitColumns + 1, CommentPragmasRegex);
1904  // Compute the columns necessary to fit the next non-breakable sequence
1905  // into the current line.
1906  unsigned ToNextSplitColumns = 0;
1907  if (NextSplit.first == StringRef::npos) {
1908  ToNextSplitColumns = Token->getRemainingLength(LineIndex, TailOffset,
1909  ContentStartColumn);
1910  } else {
1911  ToNextSplitColumns = Token->getRangeLength(
1912  LineIndex, TailOffset,
1913  Split.first + Split.second + NextSplit.first, ContentStartColumn);
1914  }
1915  // Compress the whitespace between the break and the start of the next
1916  // unbreakable sequence.
1917  ToNextSplitColumns =
1918  Token->getLengthAfterCompression(ToNextSplitColumns, Split);
1919  LLVM_DEBUG(llvm::dbgs()
1920  << " ContentStartColumn: " << ContentStartColumn << "\n");
1921  LLVM_DEBUG(llvm::dbgs()
1922  << " ToNextSplit: " << ToNextSplitColumns << "\n");
1923  // If the whitespace compression makes us fit, continue on the current
1924  // line.
1925  bool ContinueOnLine =
1926  ContentStartColumn + ToNextSplitColumns <= ColumnLimit;
1927  unsigned ExcessCharactersPenalty = 0;
1928  if (!ContinueOnLine && !Strict) {
1929  // Similarly, if the excess characters' penalty is lower than the
1930  // penalty of introducing a new break, continue on the current line.
1931  ExcessCharactersPenalty =
1932  (ContentStartColumn + ToNextSplitColumns - ColumnLimit) *
1933  Style.PenaltyExcessCharacter;
1934  LLVM_DEBUG(llvm::dbgs()
1935  << " Penalty excess: " << ExcessCharactersPenalty
1936  << "\n break : " << NewBreakPenalty << "\n");
1937  if (ExcessCharactersPenalty < NewBreakPenalty) {
1938  Exceeded = true;
1939  ContinueOnLine = true;
1940  }
1941  }
1942  if (ContinueOnLine) {
1943  LLVM_DEBUG(llvm::dbgs() << " Continuing on line...\n");
1944  // The current line fits after compressing the whitespace - reflow
1945  // the next line into it if possible.
1946  TryReflow = true;
1947  if (!DryRun)
1948  Token->compressWhitespace(LineIndex, TailOffset, Split,
1949  Whitespaces);
1950  // When we continue on the same line, leave one space between content.
1951  ContentStartColumn += ToSplitColumns + 1;
1952  Penalty += ExcessCharactersPenalty;
1953  TailOffset += Split.first + Split.second;
1954  RemainingTokenColumns = Token->getRemainingLength(
1955  LineIndex, TailOffset, ContentStartColumn);
1956  continue;
1957  }
1958  }
1959  LLVM_DEBUG(llvm::dbgs() << " Breaking...\n");
1960  // Update the ContentIndent only if the current line was not reflown with
1961  // the previous line, since in that case the previous line should still
1962  // determine the ContentIndent. Also never intent the last line.
1963  if (!Reflow)
1964  ContentIndent = Token->getContentIndent(LineIndex);
1965  LLVM_DEBUG(llvm::dbgs()
1966  << " ContentIndent: " << ContentIndent << "\n");
1967  ContentStartColumn = ContentIndent + Token->getContentStartColumn(
1968  LineIndex, /*Break=*/true);
1969 
1970  unsigned NewRemainingTokenColumns = Token->getRemainingLength(
1971  LineIndex, TailOffset + Split.first + Split.second,
1972  ContentStartColumn);
1973  if (NewRemainingTokenColumns == 0) {
1974  // No content to indent.
1975  ContentIndent = 0;
1976  ContentStartColumn =
1977  Token->getContentStartColumn(LineIndex, /*Break=*/true);
1978  NewRemainingTokenColumns = Token->getRemainingLength(
1979  LineIndex, TailOffset + Split.first + Split.second,
1980  ContentStartColumn);
1981  }
1982 
1983  // When breaking before a tab character, it may be moved by a few columns,
1984  // but will still be expanded to the next tab stop, so we don't save any
1985  // columns.
1986  if (NewRemainingTokenColumns == RemainingTokenColumns) {
1987  // FIXME: Do we need to adjust the penalty?
1988  break;
1989  }
1990  assert(NewRemainingTokenColumns < RemainingTokenColumns);
1991 
1992  LLVM_DEBUG(llvm::dbgs() << " Breaking at: " << TailOffset + Split.first
1993  << ", " << Split.second << "\n");
1994  if (!DryRun)
1995  Token->insertBreak(LineIndex, TailOffset, Split, ContentIndent,
1996  Whitespaces);
1997 
1998  Penalty += NewBreakPenalty;
1999  TailOffset += Split.first + Split.second;
2000  RemainingTokenColumns = NewRemainingTokenColumns;
2001  BreakInserted = true;
2002  NewBreakBefore = true;
2003  }
2004  // In case there's another line, prepare the state for the start of the next
2005  // line.
2006  if (LineIndex + 1 != EndIndex) {
2007  unsigned NextLineIndex = LineIndex + 1;
2008  if (NewBreakBefore)
2009  // After breaking a line, try to reflow the next line into the current
2010  // one once RemainingTokenColumns fits.
2011  TryReflow = true;
2012  if (TryReflow) {
2013  // We decided that we want to try reflowing the next line into the
2014  // current one.
2015  // We will now adjust the state as if the reflow is successful (in
2016  // preparation for the next line), and see whether that works. If we
2017  // decide that we cannot reflow, we will later reset the state to the
2018  // start of the next line.
2019  Reflow = false;
2020  // As we did not continue breaking the line, RemainingTokenColumns is
2021  // known to fit after ContentStartColumn. Adapt ContentStartColumn to
2022  // the position at which we want to format the next line if we do
2023  // actually reflow.
2024  // When we reflow, we need to add a space between the end of the current
2025  // line and the next line's start column.
2026  ContentStartColumn += RemainingTokenColumns + 1;
2027  // Get the split that we need to reflow next logical line into the end
2028  // of the current one; the split will include any leading whitespace of
2029  // the next logical line.
2030  BreakableToken::Split SplitBeforeNext =
2031  Token->getReflowSplit(NextLineIndex, CommentPragmasRegex);
2032  LLVM_DEBUG(llvm::dbgs()
2033  << " Size of reflown text: " << ContentStartColumn
2034  << "\n Potential reflow split: ");
2035  if (SplitBeforeNext.first != StringRef::npos) {
2036  LLVM_DEBUG(llvm::dbgs() << SplitBeforeNext.first << ", "
2037  << SplitBeforeNext.second << "\n");
2038  TailOffset = SplitBeforeNext.first + SplitBeforeNext.second;
2039  // If the rest of the next line fits into the current line below the
2040  // column limit, we can safely reflow.
2041  RemainingTokenColumns = Token->getRemainingLength(
2042  NextLineIndex, TailOffset, ContentStartColumn);
2043  Reflow = true;
2044  if (ContentStartColumn + RemainingTokenColumns > ColumnLimit) {
2045  LLVM_DEBUG(llvm::dbgs()
2046  << " Over limit after reflow, need: "
2047  << (ContentStartColumn + RemainingTokenColumns)
2048  << ", space: " << ColumnLimit
2049  << ", reflown prefix: " << ContentStartColumn
2050  << ", offset in line: " << TailOffset << "\n");
2051  // If the whole next line does not fit, try to find a point in
2052  // the next line at which we can break so that attaching the part
2053  // of the next line to that break point onto the current line is
2054  // below the column limit.
2055  BreakableToken::Split Split =
2056  Token->getSplit(NextLineIndex, TailOffset, ColumnLimit,
2057  ContentStartColumn, CommentPragmasRegex);
2058  if (Split.first == StringRef::npos) {
2059  LLVM_DEBUG(llvm::dbgs() << " Did not find later break\n");
2060  Reflow = false;
2061  } else {
2062  // Check whether the first split point gets us below the column
2063  // limit. Note that we will execute this split below as part of
2064  // the normal token breaking and reflow logic within the line.
2065  unsigned ToSplitColumns = Token->getRangeLength(
2066  NextLineIndex, TailOffset, Split.first, ContentStartColumn);
2067  if (ContentStartColumn + ToSplitColumns > ColumnLimit) {
2068  LLVM_DEBUG(llvm::dbgs() << " Next split protrudes, need: "
2069  << (ContentStartColumn + ToSplitColumns)
2070  << ", space: " << ColumnLimit);
2071  unsigned ExcessCharactersPenalty =
2072  (ContentStartColumn + ToSplitColumns - ColumnLimit) *
2073  Style.PenaltyExcessCharacter;
2074  if (NewBreakPenalty < ExcessCharactersPenalty) {
2075  Reflow = false;
2076  }
2077  }
2078  }
2079  }
2080  } else {
2081  LLVM_DEBUG(llvm::dbgs() << "not found.\n");
2082  }
2083  }
2084  if (!Reflow) {
2085  // If we didn't reflow into the next line, the only space to consider is
2086  // the next logical line. Reset our state to match the start of the next
2087  // line.
2088  TailOffset = 0;
2089  ContentStartColumn =
2090  Token->getContentStartColumn(NextLineIndex, /*Break=*/false);
2091  RemainingTokenColumns = Token->getRemainingLength(
2092  NextLineIndex, TailOffset, ContentStartColumn);
2093  // Adapt the start of the token, for example indent.
2094  if (!DryRun)
2095  Token->adaptStartOfLine(NextLineIndex, Whitespaces);
2096  } else {
2097  // If we found a reflow split and have added a new break before the next
2098  // line, we are going to remove the line break at the start of the next
2099  // logical line. For example, here we'll add a new line break after
2100  // 'text', and subsequently delete the line break between 'that' and
2101  // 'reflows'.
2102  // // some text that
2103  // // reflows
2104  // ->
2105  // // some text
2106  // // that reflows
2107  // When adding the line break, we also added the penalty for it, so we
2108  // need to subtract that penalty again when we remove the line break due
2109  // to reflowing.
2110  if (NewBreakBefore) {
2111  assert(Penalty >= NewBreakPenalty);
2112  Penalty -= NewBreakPenalty;
2113  }
2114  if (!DryRun)
2115  Token->reflow(NextLineIndex, Whitespaces);
2116  }
2117  }
2118  }
2119 
2120  BreakableToken::Split SplitAfterLastLine =
2121  Token->getSplitAfterLastLine(TailOffset);
2122  if (SplitAfterLastLine.first != StringRef::npos) {
2123  LLVM_DEBUG(llvm::dbgs() << "Replacing whitespace after last line.\n");
2124 
2125  // We add the last line's penalty here, since that line is going to be split
2126  // now.
2127  Penalty += Style.PenaltyExcessCharacter *
2128  (ContentStartColumn + RemainingTokenColumns - ColumnLimit);
2129 
2130  if (!DryRun)
2131  Token->replaceWhitespaceAfterLastLine(TailOffset, SplitAfterLastLine,
2132  Whitespaces);
2133  ContentStartColumn =
2134  Token->getContentStartColumn(Token->getLineCount() - 1, /*Break=*/true);
2135  RemainingTokenColumns = Token->getRemainingLength(
2136  Token->getLineCount() - 1,
2137  TailOffset + SplitAfterLastLine.first + SplitAfterLastLine.second,
2138  ContentStartColumn);
2139  }
2140 
2141  State.Column = ContentStartColumn + RemainingTokenColumns -
2142  Current.UnbreakableTailLength;
2143 
2144  if (BreakInserted) {
2145  // If we break the token inside a parameter list, we need to break before
2146  // the next parameter on all levels, so that the next parameter is clearly
2147  // visible. Line comments already introduce a break.
2148  if (Current.isNot(TT_LineComment)) {
2149  for (unsigned i = 0, e = State.Stack.size(); i != e; ++i)
2150  State.Stack[i].BreakBeforeParameter = true;
2151  }
2152 
2153  if (Current.is(TT_BlockComment))
2154  State.NoContinuation = true;
2155 
2156  State.Stack.back().LastSpace = StartColumn;
2157  }
2158 
2159  Token->updateNextToken(State);
2160 
2161  return {Penalty, Exceeded};
2162 }
2163 
2164 unsigned ContinuationIndenter::getColumnLimit(const LineState &State) const {
2165  // In preprocessor directives reserve two chars for trailing " \"
2166  return Style.ColumnLimit - (State.Line->InPPDirective ? 2 : 0);
2167 }
2168 
2169 bool ContinuationIndenter::nextIsMultilineString(const LineState &State) {
2170  const FormatToken &Current = *State.NextToken;
2171  if (!Current.isStringLiteral() || Current.is(TT_ImplicitStringLiteral))
2172  return false;
2173  // We never consider raw string literals "multiline" for the purpose of
2174  // AlwaysBreakBeforeMultilineStrings implementation as they are special-cased
2175  // (see TokenAnnotator::mustBreakBefore().
2176  if (Current.TokenText.startswith("R\""))
2177  return false;
2178  if (Current.IsMultiline)
2179  return true;
2180  if (Current.getNextNonComment() &&
2181  Current.getNextNonComment()->isStringLiteral())
2182  return true; // Implicit concatenation.
2183  if (Style.ColumnLimit != 0 && Style.BreakStringLiterals &&
2184  State.Column + Current.ColumnWidth + Current.UnbreakableTailLength >
2185  Style.ColumnLimit)
2186  return true; // String will be split.
2187  return false;
2188 }
2189 
2190 } // namespace format
2191 } // 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:921
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:1231
Defines the SourceManager interface.
unsigned IndentWidth
The number of columns to use for indentation.
Definition: Format.h:1117
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:854
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:1384
LanguageKind
Supported languages.
Definition: Format.h:1218
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:1104
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:846
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:1024
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:1224
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:2151
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:966
unsigned PenaltyBreakComment
The penalty for each line break introduced inside a comment.
Definition: Format.h:1381
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:1130
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:1364
bool LineContainsContinuedForLoopSection
true if this line contains a continued for-loop section.
unsigned ColumnLimit
The column limit.
Definition: Format.h:884
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:1713
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:1226
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:1387
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:1393
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:1492
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:861
bool BreakBeforeTernaryOperators
If true, ternary operators will be placed after line breaks.
Definition: Format.h:836
Encapsulates keywords that are context sensitive or for languages not properly supported by Clang&#39;s l...
Definition: FormatToken.h:668
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:980
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:1241
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:925
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:877
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:913
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:1697
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:1228
BinPackStyle ObjCBinPackProtocolList
Controls bin-packing Objective-C protocol conformance list items into as few lines as possible when t...
Definition: Format.h:1354
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:865
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:1478
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:970
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:1100
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:1236
__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:1630
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:1285
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