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